Maxima Manual: Funktionen und Variablen der Differentiation

Next: Integration, Previous: Funktionen und Variablen für Grenzwerte, Nach oben: Analysis [Inhalt][Index]

### 16.2 Funktionen und Variablen der Differentiation

Funktion: at (expr, [eqn_1, …, eqn_n])
Funktion: at (expr, eqn)

  Wertet den Ausdruck expr aus, wobei dessen Variablen die Werte annehmen, die in der Liste der Gleichungen `[eqn_1, ..., eqn_n]` oder in der einzelnen Gleichung eqn angegeben sind.

  Wenn ein Teilausdruck von einer Variablen abhängt, für die ein Wert angegeben ist, aber kein `atvalue`, und er auch sonst nicht ausgewertet werden kann, dann wird von `at` eine Substantivform zurückgegeben.

  `at` führt mehrfache Ersetzungen parallel aus.

  Siehe auch `atvalue`. Für andere Funktionen, die Ersetzungen ausführen, siehe weiterhin `subst` und `ev`.

  Beispiele:

      (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
                                      2
      (%o1)                          a
      (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
      (%o2)                        @2 + 1
      (%i3) printprops (all, atvalue);
                                      !
                        d             !
                       --- (f(@1, @2))!       = @2 + 1
                       d@1            !
                                      !@1 = 0

                                           2
                                f(0, 1) = a

      (%o3)                         done
      (%i4) diff (4*f(x, y)^2 - u(x, y)^2, x);
                        d                          d
      (%o4)  8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
                        dx                         dx
      (%i5) at (%, [x = 0, y = 1]);
                                               !
                    2              d           !
      (%o5)     16 a  - 2 u(0, 1) (-- (u(x, y))!            )
                                   dx          !
                                               !x = 0, y = 1

Funktion: antid (expr, x, u(x))

  Gibt eine Liste mit zwei Elementen zurück aus denen die Stammfunktion des Ausdrucks expr mit der Variablen x konstruiert werden kann. Der Ausdruck expr kann eine unbekannte Funktion u und deren Ableitungen enthalten. Ist L das Ergebnis der Funktion `antid`, dann ist der Ausdruck `L[1]+ 'integrate(L[2], x)` die gesuchte Stammfunktion des Ausdrucks expr mit der Variablen x.

  Kann `antid` die Stammfunktion vollständig bestimmen, ist das zweite Element der Liste Null. Hat `antid` keinerlei Erfolg, ist das erste Element der Liste Null. In anderen Fällen enthält das erste Elemente den integrierbaren Anteil des Ausdrucks expr und das zweite Element den nicht integrierbaren Anteil des Ausdrucks.

  Mit dem Kommando `load("antid")` wird die Funktion geladen.

  `antid` steht in folgender Beziehung zur Funktion `antidiff`. Ist L die Liste mit den Ergebnissen der Funktion `antid`, dann hat die Funktion `antidiff` das Ergebnis `L[1] + 'integrate(L[2], x)` mit x als der Variablen des Ausdrucks expr.

  Beispiele:

      (%i1) load ("antid")$
      (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
                                  z(x)  d
      (%o2)                y(x) %e     (-- (z(x)))
                                        dx
      (%i3) a1: antid (expr, x, z(x));
                             z(x)      z(x)  d
      (%o3)          [y(x) %e    , - %e     (-- (y(x)))]
                                             dx
      (%i4) a2: antidiff (expr, x, z(x));
                                  /
                           z(x)   [   z(x)  d
      (%o4)         y(x) %e     - I %e     (-- (y(x))) dx
                                  ]         dx
                                  /
      (%i5) a2 - (first (a1) + 'integrate (second (a1), x));
      (%o5)                           0
      (%i6) antid (expr, x, y(x));
                                   z(x)  d
      (%o6)             [0, y(x) %e     (-- (z(x)))]
                                         dx
      (%i7) antidiff (expr, x, y(x));
                        /
                        [        z(x)  d
      (%o7)             I y(x) %e     (-- (z(x))) dx
                        ]              dx
                        /

Funktion: antidiff (expr, x, u(x))

  Gibt die Stammfunktion des Ausdrucks expr mit der Variablen x zurück. Der Ausdruck expr kann eine unbekannte Funktion u und deren Ableitungen enthalten.

  Kann `antidiff` die Stammfunktion nicht oder nur teilweise bestimmen, enthält das Ergebnis das Integral des nicht bestimmbaren Anteils.

  Mit dem Kommando `load("antid")` wird die Funktion geladen.

  `antidiff` steht in folgender Beziehung zur Funktion `antid`. Ist L die Liste mit den Ergebnissen der Funktion `antid`, dann hat die Funktion `antidiff` das Ergebnis `L[1] + 'integrate(L[2], x)` mit x als der Variablen des Ausdrucks expr.

  Für Beispiele und weitere Ausführungen siehe die Funktion `antid`.

Eigenschaft: atomgrad

  Wird für ein Symbol eine Ableitung mit der Funktion `gradef` definiert, dann erhält das Symbol die Eigenschaft `atomgrad`.

Funktion: atvalue (expr, [x_1 = a_1, …, x_m = a_m], c)
Funktion: atvalue (expr, x_1 = a_1, c)

  Dem Ausdruck expr wird der Wert c am Punkt `x = a` zugewiesen. Typischerweise werden Randwerte mit der Funktion `atvalue` definiert.

  Der Ausdruck expr ist entweder eine Funktion `f(x_1, ..., x_m)` oder die Ableitung einer Funktion `diff(f(x_1, ..., x_m), x_1, n_1, ..., x_n, n_m)`. Die Argumente müssen explizit auftreten. n_i ist die Ordnung der Ableitung bezüglich der Variablen x_i.

  Die Randwerte werden durch die Liste `[x_1 = a_1, ..., x_m = a_m]` definiert. Eine einzelne Gleichung muss nicht als Liste angegeben werden.

  `printprops([f_1, f_2, ...], atvalue)` zeigt die Randwerte der Funktionen `f_1, f_2, ...` wie sie mit der Funktion `atvalue` definiert wurden. `printprops (f, atvalue)` zeigt nur die Randwerte für die Funktion f. `printprops (all, atvalue)` zeigt die Randwerte aller Funktionen.

  Die Symbole `@1`, `@2`, … repräsentieren die Variablen x_1, x_2, …, wenn die Randwerte angezeigt werden.

  `atvalue` wertet die Argumente aus. `atvalue` gibt den Randwert c zurück.

  Beispiele:

      (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
                                      2
      (%o1)                          a
      (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
      (%o2)                        @2 + 1
      (%i3) printprops (all, atvalue);
                                      !
                        d             !
                       --- (f(@1, @2))!       = @2 + 1
                       d@1            !
                                      !@1 = 0

                                           2
                                f(0, 1) = a

      (%o3)                         done
      (%i4) diff (4*f(x,y)^2 - u(x,y)^2, x);
                        d                          d
      (%o4)  8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
                        dx                         dx
      (%i5) at (%, [x = 0, y = 1]);

                                               !
                    2              d           !
      (%o5)     16 a  - 2 u(0, 1) (-- (u(x, y))!            )
                                   dx          !
                                               !x = 0, y = 1

Paket: cartan

  The exterior calculus of differential forms is a basic tool of differential geometry developed by Elie Cartan and has important applications in the theory of partial differential equations. The `cartan` package implements the functions `ext_diff` and `lie_diff`, along with the operators `~` (wedge product) and `|` (contraction of a form with a vector.) Type `demo (tensor)` to see a brief description of these commands along with examples.

  `cartan` was implemented by F.B. Estabrook and H.D. Wahlquist.

Funktion: del (x)

  `del(x)` repräsentiert das Differential der Variablen x.

  `diff` gibt Ausdrücke zurück, die Differentiale enthalten, wenn keine Variablen angegeben sind, nach denen abgeleitet werden soll. In diesem Fall gibt `diff` das totale Differential zurück.

  Beispiele:

      (%i1) diff (log (x));
                                   del(x)
      (%o1)                        ------
                                     x
      (%i2) diff (exp (x*y));
                           x y              x y
      (%o2)            x %e    del(y) + y %e    del(x)
      (%i3) diff (x*y*z);
      (%o3)         x y del(z) + x z del(y) + y z del(x)

Funktion: delta (t)

  Die Diracsche Delta-Funktion.

  Maxima kennt die Delta-Funktion nur im Zusammenhang mit Laplace-Transformationen. Siehe `laplace`.

  Beispiel:

      (%i1) laplace (delta (t - a) * sin(b*t), t, s);
      Is  a  positive, negative, or zero?

      p;
                                         - a s
      (%o1)                   sin(a b) %e

Systemvariable: dependencies

  Standardwert: `[]`

  `dependencies` ist eine Liste der Symbole, für die eine Abhängigkeit mit den Funktionen `depends` oder `gradef` definiert wurde. Siehe `depends` und `gradef`.

Funktion: depends (f_1, x_1, …, f_n, x_n)

  Definiert die Abhängigkeit einer Funktion f von einer Variablen x. Ist keine Abhängigkeit definiert, dann hat die Ableitung `diff(f, x)` das Ergebnis Null. Wird mit dem Kommando `depends(f, x)` definiert, dass die Funktion f von der Variablen x abhängt, dann ist das Ergebnis der Ableitung die Substantivform `'diff(f,x,1)`.

  Jedes Argument f_1, x_1, … kann der Name einer Variablen, eines Arrays oder eine Liste mit Namen sein. Jedes Symbol f_i hängt ab von den Symbolen der Liste x_i. Ist eines der Symbole f_i der Name eines Arrays, dann hängen alle Elemente des Arrays von x_i ab.

  `diff` erkennt indirekte Abhängigkeiten und wendet für diesen Fall die Kettenregel an.

  `remove(f, dependency)` entfernt alle Abhängigkeiten, die für f definiert wurden.

  `depends` gibt eine Liste der Abhängigkeiten zurück. Die Abhängigkeiten werden in die Informationsliste `dependencies` eingetragen. `depends` wertet die Argumente aus.

  Die Funktion `diff` ist die einzige Maxima-Funktion, die Abhängigkeiten erkennt, die mit `depends` definiert wurden. Andere Funktionen wie `integrate` oder `laplace` erkennen keine Abhängigkeiten, die mit der `depends` definiert wurden. Für diese Funktionen müssen die Abhängigkeiten explizit angegeben werden, zum Beispiel als `integrate(f(x), x)`.

  Beispiele:

      (%i1) depends ([f, g], x);
      (%o1)                     [f(x), g(x)]
      (%i2) depends ([r, s], [u, v, w]);
      (%o2)               [r(u, v, w), s(u, v, w)]
      (%i3) depends (u, t);
      (%o3)                        [u(t)]
      (%i4) dependencies;
      (%o4)      [f(x), g(x), r(u, v, w), s(u, v, w), u(t)]
      (%i5) diff (r.s, u);
                               dr           ds
      (%o5)                    -- . s + r . --
                               du           du

      (%i6) diff (r.s, t);
                            dr du           ds du
      (%o6)                 -- -- . s + r . -- --
                            du dt           du dt

      (%i7) remove (r, dependency);
      (%o7)                         done
      (%i8) diff (r.s, t);
                                      ds du
      (%o8)                       r . -- --
                                      du dt

Optionsvariable: derivabbrev

  Standardwert: `false`

  Hat `derivabbrev` den Wert `true`, werden symbolische Ableitungen mit einem tiefgestellten Index angezeigt. Ansonsten werden Ableitungen als `dy/dx` angezeigt.

  Beispiel:

      (%i1) derivabbrev:false$

      (%i2) 'diff(y,x);
                                     dy
      (%o2)                          --
                                     dx
      (%i3) derivabbrev:true$

      (%i4) 'diff(y,x);
      (%o4)                          y
                                      x

Funktion: derivdegree (expr, y, x)

  Gibt die höchste Ableitung des Arguments y in Bezug auf die Variable x zurück, die in dem Ausdruck expr enthalten ist.

  Beispiel:

      (%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2;
                               3     2
                              d y   d y    2 dy
      (%o1)                   --- + --- + x  --
                                3     2      dx
                              dz    dx
      (%i2) derivdegree (%, y, x);
      (%o2)                           2

Auswertungsschalter: derivlist (var_1, …, var_k)

  `derivlist` ist ein Auswertungsschalter für die Funktion `ev`. `ev` führt nur die Ableitungen in Bezug auf die angegebenen Variablen var_1, …, var_k aus. Siehe auch `ev`.

Optionsvariable: derivsubst

  Standardwert: `false`

  Hat `derivsubst` den Wert `true`, werden Substitutionen auch in Ausdrücke mit Ableitungen ausgeführt. Zum Beispiel hat dann `subst(x, 'diff(y, t), 'diff(y, t, 2))` das Ergebnis `'diff(x, t)`.

Funktion: diff (expr, x_1, n_1, …, x_m, n_m)
Funktion: diff (expr, x, n)
Funktion: diff (expr, x)
Funktion: diff (expr)
Auswertungsschalter: diff

  Gibt die Ableitungen oder Differentiale des Ausdrucks expr in Bezug auf alle oder einige der Variablen des Ausdrucks zurück.

  `diff(expr, x, n)` gibt die n-te Ableitung des Ausdrucks expr in Bezug auf die Variable x zurück.

  `diff(expr, x_1, n_1, ..., x_m, n_m)` gibt die partielle Ableitung des Ausdrucks expr in Bezug auf die Variablen x_1, ..., x_m zurück. Dies ist äquivalent zu `diff(... (diff(expr, x_m, n_m) ...), x_1, n_1)`.

  `diff(expr, x)` gibt die erste Ableitung des Ausdrucks expr in Bezug auf die Variable x zurück.

  `diff(expr)` gibt das totale Differential des Ausdrucks expr zurück. Siehe auch `del`.

  Wenn die Ableitungen nicht ausgeführt werden sollen, kann der `Quote-Operator` `'` verwendet werden, um eine Substantivform der Ableitung zu erhalten.

  Hat `derivabbrev` den Wert `true`, werden symbolische Ableitungen mit einem tiefgestelltem Index angezeigt. Ansonsten werden Ableitungen als `dy/dy` angezeigt.

  `diff` ist auch ein Auswertungsschalter für die Funktion `ev`. Das Kommando `ev(expr), diff` bewirkt, dass alle Ableitungen ausgeführt werden, die im Ausdruck expr enthalten sind. Siehe auch die Funktion `ev`.

  `derivative` ist ein Alias-Name der Funktion `diff`.

  Beispiele:

      (%i1) diff (exp (f(x)), x, 2);

                           2
                    f(x)  d               f(x)  d         2
      (%o1)       %e     (--- (f(x))) + %e     (-- (f(x)))
                            2                   dx
                          dx

      (%i2) derivabbrev: true$
      (%i3) 'integrate (f(x, y), y, g(x), h(x));
                               h(x)
                              /
                              [
      (%o3)                   I     f(x, y) dy
                              ]
                              /
                               g(x)
      (%i4) diff (%, x);
             h(x)
            /
            [
      (%o4) I     f(x, y)  dy + f(x, h(x)) h(x)  - f(x, g(x)) g(x)
            ]            x                     x                  x
            /
             g(x)

  For the tensor package, the following modifications have been incorporated:

  1. The derivatives of any indexed objects in expr will have the variables x_i appended as additional arguments. Then all the derivative indices will be sorted.
  2. The x_i may be integers from 1 up to the value of the variable `dimension` [default value: 4]. This will cause the differentiation to be carried out with respect to the x_i’th member of the list `coordinates` which should be set to a list of the names of the coordinates, e.g., `[x, y, z, t]`. If `coordinates` is bound to an atomic variable, then that variable subscripted by x_i will be used for the variable of differentiation. This permits an array of coordinate names or subscripted names like `X[1]`, `X[2]`, … to be used. If `coordinates` has not been assigned a value, then the variables will be treated as in (1) above.

Funktion: gradef (f(x_1, …, x_n), g_1, …, g_m)
Funktion: gradef (a, x, expr)

  Definiert eine partielle Ableitung der Funktion f oder Variablen a.

  Das Kommando `gradef(f(x_1, ..., x_n), g_1, ..., g_m)` definiert die partielle Ableitung `df/dx_i` als g_i. g_i ist ein Ausdruck. g_i kann ein Funktionsaufruf sein, aber nicht der Name einer Funktion. Die Anzahl der partiellen Ableitungen m kann kleiner als die Anzahl der Argumente n sein.

  `gradef(a, x, expr)` definiert die Ableitung der Variablen a in Bezug auf die Variable x als expr. Wie mit der Funktion `depends` wird a als abhängig von x deklariert. Die Abhängigkeit wird in die Liste `dependencies` eingetragen. Siehe auch `depends`.

  Bis auf das erste Argument werden die Argumente der Funktion `gradef` ausgewertet. `gradef` gibt die Funktion oder Variable zurück, für die eine partielle Ableitung definiert wurde.

  `gradef` kann die Ableitungen von vorhandenen Maxima-Funktionen neu definieren. Zum Beispiel definiert `gradef(sin(x), sqrt (1 - sin(x)^2))` eine neue Ableitung der Sinusfunktion.

  `gradef` kann keine partiellen Ableitungen für indizierte Funktionen definieren.

  `printprops([f_1, ..., f_n], gradef)` zeigt die mit `gradef` definierten partiellen Ableitungen der Funktionen f_1, …, f_n an und `printprops([a_n, ..., a_n], atomgrad)` zeigt die mit `gradef` definierten partiellen Ableitungen der Variablen a_n, …, a_n an. Siehe `printprops`.

  `gradefs` ist eine Informationsliste, die die Funktionen enthält, für die mit `gradef` eine Ableitung definierte wurde. Die Liste enthält keine Variablen, für die Ableitungen definiert wurden.

Systemvariable: gradefs

  Standardwert: `[]`

  `gradefs` ist eine Liste der Funktionen, für die eine Ableitung mit der Funktion `gradef` definiert wurde.

Next: Integration, Previous: Funktionen und Variablen für Grenzwerte, Nach oben: Analysis [Inhalt][Index]