Kurs Komputerowy S
System Symboliczny
Mathematica

Programowanie

Funkcje logiczne (analiza własności)

IntegerQ[wartość]
NumberQ[wartość]
NumericQ[wartość]
OddQ[wartość]
EvenQ[wartość]
PrimeQ[wartość]
VectorQ[wartość]
MatrixQ[wartość]
ArrayQ[wartość]
MemberQ[wartość,lista]
LetterQ[wartość]
DigitQ[wartość]
StringQ[wartość]
SyntaxQ[wartość]

IntegerQ[x]

IntegerQ[2.]

IntegerQ[2.5]

NumberQ[x]

NumberQ[2]

NumberQ[Sqrt[2]]

NumericQ[x]

NumericQ[2]

NumericQ[Sqrt[2]]

x=3

x

abc

NumericQ[abc]

VectorQ[x]

VectorQ[{1,2,3}]

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

MatrixQ[x]

MatrixQ[{1,2,3}]

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

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

ArrayQ[x]

ArrayQ[{1,2,3}]

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

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

?*Q

Wprowadzanie danych i wypisywanie

Input[tekst]
InputString[tekst]
Pause[czas]
Print[wyrażenie]
PrintTemporary[wyrażenie]

a=Input["Podaj liczbę"]

a

a=Input["a=",5]

a

a=3
Pause[5]
b=4

c=Print["a=",a]

c

d

Out[29]*4

Do[PrintTemporary["poczekaj ",i," chwile"];Pause[0.5],{i,1,5}];a

Operacje

Increment[x]            (*   x++   *)
PreIncrement[x]      (*   ++x   *)
Decrement[x]          (*   x--   *)
PreDecrement[x]    (*   --x   *)
AddTo                  (*   x+=y   *)
SubtractFrom      (*   x-=   *)
TimesBy              (*   x*=y   *)
DivideBy              (*   x/=y   *)

x=1;x++

x

y=1;++y

y

a=3;b=2;
a+=b

a

Warunki

w==5

w===4

If[warunek,jeżeli_prawda,jeżeli_fałsz,jeżeli_coś_innego]
Which[warunek_1,wyr_1,warunek_2,wyr_2,...]
Switch[wyrażenie,wart_1,wyr_1,wart_2,wyr_2,...]

b=3

a=5;
q=If[a==5,b=b^2,b=b/a];

q

b

Out[52]

a=6;
If[a==5,b=b^2,b=b/a]

a=.;
If[a==5,b=b^2,b=b/a]

a=.;
If[a==5,b=b^2,b=b/a,b=2]

b

a=5;
Which[a==5,b=b^2,a==6,b=b/a,a==2,b=2]

a=6;
Which[a<5,b=b^2,a==6,b=b/a,a==2,b=2]

a=2;
Which[a<5&&a>-3,b=b^2,a==6,b=b/a,a==2,b=2]

a=3;
Which[a==5,b=b^2,a==6,b=b/a,a==2,b=2]

a=5;
Switch[a,5,b=b^2,6,b=b/a,2,b=2]

Pętle

Do[wyrażenie,iterator]
While[warunek,wyrażenie]
For[wart_poczatkowe,warunek,zmiana_iteratora,wyrażenie]

Clear[a];

q

Do[Print["i=",i];q=i,{i,5,1,-1}]

q

i

Do[Print["i=",i];a=i,{i,5}]

a

i=.

i=0;While[i<5,i++;Print["i=",i]]

i

i=1;While[i≤ 5,Print["i=",i];i++]

i=.

For[i=1,i≤ 5,i++,Print["i=",i]]

Kontrola

Break[ ]
Continue[ ]
Return[wyrażenie]
Goto[etykieta]   Label[etykieta]
Monitor[wyrażenie,zmienna]
Throw[wartość]
Catch

Do[If[i==3,Break[]];Print["i=",i],{i,1,5}]

Do[If[i==3,Continue[]];Print["i=",i],{i,1,5}]

Do[If[i==3,Return[i]];Print["i=",i],{i,1,5}]

Monitor[i=0;While[i<20,Pause[0.1];i++];i^2,i]

Catch[Do[If[i!>10^10,Throw[i]],{i,100}]]

14!

13!

