(* Wiederholung *)

Remove["Global`*"]

(* 1 *)

(* a *)

q[t_]:= 3 Exp[-5t]Cos[4t]

i[t_]= D[q[t],t]  (* kurz: q'[t]  *)

(* b *)

Clear[q,i]

i[t_]:= 2 Exp[-2t]Sin[4t]

q[t_]=Integrate[i[t],t]+C

ls=Solve[q[0]==2,C]

q[t_]= q[t]/.ls[[1]]

(* Probe: *)

q'[t]

%//Simplify

q[0]

(* 2 *)

(* BEM.: auf die Programmierung der Cramerschen Regel wurde verzichtet *)

(* a *)

gl1= 2x +y ==0;

gl2=3x - y ==2;

gls={gl1,gl2}

(* mit Solve: *)

ls=Solve[gls,{x,y}]

(* Speichern der LÖsung: *)

xL=x/.ls[[1]]

yL=y/.ls[[1]]

(* logische Probe: *)

gls/.ls[[1]]

(* numerische Probe: *)

{gl1[[1]],gl2[[1]]}/.ls[[1]]

(* mit der Koeffizientenmatrix und dem Vektor der rechten Seite, hier "von Hand": *)

A = {{2,1},{3,-1}}

rechteSeite= {0,2}

(* Alternative: *)

{minusc, A}=Normal[CoefficientArrays[{gl1,gl2},{x,y}]]

A//MatrixForm

rechteSeite= -minusc

Det[A]

InvA= Inverse[A]

{xL,yL}= InvA.rechteSeite

(* die Lösung IST bereits gespeichert *)

xL

yL

(* b *)

Clear[x,y]

gl1= x -4y ==2;

gl2=-3x +12 y ==-6;

(* mit Solve: *)

ls=Solve[{gl1,gl2},{x,y}]

(* also unendlich viele Lösungen: x beliebig, y dann: *)

y[x_]= y/.ls[[1]]

(* Ausschnitt aus der Lösungsgeraden: *)

Plot[y[x],{x,-2,3}, AspectRatio->Automatic]

(* mit der Koeffizientenmatrix kann es nicht gehen: *)

A = {{1,-4},{-3,12}}

(* Da die Determinante  0  ist,... *)

Det[A]

(* ... existiert die Inverse nicht *)

Inverse[A]

(* c *)

Clear[x,y]

gl1= x -4y ==2;

gl2=-3x +12 y ==-5;

(* mit Solve: *)

ls=Solve[{gl1,gl2},{x,y}]

(* also keine Lösung *)

(* 3 *)

(* a *)

A = {{1,t},{2,3}}

d=Det[A]

ls=Solve[d==0,t]

tL=t/.ls[[1]]

AL = A/.ls[[1]]

(* b *)

t=2

A

es=Eigensystem[A]

ew=Eigenvalues[A]

ev=Eigenvectors[A]

ev1= ev[[1]]

ev2= ev[[2]]

ev1Normiert= ev1/Norm[ev1]

%//Simplify

%//N

ev2Normiert= ev2/Norm[ev2]

%//Simplify

%//N

ev1Normiert.ev2Normiert

%//Simplify

(* also orthogonal *)

(* 4 *)

(* a *)

Clear[f,g]

f[x_]:= 3 Sin[x]

g[x_]:= Exp[x-1]

gl=f[x]==g[x]

Solve[gl,x]

(* NSolve liefert dann auch kein Ergebnis; 
   Reduce auch nicht, deshalb wird gar nicht darauf verwiesen;
   also bleibt nur FindRoot.
 Aus einer Grafik wird der Startwert bestimmt: *)

Plot[{f[x],g[x]},{x,-4,3}]

(* die Schnittpunkte mit x > 0: ein Schnittpunkt in der Nähe von 0, 
  einer in der Nähe von 2 *)

x0=0;

ls=FindRoot[f[x]==g[x],{x,x0}]

xL1=x/.ls

(* numerische Probe: *)

f[xL1]

g[xL1]

(* logische Probe: *)

gl/.ls

x0=2;

ls=FindRoot[gl,{x,x0}]

xL2=x/.ls

(* Probe: *)

f[xL2]

g[xL2]

gl/.ls

(* graphisch, am besten über die Nullstellen der Differenzfkt: *)

Plot[{f[x]-g[x]},{x,0,3}]

(* weitere Schnittpunkte nur im negativen Bereich:  *)

Plot[{f[x],g[x]},{x,-8,0}]

(* es gibt also unendlich viele Schnittpunkte für x < 0 ; da die e-Funktion dort sehr schnell Null wird, entsprechen ab x < -6 die Schnittpunkte praktisch den Nullstellen der Sinus-Funktion *)

(* c *)

gl=2 Cos[x]-3 (Sin[x])^2==0

ls=Solve[gl,x]

ls//N

(* die ersten beiden Lösungen sind also komplex und brauchen hier nicht weiter zu interessieren *)

x1 = x/.ls[[3]]

x1//N

x2 = x/.ls[[4]]

x2//N

Reduce[gl,x]

%//N

(* zu den beiden reellen Lösungen kann also jeweils ein Vielfaches von 2 Pi addiert werden *)

x[1,n_]= x1 + n*2Pi

x[2,n_]= x2 + n*2Pi

Table[{x[1,n],x[2,n]},{n,0,5}]

%//N

%//Flatten

(* Probe: *)

Plot[2 Cos[x]-3 (Sin[x])^2,{x,-5Pi, 5Pi}]

(* 5 *)

f[x_]:= x^3

(* a *)

(* "exakt": *)

bogenlaenge = Integrate[Sqrt[1+(f'[x])^2],{x,0,1/2}]

bogenlaenge//N

N[bogenlaenge,20]

(* das Ergebnis, die sehr spezielle Funktion "Hypergeometric2F1", liegt in Mathematica auch "nur" in Form einer Taylorreihe vor *)

(* numerisch: *)

bogenlaengeN = NIntegrate[Sqrt[1+(f'[x])^2],{x,0,1/2}]

N[bogenlaengeN,20]

(* höhere Genauigkeit geht hier über "WorkingPrecision"; die numerische Berechnung wird jetzt intern sehr viel genauer durchgeführt *)

bogenlaengeNG = NIntegrate[Sqrt[1+(f'[x])^2],{x,0,1/2},WorkingPrecision->30]

(* b *)
(* mit Taylorentwicklung des Integranden: *)

taylor4Int[x_] = Series[Sqrt[1+(f'[x])^2],{x,0,4}]//Normal

bogenlaengeT=Integrate[taylor4Int[x],{x,0,1/2}]

bogenlaengeT//N

(* höhere Genauigkeit erreicht man hier durch eine höhere Ordnung. Dies funktioniert hier, da man sich bei den oben gegebenen Integralgrenzen im Konvergenzbereich der Taylorreihe befindet *)

taylor8Int[x_] = Series[Sqrt[1+(f'[x])^2],{x,0,8}]//Normal

bogenlaengeT=Integrate[taylor8Int[x],{x,0,1/2}]

bogenlaengeT//N

taylor12Int[x_] = Series[Sqrt[1+(f'[x])^2],{x,0,12}]//Normal

bogenlaengeT=Integrate[taylor12Int[x],{x,0,1/2}]

bogenlaengeT//N

taylor16Int[x_] = Series[Sqrt[1+(f'[x])^2],{x,0,16}]//Normal

bogenlaengeT=Integrate[taylor16Int[x],{x,0,1/2}]

bogenlaengeT//N

(* jetzt können die Ziffern 0.526 als gültig angesehen werden *)

(* Vergleich *)

(* zunächst das unbestimmte Integral, scheinbar exakt, dann Taylor des Integrals: *)

Clear[intE]

intE[x_]=Integrate[Sqrt[1+(f'[x])^2],x]

(* das Ergebnis wird durch eine andere sehr spezielle Fkt dargestellt *)

(* Taylorentwicklung dieser Fkt um x0=0 *)

sE= Series[intE[x],{x,0,5}]//Normal

sE//FullSimplify

(* erst Taylor des Integranden, dann Integrieren *)

Integrate[taylor4Int[x],x]