Techniki komputerowe
     w robotyce

Wykład VI

Mathematica

Robert Muszyński

Katedra Cybernetyki i Robotyki
Wydział Elektroniki, Fotoniki i Mikrosystemów
Politechnika Wrocławska

Copyright 2009-2026 RM

Skąd wziąć, jak uruchomić, jak zakończyć

Wolfram Research https://www.wolfram.com/

Mathematica https://www.wolfram.com/mathematica/

Wolfram Cloud https://www.wolframcloud.com/

Wolfram Player https://www.wolfram.com/player/

Wolfram Alpha https://www.wolframalpha.com/

Wolfram System Modeler https://www.wolfram.com/system-modeler/

Interfejsy użytkownika

tekstowy (polecenie: math lub wolfram)

graficzny (polecenie: mathematica, wolframnb lub naduszając ikonę)

Wprowadzanie wyrażeń, inicjowanie obliczeń

interfejs tekstowy – wpisz wyrażenie i naciśnij enter

interfejs graficzny – wpisz wyrażeni-e/a i naciśnij shift+enter

By zakończyć

interfejs tekstowy – użyj funkcji Quit

interfejs graficzny – użyj menu lub Ctrl+Q

Potrzebujesz pomocy?

poprzedź polecenie znakiem zapytania (lub nawet dwoma)

?Sin

użyj „wyrażeń regularnych”

?Sin*

zwracaj uwagę na kolory

?Sin*

Sin[π/3]+Sim[π/3]
Sin[π/3]+Sin[π/]

w trybie graficznym użyj menu Help :)

Nie uruchamiaj „wielu” Mathematic jeśli nie potrzebujesz

wybranie ikony pliku w formacie Mathematici czy też otwarcie pliku bezpośrednio ze strony www zazwyczaj otwiera nową instancję Mathematici (z nowym jądrem MathKernel) – by otworzyć kilka plików w tym samym jądrze użyj menu Open

Mathematica jako kalkulator – obliczenia numeryczne

Arytmetyka – dokładnie i w przybliżeniu, z dowolną precyzją

2+2                    (* dokładnie *)
2+2.                  (* przybliżenie *)
N[2+2]
2+2//N

2^100                 (* dokładnie *)
(2^100)                      (* standardowy zapis matematyczny *)
2^100//N       (* przybliżenie *)
2.^100
2^100.

