Operatoren
(Auswahl)

Binäre Operatoren | Back |

Binäre Operatoren (binary operators) verknüpfen zwei Operanden miteinander.

+	Rechenzeichen plus	b + b;	2 b
−	Rechenzeichen minus	5 - 6;	−1
*	"mal"	a*a;	a2
/	"geteilt durch"	3./4;	0.75000
^	"potenziert mit"	2^10;	1024
mod	"modulo"	8 mod 3;	2
<	"kleiner als"	x < y;	x < y
<=	"kleiner als oder  gleich"	x <= y;	x ≤  y
>	"größer als"	x > y;	x > y
>=	"größer als oder gleich"	x >= y;	x ≥  y
=	"gleich"	a = b;	a = b
<>	"ungleich"	3 <> 5;	3 ≠ 5
:=	Zuweisungsoperator	v:= lambda*f;
$	Folgenoperator	x$3;	x, x, x
@	Verkettungsoperator	f@g;	f@g
||	Verbindungsoperator	i:= 8: f||i;	f8
,	Trennungsoperator	m, n;	m, n
union	Vereinigung von Mengen	{r,s,t} union {s,t,u};	{r, s, t, u}
intersect	Schnitt von Mengen	{a,b} intersect {b,c};	{b}
minus	Differenz von Mengen	{a,b} minus {b,c};	{a}
subset	"Teilmenge von?"	{a,b} subset {a,b,c};	true
and	logisches und	3>0 and 3<0;	false
or	logisches oder	3>0 or 3<0;	true
xor	logisches exklusiv-oder	3>0 xor 3>0	false
implies	"impliziert"	false implies true;	true
::	Typoperator	k::even;	k::even
assuming	"angenommen, dass"	y:= sin(k*Pi/2):  y assuming k::even;	0

Differenzieren von Funktionen und Funktionstermen

Der links-assoziative Punktoperator (dot operator) hat - je nach Kontext - unterschiedliche Bedeutungen.
Es folgen ein paar Beispiele:

> v:= Vector ([a[1], a[2]]);
  w:= Vector ([b[1], b[2]]):
  A:= Matrix ([[a[11], a[12]], [a[21], a[22]]]);
  B:= Matrix ([[b[11], b[12]], [b[21], b[22]]]): ;
 
  '6 . 7' = 6 . 7;
  'v . w' = v . w;
  '7 . A' = 7 . A;
  'A . B' = A . B;

Unäre Operatoren | Back |

Unäre Operatoren (unary operators) haben nur einen Operanden.

Funktionsoperatoren | Back |

Mit Funktionsoperatoren (functional operators) werden in Maple Funktionen dargestellt.

Ein Funktionsoperator Variable(n) -> Ergebnis  beschreibt eine Prozedur, die auf eine Folge von Werten (bzw. auf einen Wert) angewandt wird. Das Rechenergebnis dieser Prozedur wird durch den Ausdruck hinter dem Zuordnungsoperator festgelegt.

Beispiele:
> (x -> x^2)(3);
      9
> ((x, y) -> x + y)(2, 5);
      7

Alternativ zum Zuordnungsoperator kann auch die Funktion unapply verwendet werden. Die folgenden zwei Eingaben liefern dasselbe Resultat:
> f:= x -> x^2;
  
> f:= unapply (x^2, x);
    

->	Zuordnungsoperator	x -> f(x);	f
		x -> 3*x;

> f:= x -> x^2;
  f(4);
   

> f:= x -> (3*x - x^2)/(1 - x);
  f(12);
 

> f:= x -> sum (i^2, i = 1..x);
  f(10);
  

Wenn der Ausdruck hinter dem Zuordnungsoperator kein algebraischer Ausdruck ist, dann gelingt die Auswertung von Funktionstermen auf folgende Art.

Beispiele:

> f:= x -> sqrt(x);
  f(5);
  evalf (f(5));
 

> f:= x -> sin(x)^2*cos(x);
  f(Pi/4);
  evalf (f(Pi/4));
 

Bei miteinander verketteten Funktionen sieht das Ganze wie folgt aus:

> f:= x -> x^2;
  g:= x -> sin(x);
  h:= f@g;
  h(5);
  evalf (h(5));
 

Weitere Beispiele von Funktionsoperatoren:

> f:= x -> sin(x):
  f(Pi/4);
  

> (f1 + f2)(x);
      f1(x) + f2(x)

> ((x -> sqrt(x+1))@@2)(x);
  

Differentialoperator  | Back |

Der Differentialoperator D(differential operator) wird angewandt auf Funktionen.
D(f) ist die Ableitungsfunktion von f.

D	Differentialoperator	D(sin);	cos
		D(ln);
		D(x -> x^2);

Differenzieren von Funktionen und Funktionstermen

Elementweise Operatoren  | Back |

Ab Maple 13 besteht die Möglichkeit, Operatoren auf die Elemente von Listen, Mengen, Arrays, Matrizen oder Vektoren wirken zu lassen (element-wise operations). Man schreibt hierfür eine Tilde direkt nach dem jeweiligen Operatorzeichen bzw. nach dem Funktionsnamen.
Beispiele:

> [2, 4, 3] *~ [3, 2, 5];
  [false, true, false] implies~ [true, false, false];
  {3, 4, 5} +~ 1;

[6, 8, 15]
[true, false, true]
{4, 5, 6}