t={};
Do[AppendTo[t,{}];
Do[AppendTo[t[[i]],0],{j,5}],{i,1,5}]
t

Przekazywanie zmiennych

f[zmienna_]
f[zmienna__]
f[zmienna___]
f[zmienna_:WartPocz]

Clear[f,x,y]

f[x]=x^4

f[1]
f[2]
f[x]
f[y]

Clear[f]

x=3;
f[x]=x^4

f[1]
f[2]
f[3]
f[x]
f[y]

Clear[f]

x=3;
f[x_]=x^4

f[1]
f[2]
f[y]

Clear[f]

x=3;
f[x_]:=x^4

f[1]
f[2]
f[x]
f[y]

Clear[f]

x=3;
f[x_]:=(y=x^4;{x,y})

f[5]

f[1]
f[2]
f[y]
f[]
f[x,y]

g[x__]:={Length[{x}],Flatten[{x}]/2}

g[1]
g[1,2]
g[]

g[1,2]

g[{1,2}]

g[1,2,3,4,5]

h[x___]:=Print["Ilość podanych parametrów: ",Length[{x}]]

h[1]
h[1,2]
h[]

Options[Roots]

Remove[f]

f[x___]:=Print["Ilość parametrów: ",Length[{x}]]
f[x_]:=x^2
f[x__]:={x}

f[1]
f[2]
f[1,2]
f[2,3,4]
f[]

f2[x_]:=2x

f2[1]

f2[]

f1[x_:4]:=5x

f1[2]
f1[]

Clear[g]

g[x_:4,y_:7]:=Print["x=",x,"  y=",y]

g[2,5]

g[]

g[9]

Warunkowe definicje

f[x_Head]
f[x_] := wyrażenie /; test

Clear[f,g,h,h1]

a=2x+3y^2-Sqrt[x^y]

?a

FullForm[a]

b={1,2,3,4,5}

FullForm[b]

a[[2,2,1,1]]=2

a

Head[a]

f[x_Integer]:=Print["podałeś liczbę: ",x]

f[1]

a={4.5}

Head[a]

f[1]
f[1.3]

f[x_Real]:=Print["Twoja liczba to: ",x]

f[1]
f[1.3]

f[x_List]:=Length[x]

f[5]
f[5.5]
f[{5,5}]

g[x_]:=Print["Liczba parzysta: ",x]/;EvenQ[x]

g[1]
g[2]

g[x_]:=Print["A teraz nieparzysta: ",x]/;OddQ[x]

g[x_]:=Print["Liczba rzeczywista (z przecinkiem): ",x]/;Not[IntegerQ[x]]

g[2.4]
g[2]
g[1]

?g

Clear[h]

h[x_]:=Print["Parzysta: ",x]/;EvenQ[x]
h[x_]:=Print["Nieparzysta: ",x]/;OddQ[x] 
h[x_]:=Print["Liczba: ",x]/;NumberQ[x]

h[1.4]
h[1]
h[2]

Clear[h]

h[x_]:=Print["Liczba: ",x]/;NumberQ[x]
h[x_]:=Print["Parzysta: ",x]/;EvenQ[x]
h[x_]:=Print["Nieparzysta: ",x]/;OddQ[x]

h[1.4]
h[1]
h[2]

Procedury i funkcje

Module[{zmienne_lokalne},wyrażenie]
Block[{zmienne_lokalne},wyrażenie]
With[{stale},wyrażenie]
Function[wyrażenie]

a=5
b=4

Module[{},a=10;a=b^4]

a

Clear[a]

a=4

Block[{a=10},Print["a=",a];a=b^4;Print["a=",a];a]

a

Clear[i,a];
m=i^2

Module[{i=a},i+m]

Block[{i=a},i+m]

With[{i=4},i^4+5]

p=Function[u,u^3]

p[2]

