SetDirectory[NotebookDirectory[]]

Mi történt a héten?

Felvételi

Compile,Package, Message, Cookbook, Kivétel- és hibakezelés, stílus, megoldott feladatok mérete, GraphicsComplex,Dynamic

8as: sok statisztika, futtatható kód C-ben,Workbench, Python,MathLink

matyo[s_]=Abs[1+(E^(-I π((7/12)+ Cos[s])))+(E^(-I π((7/6)+2 Cos[s])))];
Timing[PolarPlot[matyo[s],{s,-π,π},PlotRange->All]]

matyoC=Compile[{{t,_Real}},Evaluate[matyo[t]]];
Timing[PolarPlot[matyoC[t],{t,-π,π},PlotRange->All]]//Quiet

t helyébe mást írva érdekes ábrák!

Mandelbrot, B. (1924-2010)

mandel=Import["mandelbrot.jpg"]

Hyperlink["Mandelbrot","http://index.hu/tudomany/2010/10/16/elhunyt_mandelbrot_a_fraktalok_atyja/"]

Hyperlink["Életrajza","http://www-groups.dcs.st-and.ac.uk/~history/Biographies/Mandelbrot.html"]

Neumann posztdokja, Mat. Lapok

mandelbrotC=Compile[{x,y,lim},Module[{z,ct=0},z=x+I y;While[Abs[z]<2.0∧ct≤lim,z=(z^2)+(x+I y);++ct];ct]];

Hány lépés után mászik ki?

mandelbrotC[-.1,0.5,50]

mandelbrotC[-.1,0.95,50]

mandelbrotC[-1.5,0.5,50]

DensityPlot[mandelbrotC[x,y,50],{x,-2.,1.},{y,-1.5,1.5},PlotPoints->50,Mesh->False]

Ezzel rövidebben: NestWhile?

Nem nagyon érdemes ezt csinálni:

Plot3D[mandelbrotC[x,y,50],{x,-2.,1.},{y,-1.5,1.5},PlotPoints->500]

Meglévő ábra más formátumban?

newt = Compile[{{z,_Complex},{n,_Integer}}, Module[{zn = z},
Do[zn =(1/3) (2 zn +(1/(zn^2))),{n}];If[Re[zn]>0,1,If[Im[zn]>0,2,3]]]];
Off[CompiledFunction::cfn];

ArrayPlot[Table[newt[x+I y,25],{y,-1,1,.003},{x,-1,1,.003}],PlotLabel->"Honnan indítva konvergál/na Newton-módszer?"  ]

Házik megoldásához

Korábbiak

KöMaL feladat

Nagyon csúúúnya

α=1+2Cos[(π/9)];

vajh[prec_]:=Module[{},$MaxExtraPrecision=prec;Mod[IntegerPart[(α^1993)],17]]

Timing[vajh[360]]

Timing[vajh[358]]

Timing[vajh[354]]

Timing[vajh[353]]

Aszimptoták

Plot[(E^(-x))Sin[(E^(x^2))],{x,0,12}]

Manipulate[Plot[Evaluate[D[(E^(-x))Sin[(E^(x^2))],x]],{x,0,xig},PlotRange->All],{xig,0.1,12,0.1}]

Limit[(E^(-x))Sin[(E^(x^2))],x->+∞]

Limit[D[(E^(-x))Sin[(E^(x^2))],x],x->+∞]

D[(E^(-x))Sin[(E^(x^2))],x]

Aktuálisak

Horgászok

