\mnb150<nb wrap="0" txtwidth="80" autowidth="0" pprint="1" typeset="1" xface="Times New Roman" xsize="280" xbold="0" xitalic="0" xcolor="#0000FF" slidents="1" sizemult="71" minsize="160" ifont="0 280 255 0 49 Courier New" ofont="0 280 16711680 0 49 Courier New" tfont="0 280 0 0 18 Times New Roman"></nb>ÿ{\rtf1\ansi\deff0\deftab720{\fonttbl{\f0\fswiss MS Sans Serif;}{\f1\froman\fcharset2 Symbol;}{\f2\fswiss\fprq2 System;}{\f3\fswiss\fprq2 Arial;}{\f4\fswiss\fprq2 Helvetica;}{\f5\fmodern\fprq1 Courier New;}}
{\colortbl\red0\green0\blue0;\red255\green0\blue0;\red0\green128\blue0;\red0\green0\blue255;\red128\green128\blue128;}
\deflang1031\pard\ri4\plain\f5\fs20\cf0\b ________________________________________________________________________________
\par 
\par \plain\f5\fs20\cf0 Inhalt....: Einfache Prozeduren mit Fehlerabfragen
\par Kategorie.: Handwerkskasten
\par Mathematik: Programmierung
\par MuPAD.....: 3.0.0
\par Datum.....: 2002-08-14
\par Autoren...: Kai Gehrs <acrowley@mupad.de>
\par Funktionen: if, then, proc, random, isprime, error
\par \plain\f5\fs20\cf0\b ________________________________________________________________________________
\par \plain\f3\fs36\cf0\b 
\par \plain\f3\fs40\cf0\b Elementare MuPAD-Funktionen: 
\par Einfache Prozeduren in MuPAD\plain\f3\fs24\cf2 
\par 
\par Dieses Notebook ist das zweite Notebook im Rahmen des Handwerkskastens zum Thema 
\par "Einfache eigene MuPAD Prozeduren definieren".   
\par \plain\f3\fs28\cf0 
\par \plain\f3\fs28 In den \plain\f3\fs28\cf4 Notebooks zur if-Anweisung und zu for-Schleifen im Handwerkskasten\plain\f3\fs28  
\par wie auch im Notebook \plain\f3\fs28\cf4 Einfache_Prozeduren_1 des Handwerkskastens\plain\f3\fs28  haben 
\par wir einfache Programmkonstrukte kennengelernt. Hier wollen wir eine Prozedur 
\par schreiben, die schon ein kleines bi\'dfchen umfangreicher ist als die Prozedur 
\par \plain\f3\fs28\cf1 Summen\plain\f3\fs28 , die in dem Notebook \plain\f3\fs28\cf4 Einfache_Prozeduren_1\plain\f3\fs28  kennengelernt. 
\par 
\par Als n\'e4chstes wollen wir eine weitere kleine Prozedur schreiben. Sie soll 
\par zwei Werte \plain\f3\fs28\cf2 u\plain\f3\fs28  und \plain\f3\fs28\cf2 o \plain\f3\fs28 als Argumente erhalten und zus\'e4tzlich ein drittes 
\par Argument \plain\f3\fs28\cf2 n\plain\f3\fs28 . Bei Eingabe von nat\'fcrlichen Zahlen \plain\f3\fs28\cf2 u < o\plain\f3\fs28  und \plain\f3\fs28\cf2 n\plain\f3\fs28  sollen \plain\f3\fs28\cf2 n\plain\f3\fs28  
\par Zufallszahlen aus dem Bereich von \plain\f3\fs28\cf2 u\plain\f3\fs28  bis \plain\f3\fs28\cf2 o\plain\f3\fs28  erzeugt werden. Dabei sollen 
\par doppelt vorkommende Zahlen nicht mehrfach gespeichert werden. 
\par Anschlie\'dfend soll unter den erzeugten Zufallszahlen die Anzahl der 
\par Primzahlen (d.h. derjenigen Zahlen, die nur durch 1 und sich selbst teilbar 
\par sind) bestimmt werden. 
\par 
\par Wir beginnen wieder mit dem \'fcblichen "Ger\'fcst" f\'fcr unsere Prozedur, 
\par die wir schlicht \plain\f3\fs28\cf1 Primzahlen\plain\f3\fs28  nennen wollen: 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   begin 
\par     return();
\par   end_proc:
\par \pard\ri4\plain\f3\fs28  
\par 
\par Innerhalb der Prozedur m\'fcssen jetzt zuerst \plain\f3\fs28\cf2 n\plain\f3\fs28  Zufallszahlen aus dem 
\par Bereich von \plain\f3\fs28\cf2 u\plain\f3\fs28  bis \plain\f3\fs28\cf2 o\plain\f3\fs28  erzeugt und gespeichert werden. Da doppelte 
\par Vorkommen unber\'fccksichtigt bleiben sollen, entscheiden wir uns, 
\par die Zahlen in einer Menge zu speichern. Wir nennen diese Menge 
\par \plain\f3\fs28\cf1 Zufallszahlen\plain\f3\fs28  und deklarieren sie, wie \'fcblich, als lokale Variable der 
\par Prozedur:
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   local Zufallszahlen;
\par   begin 
\par     return();
\par   end_proc:
\par \pard\ri4\plain\f3\fs28 
\par Zum erzeugen der Zufallszahlen im Bereich von \plain\f3\fs28\cf2 u\plain\f3\fs28  bis \plain\f3\fs28\cf2 o\plain\f3\fs28  verwenden wir wie
\par schon in dem \plain\f3\fs28\cf4 Notebook zu for-Schleifen\plain\f3\fs28  den MuPAD Befehl \plain\f3\fs28\cf1 random(u..o)\plain\f3\fs28 . 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   local Zufallszahlen, Zufall;
\par   begin 
\par     Zufall:= random(u..o);
\par     return();
\par   end_proc:
\par \pard\ri4\plain\f3\fs28 
\par Wir ben\'f6tigen \plain\f3\fs28\cf2 n\plain\f3\fs28  Zufallszahlen und speichern diese in einer Menge, die 
\par wir der Variablen \plain\f3\fs28\cf1 Zufallszahlen\plain\f3\fs28  zuweisen: 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   local Zufallszahlen, Zufall;
\par   begin 
\par     Zufall:= random(u..o);
\par     Zufallszahlen:= \{Zufall() $ i = 1..n\};
\par     return();
\par   end_proc:
\par \pard\ri4\plain\f3\fs28 
\par Wir haben die Variable\plain\f3\fs28\cf1  i \plain\f3\fs28 als Laufvariable f\'fcr den Sequenzoperator \plain\f3\fs28\cf1 $\plain\f3\fs28  
\par verwendet. Sicherheitshalber kennzeichnen wir\plain\f3\fs28\cf1  i \plain\f3\fs28 ebenfalls als lokale 
\par Variable - zudem ben\'f6tigen wir sowieso f\'fcr eine for-Schleife noch 
\par eine Laufvariable. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   local Zufallszahlen, Zufall, i;
\par   begin 
\par     Zufall:= random(u..o);
\par     Zufallszahlen:= \{Zufall() $ i = 1..n\};
\par     return();
\par   end_proc:
\par \pard\ri4\plain\f3\fs28 
\par Nun zum mathematischen Teil unserer Prozedur: Wir wollen wissen, 
\par wie viele Primzahlen sich in der Menge \plain\f3\fs28\cf1 Zufallszahlen\plain\f3\fs28  befinden. Der erste 
\par Schritt ist also, eine for-Schleife zu schreiben, die nacheinander 
\par alle Elemente der Menge durchl\'e4uft. Innerhalb der for-Schleife 
\par k\'f6nnen wir dann testen, ob die gerade betrachtete Zahl\plain\f3\fs28\cf1  i \plain\f3\fs28 eine 
\par Primzahl ist. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   local Zufallszahlen, Zufall, i;
\par   begin 
\par     Zufall:= random(u..o);
\par     Zufallszahlen:= \{Zufall() $ i = 1..n\};
\par     for i in Zufallszahlen do 
\par               
\par     end_for;
\par     return();
\par   end_proc:
\par \pard\ri4\plain\f3\fs28 
\par Als n\'e4chstes ben\'f6tigen wir eine Z\'e4hlvariable \plain\f3\fs28\cf1 Zaehler\plain\f3\fs28 , in der wir 
\par die Anzahl aller Primzahlen in der Menge \plain\f3\fs28\cf1 Zufallszahlen\plain\f3\fs28  speichern. 
\par Zu Beginn, d.h. noch vor der for-Schleife, sollte diese Variable 
\par auf den Wert 0 gesetzt werden. Auch sollten wir daran denken, 
\par die Variable \plain\f3\fs28\cf1 Zaehler\plain\f3\fs28  als lokale Variable zu deklarieren. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   local Zufallszahlen, Zufall, i, Zaehler;
\par   begin 
\par     Zufall:= random(u..o);
\par     Zufallszahlen:= \{Zufall() $ i = 1..n\};
\par     Zaehler:= 0;
\par     for i in Zufallszahlen do 
\par            
\par     end_for;
\par     return();
\par   end_proc:
\par \pard\ri4\plain\f3\fs28 
\par Jetzt m\'fcssen wir innerhalb der for-Schleife nur noch mit Hilfe einer 
\par if-Anweisung und des Befehls \plain\f3\fs28\cf1 isprime( i )\plain\f3\fs28  testen, ob der aktuelle 
\par Wert von\plain\f3\fs28\cf1  i \plain\f3\fs28 eine Primzahl ist, oder nicht. Falls\plain\f3\fs28\cf1  i \plain\f3\fs28 eine Primzahl ist, 
\par erh\'f6hen wir den Wert der Variablen \plain\f3\fs28\cf1 Zaehler\plain\f3\fs28  um 1. Falls\plain\f3\fs28\cf1  i \plain\f3\fs28 keine 
\par Primzahl ist, so m\'fcssen wir gar nichts tun. Daher k\'f6nnen wir uns 
\par den \plain\f3\fs28\cf1 else \plain\f3\fs28 Teil der if-Anweisung sparen. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   local Zufallszahlen, Zufall, i, Zaehler;
\par   begin 
\par     Zufall:= random(u..o);
\par     Zufallszahlen:= \{Zufall() $ i = 1..n\};
\par     Zaehler:= 0;
\par     for i in Zufallszahlen do 
\par       if isprime(i) = TRUE then 
\par         Zaehler:= Zaehler + 1;
\par       end_if;
\par     end_for;
\par     return();
\par   end_proc:
\par \pard\ri4\plain\f3\fs28 
\par Abschlie\'dfend brauchen wir nur noch das Ergebnis, also den Wert 
\par der Variablen \plain\f3\fs28\cf1 Zaehler\plain\f3\fs28  zur\'fcckgeben. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   local Zufallszahlen, Zufall, i, Zaehler;
\par   begin 
\par     Zufall:= random(u..o);
\par     Zufallszahlen:= \{Zufall() $ i = 1..n\};
\par     Zaehler:= 0;
\par     for i in Zufallszahlen do 
\par       if isprime(i) = TRUE then 
\par         Zaehler:= Zaehler + 1;
\par       end_if;
\par     end_for;
\par     return(Zaehler);
\par   end_proc:
\par \pard\ri4\plain\f3\fs28 
\par Wir erproben unsere Prozedur an zwei Beispielen: 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen(23, 45, 6)
\par \pard\ri4\plain\f3\fs28 
\par Da wir Zufallszahlen betrachten, ist es klar, dass die obige Eingabezeile 
\par bei mehrfacher Auswertung mit gleichen Argumenten durchaus verschiedene 
\par Ergebnisse zur\'fcckliefern kann. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen(23, 45, 6)
\par \pard\ri4\plain\f3\fs28 
\par Auch f\'fcr gr\'f6\'dfere Werte von \plain\f3\fs28\cf2 u\plain\f3\fs28 , \plain\f3\fs28\cf2 o\plain\f3\fs28  und \plain\f3\fs28\cf2 n \plain\f3\fs28 ist unsere Prozedur durchaus 
\par schnell mit ihrer Berechnung fertig. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen(472, 67482776, 10000)
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen(472, 67482776, 10000)
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen(472, 67482776, 10000)
\par \pard\ri4\plain\f3\fs28 
\par Streng genommen ist unsere Prozedur jedoch noch nicht vollst\'e4ndig. 
\par Jemand k\'f6nnte z.B. auf die Idee kommen, f\'fcr \plain\f3\fs28\cf2 u \plain\f3\fs28 einen gr\'f6\'dferen 
\par Wert als f\'fcr \plain\f3\fs28\cf2 o\plain\f3\fs28  zu w\'e4hlen: 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen(7, 4, 3)
\par \pard\ri4\plain\f3\fs28 
\par Dann liefert MuPAD zwar von sich aus eine Fehlermeldung, aber diese ist 
\par f\'fcr einen Benutzer, der nicht wei\'df, wie unsere Prozedur funktioniert, 
\par unter Umst\'e4nden schwierig zu verstehen. Wir k\'f6nnen diese unzul\'e4ssige 
\par Eingabe z.B. durch eine if-Anweisung zuvor abfangen. Wir pr\'fcfen einfach, 
\par ob die Zahl \plain\f3\fs28\cf2 u\plain\f3\fs28  kleiner ist, als die Zahl \plain\f3\fs28\cf2 o\plain\f3\fs28 . Ist dieses der Fall, so darf unsere 
\par Prozedur einfach weiterrechnen. Andernfalls, also wenn \plain\f3\fs28\cf2 u\plain\f3\fs28  gr\'f6\'dfer oder 
\par gleich \plain\f3\fs28\cf2 o\plain\f3\fs28  ist, so geben wir die Fehlermeldung aus: 
\par 
\par \plain\f3\fs28\cf3 \tab Error: das erste Argument muss kleiner als das zweite sein
\par \plain\f3\fs28 
\par Wie wir das in unserer Prozedur realisieren k\'f6nnen, sehen wir jetzt: 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   local Zufallszahlen, Zufall, i, Zaehler;
\par   begin 
\par     if u >= o then 
\par       error("das erste Argument muss kleiner als das zweite sein");
\par     end_if;
\par     Zufall:= random(u..o);
\par     Zufallszahlen:= \{Zufall() $ i = 1..n\};
\par     Zaehler:= 0;
\par     for i in Zufallszahlen do 
\par       if isprime(i) = TRUE then 
\par         Zaehler:= Zaehler + 1;
\par       end_if;
\par     end_for;
\par     return(Zaehler);
\par   end_proc:
\par \pard\ri4\plain\f3\fs28 
\par  
\par Schauen wir uns an, was nun bei der unzul\'e4ssigen Eingabezeile von oben 
\par geschieht: 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen(7, 4, 3)
\par \pard\ri4\plain\f3\fs28 
\par Funktioniert unsere Prozedur denn auch noch, wenn wir korrekte 
\par Eingabeparameter w\'e4hlen? 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen(3, 135, 10)
\par \pard\ri4\plain\f3\fs28 
\par Wie wir sehen, ist dies der Fall. Das liegt daran, dass wir bei der 
\par neu eingef\'fcgten if-Anweisung wieder auf den \plain\f3\fs28\cf1 else\plain\f3\fs28  Teil verzichtet haben. 
\par In dem Fall, dass \plain\f3\fs28\cf2 u\plain\f3\fs28  echt kleiner als \plain\f3\fs28\cf2 o\plain\f3\fs28  ist, ist die Bedingung der 
\par if-Anweisung nicht erf\'fcllt, d.h. sie wird von MuPAD einfach ignoriert 
\par und die folgenden Programmzeilen wie gew\'fcnscht ausgef\'fchrt. 
\par 
\par Auf \'e4hnliche Weise kann man auch pr\'fcfen, ob f\'fcr \plain\f3\fs28\cf2 n\plain\f3\fs28  ein sinnvoller 
\par Wert gew\'e4hlt wurde. Es sollte \plain\f3\fs28\cf2 n\plain\f3\fs28  z.B. einen Wert haben, der 
\par gr\'f6\'dfer als Null ist. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen(3, 135, -4)
\par \pard\ri4\plain\f3\fs28 
\par Momentan gibt es bei Wahl eines unsinnigen Wertes f\'fcr \plain\f3\fs28\cf2 n\plain\f3\fs28  zwar 
\par u.U. keine Fehlermeldung (wie wir sehen), aber dennoch k\'f6nnen wir 
\par dem Benutzer der Prozedur \plain\f3\fs28\cf1 Primzahlen \plain\f3\fs28 mit Hilfe einer Fehlermeldung 
\par explizit mitteilen, dass der gew\'e4hlt Wert f\'fcr \plain\f3\fs28\cf2 n \plain\f3\fs28 nicht sinnvoll ist. 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen:= proc(u, o, n)
\par \pard\li600\ri1\fi-300\plain\f5\fs28\cf1   local Zufallszahlen, Zufall, i, Zaehler;
\par   begin 
\par     if u >= o then 
\par       error("das erste Argument muss kleiner als das zweite sein");
\par     end_if;
\par     if n <= 0 then 
\par       error("das dritte Argument muss eine nat\'fcrliche Zahl sein");
\par     end_if;
\par     Zufall:= random(u..o);
\par     Zufallszahlen:= \{Zufall() $ i = 1..n\};
\par     Zaehler:= 0;
\par     for i in Zufallszahlen do 
\par       if isprime(i) = TRUE then 
\par         Zaehler:= Zaehler + 1;
\par       end_if;
\par     end_for;
\par     return(Zaehler);
\par   end_proc:
\par \pard\ri4\plain\f3\fs28 
\par Damit ist obige Eingabezeile nicht mehr ohne Fehlermeldung durchf\'fchrbar: 
\par 
\par \pard\li300\ri5\fi-300{\*\pn\pnlvlblt\pnf1\pnindent300{\pntxtb\'b7}}\plain\f5\fs28\cf1 {\pntext\f1\'b7\tab}Primzahlen(3, 135, -4)
\par \pard\ri4\plain\f3\fs28 
\par Zur \'dcbung k\'f6nnte man nun auch die erste Prozedur \plain\f3\fs28\cf1 Summen\plain\f3\fs28  mit den 
\par entsprechenden, sinnvollen Fehlerabfragen versehen (siehe dazu das 
\par Notebook \plain\f3\fs28\cf4 Einfache_Prozeduren_1 \plain\f3\fs28\cf0 des\plain\f3\fs28\cf4  Handwerkskastens\plain\f3\fs28 ). 
\par 
\par Generell gibt es in MuPAD noch viel mehr M\'f6glichkeiten, bestimmte 
\par Werte zu testen. So haben wir in der Prozedur \plain\f3\fs28\cf1 Primzahlen \plain\f3\fs28 nirgendwo 
\par getestet, ob die eingegebenen Werte f\'fcr \plain\f3\fs28\cf2 u\plain\f3\fs28\cf0 ,\plain\f3\fs28\cf2  o\plain\f3\fs28  und \plain\f3\fs28\cf2 n\plain\f3\fs28  tats\'e4chlich 
\par ganzzahlig sind. F\'e4lle, in denen der Benutzer u = 1/3 w\'e4hlt, sind damit 
\par nicht ausreichend abgefangen. 
\par 
\par Eine vollkommen exakte Fehlerbehandlung wollen wir hier aber nicht 
\par durchf\'fchren, denn eine solche ist auch von Prozedur zu Prozedur 
\par verschieden, d.h. wir k\'f6nnen kein allgemein g\'fcltiges Rezept angeben. 
\par Da eine solche auch recht technisch werden kann, verzichten wir hier 
\par darauf und verweisen auf das \plain\f3\fs28\cf4 MuPAD Tutorium\plain\f3\fs28 , in dem eine Vielzahl 
\par von Beispielen angegeben ist. 
\par 
\par Viele Beispiele zu weiteren Prozeduren finden sich auch in der 
\par Materialsammlung unter 
\par 
\par    \tab \tab \plain\f3\fs28\cf3\ul www.schule.mupad.de/material
\par \plain\f3\fs28 
\par Dort bietet sich die M\'f6glichkeit einer Volltextsuche innerhalb aller 
\par zum Download bereitstehenden MuPAD Notebooks. Sucht man an 
\par dieser Stelle nach dem Begriff \plain\f3\fs28\cf1 proc\plain\f3\fs28 , so taucht eine Vielzahl von 
\par Notebooks auf, in denen eigene Prozeduren vorgestellt und/oder 
\par benutzt werden. Beachten Sie bitte auch das Notebook 
\par 
\par                                   \plain\f3\fs28\cf4 Einfache Prozeduren\plain\f3\fs28 
\par 
\par im Handwerkskasten.
\par \plain\f5\fs28\cf1 
\par \plain\f5\fs20\cf0\b _______________________________________________________________________________
\par \plain\f3\fs22\cf0 
\par \plain\f3\fs22\cf2\b Anmerkungen:\plain\f3\fs22\cf2 
\par \plain\f3\fs20\cf2\b 1\plain\f3\fs20\cf2 .  Weitere Anregungen finden Sie in der Buchreihe \plain\f3\fs20\cf1 Mathematik 1 x anders\plain\f3\fs20\cf2 . In dieser Reihe 
\par      wird eine Vielzahl unterschiedlichster mathematischer Probleme mit MuPAD gel\'f6st. Die 
\par      B\'fccher k\'f6nnen unter \plain\f4\fs20\cf3 www.schule.mupad.de/literatur\plain\f3\fs20\cf2  kostenfrei kopiert werden.  
\par \plain\f3\fs20\cf3 
\par \plain\f5\fs20\cf0\b _______________________________________________________________________________
\par 
\par \plain\f5\fs28\cf1 
\par }