dh-Materialien
Einführung in Maple    
Übersicht
 

Operatoren
(Auswahl)


Binäre Operatoren

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;

Beispiele für den Punktoperator

 

Unäre Operatoren

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

 +  Vorzeichen plus  +5;    5
 −  Vorzeichen minus   -a;   a
 !  "Fakultät"  4!;    24
 not  logisches nicht  not p;    not p  
 .  Dezimalpunkt  .36;    0.36



Funktionsoperatoren

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;  

Wenn der Ausdruck hinter dem Zuordnungsoperator ein algebraischer Ausdruck ist (das heißt ein Ausdruck, der nur mit Hilfe der arithmetischen Operatoren +, -, *, / und ^ gebildet wird), dann kann der Funktionsterm f(x) der durch eine solche Zuordnungsvorschrift definierten Funktion f auf einfache Art ausgewertet werden.

Beispiele:

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

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

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}


 Home   Back   Top