doc/info/de/Database.de.texi

   1 @c -----------------------------------------------------------------------------
   2 @c File        : Database.de.texi
   3 @c License     : GNU General Public License (GPL)
   4 @c Language    : German
   5 @c Original    : Database.texi revision 15.06.2011
   6 @c Translation : Dr. Dieter Kaiser
   7 @c Date        : 22.10.2010
   8 @c Revision    : 20.08.2011
   9 @c
  10 @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA
  11 @c -----------------------------------------------------------------------------
  12
  13 @menu
  14 * Einf@"uhrung in Maximas Datenbank::
  15 * Funktionen und Variablen f@"ur Eigenschaften::
  16 * Funktionen und Variablen f@"ur Fakten::
  17 * Funktionen und Variablen f@"ur Aussagen::
  18 @end menu
  19
  20 @c -----------------------------------------------------------------------------
  21 @node Einf@"uhrung in Maximas Datenbank, Funktionen und Variablen f@"ur Eigenschaften, Maximas Datenbank, Maximas Datenbank
  22 @section Einf@"uhrung in Maximas Datenbank
  23 @c -----------------------------------------------------------------------------
  24
  25 @subheading Eigenschaften
  26
  27 Variablen und Funktionen k@"onnen mit der Funktion @mref{declare} Eigenschaften
  28 zugewiesen werden.  Diese Eigenschaften werden in eine Datenbank abgelegt oder
  29 in eine von Lisp bereitgestellte Eigenschaftsliste eingetragen.  Mit der
  30 Funktion @mref{featurep} kann gepr@"uft werden, ob ein Symbol eine bestimmte
  31 Eigenschaft hat und mit der Funktion @mref{properties} k@"onnen alle
  32 Eigenschaften eines Symbols angezeigt werden.  Die Funktion @mref{remove}@w{}
  33 l@"oscht Eigenschaften aus der Datenbank oder von der Eigenschaftsliste.  Wird
  34 mit der Funktion @mref{kill} ein Symbol entfernt, werden auch die zugewiesenen
  35 Eigenschaften gel@"oscht.
  36
  37 Weiterhin k@"onnen mit den Funktionen @mref{put} und @mref{qput} beliebige
  38 vom Nutzer vorgesehene Eigenschaften in die Eigenschaftsliste zu einem Symbol
  39 abgelegt werden.  Mit der Funktion @mref{get} werden die Eigenschaften von
  40 der Eigenschaftsliste gelesen und mit der Funktion @mref{rem} gel@"oscht.
  41
  42 Variablen k@"onnen die folgenden Eigenschaften erhalten, die in die Datenbank
  43 eingetragen werden.
  44
  45 @verbatim
  46    constant
  47    integer        noninteger
  48    even           odd
  49    rational       irrational
  50    real           imaginary      complex
  51 @end verbatim
  52
  53 Funktionen k@"onnen die folgenden Eigenschaften erhalten, die in die Datenbank
  54 eingetragen werden.
  55
  56 @verbatim
  57    increasing     decreasing
  58    posfun         integervalued
  59 @end verbatim
  60
  61 Die folgenden Eigenschaften k@"onnen f@"ur Funktionen definiert werden und
  62 wirken sich auf die Vereinfachung dieser Funktionen aus.  Diese Eigenschaften
  63 werden in @ref{Vereinfachung} beschrieben.
  64
  65 @verbatim
  66    linear         additive       multiplicative
  67    outative       commutative    symmetric
  68    antisymmetric  nary           lassociativ
  69    rassociative   evenfun        oddfun
  70 @end verbatim
  71
  72 Weitere Eigenschaften, die Variablen und Funktionen erhalten k@"onnen, und
  73 die in die Lisp-Eigenschaftsliste des Symbols abgelegt werden, sind.
  74
  75 @verbatim
  76    bindtest       feature        alphabetic
  77    scalar         nonscalar      nonarray
  78 @end verbatim
  79
  80 @subheading Kontexte
  81
  82 Maxima verwaltet Kontexte, um Eigenschaften von Variablen und Funktionen sowie
  83 Fakten abzulegen.  Fakten werden mit der Funktion @mref{assume} definiert und
  84 in dem aktuellen Kontext abgelegt.  Mit @code{assume(a>10)} erh@"alt Maxima zum
  85 Beispiel die Information, dass die Variable @code{a} gr@"o@ss{}er als @code{10}
  86 ist.  Mit der Funktion @mref{forget} werden Fakten aus der Datenbank entfernt.
  87 Fragt Maxima den Nutzer nach Eigenschaften von Variablen, werden die Antworten
  88 in einem Kontext abgelegt.
  89
  90 Ein Kontext hat einen Namen, mit dem auf diesen Bezug genommen werden kann.
  91 Nach dem Starten von Maxima hat der aktuelle Kontext den Namen @code{initial}.
  92 Es kann eine beliebige Anzahl weiterer Kontexte definiert werden.  Diese
  93 k@"onnen hierarchisch voneinander abh@"angen.  So ist der Kontext @code{initial}
  94 ein Unterkontext zum Kontext @code{global}.  Die Fakten in einem
  95 @"ubergeordneten Kontext sind in dem Unterkontext immer pr@"asent.  Der Kontext
  96 @code{global} enth@"alt zum Beispiel Fakten, die von Maxima initialisiert
  97 werden, und zus@"atzlich zu den Fakten des Kontextes @code{initial} aktiv sind.
  98
  99 Kontexte k@"onnen eine beliege Anzahl an Fakten aufnehmen.  Sie k@"onnen mit der
 100 Funktion @mref{deactivate} deaktiviert werden, ohne dass die Fakten verloren
 101 gehen und sp@"ater mit der Funktion @mref{activate} aktiviert werden, wodurch
 102 die Fakten f@"ur Aussagefunktionen wieder zur Verf@"ugung stehen.
 103
 104 @c -----------------------------------------------------------------------------
 105 @node Funktionen und Variablen f@"ur Eigenschaften, Funktionen und Variablen f@"ur Fakten, Einf@"uhrung in Maximas Datenbank, Maximas Datenbank
 106 @section Funktionen und Variablen f@"ur Eigenschaften
 107 @c -----------------------------------------------------------------------------
 108
 109 @c --- 22.10.2010 DK -----------------------------------------------------------
 110 @anchor{alphabetic}
 111 @defvr {Eigenschaft} alphabetic
 112
 113 Das Kommando @code{declare(string, alphabetic)} deklariert die Zeichen der
 114 Zeichenkette @var{string} als alphabetisch.  Das Argument @var{string} muss eine
 115 Zeichenkette sein.  Zeichen, die als alphabetisch deklariert sind, k@"onnen in
 116 Maxima-Bezeichnern verwendet werden.  Siehe auch @ref{Bezeichner}.
 117
 118 Beispiele:
 119
 120 Die Zeichen @code{"~"}, @code{"@@"} und @code{`} als alphabetisch erkl@"art.
 121
 122 @example
 123 (%i1) xx\~yy\`\@@ : 1729;
 124 (%o1)                         1729
 125 (%i2) declare ("~`@@", alphabetic);
 126 (%o2)                         done
 127 (%i3) xx~yy`@@ + @@yy`xx + `xx@@@@yy~;
 128 (%o3)               `xx@@@@yy~ + @@yy`xx + 1729
 129 (%i4) listofvars (%);
 130 (%o4)                  [@@yy`xx, `xx@@@@yy~]
 131 @end example
 132 @end defvr
 133
 134 @c --- 22.10.2010 DK -----------------------------------------------------------
 135 @anchor{bindtest}
 136 @defvr {Eigenschaft} bindtest
 137
 138 Hat ein Symbol @var{x} die Eigenschaft @code{bindtest} und wird es ausgewertet,
 139 ohne das dem Symbol bisher ein Wert zugewiesen wurde, signalisiert Maxima einen
 140 Fehler.  Siehe auch die Funktion @mrefdot{declare}
 141
 142 Beispiel:
 143
 144 @example
 145 (%i1) aa + bb;
 146 (%o1)                        bb + aa
 147 (%i2) declare (aa, bindtest);
 148 (%o2)                         done
 149 (%i3) aa + bb;
 150 aa unbound variable
 151  -- an error.  Quitting.  To debug this try debugmode(true);
 152 (%i4) aa : 1234;
 153 (%o4)                         1234
 154 (%i5) aa + bb;
 155 (%o5)                       bb + 1234
 156 @end example
 157 @end defvr
 158
 159 @c --- 22.10.2010 DK -----------------------------------------------------------
 160 @anchor{constant}
 161 @defvr {Eigenschaft} constant
 162
 163 Das Kommando @code{declare(@var{a}, constant)} deklariert ein Symbol @var{a}
 164 als konstant.  Die Funktion @mref{constantp} hat f@"ur dieses Symbol dann das
 165 Ergebnis @code{true}.  Die Deklaration als eine Konstante verhindert nicht, dass
 166 dem Symbol ein Wert zugewiesen werden kann.  Siehe @mref{declare} und
 167 @mrefdot{constantp}
 168
 169 Beispiel:
 170
 171 @example
 172 (%i1) declare(c, constant);
 173 (%o1)                         done
 174 (%i2) constantp(c);
 175 (%o2)                         true
 176 (%i3) c : x;
 177 (%o3)                           x
 178 (%i4) constantp(c);
 179 (%o4)                         false
 180 @end example
 181 @end defvr
 182
 183 @c --- 22.10.2010 DK -----------------------------------------------------------
 184 @anchor{constantp}
 185 @deffn {Funktion} constantp (@var{expr})
 186
 187 Gibt f@"ur einen konstanten Ausdruck @var{expr} den Wert @code{true} zur@"uck,
 188 andernfalls @code{false}.
 189
 190 Ein Ausdruck wird von Maxima als ein konstanter Ausdruck erkannt, wenn seine
 191 Argumente Zahlen sind (einschlie@ss{}lich von Zahlen in einer CRE-Darstellung),
 192 symbolische Konstanten wie @code{%pi}, @code{%e} und @code{%i},
 193 Variablen, die einen konstanten Wert haben, Variablen, die mit
 194 @code{declare} als konstant deklariert sind, oder Funktionen, deren Argumente
 195 konstant sind.
 196
 197 Die Funktion @code{constantp} wertet das Argument aus.
 198
 199 Siehe auch die Eigenschaft @mrefdot{constant}
 200
 201 Beispiele:
 202
 203 @example
 204 (%i1) constantp (7 * sin(2));
 205 (%o1)                                true
 206 (%i2) constantp (rat (17/29));
 207 (%o2)                                true
 208 (%i3) constantp (%pi * sin(%e));
 209 (%o3)                                true
 210 (%i4) constantp (exp (x));
 211 (%o4)                                false
 212 (%i5) declare (x, constant);
 213 (%o5)                                done
 214 (%i6) constantp (exp (x));
 215 (%o6)                                true
 216 (%i7) constantp (foo (x) + bar (%e) + baz (2));
 217 (%o7)                                false
 218 (%i8)
 219 @end example
 220 @end deffn
 221
 222 @c --- 22.10.2010 DK -----------------------------------------------------------
 223 @anchor{declare}
 224 @deffn {Funktion} declare (@var{a_1}, @var{p_1}, @var{a_2}, @var{p_2}, @dots{})
 225
 226 Weist dem Symbol @var{a_i} die Eigenschaft @var{p_i} zu.  Die Argumente
 227 @var{a_i} und @var{p_i} k@"onnen Listen sein.  Ist @var{a_i} eine Liste, dann
 228 erh@"alt jedes Symbol der Liste die Eigenschaft @var{p_i}.  Ist umgekehrt
 229 @var{p_i} eine Liste mit Eigenschaften, dann erh@"alt das Symbol @var{a_i}
 230 diese Eigenschaften.  Entsprechend erhalten alle Symbole einer Liste @var{a_i}
 231 die Eigenschaften einer Liste @var{p_i}.
 232
 233 Die Funktion @code{declare} wertet die Argumente nicht aus.  @code{declare} gibt
 234 stets @code{done} als Ergebnis zur@"uck.
 235
 236 Hat ein Symbol @var{sym} die Eigenschaft @var{prop} mit der Funktion
 237 @code{declare} erhalten, dann hat das Kommando @code{featurep(@var{sym},
 238 @var{prop})} das Ergebnis @code{true}.  Mit der Funktion @code{properties}
 239 k@"onnen alle Eigenschaften eines Symbols angezeigt werden.
 240
 241 Mit der Funktion @code{declare} k@"onnen Symbole die folgenden Eigenschaften
 242 erhalten:
 243
 244 @table @code
 245 @item additive
 246 Hat eine Funktion @code{f} die Eigenschaft @code{additive}, wird ein Ausdruck
 247 der Form @code{f(x + y + z + ...)} zu @code{f(x) + f(y) + f(z) + ...}
 248 vereinfacht.  Siehe @mrefdot{additive}
 249
 250 @item alphabetic
 251 @var{a_i} ist eine Zeichenkette, deren Zeichen als alphabetische Zeichen
 252 deklariert werden.  Die Zeichen k@"onnen dann in Maxima-Bezeichnern verwendet
 253 werden.  Siehe @mref{alphabetic} f@"ur Beispiele.
 254
 255 @item antisymmetric, commutative, symmetric
 256 @var{a_i} wird als eine symmetrische, antisymmetrische oder kommutative Funktion
 257 interpretiert.  Die Eigenschaften @code{commutative} und @code{symmetric} sind
 258 @"aquivalent.  Siehe @mrefcomma{antisymmetric} @mref{commutative} und
 259 @mrefdot{symmetric}
 260
 261 @item bindtest
 262 Hat ein Symbol die Eigenschaft @code{bindtest} und wird es ausgewertet, ohne
 263 das dem Symbol bisher ein Wert zugewiesen wurde, signalisiert Maxima einen
 264 Fehler.  Siehe @mref{bindtest} f@"ur Beispiele.
 265
 266 @item constant
 267 Hat ein Symbol die Eigenschaft @code{constant}, wird es von Maxima als eine
 268 Konstante interpretiert.  Siehe auch @mrefdot{constant}
 269
 270 @item even, odd
 271 Erh@"alt eine Variable die Eigenschaft @code{even} oder @code{odd}, wird sie als
 272 gerade oder ungerade interpretiert.
 273
 274 @item evenfun, oddfun
 275 Erh@"alt eine Funktion oder ein Operator die Eigenschaft @code{evenfun} oder
 276 @code{oddfun} wird die Funktion oder der Operator von Maxima als gerade und
 277 ungerade interpretiert.  Diese Eigenschaft wird bei der Vereinfachung von
 278 Ausdr@"ucken von Maxima angewendet.  Siehe @mref{evenfun} und @mrefdot{oddfun}
 279
 280 @item evflag
 281 Deklariert die Variable @code{a_i} als einen Auswertungsschalter.  W@"ahrend der
 282 Auswertung eines Ausdrucks mit der Funktion @code{ev}, erh@"alt der
 283 Auswertungsschalter @code{a_i} den Wert @code{true}.  Siehe @mref{evflag} f@"ur
 284 Beispiele.
 285
 286 @item evfun
 287 Deklariert eine Funktion @var{a_i} als eine Auswertungsfunktion.  Tritt die
 288 Funktion @var{a_i} als Argument der Funktion @code{ev} auf, so wird die Funktion
 289 auf den Ausdruck angewendet.  Siehe @mref{evfun} f@"ur Beispiele.
 290
 291 @item feature
 292 @var{a_i} wird als eine Eigenschaft @code{feature} interpretiert.  Andere
 293 Symbole k@"onnen dann diese vom Nutzer definierte Eigenschaft erhalten.
 294 Siehe @mrefdot{feature}
 295
 296 @item increasing, decreasing
 297 Erh@"alt eine Funktion die Eigenschaft @code{decreasing} oder @code{increasing},
 298 wird die Funktion als eine monoton steigende oder fallende Funktion
 299 interpretiert.  Siehe @mref{decreasing} und @mrefdot{increasing}
 300
 301 @item integer, noninteger
 302 @var{a_i} wird als eine ganzzahlige oder nicht-ganzzahlige Variable
 303 interpretiert.  Siehe @mref{integer} und @mrefdot{noninteger}
 304
 305 @item integervalued
 306 Erh@"alt eine Funktion die Eigenschaft @code{integervalued}, nimmt Maxima f@"ur
 307 Vereinfachungen an, dass die Funktionen einen ganzzahligen Wertebereich hat.
 308 F@"ur ein Beispiel siehe @mrefdot{integervalued}
 309
 310 @item lassociative, rassociative
 311 @var{a_i} wird als eine rechts- oder links-assoziative Funktion interpretiert.
 312 Siehe @mref{lassociative} und @mrefdot{rassociative}
 313
 314 @item linear
 315 Entspricht der Deklaration einer Funktion als @code{outative} und
 316 @code{additive}.  Siehe auch @mrefdot{linear}
 317
 318 @item mainvar
 319 Wird eine Variable als @var{mainvar} deklariert, wird sie als eine
 320 "Hauptvariable" interpretiert.  Eine Hauptvariable wird vor allen Konstanten und
 321 Variablen in einer kanonischen Ordnung eines Maxima-Ausdr@"uckes angeordnet.
 322 Die Anordnung wird durch die Funktion @code{ordergreatp} bestimmt.  Siehe auch
 323 @mrefdot{mainvar}
 324
 325 @item multiplicative
 326 Hat eine Funktion @code{f} die Eigenschaft @code{multiplicative}, werden
 327 Ausdr@"ucke der Form @code{@var{a_i}(x * y * z * ...)} zu
 328 @code{@var{a_i}(x) * @var{a_i}(y) * @var{a_i}(z) * ...} vereinfacht.  Die
 329 Vereinfachung wird nur f@"ur das erste Argument der Funktion @var{f}
 330 ausgef@"uhrt.  Siehe @mrefdot{multiplicative}
 331
 332 @item nary
 333 Erh@"alt eine Funktion oder ein Operator die Eigenschaft @code{nary}, wird die
 334 Funktion oder der Operator bei der Vereinfachung als Nary-Funktion oder
 335 Nary-Operator interpretiert.  Verschachtelte Ausdr@"ucke wie
 336 @code{foo(x, foo(y, z))} werden zum Beispiel zu @code{foo(x, y, z)} vereinfacht.
 337 Die Deklaration @code{nary} unterscheidet sich von der Funktion @code{nary}.
 338 W@"ahrend der Funktionsaufruf einen neuen Operator definiert, wirkt sich die
 339 Deklaration nur auf die Vereinfachung aus.  Siehe auch
 340 @mxrefdot{property_nary, nary}
 341
 342 @item nonarray
 343 Hat ein Symbol @var{a_i} die Eigenschaft @code{nonarray}, wird es nicht als ein
 344 Array interpretiert, wenn das Symbol einen Index erh@"alt.  Diese Deklaration
 345 verhindert die mehrfache Auswertung, wenn @var{a_i} als indizierte Variable
 346 genutzt wird.  Siehe  @mrefdot{nonarray}
 347
 348 @item nonscalar
 349 @var{a_i} wird als eine nicht-skalare Variable interpretiert.  Ein Symbol wird
 350 also als ein Vektor oder eine Matrix deklariert.  Siehe @mrefdot{nonscalar}
 351
 352 @item noun
 353 @var{a_i} wird als Substantivform interpretiert.  Abh@"angig vom Kontext wird
 354 @var{a_i} durch @code{'@var{a_i}} oder @code{nounify(@var{a_i})} ersetzt.
 355 Siehe auch @mrefdot{noun} f@"ur ein Beispiel.
 356
 357 @item outative
 358 Ausdr@"ucke mit der Funktion @var{a_i} werden so vereinfacht, dass konstante
 359 Faktoren aus dem Argument herausgezogen werden.  Hat die Funktion @var{a_i} ein
 360 Argument, wird ein Faktor dann als konstant angesehen, wenn er ein Symbol oder
 361 eine deklarierte Konstante ist.  Hat die Funktion @var{a_i} zwei oder mehr
 362 Argumente, wird ein Faktor dann als konstant angesehen, wenn das zweite Argument
 363 ein Symbol und der Faktor unabh@"angig vom zweiten Argument ist.  Siehe auch
 364 @mrefdot{outative}
 365
 366 @item posfun
 367 @var{a_i} wird als eine Funktion interpretiert, die nur positive Werte hat.
 368 Siehe @mrefdot{posfun}
 369
 370 @item rational, irrational
 371 @var{a_i} wird als eine rationale oder irrationale Zahl interpretiert.  Siehe
 372 @mref{rational} und @mrefdot{irrational}
 373
 374 @item real, imaginary, complex
 375 @var{a_i} wird als eine reelle, imagin@"are oder komplexe Zahl interpretiert.
 376 Siehe @mrefcomma{real} @mref{imaginary} und @mrefdot{complex}
 377
 378 @item scalar
 379 @var{a_i} wird als skalare Variable interpretiert.  Siehe @mrefdot{scalar}
 380 @end table
 381 @end deffn
 382
 383 @c --- 06.02.2011 DK -----------------------------------------------------------
 384 @anchor{decreasing}
 385 @anchor{increasing}
 386 @defvr  {Eigenschaft} decreasing
 387 @defvrx {Eigenschaft} increasing
 388
 389 Erh@"alt eine Funktion mit der Funktion @mref{declare} die Eigenschaft
 390 @code{decreasing} oder @code{increasing} wird die Funktion als eine steigende
 391 oder fallende Funktion interpretiert.
 392
 393 Beispiel:
 394
 395 @example
 396 (%i1) assume(a > b);
 397 (%o1)                        [a > b]
 398 (%i2) is(f(a) > f(b));
 399 (%o2)                        unknown
 400 (%i3) declare(f, increasing);
 401 (%o3)                         done
 402 (%i4) is(f(a) > f(b));
 403 (%o4)                         true
 404 @end example
 405 @end defvr
 406
 407 @c --- 06.02.2011 DK -----------------------------------------------------------
 408 @anchor{even}
 409 @anchor{odd}
 410 @defvr  {Eigenschaften} even
 411 @defvrx {Eigenschaften} odd
 412
 413 Hat eine Variable mit der Funktion @mref{declare} die Eigenschaft @code{even}
 414 oder @code{odd} erhalten, wird sie von Maxima als gerade oder ungerade
 415 ganze Zahl interpretiert.  Diese Eigenschaften werden jedoch nicht von den
 416 Funktionen @mrefcomma{evenp} @mref{oddp} oder @mref{integerp} erkannt.
 417
 418 Siehe auch die Funktion @mrefdot{askinteger}
 419
 420 Beispiele:
 421
 422 @example
 423 (%i1) declare(n, even);
 424 (%o1)                         done
 425 (%i2) askinteger(n, even);
 426 (%o2)                          yes
 427 (%i3) askinteger(n);
 428 (%o3)                          yes
 429 (%i4) evenp(n);
 430 (%o4)                         false
 431 @end example
 432 @end defvr
 433
 434 @c --- 22.10.2010 DK -----------------------------------------------------------
 435 @anchor{feature}
 436 @defvr {Eigenschaft} feature
 437
 438 @code{feature} ist eine Eigenschaft, die ein Symbol @var{sym} mit der Funktion
 439 @code{declare} erhalten kann.  In diesem Fall ist das Symbol @var{sym} selbst
 440 eine Eigenschaft, so dass das Kommando @code{declare(x, sym)} einem Symbol
 441 @var{x} die vom Nutzer definierte Eigenschaft @code{sym} gibt.
 442
 443 Maxima unterscheidet Systemeigenschaften und mathematische Eigenschaften, die
 444 Symbole und Ausdr@"ucke haben k@"onnen.  F@"ur Systemeigenschaften siehe die
 445 Funktion @mrefdot{status}  F@"ur mathematische Eigenschaften siehe die
 446 Funktionen @mref{declare} und @mrefdot{featurep}
 447
 448 Beispiel:
 449
 450 @example
 451 (%i1) declare (FOO, feature);
 452 (%o1)                         done
 453 (%i2) declare (x, FOO);
 454 (%o2)                         done
 455 (%i3) featurep (x, FOO);
 456 (%o3)                         true
 457 @end example
 458 @end defvr
 459
 460 @c --- 22.10.2010 DK -----------------------------------------------------------
 461 @anchor{featurep}
 462 @deffn {Funktion} featurep (@var{a}, @var{p})
 463
 464 Stellt fest, ob das Symbol oder der Ausdruck @var{a} die Eigenschaft @var{p}
 465 hat.  Maxima nutzt die Fakten der aktiven Kontexte und die definierten
 466 Eigenschaften f@"ur Symbole und Funktionen.
 467
 468 @code{featurep} gibt sowohl f@"ur den Fall @code{false} zur@"uck, dass das
 469 Argument @var{a} nicht die Eigenschaft @var{p} hat, als auch f@"ur den Fall,
 470 dass Maxima dies nicht anhand der bekannten Fakten und Eigenschaften entscheiden
 471 kann.
 472
 473 @code{featurep} wertet die Argumente aus.
 474
 475 Siehe auch @mref{declare} und @mrefdot{featurep}.
 476
 477 Beispiele:
 478
 479 @example
 480 (%i1) declare (j, even)$
 481 (%i2) featurep (j, integer);
 482 (%o2)                           true
 483 @end example
 484 @end deffn
 485
 486 @c --- 22.10.2010 DK -----------------------------------------------------------
 487 @anchor{features}
 488 @defvr {Systemvariable} features
 489
 490 Maxima kennt spezielle mathematische Eigenschaften von Funktionen und
 491 Variablen.
 492
 493 @code{declare(@var{x})}, @var{foo} gibt der Funktion oder Variablen @var{x} die
 494 Eigenschaft @var{foo}.
 495
 496 @code{declare(@var{foo}, feature)} deklariert die neue Eigenschaft @var{foo}.
 497 Zum  Beispiel deklariert @code{declare([red, green, blue], feature)} die drei
 498 neuen Eigenschaften @code{red}, @code{green} und @code{blue}.
 499
 500 @code{featurep(@var{x}, @var{foo})} hat die R@"uckgabe @code{true}, wenn @var{x}
 501 die Eigenschaft @var{foo} hat.  Ansonsten wird @code{false} zur@"uckgegeben.
 502
 503 Die Informationsliste @code{features} enth@"alt eine Liste der Eigenschaften,
 504 die Funktionen und Variablen erhalten k@"onnen und die in die Datenbank
 505 eingetragen werden:
 506
 507 @verbatim
 508    integer         noninteger       even
 509    odd             rational         irrational
 510    real            imaginary        complex
 511    analytic        increasing       decreasing
 512    oddfun          evenfun          posfun
 513    commutative     lassociative     rassociative
 514    symmetric       antisymmetric
 515 @end verbatim
 516
 517 Hinzu kommen die vom Nutzer definierten Eigenschaften.
 518
 519 @code{features} ist eine Liste der mathematischen Eigenschaften.  Es gibt
 520 weitere Eigenschaften.  Siehe @mref{declare} und @mrefdot{status}
 521 @end defvr
 522
 523 @c --- 16.11.2010 DK -----------------------------------------------------------
 524 @anchor{get}
 525 @deffn {Funktion} get (@var{a}, @var{i})
 526
 527 Gibt die Eigenschaft @var{i} des Symbols @var{a} zur@"uck.  Hat das Symbol
 528 @var{a} nicht die Eigenschaft @var{i}, wird @code{false} zur@"uckgegeben.
 529
 530 @code{get} wertet die Argumente aus.
 531
 532 Beispiele:
 533
 534 @example
 535 (%i1) put (%e, 'transcendental, 'type);
 536 (%o1)                    transcendental
 537 (%i2) put (%pi, 'transcendental, 'type)$
 538 (%i3) put (%i, 'algebraic, 'type)$
 539 (%i4) typeof (expr) := block ([q],
 540         if numberp (expr)
 541         then return ('algebraic),
 542         if not atom (expr)
 543         then return (maplist ('typeof, expr)),
 544         q: get (expr, 'type),
 545         if q=false
 546         then errcatch (error(expr,"is not numeric.")) else q)$
 547 (%i5) typeof (2*%e + x*%pi);
 548 x is not numeric.
 549 (%o5)  [[transcendental, []], [algebraic, transcendental]]
 550 (%i6) typeof (2*%e + %pi);
 551 (%o6)     [transcendental, [algebraic, transcendental]]
 552 @end example
 553 @end deffn
 554
 555 @c --- 06.02.2011 DK -----------------------------------------------------------
 556 @anchor{integer}
 557 @anchor{noninteger}
 558 @defvr  {Eigenschaften} integer
 559 @defvrx {Eigenschaften} noninteger
 560
 561 Hat eine Variable mit der Funktion @mref{declare} die Eigenschaft @code{integer}
 562 oder @code{noninteger} erhalten, wird sie von Maxima als eine ganze Zahl oder
 563 als nicht-ganze Zahl interpretiert.  Siehe auch @mrefdot{askinteger}
 564
 565 Beispiele:
 566
 567 @example
 568 (%i1) declare(n, integer, x, noninteger);
 569 (%o1)                         done
 570 (%i2) askinteger(n);
 571 (%o2)                          yes
 572 (%i3) askinteger(x);
 573 (%o3)                          no
 574 @end example
 575 @end defvr
 576
 577 @c --- 06.02.2011 DK -----------------------------------------------------------
 578 @anchor{integervalued}
 579 @defvr {Eigenschaft} integervalued
 580
 581 Erh@"alt eine Funktion mit @mref{declare} die Eigenschaft @code{integervalued},
 582 nimmt Maxima f@"ur Vereinfachungen an, dass der Wertebereich der Funktion
 583 ganzzahlig ist.
 584
 585 Beispiel:
 586
 587 @example
 588 (%i1) exp(%i)^f(x);
 589                               %i f(x)
 590 (%o1)                      (%e  )
 591 (%i2) declare(f, integervalued);
 592 (%o2)                         done
 593 (%i3) exp(%i)^f(x);
 594                               %i f(x)
 595 (%o3)                       %e
 596 @end example
 597 @end defvr
 598
 599 @c --- 22.11.2010 DK -----------------------------------------------------------
 600 @anchor{nonarray}
 601 @deffn {Eigenschaft} nonarray
 602
 603 @code{declare(a, nonarray)} gibt dem Symbol @var{a} die Eigenschaft nicht ein
 604 Array zu sein.  Dies verhindert die mehrfache Auswertung, wenn das Symbol
 605 @var{a} als indizierte Variable genutzt wird.
 606
 607 Beispiel:
 608
 609 @example
 610 (%i1) a:'b$ b:'c$ c:'d$
 611
 612 (%i4) a[x];
 613 (%o4)                          d
 614                                 x
 615 (%i5) declare(a, nonarray);
 616 (%o5)                         done
 617 (%i6) a[x];
 618 (%o6)                          a
 619                                 x
 620 @end example
 621 @end deffn
 622
 623 @c --- 22.10.2010 DK -----------------------------------------------------------
 624 @anchor{nonscalar}
 625 @defvr {Eigenschaft} nonscalar
 626
 627 Hat ein Symbol die Eigenschaft @code{nonscalar}, verh@"alt es sich wie eine
 628 Matrix oder Liste bei nicht-kommutativen Rechenoperationen.
 629 @end defvr
 630
 631 @c --- 22.10.2010 DK -----------------------------------------------------------
 632 @anchor{nonscalarp}
 633 @deffn {Funktion} nonscalarp (@var{expr})
 634
 635 Gibt @code{true} zur@"uck, wenn der Ausdruck @var{expr} kein Skalar ist.  Der
 636 Ausdruck enth@"alt dann Matrizen, Listen oder Symbole, die als @code{nonscalar}
 637 deklariert wurden.
 638 @end deffn
 639
 640 @c --- 22.10.2010 DK -----------------------------------------------------------
 641 @anchor{posfun}
 642 @defvr {Eigenschaft} posfun
 643
 644 @code{declare(f, posfun)} deklariert die Funktion @code{f} als eine Funktion,
 645 die nur positive Werte annimmt.  @code{is(f(x) > 0)} gibt dann @code{true}
 646 zur@"uck.
 647 @end defvr
 648
 649 @c --- 27.05.2011 DK -----------------------------------------------------------
 650 @anchor{printprops}
 651 @deffn  {Funktion} printprops (@var{a}, @var{i})
 652 @deffnx {Funktion} printprops ([@var{a_1}, @dots{}, @var{a_n}], @var{i})
 653 @deffnx {Funktion} printprops (all, @var{i})
 654
 655 Zeigt die zum Kennzeichen @var{i} zugeordnete Eigenschaft des Atoms @var{a} an.
 656 @var{i} kann einer der Werte @code{gradef}, @code{atvalue}, @code{atomgrad} oder
 657 @code{matchdeclare} sein.  @var{a} kann sowohl eine Liste von Atomen, als auch
 658 das Atom @code{all} sein.  In diesem Fall werden alle Atome angezeigt, die eine
 659 Eigenschaft zum Kennzeichen @var{i} haben.
 660
 661 Beispiel:
 662
 663 @example
 664 (%i1) gradef(f(x), 2*g(x));
 665 (%o1)                         f(x)
 666 (%i2) printprops(f,gradef);
 667                        d
 668                        -- (f(x)) = 2 g(x)
 669                        dx
 670
 671 (%o2)                         done
 672 @end example
 673 @end deffn
 674
 675 @c --- 20.08.2011 DK -----------------------------------------------------------
 676 @anchor{properties}
 677 @deffn {Funktion} properties (@var{a})
 678
 679 Gibt eine Liste mit den Eigenschaften zur@"uck, die das Symbol @var{a} von
 680 Maxima oder dem Nutzer erhalten hat.  Die R@"uckgabe kann jede Eigenschaft
 681 enthalten, die mit der Funktion @mref{declare} einem Symbol zugewiesen ist.
 682 Diese Eigenschaften sind:
 683
 684 @verbatim
 685    linear         additive       multiplicative
 686    outative       commutative    symmetric
 687    antisymmetric  nary           lassociativ
 688    rassociative   evenfun        oddfun
 689    bindtest       feature        alphabetic
 690    scalar         nonscalar      nonarray
 691    constant       integer        noninteger
 692    even           odd            rational
 693    irrational     real           imaginary
 694    complex        increasing     decreasing
 695    posfun         integervalued
 696 @end verbatim
 697
 698 Die folgenden Eintr@"age beschreiben Eigenschaften, die Variablen haben
 699 k@"onnen:
 700
 701 @table @code
 702 @item value
 703 Der Variable ist mit dem Operatoren @mref{:} oder @mref{::} ein Wert zugewiesen.
 704 @item system value
 705 Die Variable ist eine Optionsvariable oder Systemvariable, die von Maxima
 706 definiert ist.
 707 @item numer
 708 Die Variable hat einen numerischen Wert auf der Eigenschaftsliste, der mit
 709 der Funktion @mref{numerval} zugewiesen ist.
 710 @item assign property
 711 Die Variable hat eine eine Funktion auf der Eigenschaftsliste, die die Zuweisung
 712 eines Wertes kontrolliert.
 713 @end table
 714
 715 Eintr@"age, die die Eigenschaften von Funktionen beschreiben:
 716
 717 @table @code
 718 @item function
 719 Eine mit dem Operator @mref{:=} oder der Funktion @mref{define} definierte
 720 Nutzerfunktion.
 721 @item macro
 722 Eine mit dem Operator @mref{::=} definierte Makrofunktion.
 723 @item system function
 724 Ein interne Maxima-Funktion.
 725 @item special evaluation form
 726 Eine Maxima-Spezialform, die die Argumente nicht auswertet.
 727 @item transfun
 728 Wird eine Nutzerfunktion mit @mref{translate} @"ubersetzt oder mit der Funktion
 729 @mref{compile} kompiliert, erh@"alt sie die Eigenschaft @code{transfun}.
 730 Interne Maxima-Funktionen, die mit dem Lisp-Makro @code{defmfun} definiert
 731 werden, haben ebenfalls diese Eigenschaft.
 732 @item deftaylor
 733 F@"ur die Funktion ist eine Taylorreihenentwicklung definiert.
 734 @item gradef
 735 Die Funktion hat eine Ableitung.
 736 @item integral
 737 Die Funktion hat eine Stammfunktion.
 738 @item distribute over bags
 739 Ist das Argument der Funktion eine Liste, Matrix oder Gleichung so wird die
 740 Funktion auf die Elemente oder beide Seiten der Gleichung angewendet.
 741 @item limit function
 742 Es existiert eine Funktion f@"ur die Behandlung spezieller Grenzwerte.
 743 @item conjugate function
 744 Es existiert eine Funktion, um die konjugiert komplexe Funktion f@"ur spezielle
 745 Wertebereiche zu ermitteln.
 746 @item mirror symmetry
 747 Die Funktion hat die Eigenschaft der Spiegelsymmetrie.
 748 @item complex characteristic
 749 Es existiert eine Funktion, um den Realteil und den Imagin@"arteil der Funktion
 750 f@"ur spezielle Wertebereiche zu ermitteln.
 751 @item user autoload function
 752 Die Funktion wird automatisch beim ersten Aufruf aus einer Datei geladen.  Der
 753 Nutzer kann mit dem Funktion @mref{setup_autoload} eine solche Funktion
 754 definieren.
 755 @end table
 756
 757 Weitere Eigenschaften, die Symbole erhalten k@"onnen:
 758
 759 @table @code
 760 @item operator
 761 Das Symbol ist ein Maxima-Operator oder ein nutzerdefinierte Operator.
 762
 763 @item rule
 764 Die Funktion oder der Operator haben eine Regel f@"ur die Vereinfachung.
 765
 766 @item alias
 767
 768 @item database info
 769 Das Symbol hat Eintr@"age in Maximas Datenbank.
 770
 771 @item hashed array, declared array, complete array
 772 Ein Hashed-Array, ein deklariertes Array oder ein Array dessen Elemente
 773 einen bestimmten Typ haben.
 774
 775 @item array function
 776 Eine Array-Funktion die mit dem Operator @mref{:=} definiert ist.
 777
 778 @item atvalue
 779 Dem Symbol ist mit der Funktion @mref{atvalue} ein Wert an einer Stelle
 780 zugewiesen.
 781
 782 @item atomgrad
 783 F@"ur das Symbol ist mit der Funktion @mref{gradef} eine Ableitung definiert.
 784
 785 @item dependency
 786 F@"ur das Symbol ist eine Abh@"angigkeit mit der Funktion @mref{depends}
 787 definiert.
 788
 789 @item matchdeclare
 790 Das Symbol ist eine mit @mref{matchdeclare} definierte Mustervariable, der eine
 791 Aussagefunktion zugeordnet ist.
 792
 793 @item modedeclare
 794 F@"ur das Symbol ist mit der Funktion @mref{mode_declare} ein Typ definiert.
 795
 796 @item user properties
 797
 798 @item context
 799 Das Symbol bezeichnet einen Kontext.
 800
 801 @item activecontext
 802 Das Symbol bezeichnet einen aktiven Kontextes.
 803 @end table
 804 @end deffn
 805
 806 @c --- 20.08.2011 DK -----------------------------------------------------------
 807 @anchor{props}
 808 @defvr {Systemvariable} props
 809 Standardwert: @code{[]}
 810
 811 @code{props} ist eine Liste der Symbole, die vom Nutzer eine Eigenschaft
 812 erhalten haben, die in die Lisp-Eigenschaftsliste des Symbols eingetragen wird.
 813 Neben den Funktionen @mref{put} und @mrefcomma{qput} mit denen der Nutzer
 814 direkt eine Eigenschaft zu einem Symbol in die Lisp-Eigenschaftsliste eintragen
 815 kann, legen auch Maxima-Funktionen Eigenschaften zu Symbolen in der
 816 Eigenschaftsliste ab und tragen diese Symbole in die Systemvariable @code{props}
 817 ein.  Zu diesen Funktionen geh@"oren zum Beispiel @mrefcomma{declare}@w{}
 818 @mrefcomma{numerval} @mrefcomma{matchdeclare} @mrefcomma{mode_declare}@w{}
 819 @mref{gradef} oder @mrefdot{setup_autoload}
 820
 821 Nach dem Start von Maxima sollte die Systemvariable @code{props} keine Symbole
 822 enthalten.  Das ist jedoch nicht der Fall und kann als ein Fehler betrachtet
 823 werden, der in Zukunft zu beheben ist.
 824 @end defvr
 825
 826 @c --- 29.12.2010 DK -----------------------------------------------------------
 827 @anchor{propvars}
 828 @deffn {Funktion} propvars (@var{prop})
 829
 830 Gibt eine Liste mit den Atomen zur@"uck, die in der Informationsliste
 831 @code{props} eingetragen sind und die die Eigenschaft @var{prop} haben.  Zum
 832 Beispiel gibt @code{propvars(atvalue)} eine Liste der Atome zur@"uck, die die
 833 Eigenschaft @code{atvalue} haben.
 834 @end deffn
 835
 836 @c --- 29.12.2010 DK -----------------------------------------------------------
 837 @anchor{put}
 838 @deffn {Funktion} put (@var{atom}, @var{value}, @var{indicator})
 839
 840 Weist den Wert @var{value} der Eigenschaft @var{indicator} des Atoms @var{atom}
 841 zu.  @var{indicator} kann eine beliebige Eigenschaft sein und beschr@"ankt sich
 842 nicht auf die vom System definierten Eigenschaften.  @code{put} wertet die
 843 Argumente aus.  @code{put} gibt @var{value} zur@"uck.
 844
 845 Beispiele:
 846
 847 @example
 848 (%i1) put (foo, (a+b)^5, expr);
 849                                    5
 850 (%o1)                       (b + a)
 851 (%i2) put (foo, "Hello", str);
 852 (%o2)                         Hello
 853 (%i3) properties (foo);
 854 (%o3)            [[user properties, str, expr]]
 855 (%i4) get (foo, expr);
 856 @group
 857                                    5
 858 (%o4)                       (b + a)
 859 @end group
 860 (%i5) get (foo, str);
 861 (%o5)                         Hello
 862 @end example
 863 @end deffn
 864
 865 @c --- 29.12.2010 DK -----------------------------------------------------------
 866 @anchor{qput}
 867 @deffn {Funktion} qput (@var{atom}, @var{value}, @var{indicator})
 868
 869 Entspricht der Funktion @code{put} mit dem Unterschied, dass @code{qput} die
 870 Argumente nicht auswertet.
 871
 872 Beispiele:
 873
 874 @example
 875 (%i1) foo: aa$
 876 (%i2) bar: bb$
 877 (%i3) baz: cc$
 878 (%i4) put (foo, bar, baz);
 879 (%o4)                          bb
 880 (%i5) properties (aa);
 881 (%o5)                [[user properties, cc]]
 882 (%i6) get (aa, cc);
 883 (%o6)                          bb
 884 (%i7) qput (foo, bar, baz);
 885 (%o7)                          bar
 886 (%i8) properties (foo);
 887 (%o8)            [value, [user properties, baz]]
 888 (%i9) get ('foo, 'baz);
 889 (%o9)                          bar
 890 @end example
 891 @end deffn
 892
 893 @c --- 06.02.2011 DK -----------------------------------------------------------
 894 @anchor{rational}
 895 @anchor{irrational}
 896 @defvr  {Eigenschaft} rational
 897 @defvrx {Eigenschaft} irrational
 898
 899 Hat eine Variable mit der Funktion @mref{declare} die Eigenschaft
 900 @code{rational} oder @code{irrational} erhalten, wird sie von Maxima als eine
 901 rationale Zahl oder als eine nicht rationale Zahl interpretiert.
 902 @end defvr
 903
 904 @c --- 06.02.2011 DK -----------------------------------------------------------
 905 @anchor{real}
 906 @anchor{imaginary}
 907 @anchor{complex}
 908 @defvr  {Eigenschaft} real
 909 @defvrx {Eigenschaft} imaginary
 910 @defvrx {Eigenschaft} complex
 911
 912 Hat eine Variable mit der Funktion @mref{declare} die Eigenschaft @code{real},
 913 @code{imaginary} oder @code{complex} erhalten, wird sie von Maxima als eine
 914 reelle Zahl, imagin@"are Zahl oder als eine komplexe Zahl interpretiert.
 915 @end defvr
 916
 917 @c --- 03.01.2011 DK -----------------------------------------------------------
 918 @anchor{rem}
 919 @deffn {Funktion} rem (@var{atom}, @var{indicator})
 920
 921 Entfernt die Eigenschaft @var{indicator} vom Atom @var{atom}.
 922 @end deffn
 923
 924 @c --- 29.12.2010 DK -----------------------------------------------------------
 925 @anchor{remove}
 926 @deffn  {Funktion} remove (@var{a_1}, @var{p_1}, @dots{}, @var{a_n}, @var{p_n})
 927 @deffnx {Funktion} remove ([@var{a_1}, @dots{}, @var{a_m}], [@var{p_1}, @dots{}, @var{p_n}], @dots{})
 928 @deffnx {Funktion} remove ("@var{a}", operator)
 929 @deffnx {Funktion} remove (@var{a}, transfun)
 930 @deffnx {Funktion} remove (all, @var{p})
 931
 932 Entfernt Eigenschaften von Atomen.
 933
 934 @code{remove(@var{a_1}, @var{p_1}, ..., @var{a_n}, @var{p_n})} entfernt die
 935 Eigenschaft @code{p_k} von dem Atom @code{a_k}.
 936
 937 @code{remove([@var{a_1}, ..., @var{a_m}], [@var{p_1}, ..., @var{p_n}], ...)}
 938 entfernt die Eigenschaften @var{p_1}, @dots{}, @var{p_n} von den Atomen
 939 @var{a_1}, @dots{}, @var{a_m}.  Es k@"onnen mehrere Paare an Listen angegeben
 940 werden.
 941
 942 @code{remove(all, @var{p})} entfernt die Eigenschaft @var{p} von allen Atomen,
 943 die diese Eigenschaft aufweisen.
 944
 945 Die zu entfernenden Eigenschaften k@"onnen vom System definierte Eigenschaften
 946 wie @code{function}, @code{macro}, @code{mode_declare} oder nutzerdefinierte
 947 Eigenschaften sein.
 948
 949 @code{remove("@var{a}", operator)} oder @code{remove("@var{a}", op)}
 950 entfernen vom Atom @var{a} die Operatoreigenschaften, die mit den Funktionen
 951 @mrefcomma{prefix} @mrefcomma{infix} @mrefcomma{nary} @mrefcomma{postfix}@w{}
 952 @mref{matchfix} oder @mref{nofix} definiert wurden.  Die Namen von Operatoren
 953 m@"ussen als eine Zeichenkette angegeben werden.
 954
 955 @code{remove} gibt immer @code{done} zur@"uck.
 956 @end deffn
 957
 958 @c --- 22.10.2010 DK -----------------------------------------------------------
 959 @anchor{scalar}
 960 @defvr {Eigenschaft} scalar
 961
 962 Hat ein Symbol die Eigenschaft @code{scalar}, verh@"alt es sich wie ein Skalar
 963 bei nicht-kommutativen Rechenoperationen.
 964 @end defvr
 965
 966 @c --- 29.12.2010 DK -----------------------------------------------------------
 967 @anchor{scalarp}
 968 @deffn {Funktion} scalarp (@var{expr})
 969
 970 Gibt @code{true} zur@"uck, wenn der Ausdruck @var{expr} eine Zahl, Konstante,
 971 ein als Skalar definiertes Symbol oder ein aus diesen Objekten zusammengesetzter
 972 Ausdruck ist.  Der Ausdruck darf jedoch keine Liste oder eine Matrix sein.
 973 @end deffn
 974
 975 @c -----------------------------------------------------------------------------
 976 @node Funktionen und Variablen f@"ur Fakten, Funktionen und Variablen f@"ur Aussagen, Funktionen und Variablen f@"ur Eigenschaften, Maximas Datenbank
 977 @section Funktionen und Variablen f@"ur Fakten
 978 @c -----------------------------------------------------------------------------
 979
 980 @c --- 12.02.2011 DK -----------------------------------------------------------
 981 @anchor{activate}
 982 @deffn {Funktion} activate (@var{context_1}, @dots{}, @var{context_n})
 983
 984 Das Kommando @code{activate(@var{context})} aktiviert den Kontext @var{context}.
 985 Der Funktion @code{activate} k@"onnen mehrere Kontexte @var{context_1}, @dots{},
 986 @var{context_n} @"ubergeben werden.  Nur die Aussagen und Fakten eines aktiven
 987 Kontextes stehen f@"ur die Auswertung von Aussagen zur Verf@"ugung.
 988
 989 Maxima gibt @code{done} zur@"uck, wenn der Kontext erfolgreich aktiviert werden
 990 konnte oder wenn der Kontext bereits aktiv ist.  Wird versucht einen nicht
 991 existierenden Kontext zu aktivieren, gibt Maxima eine Fehlermeldung aus.
 992
 993 Das Kommando @code{facts()} gibt die Fakten und Aussagen des aktuellen Kontextes
 994 aus.  Die Aussagen und Fakten anderer Kontexte k@"onnen zwar aktiv sein, sind
 995 aber in der R@"uckgabe von @code{facts} nicht enthalten.  Um die Aussagen und
 996 Fakten eines anderen als des aktuellen Kontexts auszugeben, kann das Kommando
 997 @code{facts(@var{context})} ausgef@"uhrt werden.
 998
 999 Die Systemvariable @mref{activecontexts} enth@"alt eine Liste der aktiven
1000 Kontexte.  Siehe auch die Systemvariable @mref{contexts} f@"ur eine Liste
1001 aller Kontexte, die Maxima kennt.
1002 @end deffn
1003
1004 @c --- 27.08.2010 DK -----------------------------------------------------------
1005 @anchor{activecontexts}
1006 @defvr {Systemvariable} activecontexts
1007 Standardwert: @code{[]}
1008
1009 Die Systemvariable @code{activecontexts} enth@"alt eine Liste der Kontexte, die
1010 mit der Funktion @code{activate} aktiviert wurden.  Unterkontexte sind aktiv,
1011 ohne dass die Funktion @code{activate} aufgerufen werden muss und sind nicht in
1012 der Liste @code{activecontexts} enthalten.  Siehe auch die Funktion
1013 @mref{activate} f@"ur die Aktivierung eines Kontextes und die Systemvariable
1014 @mref{contexts} f@"ur eine Liste aller vorhandenen Kontexte.
1015 @end defvr
1016
1017 @c --- 27.08.2010 DK -----------------------------------------------------------
1018 @anchor{askinteger}
1019 @deffn  {Funktion} askinteger (@var{expr}, integer)
1020 @deffnx {Funktion} askinteger (@var{expr})
1021 @deffnx {Funktion} askinteger (@var{expr}, even)
1022 @deffnx {Funktion} askinteger (@var{expr}, odd)
1023
1024 Das Kommando @code{askinteger(@var{expr}, integer)} versucht anhand der Aussagen
1025 und Fakten der aktiven Kontexte zu entscheiden, ob @var{expr} eine ganze Zahl
1026 repr@"asentiert.  Kann @code{askinteger} die Frage nicht entscheiden, fragt
1027 Maxima den Nutzer.  Die Antwort wird dem aktuellen Kontext hinzugef@"ugt.
1028 @code{askinteger(@var{expr})} ist @"aquivalent zu
1029 @code{askinteger(@var{expr}, integer)}.
1030
1031 @code{askinteger(@var{expr}, even)} und @code{askinteger(@var{expr}, odd)}
1032 versuchen zu entscheiden, ob @var{expr} eine gerade oder ungerade ganze Zahl
1033 repr@"asentiert.  Kann Maxima dies nicht entscheiden, wird der Nutzer gefragt.
1034 Die Antwort wird dem aktuellen Kontext hinzugef@"ugt.
1035
1036 Beispiele:
1037
1038 @example
1039 (%i1) askinteger(n,integer);
1040 Is n an integer?
1041 yes;
1042 (%o1)                          yes
1043 (%i2) askinteger(e,even);
1044 Is e an even number?
1045 yes;
1046 (%o2)                          yes
1047 (%i3) facts();
1048 (%o3)           [kind(n, integer), kind(e, even)]
1049 (%i4) declare(f,integervalued);
1050 (%o4)                         done
1051 (%i5) askinteger(f(x));
1052 (%o5)                          yes
1053 @end example
1054 @end deffn
1055
1056 @c --- 27.08.2010 DK -----------------------------------------------------------
1057 @anchor{asksign}
1058 @deffn {Funktion} asksign (@var{expr})
1059
1060 Die Funktion @code{asksign} versucht zu entscheiden, ob der Ausdruck @var{expr}
1061 einen positiven, negativen oder den Wert Null repr@"asentiert.  Kann Maxima dies
1062 nicht feststellen, wird der Nutzer nach weiteren Informationen gefragt, um die
1063 Frage zu entscheiden.  Die Antworten des Nutzers werden f@"ur die laufende
1064 Auswertung dem aktuellen Kontext hinzugef@"ugt.  Der R@"uckgabewert der
1065 Funktion @code{asksign} ist @code{pos}, @code{neg} oder @code{zero} f@"ur einen
1066 positiven, negativen oder den Wert Null.
1067 @end deffn
1068
1069 @c --- 26.08.2010 DK -----------------------------------------------------------
1070 @anchor{assume}
1071 @deffn {Funktion} assume (@var{pred_1}, @dots{}, @var{pred_n})
1072
1073 F@"ugt die Aussagen @var{pred_1}, @dots{}, @var{pred_n} dem aktuellen Kontext
1074 hinzu.  Eine inkonsistente oder redundante Aussage wird dem Kontext nicht
1075 hinzugef@"ugt.  @code{assume} gibt eine Liste mit den Aussagen zur@"uck, die dem
1076 Kontext hinzugef@"ugt wurden, oder die Symbole @code{redunant} und
1077 @code{inconsistent}.
1078
1079 Die Aussagen @var{pred_1}, @dots{}, @var{pred_n} k@"onnen nur Ausdr@"ucke mit
1080 den relationalen Operatoren @code{"<"}, @code{"<="}, @code{equal},
1081 @code{notequal}, @code{">="} und @code{">"} sein.  Aussagen k@"onnen nicht die
1082 Operatoren @code{"="} f@"ur Gleichungen oder @code{"#"} f@"ur Ungleichungen
1083 enthalten.  Auch k@"onnen keine Aussagefunktionen wie @code{integerp} verwendet
1084 werden.
1085
1086 Zusammengesetzte Aussagen mit dem Operator @code{and} der Form
1087 @code{@var{pred_1} and ... and @var{pred_n}} sind m@"oglich, nicht dagegen
1088 Aussagen mit dem Operator @code{or} der Form @code{@var{pred_1} or ... or
1089 @var{pred_n}}.  Ein Ausdruck mit dem Operator @code{not} der Form
1090 @code{not(@var{pred_k})} ist dann m@"oglich, wenn @var{pred_k} eine
1091 relationale Aussage ist.  Aussagen der Form @code{not (@var{pred_1} and
1092 @var{pred_2})} und @code{not (@var{pred_1} or @var{pred_2})} sind dagegen nicht
1093 m@"oglich.
1094
1095 Der Folgerungsmechanismus von Maxima ist nicht sehr stark.  Viele
1096 Schlu@ss{}folgerungen k@"onnen von Maxima nicht abgeleitet werden.  Dies ist
1097 eine bekannte Schw@"ache von Maxima.
1098
1099 @code{assume} behandelt keine Aussagen mit komplexen Zahlen.  Enth@"alt eine
1100 Aussage eine komplexe Zahl, gibt @code{assume} den Wert @code{inconsistent}
1101 oder @code{redunant} zur@"uck.
1102
1103 @code{assume} wertet die Argumente aus.
1104
1105 Siehe auch @mrefcomma{is} @mrefcomma{facts} @mrefcomma{forget}@w{}
1106 @mref{context} und @mrefdot{declare}
1107
1108 Beispiele:
1109
1110 @example
1111 (%i1) assume (xx > 0, yy < -1, zz >= 0);
1112 (%o1)              [xx > 0, yy < - 1, zz >= 0]
1113 (%i2) assume (aa < bb and bb < cc);
1114 (%o2)                  [bb > aa, cc > bb]
1115 (%i3) facts ();
1116 (%o3)     [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
1117 (%i4) is (xx > yy);
1118 (%o4)                         true
1119 (%i5) is (yy < -yy);
1120 (%o5)                         true
1121 (%i6) is (sinh (bb - aa) > 0);
1122 (%o6)                         true
1123 (%i7) forget (bb > aa);
1124 (%o7)                       [bb > aa]
1125 (%i8) prederror : false;
1126 (%o8)                         false
1127 (%i9) is (sinh (bb - aa) > 0);
1128 (%o9)                        unknown
1129 (%i10) is (bb^2 < cc^2);
1130 (%o10)                       unknown
1131 @end example
1132 @end deffn
1133
1134 @c --- 12.02.2011 DK -----------------------------------------------------------
1135 @anchor{assumescalar}
1136 @defvr {Optionsvariable} assumescalar
1137 Standardwert: @code{true}
1138
1139 Die Optionsvariable @code{assumescalar} kontrolliert, wie ein Ausdruck von den
1140 arithmetischen Operatoren @code{"+"}, @code{"*"}, @code{"^"}, @code{"."} und
1141 @code{"^^"} behandelt wird, wenn Maxima nicht ermitteln kann, ob der Ausdruck
1142 ein Skalar oder Nicht-Skalar ist.  @code{assumescalar} hat drei m@"ogliche
1143 Werte:
1144
1145 @table @code
1146 @item false
1147 Unbekannte Ausdr@"ucke werden als ein Nicht-Skalar behandelt.
1148
1149 @item true
1150 Unbekannte Ausdr@"ucke werden als ein Skalar f@"ur die kommutativen
1151 arithmetischen Operatoren @code{"+"}, @code{"*"} und @code{"^"} behandelt.
1152
1153 @item all
1154 Unbekannte Ausdr@"ucke werden f@"ur alle arithmetischen Operatoren als ein
1155 Skalar behandelt.
1156 @end table
1157
1158 Es ist besser Variablen als ein Skalar oder Nicht-Skalar mit der Funktion
1159 @mref{declare} zu deklarieren, anstatt die Vereinfachung mit der
1160 Optionsvariablen @code{assumescalar} zu kontrollieren.  Siehe auch die
1161 Eigenschaften @mref{scalar} und @mref{nonscalar} sowie die Funktionen
1162 @mref{scalarp} und @mrefdot{nonscalarp}
1163
1164 Beispiele:
1165
1166 Maxima kann nicht ermitteln, ob das Symbol @code{x} ein Skalar oder ein
1167 Nicht-Skalar ist.
1168
1169 @example
1170 (%i1) scalarp(x);
1171 (%o1)                         false
1172 (%i2) nonscalarp(x);
1173 (%o2)                         false
1174 @end example
1175
1176 Hat @code{assumescalar} den Wert @code{true}, behandelt Maxima das Symbol
1177 @code{x} als einen Skalar f@"ur die kommutative Multiplikation.
1178
1179 @example
1180 (%i3) x * [a,b,c], assumescalar:false;
1181 (%o3)                      x [a, b, c]
1182 (%i4) x * [a,b,c], assumescalar:true;
1183 (%o4)                    [a x, b x, c x]
1184 @end example
1185
1186 F@"ur die nicht kommutative Multiplikation behandelt Maxima das Symbol @code{x}
1187 dann als einen Skalar, wenn @code{assumescalar} den Wert @code{all} hat.
1188
1189 @example
1190 (%i5) x . [a,b,c], assumescalar:false;
1191 (%o5)                     x . [a, b, c]
1192 (%i6) x . [a,b,c], assumescalar:true;
1193 (%o6)                     x . [a, b, c]
1194 (%i7) x . [a,b,c], assumescalar:all;
1195 (%o7)                 [x . a, x . b, x . c]
1196 @end example
1197 @end defvr
1198
1199 @c --- 12.02.2011 DK -----------------------------------------------------------
1200 @anchor{assume_pos}
1201 @defvr {Optionsvariable} assume_pos
1202 Standardwert: @code{false}
1203
1204 Die Optionsvariable @code{assume_pos} kontrolliert das Ergebnis der Funktionen
1205 @mref{sign} und @mrefcomma{asksign} f@"ur den Fall, dass Maxima das Vorzeichen
1206 einer Variablen oder indizierten Variablen nicht aus den aktiven Kontexten
1207 ermitteln kann.  Hat @code{assume_pos} den Wert @code{true}, dann wird f@"ur
1208 Variable oder indizierte Variable, immer das Ergebnis @code{pos} ermittelt, wenn
1209 die Optionsvariable @code{assume_pos_pred} den Standardwert @code{false} hat und
1210 das Vorzeichen nicht aus den aktiven Kontexten ermittelt werden kann.
1211
1212 Die Optionsvariable @mref{assume_pos_pred} hat den Standardwert @code{false}.
1213 In diesem Fall werden von Maxima Variablen und indizierte Variablen als positiv
1214 angenommen, wenn @code{assume_pos} den Wert @code{true} hat.  Der
1215 Optionsvariablen @mref{assume_pos_pred} kann eine Aussagefunktion mit einem
1216 Argument zugewiesen werden.  Hat die Aussagefunktion f@"ur ein Argument
1217 @var{expr} das Ergebnis @code{true}, wird das Argument als positiv
1218 angenommen, wenn die Optionsvariable @code{assume_pos} den Wert @code{true} hat
1219 und Maxima das Vorzeichen nicht aus den aktiven Kontexten ermitteln kann.
1220
1221 Die Funktionen @code{sign} und @code{asksign} versuchen das Vorzeichen eines
1222 Ausdrucks anhand der Vorzeichen der Argumente zu ermitteln.  Sind zum Beispiel
1223 @code{a} und @code{b} beide positiv, dann wird f@"ur den Ausdruck @code{a+b} ein
1224 positives Vorzeichen ermittelt.  Auch wenn die Vorzeichen der Variablen @code{a}
1225 und @code{b} nicht bekannt sind, hat daher @code{asksign(a+b)} das Ergebnis
1226 @code{pos}, wenn @code{assume_pos} den Wert @code{true} hat, da in diesem Fall
1227 die Variablen als positiv angenommen werden.
1228
1229 Es gibt jedoch keine M@"oglichkeit, alle Ausdr@"ucke grunds@"atzlich als positiv
1230 zu erkl@"aren.  Selbst wenn der Optionsvariablen @code{assume_pos_pred} eine
1231 Aussagefunktion zugewiesen wird, die alle Ausdr@"ucke als positiv erkl@"art,
1232 werden Differenzen @code{a-b} oder das Vorzeichen der Logarithmusfunktion
1233 @code{log(a)} nicht als positiv ermittelt.  Die Fragen der Funktion
1234 @code{asksign} an den Nutzer k@"onnen daher nie vollst@"andig mit dem
1235 Mechanismus der Optionsvariablen @code{assume_pos} unterdr@"uckt werden.
1236
1237 Siehe f@"ur weitere Beispiele die Optionsvariable @mrefdot{assume_pos_pred}
1238
1239 Beispiele:
1240
1241 Das Vorzeichen der Variablen @code{x} ist nicht bekannt.  Erh@"alt die
1242 Optionsvariable @code{assume_pos} den Wert @code{true}, wird f@"ur die Variable
1243 @code{x} und die indizierte Variable @code{x[1]} ein positives Vorzeichen
1244 ermittelt.
1245
1246 @example
1247 (%i1) sign(x);
1248 (%o1)                          pnz
1249 (%i2) assume_pos:true;
1250 (%o2)                         true
1251 (%i3) sign(x);
1252 (%o3)                          pos
1253 (%i4) sign(x[1]);
1254 (%o4)                          pos
1255 @end example
1256
1257 Die Vorzeichen der Variablen @code{a} und @code{b} sind nicht bekannt.  Maxima
1258 ermittelt ein positives Vorzeichen f@"ur die Summe der Variablen.  Das
1259 Vorzeichen der Differenz ist dagegen weiterhin nicht bekannt.
1260
1261 @example
1262 (%i5) sign(a+b);
1263 (%o5)                          pos
1264 (%i6) sign(a-b);
1265 (%o6)                          pnz
1266 @end example
1267 @end defvr
1268
1269 @c --- 12.02.2011 DK -----------------------------------------------------------
1270 @anchor{assume_pos_pred}
1271 @defvr {Optionsvariable} assume_pos_pred
1272 Standardwert: @code{false}
1273
1274 Der Optionsvariablen @code{assume_pos_pred} kann eine Aussagefunktion wie zum
1275 Beispiel @mref{symbolp} oder ein Lambda-Ausdruck mit einem Argument @code{x}
1276 zugewiesen werden.  Hat die Optionsvariable @mref{assume_pos} den Wert
1277 @code{true}, werden Variablen, indizierte Variablen oder die Werte von
1278 Funktionen dann als positiv angenommen, wenn die Aussagefunktion das Ergebnis
1279 @code{true} hat.
1280
1281 Die Aussagefunktion wird intern von den Funktionen @mref{sign} und
1282 @mref{asksign} aufgerufen, wenn die Optionsvariable @code{assume_pos} den Wert
1283 @code{true} hat und das Vorzeichen einer Variablen, indizierten Variablen oder
1284 f@"ur den Wert einer Funktion nicht ermittelt werden konnte.  Gibt die
1285 Aussagefunktion das Ergebnis @code{true} zur@"uck, wird das Argument als
1286 positiv angenommen.
1287
1288 Hat die Optionsvariable @code{assume_pos_pred} den Standardwert @code{false}
1289 werden Variablen und indizierte Variablen von Maxima als positiv angenommen,
1290 wenn die Optionsvariable @code{assume_pos} den Wert @code{true} hat.  Das
1291 entspricht einer Aussagefunktion, die als @code{lambda([x], symbolp(x) or
1292 subvarp(x))} definiert wird.
1293
1294 Siehe auch @mref{assume} und @mrefdot{assume_pos}
1295
1296 Beispiele:
1297
1298 Der Optionsvariablen @code{assume_pos_pred} wird der Name der Aussagefunktion
1299 @code{symbolp} zugewiesen.  Indizierte Variablen werden nun nicht mehr als
1300 positiv angenommen, wie es f@"ur den Standartwert @code{false} gilt.
1301
1302 @example
1303 (%i1) assume_pos: true$
1304 (%i2) assume_pos_pred: symbolp$
1305 (%i3) sign (a);
1306 (%o3)                          pos
1307 (%i4) sign (a[1]);
1308 (%o4)                          pnz
1309 @end example
1310
1311 Der Optionsvariablen @code{assume_pos_pred} wird ein Lambda-Ausdruck zugewiesen,
1312 der f@"ur alle Argumente das Ergebnis @code{true} hat.  Die Funktion @code{sign}
1313 ermittelt nun f@"ur Variablen, indizierte Variablen und den Werten von
1314 Funktionen ein positives Vorzeichen.  Dies trifft jedoch nicht f@"ur die
1315 Logarithmusfunktion oder eine Differenz zu.
1316
1317 @example
1318 (%i1) assume_pos: true$
1319 (%i2) assume_pos_pred: lambda([x], true);
1320 (%o2)                   lambda([x], true)
1321 (%i3) sign(a);
1322 (%o3)                          pos
1323 (%i4) sign(a[1]);
1324 (%o4)                          pos
1325 (%i5) sign(foo(x));
1326 (%o5)                          pos
1327 (%i6) sign(foo(x)+foo(y));
1328 (%o6)                          pos
1329 (%i7) sign(log(x));
1330 (%o7)                          pnz
1331 (%i8) sign(x-y);
1332 (%o8)                          pnz
1333 @end example
1334 @end defvr
1335
1336 @c --- 12.02.2011 DK -----------------------------------------------------------
1337 @anchor{context}
1338 @defvr {Optionsvariable} context
1339 Standardwert: @code{initial}
1340
1341 Die Optionsvariable @code{context} enth@"alt den Namen des aktuellen Kontextes.
1342 Das ist der Kontext, der die Aussagen der Funktion @mref{assume} oder die mit
1343 der Funktion @mref{declare} definierten Eigenschaften aufnimmt und aus dem die
1344 Aussagen mit der Funktion @mref{forget} oder die Eigenschaften mit der Funktion
1345 @mref{remove} gel@"oscht werden.
1346
1347 Wird der Optionsvariablen @code{context} der Name eines existierenden Kontextes
1348 zugewiesen, wird dieser zum aktuellen Kontext.  Existiert der Kontext noch
1349 nicht, wird er durch Aufruf der Funktion @mref{newcontext} erzeugt.
1350
1351 Siehe auch @mref{contexts} f@"ur eine allgemeinere Beschreibung von Kontexten.
1352
1353 Beispiele:
1354
1355 Der Standardkontext ist @code{initial}.  Es wird ein neuer Kontext
1356 @code{mycontext} generiert, der die Aussagen und Eigenschaften aufnimmt.
1357
1358 @example
1359 (%i1) context;
1360 (%o1)                        initial
1361 (%i2) context:mycontext;
1362 (%o2)                       mycontext
1363 (%i3) contexts;
1364 (%o3)             [mycontext, initial, global]
1365 (%i4) assume(a>0);
1366 (%o4)                        [a > 0]
1367 (%i5) declare(b,integer);
1368 (%o5)                         done
1369 (%i6) facts(mycontext);
1370 (%o6)               [a > 0, kind(b, integer)]
1371 @end example
1372 @end defvr
1373
1374 @c --- 12.02.2011 DK -----------------------------------------------------------
1375 @anchor{contexts}
1376 @defvr {Systemvariable} contexts
1377 Standardwert: @code{[initial, global]}
1378
1379 Die Systemvariable @code{contexts} enth@"alt eine Liste der Kontexte, die
1380 Maxima bekannt sind.  Die Liste enth@"alt auch die nicht aktiven Kontexte.
1381
1382 Die Kontexte @code{global} und @code{initial} sind immer vorhanden.  Diese
1383 werden von Maxima initialisiert und k@"onnen nicht entfernt werden.  Der Kontext
1384 @code{global} enth@"alt Aussagen und Fakten f@"ur Systemvariablen und
1385 Systemfunktionen.  Mit den Funktionen @mref{newcontext} oder
1386 @mref{supcontext} kann der Nutzer weitere Kontexte anlegen.
1387
1388 Die Kontexte haben eine Hierarchie.  Die Wurzel ist immer der Kontext
1389 @code{global}, der damit ein Unterkontext aller anderen Kontexte und immer aktiv
1390 ist.  Der Kontext @code{initial} ist anfangs leer und nimmt, sofern kein
1391 weiterer Kontext angelegt wurde, die Aussagen und Fakten des Nutzers auf, die
1392 mit den Funktionen @mref{assume} und @mref{declare} definiert werden.  Mit der
1393 Funktion @mref{facts} k@"onnen die Aussagen und Fakten von Kontexten angezeigt
1394 werden.
1395
1396 Die Verwaltung verschiedener Kontexte erm@"oglicht es, Aussagen und Fakten in
1397 einem Kontext zusammenzustellen.  Durch das Aktivieren mit der Funktion
1398 @mref{activate} oder Deaktivieren mit der Funktion @mref{deactivate} k@"onnen
1399 diese Aussagen und Fakten f@"ur Maxima verf@"ugbar gemacht oder wieder
1400 ausgeschaltet werden.
1401
1402 Die Aussagen und Fakten in einem Kontext bleiben so lange verf@"ugbar, bis sie
1403 mit den Funktionen @mref{forget} oder @mref{remove} gel@"oscht werden.
1404 Weiterhin kann der gesamte Kontext mit der Funktion @mref{killcontext} entfernt
1405 werden.
1406
1407 Beispiel:
1408
1409 Das folgende Beispiel zeigt wie ein Kontext @code{mycontext} angelegt wird.  Der
1410 Kontext enth@"alt die Aussage @code{[a>0]}.  Der Kontext kann mit der Funktion
1411 @code{activate} aktiviert werden, um die Aussage verf@"ugbar zu machen.
1412
1413 @example
1414 (%i1) newcontext(mycontext);
1415 (%o1)                       mycontext
1416 (%i2) context;
1417 (%o2)                       mycontext
1418 (%i3) assume(a>0);
1419 (%o3)                        [a > 0]
1420 (%i4) context:initial;
1421 (%o4)                        initial
1422 (%i5) is(a>0);
1423 (%o5)                        unknown
1424 (%i6) activate(mycontext);
1425 (%o6)                         done
1426 (%i7) is(a>0);
1427 (%o7)                         true
1428 @end example
1429 @end defvr
1430
1431 @c --- 27.08.2010 DK -----------------------------------------------------------
1432 @anchor{deactivate}
1433 @deffn {Funktion} deactivate (@var{context_1}, @dots{}, @var{context_n})
1434
1435 Die Kontexte @var{context_1}, @dots{}, @var{context_n} werden deaktiviert.  Die
1436 Aussagen und Fakten dieser Kontexte stehen f@"ur die Auswertung von Aussagen
1437 nicht mehr zur Verf@"ugung.  Die Kontexte werden nicht gel@"oscht und k@"onnen
1438 mit der Funktion @mref{activate} wieder aktiviert werden.
1439
1440 Die deaktivierten Kontexte werden aus der Liste @mref{activecontexts} entfernt.
1441 @end deffn
1442
1443 @c --- 12.02.2011 DK -----------------------------------------------------------
1444 @anchor{facts}
1445 @deffn  {Funktion} facts (@var{item})
1446 @deffnx {Funktion} facts ()
1447
1448 Ist @var{item} der Name eines Kontextes, gibt @code{facts(@var{item})} eine
1449 Liste der Aussagen und Fakten des Kontextes @code{item} zur@"uck.
1450
1451 Ist @var{item} nicht der Name eines Kontextes, gibt @code{facts(@var{item})}
1452 eine Liste mit den Aussagen und Fakten zur@"uck, die zu @var{item} im aktuellen
1453 Kontext bekannt sind.  Aussagen und Fakten die zu einem anderen aktiven Kontext
1454 geh@"oren einschlie@ss{}lich der Unterkontexte, sind nicht in der Liste
1455 enthalten.
1456
1457 @code{facts()} gibt eine Liste der Fakten des aktuellen Kontextes zur@"uck.
1458
1459 Beispiel:
1460
1461 @example
1462 (%i1) context:mycontext;
1463 (%o1)                       mycontext
1464 (%i2) assume(a>0, a+b>0, x<0);
1465 (%o2)               [a > 0, b + a > 0, x < 0]
1466 (%i3) facts();
1467 (%o3)               [a > 0, b + a > 0, 0 > x]
1468 (%i4) facts(a);
1469 (%o4)                  [a > 0, b + a > 0]
1470 (%i5) facts(x);
1471 (%o5)                        [0 > x]
1472 (%i6) context:initial;
1473 (%o6)                        initial
1474 (%i7) activate(mycontext);
1475 (%o7)                         done
1476 (%i8) facts();
1477 (%o8)                          []
1478 (%i9) facts(mycontext);
1479 (%o9)               [a > 0, b + a > 0, 0 > x]
1480 @end example
1481 @end deffn
1482
1483 @c --- 27.08.2010 DK -----------------------------------------------------------
1484 @anchor{forget}
1485 @deffn  {Funktion} forget (@var{pred_1}, @dots{}, @var{pred_n})
1486 @deffnx {Funktion} forget (@var{L})
1487
1488 Entfernt Aussagen, die mit @code{assume} einem Kontext hinzugef@"ugt wurden.
1489 Die Aussagen k@"onnen Ausdr@"ucke sein, die @"aquivalent aber nicht unbedingt
1490 identisch zu vorherigen Fakten sind.
1491
1492 @code{forget(@var{L})} entfernt alle Aussagen, die in der Liste @var{L}
1493 enthalten sind.
1494 @end deffn
1495
1496 @c --- 12.11.2010 DK -----------------------------------------------------------
1497 @anchor{is}
1498 @deffn {Funktion} is (@var{expr})
1499
1500 Versucht festzustellen, ob die Aussage @var{expr} mit Hilfe der Aussagen und
1501 Fakten der aktiven Kontexte entschieden werden kann.
1502
1503 Kann die Aussage @var{expr} zu @code{true} oder @code{false} entschieden werden,
1504 wird das entsprechende Ergebnis zur@"uckgegeben.  Andernfalls wird der
1505 R@"uckgabewert durch den Schalter @mref{prederror} bestimmt.  Hat
1506 @code{prederror} den Wert @code{true}, wird eine Fehlermeldung ausgegeben.
1507 Ansonsten wird @code{unknown} zur@"uckgegeben.
1508
1509 Siehe auch @mrefcomma{assume} @mref{facts} und @mrefdot{maybe}
1510
1511 Beispiele:
1512
1513 @code{is} wertet Aussagen aus.
1514
1515 @example
1516 (%i1) %pi > %e;
1517 (%o1)                       %pi > %e
1518 (%i2) is (%pi > %e);
1519 (%o2)                         true
1520 @end example
1521
1522 @code{is} versucht Aussagen anhand der Aussagen und Fakten der aktiven
1523 Kontexte zu entscheiden.
1524
1525 @example
1526 (%i1) assume (a > b);
1527 (%o1)                        [a > b]
1528 (%i2) assume (b > c);
1529 (%o2)                        [b > c]
1530 (%i3) is (a < b);
1531 (%o3)                         false
1532 (%i4) is (a > c);
1533 (%o4)                         true
1534 (%i5) is (equal (a, c));
1535 (%o5)                         false
1536 @end example
1537
1538 Wenn @code{is} eine Aussage anhand der Aussagen und Fakten der aktiven Kontexte
1539 nicht entscheiden kann, wird der R@"uckgabewert vom Wert des Schalters
1540 @code{prederror} bestimmt.
1541
1542 @example
1543 (%i1) assume (a > b);
1544 (%o1)                        [a > b]
1545 (%i2) prederror: true$
1546 (%i3) is (a > 0);
1547 Maxima was unable to evaluate the predicate:
1548 a > 0
1549  -- an error.  Quitting.  To debug this try debugmode(true);
1550 (%i4) prederror: false$
1551 (%i5) is (a > 0);
1552 (%o5)                        unknown
1553 @end example
1554 @end deffn
1555
1556 @c --- 27.08.2010 DK -----------------------------------------------------------
1557 @anchor{killcontext}
1558 @deffn {Funktion} killcontext (@var{context_1}, @dots{}, @var{context_n})
1559
1560 Das Kommando @code{killcontext(@var{context})} l@"oscht den Kontext
1561 @var{context}.
1562
1563 Ist einer der Kontexte der aktuelle Kontext, wird der erste vorhandene
1564 Unterkontext zum aktuellen Kontext.  Ist der erste verf@"ugbare Kontext der
1565 Kontext @code{global}, dann wird der Kontext @code{initial} zum aktuellen
1566 Kontext.  Wird der Kontext @code{initial} gel@"oscht, dann wird eine neuer
1567 leerer Kontext @code{initial} erzeugt.
1568
1569 @code{killcontext} l@"oscht einen Kontext nicht, wenn dieser ein Unterkontext
1570 des aktuellen Kontextes ist oder wenn der Kontext mit der Funktion
1571 @code{activate} aktiviert wurde.
1572
1573 @code{killcontext} wertet die Argumente aus.  @code{killcontext} gibt
1574 @code{done} zur@"uck.
1575 @end deffn
1576
1577 @c --- 12.11.2010 DK -----------------------------------------------------------
1578 @anchor{maybe}
1579 @deffn {Funktion} maybe (@var{expr})
1580
1581 Versucht festzustellen, ob die Aussage @var{expr} anhand der Aussagen und
1582 Fakten der aktive Kontexte entschieden werden kann.
1583
1584 Kann die Aussage als @code{true} oder @code{false} entschieden werden, gibt
1585 @code{maybe} entsprechend @code{true} oder @code{false} zur@"uck.  Andernfalls
1586 gibt @code{maybe} den Wert @code{unknown} zur@"uck.
1587
1588 @code{maybe} entspricht der Funktion @code{is} mit @code{prederror: false}.
1589 Dabei wird @code{maybe} ausgef@"uhrt, ohne dass @code{prederror} einen Wert
1590 erh@"alt.
1591
1592 Siehe auch @mrefcomma{assume} @mref{facts} und @mrefdot{is}
1593
1594 Beispiele:
1595
1596 @example
1597 (%i1) maybe (x > 0);
1598 (%o1)                        unknown
1599 (%i2) assume (x > 1);
1600 (%o2)                        [x > 1]
1601 (%i3) maybe (x > 0);
1602 (%o3)                         true
1603 @end example
1604 @end deffn
1605
1606 @c --- 27.08.2010 DK -----------------------------------------------------------
1607 @anchor{newcontext}
1608 @deffn {Funktion} newcontext (@var{name})
1609
1610 @code{newcontext(@var{name})} erzeugt einen neuen, leeren Kontext mit dem
1611 Namen @var{name}. Der neue Kontext hat den Kontext @code{global} als Subkontext
1612 und wird zum aktuellen Kontext.
1613
1614 @code{newcontext} wertet seine Argumente aus.  @code{newcontext} gibt
1615 @code{name} zur@"uck.
1616 @end deffn
1617
1618 @c --- 28.12.2010 DK -----------------------------------------------------------
1619 @anchor{prederror}
1620 @defvr {Optionsvariable} prederror
1621 Standardwert: @code{false}
1622
1623 Hat @code{prederror} den Wert @code{true}, wird eine Fehlermeldung ausgegeben,
1624 wenn eine Aussage mit einer @code{if}-Anweisung oder der Funktion @code{is}
1625 nicht zu @code{true} oder @code{false} ausgewertet werden kann.
1626
1627 Hat @code{prederror} den Wert @code{false}, wird f@"ur diese F@"alle
1628 @code{unknown} zur@"uckgegeben.
1629
1630 Siehe auch @mref{is} und @mrefdot{maybe}
1631 @end defvr
1632
1633 @c --- 12.11.2010 DK -----------------------------------------------------------
1634 @anchor{sign}
1635 @deffn {Funktion} sign (@var{expr})
1636
1637 Versucht das Vorzeichen des Ausdrucks @var{expr} auf Grundlage der Fakten der
1638 aktuellen Datenbank zu finden.  @code{sign} gibt eine der folgende Antworten
1639 zur@"uck: @code{pos} (positiv), @code{neg} (negative), @code{zero} (null),
1640 @code{pz} (positive oder null), @code{nz} (negative oder null), @code{pn}
1641 (positiv oder negative) oder @code{pnz} (positiv, negative oder null, f@"ur den
1642 Fall das Vorzeichen nicht bekannt ist).
1643 @end deffn
1644
1645 @c --- 27.08.2010 DK -----------------------------------------------------------
1646 @anchor{supcontext}
1647 @deffn  {Funktion} supcontext (@var{name}, @var{context})
1648 @deffnx {FunKtion} supcontext (@var{name})
1649
1650 Erzeugt einen neuen Kontext, mit dem Namen @code{name}, der den Kontext
1651 @code{context} als einen Unterkontext enth@"alt.  Der Kontext @var{context} muss
1652 existieren.
1653
1654 Wird @var{context} nicht angegeben, wird der aktuelle Kontext angenommen.
1655 @end deffn
1656
1657 @c -----------------------------------------------------------------------------
1658 @node Funktionen und Variablen f@"ur Aussagen, , Funktionen und Variablen f@"ur Fakten, Maximas Datenbank
1659 @section Funktionen und Variablen f@"ur Aussagen
1660 @c -----------------------------------------------------------------------------
1661
1662 @c --- 27.08.2010 DK -----------------------------------------------------------
1663 @anchor{charfun}
1664 @deffn {Funktion} charfun (@var{p})
1665
1666 Gibt den Wert 0 zur@"uck, wenn die Aussage @var{p} zu @code{false} ausgewertet
1667 werden kann und den Wert 1, wenn die Auswertung @code{true} liefert.  Kann
1668 die Aussage weder zu @code{false} oder @code{true} ausgewertet werden, wird eine
1669 Substantiv-Form zur@"uck gegeben.
1670
1671 Beispiele:
1672
1673 @example
1674 (%i1) charfun (x < 1);
1675 (%o1)                    charfun(x < 1)
1676 (%i2) subst (x = -1, %);
1677 (%o2)                           1
1678 (%i3) e : charfun ('"and" (-1 < x, x < 1))$
1679 (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
1680 (%o4)                       [0, 1, 0]
1681 @end example
1682 @end deffn
1683
1684 @c --- 27.08.2010 DK -----------------------------------------------------------
1685 @anchor{compare}
1686 @deffn {Funktion} compare (@var{x}, @var{y})
1687
1688 Liefert den Vergleichsoperator @var{op} (@code{<}, @code{<=}, @code{>},
1689 @code{>=}, @code{=} oder @code{#}), so dass der Ausdruck @code{is(@var{x}
1690 @var{op} @var{y})} zu @code{true} ausgewertet werden kann.  Ist eines der
1691 Argumente eine komplexe Zahl, dann wird @code{notcomparable} zur@"uckgegeben.
1692 Kann Maxima keinen Vergleichsoperator bestimmen, wird @code{unknown}
1693 zur@"uckgegeben.
1694
1695 Beispiele:
1696
1697 @example
1698 (%i1) compare (1, 2);
1699 (%o1)                           <
1700 (%i2) compare (1, x);
1701 (%o2)                        unknown
1702 (%i3) compare (%i, %i);
1703 (%o3)                           =
1704 (%i4) compare (%i, %i + 1);
1705 (%o4)                     notcomparable
1706 (%i5) compare (1/x, 0);
1707 (%o5)                           #
1708 (%i6) compare (x, abs(x));
1709 (%o6)                          <=
1710 @end example
1711
1712 Die Funktion @code{compare} versucht nicht festzustellen, ob der Wertebereich
1713 einer Funktion reelle Zahlen enth@"alt.  Obwohl der Wertebereich von
1714 @code{acos(x^2+1)} bis auf Null keine reellen Zahlen enth@"alt, gibt
1715 @code{compare} das folgende Ergebnis zur@"uck:
1716
1717 @example
1718 (%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
1719 (%o1)                           <
1720 @end example
1721 @end deffn
1722
1723 @c --- 20.04.2011 DK -----------------------------------------------------------
1724 @anchor{equal}
1725 @deffn {Funktion} equal (@var{a}, @var{b})
1726
1727 Repr@"asentiert die @"Aquivalenz, das hei@ss{}t den gleichen Wert.
1728
1729 @code{equal} wird nicht ausgewertet oder vereinfacht.  Die Funktion
1730 @mref{is} versucht einen Ausdruck mit @code{equal} zu einem booleschen Wert
1731 auszuwerten.  @code{is(equal(@var{a}, @var{b}))} gibt @code{true} oder
1732 @code{false} zur@"uck, wenn und nur wenn @var{a} und @var{b} gleich oder
1733 ungleich sind f@"ur alle Werte ihrer Variablen, was mit @code{ratsimp(@var{a} -
1734 @var{b})} bestimmt wird.  Gibt @mref{ratsimp} das Ergebnis 0 zur@"uck, werden
1735 die beiden Ausdr@"ucke als @"aquivalent betracht.  Zwei Ausdr@"ucke k@"onnen
1736 @"aquivalent sein, obwohl sie nicht syntaktisch gleich (im allgemeinen
1737 identisch) sind.
1738
1739 Kann @code{is} einen Ausdruck mit @code{equal} nicht zu @code{true} oder
1740 @code{false} auswerten, h@"angt das Ergebnis vom Wert des globalen Flags
1741 @mref{prederror} ab.  Hat @code{prederror} den Wert @code{true}, gibt @code{is}
1742 eine Fehlermeldung zur@"uck.  Ansonsten wird @code{unknown} zur@"uckgegeben.
1743
1744 Es gibt weitere Operatoren, die einen Ausdruck mit @code{equal} zu @code{true}
1745 oder @code{false} auswerten k@"onnen.  Dazu geh@"oren @mrefcomma{if}@w{}
1746 @mrefcomma{and} @mref{or} und @mrefdot{not}
1747
1748 Die Umkehrung von @code{equal} ist @mrefdot{notequal}
1749
1750 Beispiele:
1751
1752 @code{equal} wird von allein weder ausgewertet noch vereinfacht:
1753
1754 @example
1755 (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
1756                         2
1757 (%o1)            equal(x  - 1, (x - 1) (x + 1))
1758 (%i2) equal (x, x + 1);
1759 (%o2)                    equal(x, x + 1)
1760 (%i3) equal (x, y);
1761 (%o3)                      equal(x, y)
1762 @end example
1763
1764 Die Funktion @code{is} versucht, @code{equal} zu einem booleschen Wert
1765 auszuwerten.  Der Ausdruck @code{is(equal(@var{a}, @var{b}))} gibt den Wert
1766 @code{true} zur@"uck, when @code{ratsimp(@var{a} - @var{b})} den Wert 0 hat.
1767 Zwei Ausdr@"ucke k@"onnen @"aquivalent sein, obwohl sie nicht syntaktisch
1768 gleich sind.
1769
1770 @example
1771 (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1772 (%o1)                           0
1773 (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
1774 (%o2)                         true
1775 (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
1776 (%o3)                         false
1777 (%i4) ratsimp (x - (x + 1));
1778 (%o4)                          - 1
1779 (%i5) is (equal (x, x + 1));
1780 (%o5)                         false
1781 (%i6) is (x = x + 1);
1782 (%o6)                         false
1783 (%i7) ratsimp (x - y);
1784 (%o7)                         x - y
1785 (%i8) is (equal (x, y));
1786 (%o8)                        unknown
1787 (%i9) is (x = y);
1788 (%o9)                         false
1789 @end example
1790
1791 Kann @code{is} einen Ausdruck mit @code{equal} nicht zu @code{true} oder
1792 @code{false} vereinfachen, h@"angt das Ergebnis vom Wert des globalen Flags
1793 @code{prederror} ab.
1794
1795 @example
1796 (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1797                     2             2
1798 (%o1)             [x  + 2 x + 1, x  - 2 x - 1]
1799 (%i2) ratsimp (aa - bb);
1800 (%o2)                        4 x + 2
1801 (%i3) prederror : true;
1802 (%o3)                         true
1803 (%i4) is (equal (aa, bb));
1804 Maxima was unable to evaluate the predicate:
1805        2             2
1806 equal(x  + 2 x + 1, x  - 2 x - 1)
1807  -- an error.  Quitting.  To debug this try debugmode(true);
1808 (%i5) prederror : false;
1809 (%o5)                         false
1810 (%i6) is (equal (aa, bb));
1811 (%o6)                        unknown
1812 @end example
1813
1814 Einige weitere Operatoren werten @code{equal} und @code{notequal} zu einem
1815 booleschen Wert aus.
1816
1817 @example
1818 (%i1) if equal (y, y - 1) then FOO else BAR;
1819 (%o1)                          BAR
1820 (%i2) eq_1 : equal (x, x + 1);
1821 (%o2)                    equal(x, x + 1)
1822 (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1823                          2                   2
1824 (%o3)             equal(y  + 2 y + 1, (y + 1) )
1825 (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1826 (%o4)                  [false, true, true]
1827 @end example
1828
1829 Da @code{not @var{expr}} den Ausdruck @var{expr} auswertet, ist
1830 @code{not equal(@var{a}, @var{b})} @"aquivalent zu
1831 @code{is(notequal(@var{a}, @var{b}))}
1832
1833 @example
1834 (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1835 (%o1)            [notequal(2 z, 2 z - 1), true]
1836 (%i2) is (notequal (2*z, 2*z - 1));
1837 (%o2)                         true
1838 @end example
1839 @end deffn
1840
1841 @c --- 12.11.2010 DK -----------------------------------------------------------
1842 @anchor{notequal}
1843 @deffn {Funktion} notequal (@var{a}, @var{b})
1844
1845 Repr@"asentiert die Verneinung von @code{equal(@var{a}, @var{b})}.
1846
1847 Beispiele:
1848
1849 @example
1850 (%i1) equal (a, b);
1851 (%o1)                      equal(a, b)
1852 (%i2) maybe (equal (a, b));
1853 (%o2)                        unknown
1854 (%i3) notequal (a, b);
1855 (%o3)                    notequal(a, b)
1856 (%i4) not equal (a, b);
1857 (%o4)                    notequal(a, b)
1858 (%i5) maybe (notequal (a, b));
1859 (%o5)                        unknown
1860 (%i6) assume (a > b);
1861 (%o6)                        [a > b]
1862 (%i7) equal (a, b);
1863 (%o7)                      equal(a, b)
1864 (%i8) maybe (equal (a, b));
1865 (%o8)                         false
1866 (%i9) notequal (a, b);
1867 (%o9)                    notequal(a, b)
1868 (%i10) maybe (notequal (a, b));
1869 (%o10)                        true
1870 @end example
1871 @end deffn
1872
1873 @c --- 12.11.2010 DK -----------------------------------------------------------
1874 @anchor{unknown}
1875 @deffn {Funktion} unknown (@var{expr})
1876
1877 @c TODO: FORMULIERUNG?
1878
1879 Gibt den Wert @code{true} zur@"uck, wenn der Ausdruck @var{expr} einen Operator
1880 oder eine Funktion enth@"alt, die nicht von Maximas Vereinfacher erkannt wird.
1881 @end deffn
1882
1883 @c --- 12.11.2010 DK -----------------------------------------------------------
1884 @anchor{zeroequiv}
1885 @deffn {Funktion} zeroequiv (@var{expr}, @var{v})
1886
1887 Testet, ob ein Ausdruck @var{expr} mit der Variablen @var{v} @"aquivalent zu
1888 Null ist.  Die Funktion gibt @code{true}, @code{false} oder @code{dontknow}
1889 zur@"uck.
1890
1891 @code{zeroequiv} hat Einschr@"ankungen:
1892
1893 @enumerate
1894 @item
1895 Funktionen im Ausdruck @var{expr} m@"ussen von Maxima differenzierbar und
1896 auswertbar sein.
1897
1898 @item
1899 Hat der Ausdruck Pole auf der reellen Achse, k@"onnen Fehler auftreten.
1900
1901 @item
1902 Enth@"alt der Ausdruck Funktionen, die nicht L@"osung einer
1903 Differentialgleichung erster Ordnung sind (zum Beispiel Bessel Funktionen),
1904 k@"onnen die Ergebnisse fehlerhaft sein.
1905
1906 @item
1907 Der Algorithmus wertet die Funktion an zuf@"allig Punkten f@"ur ausgew@"ahlte
1908 Teilausdr@"ucke aus.  Dies ist ein riskantes Verfahren und kann zu Fehlern
1909 f@"uhren.
1910 @end enumerate
1911
1912 @code{zeroequiv(sin(2*x) - 2*sin(x)*cos(x), x)} hat zum Beispiel das Ergebnis
1913 @code{true} und  @code{zeroequiv (%e^x + x, x)} hat das Ergebnis @code{false}.
1914 Andererseits hat @code{zeroequiv (log(a*b) - log(a) - log(b), a)} das Ergebnis
1915 @code{dontknow}, wegen dem zus@"atzlichem Parameter @code{b}.
1916 @end deffn
1917
1918 @c --- End of Database.de.texi -------------------------------------------------
1919