Menu
▾
▴
[Maxima-commits] CVS: maxima/doc/info/de Command.de.texi, NONE, 1.1 Help.de.texi, NONE, 1.1 Indices.de.texi, NONE, 1.1 include-maxima.de.texi, NONE, 1.1 DataTypes.de.texi, NONE, 1.1 Expressions.de.texi, NONE, 1.1 Bugs.de.texi, NONE, 1.1 Introduction.de.texi, NONE, 1.1
|
From: Dieter K. <cra...@us...> - 2010-10-17 10:49:11
|
Update of /cvsroot/maxima/maxima/doc/info/de In directory sfp-cvsdas-4.v30.ch3.sourceforge.com:/tmp/cvs-serv28096/doc/info/de Added Files: Command.de.texi Help.de.texi Indices.de.texi include-maxima.de.texi DataTypes.de.texi Expressions.de.texi Bugs.de.texi Introduction.de.texi Log Message: Committing the first chapters of a German translation of the Maxima reference manual. include-maxima.de.texi Introduction.de.texi Bugs.de.texi Help.de.texi Command.de.texi DataTypes.de.texi Expressions.de.texi Indices.de.texi --- NEW FILE: Command.de.texi --- @c ----------------------------------------------------------------------------- @c File : Command.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Date : 15.10.2010 @c @c This file contains documentation for the following symbols: @c @c __ _ % %% @c %th ? ?? @c @c inchar infolists kill labels @c linechar linenum myoptions nolabels @c optionset outchar playback prompt @c quit reset reset_verbosely showtime @c system to_lisp values @c @c %dispflag absboxchar disp dispform @c display display2d display_format_internal [...2433 lines suppressed...] @c When @code{ttyoff} is @code{true}, output expressions are not displayed. @c Output expressions are still computed and assigned labels. See @code{labels}. Hat die Optionsvariable @code{ttyoff} den Wert @code{true}, werden Ergebnisse nicht angezeigt. Die Ergebnisse werden weiter berechnet und sie werden Marken zugewiesen. Siehe @code{labels}. @c Text printed by built-in Maxima functions, such as error messages and the @c output of @code{describe}, is not affected by @code{ttyoff}. Textausgaben von internen Funktionen, wie Fehlermeldungen und Ausgaben der Hilfe mit @code{describe} werden nicht beeinflusst. @c @opencatbox @c @category{Anzeigeflags und -variablen} @c @closecatbox @end defvr @c --- Ende Command.de.texi ---------------------------------------------------- --- NEW FILE: Help.de.texi --- @c ----------------------------------------------------------------------------- @c File : Help.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Date : 15.10.2010 @c @c This file contains documentation for the following Maxima symbols: @c @c apropos @c demo @c describe @c example @c manual_demo @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @menu * Dokumentation:: * Funktionen und Variablen der Hilfe:: @end menu @c ----------------------------------------------------------------------------- @c @node Garbage Collection, Documentation, Lisp and Maxima, Help @c @section Garbage Collection @c Symbolic computation tends to create a good deal @c of garbage, and effective handling of this can be crucial to successful @c completion of some programs. @c @c HOW MUCH OF THE FOLLOWING STILL HOLDS ?? @c @c WHAT ABOUT GC IN GCL ON MS WINDOWS ?? @c @c SHOULD WE SAY SOMETHING ABOUT GC FOR OTHER LISPS ?? @c Under GCL, on UNIX systems where the mprotect system call is available @c (including SUN OS 4.0 and some variants of BSD) a stratified garbage collection @c is available. This limits the collection to pages which have been recently @c written to. See the GCL documentation under ALLOCATE and GBC. At the @c Lisp level doing (setq si::*notify-gbc* t) will help you determine which @c areas might need more space. @c --- 15.10.2010 DK ----------------------------------------------------------- @node Dokumentation, Funktionen und Variablen der Hilfe, , Hilfe @section Dokumentation @c SHOULD TALK ABOUT OTHER FORMS OF DOCUMENTATION ASIDE FROM ON-LINE MANUAL. @c The Maxima on-line user's manual can be viewed in different forms. @c From the Maxima interactive prompt, the user's manual @c is viewed as plain text by the @code{?} command (i.e., the @code{describe} @c function). The user's manual is viewed as @code{info} hypertext by the @c @code{info} viewer program and as a web page by any ordinary web browser. Die Maxima online-Dokumentation kann auf verschiedene Art gelesen werden. Von der Maxima-Kommandozeile kann die Dokumentation mit den Kommandos @code{?}, @code{??} oder @code{describe} aufgerufen werden. Weiterhin kann die Dokumentation als GNU Infotext mit dem GNU Programm @code{info} oder in einem Browser gelesen werden. @c @code{example} displays examples for many Maxima functions. @c For example, @code{example} zeigt Beispiele für viele Maxima-Funktionen. Das Kommando @example (%i1) example (integrate); @end example @c yields gibt die folgende hier verkürzt wiedergegebene Ausgabe: @example (%i2) test(f):=block([u],u:integrate(f,x),ratsimp(f-diff(u,x))) (%o2) test(f) := block([u], u : integrate(f, x), ratsimp(f - diff(u, x))) (%i3) test(sin(x)) (%o3) 0 (%i4) test(1/(x+1)) (%o4) 0 (%i5) test(1/(x^2+1)) (%o5) 0 [...] @end example @c and additional output. @c @opencatbox @c @category{Hilfe} @category{Konsole Ein- und Ausgabe} @c @closecatbox @c --- 15.10.2010 DK ----------------------------------------------------------- @node Funktionen und Variablen der Hilfe, , Dokumentation, Hilfe @section Funktionen und Variablen der Hilfe @c --- 15.10.2010 DK ----------------------------------------------------------- @deffn {Funktion} apropos (@var{string}) @c Searches for Maxima names which have @var{string} appearing anywhere within @c them. Thus, @code{apropos (exp)} returns a list of all the flags and functions @c which have @code{exp} as part of their names, such as @code{expand}, @code{exp}, @c and @code{exponentialize}. Thus if you can only remember part of the name of @c something you can use this command to find the rest of the name. Similarly, you @c could say @code{apropos (tr_)} to find a list of many of the switches relating @c to the translator, most of which begin with @code{tr_}. Liefert eine Liste der Maxima-Symbole, die @var{string} im Namen enthalten. @var{string} ist eine Zeichenkette. @c @code{apropos("")} returns a list with all Maxima names. @code{apropos("")} gibt eine Liste mit allen Maxima-Symbolen zurück. @c @code{apropos} returns the empty list @code{[]}, if no name is found. @code{apropos} gibt eine leere Liste @code{[]} zurück, wenn kein Maxima-Symbol gefunden wurde, das @var{string} im Namen enthält. Beispiel: @c Show all Maxima symbols wich have @code{"gamma"} in the name: Zeige alle Maxima-Symbole, die @code{"gamma"} im Namen enthalten: @c ===beg=== @c apropos("gamma"); @c ===end=== @example (%i1) apropos("gamma"); (%o1) [%gamma, gamma, gammalim, gamma_expand, gamma_greek, gamma_incomplete, gamma_incomplete_generalized, gamma_incomplete_regularized, Gamma, log_gamma, makegamma, prefer_gamma_incomplete, gamma_incomplete_generalized_regularized] @end example @c @opencatbox @c @category{Hilfe} @c @closecatbox @end deffn @c --- 15.10.2010 DK ----------------------------------------------------------- @deffn {Funktion} demo (@var{filename}) @c Evaluates Maxima expressions in @var{filename} and displays the results. @c @code{demo} pauses after evaluating each expression @c and continues after the user enters a carriage return. @c (If running in Xmaxima, @code{demo} may need to see a semicolon @code{;} @c followed by a carriage return.) Führt die Beispiele der Demo-Datei @var{filename} aus. @var{filename} kann ein Symbol oder eine Zeichenkette sein. @code{demo} macht nach jeder Ausgabe eine Pause und wartet auf eine Eingabe. @c @code{demo} searches the list of directories @code{file_search_demo} to find @c @code{filename}. If the file has the suffix @code{dem}, the suffix may be @c omitted. See also @code{file_search}. @code{demo} sucht in den Ordnern, die in der Optionsvariablen @code{file_search_demo} enthalten sind, nach der Datei @var{filename}. Die Dateiendung @var{.dem} muss nicht angegeben werden. Siehe auch die Funktion @code{file_search}. @c @code{demo} evaluates its argument. @c @code{demo} returns the name of the demonstration file. @code{demo} wertet sein Argument aus. @code{demo} gibt den Namen der Demo-Datei zurück, die ausgeführt wird. Beispiel: @example (%i1) demo ("disol"); batching /home/wfs/maxima/share/simplification/disol.dem At the _ prompt, type ';' followed by enter to get next demo (%i2) load(disol) _ (%i3) exp1 : a (e (g + f) + b (d + c)) (%o3) a (e (g + f) + b (d + c)) _ (%i4) disolate(exp1, a, b, e) (%t4) d + c (%t5) g + f (%o5) a (%t5 e + %t4 b) _ @end example @c @opencatbox @c @category{Hilfe} @category{Konsole Ein- und Ausgabe} @category{Dateieingabe} @c @closecatbox @end deffn @c --- 15.10.2010 DK ----------------------------------------------------------- @deffn {Funktion} describe (@var{topic}) @deffnx {Funktion} describe (@var{topic}, exact) @deffnx {Funktion} describe (@var{topic}, inexact) @ifinfo @fnindex Hilfe @end ifinfo @c @code{describe(@var{string})} is equivalent to @c @code{describe(@var{string}, exact)}. @code{describe(@var{topic})} entspricht dem Befehl @code{describe(@var{topic}, exact)}. @var{topic} ist eine Zeichenkette oder ein Symbol. Wenn @var{topic} ein Operator wie z. B. @code{+}, @code{*}, @code{do} oder @code{if} ist, muss der Name des Operators als eine Zeichenkette angegeben werden. @c @code{describe(@var{string}, exact)} finds an item with title equal @c (case-insensitive) to @var{string}, if there is any such item. @code{describe(@var{topic}, exact)} findet Einträge, die mit @var{topic} übereinstimmen. Zu beachten ist, dass bei der Suche Klein- und GroÃschreibung unterschieden werden. @c @code{describe(@var{string}, inexact)} finds all documented items which @c contain @var{string} in their titles. @c If there is more than one such item, Maxima asks the user to select @c an item or items to display. @code{describe(@var{topic}, inexact)} findet Einträge, die @var{topic} enthalten. Sind mehrere Einträge vorhanden, fragt Maxima, welcher der Einträge angezeigt werden soll. @c At the interactive prompt, @c @code{? foo} (with a space between @code{?} and @code{foo}) @c is equivalent to @code{describe("foo", exact)}, @c and @code{?? foo} is equivalent to @code{describe("foo", inexact)}. @code{? foo} (mit einem Leerzeichen zwischen @code{?} und @code{foo}) entspricht @code{describe("foo",exact)} und @code{?? foo} entspricht @code{describe("foo", inexact)}. In der Kurzschreibweise muss das Argument ein Symbol sein. @c @code{describe("", inexact)} yields a list of all topics documented in the @c on-line manual. @code{describe("", inexact)} gibt alle Themen aus, die in der Dokumentation enthalten sind. @c @code{describe} quotes its argument. @c @code{describe} returns @code{true} if some documentation is found, otherwise @c @code{false}. @code{describe} wertet das Argument nicht aus. @code{describe} gibt @code{true} zurück, wenn Einträge gefunden wurden, ansonsten @code{false}. @c See also @ref{Documentation}. Beispiel: @c In this example, items 7 and 8 were selected (output is shortened as @c indicated by @code{[...]}. All or none of the items could have been selected @c by entering @code{all} or @code{none}, which can be abbreviated @code{a} or @c @code{n}, respectively. In diesem Beispiel werden die Einträge 2 und 3 ausgewählt (Die Ausgabe ist verkürzt wiedergeben). Alle oder keiner der Einträge werden mit @code{all} und @code{none} ausgewählt. Die Eingabe kann mit @code{a} und @code{n} abgekürzt werden. @example (%i1) ?? integrat 0: Functions and Variables for Integration 1: Introduction to Integration 2: integrate (Functions and Variables for Integration) 3: integrate_use_rootsof (Functions and Variables for Integration) 4: integration_constant (Functions and Variables for Integration) 5: integration_constant_counter (Functions and Variables for Integration) Enter space-separated numbers, `all' or `none': 2 3 -- Function: integrate (<expr>, <x>) -- Function: integrate (<expr>, <x>, <a>, <b>) Attempts to symbolically compute the integral of <expr> with respect to <x>. `integrate (<expr>, <x>)' is an indefinite integral, while `integrate (<expr>, <x>, <a>, <b>)' is a definite integral, with limits of integration <a> and <b>. The limits should not contain <x>, although `integrate' does not enforce this restriction. <a> need not be less than <b>. If <b> is equal to <a>, `integrate' returns zero. [...] -- Option variable: integrate_use_rootsof Default value: `false' When `integrate_use_rootsof' is `true' and the denominator of a rational function cannot be factored, `integrate' returns the integral in a form which is a sum over the roots (not yet known) of the denominator. [...] @end example @c @opencatbox @c @category{Hilfe} @category{Konsole Ein- und Ausgabe} @c @closecatbox @end deffn @c --- 15.10.2010 DK ----------------------------------------------------------- @deffn {Funktion} example (@var{topic}) @deffnx {Funktion} example () @c @code{example (@var{topic})} displays some examples of @var{topic}, which is @c a symbol or a string. To get examples for operators like @code{if}, # @c @code{do}, or @code{lambda} the argument must be a string, e.g. @c @code{example ("do")}. @code{example} is not case sensitive. Most topics are @c function names. @code{example(@var{topic})} zeigt Beispiele für das Argument @var{topic}. @var{topic} ist ein Symbol oder eine Zeichenkette. Ist das Argument ein Operator, wie zum Beispiel @code{+}, @code{*} oder @code{do}, muss das Argument @var{topic} eine Zeichenkette sein. GroÃ- und Kleinschreibung werden nicht beachtet. @c @code{example ()} returns the list of all recognized topics. @code{example()} zeigt eine Liste aller Themen, für die Beispiele vorhanden sind. @c The name of the file containing the examples is given by the global option @c variable @code{manual_demo}, which defaults to @code{"manual.demo"}. Die Optionsvariable @code{manual_demo} enthält den Namen der Datei, die die Beispiele enthält. Der Standardwert ist @code{"manual.demo"} @c @code{example} quotes its argument. @code{example} returns @code{done} unless @c no examples are found or there is no argument, in which case @code{example} @c returns the list of all recognized topics. @code{example} wertet sein Argument nicht aus. @code{example} gibt @code{done} zurück, auÃer wenn kein Argument angeben ist oder wenn kein Beispiel gefunden wurde. In diesen Fällen wird eine Liste mit allen Themen ausgegeben, zu denen Beispiele vorhanden sind. Beispiele: @c ===beg=== @c example(append); @c example("lambda"); @c example("allROOTS"); @c ===end=== @example (%i1) example(append); (%i2) append([x+y,0,-3.2],[2.5E+20,x]) (%o2) [y + x, 0, - 3.2, 2.5E+20, x] (%o2) done (%i3) example("lambda"); (%i4) lambda([x,y,z],z^2+y^2+x^2) 2 2 2 (%o4) lambda([x, y, z], z + y + x ) (%i5) %(1,2,a) 2 (%o5) a + 5 (%i6) a+2+1 (%o6) a + 3 (%o6) done (%i7) example("allROOTS"); (%i8) (1+2*x)^3 = 13.5*(1+x^5) 3 5 (%o8) (2 x + 1) = 13.5 (x + 1) (%i9) allroots(%) (%o9) [x = .8296749902129361, x = - 1.015755543828121, x = .9659625152196369 %i - .4069597231924075, x = - .9659625152196369 %i - .4069597231924075, x = 1.0] (%o9) done @end example @c @opencatbox @c @category{Hilfe} @category{Konsole Ein- und Ausgabe} @c @closecatbox @end deffn @c --- 15.10.2010 DK ----------------------------------------------------------- @defvr {Optionsvariable} manual_demo Standardwert: @code{"manual.demo"} @c @code{manual_demo} specifies the name of the file containing the examples for @c the function @code{example}. See @code{example}. Die Optionsvariable @code{manual_demo} enthält den Namen der Datei, die die Beispiele für die Funktion @code{example} enthält. Siehe @code{example}. @c @opencatbox @c @category{Hilfe} @category{Optionsvariablen} @c @closecatbox @end defvr @c --- End of file Help.de.texi ------------------------------------------------ --- NEW FILE: Indices.de.texi --- @appendix Index der Funktionen und Variablen @printindex fn --- NEW FILE: include-maxima.de.texi --- @c ----------------------------------------------------------------------------- @c File : include-maxima.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Date : 15.10.2010 @c @c This file contains the contents, a detailed node listing and inclucdes @c all files for the documentation. @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @c -*-texinfo-*- @c 2000-04-17 Jim Van Zandt <jr...@va...> Added header, @c info directory entry, reference to introduction chapter, and menu @c descriptions. Rearranged chapters. @c to update the menus do: @c (texinfo-multiple-files-update "maxima.texi" t t) @c texinfo-multiple-files-update will delete the detailed node listing! @c %**start of header @synindex vr fn @settitle Maxima Dokumentation @c %**end of header @setchapternewpage odd @ifinfo Das ist eine Texinfo Maxima Dokumentation Copyright 1994,2001 William F. Schelter @format START-INFO-DIR-ENTRY * Maxima: (maxima). Ein Computer Algebra System. END-INFO-DIR-ENTRY @end format @end ifinfo @ifinfo @macro var {expr} <\expr\> @end macro @end ifinfo @include category-macros.de.texi @titlepage @sp 10 @center @titlefont{Maxima Manual} @center Version 5.22 @page @vskip 0pt plus 1filll @c Maxima is a computer algebra system, implemented in Lisp. @c Maxima is derived from the Macsyma system, @c developed at MIT in the years 1968 through 1982 as part of Project MAC. @c MIT turned over a copy of the Macsyma source code to the Department of Energy @c in 1982; that version is now known as DOE Macsyma. @c A copy of DOE Macsyma was maintained by Professor William F. Schelter @c of the University of Texas from 1982 until his death in 2001. @c In 1998, Schelter obtained permission from the Department of Energy @c to release the DOE Macsyma source code under the GNU Public License, @c and in 2000 he initiated the Maxima project at SourceForge to maintain @c and develop DOE Macsyma, now called Maxima. Maxima ist ein Computer Algebra System, das in Lisp programmiert ist. Maxima basiert auf Macsyma, das am MIT (Massachusetts Institute of Technology) in den Jahren 1968 bis 1982 als Teil des Projektes MAC entwickelt wurde. Das Department of Energy (DOE) erhielt im Jahr 1982 den Quellcode vom MIT; diese Version ist als DOE Macsyma bekannt. Professor William F. Schelter von der University of Texas hat von 1982 bis zu seinem Tod im Jahr 2001 eine Kopie von DOE Macsyma gepflegt. Im Jahr 1998 erhielt Schelter vom Department of Energy die Erlaubnis, den Quellcode von DOE Macsyma unter der GNU Public Lizenz zu veröffentlichen. Im Jahr 2000 initiierte Schelter das Maxima Projekt bei SourceForge, um DOE Macsyma, heute Maxima genannt, weiter zu entwickeln. @end titlepage @summarycontents @contents @ifnottex @node Top, Einführung in Maxima, (dir), (dir) @top @c Maxima is a computer algebra system, implemented in Lisp. @c Maxima is derived from the Macsyma system, @c developed at MIT in the years 1968 through 1982 as part of Project MAC. @c MIT turned over a copy of the Macsyma source code to the Department of Energy @c in 1982; that version is now known as DOE Macsyma. @c A copy of DOE Macsyma was maintained by Professor William F. Schelter @c of the University of Texas from 1982 until his death in 2001. @c In 1998, Schelter obtained permission from the Department of Energy @c to release the DOE Macsyma source code under the GNU Public License, @c and in 2000 he initiated the Maxima project at SourceForge to maintain @c and develop DOE Macsyma, now called Maxima. Maxima ist ein Computer Algebra System, das in Lisp programmiert ist. Maxima basiert auf Macsyma, das am MIT (Massachusetts Institute of Technology) in den Jahren 1968 bis 1982 als Teil des Projektes MAC entwickelt wurde. Das Department of Energy (DOE) erhielt im Jahr 1982 den Quellcode vom MIT; diese Version ist als DOE Macsyma bekannt. Professor William F. Schelter von der University of Texas hat von 1982 bis zu seinem Tod im Jahr 2001 eine Kopie von DOE Macsyma gepflegt. Im Jahr 1998 erhielt Schelter vom Department of Energy die Erlaubnis, den Quellcode von DOE Macsyma unter der GNU Public Lizenz zu veröffentlichen. Im Jahr 2000 initiierte Schelter das Maxima Projekt bei SourceForge, um DOE Macsyma, heute Maxima genannt, weiter zu entwickeln. @end ifnottex @c includes @menu Maxima Grundlagen * Einführung in Maxima:: Erste Beispiele mit Maxima. * Programmfehler:: Programmfehler finden und berichten. * Hilfe:: Hilfe in einer Maxima-Sitzung erhalten. * Kommandozeile:: Syntax der Kommandozeile. * Datentypen:: Ganze, rationale und Gleitkommazahlen, Konstante, Zeichenketten, ... * Ausdrücke:: Ausdrücke in Maxima. * Operatoren:: Operatoren in Maxima. * Auswertung:: Auswertung von Ausdrücken. * Vereinfachung:: Vereinfachung von Ausdrücken. * Mathematische Funktionen:: Mathematische Funktionen in Maxima. * Deklarationen und Fakten:: Deklarationen, Kontexte, Fakten. * Grafische Darstellung:: 2D and 3D graphical output. * Eingabe und Ausgabe:: Dateieingabe und Dateiausgaben Support for specific areas of mathematics * Polynomials:: Standard forms for polynomials, and functions operating on them. * Special Functions:: Special functions * Elliptic Functions:: Elliptic Functions and Integrals * Limits:: Limits of expressions. * Differentiation:: Differential calculus. * Integration:: Integral calculus. * Equations:: Defining and solving equations. * Differential Equations:: Defining and solving differential equations. * Numerical:: Numerical integration, Fourier transforms, etc. * Arrays:: Creating and working with arrays. * Matrices and Linear Algebra:: Matrix operations. * Affine:: * itensor:: Indicial Tensor Manipulation. * ctensor:: Component Tensor Manipulation. * atensor:: Algebraic Tensor Manipulation. * Series:: Taylor and power series. * Number Theory:: Number theory. * Symmetries:: * Groups:: Abstract algebra. Advanced facilities and programming * Runtime Environment:: Customization of the Maxima environment. * Miscellaneous Options:: Options with a global effect on Maxima. * Rules and Patterns:: User defined pattern matching and simplification rules. * Lists:: Manipulation of lists. * Sets:: Manipulation of sets. * Function Definition:: Defining functions. * Program Flow:: Defining Maxima programs. * Debugging:: Debugging Maxima programs. Additional packages * augmented_lagrangian:: augmented_lagrangian package. * bode:: Bode gain and phase plots. * contrib_ode:: Additional routines for ODEs * descriptive:: Descriptive statistics. * diag:: Jordan matrices. * distrib:: Probability distributions. * draw:: A Maxima-Gnuplot interface. * dynamics:: Graphics for dynamical systems and fractals. * ezunits:: Dimensional quantities. * f90:: Maxima to fortran translator. * ggf:: Generating function of sequences. * graphs:: Graph theory package. * grobner:: Functions for working with Groebner bases. * impdiff:: Implicit derivatives. * implicit_plot:: Implicit plots package. * interpol:: Interpolation package. * lapack:: LAPACK functions for linear algebra. * lbfgs:: L-BFGS unconstrained minimization package. * lindstedt:: Lindstedt package. * linearalgebra:: Functions for linear algebra. * lsquares:: Least squares. * makeOrders:: Polynomial utility. * mnewton:: Newton's method. * numericalio:: Reading and writing files. * opsubst:: Substitutions utility. * orthopoly:: Orthogonal polynomials. * plotdf:: Direction fields plots. * romberg:: Romberg method for numerical integration. * simplex:: Linear programming. * simplification:: Simplification rules and functions. * solve_rec:: Linear recurrences. * stats:: Statistical inference package. * stirling:: Stirling formula. * stringproc:: String processing. * unit:: Units and dimensions package. * zeilberger:: Functions for hypergeometric summation. Glossar * Glossar:: Erläuterung von Begriffen. Index * Function and Variable Index:: Index. @c ----------------------------------------------------------------------------- --- Liste der Kapitel --- Einführung * Einführung in Maxima:: Programmfehler * Programmfehler:: * Einführung in Programmfehler:: * Funktionen und Variablen für Programmfehler:: Hilfe * Dokumentation:: * Funktionen und Variablen der Hilfe:: Kommandozeile * Kommandozeile:: * Funktionen und Variablen der Eingabe:: * Funktionen und Variablen der Ausgabe:: Datentypen * Datentypen:: * Einführung in Maxima Zahlen:: * Zeichenketten:: * Funktionen und Variablen für Zahlen:: * Funktionen und Variablen für Zeichenketten:: * Funktionen und Variablen für Konstante:: Ausdrücke * Ausdrücke:: * Einführung in Ausdrücke:: * Substantive und Verben:: * Bezeichner:: * Funktionen und Variablen für Ausdrücke:: Operatoren * Arithmetische Operatoren:: * Relationale Operatoren:: * Logische Operatoren:: * Operatoren für Gleichungen:: * Zuweisungsoperatoren:: * Benutzerdefinierte Operatoren:: Auswertung * Auswertung:: * Funktionen und Variablen für die Auswertung:: Vereinfachung * Vereinfachung:: * Funktionen und Variablen für die Vereinfachung:: Mathematische Funktionen * Mathematische Funktionen:: * Exponentialfunktionen:: * Logarithmusfunktionen:: * Winkel- und Hyperbelfunktionen:: * Sonstige Funktionen:: Deklarationen und Fakten * Deklarationen:: * Funktionen und Variable für Kontexte:: * Funktionen und Variable für Deklarationen:: Grafische Darstellung * Einführung in die grafische Darstellung:: * Funktionen und Variablen für die grafische Darstellung:: Eingabe und Ausgabe * Kommentare:: * Dateien:: * Funktionen und Variablen für die Eingabe und Ausgabe:: * Funktionen und Variablen für die Tex-Ausgabe:: Polynomials * Introduction to Polynomials:: * Functions and Variables for Polynomials:: Special Functions * Introduction to Special Functions:: * Bessel Functions:: * Airy Functions:: * Gamma and factorial Functions:: * Exponential Integrals:: * Error Function:: * Struve Functions:: * Hypergeometric Functions:: * Parabolic Cylinder Functions:: * Functions and Variables for Special Functions:: Elliptic Functions * Introduction to Elliptic Functions and Integrals:: * Functions and Variables for Elliptic Functions:: * Functions and Variables for Elliptic Integrals:: Limits * Functions and Variables for Limits:: Differentiation * Functions and Variables for Differentiation:: Integration * Introduction to Integration:: * Functions and Variables for Integration:: Equations * Functions and Variables for Equations:: Differential Equations * Introduction to Differential Equations:: * Functions and Variables for Differential Equations:: Numerical * Introduction to fast Fourier transform:: * Functions and Variables for fast Fourier transform:: * Introduction to Fourier series:: * Functions and Variables for Fourier series:: Arrays * Functions and Variables for Arrays:: Matrices and Linear Algebra * Introduction to Matrices and Linear Algebra:: * Dot:: * Vectors:: * eigen:: * Functions and Variables for Matrices and Linear Algebra:: Affine * Introduction to Affine:: * Functions and Variables for Affine:: itensor * Introduction to itensor:: * Functions and Variables for itensor:: ctensor * Introduction to ctensor:: * Functions and Variables for ctensor:: atensor * Introduction to atensor:: * Functions and Variables for atensor:: Series * Introduction to Series:: * Functions and Variables for Series:: Number Theory * Functions and Variables for Number Theory:: Symmetries * Introduction to Symmetries:: * Functions and Variables for Symmetries:: Groups * Functions and Variables for Groups:: Runtime Environment * Introduction for Runtime Environment:: * Interrupts:: * Functions and Variables for Runtime Environment:: Miscellaneous Options * Introduction to Miscellaneous Options:: * Share:: * Functions and Variables for Miscellaneous Options:: Rules and Patterns * Introduction to Rules and Patterns:: * Functions and Variables for Rules and Patterns:: Lists * Introduction to Lists:: * Functions and Variables for Lists:: Sets * Introduction to Sets:: * Functions and Variables for Sets:: Function Definition * Introduction to Function Definition:: * Function:: * Macros:: * Functions and Variables for Function Definition:: * Funktionen und Variable für die Funktionsanwendung:: Program Flow * Lisp and Maxima:: * Introduction to Program Flow:: * Functions and Variables for Program Flow:: Debugging * Functions and Variables for Debugging:: augmented_lagrangian * Functions and Variables for augmented_lagrangian:: bode * Functions and Variables for bode:: contrib_ode * Introduction to contrib_ode:: * Functions and Variables for contrib_ode:: * Possible improvements to contrib_ode:: * Test cases for contrib_ode:: * References for contrib_ode:: descriptive * Introduction to descriptive:: * Functions and Variables for data manipulation:: * Functions and Variables for descriptive statistics:: * Functions and Variables for specific multivariate descriptive statistics:: * Functions and Variables for statistical graphs:: diag * Functions and Variables for diag:: distrib * Introduction to distrib:: * Functions and Variables for continuous distributions:: * Functions and Variables for discrete distributions:: draw * Introduction to draw:: * Functions and Variables for draw:: * Functions and Variables for pictures:: * Functions and Variables for worldmap:: dynamics * Introduction to dynamics:: * Functions and Variables for dynamics:: ezunits * Introduction to ezunits:: * Introduction to physical_constants:: * Functions and Variables for ezunits:: f90 * Functions and Variables for f90:: ggf * Functions and Variables for ggf:: graphs * Introduction to graphs:: * Functions and Variables for graphs:: grobner * Introduction to grobner:: * Functions and Variables for grobner:: impdiff * Functions and Variables for impdiff:: implicit_plot * Functions and Variables for implicit_plot:: interpol * Introduction to interpol:: * Functions and Variables for interpol:: lapack * Introduction to lapack:: * Functions and Variables for lapack:: lbfgs * Introduction to lbfgs:: * Functions and Variables for lbfgs:: lindstedt * Functions and Variables for lindstedt:: linearalgebra * Introduction to linearalgebra:: * Functions and Variables for linearalgebra:: lsquares * Introduction to lsquares * Functions and Variables for lsquares:: makeOrders * Functions and Variables for makeOrders:: mnewton * Introduction to mnewton:: * Functions and Variables for mnewton:: numericalio * Introduction to numericalio:: * Functions and Variables for plain-text input and output:: * Functions and Variables for binary input and output:: opsubst * Functions and Variables for opsubst:: orthopoly * Introduction to orthogonal polynomials:: * Functions and Variables for orthogonal polynomials:: plotdf * Introduction to plotdf:: * Functions and Variables for plotdf:: romberg * Functions and Variables for romberg:: simplex * Introduction to simplex:: * Functions and Variables for simplex:: simplification * Introduction to simplification:: * Package absimp:: * Package facexp:: * Package functs:: * Package ineq:: * Package rducon:: * Package scifac:: * Package sqdnst:: solve_rec * Introduction to solve_rec:: * Functions and Variables for solve_rec:: stats * Introduction to stats:: * Functions and Variables for inference_result:: * Functions and Variables for stats:: * Functions and Variables for special distributions:: stirling * Functions and Variables for stirling:: stringproc * Introduction to string processing:: * Functions and Variables for input and output:: * Functions and Variables for characters:: * Functions and Variables for strings:: unit * Introduction to Units:: * Functions and Variables for Units:: zeilberger * Introduction to zeilberger:: * Functions and Variables for zeilberger:: Glossar * Glossar:: @end menu @c ----------------------------------------------------------------------------- @c Put the @node lines here, rather than in the @included files, @c so emacs can automatically update them with C-c C-u C-e. @c nota bene: C-c C-u C-a and texinfo-multiple-files-update will delete @c the detailed node listing! @node Einführung in Maxima, Programmfehler, Top, Top @chapter Einführung in Maxima @include Introduction.de.texi @node Programmfehler, Hilfe, Einführung in Maxima, Top @chapter Programmfehler @include Bugs.de.texi @node Hilfe, Kommandozeile, Programmfehler, Top @chapter Hilfe @include Help.de.texi @node Kommandozeile, Datentypen, Hilfe, Top @chapter Kommandozeile @include Command.de.texi @node Datentypen, Ausdrücke, Kommandozeile, Top @chapter Datentypen @include DataTypes.de.texi @node Ausdrücke, Datentypen, Kommandozeile, Top @chapter Ausdrücke @include Expressions.de.texi @c @node Operatoren, Auswertung, Datentypen, Top @c @chapter Operatoren @c @include Operators.de.texi @c @node Auswertung, Vereinfachung, Operatoren, Top @c @chapter Auswertung @c @include Evaluation.de.texi @c @node Vereinfachung, Mathematische Funktionen, Auswertung, Top @c @chapter Vereinfachung @c @include Simplification.de.texi @c @node Mathematische Funktionen, Deklarationen und Fakten, Vereinfachung, Top @c @chapter Mathematische Funktionen @c @include MathFunctions.de.texi @c @node Deklarationen und Fakten, Grafische Darstellung, Mathematische Funktionen, Top @c @chapter Deklarationen und Fakten @c @include Declarations.de.texi @c @node Grafische Darstellung, Eingabe und Ausgabe, Deklarationen und Fakten, Top @c @chapter Grafische Darstellung @c @include Plotting.de.texi @c @node Eingabe und Ausgabe, Polynomials, Grafische Darstellung, Top @c @chapter Eingabe und Ausgabe @c @include Input.de.texi @c @node Polynomials, Special Functions, Eingabe und Ausgabe, Top @c @chapter Polynomials @c @include Polynomials.texi @c @node Special Functions, Elliptic Functions, Trigonometric, Top @c @chapter Special Functions @c @include Special.texi @c @node Elliptic Functions, Limits, Special Functions, Top @c @chapter Elliptic Functions @c @include Elliptic.texi @c @node Limits, Differentiation, Elliptic Functions, Top @c @chapter Limits @c @include Limits.texi @c @node Differentiation, Integration, Limits, Top @c @chapter Differentiation @c @include Differentiation.texi @c @node Integration, Equations, Differentiation, Top @c @chapter Integration @c @include Integration.texi @c @node Equations, Differential Equations, Integration, Top @c @chapter Equations @c @include Equations.texi @c @node Differential Equations, Numerical, Equations, Top @c @chapter Differential Equations @c @include Differential.texi @c @include NonCommutative.texi @c @node Numerical, Arrays, Differential Equations, Top @c @chapter Numerical @c @include Numerical.texi @c @node Arrays, Matrices and Linear Algebra, Numerical, Top @c @chapter Arrays @c @include Arrays.texi @c @node Matrices and Linear Algebra, Affine, Arrays, Top @c @chapter Matrices and Linear Algebra @c @include Matrices.texi @c @node Affine, itensor, Matrices and Linear Algebra, Top @c @chapter Affine @c @include Affine.texi @c @node itensor, ctensor, Affine, Top @c @chapter itensor @c @include Itensor.texi @c @node ctensor, atensor, itensor, Top @c @chapter ctensor @c @include Ctensor.texi @c @node atensor, Series, ctensor, Top @c @chapter atensor @c @include Atensor.texi @c @node Series, Number Theory, atensor, Top @c @chapter Series @c @include Series.texi @c @node Number Theory, Symmetries, Series, Top @c @chapter Number Theory @c @include Number.texi @c @node Symmetries, Groups, Number Theory, Top @c @chapter Symmetries @c @include Symmetries.texi @c @node Groups, Runtime Environment, Symmetries, Top @c @chapter Groups @c @include Groups.texi @c @node Runtime Environment, Miscellaneous Options, Groups, Top @c @chapter Runtime Environment @c @include Runtime.texi @c @node Miscellaneous Options, Rules and Patterns, Runtime Environment, Top @c @chapter Miscellaneous Options @c @include Miscellaneous.texi @c @node Rules and Patterns, Lists, Miscellaneous Options, Top @c @chapter Rules and Patterns @c @include Rules.texi @c @node Lists, Sets, Rules and Patterns, Top @c @chapter Lists @c @include Lists.de.texi @c @node Sets, Function Definition, Lists, Top @c @chapter Sets @c @include nset.texi @c @node Function Definition, Program Flow, Sets, Top @c @chapter Function Definition @c @include Function.de.texi @c @node Program Flow, Debugging, Function Definition, Top @c @chapter Program Flow @c @include Program.texi @c @node Debugging, augmented_lagrangian, Program Flow, Top @c @chapter Debugging @c @include Debugging.texi @c @node augmented_lagrangian, bode, Debugging, Top @c @chapter augmented_lagrangian @c @include augmented_lagrangian.texi @c @node bode, contrib_ode, augmented_lagrangian, Top @c @chapter bode @c @include bode.texi @c @node contrib_ode, descriptive, bode, Top @c @chapter contrib_ode @c @include contrib_ode.texi @c @node descriptive, diag, contrib_ode, Top @c @chapter descriptive @c @include descriptive.texi @c @node diag, distrib, descriptive, Top @c @chapter diag @c @include diag.texi @c @node distrib, draw, diag, Top @c @chapter distrib @c @include distrib.texi @c @node draw, dynamics, distrib, Top @c @chapter draw @c @include draw.texi @c @node dynamics, ezunits, draw, Top @c @chapter dynamics @c @include dynamics.texi @c @node ezunits, f90, dynamics, Top @c @chapter ezunits @c @include ezunits.texi @c @node f90, ggf, ezunits, Top @c @chapter f90 @c @include f90.texi @c @node ggf, graphs, f90, Top @c @chapter ggf @c @include ggf.texi @c @node graphs, grobner, ggf, Top @c @chapter graphs @c @include graphs.texi @c @node grobner, impdiff, graphs, Top @c @chapter grobner @c @include grobner.texi @c @node impdiff, implicit_plot, grobner, Top @c @chapter impdiff @c @include impdiff.texi @c @node implicit_plot, interpol, impdiff, Top @c @chapter implicit_plot @c @include implicit_plot.texi @c @node interpol, lapack, implicit_plot, Top @c @chapter interpol @c @include interpol.texi @c @node lapack, lbfgs, interpol, Top @c @chapter lapack @c @include lapack.texi @c @node lbfgs, lindstedt, lapack, Top @c @chapter lbfgs @c @include lbfgs.texi @c @node lindstedt, linearalgebra, lbfgs, Top @c @chapter lindstedt @c @include lindstedt.texi @c @node linearalgebra, lsquares, lindstedt, Top @c @chapter linearalgebra @c @include linearalgebra.texi @c @node lsquares, makeOrders, linearalgebra, Top @c @chapter lsquares @c @include lsquares.texi @c @node makeOrders, mnewton, lsquares, Top @c @chapter makeOrders @c @include makeOrders.texi @c @node mnewton, numericalio, makeOrders, Top @c @chapter mnewton @c @include mnewton.texi @c @node numericalio, opsubst, mnewton, Top @c @chapter numericalio @c @include numericalio.texi @c @node opsubst, orthopoly, numericalio, Top @c @chapter opsubst @c @include opsubst.texi @c @node orthopoly, plotdf, opsubst, Top @c @chapter orthopoly @c @include orthopoly.texi @c @node plotdf, romberg, orthopoly, Top @c @chapter plotdf @c @include plotdf.texi @c @node romberg, simplex, plotdf, Top @c @chapter romberg @c @include romberg.texi @c @node simplex, simplification, romberg, Top @c @chapter simplex @c @include simplex.texi @c @node simplification, solve_rec, simplex, Top @c @chapter simplification @c @include simplifications.texi @c @node solve_rec, stats, simplification, Top @c @chapter solve_rec @c @include solve_rec.texi @c @node stats, stirling, solve_rec, Top @c @chapter stats @c @include stats.texi @c @node stirling, stringproc, stats, Top @c @chapter stirling @c @include stirling.texi @c @node stringproc, unit, stirling, Top @c @chapter stringproc @c @include stringproc.texi @c @node unit, zeilberger, stringproc, Top @c @chapter unit @c @include unit.texi @c @node zeilberger, Function and Variable Index, unit, Top @c @chapter zeilberger @c @include zeilberger.texi @c @node Glossar, Function and Variable Index, zeilberger, Top @c @chapter Glossar @c @include Glossary.de.texi @node Function and Variable Index, , Glossar, Top @chapter Indizes @include Indices.de.texi @c end includes --- NEW FILE: DataTypes.de.texi --- @c ----------------------------------------------------------------------------- @c File : DataTypes.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Date : 15.10.2010 @c @c This file contains documentation for the following symbols: @c @c bfloat bfloatp bftorat bftrunc @c evenp float float2bf floatnump @c fpprec fpprintprec integerp m1pbranch @c nonnegintegerp numberp number_pbranch oddp @c ratepsilon rationalize ratnump @c concat sconcat string stringdisp @c %e %i false %gamma @c ind inf infinity minf @c %phi %pi true und @c zeroa zerob @c [...1331 lines suppressed...] @c --- 15.10.2010 DK ----------------------------------------------------------- @defvr {Konstante} zerob @c @code{zerob} represents an infinitesimal below zero. @code{zerob} can be used @c in expressions. @code{limit} simplifies expressions which contain @c infinitesimals. @code{zerob} repräsentiert eine negative unendlich kleine Zahl. @code{zerob} kann in Ausdrücken benutzt werden. Die Funktion @code{limit} vereinfacht Ausdrücke, die infinitesimale GröÃen enthalten. Siehe auch @code{zeroa} und @code{limit}. @c @opencatbox @c @category{Konstante} @c @closecatbox @end defvr @c --- End of file DataTypes.de.texi ------------------------------------------- --- NEW FILE: Expressions.de.texi --- @c ----------------------------------------------------------------------------- @c File : Expressions.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Date : 15.10.2010 @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @menu * Einführung in Ausdrücke:: * Substantive und Verben:: * Bezeichner:: * Funktionen und Variablen für Ausdrücke:: @end menu @c --- 15.10.2010 DK ----------------------------------------------------------- @node Einführung in Ausdrücke, Substantive und Verben, Ausdrücke, Top @section Einführung in Ausdrücke [...2590 lines suppressed...] @c :lisp $% @c ===end=== @example (%i1) verbify ('foo); (%o1) foo (%i2) :lisp $% $FOO (%i2) nounify (foo); (%o2) foo (%i3) :lisp $% %FOO @end example @c @opencatbox @c @category{Substantive und Verben} @category{Ausdrücke} @c @closecatbox @end deffn @c --- End of file Expressions.de.texi ----------------------------------------- --- NEW FILE: Bugs.de.texi --- @c ----------------------------------------------------------------------------- @c File : Bugs.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Date : 15.10.2010 @c @c This file contains documentation for the following Maxima symbols: @c @c run_testsuite @c testsuite_files @c bugreport @c build_info @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @menu * Einführung in Programmfehler:: * Funktionen und Variablen für Programmfehler:: @end menu @c --- 15.10.2010 DK ----------------------------------------------------------- @node Einführung in Programmfehler, Funktionen und Variablen für Programmfehler, Programmfehler, Top @section Einführung in Programmfehler Maxima wird ständig weiterentwickelt. Der Funktionsumfang wird erweitert und Fehler, die bei einem Programm dieser Komplexität kaum zu vermeiden sind, werden korrigiert. Vermutet der Nutzer einen Fehler, kann dieser berichtet werden. Werden ausreichend Informationen mitgeteilt, können die Entwickler Maxima weiter verbessern. Ein aktueller Link zur Website zum Berichten von Fehlern sowie die notwendigen Informationen über die Maxima-Installation werden mit dem Befehl @code{bug_report()} angezeigt. Um die Installation auf dem Rechner zu testen, kann die Maxima-Testsuite ausgeführt werden. Die folgende Ãbersicht zeigt die Maxima-Kommandos für das Berichten von Fehlern: @verbatim run_testsuite testsuite_files bug_report build_info @end verbatim @c --- 15.10.2010 DK ----------------------------------------------------------- @node Funktionen und Variablen für Programmfehler, , Einführung in Programmfehler, Programmfehler @section Funktionen und Variablen für Programmfehler @c --- 15.10.2010 DK ----------------------------------------------------------- @deffn {Funktion} run_testsuite ([@var{options}]) @c Run the Maxima test suite. Tests producing the desired answer are @c considered ``passes,'' as are tests that do not produce the desired @c answer, but are marked as known bugs. Das Kommando @code{run_testsuite} führt die Maxima-Testsuite aus. Erfolgreiche Tests und Tests, die zwar nicht erfolgreich, aber als ein bekannter Fehler gekennzeichnet sind, geben die Meldung "passed". @c @code{run_testsuite} takes the following optional keyword arguments @code{run_testsuite} akzeptiert die folgenden optionalen Schlüsselworte als Argumente: @table @var @item display_all @c Display all tests. Normally, the tests are not displayed, unless the test @c fails. (Defaults to @code{false}). Erhält das Schlüsselwort @code{display_all} den Wert @code{true}, werden alle Tests angezeigt. Der Standardwert ist @code{false}. In diesem Fall werden nur die Tests angezeigt, die fehlschlagen. @item display_known_bugs @c Displays tests that are marked as known bugs. (Default is @code{false}). Erhält das Schlüsselwort @code{display_known_bugs} den Wert @code{true}, werden alle Tests angezeigt, die als fehlerhaft gekennzeichnet sind. Der Standardwert ist @code{false}. @item tests @c This is a list of tests that should be run. Each test can be @c specified by either a string or a symbol. By default, all tests are @c run. The complete set of tests is specified by @code{testsuite_files}. Das Schlüsselwort @code{tests} erhält eine Liste mit den Testdateien, die ausgeführt werden sollen. Eine Testdatei kann durch eine Zeichenkette oder ein Symbol angegeben werden. Der Standard ist, dass alle Testdateien ausgeführt werden, die in der Optionsvariablen @code{testsuite_files} enthalten sind. Siehe auch @code{testsuite_files}. @item time @c Display time information. If @code{true}, the time taken for each @c test file is displayed. If @code{all}, the time for each individual @c test is shown if @code{display_all} is @code{true}. The default is @c @code{false}, so no timing information is shown. Hat das Schlüsselwort @code{time} den Wert @code{true}, werden die Laufzeiten der einzelnen Testdateien angezeigt. Hat @code{time} den Wert @code{all} und @code{display_all} den Wert @code{true}, wird die Laufzeit jedes einzelnen Tests angezeigt. Der Standardwert ist @code{false}. @end table @c For example @code{run_testsuite(display_known_bugs = true, tests=[rtest5])} @c runs just test @code{rtest5} and displays the test that are marked as @c known bugs. Zum Beispiel führt @code{run_testsuite(display_known_bugs = true, tests = [rtest5])} die Testdatei @code{rtest5} aus und zeigt die Tests an, die als fehlerhaft gekennzeichnet sind. @c @code{run_testsuite(display_all = true, tests=["rtest1", rtest1a])} will @c run tests @code{rtest1} and @code{rtest2}, and displays each test. @code{run_testsuite(display_all = true, tests = ["rtest1", rtest2])} führt die Testdateien @code{rtest1} und @code{rtest2} aus und zeigt jeden einzelnen Test an. @c @code{run_testsuite} changes the Maxima environment. @c Typically a test script executes @code{kill} to establish a known environment @c (namely one without user-defined functions and variables) @c and then defines functions and variables appropriate to the test. Es ist zu beachten, dass das Ausführen einer Testdatei die Maxima-Umgebung ändern kann. Typischerweise führt eine Testdatei zuerst das Kommando @code{kill} aus, um eine definierte Umgebung herzustellen, in der keine benutzerdefinierten Funktionen und Variablen vorhanden sind. @c @code{run_testsuite} returns @code{done}. @code{run_testsuite} hat den Rückgabewert @code{done}. @c @opencatbox @c @category{Fehlersuche} @c @closecatbox @end deffn @c --- 15.10.2010 DK ----------------------------------------------------------- @defvr {Optionsvariable} testsuite_files @c @code{testsuite_files} is the set of tests to be run by @c @code{run_testsuite}. It is a list of names of the files containing @c the tests to run. If some of the tests in a file are known to fail, @c then instead of listing the name of the file, a list containing the @c file name and the test numbers that fail is used. Die Optionsvariable @code{testsuite_files} enthält die Liste der Testdateien, die von @code{run_testsuite} standardmäÃig ausgeführt werden. Wenn bekannt ist, dass einzelne Tests einer Testdatei fehlschlagen werden, dann wird anstatt dem Namen der Datei eine Liste eingefügt, die den Namen und die Nummern der fehlerhaften Tests enthält. @c For example, this is a part of the default set of tests: Das folgende Beispiel zeigt, wie fehlerhafte Tests gekennzeichnet werden: @example ["rtest13s", ["rtest14", 57, 63]] @end example @c This specifies the testsuite consists of the files "rtest13s" and @c "rtest14", but "rtest14" contains two tests that are known to fail: 57 @c and 63. Die Einträge der Liste bedeuten, dass die Dateien "rtest13s" und "rtest14" ausgeführt werden sollen und dass bekannt ist, dass die Tests mit den Nummern 57 und 63 der Testdatei "rtest14" fehlschlagen werden. @c @opencatbox @c @category{Fehlersuche} @category{Optionsvariablen} @c @closecatbox @end defvr @c --- 15.10.2010 DK ----------------------------------------------------------- @deffn {Funktion} bug_report () @c Prints out Maxima and Lisp version numbers, and gives a link @c to the Maxima project bug report web page. @c The version information is the same as reported by @code{build_info}. Zeigt die Maxima- und Lisp-Version sowie einen Link zur Maxima-Projekt Webseite. Die Informationen zur Version werden auch von @code{build_info} angezeigt. @c When a bug is reported, it is helpful to copy the Maxima @c and Lisp version information into the bug report. Wenn ein Programmfehler berichtet wird, ist es hilfreich, die Maxima- und Lisp-Version in den Fehlerbericht aufzunehmen. @c @code{bug_report} returns an empty string @code{""}. @code{bug_report} gibt eine leere Zeichenkette @code{""} zurück. Beispiel: @example (%i1) bug_report(); The Maxima bug database is available at http://sourceforge.net/tracker/?atid=104933&group_id=4933&func=browse Submit bug reports by following the 'Add new' link on that page. Please include the following information with your bug report: ------------------------------------------------------------- Maxima version: 5.20post Maxima build date: 19:59 5/10/2010 Host type: i686-pc-linux-gnu Lisp implementation type: SBCL Lisp implementation version: 1.0.29.11.debian ------------------------------------------------------------- The above information is also reported by the function 'build_info'. @end example @c @opencatbox @c @category{Fehlersuche} @c @closecatbox @end deffn @c --- 15.10.2010 DK ----------------------------------------------------------- @deffn {Funktion} build_info () @c Prints out a summary of the parameters of the Maxima build. Zeigt eine übersicht mit Angaben zur installierten Version von Maxima. @c @code{build_info} returns an empty string @code{""}. @code{build_info} gibt eine leere Zeichenkette @code{""} zurück. Beispiel: @example (%i1) build_info(); Maxima version: 5.20post Maxima build date: 19:59 5/10/2010 Host type: i686-pc-linux-gnu Lisp implementation type: SBCL Lisp implementation version: 1.0.29.11.debian @end example @c @opencatbox @c @category{Fehlersuche} @c @closecatbox @end deffn @c --- End of file Bugs.de.texi ------------------------------------------------ --- NEW FILE: Introduction.de.texi --- @c ----------------------------------------------------------------------------- @c File : Introduction.de.texi @c License : GNU General Public License (GPL) @c Language : German @c Date : 15.10.2010 @c @c This file is part of Maxima -- GPL CAS based on DOE-MACSYMA @c ----------------------------------------------------------------------------- @c Start Maxima with the command "maxima". Maxima will display version @c information and a prompt. End each Maxima command with a semicolon. @c End the session with the command "quit();". Here's a sample session: Von einer Kommandozeile wird Maxima mit dem Kommando @code{maxima} gestartet. Maxima zeigt die aktuelle Version an und gibt einen Prompt für die Eingabe aus. Ein Maxima-Kommando wird mit einem Semikolon abgeschlossen. Eine Maxima-Sitzung wird mit dem Kommando @code{quit();} beendet. Es folgt ein Beispiel für eine Sitzung: @example [wfs@@chromium]$ maxima Maxima 5.9.1 http://maxima.sourceforge.net Using Lisp CMU Common Lisp 19a Distributed under the GNU Public License. See the file COPYING. Dedicated to the memory of William Schelter. This is a development version of Maxima. The function bug_report() provides bug reporting information. (%i1) factor(10!); 8 4 2 (%o1) 2 3 5 7 (%i2) expand ((x + y)^6); 6 5 2 4 3 3 4 2 5 6 (%o2) y + 6 x y + 15 x y + 20 x y + 15 x y + 6 x y + x (%i3) factor (x^6 - 1); 2 2 (%o3) (x - 1) (x + 1) (x - x + 1) (x + x + 1) (%i4) quit(); [wfs@@chromium]$ @end example @c Maxima can search the info pages. Use the @kbd{describe} command to show @c information about the command or all the commands and variables containing @c a string. @c The question mark @code{?} (exact search) and double question mark @code{??} @c (inexact search) are abbreviations for @code{describe}: Maxima kann GNU Infotext anzeigen. Das Kommando @code{describe(text)} zeigt alle Inhalte an, die die Zeichenkette @code{text} enthalten. Das Fragezeichen @code{?} (exakte Suche) und zwei Fragezeichen @code{??} (ungenaue Suche) sind abkürzende Schreibweisen für @code{describe}: @example @c Maxima 5.20post (%i1) ?? integrat 0: Functions and Variables for Integration 1: Introduction to Integration 2: integrate (Functions and Variables for Integration) 3: integrate_use_rootsof (Functions and Variables for Integration) 4: integration_constant (Functions and Variables for Integration) 5: integration_constant_counter (Functions and Variables for Integration) Enter space-separated numbers, `all' or `none': 4 -- System variable: integration_constant Default value: `%c' When a constant of integration is introduced by indefinite integration of an equation, the name of the constant is constructed by concatenating `integration_constant' and `integration_constant_counter'. `integration_constant' may be assigned any symbol. Examples: (%i1) integrate (x^2 = 1, x); 3 x (%o1) -- = x + %c1 3 (%i2) integration_constant : 'k; (%o2) k (%i3) integrate (x^2 = 1, x); 3 x (%o3) -- = x + k2 3 (%o1) true @end example @c To use a result in later calculations, you can assign it to a variable or @c refer to it by its automatically supplied label. In addition, @kbd{%} @c refers to the most recent calculated result: Das Ergebnis einer Rechnung wird mit dem Operator @code{:} einer Variablen zugewiesen. Weiterhin speichert Maxima die Eingaben unter den Marken @code{(%i)} und die Ausgaben unter den Marken @code{(%o)} ab. Die Marken erhalten eine fortlaufende Nummerierung. Mit diesen Marken kann auf frühere Eingaben und Ausgaben zurückgegriffen werden. Auf das letzte Ergebnis kann mit @code{%} zurückgegriffen werden. @c ===beg=== @c u: expand ((x + y)^6); @c diff(u,x); @c factor(%o2); @c %/6; @c ===end=== @example (%i1) u: expand ((x + y)^6); 6 5 2 4 3 3 4 2 5 6 (%o1) y + 6 x y + 15 x y + 20 x y + 15 x y + 6 x y + x (%i2) diff(u,x); 5 4 2 3 3 2 4 5 (%o2) 6 y + 30 x y + 60 x y + 60 x y + 30 x y + 6 x (%i3) factor(%o2); 5 (%o3) 6 (y + x) (%i4) %/6; 5 (%o4) (y + x) @end example @c Maxima knows about complex numbers and numerical constants: Maxima kennt nummerische Konstanten und kann mit komplexen Zahlen rechnen: @c ===beg=== @c cos(%pi); @c exp(%i*%pi); @c ===end=== @example (%i1) cos(%pi); (%o1) - 1 (%i2) exp(%i*%pi); (%o2) - 1 @end example @c Maxima can do differential and integral calculus... [truncated message content] |