1/3+2/7                          (* dokładnie – liczby „wymierne" *)
%+0.000000000000001 (* przybliżenie – liczby „rzeczywiste" *)
1/3.+2/7
1/3+2/7//N

Pi                       (* dokładnie *)
Pi//N             (* przybliżenie *)
N[Pi]
N[Pi,300]

x+y+z	x-y-z		x*y*z		x y z		x/y/z	-x

N[expr]	expr//N		N[expr,acc]

Funkcje matematyczne

Z argumentami w nawiasach kwadratowych [], nazwy funkcji wbudowanych zawsze dużą literą

Sin[1]          (* dokładnie *)
Sin[Pi]
Sin[Pi/3]
Sin[1.]        (* przybliżenie *)
Sin[Pi/3]//N

Sin[Pi/5]      
Sin[Pi/13]

Sin[30 Degree]
Tan[Pi/2]

Sqrt[16]              (* dokładnie *)
Sqrt[2]                (* dokładnie *)
Sqrt[2]//N      (* przybliżenie *)
Sqrt[-2]             (* urojenie *)

Sqrt[x] 	Exp[x]		Log[x]		Log[b, x]
 Sin[x]		Cos[x]		Tan[x]		Cot[x]
 ArcSin[x]	ArcCos[x]	ArcTan[x]	ArcCot[x]
 n!			Abs[x]		Round[x]	Mod[n, m]

Więcej funkcji matematycznych i ich wizualizacja

Eigenvalues[(({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}))]

Solve[(Sqrt[x])+a==2x,x]  (* a tu już obliczenia symboliczne *)

∫(Sqrt[x])(Sqrt[a+x])\[DifferentialD]x
D[%,x]
%//FullSimplify

Plot[Sin[x]+Sin[1.6x],{x,0,40}]

Plot3D[Sin[x y],{x,-4,4},{y,-4,4}]

Plot3D[Sin[x+Sin[3 y]],{x,-3,3},{y,-3,3},PlotPoints->30]
Show[%,%%]

ParametricPlot[{Cos[3u],Sin[7u]},{u,0,2π}]
ParametricPlot3D[{Cos[u],Sin[u]+Cos[v],Sin[v]},{u,0,2π},{v,-π,π}]
ParametricPlot3D[{u/20 Sin[u],u/20 Cos[u],u/10},{u,0,20}]

torus1={4+(3+Cos[v]) Sin[u],4+(3+Cos[v]) Cos[u],4+Sin[v]};
torus2={8+(3+Cos[v]) Cos[u],3+Sin[v],4+(3+Cos[v]) Sin[u]};
ParametricPlot3D[{torus1,torus2},{u,0,2Pi},{v,0,2Pi},PlotStyle->{Red,Green}]

ListPlot[Table[{k,PDF[BinomialDistribution[50,p],k]},{p,{0.3,0.5,0.8}},{k,0,50}],Filling->Axis,PlotLegends->{0.3,0.5,0.8}]

Manipulate[Plot[Evaluate[y[t]/.First[NDSolve[ {y''[x]==-x y[x],y[0]==a,y'[0]==b},y,{x,0,4}]]],{t,0,4},Epilog->{Point[{4,1/2}],Green,Arrow[{{0,a},{1,b+a}}],Red,Point[{0,a}]},ImagePadding->25,PlotRange->3],
{{a,1,TraditionalForm[y[0]]},-3,3},
{{b,0,TraditionalForm[y'[0]]},-3,3}]

A=(({{-1.1, 0.9}, {-1.4, 0.3}}));
Manipulate[ParametricPlot[Evaluate[MatrixExp[A t,#]&/@pt],{t,0,10},PlotRange->5],{{pt,{{2,0},{0,1},{-3,0}}},Locator},SaveDefinitions->True]

Animate[Plot[Evaluate[{Sin[x],Normal[Series[Sin[x],{x,0,n}]]}],{x,-10,10},PlotRange->3],{n,1,20,2},AnimationRunning->False]

Animate[Column[{Plot[{Sin[f1 x+t],Sin[f2 x-t]},{x,-2 π,2 π},PlotRange->1.1],Plot[Sin[f2 x-t]+Sin[f1 x+t],{x,-2 π,2 π},PlotRange->2]}],{f1,1,10},{f2,1,10},{t,0,2 π},AnimationRunning->False]

Animate[Graphics[Translate[Rotate[{Circle[],Point[{0,1}]},-t],{t ,0}],PlotRange->{{-2,10},{-2,2}},ImageSize->{Large,Tiny}],{t,0,2π},AnimationRunning->False]

Eigenvalues[m]	 Solve[r,z]	 Ingegrate[f,x]	  Plot[f,x]
 Eigenvectors[m] NSolve[r,z] NIngegrate[f,x]  LogPlot[f,x]
 Det[m]	         Reduce[r,z] Sum[f,{i,(Subscript[i, max])}] Plot3D[f,x,y]     
 Tr[m]    	     Root[f,c]   D[f,x]           ParametricPlot[{(Subscript[f, x]),(Subscript[f, y])},u]
 Transopse[m]    DSolve[r,z] Dt[f,x]          ListPlot[{(Subscript[y, 1]),...,(Subscript[y, n])}]
 Inverse[m]      NDSolve[r]                   Manipulate[expr,{u,(Subscript[u, min]),(Subscript[u, max])}]
 Minors[m]       ParametricNDSolve[r]         Animate[expr,{u,(Subscript[u, min]),(Subscript[u, max])}]

Równania, równania, równania

Algebraiczne

Solve[x^2-2x+1==0,x]
Solve[x^2-2x+2==0,x]
Solve[x^2-2x+a==0,x]
Solve[a x^2+b x+c==0,x]

okrag=x^2+y^2==1                      (* przecinanie *)
parab=y-2x^2+3/2==0
fkcje=ContourPlot[Evaluate[{okrag,parab}],{x,-1.5,1.5},{y,-1.5,1.5}]
rozw=Solve[okrag&&parab,{x,y}]
Show[{fkcje,Graphics[{Red,PointSize[Large],Point[{x,y}/.rozw]}]}]

Solve[x^4+2x^3-13x^2-14x+24==0,x]    (* wielomian 4 stopnia *)
Solve[x^4+2x^3-13x^2-14x+25==0,x]
Solve[x^4-6x^3+8x+1==0,x] 
Solve[x^4-6x^3+8x+1==0,x,Cubics->True]
%//N

wiel=x^5-6x^3+8x+1==0    (* wielomian 5 stopnia *)
Solve[wiel,x]
rozw=Solve[wiel,x,Cubics->True]
poch=Solve[D[wiel,x],x,Cubics->True]
rozw//N
Show[{Plot[Evaluate[wiel[[1]]],{x,-3,3}],Graphics[{Red,PointSize[Large],Point[{x,0}/.rozw]}],
Graphics[{Blue,PointSize[Large],Point[{x,0}/.poch]}]}]

Solve[x^2+y^2==5^2&&y>x>0,{x,y},Integers]  (* trójki pitagorejskie *)
Table[Solve[x^2+y^2==z^2&&y>x>0,{x,y},Integers],{z,30}]

Solve[{x^2+y^2==1,x+3 y==0},{x,y}]
Solve[Sin[x]==1/2,x]
Solve[Sin[x]==a,x]
Solve[Sin[x]==x,x]

Solve[r,z]      FindRoot[r,{z,(Subscript[z, 0])}]
NSolve[r,z]     FindMinimum[f,z]
RSolve[r,a,z]   NMinimize[f,z]

Różniczkowe zwyczajne

Proste liniowe   (( dy(x))/(dx))+y(x)==sin(x)

DSolve[y'[x]+y[x]== Sin[x],y[x],x]
rozw=DSolve[{y'[x]+y[x]==Sin[x],y[0]==0},y[x],x]
Plot[y[x]/.rozw,{x,0,40}]

Klotoidy ({{{, ({{x'(s)==cos(t(s))
y'(s)==sin(t(s)),  }, {t'(s)=s,  }})}})

klot={x'[s]==Cos[t[s]],
         y'[s]==Sin[t[s]],
         t'[s] ==s};  
rozw=DSolve[{klot,x[0]==0,y[0]==0,t[0]==0}, {x,y,t},s];
ParametricPlot[Evaluate[{x[s], y[s]}/.rozw], {s,-10,10}]

Nieliniowego oscylatora z wymuszeniem   (x')'(t)+(x^3)(t)==sin(t)

osc={x''[t]+x[t]^3==Sin[t]}
rozw=NDSolve[{osc,x[0]==x'[0]==0},x,{t,0,50}]
Plot[Evaluate[{x[t],x'[t]}/.rozw],{t,0,50},PlotLegends->{x,x'}]
ParametricPlot[Evaluate[{x[t],x'[t]}/.rozw],{t,0,50}]

Atraktora Lorentza    ({{{, ({{x'(t)==-3 (x(t)-y(t))
y'(t)==-x(t) z(t)+26.5 x(t)-y(t),  }, {z'(t)==x(t) y(t)-z(t),  }})}})

(lor={x'[t]==-3 (x[t]-y[t]),y'[t]==-x[t] z[t]+26.5 x[t]-y[t],z'[t]==x[t] y[t]-z[t]})//MatrixForm
rozw=NDSolve[{lor,x[0]==z[0]==0,y[0]==1},{x,y,z},{t,0,400},MaxSteps->∞];
ParametricPlot3D[Evaluate[{x[t],y[t],z[t]}/.rozw],{t,0,400},PlotPoints->1000,PlotStyle->Directive[Thick,RGBColor[.8,0,0]],ColorFunction->(ColorData["SolarColors",#4]&)]

Z opóźnieniem    y'(t)==λ y(t)+μ y(t-1)  – analiza stabilności

Manipulate[
Module[{syst,sol,y,t},
syst=y'[t] == λ y[t] + μ y[t - 1];
sol = First[y /. NDSolve[{syst, y[t /; t ≤ 0]==1 - t}, y,
{t,0,10}]];
If[pp, ParametricPlot[{sol[t],sol[t-1]},{t,1,10},PlotRange->{{-3,3},{-3,3}}],
Plot[sol[t],{t,0,10}, PlotRange->{{0,10},{-3,3}}]]],{{pp,False, "Plot in phase plane"},{True, False}},{{λ, 0},-5,5},{{μ,0},-5,5}, FrameLabel->ToString[y'[t] == λ y[t]+μ y[t-1], TraditionalForm]]

DSolve[r,z,x]  NDSolve[r,z,{x,(Subscript[x, 0]),(Subscript[x, k])}]  ParametricNDSolve[r,z,{x,(Subscript[x, 0]),(Subscript[x, k])},p]

Różniczkowe cząstkowe

Przepływ ciepła     ((∂u(t,x))/(∂t))==(c^2) (((∂^2)u(t,x))/(∂(x^2)))

rown=(∂_t)u[t,x]==(∂_(x,x))u[t,x]             (* przepływ ciepła w pręcie *)
rozw=NDSolve[{rown,u[0,x]==0,(* startowa temperatura całego pręta *) 
u[t,0]==Sin[t],                             (* grzanie na początku *)
u[t,5]==0                                            (* stabilizowanie temperatury na końcu *)
},u,{t,0,10},{x,0,5}]
Plot[Evaluate[{u[t,0],u[t,1]}/.rozw],{t,0,10},PlotLegends->{u[t,0],u[t,1]}]
Animate[Plot[Evaluate[{u[t,x]}/.rozw],{x,0,5},PlotRange->{-1,1}],{t,0,10}]
Plot3D[Evaluate[u[t,x]/.rozw],{t,0,10},{x,0,5}, PlotRange->All]

Falowe     (((∂^2)u(t,x))/(∂(t^2)))==(c^2) (((∂^2)u(t,x))/(∂(x^2)))

rown={D[u[t,x,y],{t,2}]-Laplacian[u[t,x,y],{x,y}]==0,DirichletCondition[u[t,x,y]==0,True]}
rown//TraditionalForm
fala[x_,y_]=2*Exp[-125((x-0.25)^2+(y-0.5)^2)];
init={u[0,x,y]==fala[x,y],Derivative[1,0,0][u][0,x,y]==0}
rΩ=RegionDifference[RegionDifference[Rectangle[{0,0},{2,1}],Rectangle[{9/10,0},{11/10,4/10}]],Rectangle[{9/10,6/10},{11/10,1}]];
sol=u/.First[NDSolve[{rown,init},u,{t,0,2},{x,y}∈rΩ]]
Plot3D[fala[x,y],{x,0,2},{y,0,1},PlotRange->All]
ListAnimate[Table[Rasterize[Plot3D[sol[t,x,y],{x,y}∈rΩ,PlotRange->{-0.75,2},AspectRatio->Automatic]],{t,0,2,1/25}],SaveDefinitions->True,AnimationRunning->False]

DSolve[r,z,x]  NDNSolve[r,z,{x,(Subscript[x, 0]),(Subscript[x, k])}]  ParametricNDNSolve[r,z,{x,(Subscript[x, 0]),(Subscript[x, k])},p]

Filozofia systemu

Wszystko jest wyrażeniem

Plus[a,b,Sin[x]]
Expand[(((x+y))^10)]
Plot[Sin[x],{x,0,10}]

x+y==10
Solve[x+y==10]
∫(1/((x^4)+1))\[DifferentialD]x
∫Cos[Cos[x]]\[DifferentialD]x

Tilde[CirclePlus[a,b], Subscript[c,Infinity]]
Graphics[{Circle[{1, 0}, 2],Circle[{-1, 0}, 2]}]
GraphPlot[Table[i->Mod[i^2,102],{i,0,102}]]
Cell[TextData[{"Ala ma kota ",Cell[BoxData[SuperscriptBox["x","2"]]]}],"Output"]//CellPrint

Także obiekty geograficzne

GeoGraphics[]
GeoGraphics[GeoDisk[LinguisticAssistant,LinguisticAssistant]]

polska=GeoGraphics[{EdgeForm[Black],FaceForm[Red],Polygon[LinguisticAssistant]}]
GeoGraphics[{EdgeForm[Black],FaceForm[Red],Polygon[Entity["Country","Poland"]]},GeoProjection->{"Orthographic","Centering"->GeoPosition[{0,-50}]},Background->Black]

I chemiczne

woda=Molecule["Water"]
Molecule[{(Entity["oxygen", Entity["Element","Oxygen"], "Entity[\"Element\", \"Oxygen\"]", "element"]),(Entity["deuterium", Entity["Isotope","Hydrogen2"], "Entity[\"Isotope\", \"Hydrogen2\"]", "isotope"]),(Entity["deuterium", Entity["Isotope","Hydrogen2"], "Entity[\"Isotope\", \"Hydrogen2\"]", "isotope"])},{Bond[{1,2},"Single"],Bond[{1,3},"Single"]}]
kofe=Molecule[(Entity["caffeine", Entity["Chemical","Caffeine"], "Entity[\"Chemical\", \"Caffeine\"]", "chemical"])]
MoleculePlot3D[woda]
MoleculePlot3D[kofe]

Czy anatomiczne

serce=Entity["AnatomicalStructure","Heart"]
serce["Graphics3D"]
serce["Shape"]
Entity["Protein","CD1A"]["StructureDiagram"]
Entity["Virus","Adenovirus"]["GenomeLength"]

Wyrażeniem reprezentowanym przez listę!

Plus[a,b,Sin[x]]//FullForm
Expand[(((x+y))^10)]//FullForm
Expand[(((x+y))^10)]//Hold//FullForm
Plot[Sin[x],{x,0,10}]//Hold//FullForm
Plot[Sin[x],{x,0,10}]//FullForm

List[a,b,c]
Plus[a,b,c]
%%//FullForm
%%//FullForm

lista=List[a,b,c];
suma=Plus[a,b,c];
lista[[2]]
suma[[3]]
lista[[0]]

lista[[2]]=5
suma[[3]]=8
lista
suma

lista[[{2,3}]]={5,8}
suma[[{2,3}]]={5,8}
lista
suma

lista[[{2,3}]]={lista[[3]],lista[[2]]}  (* zamiana miejscami elementów *)
lista

lista[[0]]=Plus
lista
lista[[0]]=List
lista

x+y==10//FullForm
Solve[x+y==10]//FullForm
Solve[x+y==10]//Hold//FullForm
∫(1/((x^4)+1))\[DifferentialD]x//FullForm
∫Cos[Cos[x]]\[DifferentialD]x//FullForm

Graphics[{Circle[{1, 0}, 2],Circle[{-1, 0}, 2]}]//Hold//FullForm
GraphPlot[Table[i->Mod[i^2,102],{i,0,102}]]//Hold//FullForm

GeoGraphics[GeoDisk[LinguisticAssistant,LinguisticAssistant]]//Hold//FullForm
GeoGraphics[{EdgeForm[Black],FaceForm[Red],Polygon[LinguisticAssistant]}]//Hold//FullForm

woda//FullForm
kofe//FullForm
MoleculePlot3D[woda]//FullForm

Entity["AnatomicalStructure","Heart"]//FullForm
Entity["Protein","CD1A"]["StructureDiagram"]//FullForm

Podstawowa reguła Mathematici – weź wyrażenie i zastosuj do niego reguły przekształcania tak długo, aż przestanie się zmieniać

Tak więc

Portret fazowy

Manipulate[Module[{sol=NDSolve[{y''[t]+Sin[y[t]]==0,y[0]==p[[1]],y'[0]==p[[2]]},y,{t,0,T}]},ParametricPlot[Evaluate[{y[t],y'[t]}/.sol],{t,0,T},PlotRange->{{-10,10},{-4,4}}]],{{p,{2,1}},Locator},{{T,10,"time"},0.1,30}]

splot=StreamPlot[{y,(1-x^2) y-x},{x,-4,4},{y,-3,3},StreamColorFunction->"Rainbow"];
Manipulate[Show[splot,ParametricPlot[Evaluate[First[{x[t],y[t]}/.NDSolve[{x'[t]==y[t],y'[t]==y[t] (1-x[t]^2)-x[t]+0.5 Cos[1.1 t],Thread[{x[0],y[0]}==point]},{x,y},{t,0,T}]]],{t,0,T},PlotStyle->Red]],{{T,20,"time"},1,100},{{point,{3,0}},Locator},SaveDefinitions->True]

Fraktal

M=Compile[{x,y},Block[{z=x+I*y,k=0},While[Abs[z]<2&&k<50,z=z^2+x+I*y;++k];k]];
DensityPlot[50-M[x,y],{x,-2,1},{y,-1.5,1.5},PlotPoints->200,Mesh->False]

Coś "dynamicznego"

Dynamic@Module[{hour,min,sec,ht,mt,st},Clock[];{hour,min,sec}=Take[DateList[],-3];ht=Pi/2-2Pi hour/12-2Pi min/720;mt=Pi/2-2Pi min/60;st=Pi/2-2Pi Floor[sec]/60;Graphics[{Arrowheads[0.1],Arrow[{{0,0},0.6{Cos[ht],Sin[ht]}}],Arrow[{{0,0},0.85{Cos[mt],Sin[mt]}}],Line[{{0,0},0.85{Cos[st],Sin[st]}}],PointSize[Medium],Table[Point[0.9{Cos[i],Sin[i]}],{i,0,2Pi,Pi/6}],Point[{0,0}],Circle[]}]]

I "geograficznego"

DynamicModule[{pt={52,19}},LocatorPane[Dynamic[pt],Dynamic@GeoGraphics[{Red,Opacity[0.5],GeoDisk[Reverse@pt,Quantity[2000,"Kilometers"]]},GeoRange->"World"]]]
DynamicModule[{pt={52,19},pos=GeoPosition[{52,19}]},LocatorPane[Dynamic[pt,(pt=#;pos=GeoGridPosition[#+{0,0},"Robinson"])&],Dynamic@GeoGraphics[{Red,Opacity[0.5],GeoDisk[pos,Quantity[2000,"Kilometers"]]},GeoProjection->"Robinson", (* Orthographic LambertAzimuthal *)
GeoRange->"World",GeoGridLines->Automatic,ImageSize->Large]]]

With[{locations={GeoPosition[{-35,-55}],GeoPosition[{70,100}]}},GeoGraphics[{{Blue,GeoPath[locations,"Geodesic"]}},GeoRange->"World",GeoProjection->"Robinson"]] (* Orthographic LambertAzimuthal *)

{zakrWys,zakrSzer}=GeoBounds[Entity["Country","Poland"]]   (* wielkość Polski *)
wysokosc=GeoDistance[{zakrWys[[1]],zakrSzer[[1]]},{zakrWys[[2]],zakrSzer[[1]]}]
szerokosc=GeoDistance[{zakrWys[[1]],zakrSzer[[1]]},{zakrWys[[1]],zakrSzer[[2]]}]
GeoGraphics[{EdgeForm[Red],GeoStyling[None],Entity["Country","Poland"],Blue,Opacity[0.2],GeoBoundsRegion[{zakrWys,zakrSzer}]},GeoRangePadding->Quantity[100,"Kilometers"]]

olympus=GeoGraphics[(Entity["Olympus Mons", Entity["SolarSystemFeature","OlympusMonsMars"], "Entity[\"SolarSystemFeature\", \"OlympusMonsMars\"]", "solar system feature"]),GeoRange->Quantity[750,"Kilometers"]]
obrPolska=Rasterize[polska,ImageSize->400];
obrOlimp=Rasterize[olympus,ImageSize->400];
ImageCompose[obrPolska,{obrOlimp,0.6}]

ImageData[obrazekPolska][[100,100]]
obrPolska//FullForm

wroclaw=Entity["City",{"Wroclaw","Dolnoslaskie","Poland"}]
poland=Entity["Country","Poland"]
EntityValue[wroclaw,"Population"]
EntityValue[wroclaw,EntityProperty["City","Population",{"Date"->DateObject[{2005}]}]]

lives=Map[EntityValue[wroclaw,EntityProperty["City","Population",{"Date"->DateObject[{#}]}]]&,Range[1975,2026]]
ListPlot[lives]

EntityProperties[wroclaw]

Length[cities=CityData[{Large,"Poland"}]]
roads=Quiet@TravelDirections[{#,wroclaw},"TravelPath"]&/@cities;
Length[roads=Cases[roads,_GeoPath]]

GeoGraphics[{GeoStyling[White],Polygon[poland],Red,Opacity[.1],roads,Black,Opacity[0.6],Point[cities],Blue,Opacity[1],PointSize[Large],Point[wroclaw]},GeoBackground->LightBlue,ImageSize->600,GeoRange->poland]//Rasterize

A tu anatomicznego

EntityList[EntityClass["AnatomicalStructure", {"WeightPercerontageOfTotalBody" -> TakeLargest[10]}]]

AnatomyPlot3D[{Entity["AnatomicalStructure", "Skeleton"], Entity["AnatomicalStructure", "AlimentarySystem"]}, PlotRange -> Entity["AnatomicalStructure", "Trunk"], ImageSize -> 300]

Przetwarzanie obrazów

img=Import["cat.jpg"];
cat=ImageData[img];
ArrayPlot[cat,ColorFunction->(RGBColor[#]&),ColorFunctionScaling->False]
cat//Dimensions
cat

data=cat.{0.299,0.587,0.114}//Reverse;
ListDensityPlot[data,ColorFunction->RGBColor]
ListDensityPlot[data^2,ColorFunction->RGBColor]
ListDensityPlot[Log[(Sqrt[data])],ColorFunction->RGBColor]

ListDensityPlot[Cos[2 Pi data],ColorFunction->RGBColor]
ListDensityPlot[Cos[16 Pi data],ColorFunction->RGBColor]

ListContourPlot[data,ContourShading->False,Contours->6]

lenaimg=ExampleData[{"TestImage","Lena"}]
lena=ImageData[lenaimg];

ExampleData[{"AerialImage","Pentagon"}]

Dźwięk i sonifikacja

Play[Sin[2Pi 440 t],{t,0,1}]
Play[Sin[1000/t],{t,0,5}]
ListPlay[RandomReal[{-1,1},16000]]

Play[Sin[700 t+25 t Sin[350 t]],{t,0,4}]
Play[Sin[((π t)/2)] (∑_(ν=0)^24)If[(ν/12)<t<(ν/12)+(1/4),(1/24) (E^(-(1/36) (((3+2 ν-24 t))^2))) ν Sin[1625 ν t-13000 t],0],{t,0,2},PlayRange->All]

<<Music`
MusicScale[JustMajor,440,3]
Show[MusicScale[JustMinor[[{1,3,5,8,5,3,1}]],Aflat3,3]]

Sound[{SoundNote["C"],SoundNote["G"],SoundNote["A"]}]

Sound[SoundNote[DeleteCases[3 Range[21]Reverse[#],0]-24,.1]&/@Transpose[CellularAutomaton[90,{{1},0},20]]]

Sound[SoundNote[#,RandomReal[2],RandomChoice[{"Piano","Cello","Tuba"}]]& /@ RandomInteger[12, 50], 4]

Grid[Partition[MapIndexed[Labeled[Audio[Mean[AudioGenerator[{"Sin",#},.1]&/@#],Appearance->"Minimal"],First@#2]&,Flatten[Outer[List,{697,770,852},{1209,1336,1477}],1]],3]]

Speak["this is some text which I can read"]

Sieci neuronowe

resource = ResourceObject["MNIST"]; trainingData = ResourceData[resource, "TrainingData"]; testData = ResourceData[resource, "TestData"];
RandomSample[trainingData, 5]

lenet = NetChain[ {ConvolutionLayer[20, 5], Ramp, PoolingLayer[2, 2], ConvolutionLayer[50, 5], Ramp, PoolingLayer[2, 2], FlattenLayer[], 500, Ramp, 10, SoftmaxLayer[]}, "Output" -> NetDecoder[{"Class", Range[0, 9]}], "Input" -> NetEncoder[{"Image", {28, 28}, "Grayscale"}] ]
lenet = NetTrain[lenet, trainingData, ValidationSet -> testData, MaxTrainingRounds -> 3]

imgs = Keys @ RandomSample[testData, 5]; Thread[imgs -> lenet[imgs]]

Także drugi przykład wykwintny w Classify (logistic classifier for digits)

?Classify

Media społecznościowe

https://www.wolfram.com/language/11/computational-photography/import-and-analyze-a-collection-from-social-media.html

https://reference.wolfram.com/language/ref/SocialMediaData.html

LLM-y

https://reference.wolfram.com/language/guide/LLMFunctions.html

Filmoteka

Więcej w MovieData

Zmienne mogą przyjmować dowolne wartości – także symboliczne! Można więc przypisać  do nich cokolwiek, nawet kota, jeśli ma się jakiegoś pod ręką (choć po prawdzie to nie może być kot zewnętrzny ;)