| blob | c91d8913c3032981fba8b61f79476cbf3c362af1 |
1 @c -----------------------------------------------------------------------------
2 @c File : Nset.de.texi
3 @c License : GNU General Public License (GPL)
4 @c Language : German
5 @c Original : Nset.texi revision 08.07.2011
6 @c Translation : Dr. Dieter Kaiser
7 @c Date : 14.11.2010
8 @c Revision : 09.07.2011
9 @c
10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
11 @c -----------------------------------------------------------------------------
13 @menu
14 * Einf@"uhrung in Mengen::
15 * Funktionen und Variablen f@"ur Mengen::
16 @end menu
18 @c -----------------------------------------------------------------------------
19 @node Einf@"uhrung in Mengen, Funktionen und Variablen f@"ur Mengen, Mengen, Mengen
20 @section Einf@"uhrung in Mengen
21 @c -----------------------------------------------------------------------------
23 Maxima hat Funktionen wie den Schnitt und die Vereinigung von endlichen Mengen,
24 die durch eine explizite Aufz@"ahlung definiert werden k@"onnen. Listen und
25 Mengen sind in Maxima unterschiedliche Objekte und k@"onnen selbst Elemente von
26 Mengen sein. Siehe auch @ref{Listen}.
28 Neben den Funktionen f@"ur Mengen, enth@"alt dieses Kapitel weitere Funktionen
29 der Kombinatorik. Darunter die Stirling-Zahlen der ersten und zweiten Art, die
30 Bellschen Zahlen, Multinomialverteilungen, Partitionsfunktionen oder die
31 Kronecker-Delta-Funktion.
33 @c -----------------------------------------------------------------------------
34 @subsection Anwendung
36 Mit @code{set(a_1, ..., a_n)} oder @code{@{a_1, ..., a_n@}} wird eine Menge
37 mit den Elementen @code{a_1, ..., a_n} konstruiert. Die leere Menge
38 wird mit @code{set()} oder @code{@{@}} angegeben. Mengen werden immer mit
39 geschweiften Klammern angezeigt. Werden Elemente mehrmals angegeben, werden
40 die doppelten Elemente aus der Menge entfernt.
42 Beispiele:
44 @example
45 (%i1) set();
46 (%o1) @{@}
47 (%i2) set(a, b, a);
48 (%o2) @{a, b@}
49 (%i3) set(a, set(b));
50 (%o3) @{a, @{b@}@}
51 (%i4) set(a, [b]);
52 (%o4) @{a, [b]@}
53 (%i5) @{@};
54 (%o5) @{@}
55 (%i6) @{a, b, a@};
56 (%o6) @{a, b@}
57 (%i7) @{a, @{b@}@};
58 (%o7) @{a, @{b@}@}
59 (%i8) @{a, [b]@};
60 (%o8) @{a, [b]@}
61 @end example
63 Zwei Elemente @var{x} und @var{y} werden als gleich angesehen, wenn
64 @code{is(@var{x} = @var{y})} das Ergebnis @code{true} hat. Die Elemente sind
65 dann syntaktisch gleich. Es ist zu beachten, dass @code{is(equal(@var{x},
66 @var{y}))} das Ergebnis @code{true} haben kann, jedoch der Ausdruck
67 @code{is(@var{x} = @var{y})} das Ergebnis @code{false} liefert.
69 @example
70 (%i1) x: a/c + b/c;
71 b a
72 (%o1) - + -
73 c c
74 (%i2) y: a/c + b/c;
75 @group
76 b a
77 (%o2) - + -
78 c c
79 @end group
80 (%i3) z: (a + b)/c;
81 b + a
82 (%o3) -----
83 c
84 (%i4) is (x = y);
85 (%o4) true
86 (%i5) is (y = z);
87 (%o5) false
88 (%i6) is (equal (y, z));
89 (%o6) true
90 (%i7) y - z;
91 b + a b a
92 (%o7) - ----- + - + -
93 c c c
94 (%i8) ratsimp (%);
95 (%o8) 0
96 (%i9) @{x, y, z@};
97 b + a b a
98 (%o9) @{-----, - + -@}
99 c c c
100 @end example
102 Mit der Funktion @mref{setify} kann eine Menge aus einer Liste konstruiert
103 werden.
105 @example
106 (%i1) setify ([b, a]);
107 (%o1) @{a, b@}
108 @end example
110 Die Elemente @code{x} und @code{y} einer Menge sind gleich, wenn der Ausdruck
111 @code{is(x = y)} das Ergebnis @code{true} hat. Daher werden zum Beispiel
112 @code{rat(x)} und @code{x} als gleich betrachtet.
114 @example
115 (%i1) @{x, rat(x)@};
116 (%o1) @{x@}
117 @end example
119 Da der Ausdruck @code{is((x - 1)*(x + 1) = x^2 - 1)} das Ergebnis @code{false}
120 hat, werden @code{(x - 1)*(x + 1)} und @code{x^2 - 1} als verschiedene Elemente
121 angenommen.
123 @example
124 (%i1) @{(x - 1)*(x + 1), x^2 - 1@};
125 2
126 (%o1) @{(x - 1) (x + 1), x - 1@}
127 @end example
129 Um die Menge des letzten Beispiels auf ein Element zu reduzieren, kann die
130 Funktion @mref{rat} auf die Elemente der Menge angewendet werden.
132 @example
133 (%i1) @{(x - 1)*(x + 1), x^2 - 1@};
134 2
135 (%o1) @{(x - 1) (x + 1), x - 1@}
136 (%i2) map (rat, %);
137 2
138 (%o2)/R/ @{x - 1@}
139 @end example
141 Um redundante Elemente von Mengen zu entfernen, k@"onnen Funktionen f@"ur die
142 Vereinfachung von Ausdr@"ucken angewendet werden. In diesem Beispiel wird
143 die Funktion @mref{trigsimp} auf die Elemente der Menge angewendet.
145 @example
146 (%i1) @{1, cos(x)^2 + sin(x)^2@};
147 @group
148 2 2
149 (%o1) @{1, sin (x) + cos (x)@}
150 @end group
151 (%i2) map (trigsimp, %);
152 (%o2) @{1@}
153 @end example
155 Hat eine Menge redundante Elemente, wird sie vereinfacht und sortiert. Die
156 Ordnung der Elemente wird von der Funktion @mref{orderlessp} bestimmt. Einige
157 Operationen auf Mengen, wie zum Beispiel Substitutionen erzwingen die
158 Vereinfachung von Mengen.
160 @example
161 (%i1) s: @{a, b, c@}$
162 (%i2) subst (c=a, s);
163 (%o2) @{a, b@}
164 (%i3) subst ([a=x, b=x, c=x], s);
165 (%o3) @{x@}
166 (%i4) map (lambda ([x], x^2), set (-1, 0, 1));
167 (%o4) @{0, 1@}
168 @end example
170 Maxima behandelt Listen und Mengen als verschiedene Objekte. Funktionen wie
171 @mref{union} oder @mref{intersection} geben eine Fehlermeldung, wenn die
172 Argumente keine Mengen sind. Um eine Funktion f@"ur Mengen auf eine Liste
173 anzuwenden, kann diese mit der Funktion @mref{setify} in eine Menge
174 umgewandelt werden.
176 @example
177 (%i1) union ([1, 2], @{a, b@});
178 Function union expects a set, instead found [1,2]
179 -- an error. Quitting. To debug this try debugmode(true);
180 (%i2) union (setify ([1, 2]), @{a, b@});
181 (%o2) @{1, 2, a, b@}
182 @end example
184 Mit der Funktion @mref{subset} kann eine Teilmenge ermittelt werden, deren
185 Elemente f@"ur eine Aussagefunktion das Ergebnis @code{true} haben. Um die
186 Gleichungen einer Menge zu finden, die nicht von der Variablen @code{z}
187 abh@"angen, wird im Folgenden die Aussagefunktion @mref{freeof} verwendet.
189 @example
190 (%i1) subset (@{x + y + z, x - y + 4, x + y - 5@},
191 lambda ([e], freeof (z, e)));
192 (%o1) @{- y + x + 4, y + x - 5@}
193 @end example
195 In @ref{Funktionen und Variablen f@"ur Mengen} sind die Funktionen dokumentiert,
196 die Maxima f@"ur Mengen kennt.
198 @c -----------------------------------------------------------------------------
199 @subsection Iteration @"uber Mengen
201 Es gibt zwei M@"oglichkeiten, @"uber die Elemente einer Menge zu iterieren.
202 Im ersten Fall wird die Funktion @mref{map} genutzt.
204 @example
205 (%i1) map (f, @{a, b, c@});
206 (%o1) @{f(a), f(b), f(c)@}
207 @end example
209 Eine weitere M@"oglichkeit ist, eine @mref{for}-Schleife einzusetzen.
211 @example
212 (%i1) s: @{a, b, c@};
213 (%o1) @{a, b, c@}
214 (%i2) for si in s do print (concat (si, 1));
215 a1
216 b1
217 c1
218 (%o2) done
219 @end example
221 Die Funktionen @mref{first} und @mref{rest} funktionieren auch f@"ur Mengen.
222 Wird die Funktion @code{first} auf eine Menge angewendet, ist das Ergebnis
223 das erste Element, wie es in der Anzeige erscheint. Ist @code{s} eine Menge,
224 dann ist der Ausdruck @code{rest(s)} @"aquivalent zu
225 @code{disjoin(first(s), s)}. Siehe die Funktion @mrefdot{disjoin}
227 @c -----------------------------------------------------------------------------
228 @subsection Programmfehler
230 Die M@"oglichkeit mit den Funktionen @mref{orderless} und @mref{ordergreat}@w{}
231 eine neue Ordnung f@"ur Variablen zu definieren, ist nicht kompatibel mit den
232 Funktionen f@"ur Mengen. Wird eine der Funktionen @code{orderless} oder
233 @code{ordergreat} ben@"otigt, sollten diese vor der Konstruktion der ersten
234 Menge ausgef@"uhrt werden. Die Funktion @mref{unorder} sollte nicht
235 ausgef@"uhrt werden.
237 @c -----------------------------------------------------------------------------
238 @subsection Autoren
240 Stavros Macrakis aus Cambridge, Massachusetts und Barton Willis von der
241 Universit@"at Nebraska in Kearney (UNK) haben die Funktionen und die
242 Dokumentation f@"ur Mengen geschrieben.
244 @c -----------------------------------------------------------------------------
245 @node Funktionen und Variablen f@"ur Mengen, , Einf@"uhrung in Mengen, Mengen
246 @section Funktionen und Variablen f@"ur Mengen
247 @c -----------------------------------------------------------------------------
249 @c --- 24.04.2011 DK -----------------------------------------------------------
250 @anchor{adjoin}
251 @deffn {Funktion} adjoin (@var{x}, @var{a})
253 Vereinigt die Menge @var{a} mit @code{@{@var{x}@}} und gibt die vereinigte
254 Menge als Ergebnis zur@"uck.
256 @code{adjoin} gibt eine Fehlermeldung, wenn das Argument @var{a} keine Menge
257 ist.
259 @code{adjoin(@var{x}, @var{a})} und @code{union(set(@var{x}), @var{a})} sind
260 @"aquivalent. Die Funktion @code{adjoin} kann etwas schneller als die Funktion
261 @mref{union} sein.
263 Siehe auch die Funktion @mrefdot{disjoin}
265 Beispiele:
267 @example
268 (%i1) adjoin (c, @{a, b@});
269 (%o1) @{a, b, c@}
270 (%i2) adjoin (a, @{a, b@});
271 (%o2) @{a, b@}
272 @end example
273 @end deffn
275 @c --- 24.04.2011 DK -----------------------------------------------------------
276 @anchor{belln}
277 @deffn {Funktion} belln (@var{n})
279 Repr@"asentiert die @math{n}-te Bellsche Zahl.
281 Ist das Argument @var{n} eine nicht-negative ganze Zahl, vereinfacht
282 @code{belln(@var{n})} zu der @math{n}-ten Bellschen Zahl. F@"ur andere
283 Argumente vereinfacht die Funktion @code{belln} nicht.
285 Ist das Argument der Funktion @code{belln} eine Liste, Menge, Matrix oder
286 eine Gleichung, wird die Funktion auf die Elemente oder beide Seiten der
287 Gleichung angewendet.
289 @need 600
290 Beispiele:
292 Anwendung der Funktion @code{belln} auf nicht-negative ganze Zahlen.
294 @example
295 (%i1) makelist (belln (i), i, 0, 6);
296 (%o1) [1, 1, 2, 5, 15, 52, 203]
297 (%i2) is (cardinality (set_partitions (@{@})) = belln (0));
298 (%o2) true
299 (%i3) is (cardinality (set_partitions (@{1, 2, 3, 4, 5, 6@})) =
300 belln (6));
301 (%o3) true
302 @end example
304 Anwendung der Funktion @code{belln} auf andere Argumente als nicht-negative
305 ganze Zahlen.
307 @example
308 (%i1) [belln (x), belln (sqrt(3)), belln (-9)];
309 (%o1) [belln(x), belln(sqrt(3)), belln(- 9)]
310 @end example
311 @end deffn
313 @c --- 24.04.2011 DK -----------------------------------------------------------
314 @anchor{cardinality}
315 @deffn {Funktion} cardinality (@var{a})
317 Gibt die M@"achtigkeit (Kardinalit@"at) einer Menge zur@"uck. F@"ur endliche
318 Mengen ist die M@"achtigkeit die Anzahl der Elemente der Menge.
320 Die Funktion @code{cardinality} ignoriert redundante Elemente einer Menge auch
321 dann, wenn die Vereinfachung abgeschaltet ist.
323 Beispiele:
325 @example
326 (%i1) cardinality (@{@});
327 (%o1) 0
328 (%i2) cardinality (@{a, a, b, c@});
329 (%o2) 3
330 (%i3) simp : false;
331 (%o3) false
332 (%i4) cardinality (@{a, a, b, c@});
333 (%o4) 3
334 @end example
335 @end deffn
337 @c --- 24.04.2011 DK -----------------------------------------------------------
338 @anchor{cartesian_product}
339 @deffn {Funktion} cartesian_product (@var{b_1}, @dots{}, @var{b_n})
341 Gibt das kartesische Produkt der Mengen @var{b_1}, @dots{}, @var{b_n} zur@"uck.
342 Das kartesische Produkt ist die Menge der geordneten Paare.
344 Das Ergebnis ist eine Menge mit Listen der Form @code{[@var{x_1}, ...,
345 @var{x_n}]}, wobei @var{x_1}, @dots{}, @var{x_n} die Elemente der Mengen
346 @var{b_1}, @dots{}, @var{b_n} sind.
348 Die Funktion @code{cartesian_product} gibt eine Fehlermeldung, wenn eines
349 der Argumente keine Menge ist.
351 Beispiele:
353 @example
354 (%i1) cartesian_product (@{0, 1@});
355 (%o1) @{[0], [1]@}
356 (%i2) cartesian_product (@{0, 1@}, @{0, 1@});
357 (%o2) @{[0, 0], [0, 1], [1, 0], [1, 1]@}
358 (%i3) cartesian_product (@{x@}, @{y@}, @{z@});
359 (%o3) @{[x, y, z]@}
360 (%i4) cartesian_product (@{x@}, @{-1, 0, 1@});
361 (%o4) @{[x, - 1], [x, 0], [x, 1]@}
362 @end example
363 @end deffn
365 @c --- 24.04.2011 DK -----------------------------------------------------------
366 @anchor{disjoin}
367 @deffn {Funktion} disjoin (@var{x}, @var{a})
369 Entfernt das Element @var{x} aus der Menge @var{a} und gibt das Ergebnis
370 zur@"uck.
372 @code{disjoin} gibt eine Fehlermeldung, wenn das Argument @var{a} keine Menge
373 ist.
375 Die Ausdr@"ucke @code{disjoin(@var{x}, @var{a})}, @code{delete(@var{x},
376 @var{a})} und @code{setdifference(@var{a}, set(@var{x}))} sind @"aquivalent.
377 Von diesen M@"oglichkeiten ist im Allgemeinen die Funktion @code{disjoin} am
378 schnellsten.
380 Siehe auch die Funktion @mref{adjoin} sowie die Funktionen @mref{delete} und
381 @mrefdot{setdifference}
383 Beispiele:
385 @example
386 (%i1) disjoin (a, @{a, b, c, d@});
387 (%o1) @{b, c, d@}
388 (%i2) disjoin (a + b, @{5, z, a + b, %pi@});
389 (%o2) @{5, %pi, z@}
390 (%i3) disjoin (a - b, @{5, z, a + b, %pi@});
391 (%o3) @{5, %pi, b + a, z@}
392 @end example
393 @end deffn
395 @c --- 24.04.2011 DK -----------------------------------------------------------
396 @anchor{disjointp}
397 @deffn {Funktion} disjointp (@var{a}, @var{b})
399 @code{disjointp} hat das Ergebnis @code{true}, wenn die Mengen @var{a} und
400 @var{b} disjunkt sind. Zwei Mengen sind disjunkt, wenn sie kein gemeinsames
401 Element besitzen.
403 @code{disjointp} gibt eine Fehlermeldung, wenn eines der Argumente keine
404 Menge ist.
406 Beispiele:
408 @example
409 (%i1) disjointp (@{a, b, c@}, @{1, 2, 3@});
410 (%o1) true
411 (%i2) disjointp (@{a, b, 3@}, @{1, 2, 3@});
412 (%o2) false
413 @end example
414 @end deffn
416 @c --- 24.04.2011 DK -----------------------------------------------------------
417 @anchor{divisors}
418 @deffn {Funktion} divisors (@var{n})
420 Gibt die Menge der Teiler der Zahl @var{n} zur@"uck.
422 Ist das Argument @var{n} eine von Null verschiedene ganze Zahl, vereinfacht
423 @code{divisors(@var{n})} zu einer Menge mit ganzen Zahlen, die Teiler des
424 Argumentes @var{n} sind. Ist das Argument @var{n} eine negative Zahl wird
425 der Betrag des Argumentes genommen. Das Ergebnis enth@"alt die Elemente
426 @var{1} und @var{n}.
428 Ist das Argument der Funktion @code{divisors} eine Liste, Menge, Matrix oder
429 eine Gleichung, wird die Funktion auf die Elemente oder beide Seiten der
430 Gleichung angewendet.
432 Beispiele:
434 Das Beispiel zeigt, dass 28 eine perfekte Zahl ist, die gleich die Summe
435 ihrer Teiler au@ss{}er sich selbst ist.
437 @example
438 (%i1) s: divisors(28);
439 (%o1) @{1, 2, 4, 7, 14, 28@}
440 (%i2) lreduce ("+", args(s)) - 28;
441 (%o2) 28
442 @end example
444 @code{divisors} ist eine vereinfachende Funktion. In diesem Beispiel braucht
445 daher der Ausdruck nach der Substitution nicht erneut ausgewertet werden.
447 @example
448 (%i1) divisors (a);
449 (%o1) divisors(a)
450 (%i2) subst (8, a, %);
451 (%o2) @{1, 2, 4, 8@}
452 @end example
454 Anwendung der Funktion @code{divisors} auf Gleichungen, Listen, Matrizen oder
455 Mengen.
457 @example
458 (%i1) divisors (a = b);
459 (%o1) divisors(a) = divisors(b)
460 (%i2) divisors ([a, b, c]);
461 (%o2) [divisors(a), divisors(b), divisors(c)]
462 (%i3) divisors (matrix ([a, b], [c, d]));
463 [ divisors(a) divisors(b) ]
464 (%o3) [ ]
465 [ divisors(c) divisors(d) ]
466 (%i4) divisors (@{a, b, c@});
467 (%o4) @{divisors(a), divisors(b), divisors(c)@}
468 @end example
469 @end deffn
471 @c --- 24.04.2011 DK -----------------------------------------------------------
472 @anchor{elementp}
473 @deffn {Funktion} elementp (@var{x}, @var{a})
475 Gibt @code{true} zur@"uck, wenn das Argument @var{x} Element der Menge @var{a}
476 ist.
478 @code{elementp} gibt eine Fehlermeldung, wenn das Argument @var{a} keine
479 Menge ist.
481 Beispiele:
483 @example
484 (%i1) elementp (sin(1), @{sin(1), sin(2), sin(3)@});
485 (%o1) true
486 (%i2) elementp (sin(1), @{cos(1), cos(2), cos(3)@});
487 (%o2) false
488 @end example
489 @end deffn
491 @c --- 24.04.2011 DK -----------------------------------------------------------
492 @anchor{emptyp}
493 @deffn {Funktion} emptyp (@var{a})
495 Gibt @code{true} zur@"uck, wenn das Argument @var{a} die leere Menge oder eine
496 leere Liste ist.
498 Beispiele:
500 @example
501 (%i1) map (emptyp, [@{@}, []]);
502 (%o1) [true, true]
503 (%i2) map (emptyp, [a + b, @{@{@}@}, %pi]);
504 (%o2) [false, false, false]
505 @end example
506 @end deffn
508 @c --- 24.04.2011 DK -----------------------------------------------------------
509 @anchor{equiv_classes}
510 @deffn {Funktion} equiv_classes (@var{s}, @var{F})
512 Gibt die Menge der @"Aquivalenzklassen der Menge @var{s} f@"ur die
513 @"Aquivalenzrelation @code{F} zur@"uck.
515 Die @"Aquivalenzrelation @code{F} ist eine Funktion mit zwei Argumenten
516 definiert auf dem Kartesischen Produkt der Menge @var{s} mit @var{s}. Die
517 R@"uckgabe der Funktion @code{F} ist @code{true} oder @code{false} oder ein
518 Ausdruck @var{expr}, so dass @code{is(@var{expr})} das Ergebnis @code{true}
519 oder @code{false} hat.
521 Ist @var{F} keine @"Aquivalenzrelation, wird die Funktion von
522 @code{equiv_classes} ohne Fehlermeldung akzeptiert. Das Ergebnis ist jedoch
523 im Allgemeinen nicht korrekt.
525 Beispiele:
527 Die @"Aquivalenzrelation ist ein Lambda-Ausdruck mit den Ergebnissen
528 @code{true} oder @code{false}.
530 @example
531 (%i1) equiv_classes (@{1, 1.0, 2, 2.0, 3, 3.0@},
532 lambda ([x, y], is (equal (x, y))));
533 (%o1) @{@{1, 1.0@}, @{2, 2.0@}, @{3, 3.0@}@}
534 @end example
536 Die @"Aquivalenzrelation ist der Name einer relationalen Funktion, die von
537 @code{is} zu @code{true} oder @code{false} ausgewertet wird.
539 @example
540 (%i1) equiv_classes (@{1, 1.0, 2, 2.0, 3, 3.0@}, equal);
541 (%o1) @{@{1, 1.0@}, @{2, 2.0@}, @{3, 3.0@}@}
542 @end example
544 Die @"Aquivalenzklassen sind Mengen mit Zahlen, die sich um ein Vielfaches von
545 3 voneinander unterscheiden.
547 @example
548 (%i1) equiv_classes (@{1, 2, 3, 4, 5, 6, 7@},
549 lambda ([x, y], remainder (x - y, 3) = 0));
550 (%o1) @{@{1, 4, 7@}, @{2, 5@}, @{3, 6@}@}
551 @end example
552 @end deffn
554 @c --- 24.04.2011 DK -----------------------------------------------------------
555 @anchor{every}
556 @deffn {Funktion} every (@var{f}, @var{s})
557 @deffnx {Funktion} every (@var{f}, @var{L_1}, @dots{}, @var{L_n})
559 Gibt das Ergebnis @code{true} zur@"uck, wenn die Aussage @code{f} das Ergebnis
560 @code{true} f@"ur alle Elemente der Menge @var{s} hat.
562 Ist das zweite Argument eine Menge, dann gibt @code{every(@var{f}, @var{s})}
563 den Wert @code{true} zur@"uck, wenn @code{is(@var{f}(@var{a_i}))} das Ergebnis
564 @code{true} f@"ur alle Elemente @var{a_i} der Menge @var{s} hat. @code{every}
565 wertet @var{f} nicht notwendigerweise f@"ur alle Elemente @var{a_i} aus, wenn
566 das Ergebnis bereits feststeht. Da Mengen nicht geordnet sind, kann die
567 Funktion @code{every} die Ausdr@"ucke @code{@var{f}(@var{a_i})} in irgendeiner
568 Reihenfolge auswerten.
570 Sind die Argumente eine oder mehrere Listen, dann gibt
571 @code{every(@var{f}, @var{L_1}, ..., @var{L_n})} den Wert @code{true} zur@"uck,
572 wenn @code{is(@var{f}(@var{x_1}, ..., @var{x_n}))} das Ergebnis @code{true}
573 f@"ur alle @var{x_1}, @dots{}, @var{x_n} der Listen @var{L_1}, @dots{},
574 @var{L_n} hat. @code{every} wertet @var{f} wird nicht notwendigerweise f@"ur
575 alle Kombinationen @var{x_1}, @dots{}, @var{x_n} aus, wenn das Ergebnis bereits
576 feststeht. @code{every} wertet die Listen in der Reihenfolge des steigenden
577 Index aus.
579 Ist die leere Menge oder leere Liste ein Argument der Funktion @code{every},
580 dann ist das Ergebnis immer @code{false}.
582 Hat die Optionsvariable @mref{maperror} den Wert @code{true}, m@"ussen alle
583 Listen @var{L_1}, @dots{}, @var{L_n} die gleiche L@"ange haben. Hat die
584 Optionsvariable @code{maperror} den Wert @code{false}, werden die Listen auf
585 die L@"ange der k@"urzesten Liste abgeschnitten.
587 Kann die Aussagefunktion @var{f} von der Funktion @code{is} nicht zu @code{true}
588 oder @code{false} ausgewertet werden, h@"angt das Ergebnis von der
589 Optionsvariablen @mref{prederror} ab. Hat die Optionsvariable @code{prederror}
590 den Wert @code{true}, werden solche Werte als @code{false} behandelt und die
591 Funktion @code{every} hat das Ergebnis @code{false}. Hat @code{prederror}
592 den Wert @code{false}, werden solche Werte als @code{unknown} behandelt und die
593 Funktion @code{every} hat das Ergebnis @code{unknown}.
595 Beispiele:
597 @code{every} angewendet auf eine Menge. Die Aussagefunktion hat ein Argument.
599 @example
600 (%i1) every (integerp, @{1, 2, 3, 4, 5, 6@});
601 (%o1) true
602 (%i2) every (atom, @{1, 2, sin(3), 4, 5 + y, 6@});
603 (%o2) false
604 @end example
606 @code{every} angewendet auf zwei Listen. Die Aussagefunktion hat zwei
607 Argumente entsprechend der Anzahl der Listen.
609 @example
610 (%i1) every ("=", [a, b, c], [a, b, c]);
611 (%o1) true
612 (%i2) every ("#", [a, b, c], [a, b, c]);
613 (%o2) false
614 @end example
616 Kann die Aussagefunktion @var{f} nicht zu @code{true} oder @code{false}
617 ausgewertet werden, h@"angt das Ergebnis von @code{every} von der
618 Optionsvariablen @code{prederror} ab.
620 @example
621 (%i1) prederror : false;
622 (%o1) false
623 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
624 [x^2, y^2, z^2]);
625 (%o2) [unknown, unknown, unknown]
626 (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
627 (%o3) unknown
628 (%i4) prederror : true;
629 (%o4) true
630 (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
631 (%o5) false
632 @end example
633 @end deffn
635 @c --- 24.04.2011 DK -----------------------------------------------------------
636 @anchor{extremal_subset}
637 @deffn {Funktion} extremal_subset (@var{s}, @var{f}, max)
638 @deffnx {Funktion} extremal_subset (@var{s}, @var{f}, min)
640 Gibt die Teilmenge von @var{s} zur@"uck, f@"ur die die Funktion @var{f} maximale
641 oder minimale Ergebnisse hat.
643 @code{extremal_subset(@var{s}, @var{f}, max)} gibt die Teilmenge der Liste oder
644 Menge @var{s} zur@"uck, f@"ur die die Funktion @var{f} ihre maximalen Werte
645 annimmt.
647 @code{extremal_subset(@var{s}, @var{f}, min)} gibt die Teilmenge der Liste oder
648 Menge @var{s} zur@"uck, f@"ur die die Funktion @var{f} ihre minimalen Werte
649 annimmt.
651 Beispiele:
653 @example
654 (%i1) extremal_subset (@{-2, -1, 0, 1, 2@}, abs, max);
655 (%o1) @{- 2, 2@}
656 (%i2) extremal_subset (@{sqrt(2), 1.57, %pi/2@}, sin, min);
657 (%o2) @{sqrt(2)@}
658 @end example
659 @end deffn
661 @c --- 24.04.2011 DK -----------------------------------------------------------
662 @anchor{flatten}
663 @deffn {Funktion} flatten (@var{expr})
665 Sammelt die Argumente von allen Teilausdr@"ucken, die denselben Operator wie
666 der Ausdruck @var{expr} haben und konstruiert einen Ausdruck mit dem Operator
667 des Ausdrucks @var{expr} und den Argumenten. Ein einfaches Beispiel ist eine
668 verschachtelte Liste. @code{flatten} konstruiert in diesem Fall eine Liste
669 aus den Elementen aller Teillisten.
671 Teilausdr@"ucke, deren Operator sich von dem Hauptoperator des Ausdrucks
672 @var{expr} unterscheidet, werden als ein Argument betrachtet, auch wenn der
673 Teilausdr@"uck wiederum Teilausdr@"ucke des Hauptoperators enth@"alt.
675 Es ist m@"oglich, dass @code{flatten} Ausdr@"ucke konstruiert, in denen die
676 Anzahl der Argumente nicht der erforderlichen Anzahl an Argumenten des Operators
677 entspricht. Dies kann zu Fehlermeldungen bei der Auswertung oder Vereinfachung
678 f@"uhren. @code{flatten} kontrolliert nicht, ob die konstruierten Ausdr@"ucke
679 g@"ultig sind.
681 Ausdr@"ucke mit speziellen Darstellungen, wie zum Beispiel CRE-Ausdr@"ucke,
682 k@"onnen von @code{flatten} nicht verarbeitet werden. In diesem F@"allen gibt
683 @code{flatten} das Argument unver@"andert zur@"uck.
685 Beispiele:
687 Wird @code{flatten} auf eine Liste angewendet, werden die Elemente aller
688 Teillisten zu einer Liste zusammengef@"ugt.
690 @example
691 (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
692 (%o1) [a, b, c, d, e, f, g, h, i, j]
693 @end example
695 Wird @code{flatten} auf eine Menge angewendet, werden die Elemente aller
696 Teilmengen zu einer Menge zusammengef@"ugt.
698 @example
699 (%i1) flatten (@{a, @{b@}, @{@{c@}@}@});
700 (%o1) @{a, b, c@}
701 (%i2) flatten (@{a, @{[a], @{a@}@}@});
702 (%o2) @{a, [a]@}
703 @end example
705 Die Funktionsweise von @code{flatten} ist vergleichbar mit der Deklaration eines
706 Operators als ein N-ary-Operator. Im Unterschied zu einer Deklaration hat
707 @code{flatten} keinen Einfluss auf Teilausdr@"ucke, die einen vom Hauptoperator
708 verschiedenen Operator haben.
710 @example
711 (%i1) expr: flatten (f (g (f (f (x)))));
712 (%o1) f(g(f(f(x))))
713 (%i2) declare (f, nary);
714 (%o2) done
715 (%i3) ev (expr);
716 (%o3) f(g(f(x)))
717 @end example
719 @code{flatten} kann Ausdr@"ucke mit indizierte Funktionen vereinfachen.
721 @example
722 (%i1) flatten (f[5] (f[5] (x, y), z));
723 (%o1) f (x, y, z)
724 5
725 @end example
727 Es ist m@"oglich, dass @code{flatten} einen Ausdruck konstruiert, der nicht die
728 korrekte Anzahl an Argumenten eines Operators enth@"alt.
730 @example
731 (%i1) 'mod (5, 'mod (7, 4));
732 (%o1) mod(5, mod(7, 4))
733 (%i2) flatten (%);
734 (%o2) mod(5, 7, 4)
735 (%i3) ''%, nouns;
736 Wrong number of arguments to mod
737 -- an error. Quitting. To debug this try debugmode(true);
738 @end example
739 @end deffn
741 @c --- 24.04.2011 DK -----------------------------------------------------------
742 @anchor{full_listify}
743 @deffn {Funktion} full_listify (@var{a})
745 Ersetzt jedes Auftreten des Operators f@"ur Mengen in dem Ausdruck @var{a}
746 durch den Operator f@"ur Listen. Die Ersetzung wird auch in verschachtelten
747 Teilausdr@"ucken ausgef@"uhrt, deren Operator nicht der Operator f@"ur Mengen
748 ist.
750 Die Funktion @mref{listify} ersetzt nur den Hauptoperator eines Ausdrucks.
752 @need 800
753 Beispiele:
755 @example
756 (%i1) full_listify (@{a, b, @{c, @{d, e, f@}, g@}@});
757 (%o1) [a, b, [c, [d, e, f], g]]
758 (%i2) full_listify (F (G (@{a, b, H(@{c, d, e@})@})));
759 (%o2) F(G([a, b, H([c, d, e])]))
760 @end example
761 @end deffn
763 @c --- 24.04.2011 DK -----------------------------------------------------------
764 @anchor{fullsetify}
765 @deffn {Funktion} fullsetify (@var{a})
767 Ist @var{a} eine Liste, wird der Operator f@"ur Listen durch den Operator f@"ur
768 Mengen ersetzt. Dann wird @code{fullsetify} auf alle Argumente der Liste
769 angewendet. Ist ein Argument keine Liste, wenn das Argument unver@"andert
770 zur@"uckgegeben.
772 Die Funktion @mref{setify} ersetzt nur den Hauptoperator eines Ausdrucks.
774 Beispiele:
776 Im zweiten Beispiel wird das Argument der Funktion @code{f} nicht in eine
777 Menge konvertiert, da der Operator des Teilausdrucks keine Liste ist.
779 @example
780 (%i1) fullsetify ([a, [a]]);
781 (%o1) @{a, @{a@}@}
782 (%i2) fullsetify ([a, f([b])]);
783 (%o2) @{a, f([b])@}
784 @end example
785 @end deffn
787 @c --- 24.04.2011 DK -----------------------------------------------------------
788 @anchor{identity}
789 @deffn {Funktion} identity (@var{x})
791 Gibt f@"ur jedes Argument @var{x} das Argument selbst zur@"uck.
793 Beispiele:
795 @code{identity} kann als eine Aussagefunktion genutzt werden, wenn die Argumente
796 boolesche Werte sind.
798 @example
799 (%i1) every (identity, [true, true]);
800 (%o1) true
801 @end example
802 @end deffn
804 @c --- 24.04.2011 DK -----------------------------------------------------------
805 @anchor{integer_partitions}
806 @deffn {Funktion} integer_partitions (@var{n})
807 @deffnx {Funktion} integer_partitions (@var{n}, @var{len})
809 Ermittelt die Zerlegung einer ganzen Zahl @var{n} in ganze Zahlen, die
810 @var{n} als Summe haben.
812 @code{integer_partitions(@var{n})} gibt eine Menge aller Zerlegungen der ganzen
813 Zahl @var{n} zur@"uck. Jede Zerlegung ist eine Liste mit den ganzen Zahlen, die
814 @var{n} als Summe haben. Die Listen sind nach der Gr@"o@ss{}e sortiert.
816 @code{integer_partitions(@var{n}, @var{len})} gibt eine Menge aller Zerlegungen
817 der ganzen Zahl @var{n} zur@"uck, deren Listen @code{len} oder weniger Elemente
818 haben. Listen die weniger als @code{len} Elemente haben, werden mit Nullen
819 aufgef@"ullt.
821 Siehe auch die Funktionen @mref{num_partitions} und
822 @mrefdot{num_distinct_partitions}
824 Beispiele:
826 @example
827 (%i1) integer_partitions (3);
828 (%o1) @{[1, 1, 1], [2, 1], [3]@}
829 (%i2) s: integer_partitions (25)$
830 (%i3) cardinality (s);
831 (%o3) 1958
832 (%i4) map (lambda ([x], apply ("+", x)), s);
833 (%o4) @{25@}
834 (%i5) integer_partitions (5, 3);
835 (%o5) @{[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]@}
836 (%i6) integer_partitions (5, 2);
837 (%o6) @{[3, 2], [4, 1], [5, 0]@}
838 @end example
840 Um alle Zerlegungen zu finden, die eine Bedingung erf@"ullen, kann die Funktion
841 @mref{subset} genutzt werden. In diesem Beispiel werden alle Zerlegungen
842 der Zahl 10 ermittelt, die nur Primzahlen enthalten.
844 @example
845 (%i1) s: integer_partitions (10)$
846 (%i2) cardinality (s);
847 (%o2) 42
848 (%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
849 (%i4) subset (s, lambda ([x], every (xprimep, x)));
850 (%o4) @{[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]@}
851 @end example
852 @end deffn
854 @c --- 24.04.2011 DK -----------------------------------------------------------
855 @anchor{intersect}
856 @deffn {Funktion} intersect (@var{a_1}, @dots{}, @var{a_n})
858 @code{intersect} ist identisch mit der Funktion @mrefdot{intersection}
859 @end deffn
861 @c --- 24.04.2011 DK -----------------------------------------------------------
862 @anchor{intersection}
863 @deffn {Funktion} intersection (@var{a_1}, @dots{}, @var{a_n})
865 Gibt die Schnittmenge der Mengen @var{a_1}, @dots{}, @var{a_n} zur@"uck. Die
866 Schnittmenge enth@"alt die Elemente, die den Mengen gemeinsam sind.
868 @code{intersection} gibt eine Fehlermeldung, wenn eines der Argumente
869 keine Menge ist.
871 Beispiele:
873 @example
874 (%i1) S_1 : @{a, b, c, d@};
875 (%o1) @{a, b, c, d@}
876 (%i2) S_2 : @{d, e, f, g@};
877 (%o2) @{d, e, f, g@}
878 (%i3) S_3 : @{c, d, e, f@};
879 (%o3) @{c, d, e, f@}
880 (%i4) S_4 : @{u, v, w@};
881 (%o4) @{u, v, w@}
882 (%i5) intersection (S_1, S_2);
883 (%o5) @{d@}
884 (%i6) intersection (S_2, S_3);
885 (%o6) @{d, e, f@}
886 (%i7) intersection (S_1, S_2, S_3);
887 (%o7) @{d@}
888 (%i8) intersection (S_1, S_2, S_3, S_4);
889 (%o8) @{@}
890 @end example
891 @end deffn
893 @c --- 09.07.2011 DK -----------------------------------------------------------
894 @anchor{kron_delta}
895 @deffn {Funktion} kron_delta (@var{x_1}, @var{x_2}, @dots{}, @var{x_p})
897 Ist die Kronecker-Delta-Funktion.
899 @c @code{kron_delta} simplifies to 1 when @var{xi} and @var{yj} are equal
900 @c for all pairs of arguments, and it simplifies to 0 when @var{xi} and
901 @c @var{yj} are not equal for some pair of arguments. Equality is
902 @c determined using @code{is(equal(xi,xj))} and inequality by
903 @c @code{is(notequal(xi,xj))}. For exactly one argument, @code{kron_delta}
904 @c signals an error.
906 @code{kron_delta} vereinfacht zu @code{1}, wenn die Argumente @var{x_i} und
907 @var{y_i} f@"ur alle Paare gleich sind, und zu @code{0}, wenn @var{x_i} und
908 @var{y_i} nicht gleich sind f@"ur irgendein Paar der Argumente. Die Gleichheit
909 wird festgestellt mit @code{is(equal(xi,xj))} und die Ungleichheit mit
910 @code{is(notequal(xi,xj))}. Wird nur ein Argument angegeben, signalisiert
911 die Funktion @code{kron_delta} einen Fehler.
913 Beispiele:
915 @example
916 (%i1) kron_delta(a,a);
917 (%o1) 1
918 (%i2) kron_delta(a,b,a,b);
919 (%o2) kron_delta(a, b)
920 (%i3) kron_delta(a,a,b,a+1);
921 (%o3) 0
922 (%i4) assume(equal(x,y));
923 (%o4) [equal(x, y)]
924 (%i5) kron_delta(x,y);
925 (%o5) 1
926 @end example
927 @end deffn
929 @c --- 24.04.2011 DK -----------------------------------------------------------
930 @anchor{listify}
931 @deffn {Funktion} listify (@var{a})
933 Ist das Argument @var{a} eine Menge, werden die Elemente der Menge als eine
934 Liste zur@"uckgegeben. Ansonsten wird @var{a} zur@"uckgegeben.
936 Siehe die Funktion @mrefcomma{full_listify} um auch Mengen in Teilausdr@"ucken
937 von @var{a} durch Listen zu ersetzen.
939 Beispiele:
941 @example
942 (%i1) listify (@{a, b, c, d@});
943 (%o1) [a, b, c, d]
944 (%i2) listify (F (@{a, b, c, d@}));
945 (%o2) F(@{a, b, c, d@})
946 @end example
947 @end deffn
949 @c --- 25.04.2011 DK -----------------------------------------------------------
950 @anchor{lreduce}
951 @deffn {Funktion} lreduce (@var{F}, @var{s})
952 @deffnx {Funktion} lreduce (@var{F}, @var{s}, @var{s_0})
954 Wendet eine Funktion @var{F}, die zwei Argumente hat, auf die Elemente einer
955 Liste @var{s} an, indem die Funktionsaufrufe verkettet werden.
957 Das Kommando @code{lreduce(@var{F}, @var{s})} bildet den Ausdruck
958 @code{F(... F(F(s_1, s_2), s_3), ... s_n)}. Ist das optionale Argument
959 @var{s_0} vorhanden, dann ist das Ergebnis @"aquivalent zu
960 @code{lreduce(@var{F}, cons(@var{s_0}, @var{s}))}.
962 Siehe auch @mrefcomma{rreduce} @mref{xreduce} und @mrefdot{tree_reduce}
964 @need 600
965 Beispiele:
967 @code{lreduce} ohne das optionale Argument.
969 @example
970 (%i1) lreduce (f, [1, 2, 3]);
971 (%o1) f(f(1, 2), 3)
972 (%i2) lreduce (f, [1, 2, 3, 4]);
973 (%o2) f(f(f(1, 2), 3), 4)
974 @end example
976 @code{lreduce} mit dem optionalen Argument.
978 @example
979 (%i1) lreduce (f, [1, 2, 3], 4);
980 (%o1) f(f(f(4, 1), 2), 3)
981 @end example
983 @code{lreduce} mit den bin@"aren Operatoren der Exponentiation "^" und der
984 Division "/".
986 @example
987 (%i1) lreduce ("^", args (@{a, b, c, d@}));
988 b c d
989 (%o1) ((a ) )
990 (%i2) lreduce ("/", args (@{a, b, c, d@}));
991 a
992 (%o2) -----
993 b c d
994 @end example
995 @end deffn
997 @c --- 05.05.2011 DK -----------------------------------------------------------
998 @anchor{makeset}
999 @deffn {Funktion} makeset (@var{expr}, @var{x}, @var{s})
1001 Generiert eine Menge, indem der Ausdruck @var{expr} ausgewertet wird, wobei das
1002 Argument @var{x} eine Liste mit Variablen des Ausdrucks und @var{s} eine
1003 Menge oder eine Liste mit Listen ist. Ein Element der Menge wird generiert,
1004 indem die Variablen in @var{x} nacheinander an die Elemente in @var{s}
1005 gebunden werden.
1007 Jedes Element des Argumentes @var{s} muss dieselbe L@"ange wie @var{x} haben.
1008 Die Liste der Variablen @var{x} muss eine List mit Symbolen sein. Indizierte
1009 Variablen sind nicht m@"oglich. Auch wenn nur eine Variable angegeben wird,
1010 muss diese Element einer Liste sein und jedes Element von @var{s} muss eine
1011 Liste mit einem Element sein.
1013 Siehe auch die Funktion @mrefcomma{makelist} um eine Liste zu generieren.
1015 Beispiele:
1017 @example
1018 (%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
1019 1 2 3 4
1020 (%o1) @{-, -, -, -@}
1021 a b c d
1022 (%i2) S : @{x, y, z@}$
1023 (%i3) S3 : cartesian_product (S, S, S);
1024 (%o3) @{[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
1025 [x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
1026 [y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
1027 [y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
1028 [z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
1029 [z, z, y], [z, z, z]@}
1030 (%i4) makeset (i + j + k, [i, j, k], S3);
1031 (%o4) @{3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
1032 z + 2 y, 2 z + x, 2 z + y@}
1033 (%i5) makeset (sin(x), [x], @{[1], [2], [3]@});
1034 (%o5) @{sin(1), sin(2), sin(3)@}
1035 @end example
1036 @end deffn
1038 @c --- 05.05.2011 DK -----------------------------------------------------------
1039 @anchor{moebius}
1040 @deffn {Funktion} moebius (@var{n})
1042 Ist die M@"obiusfunktion.
1044 Ist die nat@"urliche Zahl @var{n} quadratfrei, dann vereinfacht die
1045 M@"obiusfunktion zu @code{-1^k}, wobei @var{k} die Anzahl der Primfaktoren der
1046 Zahl @var{n} ist. Eine Zahl ist quadratfrei, wenn sie nur voneinander
1047 verschiedene Primfaktoren hat. F@"ur @code{@var{n} = 1} vereinfacht die
1048 M@"obiusfunktion zu @code{1} und f@"ur alle anderen positiven ganzen Zahlen zum
1049 Wert @code{0}. F@"ur andere Argumente wird eine Substantivform als Ergebnis
1050 zur@"uckgegeben.
1052 Ist das Argument der Funktion @code{moebius} eine Liste, Menge, Matrix oder
1053 eine Gleichung, wird die Funktion auf die Elemente oder beide Seiten der
1054 Gleichung angewendet.
1056 Beispiele:
1058 @example
1059 (%i1) moebius (1);
1060 (%o1) 1
1061 (%i2) moebius (2 * 3 * 5);
1062 (%o2) - 1
1063 (%i3) moebius (11 * 17 * 29 * 31);
1064 (%o3) 1
1065 (%i4) moebius (2^32);
1066 (%o4) 0
1067 (%i5) moebius (n);
1068 (%o5) moebius(n)
1069 (%i6) moebius (n = 12);
1070 (%o6) moebius(n) = 0
1071 (%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
1072 (%o7) [- 1, 1, 1]
1073 (%i8) moebius (matrix ([11, 12], [13, 14]));
1074 [ - 1 0 ]
1075 (%o8) [ ]
1076 [ - 1 1 ]
1077 (%i9) moebius (@{21, 22, 23, 24@});
1078 (%o9) @{- 1, 0, 1@}
1079 @end example
1080 @end deffn
1082 @c --- 05.05.2011 DK -----------------------------------------------------------
1083 @anchor{multinomial_coeff}
1084 @deffn {Funktion} multinomial_coeff (@var{a_1}, @dots{}, @var{a_n})
1085 @deffnx {Funktion} multinomial_coeff ()
1087 Gibt den Multinomialkoeffizienten zur@"uck. Im Spezialfall @code{@var{k} = 2}
1088 ergibt sich die Binomialverteilung. Siehe @mrefdot{binomial}
1090 Enth@"alt das Ergebnis Fakult@"aten, kann das Ergebnis m@"oglicherweise mit der
1091 Funktion @mref{minfactorial} weiter vereinfacht werden.
1093 Beispiele:
1095 @example
1096 (%i1) multinomial_coeff (1, 2, x);
1097 (x + 3)!
1098 (%o1) --------
1099 2 x!
1100 (%i2) minfactorial (%);
1101 (x + 1) (x + 2) (x + 3)
1102 (%o2) -----------------------
1103 2
1104 (%i3) multinomial_coeff (-6, 2);
1105 (- 4)!
1106 (%o3) --------
1107 2 (- 6)!
1108 (%i4) minfactorial (%);
1109 (%o4) 10
1110 @end example
1111 @end deffn
1113 @c --- 05.05.2011 DK -----------------------------------------------------------
1114 @anchor{num_distinct_partitions}
1115 @deffn {Funktion} num_distinct_partitions (@var{n})
1116 @deffnx {Funktion} num_distinct_partitions (@var{n}, list)
1118 Gibt die Anzahl der M@"oglichkeiten an, eine nat@"urliche Zahl @var{n} in
1119 Summanden zu zerlegen, wobei jeder Summand nur einmal vorkommt. Ist @var{n}
1120 keine nat@"urliche Zahl wird eine Substantivform als Ergebnis zur@"uckgegeben.
1122 @code{num_distinct_partitions(@var{n}, list)} gibt eine Liste mit der Anzahl
1123 der voneinander verschiedenen Partitionen der nat@"urlichen Zahlen 1, 2, 3,
1124 @dots{}, @var{n} zur@"uck.
1126 Siehe auch die Funktionen @mref{num_partitions} und @mrefdot{integer_partitions}
1128 Beispiele:
1130 @example
1131 (%i1) num_distinct_partitions (12);
1132 (%o1) 15
1133 (%i2) num_distinct_partitions (12, list);
1134 (%o2) [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15]
1135 (%i3) num_distinct_partitions (n);
1136 (%o3) num_distinct_partitions(n)
1137 @end example
1138 @end deffn
1140 @c --- 05.05.2011 DK -----------------------------------------------------------
1141 @anchor{num_partitions}
1142 @deffn {Funktion} num_partitions (@var{n})
1143 @deffnx {Funktion} num_partitions (@var{n}, list)
1145 Gibt die Anzahl der M@"oglichkeiten an, eine nat@"urliche Zahl @var{n} in
1146 Summanden zu zerlegen. Ist @var{n} keine nat@"urliche Zahl wird eine
1147 Substantivform als Ergebnis zur@"uckgegeben.
1149 @code{num_partitions(@var{n}, list)} gibt eine Liste mit der Anzahl
1150 der Partitionen der nat@"urlichen Zahlen 1, 2, 3, @dots{}, @var{n} zur@"uck.
1152 Das Kommando @code{num_partitions(@var{n})} ist f@"ur eine nat@"urliche Zahl
1153 @var{n} @"aquivalent zu @code{cardinality(integer_partitions(@var{n}))}.
1154 Da die Funktion @code{num_partitions} die Menge nicht konstruiert, ist diese
1155 Funktion deutlich schneller.
1157 Siehe auch die Funktionen @mref{num_distinct_partitions} und
1158 @mrefdot{integer_partitions}
1160 Beispiele:
1162 @example
1163 (%i1) num_partitions (5) = cardinality (integer_partitions (5));
1164 (%o1) 7 = 7
1165 (%i2) num_partitions (8, list);
1166 (%o2) [1, 1, 2, 3, 5, 7, 11, 15, 22]
1167 (%i3) num_partitions (n);
1168 (%o3) num_partitions(n)
1169 @end example
1170 @end deffn
1172 @c --- 05.05.2011 DK -----------------------------------------------------------
1173 @anchor{partition_set}
1174 @deffn {Funktion} partition_set (@var{a}, @var{f})
1176 Zerlegt eine Menge @var{a} mit der Aussagefunktion @var{f}.
1178 @code{partition_set} gibt eine Liste mit zwei Elementen zur@"uck. Das erste
1179 Element ist die Menge der Elemente, f@"ur die die Aussagefunktion @var{f} zu
1180 @code{false} ausgewertet wird. Das zweite Element ist die Menge aller anderen
1181 Elemente. @code{partition_set} wendet nicht die Funktion @code{is} auf das
1182 Ergebnis der Aussagefunktion @var{f} an.
1184 @code{partition_set} gibt eine Fehlermeldung, wenn @var{a} keine Menge ist.
1186 Siehe auch die Funktion @mrefdot{subset}
1188 Beispiele:
1190 @example
1191 (%i1) partition_set (@{2, 7, 1, 8, 2, 8@}, evenp);
1192 (%o1) [@{1, 7@}, @{2, 8@}]
1193 (%i2) partition_set (@{x, rat(y), rat(y) + z, 1@},
1194 lambda ([x], ratp(x)));
1195 (%o2)/R/ [@{1, x@}, @{y, y + z@}]
1196 @end example
1197 @end deffn
1199 @c --- 06.05.2011 DK -----------------------------------------------------------
1200 @anchor{permutations}
1201 @deffn {Funktion} permutations (@var{a})
1203 Gibt eine Menge mit allen voneinander verschiedenen Permutationen der Elemente
1204 der Liste oder Menge @var{a} zur@"uck. Die Permutationen sind Listen.
1206 Ist das Argument @var{a} eine Liste, werden auch doppelte Elemente in die
1207 m@"oglichen Permutationen eingeschlossen.
1209 @code{permutations} gibt eine Fehlermeldung, wenn @var{a} keine Liste oder
1210 Menge ist.
1212 Siehe auch die Funktion @mrefdot{random_permutation}
1214 Beispiele:
1216 @example
1217 (%i1) permutations ([a, a]);
1218 (%o1) @{[a, a]@}
1219 (%i2) permutations ([a, a, b]);
1220 (%o2) @{[a, a, b], [a, b, a], [b, a, a]@}
1221 @end example
1222 @end deffn
1224 @c --- 06.05.2011 DK -----------------------------------------------------------
1225 @anchor{powerset}
1226 @deffn {Funktion} powerset (@var{a})
1227 @deffnx {Funktion} powerset (@var{a}, @var{n})
1229 Gibt die Menge aller Teilmengen der Menge @var{a} oder eine Teilmenge dieser
1230 Menge zur@"uck.
1232 @code{powerset(@var{a})} gibt die Menge aller Teilmengen der Menge @var{a}
1233 zur@"uck. Die Ergebnismenge hat @code{2^cardinality(@var{a})} Elemente.
1235 @code{powerset(@var{a}, @var{n})} gibt die Menge aller Teilmengen der Menge
1236 @var{a} zur@"uck, die die M@"achtigkeit @var{n} haben.
1238 @code{powerset} gibt eine Fehlermeldung, wenn @var{a} keine Menge oder @var{n}
1239 keine nat@"urliche Zahl ist.
1241 Beispiele:
1243 @example
1244 (%i1) powerset (@{a, b, c@});
1245 (%o1) @{@{@}, @{a@}, @{a, b@}, @{a, b, c@}, @{a, c@}, @{b@}, @{b, c@}, @{c@}@}
1246 (%i2) powerset (@{w, x, y, z@}, 4);
1247 (%o2) @{@{w, x, y, z@}@}
1248 (%i3) powerset (@{w, x, y, z@}, 3);
1249 (%o3) @{@{w, x, y@}, @{w, x, z@}, @{w, y, z@}, @{x, y, z@}@}
1250 (%i4) powerset (@{w, x, y, z@}, 2);
1251 (%o4) @{@{w, x@}, @{w, y@}, @{w, z@}, @{x, y@}, @{x, z@}, @{y, z@}@}
1252 (%i5) powerset (@{w, x, y, z@}, 1);
1253 (%o5) @{@{w@}, @{x@}, @{y@}, @{z@}@}
1254 (%i6) powerset (@{w, x, y, z@}, 0);
1255 (%o6) @{@{@}@}
1256 @end example
1257 @end deffn
1259 @c --- 06.05.2011 DK -----------------------------------------------------------
1260 @anchor{random_permutation}
1261 @deffn {Funktion} random_permutation (@var{a})
1263 Gibt eine zuf@"allige Permutation der Menge oder Liste @var{a} zur@"uck, die mit
1264 dem Knuth-Misch-Algorithmus generiert wird.
1266 Die R@"uckgabe ist eine neue Liste, die verschieden vom Argument @var{a}.
1267 Jedoch werden nicht die Elemente kopiert.
1269 Beispiele:
1271 @example
1272 (%i1) random_permutation ([a, b, c, 1, 2, 3]);
1273 (%o1) [c, 1, 2, 3, a, b]
1274 (%i2) random_permutation ([a, b, c, 1, 2, 3]);
1275 (%o2) [b, 3, 1, c, a, 2]
1276 (%i3) random_permutation (@{x + 1, y + 2, z + 3@});
1277 (%o3) [y + 2, z + 3, x + 1]
1278 (%i4) random_permutation (@{x + 1, y + 2, z + 3@});
1279 (%o4) [x + 1, y + 2, z + 3]
1280 @end example
1281 @end deffn
1283 @c --- 25.04.2011 DK -----------------------------------------------------------
1284 @anchor{rreduce}
1285 @deffn {Funktion} rreduce (@var{F}, @var{s})
1286 @deffnx {Funktion} rreduce (@var{F}, @var{s}, @var{s_@{n + 1@}})
1288 Wendet eine Funktion @var{F}, die zwei Argumente hat, auf die Elemente einer
1289 Liste @var{s} an, indem die Funktionsaufrufe verkettet werden.
1291 Das Kommando @code{rreduce(@var{F}, @var{s})} bildet den Ausdruck
1292 @code{F(s_1, ... F(s_@{n - 2@}, F(s_@{n - 1@}, s_n)))}. Ist das optionale
1293 Argument @var{s_0} vorhanden, dann ist das Ergebnis @"aquivalent zu
1294 @code{rreduce(@var{F}, endcons(@var{s_@{n + 1@}}, @var{s}))}.
1296 Siehe auch @mrefcomma{lreduce} @mref{xreduce} und @mrefdot{tree_reduce}
1298 Beispiele:
1300 @code{rreduce} ohne das optionale Argument.
1302 @example
1303 (%i1) rreduce (f, [1, 2, 3]);
1304 (%o1) f(1, f(2, 3))
1305 (%i2) rreduce (f, [1, 2, 3, 4]);
1306 (%o2) f(1, f(2, f(3, 4)))
1307 @end example
1309 @code{rreduce} mit dem optionalen Argument.
1311 @example
1312 (%i1) rreduce (f, [1, 2, 3], 4);
1313 (%o1) f(1, f(2, f(3, 4)))
1314 @end example
1316 @code{rreduce} mit den bin@"aren Operatoren der Exponentiation "^" und der
1317 Division "/".
1319 @example
1320 (%i1) rreduce ("^", args (@{a, b, c, d@}));
1321 d
1322 c
1323 b
1324 (%o1) a
1325 (%i2) rreduce ("/", args (@{a, b, c, d@}));
1326 a c
1327 (%o2) ---
1328 b d
1329 @end example
1330 @end deffn
1332 @c --- 06.05.2011 DK -----------------------------------------------------------
1333 @anchor{setdifference}
1334 @deffn {Funktion} setdifference (@var{a}, @var{b})
1336 Gibt eine Menge mit den Elementen zur@"uck, die in der Menge @var{a}, aber nicht
1337 in der Menge @var{b} enthalten sind.
1339 @code{setdifference} gibt eine Fehlermeldung, wenn die Argumente @var{a} oder
1340 @var{b} keine Mengen sind.
1342 Beispiele:
1344 @example
1345 (%i1) S_1 : @{a, b, c, x, y, z@};
1346 (%o1) @{a, b, c, x, y, z@}
1347 (%i2) S_2 : @{aa, bb, c, x, y, zz@};
1348 (%o2) @{aa, bb, c, x, y, zz@}
1349 (%i3) setdifference (S_1, S_2);
1350 (%o3) @{a, b, z@}
1351 (%i4) setdifference (S_2, S_1);
1352 (%o4) @{aa, bb, zz@}
1353 (%i5) setdifference (S_1, S_1);
1354 (%o5) @{@}
1355 (%i6) setdifference (S_1, @{@});
1356 (%o6) @{a, b, c, x, y, z@}
1357 (%i7) setdifference (@{@}, S_1);
1358 (%o7) @{@}
1359 @end example
1360 @end deffn
1362 @c --- 06.05.2011 DK -----------------------------------------------------------
1363 @anchor{setequalp}
1364 @deffn {Funktion} setequalp (@var{a}, @var{b})
1366 Gibt das Ergebnis @code{true} zur@"uck, wenn die Mengen @var{a} und @var{b}
1367 dieselbe Anzahl an Elementen haben und der Ausdruck @code{is(@var{x} = @var{y})}
1368 das Ergebnis @code{true} f@"ur alle Elemente @var{x} der Menge @var{a} und
1369 @var{y} der Menge @var{b} hat. Dabei haben die Elemente eine Ordnung wie sie
1370 von der Funktion @code{listify} generiert wird. Ansonsten ist das Ergebnis
1371 @code{false}.
1373 Beispiele:
1375 @example
1376 (%i1) setequalp (@{1, 2, 3@}, @{1, 2, 3@});
1377 (%o1) true
1378 (%i2) setequalp (@{a, b, c@}, @{1, 2, 3@});
1379 (%o2) false
1380 (%i3) setequalp (@{x^2 - y^2@}, @{(x + y) * (x - y)@});
1381 (%o3) false
1382 @end example
1383 @end deffn
1385 @c --- 06.05.2011 DK -----------------------------------------------------------
1386 @anchor{setify}
1387 @deffn {Funktion} setify (@var{a})
1389 Konstruiert eine Menge aus den Elementen der Liste @var{a}. Doppelte Elemente
1390 der Liste @var{a} werden entfernt und die Elemente werden mit der
1391 Aussagefunktion @mref{orderlessp} sortiert.
1393 @code{setify} gibt eine Fehlermeldung, wenn @var{a} keine Liste ist.
1395 Beispiele:
1397 @example
1398 (%i1) setify ([1, 2, 3, a, b, c]);
1399 (%o1) @{1, 2, 3, a, b, c@}
1400 (%i2) setify ([a, b, c, a, b, c]);
1401 (%o2) @{a, b, c@}
1402 (%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
1403 (%o3) @{1, 3, 5, 7, 9, 11, 13@}
1404 @end example
1405 @end deffn
1407 @c -----------------------------------------------------------------------------
1408 @anchor{setp}
1409 @deffn {Funktion} setp (@var{a})
1411 Gibt das Ergebnis @code{true} zur@"uck, wenn das Argument @var{a} eine Menge
1412 ist.
1414 @code{setp} gibt @code{true} auch f@"ur Mengen zur@"uck, die noch nicht
1415 vereinfacht sind, also m@"oglicherweise doppelte Elemente enthalten.
1417 @code{setp} ist @"aquivalent zu dem Kommando @code{setp(a) := not atom(a)
1418 and op(a) = 'set}.
1420 Beispiele:
1422 @example
1423 (%i1) simp : false;
1424 (%o1) false
1425 (%i2) @{a, a, a@};
1426 (%o2) @{a, a, a@}
1427 (%i3) setp (%);
1428 (%o3) true
1429 @end example
1430 @end deffn
1432 @c --- 09.05.2011 DK -----------------------------------------------------------
1433 @anchor{set_partitions}
1434 @deffn {Funktion} set_partitions (@var{a})
1435 @deffnx {Funktion} set_partitions (@var{a}, @var{n})
1437 Gibt die Menge aller Partitionen der Menge @var{a} oder eine Teilmenge
1438 dieser Menge zur@"uck.
1440 @code{set_partitions(@var{a}, @var{n})} gibt eine Menge aller Zerlegungen der
1441 Menge @var{a} in @var{n} nicht-leere voneinander disjunkte Teilmengen zur@"uck.
1443 @code{set_partitions(@var{a})} gibt die Menge aller Zerlegungen zur@"uck.
1445 @mref{stirling2} gibt die M@"achtigkeit einer Menge zur@"uck, die alle
1446 Zerlegungen einer Menge enth@"alt.
1448 Eine Menge mit Zerlegungen @math{P} ist eine Zerlegung der Menge @math{S}, wenn
1450 @enumerate
1451 @item
1452 jedes Elemente der Menge @math{P} eine nicht-leere Menge ist,
1453 @item
1454 verschiedene Elemente der Menge @math{P} voneinander disjunkt sind,
1455 @item
1456 die Vereinigung von Elementen der Menge @math{P} gleich der Menge @math{S} ist.
1457 @end enumerate
1459 Beispiele:
1461 Die leere Menge ist eine Zerlegung von sich selbst.
1463 @example
1464 (%i1) set_partitions (@{@});
1465 (%o1) @{@{@}@}
1466 @end example
1468 Die M@"achtigkeit der Menge der Zerlegungen einer Menge kann mit der Funktion
1469 @code{stirling2} ermittelt werden.
1471 @example
1472 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
1473 (%i2) p: set_partitions (s, 3)$
1474 (%i3) cardinality(p) = stirling2 (6, 3);
1475 (%o3) 90 = 90
1476 @end example
1478 Jedes Element der Menge @code{p} hat 3 Elemente.
1480 @example
1481 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
1482 (%i2) p: set_partitions (s, 3)$
1483 (%i3) map (cardinality, p);
1484 (%o3) @{3@}
1485 @end example
1487 F@"ur jedes Element der Menge @code{p}, ist die Vereinigung ihrer Elemente
1488 gleich der Menge @code{s}.
1490 @example
1491 (%i1) s: @{0, 1, 2, 3, 4, 5@}$
1492 (%i2) p: set_partitions (s, 3)$
1493 (%i3) map (lambda ([x], apply (union, listify (x))), p);
1494 (%o3) @{@{0, 1, 2, 3, 4, 5@}@}
1495 @end example
1496 @end deffn
1498 @c --- 09.05.20111 DK ----------------------------------------------------------
1499 @anchor{some}
1500 @deffn {Funktion} some (@var{f}, @var{a})
1501 @deffnx {Funktion} some (@var{f}, @var{L_1}, @dots{}, @var{L_n})
1503 Gibt das Ergebnis @code{true} zur@"uck, wenn die Aussage @var{f} das Ergebnis
1504 @code{true} f@"ur eines oder mehrere Argumente hat.
1506 Ist eine Menge @var{a} als Argument gegeben, gibt @code{some(@var{f}, @var{s})}
1507 das Ergebnis @code{true} zur@"uck, wenn @code{is(@var{f}(@var{a_i}))} das Ergebnis
1508 @code{true} f@"ur eines oder mehrere Elemente @var{a_i} der Menge @var{a} hat.
1509 @code{some} wertet @var{f} nicht notwendigerweise f@"ur alle Elemente @var{a_i}
1510 aus, wenn das Ergebnis bereits feststeht. Da Mengen nicht geordnet sind, kann
1511 die Funktion @code{some} die Ausdr@"ucke @code{@var{f}(@var{a_i})} in
1512 irgendeiner Reihenfolge auswerten.
1514 Sind die Argumente eine oder mehrere Listen, dann gibt
1515 @code{some(@var{f}, @var{L_1}, ..., @var{L_n})} den Wert @code{true} zur@"uck,
1516 wenn @code{is(@var{f}(@var{x_1}, ..., @var{x_n}))} das Ergebnis @code{true}
1517 f@"ur eines oder mehrere Elemente @var{x_1}, @dots{}, @var{x_n} der Listen
1518 @var{L_1}, @dots{}, @var{L_n} hat. @code{some} wertet @var{f} wird nicht
1519 notwendigerweise f@"ur alle Kombinationen @var{x_1}, @dots{}, @var{x_n} aus,
1520 wenn das Ergebnis bereits feststeht. @code{some} wertet die Listen in der
1521 Reihenfolge des steigenden Index aus.
1523 Ist die leere Menge @code{@{@}} oder die leere Liste @code{[]} unter den
1524 Argumenten, ist das Ergebnis immer @code{false}.
1526 Hat die Optionsvariable @mref{maperror} den Wert @code{true}, m@"ussen alle
1527 Listen @var{L_1}, @dots{}, @var{L_n} die gleiche L@"ange haben. Hat die
1528 Optionsvariable @code{maperror} den Wert @code{false}, werden Listen auf die
1529 L@"ange der k@"urzesten Liste abgeschnitten.
1531 Kann die Aussagefunktion @var{f} von der Funktion @code{is} nicht zu @code{true}
1532 oder @code{false} ausgewertet werden, h@"angt das Ergebnis von der
1533 Optionsvariablen @mref{prederror} ab. Hat die Optionsvariable @code{prederror}
1534 den Wert @code{true}, werden solche Werte als @code{false} behandelt. Hat
1535 @code{prederror} den Wert @code{false}, werden solche Werte als @code{unknown}
1536 behandelt.
1538 Beispiele:
1540 @code{some} f@"ur eine Menge als Argument. Die Aussage ist eine Funktion mit
1541 einem Argument.
1543 @example
1544 (%i1) some (integerp, @{1, 2, 3, 4, 5, 6@});
1545 (%o1) true
1546 (%i2) some (atom, @{1, 2, sin(3), 4, 5 + y, 6@});
1547 (%o2) true
1548 @end example
1550 @code{some} angewendet auf zwei Listen. Die Aussage ist eine Funktion mit
1551 zwei Argumenten.
1553 @example
1554 (%i1) some ("=", [a, b, c], [a, b, c]);
1555 (%o1) true
1556 (%i2) some ("#", [a, b, c], [a, b, c]);
1557 (%o2) false
1558 @end example
1560 Ergebnisse der Aussage @var{f}, die zu einem Ergebnis verschieden von
1561 @code{true} oder @code{false} auswerten, werden von der Optionsvariablen
1562 @code{prederror} kontrolliert.
1564 @example
1565 (%i1) prederror : false;
1566 (%o1) false
1567 (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
1568 [x^2, y^2, z^2]);
1569 (%o2) [unknown, unknown, unknown]
1570 (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
1571 (%o3) unknown
1572 (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
1573 (%o4) true
1574 (%i5) prederror : true;
1575 (%o5) true
1576 (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
1577 (%o6) false
1578 (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
1579 (%o7) true
1580 @end example
1581 @end deffn
1583 @c --- 09.05.2011 DK -----------------------------------------------------------
1584 @anchor{stirling1}
1585 @deffn {Funktion} stirling1 (@var{n}, @var{m})
1587 Berechnet Stirling-Zahlen der ersten Art.
1589 Sind die Argumente @var{n} und @var{m} nat@"urliche Zahlen, ist der Wert von
1590 @code{stirling1(@var{n}, @var{m})} die Anzahl der Permutationen einer Menge
1591 mit @var{n} Elementen, die @var{m} Zyklen hat. F@"ur Details siehe Graham,
1592 Knuth und Patashnik in @i{Conrecte Mathematics}. Maxima nutzt eine Rekursion,
1593 um @code{stirling1(@var{n}, @var{m})} f@"ur @var{m} kleiner als @code{0} zu
1594 berechnen. Die Funktion ist nicht definiert f@"ur @code{n} kleiner als @code{0}
1595 und f@"ur Argumente die keine ganze Zahlen sind.
1597 @code{stirling1} ist eine vereinfachende Funktion. Maxima kennt die folgenden
1598 Beziehungen (siehe [1]).
1600 @itemize
1601 @item
1602 @code{stirling1(0, n) = kron_delta(0, n)}
1603 @item
1604 @code{stirling1(n, n) = 1}
1605 @item
1606 @code{stirling1(n, n - 1) = binomial(n, 2)}
1607 @item
1608 @code{stirling1(n + 1, 0) = 0}
1609 @item
1610 @code{stirling1(n + 1, 1) = n!}
1611 @item
1612 @code{stirling1(n + 1, 2) = 2^n - 1}
1613 @end itemize
1615 Diese Beziehungen werden angewendet, wenn die Argumente ganze Zahlen oder
1616 Symbole sind, die als ganze Zahlen deklariert sind, und das erste Argument
1617 keine negative Zahl ist. @code{stirling1} vereinfacht nicht f@"ur Argumente,
1618 die keine ganzen Zahlen sind.
1620 Referenz:
1622 [1] Donald Knuth, @i{The Art of Computer Programming,}
1623 third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
1625 Beispiele:
1627 @example
1628 (%i1) declare (n, integer)$
1629 (%i2) assume (n >= 0)$
1630 (%i3) stirling1 (n, n);
1631 (%o3) 1
1632 @end example
1634 @code{stirling1} vereinfacht nicht f@"ur Argumente, die keine ganzen Zahlen
1635 sind.
1637 @example
1638 (%i1) stirling1 (sqrt(2), sqrt(2));
1639 (%o1) stirling1(sqrt(2), sqrt(2))
1640 @end example
1642 Maxima kennt Vereinfachungen der Funktion @code{stirling1}.
1644 @example
1645 (%i1) declare (n, integer)$
1646 (%i2) assume (n >= 0)$
1647 (%i3) stirling1 (n + 1, n);
1648 n (n + 1)
1649 (%o3) ---------
1650 2
1651 (%i4) stirling1 (n + 1, 1);
1652 (%o4) n!
1653 @end example
1654 @end deffn
1656 @c --- 09.05.2011 DK -----------------------------------------------------------
1657 @anchor{stirling2}
1658 @deffn {Funktion} stirling2 (@var{n}, @var{m})
1660 Berechnet Stirling-Zahlen der zweiten Art.
1662 Sind die Argumente @var{n} und @var{m} nat@"urliche Zahlen, ist der Wert von
1663 @code{stirling2(@var{n}, @var{m})} die Anzahl der M@"oglichkeiten, mit der eine
1664 Menge der M@"achtigkeit @var{n} in @var{m} disjunkte Mengen zerlegt werden kann.
1665 Maxima nutzt eine Rekursion, um @code{stirling2(@var{n}, @var{m})} f@"ur @var{m}
1666 kleiner als @code{0} zu berechnen. Die Funktion ist nicht definiert f@"ur
1667 @code{n} kleiner als @code{0} und f@"ur Argumente, die keine ganze Zahlen sind.
1669 @code{stirling2} ist eine vereinfachende Funktion. Maxima kennt die folgenden
1670 Beziehungen (siehe [1], [2], [3]).
1672 @itemize
1673 @item
1674 @code{stirling2(0, n) = kron_delta(0, n)}
1675 @item
1676 @code{stirling2(n, n) = 1}
1677 @item
1678 @code{stirling2(n, n - 1) = binomial(n, 2)}
1679 @item
1680 @code{stirling2(n + 1, 1) = 1}
1681 @item
1682 @code{stirling2(n + 1, 2) = 2^n - 1}
1683 @item
1684 @code{stirling2(n, 0) = kron_delta(n, 0)}
1685 @item
1686 @code{stirling2(n, m) = 0} f@"ur @code{m > n}
1687 @item
1688 @code{stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m!}, wenn
1689 @math{m} und @math{n} ganze Zahlen und @math{n} eine nat@"urliche Zahl ist.
1690 @end itemize
1692 Diese Beziehungen werden angewendet, wenn die Argumente ganze Zahlen oder
1693 Symbole sind, die als ganze Zahlen deklariert sind, und das erste Argument
1694 keine negative Zahl ist. @code{stirling2} vereinfacht nicht f@"ur Argumente,
1695 die keine ganzen Zahlen sind.
1697 Referenzen:
1699 [1] Donald Knuth. @i{The Art of Computer Programming},
1700 third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.
1702 [2] Graham, Knuth, and Patashnik. @i{Concrete Mathematics}, Table 264.
1704 [3] Abramowitz and Stegun. @i{Handbook of Mathematical Functions},
1705 Section 24.1.4.
1707 Beispiele:
1709 @example
1710 (%i1) declare (n, integer)$
1711 (%i2) assume (n >= 0)$
1712 (%i3) stirling2 (n, n);
1713 (%o3) 1
1714 @end example
1716 @code{stirling2} vereinfacht nicht, wenn die Argumente keine ganze Zahlen sind.
1718 @example
1719 (%i1) stirling2 (%pi, %pi);
1720 (%o1) stirling2(%pi, %pi)
1721 @end example
1723 Maxima kennt Vereinfachungen der Funktion @code{stirling2}.
1725 @example
1726 (%i1) declare (n, integer)$
1727 (%i2) assume (n >= 0)$
1728 (%i3) stirling2 (n + 9, n + 8);
1729 (n + 8) (n + 9)
1730 (%o3) ---------------
1731 2
1732 (%i4) stirling2 (n + 1, 2);
1733 n
1734 (%o4) 2 - 1
1735 @end example
1736 @end deffn
1738 @c --- 25.04.2011 DK -----------------------------------------------------------
1739 @anchor{subset}
1740 @deffn {Funktion} subset (@var{a}, @var{f})
1742 Gibt eine Teilmenge der Menge @var{a} zur@"uck, deren Elemente der Bedingung
1743 @var{f} gen@"ugen.
1745 @code{subset} gibt eine Menge zur@"uck, die alle Elemente der Menge @var{a}
1746 enth@"alt, die f@"ur die Bedingung @var{f} ein von @code{false} verschiedenes
1747 Ergebnis haben. @code{subset} wendet nicht die Funktion @code{is} auf das
1748 Ergebnis der Bedingung @code{f} an.
1750 @code{subset} gibt eine Fehlermeldung, wenn das Argument @var{a} keine Menge
1751 ist.
1753 Siehe auch die Funktion @mrefdot{partition_set}
1755 Beispiele:
1757 @example
1758 (%i1) subset (@{1, 2, x, x + y, z, x + y + z@}, atom);
1759 (%o1) @{1, 2, x, z@}
1760 (%i2) subset (@{1, 2, 7, 8, 9, 14@}, evenp);
1761 (%o2) @{2, 8, 14@}
1762 @end example
1763 @end deffn
1765 @c --- 25.04.2011 DK -----------------------------------------------------------
1766 @anchor{subsetp}
1767 @deffn {Funktion} subsetp (@var{a}, @var{b})
1769 Gibt das Ergebnis @code{true} zur@"uck, wenn die Menge @var{a} einer Teilmenge
1770 der Menge @var{b} ist.
1772 @code{subsetp} gibt eine Fehlermeldung, wenn eines der Argumente keine Menge
1773 ist.
1775 Beispiele:
1777 @example
1778 (%i1) subsetp (@{1, 2, 3@}, @{a, 1, b, 2, c, 3@});
1779 (%o1) true
1780 (%i2) subsetp (@{a, 1, b, 2, c, 3@}, @{1, 2, 3@});
1781 (%o2) false
1782 @end example
1783 @end deffn
1785 @c --- 25.04.2011 DK -----------------------------------------------------------
1786 @anchor{symmdifference}
1787 @deffn {Funktion} symmdifference (@var{a_1}, @dots{}, @var{a_n})
1789 Gibt die symmetrische Differenz der Mengen @code{@var{a_1}, ..., @var{a_n}}
1790 zur@"uck. F@"ur zwei Argumente ist die symmetrische Differenz @"aquivalent zu
1791 @code{union(setdifference(@var{a}, @var{b}), setdifference(@var{b}, @var{a}))}.
1793 @code{symmdifference} gibt eine Fehlermeldung, wenn eines der Argumente keine
1794 Menge ist.
1796 Beispiele:
1798 @example
1799 (%i1) S_1 : @{a, b, c@};
1800 (%o1) @{a, b, c@}
1801 (%i2) S_2 : @{1, b, c@};
1802 (%o2) @{1, b, c@}
1803 (%i3) S_3 : @{a, b, z@};
1804 (%o3) @{a, b, z@}
1805 (%i4) symmdifference ();
1806 (%o4) @{@}
1807 (%i5) symmdifference (S_1);
1808 (%o5) @{a, b, c@}
1809 (%i6) symmdifference (S_1, S_2);
1810 (%o6) @{1, a@}
1811 (%i7) symmdifference (S_1, S_2, S_3);
1812 (%o7) @{1, b, z@}
1813 (%i8) symmdifference (@{@}, S_1, S_2, S_3);
1814 (%o8) @{1,b, z@}
1815 @end example
1816 @end deffn
1818 @c --- 25.04.2011 DK -----------------------------------------------------------
1819 @anchor{tree_reduce}
1820 @deffn {Funktion} tree_reduce (@var{F}, @var{s})
1821 @deffnx {Funktion} tree_reduce (@var{F}, @var{s}, @var{s_0})
1823 Wendet eine Funktion @var{F}, die zwei Argumente hat, auf die Elemente einer
1824 Liste oder Menge @var{s} an, indem die Funktionsaufrufe verkettet werden.
1826 @code{tree_reduce} f@"uhrt folgende Operationen aus: Die Funktion @var{F} wird
1827 auf Paare von Elementen der Liste @var{s} angewendet, wodurch die neue Liste
1828 @code{[@var{F}(@var{s_1}, @var{s_2}), @var{F}(@var{s_3}, @var{s_4}), ...]}
1829 entsteht. Hat die Liste eine ungerade Anzahl an Elementen, bleibt das letzte
1830 Element unver@"andert. Dann wird das Verfahren solange wiederholt, bis nur noch
1831 ein einziges Element @"ubrig ist. Dieses wird als Ergebnis zur@"uckgegeben.
1833 Ist das optionale Argument @var{s_0} vorhanden, dann ist das Ergebnis
1834 @"aquivalent zu @code{tree_reduce(@var{F}, cons(@var{s_0}, @var{s})}.
1836 Werden Gleitkommazahlen addiert, dann kann @code{tree_reduce} ein Ergebnis
1837 mit einem kleineren Rundungsfehler als @mref{lreduce} oder @mref{rreduce}@w{}
1838 liefern.
1840 Siehe auch @mrefcomma{lreduce} @mref{rreduce} und @mrefdot{xreduce}
1842 Beispiele:
1844 @code{tree_reduce} angewendet auf eine Liste mit einer geraden Anzahl an
1845 Elementen.
1847 @example
1848 (%i1) tree_reduce (f, [a, b, c, d]);
1849 (%o1) f(f(a, b), f(c, d))
1850 @end example
1852 @code{tree_reduce} angewendet auf eine List mit einer ungeraden Anzahl an
1853 Elementen.
1855 @example
1856 (%i1) tree_reduce (f, [a, b, c, d, e]);
1857 (%o1) f(f(f(a, b), f(c, d)), e)
1858 @end example
1859 @end deffn
1861 @c --- 25.04.2011 DK -----------------------------------------------------------
1862 @anchor{union}
1863 @deffn {Funktion} union (@var{a_1}, @dots{}, @var{a_n})
1865 Gibt die Vereinigung der Mengen @var{a_1}, @dots{}, @var{a_n} zur@"uck. Wird
1866 @code{union} ohne ein Argument aufgerufen, wird die leere Menge zur@"uckgegeben.
1868 @code{union} gibt eine Fehlermeldung, wenn eines der Argumente keine Menge ist.
1870 Beispiele:
1872 @example
1873 (%i1) S_1 : @{a, b, c + d, %e@};
1874 (%o1) @{%e, a, b, d + c@}
1875 (%i2) S_2 : @{%pi, %i, %e, c + d@};
1876 (%o2) @{%e, %i, %pi, d + c@}
1877 (%i3) S_3 : @{17, 29, 1729, %pi, %i@};
1878 (%o3) @{17, 29, 1729, %i, %pi@}
1879 (%i4) union ();
1880 (%o4) @{@}
1881 (%i5) union (S_1);
1882 (%o5) @{%e, a, b, d + c@}
1883 (%i6) union (S_1, S_2);
1884 (%o6) @{%e, %i, %pi, a, b, d + c@}
1885 (%i7) union (S_1, S_2, S_3);
1886 (%o7) @{17, 29, 1729, %e, %i, %pi, a, b, d + c@}
1887 (%i8) union (@{@}, S_1, S_2, S_3);
1888 (%o8) @{17, 29, 1729, %e, %i, %pi, a, b, d + c@}
1889 @end example
1890 @end deffn
1892 @c --- 25.04.2011 DK -----------------------------------------------------------
1893 @anchor{xreduce}
1894 @deffn {Funktion} xreduce (@var{F}, @var{s})
1895 @deffnx {Funktion} xreduce (@var{F}, @var{s}, @var{s_0})
1897 Wendet eine Funktion @var{F}, die zwei Argumente hat, auf die Elemente einer
1898 Liste oder Menge @var{s} an, indem die Funktionsaufrufe verkettet werden. Ist
1899 die Funktion eine N-ary-Funktion wird die Funktion @var{F} auf die Liste
1900 angewendet. Ist die Funktion @var{F} keine N-ary_Funktion ist @code{xreduce}
1901 @"aquivalent zu @mrefdot{lreduce}
1903 Folgende N-ary-Funktionen und Operatoren kennt @code{xreduce}:
1904 Addition @code{"+"}, Multiplikation @code{"*"}, @code{and}, @code{or},
1905 @code{max}, @code{min} und @code{append}. Funktionen und Operatoren k@"onnen
1906 mit der Funktion @mref{declare} als @mref{nary} deklariert werden. F@"ur diese
1907 Funktionen ist @code{xreduce} schneller als @mref{lreduce} oder
1908 @mrefdot{rreduce}
1910 Ist das optionale Argument @var{s_0} vorhanden, dann ist das Ergebnis
1911 @"aquivalent zu @code{xreduce(@var{s}, cons(@var{s_0}, @var{s}))}.
1913 Siehe auch @mrefcomma{lreduce} @mref{rreduce} und @mrefdot{tree_reduce}
1915 Beispiele:
1917 @code{xreduce} angewendet mit einer N-ary-Funktion. @code{F} wird einmal mit
1918 allen Argumenten aufgerufen.
1920 @example
1921 (%i1) declare (F, nary);
1922 (%o1) done
1923 (%i2) F ([L]) := L;
1924 (%o2) F([L]) := L
1925 (%i3) xreduce (F, [a, b, c, d, e]);
1926 (%o3) [[[[[("[", simp), a], b], c], d], e]
1927 @end example
1929 @code{xreduce} angewendet mit einer Funktion, die nicht die Eigenschaft
1930 @code{nary} hat.
1932 @example
1933 (%i1) G ([L]) := L;
1934 (%o1) G([L]) := L
1935 (%i2) xreduce (G, [a, b, c, d, e]);
1936 (%o2) [[[[[("[", simp), a], b], c], d], e]
1937 (%i3) lreduce (G, [a, b, c, d, e]);
1938 (%o3) [[[[a, b], c], d], e]
1939 @end example
1940 @end deffn
1942 @c --- End of file Nset.de.texi ------------------------------------------------