Function[#^3]

%[6]

#^3&

%[4]

Clear[f,g]

f[x_,y_]:=x^3+y/2

f[2,6]

g=Function[{x,y},x^3+y/2]

g[2,6]

Właściwości nowych poleceń

a=x+y

b=y+x

??Plus

Plus=4

Attributes[polecenie]
SetAttributes[polecenie, właściwość]
ClearAttrbutes[polecenie,właściwość]

Attributes[Plus]

Plus[2,q]=5

Attributes[f]

?f

Attributes[f]=Flat

Attributes[f]

Attributes[f]={Listable,Orderless}

Attributes[f]

SetAttributes[f,Flat]

Attributes[f]

ClearAttributes[f,Orderless]

Attributes[f]

Właściwości

Constant

Clear[f,x,b,g]

D[f[x],x]

Attributes[f]=Constant

D[f[x],x]

ClearAttributes[f,Constant]

Flat

Clear[a];

f[a,f[b],c]

Attributes[f]=Flat

f[a,f[b],c]

ClearAttributes[f,Flat]

HoldAll

f[2+4,6+2,5-3]

Attributes[f]=HoldAll

f[2+4,6+2,5-3]

f[Evaluate[2+4],6+2,5-3]

ClearAttributes[f,HoldAll]

HoldAllComplete

f[2+4,6+2,5-3]

Attributes[f]=HoldAllComplete

f[2+4,6+2,5-3]

f[Evaluate[2+4],6+2,5-3]

ClearAttributes[f,HoldAllComplete]

HoldFirst

HoldRest

Listable

f[{a,b,c}]

Attributes[f]=Listable

f[{a,b,c}]

ClearAttributes[f,Listable]

Locked

Attributes[f]={Constant,Flat,Listable}

Attributes[f]

Attributes[f]={Constant,Flat}

Attributes[f]

SetAttributes[f,Locked]

Attributes[f]

Attributes[f]={Constant,Flat,Listable}

Attributes[f]

ClearAttributes[f,Locked]

NHoldAll

g[2+3,2+Pi]

N[%]

Attributes[g]=NHoldAll

g[2+3,2+Pi]

N[%]

ClearAttributes[g,NHoldAll]

NHoldFirst

NHoldRest

NumericFunction

Clear[g]

NumericQ[g[2,3]]

Attributes[g]=NumericFunction

NumericQ[g[2,3]]

g[2,3]

ClearAttributes[g,NumericFunction]

OneIdentity

Orderless

g[b,c,a]

Attributes[g]=Orderless

g[b,c,a]

g[5,2,4]

ClearAttributes[g,Orderless]

Protected

Attributes[g]

g[x_]:=x^2

g[4]

g[x_]:=2+x

g[4]

Attributes[g]=Protected

g[x_]:=5x

?g

ClearAttributes[g,Protected]

g[x_]:=5x

g[4]

ReadProtected

Attributes[g]=Flat

?g

SetAttributes[g,ReadProtected]

?g

??g

ClearAttributes[g,ReadProtected]

SequenceHold

g[a,Sequence[b,c]]

Attributes[g]=SequenceHold

g[a,Sequence[b,c]]

ClearAttributes[g,SequenceHold]

Stub

Temporary

Module[{},Attributes[x]]

Module[{x},Attributes[x]]

Opis i komunikaty o bledach

polecenie::usage
polecenie::nazwa
Message[polecenie::nazwa]
On[polecenie::nazwa]
Off[polecenie::nazwa]

Remove[g]

?g

Remove[a]

?a

a

?a

g[x_]:=Sqrt[x]

?g

g::usage="Polecenie g[liczba] liczy pierwiastek drugiego stopnia z podanej liczby.";

?g

??g

g[-3]

g[x_]:=If[x<0,Message[g::neg],Sqrt[x]]

g[-3]

g::neg="Jako argument należy podać wartość nieujemną.";

g[-4]

Print["a"]

Sqrt[2,3,4,6]

Sqrt[2,3,4]

g[x_]:=If[x<0,Message[g::neg];Return[HoldForm[g[x]]],Sqrt[x]]

g[-1]

g[x_]:=If[x<0,Message[g::neg1,x];Return[HoldForm[g[x]]],Sqrt[x]]

g::neg1="Jako argument podałeś wartość `1`. Powinna to być wartość nieujemna.";

g[4]

g[-1]

g[-4]

Off[g::neg1]
g[-1]

On[g::neg1]
g[-1]

Różne błędy

Zmiana wartości parametrów wywołania

Remove[g]

g[x_]:=Module[{},x=x+2;x]

g[1]

g1[x_]:=Module[{y},y=x+2;y]

g1[1]

Brak informacji o poleceniu (definicja komunikatów w poleceniu)

Remove[g]

g[x_]:=Module[{},
g::usage="Polecenie g[liczba] liczy pierwiastek drugiego stopnia z podanej liczby.";
g::neg="Jako argument należy podać wartość nieujemną.";
If[x<0,Message[g::neg];Return[HoldForm[g[x]]],Sqrt[x]]]

?g

g[1]

?g

Brak wyniku

ostatnie polecenie zakończone średnikiem

Remove[g]

g[x_]:=Module[{},
If[x<0,Message[g::neg];Return[HoldForm[g[x]]],Sqrt[x]];]
g::usage="Polecenie g[liczba] liczy pierwiastek drugiego stopnia z podanej liczby.";
g::neg="Jako argument należy podać wartość nieujemną.";

g[1]

g[-1]

wynik generowany przez polecenie Print

g[x_]:=Module[{},
If[x<0,Message[g::neg];Return[HoldForm[g[x]]],Print[Sqrt[x]]]]
g::usage="Polecenie g[liczba] liczy pierwiastek drugiego stopnia z podanej liczby.";
g::neg="Jako argument należy podać wartość nieujemną.";

Clear[a]

a=g[1]

a

g[-1]

Dziwne wyniki (brak średnika między poleceniami)

Remove[g1]

g1[x_]:=Module[{a=x},
If[Not[VectorQ[x]],Message[g1::tab];Return[HoldForm[g1[x]]]];
Do[a[[i]]=Table[x[[i]],{Length[a]}],{i,Length[a]}]
a]
g1::usage="Polecenie g[liczba] liczy pierwiastek drugiego stopnia z podanej liczby.";
g1::tab="Jako parametr należy podać listę jednowymiarową.";

g1[1]

g1[{a1,a2}]

Przykład

Przykład 1

Napisać polecenie, które wyznaczy listę różnic kwadratów i sześcianów pierwszych x liczb.

lista[x_]:=Module[{},
If[Not[IntegerQ[x]&&x>0],Message[lista::blad];Return[HoldForm[lista[x]]]];
Map[#^2-#^3&,Range[x]]]
lista::blad="Jako parametr należy podać liczbę naturalną.";
lista::usage="Polecenie lista[liczba] wyznacza różnice między kwadratem i sześcianem kolejnych liczb.";

?lista

lista[4]

lista[3.4]

Map[Length[#]&,{{1},{2,2},{1,1,1}}]

Length[#]&;
%[{{1},{2,2},{1,1,1}}]

Map[a[#]&,{7,6,5,4,3,2,1}]

Przykład 2

Zamiana dwóch wierszy miejscami w macierzy. Opcja obroc określa, czy zamiana jest dokonywana na macierzy transponowanej.

Unprotect[zamien,obroc];
Options[zamien]={obroc->False};
zamien[a_,b_,c_,o___]:=Module[{m,opcje,tmp},
If[Not[MatrixQ[a]],Message[zamien::tab];Return[Return[HoldForm[zamien[a,b,c]]]]];
If[Not[IntegerQ[b]&&IntegerQ[c]],Message[zamien::par1];Return[HoldForm[zamien[a,b,c]]]];
opcje=obroc/.{o}/.Options[zamien];
If[opcje,m=Transpose[a],m=a];
If[Not[b>0&&b≤Length[m]&&c>0&&c≤Length[m]],Message[zamien::out,1,Length[m]];Return[Return[HoldForm[zamien[a,b,c]]]]];
tmp=m[[b]];
m[[b]]=m[[c]];
m[[c]]=tmp;
If[opcje,Transpose[m],m]]
zamien::usage="Polecenie zamien[macierz, nr1,nr2] zamienia w macierzy miejscami wiersze o podanych numerach. Użycie opcji obroc umożliwia transpozycję macierzy przez zamianą.";
zamien::tab="Pierwszy parametr powinein być macierzą.";
zamien::par1="Drugi i trzeci parametr powinny być liczbami całkowitymi.";
zamien::out="Drugi i trzeci parametr powinny być z zakresu (`1`,`2`).";
obroc::usage="Opcja obroc jest opcją polecenia zamien i umożliwia transpozycję macierzy. Domyślną wartością jest False";
Attributes[zamien]=ReadProtected;
Protect[zamien,obroc];

a=Table[RandomInteger[20],{5},{5}];TableForm[a]

x+4/.y->2

x

?obroc

?zamien

??zamien

q=zamien[a,2,4,obroc->False];TableForm[q]

q=zamien[a,2,4,obroc->True];TableForm[q]

Przykład 3

Dodawanie dwóch liczb i wyświetlanie wyniku w innym systemie liczenia. Opcja baza umożliwia określenie systemu pozycyjnego

Unprotect[dodaj,baza];
dodaj[a_,b_,o___]:=Module[{opt},
If [Not[IntegerQ[a]&&IntegerQ[b]],Message[dodaj::int];Return[HoldForm[dodaj[a,b,o]]]];
opt=baza/.{o}/.Options[dodaj];
BaseForm[a+b,opt]]
dodaj::usage="Polecenie dodaj[a,b] dodaje podane parametry i pokazuje wynik w dziesiętnym systemie. Opcja baza umożliwia zmianę systemu pozycyjnego.";
dodaj::int="Jako parametry należy podać liczby całkowite.";
baza::usage="baza jest opcją do polecenia dodaj, które określa w jakim systemie pozycyjnym bedzie podany wynik.";
Options[dodaj]={baza->10};
Attributes[dodaj]=ReadProtected;
Protect[dodaj,baza];

dodaj[3,5]

dodaj[3,5,baza->4]

dodaj[BaseForm[14,3],BaseForm[43,6]]

dodaj[2^^1001011,4^^103]

Przykład 4

Wykres funkcji kwadratowej. Opcja zakres umożliwia indywidualne określenie przedziału, na którym będzie rysowana funkcja

Unprotect[trojmian,zakres];
trojmian[a_,b_,c_,o___]:=Block[{x,p,d,t,opt,x1,x2},
If[
(*sprawdzenie, czy współczynniki trójmianu są wartościami liczbowymi*)
NumericQ[a]&&NumericQ[b]&&NumericQ[c],
opt=zakres/.{o}/.Options[trojmian];
(*analiza opcji zakres*)
(*czy jest listą dwuelementową liczb lub "Automatic"*)
If[(Length[opt]==2&&Not[NumericQ[opt[[1]]]&&NumericQ[opt[[2]]]])||(Length[opt]≠2&&opt=!=Automatic),
Message[trojmian::opt];Return[HoldForm[trojmian[a,b,c]]]];
(*czy lista nie zawiera takich samych wartości*)
If[opt=!=Automatic&&Length[Union[opt,{}]]!=2,Message[trojmian::opt];Return[HoldForm[trojmian[a,b,c]]]];
(*współrzędna p wierzchołka oraz delta*)
p=-b/(2a);d=b^2-4 a c;
(*jeżeli są miejsca zerowe; zmienna t jest odległością m.zerowego od wierzchołka*)
If[d>0,t=Abs[p-(-b-Sqrt[d])/(2a)],t=5];
If[Length[opt]==2,x1=opt[[1]];x2=opt[[2]],x1=p-1.1t;x2=p+1.1t];
Plot[a x^2+b x+c,{x,x1,x2},AxesOrigin->{0,0}],Message[trojmian::error];HoldForm[trojmian[a,b,c]]]]
trojmian::usage="Polecenie trojmian[a,b,c] rysuje wykres funkcji kwadratowej o podanych wspolczynnikach. Uzycie opcji zakres->{x1,x2} pozwala na zmiane domyslnego przedzialu rysowania. Domyslna wartoscia opcji zakres jest Automatic.";
zakres::usage=
trojmian::error="Jako parametry polecenia nalezy podac wartosci numeryczne";
trojmian::opt="Wartoscia opcji powinna byc lista dwuelementowa okreslajaca przedzial rysowania";
Options[trojmian]={zakres->Automatic};
Attributes[trojmian]=ReadProtected;
Protect[trojmian,zakres];

trojmian[1,0,1]

trojmian[3,6,8]

trojmian[1,0,-10]

trojmian[1,4,3]

trojmian[1,0,-10,zakres->{-4,4}]

trojmian[1,0,-10,zakres->{4,-2}]

trojmian[1,0,-10,zakres->{-4,0}]

z=Automatic
z===Automatic

z={2,6}
z===Automatic