Select[Permutations[Range[4]],((#[[1]]≠1)∧(#[[2]]≠2)∧(#[[3]]≠3)∧(#[[4]]≠4))&]

Select[Permutations[Range[4]],And@@Table[(#[[i]]≠i),{i,4}]&]

HammingDistance[{2,1,4,3},{1,2,3,4}]

Select[Permutations[Range[4]],(HammingDistance[#,Range[4]]==4)&]

sel[n_]:=Select[Permutations[Range[n]],(HammingDistance[#,Range[n]]==n)&]

sel[4]

TableForm[Length[sel[#]]&/@Range[6],TableHeadings->{Range[6],None}]

Euler not only gives the first ten or so terms of the sequence, he also proves both recurrences  a(n)=(n-1)(a(n-1)+a(n-2)) and a(n)=na(n-1)+(((-1))^n).

rsola=RSolve[{a[n]==(n-1)(a[n-1]+a[n-2]),a[1]==0,a[2]==1},a[n],n]

a[n]/.rsola[[1]]/.n->5//FullSimplify

rsolb=RSolve[{b[n]==n b[n-1]+(((-1))^n),b[1]==0},b[n],n]

b[n] /. First@rsolb /. n -> 5 // FullSimplify

Hyperlink["Sloane","http://www.research.att.com/~njas/sequences/index.html?q=0%2C1%2C2%2C9%2C44%2C265&language=english&go=Search"]

Elmélet, tovább

Alapértelmezés

Egyszerűen

ClearAll[f];f[x_,y_:0]:=(x^2)+y;

f[10]

f[10,0]

f[10,2]

A Default függvénnyel (lekérdezés, beállítás)

Lekérdezés

Default[Plus]

Plus[]

Definiálás

(*2 a változó sorszáma*)

Default[fff,2]=0

Default[fff,2]

Ezek után _. utal a fentire.

fff[x_,y_.]:=(x^y)-x+y

Definition[fff]

??fff

fff[10,1]

fff[4]

fff[4,0]

Előny: különválik a fvérték és az alapértelmezés definíciója.

Nem kell a végére tenni

ff[x_:1,y_]:=(x^2)+y

ff[10]==ff[1,10]

Kétértelműség ellen: balról illeszt

f3[x_:1,y_:0]:=2x+y

f3[10]==f3[10,0]

f4[x_String:"test",y_Integer:1]:=StringTake[x,y]

f4[3]

Csomagban jobb a végére tenni.

Opciók saját függvényhez

SetOptions: beépített fvre is. Jól jöhet az elején:

OptionValue[Plot,PlotStyle]

SetOptions[Plot,PlotStyle->Dashing[{.05,.01}]];

Plot[{Sin[x],Cos[x]},{x,0,1}]

SetOptions[Plot,PlotStyle->Automatic];

Saját fv-re:

Options[skalarszorzat]={suly->(((1-x))^2)(((1+x))^3)};

suly/.{suly->(((1-x))^2)(((1+x))^3)}

suly/.Options[skalarszorzat]

skalarszorzat[funval1_,funval2_,opts___?OptionQ]:=Module[{weight},weight=(suly/.{opts}/.Options[skalarszorzat]);
Integrate[funval1 funval2 weight,{x,-1,1}]]

skalarszorzat[JacobiP[3,2,3,x],JacobiP[5,2,3,x],suly-> x]

skalarszorzat[JacobiP[3,2,3,x],JacobiP[5,2,3,x],suly->(((1-x))^2)(((1+x))^3)]

skalarszorzat[JacobiP[3,2,3,x],JacobiP[5,2,3,x]]

Jobbak az opciók, mint a default, ha sokan vannak.

Hová, melyik?

odeplot[inival_,opts:OptionsPattern[]]:=Module[{nds},nds=NDSolve[inival,y[x],{x,-0.8,0.8},opts];If[TrueQ[Head[nds]==NDSolve],$Failed,Plot[Evaluate[y[x]/.nds],{x,-0.8,0.8},opts]]]

odeplot[{(1-(x^2))y''[x]-4x y'[x]+5(5+3)y[x]==0,y[0]==1,y'[0]==0}]

odeplot[{(1-(x^2))y''[x]-4x y'[x]+5(5+3)y[x]==0,y[0]==1,y'[0]==0},Method->"ExplicitRungeKutta"]

Nadenade:

odeplot[{(1-(x^2))y''[x]-4x y'[x]+5(5+3)y[x]==0,y[0]==1,y'[0]==0},PlotLabel->TraditionalForm[JacobiP[3,1,1,x]]]

Ez a megoldás:

FilterRules

odeplot[inival_,opts:OptionsPattern[]]:=Module[{nds},nds=NDSolve[inival,y[x],{x,-0.8,0.8},FilterRules[{opts},Options[NDSolve]]];If[TrueQ[Head[nds]==NDSolve],$Failed,Plot[Evaluate[y[x]/.nds],{x,-0.8,0.8},Evaluate[FilterRules[{opts},Options[Plot]]]]]]

odeplot[{(1-(x^2))y''[x]-4x y'[x]+5(5+3)y[x]==0,y[0]==1,y'[0]==0},PlotLabel->TraditionalForm[JacobiP[3,1,1,x]],Method->"ExplicitRungeKutta"]

Ez még akkor is segít, ha mindkt helyen Method opció van.

(1-(x^2))y''(x)+(b-a-(a+b+2)x)y'(x)+n(n+a+b+1)y(x)=0

Vigyázat: Az első nyer

Plot[JacobiP[3,1,1,x],{x,-0.99,0.99},PlotStyle->Dashed,PlotStyle->Thick]

(Majdnem) mindenre  van megoldás:

Plot[JacobiP[3,1,1,x],{x,-0.99,0.99},PlotStyle->Directive[{Dashed,Thick}]]

Adatszerkezetekről

(Általánosított) lista, listakezelő függvények

Listakezelés

Generálás a semmiből

Grid[{Table[1,{10}],ConstantArray[1,9],Table[(i^2),{i,2,8}],((Range[3,8])^3),Log[Range[3,15,3]],Array[1&,4]},Frame->All]

Table[1,{2},{3}]

Harmadrendű tenzor

Table[i+(j^2)+(k^3),{i,0,2},{j,0,2},{k,0,2}]//MatrixForm

Normal[LeviCivitaTensor[3]]//MatrixForm

IdentityMatrix[3]==Table[If[i==j,1,0],{i,3},{j,3}]

Generálás valamiből

TableForm[{l=Range[10],(l^2),Append[l,11],Prepend[l,0],Insert[l, 3.5,4],Insert[l, 3.5,-4]},TableHeadings->{{Range,Square,Append,Prepend,"Insert1",Insert2},None}]

l

Range[2,Length[l]]

List/@Range[2,Length[l]]

Insert[l,0,List/@Range[2,1+Length[l]]]

Join[l,(l^3)]

Riffle[l,0]

Riffle[l,Sin[l]]

l[[3]]==Part[l,3]

First[l](*LISP-ben: car*)

Rest[l](*LISP-ben: cdr*)

Through[{Most,Last}[l]]

{Take[l,3],Drop[l,3]}

Select[l,EvenQ]

Cases[(l/3),a_Integer->3a]

Reverse[l]

{RotateLeft[l],RotateRight[l]}//TableForm

bifurc[l_]:=Nest[Partition[#,2]&,l,Floor[Log[2,Length[l]]]]

(strucc=bifurc[l])//TreeForm

strucc

strucc//Flatten

TreeForm/@(Flatten[strucc,#]&/@Range[0,3])

Halmazok

Union[l,(l^2)]

DeleteDuplicates

Intersection[l,(l^2)]

setDifference[a_,b_]:=Complement[a,Intersection[a,b]]

setDifference[l,(l^2)]

setDifference[(l^2),l]

Subsets[{a,b,c}]

MemberQ[l,4]

Vektorfvek

3l-3

Intersection@Flatten@Attributes@{Times,Plus,Minus,Divide,Power}

((Range[10])^(Range[10,1,-1]))

<<VectorAnalysis`

??VectorAnalysis`*

{l.l,Norm[l]}

Orthogonalize[{{1,2},{1,8}}]

Projection[{1,2},{3,4}]

CrossProduct[{1,2,3},{-5,3,4}]

Mátrix- és tenzorfüggvények

ClearAll[i,j,k,l,a];
(tensor4=Table[(Subscript[a, i,j,k,l]),{i,2},{j,2},{k,2},{l,2}])//MatrixForm

Figyeljük, h mi marad!

tensor4[[1]]//MatrixForm

tensor4[[1,1]]//MatrixForm

tensor4[[1,1,2]]//MatrixForm

tensor4[[2,1,2,2]]

Outer[lll,{i,j,k,l},{2}]

Descartes-szorzat

Flatten[Outer[List,{i,j,k,l},{2}],1]

Table[(Subscript[a, i,j,k,l]),Flatten[Outer[List,{i,j,k,l},{2}],1]]

Table[(Subscript[a, i,j,k,l]),Evaluate[Flatten[Outer[List,{i,j,k,l},{2}],1]]]

Evaluate[Flatten[Outer[List,{i,j,k,l},{2}],1]]

Apply[Table[(Subscript[a, i,j,k,l]),#]&,Evaluate[Flatten[Outer[List,{i,j,k,l},{2}],1]]]

Dot[{(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3])},{(Subscript[y, 1]),(Subscript[y, 2]),(Subscript[y, 3])}]

Dot[Table[Subscript[x,i,j],{i,3},{j,2}],Array[(Subscript[y, #1,#2])&,{2,3}]]

Inner[fnf,{(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3])},{(Subscript[y, 1]),(Subscript[y, 2]),(Subscript[y, 3])},gg]

Inner[List,Array[((#1)^(#2))&,{4,3}],Table[i!j!,{i,3},{j,4}],Max]//MatrixForm

Inner[List,Array[#1 #2&,{2,2}],Array[#1+#2&,{2,2}],Join]//MatrixForm

?*Style

Grid[Inner[And,Array[#1<#2&,{3,3}],Array[#1>#2&,{3,3}],Or],Frame->All,ItemStyle->Directive[FontSize->16,Red,Bold]]

Numerikus listák hatékony reprezentálása

<<Developer`

PackedArray: csak egészek v csak valósak hatékony tárolására

Vektor

vec=Table[Random[],{10000}];
vec//ByteCount

Do[(vec^2),{50}]//Timing

PackedArrayQ[vec]

Elrontjuk

vec[[1]]=x

PackedArrayQ[vec]

vec//ByteCount

Do[(vec^2),{50}]//Timing

Vigyázat!

Timing[array1=Table[i ℼ,{i,0,500000}];]

PackedArrayQ[array1]

Timing[array2=Table[N[i ℼ],{i,0,500000}];]

PackedArrayQ[array2]

Timing[array3=ToPackedArray[Array[N[#π]&,500000]];]

PackedArrayQ[array3]

Timing[array4=ToPackedArray[Table[N[i ℼ],{i,0,500000}]];]

PackedArrayQ[array4]

Grid[{{"","méret","elemenként"},{"array1",ByteCount[array1],N[((ByteCount[array1])/(Length[array1]))],Length[array1]},{"array2",ByteCount[array2],N[((ByteCount[array2])/(Length[array2]))],Length[array2]},{"array3",ByteCount[array3],N[((ByteCount[array3])/(Length[array3]))],Length[array3]},{"array4",ByteCount[array4],N[((ByteCount[array4])/(Length[array4]))],Length[array4]}},Background->{None,{{None,None,None,Yellow,None}}}]

Mean@Table[Timing[array1 array1][[1]],{10}]

Mean@Table[Timing[array3 array3][[1]],{10}]

Ennek kellene működnie ☹

array5=ToPackedArray[array1];
PackedArrayQ[array5]

De nem.

Új házi feladatok: amik elmaradtak :)

1. Valamelyik korábbi függényt egészítsük ki opcióval és alapértelmezés szerinti értékkel. (Szabad ellopni a másét - feltéve, h a lopó megértette a működését! - a honlapomról evégett.)

2. Rajzoljunk meg négy vagy akárhány halmazra olyan ábrát, amely az összes lehetséges viszonyt mutatja.