# Maxima branch_5_47_base_7_g39559bd_dirty Manual

## Short Table of Contents

- 1 Introduction to Maxima
- 2 Bug Detection and Reporting
- 3 Help
- 4 Command Line
- 5 Data Types and Structures
- 6 Expressions
- 7 Operators
- 8 Evaluation
- 9 Simplification
- 10 Mathematical Functions
- 11 Maximas Database
- 12 Plotting
- 13 File Input and Output
- 14 Polynomials
- 15 Special Functions
- 16 Elliptic Functions
- 17 Limits
- 18 Differentiation
- 19 Integration
- 20 Equations
- 21 Differential Equations
- 22 Numerical
- 23 Matrices and Linear Algebra
- 24 Affine
- 25 itensor
- 26 ctensor
- 27 atensor
- 28 Sums, Products, and Series
- 29 Number Theory
- 30 Symmetries
- 31 Groups
- 32 Runtime Environment
- 33 Miscellaneous Options
- 34 Rules and Patterns
- 35 Sets
- 36 Function Definition
- 37 Program Flow
- 38 Debugging
- 39 asympa
- 40 augmented_lagrangian
- 41 Bernstein
- 42 bode
- 43 cobyla
- 44 contrib_ode
- 45 descriptive
- 46 diag
- 47 distrib
- 48 draw
- 49 drawdf
- 50 dynamics
- 51 ezunits
- 52 f90
- 53 finance
- 54 fractals
- 55 ggf
- 56 graphs
- 57 grobner
- 58 impdiff
- 59 implicit_plot
- 60 interpol
- 61 lapack
- 62 lbfgs
- 63 lindstedt
- 64 linearalgebra
- 65 lsquares
- 66 minpack
- 67 makeOrders
- 68 mnewton
- 69 numericalio
- 70 opsubst
- 71 orthopoly
- 72 plotdf
- 73 romberg
- 74 simplex
- 75 simplification
- 76 solve_rec
- 77 stats
- 78 stirling
- 79 stringproc
- 80 to_poly_solve
- 81 unit
- 82 zeilberger
- 83 Indices
- Appendix A Translator’s Comments
- B Documentation Categories

## Table of Contents

- 1 Introduction to Maxima
- 2 Bug Detection and Reporting
  - 2.1 Functions and Variables for Bug Detection and Reporting
- 3 Help
  - 3.1 Documentation
  - 3.2 Functions and Variables for Help
- 4 Command Line
  - 4.1 Introduction to Command Line
  - 4.2 Functions and Variables for Command Line
  - 4.3 Functions and Variables for Display
- 5 Data Types and Structures
  - 5.1 Numbers
    - 5.1.1 Introduction to Numbers
    - 5.1.2 Functions and Variables for Numbers
  - 5.2 Strings
    - 5.2.1 Introduction to Strings
    - 5.2.2 Functions and Variables for Strings
  - 5.3 Constants
  - 5.4 Functions and Variables for Constants
  - 5.5 Lists
    - 5.5.1 Introduction to Lists
    - 5.5.2 Functions and Variables for Lists
  - 5.6 Arrays
  - 5.7 Functions and Variables for Arrays
  - 5.8 Structures
    - 5.8.1 Introduction to Structures
    - 5.8.2 Functions and Variables for Structures
- 6 Expressions
  - 6.1 Introduction to Expressions
  - 6.2 Nouns and Verbs
  - 6.3 Identifiers
  - 6.4 Inequality
  - 6.5 Functions and Variables for Expressions
- 7 Operators
  - 7.1 Introduction to operators
  - 7.2 Arithmetic operators
  - 7.3 Relational operators
  - 7.4 Logical operators
  - 7.5 Operators for Equations
  - 7.6 Assignment operators
  - 7.7 User defined operators
- 8 Evaluation
  - 8.1 Functions and Variables for Evaluation
- 9 Simplification
  - 9.1 Functions and Variables for Simplification
- 10 Mathematical Functions
  - 10.1 Functions for Numbers
  - 10.2 Functions for Complex Numbers
  - 10.3 Combinatorial Functions
  - 10.4 Root, Exponential and Logarithmic Functions
  - 10.5 Trigonometric Functions
    - 10.5.1 Introduction to Trigonometric
    - 10.5.2 Functions and Variables for Trigonometric
  - 10.6 Random Numbers
- 11 Maximas Database
  - 11.1 Introduction to Maximas Database
  - 11.2 Functions and Variables for Properties
  - 11.3 Functions and Variables for Facts
  - 11.4 Functions and Variables for Predicates
- 12 Plotting
  - 12.1 Introduction to Plotting
  - 12.2 Plotting Formats
  - 12.3 Functions and Variables for Plotting
  - 12.4 Plotting Options
  - 12.5 Gnuplot Options
  - 12.6 Gnuplot_pipes Format Functions
- 13 File Input and Output
  - 13.1 Comments
  - 13.2 Files
  - 13.3 Functions and Variables for File Input and Output
- 14 Polynomials
  - 14.1 Introduction to Polynomials
  - 14.2 Functions and Variables for Polynomials
- 15 Special Functions
  - 15.1 Introduction to Special Functions
  - 15.2 Bessel Functions
  - 15.3 Airy Functions
  - 15.4 Gamma and factorial Functions
  - 15.5 Exponential Integrals
  - 15.6 Error Function
  - 15.7 Struve Functions
  - 15.8 Hypergeometric Functions
  - 15.9 Parabolic Cylinder Functions
  - 15.10 Functions and Variables for Special Functions
- 16 Elliptic Functions
  - 16.1 Introduction to Elliptic Functions and Integrals
  - 16.2 Functions and Variables for Elliptic Functions
  - 16.3 Functions and Variables for Elliptic Integrals
- 17 Limits
  - 17.1 Functions and Variables for Limits
- 18 Differentiation
  - 18.1 Functions and Variables for Differentiation
- 19 Integration
  - 19.1 Introduction to Integration
  - 19.2 Functions and Variables for Integration
  - 19.3 Introduction to QUADPACK
    - 19.3.1 Overview
  - 19.4 Functions and Variables for QUADPACK
- 20 Equations
  - 20.1 Functions and Variables for Equations
- 21 Differential Equations
  - 21.1 Introduction to Differential Equations
  - 21.2 Functions and Variables for Differential Equations
- 22 Numerical
  - 22.1 Introduction to fast Fourier transform
  - 22.2 Functions and Variables for fast Fourier transform
  - 22.3 Introduction to Fourier series
  - 22.4 Functions and Variables for Fourier series
- 23 Matrices and Linear Algebra
  - 23.1 Introduction to Matrices and Linear Algebra
    - 23.1.1 Dot
    - 23.1.2 Vectors
    - 23.1.3 eigen
  - 23.2 Functions and Variables for Matrices and Linear Algebra
- 24 Affine
  - 24.1 Introduction to Affine
  - 24.2 Functions and Variables for Affine
- 25 itensor
  - 25.1 Introduction to itensor
    - 25.1.1 New tensor notation
    - 25.1.2 Indicial tensor manipulation
  - 25.2 Functions and Variables for itensor
    - 25.2.1 Managing indexed objects
    - 25.2.2 Tensor symmetries
    - 25.2.3 Indicial tensor calculus
    - 25.2.4 Tensors in curved spaces
    - 25.2.5 Moving frames
    - 25.2.6 Torsion and nonmetricity
    - 25.2.7 Exterior algebra
    - 25.2.8 Exporting TeX expressions
    - 25.2.9 Interfacing with ctensor
    - 25.2.10 Reserved words
- 26 ctensor
  - 26.1 Introduction to ctensor
  - 26.2 Functions and Variables for ctensor
    - 26.2.1 Initialization and setup
    - 26.2.2 The tensors of curved space
    - 26.2.3 Taylor series expansion
    - 26.2.4 Frame fields
    - 26.2.5 Algebraic classification
    - 26.2.6 Torsion and nonmetricity
    - 26.2.7 Miscellaneous features
    - 26.2.8 Utility functions
    - 26.2.9 Variables used by `ctensor`
    - 26.2.10 Reserved names
    - 26.2.11 Changes
- 27 atensor
  - 27.1 Introduction to atensor
  - 27.2 Functions and Variables for atensor
- 28 Sums, Products, and Series
  - 28.1 Sums and Products
  - 28.2 Introduction to Series
  - 28.3 Functions and Variables for Series
  - 28.4 Poisson series
- 29 Number Theory
  - 29.1 Functions and Variables for Number Theory
- 30 Symmetries
  - 30.1 Introduction to Symmetries
  - 30.2 Functions and Variables for Symmetries
    - 30.2.1 Changing bases
    - 30.2.2 Changing representations
    - 30.2.3 Groups and orbits
    - 30.2.4 Partitions
    - 30.2.5 Polynomials and their roots
    - 30.2.6 Resolvents
    - 30.2.7 Miscellaneous
- 31 Groups
  - 31.1 Functions and Variables for Groups
- 32 Runtime Environment
  - 32.1 Introduction for Runtime Environment
  - 32.2 Interrupts
  - 32.3 Functions and Variables for Runtime Environment
- 33 Miscellaneous Options
  - 33.1 Introduction to Miscellaneous Options
  - 33.2 Share
  - 33.3 Functions and Variables for Miscellaneous Options
- 34 Rules and Patterns
  - 34.1 Introduction to Rules and Patterns
  - 34.2 Functions and Variables for Rules and Patterns
- 35 Sets
  - 35.1 Introduction to Sets
    - 35.1.1 Usage
    - 35.1.2 Set Member Iteration
    - 35.1.3 Bugs
    - 35.1.4 Authors
  - 35.2 Functions and Variables for Sets
- 36 Function Definition
  - 36.1 Introduction to Function Definition
  - 36.2 Function
    - 36.2.1 Ordinary functions
    - 36.2.2 Array functions
  - 36.3 Macros
  - 36.4 Functions and Variables for Function Definition
- 37 Program Flow
  - 37.1 Lisp and Maxima
  - 37.2 Garbage Collection
  - 37.3 Introduction to Program Flow
  - 37.4 Functions and Variables for Program Flow
- 38 Debugging
  - 38.1 Source Level Debugging
  - 38.2 Keyword Commands
  - 38.3 Functions and Variables for Debugging
- 39 asympa
  - 39.1 Introduction to asympa
  - 39.2 Functions and variables for asympa
- 40 augmented_lagrangian
  - 40.1 Functions and Variables for augmented_lagrangian
- 41 Bernstein
  - 41.1 Functions and Variables for Bernstein
- 42 bode
  - 42.1 Functions and Variables for bode
- 43 cobyla
  - 43.1 Introduction to cobyla
  - 43.2 Functions and Variables for cobyla
  - 43.3 Examples for cobyla
- 44 contrib_ode
  - 44.1 Introduction to contrib_ode
  - 44.2 Functions and Variables for contrib_ode
  - 44.3 Possible improvements to contrib_ode
  - 44.4 Test cases for contrib_ode
  - 44.5 References for contrib_ode
- 45 descriptive
  - 45.1 Introduction to descriptive
  - 45.2 Functions and Variables for data manipulation
  - 45.3 Functions and Variables for descriptive statistics
  - 45.4 Functions and Variables for statistical graphs
- 46 diag
  - 46.1 Functions and Variables for diag
- 47 distrib
  - 47.1 Introduction to distrib
  - 47.2 Functions and Variables for continuous distributions
  - 47.3 Functions and Variables for discrete distributions
- 48 draw
  - 48.1 Introduction to draw
  - 48.2 Functions and Variables for draw
    - 48.2.1 Scenes
    - 48.2.2 Functions
    - 48.2.3 Graphic options
    - 48.2.4 Graphics objects
  - 48.3 Functions and Variables for pictures
  - 48.4 Functions and Variables for worldmap
    - 48.4.1 Variable and Functions
    - 48.4.2 Graphic objects
- 49 drawdf
  - 49.1 Introduction to drawdf
  - 49.2 Functions and Variables for drawdf
    - 49.2.1 Functions
- 50 dynamics
  - 50.1 Introduction to dynamics
  - 50.2 Functions and Variables for dynamics
- 51 ezunits
  - 51.1 Introduction to ezunits
  - 51.2 Introduction to physical_constants
  - 51.3 Functions and Variables for ezunits
- 52 f90
  - 52.1 Functions and Variables for f90
- 53 finance
  - 53.1 Introduction to finance
  - 53.2 Functions and Variables for finance
- 54 fractals
  - 54.1 Introduction to fractals
  - 54.2 Definitions for IFS fractals
  - 54.3 Definitions for complex fractals
  - 54.4 Definitions for Koch snowflakes
  - 54.5 Definitions for Peano maps
- 55 ggf
  - 55.1 Functions and Variables for ggf
- 56 graphs
  - 56.1 Introduction to graphs
  - 56.2 Functions and Variables for graphs
    - 56.2.1 Building graphs
    - 56.2.2 Graph properties
    - 56.2.3 Modifying graphs
    - 56.2.4 Reading and writing to files
    - 56.2.5 Visualization
- 57 grobner
  - 57.1 Introduction to grobner
    - 57.1.1 Notes on the grobner package
    - 57.1.2 Implementations of admissible monomial orders in grobner
  - 57.2 Functions and Variables for grobner
    - 57.2.1 Global switches for grobner
    - 57.2.2 Simple operators in grobner
    - 57.2.3 Other functions in grobner
    - 57.2.4 Standard postprocessing of Groebner Bases
- 58 impdiff
  - 58.1 Functions and Variables for impdiff
- 59 implicit_plot
  - 59.1 Functions and Variables for implicit_plot
- 60 interpol
  - 60.1 Introduction to interpol
  - 60.2 Functions and Variables for interpol
- 61 lapack
  - 61.1 Introduction to lapack
  - 61.2 Functions and Variables for lapack
- 62 lbfgs
  - 62.1 Introduction to lbfgs
  - 62.2 Functions and Variables for lbfgs
- 63 lindstedt
  - 63.1 Functions and Variables for lindstedt
- 64 linearalgebra
  - 64.1 Introduction to linearalgebra
  - 64.2 Functions and Variables for linearalgebra
- 65 lsquares
  - 65.1 Introduction to lsquares
  - 65.2 Functions and Variables for lsquares
- 66 minpack
  - 66.1 Introduction to minpack
  - 66.2 Functions and Variables for minpack
- 67 makeOrders
  - 67.1 Functions and Variables for makeOrders
- 68 mnewton
  - 68.1 Introduction to mnewton
  - 68.2 Functions and Variables for mnewton
- 69 numericalio
  - 69.1 Introduction to numericalio
    - 69.1.1 Plain-text input and output
    - 69.1.2 Separator flag values for input
    - 69.1.3 Separator flag values for output
    - 69.1.4 Binary floating-point input and output
  - 69.2 Functions and Variables for plain-text input and output
  - 69.3 Functions and Variables for binary input and output
- 70 opsubst
  - 70.1 Functions and Variables for opsubst
- 71 orthopoly
  - 71.1 Introduction to orthogonal polynomials
    - 71.1.1 Getting Started with orthopoly
    - 71.1.2 Limitations
    - 71.1.3 Floating point Evaluation
    - 71.1.4 Graphics and `orthopoly`
    - 71.1.5 Miscellaneous Functions
    - 71.1.6 Algorithms
  - 71.2 Functions and Variables for orthogonal polynomials
- 72 plotdf
  - 72.1 Introduction to plotdf
  - 72.2 Functions and Variables for plotdf
- 73 romberg
  - 73.1 Functions and Variables for romberg
- 74 simplex
  - 74.1 Introduction to simplex
  - 74.2 Functions and Variables for simplex
- 75 simplification
  - 75.1 Introduction to simplification
  - 75.2 Package absimp
  - 75.3 Package facexp
  - 75.4 Package functs
  - 75.5 Package ineq
  - 75.6 Package rducon
  - 75.7 Package scifac
  - 75.8 Package sqdnst
- 76 solve_rec
  - 76.1 Introduction to solve_rec
  - 76.2 Functions and Variables for solve_rec
- 77 stats
  - 77.1 Introduction to stats
  - 77.2 Functions and Variables for inference_result
  - 77.3 Functions and Variables for stats
  - 77.4 Functions and Variables for special distributions
- 78 stirling
  - 78.1 Functions and Variables for stirling
- 79 stringproc
  - 79.1 Introduction to string processing
  - 79.2 Functions and Variables for input and output
  - 79.3 Functions and Variables for characters
  - 79.4 Functions and Variables for strings
- 80 to_poly_solve
  - 80.1 Functions and Variables for to_poly_solve
- 81 unit
  - 81.1 Introduction to Units
  - 81.2 Functions and Variables for Units
- 82 zeilberger
  - 82.1 Introduction to zeilberger
    - 82.1.1 The indefinite summation problem
    - 82.1.2 The definite summation problem
    - 82.1.3 Verbosity levels
  - 82.2 Functions and Variables for zeilberger
  - 82.3 General global variables
  - 82.4 Variables related to the modular test
- 83 Indices
- Appendix A Translator’s Comments
  - A.1 Translation Policies
  - A.2 About Terms in Japanese
- B Documentation Categories

Next: Introduction to Maxima, Previous: (dir), Up: (dir) [Contents][Index]

Maximaはコンピュータ代数システムです。Lispで実装されています。

MaximaはMacsymaシステムから派生したものです。 Macsymaシステムは、MITで1968年から1982年にかけてプロジェクトMACの一部として開発されました。 MITは、1982年にMacsymaソースコードのコピーをエネルギー省に引き渡しました; そのバージョンは現在、DOE Macsymaとして知られています。 DOE Macsymaのコピーは、テキサス大学のWilliam F. Schelter教授によって、 1982年から教授がなくなる2001年まで保守されました。 1998年にSchelterは、 エネルギー省からDOE MacsymaソースコードをGNU Public Licenseの下で公開する許可を得て、 2000年に彼は、 DOE Macsymaを保守・開発するために、MaximaプロジェクトをSourceForgeで始めました。 だから、Maximaと呼ばれています。

Next: Bug Detection and Reporting, Previous: Top, Up: Top [Contents][Index]

## 1 Introduction to Maxima

コマンド"maxima"でMaximaを起動してください。 Maximaがバージョン情報とプロンプトを表示します。 それぞれのMaximaコマンドにはセミコロンを終わりに付けてください。 コマンド"quit();"でセッションが終了します。 以下は、セッションのサンプルです。

    [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]$

Maximaはインフォページを検索できます。 コマンドの情報や、文字列を含むコマンドや変数すべてを表示させるには、 `describe`コマンドを使ってください。 クエスチョンマーク`?` (完全一致検索)と 二重クエスチョンマーク`??`(部分一致検索)は`describe`の省略形です:

    (%i1) ?? integ
     0: Functions and Variables for Elliptic Integrals
     1: Functions and Variables for Integration
     2: Introduction to Elliptic Functions and Integrals
     3: Introduction to Integration
     4: askinteger  (Functions and Variables for Simplification)
     5: integerp  (Functions and Variables for Miscellaneous Options)
     6: integer_partitions  (Functions and Variables for Sets)
     7: integrate  (Functions and Variables for Integration)
     8: integrate_use_rootsof  (Functions and Variables for Integration)
     9: integration_constant_counter  (Functions and Variables for
        Integration)
     10: nonnegintegerp  (Functions and Variables for linearalgebra)
    Enter space-separated numbers, `all' or `none': 5 4

     -- Function: integerp (<expr>)
         Returns `true' if <expr> is a literal numeric integer, otherwise
         `false'.

         `integerp' returns false if its argument is a symbol, even if the
         argument is declared integer.

         Examples:

              (%i1) integerp (0);
              (%o1)                         true
              (%i2) integerp (1);
              (%o2)                         true
              (%i3) integerp (-17);
              (%o3)                         true
              (%i4) integerp (0.0);
              (%o4)                         false
              (%i5) integerp (1.0);
              (%o5)                         false
              (%i6) integerp (%pi);
              (%o6)                         false
              (%i7) integerp (n);
              (%o7)                         false
              (%i8) declare (n, integer);
              (%o8)                         done
              (%i9) integerp (n);
              (%o9)                         false

     -- Function: askinteger (<expr>, integer)
     -- Function: askinteger (<expr>)
     -- Function: askinteger (<expr>, even)
     -- Function: askinteger (<expr>, odd)
         `askinteger (<expr>, integer)' attempts to determine from the
         `assume' database whether <expr> is an integer.  `askinteger'
         prompts the user if it cannot tell otherwise, and attempt to
         install the information in the database if possible.  `askinteger
         (<expr>)' is equivalent to `askinteger (<expr>, integer)'.

         `askinteger (<expr>, even)' and `askinteger (<expr>, odd)'
         likewise attempt to determine if <expr> is an even integer or odd
         integer, respectively.

    (%o1)                                true

結果を後で使うには、結果を変数に割り当てるか、 自動的に供給されるラベルで参照することができます。 加えて、`%`は直前の計算結果を示します:

    (%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)

Maximaは複素数や数値定数について知っています:

    (%i1) cos(%pi);
    (%o1)                          - 1
    (%i2) exp(%i*%pi);
    (%o2)                          - 1

Maximaは微積分法ができます:

    (%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 (%, 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) integrate (1/(1 + x^3), x);
                                      2 x - 1
                    2            atan(-------)
               log(x  - x + 1)        sqrt(3)    log(x + 1)
    (%o3)    - --------------- + ------------- + ----------
                      6             sqrt(3)          3

Maximaは1次方程式系や3次方程式を解くことができます:

    (%i1) linsolve ([3*x + 4*y = 7, 2*x + a*y = 13], [x, y]);
                            7 a - 52        25
    (%o1)              [x = --------, y = -------]
                            3 a - 8       3 a - 8
    (%i2) solve (x^3 - 3*x^2 + 5*x = 15, x);
    (%o2)       [x = - sqrt(5) %i, x = sqrt(5) %i, x = 3]

Maximaは非線形方程式系を解くことができます。 もし結果を表示させたくなければ、コマンドの終わりに`;`の代わりに`$`をつければよいことに注意してください:

    (%i1) eq_1: x^2 + 3*x*y + y^2 = 0$
    (%i2) eq_2: 3*x + y = 1$
    (%i3) solve ([eq_1, eq_2]);
                  3 sqrt(5) + 7      sqrt(5) + 3
    (%o3) [[y = - -------------, x = -----------],
                        2                 2

                                   3 sqrt(5) - 7        sqrt(5) - 3
                              [y = -------------, x = - -----------]]
                                         2                   2

Maximaは関数のプロットが生成できます:

    (%i1) plot2d (sin(x)/x, [x, -20, 20])$

    (%i2) plot2d ([atan(x), erf(x), tanh(x)], [x, -5, 5], [y, -1.5, 2])$

    (%i3) plot3d (sin(sqrt(x^2 + y^2))/sqrt(x^2 + y^2),
             [x, -12, 12], [y, -12, 12])$

Help ·

Next: Help, Previous: Introduction to Maxima, Up: Top [Contents][Index]

## 2 Bug Detection and Reporting

Up: Bug Detection and Reporting [Contents][Index]

### 2.1 Functions and Variables for Bug Detection and Reporting

関数: run_testsuite ([options])

  Maximaのテストスイートを走らせます。 望みの答えを生成したテストは「パス」とみなされます。 望みの答えを生成しないテストも同様ですが、既知のバグとしてマークされています。

  `run_testsuite`は、以下のオプションキーワード引数を取ります。

  `display_all`

    テストすべてを表示します。 通常は、テストが失敗しない限りテストを表示しません。 （デフォルトでは `false`に設定されます。）

  `display_known_bugs`

    既知のバグとしてマークされているテストを表示します。 （デフォルトでは `false`に設定されます。）

  `tests`

    これは、実行するテストのリストです。 それぞれのテストは文字列かシンボルで指定することができます。 デフォルトではテストすべてを実行します。 テストの完全な組は `testsuite_files`で指定されています。

  `time`

    時間情報を表示します。 もし `true`ならそれぞれのテストファイルにかかった時間を表示します。 もし `all`なら `display_all`が `true`の時、 それぞれ個々のテストにかかった時間を示します。 デフォルトは`false`で、時間情報を示しません。

  例えば、 `run_testsuite(display_known_bugs = true, tests=[rtest5])`は、 テスト `rtest5`だけを走らせ、既知のバグとしてマークされているテストを表示します。

  `run_testsuite(display_all = true, tests=["rtest1", rtest1a])`は、 テスト `rtest1`と `rtest2`を走らせ、 テストそれぞれを表示します。

  `run_testsuite`は、Maxima環境を変更します。 通常は、テストスクリプトは 既知の環境（すなわちユーザー定義の関数や変数のない環境）を確立するために `kill`を実行し、 それからテストにふさわしい関数や変数を定義します。

  `run_testsuite`は `done`を返します。

  Debugging ·

オプション変数: testsuite_files

  `testsuite_files`は `run_testsuite`が実行するテスト一式です。 それは実行するテストを含むファイル名のリストです。 もしファイルの中のテストのいくつかが失敗することが既知なら、 ファイル名をリストする代わりに、 ファイル名と失敗するテスト番号を含むリストを使います。

  例えば、以下はデフォルトのテスト一式の一部です:

       ["rtest13s", ["rtest14", 57, 63]]

  これは、ファイル"rtest13s", "rtest14"から成るテストスイートを指定しますが、 "rtest14" は失敗することが既知の２つのテスト57と63を含みます。

  Debugging ·Global variables ·

関数: bug_report ()

  MaximaとLispのバージョン番号を表示し、Maximaプロジェクトのバグレポートウェブサイトへのリンクを与えます。 バージョン情報は`build_info`がレポートするものと同じです。

  バグをレポートする時、 MaximaとLispのバージョン情報をバグレポートにコピーしてもらえると助かります。

  `bug_report`は空の文字列 `""`を返します。

  Debugging ·

関数: build_info ()

  Maximaビルドのパラメータのまとめを表示します。

  `build_info`は空の文字列 `""`を返します。 `bug_report`.も参照してください。

  Debugging ·

Next: Command Line, Previous: Bug Detection and Reporting, Up: Top [Contents][Index]

## 3 Help

Next: Functions and Variables for Help, Previous: Help, Up: Help [Contents][Index]

### 3.1 Documentation

このMaximaのオンラインユーザーズマニュアルは、違った形でも見ることができます。 Maximaの対話プロンプトから`?`コマンド（すなわち`describe`関数）を使うと、テキスト形式でユーザーズマニュアルが表示されます。`info`ビューアを使うと、ユーザーズマニュアルは、`info`ハイパーテキストとして表示され、通常のウェブブラウザを使えば、ウェブページとして表示されます。

`example`はたくさんのMaxima関数の使用例を表示します。 例えば、

    (%i1) example (integrate);

は、

    (%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

という感じでさらに出力を表示します。

Console interaction ·

Previous: Documentation, Up: Help [Contents][Index]

### 3.2 Functions and Variables for Help

関数: apropos (string)

  stringを含むMaxima上の名前を検索します。 例えば、`apropos ("exp")`は、 （`expand`, `exp`, `exponentialize`のように） `exp`を名前の一部として含むフラグ、関数すべてのリストを返します。 このように、もしなにかの名前の一部だけ覚えていたなら、 このコマンドを使って名前の残りを見つけることができます。 同様に、 `apropos ("tr_")`とすれば、翻訳器に関係した多くのスイッチのリストを 見つけることができます。翻訳器に関係したスイッチのほとんどは`tr_`で始まります。

  `apropos("")`は、Maximaの名前すべてのリストを返します。

  もし名前が見つからなければ、`apropos`は空のリスト`[]`を返します。

  例:

  `"gamma"`を含むMaximaシンボルすべてを表示します:

      (%i1) apropos("gamma");
      (%o1) [%gamma, gamma, gammalim, gamma_expand, gamma_incomplete_lower,
      gamma_incomplete, gamma_incomplete_generalized,
      gamma_incomplete_regularized, Gamma, log_gamma, makegamma,
      prefer_gamma_incomplete,
      gamma_incomplete_generalized_regularized]

  Help ·

関数: demo (filename)

  filenameの中のMaxima式を評価し、結果を表示します。 `demo`はそれぞれの式を評価した後 停止し、 ユーザーがリターンキーを入力すると続きを実行します。 (Xmaximaで走らせている場合、 `demo`はセミコロン`;`に続けて改行を入力する必要があります。)

  `demo`は、filnameのファイルを探すため、 ディレクトリ`file_search_demo`のリストを検索します。 もしファイルの拡張子が`.dem`なら、拡張子は省略できます。 `file_search`も参照してください。

  `demo`は引数を評価します。 `demo`はデモンストレーションファイルの名前を返します。

  例:

      (%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)

      _

  Help ·Console interaction ·File input ·

関数: describe (string)
関数: describe (string, exact)
関数: describe (string, inexact)

  `describe(string)`は`describe(string, exact)`と同値です。

  `describe(string, exact)`は（大文字小文字は区別せず）stringに等しいタイトルを持った項目があれば、それを見つけます。

  `describe(string, inexact)`はタイトルの中にstringを含むすべての項目を見つけます。 もし複数あれば、Maximaはユーザーに項目を選択するよう尋ねます。

  対話プロンプトでは、 `? foo`(`?`と`foo`の間にスペース)は `describe("foo", exact)`と同値であり、 `?? foo`は`describe("foo", inexact)`と同値です。

  `describe("", inexact)`は、オンラインマニュアルでドキュメント化されたすべてのトピックのリストを出力します。

  `describe`は引数をクォートします。 `describe`は、ドキュメントが見つかれば`true`を返し、見つからなければ`false`を返します。

  Documentationも参照してください。

  例:

      (%i1) ?? integ
       0: Functions and Variables for Elliptic Integrals
       1: Functions and Variables for Integration
       2: Introduction to Elliptic Functions and Integrals
       3: Introduction to Integration
       4: askinteger  (Functions and Variables for Simplification)
       5: integerp  (Functions and Variables for Miscellaneous Options)
       6: integer_partitions  (Functions and Variables for Sets)
       7: integrate  (Functions and Variables for Integration)
       8: integrate_use_rootsof  (Functions and Variables for
          Integration)
       9: integration_constant_counter  (Functions and Variables for
          Integration)
       10: nonnegintegerp  (Functions and Variables for linearalgebra)
      Enter space-separated numbers, `all' or `none': 7 8

       -- 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, [...]

       -- 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.
           [...]

  この例では、項目7と8を選択しました。 （`[...]`でほのめかされているように出力は省略されています。） `all`や`none`を入力すると、項目すべてを選択したり、１つも選ばなかったりできます。 それぞれ`a`もしくは`n`と省略形を使うことができます。

  Help ·Console interaction ·

関数: example (topic)
関数: example ()

  `example (topic)`は、topicの例をいくつか表示します。 topicはシンボルもしくは文字列です。 `if`や`do`、`lambda`のような演算子の例を得るには、引数は文字列でなければなりません。例えば、 `example ("do")`。 `example`は、大文字小文字を区別しません。トピックのほとんどは関数名です。

  `example ()`はわかっているトピックすべてのリストを表示します。

  例を含むファイル名は、グローバル変数`manual_demo`で与えられます。デフォルトは`"manual.demo"`です。

  `example`は引数をクォートします。 `example`はエラーがあったり引数がなかったりしなければ`done`を返します。 引数がない場合には わかっているトピックすべてのリストを表示します。

  例:

      (%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

  Help ·Console interaction ·

オプション変数: manual_demo

  デフォルト値: `"manual.demo"`

  `manual_demo`は、 関数`example`のための例が入っているファイルの名前を指定します。 `example`を参照してください。

  Help ·Global variables ·

Next: Data Types and Structures, Previous: Help, Up: Top [Contents][Index]

## 4 Command Line

Next: Functions and Variables for Command Line, Previous: Command Line, Up: Command Line [Contents][Index]

### 4.1 Introduction to Command Line

Next: Functions and Variables for Display, Previous: Introduction to Command Line, Up: Command Line [Contents][Index]

### 4.2 Functions and Variables for Command Line

システム変数: __

  `__`は、現在評価中の入力式です。 すなわち、入力式 exprが評価されている間、 `__`は exprです。

  `__`は、入力が整理されたり評価されたりする前に入力式に割り当てられます。 しかし表示される時、`__`の値は（評価はされませんが）整理されます。

  `batch`と `load`は `__`を認識します。 `batch`が処理するファイル内では、 `__`は対話プロンプトでのそれと同じ意味になります。 `load`が処理するファイル内では、 `__`は対話プロンプトやバッチファイルの中で直前に入力された入力式にバインドされています; `__`は処理中のファイル内の入力式にはバインドされません。 特に、 `load (filename)`が対話プロンプトからコールされた時、 `__`は、ファイルが処理されている間、 `load (filename)`にバインドされます。

  `_`や `%`も参照してください。

  例:

      (%i1) print ("I was called as", __);
      I was called as print(I was called as, __)
      (%o1)              print(I was called as, __)
      (%i2) foo (__);
      (%o2)                     foo(foo(__))
      (%i3) g (x) := (print ("Current input expression =", __), 0);
      (%o3) g(x) := (print("Current input expression =", __), 0)
      (%i4) [aa : 1, bb : 2, cc : 3];
      (%o4)                       [1, 2, 3]
      (%i5) (aa + bb + cc)/(dd + ee + g(x));
                                  cc + bb + aa
      Current input expression = --------------
                                 g(x) + ee + dd
                                      6
      (%o5)                        -------
                                   ee + dd

  Global variables ·

システム変数: _

  `_`は直前の入力式です。 (例えば、`%i1`, `%i2`, `%i3`, …)

  `_`は、入力が整理されたり評価されたりする前に、入力式に割り当てられます。 しかし、 `_`の値は、表示される時（評価はされませんが）整理されます。

  `batch`と `load`は `_`を認識します。 `batch`が処理するファイル内では、 `_`は対話プロンプトでのそれと同じ意味になります。 `load`が処理するファイル内では、 `_`は、対話プロンプトやバッチファイルの中で、直前に入力された入力式にバインドされます; `_`は処理中のファイル内の入力式にはバインドされません。

  `__`や `%`も参照してください。

  例:

      (%i1) 13 + 29;
      (%o1)                          42
      (%i2) :lisp $_
      ((MPLUS) 13 29)
      (%i2) _;
      (%o2)                          42
      (%i3) sin (%pi/2);
      (%o3)                           1
      (%i4) :lisp $_
      ((%SIN) ((MQUOTIENT) $%PI 2))
      (%i4) _;
      (%o4)                           1
      (%i5) a: 13$
      (%i6) b: 29$
      (%i7) a + b;
      (%o7)                          42
      (%i8) :lisp $_
      ((MPLUS) $A $B)
      (%i8) _;
      (%o8)                         b + a
      (%i9) a + b;
      (%o9)                          42
      (%i10) ev (_);
      (%o10)                         42

  Console interaction ·Global variables ·

システム変数: %

  `%`はMaximaが直前に計算した出力式です。 (例えば、 `%o1`, `%o2`, `%o3`, …) 出力の表示には無関係です。

  `batch`と `load`は`%`を認識します。 `batch`が処理するファイル内では、 `%`は対話プロンプトでのそれと同じ意味になります。 `load`が処理するファイル内では、 `%`は、対話プロンプトやバッチファイルの中で、直前に計算された出力式にバインドされます; `%`は、処理中のファイル内の出力式にはバインドされません。

  `_`, `%%`, `%th`も参照してください。

  Console interaction ·Global variables ·

システム変数: %%

  合成文、すなわち`block`, `lambda`, もしくは`(s_1, ..., s_n)`の中で、 `%%`は前の文の値です。

  合成文の最初の文もしくは合成文の外側では`%%`は未定義です。

  `%%`は、`batch`や `load`で認識され、 対話プロンプトでのそれと同じ意味になります。

  `%`も参照してください。

  例:

  以下の二つの例は同じ結果になります。

      (%i1) block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
                                     21
      (%o1)                          --
                                     2
      (%i2) block ([prev], prev: integrate (x^5, x),
                     ev (prev, x=2) - ev (prev, x=1));
                                     21
      (%o2)                          --
                                     2

  合成文は他の合成文を含むかもしれません。 文が単文か合成文かに関係なく、 `%%`は前の文の値です。

      (%i3) block (block (a^n, %%*42), %%/6);
                                       n
      (%o3)                         7 a

  合成文の中ではブレイクプロンプトで`%%`の値を検査することができます。 ブレイクプロンプトは `break`関数を実行することで開きます。 例えば、以下の例で`%%;`を入力すると、`42`が出力されます。

      (%i4) block (a: 42, break ())$

      Entering a Maxima break point. Type 'exit;' to resume.
      _%%;
      42
      _

  Global variables ·

関数: %th (i)

  i番前の出力式の値。 すなわち、計算される次の式をn番目の出力とすると `%th (m)`は、(n - m)番目の出力です。

  `batch`と`load`は`%th`を認識されます。 `batch`が処理するファイル内では、 `%th`は、対話プロンプトでのそれと同じ意味になります。 `load`が処理するファイル内では、 `%th`は、対話プロンプトやバッチファイルの中で、直前に計算された出力式にバインドされます; `%th`は、処理中のファイル内の出力式にはバインドされません。

  `%`と `%%`も参照してください。

  例:

  `batch`ファイルの中でとか、出力式のグループを参照する時`%th`は役立ちます。 この例は`s`を最後の5つの出力式の和に設定します。

      (%i1) 1;2;3;4;5;
      (%o1)                           1
      (%o2)                           2
      (%o3)                           3
      (%o4)                           4
      (%o5)                           5
      (%i6) block (s: 0, for i:1 thru 5 do s: s + %th(i), s);
      (%o6)                          15

  Console interaction ·

特殊シンボル: ?

  関数名や変数名の前置としての`?`は、 名前が、Maximaの名前ではなくLispの名前であることを意味します。 例えば、`?round`は、Lisp関数`ROUND`を意味します。 この点に関して更に知るにはLisp and Maximaを参照してください。

  表記`? word` (空白を空けて単語が続くクエスチョンマーク)は `describe("word")`と同値です。 クエスチョンマークは入力ラインの先頭になければいけません; そうでなければドキュメンテーションのリクエストとして認識されません。 `describe`も参照してください。

  Help ·Console interaction ·

特殊シンボル: ??

  表記`?? word`(空白を空けて単語が続く`??`)は `describe("word", inexact)`と同値です。 クエスチョンマークは入力行の先頭になければいけません; そうでなければドキュメンテーションのリクエストとして認識されません。 `describe`も参照してください。

  Help ·Console interaction ·

オプション変数: inchar

  デフォルト値: `%i`

  `inchar`はユーザーが入力した式のラベルの前置です。 Maximaは、 `inchar`と`linenum`を連結することで、 入力式それぞれのラベルを自動的に構成します。

  `inchar`は単一文字である必要はなく、 任意の文字列もしくはシンボルを割り当てられます。 Maximaは内部的に前置の最初の文字だけを考慮するので、 前置`inchar`, `outchar`, `linechar`は異なる最初の文字を持たなければいけません。 そうでなければ`kill(inlables)`のようないくつかのコマンドは期待通りに動きません。

  `labels`も参照してください。

  例:

      (%i1) inchar: "input";
      (%o1)                         input
      (input2) expand((a+b)^3);
                           3        2      2      3
      (%o2)               b  + 3 a b  + 3 a  b + a
      (input3)

  Display flags and variables ·

システム変数: infolists

  デフォルト値: `[]`

  `infolists`はMaximaに関する情報リストすべての名前のリストです。 これらは以下の通りです:

  `labels`

    すべてのバインドされた`%i`, `%o`, `%t`ラベル

  `values`

    `:`や`::`や関数バインドが生成する、 ユーザー変数であって、Maximaオプションやスイッチでない、 すべてのバインドされたアトム

  `functions`

    `:=`や`define`が生成するすべてのユーザー定義関数

  `arrays`

    `:`, `::`, または`:=`が生成するすべての宣言配列と未宣言配列

  `macros`

    `::=`が生成したすべてのユーザー定義マクロ関数

  `myoptions`

    (それらが後にデフォルト値に再設定されようがされまいが) ユーザーが再設定したすべてのオプション

  `rules`

    `tellsimp`, `tellsimpafter`, `defmatch`, または`defrule`が生成するすべてのユーザー定義パターンマッチングと整理規則

  `aliases`

    `alias`, `ordergreat`, `orderless`関数が生成するか、 `declare`を使ってアトムを`noun`として宣言することで生成された、 ユーザー定義エーリアスを持つすべてのアトム

  `dependencies`

    `depends`や`gradef`関数が生成する関数依存性を持つすべてのアトム

  `gradefs`

    `gradef`関数が生成するユーザー定義の導関数を持つすべての関数

  `props`

    `declare`関数で確立されるプロパティはもちろん、 `atvalue`や`matchdeclare`などが確立するプロパティで、 上で述べたもの以外の任意のプロパティを持つすべてのアトム

  `let_rule_packages`

    特別パッケージ`default_let_rule_package`に加えて すべてのユーザー定義`let`規則パッケージ (`default_let_rule_package`は、 ユーザーが陽に設定していない時使われる規則パッケージの名前です。)

  Declarations and inferences ·Global variables ·

関数: kill (a_1, …, a_n)
関数: kill (labels)
関数: kill (inlabels, outlabels, linelabels)
関数: kill (n)
関数: kill ([m, n])
関数: kill (values, functions, arrays, …)
関数: kill (all)
関数: kill (allbut (a_1, …, a_n))

  引数a_1, …, a_nからすべてのバインド（値、関数、配列、ルール）を解除します。 引数a_kはシンボルか配列要素を取り得ます。 a_kが配列要素の時、`kill`は配列の他の要素には影響することなくその要素をアンバインドします。

  いくつかの特殊な引数が認識されます。 例えば、`kill (inlabels, functions, allbut (foo, bar))`のように、異なる引数の種類が組み合わされます。

  `kill (labels)`はそれまでに作られた入力、出力、中間式のラベルすべてをアンバインドします。 `kill (inlabels)`は `inchar`の現在の値で始まる入力ラベルのみをアンバインドします。 同様に、 `kill (outlabels)`は `outchar`の現在の値で始まる出力ラベルのみをアンバインドし、 `kill (linelabels)`は `linechar`の現在の値で始まる中間式ラベルのみをアンバインドします。

  `kill (`n`)`（nは整数）は入力、出力ラベルの最近のn個をアンバインドします。

  `kill ([m, n])`は入力、出力ラベルmからnまでをアンバインドします。

  `kill (infolist)`は infolistの中のすべての項目をアンバインドします。 ここで、infolistは（`values`, `functions`, `arrays`のような) `infolists`の中の任意の項目です。 `infolists`も参照してください。

  `kill (all)`はinfolistsのすべての項目をアンバインドします。 `kill (all)`はグローバル変数をデフォルト値にリセットしません; この点に関しては`reset`を参照してください。

  `kill (allbut (a_1, ..., a_n))`は、 a_1, ..., a_nを除いて すべてのinfolistsの中のすべての項目をアンバインドします。 `kill (allbut (infolist))`は infolist（infolistは`values`, `functions`, `arrays`など） 上の項目を除いてすべての項目をアンバインドします。

  バインドされたプロパティによって使われたメモリは、すべてのシンボルがプロパティからアンバインドされるまで解放されません。 特に、シンボルの値によって使われているメモリを解放するには、 シンボルそのもののアンバインドだけでなく、バインドされた値を表示する出力ラベルをアンバインドします。

  `kill`は引数をクォートします。 引数を評価するにはクォートクォート演算子`''`を使います。

  `kill (symbol)`はシンボルのすべてのプロパティをアンバインドします。 対照的に、関数`remvalue`, `remfunction`, `remarray`, `remrule`は特定のプロパティをアンバインドします。

  `kil`は常に、たとえ引数がバインドされていなくても、`done`を返します。

  Evaluation ·Console interaction ·Session management ·

関数: labels (symbol)
システム変数: labels

  symbolで始まる入力、出力、中間式ラベルのリストを返します。 symbolは、`inchar`, `outchar`, もしくは`linechar`の値が典型的です。 ラベル文字はパーセント記号ありでもあしでもかまいませんので、 例えば、`i`と`%i`は同じ結果になります。

  もしsymbolで始まるラベルがなければ、`labels`は空のリストを返します。

  関数`labels`は引数をクォートします。 引数を評価するにはクォートクォート演算子`''`を使います。 例えば， `labels (''inchar)`は、現在の入力ラベル文字で始まる入力ラベルを返します。

  変数`labels`は入力、出力、中間式ラベルのリストです。 `inchar`, `outchar`, もしくは`linechar`が再定義されても、以前のラベルすべてを含みます。

  デフォルトで、Maximaはそれぞれのユーザー入力式の結果を表示し、結果に出力ラベルが与えられます。 入力を`;`(セミコロン)の代わりに`$`(ドル記号)で終了することで、出力表示は抑制されます。 出力ラベルが構成され、結果にバインドされますが、表示されません。 ラベルは表示された出力ラベルと同じ方法で参照できます。 `%`や`%%`, `%th`も参照してください。

  いくつかの関数では中間式ラベルが生成されることがあります。 フラグ`programmode`は `solve`や他の関数が式のリストを返す代わりに中間式ラベルを生成するかどうかを制御します。 `ldisplay`のようないくつかの他の関数は常に中間式ラベルを生成します。

  `inchar`や`outchar`, `linechar`, `infolists`も参照してください。

  Display functions ·Display flags and variables ·Console interaction ·

オプション変数: linechar

  デフォルト値: `%t`

  `linechar`は Maximaが生成する中間式のラベルの前置です。 Maximaは（もし表示されるなら） `linechar`と`linenum`を連結することで 中間式それぞれのラベルを構成します。

  `linechar`は単一文字である必要はなく、 任意の文字列もしくはシンボルを割り当てられます。 Maximaは内部的に 前置の最初の文字だけを考慮するので、 前置`inchar`, `outchar`, `linechar`は異なる最初の文字を持たなければいけません。 そうでなければ `kill(inlables)`のようないくつかのコマンドは期待通りに動きません。

  中間式は表示されるかもしれませんし、表示されないかもしれません。 `programmode`と`labels`も参照してください。

  Display flags and variables ·

システム変数: linenum

  入力出力式の現在のペアの行番号。

  Display flags and variables ·Console interaction ·

システム変数: myoptions

  デフォルト値: `[]`

  `myoptions`はユーザーが再設定したオプションすべてのリストです。 初期値に再設定されたか否かに関わらずです。

  Global variables ·Session management ·Console interaction ·

オプション変数: nolabels

  デフォルト値: `false`

  `nolabels`は`true`であれば、 入力と出力結果のラベル（それぞれ`%i`と`%o`）は表示されますが、 ラベルは結果にバインドされず、`labels`リストにも追加されません。 ラベルは結果にバインドされないので、 ガーベッジコレクションは結果が使ったメモリを回復することができます。

  そうでなければ、入力と出力の結果のラベルは結果にバインドされ、`labels`リストに追加されます。

  中間式ラベル(`%t`)は`nolabels`に影響されません; `nolabels`が`true`でも`false`でも、中間式ラベルはバインドされ、`labels`リストに追加されます。

  `batch`や`load`、 `labels`も参照してください。

  Global flags ·Session management ·

オプション変数: optionset

  デフォルト値: `false`

  `optionset`が`true`の時、Maximaは、Maximaオプションが再設定されるといつでも、メッセージを表示します。 もしユーザーがあるオプションの綴りが怪しく、割り当てた変数が本当にオプション変数か確認したいなら便利です。

  例:

      (%i1) optionset:true;
      assignment: assigning to option optionset
      (%o1)                         true
      (%i2) gamma_expand:true;
      assignment: assigning to option gamma_expand
      (%o2)                         true

  Global flags ·Session management ·Console interaction ·

オプション変数: outchar

  デフォルト値: `%o`

  `outchar`はMaximaが計算した式のラベルの前置です。 `outchar`と`linenum`を連結することで、 Maximaは計算された式それぞれのラベルを自動的に構成します。 `outchar`は、単一文字である必要はなく、 任意の文字列もしくはシンボルを割り当てられます。 Maximaは内部的に前置の最初の文字だけを考慮するので、 前置`inchar`, `outchar`, `linechar`は異なる最初の文字を持たなければいけません。 そうでなければ、`kill(inlables)`のようないくつかのコマンドは期待通りに動きません。

  `labels`も参照してください。

  例:

      (%i1) outchar: "output";
      (output1)                    output
      (%i2) expand((a+b)^3);
                           3        2      2      3
      (output2)           b  + 3 a b  + 3 a  b + a
      (%i3)

  Display flags and variables ·

関数: playback ()
関数: playback (n)
関数: playback ([m, n])
関数: playback ([m])
関数: playback (input)
関数: playback (slow)
関数: playback (time)
関数: playback (grind)

  入力、出力、中間式を表示します。再計算はしません。 `playback`はラベルにバインドされた式表示するだけです; （`print`や`describe`で表示されたテキストやエラーメッセージなど）他の出力は表示されません。 `labels`も参照してください。

  `playback`は引数をクォートします。 引数を評価するにはクォートクォート演算子`''`を使います。 `playback`は常に`done`を返します。

  `playback ()`（引数なし）は今までに生成された入力、出力、中間式すべてを表示します。 たとえ計算時に`$`終端子で出力が抑制されていても、 出力式は表示されます。

  `playback (n)`は最近のn個の式を表示します。 入力、出力、中間式それぞれを１と数えます。

  `playback ([m, n])`は m番目からn番目までの入力、出力、中間式を表示します。

  `playback ([m])`は `playback ([m, m])`と同値です; これは普通、入力と出力の式のペアを１つ表示します。

  `playback (input)`は今までに生成された入力式をすべて表示します。

  `playback (slow)`は式の間でポーズし、ユーザーが `enter`を入力するのを待ちます。 これは `demo`と似たような振る舞いです。 `playback (slow)`は、`save`や`stringout`と関連して、 役立つ式を取り出すために２次記憶ファイルを生成するときに便利です。

  `playback (time)`はそれぞれの式の計算時間を表示します。

  `playback (grind)`は入力式を `grind`関数と同じ形式で表示します。 出力式は `grind`オプションで影響を受けません。 `grind`を参照してください。

  例えば、`playback ([5, 10], grind, time, slow)`のように、 引数を組み合わせられます。

  Display functions ·Console interaction ·

オプション変数: prompt

  デフォルト値: `_`

  `prompt`は、`demo`関数や`playback (slow)`モード、 （`break`で呼び出された）Maximaブレイクループのプロンプトシンボルです。

  Global variables ·Console interaction ·

関数: quit ()

  Maximaセッションを終了します。 関数は、`quit`ではなく、`quit();`もしくは`quit()$`として呼び出さなければいけないことに注意してください。

  長い計算を中断するには `control-C`をタイプしてください。 デフォルトの動作では Maximaプロンプトに戻ります。 もし`*debugger-hook*`が`nil`なら、 `control-C`はLispデバッガを開きます。 `debugging`も参照してください。

  Console interaction ·

関数: read (expr_1, …, expr_n)

  expr_1, …, expr_nを表示し、 コンソールから式１つを読み込み、評価された式を返します。 式はセミコロン`;`もしくはドル記号`$`で終了します。

  `readonly`も参照してください。

      (%i1) foo: 42$
      (%i2) foo: read ("foo is", foo, " -- enter new value.")$
      foo is 42  -- enter new value.
      (a+b)^3;
      (%i3) foo;
                                           3
      (%o3)                         (b + a)

  Console interaction ·

関数: readonly (expr_1, …, expr_n)

  expr_1, …, expr_nを表示し、 コンソールから式を１つ読み込み、 式を（評価せずに）返します。 式はセミコロン`;`もしくはドル記号`$`で終了します。

  `read`も参照してください。

  例:

      (%i1) aa: 7$
      (%i2) foo: readonly ("Enter an expression:");
      Enter an expression:
      2^aa;
                                        aa
      (%o2)                            2
      (%i3) foo: read ("Enter an expression:");
      Enter an expression:
      2^aa;
      (%o3)                            128

  Console interaction ·

関数: reset ()

  多くのグローバル変数やオプション、いくつかの他の変数をデフォルト値に再設定します。

  `reset`は Lispリスト`*variable-initial-values*`上の変数を処理します。 Lispマクロ`defmvar`は（他の動作の間に）このリストに変数を置きます。 すべてではありませんが多くのグローバル変数やオプションがdefmvarによって定義されており、 また、`defmvar`で定義されたいくつかの変数はグローバル変数でもオプションでもありません。

  Session management ·

オプション変数: showtime

  デフォルト値: `false`

  `showtime`が`true`の時、出力式と一緒に計算時間と経過時間を表示します。

  計算時間は常に記録されており、 `showtime`が`false`の時でも、 `time`や`playback`で計算時間を表示することができます。

  `timer`も参照してください。

  Display flags and variables ·Debugging ·

関数: to_lisp ()

  Maximaの下のLispシステムに入ります。`(to-maxima)`でMaximaに戻ります。

  例:

  関数を定義し、Maximaの下のLispシステムに入ります。 定義をプロパティリスト上で検査します。そして、関数定義を抽出し、因数分解し、 変数$resultに格納します。 変数はMaximaに戻った後、Maximaで使うことができます。

      (%i1) f(x):=x^2+x;
                                        2
      (%o1)                    f(x) := x  + x
      (%i2) to_lisp();
      Type (to-maxima) to restart, ($quit) to quit Maxima.

      MAXIMA> (symbol-plist '$f)
      (MPROPS (NIL MEXPR ((LAMBDA) ((MLIST) $X)
                                   ((MPLUS) ((MEXPT) $X 2) $X))))
      MAXIMA> (setq $result ($factor (caddr (mget '$f 'mexpr))))
      ((MTIMES SIMP FACTORED) $X ((MPLUS SIMP IRREDUCIBLE) 1 $X))
      MAXIMA> (to-maxima)
      Returning to Maxima
      (%o2)                         true
      (%i3) result;
      (%o3)                       x (x + 1)

  Console interaction ·

システム変数: values

  初期値: `[]`

  `values`は（Maximaのオプションやスイッチではなく）バインドされたユーザー変数すべてのリストです。 リストは、`:`や`::`でバインドされたシンボルを含みます。

  もし変数の値がコマンド`kill`や, `remove`, `remvalue`で削除されたら、 変数は`values`から削除されます。

  ユーザー定義関数のリストに関しては `functions`を参照してください。

  例:

  最初、`values`はシンボル`a`, `b`, `c`を示しますが、 `d`も―それは値にバインドされていません―ユーザー関数`f`も示しません。 値は変数から削除されます。`values`は空のリストです。

      (%i1) [a:99, b::a-90, c:a-b, d, f(x):= x^2];
                                                 2
      (%o1)              [99, 9, 90, d, f(x) := x ]
      (%i2) values;
      (%o2)                       [a, b, c]
      (%i3) [kill(a), remove(b,value), remvalue(c)];
      (%o3)                   [done, done, [c]]
      (%i4) values;
      (%o4)                          []

  Evaluation ·Global variables ·

Previous: Functions and Variables for Command Line, Up: Command Line [Contents][Index]

### 4.3 Functions and Variables for Display

オプション変数: %edispflag

  デフォルト値: `false`

  `%edispflag`が`true`の時、 Maximaは `%e`の負の指数乗を商として表示します。 例えば、`%e^-x`は `1/%e^x`と表示されます。 `exptdispflag`も参照してください。

  例:

      (%i1) %e^-10;
                                     - 10
      (%o1)                        %e
      (%i2) %edispflag:true$
      (%i3) %e^-10;
                                     1
      (%o3)                         ----
                                      10
                                    %e

  Exponential and logarithm functions ·Display flags and variables ·

オプション変数: absboxchar

  デフォルト値: `!`

  `absboxchar`は１行より広い式の回りに絶対値記号を描くのに使われる文字です。

  例:

      (%i1) abs((x^3+1));
                                  ! 3    !
      (%o1)                       !x  + 1!

  Display flags and variables ·

関数: disp (expr_1, expr_2, …)

  `display`のようですが、 等式ではなく引数の値だけが表示されます。 これは名前を持たない複雑な引数や引数の値だけに興味があって 名前には興味がない引数に役立ちます。

  `ldisp`と`print`も参照してください。

  例:

      (%i1) b[1,2]:x-x^2$
      (%i2) x:123$
      (%i3) disp(x, b[1,2], sin(1.0));
                                     123

                                        2
                                   x - x

                              .8414709848078965

      (%o3)                         done

  Display functions ·

関数: display (expr_1, expr_2, …)

  左辺が未評価のexpr_iで、右辺が式の値の等式を行の中央に表示します。 この関数は、中間結果を表示するのにブロックや`for`文の中で役立ちます。 `display`の引数は、通常アトムや、添字付き変数、関数コールです。 `disp`も参照してください。

  `ldisplay`, `disp`, `ldisp`も参照してください。

  例:

      (%i1) b[1,2]:x-x^2$
      (%i2) x:123$
      (%i3) display(x, b[1,2], sin(1.0));
                                   x = 123

                                            2
                               b     = x - x
                                1, 2

                        sin(1.0) = .8414709848078965

      (%o3)                         done

  Display functions ·

オプション変数: display2d

  デフォルト値: `true`

  `display2d`が`false`の時、 コンソール表示は（２次元）形式ではなく文字列（１次元）形式です。

  例:

      (%i1) x/(x^2+1);
                                     x
      (%o1)                        ------
                                    2
                                   x  + 1
      (%i2) display2d:false$
      (%i3) x/(x^2+1);
      (%o3) x/(x^2+1)

  Display flags and variables ·

オプション変数: display_format_internal

  デフォルト値: `false`

  `display_format_internal`が`true`の時、 式は数学的内部表現を隠すように変換されることなく表示されます。 表示は`part`ではなく`inpart`が返すものに対応します。

  例:

      User     part       inpart
      a-b;      a - b     a + (- 1) b

                 a            - 1
      a/b;       -         a b
                 b
                             1/2
      sqrt(x);   sqrt(x)    x

                4 X        4
      X*4/3;    ---        - X
                 3         3

  Display flags and variables ·

関数: dispterms (expr)

  exprをパーツ毎に一行ずつ使って表示します。 すなわち、最初にexprの演算子が表示され、 それぞれの項が別々に表示されます。 もしexprが他の方法で表示するには大きすぎるなら、 これは役に立ちます。 例えば、もし`P1`, `P2`, ...が非常に大きな式なら、 `P1 + P2 + ...`を一度に表示しようとする場合、 表示プログラムは保存の空き領域を使い尽くすかもしれません。 しかしながら、 `dispterms (P1 + P2 + ...)`は、 `P1`を表示し、その下に`P2`を表示し、という具合です。 `dispterms`を使わない時、 もし指数式が`A^B`のように表示するには広すぎるなら、 それは`expt (A, B)` (もしくは`A^^B`の場合、`ncexpt (A, B)`）のように現れます。

  Display functions ·

関数: expt (a, b)
関数: ncexpt (a, b)

  もし指数式が`a^b`のように表示するには広すぎるなら、 `expt (a, b)` (もしくは、`a^^b`の場合、`ncexpt (a, b)` のように現れます。

  `expt`や`ncexpt`は入力では認識されません。

オプション変数: exptdispflag

  デフォルト値: `true`

  `exptdispflag`が`true`の時、 Maximaは式を商を使って負の指数の式を表示します。

  例:

      (%i1) exptdispflag:true;
      (%o1)                         true
      (%i2) 10^-x;
                                      1
      (%o2)                          ---
                                       x
                                     10
      (%i3) exptdispflag:false;
      (%o3)                         false
      (%i4) 10^-x;
                                      - x
      (%o4)                         10

  Expressions ·Display flags and variables ·

関数: grind (expr)
オプション変数: grind

  関数`grind`は コンソールにMaximaへの入力に適した形でexprを印刷します。 `grind`はいつも`done`を返します。

  exprが関数名やマクロ名の時、 `grind`は、名前だけでなく関数やマクロ定義を出力します。

  `string`も参照してください。 それは出力を印刷する代わりに文字列を返します。 `grind`は `string`の出力より若干読みやすい方法で 式を印刷しようとします。

  変数`grind`が`true`の時、 `string`や`stringout`の出力は `grind`のそれと同じフォーマットです; そうでなければ、それらの関数の出力を特別にフォーマットしようとはしません。 変数`grind`のデフォルト値は`false`です。

  `grind`は `playback`の引数としても指定できます。 `grind`が存在する時、 `playback`は `grind`関数と同じフォーマットで入力式を印刷します。 そうでなければ、入力式を特にフォーマットしようとはしません。

  `grind`は引数を評価します。

  例:

      (%i1) aa + 1729;
      (%o1)                       aa + 1729
      (%i2) grind (%);
      aa+1729$
      (%o2)                         done
      (%i3) [aa, 1729, aa + 1729];
      (%o3)                 [aa, 1729, aa + 1729]
      (%i4) grind (%);
      [aa,1729,aa+1729]$
      (%o4)                         done
      (%i5) matrix ([aa, 17], [29, bb]);
                                 [ aa  17 ]
      (%o5)                      [        ]
                                 [ 29  bb ]
      (%i6) grind (%);
      matrix([aa,17],[29,bb])$
      (%o6)                         done
      (%i7) set (aa, 17, 29, bb);
      (%o7)                   {17, 29, aa, bb}
      (%i8) grind (%);
      {17,29,aa,bb}$
      (%o8)                         done
      (%i9) exp (aa / (bb + 17)^29);
                                      aa
                                  -----------
                                           29
                                  (bb + 17)
      (%o9)                     %e
      (%i10) grind (%);
      %e^(aa/(bb+17)^29)$
      (%o10)                        done
      (%i11) expr: expand ((aa + bb)^10);
               10           9        2   8         3   7         4   6
      (%o11) bb   + 10 aa bb  + 45 aa  bb  + 120 aa  bb  + 210 aa  bb
               5   5         6   4         7   3        8   2
       + 252 aa  bb  + 210 aa  bb  + 120 aa  bb  + 45 aa  bb
              9        10
       + 10 aa  bb + aa
      (%i12) grind (expr);
      bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
           +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
           +10*aa^9*bb+aa^10$
      (%o12)                        done
      (%i13) string (expr);
      (%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
      +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
      bb+aa^10
      (%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A),
        p : makelist (0, i, 1, length (A))], for i thru n do
        for j : i thru n do
        (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1),
        if i = j then p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]),
        for i thru n do L[i, i] : 1 / p[i],
        for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
      (%i15) grind (cholesky);
      cholesky(A):=block(
               [n:length(A),L:copymatrix(A),
                p:makelist(0,i,1,length(A))],
               for i thru n do
                   (for j from i thru n do
                        (x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),
                         if i = j then p[i]:1/sqrt(x)
                             else L[j,i]:x*p[i])),
               for i thru n do L[i,i]:1/p[i],
               for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$
      (%o15)                        done
      (%i16) string (fundef (cholesky));
      (%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\
      t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\
      [i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\
      ) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \
      n do (for j from i+1 thru n do L[i,j]:0),L)

  Display functions ·Display flags and variables ·

オプション変数: ibase

  デフォルト値: `10`

  `ibase`は Maximaが読む整数の基数です。

  `ibase`は2から(十進数で)36までの任意の整数を割り当てられます。 `ibase`が10よりも大きい時、 数値は十進数字0から9に加えて、 `ibase`ディジットに必要なアルファベットA, B, C, …で構成されます。 最初のディジットが0から9の時だけ文字はディジットとして解釈されます。 大文字小文字は区別されません。 許容される最も大きな基数36の数値は0から9までとAからZまでから構成されます。

  `ibase`の値がいくつでも、 整数が小数点で終了する時は基数10として解釈されます。

  `obase`も参照してください。

  例:

  `ibase` less than 10.

      (%i1) ibase : 2 $
      (%i2) obase;
      (%o2)                          10
      (%i3) 1111111111111111;
      (%o3)                         65535

  10より大きな`ibase`。 最初のディジットが0から9までの時だけ文字はディジットとして解釈されます。

      (%i1) ibase : 16 $
      (%i2) obase;
      (%o2)                          10
      (%i3) 1000;
      (%o3)                         4096
      (%i4) abcd;
      (%o4)                         abcd
      (%i5) symbolp (abcd);
      (%o5)                         true
      (%i6) 0abcd;
      (%o6)                         43981
      (%i7) symbolp (0abcd);
      (%o7)                         false

  整数が小数点で終了する時、基数10として解釈されます。

      (%i1) ibase : 36 $
      (%i2) obase;
      (%o2)                          10
      (%i3) 1234;
      (%o3)                         49360
      (%i4) 1234.;
      (%o4)                         1234

  Console interaction ·

関数: ldisp (expr_1, …, expr_n)

  式expr_1, ..., expr_nをコンソールに印刷出力として表示します。 `ldisp`は 引数それぞれに中間式ラベルを割り当て、ラベルのリストを返します。

  `disp`, `display`, `ldisplay`も参照してください。

  例:

      (%i1) e: (a+b)^3;
                                         3
      (%o1)                       (b + a)
      (%i2) f: expand (e);
                           3        2      2      3
      (%o2)               b  + 3 a b  + 3 a  b + a
      (%i3) ldisp (e, f);
                                         3
      (%t3)                       (b + a)

                           3        2      2      3
      (%t4)               b  + 3 a b  + 3 a  b + a

      (%o4)                      [%t3, %t4]
      (%i4) %t3;
                                         3
      (%o4)                       (b + a)
      (%i5) %t4;
                           3        2      2      3
      (%o5)               b  + 3 a b  + 3 a  b + a

  Display functions ·

関数: ldisplay (expr_1, …, expr_n)

  式expr_1, ..., expr_nをコンソールに印刷出力として表示します。 式それぞれは、 `lhs`が`ldisplay`の引数の１つで、`rhs`がその値の、 形式`lhs = rhs`の等式として表示されます。 典型的には引数それぞれは変数です。 `ldisp`は式それぞれに中間式ラベルを割り当て、ラベルのリストを返します。

  `display`, `disp`も参照してください。

  例:

      (%i1) e: (a+b)^3;
                                         3
      (%o1)                       (b + a)
      (%i2) f: expand (e);
                           3        2      2      3
      (%o2)               b  + 3 a b  + 3 a  b + a
      (%i3) ldisplay (e, f);
                                           3
      (%t3)                     e = (b + a)

                             3        2      2      3
      (%t4)             f = b  + 3 a b  + 3 a  b + a

      (%o4)                      [%t3, %t4]
      (%i4) %t3;
                                           3
      (%o4)                     e = (b + a)
      (%i5) %t4;
                             3        2      2      3
      (%o5)             f = b  + 3 a b  + 3 a  b + a

  Display functions ·

オプション変数: linel

  デフォルト値: `79`

  `linel`はコンソールディスプレイの仮定された(文字単位の)幅です。 `linel`はユーザーによって任意の値に割り当てられます。 非常に小さい値や非常に大きな値は実用的ではありませんが。 エラーメッセージや`describe`の出力のように、 Maximaの組み込み関数が表示するテキストは`linel`の影響を受けません。

  Display flags and variables ·

オプション変数: lispdisp

  デフォルト値: `false`

  `lispdisp`が`true`の時、 Lispシンボルはクエスチョンマーク`?`を先頭文字として表示されます。 そうでなければ、Lispシンボルは先頭文字を持ちません。

  例:

      (%i1) lispdisp: false$
      (%i2) ?foo + ?bar;
      (%o2)                       foo + bar
      (%i3) lispdisp: true$
      (%i4) ?foo + ?bar;
      (%o4)                      ?foo + ?bar

  Display flags and variables ·

オプション変数: negsumdispflag

  デフォルト値: `true`

  `negsumdispflag`が`true`の時、 `x - y`は `- y + x`でなく`x - y`と表示されます。 `false`に設定すると、 ２つの式の違いに関する表示での特殊なチェックがされないようになります。 １つの応用は、例えば、`a + %i*b`と`a - %i*b`を同じ表示にすることです。

  Display flags and variables ·

オプション変数: obase

  デフォルト値: `10`

  `obase`はMaximaが表示する整数の基数です。

  `obase`は2から(十進数で)36までの任意の整数を割り当てられます。 `obase`が10よりも大きい時、 数値は十進数字0から9に加えて、 必要な大文字アルファベットA, B, C, ...で構成されます。 もし先頭ディジットがそうでなければ文字なら、0ディジットが先頭に表示されます。 許容される最も大きな基数36の数値は0から9までとAからZまでから構成されます。

  `ibase`も参照してください。

  例:

      (%i1) obase : 2;
      (%o1)                          10
      (%i2) 2^8 - 1;
      (%o10)                      11111111
      (%i3) obase : 8;
      (%o3)                          10
      (%i4) 8^8 - 1;
      (%o4)                       77777777
      (%i5) obase : 16;
      (%o5)                          10
      (%i6) 16^8 - 1;
      (%o6)                       0FFFFFFFF
      (%i7) obase : 36;
      (%o7)                          10
      (%i8) 36^8 - 1;
      (%o8)                       0ZZZZZZZZ

  Display flags and variables ·Console interaction ·

オプション変数: pfeformat

  デフォルト値: `false`

  `pfeformat`が`true`の時、 整数の比は斜線（スラッシュ）文字で表示され、 整数分母`n`は掛け算項`1/n`として先に表示されます。

      (%i1) pfeformat: false$
      (%i2) 2^16/7^3;
                                    65536
      (%o2)                         -----
                                     343
      (%i3) (a+b)/8;
                                    b + a
      (%o3)                         -----
                                      8
      (%i4) pfeformat: true$
      (%i5) 2^16/7^3;
      (%o5)                       65536/343
      (%i6) (a+b)/8;
      (%o6)                      1/8 (b + a)

  Display flags and variables ·

オプション変数: powerdisp

  デフォルト値: `false`

  `powerdisp`が`true`の時、 べきを増やす順に項を使って和が表示されます。 例えば、 多項式は切り詰められたべき級数として表示され、 最初に定数項最後に最高次項となります。

  デフォルトでは和の項はべきを減らす順に表示されます。

  Display flags and variables ·

関数: print (expr_1, …, expr_n)

  expr_1, …, expr_nを１つ１つ、左から右へ評価し、 コンソールディスプレイの左端から表示します。

  `print`が返す値は最後の引数の値です。 `print`は中間式ラベルを生成しません。

  `display`, `disp`, `ldisplay`, `ldisp`も参照してください。 これらの関数は一行ずつ１つの式を表示しますが、 `print`は一行に２つ以上の式を表示しようとします。

  ファイルの中身を表示するには `printfile`を参照してください。

  例:

      (%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
            radcan (log (a^10/b)))$
                  3        2      2      3
      (a+b)^3 is b  + 3 a b  + 3 a  b + a  log (a^10/b) is

                                                    10 log(a) - log(b)
      (%i2) r;
      (%o2)                  10 log(a) - log(b)
      (%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
            radcan (log (a^10/b)))$
                                 (a+b)^3 is

                           3        2      2      3
                          b  + 3 a b  + 3 a  b + a

                               log (a^10/b) is

                             10 log(a) - log(b)

  Display functions ·

オプション変数: sqrtdispflag

  デフォルト値: `true`

  `sqrtdispflag`が`false`の時、 `sqrt`を指数1/2で表示するようにします。

  Mathematical functions ·Display flags and variables ·

オプション変数: stardisp

  デフォルト値: `false`

  `stardisp`が`true`の時 掛け算はオペランドの間のアスタリスク`*`で表示されます。

  Display flags and variables ·

オプション変数: ttyoff

  デフォルト値: `false`

  `ttyoff`が`true`の時、 出力式は表示されません。 出力式は計算され、ラベルに割り当てられます。 `labels`を参照してください。

  エラーメッセージや`describe`の出力のように、組み込みMaxima関数によって出力されたテキストは `ttyoff`の影響を受けません。

  Display flags and variables ·

Next: Expressions, Previous: Command Line, Up: Top [Contents][Index]

## 5 Data Types and Structures

Next: Strings, Previous: Data Types and Structures, Up: Data Types and Structures [Contents][Index]

### 5.1 Numbers

Next: Functions and Variables for Numbers, Previous: Numbers, Up: Numbers [Contents][Index]

#### 5.1.1 Introduction to Numbers

#### Complex numbers

Maximaでは複素数式を式の実部と`%i`かける虚部の足し算で指定します。 例えば、等式 `x^2 - 4*x + 13 = 0`の根は `2 + 3*%i`と `2 - 3*%i`です。 複素数式の積の整理は積を展開することで影響を受けるかもしれないことに注意してください。 複素数式の商や根、他の関数の整理は普通、 `realpart`, `imagpart`, `rectform`, `polarform`, `abs`, `carg`関数を使って達成することができます。

Complex variables ·

Previous: Introduction to Numbers, Up: Numbers [Contents][Index]

#### 5.1.2 Functions and Variables for Numbers

関数: bfloat (expr)

  exprの中のすべての数や数の関数を多倍長浮動小数点に変換します。 戻り値の多倍長浮動小数点の有効桁数は、 グローバル変数`fpprec`によって規定されます。

  `float2bf`が`false`の場合、 浮動小数点が多倍長浮動小数点に変換される時 （精度が落ちることを意味するので）警告メッセージが出力されます。

  Numerical evaluation ·

関数: bfloatp (expr)

  もしexprが多倍長浮動小数点数なら`true`を、そうでなければ`false`を返します。

  Numerical evaluation ·Predicate functions ·

オプション変数: bftorat

  デフォルト値: `false`

  `bftorat`は多倍長浮動小数点の有理数への変換を制御します。 `bftorat`が`false`の時、 `ratepsilon`が変換を制御するのに使われます。 (これは比較的小さな有理数になります。) `bftorat`が`true`の時、 生成された有理数は多倍長浮動小数点を正確に表します。

  Numerical evaluation ·

オプション変数: bftrunc

  デフォルト値: `true`

  `bftrunc`は、非ゼロの多倍長浮動小数点数の中のずるずる続くゼロを表示しないようにします。 例えば、もし`bftrunc`が`false`なら、 `bfloat (1)`は`1.000000000000000B0`と表示されます。 そうでなければ、これは、`1.0B0`と表示されます。

  Numerical evaluation ·

関数: evenp (expr)

  もしexprが偶数なら`true`を返します。 他の場合には`false`を返します。

  Predicate functions ·

関数: float (expr)

  exprの中の整数、有理数、多倍長浮動小数点を浮動小数点に変換します。 `float`は`evflag`でもあり、 非整数有理数と多倍長浮動小数点を浮動小数点に変換します。

  Numerical evaluation ·Evaluation flags ·

オプション変数: float2bf

  デフォルト値: `true`

  `float2bf`が`false`の場合、 浮動小数点が多倍長浮動小数点に変換される時、 （これは精度の無駄使いとなるかもしれないので、） 警告メッセージが表示されます。 デフォルト値は`true`です。

  Numerical evaluation ·

関数: floatnump (expr)

  もしexprが浮動小数点なら `true`を返し、そうでないなら `false`を返します。

  Numerical evaluation ·Predicate functions ·

オプション変数: fpprec

  デフォルト値: 16

  `fpprec`は多倍長浮動小数点上の代数のための有効桁数です。 `fpprec`は通常の浮動小数点上の計算に影響を与えません。

  `bfloat`と`fpprintprec`も参照してください。

  Numerical evaluation ·

オプション変数: fpprintprec

  デフォルト値: 0

  `fpprintprec`は、通常の浮動小数点もしくは多倍長浮動小数点を表示する時の 表示する桁数です。

  通常の浮動小数点に関しては、 `fpprintprec`が2から16までの値を持つ時、 表示されるディジット数は`fpprintprec`に等しいです。 そうでなければ、`fpprintprec`は0もしくは16より大きく、 表示されるディジット数は16です。

  多倍長浮動小数点に関しては、 `fpprintprec`が2から`fpprec`までの値を持つ時、 表示される桁数は、`fpprintprec`に等しいです。 そうでなければ、`fpprintprec`は、0もしくは`fpprec`より大きく、 表示される桁数は`fpprec`に等しいです。

  `fpprintprec`は1にはできません。

  Numerical evaluation ·Display flags and variables ·

関数: integerp (expr)

  もしexprが整数リテラルなら `true`を、 そうでないなら `false`を返します。

  もし引数がシンボルならたとえ引数が宣言された整数でも、 `integerp`は `false`を返します。

  例:

      (%i1) integerp (0);
      (%o1)                         true
      (%i2) integerp (1);
      (%o2)                         true
      (%i3) integerp (-17);
      (%o3)                         true
      (%i4) integerp (0.0);
      (%o4)                         false
      (%i5) integerp (1.0);
      (%o5)                         false
      (%i6) integerp (%pi);
      (%o6)                         false
      (%i7) integerp (n);
      (%o7)                         false
      (%i8) declare (n, integer);
      (%o8)                         done
      (%i9) integerp (n);
      (%o9)                         false

  Predicate functions ·

オプション変数: m1pbranch

  デフォルト値: `false`

  `m1pbranch`は `-1`のべき乗の主枝です。 `(-1)^(1/3)`(すなわち、「奇」の有理指数)や `(-1)^(1/4)`(すなわち、「偶」の有理指数) のような量は以下のように扱われます:

                    domain:real

      (-1)^(1/3):      -1
      (-1)^(1/4):   (-1)^(1/4)

                   domain:complex
      m1pbranch:false          m1pbranch:true
      (-1)^(1/3)               1/2+%i*sqrt(3)/2
      (-1)^(1/4)              sqrt(2)/2+%i*sqrt(2)/2

  Expressions ·Global flags ·

関数: nonnegintegerp (n)

  `n >= 0`かつ nが整数の時だけ`true`を返します。

  Package linearalgebra ·Predicate functions ·

関数: numberp (expr)

  もしexprが文字リテラルか、有理数か、浮動小数点数か、多倍長浮動小数点なら `true`を、 そうでなければ `false`を返します。

  もし引数がシンボルなら、 たとえ引数が`%pi`や`%i`のようなシンボリックな数でも、また、 `even`, `odd`, `integer`, `rational`, `irrational`, `real`, `imaginary`, `complex`のいずれかに宣言されていても、 `numberp`は `false`を返します。

  例:

      (%i1) numberp (42);
      (%o1)                         true
      (%i2) numberp (-13/19);
      (%o2)                         true
      (%i3) numberp (3.14159);
      (%o3)                         true
      (%i4) numberp (-1729b-4);
      (%o4)                         true
      (%i5) map (numberp, [%e, %pi, %i, %phi, inf, minf]);
      (%o5)      [false, false, false, false, false, false]
      (%i6) declare (a, even, b, odd, c, integer, d, rational,
           e, irrational, f, real, g, imaginary, h, complex);
      (%o6)                         done
      (%i7) map (numberp, [a, b, c, d, e, f, g, h]);
      (%o7) [false, false, false, false, false, false, false, false]

  Predicate functions ·

特殊シンボル: numer

  `numer`は数値の引数を持つ（指数関数を含む）いくつかの数学関数を 浮動小数点に評価するようにします。 数値が与えられた`expr`の中の変数を値に置き換えるようにします。 それは `float`スイッチをオンにもします。

  `%enumer`も参照してください。

  例:

      (%i1) [sqrt(2), sin(1), 1/(1+sqrt(3))];
                                              1
      (%o1)            [sqrt(2), sin(1), -----------]
                                         sqrt(3) + 1
      (%i2) [sqrt(2), sin(1), 1/(1+sqrt(3))],numer;
      (%o2) [1.414213562373095, .8414709848078965, .3660254037844387]

  Numerical evaluation ·Evaluation flags ·

オプション変数: numer_pbranch

  デフォルト値: `false`

  オプション変数`numer_pbranch`は 負の整数、有理数、または浮動小数点数のべきの数値評価を制御します。 `numer_pbranch`が`true`でかつ、指数が浮動小数点数であるか オプション変数`numer`も`true`の時、 Maximaは主枝を使って数値結果を評価します。 そうでなければ、式整理されたが未評価の結果が返されます。

  例:

      (%i1) (-2)^0.75;
      (%o1) (-2)^0.75

      (%i2) (-2)^0.75,numer_pbranch:true;
      (%o2) 1.189207115002721*%i-1.189207115002721

      (%i3) (-2)^(3/4);
      (%o3) (-1)^(3/4)*2^(3/4)

      (%i4) (-2)^(3/4),numer;
      (%o4) 1.681792830507429*(-1)^0.75

      (%i5) (-2)^(3/4),numer,numer_pbranch:true;
      (%o5) 1.189207115002721*%i-1.189207115002721

  Numerical evaluation ·

関数: numerval (x_1, expr_1, …, x_n, expr_n)

  変数`x_1`, …, `x_n`を `expr_1`, …, `expr_n`に等しい数値を持つ変数だと宣言します。 もし `numer`フラグが `true`なら、 変数が現れる任意の式にて、数値は評価され、変数に代入されます。 `ev`も参照してください。

  式`expr_1`, …, `expr_n`は、任意の式を取り得ます。数値である必要はありません。

  Declarations and inferences ·Numerical evaluation ·

関数: oddp (expr)

  もしもexpが奇数であれば`true`を返し、 それ以外では`false`を返します。

  Predicate functions ·

オプション変数: ratepsilon

  デフォルト値: 2.0e-8

  `ratepsilon`は浮動小数点数を有理数に変換する際に使われる許容誤差です。

  Numerical evaluation ·Rational expressions ·

関数: rationalize (expr)

  Maximaの式exprの中の倍精度浮動小数点やビッグフローすべてを同値の有理数に変換します。 もし浮動小数点の２値表現に詳しくなれば、`rationalize (0.1)`が1/10に等しくないことに 驚くかもしれません。 この振る舞いはMaximaに特別なわけではありません。―1/10は２値の循環小数表現を持ちます。

      (%i1) rationalize (0.5);
                                      1
      (%o1)                           -
                                      2
      (%i2) rationalize (0.1);
                                     1
      (%o2)                          --
                                     10
      (%i3) fpprec : 5$
      (%i4) rationalize (0.1b0);
                                   209715
      (%o4)                        -------
                                   2097152
      (%i5) fpprec : 20$
      (%i6) rationalize (0.1b0);
                           236118324143482260685
      (%o6)                ----------------------
                           2361183241434822606848
      (%i7) rationalize (sin (0.1*x + 5.6));
                                    x    28
      (%o7)                     sin(-- + --)
                                    10   5

  使用例:

      (%i1) unitfrac(r) := block([uf : [], q],
          if not(ratnump(r)) then
             error("The input to 'unitfrac' must be a rational number"),
          while r # 0 do (
              uf : cons(q : 1/ceiling(1/r), uf),
              r : r - q),
          reverse(uf))$

      (%o1) unitfrac(r) := block([uf : [], q],
      if not ratnump(r) then
         error("The input to 'unitfrac' must be a rational number"),
                                        1
      while r # 0 do (uf : cons(q : ----------, uf), r : r - q),
                                            1
                                    ceiling(-)
                                            r
      reverse(uf))
      (%i2) unitfrac (9/10);
                                  1  1  1
      (%o2)                      [-, -, --]
                                  2  3  15
      (%i3) apply ("+", %);
                                     9
      (%o3)                          --
                                     10
      (%i4) unitfrac (-9/10);
                                        1
      (%o4)                       [- 1, --]
                                        10
      (%i5) apply ("+", %);
                                      9
      (%o5)                         - --
                                      10
      (%i6) unitfrac (36/37);
                              1  1  1  1    1
      (%o6)                  [-, -, -, --, ----]
                              2  3  8  69  6808
      (%i7) apply ("+", %);
                                     36
      (%o7)                          --
                                     37

  Numerical evaluation ·

関数: ratnump (expr)

  もしexprが整数リテラルもしくは整数リテラルの比なら `true`を返し、 そうでなければ `false`を返します。

  Predicate functions ·Rational expressions ·

Next: Constants, Previous: Numbers, Up: Data Types and Structures [Contents][Index]

### 5.2 Strings

Next: Functions and Variables for Strings, Previous: Strings, Up: Strings [Contents][Index]

#### 5.2.1 Introduction to Strings

文字列(クォートされた文字の列)は入力の際にはダブルクォートマーク `"`で括り、 グローバル変数 `stringdisp`に依存して、クォートマークありだったりなしだったりで 表示されます。

文字列は、埋め込みタブ、改行、キャリッジリターン文字を含む任意の文字を含み得ます。 列 `\"`は文字通りダブルクォートとして認識され、 `\\`は文字通りバックスラッシュとして認識されます。 バックスラッシュが行の終わりに現れる時、 バックスラッシュと(改行かキャリッジリターンと改行かいずれかの)行終端を無視します。 そして、文字列は次の行に続きます。 他にバックスラッシュともう一つの文字の組み合わせで特殊なものはありません; `"`か, `\`,　行終端以外の任意の文字の前にバックスラッシュが現れる時、 バックスラッシュは無視されます。 文字列の中に文字リテラルを埋め込むことを除いて (タブ、改行、キャリッジリターンのような)特殊文字を表す方法はありません。

Maximaでは文字タイプはありません; 文字単体は1文字の文字列として表されます。

`stringproc`アドオンパッケージは文字列に機能する多くの関数を含みます。

例:

    (%i1) s_1 : "This is a string.";
    (%o1)               This is a string.
    (%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters.";
    (%o2) Embedded "double quotes" and backslash \ characters.
    (%i3) s_3 : "Embedded line termination
    in this string.";
    (%o3) Embedded line termination
    in this string.
    (%i4) s_4 : "Ignore the \
    line termination \
    characters in \
    this string.";
    (%o4) Ignore the line termination characters in this string.
    (%i5) stringdisp : false;
    (%o5)                         false
    (%i6) s_1;
    (%o6)                   This is a string.
    (%i7) stringdisp : true;
    (%o7)                         true
    (%i8) s_1;
    (%o8)                  "This is a string."

Syntax ·

Previous: Introduction to Strings, Up: Strings [Contents][Index]

#### 5.2.2 Functions and Variables for Strings

関数: concat (arg_1, arg_2, …)

  引数を連結します。 引数はアトムに評価されなければいけません。 もし最初の引数がシンボルなら戻り値はシンボルで、 そうでなければ文字列です。

  `concat`は引数を評価します。 シングルクォート`'`は評価を抑制します。

      (%i1) y: 7$
      (%i2) z: 88$
      (%i3) concat (y, z/2);
      (%o3)                          744
      (%i4) concat ('y, z/2);
      (%o4)                          y44

  `concat`によって組み立てられたシンボルは値に割り当てられたり、式の中に現れたりします。 `::` (ダブルコロン)割り当て演算子は左辺を評価します。

      (%i5) a: concat ('y, z/2);
      (%o5)                          y44
      (%i6) a:: 123;
      (%o6)                          123
      (%i7) y44;
      (%o7)                          123
      (%i8) b^a;

                                     y44
      (%o8)                         b

      (%i9) %, numer;
                                     123
      (%o9)                         b

  `concat (1, 2)`は数のように見えますが、文字列であることに注意してください。

      (%i10) concat (1, 2) + 3;
      (%o10)                       12 + 3

  Expressions ·Strings ·

関数: sconcat (arg_1, arg_2, ...)

  引数を文字列に連結します。 `concat`と違い、引数はアトムである必要はありません。

      (%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
      (%o1)               xx[3]:y^3+3*x*y^2+3*x^2*y+x^3

  Expressions ·Strings ·

関数: string (expr)

  `expr`を、ただまるでタイプされたようにMaximaの線形表記に変換します。

  `string`の戻り値は文字列であり、 計算の中で使うことはできません。

  Strings ·

オプション変数: stringdisp

  デフォルト値: `false`

  `stringdisp`が`true`の時、 文字列はダブルクォートマークで囲まれて表示されます。 そうでなければクォートマークは表示されません。

  関数定義を表示する時はいつも、`stringdisp`は `true`です。

  例:

      (%i1) stringdisp: false$
      (%i2) "This is an example string.";
      (%o2)              This is an example string.

      (%i3) foo () :=
            print ("This is a string in a function definition.");

      (%o3) foo() :=
                    print("This is a string in a function definition.")
      (%i4) stringdisp: true$
      (%i5) "This is an example string.";
      (%o5)             "This is an example string."

  Display flags and variables ·

Next: Lists, Previous: Strings, Up: Data Types and Structures [Contents][Index]

### 5.3 Constants

Previous: Constants, Up: Constants [Contents][Index]

### 5.4 Functions and Variables for Constants

定数: %e

  `%e`はEuler数としても知られる自然対数の基数を表します。 `%e`の数値は倍精度浮動小数点数2.718281828459045d0です。

  Constants ·

定数: %i

  `%i`は虚数単位sqrt(- 1)を表します。

  Constants ·

定数: false

  `false`は同じ名前のブーリアン定数を表します。 Maximaは、Lispの値`NIL`で`false`を実装しています。

  Constants ·

定数: %gamma

  Euler-Macheroni定数0.5772156649015329 ....

  Constants ·

定数: ind

  `ind`は有界で不定の結果を表します。

  `limit`も参照してください。

  例:

      (%i1) limit (sin(1/x), x, 0);
      (%o1)                          ind

  Constants ·

定数: inf

  `inf`は実数の正の無限大を表します。

  Constants ·

定数: infinity

  `infinity`は複素数の無限大を表します。

  Constants ·

定数: minf

  `minf`は実数のマイナスの（すなわち負の）無限大を表します。

  Constants ·

定数: %phi

  `%phi`は黄金比と呼ばれる(1 + sqrt(5))/2を表します。 `%phi`の数値は倍精度浮動小数点数1.618033988749895d0です。

  `fibtophi`は、`%phi`を使って フィボナッチ数`fib(n)`を表現します。

  デフォルトでは、Maximaは `%phi`の代数的プロパティを知りません。 `tellrat(%phi^2 - %phi - 1)`と`algebraic: true`を評価した後、 `ratsimp`は `%phi`を含むいくつかの式を整理できます。

  例:

  `fibtophi`は、`%phi`を使って フィボナッチ数`fib(n)`を表現します。

      (%i1) fibtophi (fib (n));
                                 n             n
                             %phi  - (1 - %phi)
      (%o1)                  -------------------
                                 2 %phi - 1
      (%i2) fib (n-1) + fib (n) - fib (n+1);
      (%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
      (%i3) fibtophi (%);
                  n + 1             n + 1       n             n
              %phi      - (1 - %phi)        %phi  - (1 - %phi)
      (%o3) - --------------------------- + -------------------
                      2 %phi - 1                2 %phi - 1
                                                n - 1             n - 1
                                            %phi      - (1 - %phi)
                                          + ---------------------------
                                                    2 %phi - 1
      (%i4) ratsimp (%);
      (%o4)                           0

  デフォルトでは、Maximaは `%phi`の代数的プロパティを知りません。 `tellrat(%phi^2 - %phi - 1)`と`algebraic: true`を評価した後、 `ratsimp`は `%phi`を含むいくつかの式を整理できます。

      (%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1));
                       2                      2
      (%o1)        %phi  A - %phi A - A + %phi  - %phi - 1
      (%i2) ratsimp (e);
                        2                     2
      (%o2)        (%phi  - %phi - 1) A + %phi  - %phi - 1
      (%i3) tellrat (%phi^2 - %phi - 1);
                                  2
      (%o3)                  [%phi  - %phi - 1]
      (%i4) algebraic : true;
      (%o4)                         true
      (%i5) ratsimp (e);
      (%o5)                           0

  Constants ·

定数: %pi

  `%pi`は直径に体する円周の比を表します。 `%pi`の数値は倍精度浮動小数点数3.141592653589793d0です。

  Constants ·

定数: true

  `true`は同じ名前のブーリアン定数を表します。 MaximaはLispの値`T`で`true`を実装しています。

  Constants ·

定数: und

  `und`は未定義の結果を表します。

  `limit`も参照してください。

  例:

      (%i1) limit (x*sin(x), x, inf);
      (%o1)                          und

  Constants ·

定数: zeroa

  `zeroa`はゼロの上の無限小を表します。 `zeroa`は式の中で使うことができます。 `limit`は無限小を含む式を整理します。

  `zerob`と`limit`も参照してください。

  例:

  `limit`は無限小を含む式を整理します:

      (%i1) limit(zeroa);
      (%o1)                           0
      (%i2) limit(x+zeroa);
      (%o2)                           x

  Constants ·

定数: zerob

  `zerob`はゼロの下の無限小を表します。 `zerob`は式の中で使うことができます。 `limit`は無限小を含む式を整理します。

  `zeroa`と`limit`も参照してください。

  Constants ·

Next: Arrays, Previous: Constants, Up: Data Types and Structures [Contents][Index]

### 5.5 Lists

Next: Functions and Variables for Lists, Previous: Lists, Up: Lists [Contents][Index]

#### 5.5.1 Introduction to Lists

リストはMaximaとLispにとって基本的な構成要素です。 配列、ハッシュテーブル、数以外のデータタイプすべてはLispのリストとして表現されます。 これらのLispのリストは 式 `a+2`を示すために以下の形式を取ります。

    ((MPLUS) $A 2)

Maximaレベルでは中置表記`a+2`を見ることになるでしょう。 Maximaには、以下のようにプリントされるリストもあります。

    [1, 2, 7, x+y]

これは4要素のリストの場合の例です。 内部的には、これは以下の形式のLispのリストに対応します。

    ((MLIST) 1  2  7  ((MPLUS)  $X $Y ))

Maxima式のタイプフィールドを意味するフラグはそれ自体リストです。 整理器を通った後、上のリストは以下のようになるでしょう。

    ((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))

Previous: Introduction to Lists, Up: Lists [Contents][Index]

#### 5.5.2 Functions and Variables for Lists

特殊シンボル: [
特殊シンボル: ]

  先頭が`[`で終わりが`]`のマークはリストです。

  `[`と`]`は、リスト、配列、ハッシュ配列、配列関数の添字もくくります。

  例:

      (%i1) x: [a, b, c];
      (%o1)                       [a, b, c]
      (%i2) x[3];
      (%o2)                           c
      (%i3) array (y, fixnum, 3);
      (%o3)                           y
      (%i4) y[2]: %pi;
      (%o4)                          %pi
      (%i5) y[2];
      (%o5)                          %pi
      (%i6) z['foo]: 'bar;
      (%o6)                          bar
      (%i7) z['foo];
      (%o7)                          bar
      (%i8) g[k] := 1/(k^2+1);
                                        1
      (%o8)                     g  := ------
                                 k     2
                                      k  + 1
      (%i9) g[10];
                                      1
      (%o9)                          ---
                                     101

  Lists ·Operators ·

関数: append (list_1, …, list_n)

  list_1の要素のあとに list_2の要素が続き、… という１つのリストを返します。 `append`は一般式上でも機能します。 例えば、 `append (f(a,b), f(c,d,e));`は `f(a,b,c,d,e)`をもたらします。

  例を見るには、 `example(append);`を実行してください。

  Lists ·Expressions ·

関数: assoc (key, list, default)
関数: assoc (key, list)

  この関数は 形式 `[x,y,z,...]`の入力 listの左辺の中で keyを探します。 ここで listの要素のそれぞれは二項演算子と２つの要素の式です。 例えば、 `x=1`, `2^3`, `[a,b]`など。 最初のオペランドに対して keyがチェックされます。 もし `key`が見つかったら、 `assoc`は二番目のオペランドを返します。 もし `key`が見つからなかったら、 default値を返します。 defaultはオプションで、省略すると `false`に設定されます。

  Lists ·Expressions ·

関数: cons (expr, list)

  最初の要素として要素 exprで構成され、 listの要素が続く新しいリストを返します。 `cons`は他の式上でも機能します。 例えば、 `cons(x, f(a,b,c));` -> `f(x,a,b,c)`。

  Lists ·Expressions ·

関数: copylist (list)

  リスト listのコピーを返します。

  Lists ·

関数: create_list (form, x_1, list_1, …, x_n, list_n)

  list_1の要素それぞれにバインドされた x_1で、 また、それぞれのバインドに対して、 x_2を list_2の要素それぞれにバインドして、... それらのバインドを使って formを評価することによって リストを生成します。 結果の要素の数はそれぞれのリストの要素の数の積です。 それぞれの変数 x_iは実際に、シンボルでなければいけません。ーそれは評価されません。 リスト引数は繰り返しの始めに一度だけ評価されます。

      (%i1) create_list(x^i,i,[1,3,7]);
                       3   7
      (%o1)       [x, x , x ]

  二重の繰り返しで:

      (%i1) create_list([i,j],i,[a,b],j,[e,f,h]);
      (%o1) [[a, e], [a, f], [a, h], [b, e], [b, f], [b, h]]

  list_iの代わりに、 それぞれが数に評価される２つの引数を供給することもできます。 これらは繰り返しの下限と上限になります。

      (%i1) create_list([i,j],i,[1,2,3],j,1,i);
      (%o1) [[1, 1], [2, 1], [2, 2], [3, 1], [3, 2], [3, 3]]

  `j`変数の範囲やリストは `i`の現在値に依存することができることに注意してください。

  Lists ·

関数: delete (expr_1, expr_2)
関数: delete (expr_1, expr_2, n)

  `delete(expr_1, expr_2)`は、 expr_2から そのトップレベル演算子の引数のうち、 expr_1と("="で決定される意味で)同じ引数を取り除きます。 "="は、同値ではなく、形式的な同一をテストすることに注意してください。 部分式の引数には影響しないことにも注意してください。

  expr_1はアトムか、非アトムの式を取り得ます。 expr_2は任意の非アトムの式を取り得ます。 `delete`は新しい式を返します; expr_2を変更しません。

  `delete(expr_1, expr_2, n)`は、

  expr_2から そのトップレベル演算子の引数のうち、 expr_1と同じ最初の n個の引数を取り除きます。 もしそんな引数が n個より少ないなら、 該当するすべての引数が取り除かれます。

  例:

  リストから要素を削除。

      (%i1) delete (y, [w, x, y, z, z, y, x, w]);
      (%o1)                  [w, x, z, z, x, w]

  和から項を削除。

      (%i1) delete (sin(x), x + sin(x) + y);
      (%o1)                         y + x

  積から因子を削除。

      (%i1) delete (u - x, (u - w)*(u - x)*(u - y)*(u - z));
      (%o1)                (u - w) (u - y) (u - z)

  任意の式から引数を削除。

      (%i1) delete (a, foo (a, b, c, d, a));
      (%o1)                     foo(b, c, d)

  削除する引数の数を制限。

      (%i1) delete (a, foo (a, b, a, c, d, a), 2);
      (%o1)                    foo(b, c, d, a)

  引数が expr_1と同じかどうかは"="で決定されます。 `equal`ですが、"="でない引数は取り除かれません。

      (%i1) [is(equal(0, 0)), is(equal(0, 0.0)), is(equal(0, 0b0))];

      `rat' replaced 0.0 by 0/1 = 0.0
      `rat' replaced 0.0B0 by 0/1 = 0.0B0
      (%o1)                  [true, true, true]
      (%i2) [is (0 = 0), is (0 = 0.0), is (0 = 0b0)];
      (%o2)                 [true, false, false]
      (%i3) delete (0, [0, 0.0, 0b0]);
      (%o3)                     [0.0, 0.0b0]
      (%i4) is (equal ((x + y)*(x - y), x^2 - y^2));
      (%o4)                         true
      (%i5) is ((x + y)*(x - y) = x^2 - y^2);
      (%o5)                         false
      (%i6) delete ((x + y)*(x - y), [(x + y)*(x - y), x^2 - y^2]);
                                    2    2
      (%o6)                       [x  - y ]

  Lists ·Expressions ·

関数: eighth (expr)

  式またはリスト exprの8番目の項を返します。 詳細は `first`を参照してください。

  Lists ·Expressions ·

関数: endcons (expr, list)

  exprが続く `list`の要素から成る新しいリストを返します。 `endcons`は一般式上でも機能します。 例えば、 `endcons(x, f(a,b,c));` -> `f(a,b,c,x)`。

  Lists ·Expressions ·

関数: fifth (expr)

  式またはリスト exprの5番目の項を返します。 詳細は `first`を参照してください。

  Lists ·Expressions ·

関数: first (expr)

  リストの最初の要素、行列の最初の行、和の最初の項などに帰着する、 exprの最初の部分を返します。 `first`とその関連関数 `rest`と `last`は、 入力時にタイプした形式ではなく、 exprの表示形式上で機能することに注意してください。 しかしながら、もし変数 `inflag`が `true`に設定されているなら、 これらの関数は exprの内部形式を見ます。 整理器は式を再配置することに注意してください。 例えば、 `first(x+y)`は、 もし `inflag`が `true`なら `x`で、 もし `inflag`が `false`なら `y` です。 (`first(y+x)`は同じ結果を与えます。) 関数 `second` .. `tenth`は 入力引数の二番目から十番目の部分をもたらします。

  Lists ·Expressions ·

関数: fourth (expr)

  式またはリスト exprの4番目の項を返します。 詳細は `first`を参照してください。

  Lists ·Expressions ·

関数: join (l, m)

  リストlとmの要素を交互に含む新しいリストを生成します。 結果は、要素 `[l[1], m[1], l[2], m[2], ...]`を持ちます。 リスト lと mは、任意のタイプの要素を含めます。

  もしリストの長さが違ったら、 `join`は長いリストの要素を無視します。

  もし lか mがリストでなかったら、 Maximaは文句を言います。

  例:

      (%i1) L1: [a, sin(b), c!, d - 1];
      (%o1)                [a, sin(b), c!, d - 1]
      (%i2) join (L1, [1, 2, 3, 4]);
      (%o2)          [a, 1, sin(b), 2, c!, 3, d - 1, 4]
      (%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
      (%o3)        [a, aa, sin(b), bb, c!, cc, d - 1, dd]

  Lists ·

関数: last (expr)

  expr最後の(項、行、要素など）部分を返します。

  Lists ·Expressions ·

関数: length (expr)

  (デフォルトでは) exprの外部(表示)形式の部分の数を返します。 リストに関しては、これは要素の数を返し、 行列に関しては行数であり、 和に関しては項数です。 (`dispform`を参照してください。)

  `length`コマンドは `inflag`スイッチに影響されます。 だから例えば、 `length(a/(b*c));`は、 (`exptdispflag`が `true`と仮定して) もし `inflag`が `false`なら2を与えますが、 もし `inflag`が `true`なら3を与えます。 (内部表現は本質的には `a*b^-1*c^-1`です。)

  Lists ·Expressions ·

オプション変数: listarith

  デフォルト値: `true` - もし `false`なら、 リストを伴う任意の算術演算が抑制されるようになります; `true`の時、リスト-行列演算では、 リストが行列に変換されるようになり、いつも行列の結果をもたらすよう連鎖します。 しかしながら、リスト-リスト演算はリストを返します。

  Lists ·Global flags ·

関数: listp (expr)

  もし exprがリストなら `true`、 そうでなければ `false`を返します。

  Lists ·Predicate functions ·

関数: makelist (expr, i, i_0, i_1)
関数: makelist (expr, x, list)

  要素それぞれが exprから生成されたリストを構成し、返します。

  `makelist (expr, i, i_0, i_1)`は、 i_0から i_1に等しい `j`に対して `j`番目の要素が `ev (expr, i=j)`に等しい リストを返します。

  `makelist (expr, x, list)`は、 1から `length (list)`に等しい `j`に対して、 `j`番目の要素が `ev (expr, x=list[j])`に等しい リストを返します。

  例:

      (%i1) makelist(concat(x,i),i,1,6);
      (%o1)               [x1, x2, x3, x4, x5, x6]
      (%i2) makelist(x=y,y,[a,b,c]);
      (%o2)                 [x = a, x = b, x = c]

  Lists ·

関数: member (expr_1, expr_2)

  もし `args(expr_2)`の中のある要素aに対して `is(expr_1 = a)`なら `true`を返し、 そうでなければ `false`を返します。

  `expr_2`は通常リストです。 その場合、 `args(expr_2) = expr_2`かつ `expr_2`の中のある要素 aに対して、 `is(expr_1 = a)`であることがテストです。

  `member`は `expr_2`の引数の部分を検査しません。 だから、 たとえ `expr_1`が `expr_2`のある引数の部分であっても `false`を返すかもしれません。

  `elementp`も参照してください。

  例:

      (%i1) member (8, [8, 8.0, 8b0]);
      (%o1)                         true
      (%i2) member (8, [8.0, 8b0]);
      (%o2)                         false
      (%i3) member (b, [a, b, c]);
      (%o3)                         true
      (%i4) member (b, [[a, b], [b, c]]);
      (%o4)                         false
      (%i5) member ([b, c], [[a, b], [b, c]]);
      (%o5)                         true
      (%i6) F (1, 1/2, 1/4, 1/8);
                                     1  1  1
      (%o6)                     F(1, -, -, -)
                                     2  4  8
      (%i7) member (1/8, %);
      (%o7)                         true
      (%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
      (%o8)                         true

  Lists ·Expressions ·Predicate functions ·

関数: ninth (expr)

  式またはリスト exprの9番目の項を返します。 詳細は `first`を参照してください。

  Lists ·Expressions ·

関数: pop (list)

  `pop`は、リスト listから最初の要素を取り除き、この要素を返します。 listはリストそのものではなく、リストにバインドされたシンボルでなければいけません。

  もし引数 listがリストにバインドされていないかリストが空なら、 Maximaはエラーメッセージを生成します。

  例には `push`も参照してください。

  `load("basic")`はこの関数をロードします。

  Lists ·Expressions ·

関数: push (item, list)

  `push`は項目 itemをリスト listの先頭に追加し、 新しいリストのコピーを返します。 listはリストそのものではなく、リストにバインドされたシンボルでなければいけません。 itemは任意のMaximaシンボルや式が使えます。

  もし引数 listがリストにバインドされていないかリストが空なら、 Maximaはエラーメッセージを生成します。

  リストから最初の項目を取り除くには `pop`も参照してください。

  `load("basic")`はこの関数をロードします。

  例:

      (%i1) ll:[];
      (%o1)                          []
      (%i2) push(x,ll);
      (%o2)                          [x]
      (%i3) push(x^2+y,ll);
                                       2
      (%o3)                      [y + x , x]
      (%i4) a:push("string",ll);
                                           2
      (%o4)                  [string, y + x , x]
      (%i5) pop(ll);
      (%o5)                        string
      (%i6) pop(ll);
                                        2
      (%o6)                        y + x
      (%i7) pop(ll);
      (%o7)                           x
      (%i8) ll;
      (%o8)                          []
      (%i9) a;
                                           2
      (%o9)                  [string, y + x , x]

  Lists ·Expressions ·

関数: rest (expr, n)
関数: rest (expr)

  もし nが正なら、 頭の n個の要素を取り除いた exprを返し、 もし nが負なら、 お尻の `- n`個の要素を取り除いた exprを返します。 もし nが1なら、省略できます。 exprは、リスト、行列、他の式を取り得ます。

  Lists ·Expressions ·

関数: reverse (list)

  list のメンバーの順序を逆にします。 (メンバー自身は変えません。) `reverse`は、一般式でも機能します。 例えば、 `reverse(a=b);`は `b=a`を与えます。

  Lists ·Expressions ·

関数: second (expr)

  式またはリスト exprの二番目の項を返します。 詳細は `first`を参照してください。

  Lists ·Expressions ·

関数: seventh (expr)

  式またはリスト exprの7番目の項を返します。 詳細は `first`を参照してください。

  Lists ·Expressions ·

関数: sixth (expr)

  式またはリスト exprの6番目の項を返します。 詳細は `first`を参照してください。

  Lists ·Expressions ·

関数: sort (L, P)
関数: sort (L)

  任意の隣り合う要素について`P (L[k], L[k + 1])`が`true` になるように ２つの引数の述語論理`P`に従ってリストLをソートします。 述語論理は関数や２値中値演算子の名前として、`lambda`式として指定されるかもしれません。 もし演算子名として指定されたなら、名前は「ダブルクォート」でくくられます。

  ソートされたリストは新しいオブジェクトとして返されます; Lは変更されません。 戻り値を構成するために、 `sort`は、Lの要素の浅いコピーを実行します。

  もし述語論理PがLの要素の総順序でなければ、 `sort`は、エラーなしに実行を完了するかもしれませんが、結果は未定義です。 もし述語論理が`true`もしくは`false`以外の何かに評価されるなら、 `sort`はエラーを出力します。

  `sort (L)`は `sort (L, orderlessp)`と同値です。 すなわち、デフォルトソート順序は昇順です。`orderlessp`で決められているように。

  述語論理`ordergreatp`はリストを降順にソートします。 述語論理`ordermagnitudep`はMaxima数や数値を持つ定数シンボル、 定数に評価されることができる式を大きさによってソートします。 リストLの他のすべての要素は`orderlessp`によってソートされます。 述語論理`"<"`も大きさによる順序付けを許しますが、 もしリストLの要素が`"<"`の下で比較可能でないなら完全には並べません。

  例:

      (%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c,
            19 - 3 * x]);
                     5
      (%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
                     2
      (%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9*c, 19 - 3*x],
            ordergreatp);
                                                         5
      (%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
                                                         2
      (%i3) sort ([%pi, 3, 4, %e, %gamma]);
      (%o3)                [3, 4, %e, %gamma, %pi]
      (%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
      (%o4)                [%gamma, %e, 3, %pi, 4]
      (%i5) my_list: [[aa,hh,uu], [ee,cc], [zz,xx,mm,cc], [%pi,%e]];
      (%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
      (%i6) sort (my_list);
      (%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]

      (%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a),
            reverse (b))));

      (%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]

  Maxima数と定数、定数式を大きさ順に並べ、他のすべての要素を降順で並べます:

      (%i8) sort([%i,1+%i,2*x,minf,inf,%e,sin(1),0,1,2,3,1.0,1.0b0],
            ordermagnitudep);
      (%o8)  [minf, 0, sin(1), 1, 1.0, 1.0b0, 2, %e, 3, inf, %i,
                                                            %i + 1, 2 x]

  Lists ·

関数: sublist (list, p)

  述語論理`p`が`true`を返すlistの要素のリストを返します。

  例:

      (%i1) L: [1, 2, 3, 4, 5, 6];
      (%o1)                  [1, 2, 3, 4, 5, 6]
      (%i2) sublist (L, evenp);
      (%o2)                       [2, 4, 6]

  Lists ·

関数: sublist_indices (L, P)

  述語論理 `maybe(P(x))`が `true`を返す、 リスト Lの要素 `x`のインデックスを返します; これは `false`はもちろん `unknown`も除外します。 Pは関数名かラムダ式を取り得ます。 Lはリストリテラルでなければいけません。

  例:

      (%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b],
                             lambda ([x], x='b));
      (%o1)                     [2, 3, 7, 9]
      (%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
      (%o2)                  [1, 2, 3, 4, 7, 9]
      (%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0],
                             identity);
      (%o3)                       [1, 4, 5]
      (%i4) assume (x < -1);
      (%o4)                       [x < - 1]
      (%i5) map (maybe, [x > 0, x < 0, x < -2]);
      (%o5)                [false, true, unknown]
      (%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
      (%o6)                          [2]

  Lists ·

関数: unique (L)

  リスト Lの重複しない要素を返します。

  Lの要素すべてが重複しない時、 `unique`は、 L自身ではなく、 Lの浅いコピーを返します。

  もし Lがリストでないなら、 `unique`はLを返します。

  例:

      (%i1) unique ([1, %pi, a + b, 2, 1, %e, %pi, a + b, [1]]);
      (%o1)              [1, 2, %e, %pi, [1], b + a]

関数: tenth (expr)

  式またはリスト exprの10番目の項を返します。 詳細は `first`を参照してください。

  Lists ·Expressions ·

関数: third (expr)

  式またはリスト exprの三番目の項を返します。 詳細は `first`を参照してください。

  Lists ·Expressions ·

Next: Structures, Previous: Lists, Up: Data Types and Structures [Contents][Index]

### 5.6 Arrays

Previous: Arrays, Up: Arrays [Contents][Index]

### 5.7 Functions and Variables for Arrays

関数: array (name, dim_1, …, dim_n)
関数: array (name, type, dim_1, …, dim_n)
関数: array ([name_1, …, name_m], dim_1, …, dim_n)

  n次元の配列を生成します。 nは5以下を取り得ます。 i番目の次元のための添字は0からdim_iまで動く整数です。

  `array (name, dim_1, ..., dim_n)`は 一般的な配列を生成します。

  `array (name, type, dim_1, ..., dim_n)`は 指定されたタイプの要素を持つ配列を生成します。 typeには 制限されたサイズの整数には`fixnum`が使え、 また、浮動小数点には`flonum`が使えます。

  `array ([name_1, ..., name_m], dim_1, ..., dim_n)` は同じ次元のm個の配列を生成します。

  もしユーザーが対応する配列を宣言する前に添字付き変数に割り当てたら、 未宣言配列が生成されます。 (ハッシュコーディングが添字上でされるので)別名ハッシュド配列と知られる未宣言配列は、 宣言配列よりもっと一般的です。 ユーザーは最大サイズを宣言せず、さらなる要素が値に割り当てられる時、ハッシュすることで それらは動的に成長します。 未宣言配列の添字は数である必要すらありません。 しかしながら、 配列がむしろ疎でないなら、 未宣言のまま放っておくより、可能な時に宣言した方がおそらく効率的です。 `array`関数は未宣言配列を宣言配列に変換するのに使うことができます。

  Arrays ·

関数: arrayapply (A, [i_1, … i_n])

  `A [i_1, ..., i_n]`を評価します。 ここで、Aは配列、i_1, …, i_nは整数です。

  これは、最初の引数が関数の代わりに配列だということを除いて、 `apply`を連想させます。

  Expressions ·Arrays ·

関数: arrayinfo (A)

  配列Aに関する情報を返します。 引数Aは、宣言配列、未宣言(ハッシュド)配列、配列関数、または添字付き関数を取り得ます。

  宣言配列では、 `arrayinfo`は、 アトム`declared`と、次元数、それぞれの次元のサイズを含むリストを返します。 配列の要素は、バインドされたものもそうでないものも、`listarray`で返されます。

  未宣言配列(ハッシュド配列)では、 `arrayinfo`は、 アトム`hashed`と、添字の数、値を持つすべての要素の添字を含むリストを返します。 値は `listarray`で返されます。

  配列関数では、 `arrayinfo`は、 アトム`hashed`と、添字の数、 記憶された関数値がある添字の値すべてを含むリストを返します。 記憶された関数値は、`listarray`で返されます。

  添字付き関数では、、 `arrayinfo`は、 returns a list comprising the アトム`hashed`と、添字の数、 ラムダ式がある添字の値すべてを含むリストを返します。 ラムダ式は `listarray`で返されます。

  `listarray`も参照してください。

  例:

  宣言配列に適用された`arrayinfo`と`listarray`。

      (%i1) array (aa, 2, 3);
      (%o1)                          aa

      (%i2) aa [2, 3] : %pi;
      (%o2)                          %pi

      (%i3) aa [1, 2] : %e;
      (%o3)                          %e

      (%i4) arrayinfo (aa);
      (%o4)                 [declared, 2, [2, 3]]

      (%i5) listarray (aa);
      (%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
                                              #####, #####, #####, %pi]

  未宣言(ハッシュド)配列に適用された`arrayinfo`と`listarray`。

      (%i1) bb [FOO] : (a + b)^2;
                                         2
      (%o1)                       (b + a)

      (%i2) bb [BAR] : (c - d)^3;
                                         3
      (%o2)                       (c - d)

      (%i3) arrayinfo (bb);
      (%o3)               [hashed, 1, [BAR], [FOO]]

      (%i4) listarray (bb);
                                    3         2
      (%o4)                 [(c - d) , (b + a) ]

  配列関数に適用された`arrayinfo`と`listarray`。

      (%i1) cc [x, y] := y / x;
                                           y
      (%o1)                      cc     := -
                                   x, y    x

      (%i2) cc [u, v];
                                      v
      (%o2)                           -
                                      u

      (%i3) cc [4, z];
                                      z
      (%o3)                           -
                                      4

      (%i4) arrayinfo (cc);
      (%o4)              [hashed, 2, [4, z], [u, v]]

      (%i5) listarray (cc);
                                    z  v
      (%o5)                        [-, -]
                                    4  u

  添字付き関数に適用された`arrayinfo`と`listarray`。

      (%i1) dd [x] (y) := y ^ x;
                                           x
      (%o1)                     dd (y) := y
                                  x

      (%i2) dd [a + b];
                                          b + a
      (%o2)                  lambda([y], y     )

      (%i3) dd [v - u];
                                          v - u
      (%o3)                  lambda([y], y     )

      (%i4) arrayinfo (dd);
      (%o4)             [hashed, 1, [b + a], [v - u]]

      (%i5) listarray (dd);
                               b + a                v - u
      (%o5)      [lambda([y], y     ), lambda([y], y     )]

  Arrays ·

関数: arraymake (A, [i_1, …, i_n])

  式`A[i_1, ..., i_n]`を返します。 結果は未評価の配列参照です。

  `arraymake`は、 戻り値は、未評価関数コールの代わりに未評価の配列参照だということを除いて、 `funmake`を連想させます。

  例:

      (%i1) arraymake (A, [1]);
      (%o1)                          A
                                      1

      (%i2) arraymake (A, [k]);
      (%o2)                          A
                                      k

      (%i3) arraymake (A, [i, j, 3]);
      (%o3)                       A
                                   i, j, 3

      (%i4) array (A, fixnum, 10);
      (%o4)                           A

      (%i5) fillarray (A, makelist (i^2, i, 1, 11));
      (%o5)                           A

      (%i6) arraymake (A, [5]);
      (%o6)                          A
                                      5

      (%i7) ''%;
      (%o7)                          36

      (%i8) L : [a, b, c, d, e];
      (%o8)                    [a, b, c, d, e]

      (%i9) arraymake ('L, [n]);
      (%o9)                          L
                                      n

      (%i10) ''%, n = 3;
      (%o10)                          c

      (%i11) A2 : make_array (fixnum, 10);
      (%o11)          {Array:  #(0 0 0 0 0 0 0 0 0 0)}

      (%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
      (%o12)          {Array:  #(1 2 3 4 5 6 7 8 9 10)}

      (%i13) arraymake ('A2, [8]);
      (%o13)                         A2
                                       8

      (%i14) ''%;
      (%o14)                          9

  Expressions ·Arrays ·

システム変数: arrays

  デフォルト値: `[]`

  `arrays`は割り当てられた配列のリストです。 これらは、`array`で宣言された配列、 (なにかw配列要素に割り当てられた)陰の定義で構成されたハッシュド配列、 `:=`と`define`で定義された配列関数を含みます。 `make_array`で定義された配列は含まれません。

  `array`, `arrayapply`, `arrayinfo`, `arraymake`, `fillarray`, `listarray`, `rearray`も参照してください。

  例:

      (%i1) array (aa, 5, 7);
      (%o1)                          aa

      (%i2) bb [FOO] : (a + b)^2;
                                         2
      (%o2)                       (b + a)

      (%i3) cc [x] := x/100;
                                         x
      (%o3)                      cc  := ---
                                   x    100

      (%i4) dd : make_array ('any, 7);
      (%o4)       {Array:  #(NIL NIL NIL NIL NIL NIL NIL)}

      (%i5) arrays;
      (%o5)                     [aa, bb, cc]

  Arrays ·Global variables ·

関数: fillarray (A, B)

  配列AをBから埋めます。 ここで、Bはリストか配列です。

  もし生成時に特定のタイプがAのために宣言されたら、 その同じタイプの要素でだけ埋めることができます; もし違ったタイプの要素をコピーする試みがなされたらエラーです。

  もし配列AとBの次元が違ったら、 Aは行優先順で埋められます。 もしBの中の要素が十分でないなら、 Aの残りを埋めるのに最後の要素が使われます。 もし多すぎるなら、残りは無視されます。

  `fillarray`は最初の引数を返します。

  例:

  9個の要素の配列を生成し、リストから埋めます。

      (%i1) array (a1, fixnum, 8);
      (%o1)                          a1

      (%i2) listarray (a1);
      (%o2)              [0, 0, 0, 0, 0, 0, 0, 0, 0]

      (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
      (%o3)                          a1

      (%i4) listarray (a1);
      (%o4)              [1, 2, 3, 4, 5, 6, 7, 8, 9]

  配列を埋めるのに要素が足らない時、 最後の要素が繰り返されます。 要素が多すぎる時、余分の要素は無視されます。

      (%i1) a2 : make_array (fixnum, 8);
      (%o1)             {Array:  #(0 0 0 0 0 0 0 0)}

      (%i2) fillarray (a2, [1, 2, 3, 4, 5]);
      (%o2)             {Array:  #(1 2 3 4 5 5 5 5)}

      (%i3) fillarray (a2, [4]);
      (%o3)             {Array:  #(4 4 4 4 4 4 4 4)}

      (%i4) fillarray (a2, makelist (i, i, 1, 100));
      (%o4)             {Array:  #(1 2 3 4 5 6 7 8)}

  多次元配列は行優先順に埋められます。

      (%i1) a3 : make_array (fixnum, 2, 5);
      (%o1)        {Array:  #2A((0 0 0 0 0) (0 0 0 0 0))}

      (%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
      (%o2)        {Array:  #2A((1 2 3 4 5) (6 7 8 9 10))}

      (%i3) a4 : make_array (fixnum, 5, 2);
      (%o3)     {Array:  #2A((0 0) (0 0) (0 0) (0 0) (0 0))}

      (%i4) fillarray (a4, a3);
      (%o4)     {Array:  #2A((1 2) (3 4) (5 6) (7 8) (9 10))}

  Arrays ·

関数: listarray (A)

  配列Aの要素のリストを返します。 引数Aは、宣言配列、未宣言(ハッシュド)配列、配列関数、添字付き関数を取り得ます。

  要素は行優先順にリストされます。 すなわち、要素は、最初のインデックスに従って振り分けられ、次に二番目のインデックスに従って、などなど。 インデックス値の振り分け順は、 `orderless`が確立する順と同じです。

  未宣言配列や、配列関数、添字付き関数では、 要素は`arrayinfo`が返すインデックス値に対応します。

  宣言された一般配列のバインドされていない要素(すなわち、`fixnum`でも`flonum`でもない要素)は、 `#####`として返されます。 宣言された`fixnum`配列または`flonum`配列のバイドされていない要素は、 それぞれ0または0.0として返されます。 未宣言配列、配列関数、添字付き関数のバインドされていない要素は返されません。

  例:

  宣言配列に適用された`listarray`と`arrayinfo`。

      (%i1) array (aa, 2, 3);
      (%o1)                          aa

      (%i2) aa [2, 3] : %pi;
      (%o2)                          %pi

      (%i3) aa [1, 2] : %e;
      (%o3)                          %e

      (%i4) listarray (aa);
      (%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
                                              #####, #####, #####, %pi]

      (%i5) arrayinfo (aa);
      (%o5)                 [declared, 2, [2, 3]]

  未宣言(ハッシュド)配列に適用された`listarray`と`arrayinfo`。

      (%i1) bb [FOO] : (a + b)^2;
                                         2
      (%o1)                       (b + a)

      (%i2) bb [BAR] : (c - d)^3;
                                         3
      (%o2)                       (c - d)

      (%i3) listarray (bb);
                                    3         2
      (%o3)                 [(c - d) , (b + a) ]

      (%i4) arrayinfo (bb);
      (%o4)               [hashed, 1, [BAR], [FOO]]

  配列関数に適用された`listarray`と`arrayinfo`。

      (%i1) cc [x, y] := y / x;
                                           y
      (%o1)                      cc     := -
                                   x, y    x

      (%i2) cc [u, v];
                                      v
      (%o2)                           -
                                      u

      (%i3) cc [4, z];
                                      z
      (%o3)                           -
                                      4

      (%i4) listarray (cc);
                                    z  v
      (%o4)                        [-, -]
                                    4  u

      (%i5) arrayinfo (cc);
      (%o5)              [hashed, 2, [4, z], [u, v]]

  添字付き関数に適用された`listarray`と`arrayinfo`。

      (%i1) dd [x] (y) := y ^ x;
                                           x
      (%o1)                     dd (y) := y
                                  x

      (%i2) dd [a + b];
                                          b + a
      (%o2)                  lambda([y], y     )

      (%i3) dd [v - u];
                                          v - u
      (%o3)                  lambda([y], y     )

      (%i4) listarray (dd);
                               b + a                v - u
      (%o4)      [lambda([y], y     ), lambda([y], y     )]

      (%i5) arrayinfo (dd);
      (%o5)             [hashed, 1, [b + a], [v - u]]

  Arrays ·

関数: make_array (type, dim_1, ..., dim_n)

  Lisp配列を生成し、返します。 typeは、`any`, `flonum`, `fixnum`, `hashed`, `functional`を取り得ます。 n個のインデックスがあり、 i番目のインデックスは0からdim_i - 1まで動きます。

  `make_array`の`array`に対する利点は、 戻り値が名前を持たないことであり、 一旦、それへのポインタが消えると、それも消えます。 例えば、もし`y: make_array (...)`なら、 `y`は領域を取るオブジェクトを指しますが、 `y: false`の後、`y`はそのオブジェクトをもはや指さないので、 オブジェクトはガーベッジコレクトされることができます。

  例:

      (%i1) A1 : make_array (fixnum, 10);
      (%o1)           {Array:  #(0 0 0 0 0 0 0 0 0 0)}

      (%i2) A1 [8] : 1729;
      (%o2)                         1729

      (%i3) A1;
      (%o3)          {Array:  #(0 0 0 0 0 0 0 0 1729 0)}

      (%i4) A2 : make_array (flonum, 10);
      (%o4) {Array:  #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}

      (%i5) A2 [2] : 2.718281828;
      (%o5)                      2.718281828

      (%i6) A2;
      (%o6)
           {Array:  #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}

      (%i7) A3 : make_array (any, 10);
      (%o7) {Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)}

      (%i8) A3 [4] : x - y - z;
      (%o8)                      - z - y + x

      (%i9) A3;
      (%o9) {Array:  #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
       -1 $Y) ((MTIMES SIMP) -1 $Z))
        NIL NIL NIL NIL NIL)}

      (%i10) A4 : make_array (fixnum, 2, 3, 5);
      (%o10) {Array:  #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
      0 0 0) (0 0 0 0 0) (0 0 0 0 0)))}

      (%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
      (%o11) {Array:  #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
          ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))}

      (%i12) A4 [0, 2, 1];
      (%o12)                         12

  Arrays ·

関数: rearray (A, dim_1, ..., dim_n)

  配列の次元を変えます。 新しい配列は 行優先順に古いものの配列で埋められます。 もし古い配列が小さすぎるなら、 残りの要素は、 配列のタイプに依って、 `false`, `0.0`または`0`で埋められます。 配列のタイプは変えられません。

  Arrays ·

関数: remarray (A_1, ..., A_n)
関数: remarray (all)

  配列と関数に関連づけられた配列を削除し、占められた領域を開放します。 引数は、宣言配列、未宣言(ハッシュド)配列、配列関数、添字付き関数を取り得ます。

  `remarray (all)`は、 グローバルリスト`arrays`の中の項目すべてを削除します。

  もしハッシュド配列の中の値を再定義することが望ましいなら、この関数を使うことが必要になるかもしれません。

  `remarray`は削除された配列のリストを返します。

  `remarray`はクォートします。

  Arrays ·

関数: subvar (x, i)

  添字付き式`x[i]`を評価します。

  `subvar`は引数を評価します。

  `arraymake (x, [i]`は 式`x[i]`を構成しますが、 それを評価はしません。

  例:

      (%i1) x : foo $
      (%i2) i : 3 $

      (%i3) subvar (x, i);
      (%o3)                         foo
                                       3

      (%i4) foo : [aa, bb, cc, dd, ee]$

      (%i5) subvar (x, i);
      (%o5)                          cc

      (%i6) arraymake (x, [i]);
      (%o6)                         foo
                                       3

      (%i7) ''%;
      (%o7)                          cc

  Expressions ·Arrays ·

関数: subvarp (expr)

  もしexprが例えば`a[i]`のように添字された変数なら、`true`を返します。

  Predicate functions ·

オプション変数: use_fast_arrays

  もし`true`なら、配列の２つのタイプだけが認識されます:

  1. 整数でインデックスされたいくつかの次元を持つができ、 情報入力としてLispまたはMaximaオブジェクトを保てるart-q配列(Common Lispでのt)。 そんな配列を構成するには、 `a:make_array(any,3,4);`を入力してください。 `a`は、12個の枠を持つ配列を値として持ち、インデックスはゼロベースです
  2. もし`b[x+1]:y^2`を実行したら、生成された配列のデフォルト値でハッシュテーブル配列 (`b`はまだ配列でもリストでも行列でもありません – もしこれらの１つなら、`x+1`は、art-q配列やリスト、行列の有効な添字ではないので 、エラーが起こります。) (キーとしても知られている)インデックスは、任意のオブジェクトを取り得ます。 一度の１つのキーだけを取ります((`b[x+1,u]:y`は`u`を無視します。)。 参照は、`b[x+1] ==> y^2`によってされます。 もちろん、キーは、例えば、 `b[[x+1,u]]:y`が有効なように リストを取り得ます。 これは古いMaximaハッシュ配列と非互換ですが、コンシングを保ちます。

  配列をシンボルの値として記憶することの利点は、 関数のローカル変数についての普通の慣例が配列にも適用することです。 ハッシュテーブルタイプは、 Maximaハッシャの古いタイプよりも 少ないコンシングを使い、もっと効率的です。 翻訳され、コンパイルされたコードに関する一貫した振る舞いを得るためには、 `translate_fast_arrays`を`true`に設定してください。

  Arrays ·Global flags ·

Previous: Arrays, Up: Data Types and Structures [Contents][Index]

### 5.8 Structures

Next: Functions and Variables for Structures, Previous: Structures, Up: Structures [Contents][Index]

#### 5.8.1 Introduction to Structures

Maximaは構造体と呼ばれる簡単なデータ集合体を提供します。 構造体は 引数が名前(フィールド名)によって識別され、式全体が演算子(構造体名)によって識別される式です。 フィールド名は任意の式を取り得ます。

構造体は`defstruct`関数によって定義されます; グローバル変数`structures`はユーザー定義の構造体のリストです。 関数`new`は構造体のインスタンスを生成します。 `@`演算子はフィールドを参照します。 `kill(S)`は構造体定義Sを取り除き、 `kill(x@ a)`は 構造体インスタンスxのフィールドaをアンバインドします。

(`display2d`を`true`で使う)プリティプリンティングのコンソール表示では、 構造体インスタンスは、 左辺側にフィールド名、右辺側に値の式として表されたそれぞれのフィールドの値と一緒に 表示されます。 (等式は単に表示物です; 値だけが実際に保存されます。) (`grind`を介してか、`display2d`を`false`で使う)1次元表示では 構造体はフィールド名ないで表示されます。

フィールド値はラムダ式でありえますが、フィールド名を関数名として使う方法はありません。 フィールドの値はあるタイプに制約することもできません; 任意のフィールドにはどんな種類の式に割り当てることができます。 フィールドを、違った文脈でアクセス可能にしたり不可能する方法はありません; すべてのフィールドはいつも可視です。

Previous: Introduction to Structures, Up: Structures [Contents][Index]

#### 5.8.2 Functions and Variables for Structures

グローバル変数: structures

  `structures`は `defstruct`で定義されたユーザー定義の構造体のリストです。

  Structures ·Global variables ·

関数: defstruct (S(a_1, …, a_n))
関数: defstruct (S(a_1 = v_1, …, a_n = v_n))

  構造体を定義します。 構造体はシンボルSと関連付けられた名前フィールドのリストa_1, …, a_nです。

  構造体のインスタンスは演算子Sと正確に`n`個の引数を持つただの式です。 `new(S)`は構造体Sの新しいインスタンスを生成します。

  ただのシンボルaである引数はフィールド名を指定します。 等式`a = v`である引数は フィールド名aとデフォルト値vを指定します。 デフォルト値は任意の式を取り得ます。

  `defstruct`は ユーザー定義の構造体のリスト`structures`上にSを入れます。

  `kill(S)`は ユーザー定義の構造体のリストからSを取り除き、構造体定義を取り除きます。

  例:

      (%i1) defstruct (foo (a, b, c));
      (%o1)                    [foo(a, b, c)]
      (%i2) structures;
      (%o2)                    [foo(a, b, c)]
      (%i3) new (foo);
      (%o3)                     foo(a, b, c)
      (%i4) defstruct (bar (v, w, x = 123, y = %pi));
      (%o4)             [bar(v, w, x = 123, y = %pi)]
      (%i5) structures;
      (%o5)      [foo(a, b, c), bar(v, w, x = 123, y = %pi)]
      (%i6) new (bar);
      (%o6)              bar(v, w, x = 123, y = %pi)
      (%i7) kill (foo);
      (%o7)                         done
      (%i8) structures;
      (%o8)             [bar(v, w, x = 123, y = %pi)]

  Structures ·

関数: new (S)
関数: new (S (v_1, …, v_n))

  `new`は構造体の新しいインスタンスを生成します。

  `new(S)`は 構造体Sの新しいインスタンスを生成します。 それぞれのフィールドは、もしデフォルト値があればデフォルト値を割り当てられ、 もしデフォルト値が構造体定義で指定されなかったなら、割り当てなしになります。

  `new(S(v_1, ..., v_n))`は フィールドが値v_1, …, v_nに割り当てられた 構造体Sの新しいインスタンスを生成します。

  例:

      (%i1) defstruct (foo (w, x = %e, y = 42, z));
      (%o1)              [foo(w, x = %e, y = 42, z)]
      (%i2) new (foo);
      (%o2)               foo(w, x = %e, y = 42, z)
      (%i3) new (foo (1, 2, 4, 8));
      (%o3)            foo(w = 1, x = 2, y = 4, z = 8)

  Structures ·

演算子: @

  `@`構造体フィールドアクセス演算子です。 式`x@ a`は 構造体インスタンスxのフィールドaの値を参照します。 フィールド名は評価されません。

  もしxのフィールドaが値を割り当てられていないなら、 `x@ a`はそれ自身に評価されます。

  `kill(x@ a)`は xのフィールド値aを値を取り除きます。

  例:

      (%i1) defstruct (foo (x, y, z));
      (%o1)                    [foo(x, y, z)]
      (%i2) u : new (foo (123, a - b, %pi));
      (%o2)           foo(x = 123, y = a - b, z = %pi)
      (%i3) u@z;
      (%o3)                          %pi
      (%i4) u@z : %e;
      (%o4)                          %e
      (%i5) u;
      (%o5)            foo(x = 123, y = a - b, z = %e)
      (%i6) kill (u@z);
      (%o6)                         done
      (%i7) u;
      (%o7)              foo(x = 123, y = a - b, z)
      (%i8) u@z;
      (%o8)                          u@z

  フィールド名は評価されません。

      (%i1) defstruct (bar (g, h));
      (%o1)                      [bar(g, h)]
      (%i2) x : new (bar);
      (%o2)                       bar(g, h)
      (%i3) x@h : 42;
      (%o3)                          42
      (%i4) h : 123;
      (%o4)                          123
      (%i5) x@h;
      (%o5)                          42
      (%i6) x@h : 19;
      (%o6)                          19
      (%i7) x;
      (%o7)                    bar(g, h = 19)
      (%i8) h;
      (%o8)                          123

  Structures ·Operators ·

Next: Operators, Previous: Data Types and Structures, Up: Top [Contents][Index]

## 6 Expressions

Next: Nouns and Verbs, Previous: Expressions, Up: Expressions [Contents][Index]

### 6.1 Introduction to Expressions

変数名として使えないたくさんの予約語があります。 これらを使うと、不可解な構文法エラーの原因となります。

    integrate            next           from                 diff
    in                   at             limit                sum
    for                  and            elseif               then
    else                 do             or                   if
    unless               product        while                thru
    step

Maximaのほとんどのものは式です。 括弧で囲み、コンマで区切ることで、式の列が構成できます。 これは、C言語のコンマ式に似ています。

    (%i1) x: 3$
    (%i2) (x: x+1, x: x^2);
    (%o2)                          16
    (%i3) (if (x > 17) then 2 else 4);
    (%o3)                           4
    (%i4) (if (x > 17) then x: 2 else y: 4, y+x);
    (%o4)                          20

ループが返す値はあまり役に立たない`done`ですが、Maximaではループでさえ式です。

    (%i1) y: (x: 1, for i from 1 thru 10 do (x: x*i))$
    (%i2) y;
    (%o2)                         done

ところが、本当に欲しいものは、たぶん、実際に値を戻すコンマ式の３番目の項を含むことで得られます。

    (%i3) y: (x: 1, for i from 1 thru 10 do (x: x*i), x)$
    (%i4) y;
    (%o4)                        3628800

Next: Identifiers, Previous: Introduction to Expressions, Up: Expressions [Contents][Index]

### 6.2 Nouns and Verbs

Maximaは「名詞(Noun)」演算子と「動詞(Verb)」演算子を区別します。 動詞は実行される演算子です。 名詞は式の中で、実行されずシンボルとして現れる演算子です。 デフォルトでは、関数名は動詞です。 動詞は、関数名をクォートすることで、また、`nounify`関数を適用することで、 名詞に変えることができます。 名詞は、`verbify`関数を適用することで動詞に変えることができます。 評価フラグ`nouns`は、`ev`を式の中の名詞を評価するようにします。

動詞形は、対応するLispシンボル上では、先頭のドル記号`$`で区別されます。 対照的に、 名詞形は、対応するLispシンボル上では、先頭のパーセント記号`%`で区別されます。 `'integrate`や（`diff`が返す）`'derivative`のように、 いくつかの名詞は特別な表示プロパティを持ちますが、ほとんどは特別な表示を持ちません。 デフォルトでは、表示される時、関数の名詞と動詞形は同一です。 グローバルフラグ`noundisp`は、 Maximaに、先頭のクォートマーク`'`で名詞形を表示させます。

`noun`, `nouns`, `nounify`, や`verbify`も参照してください。

例:

    (%i1) foo (x) := x^2;
                                         2
    (%o1)                     foo(x) := x
    (%i2) foo (42);
    (%o2)                         1764
    (%i3) 'foo (42);
    (%o3)                        foo(42)
    (%i4) 'foo (42), nouns;
    (%o4)                         1764
    (%i5) declare (bar, noun);
    (%o5)                         done
    (%i6) bar (x) := x/17;
                                         x
    (%o6)                    ''bar(x) := --
                                         17
    (%i7) bar (52);
    (%o7)                        bar(52)
    (%i8) bar (52), nouns;
                                   52
    (%o8)                          --
                                   17
    (%i9) integrate (1/x, x, 1, 42);
    (%o9)                        log(42)
    (%i10) 'integrate (1/x, x, 1, 42);
                                 42
                                /
                                [   1
    (%o10)                      I   - dx
                                ]   x
                                /
                                 1
    (%i11) ev (%, nouns);
    (%o11)                       log(42)

Evaluation ·Nouns and verbs ·

Next: Inequality, Previous: Nouns and Verbs, Up: Expressions [Contents][Index]

### 6.3 Identifiers

Maximaの識別子は、アルファベット文字と、0から9までの数詞と、 バックスラッシュ`\`文字に続く任意の特別文字で構成されます。

もしバックスラッシュが先行するなら、数詞は、識別子の最初の文字となることができます。 ２番目や後の文字の数詞は、バックスラッシュが先行する必要はありません。

文字は、`declare`関数によってアルファベットと宣言することができます。 もし宣言されたら、識別子の中でバックスラッシュで先行する必要はありません。 アルファベット文字は、`A`から`Z`まで, `a`から `z`まで, `%`,と`_`が初期設定です。

Maximaは大文字小文字を区別します。 識別子`foo`, `FOO`, と`Foo`は別の物です。 この点に関してLisp and Maximaを参照してください。

Maximaの識別子は、ドル記号`$`で始まるLispのシンボルです。 Maximaの中で現れる時、他の任意のLispシンボルは、クエスチョンマーク`?`で始まります。 この点に関してLisp and Maximaを参照してください。

例:

    (%i1) %an_ordinary_identifier42;
    (%o1)               %an_ordinary_identifier42
    (%i2) embedded\ spaces\ in\ an\ identifier;
    (%o2)           embedded spaces in an identifier
    (%i3) symbolp (%);
    (%o3)                         true
    (%i4) [foo+bar, foo\+bar];
    (%o4)                 [foo + bar, foo+bar]
    (%i5) [1729, \1729];
    (%o5)                     [1729, 1729]
    (%i6) [symbolp (foo\+bar), symbolp (\1729)];
    (%o6)                     [true, true]
    (%i7) [is (foo\+bar = foo+bar), is (\1729 = 1729)];
    (%o7)                    [false, false]
    (%i8) baz\~quux;
    (%o8)                       baz~quux
    (%i9) declare ("~", alphabetic);
    (%o9)                         done
    (%i10) baz~quux;
    (%o10)                      baz~quux
    (%i11) [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
    (%o11)                [false, false, false]
    (%i12) :lisp (defvar *my-lisp-variable* '$foo)
    *MY-LISP-VARIABLE*
    (%i12) ?\*my\-lisp\-variable\*;
    (%o12)                         foo

Syntax ·

Next: Functions and Variables for Expressions, Previous: Identifiers, Up: Expressions [Contents][Index]

### 6.4 Inequality

Maximaは、不等式演算子`<`, `<=`, `>=`, `>`, `#`, `notequal`を持ちます。 条件式の記述に関しては、`if`を参照してください。

Previous: Inequality, Up: Expressions [Contents][Index]

### 6.5 Functions and Variables for Expressions

関数: alias (new_name_1, old_name_1, …, new_name_n, old_name_n)

  (利用者もしくはシステム)関数や変数、配列等に対して別名を与えます。 任意の偶数個の引数を取ります。

  Declarations and inferences ·

システム変数: aliases

  デフォルト値: `[]`

  `aliases`は、 (`alias`, `ordergreat`, `orderless`関数によって、もしくは、 `declare`で アトムを`noun`に宣言することで、設定される) ユーザー定義のエーリアスを持つ アトムのリストです。

  Declarations and inferences ·Global variables ·

キーワード: allbut

  `part`コマンド(すなわち、`part`,`inpart`,`substpart`, `substinpart`,`dpart`, `lpart`)と共に動作します。例えば、

      (%i1) expr : e + d + c + b + a;
      (%o1)                   e + d + c + b + a
      (%i2) part (expr, [2, 5]);
      (%o2)                         d + a

  一方、

      (%i1) expr : e + d + c + b + a;
      (%o1)                   e + d + c + b + a
      (%i2) part (expr, allbut (2, 5));
      (%o2)                       e + c + b

  `kill`も`allbut`を認識します。

      (%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
      (%o1)                 [11, 22, 33, 44, 55]
      (%i2) kill (allbut (cc, dd));
      (%o0)                         done
      (%i1) [aa, bb, cc, dd];
      (%o1)                   [aa, bb, 33, 44]

  `kill(allbut(a_1, a_2, ...))`は、 シンボルa_1, a_2, …をキルしないよう除外して `kill(all)`を実行します。

関数: args (expr)

  `expr`の引数のリストを返します。 ここで、`expr`アトム以外のいかなる種類の式を取り得ます。 トップレベル演算子の引数だけが抽出されます; `expr`の部分式は、要素として、または、引数のリストの要素の部分式として現れます。

  リストの中の項目の順序は、グローバルフラグ`inflag`に依存するかもしれません。

  `args (expr)`は、`substpart ("[", expr, 0)`と同値です。 `substpart`と`op`も参照してください。

  Expressions ·

関数: atom (expr)

  もし exprがアトム(すなわち、数や名前や文字)なら、 `true`、そうでなければ `false`を返します。 例えば、 `atom(5)`は `true`ですが、 (`a[1]`と `x`はバインドされていないと仮定して) `atom(a[1])`や `atom(sin(x))`は `false`です。

  Expressions ·Predicate functions ·

関数: box (expr)
関数: box (expr, a)

  枠で囲んだexprを返します。 返り値は、演算子として`box`を持ち、引数としてexprを持つ式です。 `display2d`が`true`の時、ディスプレイ上に枠が描かれます。

  `box (expr, a)`は、 シンボルaでラベルされた枠でexprを囲みます。 もし枠の幅より長ければ、ラベルは切りつめられます。

  `box`は引数を評価します。 しかしながら、枠に入れられた式は中身に評価されないので、 枠に入れられた式は、計算から効果的に除外されます。

  `boxchar`は、`box`, `dpart`, `lpart`関数において 枠を描くのに使われる文字です。

  例:

      (%i1) box (a^2 + b^2);
                                  """""""""
                                  " 2    2"
      (%o1)                       "b  + a "
                                  """""""""
      (%i2) a : 1234;
      (%o2)                         1234
      (%i3) b : c - d;
      (%o3)                         c - d
      (%i4) box (a^2 + b^2);
                            """"""""""""""""""""
                            "       2          "
      (%o4)                 "(c - d)  + 1522756"
                            """"""""""""""""""""
      (%i5) box (a^2 + b^2, term_1);
                            term_1""""""""""""""
                            "       2          "
      (%o5)                 "(c - d)  + 1522756"
                            """"""""""""""""""""
      (%i6) 1729 - box (1729);
                                       """"""
      (%o6)                     1729 - "1729"
                                       """"""
      (%i7) boxchar: "-";
      (%o7)                           -
      (%i8) box (sin(x) + cos(y));
                              -----------------
      (%o8)                   -cos(y) + sin(x)-
                              -----------------

  Expressions ·

オプション変数: boxchar

  デフォルト値: `"`

  `boxchar`は、`box`, `dpart`, `lpart`関数において 枠を描くのに使われる文字です。

  式の中の枠すべては、`boxchar`の現在値で描かれます; 描画文字は枠式に保存されていません。

  Expressions ·

関数: collapse (expr)

  共通の（すなわち等しい）部分式の全てを共用と（すなわち、同じセルを使用）させることで、 exprを縮約し、スペースを節約します。 (`collapse`は、`optimize`コマンドによって使われるサブルーチンです。） 例えば，`collapse`をコールすることは、 `save`ファイルに積んだ後役に立つかもしれません。 `collapse ([expr_1, ..., expr_n])`を使うことで、いくつかの式を 一緒に縮約できます。 同様に、`collapse (listarray ('A))`を実行することで、配列`A`の要素を縮約できます。

  Expressions ·

関数: disolate (expr, x_1, …, x_n)

  ユーザーに１つ以上の変数を同時にisolate可能にさせることを除いて、 `isolate (expr, x)`に似ています。 例えば、もし多重積分の中で変数を変えようとしていて、それが２つ以上の積分変数を含んだ変数変換なら、これは役立つかもしれません。 この関数は、`simplification/disol.mac`から自動ロードされます。 `demo("disol")$`でデモが入手可能です。

  Expressions ·

関数: dispform (expr)
関数: dispform (expr, all)

  exprの外部表現を返します。

  `dispform(expr)`は、主（トップレベル）演算子に関して外部表現を返します。 `dispform(expr, all)`は、exprの中の演算子すべてに関して 外部表現を返します。

  `part`, `inpart`, `inflag`も参照してください。

  例:

  `- x`の内部表現は、「-1掛ける`x`」ですが、 外部表現は、「マイナス`x`」です。

      (%i1) - x;
      (%o1)                          - x
      (%i2) ?format (true, "~S~%", %);
      ((MTIMES SIMP) -1 $X)
      (%o2)                         false
      (%i3) dispform (- x);
      (%o3)                          - x
      (%i4) ?format (true, "~S~%", %);
      ((MMINUS SIMP) $X)
      (%o4)                         false

  `sqrt(x)`の内部表現は、「`x`の1/2乗」ですが、 外部表現は、「`x`の平方根」です。

      (%i1) sqrt (x);
      (%o1)                        sqrt(x)
      (%i2) ?format (true, "~S~%", %);
      ((MEXPT SIMP) $X ((RAT SIMP) 1 2))
      (%o2)                         false
      (%i3) dispform (sqrt (x));
      (%o3)                        sqrt(x)
      (%i4) ?format (true, "~S~%", %);
      ((%SQRT SIMP) $X)
      (%o4)                         false

  オプション引数`all`の使用。

      (%i1) expr : sin (sqrt (x));
      (%o1)                     sin(sqrt(x))
      (%i2) freeof (sqrt, expr);
      (%o2)                         true
      (%i3) freeof (sqrt, dispform (expr));
      (%o3)                         true
      (%i4) freeof (sqrt, dispform (expr, all));
      (%o4)                         false

  Expressions ·

関数: dpart (expr, n_1, …, n_k)

  `part`と同じ部分式を選択しますが、 その部分式を値として返すだけの代わりに、 枠の中に表示されて選択された部分式を持つ式全体を返します。 枠は実際に式の一部です。

      (%i1) dpart (x+y/z^2, 1, 2, 1);
                                   y
      (%o1)                       ---- + x
                                     2
                                  """
                                  "z"
                                  """

  Expressions ·

オプション変数: exptisolate

  デフォルト値: `false`

  `exptisolate`が`true`の時、 `isolate (expr, var)`は、 `var`を含む(`%e`のような)アトムの指数を検査します。

  Expressions ·

オプション変数: exptsubst

  デフォルト値: `false`

  `exptsubst`が`true`の時、 `%e^(a x)`の中の`%e^x`へ`y`を代入するような代入を許します。

  Exponential and logarithm functions ·Expressions ·

関数: freeof (x_1, …, x_n, expr)

  もしx_1と等しいexprの部分式がないか、 x_1がexprの中でダミー変数としてのみ現れるか、 x_1がexprの中で任意の演算子の名詞形でも動詞形でもないなら、 `freeof (x_1, expr)`は、`true`を返します。 そうでなければ、`false`を返します。

  `freeof (x_1, ..., x_n, expr)`は、 `freeof (x_1, expr)かつ、 ...かつfreeof (x_n, expr)`と同値です。

  引数x_1, …, x_n は、 関数や変数の名前、添字付き名前、（ダブルクォートでくくられた）演算子、もしくは一般式 を取り得ます。 `freeof`は引数を評価します。

  `freeof`は、そのままは（整理と評価の後）expr上でのみ演算し、 ある同値の表現が違った結果を与えるかどうかを決定しようとはしません。 特に、整理は、同値ですが、exprの原型とは違った要素を含む異なる式を生成するかもしれません。

  もし式の外部にバインドを持たなければ、変数は、式の中のダミー変数です。 `freeof`によって認識されたダミー変数は、 和や積のインデックス、`limit`の中の極限変数、 `integrate`の定積分形の中の積分変数、 `laplace`の中のオリジナル変数、 `at`式の中の形式変数、 `lambda`式の中の引数です。

  `integrate`の不定積分形は、積分変数から自由ではありません。

  例:

  引数は、関数、変数、添字付き名前、演算子、式の名前です。 `freeof (a, b, expr)`は `freeof (a, expr) and freeof (b, expr)`と同値です。

      (%i1) expr: z^3 * cos (a[1]) * b^(c+d);
                                       d + c  3
      (%o1)                   cos(a ) b      z
                                   1
      (%i2) freeof (z, expr);
      (%o2)                         false
      (%i3) freeof (cos, expr);
      (%o3)                         false
      (%i4) freeof (a[1], expr);
      (%o4)                         false
      (%i5) freeof (cos (a[1]), expr);
      (%o5)                         false
      (%i6) freeof (b^(c+d), expr);
      (%o6)                         false
      (%i7) freeof ("^", expr);
      (%o7)                         false
      (%i8) freeof (w, sin, a[2], sin (a[2]), b*(c+d), expr);
      (%o8)                         true

  `freeof`は引数を評価します。

      (%i1) expr: (a+b)^5$
      (%i2) c: a$
      (%i3) freeof (c, expr);
      (%o3)                         false

  `freeof`は、同値の式を考慮しません。 整理は、同値ですが異なる式を生成します。

      (%i1) expr: (a+b)^5$
      (%i2) expand (expr);
                5        4       2  3       3  2      4      5
      (%o2)    b  + 5 a b  + 10 a  b  + 10 a  b  + 5 a  b + a
      (%i3) freeof (a+b, %);
      (%o3)                         true
      (%i4) freeof (a+b, expr);
      (%o4)                         false
      (%i5) exp (x);
                                       x
      (%o5)                          %e
      (%i6) freeof (exp, exp (x));
      (%o6)                         true

  和や定積分はダミー変数から自由です。 不定積分は積分変数から自由ではありません。

      (%i1) freeof (i, 'sum (f(i), i, 0, n));
      (%o1)                         true
      (%i2) freeof (x, 'integrate (x^2, x, 0, 1));
      (%o2)                         true
      (%i3) freeof (x, 'integrate (x^2, x));
      (%o3)                         false

  Expressions ·

オプション変数: inflag

  デフォルト値: `false`

  `inflag`が`true`の時、 部分抽出のための関数は、`expr`の内部形式を検査します。

  整理器は式を再順序付けすることに注意してください。 例えば、 もし`inflag`が`true`なら、 `first (x + y)`は、`x`を返し、 もしif `inflag`が`false`なら、`y`を返します。 (`first (y + x)`は同じ結果を与えます。)

  また、`inflag`を`true`に設定し、`part`や`substpart`をコールすることは、 `inpart`や`substinpart`をコールすることと同じです。

  `inflag`の設定に影響される関数は以下の通りです: `part`, `substpart`, `first`, `rest`, `last`, `length`, `for` ... `in`構成子, `map`, `fullmap`, `maplist`, `reveal`, `pickapart`。

  Expressions ·

関数: inpart (expr, n_1, ..., n_k)

  `part`に似ていますが、表示形式ではなく内部表現上で機能し、 フォーマットが実行されないのでより速いかもしれません。 （内部形式での変数の順序はしばしば表示形式でのそれと異なるので） 和や積の中の部分式の順序や、 （以下の演算子は式から取り除かれるので）単項マイナス、引き算、割り算を扱う際の部分式の順序 に関して注意が必要です。 `part (x+y, 0)`や`inpart (x+y, 0)`は、 `+`を返しますが、 演算子を参照するため、"で囲まれたものになります。 例えば、`... if inpart (%o9,0) = "+" then ...`.

  例:

      (%i1) x + y + w*z;
      (%o1)                      w z + y + x
      (%i2) inpart (%, 3, 2);
      (%o2)                           z
      (%i3) part (%th (2), 1, 2);
      (%o3)                           z
      (%i4) 'limit (f(x)^g(x+1), x, 0, minus);
                                        g(x + 1)
      (%o4)                 limit   f(x)
                            x -> 0-
      (%i5) inpart (%, 1, 2);
      (%o5)                       g(x + 1)

  Expressions ·

関数: isolate (expr, x)

  和であり、中間式ラベル(それらは`%t1`, `%t2`, ...のようなアトムなシンボルです) で置き換えられたxを含まない部分式を含むexprを返します。 興味のある変数を含まない部分式の不必要な展開を避けるのに、これはしばしば役立ちます。 中間ラベルは部分式にバインドされているので、 それらが現れた式を評価することで、それらをすべて元に代入することができます。

  もし`exptisolate` (デフォルト値: `false`)が`true`なら、 `isolate`は、xを含むか、(`%e`のような)アトムの指数を検査します。

  もし`isolate_wrt_times`が`true`なら、 `isolate`は積に関してもisolateします。 `isolate_wrt_times`を参照してください。

  サンプルを見るには、`example (isolate)`を実行してください。

  Expressions ·

オプション変数: isolate_wrt_times

  デフォルト値: `false`

  `isolate_wrt_times`が`true`の時, `isolate`は、積に関してもisolateします。 例えば、スイッチの両方の設定を比較すると、

      (%i1) isolate_wrt_times: true$
      (%i2) isolate (expand ((a+b+c)^2), c);

      (%t2)                          2 a

      (%t3)                          2 b

                                2            2
      (%t4)                    b  + 2 a b + a

                           2
      (%o4)               c  + %t3 c + %t2 c + %t4
      (%i4) isolate_wrt_times: false$
      (%i5) isolate (expand ((a+b+c)^2), c);
                           2
      (%o5)               c  + 2 b c + 2 a c + %t4

  Expressions ·

オプション変数: listconstvars

  デフォルト値: `false`

  `listconstvars`が`true`の時、 `listofvars`は、`%e`, `%pi`, `%i`や 定数と宣言された任意の変数を、 もしそれらが、`listofvars`がコールされた式の中で現れたなら、 戻り値のリストの中に含みます。 デフォルトはこれらを省略します。

  Expressions ·

オプション変数: listdummyvars

  デフォルト値: `true`

  `listdummyvars`が`false`の時、 式の中の「ダミー変数」は、`listofvars`が返すリストの中に含まれません。 （「ダミー変数」の意味は`freeof`で与えられているものです。 「ダミー変数」は、和や積のインデックスや、極限変数、定積分変数のように数学的なものです。）

  例:

      (%i1) listdummyvars: true$
      (%i2) listofvars ('sum(f(i), i, 0, n));
      (%o2)                        [i, n]
      (%i3) listdummyvars: false$
      (%i4) listofvars ('sum(f(i), i, 0, n));
      (%o4)                          [n]

  Expressions ·

関数: listofvars (expr)

  exprの中の変数のリストを返します。

  もし`listconstvars`が`true`なら、 `listofvars`は、`%e`, `%pi`, `%i`や 定数と宣言された任意の変数を、 もしそれらが、exprの中で現れたなら、 戻り値のリストの中に含みます。 デフォルトはこれらを省略します。

  変数のリストのなかの「ダミー変数」を除外したり含めたりするには、オプション変数 `listdummyvars`も参照してください。

      (%i1) listofvars (f (x[1]+y) / g^(2+a));
      (%o1)                     [g, a, x , y]
                                        1

  Expressions ·

関数: lfreeof (list, expr)

  listのそれぞれのメンバーmに関して、 `freeof (m, expr)`をコールします。 もし`freeof`のコールのいずれかが`false`を返すなら、 `false`を返し、そうでなければ、`true`を返します。

  Expressions ·

関数: lpart (label, expr, n_1, …, n_k)

  `dpart`に似ていますが、ラベルされた枠を使います。 ラベルされた枠は、`dpart`によって生成されたものに似ていますが、 トップラインの中での名前を持ちます。

  Expressions ·

宣言: mainvar

  変数を`mainvar`に宣言することができます。 アトムに関する順序付けスケールは本質的に以下の通りです: 数 < 定数 (例えば、`%e`, `%pi`) < スカラー < 他の変数 < mainvars。 例えば、`(declare (x, mainvar), expand ((x+y)^4))`を伴う `expand ((X+Y)^4)`。 （上の特長を使うことを選択したなら注意が必要なことに注意してください。 例えば、もし、 `mainvar`である`x`を含む式を、`mainvar`でない`x`を含む式から引くなら、 もし打ち消しが起こるようにするなら、 例えば`ev (expr, simp)`のような再整理が必要かもしれません。 また、`mainvar`である`x`を含む式を保存するなら、 `x`もまた保存すべきです。）

  Declarations and inferences ·Expressions ·

宣言: noun

  `noun`は、`declare`コマンドのオプションの１つです。 関数を「名詞」に宣言するのに使います。 「名詞」は、自動的には評価されないことを意味します。

  Nouns and verbs ·

オプション変数: noundisp

  デフォルト値: `false`

  `noundisp`が`true`の時、 名詞は、単一クォートで表示されます。 このスイッチは、関数定義を表示する時には、常に`true`です。

  Display flags and variables ·Nouns and verbs ·

関数: nounify (f)

  関数名fの名詞形を返します。 もし動詞関数の名前をまるで名詞のように参照したいなら、これが必要とされます。 もしある引数に関して関数が評価されないなら、 いくつかの動詞関数は名詞形を返すことに注意してください。 これは、クォートに関数コールが続く時、返される形式でもあります。

  `verbify`も参照してください。

  Nouns and verbs ·

関数: nterms (expr)

  もし完全に展開されて、項の打ち消しや結合が起こらない場合の、exprが持つ 項の数を返します。 `sin (expr)`, `sqrt (expr)`, `exp (expr)`, などのような式は、 exprが（もしそれが和なら） どんなにたくさんの項を持とうと、１項と数えます。

  Expressions ·

関数: op (expr)

  式exprのメインの演算子を返します。 `op (expr)`は`part (expr, 0)`と同値です。

  `op`は、 もしメインの演算子が組み込みもしくはユーザー定義の前置、二項もしくはn項中置、後置、マッチフィックスもしくは無項演算子なら、文字列を返します。 そうでなければ、 もしexprが添字付き関数式なら、 `op`は添字付き関数を返します; この場合、戻り値はアトムではありません。 そうでなければ、 exprは配列関数もしくは通常の関数式であり、 `op`はシンボルを返します。

  `op`はグローバルフラグ`inflag`の値を見ています。

  `op`は引数を評価します。

  `args`も参照してください。

  例:

      (%i1) stringdisp: true$
      (%i2) op (a * b * c);
      (%o2)                          "*"
      (%i3) op (a * b + c);
      (%o3)                          "+"
      (%i4) op ('sin (a + b));
      (%o4)                          sin
      (%i5) op (a!);
      (%o5)                          "!"
      (%i6) op (-a);
      (%o6)                          "-"
      (%i7) op ([a, b, c]);
      (%o7)                          "["
      (%i8) op ('(if a > b then c else d));
      (%o8)                         "if"
      (%i9) op ('foo (a));
      (%o9)                          foo
      (%i10) prefix (foo);
      (%o10)                        "foo"
      (%i11) op (foo a);
      (%o11)                        "foo"
      (%i12) op (F [x, y] (a, b, c));
      (%o12)                        F
                                     x, y
      (%i13) op (G [u, v, w]);
      (%o13)                          G

  Expressions ·Operators ·

関数: operatorp (expr, op)
関数: operatorp (expr, [op_1, …, op_n])

  もしopがexprの演算子に等しければ、 `operatorp (expr, op)`は`true`を返します。

  もしある要素op_1, ..., op_nがexprに等しければ、 `operatorp (expr, [op_1, …, op_n])`は`true`を返します。

  Operators ·Predicate functions ·

オプション変数: opsubst

  デフォルト値: `true`

  `opsubst`が`false`の時、 `subst`は、式の中の演算子に代入を試みません。 例えば、 `(opsubst: false, subst (x^2, r, r+r[0]))`は機能します。

  Expressions ·

関数: optimize (expr)

  exprと同じ値と副作用を生成する式を返しますが、 共通の部分式の再計算を避けることによってより効率的に行います。 `optimize`は、共通の部分式すべてが共用されるように引数を縮約する副作用も持ちます。 例を見るには、`example (optimize)`を実行してください。

  Expressions ·

オプション変数: optimprefix

  デフォルト値: `%`

  `optimprefix`は`optimize`コマンドによって生成されたシンボルのために 使われる前置です。

  Expressions ·

関数: ordergreat (v_1, …, v_n)
関数: orderless (v_1, …, v_n)

  `ordergreat`は、 v_1がv_2に続き、v_2は、…, v_nに続き、 そしてv_nは 引数として言及されなかった他の任意のシンボルに続くというように、 Maximaの式の標準の順序付けを変えます。

  `orderless`は、 v_1がv_2に先行し、v_2は、…, v_nに先行し、 そしてv_nは 引数として言及されなかった他の任意のシンボルに先行するというように、 Maximaの式の標準の順序付けを変えます。

  `ordergreat`や`orderless`によって確立される順序は、 `unorder`によって解消されます。 `ordergreat`や`orderless`は、 `unorder`がコールされるまで、 それぞれ一度だけコールすることができます; `ordergreat`の`orderless`の最後のコールだけが効果を持ちます。

  `ordergreatp`も参照してください。

  Expressions ·

関数: ordergreatp (expr_1, expr_2)
関数: orderlessp (expr_1, expr_2)

  もしMaximaの式の標準の順序付けの中で、expr_1がexpr_2に続くなら、 `ordergreatp`は、`true`を返し、 そうでなければ、`false`を返します。

  もしMaximaの式の標準の順序付けの中で、expr_1がexpr_2に先行するなら、 `orderlessp`は、`true`を返し、 そうでなければ、`false`を返します。

  Maximaのアトムや式のすべては、`ordergreatp`と`orderlessp`の下で比較可能です。これらの述語論理が推移的でないような式の孤立した例はあるけれども; それはバグです。

  アトム（シンボル、数リテラル、文字列）の標準の順序付けは以下の通りです。

  (整数と浮動小数点)は以下に先行 (多倍長浮動小数点)は以下に先行 (宣言された定数)は以下に先行 (文字列)は以下に先行 (宣言されたスカラー)は以下に先行 (`orderless`の最初の引数)は以下に先行 …は以下に先行 (`orderless`の最後の引数) は以下に先行 (他のシンボル) は以下に先行 (`ordergreat`の最後の引数)は以下に先行 …は以下に先行 (`ordergreat`の最初の引数)は以下に先行 (宣言されたメイン変数)

  アトムでない式に関して、標準の順序付けはアトムの順序付けから演繹されます。 組み込みの`+` `*` `^`演算子に関しては、 順序付けは簡単にはまとめられません。 他の組み込み演算子と他の半数や演算子、式すべてに関しては、 （最初の引数から始めて）それらの引数によって順序付けされ、 それから演算子や関数の名前によって順序付けされます。 添字付き式の場合、 添字付きのシンボルは演算子と、添字は引数と考えられます。

  式の標準の順序付けは、関数`ordergreat`と`orderless`と、 `mainvar`, `constant`, `scalar`宣言によって変更されます。

  `sort`も参照してください。

  例:

  通常のシンボルや定数の順序付け。 `%pi`は数値に従って順序付けされないことに注意してください。

      (%i1) stringdisp : true;
      (%o1)                         true
      (%i2) sort([%pi, 3b0, 3.0, x, X, "foo", 3, a, 4, "bar", 4.0, 4b0]);
      (%o2) [3, 3.0, 4, 4.0, 3.0b0, 4.0b0, %pi, "bar", "foo", a, x, X]

  `ordergreat`、`orderless`関数の効果。

      (%i1) sort ([M, H, K, T, E, W, G, A, P, J, S]);
      (%o1)           [A, E, G, H, J, K, M, P, S, T, W]
      (%i2) ordergreat (S, J);
      (%o2)                         done
      (%i3) orderless (M, H);
      (%o3)                         done
      (%i4) sort ([M, H, K, T, E, W, G, A, P, J, S]);
      (%o4)           [M, H, A, E, G, K, P, T, W, J, S]

  `mainvar`, `constant`, `scalar`宣言の効果

      (%i1) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
      (%o1)   [aa, bar, baz, bb, cc, dd, foo, quux, A1, B1, C1]
      (%i2) declare (aa, mainvar);
      (%o2)                         done
      (%i3) declare ([baz, quux], constant);
      (%o3)                         done
      (%i4) declare ([A1, B1], scalar);
      (%o4)                         done
      (%i5) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
      (%o5)   [baz, quux, A1, B1, bar, bb, cc, dd, foo, C1, aa]

  アトムでない式の順序付け

      (%i1) sort ([1, 2, n, f(1), f(2), f(2, 1), g(1), g(1, 2), g(n),
                   f(n, 1)]);
      (%o1) [1, 2, f(1), g(1), g(1, 2), f(2), f(2, 1), n, g(n),
                                                               f(n, 1)]
      (%i2) sort ([foo(1), X[1], X[k], foo(k), 1, k]);
      (%o2)            [1, foo(1), X , k, foo(k), X ]
                                    1              k

  Expressions ·Predicate functions ·

関数: part (expr, n_1, …, n_k)

  `expr`の表示形式のパーツを返します。 `expr`の最初のパーツn_1、それから、パーツn_2などなど、 結果は、`expr`のパーツn_1のパーツn_2の, ...パーツn_kです。 もし添字が指定されないなら、`expr`を返します。

  `part`はリストの要素や行列の行を得るのに使うことができます。

  もし`part`関数の最後の引数がインデックスのリストなら、 それぞれがリストのインデックスに対応するいくつかの部分式が抽出されます。 従って、`part (x + y + z, [1, 3])`は`z+x`です。

  `piece`は、`part`関数を使ったとき、選択された最後の式を保持します。 それは関数の実行中にセットされ、以下で示すように、関数自身の中で参照されることもあります。

  もし`partswitch`が`true`に設定されているなら、 式の選択されたパーツが存在しないとき、`end`が返されます。 そうでなければ、エラーメッセージが出力されます。

  `inpart`, `substpart`, `substinpart`, `dpart`, `lpart`も参照してください。

  例:

      (%i1) part(z+2*y+a,2);
      (%o1)                                 2 y
      (%i2) part(z+2*y+a,[1,3]);
      (%o2)                                z + a
      (%i3) part(z+2*y+a,2,1);
      (%o3)                                  2

  `example (part)`でさらに例を見ることができます。

  Expressions ·

関数: partition (expr, x)

  ２つの式のリストを返します。 それらは、 (1)（積なら）exprの因子、（和なら）expr項、 もしくは、（リストなら）xを含まないリストと、 (2)xを含む因子、項、リスト、 です。

  例:

      (%i1) partition (2*a*x*f(x), x);
      (%o1)                     [2 a, x f(x)]
      (%i2) partition (a+b, x);
      (%o2)                      [b + a, 0]
      (%i3) partition ([a, b, f(a), c], a);
      (%o3)                  [[b, c], [a, f(a)]]

  Expressions ·

オプション変数: partswitch

  デフォルト値: `false`

  `partswitch`が`true`の時、 式の選択された部分が存在しない時、`end`が返されます。 そうでない時は、エラーメッセージが出力されます。

  Expressions ·

関数: pickapart (expr, n)

  中間式ラベルを、深さが整数nでのexprの部分式に割り当てます。 より大きなもしくは小さな深さでの部分式はラベルに割り当てられません。 `pickapart`は、元の式exprと同値の中間式の項による式を返します。

  `part`, `dpart`, `lpart`, `inpart`, `reveal`も参照してください。

  例:

      (%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1));
                                                2
                                           sin(x )   b + a
      (%o1)       - log(sqrt(x + 1) + 1) + ------- + -----
                                              3        2
      (%i2) pickapart (expr, 0);

                                                2
                                           sin(x )   b + a
      (%t2)       - log(sqrt(x + 1) + 1) + ------- + -----
                                              3        2

      (%o2)                          %t2
      (%i3) pickapart (expr, 1);

      (%t3)                - log(sqrt(x + 1) + 1)

                                        2
                                   sin(x )
      (%t4)                        -------
                                      3

                                    b + a
      (%t5)                         -----
                                      2

      (%o5)                    %t5 + %t4 + %t3
      (%i5) pickapart (expr, 2);

      (%t6)                 log(sqrt(x + 1) + 1)

                                        2
      (%t7)                        sin(x )

      (%t8)                         b + a

                               %t8   %t7
      (%o8)                    --- + --- - %t6
                                2     3
      (%i8) pickapart (expr, 3);

      (%t9)                    sqrt(x + 1) + 1

                                      2
      (%t10)                         x

                        b + a              sin(%t10)
      (%o10)            ----- - log(%t9) + ---------
                          2                    3
      (%i10) pickapart (expr, 4);

      (%t11)                     sqrt(x + 1)

                            2
                       sin(x )   b + a
      (%o11)           ------- + ----- - log(%t11 + 1)
                          3        2

      (%i11) pickapart (expr, 5);

      (%t12)                        x + 1

                         2
                    sin(x )   b + a
      (%o12)        ------- + ----- - log(sqrt(%t12) + 1)
                       3        2
      (%i12) pickapart (expr, 6);
                        2
                   sin(x )   b + a
      (%o12)       ------- + ----- - log(sqrt(x + 1) + 1)
                      3        2

  Expressions ·

システム変数: piece

  `part`関数を使った時選択された最後の式を返します。 関数の実行中に設定され、関数そのものの中で参照されることもあります。

  Expressions ·

関数: psubst (list, expr)
関数: psubst (a, b, expr)

  `psubst(a, b, expr)`は`subst`に似ています。 `subst`を参照してください。

  `subst`とは違って、 もし最初の引数listが等式のリストなら、 関数`psubst`は平行代入します。

  並列代入するには、`sublis`も参照してください。

  例:

  最初の例は、 `psubst`を使った平行代入を示します。 二番目の例は、 関数`subst`での結果を示します。それは逐次代入します。

      (%i4) psubst ([a^2=b, b=a], sin(a^2) + sin(b));
      (%o4)                           sin(b) + sin(a)
      (%i5) subst ([a^2=b, b=a], sin(a^2) + sin(b));
      (%o5)                              2 sin(a)

  Expressions ·

関数: rembox (expr, unlabelled)
関数: rembox (expr, label)
関数: rembox (expr)

  exprから枠を取り除きます。

  `rembox (expr, unlabelled)`は、 exprからラベルされていない枠すべてを取り除きます。

  `rembox (expr, label)`は、 labelを負う枠のみを取り除きます。

  `rembox (expr)`は、ラベルされているか否か問わず、 枠すべてを取り除きます。

  枠は、`box`, `dpart`, `lpart`関数によって描画されます。

  例:

      (%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x);

                                        a d - b c
      (%o1)                sin(%pi x) + ---------
                                            2
                                           h

      (%i2) dpart (dpart (expr, 1, 1), 2, 2);
                              """""""    a d - b c
      (%o2)               sin("%pi x") + ---------
                              """""""      """"
                                           " 2"
                                           "h "
                                           """"
      (%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2);
                        FOO"""""""""""   BAR""""""""
                        "    """"""" "   "a d - b c"
      (%o3)             "sin("%pi x")" + "---------"
                        "    """"""" "   "  """"   "
                        """"""""""""""   "  " 2"   "
                                         "  "h "   "
                                         "  """"   "
                                         """""""""""
      (%i4) rembox (expr2, unlabelled);
                                        BAR""""""""
                         FOO"""""""""   "a d - b c"
      (%o4)              "sin(%pi x)" + "---------"
                         """"""""""""   "    2    "
                                        "   h     "
                                        """""""""""
      (%i5) rembox (expr2, FOO);
                                        BAR""""""""
                             """""""    "a d - b c"
      (%o5)              sin("%pi x") + "---------"
                             """""""    "  """"   "
                                        "  " 2"   "
                                        "  "h "   "
                                        "  """"   "
                                        """""""""""
      (%i6) rembox (expr2, BAR);
                         FOO"""""""""""
                         "    """"""" "   a d - b c
      (%o6)              "sin("%pi x")" + ---------
                         "    """"""" "     """"
                         """"""""""""""     " 2"
                                            "h "
                                            """"
      (%i7) rembox (expr2);
                                        a d - b c
      (%o7)                sin(%pi x) + ---------
                                            2
                                           h

  Expressions ·

関数: reveal (expr, depth)

  指定された整数depthのexprの部分を 記述的な要約で 置き換えます。

  - 和と差分は、`Sum(n)`で置き換えられます。 ここで、nは、和のオペランドの数です。
  - 積は`Product(n)`で置き換えられます。 ここで、nは、積のオペランドの数です。
  - 指数は、`Expt`で置き換えられます。
  - 商は、`Quotient`で置き換えられます。
  - 単項マイナスは、`Negterm`で置き換えられます。
  - リストは`List(n)`で置き換えられます ここで、nはリストの要素の数です。

  depthがexprの最大深さ以上の時、 `reveal (expr, depth)`は、exprをそのまま返します。

  `reveal`は、引数を評価します。 `reveal`は、要約された式を返します。

  例:

      (%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
                                2            2
                               b  - 2 a b + a
      (%o1)               -------------------------
                              b + a     2 b     2 a
                          2 %e      + %e    + %e
      (%i2) reveal (e, 1);
      (%o2)                       Quotient
      (%i3) reveal (e, 2);
                                   Sum(3)
      (%o3)                        ------
                                   Sum(3)
      (%i4) reveal (e, 3);

                           Expt + Negterm + Expt
      (%o4)               ------------------------
                          Product(2) + Expt + Expt

      (%i5) reveal (e, 4);
                             2                 2
                            b  - Product(3) + a
      (%o5)         ------------------------------------
                               Product(2)     Product(2)
                    2 Expt + %e           + %e
      (%i6) reveal (e, 5);
                               2            2
                              b  - 2 a b + a
      (%o6)              --------------------------
                             Sum(2)     2 b     2 a
                         2 %e       + %e    + %e
      (%i7) reveal (e, 6);
                                2            2
                               b  - 2 a b + a
      (%o7)               -------------------------
                              b + a     2 b     2 a
                          2 %e      + %e    + %e

  Expressions ·Display functions ·

関数: sublis (list, expr)

  式に対して多重平行代入を行います。 listは等式のリストです。 等式の左辺はアトムでなければいけません。

  変数`sublis_apply_lambda`は`sublis`の後の式整理を制御します。

  平行代入を行うには、`psubst`も参照してください。

  例:

      (%i1) sublis ([a=b, b=a], sin(a) + cos(b));
      (%o1)                    sin(b) + cos(a)

  Expressions ·

オプション変数: sublis_apply_lambda

  デフォルト値: `true`

  `lambda`の代入が`sublis`が使われた後の式整理の中で適用されるか 、もしくは、ユーザーが、ものに適用されるように`ev`を実行しなければいけないかを決めます。 `true`は適用を意味します。

  Expressions ·

オプション変数: subnumsimp

  デフォルト値: `false`

  もし`true`なら、シンボル`f`が与えられた時だけ、 関数`subst`と`psubst`は添字付き変数`f[x]`に数を代入できます。

  `subst`も参照してください。

      (%i1) subst(100,g,g[x]+2);

      subst: cannot substitute 100 for operator g in expression g
                                                                 x
       -- an error. To debug this try: debugmode(true);

      (%i2) subst(100,g,g[x]+2),subnumsimp:true;
      (%o2)                          102

  Expressions ·

関数: subst (a, b, c)

  cの中のbにaを代入します。 bはアトムもしくはcの完全な部分式でなければなりません。 例えば、`x+y+z`は`2*(x+y+z)`の完全な部分式である一方、`x+y`は完全な部分式ではありません。 bがこれらの性質を持たない時は、`substpart`もしくは`ratsubst`が使える時があります（下記参照）。 代わりに、もしbが`e/f`形式なら、`subst (a*f, e, c)`が使えますし、 もしbが`e^(1/f)`形式なら、`subst (a^f, e, c)`が使えます。 `subst`コマンドは`x^-y`の中の`x^y`も認識するので、 `subst (a, sqrt(x), 1/sqrt(x))`は`1/a`を出力します。 aとbはダブルクォート`"`で囲まれた式の演算子でも、関数名でも問題ありません。 導関数形式の独立変数に代入したいなら、`at`関数（下記参照）を使うべきです。

  `subst`は`substitute`のエーリアスです。

  コマンド`subst (eq_1, expr)`もしくは`subst ([eq_1, ..., eq_k], expr)`も許されている形式です。 eq_iはされるべき代入を指示する等式です。 それぞれの等式において、右辺が、式exprの中の左辺に代入されます。 等式は、exprに、左から右へ逐次に代入されます。 平行代入するには、関数`sublis`と`psubst`を参照してください。

  `exptsubst`が`true`なら、 `%e^(a*x)`の中の`%e^x`が`y`に置き換えられるような代入が許されます。

  `opsubst`が`false`の時、 `subst`は式の演算子への代入を行いません。 例えば、`(opsubst: false, subst (X^2, r, r+r[9]))`は意図通り動作します。

  例:

      (%i1) subst (a, x+y, x + (x+y)^2 + y);
                                          2
      (%o1)                      y + x + a
      (%i2) subst (-%i, %i, a + b*%i);
      (%o2)                       a - %i b

  代入は、等式のリストに関して逐次になされます。 これを並列代入と比較してください。

      (%i3) subst([a=b, b=c], a+b);
      (%o3)                                 2 c
      (%i4) sublis([a=b, b=c], a+b);
      (%o4)                                c + b

  もっと例を見るには、`example (subst)`を実行してください。

  Expressions ·

関数: substinpart (x, expr, n_1, ..., n_k)

  `substpart`と同様ですが、`substinpart`はexprの内部表現上で 働きます。

  例:

      (%i1) x . 'diff (f(x), x, 2);
                                    2
                                   d
      (%o1)                   x . (--- (f(x)))
                                     2
                                   dx
      (%i2) substinpart (d^2, %, 2);
                                        2
      (%o2)                        x . d
      (%i3) substinpart (f1, f[1](x + 1), 0);
      (%o3)                       f1(x + 1)

  もし`part`関数の最後の引数がインデックスのリストなら、 複数の部分式が選ばれます。それぞれはリストのインデックスに対応します。 例えば、

      (%i1) part (x + y + z, [1, 3]);
      (%o1)                         z + x

  `part`関数を使った時、`piece`は、最後の式の値を保持します。 関数の実行の間に設定され、以下で示すように関数自身の中で参照されることもあります。 もし`partswitch`が`true`に設定されたら、 式の選択された部分が存在しない時には`end`が返されます。 そうでなければ、エラーメッセージが出力されます。

      (%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
                    3         2       2            3
      (%o1)     27 y  + 54 x y  + 36 x  y + y + 8 x  + x + 1
      (%i2) part (expr, 2, [1, 3]);
                                        2
      (%o2)                         54 y
      (%i3) sqrt (piece/54);
      (%o3)                        abs(y)
      (%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
                                     3
      (%o4)               (3 y + 2 x)  + y + x + 1
      (%i5) expr: 1/x + y/x - 1/z;
                                   1   y   1
      (%o5)                      - - + - + -
                                   z   x   x
      (%i6) substpart (xthru (piece), expr, [2, 3]);
                                  y + 1   1
      (%o6)                       ----- - -
                                    x     z

  また、 オプション `inflag`を `true`に設定し `part`か `substpart`をコールすることは `inpart`か `substinpart`をコールすることと同じです。

  Expressions ·

関数: substpart (x, expr, n_1, …, n_k)

  xを、残りの引数を`part`に食わせた結果の部分式に代入します。 exprの新しい値を返します。 xはexprの演算子に代入される演算子でも問題ありません。 いくつかの場合、xはダブルクォート`"`で囲まれる必要があります。 （例えば、`substpart ("+", a*b, 0)`は`b + a`を返します。）

  例:

      (%i1) 1/(x^2 + 2);
                                     1
      (%o1)                        ------
                                    2
                                   x  + 2
      (%i2) substpart (3/2, %, 2, 1, 2);
                                     1
      (%o2)                       --------
                                   3/2
                                  x    + 2
      (%i3) a*x + f(b, y);
      (%o3)                     a x + f(b, y)
      (%i4) substpart ("+", %, 1, 0);
      (%o4)                    x + f(b, y) + a

  また、オプション`inflag`を`true`に設定し、 `part`や`substpart`をコールすることは、 `inpart`や`substinpart`をコールすることと同じになります。

  Expressions ·

関数: symbolp (expr)

  もしexprがシンボルなら`true`、そうでないなら`false`を返します。 事実上、`symbolp(x)`は、述語論理`atom(x) and not numberp(x)`と同値です。

  Identifiersも参照してください。

  Predicate functions ·

関数: unorder ()

  順序付けコマンド`ordergreat`と`orderless`の最後の使用で生成されたエーリアシングを使用不可にします。 `ordergreat`と`orderless`は、 `unorder`を呼び出さずに、一回以上使えないかもしれません。 `unorder`は、 `ordergreat`と`orderless`で導入されたエーリアスに 元のシンボルを式に再代入しません。 それ故に、`unorder`の実行後、以前の式にエーリアスが現れます。

  `ordergreat`と`orderless`も参照してください。

  例s:

  `ordergreat(a)`はシンボル`a`のエーリアスを導入します。 それ故に、 `%o2`と`%o4`の違いは消えません。 `unorder`はシンボル`a`を再代入しないし、 出力`%o7`にエーリアスが現れます。

      (%i1) unorder();
      (%o1)                          []
      (%i2) b*x+a^2;
                                         2
      (%o2)                       b x + a
      (%i3) ordergreat(a);
      (%o3)                         done
      (%i4) b*x+a^2;
                                   2
      (%o4)                       a  + b x
      (%i5) %th(1)-%th(3);
                                    2    2
      (%o5)                        a  - a
      (%i6) unorder();
      (%o6)                          [a]
      (%i7) %th(2);
                                      2    2
      (%o7)                      _101a  - a

  Expressions ·

関数: verbify (f)

  関数名fの動詞形を返します。 `verb`, `noun`, `nounify`も参照してください。

  例:

      (%i1) verbify ('foo);
      (%o1)                          foo
      (%i2) :lisp $%
      $FOO
      (%i2) nounify (foo);
      (%o2)                          foo
      (%i3) :lisp $%
      %FOO

  Nouns and verbs ·

Next: Evaluation, Previous: Expressions, Up: Top [Contents][Index]

## 7 Operators

Next: Arithmetic operators, Previous: Operators, Up: Operators [Contents][Index]

### 7.1 Introduction to operators

指定された優先順位を持つ新しい演算子を定義したり、 既存の演算子を未定義にしたり、既存の演算子の優先順位を再定義することが可能です。 演算子は単項前置、単項後置、二項中置、n項中置、マッチフィックスか無項でありえます。 「マッチフィックス」は引数を括るシンボルの対を意味し、 「無項」は引数を取らない演算子を意味します。 異なるタイプの演算子の例として、以下があります。

unary prefix

  negation `- a`

unary postfix

  factorial `a!`

binary infix

  exponentiation `a^b`

n-ary infix

  addition `a + b`

matchfix

  list construction `[a, b]`

(組み込みの無項演算子はありません; そんな演算子の例は、`nofix`を参照してください。.)

新しい演算子を定義するメカニズムはわかりやすいものです。 関数を演算子として宣言することだけが必要です; 演算子関数は定義されることもされないこともあります。

ユーザー定義の演算子の例は以下の通りです。 明示的な関数コール `"dd" (a)`は `dd a`と同値であり、また、 `"<-" (a, b)`は `a <- b`と同値であることに注意してください。 この例で、 `"dd"`と `"<-"`は未定義です。

    (%i1) prefix ("dd");
    (%o1)                          dd
    (%i2) dd a;
    (%o2)                         dd a
    (%i3) "dd" (a);
    (%o3)                         dd a
    (%i4) infix ("<-");
    (%o4)                          <-
    (%i5) a <- dd b;
    (%o5)                      a <- dd b
    (%i6) "<-" (a, "dd" (b));
    (%o6)                      a <- dd b

新しい演算子を定義するMaxima関数はこの表にまとめられます。 デフォルトの左と右の結合力(それぞれlbpとrbp)を記載します。 (結合力は演算子の優先順位を決めます。 しかしながら、左と右の結合力は異なることがあり、 結合力は優先順位より幾分複雑です。) 演算定義関数のいくつかは追加の引数を取ります; 詳細は関数記述を参照してください。

`prefix`

  rbp=180

`postfix`

  lbp=180

`infix`

  lbp=180, rbp=180

`nary`

  lbp=180, rbp=180

`matchfix`

  (binding power not applicable)

`nofix`

  (binding power not applicable)

比較のために、いくつかの組み込み演算子と左右結合力を上げます。

    Operator   lbp     rbp

      :        180     20
      ::       180     20
      :=       180     20
      ::=      180     20
      !        160
      !!       160
      ^        140     139
      .        130     129
      *        120
      /        120     120
      +        100     100
      -        100     134
      =        80      80
      #        80      80
      >        80      80
      >=       80      80
      <        80      80
      <=       80      80
      not              70
      and      65
      or       60
      ,        10
      $        -1
      ;        -1

`remove`と `kill`は演算子プロパティをアトムから削除します。 `remove ("a", op)`は aの演算子プロパティだけを削除します。 `kill ("a")`は 演算子プロパティを含むaのすべてのロパティを削除します。 演算子名はクォーテーションマークで括らないといけないことに注意してください。

    (%i1) infix ("##");
    (%o1)                          ##
    (%i2) "##" (a, b) := a^b;
                                         b
    (%o2)                     a ## b := a
    (%i3) 5 ## 3;
    (%o3)                          125
    (%i4) remove ("##", op);
    (%o4)                         done
    (%i5) 5 ## 3;
    Incorrect syntax: # is not a prefix operator
    5 ##
      ^
    (%i5) "##" (5, 3);
    (%o5)                          125
    (%i6) infix ("##");
    (%o6)                          ##
    (%i7) 5 ## 3;
    (%o7)                          125
    (%i8) kill ("##");
    (%o8)                         done
    (%i9) 5 ## 3;
    Incorrect syntax: # is not a prefix operator
    5 ##
      ^
    (%i9) "##" (5, 3);
    (%o9)                       ##(5, 3)

Operators ·Syntax ·

Next: Relational operators, Previous: Introduction to operators, Up: Operators [Contents][Index]

### 7.2 Arithmetic operators

演算子: +
演算子: -
演算子: *
演算子: /
演算子: ^

  シンボル `+` `*` `/` `^`はそれぞれ、 足し算、かけ算、割り算、べき乗を表します。 これらの演算子の名前は `"+"` `"*"` `"/"` `"^"`です。 これらは関数や演算子の名前が求められるところで使います。

  シンボル `+`や `-`はそれぞれ、プラスとマイナスの単項演算子を示し、 それらの名前はそれぞれ `"+"`と`"-"`です。

  引き算 `a - b`はMaximaの中では足し算 `a + (- b)`として表されます。 `a + (- b)`のような式は引き算として表示されます。 Maximaは `"-"`を足し算の単項逆元演算子の名前としてのみ認識して、 二項引き算演算子としては認識しません。

  Maximaの中では割り算`a / b`をかけ算`a * b^(- 1)`として表現します。 `a * b^(- 1)`のような式は割り算として表示されます。 Maximaは`"/"`を割り算演算子の名前として認識します。

  足し算とかけ算はn項可換演算子です。 割り算とべき乗は二項の非可換演算子です。

  Maximaは正準表現を構成するために可換演算子のオペランド(訳注：引数)を並べ替えます。 順序は内部的には `orderlessp`で決定します。 表示のためには、足し算の順序は `ordergreatp`で決定し、 かけ算は内部的な順序と同じです。

  算術計算は、数リテラル（整数、有理数、通常の浮動小数点、多倍長浮動小数点）上で実行されます。 べき乗を除いて、数に対するすべての算術演算子は数に整理されます。 べき乗は、オペランドが通常の浮動小数点か多倍長浮動小数点の時、もしくは結果が厳密に整数もしくは有理数の時、数に整理されます; そうでなければ、べき乗は `sqrt`か他のべき乗に整理されるか、そのまま残されます。

  浮動小数点の伝搬が算術計算に適用されます: もしどれか１つでもオペランドが多倍長浮動小数点なら、結果は多倍長浮動小数点です; そうでなければ、もしどれか１つでもオペランドが通常の浮動小数点なら、結果は通常の浮動小数点です; そうでなければオペランドは有理数か整数であり、結果は有理数か整数です。

  算術計算は式整理であって、評価ではありません。 従って、クォートされた（しかし整理される）式の中で算術計算は実行されます。

  算術演算は、 グローバルフラグ `listarith`が `true`の時 リストに対して要素毎に適用され、 行列に対しては常に要素毎に適用されます。 オペランドの１つがリストか行列であり、もう１つのオペランドが別のタイプの時、 他のオペランドはリストか行列の要素のそれぞれに組み合わされます。

  例:

  足し算とかけ算は、n項可換演算子です。 Maximaは、正準表現を構成するために、可換演算子のオペランドを並べ替えます。 それらの名前はそれぞれ `"+"`と `"*"`です。

      (%i1) c + g + d + a + b + e + f;
      (%o1)               g + f + e + d + c + b + a
      (%i2) [op (%), args (%)];
      (%o2)              [+, [g, f, e, d, c, b, a]]
      (%i3) c * g * d * a * b * e * f;
      (%o3)                     a b c d e f g
      (%i4) [op (%), args (%)];
      (%o4)              [*, [a, b, c, d, e, f, g]]
      (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
      (%o5)                    3 x + 2 a + 19
      (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
                                       2  3
      (%o6)                       144 a  x

  割り算とべき乗は、二項の非可換演算子です。 それらの名前はそれぞれ `"/"`と `"^"`です。

      (%i1) [a / b, a ^ b];
                                    a   b
      (%o1)                        [-, a ]
                                    b
      (%i2) [map (op, %), map (args, %)];
      (%o2)              [[/, ^], [[a, b], [a, b]]]
      (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
                                    a   b
      (%o3)                        [-, a ]
                                    b

  引き算と割り算は内部的にはそれぞれ、足し算とかけ算を使って表現されます。

      (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
      (%o1)                      [+, a, - b]
      (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
                                         1
      (%o2)                       [*, a, -]
                                         b

  計算は数リテラルに対して実行されます。 浮動小数点伝搬が適用されます。

      (%i1) 17 + b - (1/2)*29 + 11^(2/4);
                                             5
      (%o1)                   b + sqrt(11) + -
                                             2
      (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
      (%o2)                   [46, 46.0, 4.6b1]

  算術計算は式整理であって、評価ではありません。

      (%i1) simp : false;
      (%o1)                         false
      (%i2) '(17 + 29*11/7 - 5^3);
                                    29 11    3
      (%o2)                    17 + ----- - 5
                                      7
      (%i3) simp : true;
      (%o3)                         true
      (%i4) '(17 + 29*11/7 - 5^3);
                                      437
      (%o4)                         - ---
                                       7

  算術計算は（`listarith`に依存して）リストや行列に対して要素毎に実行されます。

      (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);

                              [ a - 1  x - 2 ]
      (%o1)                   [              ]
                              [ h - 3  u - 4 ]

      (%i2) 5 * matrix ([a, x], [h, u]);

                                [ 5 a  5 x ]
      (%o2)                     [          ]
                                [ 5 h  5 u ]
      (%i3) listarith : false;
      (%o3)                         false
      (%i4) [a, c, m, t] / [1, 7, 2, 9];
                                [a, c, m, t]
      (%o4)                     ------------
                                [1, 7, 2, 9]
      (%i5) [a, c, m, t] ^ x;
                                            x
      (%o5)                     [a, c, m, t]
      (%i6) listarith : true;
      (%o6)                         true
      (%i7) [a, c, m, t] / [1, 7, 2, 9];
                                    c  m  t
      (%o7)                     [a, -, -, -]
                                    7  2  9
      (%i8) [a, c, m, t] ^ x;
                                x   x   x   x
      (%o8)                   [a , c , m , t ]

  Operators ·

演算子: **

  べき乗演算子。 Maximaは入力の中で `**`を `^`と同じ演算子と認識し、 1次元出力の中では `^`として表示し、 また、2次元出力の中では指数を上付き添字として配置します。

  `fortran`関数は、入力が `**`でも `^`でも、 べき乗演算子を `**`として表示します。

  例:

      (%i1) is (a**b = a^b);
      (%o1)                         true
      (%i2) x**y + x^z;
                                    z    y
      (%o2)                        x  + x
      (%i3) string (x**y + x^z);
      (%o3)                        x^z+x^y
      (%i4) fortran (x**y + x^z);
            x**z+x**y
      (%o4)                         done

  Operators ·

演算子: ^^

  非可換べき乗演算子。 ちょうど可換なかけ算 `*`に通常のべき乗演算子 `^`が対応するように、 `^^`は非可換かけ算 `.`に対応するべき乗演算子です。

  非可換べき乗演算子は、１次元出力では `^^`で表示され、 ２次元出力では、指数をかっこ `< >`で囲まれた上付き添字として置きます。

  例:

      (%i1) a . a . b . b . b + a * a * a * b * b;
                              3  2    <2>    <3>
      (%o1)                  a  b  + a    . b
      (%i2) string (a . a . b . b . b + a * a * a * b * b);
      (%o2)                  a^3*b^2+a^^2 . b^^3

  Operators ·

演算子: .

  行列（非可換）かけ算のためのドット演算子。 `"."`をこの意味で用いる時、 例えば `A . B`のように両側にスペースを置かなければいけません。 これで浮動小数点の小数点と区別します。

  `dot`や `dot0nscsimp`, `dot0simp`, `dot1simp`, `dotassoc`, `dotconstrules`, `dotdistrib`, `dotexptsimp`, `dotident`, `dotscrules`. も参照してください。

  Operators ·

Next: Logical operators, Previous: Arithmetic operators, Up: Operators [Contents][Index]

### 7.3 Relational operators

演算子: <
演算子: <=
演算子: >=
演算子: >

  シンボル `<` `<=` `>=` `>`はそれぞれ、小なり、以下、以上、大なり、を表します。 これらの演算子の名前は、 `"<"`、 `"<="`、 `">="`、 `">"`です。 それらは関数や演算子の名前が求められるところで使われます。

  これらの関係演算子はすべて二項演算子です; `a < b < c`のような構成をMaximaは認識しません。

  関数 `is`や `maybe`、 プログラミング構成子 `if`, `while`, `unless`が 関係式をブーリアン値に評価します。 そうでなければ、関係式はブーリアン値に評価されたり整理されたりしませんが、 関係式の引数は（評価がクォーテーションによって妨げられないかぎり）評価されます。

  関係式が `true`もしくは `false`に評価できない時、 `is`や `if`の振る舞いは、グローバルフラグ `prederror`が決定します。 `prederror`が `true`の時、 `is`や `if`はエラーをトリガーします。 `prederror`が `false`の時、 `is`は `unknown`を返し、 `if`は部分的に評価された条件式を返します。

  `maybe`はいつも、 `prederror`が `false`であるかのように振る舞い、 `while`や `unless`はいつも、 `prederror`が `true`であるかのように振る舞います。

  関係演算子はリストやほかの集合上で展開されることはありません。

  `=`や `#`、 `equal`、 `notequal`も参照してください。

  例:

  いくつかの関数やプログラミング構成子が関係式をブーリアン値に評価します。

      (%i1) [x, y, z] : [123, 456, 789];
      (%o1)                    [123, 456, 789]
      (%i2) is (x < y);
      (%o2)                         true
      (%i3) maybe (y > z);
      (%o3)                         false
      (%i4) if x >= z then 1 else 0;
      (%o4)                           0
      (%i5) block ([S], S : 0, for i:1 while i <= 100 do S : S + i,
                   return (S));
      (%o5)                         5050

  そうでなければ関係式はブーリアン値に評価されたり整理されたりしませんが、 関係式の引数は評価されます。

      (%o1)                    [123, 456, 789]
      (%i2) [x < y, y <= z, z >= y, y > z];
      (%o2)    [123 < 456, 456 <= 789, 789 >= 456, 456 > 789]
      (%i3) map (is, %);
      (%o3)               [true, true, true, false]

  Operators ·

Next: Operators for Equations, Previous: Relational operators, Up: Operators [Contents][Index]

### 7.4 Logical operators

演算子: and

  論理積演算子。 `and`は、n項中置演算子です; オペランドはブーリアン値で、結果もブーリアン値です。

  `and`は、（`is`のように）１以上のオペランドの評価を強制し、 すべてのオペランドの評価を強制するかもしれません。

  オペランドは、出現順に評価されます。 `and`は、結果を決定するのに必要なだけオペランドを評価します。 もし任意のオペランドが`false`なら、結果は`false`であり、 ほかのオペランドは評価されません。

  グローバルフラグ`prederror`は、 評価されたオペランドが`true`か`false`に決定できない時の`and`の振る舞いを決定します。 `prederror`が`true`の時、`and`は、エラーメッセージを出力します。 そうでなければ、`true`か`false`に評価されないオペランドを受け付け、 結果はブーリアン式になります。

  `and`は可換ではありません: `a and b`は、不定のオペランドの扱いのため、`b and a`と同値ではないかもしれません。

  Operators ·

演算子: not

  論理否定演算子。 `not`は、接頭演算子です; オペランドはブーリアン値で、結果もブーリアン値です。

  `or`は、（`is`のように）オペランドの評価を強制します。

  グローバルフラグ`prederror`は、 評価されたオペランドが`true`か`false`に決定できない時の`not`の振る舞いを決定します。 `prederror`が`true`の時、`not`は、エラーメッセージを出力します。 そうでなければ、`true`か`false`に評価されないオペランドを受け付け、 結果はブーリアン式になります。

  Operators ·

演算子: or

  論理和演算子。 `or`は、n項中置演算子です; オペランドはブーリアン値で、結果もブーリアン値です。

  `or`は、（`is`のように）１以上のオペランドの評価を強制し、 すべてのオペランドの評価を強制するかもしれません。

  オペランドは、出現順に評価されます。 `and`は、結果を決定するのに必要なだけオペランドを評価します。 もし任意のオペランドが`true`なら、結果は`true`であり、 ほかのオペランドは評価されません。

  グローバルフラグ`prederror`は、 評価されたオペランドが`true`か`false`に決定できない時の`or`の振る舞いを決定します。 `prederror`が`true`の時、`or`は、エラーメッセージを出力します。 そうでなければ、`true`か`false`に評価されないオペランドを受け付け、 結果はブーリアン式になります。

  `or`は可換ではありません: `a or b`は、不定のオペランドの扱いのため、`b or a`と同値ではないかもしれません。

  Operators ·

Next: Assignment operators, Previous: Logical operators, Up: Operators [Contents][Index]

### 7.5 Operators for Equations

演算子: #

  構文的等号`=`の否定を表します。

  述語論理式の評価のルールのため （特に `not expr`は exprの評価を伴うので）、 `not a = b`は、 `a # b`ではなく、 `is(a # b)`と同値です。

  例:

      (%i1) a = b;
      (%o1)                         a = b
      (%i2) is (a = b);
      (%o2)                         false
      (%i3) a # b;
      (%o3)                         a # b
      (%i4) not a = b;
      (%o4)                         true
      (%i5) is (a # b);
      (%o5)                         true
      (%i6) is (not a = b);
      (%o6)                         true

  Operators ·

演算子: =

  等式演算子。

  式`a = b`は、それ自身、未評価の等式を表します。 等式は成り立つかもしれませんし、成り立たないかもしれません。 未評価の等式は、`solve`や`algsys`や他の関数の引数として用いられます。

  関数`is`は、`=`をブーリアン値に評価します。 `is(a = b)`は、aとbが同一のとき、 `a = b`を`true`に評価します。 すなわち、aとbが同一のアトムであるか、もしくは、それらはアトムではなく、 それらの演算子が同一で、演算子の引数が同一です。 そうでなければ、`is(a = b)`は`false`に評価されます; 決して、`unknown`には評価されません。 `is(a = b)`が`true`の時、 aとbは、同値の式と対照的に、構文法的に等しいと言われます。 同値の式は、`is(equal(a, b))`が`true`の式です。 式は、同値だが構文法的に等しくないことが起こりえます。

  `=`の否定は、`#`で表されます。 `=`と同様、式`a # b`は、それ自身、評価されません。 `is(a # b)`は、`a # b`を`true`もしくは`false`に評価します。

  `is`に加えて、他のいくつかの演算子が`=`と`#`を`true`もしくは`false`に評価します。`if`, `and`, `or`, `not`という演算子です。

  述語論理式の評価規則のため （特に、`not expr`はexprの評価を起こすため）、 `not a = b`は、`a # b`ではなく、 `is(a # b)`と同値になります。

  `rhs`と`lhs`は、それぞれ、等式、不等式の右辺と左辺を返します。

  `equal`や`notequal`も参照してください。

  例:

  式`a = b`は、それ自身、未評価の等式であり、成り立つことも成り立たないこともあります。

      (%i1) eq_1 : a * x - 5 * y = 17;
      (%o1)                    a x - 5 y = 17
      (%i2) eq_2 : b * x + 3 * y = 29;
      (%o2)                    3 y + b x = 29
      (%i3) solve ([eq_1, eq_2], [x, y]);
                              196         29 a - 17 b
      (%o3)          [[x = ---------, y = -----------]]
                           5 b + 3 a       5 b + 3 a
      (%i4) subst (%, [eq_1, eq_2]);
               196 a     5 (29 a - 17 b)
      (%o4) [--------- - --------------- = 17,
             5 b + 3 a      5 b + 3 a
                                        196 b     3 (29 a - 17 b)
                                      --------- + --------------- = 29]
                                      5 b + 3 a      5 b + 3 a
      (%i5) ratsimp (%);
      (%o5)                  [17 = 17, 29 = 29]

  `is(a = b)`は、 aとbが構文法的に等しい（すなわち、同一の）時 式は、同値だが構文法的に等しくないことがありえます。

      (%i1) a : (x + 1) * (x - 1);
      (%o1)                    (x - 1) (x + 1)
      (%i2) b : x^2 - 1;
                                    2
      (%o2)                        x  - 1
      (%i3) [is (a = b), is (a # b)];
      (%o3)                     [false, true]
      (%i4) [is (equal (a, b)), is (notequal (a, b))];
      (%o4)                     [true, false]

  いくつかの演算子は、`=`と`#`を`true`もしくは`false`に評価します。

      (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
            BAR;
      (%o1)                          FOO
      (%i2) eq_3 : 2 * x = 3 * x;
      (%o2)                       2 x = 3 x
      (%i3) eq_4 : exp (2) = %e^2;
                                    2     2
      (%o3)                       %e  = %e
      (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
      (%o4)                  [false, true, true]

  `not expr`はexprの評価をするので、 `not a = b`は、`is(a # b)`と同値です。

      (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
      (%o1)                   [2 x # 3 x, true]
      (%i2) is (2 * x # 3 * x);
      (%o2)                         true

  Operators ·

Next: User defined operators, Previous: Operators for Equations, Up: Operators [Contents][Index]

### 7.6 Assignment operators

演算子: :

  割り当て演算子。

  左辺が（添字のない）単純変数の時、 `:`は右辺を評価し、その値を左辺に関連づけます。

  左辺がリストや行列、宣言されたMaxima配列、Lisp配列の添字指定された要素の時、 右辺がその要素に割り当てられます。 添字は存在している要素を示していなければなりません; 先に列挙した対象は、存在していない要素を名付けることで拡張することはできません。

  左辺が未宣言のMaxima配列の添字指定された要素の時、 もし既に存在しているなら、右辺はその要素に割り当てられ、 もしまだ存在していなければ新しい要素が確保されます。

  左辺が単純変数や添字あり変数のリストの時、 右辺はリストに評価されなければなりません。 そして、右辺の要素が左辺の要素に平行に割り当てられます。

  `kill`や`remvalue`も参照してください。 それらは左辺とその値の関連をアンドゥします。

  例:

  単純変数への割り当て

      (%i1) a;
      (%o1)                           a
      (%i2) a : 123;
      (%o2)                          123
      (%i3) a;
      (%o3)                          123

  リストの要素への割り当て

      (%i1) b : [1, 2, 3];
      (%o1)                       [1, 2, 3]
      (%i2) b[3] : 456;
      (%o2)                          456
      (%i3) b;
      (%o3)                      [1, 2, 456]

  割り当ては未宣言配列を生成する。

      (%i1) c[99] : 789;
      (%o1)                          789
      (%i2) c[99];
      (%o2)                          789
      (%i3) c;
      (%o3)                           c
      (%i4) arrayinfo (c);
      (%o4)                   [hashed, 1, [99]]
      (%i5) listarray (c);
      (%o5)                         [789]

  多重割り当て

      (%i1) [a, b, c] : [45, 67, 89];
      (%o1)                     [45, 67, 89]
      (%i2) a;
      (%o2)                          45
      (%i3) b;
      (%o3)                          67
      (%i4) c;
      (%o4)                          89

  多重割り当ては平行に実行されます。 この例では`a`と`b`の値が置換されます。

      (%i1) [a, b] : [33, 55];
      (%o1)                       [33, 55]
      (%i2) [a, b] : [b, a];
      (%o2)                       [55, 33]
      (%i3) a;
      (%o3)                          55
      (%i4) b;
      (%o4)                          33

  Evaluation ·Operators ·

演算子: ::

  割り当て演算子。

  `::`は、`::`は右辺はもちろん左辺も評価することを除いて、`:`と同じです。

  例:

      (%i1) x : 'foo;
      (%o1)                          foo
      (%i2) x :: 123;
      (%o2)                          123
      (%i3) foo;
      (%o3)                          123
      (%i4) x : '[a, b, c];
      (%o4)                       [a, b, c]
      (%i5) x :: [11, 22, 33];
      (%o5)                     [11, 22, 33]
      (%i6) a;
      (%o6)                          11
      (%i7) b;
      (%o7)                          22
      (%i8) c;
      (%o8)                          33

  Evaluation ·Operators ·

演算子: ::=

  マクロ関数定義の演算子。 `::=`は、引数をクォートする関数（歴史的理由によりマクロと呼ばれる）を定義します。 そして、それが返す式（マクロ展開と呼ばれる）はマクロが呼ばれた文脈の中で評価されます。 それ以外はマクロ関数は通常の関数と同じです。

  `macroexpand`は（評価せずに）マクロ展開を返します。 `foo`がマクロ関数の時、 `macroexpand (foo (x))`に続けて ```%`を実行すると、 それは `foo (x)`と同値です。

  `::=`は、新しいマクロ関数の名前をグローバルリスト `macros`に追加します。 `kill`や `remove`, `remfunction`は、マクロ関数定義をアンバインドし、 `macros`から名前を削除します。

  `fundef`や `dispfun`はそれぞれマクロ関数定義を返し、 それをラベルに割り当てます。

  評価対象となる式を構成するために、 マクロ関数は一般的に`buildq`, `splice`式を含みます。

  例

  マクロ関数は引数をクォートします。 だから、メッセージ(1)は `y - z`の値ではなく、 `y - z`を示します。 マクロ展開（クォートされた式 `'(print ("(2) x is equal to", x)`）は、 マクロが呼ばれた文脈（表示メッセージ(2)）の中で評価されます。

      (%i1) x: %pi$
      (%i2) y: 1234$
      (%i3) z: 1729 * w$
      (%i4) printq1 (x) ::= block (print ("(1) x is equal to", x),
            '(print ("(2) x is equal to", x)))$
      (%i5) printq1 (y - z);
      (1) x is equal to y - z
      (2) x is equal to %pi
      (%o5)                                 %pi

  通常の関数は引数を評価します。だから、メッセージ(1)は `y - z`の値を示します。 戻り値は評価されず、従って、メッセージ(2)は ```%`で陽に評価されるまで出力されません。

      (%i1) x: %pi$
      (%i2) y: 1234$
      (%i3) z: 1729 * w$
      (%i4) printe1 (x) := block (print ("(1) x is equal to", x),
            '(print ("(2) x is equal to", x)))$
      (%i5) printe1 (y - z);
      (1) x is equal to 1234 - 1729 w
      (%o5)                     print((2) x is equal to, x)
      (%i6) ''%;
      (2) x is equal to %pi
      (%o6)                                 %pi

  `macroexpand`はマクロ展開を返します。 `foo`がマクロ関数の時、 `macroexpand (foo (x))`の後 ```%`を実行すると、`foo (x)`と同値です。

      (%i1) x: %pi$
      (%i2) y: 1234$
      (%i3) z: 1729 * w$
      (%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$
      (%i5) macroexpand (g (y - z));
      (%o5)                     print(x is equal to, y - z)
      (%i6) ''%;
      x is equal to 1234 - 1729 w
      (%o6)                            1234 - 1729 w
      (%i7) g (y - z);
      x is equal to 1234 - 1729 w
      (%o7)                            1234 - 1729 w

  Function definition ·Operators ·

演算子: :=

  関数定義の演算子。 `f(x_1, .., x_n) := expr`は、 引数がx_1, ..., x_nで関数本体がexprの、fという名前の関数を定義します。 `:=`は（クォートクォート````で陽に評価されない限り）関数本体は評価しません。 定義される関数は（引数をかっこでくくる）通常のMaxima関数か、（引数をかぎかっこでくくる）配列関数です。

  最後の引数x_nが要素１つのリストの時、`:=`で定義された関数は可変の数の引数をとります。 実際の引数は、形式的な引数x_1, …, x_(n - 1)に一対一に割り当てられ、 さらに引数があれば、x_nにリストとして割り当てられます。

  関数定義すべては、同じ名前空間を使います; 別の関数`g`の中で関数`f`を定義することは、`f`のスコープを`g`に限定しません。 しかし、`local(f)`は、関数`f`の定義を`local`が現れたブロックや他の合成式内に限定します。

  もしある形式引数x_kがクォートされたシンボルなら、`:=`で定義された関数は対応する実際の引数を評価しません。 それ以外の場合、実際の引数はすべて評価されます。

  `define`や`::=`も参照してください。

  例:

  `:=`は（クォートクォートで陽に評価されない限り）関数本体を評価しません。

      (%i1) expr : cos(y) - sin(x);
      (%o1)                    cos(y) - sin(x)
      (%i2) F1 (x, y) := expr;
      (%o2)                   F1(x, y) := expr
      (%i3) F1 (a, b);
      (%o3)                    cos(y) - sin(x)
      (%i4) F2 (x, y) := ''expr;
      (%o4)              F2(x, y) := cos(y) - sin(x)
      (%i5) F2 (a, b);
      (%o5)                    cos(b) - sin(a)

  `:=`で定義された関数は、通常のMaxima関数か、配列関数です。

      (%i1) G1 (x, y) := x.y - y.x;
      (%o1)               G1(x, y) := x . y - y . x
      (%i2) G2 [x, y] := x.y - y.x;
      (%o2)                G2     := x . y - y . x
                             x, y

  最後の引数x_nが要素１つのリストの時、 `:=`で定義された関数は、可変の数の引数を取ります。

      (%i1) H ([L]) := apply ("+", L);
      (%o1)                H([L]) := apply("+", L)
      (%i2) H (a, b, c);
      (%o2)                       c + b + a

  `local`はローカル関数定義を可能にします。

      (%i1) foo (x) := 1 - x;
      (%o1)                    foo(x) := 1 - x
      (%i2) foo (100);
      (%o2)                         - 99
      (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
      (%o3)                          200
      (%i4) foo (100);
      (%o4)                         - 99

  Function definition ·Operators ·

Previous: Assignment operators, Up: Operators [Contents][Index]

### 7.7 User defined operators

関数: infix (op)
関数: infix (op, lbp, rbp)
関数: infix (op, lbp, rbp, lpos, rpos, pos)

  opを中置演算子に宣言します。 中置演算子は２つの引数の関数で、引数の間に関数名が来ます。 例えば、引き算演算子`-`は中置演算子です。

  `infix (op)`は、デフォルトの結合力（左右両方とも180）と品詞 （左右両方とも`any`)に等しい）でopを中置演算子に宣言します。

  `infix (op, lbp, rbp)`は、 記述された左右の結合力 とデフォルトの品詞（左右両方とも`any`)に等しい）で、 opを中置演算子に宣言します。

  `infix (op, lbp, rbp, lpos, rpos, pos)`は、 記述された左右の結合力と、 左オペランド、右オペランド、演算子結果それぞれについて、 品詞をlpos, rpos, posに設定して、 opを中置演算子に宣言します。

  （演算子宣言に関係して）「品詞」は、式のタイプを意味します。 ３つのタイプが認識されます; `expr`, `clause`, `any`。それぞれは、 代数式、ブーリアン式、任意の種類の式を示します。 Maximaは、宣言された品詞を実際の式に比較することで、 いくつかの構文法エラーを検出します。

  他の演算子に関するopの優先順位は、問題となっている演算子の左右結合力から演繹されます。 もしopの左右結合力のどちらもある他の演算子の左右結合力より大きいなら、 opは、他の演算子より高い優先順位をとります。 もし結合力がどちらも大きくも、どちらも小さくもなければ、 あるもっと複雑な関係が成り立ちます。

  opの結合性は結合力に依存します。 より大きな左結合力(lbp)は、opのインスタンスが 式の中で左にある他の演算子の前に評価されることを示し、 より大きな右結合力(rbp)は、opのインスタンスが 式の中で右にある他の演算子の前に評価されることを示します。 このように、より大きなlbpはopを右結合にし、 より大きなrbpはopを左結合にします。 もしlbpがrbpと等しいなら、 opは左結合です。

  `Syntax`も参照してください。

  例:

  もしop左右結合力それぞれが、他の演算子のそれより大きいなら、 opは他の演算子より高い優先順位をとります。

      (%i1) :lisp (get '$+ 'lbp)
      100
      (%i1) :lisp (get '$+ 'rbp)
      100
      (%i1) infix ("##", 101, 101);
      (%o1)                          ##
      (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
      (%o2)       (a ## b) := sconcat("(", a, ",", b, ")")
      (%i3) 1 + a ## b + 2;
      (%o3)                       (a,b) + 3
      (%i4) infix ("##", 99, 99);
      (%o4)                          ##
      (%i5) 1 + a ## b + 2;
      (%o5)                       (a+1,b+2)

  より大きなlbpはopを右結合にし、 より大きなrbpはopを左結合にします。

      (%i1) infix ("##", 100, 99);
      (%o1)                          ##
      (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
      (%i3) foo ## bar ## baz;
      (%o3)                    (foo,(bar,baz))
      (%i4) infix ("##", 100, 101);
      (%o4)                          ##
      (%i5) foo ## bar ## baz;
      (%o5)                    ((foo,bar),baz)

  Maximaは、宣言された品詞を実際の式と比較することで、 いくつかの構文法エラーを検出します。

      (%i1) infix ("##", 100, 99, expr, expr, expr);
      (%o1)                          ##
      (%i2) if x ## y then 1 else 0;
      Incorrect syntax: Found algebraic expression where logical
      expression expected
      if x ## y then
                   ^
      (%i2) infix ("##", 100, 99, expr, expr, clause);
      (%o2)                          ##
      (%i3) if x ## y then 1 else 0;
      (%o3)                if x ## y then 1 else 0

  Operators ·Declarations and inferences ·Syntax ·

関数: matchfix (ldelimiter, rdelimiter)
関数: matchfix (ldelimiter, rdelimiter, arg_pos, pos)

  左と右の区切り記号ldelimiterとrdelimiterを持つ matchfix演算子を宣言します 区切り記号は文字列として指定されます。

  "matchfix"演算子は、 任意の数の引数の関数で、引数は左と右の区切り記号をマッチする間で現れます。 パーサがオペランドや他の式や演算子から区切り記号を区別できる限り 区切り記号は任意の文字列を取り得ます。 実際には、これは、`%`, `,`, `$`, `;`のような パースできない区切り記号を除外し、空白を持つ区切り記号を分離することを要求するかもしれません。 右区切り記号は、左区切り記号と同じかもしれませんし、違うかもしれません。

  左区切り記号は、たった１つの右区切り記号と関連づけられることができます; ２つの異なるmatchfix演算子は同じ左区切り記号を持つことはできません。

  存在する演算子は、 他のプロパティを変えることなく、 matchfix演算子として再宣言することができます。 特に、足し算`+`のような組み込み演算子が matchfixに宣言されることが可能ですが、 演算子関数は組み込み演算子に関して定義できません。

  コマンド`matchfix (ldelimiter, rdelimiter, arg_pos, pos)` は、 引数品詞arg_posと結果品詞pos、区切り記号 ldelimiterとrdelimiterを宣言します。

  演算子宣言に関して、「品詞」は式のタイプを意味します。 ３つのタイプが認識されます: それぞれ、代数式、ブーリアン式、任意の種類の式を示す、 `expr`, `clause`, `any`。 Maximaは、 宣言された品詞を実際の式と比較することで、 いくつかの構文法エラーを検知します。

  matchfix演算を実行する関数は通常のユーザー定義関数です。 演算子関数は、 関数定義演算子`:=`や`define`を使って 普通の方法で定義されます。 引数は、区切り記号の間に書かれるか、 クォートされた文字列としての左区切り記号と括弧の中で続く引数を使って書かれます。 `dispfun (ldelimiter)`は関数定義を表示します。

  唯一の組み込みmatchfix演算子はリスト構成子`[ ]`です。 括弧`( )`とダブルクォート`" "`はmatchfix演算子のように振る舞いますが、 Maximaパーサによってそのようには扱われません。

  `matchfix`は引数を評価します。 `matchfix`は最初の引数ldelimiterを返します。

  例:

  区切り記号はほとんど任意の文字列を取り得ます。

      (%i1) matchfix ("@@", "~");
      (%o1)                          @@
      (%i2) @@ a, b, c ~;
      (%o2)                      @@a, b, c~
      (%i3) matchfix (">>", "<<");
      (%o3)                          >>
      (%i4) >> a, b, c <<;
      (%o4)                      >>a, b, c<<
      (%i5) matchfix ("foo", "oof");
      (%o5)                          foo
      (%i6) foo a, b, c oof;
      (%o6)                     fooa, b, coof
      (%i7) >> w + foo x, y oof + z << / @@ p, q ~;
                           >>z + foox, yoof + w<<
      (%o7)                ----------------------
                                  @@p, q~

  Matchfix演算子は通常のユーザー定義関数です。

      (%i1) matchfix ("!-", "-!");
      (%o1)                         "!-"
      (%i2) !- x, y -! := x/y - y/x;
                                          x   y
      (%o2)                   !-x, y-! := - - -
                                          y   x
      (%i3) define (!-x, y-!, x/y - y/x);
                                          x   y
      (%o3)                   !-x, y-! := - - -
                                          y   x
      (%i4) define ("!-" (x, y), x/y - y/x);
                                          x   y
      (%o4)                   !-x, y-! := - - -
                                          y   x
      (%i5) dispfun ("!-");
                                          x   y
      (%t5)                   !-x, y-! := - - -
                                          y   x

      (%o5)                         done
      (%i6) !-3, 5-!;
                                      16
      (%o6)                         - --
                                      15
      (%i7) "!-" (3, 5);
                                      16
      (%o7)                         - --
                                      15

  Syntax ·Operators ·

関数: nary (op)
関数: nary (op, bp, arg_pos, pos)

  `nary`演算子は 任意の数の引数の関数を示すのに使われます。 引数それぞれは、例えば、A+BやA+B+Cように演算子の出現で分離されます。 `nary("x")`関数は `x`を `nary`演算子に宣言する構文拡張関数です。 関数は `nary`であると宣言されるかもしれません。 もし `declare(j,nary);`が実行されたら、 これは整理器に 例えば、`j(j(a,b),j(c,d))`を `j(a, b, c, d)`に整理するよう指示します。

  Introduction to operatorsも参照してください。

  Operators ·Syntax ·

関数: nofix (op)
関数: nofix (op, pos)

  `nofix`演算子は引数のない関数を示すのに使われます。 コマンドにそんな演算子が存在すると、 対応する関数が評価されるだけです。 例えば、Maximaブレイクから抜けるために"exit;"とタイプする時、 "exit"は`nofix`演算子と似たように振る舞います。 関数 `nofix("x")`は `x`を `nofix`演算子に宣言する構文拡張関数です。

  Introduction to operatorsも参照してください。

  Operators ·Syntax ·

関数: postfix (op)
関数: postfix (op, lbp, lpos, pos)

  `prefix`変種のような`postfix`演算子は引数一つの関数を示しますが、 この場合、例えば3!のように、入力文字列の中で引数が演算子に先行します。 `postfix("x")`関数は `x`を`postfix`演算子に宣言する構文拡張関数です。

  Introduction to operatorsも参照してください。

  Operators ·Syntax ·

関数: prefix (op)
関数: prefix (op, rbp, rpos, pos)

  `prefix`演算子は引数一つの関数であり、 その引数は演算子のすぐ後ろに置かれます。 `prefix("x")`は `x`を`prefix`演算子に宣言する構文拡張関数です。

  Introduction to operatorsも参照してください。

  Operators ·Syntax ·

Next: Simplification, Previous: Operators, Up: Top [Contents][Index]

## 8 Evaluation

Previous: Evaluation, Up: Evaluation [Contents][Index]

### 8.1 Functions and Variables for Evaluation

演算子: '

  シングルクォート演算子`'`は評価を抑制します。

  シンボルにシングルクォートを用いると、シンボルが評価されません。

  関数コールにシングルクォートを用いると、 関数の引数は（抑制されない限り）評価されますが、関数コールは評価されません。結果は、関数コールの名詞形です。

  括弧でくくられた式にシングルクォートを用いると、 式の中のすべてのシンボルと関数コールは評価されません。 例えば、`'(f(x))`は、式`f(x)`を評価しないことを意味します。 `'f(x)`（`f(x)`ではなく`f`へ適用されたシングルクォート）は`[x]`に適用された`f`の名詞形を返します。

  シングルクォートは式整理を抑制しません。

  グローバルフラグ `noundisp`が `true`の時、名詞はシングルクォート付きで表示されます。 このスイッチは関数定義を表示するときには、常に`true`です。

  クォートクォート演算子 `''`と `nouns`も参照ください。

  例:

  シンボルにシングルクォートを用いると、シンボルが評価されません。

      (%i1) aa: 1024;
      (%o1)                         1024
      (%i2) aa^2;
      (%o2)                        1048576
      (%i3) 'aa^2;
                                       2
      (%o3)                          aa
      (%i4) ''%;
      (%o4)                        1048576

  関数コールにシングルクォートを用いると、関数の引数は評価されますが、関数コールが評価されません。 結果は、関数コールの名詞形です。

      (%i1) x0: 5;
      (%o1)                           5
      (%i2) x1: 7;
      (%o2)                           7
      (%i3) integrate (x^2, x, x0, x1);
                                     218
      (%o3)                          ---
                                      3
      (%i4) 'integrate (x^2, x, x0, x1);
                                   7
                                  /
                                  [   2
      (%o4)                       I  x  dx
                                  ]
                                  /
                                   5
      (%i5) %, nouns;
                                     218
      (%o5)                          ---
                                      3

  括弧でくくられた式にシングルクォートを用いると、式の中のすべてのシンボルと関数コールは評価されません。

      (%i1) aa: 1024;
      (%o1)                         1024
      (%i2) bb: 19;
      (%o2)                          19
      (%i3) sqrt(aa) + bb;
      (%o3)                          51
      (%i4) '(sqrt(aa) + bb);
      (%o4)                     bb + sqrt(aa)
      (%i5) ''%;
      (%o5)                          51

  シングルクォートは式整理を抑制しません。

      (%i1) sin (17 * %pi) + cos (17 * %pi);
      (%o1)                          - 1
      (%i2) '(sin (17 * %pi) + cos (17 * %pi));
      (%o2)                          - 1

  Maximaは組み込み数学関数による浮動小数点演算を整理とみなします。

      (%i1) sin(1.0);
      (%o1)                          .8414709848078965
      (%i2) '(sin(1.0));
      (%o2)                          .8414709848078965

  Evaluation ·Operators ·

演算子: ''

  クォートクォート演算子`''`(シングルクォートマーク２つ）は、入力式の中の評価を部分修正します。

  一般式exprにクォートクォートを用いると、入力式の中のexprにexprの値を代入します。

  式の演算子にクォートクォートを用いると、（もし動詞でないなら）演算子は名詞から動詞に変わります。

  クォートクォート演算子は入力パーサが適用します; クォートクォート演算子はパースされた入力式の一部としては格納されません。 クォートクォート演算子は、パースされるといつもすぐに適用され、クォートできません。 このように、関数定義やラムダ式、シングルクォート`'`でクォートされた式の中のように通常評価が抑制される時も、 クォートクォートがあると評価を実行します。

  `batch`や`load`はクォートクォートを認識します。

  シングルクォート演算子 `'`と `nouns`も参照ください。

  例:

  一般式exprにクォートクォートを用いると、入力式の中のexprにexprの値を代入します。

      (%i1) expand ((a + b)^3);
                           3        2      2      3
      (%o1)               b  + 3 a b  + 3 a  b + a
      (%i2) [_, ''_];
                               3    3        2      2      3
      (%o2)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
      (%i3) [%i1, ''%i1];
                               3    3        2      2      3
      (%o3)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
      (%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
      (%o4)                   [cc, dd, 17, 29]
      (%i5) foo_1 (x) := aa - bb * x;
      (%o5)                 foo_1(x) := aa - bb x
      (%i6) foo_1 (10);
      (%o6)                      cc - 10 dd
      (%i7) ''%;
      (%o7)                         - 273
      (%i8) ''(foo_1 (10));
      (%o8)                         - 273
      (%i9) foo_2 (x) := ''aa - ''bb * x;
      (%o9)                 foo_2(x) := cc - dd x
      (%i10) foo_2 (10);
      (%o10)                        - 273
      (%i11) [x0 : x1, x1 : x2, x2 : x3];
      (%o11)                    [x1, x2, x3]
      (%i12) x0;
      (%o12)                         x1
      (%i13) ''x0;
      (%o13)                         x2
      (%i14) '' ''x0;
      (%o14)                         x3

  式の演算子にクォートクォートを用いると、（もし動詞でないなら）演算子は名詞から動詞に変わります。

      (%i1) declare (foo, noun);
      (%o1)                         done
      (%i2) foo (x) := x - 1729;
      (%o2)                 ''foo(x) := x - 1729
      (%i3) foo (100);
      (%o3)                       foo(100)
      (%i4) ''foo (100);
      (%o4)                        - 1629

  クォートクォート演算子は入力パーサが適用します； クォートクォート演算子はパースされた入力式の一部としては格納されません。

      (%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
      (%o1)                 [bb, dd, 1234, 5678]
      (%i2) aa + cc;
      (%o2)                        dd + bb
      (%i3) display (_, op (_), args (_));
                                 _ = cc + aa

                               op(cc + aa) = +

                          args(cc + aa) = [cc, aa]

      (%o3)                         done
      (%i4) ''(aa + cc);
      (%o4)                         6912
      (%i5) display (_, op (_), args (_));
                                 _ = dd + bb

                               op(dd + bb) = +

                          args(dd + bb) = [dd, bb]

      (%o5)                         done

  関数定義やラムダ式、シングルクォート`'`でクォートされた式の中のように 通常評価が抑制される時も、 クォートクォートがあると評価を実行します。

      (%i1) foo_1a (x) := ''(integrate (log (x), x));
      (%o1)               foo_1a(x) := x log(x) - x
      (%i2) foo_1b (x) := integrate (log (x), x);
      (%o2)           foo_1b(x) := integrate(log(x), x)
      (%i3) dispfun (foo_1a, foo_1b);
      (%t3)               foo_1a(x) := x log(x) - x

      (%t4)           foo_1b(x) := integrate(log(x), x)

      (%o4)                      [%t3, %t4]
      (%i5) integrate (log (x), x);
      (%o5)                     x log(x) - x
      (%i6) foo_2a (x) := ''%;
      (%o6)               foo_2a(x) := x log(x) - x
      (%i7) foo_2b (x) := %;
      (%o7)                    foo_2b(x) := %
      (%i8) dispfun (foo_2a, foo_2b);
      (%t8)               foo_2a(x) := x log(x) - x

      (%t9)                    foo_2b(x) := %

      (%o9)                      [%t7, %t8]
      (%i10) F : lambda ([u], diff (sin (u), u));
      (%o10)             lambda([u], diff(sin(u), u))
      (%i11) G : lambda ([u], ''(diff (sin (u), u)));
      (%o11)                  lambda([u], cos(u))
      (%i12) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
      (%o12)         sum(b , k, 1, 3) + sum(a , k, 1, 3)
                          k                  k
      (%i13) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
      (%o13)             b  + a  + b  + a  + b  + a
                          3    3    2    2    1    1

  Evaluation ·Operators ·

関数: alias (new_name_1, old_name_1, ..., new_name_n, old_name_n)

  (利用者もしくはシステム)関数や変数、配列等に対して別名を与えます。 任意の偶数個の引数を取ります。

  Declarations and inferences ·

関数: ev (expr, arg_1, …, arg_n)

  引数arg_1, …, arg_nで指定された環境下で 式exprを評価します。 引数は、スイッチ（ブーリアンフラグ）だったり、割り当てだったり、 等式だったり、関数だったりします。 evは評価の結果（別の式）を返します。

  評価は以下のようにステップを追って実行されます。

  1. 最初に、以下の任意のもしくはすべての引数をスキャンして環境を準備します。
     - `simp`を引数に指定するとexprを整理します。`false`なら整理を抑制するスイッチ`simp`の設定に関わらずです。
     - `noeval`を引数に指定すると`ev`の評価フェイズを抑制します。 （以下のステップ(4)を参照してください。） これは、他のスイッチとの連携時や、exprを再評価せずに再整理をさせる時に役に立ちます。
     - `nouns`を引数に指定するとexprの中の名詞形式 （典型的には、`'integrate`や`'diff`のような未評価関数）を評価します。
     - `expand`を引数に指定すると展開します。
     - `expand (m, n)`を引数に指定すると、 `maxposex`と`maxnegex`の値をそれぞれmとnに設定して、展開します。
     - `detout`を引数に指定すると、exprの中で計算されるどんな逆行列も、逆行列の外側に行列式を保つようにします。
     - `diff`を引数に指定するとexprの中のすべての微分を実行します。
     - `derivlist (x, y, z, ...)`を引数に指定すると指定された変数に関する微分のみを実行します。
     - `risch`を引数に指定すると exprの中の積分をRischアルゴリズムを使って評価します。 `risch`を参照してください。 特殊なシンボル`nouns`を使った時には標準の積分ルーチンが呼び出されます。
     - `float`を引数に指定すると非整数有理数を浮動小数点に変換します。
     - `numer`を引数に指定すると数値引数が指定された（指数関数を含む）いくつかの数学関数を浮動小数点に評価します。 また、exprの中の numerval宣言された変数は、宣言された値に置き換えられます。 また、`float`スイッチをオンにします。
     - `pred`を引数に指定すると述語（`true`もしくは`false`に評価される式）を評価します。
     - `eval`を引数に指定するとexprの特別な後評価をします。（ステップ(5)を参照。） `eval`は複数回起こるかもしれません。`eval`のそれぞれのインスタンスのために、式は再評価されます。
     - 評価フラグ（`evflag`を参照）として宣言されたアトム`A`を引数に指定すると、 exprの評価の最中、`A`が`true`にバインドされます。
     - `V: expression`（もしくは代わりに`V=expression`）を引数に指定すると、 exprの評価の最中、`V`が`expression`の値にバインドされます。 もし`V`がMaximaオプションなら、exprの評価の最中、`V`の値に`expression`が使われることに注意してください。 もし`ev`の複数の引数がこのタイプの場合、並列してバインドされます。 もし`V`が非アトムの式なら、バインドではなく、代入が実行されます。
     - 関数名 `F`が評価関数(`evfun`参照)として宣言されている場合、 `F`を引数に指定すると `F`が exprに適用されます。
     - 他のどんな関数名（例えば、`sum`)でも引数に指定すると、 exprの中にそれらの名前が現れた時それらが動詞であるかのように評価します。
     - 加えて、exprの中で出現する関数（`F(x)`としましょう）を、 exprの今回の評価の目的のため、 `F(X) := expression`を`ev`の引数に与えて、局所的に定義することができます。
     - もし以上で言及しなかったアトム、添字付き変数、または、添字付き式が引数として与えられたら、 それを評価して、 もしその結果が等式もしくは割り当てであったら、示されたバインドもしくは代入を実行します。 もしその結果がリストなら、リストのメンバが、 `ev`に与えられた追加の引数であるかのように扱います。 これにより、 `solve`が返すような、与えられた等式のリスト （例えば、 `[X=1,Y=A**2]`)や 等式の名前のリスト（例えば、 `[%t1, %t2]`。ここで `%t1`, `%t2`は等式）が使えます。

     `ev`の引数は、代入等式と評価関数以外はどんな順序で与えてもかまいません。 代入等式は左から右へ順に扱われ、 評価関数は、例えば、 `ev (expr, ratsimp, realpart)`は `realpart (ratsimp (expr))`と扱われるように、合成されます。

     `simp`, `numer`, `float`スイッチは、ブロックの中でローカルにも、 またMaximaの中でグローバルにも設定でき、その場合，リセットされるまで効果を保ちます。

     `numer`と`float`スイッチがともに`true`でない場合、 もしexprが標準有理式(CRE)なら、`ev`が返す式もまたCREです。

  2. step (1)の最中に、引数の中のもしくは引数の値の、等式の左辺に現れる添字なしの変数のリストを作ります。 exprの中の変数（添字なし変数や配列関数に関連づけられていない添字付き変数）は、 先のリストに現れるものを除いて、グローバルな値に置き換えられます。 普通、 exprは、ただのラベルだったり (以下の例の `%i2`のように） `%`だったりするので、 その場合，このステップは単にラベルされた式を取り出し、 `ev`はその式に対して機能することになります。
  3. 引数で指定されたどんな代入文もすぐ実行されます。
  4. （引数で`noeval`が指定されていない限り）結果の式は再評価され、 引数に従って整理されます。 exprの中のどんな関数コールもその中の変数が評価された後実行されること、 `ev(F(x))`は `F(ev(x))`のように振る舞うことに注意してください。
  5. 引数の中の`eval`のそれぞれのインスタンスのために、step (3)(4)を繰り返します。

  例:

      (%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
                                           d                    2
      (%o1)              cos(y) + sin(x) + -- (sin(w)) + (w + 1)
                                           dw
      (%i2) ev (%, numer, expand, diff, x=2, y=1);
                                   2
      (%o2)              cos(w) + w  + 2 w + cos(1) + 2.449599732693821

  `ev`のために、代わりのトップレベルの文法が提供されています。 それによって、`ev()`なしに引数をタイプして入力するだけでよくなります。 すなわち、単に以下のように書けます。

      expr, arg_1, ..., arg_n

  これは、例えば、関数やブロックの中など、他の式の一部としては許されません。

  以下の例では並列のバインドプロセスに注意してください。

      (%i3) programmode: false;
      (%o3)                                false
      (%i4) x+y, x: a+y, y: 2;
      (%o4)                              y + a + 2
      (%i5) 2*x - 3*y = 3$
      (%i6) -3*x + 2*y = -4$
      (%i7) solve ([%o5, %o6]);
      Solution

                                                1
      (%t7)                               y = - -
                                                5

                                               6
      (%t8)                                x = -
                                               5
      (%o8)                            [[%t7, %t8]]
      (%i8) %o6, %o8;
      (%o8)                              - 4 = - 4
      (%i9) x + 1/x > gamma (1/2);
                                         1
      (%o9)                          x + - > sqrt(%pi)
                                         x
      (%i10) %, numer, x=1/2;
      (%o10)                      2.5 > 1.772453850905516
      (%i11) %, pred;
      (%o11)                               true

  Evaluation ·

特殊シンボル: eval

  `ev (expr)`のコールの引数として、 `eval`は exprの追加の評価をもたらします。 `ev`を参照してください。

  例:

      (%i1) [a:b,b:c,c:d,d:e];
      (%o1)                            [b, c, d, e]
      (%i2) a;
      (%o2)                                  b
      (%i3) ev(a);
      (%o3)                                  c
      (%i4) ev(a),eval;
      (%o4)                                  e
      (%i5) a,eval,eval;
      (%o5)                                  e

  Evaluation flags ·

プロパティ: evflag

  シンボル`x`が`evflag`プロパティを持つ時、 式`ev(expr, x)`や対話プロンプトでの`expr, x`は、 `ev(expr, x = true)`と同値です。 すなわち、exprが評価される間、xは`true`にバインドされます。

  式`declare(x, evflag)`は、変数xに`evflag`プロパティを与えます。

  デフォルトで`evflag`プロパティを持つフラグは以下の通りです:

         algebraic          cauchysum       demoivre
         dotscrules         %emode          %enumer
         exponentialize     exptisolate     factorflag
         float              halfangles      infeval
         isolate_wrt_times  keepfloat       letrat
         listarith          logabs          logarc
         logexpand          lognegint       lognumer
         m1pbranch          numer_pbranch   programmode
         radexpand          ratalgdenom     ratfac
         ratmx              ratsimpexpons   simp
         simpproduct        simpsum         sumexpand
         trigexpand

  例:

      (%i1) sin (1/2);
                                       1
      (%o1)                        sin(-)
                                       2
      (%i2) sin (1/2), float;
      (%o2)                   0.479425538604203
      (%i3) sin (1/2), float=true;
      (%o3)                   0.479425538604203
      (%i4) simp : false;
      (%o4)                         false
      (%i5) 1 + 1;
      (%o5)                         1 + 1
      (%i6) 1 + 1, simp;
      (%o6)                           2
      (%i7) simp : true;
      (%o7)                         true
      (%i8) sum (1/k^2, k, 1, inf);
                                  inf
                                  ====
                                  \     1
      (%o8)                        >    --
                                  /      2
                                  ====  k
                                  k = 1
      (%i9) sum (1/k^2, k, 1, inf), simpsum;
                                       2
                                    %pi
      (%o9)                         ----
                                     6
      (%i10) declare (aa, evflag);
      (%o10)                        done
      (%i11) if aa = true then YES else NO;
      (%o11)                         NO
      (%i12) if aa = true then YES else NO, aa;
      (%o12)                         YES

  Evaluation flags ·Simplification flags and variables ·

プロパティ: evfun

  関数Fが`evfun`プロパティを持つ時、 式`ev(expr, F)`や（対話プロンプトでの）`expr, F`は、 `F(ev(expr))`と同値です。

  もし２つ以上の`evfun`関数F, Gなどが指定されたなら、関数は指定された順に適用されます。

  式`declare(F, evfun)`は、関数Fに`evfun`プロパティを与えます。

  デフォルトで`evfun`プロパティを持つ関数は以下の通りです:

         bfloat          factor       fullratsimp
         logcontract     polarform    radcan
         ratexpand       ratsimp      rectform
         rootscontract   trigexpand   trigreduce

  例:

      (%i1) x^3 - 1;
                                    3
      (%o1)                        x  - 1
      (%i2) x^3 - 1, factor;
                                      2
      (%o2)                 (x - 1) (x  + x + 1)
      (%i3) factor (x^3 - 1);
                                      2
      (%o3)                 (x - 1) (x  + x + 1)
      (%i4) cos(4 * x) / sin(x)^4;

                                  cos(4 x)
      (%o4)                       --------
                                     4
                                  sin (x)

      (%i5) cos(4 * x) / sin(x)^4, trigexpand;
                       4           2       2         4
                    sin (x) - 6 cos (x) sin (x) + cos (x)
      (%o5)         -------------------------------------
                                      4
                                   sin (x)
      (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
                                 2         4
                            6 cos (x)   cos (x)
      (%o6)               - --------- + ------- + 1
                                2          4
                             sin (x)    sin (x)
      (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
                                 2         4
                            6 cos (x)   cos (x)
      (%o7)               - --------- + ------- + 1
                                2          4
                             sin (x)    sin (x)
      (%i8) declare ([F, G], evfun);
      (%o8)                         done
      (%i9) (aa : bb, bb : cc, cc : dd);
      (%o9)                          dd
      (%i10) aa;
      (%o10)                         bb
      (%i11) aa, F;
      (%o11)                        F(cc)
      (%i12) F (aa);
      (%o12)                        F(bb)
      (%i13) F (ev (aa));
      (%o13)                        F(cc)
      (%i14) aa, F, G;
      (%o14)                      G(F(cc))
      (%i15) G (F (ev (aa)));
      (%o15)                      G(F(cc))

  Evaluation flags ·

オプション変数: infeval

  「無限評価」モードにします。`ev`は、値が変わらなくなるまで式を繰り返し評価します。 このモードで変数(`X`とします）が評価されることを避けるには、単に`X='X`を`ev`の引数として含めます。 `ev (X, X=X+1, infeval)`のような式は、もちろん、無限ループを引き起こします。

  Evaluation flags ·

特殊シンボル: noeval

  `noeval`は、`ev`の評価フェイズを抑制します。 これは、他のスイッチとの関連や、 式を再評価することなしに再整理するのに役に立ちます。

  Evaluation flags ·

特殊シンボル: nouns

  `nouns`は`evflag`の１つです。 `ev`コマンドのオプションとして使われる時、 `nouns`は、式の中に現れる「名詞」形すべてを「動詞」に`ev`します。すなわち、それらを評価します。 `noun`, `nounify`, `verb`, `verbify`も参照してください。

  Evaluation flags ·Nouns and verbs ·

特殊シンボル: pred

  `ev (expr)`のコールでの引数として、 `pred`は、 述語論理(`true`または`false`に評価される式)を評価するようにします。 `ev`を参照してください。

  例:

      (%i1) 1<2;
      (%o1)                                1 < 2
      (%i2) 1<2,pred;
      (%o2)                                true

  Evaluation flags ·

Next: Mathematical Functions, Previous: Evaluation, Up: Top [Contents][Index]

## 9 Simplification

Previous: Simplification, Up: Simplification [Contents][Index]

### 9.1 Functions and Variables for Simplification

キーワード: additive

  もし`declare(f, additive)`が実行されると:

  (1) もし`f`が1変数関数なら、`f`が和に適用された時はいつでも、 `f`は和の上に分配整理されます。 例えば、`f(y+x)`は、`f(y)+f(x)`に整理されます。

  (2) もし`f`が2変数以上の関数なら、 `sum`や`integrate`の場合と同様に 加法性が第一番目の引数に対して定義されます。 例えば、`f(h(x)+g(x),x)`は`f(h(x),x)+f(g(x),x)`に整理されます。 `f`が`sum(x[i],i,lower-limit,upper-limit)`の形の式に適用されたときには この整理はされません。

  Operators ·Declarations and inferences ·

宣言: antisymmetric

  もし`declare(h,antisymmetric)`が実行されると、 `h`は反対称として整理されます。 例えば、`h(x,z,y)`は`-h(x,y,z)`と整理されます。 即ち、`symmetric`か`commutative`で得られた結果に(-1)^nを掛けたものとなります。 ここで、nはその形に変換するのに必要な置換の回数です。

  Operators ·Declarations and inferences ·

関数: combine (expr)

  同じ分母を持つ項を単一の項に結合することによって和exprを整理します。

  Expressions ·

宣言: commutative

  もし`declare(h,commutative)`が実行されたなら、 `h`は可換関数として整理されます。 例えば、`h(x,z,y)`は`h(x,y,z)`に整理されます。 これは`symmetric`と同じです。

  Operators ·Declarations and inferences ·

関数: demoivre (expr)
オプション変数: demoivre

  関数`demoivre (expr)`は、 グローバル変数`demoivre`を設定することなしに式を変換します。

  変数`demoivre`が`true`の時、 複素数の指数関数は、円関数の項で表した同値な式に変換されます: もし`b`が`%i`を含まなければ、 `exp (a + b*%i)`は、`%e^a * (cos(b) + %i*sin(b))`に整理されます。 `a`と`b`は展開されません。

  `demoivre`のデフォルト値は`false`です。

  `exponentialize`は、円関数や双曲関数を指数関数形に変換します。 `demoivre`と`exponentialize`は、同時に両方trueにはできません。

  Complex variables ·Trigonometric functions ·Hyperbolic functions ·

関数: distrib (expr)

  和を積上に分配します。 式のトップレベルのみで働き、すなわち、再帰的でなく、 `expand`より速い点で、`expand`とは違います。 トップレベルの和すべてを展開する点で、`multthru`とは違います。

  例:

      (%i1) distrib ((a+b) * (c+d));
      (%o1)                 b d + a d + b c + a c
      (%i2) multthru ((a+b) * (c+d));
      (%o2)                 (b + a) d + (b + a) c
      (%i3) distrib (1/((a+b) * (c+d)));
                                      1
      (%o3)                    ---------------
                               (b + a) (d + c)
      (%i4) expand (1/((a+b) * (c+d)), 1, 0);
                                      1
      (%o4)                 ---------------------
                            b d + a d + b c + a c

  Expressions ·

オプション変数: distribute_over

  デフォルト値: `true`

  `distribute_over`は、 リストや行列や等式のようなバッグ(重複を許す集合)上の関数のマッピングを制御します。 今回、すべてのMaxima関数がこのプロパティを持つ訳ではありません。 このプロパティはコマンド`properties`で調べることが可能です。

  `distribute_over`を値`false`に設定した時、 関数のマッピングはオフにスイッチされます。

  例:

  `sin`関数はリスト上にマップします:

      (%i1) sin([x,1,1.0]);
      (%o1)                 [sin(x), sin(1), .8414709848078965]

  `mod`は リスト上にマップされる２変数関数です。 入れ子のリスト上のマッピングも可能です:

      (%i2) mod([x,11,2*a],10);
      (%o2)                    [mod(x, 10), 1, 2 mod(a, 5)]
      (%i3) mod([[x,y,z],11,2*a],10);
      (%o3)       [[mod(x, 10), mod(y, 10), mod(z, 10)], 1, 2 mod(a, 5)]

  `floor`関数の行列や等式上のマッピング:

      (%i4) floor(matrix([a,b],[c,d]));
                                  [ floor(a)  floor(b) ]
      (%o4)                       [                    ]
                                  [ floor(c)  floor(d) ]
      (%i5) floor(a=b);
      (%o5)                         floor(a) = floor(b)

  １変数以上の関数は、任意の引数上、または、すべての引数上にマップします:

      (%i6) expintegral_e([1,2],[x,y]);
      (%o6) [[expintegral_e(1, x), expintegral_e(1, y)],
             [expintegral_e(2, x), expintegral_e(2, y)]]

  関数がプロパティdistribute_overを持つかチェックします:

      (%i7) properties(abs);
      (%o7) [integral, distributes over bags, noun, rule, gradef]

  Simplification flags and variables ·

オプション変数: domain

  デフォルト値: `real`

  `domain`が`complex`に設定されている時、 `sqrt (x^2)`は、`abs(x)`を返さず、`sqrt (x^2)` のままを保ちます。

  Simplification flags and variables ·

宣言: evenfun
宣言: oddfun

  `declare(f, evenfun`や `declare(f, oddfun`は 関数 `f`を奇関数か偶関数として認識するように指示します。

  例:

      (%i1) o (- x) + o (x);
      (%o1)                     o(x) + o(- x)
      (%i2) declare (o, oddfun);
      (%o2)                         done
      (%i3) o (- x) + o (x);
      (%o3)                           0
      (%i4) e (- x) - e (x);
      (%o4)                     e(- x) - e(x)
      (%i5) declare (e, evenfun);
      (%o5)                         done
      (%i6) e (- x) - e (x);
      (%o6)                           0

関数: expand (expr)
関数: expand (expr, p, n)

  式exprを展開します。 指数和や和の積の積を実行し、有理式の分子をそれぞれの項に分割し、 （可換、非可換な）積がexprのすべてのレベルの和で分配されます。

  多項式の場合、もっと効率的なアルゴリズムの`ratexpand`を普通使うべきです。

  `maxnegex`と`maxposex`はそれぞれ、展開される最大の負と正の指数を制御します。

  `expand (expr, p, n)`は、 exprを、`maxposex`にpを`maxnegex`にnを使って展開します。 これは、式のすべてではなく、一部を展開するために役立ちます。

  `expon` - 自動的に展開される最大の負のべきの指数（`expand`のコールに独立して）。 例えば、もしも`expon`が4なら`(x+1)^(-5)`は自動では展開されません。

  `expop` - 自動的に展開される最大の正の指数。 もし`expop`が3以上なら、`(x+1)^3`は自動的に展開されます。 もし`n`が`expop`よりも大きい時`(x+1)^n`が展開されるのが望まれるなら、 `maxposex`が`n`より小さくない場合のみ、`expand ((x+1)^n)`の実行が行われます。

  `ev`で使われる`expand`フラグによって展開が実行されます。

  ファイル`share/simplification/facexp.mac`は、 ユーザーに制御された展開によって式を構成する機能を提供するいくつかの関連関数 （特に自動ロードされる`facsum`, `factorfacsum`と`collectterms`）と 変数(`nextlayerfactor`と`facsum_combine`)を含みます。 簡単な関数の記述が`simplification/facexp.usg`にあります。 `demo("facexp")`でデモが実行できます。

  例:

      (%i1) expr:(x+1)^2*(y+1)^3;
                                     2        3
      (%o1)                   (x + 1)  (y + 1)
      (%i2) expand(expr);
             2  3        3    3      2  2        2      2      2
      (%o2) x  y  + 2 x y  + y  + 3 x  y  + 6 x y  + 3 y  + 3 x  y
                                                            2
                                           + 6 x y + 3 y + x  + 2 x + 1
      (%i3) expand(expr,2);
                     2        3              3          3
      (%o3)         x  (y + 1)  + 2 x (y + 1)  + (y + 1)
      (%i4) expr:(x+1)^-2*(y+1)^3;
                                         3
                                  (y + 1)
      (%o4)                       --------
                                         2
                                  (x + 1)
      (%i5) expand(expr);
                  3               2
                 y             3 y            3 y             1
      (%o5) ------------ + ------------ + ------------ + ------------
             2              2              2              2
            x  + 2 x + 1   x  + 2 x + 1   x  + 2 x + 1   x  + 2 x + 1
      (%i6) expand(expr,2,2);

                                         3
                                  (y + 1)
      (%o6)                     ------------
                                 2
                                x  + 2 x + 1

  展開なしに式を再整理します:

      (%i7) expr:(1+x)^2*sin(x);
                                             2
      (%o7)                           (x + 1)  sin(x)
      (%i8) exponentialize:true;
      (%o8)                                true
      (%i9) expand(expr,0,0);
                                         2    %i x     - %i x
                               %i (x + 1)  (%e     - %e      )
      (%o9)                  - -------------------------------
                                              2

  Expressions ·

関数: expandwrt (expr, x_1, ..., x_n)

  式`expr`を、変数x_1, ..., x_nに関して展開します。 変数を含む積すべては陽に現れます。 返される形式は、変数を含む式の和の積を含みません。 x_1, ..., x_nは、変数、演算子、式であり得ます。

  デフォルトでは、分母は展開されませんが、これは、スイッチ`expandwrt_denom`によって 制御することができます。

  この関数は`simplification/stopex.mac`から自動ロードされます。

  Expressions ·

オプション変数: expandwrt_denom

  デフォルト値: `false`

  `expandwrt_denom`は、`expandwrt`によって有理式の扱いを制御します。 もし`true`なら、式の分子も分母も`expandwrt`の引数に従って展開されますが、 もし`expandwrt_denom`が`false`なら、分子だけがその方法で展開されます。

  Expressions ·

関数: expandwrt_factored (expr, x_1, ..., x_n)

  `expandwrt`に似ていますが、積の式を幾分違って扱います。 `expandwrt_factored`は、`expr`の、 変数x_1, ..., x_nを含む因子上でだけ展開します。

  この関数は、`simplification/stopex.mac`から自動ロードされます。

  Expressions ·

オプション変数: expon

  デフォルト値: 0

  `expon`は、(`expand`のコールに依らず)自動的に展開される負のべき乗の最大指数です。 例えば、 もし`expon`が4なら、 `(x+1)^(-5)`は自動的には展開されません。

  Expressions ·

関数: exponentialize (expr)
オプション変数: exponentialize

  関数`exponentialize (expr)`は、 exprの中の円関数や双曲関数を指数関数に変換します。 グローバル変数`exponentialize`を設定する必要はありません。

  変数`exponentialize`が`true`の時、 円関数や双曲関数すべては指数関数形に変換されます。 デフォルト値は`false`です。

  `demoivre`は複素数の指数関数を円関数に変換します。 `exponentialize`や`demoivre`は同時にtrueにすることはできません。

  Complex variables ·Trigonometric functions ·Hyperbolic functions ·

オプション変数: expop

  デフォルト値: 0

  `expop`は、自動的に展開される最高の正の指数です。 例えば、`(x + 1)^3`が入力された時、 `expop`が3以下の時だけ自動的に展開されます。 もし、`n`が`expop`より大きい`(x + 1)^n`が展開されることを望むなら、 `expand ((x + 1)^n)`の実行は、 `maxposex`がn以上の時だけ機能します。

  Expressions ·

宣言: lassociative

  `declare (g, lassociative)`は、 Maximaの整理器に `g`が左結合であることを告げます。 例えば、`g (g (a, b), g (c, d))`は`g (g (g (a, b), c), d)`に整理されます。

  Declarations and inferences ·Operators ·Simplification ·

宣言: linear

  Maximaの演算子のプロパティの１つ。 そう宣言された1変数関数`f`に関して、 "expansion" `f(x + y)`は`f(x) + f(y)`を出力し、 `a`が定数の`f(a*x)`は、`a*f(x)`を出力します。 ２つ以上の引数の関数に関しては、 「線形性」は、`sum`や`integrate`の場合のように定義されます。 すなわち、`a`と`b`が`x`に独立の場合， `f (a*x + b, x)`は`a*f(x,x) + b*f(1,x)`を出力します。

  `linear`は、`additive`かつ`outative`と同値です。 `opproperties`も参照してください。

  Declarations and inferences ·Operators ·Simplification ·

オプション変数: maxnegex

  デフォルト値: 1000

  `maxnegex`は、 `expand`コマンドによって展開される最大の負の指数です。 （`maxposex`)も参照してください。）

  Expressions ·

オプション変数: maxposex

  デフォルト値: 1000

  `maxposex`は、 `expand`コマンドで展開される最大指数です。 （`maxnegex`)も参照してください。）

  Expressions ·

宣言: multiplicative

  `declare (f, multiplicative)`は、Maxima整理器に `f`が乗法的であることを告げます。

  1. もし`f`が１変数関数なら、 整理器が積に適用された`f`に出会うといつでも、 `f`はその積上に分配されます。 例えば、`f(x*y)`は`f(x)*f(y)`に整理されます。
  2. もし`f`が多変数関数なら、 乗法性は、`f`の最初の引数の乗法性として定義されます。 例えば、 `f (g(x) * h(x), x)`は、`f (g(x) ,x) * f (h(x), x)`に整理されます。

  この式整理は、`f`が`product (x[i], i, m, n)`の形の式に適用された時にはなされません。

  Declarations and inferences ·Expressions ·Simplification ·

関数: multthru (expr)
関数: multthru (expr_1, expr_2)

  exprの（和の）因子にexprの他の因子を掛ける。 すなわち、exprは`f_1 f_2 ... f_n`です。 ここで、少なくとも１つの因子、f_iとしましょう、は項の和です。 この和の各項に、積の中の他の因子を掛けます。 （すなわち、f_iを除いた因子すべてです。） `multthru`は、指数化された和を展開しません。 この関数は、（可換であれ非可換であれ）積を和上に分配する最も速い方法です。 割り算は積として表現されるので、 `multthru`は積によって和を割ることにも使うことができます。

  `multthru (expr_1, expr_2)`は、 （和もしくは等式の）expr_2の中の各項にexpr_1を掛けます。 もしexpr_1がそれ自身和でなければ、 この形式は`multthru (expr_1*expr_2)`と同値です。

      (%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3;
                            1        x         f(x)
      (%o1)             - ----- + -------- - --------
                          x - y          2          3
                                  (x - y)    (x - y)
      (%i2) multthru ((x-y)^3, %);
                                 2
      (%o2)             - (x - y)  + x (x - y) - f(x)
      (%i3) ratexpand (%);
                                 2
      (%o3)                   - y  + x y - f(x)
      (%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2);
                              10  2              2  2
                       (b + a)   s  + 2 a b s + a  b
      (%o4)            ------------------------------
                                        2
                                   a b s
      (%i5) multthru (%);  /* note that this does not expand (b+a)^10 */
                                              10
                             2   a b   (b + a)
      (%o5)                  - + --- + ---------
                             s    2       a b
                                 s
      (%i6) multthru (a.(b+c.(d+e)+f));
      (%o6)            a . f + a . c . (e + d) + a . b
      (%i7) expand (a.(b+c.(d+e)+f));
      (%o7)         a . f + a . c . e + a . c . d + a . b

  Expressions ·

宣言: nary

  `declare(f, nary)`はMaximaに 関数 `f`をn項関数として認識するよう指示します。

  `nary`宣言は `nary`関数をコールするのと同じではありません。 `declare(f, nary)`は唯一の効果は 例えば、 `foo(x, foo(y, z))`を `foo(x, y, z)`に整理するように 入れ子の式をフラットにするようMaxima整理器に指示することです。 `declare`.も参照してください。

  例:

      (%i1) H (H (a, b), H (c, H (d, e)));
      (%o1)               H(H(a, b), H(c, H(d, e)))
      (%i2) declare (H, nary);
      (%o2)                         done
      (%i3) H (H (a, b), H (c, H (d, e)));
      (%o3)                   H(a, b, c, d, e)

オプション変数: negdistrib

  デフォルト値: `true`

  `negdistrib`が`true`の時, -1が式上に分配されます。 例えば、`-(x + y)`は`- y - x`になります。 `false`に設定すると、`- (x + y)`はそのまま表示されることになるでしょう。 これは時々役に立ちますが、非常に注意してください; `simp`フラグ同様に、 当然のことながら、Maximaの中でローカルな使用以外には、 これは、`false`に設定したくないフラグの１つです。

  Simplification flags and variables ·

システム変数: opproperties

  `opproperties`は、Maximaの整理器が認識する特殊演算子プロパティのリストです: `linear`, `additive`, `multiplicative`, `outative`, `evenfun`, `oddfun`, `commutative`, `symmetric`, `antisymmetric`, `nary`, `lassociative`, `rassociative`.

  Global variables ·Operators ·

宣言: outative

  `declare (f, outative)`は、Maximaの整理器に `f`の引数の中の定数因子が外に出すことができることを告げます。

  1. もし`f`が1変数関数なら、 整理器が積に適用された`f`に出会うといつでも、その積は定数因子と、ていすうでない因子に分割され、定数因子が外に出されます。 例えば、`f(a*x)`は、`a`を定数とすると、`a*f(x)`に整理されます。 非アトムな定数因子は外に出されません。
  2. もし`f`が多変数関数なら、 outativityは、`sum`や`integrate`の場合のように定義されます。 すなわち、`f (a*g(x), x)`は、`a`が`x`に依らないとすると、 `a * f(g(x), x)`に整理されます。

  `sum`, `integrate`, `limit`はすべて`outative`です。

  Declarations and inferences ·Operators ·

関数: radcan (expr)

  対数関数、指数関数、累乗根を含むexprを、与えられ場変数の順序で式の大きなクラス上の標準形式に整理します; 関数的に同値な形式は特殊な形式にマップされます。 式の幾分大きなクラスのため、`radcan`は正規の形式を生成します。 このクラスの２つの式は、必ずしも、同じ結果ではありませんが、それらの差は`radcan`によって0に整理されます。

  いくつかの式のため、`radcan`は特殊な時間消費をします。 これは、因数分解や指数関数の部分分解展開に基づいた整理のための式のコンポーネントの間のある関係を探求するコストです。

  例:

      (%i1) radcan((log(x+x^2)-log(x))^a/log(1+x)^(a/2));
                                                 a/2
      (%o1)                            log(x + 1)

      (%i2) radcan((log(1+2*a^x+a^(2*x))/log(1+a^x)));
      (%o2)                                  2

      (%i3) radcan((%e^x-1)/(1+%e^(x/2)));
                                           x/2
      (%o3)                              %e    - 1

  Simplification functions ·

オプション変数: radexpand

  デフォルト値: `true`

  `radexpand`は、根号のいくつかの整理を制御します。

  `radexpand`が`all`の時 n乗の積の因子のn番目の根を根号の外に出すようにします。 例えば、もし`radexpand`が`all`なら、 `sqrt (16*x^2)`は`4*x`に整理されます。

  特に、`sqrt (x^2)`を考えます。

  - もし`radexpand`が`all`もしくは`assume (x > 0)`が実行されたなら、 `sqrt(x^2)`は`x`に整理されます。
  - もし`radexpand`が`true`、かつ`domain`が`real`(これはデフォルトです)なら、 `sqrt(x^2)`は`abs(x)`に整理されます。
  - もし`radexpand`が`false`、もしくは、`radexpand`が`true`かつ`domain`が`complex`なら、 `sqrt(x^2)`は整理されません。

  `domain`は、`radexpand`が`true`の時だけ意味を持つことに注意してください。

  Simplification flags and variables ·

宣言: rassociative

  `declare (g, rassociative)`は、 Maximaの整理器に `g`が右結合であることを告げます。 例えば、 `g(g(a, b), g(c, d))`は、`g(a, g(b, g(c, d)))`に整理されます。

  Declarations and inferences ·Operators ·

関数: scsimp (expr, rule_1, ..., rule_n)

  順次的な相対整理(Sequential Comparative Simplification) (Stouteによる方法)。 `scsimp`は、 規則rule_1, ..., rule_nに従って、 exprを整理しようとします。 もしより小さな式が得られたら、 プロセスは繰り返されます。 そうでなければ、すべての整理が試された後、 元の答えを返します。

  `example (scsimp)`はいくつかの例を表示します。

  Simplification functions ·

オプション変数: simp

  デフォルト値: `true`

  `simp`は整理を有効にします。 これは標準です。 `simp`は`evflag`でもあります。 それは関数`ev`に認識されます。`ev`を参照してください。

  `simp`が 値`false`で`evflag`として使われる時、 式の評価フェイズの間だけ 整理は抑制されます。 フラグは評価フェイズに続く整理を抑制できません。

  例:

  整理がグローバルにオフにスイッチされます。 式`sin(1.0)`は数値に整理されません。 `simp`-フラグは整理をオンにスイッチします。

      (%i1) simp:false;
      (%o1)                                false
      (%i2) sin(1.0);
      (%o2)                              sin(1.0)
      (%i3) sin(1.0),simp;
      (%o3)                          .8414709848078965

  整理が再びオンにスイッチされます。 `simp`-フラグは完全に整理を抑制できません。 割り当ては式の評価フェイズの間に起こるので、 出力は整理された式を示しますが、 変数`x`は、値として未整理の式を持ちます。

      (%i4) simp:true;
      (%o4)                                true
      (%i5) x:sin(1.0),simp:false;
      (%o5)                          .8414709848078965
      (%i6) :lisp $X
      ((%SIN) 1.0)

  Evaluation flags ·

宣言: symmetric

  `declare (h, symmetric)`は、Maximaの整理器に `h`が対称関数であることを告げます。 例えば、`h (x, z, y)`は`h (x, y, z)`に整理されます。

  `commutative`は`symmetric`と同義です。

  Declarations and inferences ·Operators ·

関数: xthru (expr)

  （和でなければいけない）exprのすべての項を、 共通分母上で、`ratsimp`がするように積や指数和を展開することなしに結合させます。 `xthru`は、因子が陽であるときだけ、有理式の分子と分母の共通因子を消去します。

  分子と分母の最大公約数の陽因子を消去するために、式を`ratsimp`する前に`xthru`を使うのがよい場合があります。

      (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;

                                      20
                       1       (x + 2)   - 2 y       x
      (%o1)        --------- + --------------- - ---------
                          19             20             20
                   (y + x)        (y + x)        (y + x)

      (%i2) xthru (%);
                                       20
                                (x + 2)   - y
      (%o2)                     -------------
                                         20
                                  (y + x)

  Expressions ·

Next: Maximas Database, Previous: Simplification, Up: Top [Contents][Index]

## 10 Mathematical Functions

Next: Functions for Complex Numbers, Previous: Mathematical Functions, Up: Mathematical Functions [Contents][Index]

### 10.1 Functions for Numbers

関数: abs (expr)

  exprの絶対値を返します。もしexprが複素数なら、exprの絶対値(modulus)を返します。

  `abs`はリスト上、行列上、等式上に分配されます。 `distribute_over`を参照してください。

  Mathematical functions ·

関数: ceiling (x)

  xが実数の時、x以上の最小の整数を返します。

  もしxが定数式(例えば`10 * %pi`)なら、 `ceiling`は、xを多倍長浮動小数点数を使って評価し、 その多倍長浮動小数点数に`ceiling`を適用します。 `ceiling`は浮動小数点を使うので、ほとんど起こりえませんが、 `ceiling`は定数入力に対して間違った値を返す可能性があります。 このエラーを起こさないようにするには、`fpprec`の３つの値を使って浮動小数点評価を行います。

  定数でない入力に関しては、`ceiling`は整理された値を返そうとします。 以下は、`ceiling`が知っている式整理の例です:

      (%i1) ceiling (ceiling (x));
      (%o1)                      ceiling(x)
      (%i2) ceiling (floor (x));
      (%o2)                       floor(x)
      (%i3) declare (n, integer)$
      (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
      (%o4)                [n, abs(n), max(n, 6)]
      (%i5) assume (x > 0, x < 1)$
      (%i6) ceiling (x);
      (%o6)                           1
      (%i7) tex (ceiling (a));
      $$\left \lceil a \right \rceil$$
      (%o7)                         false

  関数`ceiling`は、自動ではリストや行列上にマップしません。 最終的に、明らかに複雑な入力すべてに対して、`ceiling`は名詞形を返します。

  もし関数の範囲が整数の部分集合なら、 `integervalued`に宣言できます。 `ceiling`、`floor`関数両方とも、この情報を使います; 例えば:

      (%i1) declare (f, integervalued)$
      (%i2) floor (f(x));
      (%o2)                         f(x)
      (%i3) ceiling (f(x) - 1);
      (%o3)                       f(x) - 1

  Mathematical functions ·

関数: entier (x)

  xが数値の場合、x以下の最大の整数を返します。 （`fixnum`における）`fix`はこれの別名で、 `fix(x)`は正確に同じです。

  Mathematical functions ·

関数: floor (x)

  xが実数の時、x以下の最大の整数を返します。

  もしxが定数式(例えば`10 * %pi`)なら、 `floor`は、多倍長浮動小数点数を使ってxを評価し、 結果の多倍長浮動小数点に`floor`を適用します。 `floor`は浮動小数点を使うので、ほとんど起こりえませんが、 `floor`は定数入力に対して間違った値を返す可能性があります。 このエラーを起こさないようにするには、`fpprec`の３つの値を使って浮動小数点評価を行います。

  定数でない入力に関しては、`floor`は整理された値を返そうとします。 以下は、`ceiling`が知っている式整理の例です:

      (%i1) floor (ceiling (x));
      (%o1)                      ceiling(x)
      (%i2) floor (floor (x));
      (%o2)                       floor(x)
      (%i3) declare (n, integer)$
      (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))];
      (%o4)                [n, abs(n), min(n, 6)]
      (%i5) assume (x > 0, x < 1)$
      (%i6) floor (x);
      (%o6)                           0
      (%i7) tex (floor (a));
      $$\left \lfloor a \right \rfloor$$
      (%o7)                         false

  関数`floor`は、自動ではリストや行列上にマップしません。 最終的に、明らかに複雑な入力すべてに対して、`floor`は名詞形を返します。

  もし関数の範囲が整数の部分集合なら、 `integervalued`に宣言できます。 `ceiling`、`floor`関数両方とも、この情報を使います; 例えば:

      (%i1) declare (f, integervalued)$
      (%i2) floor (f(x));
      (%o2)                         f(x)
      (%i3) ceiling (f(x) - 1);
      (%o3)                       f(x) - 1

  Mathematical functions ·

関数: fix (x)

  `entier (x)`の別名です。

  Mathematical functions ·

関数: lmax (L)

  Lがリストもしくは集合の時、`apply ('max, args (L))`を返します。 Lがリストでも集合でもない時、エラーを示します。

  Mathematical functions ·Lists ·Sets ·

関数: lmin (L)

  Lがリストもしくは集合の時、`apply ('min, args (L))`を返します。 Lがリストでも集合でもない時、エラーを示します。

  Mathematical functions ·Lists ·Sets ·

関数: max (x_1, ..., x_n)

  式x_1からx_nの中の最大値に関して整理された値を返します。 `get (trylevel, maxmin)`が２以上の時、 `max`は、式整理`max (e, -e) --> |e|`を使います。 `get (trylevel, maxmin)`が３以上の時、 maxは、２つの他の引数の間の式を消去しようとします; 例えば、`max (x, 2*x, 3*x) --> max (x, 3*x)`。 `trylevel`を2に設定するには、`put (trylevel, 2, maxmin)`を使います。

  Mathematical functions ·

関数: min (x_1, ..., x_n)

  式x_1からx_nの中の最小値に関して整理された値を返します。 `get (trylevel, maxmin)`が２以上の時、 `max`は、式整理`max (e, -e) --> |e|`を使います。 `get (trylevel, maxmin)`が３以上の時、 maxは、２つの他の引数の間の式を消去しようとします; 例えば、`max (x, 2*x, 3*x) --> max (x, 3*x)`。 `trylevel`を2に設定するには、`put (trylevel, 2, maxmin)`を使います。

  `max`や `lmin`.も参照してください。

  Mathematical functions ·

関数: round (x)

  xが実数の時、xに最も近い整数を返します。 1/2を掛けてroundして2を掛けると、最も近い偶数に丸められます。 xの評価は、`floor`や`ceiling`に似ています。

  Mathematical functions ·

関数: signum (x)

  実数か複素数xに対して、もしxが0ならsignum関数は0を返します; 非ゼロ数値入力xに対して、signum関数は`abs(x)/x`を返します。

  非数値入力に対して、Maximaは入力の符号を決定しようと試みます。 符号が負、ゼロ、正いずれかの時、`signum`はそれぞれ、-1, 0, 1を返します。 符号に関する他の値すべてに対して、`signum`は式整理された同値形を返します。 式整理は(`signum(-x)`は`-signum(x)`を与える)反転と (`signum(x*y)`は`signum(x) * signum(y)`を与える)乗法恒等式を含みます。

  `signum`関数はリスト、行列もしくは等式上に分配されます。 `distribute_over`を参照してください。

  Mathematical functions ·

Next: Combinatorial Functions, Previous: Functions for Numbers, Up: Mathematical Functions [Contents][Index]

### 10.2 Functions for Complex Numbers

関数: cabs (expr)

  exprの複素数の絶対値を返します。

  Complex variables ·

関数: carg (z)

  zの複素偏角を返します。 複素偏角は、 `r exp (theta %i) = z`（`r`はzの絶対値）を満たす `(-%pi, %pi]`の間の角`theta`です。

  `carg`は、計算関数であって、式整理関数ではありません。

  `abs` (複素絶対値), `polarform`, `rectform`, `realpart`, `imagpart`も参照してください。

  例:

      (%i1) carg (1);
      (%o1)                           0
      (%i2) carg (1 + %i);
                                     %pi
      (%o2)                          ---
                                      4
      (%i3) carg (exp (%i));
      (%o3)                           1
      (%i4) carg (exp (%pi * %i));
      (%o4)                          %pi
      (%i5) carg (exp (3/2 * %pi * %i));
                                      %pi
      (%o5)                         - ---
                                       2
      (%i6) carg (17 * exp (2 * %i));
      (%o6)                           2

  Complex variables ·

関数: conjugate (x)

  xの複素共役を返します。

      (%i1) declare ([aa, bb], real, cc, complex, ii, imaginary);

      (%o1)                         done
      (%i2) conjugate (aa + bb*%i);

      (%o2)                      aa - %i bb
      (%i3) conjugate (cc);

      (%o3)                     conjugate(cc)
      (%i4) conjugate (ii);

      (%o4)                         - ii
      (%i5) conjugate (xx + yy);

      (%o5)             conjugate(yy) + conjugate(xx)

  Complex variables ·

関数: imagpart (expr)

  式exprの虚部を返します。

  `imagpart`は、計算関数であり、整理関数ではありません。

  `abs`, `carg`, `polarform`, `rectform`, `realpart`も 参照してください。

  Complex variables ·

関数: polarform (expr)

  exprと同値な式`r %e^(%i theta)`を返します。 ここで、`r`と`theta`は純粋な実数です。

  Complex variables ·Exponential and logarithm functions ·

関数: realpart (expr)

  exprの実部を返します。 `realpart`と`imagpart`は、 平方根、対数関数、指数関数はもちろん三角関数や双曲関数を含む式上で機能します。

  Complex variables ·

関数: rectform (expr)

  exprと同値な式`a + b %i`を返します。 ここでaとbは純粋な実数です。

  Complex variables ·

Next: Root Exponential and Logarithmic Functions, Previous: Functions for Complex Numbers, Up: Mathematical Functions [Contents][Index]

### 10.3 Combinatorial Functions

演算子: !!

  二重階乗演算子。

  整数や浮動小数点、有理数 `n`に対して、 `n!!`は、 積 `n (n-2) (n-4) (n-6) ... (n - 2 (k - 1))` （`k`は `entier (n/2)`、すなわち `n/2`以下の最大整数に等しい）に評価します。 この定義は、非整数の引数に対して他の出版物の定義と一致しないことに注意してください。

  偶数(もしくは奇数) `n`に対して、 `n!!`は、2(もしくは1)からnまでのすべての偶数 (もしくは奇数)の積に評価されます。

  整数でも浮動小数点でも有理数でもない引数 `n`に対して、 `n!!`は名詞形 `genfact (n, n/2, 2)`を返します。

  Gamma and factorial functions ·Operators ·

関数: binomial (x, y)

  二項係数`x!/(y! (x - y)!)`。 もしxとyが整数なら、 二項係数の数値が計算されます。 もしyもしくはx - yが整数なら、 二項係数は多項式として表現されます。

  例:

      (%i1) binomial (11, 7);
      (%o1)                          330
      (%i2) 11! / 7! / (11 - 7)!;
      (%o2)                          330
      (%i3) binomial (x, 7);
              (x - 6) (x - 5) (x - 4) (x - 3) (x - 2) (x - 1) x
      (%o3)   -------------------------------------------------
                                    5040
      (%i4) binomial (x + 7, x);
            (x + 1) (x + 2) (x + 3) (x + 4) (x + 5) (x + 6) (x + 7)
      (%o4) -------------------------------------------------------
                                     5040
      (%i5) binomial (11, y);
      (%o5)                    binomial(11, y)

  Number theory ·

関数: factcomb (expr)

  例えば、`(n + 1)*n!`を`(n + 1)!`に変換することによって、 exprの中の階乗の係数を階乗それ自身と結合しようとします。

  もし`sumsplitfact`が`false`に設定されたなら、 `minfactorial`が`factcomb`の後適用されるようになります。

  Gamma and factorial functions ·

関数: factorial
演算子: !

  階乗演算子。

  （整数、有理数、実数を含む）負の整数を除いた任意の複素数 `x`に対して、 `x!`は `gamma(x+1)`として定義されます。

  整数 `x`に対して、 `x!`は1からxまでの整数の積に整理されます。 `0!`は1に整理されます。 浮動小数点または多倍長浮動小数点精度の実数または複素数 `x`に対して、 `x!`は `gamma(x+1)`の値に整理されます。 `x`が `n/2`（`n`は奇数）に等しい時、 （`gamma (1/2)`は`sqrt (%pi)`に等しいから） `x!`は有理因子に`sqrt (%pi)`を掛けたものに整理されます。

  変数 `factlim`, `gammalim`は整数や有理数の引数の階乗の数値評価を制御します。 関数 `minfactorial`, `factcomb`は階乗を含む式の整理を制御します。 `factlim`, `gammalim`, `minfactorial`, `factcomb`を参照してください。

  関数 `gamma`, `bffac`, `cbffac`はガンマ関数の変形です。 多倍長浮動小数点精度の実数と複素数のガンマ関数を評価するために、 `gamma`は内部で `bffac`や `cbffac`をコールします。

  `makegamma`は階乗や関係した関数に`gamma`を代入します。

  Maximaは階乗関数の導関数や、負の整数のような特殊な値の極限を知っています。

  オプション変数 `factorial_expand`は `(n+x)!`のような式の整理を制御します。 ここで`n`は整数です。

  `binomial`も参照してください。

  オペランドが`factlim`より大きくないなら、整数の階乗は正確な値に整理されます。 実数と複素数の階乗は浮動小数点または多倍長浮動小数点精度に評価されます。

      (%i1) factlim : 10;
      (%o1)                          10
      (%i2) [0!, (7/2)!, 8!, 20!];

                                  105 sqrt(%pi)
      (%o2)                   [1, -------------, 40320, 20!]
                                       16

      (%i3) [4.77!, (1.0+%i)!];
      (%o3)    [81.44668037931197,
                .3430658398165454 %i + .6529654964201665]
      (%i4) [2.86b0!, (1.0b0+%i)!];
      (%o4) [5.046635586910012b0,
             3.430658398165454b-1 %i + 6.529654964201667b-1]

  既知の定数や一般式の階乗は整理されません。 オペランドを評価した後階乗を整理できたとしても整理はされません。

      (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
      (%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
      (%i2) ev (%, numer, %enumer);
      (%o2) [.3430658398165454 %i + .6529654964201665,
             7.188082728976031,
             4.260820476357003, 1.227580202486819]

      (%i1) kill (foo);
      (%o1)                         done
      (%i2) foo!;
      (%o2)                         foo!

  階乗の計算は整理であって、評価ではありません。 従って、`x!`はクォートされた式の中でも置き換えられます。

      (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
                105 sqrt(%pi)
      (%o1) [1, -------------, 81.44668037931199, 40320,
                     16
                                                   2432902008176640000]

  Maximaは階乗関数の導関数を知っています。

      (%i1) diff(x!,x);
      (%o1)                           x! psi (x + 1)
                                            0

  オプション変数`factorial_expand`は、 階乗関数を含む式の展開と整理を制御します。

      (%i1) (n+1)!/n!,factorial_expand:true;
      (%o1)                                n + 1

  Gamma and factorial functions ·Operators ·

オプション変数: factlim

  デフォルト値: -1

  `factlim`は、自動的に展開される最高の階乗を指定します。 もし-1なら、すべての整数は展開されます。

  Gamma and factorial functions ·

オプション変数: factorial_expand

  デフォルト値: false

  オプション変数`factorial_expand`は `(n+1)!`のような式の整理を制御します。 ここで`n`は整数です。 例は`!`を参照してください。

  Gamma and factorial functions ·

関数: genfact (x, y, z)

  一般化された階乗を返します。 `x (x-z) (x - 2 z) ... (x - (y - 1) z)`のように定義されます。 それゆえに、整数xに関して、 `genfact (x, x, 1) = x!`であり、`genfact (x, x/2, 2) = x!!`です。

  Gamma and factorial functions ·

関数: minfactorial (expr)

  整数だけ違う２つの階乗の出現に関して exprを検査します。 そして、`minfactorial`は、 一方を多項式掛ける他方に変えます。

      (%i1) n!/(n+2)!;
                                     n!
      (%o1)                       --------
                                  (n + 2)!
      (%i2) minfactorial (%);
                                      1
      (%o2)                    ---------------
                               (n + 1) (n + 2)

  Number theory ·

オプション変数: sumsplitfact

  デフォルト値: `true`

  `sumsplitfact`が`false`の時、 `minfactorial`は、`factcomb`の後に適用されます。

  Gamma and factorial functions ·Simplification flags and variables ·

Next: Trigonometric Functions, Previous: Combinatorial Functions, Up: Mathematical Functions [Contents][Index]

### 10.4 Root, Exponential and Logarithmic Functions

オプション変数: %e_to_numlog

  デフォルト値: `false`

  `true`の時、 `r`をある有理数、`x`をある式とすると、 `%e^(r*log(x))`は`x^r`に整理されます。 `radcan`コマンドもこの変換を行い、その上この同類のさらに複雑な変換をすることに注意すべきです。 `logcontract`コマンドは`log`を含む式を「短縮」します。

  Exponential and logarithm functions ·Simplification flags and variables ·

オプション変数: %emode

  デフォルト値: `true`

  `%emode`が`true`の時、 `%e^(%pi %i x)`は以下のように整理されます。

  もし`x`が浮動小数点、整数、もしくは1/2, 1/3, 1/4, 1/6の整数倍なら、 `%e^(%pi %i x)`は`cos (%pi x) + %i sin (%pi x)`に整理された後、 さらに整理されます。

  他の数値`x`に関して、 `%e^(%pi %i x)`は、`%e^(%pi %i y)`に整理されます。 ここで`y`は`x - 2 k`（`k`は`abs(y) < 1`が成り立つような整数）です。

  `%emode`が`false`の時には、 `%e^(%pi %i x)`の特別な整理は実行されません。

  Exponential and logarithm functions ·Simplification flags and variables ·

オプション変数: %enumer

  デフォルト値: `false`

  `%enumer`が`true`の時、 `numer`が`true`の時はいつでも、 `%e`は数値2.718...に置き換えられます。

  `%enumer`が`false`の時、 `%e^x`の指数が数に評価される時だけ、 この代入が実行されます。

  `ev`, `numer`も参照してください。

  Exponential and logarithm functions ·Evaluation flags ·

関数: exp (x)

  指数関数を表します。 入力にある`exp (x)`のインスタンスは、`%e^x`に整理されます; `exp`は整理された式の中には現れません。

  もし`demoivre`が`true`で、かつ、 `b`が`%i`を含まないなら、 `%e^(a + b %i)`は`%e^(a (cos(b) + %i sin(b)))`に整理されます。 `demoivre`を参照してください。

  `%emode`が`true`の時、 `%e^(%pi %i x)`は整理されます。 `%emode`を参照してください。

  `%enumer`が`true`の時、 `numer`が`true`の時にはいつでも `%e`は2.718...に置き換えれます。 `%enumer`を参照してください。

  Exponential and logarithm functions ·

関数: li [s] (z)

  次数s、引数zの多重対数関数を表します。 これは、以下の無限級数で定義されます。

                                       inf
                                       ====   k
                                       \     z
                              Li (z) =  >    --
                                s      /      s
                                       ====  k
                                       k = 1

  `li [1]`は、`- log (1 - z)`です。 `li [2]`と`li [3]`は、それぞれ、dilogarithm関数、trilogarithm関数です。

  次数が1の時、多重対数関数は`- log (1 - z)`に整理され、 もしzが実数もしくは複素数の浮動小数点数、もしくは、`numer`評価フラグが有効なら、さらに数値に整理されます。

  次数が2もしくは3の時、 もしzが実数の浮動小数点数、もしくは`numer`評価フラグが有効なら、 多重対数関数は数値に整理されます。

  例:

      (%i1) assume (x > 0);
      (%o1)                        [x > 0]
      (%i2) integrate ((log (1 - t)) / t, t, 0, x);
      (%o2)                       - li (x)
                                      2
      (%i3) li [2] (7);
      (%o3)                        li (7)
                                     2
      (%i4) li [2] (7), numer;
      (%o4)        1.24827317833392 - 6.113257021832577 %i
      (%i5) li [3] (7);
      (%o5)                        li (7)
                                     3
      (%i6) li [2] (7), numer;
      (%o6)        1.24827317833392 - 6.113257021832577 %i
      (%i7) L : makelist (i / 4.0, i, 0, 8);
      (%o7)   [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
      (%i8) map (lambda ([x], li [2] (x)), L);

      (%o8) [0, .2676526384986274, .5822405249432515,
      .9784693966661848, 1.64493407, 2.190177004178597
       - .7010261407036192 %i, 2.374395264042415
       - 1.273806203464065 %i, 2.448686757245154
       - 1.758084846201883 %i, 2.467401098097648
       - 2.177586087815347 %i]

      (%i9) map (lambda ([x], li [3] (x)), L);
      (%o9) [0, .2584613953442624, 0.537213192678042,
      .8444258046482203, 1.2020569, 1.642866878950322
       - .07821473130035025 %i, 2.060877505514697
       - .2582419849982037 %i, 2.433418896388322
       - .4919260182322965 %i, 2.762071904015935
       - .7546938285978846 %i]

  Exponential and logarithm functions ·

関数: log (x)

  xの自然対数（基数eの対数）を表します。

  Maximaは、基数10や他の基数の対数の組み込み関数を持ちません。 `log10(x) := log(x) / log(10)`は、役立つ定義です。

  対数の整理と評価は、いくつかのグローバルフラグによって管理されます:

  ``logexpand``

    `log(a^b)`を`b*log(a)`にします。 もし`all`に設定されているなら、 `log(a*b)`も`log(a)+log(b)`に整理されます。 もし`super`に設定されているなら, 有理数`a/b`ただし`a#1`について`log(a/b)`も`log(a)-log(b)`に整理されます。 (整数`b`に関して`log(1/b)`はいつも整理されます。) もし`false`に設定されているなら、 これらのすべての整理は止められます。

  ``logsimp``

    もし`false`なら、 `%e`は、`log`を含む累乗へ整理がなされます。

  ``lognumer``

    もし`true`なら、 引数は、`log`の計算の前に絶対値に変換されます。 もし`numer`も`true`なら、 `log`の引数に負の整数を与えたとき、 引数は、`log`の計算の前に絶対値に変換されます。

  ``lognegint``

    もし`true`なら、正の整数`n`に対して規則 `log(-n)` -> `log(n)+%i*%pi` が実装されます。

  ``%e_to_numlog``

    `true`の時、 `r`をある有理数、`x`をある式とすると、 式`%e^(r*log(x))`は`x^r`に整理されます。 `radcan`コマンドもこの変換を行い、その上この同類のさらに複雑な変換をすることに注意すべきです。 `logcontract`コマンドは`log`を含む式を「短縮」します。

  Exponential and logarithm functions ·

オプション変数: logabs

  デフォルト値: `false`

  例えば`integrate(1/x,x)`のように、logが生成される不定積分を実行する時、 もし`logabs`が`true`なら もし`logabs`が`false`なら 答えは、`log(...)`の形で与えられます。 定積分については、 終端での不定積分の「評価」がしばしば必要になるので、`logabs:true`設定が使われます。

  Exponential and logarithm functions ·Integral calculus ·Global flags ·

オプション変数: logarc
関数: logarc (expr)

  グローバル変数`logarc`が`true`の時、 逆円関数や逆双曲線関数は、同値の対数関数に置き換えられます。 `logarc`のデフォルト値は`false`です。

  関数`logarc(expr)`は、 グローバル変数`logarc`を設定することなしに、式exprに対して上記置き換えを実行します。

  Exponential and logarithm functions ·Simplification flags and variables ·Simplification functions ·

オプション変数: logconcoeffp

  デフォルト値: `false`

  `logcontract`を使った時、どの係数が短縮されるかを制御します。 引数１つの述語論理関数の名前に設定することができます。 例えば、もしSQRTを生成したいなら、 `logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or ratnump(m)$`を実行できます。 すると、 `logcontract(1/2*log(x));`は`log(sqrt(x))`を与えるでしょう。

  Exponential and logarithm functions ·Simplification flags and variables ·

関数: logcontract (expr)

  形式`a1*log(b1) + a2*log(b2) + c`の部分式を `log(ratsimp(b1^a1 * b2^a2)) + c`に変換しながら、 再帰的に式exprを走査します。

      (%i1) 2*(a*log(x) + 2*a*log(y))$
      (%i2) logcontract(%);
                                       2  4
      (%o2)                     a log(x  y )

  `declare(n,integer);`を実行すると、 `logcontract(2*a*n*log(x));`は、`a*log(x^(2*n))`に整理されます。 この方法で「短縮」される係数は、ここで2や`n`に当たるもので、`featurep(coeff,integer)`を満たします。 ユーザーは、 オプション`logconcoeffp`を引数１つの述語論理関数名に設定することで、 どの係数を短縮するか制御できます。 例えば、もしSQRTを生成したいなら、 `logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) or ratnump(m)$`を実行できます。 すると、 `logcontract(1/2*log(x));`は`log(sqrt(x))`を与えるでしょう。

  Exponential and logarithm functions ·

オプション変数: logexpand

  デフォルト値: `false`

  もし`true`なら、 `log(a^b)`が`b*log(a)`になるようにします。 もし`all`に設定されているなら、 `log(a*b)`も`log(a)+log(b)`に整理されます。 もし`super`に設定されているなら, 有理数`a/b`ただし`a#1`について`log(a/b)`も`log(a)-log(b)`に整理されます。 (整数`b`に関して`log(1/b)`はいつも整理されます。) もし`false`に設定されているなら、 これらのすべての整理は止められます。

  Exponential and logarithm functions ·Simplification flags and variables ·

オプション変数: lognegint

  デフォルト値: `false`

  もし`true`なら、正の整数`n`に対して規則 `log(-n)` -> `log(n)+%i*%pi` が実装されます。

  Exponential and logarithm functions ·Simplification flags and variables ·

オプション変数: lognumer

  デフォルト値: `false`

  もし`true`なら、 引数は、`log`の計算の前に絶対値に変換されます。 もし`numer`も`true`なら、 `log`の引数に負の整数を与えたとき、 引数は、`log`の計算の前に絶対値に変換されます。

  Exponential and logarithm functions ·Simplification flags and variables ·Numerical evaluation ·

オプション変数: logsimp

  デフォルト値: `true`

  もし`false`なら、 `%e`は、`log`を含む累乗へ整理がなされます。

  Exponential and logarithm functions ·Simplification flags and variables ·

関数: plog (x)

  `-%pi` < `carg(x)` <= `+%pi`を虚部係数とする複素数値の自然対数の主値を表します。

  Exponential and logarithm functions ·Complex variables ·

関数: sqrt (x)

  xの平方根。 内部的には`x^(1/2)`で表現されます。 `rootscontract`も参照してください。

  `radexpand`が`true`なら、nのべき乗となる積の因子のn番目の根を 累乗根の外部に押し出すようにします。 例えば、 `radexpand`が`true`の時だけ、`sqrt(16*x^2)`は`4*x`になります。

  Mathematical functions ·

Next: Random Numbers, Previous: Root Exponential and Logarithmic Functions, Up: Mathematical Functions [Contents][Index]

### 10.5 Trigonometric Functions

Next: Functions and Variables for Trigonometric, Previous: Trigonometric Functions, Up: Trigonometric Functions [Contents][Index]

#### 10.5.1 Introduction to Trigonometric

Maximaは、定義されたたくさんの三角関数を持ちます。 すべての三角恒等式がプログラムされているわけではありませんが、 ユーザーは、システムのパターンマッチング能力を使ってそれらの多くを追加することができます。 Maximaで定義された三角関数は以下の通りです: `acos`, `acosh`, `acot`, `acoth`, `acsc`, `acsch`, `asec`, `asech`, `asin`, `asinh`, `atan`, `atanh`, `cos`, `cosh`, `cot`, `coth`, `csc`, `csch`, `sec`, `sech`, `sin`, `sinh`, `tan`, `tanh`。 特に三角関数を扱うためのたくさんのコマンドがあります。 `trigexpand`, `trigreduce`, スイッチ`trigsign`を参照してください。 ２つの共用パッケージ`ntrig`, `atrig1`は、 Maximaに組み込まれた整理規則を拡張します。 詳しくは、`describe(command)`を実行してください。

Trigonometric functions ·

Previous: Introduction to Trigonometric, Up: Trigonometric Functions [Contents][Index]

#### 10.5.2 Functions and Variables for Trigonometric

オプション変数: %piargs

  デフォルト値: `true`

  `%piargs`が`true`の時で、 引数が %pi, %pi/2, %pi/3, %pi/4, %pi/6のいずれか の整数倍の時は、 三角関数は、代数定数に整理されます。

  Maximaは、 %pi などが、整数変数（すなわち、整数に宣言されたシンボル）倍された時適用できる いくつかの恒等式を知っています。

  例:

      (%i1) %piargs : false$

      (%i2) [sin (%pi), sin (%pi/2), sin (%pi/3)];
                                      %pi       %pi
      (%o2)            [sin(%pi), sin(---), sin(---)]
                                       2         3

      (%i3) [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
                            %pi       %pi       %pi
      (%o3)            [sin(---), sin(---), sin(---)]
                             4         5         6

      (%i4) %piargs : true$

      (%i5) [sin (%pi), sin (%pi/2), sin (%pi/3)];
                                      sqrt(3)
      (%o5)                    [0, 1, -------]
                                         2

      (%i6) [sin (%pi/4), sin (%pi/5), sin (%pi/6)];
                               1         %pi   1
      (%o6)                [-------, sin(---), -]
                            sqrt(2)       5    2

      (%i7) [cos (%pi/3), cos (10*%pi/3), tan (10*%pi/3),
             cos (sqrt(2)*%pi/3)];
                      1    1               sqrt(2) %pi
      (%o7)          [-, - -, sqrt(3), cos(-----------)]
                      2    2                    3

  %pi and %pi/2 が整数変数にかけられた時、いくつかの恒等式が適用されます。

      (%i1) declare (n, integer, m, even)$
      (%i2) [sin (%pi * n), cos (%pi * m), sin (%pi/2 * m),
             cos (%pi/2 * m)];
                                            m/2
      (%o2)                  [0, 1, 0, (- 1)   ]

  Trigonometric functions ·Simplification flags and variables ·

オプション変数: %iargs

  デフォルト値: `true`

  `%iargs`が`true`の時、 引数が明らかに、虚数単位 %i を掛けたものの時、 三角関数は双曲線関数に整理されます。

  引数が明らかに実数の時でさえ、整理は実行されます; Maximaは、ただ、引数が、 %i を文字通り掛けたものかどうかを考慮します。

  例:

      (%i1) %iargs : false$
      (%i2) [sin (%i * x), cos (%i * x), tan (%i * x)];
      (%o2)           [sin(%i x), cos(%i x), tan(%i x)]
      (%i3) %iargs : true$
      (%i4) [sin (%i * x), cos (%i * x), tan (%i * x)];
      (%o4)           [%i sinh(x), cosh(x), %i tanh(x)]

  引数が明らかに実数の時でさえ、整理は実行されます。

      (%i1) declare (x, imaginary)$

      (%i2) [featurep (x, imaginary), featurep (x, real)];
      (%o2)                     [true, false]

      (%i3) sin (%i * x);
      (%o3)                      %i sinh(x)

  Trigonometric functions ·Hyperbolic functions ·Simplification flags and variables ·

関数: acos (x)

  – 逆余弦

  Trigonometric functions ·

関数: acosh (x)

  – 逆双曲余弦

  Hyperbolic functions ·

関数: acot (x)

  – 逆余接

  Trigonometric functions ·

関数: acoth (x)

  – 逆双曲余接

  Hyperbolic functions ·

関数: acsc (x)

  – 逆余割

  Trigonometric functions ·

関数: acsch (x)

  – 逆双曲余割

  Hyperbolic functions ·

関数: asec (x)

  – 逆正割

  Trigonometric functions ·

関数: asech (x)

  – 逆双曲正割

  Hyperbolic functions ·

関数: asin (x)

  – 逆正弦

  Trigonometric functions ·

関数: asinh (x)

  – 逆双曲正弦

  Hyperbolic functions ·

関数: atan (x)

  – 逆正接

  Trigonometric functions ·

関数: atan2 (y, x)

  – `-%pi`から`%pi`までの間の`atan(y/x)`の値をもたらします。

  Trigonometric functions ·

関数: atanh (x)

  – 逆双曲正接

  Hyperbolic functions ·

パッケージ: atrig1

  `atrig1`パッケージは、逆三角関数のためのいくつかの追加の整理規則を含みます。 Maximaが既に知っている規則と合わせて、 以下の角度が完全に実装されます: `0`, `%pi/6`, `%pi/4`, `%pi/3`, `%pi/2`。 他の3象限の対応する角度も利用可能です。 これらを使うには、`load("atrig1");`を実行してください。

  Trigonometric functions ·Package atrig1 ·

関数: cos (x)

  – 余弦

  Trigonometric functions ·

関数: cosh (x)

  – 双曲余弦

  Hyperbolic functions ·

関数: cot (x)

  – 余接

  Trigonometric functions ·

関数: coth (x)

  – 双曲余接

  Hyperbolic functions ·

関数: csc (x)

  – 余割

  Trigonometric functions ·

関数: csch (x)

  – 双曲余割

  Hyperbolic functions ·

オプション変数: halfangles

  デフォルト値: `false`

  `halfangles`が`true`の時、 引数`expr/2`の三角関数は、exprの関数に整理されます。

  区間`0 < x < 2*%pi`の実引数xに関して、 半角の正弦は簡単な公式に整理されます:

                               sqrt(1 - cos(x))
                               ----------------
                                   sqrt(2)

  複雑な因子は すべての複素引数zでこの公式を正しくするために必要です:

                 realpart(z)
           floor(-----------)
                    2 %pi
      (- 1)                   (1 - unit_step(- imagpart(z))

                                  realpart(z)            realpart(z)
                            floor(-----------) - ceiling(-----------)
                                     2 %pi                  2 %pi
                      ((- 1)                                          + 1))

  Maximaは、この因子と、 関数`sin`, `cos`, `sinh`, `cosh`に関する類似の因子を知っています。 引数zの特別な値に関して、 これらの因子は相応に整理されます。

  例:

      (%i1) halfangles:false;
      (%o1)                                false
      (%i2) sin(x/2);
                                              x
      (%o2)                               sin(-)
                                              2
      (%i3) halfangles:true;
      (%o3)                                true
      (%i4) sin(x/2);
                                                          x
                                                  floor(-----)
                                                        2 %pi
                            sqrt(1 - cos(x)) (- 1)
      (%o4)                 ----------------------------------
                                         sqrt(2)
      (%i5) assume(x>0, x<2*%pi)$
      (%i6) sin(x/2);
                                     sqrt(1 - cos(x))
      (%o6)                          ----------------
                                         sqrt(2)

  Trigonometric functions ·Simplification flags and variables ·

パッケージ: ntrig

  `ntrig`パッケージは、 引数が形式`f(n %pi/10)` ―fは関数 `sin`, `cos`, `tan`, `csc`, `sec`, `cot`のいずれか― の三角関数を整理するのに使われる整理規則の集合を含みます。

  Trigonometric functions ·Package ntrig ·

関数: sec (x)

  – 正割

  Trigonometric functions ·

関数: sech (x)

  – 双曲正割

  Hyperbolic functions ·

関数: sin (x)

  – 正弦

  Trigonometric functions ·

関数: sinh (x)

  – 双曲正弦

  Hyperbolic functions ·

関数: tan (x)

  – 正接

  Trigonometric functions ·

関数: tanh (x)

  – 双曲正接

  Hyperbolic functions ·

関数: trigexpand (expr)

  exprの中に現れる角の和や角の倍数の三角関数、双曲線関数を展開します。 最もよい結果では、exprは展開されるべきです。 整理のユーザー制御を強化するために、 この関数は、一度に１レベルのみ、角の和もしくは角の倍数を展開します。 ただちにサインとコサインへの完全な展開を得るには、 スイッチ`trigexpand: true`を設定してください。

  `trigexpand`は、以下のグローバルフラグによって決定されます:

  `trigexpand`

    もし`true`なら、 続いて現れるサインやコサインを含んでいる式すべての展開を起こします。

  `halfangles`

    もし`true`なら、 半角が整理されます。

  `trigexpandplus`

    `trigexpand`の「和」規則を制御します。 和（例えば`sin(x + y)`）の展開は、 `trigexpandplus`が`true`の時だけ起こります。

  `trigexpandtimes`

    `trigexpand`の「積」規則を制御します。 積(例えば`sin(2 x)`)の展開は、 `trigexpandtimes`が`true`の時だけ起こります。

  例:

      (%i1) x+sin(3*x)/sin(x),trigexpand=true,expand;

                               2           2
      (%o1)               - sin (x) + 3 cos (x) + x

      (%i2) trigexpand(sin(10*x+y));
      (%o2)          cos(10 x) sin(y) + sin(10 x) cos(y)

  Trigonometric functions ·Simplification functions ·

オプション変数: trigexpandplus

  デフォルト値: `true`

  `trigexpandplus`は、`trigexpand`の「和」規則を制御します。 `trigexpand`コマンドが使われるか、もしくは `trigexpand`スイッチが`true`に設定されている時 和(例えば`sin(x+y))`)の展開は、 `trigexpandplus`が`true`の時だけ起こります。

  Trigonometric functions ·Simplification flags and variables ·

オプション変数: trigexpandtimes

  デフォルト値: `true`

  `trigexpandtimes`は、`trigexpand`の「積」規則を制御します。 `trigexpand`コマンドが使われるか、もしくは、 `trigexpand`スイッチが`true`に設定されている時、 積(例えば`sin(2*x)`)の展開は、 `trigexpandtimes`が`true`の時だけ起こります。

  Trigonometric functions ·Simplification flags and variables ·

オプション変数: triginverses

  デフォルト値: `true`

  `triginverses`は、 三角関数や双曲線関数とそれらの逆関数の合成の整理を制御します。

  もし`all`なら、 例えば、`atan(tan(x))` と`tan(atan(x))`のどちらもxに整理されます。

  もし`true`なら、 `arcfun(fun(x))`の整理は止められます。

  もし`false`なら、 `arcfun(fun(x))`と `fun(arcfun(x))`のどちらの整理も止められます。

  Trigonometric functions ·Simplification flags and variables ·

関数: trigreduce (expr, x)
関数: trigreduce (expr)

  xを引数とする三角と双曲の正弦、余弦の積とべきを xの倍数のそれらに結合します。 これらの関数が分母に現れた時、これらを消去しようともします。 もしxが省略されたら、exprの中の変数すべてが使われます。

  `poissimp`も参照してください。

      (%i1) trigreduce(-sin(x)^2+3*cos(x)^2+x);

                     cos(2 x)      cos(2 x)   1        1
      (%o1)          -------- + 3 (-------- + -) + x - -
                        2             2       2        2

  Trigonometric functions ·Simplification functions ·

オプション変数: trigsign

  デフォルト値: `true`

  `trigsign`が`true`の時、 三角関数への負の引数の整理を認めます。 例えば、`sin(-x)`は、 `trigsign`が`true`の時だけ、 `-sin(x)`になります。

  Trigonometric functions ·Simplification flags and variables ·

関数: trigsimp (expr)

  `tan`, `sec`などを含む式を`sin`, `cos`, `sinh`, `cosh`に整理するために、 恒等式 sin(x)^2 + cos(x)^2 = 1 と cosh(x)^2 - sinh(x)^2 = 1 を使います。

  `trigreduce`, `ratsimp`, `radcan` は、結果を更に整理できるかもしれません。

  `demo ("trgsmp.dem")`は、`trigsimp`のいくつかの例を表示します。

  Trigonometric functions ·Simplification functions ·

関数: trigrat (expr)

  三角関数の整理された標準疑似線形形式を与えます; exprは、`sin`, `cos`もしくは`tan`のいくつかの有理分数であり、 それらの引数は、整数係数を持つ、いくつかの変数（もしくは核）と`%pi/n` (nは整数)の線形形式です。 結果は、分子と分母が`sin`と`cos`に関して線形の整理された分数です。 `trigrat`はいつも可能なときは線形化します。

      (%i1) trigrat(sin(3*a)/sin(a+%pi/3));
      (%o1)            sqrt(3) sin(2 a) + cos(2 a) - 1

  以下の例は、 Davenport, Siret, and TournierのCalcul Formel, Masson (もしくは英語版ではAddison-Wesley), 1.5.5節, モーレイの定理から取られました。

      (%i1) c : %pi/3 - a - b$
      (%i2) bc : sin(a)*sin(3*c)/sin(a+b);

                                                %pi
                        sin(a) sin(3 (- b - a + ---))
                                                 3
      (%o2)             -----------------------------
                                 sin(b + a)

      (%i3) ba : bc, c=a, a=c;

                                               %pi
                          sin(3 a) sin(b + a - ---)
                                                3
      (%o3)               -------------------------
                                        %pi
                                sin(a - ---)
                                         3

      (%i4) ac2 : ba^2 + bc^2 - 2*bc*ba*cos(b);

               2         2         %pi
            sin (3 a) sin (b + a - ---)
                                    3
      (%o4) ---------------------------
                      2     %pi
                   sin (a - ---)
                             3
                                             %pi
       - (2 sin(a) sin(3 a) sin(3 (- b - a + ---)) cos(b)
                                              3
                   %pi            %pi
       sin(b + a - ---))/(sin(a - ---) sin(b + a))
                    3              3
            2       2              %pi
         sin (a) sin (3 (- b - a + ---))
                                    3
       + -------------------------------
                      2
                   sin (b + a)

      (%i5) trigrat (ac2);

      (%o5) - (sqrt(3) sin(4 b + 4 a) - cos(4 b + 4 a)
       - 2 sqrt(3) sin(4 b + 2 a) + 2 cos(4 b + 2 a)
       - 2 sqrt(3) sin(2 b + 4 a) + 2 cos(2 b + 4 a)
       + 4 sqrt(3) sin(2 b + 2 a) - 8 cos(2 b + 2 a) - 4 cos(2 b - 2 a)
       + sqrt(3) sin(4 b) - cos(4 b) - 2 sqrt(3) sin(2 b) + 10 cos(2 b)
       + sqrt(3) sin(4 a) - cos(4 a) - 2 sqrt(3) sin(2 a) + 10 cos(2 a)
       - 9)/4

  Trigonometric functions ·Simplification functions ·

Previous: Trigonometric Functions, Up: Mathematical Functions [Contents][Index]

### 10.6 Random Numbers

関数: make_random_state (n)
関数: make_random_state (s)
関数: make_random_state (true)
関数: make_random_state (false)

  ランダムステートオブジェクトは、乱数生成器の状態を表します。 状態は、627個の32ビットワードで構成されます。

  `make_random_state (n)`は、 nを2^32で割った余りに等しい整数シードの値から新しいランダムステートオブジェクトを 生成します。nは負でもいいです。

  `make_random_state (s)`は、ランダムステートsのコピーを返します。

  `make_random_state (true)`は、新しいランダムステートオブジェクトを返します。 シードとしてコンピュータの現在時刻を使います。

  `make_random_state (false)`は、乱数生成器の現在のステートのコピーを返します。

  Random numbers ·

関数: set_random_state (s)

  sを乱数生成器状態にコピーします。

  `set_random_state`はいつも`done`を返します。

  Random numbers ·

関数: random (x)

  疑似乱数を返します。 もしxが整数なら、`random (x)`は、0から`x - 1`までの 整数を返します。 もしxが浮動小数点なら、`random (x)`は、xより小さい非負の浮動小数点を返します。 もしxが整数でも浮動小数点でもなかったり、xが正でなければ、 `random`は、エラーを出力します。

  関数`make_random_state`と`set_random_state`は、 乱数生成器の状態を保守します。

  Maximaの乱数生成器は、メルセンヌ・ツイスタ MT 19937の実装です。

  例:

      (%i1) s1: make_random_state (654321)$
      (%i2) set_random_state (s1);
      (%o2)                         done
      (%i3) random (1000);
      (%o3)                          768
      (%i4) random (9573684);
      (%o4)                        7657880
      (%i5) random (2^75);
      (%o5)                11804491615036831636390
      (%i6) s2: make_random_state (false)$
      (%i7) random (1.0);
      (%o7)                   .2310127244107132
      (%i8) random (10.0);
      (%o8)                   4.394553645870825
      (%i9) random (100.0);
      (%o9)                   32.28666704056853
      (%i10) set_random_state (s2);
      (%o10)                        done
      (%i11) random (1.0);
      (%o11)                  .2310127244107132
      (%i12) random (10.0);
      (%o12)                  4.394553645870825
      (%i13) random (100.0);
      (%o13)                  32.28666704056853

  Random numbers ·Numerical methods ·

Next: Plotting, Previous: Mathematical Functions, Up: Top [Contents][Index]

## 11 Maximas Database

Next: Functions and Variables for Properties, Previous: Maximas Database, Up: Maximas Database [Contents][Index]

### 11.1 Introduction to Maximas Database

Next: Functions and Variables for Facts, Previous: Introduction to Maximas Database, Up: Maximas Database [Contents][Index]

### 11.2 Functions and Variables for Properties

関数: declare (a_1, p_1, a_2, p_2, …)

  アトムやアトムのリストa_iに、プロパティやプロパティのリストp_iを割り当てます。 a_iやp_iがリストの時、 アトムのそれぞれは、プロパティすべてを得ます。

  `declare`は引数をクォートします。 `declare`はいつも`done`を返します。

  それぞれの宣言フラグに関する記述で注意しているように、 いくつかのフラグに関して、 もしobjectがfeatureを持つよう宣言されているなら、 `featurep(object, feature)`は、 `true`を返します。 しかしながら、`featurep`はいくつかのフラグを認識しません; これはバグです。

  `features`も参照してください。

  `declare`は以下のプロパティを認識します:

  `evfun`

    `ev`のフラグ引数としてa_iが現れた時 a_iで名付けられた関数を適用するように `ev`に伝えます。 `evfun`を参照してください。

  `evflag`

    `ev`のフラグ引数としてa_iが現れた時 `ev`の実行中a_iが`true`にバインドされるように `ev`に伝えます。 `evflag`を参照してください。

  `bindtest`

    a_iがバインドされていない状態に評価された時、 Maximaにエラーをトリガーするように伝えます。

  `noun`

    a_iを名詞としてパースするようにMaximaに伝えます。 この効果は、a_iのインスタンスを`'a_i`や`nounify(a_i)` で置き換えることです。どちらに置き換えるかは文脈に依存します。

  `constant`

    a_iをシンボル定数と考えるようにMaximaに伝えます。

  `scalar`

    a_iをスカラー変数と考えるようにMaximaに伝えます。

  `nonscalar`

    a_iを非スカラー変数と考えるようにMaximaに伝えます。 普通の使い方は、変数をシンボルベクトルや行列として宣言することです。

  `nonarray`

    Maximaにa_iを配列でないものと考えるように伝えます。 この宣言は添字付き変数名の多重評価を抑制します。

  `mainvar`

    a_iを「主変数」と考えるようにMaximaに伝えます。 `ordergreatp`で決定されるように、 Maximaの式の標準順序では、主変数は他のすべての定数や変数に続きます。

  `alphabetic`

    （文字列の）a_iの中の文字すべてをアルファベット文字として認識するように Maximaに伝えます。

  `feature`

    a_iをfeature名として認識するようにMaximaに伝えます。 他のアトムは、a_iプロパティを持つように定義されます。

  `rassociative`, `lassociative`

    a_iを右結合、もしくは左結合関数として認識するようにMaximaに伝えます。

  `nary`

    a_iをn項関数として認識するようにMaximaに伝えます。

    `nary`宣言は、`nary`関数をコールするのとは同じではありません。 `declare(foo, nary)`だけの効果は、Maxima整理器を ネストされた式を平坦にするように指示することです。 例えば、`foo(x, foo(y, z))`を`foo(x, y, z)`に整理します。

  `symmetric`, `antisymmetric`, `commutative`

    a_iを対称もしくは反対称関数として認識するようにMaximaに伝えます。 `commutative`は`symmetric`と同じです。

  `oddfun`, `evenfun`

    a_iを偶関数もしくは奇関数として認識するようにMaximaに伝えます。

  `outative`

    a_i式を最初の引数から定数因子を引き出すことで整理するようにMaximaに伝えます。

    a_iが１つ引数を持つ時、 もしリテラル定数や宣言定数なら、因子は定数とみなされます。

    a_iが２つ以上の引数を持つ時、 もし２番目の引数がシンボルであり、因子が２番目の引数の制約を受けなければ、 因子は定数とみなされます。

  `multiplicative`

    代入`a_i(x * y * z * ...)` `-->` `a_i(x) * a_i(y) * a_i(z) * ...`. によって、a_i式を整理するようにMaximaに伝えます。 代入は、１番目の引数のみで実行されます。

  `additive`

    代入`a_i(x + y + z + ...)` `-->` `a_i(x) + a_i(y) + a_i(z) + ...`. によって、a_i式を整理するようにMaximaに伝えます。 代入は、１番目の引数のみで実行されます。

  `linear`

    a_iを`outative`かつ`additive`に宣言することと同値です。

  `integer`, `noninteger`

    a_iを整数もしくは非整数変数として認識するようにMaximaに伝えます。

  `even`, `odd`

    a_iを偶数変数もしくは奇数変数として認識するようにMaximaに伝えます。

  `rational`, `irrational`

    a_iを有理変数もしくは非有理実変数として認識するようにMaximaに伝えます。

  `real`, `imaginary`, `complex`

    a_iを実変数もしくは純虚数変数もしくは複素変数として認識するようにMaximaに伝えます。

  `increasing`, `decreasing`

    a_iを単調増加関数もしくは単調減少関数として認識するようにMaximaに伝えます。

  `posfun`

    a_iを正関数として認識するようにMaximaに伝えます。

  `integervalued`

    a_iを整数値を返す関数として認識するようにMaximaに伝えます。

  例:

  `evfun`と`evflag`宣言。

      (%i1) declare (expand, evfun);
      (%o1)                         done
      (%i2) (a + b)^3;
                                         3
      (%o2)                       (b + a)
      (%i3) (a + b)^3, expand;
                           3        2      2      3
      (%o3)               b  + 3 a b  + 3 a  b + a
      (%i4) declare (demoivre, evflag);
      (%o4)                         done
      (%i5) exp (a + b*%i);
                                   %i b + a
      (%o5)                      %e
      (%i6) exp (a + b*%i), demoivre;
                            a
      (%o6)               %e  (%i sin(b) + cos(b))

  `bindtest`宣言。

      (%i1) aa + bb;
      (%o1)                        bb + aa
      (%i2) declare (aa, bindtest);
      (%o2)                         done
      (%i3) aa + bb;
      aa unbound variable
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i4) aa : 1234;
      (%o4)                         1234
      (%i5) aa + bb;
      (%o5)                       bb + 1234

  `noun`宣言。

      (%i1) factor (12345678);
                                   2
      (%o1)                     2 3  47 14593
      (%i2) declare (factor, noun);
      (%o2)                         done
      (%i3) factor (12345678);
      (%o3)                   factor(12345678)
      (%i4) ''%, nouns;
                                   2
      (%o4)                     2 3  47 14593

  `constant`, `scalar`, `nonscalar`, `mainvar`宣言。

  `alphabetic`宣言。

      (%i1) xx\~yy\`\@ : 1729;
      (%o1)                         1729
      (%i2) declare ("~`@", alphabetic);
      (%o2)                         done
      (%i3) xx~yy`@ + @yy`xx + `xx@@yy~;
      (%o3)               `xx@@yy~ + @yy`xx + 1729
      (%i4) listofvars (%);
      (%o4)                  [@yy`xx, `xx@@yy~]

  `feature`宣言。

      (%i1) declare (FOO, feature);
      (%o1)                         done
      (%i2) declare (x, FOO);
      (%o2)                         done
      (%i3) featurep (x, FOO);
      (%o3)                         true

  `rassociative`, `lassociative`宣言。

  `nary`宣言。

      (%i1) H (H (a, b), H (c, H (d, e)));
      (%o1)               H(H(a, b), H(c, H(d, e)))
      (%i2) declare (H, nary);
      (%o2)                         done
      (%i3) H (H (a, b), H (c, H (d, e)));
      (%o3)                   H(a, b, c, d, e)

  `symmetric`, `antisymmetric`宣言。

      (%i1) S (b, a);
      (%o1)                        S(b, a)
      (%i2) declare (S, symmetric);
      (%o2)                         done
      (%i3) S (b, a);
      (%o3)                        S(a, b)
      (%i4) S (a, c, e, d, b);
      (%o4)                   S(a, b, c, d, e)
      (%i5) T (b, a);
      (%o5)                        T(b, a)
      (%i6) declare (T, antisymmetric);
      (%o6)                         done
      (%i7) T (b, a);
      (%o7)                       - T(a, b)
      (%i8) T (a, c, e, d, b);
      (%o8)                   T(a, b, c, d, e)

  `oddfun`, `evenfun`宣言。

      (%i1) o (- u) + o (u);
      (%o1)                     o(u) + o(- u)
      (%i2) declare (o, oddfun);
      (%o2)                         done
      (%i3) o (- u) + o (u);
      (%o3)                           0
      (%i4) e (- u) - e (u);
      (%o4)                     e(- u) - e(u)
      (%i5) declare (e, evenfun);
      (%o5)                         done
      (%i6) e (- u) - e (u);
      (%o6)                           0

  `outative`宣言。

      (%i1) F1 (100 * x);
      (%o1)                       F1(100 x)
      (%i2) declare (F1, outative);
      (%o2)                         done
      (%i3) F1 (100 * x);
      (%o3)                       100 F1(x)
      (%i4) declare (zz, constant);
      (%o4)                         done
      (%i5) F1 (zz * y);
      (%o5)                       zz F1(y)

  `multiplicative`宣言。

      (%i1) F2 (a * b * c);
      (%o1)                       F2(a b c)
      (%i2) declare (F2, multiplicative);
      (%o2)                         done
      (%i3) F2 (a * b * c);
      (%o3)                   F2(a) F2(b) F2(c)

  `additive`宣言。

      (%i1) F3 (a + b + c);
      (%o1)                     F3(c + b + a)
      (%i2) declare (F3, additive);
      (%o2)                         done
      (%i3) F3 (a + b + c);
      (%o3)                 F3(c) + F3(b) + F3(a)

  `linear`宣言。

      (%i1) 'sum (F(k) + G(k), k, 1, inf);
                             inf
                             ====
                             \
      (%o1)                   >    (G(k) + F(k))
                             /
                             ====
                             k = 1
      (%i2) declare (nounify (sum), linear);
      (%o2)                         done
      (%i3) 'sum (F(k) + G(k), k, 1, inf);

                           inf          inf
                           ====         ====
                           \            \
      (%o3)                 >    G(k) +  >    F(k)
                           /            /
                           ====         ====
                           k = 1        k = 1

  Declarations and inferences ·

宣言: features

  Maximaは、関数や変数のある数学的プロパティを認識します。 それらは「フィーチャー」と呼ばれます。

  `declare (x, foo)`は、 プロパティfooを関数もしくは変数xに与えます。

  `declare (foo, feature)`は、 新しいフィーチャーfooを宣言します。 例えば、 `declare ([red, green, blue], feature)`は、 ３つの新しいフィーチャー`red`, `green`, `blue`を宣言します。

  もしxがfooプロパティを持つなら、 述語論理`featurep (x, foo)`は、`true`を返し、 そうでなければ、`false`を返します。

  インフォリスト`features`は既知のフィーチャーのリストです。 それらは、

         integer        noninteger      even
         odd            rational        irrational
         real           imaginary       complex
         analytic       increasing      decreasing
         oddfun         evenfun         posfun
         commutative    lassociative    rassociative
         symmetric      antisymmetric

  プラス、任意のユーザー定義フィーチャーです。

  `features`は、数学的フィーチャーのリストです。 非数学的で、システム依存のフィーチャーのリストもあります。 `status`を参照してください。

  Declarations and inferences ·

関数: get (a, i)

  iが示すアトム aのユーザープロパティを検索し、 もしaがプロパティ iを持たないなら、 `false`を返します。

  `get`は、引数を評価します。

      (%i1) put (%e, 'transcendental, 'type);
      (%o1)                    transcendental
      (%i2) put (%pi, 'transcendental, 'type)$
      (%i3) put (%i, 'algebraic, 'type)$
      (%i4) typeof (expr) := block ([q],
              if numberp (expr)
              then return ('algebraic),
              if not atom (expr)
              then return (maplist ('typeof, expr)),
              q: get (expr, 'type),
              if q=false
              then errcatch (error(expr,"is not numeric.")) else q)$
      (%i5) typeof (2*%e + x*%pi);
      x is not numeric.
      (%o5)  [[transcendental, []], [algebraic, transcendental]]
      (%i6) typeof (2*%e + %pi);
      (%o6)     [transcendental, [algebraic, transcendental]]

  Declarations and inferences ·

プロパティ: nonarray

  コマンド`declare(a, nonarray)`はMaximaに aが配列でないものと考えるように伝えます。 もしaが添字付き変数なら、この宣言は多重評価を抑制します。

  例:

      (%i1) a:'b$ b:'c$ c:'d$

      (%i4) a[x];
      (%o4)                          d
                                      x
      (%i5) declare(a, nonarray);
      (%o5)                         done
      (%i6) a[x];
      (%o6)                          a
                                      x

  Expressions ·

宣言: posfun

  `declare (f, posfun)`は、 `f`を正の関数と宣言します。 `is (f(x) > 0)`は`true`を出力します。

  Declarations and inferences ·Operators ·

関数: printprops (a, i)
関数: printprops ([a_1, ..., a_n], i)
関数: printprops (all, i)

  アトムaに関連付けられた指標iの属性を表示します。 aは、アトムのリストもしくはアトム`all`もありえます。 その場合，与えられたプロパティを持つすべてのアトムに適用します。 例えば、 `printprops ([f, g], atvalue)`。 `printprops`は、表示できないプロパティ、 すなわち`atvalue`, `atomgrad`, `gradef`, `matchdeclare`のためのものです。

  Declarations and inferences ·Display functions ·

Next: Functions and Variables for Predicates, Previous: Functions and Variables for Properties, Up: Maximas Database [Contents][Index]

### 11.3 Functions and Variables for Facts

関数: activate (context_1, …, context_n)

  文脈context_1, …, context_nをアクティベートします。 これらの文脈に関する事実は、演繹し情報を検索するために利用可能となります。 これらの文脈に関する事実は、`facts ()`によってリストされません。

  変数`activecontexts`は、 `activate`関数を使ってアクティブになった文脈のリストです。

  Declarations and inferences ·

システム変数: activecontexts

  デフォルト値: `[]`

  変数`activecontexts`は、 アクティブである文脈と対照的に、 `activate`関数を使ってアクティブになった文脈のリストです。 ゆえに、それらは現在の文脈の部分文脈です。

  Declarations and inferences ·

システム変数: askexp

  `asksign`がコールされた時、 `askexp`は、`asksign`がテストしている式です。

  以前は、control-AでMaximaブレイクに入ることによって、 ユーザーが`askexp`を検査することができました。

  Declarations and inferences ·

関数: askinteger (expr, integer)
関数: askinteger (expr)
関数: askinteger (expr, even)
関数: askinteger (expr, odd)

  `askinteger (expr, integer)`は、 `assume`データベースから、exprが整数かどうかを決定しようとします。 そうでなく、もし決定できなければ、`askinteger`はユーザーに入力を促し、 可能ならばデータベースに情報をインストールしようとします。 `askinteger (expr)`は、 `askinteger (expr, integer)`と同値です。

  同様に、 `askinteger (expr, even)`や`askinteger (expr, odd)`は、 それぞれ、exprが偶数か奇数か、決定しようとします。

  Declarations and inferences ·

関数: asksign (expr)

  最初に、指定された式が正か負かゼロか決定しようとします。 できなければ、演繹を完了するのに必要な質問をユーザーに尋ねます。 ユーザーの答えは、現在の計算の演繹のため、データベースに記録されます。 `asksign`の戻り値は、`pos`, `neg`もしくは`zero`のいずれか１つです。

  Declarations and inferences ·

関数: assume (pred_1, …, pred_n)

  述語論理pred_1, …, pred_nを現在の文脈に追加します。 もし述語論理が現在の文脈と矛盾していたり、冗長だったりしたなら、文脈に追加されません。 文脈は`assume`がコールされる毎に述語論理を累積していきます。

  `assume`は、文脈に追加された述語論理を要素に持つリストか、 適用されたアトム`redundant`もしくは`inconsistent`を返します。

  述語論理pred_1, …, pred_nは 関係演算子`< <= equal notequal >= >`を持つ式のみ許されます。 述語論理はリテラル等号`=`やリテラル不等号`#`の式は使えません。 `integerp`のような述語関数も使えません。

  形式`pred_1 and ...and pred_n`の合成された述語論理が認識されます。 しかし、`pred_1 or ... or pred_n`は認識されません。 もし`pred_k`が関係述語論理なら、`not pred_k`は認識されます。 形式`not (pred_1 and pred_2)`の式や `not (pred_1 or pred_2)`は認識されません。

  Maximaの推論メカニズムはそれほど強くありません; `is`によって決定されない多くの明らかな結果があります。 これは既知の弱みです。

  `assume`は複素数を伴う述語論理を扱いません。 もし述語論理が複素数を含むなら、`assume`は`inconsistent`か`redundant`を返します。

  `assume`は引数を評価します。

  `is`や`facts`, `forget`, `context`, `declare`も参照してください。

  例:

      (%i1) assume (xx > 0, yy < -1, zz >= 0);
      (%o1)              [xx > 0, yy < - 1, zz >= 0]
      (%i2) assume (aa < bb and bb < cc);
      (%o2)                  [bb > aa, cc > bb]
      (%i3) facts ();
      (%o3)     [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
      (%i4) is (xx > yy);
      (%o4)                         true
      (%i5) is (yy < -yy);
      (%o5)                         true
      (%i6) is (sinh (bb - aa) > 0);
      (%o6)                         true
      (%i7) forget (bb > aa);
      (%o7)                       [bb > aa]
      (%i8) prederror : false;
      (%o8)                         false
      (%i9) is (sinh (bb - aa) > 0);
      (%o9)                        unknown
      (%i10) is (bb^2 < cc^2);
      (%o10)                       unknown

  Declarations and inferences ·

オプション変数: assumescalar

  デフォルト値: `true`

  `assumescalar`は、 `nonscalarp (expr)`が`false`であるような式`expr`が、 ある変換に関してスカラーのように振る舞うと仮定されるかどうかを決めるのを助けます。

  Let `expr`がリストや行列以外の任意の式を表してるとし、 `[1, 2, 3]`が任意のリストや行列を表しているとすると、 もし`assumescalar`が`true`、 もしくは`scalarp (expr)`が`true`、 もしくは`constantp (expr)`が`true`なら、 `expr . [1, 2, 3]`は、`[expr, 2 expr, 3 expr]`をもたらします。

  もし`assumescalar`が`true`なら、 そんな式は可換演算子に関してだけスカラーのように振る舞いますが、 非可換乗算`.`に関してはそうは振る舞いません。

  `assumescalar`が`false`の時 そんな式は、非スカラーのように振る舞います。

  `assumescalar`が`all`の時、 そんな式は、上でリストされた演算子すべてに関してスカラーのように振る舞います。

  Declarations and inferences ·

オプション変数: assume_pos

  デフォルト値: `false`

  `assume_pos`が`true`で、 パラメータxの符号が現在の文脈や他の考慮から決定できない時、 `sign`や`asksign (x)`は、`true`を返します。 これは、`integrate`や他の計算から起こるような、 自動生成される`asksign`問い合わせを事前に防ぐことができます。

  デフォルトでは、パラメータは`symbolp (x)`もしくは `subvarp (x)`のようなxです。 パラメータとして考えられる式のクラスは、 変数`assume_pos_pred`を介して、ある程度変えることができます。

  `sign`と`asksign`は、 式の中のオペランドの符号から式の符号を演繹しようとします。 例えば、もし`a`や`b`がともに正なら、 `a + b`も正です。

  しかしながら、`asksign`問い合わせすべてを迂回する方法はありません。 特に、`asksign`引数が、差`x - y`もしくは 対数`log(x)`の時、 たとえ`assume_pos`が`true`で、`assume_pos_pred`が 引数すべてに`true`を返す関数であっても、 `asksign`は、いつもユーザーからの入力を要請します。

  Declarations and inferences ·

オプション変数: assume_pos_pred

  デフォルト値: `false`

  `assume_pos_pred`が関数名や、引数xのラムダ式に割り当てられている時、 その関数は、 xが、`assume_pos`のためのパラメータと考えられるかどうかを決定するために コールされます。 `assume_pos`が`false`の時、 `assume_pos_pred`は、無視されます。

  `assume_pos_pred`関数は、引数xで`sign`と`asksign`によってコールされます。 ここで、xはアトム、添字付き変数、関数コール式のいずれかです。 もし`assume_pos_pred`関数が`true`を返すなら、 xは、`assume_pos`のためのパラメータと考えられます。

  デフォルトでは、パラメータは、`symbolp (x)`もしくは`subvarp (x)`のようなxです。

  `assume`と`assume_pos`も参照してください。

  例:

      (%i1) assume_pos: true$
      (%i2) assume_pos_pred: symbolp$
      (%i3) sign (a);
      (%o3)                          pos
      (%i4) sign (a[1]);
      (%o4)                          pnz
      (%i5) assume_pos_pred: lambda ([x], display (x), true)$
      (%i6) asksign (a);
                                    x = a

      (%o6)                          pos
      (%i7) asksign (a[1]);
                                   x = a
                                        1

      (%o7)                          pos
      (%i8) asksign (foo (a));
                                 x = foo(a)

      (%o8)                          pos
      (%i9) asksign (foo (a) + bar (b));
                                 x = foo(a)

                                 x = bar(b)

      (%o9)                          pos
      (%i10) asksign (log (a));
                                    x = a

      Is  a - 1  positive, negative, or zero?

      p;
      (%o10)                         pos
      (%i11) asksign (a - b);
                                    x = a

                                    x = b

                                    x = a

                                    x = b

      Is  b - a  positive, negative, or zero?

      p;
      (%o11)                         neg

  Declarations and inferences ·

オプション変数: context

  デフォルト値: `initial`

  `context`は、`assume`と`forget`によって保守される事実の集まりの名前です。

  `assume`は、`context`と名付けられた集まりに事実を追加する一方、 `forget`は、事実を取り除きます。

  `context`を名前fooにバインドすることは、 現在の文脈をfooに変えます。 もし指定された文脈fooがまだ存在しないなら、 `newcontext`のコールによって自動的に生成されます。 指定された文脈は自動的にアクティベートされます。

  文脈メカニズムの一般的な記述に関しては、`contexts`を参照してください。

  Declarations and inferences ·

オプション変数: contexts

  デフォルト値: `[initial, global]`

  `contexts`は、 現在アクティブな文脈を含んでいる、現在存在する文脈のリストです。

  文脈メカニズムは、ユーザーが 文脈と呼ばれる事実の集まりにバインドし、名付けることを可能にします。 一旦これがなされると、ユーザーは、 文脈を単にアクティベートしたりデアクティベートすることで、 たくさんの数の事実をMaximaに仮定させたり忘れさせたりできます。

  任意のシンボルのアトムは、文脈となりえ、 その文脈の中に含まれた事実は、 `forget`をコールすることで１つ１つ破壊されるまで、 あるいは、それらが属する文脈を破壊するために`kill`をコールすることで、全体として破壊されるまで、記憶装置に保持されます。

  文脈は階層的に存在します。 その根はいつも文脈`global`であり、 文脈`global`は、いくつかの関数が必要とするMaximaについての情報を含みます。 アクティブな文脈の部分文脈である任意の文脈の中の事実すべてそうであるように、 与えられた文脈の中では、 その文脈の中の事実すべては、「アクティブ」（それらが演繹や探索に使われるという意味） です。

  新鮮なMaximaが起動された時、 ユーザーは、`initial`と呼ばれる文脈の中にいます。 それは、部分文脈として`global`を持ちます。

  `facts`, `newcontext`, `supcontext`, `killcontext`, `activate`, `deactivate`, `assume`, `forget`も参照してください。

  Declarations and inferences ·

関数: deactivate (context_1, …, context_n)

  特定の文脈context_1, …, context_nをデアクティベートします。

  Declarations and inferences ·

関数: facts (item)
関数: facts ()

  もしitemが文脈の名前なら、 `facts (item)`は指定された文脈の`facts`のリストを返します。

  もしitemが文脈の名前でなければ、 `facts (item)`は現在の文脈の中で、 itemについて知っている`facts`のリストを返します。 異なる文脈中のアクティブな`facts`はリストされません。

  `facts ()`（すなわち引数なし）は現在の文脈をリストします。

  Declarations and inferences ·

関数: forget (pred_1, …, pred_n)
関数: forget (L)

  `assume`で規定された述語論理を取り除きます。 述語論理は以前に規定されたものと同値の（必ずしも同一である必要なない）式です。

  `forget (L)`（Lは述語論理のリスト）は、 リスト上のそれぞれの項目を忘れます。

  Declarations and inferences ·

関数: is (expr)

  `assume`データベースの中の事実から述語論理exprが確かか否かを決定 しようとします。

  もし述語論理が確かに`true`もしくは`false`なら、 `is`は、それぞれ`true`もしくは`false`を返します。 そうでなければ、戻り値は、グローバルフラグ`prederror`に依存します。 `prederror`が`true`の時、 `is`はエラーメッセージを出力します。 そうでなければ、`is`は`unknown`を出力します。

  `ev(expr, pred)` (対話プロンプトでは、`expr, pred`と書けます) は、`is(expr)`と同値です。

  `assume`, `facts`, `maybe`も参照してください。

  例:

  `is`は述語論理の評価を引き起こします。

      (%i1) %pi > %e;
      (%o1)                       %pi > %e
      (%i2) is (%pi > %e);
      (%o2)                         true

  `is`は、`assume`データベースから述語論理を演繹しようとします。

      (%i1) assume (a > b);
      (%o1)                        [a > b]
      (%i2) assume (b > c);
      (%o2)                        [b > c]
      (%i3) is (a < b);
      (%o3)                         false
      (%i4) is (a > c);
      (%o4)                         true
      (%i5) is (equal (a, c));
      (%o5)                         false

  もし`is`が`assume`データベースから述語論理を証明もしくは否定できなかったら、 グローバルフラグ`prederror`が`is`の振る舞いを決めます。

      (%i1) assume (a > b);
      (%o1)                        [a > b]
      (%i2) prederror: true$
      (%i3) is (a > 0);
      Maxima was unable to evaluate the predicate:
      a > 0
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i4) prederror: false$
      (%i5) is (a > 0);
      (%o5)                        unknown

  Predicate functions ·Declarations and inferences ·

関数: killcontext (context_1, …, context_n)

  文脈context_1, …, context_nを消します。

  もし文脈の１つが現在の文脈なら、 新しい文脈は、 消されなかった現在の文脈の最初の利用可能な部分文脈になるでしょう。 もし最初の利用可能な消されなかった文脈が`global`なら、 `initial`が代わりに使われます。 もし`initial`文脈が消されたら、 新しい、空の`initial`文脈が生成されます。

  `killcontext`は、現在アクティブな文脈を消すことを拒否します。 なぜなら、それは現在の文脈の部分文脈、もしくは 関数`activate`の使用によってアクティブになっているから。

  `killcontext`は、引数を評価します。 `killcontext`は、`done`を返します。

  Declarations and inferences ·

関数: maybe (expr)

  述語論理exprが`assume`データベースの事実から正しいかどうかを 決定しようとします。

  もし述語論理が確かに`true`もしくは`false`なら、 `maybe`は、それぞれ`true`もしくは`false`を返します。 そうでなければ、`maybe`は`unknown`を返します。

  `maybe`は、`prederror: false`での`is`と関数的に同値です。 しかし、`prederror`に値を実際に割り当てることなく結果が計算されます。

  `assume`, `facts`, `is`も参照してください。

  例:

      (%i1) maybe (x > 0);
      (%o1)                        unknown
      (%i2) assume (x > 1);
      (%o2)                        [x > 1]
      (%i3) maybe (x > 0);
      (%o3)                         true

  Predicate functions ·Declarations and inferences ·

関数: newcontext (name)

  nameと呼ばれる新しい、空の文脈を生成します。 nameは、唯一の部分文脈として`global`を持ちます。 新しく生成された文脈は現在アクティブな文脈になります。

  `newcontext`は、引数を評価します。 `newcontext`は、nameを返します。

  Declarations and inferences ·

関数: sign (expr)

  現在のデータベースの事実に基づいてexprの符号を決定しようとします。 以下の答えの１つを返します; `pos` (positive), `neg` (negative), `zero`, `pz` (正もしくはゼロ), `nz` (負もしくはゼロ), `pn` (正もしくは負), or `pnz` (正、負もしくはゼロ、すなわちなにもわからない).

  Declarations and inferences ·

関数: supcontext (name, context)
関数: supcontext (name)

  nameと呼ばれる新しい文脈を生成します。 nameは、部分文脈としてcontextを持ちます。 contextは存在しなければいけません。

  もしcontextが指定されないなら、 現在の文脈が仮定されます。

  Declarations and inferences ·

Previous: Functions and Variables for Facts, Up: Maximas Database [Contents][Index]

### 11.4 Functions and Variables for Predicates

関数: charfun (p)

  述語論理pが`false`に評価される時、0を返します; 述語論理pが`true`に評価される時、1を返します。 述語論理が`true`も`false`でもない何かに評価される時(unknown), 名詞形を返します。

  例:

      (%i1) charfun (x < 1);
      (%o1)                    charfun(x < 1)
      (%i2) subst (x = -1, %);
      (%o2)                           1
      (%i3) e : charfun ('"and" (-1 < x, x < 1))$
      (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
      (%o4)                       [0, 1, 0]

  Mathematical functions ·

関数: compare (x, y)

  `is (x op y)`が `true`に評価されるような比較演算子op (`<`,`<=`,`>`,`>=`,`=`,`#`)を返します; xかyが `%i`に依存して、`x # `y``の時、 `notcomparable`を返します; 該当する演算子がなかったり、Maximaが演算子を決定できなかった時には `unknown`を返します。

  例:

      (%i1) compare (1, 2);
      (%o1)                           <
      (%i2) compare (1, x);
      (%o2)                        unknown
      (%i3) compare (%i, %i);
      (%o3)                           =
      (%i4) compare (%i, %i + 1);
      (%o4)                     notcomparable
      (%i5) compare (1/x, 0);
      (%o5)                           #
      (%i6) compare (x, abs(x));
      (%o6)                          <=

  関数`compare`は引数の実領域が空でないか決定しようとはしません; 従って、

      (%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
      (%o1)                           <

  `acos (x^2 + 1)`の実領域は空です。

  Declarations and inferences ·

特殊演算子: constant

  `declare (a, constant)`は、aを定数に宣言します。 `declare`を参照してください。

  Declarations and inferences ·Constants ·

関数: constantp (expr)

  もしexprが定数式なら、`true`を返します。 そうでなければ、`false`を返します。

  もし引数が、（`/R/`をつけて表示される有理数を含む）数や `%pi`, `%e`, `%i`にようなシンボル定数、 定数にバインドされた変数、`declare`で宣言された定数、 引数が定数の関数のいずれかなら、 式は定数式と考えられます。

  `constantp`は引数を評価します。

  例:

      (%i1) constantp (7 * sin(2));
      (%o1)                                true
      (%i2) constantp (rat (17/29));
      (%o2)                                true
      (%i3) constantp (%pi * sin(%e));
      (%o3)                                true
      (%i4) constantp (exp (x));
      (%o4)                                false
      (%i5) declare (x, constant);
      (%o5)                                done
      (%i6) constantp (exp (x));
      (%o6)                                true
      (%i7) constantp (foo (x) + bar (%e) + baz (2));
      (%o7)                                false
      (%i8)

  Predicate functions ·Constants ·

関数: equal (a, b)

  同値、すなわち、同じ値であることを表します。

  `equal`はそれ自身で評価も整理もされません。 関数`is`は、`equal`をブーリアン値に評価しようとします。 `is(equal(a, b)`は、 もしaとbが、`ratisimp(a - b)`を評価することで決定されるように、 変数の可能な値すべてで等しいときだけ`true`を返します; もし`ratsimp`が0を返したら、２つの式は同値と考えれます。 ２つの式は構文法的に等しくなくても（すなわち同一でなくても）同値でありえます。

  `is`が`equal`を`true`もしくは`false`への換算に失敗した時、 結果は、グローバルフラグ`prederror`に依ります。 `prederror`が`true`の時、`is`はエラーメッセージを出力します。 そうでなければ、`is`は`unknown`を返します。

  `is`に加えて、 いくつかの他の演算子、`if`, `and`, `or`, `not`は `equal`と`notequal`を`true`もしくは`false`に評価します。

  `equal`の否定が`notequal`です。

  例:

  `equal`はそれ自身で評価も整理もされません。

      (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
                              2
      (%o1)            equal(x  - 1, (x - 1) (x + 1))
      (%i2) equal (x, x + 1);
      (%o2)                    equal(x, x + 1)
      (%i3) equal (x, y);
      (%o3)                      equal(x, y)

  関数`is`は、`equal`をブーリアン値に評価しようとします。 `is(equal(a, b)`は、 `ratisimp(a - b)`が0を返すとき`true`を返します。 ２つの式は構文法的に等しくなくても（すなわち同一でなくても）同値でありえます。

      (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
      (%o1)                           0
      (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
      (%o2)                         true
      (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
      (%o3)                         false
      (%i4) ratsimp (x - (x + 1));
      (%o4)                          - 1
      (%i5) is (equal (x, x + 1));
      (%o5)                         false
      (%i6) is (x = x + 1);
      (%o6)                         false
      (%i7) ratsimp (x - y);
      (%o7)                         x - y
      (%i8) is (equal (x, y));
      (%o8)                        unknown
      (%i9) is (x = y);
      (%o9)                         false

  `is`が、`equal`を`true`もしくは`false`への換算に失敗したとき、 結果は、グローバルフラグ`prederror`に依ります。

      (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
                          2             2
      (%o1)             [x  + 2 x + 1, x  - 2 x - 1]
      (%i2) ratsimp (aa - bb);
      (%o2)                        4 x + 2
      (%i3) prederror : true;
      (%o3)                         true
      (%i4) is (equal (aa, bb));
      Maxima was unable to evaluate the predicate:
             2             2
      equal(x  + 2 x + 1, x  - 2 x - 1)
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i5) prederror : false;
      (%o5)                         false
      (%i6) is (equal (aa, bb));
      (%o6)                        unknown

  いくつかの演算子が`equal`や`notequal`を `true`もしくは`false`に評価します。

      (%i1) if equal (y, y - 1) then FOO else BAR;
      (%o1)                          BAR
      (%i2) eq_1 : equal (x, x + 1);
      (%o2)                    equal(x, x + 1)
      (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
                               2                   2
      (%o3)             equal(y  + 2 y + 1, (y + 1) )
      (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
      (%o4)                  [false, true, true]

  `not expr`は、exprの評価を伴うので、 `not equal(a, b)`は、`is(notequal(a, b))`と同値です。

      (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
      (%o1)            [notequal(2 z, 2 z - 1), true]
      (%i2) is (notequal (2*z, 2*z - 1));
      (%o2)                         true

  Operators ·

関数: notequal (a, b)

  `equal(a, b)`の否定を表します。

  例:

      (%i1) equal (a, b);
      (%o1)                      equal(a, b)
      (%i2) maybe (equal (a, b));
      (%o2)                        unknown
      (%i3) notequal (a, b);
      (%o3)                    notequal(a, b)
      (%i4) not equal (a, b);
      (%o4)                    notequal(a, b)
      (%i5) maybe (notequal (a, b));
      (%o5)                        unknown
      (%i6) assume (a > b);
      (%o6)                        [a > b]
      (%i7) equal (a, b);
      (%o7)                      equal(a, b)
      (%i8) maybe (equal (a, b));
      (%o8)                         false
      (%i9) notequal (a, b);
      (%o9)                    notequal(a, b)
      (%i10) maybe (notequal (a, b));
      (%o10)                        true

  Operators ·

関数: unknown (expr)]

  exprがMaximaの整理器が認識しない演算子や関数を含む時だけ、 `true`を返します。

  Predicate functions ·Simplification functions ·

関数: zeroequiv (expr, v)

  変数vの式exprがゼロと同値かどうかテストし、 `true`, `false`, もしくは`dontknow`を返します。

  `zeroequiv`は以下の制限を持ちます:

  1. Maximaが微分や評価する方法を知らない関数を使わない。
  2. もし式が実線上で極を持つなら、 結果としてエラーになります。（しかしこれは起こりにくいことです。）
  3. もし式が１階微分方程式の解ではない関数（例えばベッセル関数）を含むなら、 正しくない結果になるかもしれません。
  4. アルゴリズムは、注意深く選ばれた部分式に関してランダムに選ばれた点での評価を使います。 アルゴリズムはエラーの可能性を細小にしようとしますが、これはいつも危険な仕事です。

  例えば、`zeroequiv (sin(2 * x) - 2 * sin(x) * cos(x), x)`は`true`を返し、 `zeroequiv (%e^x + x, x)`は`false`を返します。 一方、 `zeroequiv (log(a * b) - log(a) - log(b), a)`は、 余分なパラメータ`b`があるので、`dontknow`を返します。

  Predicate functions ·

Next: File Input and Output, Previous: Maximas Database, Up: Top [Contents][Index]

## 12 Plotting

Next: Plotting Formats, Previous: Plotting, Up: Plotting [Contents][Index]

### 12.1 Introduction to Plotting

Maximaは、プロットするために、外部のプロットパッケージを使います （以下のPlottingフォーマットを参照してください）。 プロット関数は、点一式を計算し、コマンド一式と一緒にプロットパッケージに渡します。 その情報は、パイプを通したり、 データが保存されたファイル名と共にプログラムをコールすることで、 外部のプログラムに渡されます。 データファイルは名前`maxout.interface`を与えられます。 `interface`は使われるプロットインターフェース名 (gnuplot, xmaxima, mgnuplotまたはgnuplot_pipes)です。

`maxout.interface`ファイルが使われる場合、 システム変数maxima_tempdirで指定されたディレクトリに生成されます。 場所は変更できます; その変数に、Maximaが新しいファイルを作ることができる有効なディレクトリ を示す文字列を割り当てることで。

プロットが生成さられた後でも、 ファイル`maxout.interface`は、 適切な外部のプログラムで再度実行することができます。 もしMaximaのプロットコマンドが何かを表示するのに失敗したなら、 問題の可能性のある元をファイルで調べることができます。

この章で記述されたプロット関数と合わせて、 パッケージ `draw`は他の機能を加えます。 いくつかのプロットオプションはどちらのプロット文脈でも同じ名前が付けられていますが、 異なる構文を持つことに注意してください; もしこれらのオプションに関係した描画情報をアクセスしたいなら、 `?? opt`とタイプしなければいけません。ここで、`opt`はオプション名です。

Plotting ·

Next: Functions and Variables for Plotting, Previous: Introduction to Plotting, Up: Plotting [Contents][Index]

### 12.2 Plotting Formats

現在、Maximaが使う２つの外部のプロットプログラムがあります: GnuplotとXmaximaです。 これらのプログラムに対して様々な異なるフォーマットがあります。 それらは、オプション`plot_format`で選択することができます。 (Plotting Options節を参照してください。)

プロットフォーマットは以下の通りです:

- gnuplot (Windowsでのデフォルト)

  外部のプログラムgnuplotを起動するのに使われます。 gnuplotはあなたのシステムにインストールされていなければいけません。 すべてのプロットコマンドとデータは、ファイル`maxout.gnuplot`に保存されます。

- gnuplot_pipes (Windows以外のプラットフォームでのデフォルト)

  このフォーマットはWindowsプラットフォームでは利用できません。 `gnuplot`フォーマットと似ていますが、 データがファイル`maxout.gnuplot_pipes`に保存される一方、 コマンドがパイプを通してgnuplotに送られるところが違います。 gnuplotパイプが関数`gnuplot_close()`で閉じられない限り、 １つのgnuplotプロセスが開き続けて、続きのプロットコマンドは同じプロセスに送られ、 以前のプロットを置き換えます。 このフォーマットが使われる時、関数`gnuplot_replot`は スクリーン上に既に表示されたプロットを変更するのに使うことができます。 (`gnuplot_replot`を参照してください。)

  このフォーマットはスクリーンへのプロットするのにだけ使うべきです; ファイルへのプロットには`gnuplot`フォーマットを使ったほうがいいです。

- 値: `mgnuplot`

  Mgnuplotは、gnuplotのTkベースのラッパーです。 Maximaディストリビューションに含まれます。 Mgnuplotはgnuplotの基本的なGUIを提供しますが、gnuplotの素のインターフェースより 総合的な特長が少ないです。 Mgnuplotは、gnuplotとTckl/Tkを別途インストールする必要があります。

- xmaxima

  XmaximaはMaxima用Tcl/Tkグラフィカルインターフェースです。 これもまた、コンソールや他のグラフィカルインターフェースからMaximaを走らせた時、 生成されるプロットを表示するのに使うことができます。 このフォーマットを使うには、xmaximaプログラム―これはMaximaと一緒に配布されます― をインストールする必要があります。 もしMaximaをxmaxima自身から走らせるなら、 このフォーマットは、MaximaとXmaximaの間の通信に使われているのと同じソケットを通して、 プロット関数にデータとコマンドを送らせます。 コンソールや他のインターフェースから使われる時、 xmaximaプログラムはそのファイルの位置の名前を引数として起動されます。

  以前のバージョンでは、このフォーマットは`openmath`と呼ばれていました; その古い名前はまだ`xmaxima`に対する同義語として受け付けられます。

Plotting ·

Next: Plotting Options, Previous: Plotting Formats, Up: Plotting [Contents][Index]

### 12.3 Functions and Variables for Plotting

関数: contour_plot (expr, x_range, y_range, options, …)

  exprの等高線を、領域x_range、y_rangeでプロットします。 他の引数は、`plot3d`と同じように扱われます。

  この関数は、プロットフォーマットが`gnuplot`か`gnuplot_pipes`の時だけ、 動作します。 付加パッケージ`implicit_plot`も等高線をプロットするのに使われ、 それは任意のフォーマットで動作します。 `implicit_plot`も参照してください。

  例:

      (%i1) contour_plot (x^2 + y^2, [x, -4, 4], [y, -4, 4])$

      (%i1) F(x, y) := x^3 + y^2;
                                         3    2
      (%o1)                  F(x, y) := x  + y

      (%i2) contour_plot (F, [u, -4, 4], [v, -4, 4])$

  `plot3d`が受け付ける任意のオプションを足すことができます; 例えば、オプション`legend`にfalseの値を入れると、凡例を取り除きます。 Gnuplotはデフォルトで3つの高等線を示すように選びます。 レベルの数を増やすには、カスタムのgnuplot前置きを指定する必要があります;

      (%i1) contour_plot (u^3 + v^2, [u, -4, 4], [v, -4, 4],
                          [legend,false],
                          [gnuplot_preamble, "set cntrparam levels 12"])$

  Plotting ·

関数: get_plot_option (keyword, index)

  グローバル変数`plot_options`に保存されている 名前keywordを持つオプションの値を返します。 添字で1の値はキーワード自身を返します; 2番の値はキーワードに続く一番目のパラメータを返す、などなど。

  `plot_options`や`set_plot_option`、Plotting Optionの節も参照してください。

関数: make_transform ([var1, var2, var3], fx, fy, fz)

  plot3dのオプション`transform_xy`で使われるのに適した関数を返します。 3つの変数var1, var2, var3は3つのダミー変数名です。 それらは、plot3dコマンドが与える3変数 (最初2つの独立変数と、その後それら2つの変数に依存する関数)を表します。 3つの関数fx, fy, fzは、 それら3変数にだけ依存しなければいけなく、プロットすべき対応するx, y, z座標を与えます。 デフォルトで定義された2つの変換があります; `polar_to_xy`と`spherical_to_xyz`; それら2つの変換に関するドキュメンテーションを参照してください。

  Plotting ·

システム関数: polar_to_xy

  plot3dの`transform_xy`オプションに対する値として与えることができます。 その効果はplot3dの2つの独立変数をz軸からの距離と方位角(極座標)として通訳し、 それらをxとy座標に変換することです。

  Plotting ·

関数: plot2d (plot, x_range, …, options, …)
関数: plot2d ([plot_1, …, plot_n], …, options, …)
関数: plot2d ([plot_1, …, plot_n], x_range, …, options, …)

  ここで、plot, plot_1, …, plot_nは式か関数名、もしくは以下のいずれかの形式のリストです:

  `[discrete, [x1, ..., xn], [y1, ..., yn]]`, `[discrete, [[x1, y1], ..., [xn, ..., yn]]`, または`[parametric, x_expr, y_expr, t_range]`.

  １つもしくは複数の式を１変数か1パラメータの関数としてプロット表示します。

  `plot2d`は1つもしくは複数のプロットを2次元に表示します。 プロットを定義するのに式や関数名を使う時には、 それらは１変数varだけに依存すべきであり、 変数名とその最小値と最大値を提供するためにx_rangeの使用が必須です; x_rangeの構文法は以下の通りです:

  `[variable, min, max]`

  プロットを、離散形式やパラメトリック形式で定義することもできます。 離散形式は既定の座標で表された点の集合をプロットするのに使われます。 離散プロットは、キーワードdiscreteで始まり、 値についてのリスト1つか2つが続くリストで定義されます。 もし2つのリストが与えられたら、それらは同じ長さを持たなければいけません; 1番目のリストはプロットされる点のx座標として、 2番目のリストはy座標として解釈されます。 もしdiscreteキーワードの後、1つのリストだけ与えられたら、 リスト上のそれぞれの要素は、点のxとy座標に対応する2つの値を持つリストでなければいけません。

  パラメトリックプロットは、 キーワードparametricで始まり、 2つの式か関数名と、パラメータの範囲が続くリストで定義されます。 パラメータの範囲は、パラメータ名とその最小値、最大値が続くリストでなければいけません:

  `[param, min, max]`。

  paramがminからmaxに増えるにつれ、 2つの式または関数で与えられる座標の点によって描かれる軌跡をプロットは表示します。

  垂直軸の範囲は以下の形式を持つオプション引数です:

  `[y, min, max]`(キーワードyはいつも垂直軸に使われます)。

  もしこのオプションを使ったなら、 プロットが到達する値と別に、ちょうどオプションの垂直範囲をプロットは表示します。 もし垂直範囲を指定しなかったなら、プロット点のy座標の最小値と最大値に従って、 垂直範囲が設定されます。

  他のすべてのオプションも、 キーワードで始まり、1つか複数の値が続くリストでなければいけません。 `plot_options`を参照してください。

  もし複数のプロットがプロットされるなら、式のそれぞれを識別するために凡例が書かれます。 その凡例で使われるラベルは、オプションlegendで与えることができます。 もしそのオプションが使われないなら、Maximaは式や関数名からラベルを生成します。

  例:

  よくある関数のプロット:

      (%i1) plot2d (sin(x), [x, -%pi, %pi])$

  もし関数の増大が速すぎるなら、yオプションを使って、垂直軸の値を制限する必要があるかもしれません:

      (%i1) plot2d (sec(x), [x, -2, 2], [y, -20, 20])$
      plot2d: some values were clipped.

  プロットの外観は使うプロットプログラムに依存して異なるかもしれません。 プロットボックスが使用不可能になっている時、Xmaximaは矢印を使って軸をプロットします:

      (%i1) plot2d ( x^2-1, [x, -3, 3], [y, -2, 10],
                            [box, false], [plot_format, xmaxima])$

  対数プロットの例:

      (%i11) plot2d (exp(3*s), [s, -2, 2], [logy])$

  関数を名前でプロット:

      (%i1) F(x) := x^2 $

      (%i2) :lisp (defun |$g| (x) (m* x x x))
      $g

      (%i2) H(x) := if x < 0 then x^4 - 1 else 1 - x^5 $
      (%i3) plot2d ([F, G, H], [u, -1, 1], [y, -1.5, 1.5])$

  パラメトリックに定義されたバタフライカーブのプロット:

      (%i1) r: (exp(cos(t))-2*cos(4*t)-sin(t/12)^5)$
      (%i2) plot2d([parametric, r*sin(t), r*cos(t),
                   [t, -8*%pi, 8*%pi], [nticks, 2000]])$

  7点だけでプロットする時の2回転「円」:

      (%i1) plot2d ([parametric, cos(t), sin(t),
                    [t, -2*%pi, 2*%pi], [nticks, 8]])$

  円のパラメトリック表現と一緒に、よくある関数のプロット。 プロットのサイズは、円を丸く、楕円のように変形しないように、 xとyオプションで調整されています。 これらの値は、このプロットを生成するのに使われたPostscript端末ではうまく機能します; あなたはあなたのスクリーンのために値を調整しなければいけないかもしれません。

      (%i1) plot2d([[parametric, cos(t), sin(t),
                    [t,0,2*%pi], [nticks, 80]],
              abs(x)], [x,-2,2], [y, -1.5, 1.5])$
      plot2d: some values were clipped.

  x座標、y座標を別々に定義した点の離散集合のプロット:

      (%i1) plot2d ([discrete, [10, 20, 30, 40, 50],
                               [.6, .9, 1.1, 1.3, 1.4]])$

  それぞれの点を別々に定義し、点を繋ぐ線をなくした、前の例で示された同じ点:

      (%i1) plot2d([discrete, [[10, .6], [20, .9], [30, 1.1],
                               [40, 1.3], [50, 1.4]]],
                              [style, points])$

  この例では、3つの列を持つテーブルがファイル”data.txt”に保存され、 読み込まれ、2番目、3番目の列は2つの軸上にプロットされます:

      (%i1) with_stdout ("data.txt", for x:0 thru 10 do
                                         print (x, x^2, x^3))$
      (%i2) data: transpose ( read_matrix ("data.txt"))$

      (%i3) plot2d ([discrete, transpose(data)[2], transpose(data)[3]],
        [style,points], [point_type,diamond], [color,red])$

  実験データ点を、データを予測する理論的関数と一緒にプロット:

      (%i1) xy: [[10, .6], [20, .9], [30, 1.1], [40, 1.3], [50, 1.4]]$

      (%i2) plot2d([[discrete, xy], 2*%pi*sqrt(l/980)], [l,0,50],
              [style, points, lines], [color, red, blue],
              [point_type, asterisk],
              [legend, "experiment", "theory"],
              [xlabel, "pendulum's length (cm)"],
              [ylabel, "period (s)"])$

  プロットオプションに関する節も参照してください。

  Plotting ·

関数: plot3d (expr, x_range, y_range, …, options, …)
関数: plot3d ([expr_1, expr_2, expr_3], x_range, y_range, …, options, …)

  ２変数関数もしくはパラメトリック形式で定義された、１つか複数の表面のプロットを表示します。

  プロットされる関数は、式か関数名として指定できます。 違った側面から表面を見るためにマウスを使ってプロットを回転することができます。

  例:

  よくある関数のプロット:

      (%i1) plot3d (2^(-u^2 + v^2), [u, -3, 3], [v, -2, 2]);

  無限大に発散する関数を制限するためのzオプションの使用(この場合、関数はxとy軸上でマイナス無限だい); これは線のみ陰影なしでプロットする仕方も示します。

      (%i1) plot3d ( log ( x^2*y^2 ), [x, -2, 2], [y, -2, 2], [z, -8, 4],
                     [palette, false], [color, magenta, blue])$

  zの無限大は、いかなる漸近線上にも落ちないグリッドを選ぶことによっても避けることができます; この例は事前に定義されたパレットの1つ、この場合4番目のものを選択する仕方も示します:

      (%i1) plot3d( log (x^2*y^2), [x, -2, 2], [y, -2, 2],
               [grid, 29, 29],
               [palette, get_plot_option(palette,5)])$

  同じ領域を共有する同じプロットでの2つの表面; gnuplotでは2つの表面は同じパレットを使用します:

      (%i1) plot3d ([2^(-x^2 + y^2), 4*sin(3*(x^2+y^2))/(x^2+y^2),
                    [x, -3, 3], [y, -2, 2]])$

  異なる領域を持つ、同じ2つの表面; xmaximaでは、それぞれの表面は、オプションパレットで定義されたリストから選ばれた 異なるパレットを使います:

      (%i1) plot3d ( [[2^(-x^2 + y^2),[x,-2,2],[y,-2,2]],
               4*sin(3*(x^2+y^2))/(x^2+y^2),
               [x, -3, 3], [y, -2, 2]], [plot_format,xmaxima])$

  パラメトリックに定義されたKleinの壷のプロット:

      (%i1) expr_1:5*cos(x)*(cos(x/2)*cos(y)+sin(x/2)*sin(2*y)+3.0)-10.0$
      (%i2) expr_2:-5*sin(x)*(cos(x/2)*cos(y) + sin(x/2)*sin(2*y) + 3.0)$
      (%i3) expr_3: 5*(-sin(x/2)*cos(y) + cos(x/2)*sin(2*y))$

      (%i4) plot3d ([expr_1, expr_2, expr_3], [x, -%pi, %pi],
              [y, -%pi, %pi], [grid, 40, 40])$

  球座標から直交座標に変換するのにあらかじめ定義された変換`spherical_to_xyz` を使った球調和のプロット。 `spherical_to_xyz`に関するドキュメンテーションを参照してください。

      (%i1) plot3d (sin(2*theta)*cos(phi), [theta, 0, %pi],
                    [phi, 0, 2*%pi],
                    [transform_xy, spherical_to_xyz], [grid,30,60])$

  円筒座標から直交座標に変換するのにあらかじめ定義された変換`polar_to_xyz` を使った球面調和関数のプロット。 `polarl_to_xyz`に関するドキュメンテーションを参照してください。 この例は境界ボックスと凡例を消去する仕方も示します。

      (%i1) plot3d (r^.33*cos(th/3), [r, 0, 1], [th, 0, 6*%pi],
               [grid, 12, 80],
               [transform_xy, polar_to_xy], [box, false],
               [legend,false])$

  球座標から直交座標への変換を使っての球のプロット。 xmaximaでは、球の対称形を維持するように3つの軸は同じ比でスケールされます。 同一色で異なる陰影のパレットが使われます:

      (%i1) plot3d ( 5, [theta, 0, %pi], [phi, 0, 2*%pi],
               [plot_format,xmaxima],
               [transform_xy, spherical_to_xyz],
               [palette,[value,0.65,0.7,0.1,0.9]])$

  行列を使った2変数関数の定義。 関数の定義の中のシングルクォートに注意してください。 行列が整数添字を要求する状況に実際に至る時、plot3dが失敗しないためのものです。

      (%i1) M: matrix([1, 2, 3, 4], [1, 2, 3, 2], [1, 2, 3, 4],
                      [1, 2, 3, 3])$
      (%i2) f(x, y) := float('M [round(x), round(y)])$

      (%i3) plot3d (f(x,y), [x, 1, 4], [y, 1, 4], [grid, 4, 4])$
      apply: subscript must be an integer; found: round(x)

  elevationを零の等しく設定することで， 表面は地図として見ることができます。 その地図は、それぞれの色は違ったレベルを表現します。 オプション`colorbox`は、 色とレベルの対応を示すのに使われます。 メッシュ線を使用不可にし、色が見やすいようにしています。

      (%i1) plot3d (cos (-x^2 + y^3/4), [x, -4, 4], [y, -4, 4],
              [mesh_lines_color, false], [elevation, 0], [azimuth, 0],
              [colorbox, true], [grid, 150, 150])$

  プロットオプションについての節も参照してください。

  Plotting ·

システム変数: plot_options

  このリストの要素は、プロットのデフォルトオプションを指定します。 もし`plot2d`もしくは`plot3d`がコールされる時、オプションが指定されたら、 その値は、デフォルトオプションより優先されます。 そうでなければ、`plot_options`の中の値が使われます。 デフォルトオプションは、`set_plot_option`を使って割り当てられます。 それぞれのプロットコマンドに特化したローカルオプションがあり、それらは、この、グローバルオプションのリストには含まれません。

  `plot_options`のそれぞれの要素は、２つ以上の項目のリストです。 最初の項目はオプション名で、残りはオプションに割り当てられる値です。 いくつかの場合、割り当てられた値はリストであり、複数の項目からなることがあります。

  `set_plot_option`と`get_option`、プロットオプションの節も参照してください。

  Plotting ·

関数: set_plot_option (option)

  プロットオプションの節にリストされているオプションのほとんどを受け付け、 それらをグローバル変数`plot_options`に保存します。

  `set_plot_option`は引数を評価し、 (与えられたオプションを変更した後、)完全なリスト`plot_options`を返します。

  `plot_options`と`get_option`、プロットオプションの節も参照してください。

  例:

  `grid`値の変更。

      (%i1) set_plot_option ([grid, 30, 40]);

      (%o1) [[t, - 3, 3], [grid, 30, 40], [transform_xy, false],
      [run_viewer, true], [axes, true], [plot_format, gnuplot_pipes],
      [color, blue, red, green, magenta, black, cyan],
      [point_type, bullet, circle, plus, times, asterisk, box, square,
      triangle, delta, wedge, nabla, diamond, lozenge],
      [palette, [hue, 0.25, 0.7, 0.8, 0.5],
      [hue, 0.65, 0.8, 0.9, 0.55], [hue, 0.55, 0.8, 0.9, 0.4],
      [hue, 0.95, 0.7, 0.8, 0.5]], [gnuplot_term, default],
      [gnuplot_out_file, false], [nticks, 29], [adapt_depth, 5],
      [gnuplot_preamble, ], [gnuplot_default_term_command,
      set term pop], [gnuplot_dumb_term_command, set term dumb 79 22],
      [gnuplot_ps_term_command, set size 1.5, 1.5;set term postscript ¥
      eps enhanced color solid 24], [plot_realpart, false]]

  Plotting ·

システム関数: spherical_to_xyz

  plot3dの`transform_xy`オプションに対する値として与えることができます。 その効果はplot3dでの2つの独立変数と関数を点の球座標 (1番目はz軸に対する角度、次にxy射影のx軸に対する角度、最後に原点からの距離) として解釈し、それらをx,y,z座標に変換することです。

  Plotting ·

Next: Gnuplot Options, Previous: Functions and Variables for Plotting, Up: Plotting [Contents][Index]

### 12.4 Plotting Options

すべてのオプションは、この節のキーワードの1つで始まり、 1つ以上の値が続くリストで構成されます。 オプションのほとんどは (plot2d, plot3d, contour_plot, implicit_plot) どのプロットコマンドでも。また関数set_plot_optionの中でも使うことができます; 例外は以下のリストで指定されます。

プロットオプション: adapt_depth [adapt_depth, integer]

  適応プロットルーチンで使われる分割の最大数です。

  デフォルト値: 5

  Plotting ·

プロットオプション: axes [axes, symbol]

  ここで、symbolは`true`, `false`, `x`, `y`のいずれかでありえます。 もし`false`なら、軸は表示されません; もし`x`か`y`に等しいなら、xかy軸のみが表示され、 `true`に等しいなら、両方の軸が表示されます。 このオプションはplot2dとimplicit_plotだけが使います。

  デフォルト値: `true`

  Plotting ·

プロットオプション: azimuth [azimuth, number]

  plot3dプロットは plot2dと同様の水平軸と垂直軸に関してx軸とy軸と、 紙から垂直に出てくるz軸で始まるものと考えることができます。 z軸はその後x軸の回りに`elevation`に等しい角度だけ回転され、 その後、xy平面は新しいz軸の回りに角度`azimuth`だけ回転されます。 このオプションはazimuthに関する値を単位、度で設定します。

  デフォルト値: 30

  `elevation`も参照してください。

  Plotting ·

プロットオプション: box [box, symbol]

  もし`true`に設定されるなら、 境界枠がプロットに表示されます; もし`false`に設定されるなら、 枠は表示されません。

  デフォルト値: `true`

  Plotting ·

プロットオプション: color [color, color_1, …, color_n]

  plot2dとimplicit_plotでは、様々な曲線の色を定義します。 plot3dでは、パレットが使われない時、表面のメッシュ線の色を定義します; 表面の片方の側面は色`color_1`を持ち、逆の側面はcolor_2を(またはもし1つの色しかないなら、同じ色を)持ちます。

  もし色よりも曲線や表面が多いなら、色は順に繰り返されます。 gnuplotを使う時、色は、 青、赤、緑、マゼンタ、シアンまたは黒です; xmaximaでは、色はそれらもしくは文字#で始まり、6桁の16進数字が続く文字列です; 2つは赤成分、2つは緑成分、2つが青成分です。 もし未知の色の名前が与えられたら、黒が代わりに使われます。

  デフォルト値: blue, red, green, magenta, black, byan

  Plotting ·

プロットオプション: colorbox [colorbox, symbol]

  ここで、symbolは`true`か`false`であり得ます。 もし`true`なら、 plot3dはzの違った値を表現するために、 違った色のパレットを使う時はいつでも、 zの値の大きさに従って使われた色を示す枠が右に示されます。 このオプションはxmaximaでは機能しません。

  デフォルト値: `false`

  Plotting ·

プロットオプション: elevation [elevation, number]

  plot3dプロットは plot2dでの水平と垂直軸にxとy軸に 紙から直立に立ったz軸から始まると考えられます。 その後、z軸はx軸の回りを `elevation`に等しい角度だけ回転し、 xy平面は新しいz軸の回りを `azimuth`角度だけ回転します。 このオプションはelevationの値を度単位で設定します。

  デフォルト値: 60

  `azimuth`も参照してください。

  Plotting ·

プロットオプション: grid [grid, integer, integer]

  3次元プロットのためにx方向、y方向で使われるグリッド点の数を設定します。

  デフォルト値: 30, 30

  Plotting ·

プロットオプション: legend [legend, string_1, …, string_n]
プロットオプション: legend [legend, false]

  複数のプロットが示される時、プロットのラベルを指定します。 もし与えられたラベルの数より多くの式があるなら、ラベルは繰り返されます。 もし値`false`が与えられるなら、凡例は表示されません。 デフォルトでは、式や関数の名前が使われます。また、点の離散集合に関しては、 単語discrete1, discrete2, …が使われます。 このオプションはset_plot_optiionで設定することができます。

  Plotting ·

プロットオプション: logx [logx]

  水平軸を対数的にスケールするようにします。 set_plot_optionでは使うことはできません。

  Plotting ·

プロットオプション: logy [logy]

  垂直軸を対数的にスケールするようにします。 set_plot_optionでは使うことはできません。

  Plotting ·

Plot option: mesh_lines_color [mesh_lines_color, color]

  パレットが使われる時、plot3dがメッシュ線を描くのに使う色を設定します。 オプション `color`と同じ色を受け付けます。 (`color`で許される色のリストを参照してください。) 値 `false`を与えて、メッシュ線を完全に消すこともできます。

  デフォルト値: black

  Plotting ·

プロットオプション: nticks [nticks, integer]

  plot2dで関数をプロットする時、 関数をプロットするための適応プロットルーチンによって使われる点の数の初期値を与えます。 plot2dやplot3dでパラメトリック関数をプロットする時、 プロットで表示される点の数を設定します。

  デフォルト値: 29

  Plotting ·

プロットオプション: palette [palette, [palette_1], ..., [palette_n]]
プロットオプション: palette [palette, false]

  1つのパレットか複数のパレットのリストで構成されます。 それぞれのパレットは4つの数が続くキーワード付きリストです。 最初の3つの数は、0と1の間でなければならず、 zの最小値に割り当てられる基本色の色調と飽和、値を定義します。 キーワードは3つの属性(色調、飽和、値)のいずれかがzの値に従っての増えることを指定します。 その最後の数は1よりも大きいこともマイナスでもありえます; 変更された属性の対応する値は法1で丸められます。

  gnuplotはリストの中の最初のパレットだけを使います; xmaximaは、複数の表面が一緒にプロットされる時、リストの中のパレットを順に使います; パレットの数が尽きたら、それらは順に繰り返されます。

  メッシュ線の色はオプション`mesh_lines_color`で与えられます。 もし`palette`が値`false`を与えられたら、 表面は陰影されず、曲線のメッシュだけで表されます。 その場合、線の色はオプション`color`で決定されます。

  デフォルト値: [hue, 0.25, 0.7, 0.8, 0.5], [hue, 0.65, 0.8, 0.9, 0.55], [hue, 0.55, 0.8, 0.9, 0.4], [hue, 0.95, 0.7, 0.8, 0.5]

  Plotting ·

プロットオプション: plot_format [plot_format, format]

  ここでformatは以下のいずれかです; gnuplot, xmaxima, mgnuplot, gnuplot_pipes.

  プロットで使われるフォーマットを設定します。

  デフォルト値: Windowsシステムではgnuplot, 他のシステムではgnuplot_pipes

  Plotting ·

プロットオプション: plot_real_part [plot_real_part, symbol]

  `true`に設定される時、プロットされる関数は 実数値がプロットされる複素関数と見なされます; これは`realpart(function)`をプロットすることと同値です。 もし`false`に設定されたら、 関数が実数値を与えない時には何も表示されません。 例えば、`x`が負の時、`log(x)`は、 実数値が`log(abs(x))`に等しい複素数値を与えます; もし`plot_real_part` が`true`だったなら、 `log(-5)`は`log(5)`としてプロットされますが、 もし`plot_real_part` が`false`だったなら、 何もプロットされません。

  デフォルト値: `false`

  Plotting ·

プロットオプション: point_type [point_type, type_1, …, type_n]

  gnuplotでは、 , each set of points to be plotted with the style スタイル“points”か“linespoints”でプロットされた点のそれぞれの集合は このリストから取られたオブジェクトで順に表されます。 もしこのリスト内のオブジェクト以上に点の集合があるなら、 それらは順に繰り返されます。 使うことができる可能なオブジェクト: bullet, circle, plus, times, asterisk, box, square,triangle, delta, wedge, nabla, diamond, lozenge

  デフォルト値: bullet, circle, plus, times, asterisk, box, square,triangle, delta, wedge, nabla, diamond, lozenge

  Plotting ·

プロットオプション: psfile [psfile, string]

  このオプションは、プロットをスクリーンに表示する代わりに、 stringに等しい名前のポストスクリプトファイルに保存します。 デフォルトでは、そのファイルは、変数maxima_tempdirで定義されたディレクトリに 生成されます; 変数の値を変えて、違うディレクトリにファイルを保存できます。

  Plotting ·

プロットオプション: run_viewer [run_viewer, symbol]

  プロットフォーマット用の適切なビューアを走らせるかどうか制御します。

  デフォルト値: `true`

  Plotting ·

プロットオプション: style [style, type_1, …, type1_n]
プロットオプション: style [style, [style_1], …, [style_n]]

  様々な関数やデータ一式のために2dプロットで使われるスタイル。 単語styleの後には、１つ以上のスタイルが続きます。 もし与えられたスタイルよりも多くの関数やデータ集合があったら、スタイルは繰り返されます。 それぞれのスタイルは、実線のためにはlines、孤立点のためにはpoints、 線分と孤立点のためにはlinespoints、点線のためにはdotsを取り得ます。 Gnuplotでは、impulsesスタイルも使えます。

  スタイルのそれぞれは、いくつかの追加のパラメータとリストの中に入れることができます。 linesは、１つか２つの数を取ります: 線の太さと、色を指定する整数。 デフォルトの色コードは、1: 青, 2: 赤, 3: マゼンタ, 4: オレンジ, 5: ブラウン, 6: ライム, 7: アクア、です。 もしX11ではない端末でGnuplotを使うなら、これらの色は、違っているかもしれません; 例えば、もしオプション[gnuplot_term,ps]を使うなら、色インデックス4は、 オレンジではなく、黒に対応します。

  pointsは、１つか２つか３つのパラメータを取ります; 最初のパラメータは、点の半径、 ２番目のパラメータは、同じ色を選択する（linesで使われるコードと同じ）整数、 ３番目のパラメータは現在、Gnuplotでだけ使われており、点の代わりにいくつかのオブジェクトに対応します。オブジェクトのデフォルト値は、1: 黒丸, 2: 白丸, 3: 十字, 4: ×, 5: 米印, 6: 黒四角, 7: 白四角, 8: 黒三角, 9: 白三角, 10: 黒逆三角, 11: 白逆三角, 12: 黒菱形, 13: 白菱形、です。

  linesdotsは、４つまでのパラメータを取ります; 線の太さ、点の半径、色、点を置き換えるオブジェクトのタイプ。

  デフォルト値: lines (太さ1で、オプション`color`で与えられた最初の色を持つ線で結んだ点一式をプロットします)

  `color`と`point_type`も参照してください。

  Plotting ·

プロットオプション: t [t, min, max]

  パラメトリックプロットのデフォルトの範囲。

  デフォルト値: -3, 3

  Plotting ·

プロットオプション: transform_xy [transform_xy, symbol]

  ここで、symbolは`false`か 関数`transform_xy`を使うことで得られる結果をとり得ます。 もし`false`と違うなら、 plot3dで3座標を変換するのに使われます。

  デフォルト値: `false`

  `make_transform`, `polar_to_xy`, `spherical_to_xyz`を参照してください。

  Plotting ·

プロットオプション: x [x, min, max]

  2dプロットコマンドの最初の(またはplot3dの最初の二つのどちらかの) オプションとして使われる時、 1番目の独立変数がxであることを示し、その範囲を設定します。 最初のオプションの後(またはplot3dでは2番目のオプションの後)、 プロット内で示される有効な水平領域を定義するために、 再び使うことができます。

  Plotting ·

プロットオプション: xlabel [xlabel, string]

  1番目の軸をラベルするstringを指定します; もしこのオプションが使われないなら、 plot2dかimplicit_plotで関数をプロットする時、そのラベルは独立変数の名前です。 plot3dで表面を、もしくはcontour_plotで等高線をプロットする時、 そのラベルは1番目の変数の名前です。 パラメトリックプロットの場合、1番目の式です。 set_plot_optionでは使うことはできません。

  Plotting ·

プロットオプション: y [y, min, max]

  plot3dでの最初の2つのオプションの1つとして使われる時、 独立変数の1つがyであることを示し、その範囲を設定します。 そうでなければ、 プロットで示される2番目の変数の有効領域を定義します。

  Plotting ·

プロットオプション: ylabel [ylabel, string]

  二番目の軸をラベルするstringを指定します; もしこのオプションが使われないなら、 plot2dやimplicit_plotで関数をプロットする時、そのラベルは、”y”となり、 plot3dで表面をプロットするときや、contour_plotで等高線をプロットする時、 二番目の変数名となり、 パラメトリックプロットの場合には、二番目の式になります。 set_plot_optionでは使うことはできません。

  Plotting ·

プロットオプション: z [z, min, max]

  プロットで示されるzの値の有効範囲を設定するためにplot3dで使われます。

  Plotting ·

プロットオプション: zlabel [zlabel, string]

  plot3dを使う時、第三軸をラベルするstringを指定します。 もしこのオプションが使われないなら、 そのラベルは、 表面をプロットする時は“z”となり、 パラメトリックプロットの場合には三番目の式になります。 set_plot_optionでは使うことはできません。 また、plot2d, implicit_plotでは無視されます。

  Plotting ·

Next: Gnuplot_pipes Format Functions, Previous: Plotting Options, Up: Plotting [Contents][Index]

### 12.5 Gnuplot Options

gnuplotに特化したプロットオプションがいくつかあります。 これらのオプションのいくつかは、gnuplotコマンドそのもので、文字列として指定されます。 詳細はgnuplotドキュメンテーションを参照してください。 ほとんどの場合、これらのオプションは、 より一般的な上記のオプションの１つで置き換えることができます; これらの場合、より一般的な形式を使うことをお勧めします。

プロットオプション: gnuplot_term

  gnuplot用の出力端末タイプを設定します。

  - default (デフォルト値)

    Gnuplot出力が、別のグラフィカルなウィンドウに表示されます。

  - dumb

    Gnuplot出力が、Mグラフィックスの"ASCIIアート"近似で、Maximaコンソールに表示されます。

  - ps

    Gnuplotが、ポストスクリプトページ記述言語でコマンドを生成します。 もしオプション`gnuplot_out_file`がfilenameに設定されているなら、 gnuplotは、filenameにポストスクリプトコマンドを書きます。 そうでなければ、`maxplot.ps`ファイルとして保存します。

  - 他のいかなる有効なgnuplot端末仕様

    Gnuplotは、png, jpeg, svgのような多くの他のグラフィカルフォーマットで出力を 生成することができます。 これらのフォーマットすべてでプロットを生成するに、`gnuplot_term`に 任意のサポートされたgnuplot端末名(シンボル)もしくは、任意の有効なオプションを伴う gnuplot端末フル仕様(文字列)さえ設定できます。 例えば、`[gnuplot_term,png]`は、PNG (Portable Network Graphics)形式で 出力を生成する一方、`[gnuplot_term,"png size 1000,1000"]`は、 1000x1000ピクセルサイズのPNGを生成します。

    もしオプション`gnuplot_out_file`がfilenameに設定されたら、 gnuplotは、filenameに出力を書き込みます。 そうでなければ、`maxplot.term`ファイルに書き込みます。 ここで、termはgnuplot端末名です。

  Plotting ·

プロットオプション: gnuplot_out_file

  `gnuplot_term`オプションと関連して使われる時、 Gnuplotがサポートするグラフィックフォーマットの１つで、 ファイルにプロットを保存するのに使われます。 もしポストスクリプトファイルを生成したければ、 代わりにオプション `psfile`を使うことができます。 これは、Openmathでも機能し、たった１つのオプションで同じことができます。

      [gnuplot_term, png], [gnuplot_out_file, "graph3.png"]

  Plotting ·

プロットオプション: gnuplot_pm3d

  `false`の値では、PM3Dモードの使用を抑制するのに使われます。 PM3Dモードはデフォルトで使用可能です。

  Plotting ·

プロットオプション: gnuplot_preamble

  プロットを描く前に、gnuplotコマンドを挿入します。 有効などんなgnuplotコマンドも使うことができます。 複数のコマンドは、セミコロンで分離されなければいけません。 示される例はログスケールプロットを生成します。 `gnuplot_preamble`のデフォルト値は、空の文字列`""`です。

  Plotting ·

プロットオプション: gnuplot_curve_titles

  これは、上記で記載したlegendで置き換えられた古いオプションです。

  Plotting ·

プロットオプション: gnuplot_curve_styles

  これは、上記で記載したstyleで置き換えられた古いオプションです。

  Plotting ·

プロットオプション: gnuplot_default_term_command

  デフォルト端末の端末タイプを設定するgnuplotコマンド。 デフォルト値は、`set term pop`です。

  Plotting ·

プロットオプション: gnuplot_dumb_term_command

  ダム端末の端末タイプを設定するgnuplotコマンド。 デフォルト値は、`"set term dumb 79 22"`です。 これは、79文字 x 22文字のテキスト出力を生成します。

  Plotting ·

プロットオプション: gnuplot_ps_term_command

  ポストスクリプト端末の端末タイプを設定するgnuplotコマンド。 デフォルト値は、 `"set size 1.5, 1.5; set term postscript eps enhanced color solid 24"`, です。 これは、サイズをgnuplotのデフォルトの1.5倍に設定し、フォントサイズを24に設定などします。 `set term postscript`の詳細については、gnuplotドキュメンテーションを 参照してください。

  Plotting ·

Previous: Gnuplot Options, Up: Plotting [Contents][Index]

### 12.6 Gnuplot_pipes Format Functions

関数: gnuplot_start ()

  `gnuplot_pipes`フォーマットでのプロットのため使われるgnuplotへのパイプを開きます。 プロットの前に手動でパイプを開く必要はありません。

  Plotting ·

関数: gnuplot_close ()

  `gnuplot_pipes`フォーマットで使われたgnuplotへのパイプを閉じます。

  Plotting ·

関数: gnuplot_restart ()

  `gnuplot_pipes`フォーマットで使われたgnuplotへのパイプを閉じて、 新しいパイプを開きます。

  Plotting ·

関数: gnuplot_replot ()
関数: gnuplot_replot (s)

  gnuplotウィンドウを更新します。 もし`gnuplot_replot`が、文字列sの中のgnuplotコマンドを引数としてコールされたなら、 `s`はウィンドウが再プロットされる前にgnuplotに送られます。

  Plotting ·

関数: gnuplot_reset ()

  `gnuplot_pipes`フォーマットと一緒に使われるgnuplotの状態をリセットします。 gnuplotウィンドウを更新するには、 `gnuplot_reset`の後に`gnuplot_replot`をコールください。

  Plotting ·

Next: Polynomials, Previous: Plotting, Up: Top [Contents][Index]

## 13 File Input and Output

Next: Files, Previous: File Input and Output, Up: File Input and Output [Contents][Index]

### 13.1 Comments

Maximaの入力の中のコメントは、`/*`と`*/`の間の任意のテキストです。

Maximaのパーサは、コメントを、入力外リームでのトークンを見つけるための空白として扱います; コメントで常にトークンは終わります。 `a/* foo */b`のような入力は、１つのトークン`ab`ではなく、２つのトークン、`a`と`b`を含みます。 そうでなければ、Maximaはコメントを無視します; コメントの中身も位置もパースされた入力式に残りません。

コメントは任意の深さに入れ子にすることができます。 `/*`と`*/`の区切り記号はマッチングペアを形作ります。 `/*`の数は`*/`と同じでなければいけません。

例:

    (%i1) /* aa is a variable of interest */  aa : 1234;
    (%o1)                         1234
    (%i2) /* Value of bb depends on aa */  bb : aa^2;
    (%o2)                        1522756
    (%i3) /* User-defined infix operator */  infix ("b");
    (%o3)                           b
    (%i4) /* Parses same as a b c, not abc */  a/* foo */b/* bar */c;
    (%o4)                         a b c
    (%i5) /* Comments /* can be nested /* to any depth */ */ */  1 + xyz;
    (%o5)                        xyz + 1

Syntax ·

Next: Functions and Variables for File Input and Output, Previous: Comments, Up: File Input and Output [Contents][Index]

### 13.2 Files

ファイルは、単に、データやテキスト含む、特別なストレージデバイスのある領域です。 ディスク上のファイルは、比喩的に「ディレクトリ」の中にグループ化されます。 ディレクトリは、単にファイルのリストです。 ファイルを扱うコマンドは以下の通りです:

`save`, `load`, `loadfile`, `stringout`, `batch`, `demo`, `writefile`, `closefile`,と `appendfile`。

ファイル名が`plot2d`や`save`、`writefile`のような関数に渡され、 ファイル名がパスを含まない時、Maximaは現在のワーキングディレクトリにファイルを保存します。 現在のワーキングディレクトリはWindowsやLinuxのようなシステムと、インストールに依存します。

Previous: Files, Up: File Input and Output [Contents][Index]

### 13.3 Functions and Variables for File Input and Output

関数: appendfile (filename)

  コンソールの筆記録をfilenameに追加します。 `appendfile`は、 筆記録ファイルが、存在すれば、いつも追加されることを除いて、 `writefile`と同じです。

  `closefile`は、`appendfile`や`writefile`によって開かれた筆記録ファイルを閉じます。

  File output ·Console interaction ·

関数: batch (filename)
関数: batch (filename, `option`)

  `batch(filename)`はMaximaの式をfilenameから読み込み、評価します。 `batch`は、リスト`file_search_maxima`の中でfilenameを検索します。 `file_search`も参照してください。

  `batch(filename, `demo`)`は、 `demo(filename)`ようなものです。 この場合、`batch`は、リスト`file_search_demo`の中で filenameを検索します。 `demo`を参照してください。

  `batch(filename, `test`)`は、 オプション`display_all=true`を付けた`run_testsuite`ようなものです。 この場合、`batch`は、 `run_testsuite`のようにリスト`file_search_tests`ではなく、 リスト`file_search_maxima`の中でfilenameを検索します。 更に、`run_testsuite`はリスト`testsuite_files`の中にあるテストを実行します。 `batch`を使うと、どんなファイルもテストモードで実行することが可能です。 ファイルはリスト`file_search_maxima`の中であってもいいです。 これはテストファイルを書いている時に便利です。

  filenameは、一連のMaximaの式より成り、それぞれの式は、`;`もしくは`$`で終了します。 特殊変数`%`と関数`%th`は、ファイル内での前の結果を参照します。 ファイルは`:lisp`構成子を含むかもしれません。 ファイルの中の空白、タブ、改行は無視されます。 適した入力ファイルは、テキストエディタもしくは、`stringout`関数で作ることができます。

  `batch`は、それぞれの入力式をfilenameから読み込み、 入力をコンソールに表示し、 対応する出力式を計算し、 出力式を表示します。 入力ラベルは入力式に割り当てられ、出力ラベルは出力式に割り当てられます。 `batch`は、エラーがない限り、ファイルの中のすべての入力式を評価します。 もしユーザー入力が（例えば、`asksign`や`askinteger`によって）要求されたら、 `batch`は、ポーズして必要な入力を入手し、続けます。

  コンソールで`control-C`をタイプすることで、`batch`を停止させることが可能かもしれません。 `control-C`の効果は、基礎となるLispの実装に依存します。

  `batch`にはいくつか用法があります。 役立つコマンドラインの蓄積を供給したり、 エラーのないデモンストレーションを与えたり、 複雑な問題を解く時、人の考えを整理するのを助けたり。

  `batch`は引数を評価します。 第二引数なしで呼び出されたり、オプション`demo`で呼び出された時、 `batch`は`filename`のパスを文字列として返します。 オプション`test`で呼び出された時、 戻り値は、空のリスト`[]`か、filenameと失敗したテストの数を含むリストです。

  `load`, `batchload`, `demo`も参照してください。

  Session management ·File input ·

関数: batchload (filename)

  filenameからMaximaの式を読み込み、評価します。 入力式や出力式を表示しません。 ラベルを出力式に割り当てません。 しかし、（`print`や`describe`が生成するような)プリント文の出力は表示されます。

  特殊変数`%`や関数`%th`は、 ファイルの中の結果ではなく、対話インタープリタからの以前の結果を参照します。 ファイルは`:lisp`構成子を含むことはできません。

  `batchload`は、filenameのパスを文字列として返します。 `batchload`は引数を評価します。

  `batch`や`load`も参照してください。

  Session management ·File input ·

関数: closefile ()

  `writefile`や`appendfile`で開いたトランスクリプトファイルを閉じます。

  File output ·Console interaction ·

オプション変数: file_output_append

  デフォルト値: `false`

  `file_output_append`は、 ファイル出力関数が出力ファイルに追加するか、ファイルを切り詰めるか決めます。 `file_output_append`が`true`の時、 ファイル出力関数は出力ファイルに追加します。 そうでなければ，出力ファイルは切り詰められます。

  `save`, `stringout`, `with_stdout`は、`file_output_append`を考慮します。 出力ファイルを書き出す他の関数は`file_output_append`を考慮しません。 特に、プロット感巣や変換関数は常に出力ファイルを切り詰め、 `tex`や`appendfile`はいつも追加します。

  File output ·Global flags ·

関数: filename_merge (path, filename)

  pathとfilenameから修正されたパスを構成します。 もし、pathの最後の構成要素が形式`###.something`なら、 構成要素は、`filename.something`に置き換えられます。 そうでなければ、最後の構成要素は単にfilenameに置き換えられます。

  結果はLispのパス名オブジェクトです。

  File input ·File output ·

関数: file_search (filename)
関数: file_search (filename, pathlist)

  `file_search`は、ファイルfilenameを検索し、 もし見つかれば、（文字列として）ファイルへのパスを返します; そうでなければ、`file_search`は`false`を返します。 `file_search (filename)`は、 デフォルトのサーチディレクトリを検索します。 デフォルトのサーチディレクトリは、`file_search_maxima`, `file_search_lisp`, `file_search_demo`変数によって指定されます。

  `file_search`は、 名前を「ワイルドカード」ファイルサーチパターンにマッチさせようとする前に、 最初に、渡された実際の名前が存在するかチェックします。 ファイルサーチパターンに関連した`file_search_maxima`を参照してください。

  引数filenameは、パスとファイル名、もしくは単にファイル名、もしくは、 もしファイルサーチディレクトリがファイルサーチパターンを含むなら、単にファイル名のベース（拡張子なし）、を取り得ます。 例えば、

      file_search ("/home/wfs/special/zeta.mac");
      file_search ("zeta.mac");
      file_search ("zeta");

  ファイルが存在していて、`/home/wfs/special/###.mac`が`file_search_maxima`に中にあるという仮定の下で、上記すべては同じファイルを見つけます。

  `file_search (filename, pathlist)`は、 pathlistによって指定されたディレクトリの中だけを検索します。 ここで、pathlistは文字列のりすとです。 引数pathlistは、デフォルトの検索ディレクトリに取って代わります。 だから、もしパスリストが与えられたら、デフォルトの検索ディレクトリのいずれでもなく、`file_search`は指定されたところだけを検索します。 pathlistの中に１つのディレクトリだけしかない場合でさえ、まだ、 それは、要素１つのリストとして与えられなければいけません。

  ユーザーはデフォルト検索ディレクトリを修正できます。 `file_search_maxima`を参照してください。

  `file_search`は、`file_search_maxima`と`file_search_lisp`を を検索ディレクトリとして、 `load`によって呼び出されます。

  File input ·

オプション変数: file_search_maxima
オプション変数: file_search_lisp
オプション変数: file_search_demo
オプション変数: file_search_usage
オプション変数: file_search_tests

  これらの変数は、`load`, `demo`や他のいくつかのMaximaの関数が検索する ディレクトリのリストを指定します。 これらの変数のデフォルト値は、Maxima員ストレーションの様々なディレクトリを名指ししています。

  ユーザーは、 デフォルト値を置き換えるか、ディレクトリを追加することで、 これらの変数を変更できます 例えば、

      file_search_maxima: ["/usr/local/foo/###.mac",
          "/usr/local/bar/###.mac"]$

  は、`file_search_maxima`のデフォルト値を置き換える一方、

      file_search_maxima: append (file_search_maxima,
          ["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$

  は、２つのディレクトリを追加します。 ファイル`maxima-init.mac`に Maximaが起動した時にファイル検索パスが自動的に割り当てられるような式を入れておくと便利かもしれません。 Introduction for Runtime Environmentも参照してください。

  特別な「ワイルドカード」構造によって、ファイル名の拡張子やパスを多重にしてすることができます。 文字列`###`は、求められている名前に拡張される一方、 カーリ括弧`{foo,bar,baz}`で囲まれた、コンマで分離されたリストは多重文字列に拡張されます。 例えば、求められてる名前が`neumann`とすると、

      "/home/{wfs,gcj}/###.{lisp,mac}"

  は、`/home/wfs/neumann.lisp`, `/home/gcj/neumann.lisp`, `/home/wfs/neumann.mac`, `/home/gcj/neumann.mac`に展開されます。

  File input ·Global variables ·

関数: file_type (filename)

  filenameの中身について、ファイル名拡張子を下に、推測を返します。 filenameは、実際のファイルを参照する必要はありません; ファイルを開いたり、中身を探索したりはしません。

  戻り値はシンボルであり、`object`, `lisp`, `maxima`のいずれかです。 もし拡張子が`file_type_maxima`の中の値の1つと一致したら、 `file_type`は`maxima`を返します。 もし拡張子が"`file_type_lisp`の中の値の1つと一致したら、 `file_type`は`lisp`を返します。 上のいずれでもないなら、`file_type`は`object`を返します。

  `pathname_type`も参照してください。

  デフォルト値に関しては、`file_type_maxima`と`file_type_lisp`を 参照してください。

  例:

      (%i2) map('file_type,
                ["test.lisp", "test.mac", "test.dem", "test.txt"]);
      (%o2)            [lisp, maxima, maxima, object]

  File input ·

オプション変数: file_type_lisp

  デフォルト値: `[l, lsp, lisp]`

  `file_type_lisp`は、 maximaがLispソースファイルの印として認識するファイル拡張子のリストです。

  `file_type`も参照してください。

オプション変数: file_type_maxima

  デフォルト値: `[mac, mc, demo, dem, dm1, dm2, dm3, dmt]`

  `file_type_maxima`は、 maximaがMaximaソースファイルの印として認識するファイル拡張子のリストです。

  `file_type`も参照してください。

関数: load (filename)

  filenameの中の式を評価します。 そして、変数、関数、他のオブジェクトをMaximaにもたらします。 、filenameから再生されたバインドは存在するオブジェクトのバインドを上書きします(clobber)。 ファイルを見つけるために、 `load`は、探索ディレクトリとして`file_search_maxima`と`file_search_lisp`を引数として`file_search`をコールします。 もし`load`が成功したら ファイルの名前を返します。 そうでなければ、`load`はエラーメッセージを出力します。

  `load`は、LispコードでもMaximaコードでも等しく機能します。 `save`, `translate_file`, `compile_file`―これらはLispコードを生成します―が生成したファイルはすべて`load`によって処理できます。 `load`は、Lispファイルをロードするために`loadfile`をコールし、 Maximaファイルをロードするために`batchload`をコールします。

  `load`は、Maximaファイルの中で`:lisp`構成子を認識しません。 filenameを処理する時、 グローバル変数`_`, `__`, `%`, `%th`は、 `load`がコールされた時バインドされていた値を持ちます。

  `loadfile`, `batch`, `batchload`, `demo`も参照してください。 `loadfile`はLispファイルを処理します; `batch`, `batchload`, `demo`はMaximaファイルを処理します。

  ファイル探索メカニズムについてもっと詳しいことは`file_search`を参照してください。

  `load`は引数を評価します。

  Session management ·File input ·

システム変数: load_pathname

  デフォルト値: `false`

  関数`load`や、`loadfile`、`batchload`を使ってファイルがロードされる時、 システム変数`load_pathname`は処理するファイルのパス名を示します。

  変数`load_pathname`はロード中にファイルからアクセスすることができます。

  例:

  ディレクトリ

  `"/home/dieter/workspace/mymaxima/temp/"`に、以下のコマンドを含む

  バッチファイル`test.mac`があるとしましょう。

      print("The value of load_pathname is: ", load_pathname)$
      print("End of batchfile")$

  すると、以下の出力を得ます。

      (%i1) load("/home/dieter/workspace/mymaxima/temp/test.mac")$
      The value of load_pathname is:
                         /home/dieter/workspace/mymaxima/temp/test.mac
      End of batchfile

  File input ·

関数: loadfile (filename)

  filenameの中のLisp式を評価します。 `loadfile`は、`file_search`を呼び出しません。 だから、`filename`はファイル拡張子とファイルを見つけるのに必要なパスも含まなければいけません。

  `loadfile`は、`save`, `translate_file`, `compile_file`によって生成されたファイルを処理できます。 ユーザーは、`loadfile`の代わりに`load`を使うほうが便利だと気づくでしょう。

  Session management ·File input ·

オプション変数: loadprint

  デフォルト値: `true`

  `loadprint`は、ファイルがロードされた時、メッセージを表示するかどうか告げます。

  - `loadprint`が`true`の時, いつもメッセージを表示します。
  - `loadprint`が`'loadfile`の時, ファイルが関数`loadfile`によってロードされた時だけメッセージを表示します。
  - `loadprint`が`'autoload`の時、 ファイルが自動的にロードされた時だけメッセージを表示します。 `setup_autoload`を参照してください。
  - `loadprint`が`false`の時, メッセージは決して表示されません。
  File input ·Global flags ·

オプション変数: packagefile

  デフォルト値: `false`

  他の人が使うパッケージ（ファイル）を生成するために`save`や`translate`を使う パッケージデザイナは、 ファイルがロードされる時必要な場合を除いて、 Maximaの情報リスト（例えば、`values`, `functions`）に情報が追加されることを抑制するために、`packagefile: true`を設定したいかもしれません。 この方法によれば、 ユーザーが自身のデータを追加した時ユーザーの方法では パッケージの中身は、得られないでしょう。 これは、起こりうる名前衝突の問題を解決はしないことに注意してください。 このフラグは、パッケージファイルへの出力であるものに素直に影響することにも注意してください。 フラグを`true`に設定することは、 Maxima初期化ファイルを生成するにも役に立ちます。

  Translation flags and variables ·

関数: pathname_directory (pathname)
関数: pathname_name (pathname)
関数: pathname_type (pathname)

  これらの関数はpathnameの構成要素を返します。

  例:

      (%i1) pathname_directory("/home/dieter/maxima/changelog.txt");
      (%o1)                 /home/dieter/maxima/
      (%i2) pathname_name("/home/dieter/maxima/changelog.txt");
      (%o2)                       changelog
      (%i3) pathname_type("/home/dieter/maxima/changelog.txt");
      (%o3)                          txt

  File input ·

関数: printfile (path)

  pathという名前のファイルをコンソールに表示します。 pathは、文字列もしくはシンボルです; もしシンボルなら、文字列に変換されます。

  もしpathが現在のワーキングディレクトリからアクセス可能なファイル名なら、 そのファイルがコンソールに表示されます。 そうでなければ、 `printfile`は、 `filename_merge`を介して`file_search_usage`の要素のそれぞれに pathを追加することでファイルを見つけようとします。

  `printfile`は、もしpathが存在しているファイルを示しているなら、 pathを返し、そうでなければ、 成功したファイル名マージの結果を返します。

  File input ·Console interaction ·

関数: tcl_output (list, i0, skip)
関数: tcl_output (list, i0)
関数: tcl_output ([list_1, …, list_n], i)

  リストの要素を、 カーリ括弧`{ }`で囲んで表示します。 Tcl/Tk言語でプログラムの一部として適した形です。

  `tcl_output (list, i0, skip)` は、 要素i0で始まり、要素`i0 + skip`, `i0 + 2 skip`, などを表示するよう、listを表示します。

  `tcl_output (list, i0)`は、 `tcl_output (list, i0, 2)`と同値です。

  `tcl_output ([list_1, ..., list_n], i)`は、 list_1, …, list_nのi番目の要素を表示します。

  例:

      (%i1) tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$

       {1.000000000     4.000000000
       }
      (%i2) tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$

       {2.000000000     5.000000000
       }
      (%i3) tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$

       {((RAT SIMP) 3 7) ((RAT SIMP) 11 13)
       }
      (%i4) tcl_output ([x1, y1, x2, y2, x3, y3], 2)$

       {$Y1 $Y2 $Y3
       }
      (%i5) tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$

       {SIMP 1.000000000     11.00000000
       }

関数: save (filename, name_1, name_2, name_3, …)
関数: save (filename, values, functions, labels, …)
関数: save (filename, [m, n])
関数: save (filename, name_1=expr_1, …)
関数: save (filename, all)
関数: save (filename, name_1=expr_1, name_2=expr_2, …)

  filenameに、name_1, name_2, name_3, …,の現在値を 保存します。 引数は、変数、関数、他のオブジェクトの名前です。 もし名前が関連づけられた値や関数を持たないなら、無視されます。 `save`は、filenameを返します。

  `save`は、データをLisp式の形式で保存します。 `save`で保存されたデータは、`load (filename)`によって回復できます。 `load`を参照してください。

  グローバルフラグ `file_output_append`は、 `save`が出力ファイルに追加するか、切り詰めるか決めます。 `file_output_append`が`true`の時、 `save`は出力ファイルに追加します。 そうでなければ、`save`は出力ファイルを切り詰めます。 どちらの場合も、もしファイルが存在しなければ、`save`はファイルを生成します。

  特殊形式`save (filename, values, functions, labels, ...)` は、`values`, `functions`, `labels`, などと名付けられた項目を 保存します。 名前は、変数`infolists`によって指定された任意のものです。 `values`は、ユーザー定義変数すべてから成ります。

  特殊形式`save (filename, [m, n])`は、 mからnまでの入力ラベル、出力ラベルの値を保存します。 mとnは、整数リテラルでなければならないことに注意してください。 例えば、`save ("foo.1", %i42, %o42)`のように、 入力ラベル、出力ラベルは１つ１つ保存することもできます。 `save (filename, labels)`は、 入力ラベル出力ラベルすべてを保存します。 保存されたラベルが回復された時、それらは存在していたラベルを負かします。

  特殊形式`save (filename, name_1=expr_1, name_2=expr_2, ...)`は、 expr_1, expr_2, …,の値をname_1, name_2, …という名前で保存します。 例えば、`save ("foo.1", aa=%o88)`のように、 この形式を入力ラベル出力ラベルに適用することは便利です。 この形式の等式の右辺は任意の式であり、その式は評価されます。 この形式は、新しい名前を現在のMaximaの環境に導入はせず、 ただ、filenameにそれらを保存します。

  これらの特殊形式と`save`の一般形式は自由に混在させることができます。 例えば、`save (filename, aa, bb, cc=42, functions, [11, 17])`。

  特殊形式`save (filename, all)`は、Maximaの現在の状態を保存します。 これは、自動的に定義された項目はもちろん、ユーザー定義の変数、関数、配列などすべてを 含みます。 保存される項目は、 もしそれらがユーザーによって新しい値を割り当てられたなら、 `file_search_maxima`や`showtime`のようなシステム変数を含みます。 `myoptions`を参照してください。

  `save`はfilenameを評価し、他の引数すべてをクォートします。

  Session management ·File output ·

関数: stringout (filename, expr_1, expr_2, expr_3, …)
関数: stringout (filename, [m, n])
関数: stringout (filename, input)
関数: stringout (filename, functions)
関数: stringout (filename, values)

  `stringout`は、 式が入力としてタイプされたのと同じ形式で、式をファイルに書き込みます。 なので、ファイルは`batch`や`demo`コマンドの入力として使えますし、 どんな目的のためでも編集できます。 `stringout`は、`writefile`が進行中の間に実行することができます。

  グローバルフラグ`file_output_append`は、 `stringout`が出力ファイルに追加するか、切り詰めるか決めます。 `file_output_append`が`true`の時、 `stringout`は、出力ファイルに追加します。 そうでなければ、`stringout`は出力ファイルを切り詰めます。 どちらの場合も、もしファイルが存在しなければ，`stringout`はファイルを生成します。

  `stringout`の一般形式は、１つ以上の式の値を出力ファイルに書き込みます。 もし式が変数なら、変数の値だけが書き込まれ、変数名は書き込まれないことに注意してください。 役に立つ特殊な場合として、式は、 入力ラベル(`%i1`, `%i2`, `%i3`, …)もしくは出力ラベル(`%o1`, `%o2`, `%o3`, …)でもよいです。 ）

  もし`grind`が`true`なら、 `stringout`は、`grind`フォーマットを使って出力をフォーマットします。 そうでなければ、`string`フォーマットが使われます。 `grind`と`string`を参照してください。

  特殊形式`stringout (filename, [m, n])`は、 mからnまでの入力ラベルの値を書き込みます。

  特殊形式 `stringout (filename, input)`は、 入力ラベルすべてをファイルに書き込みます。

  特殊形式`stringout (filename, functions)`は、 （グローバルリスト`functions`で名付けられた）ユーザー定義関数すべてをファイルに書き込みます。

  特殊形式`stringout (filename, values)`は、 （グローバルリスト`values`で名付けられた）ユーザーが割り当てた変数すべてをファイルに書き込みます。 変数それぞれは、変数名とコロンとその値という割り当て文として出力されます。 `stringout`の一般形式は変数を割り当て文として出力しないことに注意してください。

  Session management ·File output ·

関数: tex (expr)
関数: tex (expr, destination)
関数: tex (expr, false)
関数: tex (label)
関数: tex (label, destination)
関数: tex (label, false)

  TeXドキュメントの準備に適した式の表現を出力します。 結果は、ドキュメントの断片です。 それは、より大きなドキュメントにコピーすることができますが、それ自身では処理されません。

  `tex (expr)`は、exprのTeX表現をコンソールに出力します。

  `tex (label)`は、labelで名付けられた式のTeX表現を出力し、 （式の左に表示されるよう）等式ラベルをそれに割り当てます。 TeX等式ラベルは、Maximaラベルと同じです。

  destinationは、出力ストリームもしくはファイル名です。 destinationがファイル名の時、 `tex`は、ファイルに出力を追加します。 関数`openw`と`opena`は、出力ストリームを生成します。

  `tex (expr, false)`と`tex (label, false)`は、 TeX出力を文字列として返します。

  `tex`は、最初の引数がラベルかどうか見るためにテストした後、最初の引数を評価します。 クォートクォート`''`は、引数の評価を強制し、 その結果、テストをだめにして、ラベルを妨げます。

  `texput`も参照してください。

  例:

      (%i1) integrate (1/(1+x^3), x);
                                          2 x - 1
                        2            atan(-------)
                   log(x  - x + 1)        sqrt(3)    log(x + 1)
      (%o1)      - --------------- + ------------- + ----------
                          6             sqrt(3)          3
      (%i2) tex (%o1);
      $$-{{\log \left(x^2-x+1\right)}\over{6}}+{{\arctan \left({{2\,x-1
       }\over{\sqrt{3}}}\right)}\over{\sqrt{3}}}+{{\log \left(x+1\right)
       }\over{3}}\leqno{\tt (\%o1)}$$
      (%o2)                          (\%o1)
      (%i3) tex (integrate (sin(x), x));
      $$-\cos x$$
      (%o3)                           false
      (%i4) tex (%o1, "foo.tex");
      (%o4)                          (\%o1)

  `tex (expr, false)`はTeX出力を文字列として返します。

      (%i1) S : tex (x * y * z, false);
      (%o1) $$x\,y\,z$$
      (%i2) S;
      (%o2) $$x\,y\,z$$

  TeX output ·File output ·

関数: tex1 (e)

  式eのTeX出力を表現する文字列を返します。 TeX出力は、等式や他の任意の環境のため、区切り記号で囲まれません。

  例:

      (%i1) tex1 (sin(x) + cos(x));
      (%o1)                     \sin x+\cos x

関数: texput (a, s)
関数: texput (a, f)
関数: texput (a, s, operator_type)
関数: texput (a, [s_1, s_2], matchfix)
関数: texput (a, [s_1, s_2, s_3], matchfix)

  アトムaのためのTeX出力を割り当てます。 ここでaはシンボルもしくは演算子名です。

  `texput (a, s)`は、 `tex`関数に、 aの代わりに文字列sをTeX出力に入れるようにさせます。

  `texput (a, f)`は、 `tex`関数に、 TeX出力を生成するために関数fをコールさせます。 fは、１つの引数を受け入れなければいけません。 ここで、引数は、演算子aを持つ式で、文字列（TeX出力）を返さなければいけません。 fは、入力式の引数のためにTeX出力を生成するよう、`tex1`をコールするかもしれません。

  operator_typeが`prefix`, `infix`, `postfix`, `nary`, もしくは `nofix`,として、 `texput (a, s, operator_type)`は、 `tex`関数に aの代わりにsをTeX出力に入れるようにさせ、 適切な位置に挿入された手キスを置くようにさせます。

  `texput (a, [s_1, s_2], matchfix)`は、 `tex`関数に、 aの引数のそれぞれの側にs_1とs_2を TeX出力に入れるようにさせます。 （もし複数なら）引数はコンマで分離されます。

  `texput (a, [s_1, s_2, s_3], matchfix)`は、 `tex`関数に、 引数を分離するs_3と一緒に aの引数のそれぞれの側にs_1とs_2をTeX出力に入れるようにさせます。

  例:

  変数にTeX出力を割り当てます。

      (%i1) texput (me,"\\mu_e");
      (%o1)                         \mu_e
      (%i2) tex (me);
      $$\mu_e$$
      (%o2)                         false

  任意の関数（演算子ではない）にTeX出力を割り当てます。

      (%i1) texput (lcm, "\\mathrm{lcm}");
      (%o1)                     \mathrm{lcm}
      (%i2) tex (lcm (a, b));
      $$\mathrm{lcm}\left(a , b\right)$$
      (%o2)                         false

  TeX出力を生成する関数をコールします。

      (%i1) texfoo (e) := block ([a, b], [a, b] : args (e),
        concat ("\\left[\\stackrel{",tex1(b),"}{",tex1(a),"}\\right]"))$
      (%i2) texput (foo, texfoo);
      (%o2)                        texfoo
      (%i3) tex (foo (2^x, %pi));
      $$\left[\stackrel{\pi}{2^{x}}\right]$$
      (%o3)                         false

  前置演算子にTeX出力を割り当てます。

      (%i1) prefix ("grad");
      (%o1)                         grad
      (%i2) texput ("grad", " \\nabla ", prefix);
      (%o2)                        \nabla
      (%i3) tex (grad f);
      $$ \nabla f$$
      (%o3)                         false

  中置演算子にTeX出力を割り当てます。

      (%i1) infix ("~");
      (%o1)                           ~
      (%i2) texput ("~", " \\times ", infix);
      (%o2)                        \times
      (%i3) tex (a ~ b);
      $$a \times b$$
      (%o3)                         false

  後置演算子にTeX出力を割り当てます。

      (%i1) postfix ("##");
      (%o1)                          ##
      (%i2) texput ("##", "!!", postfix);
      (%o2)                          !!
      (%i3) tex (x ##);
      $$x!!$$
      (%o3)                         false

  n項演算子にTeX出力を割り当てます。

      (%i1) nary ("@@");
      (%o1)                          @@
      (%i2) texput ("@@", " \\circ ", nary);
      (%o2)                         \circ
      (%i3) tex (a @@ b @@ c @@ d);
      $$a \circ b \circ c \circ d$$
      (%o3)                         false

  無項演算子にTeX出力を割り当てます。

      (%i1) nofix ("foo");
      (%o1)                          foo
      (%i2) texput ("foo", "\\mathsc{foo}", nofix);
      (%o2)                     \mathsc{foo}
      (%i3) tex (foo);
      $$\mathsc{foo}$$
      (%o3)                         false

  マッチフィックス演算子にTeX出力を割り当てます。

      (%i1) matchfix ("<<", ">>");
      (%o1)                          <<
      (%i2) texput ("<<", [" \\langle ", " \\rangle "], matchfix);
      (%o2)                [ \langle ,  \rangle ]
      (%i3) tex (<<a>>);
      $$ \langle a \rangle $$
      (%o3)                         false
      (%i4) tex (<<a, b>>);
      $$ \langle a , b \rangle $$
      (%o4)                         false
      (%i5) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"],
            matchfix);
      (%o5)           [ \langle ,  \rangle ,  \, | \,]
      (%i6) tex (<<a>>);
      $$ \langle a \rangle $$
      (%o6)                         false
      (%i7) tex (<<a, b>>);
      $$ \langle a \, | \,b \rangle $$
      (%o7)                         false

  TeX output ·

関数: get_tex_environment (op)
関数: set_tex_environment (op, before, after)

  `tex`によって出力されるTeX環境をカスタマイズします。 これらの関数によって保持されるように、TeX環境は２つの文字列から成ります; １つは他の任意のTeX出力に前もって出力されるもの、もう１つは後に出力されるものです。

  式のトップレベル演算子のTeX環境だけが、出力されます; 他の演算子に関連づけられたTeX環境は無視されます。

  `get_tex_environment`は、 演算子opに適用されたTeX環境を返します; もし他の環境が割り当てられていなければ、デフォルトを返します。

  `set_tex_environment`は、 演算子opのためのTeX環境を割り当てます。

  例:

      (%i1) get_tex_environment (":=");
      (%o1) [
      \begin{verbatim}
      , ;
      \end{verbatim}
      ]
      (%i2) tex (f (x) := 1 - x);

      \begin{verbatim}
      f(x):=1-x;
      \end{verbatim}

      (%o2)                         false
      (%i3) set_tex_environment (":=", "$$", "$$");
      (%o3)                       [$$, $$]
      (%i4) tex (f (x) := 1 - x);
      $$f(x):=1-x$$
      (%o4)                         false

  TeX output ·

関数: get_tex_environment_default ()
関数: set_tex_environment_default (before, after)

  `tex`によって出力されるTeX環境をカスタマイズします。 これらの関数によって保持されるように、TeX環境は２つの文字列から成ります; １つは他の任意のTeX出力に前もって出力されるもの、もう１つは後に出力されるものです。

  `get_tex_environment_default`は、 トップレベル演算子が（`set_tex_environment`で割り当てられたような）特定のTeX環境を持たない式に適用されたTeX環境を返します。

  `set_tex_environment_default`は、デフォルトのTeX環境を割り当てます。

  例:

      (%i1) get_tex_environment_default ();
      (%o1)                       [$$, $$]
      (%i2) tex (f(x) + g(x));
      $$g\left(x\right)+f\left(x\right)$$
      (%o2)                         false
      (%i3) set_tex_environment_default ("\\begin{equation}
      ", "
      \\end{equation}");
      (%o3) [\begin{equation}
      ,
      \end{equation}]
      (%i4) tex (f(x) + g(x));
      \begin{equation}
      g\left(x\right)+f\left(x\right)
      \end{equation}
      (%o4)                         false

  TeX output ·

関数: with_stdout (f, expr_1, expr_2, expr_3, …)
関数: with_stdout (s, expr_1, expr_2, expr_3, …)

  expr_1, expr_2, expr_3, ...を評価し、 生成された出力すべてをファイルfもしくは出力ストリームsに書き込みます。 評価される式は出力に書き込まれません。 出力は、`print`, `display`, `grind`や他の関数によって生成されたものです。

  グローバルフラグ `file_output_append`は、 `with_stdout`が出力ファイルfに追加するか切り詰めるか決めます。 `file_output_append`が`true`の時、 `with_stdout`は出力ファイルに追加します。 そうでなければ、`with_stdout`は出力ファイルを切り詰めます。 どちらの場合も、もしファイルが存在しないなら、`with_stdout`はファイルを生成します。

  `with_stdout`は最後の引数の値を返します。

  `writefile`も参照してください。

      (%i1) with_stdout ("tmp.out", for i:5 thru 10 do
            print (i, "! yields", i!))$
      (%i2) printfile ("tmp.out")$
      5 ! yields 120
      6 ! yields 720
      7 ! yields 5040
      8 ! yields 40320
      9 ! yields 362880
      10 ! yields 3628800

  File output ·

関数: writefile (filename)

  Maximaセッションのトランスクリプトをfilenameに書き込むことを開始します。 ユーザーとMaximaの間の対話すべてが、ちょうどコンソールに現れるように、このファイルに記録されます。

  トランスクリプトがコンソール出力フォーマットで出力されるので、 それはMaximaに再ロードすることはできません。 最ロード可能な式を含むファイルを作るには、 `save`と`stringout`を参照してください。 `save`は、Lisp形式の式を保存する一方、`stringout`は、Maxima形式 の式を保存します。

  filenameが既に存在している時、`writefile`の実行の効果は、 基礎となるLisp実装に依存します; トランスクリプファイルは負かされるかもしれませんし、ファイルは追加されるかもしれません。 `appendfile`は、いつもトランスクリプトファイルに追加します。

  以前の対話の表示を保存するために`writefile`の後、 `playback`を実行するのが便利かもしれません。 `playback`は入力と出力変数(`%i1`, `%o1`, など)だけを表示し、 （戻り値と対照的に）関数の中のプリント文によって生成された任意の出力は`playback`によって表示されません。

  `closefile`は、`writefile`や`appendfile`が開いたトランスクリプトファイルを閉じます。

  File output ·Console interaction ·

Next: Special Functions, Previous: File Input and Output, Up: Top [Contents][Index]

## 14 Polynomials

Next: Functions and Variables for Polynomials, Previous: Polynomials, Up: Polynomials [Contents][Index]

### 14.1 Introduction to Polynomials

多項式は、Maximaの中では、一般形もしくは、標準有理式(CRE)形として記憶されます。 後者は標準形であり、factor, ratsimpなどのような演算によって内部で使われます。

標準有理式は、特に （RATFACが`true`に設定された時の部分的に因数分解された多項式や有理関数はもちろん） 展開された多項式や有理関数に適したある種の表現を構成します。 このCRE形では、変数の（最もメインから最小にまでの）順序付けは、 式それぞれに仮定されます。 多項式は、一連の式の対が続く主変数から成るリストによって再帰的に表現されます。 それぞれの対の最初のメンバーは、その項の主変数の指数であり、 ２番目のメンバーは、その項の係数で、係数は、数、もしくは、再度の形式で表現された別の変数の多項式です。 このように、3*X^2-1のCRE形の主要な部分は、(X 2 3 0 -1)であり、 2*X*Y+X-3のそれは、 Yが主変数と仮定すると(Y 1 (X 1 2) 0 (X 1 1 0 -3)) であり、 Xが主変数と仮定すると(X 1 (Y 1 2 0 1) 0 -3)です。 「主」であることは、普通、アルファベットの逆順で決定されます。 CRE式の「変数」はアトムである必要はありません。 実査、主演算子が+ - * /でも、整数べきの^でもない任意の部分式は、 それが式の中で現れると、（CRE形の）式の「変数」と考えられます。 例えば、式X+SIN(X+1)+2*SQRT(X)+1のCRE変数は、XとSQRT(X)、SIN(X+1)です。 もしユーザーがRATVARS関数を使って変数の順序付けを指定しないなら、 Maximaはアルファベットの順序付けを選びます。 一般に、CREは、有理式、すなわち、分子と分母が共通因子を持たず、分母が正の多項式の比を表します。 内部形は、本質的に、変数順序付けリストが先行する多項式の対（分子と分母）です。 もし表示される式がCRE形なら、もしくはもしCRE形の部分式を含むなら、 シンボル/R/が行ラベルに続きます。 式をCRE形に変換することに関してはRAT関数を参照してください。 拡張CRE形は、テイラー級数の表現に使われます。 有理式の概念が拡張され、変数の指数は、単に正の整数ではなく、正の有理数も負の有理数も取ることができ、係数はそれ自身単なる多項式ではなく上で記載された有理式を取ることができます。 これらは内部的にはCRE形に似ていて、その一般化である再帰多項式形によって表現されます。 それは、切り詰めの次数のような追加の情報を持ちます。 CRE形として、そんな式の行ラベルにはシンボル/T/が続きます。

Polynomials ·Rational expressions ·

Previous: Introduction to Polynomials, Up: Polynomials [Contents][Index]

### 14.2 Functions and Variables for Polynomials

オプション変数: algebraic

  デフォルト値: `false`

  代数的整数の整理の効果が現れるようにするためには、 `algebraic`は`true`に設定されなければいけません。

  Simplification flags and variables ·

オプション変数: berlefact

  デフォルト値: `true`

  `berlefact`が`false`の時、 Kroneckerの因数分解アルゴリズムが使われます。 そうでなければ、Berlekampのアルゴリズム―これがデフォルトですーが使われます。

  Polynomials ·

関数: bezout (p1, p2, x)

  `resultant`コマンドの代替。 行列を返します。 この行列の`determinant`は、望みの結果です。

  Polynomials ·

関数: bothcoef (expr, x)

  最初のメンバーがexprの中のxの （もしexprがCRE形なら`ratcoef`が見つけるような） 係数であり、 ２番目のメンバーがexprの残りの部分であるリストを返します。 例えば、 `expr = A*x + B`の`[A, B]`。

  例:

      (%i1) islinear (expr, x) := block ([c],
              c: bothcoef (rat (expr, x), x),
              is (freeof (x, c) and c[1] # 0))$
      (%i2) islinear ((r^2 - (x - r)^2)/x, x);
      (%o2)                         true

  Polynomials ·

関数: coeff (expr, x, n)
関数: coeff (expr, x)

  exprの`x^n`の係数を返します。 ここで、exprはxの多項式か単項式です。

  `coeff(expr, x^n)`は `coeff(expr, x, n)`と同値です。 `coeff(expr, x, 0)`は xを含まないexprの剰余項を返します。 もし省略されたら、nは1が仮定されます。

  xは単純変数か添字付き変数か、演算子1つとその引数のすべてから構成されるexprの部分式です。

  `expand`か`factor`を適用することで、 exprと同値な式の係数を計算することが可能かもしれません。 `coeff`自身は`expand`や`factor`や他のいかなる関数も 適用しません。

  例:

  `coeff`はexprの`x^n`の係数を返します。

      (%i1) coeff (b^3*a^3 + b^2*a^2 + b*a + 1, a^3);
                                      3
      (%o1)                          b

  `coeff(expr, x^n)`は `coeff(expr, x, n)`と同値です。

      (%i1) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z, 3);
      (%o1)                         - c
                                       3
      (%i2) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z^3);
      (%o2)                         - c
                                       3

  `coeff(expr, x, 0)`は exprのxを含まない剰余項です。

      (%i1) coeff (a*u + b^2*u^2 + c^3*u^3, b, 0);
                                  3  3
      (%o1)                      c  u  + a u

  xは単純変数か添字付き変数か、演算子1つとその引数のすべてから構成されるexprの部分式です。

      (%i1) coeff (h^4 - 2*%pi*h^2 + 1, h, 2);
      (%o1)                        - 2 %pi
      (%i2) coeff (v[1]^4 - 2*%pi*v[1]^2 + 1, v[1], 2);
      (%o2)                        - 2 %pi
      (%i3) coeff (sin(1+x)*sin(x) + sin(1+x)^3*sin(x)^3, sin(1+x)^3);
                                      3
      (%o3)                        sin (x)
      (%i4) coeff ((d - a)^2*(b + c)^3 + (a + b)^4*(c - d), a + b, 4);
      (%o4)                         c - d

  `coeff`自身は`expand`や`factor`や他のいかなる関数も 適用しません。

      (%i1) coeff (c*(a + b)^3, a);
      (%o1)                           0
      (%i2) expand (c*(a + b)^3);
                       3          2        2        3
      (%o2)           b  c + 3 a b  c + 3 a  b c + a  c
      (%i3) coeff (%, a);
                                      2
      (%o3)                        3 b  c
      (%i4) coeff (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c, (a + b)^3);
      (%o4)                           0
      (%i5) factor (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c);
                                        3
      (%o5)                      (b + a)  c
      (%i6) coeff (%, (a + b)^3);
      (%o6)                           c

  `coeff`はリスト、行列、等式上を散逸します。

      (%i1) coeff ([4*a, -3*a, 2*a], a);
      (%o1)                      [4, - 3, 2]
      (%i2) coeff (matrix ([a*x, b*x], [-c*x, -d*x]), x);
                                [  a    b  ]
      (%o2)                     [          ]
                                [ - c  - d ]
      (%i3) coeff (a*u - b*v = 7*u + 3*v, u);
      (%o3)                         a = 7

  Polynomials ·

関数: content (p_1, x_1, …, x_n)

  最初のメンバーが、多項式変数p_1のx_n に関する項の係数（これが中身です）の最大公約数であり、 ２番目のメンバーが中身で多項式p_1を割ったものであるリストを返します。

  例:

      (%i1) content (2*x*y + 4*x^2*y^2, y);

                                         2
      (%o1)                   [2 x, 2 x y  + y]

  Polynomials ·

関数: denom (expr)

  有理式exprの分母を返します。

  Expressions ·

関数: divide (p_1, p_2, x_1, …, x_n)

  メインの多項式変数x_nに関して、 多項式p_2で割った多項式p_1の商と余りを計算します。 他の変数は、`ratvars`関数の中でようなものです。 結果は、最初の要素が商で、２番目の要素が余りのリストです。

  例:

      (%i1) divide (x + y, x - y, x);
      (%o1)                       [1, 2 y]
      (%i2) divide (x + y, x - y);
      (%o2)                      [- 1, 2 x]

  `y`は２番目の例の主変数であることに注意してください。

  Polynomials ·

関数: eliminate ([eqn_1, …, eqn_n], [x_1, …, x_k])

  連続する結果を取ることによって、式（もしくは0に等しいと仮定された式）から変数を消去します。 これは、k個の変数x_1, ..., x_kが消去された `n - k`個の式のリストを返します。 最初、x_1が消去され、`n - 1`個の式をもたらし、 そして、変数x_2が消去され、などなど。 もし`k = n`なら、 変数x_1, ..., x_kに依らないリストの中の単一式が返されます。 この場合、最後の変数について最後の結果を解くため、`solve`がコールされます。

  例:

      (%i1) expr1: 2*x^2 + y*x + z;
                                            2
      (%o1)                    z + x y + 2 x
      (%i2) expr2: 3*x + 5*y - z - 1;
      (%o2)                  - z + 5 y + 3 x - 1
      (%i3) expr3: z^2 + x - y^2 + 5;
                                2    2
      (%o3)                    z  - y  + x + 5
      (%i4) eliminate ([expr3, expr2, expr1], [y, z]);
                   8         7         6          5          4
      (%o4) [7425 x  - 1170 x  + 1299 x  + 12076 x  + 22887 x

                                          3         2
                                  - 5154 x  - 1291 x  + 7688 x + 15376]

  Polynomials ·Algebraic equations ·

関数: ezgcd (p_1, p_2, p_3, …)

  最初の要素が、多項式p_1, p_2, p_3, …の最大公約数で、 残りの要素が、多項式を最大公約数で割ったものであるリストを返します。 これはいつも`ezgcd`アルゴリズムを使います。

  `gcd`, `gcdex`, `gcdivide`, `poly_gcd`も参照してください。

  例:

  三つの多項式は最大公約数 `2*x-3`を持ちます。 GCDは最初、関数 `gcd`で計算され、その後、関数 `ezgcd`で計算されます。

      (%i1) p1 : 6*x^3-17*x^2+14*x-3;
                              3       2
      (%o1)                6 x  - 17 x  + 14 x - 3
      (%i2) p2 : 4*x^4-14*x^3+12*x^2+2*x-3;
                          4       3       2
      (%o2)            4 x  - 14 x  + 12 x  + 2 x - 3
      (%i3) p3 : -8*x^3+14*x^2-x-3;
                                3       2
      (%o3)                - 8 x  + 14 x  - x - 3

      (%i4) gcd(p1, gcd(p2, p3));
      (%o4)                        2 x - 3

      (%i5) ezgcd(p1, p2, p3);
                         2               3      2           2
      (%o5) [2 x - 3, 3 x  - 4 x + 1, 2 x  - 4 x  + 1, - 4 x  + x + 1]

  Polynomials ·

オプション変数: facexpand

  デフォルト値: `true`

  `facexpand`は、`factor`が返すこれ以上小さくできない因子が 展開された形式（デフォルト）か再帰的（正規のCRE）形式かを制御します。

  Polynomials ·

関数: factor (expr)
関数: factor (expr, p)

  任意の数の変数と関数を含んだ式exprを整数上既約な因子に因数分解します。 `factor (expr, p)`はexprを、 有理数体上で、最小多項式がpである要素で因数分解します。

  `factor`は、整数を素因数分解するのに`ifactor`関数を使います。

  `factorflag`が`false`なら有理式の整数因子の素因数分解を抑制します。

  `dontfactor`は、因数分解しない変数のリストに設定されます。 （初期状態では空です。） 因数分解は、`dontfactor`リスト上のそれらより（CRE形式で仮定された変数順序を使って）重要でない変数に関しても 実行されません。

  `savefactors`が`true`なら、 同じ因子のいくつかを含む式の後の因数分解をスピードアップするために、因子の積である式の因子が、ある関数によって保存されます。

  `berlefact`が `false`ならKroneckerの因数分解アルゴリズムが使われ、 そうでなければ、デフォルトであるBerlekampのアルゴリズムが使われます。

  `intfaclim`が`true`なら、 もし自明な割り算やPollardのロー法の後、因子が見つからないなら、整数の素因数分解をあきらめます。 `false`に設定されていれば（これはユーザーが陽に`factor`をコールする場合です）整数の完全な素因数分解が企てられます。 `intfaclim`のユーザー設定は内部で`factor`がコールされた時に使われます。 `intfaclim`はMaximaが大きな整数を素因数分解するのにありえない長い時間を使うことを妨げるようにリセットされます。

  例:

      (%i1) factor (2^63 - 1);
                          2
      (%o1)              7  73 127 337 92737 649657
      (%i2) factor (-8*y - 4*x + z^2*(2*y + x));
      (%o2)               (2 y + x) (z - 2) (z + 2)
      (%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
                      2  2        2    2    2
      (%o3)          x  y  + 2 x y  + y  - x  - 2 x - 1
      (%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));

                             2
                           (x  + 2 x + 1) (y - 1)
      (%o4)                ----------------------
                                 36 (y + 1)

      (%i5) factor (1 + %e^(3*x));
                            x         2 x     x
      (%o5)              (%e  + 1) (%e    - %e  + 1)
      (%i6) factor (1 + x^4, a^2 - 2);
                          2              2
      (%o6)             (x  - a x + 1) (x  + a x + 1)
      (%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
                             2
      (%o7)              - (y  + x) (z - x) (z + x)
      (%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2;
                                   x + 2
      (%o8)               ------------------------
                                                 2
                          (x + 3) (x + b) (x + c)
      (%i9) ratsimp (%);
                      4                  3
      (%o9) (x + 2)/(x  + (2 c + b + 3) x

           2                       2             2                   2
       + (c  + (2 b + 6) c + 3 b) x  + ((b + 3) c  + 6 b c) x + 3 b c )
      (%i10) partfrac (%, x);
                 2                   4                3
      (%o10) - (c  - 4 c - b + 6)/((c  + (- 2 b - 6) c

           2              2         2                2
       + (b  + 12 b + 9) c  + (- 6 b  - 18 b) c + 9 b ) (x + c))

                       c - 2
       - ---------------------------------
           2                             2
         (c  + (- b - 3) c + 3 b) (x + c)

                               b - 2
       + -------------------------------------------------
                   2             2       3      2
         ((b - 3) c  + (6 b - 2 b ) c + b  - 3 b ) (x + b)

                               1
       - ----------------------------------------------
                   2
         ((b - 3) c  + (18 - 6 b) c + 9 b - 27) (x + 3)
      (%i11) map ('factor, %);

                    2
                   c  - 4 c - b + 6                 c - 2
      (%o11) - ------------------------- - ------------------------
                      2        2                                  2
               (c - 3)  (c - b)  (x + c)   (c - 3) (c - b) (x + c)

                             b - 2                        1
                  + ------------------------ - ------------------------
                                   2                          2
                    (b - 3) (c - b)  (x + b)   (b - 3) (c - 3)  (x + 3)

      (%i12) ratsimp ((x^5 - 1)/(x - 1));
                             4    3    2
      (%o12)                x  + x  + x  + x + 1
      (%i13) subst (a, x, %);
                             4    3    2
      (%o13)                a  + a  + a  + a + 1
      (%i14) factor (%th(2), %);
                             2        3        3    2
      (%o14)   (x - a) (x - a ) (x - a ) (x + a  + a  + a + 1)
      (%i15) factor (1 + x^12);
                             4        8    4
      (%o15)               (x  + 1) (x  - x  + 1)
      (%i16) factor (1 + x^99);
                       2            6    3
      (%o16) (x + 1) (x  - x + 1) (x  - x  + 1)

         10    9    8    7    6    5    4    3    2
       (x   - x  + x  - x  + x  - x  + x  - x  + x  - x + 1)

         20    19    17    16    14    13    11    10    9    7    6
       (x   + x   - x   - x   + x   + x   - x   - x   - x  + x  + x

          4    3            60    57    51    48    42    39    33
       - x  - x  + x + 1) (x   + x   - x   - x   + x   + x   - x

          30    27    21    18    12    9    3
       - x   - x   + x   + x   - x   - x  + x  + 1)

  Polynomials ·

オプション変数: factorflag

  デフォルト値: `false`

  `factorflag`が`false`の時、 有理式の整数因子の素因素分解を抑制します。

  Polynomials ·

関数: factorout (expr, x_1, x_2, …)

  和exprを 形式`f (x_1, x_2, …)*g`の項の和に再整理します。 ここで、`g`は、いかなるx_iも含まない式の積で、`f`は因数分解されています。

  オプション変数`keepfloat`は`factorout`に無視されることに注意してください。

  例:

      (%i1) expand (a*(x+1)*(x-1)*(u+1)^2);
                   2  2          2      2      2
      (%o1)     a u  x  + 2 a u x  + a x  - a u  - 2 a u - a
      (%i2) factorout(%,x);
               2
      (%o2) a u  (x - 1) (x + 1) + 2 a u (x - 1) (x + 1)
                                                    + a (x - 1) (x + 1)

  Expressions ·

関数: factorsum (expr)

  exprの因子（それらは和です）の中の項を それらの和が因数分解可能な項のグループにグループ化しようとします。 `factorsum`は、 `expand ((x + y)^2 + (z + w)^2)`の結果を回復できますが、 項が共通の変数を持つので、 `expand ((x + 1)^2 + (x + y)^2)`は回復できません。

  例:

      (%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
                 2      2                            2      2
      (%o1) a x z  + a z  + 2 a w x z + 2 a w z + a w  x + v  x

                                           2        2    2            2
                              + 2 u v x + u  x + a w  + v  + 2 u v + u
      (%i2) factorsum (%);
                                         2          2
      (%o2)            (x + 1) (a (z + w)  + (v + u) )

  Expressions ·

関数: fasttimes (p_1, p_2)

  多項式の掛け算のための特殊なアルゴリズムを使って、 多項式p_1とp_2の積を返します。 `p_1`と`p_2`は、 多変数で、密で、ほぼ同じサイズであるべきです。 `n_1`が`p_1`の次数で、 `n_2`が`p_2`の次数だとすると、 古典的な掛け算は、 `n_1 n_2`のオーダーですが、 `fasttimes`は、`max (n_1, n_2)^1.585`のオーダーです。

  Polynomials ·

関数: fullratsimp (expr)

  `fullratsimp`は、ratsimpと式の非有理的整理を、式変形されなくなるまで繰り返し適応し、結果を返します。

  非有理式が含まれる時、`ratsimp`を１回コールと、その後の非有理的（「一般」）整理だけでは、 整理された結果を返すのに十分でないかもしれません。 時々、複数回のコールが必要とされます。 `fullratsimp`はこのプロセスを楽にしてくれます。

  `fullratsimp (expr, x_1, ..., x_n)`は`ratsimp`や`rat`と同様 複数の引数を取ります。

  例:

      (%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
                             a/2     2   a/2     2
                           (x    - 1)  (x    + 1)
      (%o1)                -----------------------
                                    a
                                   x  - 1
      (%i2) ratsimp (expr);
                                2 a      a
                               x    - 2 x  + 1
      (%o2)                    ---------------
                                    a
                                   x  - 1
      (%i3) fullratsimp (expr);
                                    a
      (%o3)                        x  - 1
      (%i4) rat (expr);
                             a/2 4       a/2 2
                           (x   )  - 2 (x   )  + 1
      (%o4)/R/             -----------------------
                                    a
                                   x  - 1

  Simplification functions ·Rational expressions ·

関数: fullratsubst (a, b, c)

  結果が変わらなくなるまで、自身を再帰的にコールすることを除いて、 `ratsubst`と同じです。 置き換える式と置き換えられる式が１つ以上の変数を共通に持つ時、 この関数は役に立ちます。

  `fullratsubst`は、`lratsubst`のフォーマットでも引数を受け付けます。 すなわち、最初の引数は、１つの代入等式もしくは、そんな等式のリストで、 一方、２番目の引数は処理される式というものです。

  `load ("lrats")`は、`fullratsubst`と`lratsubst`をロードします。

  例:

      (%i1) load ("lrats")$

  - `subst`は多重代入を実行できます。 `lratsubst`は`subst`に類似しています。

      (%i2) subst ([a = b, c = d], a + c);
      (%o2)                         d + b
      (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
      (%o3)                (d + a c) e + a d + b c

  - もしただ１つの代入が望まれるなら、 最初の引数として１つの等式を与えます。

      (%i4) lratsubst (a^2 = b, a^3);
      (%o4)                          a b

  - `fullratsubst`は、 結果が変わらなくなるまで再帰することを除いて、 `ratsubst`と同値です。

      (%i5) ratsubst (b*a, a^2, a^3);
                                     2
      (%o5)                         a  b
      (%i6) fullratsubst (b*a, a^2, a^3);
                                       2
      (%o6)                         a b

  - `fullratsubst`も、 最初の引数として、等式のリストもしくは１つの式を受け入れます。

      (%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
      (%o7)                           b
      (%i8) fullratsubst (a^2 = b*a, a^3);
                                       2
      (%o8)                         a b

  - `fullratsubst`は、不確定な再帰を起こすかもしれません。

      (%i9) errcatch (fullratsubst (b*a^2, a^2, a^3));

      *** - Lisp stack overflow. RESET

  Rational expressions ·

関数: gcd (p_1, p_2, x_1, …)

  p_1とp_2の最大公約数を返します。 フラグ`gcd`は、どのアルゴリズムを利用するか決めます。 `gcd`を`ez`, `subres`, `red`, もしくは`spmod` 設定することは、それぞれ、`ezgcd`, 部分終結式`prs`, 被約, もしくはモジュラーアルゴリズムを選択します。 もし`gcd`が`false`なら、 `gcd (p_1, p_2, x)`は、すべてのxに関していつも1を返します。 （例えば、`ratsimp`, `factor`, など）多くの関数は、 陰にgcdを計算します。 斉次多項式に関して、 `subres`に等しい`gcd`を使うことが推奨されます。 例えば、`gcd (x^2 - 2*sqrt(2)*x + 2, x - sqrt(2))`のように、代数的数が含まれる時 `algebraic`は`true`でなくてはいけません。また、`gcd`は`ez`であってはいけません。

  `gcd`フラグ―デフォルトは`spmod`―は、 もし`false`なら、 式が標準有理式(CRE)形に変換される時も、最大公約数を計算させません。 もしgcdが要求されないなら、これは、時々計算のスピードを上げます。

  `ezgcd`, `gcdex`, `gcdivide`, `poly_gcd`も参照してください。

  例:

      (%i1) p1:6*x^3+19*x^2+19*x+6;
                              3       2
      (%o1)                6 x  + 19 x  + 19 x + 6
      (%i2) p2:6*x^5+13*x^4+12*x^3+13*x^2+6*x;
                        5       4       3       2
      (%o2)          6 x  + 13 x  + 12 x  + 13 x  + 6 x
      (%i3) gcd(p1, p2);
                                  2
      (%o3)                    6 x  + 13 x + 6
      (%i4) p1/gcd(p1, p2), ratsimp;
      (%o4)                         x + 1
      (%i5) p2/gcd(p1, p2), ratsimp;
                                    3
      (%o5)                        x  + x

  `ezgcd`は 一番目の要素が多項式 p_1と p_2の最大公約数で、 残りの要素が最大公約数で多項式を割ったもので構成されるリストを返します。

      (%i6) ezgcd(p1, p2);
                          2                     3
      (%o6)           [6 x  + 13 x + 6, x + 1, x  + x]

  Polynomials ·Rational expressions ·

関数: gcdex (f, g)
関数: gcdex (f, g, x)

  リスト`[a, b, u]`を返します。 ここで、uはfとgの最大公約数(gcd)であり、 かつ、`a f + b g`はuに等しいです。 引数fとgは、１変数多項式であるか、 そうでなければ、指定された主変数xの多項式でなければいけません。 これが機能するには単項イデアル整域にある必要があるからです。 gcdは、他の変数の有理関数係数を持つ１変数多項式としてのfとgに関するgcdを意味します。

  `gcdex`は、ユークリッドのアルゴリズムを実行します。 すべてが`[f, g, -1]`に直角の`L[i]: [a[i], b[i], r[i]]`の列を持ち、 `q = quotient(r[i]/r[i+1])`なら`L[i+2]: L[i] - q L[i+1]`となるように次を組み立て、 余り`r[i+2]`がゼロの時、`L[i+1]`で終了します。

  引数 fと gは整数であり得ます。 この場合、`gcdex`は関数 `igcdex`を呼び出します。

  `ezgcd`, `gcd`, `gcdivide`, `poly_gcd`も参照してください。

  例:

      (%i1) gcdex (x^2 + 1, x^3 + 4);

                             2
                            x  + 4 x - 1  x + 4
      (%o1)/R/           [- ------------, -----, 1]
                                 17        17

      (%i2) % . [x^2 + 1, x^3 + 4, -1];
      (%o2)/R/                        0

  以下のgcdは、 `k(y)[x]`に関して働くので`1`です。 `k[y, x]`で期待する`y+1`ではないことに注意してください。

      (%i1) gcdex (x*(y + 1), y^2 - 1, x);

                                     1
      (%o1)/R/                 [0, ------, 1]
                                    2
                                   y  - 1

  Polynomials ·Rational expressions ·

関数: gcfactor (n)

  ガウス整数 すなわち、aとbが有理整数(元々の整数) である形式`a + b `%i`` の数、nをガウス整数上に因数分解します。 因子は、aとbを非負にすることによって正規化されます。

  Integers ·

関数: gfactor (expr)

  多項式exprをガウス整数（虚数単位`%i`を付け加えた整数）上で因数分解します。 aが`%i`となる`factor (expr, a^2+1)`ようなものです。

  例:

      (%i1) gfactor (x^4 - 1);
      (%o1)           (x - 1) (x + 1) (x - %i) (x + %i)

  Polynomials ·

関数: gfactorsum (expr)

  `factorsum`に似ていますが、 `factor`の代わりに`gfactor`を適用します。

  Expressions ·

関数: hipow (expr, x)

  exprの中で、xの、陽に示された最も大きな指数を返します。 xは変数もしくは一般式です。 もしxがexprの中に現れないなら、 `hipow`は`0`を返します。

  `hipow`は、`expr`に等価な式を考慮しません。 特に、`hipow`は、`expr`を展開しないので、 `hipow (expr, x)`と`hipow (expand (expr, x))` は、違った結果をもたらすかもしれません。

  例:

      (%i1) hipow (y^3 * x^2 + x * y^4, x);
      (%o1)                           2
      (%i2) hipow ((x + y)^5, x);
      (%o2)                           1
      (%i3) hipow (expand ((x + y)^5), x);
      (%o3)                           5
      (%i4) hipow ((x + y)^5, x + y);
      (%o4)                           5
      (%i5) hipow (expand ((x + y)^5), x + y);
      (%o5)                           0

  Expressions ·

オプション変数: intfaclim

  デフォルト値: true

  もし`true`なら、 もし試し割りとPollardのロー法の後、因子が見つからなければ、 Maximaは、整数の素因素分解をあきらめ、素因数分解は完了しません。

  `intfaclim`が`false`の時、 (これは、ユーザーが明示的に`factor`をコールした場合です） 完全な素因数分解が試みられます。 `divisors`, `divsum` や`totient`の中で因子が計算される時は、 `intfaclim`は`false`に設定されます

  `factor`への内部コールは、 `intfaclim`のユーザー指定の値を考慮します。 `intfaclim`を`true`に設定することは、 大きな整数を素因数分解するのに費やす時間を少なくするかもしれません。

  Integers ·

オプション変数: keepfloat

  デフォルト値: `false`

  `keepfloat`が`true`の時、 浮動小数点数を含む式が標準有理式(CRE)形に変換される時、 浮動小数点が有理数化されないようにします。

  関数`solve`とそれを呼び出す関数(例えば`eigenvalues`)は、 現在、このフラグを無視し、とにかく浮動小数点数を変換することに注意してください。

  例:

      (%i1) rat(x/2.0);

      `rat' replaced 0.5 by 1/2 = 0.5
                                             x
      (%o1)/R/                               -
                                             2
      (%i2) rat(x/2.0), keepfloat;

      (%o2)/R/                     E        0.5 x

  `solve` ignores `keepfloat`:

      (%i3) solve(1.0-x,x), keepfloat;

      `rat' replaced 1.0 by 1/1 = 1.0
      (%o3)                               [x = 1]

  Numerical evaluation ·

関数: lopow (expr, x)

  exprの中に陽に現れるxの最小の指数を返します。 例えば、

      (%i1) lopow ((x+y)^2 + (x+y)^a, x+y);
      (%o1)                       min(a, 2)

  Expressions ·

関数: lratsubst (L, expr)

  `subst`の代わりに`ratsubst`を使うことを除いて、 `subst (L, expr)`に類似しています。

  `lratsubst`の最初の引数は、 `subst`が受け付けるそれと同一のフォーマットの等式もしくは等式のリストです。 代入は、等式のリストによって与えられた順、すなわち、左から右に、実行されます。

  `load ("lrats")`は、`fullratsubst`と`lratsubst`をロードします。

  例:

      (%i1) load ("lrats")$

  - `subst`は多重代入を実行できます。 `lratsubst`は`subst`に似ています。

      (%i2) subst ([a = b, c = d], a + c);
      (%o2)                         d + b
      (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
      (%o3)                (d + a c) e + a d + b c

  - もし代入１つだけを望むなら、 １つの等式を最初の引数として与えることができます。

      (%i4) lratsubst (a^2 = b, a^3);
      (%o4)                          a b

  Polynomials ·Rational expressions ·

オプション変数: modulus

  デフォルト値: `false`

  `modulus`が正の数pの時、 （`rat`や関連の関数が返すように）有理数上の演算は、 「バランスさせた」モジュラス系と呼ばれるものを使って、 pを法とする合同変換が実行されます。 「バランスさせた」モジュラス系では、 `n modulo p`は、 `a p + k`がnに等しくなるようなある整数aが存在するような整数kと定義され、kは、 pが奇数の時、 `[-(p-1)/2, ..., 0, ..., (p-1)/2]`の中から、 pが偶数の時、`[-(p/2 - 1), ..., 0, ...., p/2]`の中から 選ばれます。

  `modulus`が再設定された時、もしexprが既に標準有理式(CRE)形なら、 正しい結果を得るためには、 例えば`expr: rat (ratdisrep (expr))`というように、exprを再ratする必要があるかもしれません。

  典型的には、`modulus`は素数が設定されます。 もし`modulus`が正の合成数に設定されたら、 この設定は受け入れられますが、警告メッセージが表示されます。 Maximaは、ゼロや負の整数が`modulus`に割り当てられるのを許します。 それが役に立つ結果を持つかどうか明らかではありませんが。

  Integers ·

関数: num (expr)

  もしexprが比なら、その分子を返します。 もしexprが比でないなら、exprが返されます。

  `num`は引数を評価します。

  Expressions ·

関数: polydecomp (p, x)

  変数xの多項式pをxの多項式の関数合成に分解します。 `polydecomp`は、

      lambda ([x], p_1) (lambda ([x], p_2) (... (lambda ([x], p_n) (x))
        ...))

  がpに等しいようなリスト`[p_1, ..., p_n]`を返します。 nより小さいiについてp_iの次数は1より大きいです。

  このような分解は一意的ではありません。

  例:

      (%i1) polydecomp (x^210, x);
                                7   5   3   2
      (%o1)                   [x , x , x , x ]
      (%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a));
                      6      4      3    2
      (%o2)          x  - 2 x  - 2 x  + x  + 2 x - a + 1
      (%i3) polydecomp (p, x);
                              2       3
      (%o3)                 [x  - a, x  - x - 1]

  以下の関数は、`x`の関数として、 `L = [e_1, ..., e_n]`を合成します; それはpolydecompの逆です。

      compose (L, x) :=
        block ([r : x], for e in L do r : subst (e, x, r), r) $

  `compose`を使って、上の例を再表現します:

      (%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
                              2       3
      (%o3)                 [x  - a, x  - x - 1]

  `compose (polydecomp (p, x), x)`はいつも （展開されていない）pを返しますが、 `polydecomp (compose ([p_1, ..., p_n], x), x)`は、 必ずしも`[p_1, ..., p_n]`を返さないことに注意してください。

      (%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x);
                                2       2
      (%o4)                   [x  + 2, x  + 1]
      (%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x);
                            2       2
                           x  + 3  x  + 5
      (%o5)               [------, ------, 2 x + 1]
                             4       2

  Polynomials ·

関数: polymod (p)
関数: polymod (p, m)

  多項式pを、変数`modulus`の値である現在の法に関してモジュラー表現に変換します。

  `polymod (p, m)`は、 `modulus`の現在値の代わりに法mを使うように指定します。

  `modulus`を参照してください。

  Polynomials ·

関数: powers (expr, x)

  exprに現れるxのべきを返します。

  `load ("powers")` loads this function.

  Expressions ·Polynomials ·

関数: quotient (p_1, p_2)
関数: quotient (p_1, p_2, x_1, …, x_n)

  多項式p_1を多項式p_2で割った結果を返します。 引数x_1, …, x_nは、`ratvars`と同様に解釈されます。

  `quotient`は、`divide`が返す２要素リストの最初の要素を返します。

  Polynomials ·

関数: rat (expr)
関数: rat (expr, x_1, …, x_n)

  exprを標準有理式(CRE)形式に変換します。 展開し、共通の分母上ですべての項を結合し、通分し、`ratepsilon`の許容誤差内で浮動小数点を有理数に変換します。 変数は、もし指定されたなら、`ratvars`のようにx_1, …, x_nに従って並び替えられます。

  `rat`は一般に、加算`+`, 減算`-`, 乗算`*`, 除算`/`と整数べきの指数を除いた関数を 整理しません。 一方で`ratsimp`はこれらの場合を扱います。 CRE形式の中のアトム(数と変数）は一般形式でのそれと同じではないことに注意してください。 例えば、`rat(x) - x`は`rat(0)`を出力します。 これは0とは違う内部表現を持ちます。

  `ratfac`が`true`の時、 `rat`は、CREの一部因数分解された形式を出力します。 有理演算の最中、因数分解パッケージをコールなしに、式は可能な限り因数分解され続けます。 これにより常に、いくつかの計算でメモリと時間を節約することになります。 分子と分母は互いに素になり（例えば、`((x^2 - 1)^4/(x + 10^2)`は`(x - 1)^4 (x + 1)^2`を出力します）、 それぞれの部分の中の因子は互いに素とは限りません。

  `ratprint`が`false`ならユーザーに浮動小数点を有理数に変換したことを通知するメッセージの出力を抑制します。

  `keepfloat`が`true`なら、浮動小数点が有理数に変換されることを抑制します。

  `ratexpand`と`ratsimp`も参照してください。

  例:

      (%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x) /
            (4*y^2 + x^2);

                                                 4
                                        (x - 2 y)
                    (y + a) (2 y + x) (------------ + 1)
                                         2      2 2
                                       (x  - 4 y )
      (%o1)         ------------------------------------
                                    2    2
                                 4 y  + x

      (%i2) rat (%, y, a, x);
                                  2 a + 2 y
      (%o2)/R/                    ---------
                                   x + 2 y

  Rational expressions ·

オプション変数: ratalgdenom

  デフォルト値: `true`

  `ratalgdenom`が`true`の時、 根号に関する分母の有理化が有効になることを許します。 `ratalgdenom`は、 標準有理式(CRE)が代数モードで使われる時だけ、効果を持ちます。

  Simplification flags and variables ·

関数: ratcoef (expr, x, n)
関数: ratcoef (expr, x)

  式exprの中の式`x^n`の係数を返します。 nを省略した場合、nは1が仮定されます。

  戻り値は、（非有理な意味で可能な場合を除いて、）xの中の変数の制約を受けません。 このタイプの係数が存在しなければ、0を返します。

  `ratcoef`は最初の引数を展開し、有理的に整理するので、 純粋に構文法的な`coeff`のそれとは違った答えを生成することがあります。 このように、`ratcoef ((x + 1)/y + x, x)`は`(y + 1)/y`を返しますが、`coeff`は1を返します。

  `ratcoef (expr, x, 0)`は、exprをsumとして見て、 xを含まない項の和を返します。 ゆえに、もしxの負のべき乗が存在するなら、ratcoefを使うべきではありません。

  exprは検査される前に有理的に整理されるので、 係数は、想像された形とは全く違って現れることがあります。

  例:

      (%i1) s: a*x + b*x + 5$
      (%i2) ratcoef (s, a + b);
      (%o2)                           x

  Polynomials ·Rational expressions ·

関数: ratdenom (expr)

  exprを標準有理式(CRE)に強制した後、exprの分母を返します。 戻り値はCREです。

  exprは、もしまだCREでないなら、`rat`によってCREに強制的に変換されます。 この変換は、すべての項を共通の分母上に置くことによって、 exprの形式を変えます。

  `denom`は似ていますが、 CREではなく通常の式を返します。 また、`denom`は共通の分母上にすべての項を置こうとはしませんし、 `ratdenom`によって比と見なされるいくつかの式は、`denom`には比と見なされません。

  Rational expressions ·

オプション変数: ratdenomdivide

  デフォルト値: `true`

  `ratdenomdivide`が`true`の時、 `ratexpand`は、分子が和である比を、共通の分母を持つ比の和に展開します。 そうでなければ、`ratexpand`は比の和を１つの比に縮約します。 その比の分子はそれぞれの比の分子の和です。

  例:

      (%i1) expr: (x^2 + x + 1)/(y^2 + 7);
                                  2
                                 x  + x + 1
      (%o1)                      ----------
                                    2
                                   y  + 7
      (%i2) ratdenomdivide: true$
      (%i3) ratexpand (expr);
                             2
                            x        x        1
      (%o3)               ------ + ------ + ------
                           2        2        2
                          y  + 7   y  + 7   y  + 7
      (%i4) ratdenomdivide: false$
      (%i5) ratexpand (expr);
                                  2
                                 x  + x + 1
      (%o5)                      ----------
                                    2
                                   y  + 7
      (%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3);
                                           2
                                 b        a
      (%o6)                    ------ + ------
                                2        2
                               b  + 3   b  + 3
      (%i7) ratexpand (expr2);
                                        2
                                   b + a
      (%o7)                        ------
                                    2
                                   b  + 3

  Simplification flags and variables ·Rational expressions ·

関数: ratdiff (expr, x)

  有理式exprをxに関して微分します。 exprはxの多項式もしくは多項式の商でなければなりません。 引数xはexprの変数もしくは部分式を取り得ます。

  たぶん違った形式になりますが、結果は、`diff`と同値です。 有理式の場合、`ratdiff`は`diff`より速いでしょう。

  `ratdiff`は、もしexprが標準有理式(CRE)なら、標準有理式を返します。 そうでなければ、一般式を返します。

  `ratdiff`は、exprのxへの依存のみを考慮し、`depends`で規定された依存性は無視します。

  例:

      (%i1) expr: (4*x^3 + 10*x - 11)/(x^5 + 5);
                                 3
                              4 x  + 10 x - 11
      (%o1)                   ----------------
                                    5
                                   x  + 5
      (%i2) ratdiff (expr, x);
                          7       5       4       2
                       8 x  + 40 x  - 55 x  - 60 x  - 50
      (%o2)          - ---------------------------------
                                10       5
                               x   + 10 x  + 25
      (%i3) expr: f(x)^3 - f(x)^2 + 7;
                               3       2
      (%o3)                   f (x) - f (x) + 7
      (%i4) ratdiff (expr, f(x));
                                 2
      (%o4)                   3 f (x) - 2 f(x)
      (%i5) expr: (a + b)^3 + (a + b)^2;
                                    3          2
      (%o5)                  (b + a)  + (b + a)
      (%i6) ratdiff (expr, a + b);
                          2                    2
      (%o6)            3 b  + (6 a + 2) b + 3 a  + 2 a

  Rational expressions ·

関数: ratdisrep (expr)

  一般式として引数を返します。 もしexprが一般式なら、戻り値は引数から変わりません。

  典型的には、`ratdisrep`は、 標準有理式(CRE)を一般式に変換するためにコールされます。 もし「伝染」を止めたかったり、非有理文脈で有理関数を使いたいなら、 これは、時々便利です。

  `totaldisrep`も参照してください。

  Rational expressions ·

関数: ratexpand (expr)
オプション変数: ratexpand

  exprを展開します。 指数和や和の積を展開し、共通分母上の分数を結合し、通分し、（もし和なら）分子を分母で割ったそれぞれの項に分割します。

  たとえexprが標準有理式(CRE)でも、`ratexpand`の戻り値は一般式です。

  スイッチ`ratexpand`が`true`なら、CRE式は、一般式や表示形式に変換された時フルに展開されます。 一方もし`false`なら再帰形式に変換します。 `ratsimp`も参照してください。

  `ratdenomdivide`が`true`の時、 `ratexpand`は、分子が和である比を、共通の分母を持つ比の和に展開します。 そうでなければ、`ratexpand`は日の和を、その分子がそれぞれの比の分子の和である単一の比にまとめます。

  `keepfloat`が`true`の時、 浮動小数点を含んだ式がCRE形式に変換される時、浮動小数点が有理化されるのを抑制します。

  例:

      (%i1) ratexpand ((2*x - 3*y)^3);
                           3         2       2        3
      (%o1)          - 27 y  + 54 x y  - 36 x  y + 8 x
      (%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1);
                               x - 1       1
      (%o2)                   -------- + -----
                                     2   x - 1
                              (x + 1)
      (%i3) expand (expr);
                          x              1           1
      (%o3)          ------------ - ------------ + -----
                      2              2             x - 1
                     x  + 2 x + 1   x  + 2 x + 1
      (%i4) ratexpand (expr);
                              2
                           2 x                 2
      (%o4)           --------------- + ---------------
                       3    2            3    2
                      x  + x  - x - 1   x  + x  - x - 1

  Rational expressions ·

オプション変数: ratfac

  デフォルト値: `false`

  `ratfac`が`true`の時、 標準有理式(CRE)は部分的に因数分解された形式で操作されます。

  有理演算の間、 式は、`factor`をコールすることなしに、 可能な限り最大限因数分解されるよう維持されます。 これは、いつも保存領域を節約し、いくつかの計算では時間も節約ことがあります。 分子と分母は互いに素になります。 例えば、`rat ((x^2 - 1)^4/(x + 1)^2)`は、 `(x - 1)^4 (x + 1)^2)`をもたらしますが、 それぞれの部分の中の因子は互いに素ではないかもしれません。

  `ctensr`（成分テンソル操作）パッケージでは、 `ratfac`が`true`の時、 リッチ、アインシュタイン、リーマン、そしてワイルテンソルとスカラー曲率は、 自動的に因数分解されます。 `ratfac`は、テンソルの成分が２、３の項から成ると知られている場合だけ 設定すべきです。

  `ratfac`と`ratweight`体系は互換性はなく、 同時には使えないかもしれません。

  Rational expressions ·

関数: ratnumer (expr)

  exprを標準有理式(CRE)に強制変換した後、その分子を返します。 戻り値はCREです。

  もしまだCREでないなら、exprは、`rat`によってCREに強制変換されます。 この変換は、 共通の分母上にすべての項を置くことによって、 exprの形式を変えるかもしれません。

  `num`は似ていますが、 CREではなく通常の式を返します。 また、`num`は共通の分母上にすべての項を置こうとはしませんし、 `ratnumer`によって比と見なされるいくつかの式は、`num`には比と見なされません。

  Rational expressions ·

関数: ratp (expr)

  もしexprが標準有理式(CRE)もしくは拡張CREなら、`true`を返し、 そうでなければ、`false`を返します。

  CREは、`rat`と関連関数によって生成されます。 拡張CREは、`taylor`と関連関数によって生成されます。

  Predicate functions ·Rational expressions ·

オプション変数: ratprint

  デフォルト値: `true`

  `ratprint`が`true`の時、 ユーザーに浮動小数点を有理数に変換したことを通知するメッセージが表示されます。

  Rational expressions ·Numerical evaluation ·Console interaction ·

関数: ratsimp (expr)
関数: ratsimp (expr, x_1, ..., x_n)

  式expとその部分式の全てを有理的に整理します（非有理的関数の引数も含みます）。 結果は二つの多項式の商として、再帰的形式—主変数の係数が他の変数の多項式である形式—で返されます。 変数は(例えば、`sin(z^2+1)`のような)非有理関数を含むかもしれませんが、 どんな非有理関数の引数もまた、有理的に整理されます。

  `ratsimp (expr, x_1, ..., x_n)`は、`ratvars`で指定した場合と同様に、 変数の順序指定に従って有理的に整理します。

  `ratsimpexpons`が`true`の時、 `ratsimp`は式の指数にも適用されます。

  `ratexpand`も参照してください。 `ratsimp`は、`ratexpand`に影響するフラグのいくつかに影響されることに注意してください。

  例:

      (%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2);

                                               2      2
                         x         (log(x) + 1)  - log (x)
      (%o1)        sin(------) = %e
                        2
                       x  + x

      (%i2) ratsimp (%);
                                   1          2
      (%o2)                  sin(-----) = %e x
                                 x + 1
      (%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1));

                             3/2
                      (x - 1)    - sqrt(x - 1) (x + 1)
      (%o3)           --------------------------------
                           sqrt((x - 1) (x + 1))

      (%i4) ratsimp (%);
                                 2 sqrt(x - 1)
      (%o4)                    - -------------
                                       2
                                 sqrt(x  - 1)
      (%i5) x^(a + 1/a), ratsimpexpons: true;
                                     2
                                    a  + 1
                                    ------
                                      a
      (%o5)                        x

  Simplification functions ·Rational expressions ·

オプション変数: ratsimpexpons

  デフォルト値: `false`

  `ratsimpexpons`が`true`の時、 式整理の間、`ratsimp`が式の指数に適用されます。

  Simplification flags and variables ·Rational expressions ·

オプション変数: radsubstflag

  デフォルト値: `false`

  `radsubstflag`がもし `true`なら、 `ratsubst`が `x`に関して`sqrt (x)`に `u`を代入するような代入をできるようにします。

  Simplification flags and variables ·

関数: ratsubst (a, b, c)

  cの中のbにaを代入し、結果の式を返します。 bはsumでもproductでもpowerなどでも問題ありません。

  `subst`は純粋に構文法的代入ですが、`ratsubst`は式の意味の何かを知っています。 ゆえに、`subst (a, x + y, x + y + z)`は`x + y + z`を返す一方、 `ratsubst`は`z + a`を返します。

  `ratsubstflag`が`true`の時、`ratsubst`は、式が陽には含んでいない根への代入を実行します。

  `ratsubst`はオプション変数`keepfloat`の値`true`を無視します。

  例:

      (%i1) ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8);
                                    3      4
      (%o1)                      a x  y + a
      (%i2) cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1;
                     4         3         2
      (%o2)       cos (x) + cos (x) + cos (x) + cos(x) + 1
      (%i3) ratsubst (1 - sin(x)^2, cos(x)^2, %);
                  4           2                     2
      (%o3)    sin (x) - 3 sin (x) + cos(x) (2 - sin (x)) + 3
      (%i4) ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4);

                              4           2
      (%o4)                cos (x) - 2 cos (x) + 1

      (%i5) radsubstflag: false$
      (%i6) ratsubst (u, sqrt(x), x);
      (%o6)                           x
      (%i7) radsubstflag: true$
      (%i8) ratsubst (u, sqrt(x), x);
                                      2
      (%o8)                          u

  Rational expressions ·

関数: ratvars (x_1, …, x_n)
関数: ratvars ()
システム変数: ratvars

  有理式に関して主変数x_1, ..., x_nを宣言します。 もし有理式の中に存在するなら、x_nは主変数と見なされます。 そうでなければ、もし存在すれば、x_[n-1]が主変数と見なされます。 と、先行する変数を通してx_1まで続きます。 x_1は、続く変数が存在しなかった時だけ主変数と見なされます。

  もし有理式の中の変数が`ratvars`リストの中に存在しなかったら、 その変数には、x_1よりも低い優先順位が与えられます。

  `ratvars`の引数は、変数もしくは`sin(x)`のような非有理関数であり得ます。

  変数`ratvars`は、直近にコールされたときの関数`ratvars`の引数のリストです。 関数`ratvars`のコールそれぞれは、リストを再設定します。 `ratvars ()`はリストをクリアします。

  Rational expressions ·

オプション変数: ratvarswitch

  デフォルト値: `true`

  MaximaはLisp変数`VARLIST`の中に有理式の主変数の内部リストを保持します。 もし`ratvarswitch`が`true`なら、 すべての評価は新しいリスト`VARLIST`で開始します。 これがデフォルトの振る舞いです。 そうでなければ、以前の評価からの主変数は 内部リスト`VARLIST`から取り除かれません。

  主変数は関数`ratvars`で宣言されるのですが、 それはオプション変数`ratvarswitch`によって影響されません。

  例:

  もし `ratvarswitch`が`true`, すべての評価は 新しいリスト`VARLIST`で始まります。

      (%i1) ratvarswitch:true$

      (%i2) rat(2*x+y^2);
                                   2
      (%o2)/R/                    y  + 2 x
      (%i3) :lisp varlist
      ($X $Y)

      (%i3) rat(2*a+b^2);
                                   2
      (%o3)/R/                    b  + 2 a

      (%i4) :lisp varlist
      ($A $B)

  もし`ratvarswitch`が`false`なら、 直前の評価からの主変数はまだ存在しています。

      (%i4) ratvarswitch:false$

      (%i5) rat(2*x+y^2);
                                   2
      (%o5)/R/                    y  + 2 x
      (%i6) :lisp varlist
      ($X $Y)

      (%i6) rat(2*a+b^2);
                                   2
      (%o6)/R/                    b  + 2 a

      (%i7) :lisp varlist
      ($A $B $X $Y)

  Rational expressions ·Global flags ·

関数: ratweight (x_1, w_1, …, x_n, w_n)
関数: ratweight ()

  重みw_iを変数x_iに割り当てます。 これは、もし重みが変数`ratwtlvl`の値を越えるなら、項を0に置き換えるようにします。 （デフォルトでは切り詰めはもたらしません。） 項の重みは、項の中の変数の重みの積の和に変数の指数を掛けたものです。 例えば、`3 x_1^2 x_2`の重みは`2 w_1 + w_2`です。 `ratwtlvl`に従った切り詰めは、 標準有理式(CRE)を掛けたり、指数化する時だけ実行されます。

  `ratweight ()`は、重み割り当ての累積リストを返します。

  注意：`ratfac`と`ratweight`体系は互換性はなく、 同時には使えないかもしれません。

  例:

      (%i1) ratweight (a, 1, b, 1);
      (%o1)                     [a, 1, b, 1]
      (%i2) expr1: rat(a + b + 1)$
      (%i3) expr1^2;
                        2                  2
      (%o3)/R/         b  + (2 a + 2) b + a  + 2 a + 1
      (%i4) ratwtlvl: 1$
      (%i5) expr1^2;
      (%o5)/R/                  2 b + 2 a + 1

  Rational expressions ·

システム変数: ratweights

  デフォルト値: `[]`

  `ratweights`は、`ratweight`で割り当てられた重みのリストです。 リストは累積されます: `ratweight`のコールそれぞれは、リストに項目を追加します。

  `kill (ratweights)`と`save (ratweights)`はともに期待通り動作します。

  Rational expressions ·

オプション変数: ratwtlvl

  デフォルト値: `false`

  `ratwtlvl`は、 標準有理式(CRE)の切り詰めを制御するために、 `ratweight`関数と組み合わせて使われます。 デフォルト値の`false`では、切り詰めは起こりません。

  Rational expressions ·

関数: remainder (p_1, p_2)
関数: remainder (p_1, p_2, x_1, …, x_n)

  多項式p_1を多項式p_2で割った余りを返します。 引数x_1, ..., x_nは、`ratvars`と同様に解釈されます。

  `remainder`は、`divide`が返す２要素リストの２番目の要素を返します。

  Polynomials ·

関数: resultant (p_1, p_2, x)
変数: resultant

  変数xを消去して、２つの多項式p_1とp_2の終結式を計算します。 終結式はp_1とp_2の中のxの係数の判別式です。 それは、p_1とp_2が共通に定数でない因子を持つ時だけゼロに等しいです。

  もしp_1もしくはp_2が因数分解できるなら、 `resultant`をコールする前に`factor`をコールするのが望ましいかもしれません。

  変数`resultant`は、 どのアルゴリズムが計算に使われるか制御します。 部分終結式prsには`subres` モジュラー終結式アルゴリズムには`mod` 通分prsには`red`。 大抵の問題では、`subres`が最適です。 いくつかの大きな次数の１変数もしくは２変数問題では、`mod`がよりよいかもしれません。

  関数`bezout`は、`resultant`と同じ引数を取り、 行列を返します。 戻り値の判別式は望みの終結式です。

  Polynomials ·

オプション変数: savefactors

  デフォルト値: `false`

  `savefactors`が`true`の時、 同じ因子のいくつかを含む式の因数分解を後でする時にスピードアップするために、 因子の積である式の因子がある関数によって保存されるようにします。

  Polynomials ·

関数: showratvars (expr)

  式`expr`の中の標準有理式 (CRE)変数のリストを返します。

  `ratvars`も参照してください。

  Rational expressions ·Display functions ·

関数: sqfr (expr)

  多項式因子が「平方にならない」ことを除いて、 `factor`に似ています。 すなわち、それらは、次数１だけの因子を持ちます。 このアルゴリズムは、`factor`の最初の段階でも使われるのですが、 多項式は、n階微分と共通に nよりも大きな次数のすべての因子を持つという事実を使います。 このように、それぞれの変数に関する微分の多項式との最大公約数を取ることによって、 1よりも大きな次数の因子を見つけることができます。

  例:

      (%i1) sqfr (4*x^4 + 4*x^3 - 3*x^2 - 4*x - 1);
                                      2   2
      (%o1)                  (2 x + 1)  (x  - 1)

  Polynomials ·

関数: tellrat (p_1, ..., p_n)
関数: tellrat ()

  多項式p_1, ..., p_nの解である要素を Maximaに知られている代数的整数の環に加えます。 それぞれの引数p_iは、整数係数の多項式です。

  `tellrat (x)`は、実際には、 有理関数の中でxに0を代入することを意味します。

  `tellrat ()`は、現在の代入のリストを返します。

  代数的整数の整理が効果を持つようにするために、 `algebraic`は、`true`に設定されなければいけません。

  Maximaは、起動の際には、虚数単位と整数の根すべてについて知っています。

  核を取り、`tellrat`プロパティを削除するコマンド`untellrat`があります。

  例えば、`tellrat (x^2 - y^2)`のように、 多変数多項式を`tellrat`する時、 `y^2`を`x^2`に代入するのか逆なのかといった あいまいさがあります。 Maximaは、特定の順序付けを選びますが、 もしユーザーがどちらか指定したいなら、 例えば，`tellrat (y^2 = x^2)`は `y^2`を`x^2`で置き換えることを示す構文法を供給します。

  例:

      (%i1) 10*(%i + 1)/(%i + 3^(1/3));
                                 10 (%i + 1)
      (%o1)                      -----------
                                        1/3
                                  %i + 3
      (%i2) ev (ratdisrep (rat(%)), algebraic);
                   2/3      1/3              2/3      1/3
      (%o2)    (4 3    - 2 3    - 4) %i + 2 3    + 4 3    - 2
      (%i3) tellrat (1 + a + a^2);
                                  2
      (%o3)                     [a  + a + 1]
      (%i4) 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2));
                            1                 a
      (%o4)           ------------- + -----------------
                      sqrt(2) a - 1   sqrt(3) + sqrt(2)
      (%i5) ev (ratdisrep (rat(%)), algebraic);
               (7 sqrt(3) - 10 sqrt(2) + 2) a - 2 sqrt(2) - 1
      (%o5)    ----------------------------------------------
                                     7
      (%i6) tellrat (y^2 = x^2);
                              2    2   2
      (%o6)                 [y  - x , a  + a + 1]

  Polynomials ·Rational expressions ·

関数: totaldisrep (expr)

  exprのすべての部分式を標準有理式(CRE)から一般形に変換して、 結果を返します。 もしexprがそれ自身CRE形なら、`totaldisrep`は、`ratdisrep`と同一です。

  `totaldisrep`は、 CRE形の部分式を持つ等式やリストや行列などの式をratdisrepするために役に立つかもしれません。

  Rational expressions ·

関数: untellrat (x_1, …, x_n)

  x_1, …, x_nから `tellrat`プロパティを 削除します。

  Polynomials ·Rational expressions ·

Next: Elliptic Functions, Previous: Polynomials, Up: Top [Contents][Index]

## 15 Special Functions

Next: Bessel Functions, Previous: Special Functions, Up: Special Functions [Contents][Index]

### 15.1 Introduction to Special Functions

特殊関数表記は以下の通りです:

    bessel_j (index, expr)         第一種ベッセル関数
    bessel_y (index, expr)         第二種ベッセル関数
    bessel_i (index, expr)         第一種変形ベッセル関数
    bessel_k (index, expr)         第二種変形ベッセル関数

    hankel_1 (v,z)                 第一種ハンケル関数
    hankel_2 (v,z)                 第二種ハンケル関数
    struve_h (v,z)                 シュトルーベH関数
    struve_l (v,z)                 シュトルーベL関数

    assoc_legendre_p[v,u] (z)      位数v、次数uのルジャンドル関数
    assoc_legendre_q[v,u] (z)      第二種ルジャンドル関数

    %f[p,q] ([], [], expr)         一般化超幾何関数
    gamma()                        ガンマ関数
    gamma_incomplete_lower(a,z)    第一種不完全ガンマ関数
    gammaincomplete(a,z)           第二種不完全ガンマ関数
    hypergeometric(l1, l2, z)      超幾何関数
    slommel
    %m[u,k] (z)                    第一種Whittaker関数
    %w[u,k] (z)                    第二種Whittaker関数
    erfc (z)                       相補誤差関数
    ei (z)                         指数積分 (?)
    kelliptic (z)                  第一種完全楕円積分 (K)
    parabolic_cylinder_d (v,z)     放物円筒D関数

Bessel functions ·Airy functions ·Special functions ·

Next: Airy Functions, Previous: Introduction to Special Functions, Up: Special Functions [Contents][Index]

### 15.2 Bessel Functions

関数: bessel_j (v, z)

  次数vと独立変数zの第一種ベッセル関数。

  `bessel_j`は以下のように定義されます。

                      inf
                      ====       k  - v - 2 k  v + 2 k
                      \     (- 1)  2          z
                       >    --------------------------
                      /        k! gamma(v + k + 1)
                      ====
                      k = 0

  計算のために無限級数は使われませんが。

  Bessel functions ·Special functions ·

関数: bessel_y (v, z)

  次数vと独立変数zの第二種ベッセル関数

  vが整数でない時、 `bessel_y`は以下のように定義されます。

                    cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
                    -------------------------------------------
                                   sin(%pi v)

  vが整数nの時、 vがnに近づく極限が取られます。

  Bessel functions ·Special functions ·

関数: bessel_i (v, z)

  次数v、独立変数zの第一種変形ベッセル関数

  `bessel_i`は以下のように定義されます。

                          inf
                          ====   - v - 2 k  v + 2 k
                          \     2          z
                           >    -------------------
                          /     k! gamma(v + k + 1)
                          ====
                          k = 0

  無限級数は計算には使われませんが。

  Bessel functions ·Special functions ·

関数: bessel_k (v, z)

  次数v、独立変数zの第二種変形ベッセル関数

  vが整数の時 `bessel_k`は以下のように定義されます。

                 %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
                 -------------------------------------------------
                                        2

  もしvが整数nでないなら、 vがnに近づく極限が取られます。

  Bessel functions ·Special functions ·

関数: hankel_1 (v, z)

  次数v、独立変数zの第一種ハンケル関数 (A&S 9.1.3)。 `hankel_1`は以下のように定義されます。

         bessel_j(v,z) + %i * bessel_y(v,z)

  Maximaは、 浮動小数点精度の実数次数vと複素独立変数zに対して `hankel_1`を数値的に評価します。 多倍長浮動小数点精度の数値評価と複素次数vはサポートされていません。

  `besselexpand`が`true`の時、 次数vが奇数の1/2の時`hankel_1`は初等関数の項に展開されます。 `besselexpand`を参照してください。

  Maximaは`hankel_1`の独立変数zに関する導関数を知っています。

  例:

  数値評価:

      (%i1) hankel_1(1,0.5);
      (%o1)              .2422684576748738 - 1.471472392670243 %i
      (%i2) hankel_1(1,0.5+%i);
      (%o2)             - .2558287994862166 %i - 0.239575601883016

  複素次数vはサポートされていません。 Maximaは名詞形を返します:

      (%i3) hankel_1(%i,0.5+%i);
      (%o3)                       hankel_1(%i, %i + 0.5)

  `besselexpand`が`true`の時の`hankel_1`の展開:

      (%i4) hankel_1(1/2,z),besselexpand:true;
                            sqrt(2) sin(z) - sqrt(2) %i cos(z)
      (%o4)                 ----------------------------------
                                    sqrt(%pi) sqrt(z)

  `hankel_1`の独立変数zに関する導関数。 次数vに関する導関数はサポートされていません。 Maximaは名詞形を返します:

      (%i5) diff(hankel_1(v,z),z);
                          hankel_1(v - 1, z) - hankel_1(v + 1, z)
      (%o5)               ---------------------------------------
                                             2
      (%i6) diff(hankel_1(v,z),v);
                                   d
      (%o6)                        -- (hankel_1(v, z))
                                   dv

  Bessel functions ·Special functions ·

関数: hankel_2 (v, z)

  次数v、独立変数zの第二種ハンケル関数 (A&S 9.1.4)。 `hankel_2`は以下のように定義されます。

         bessel_j(v,z) - %i * bessel_y(v,z)

  Maximaは、 浮動小数点精度の実数次数vと複素独立変数zに対して `hankel_2`を数値的に評価します。 多倍長浮動小数点精度の数値評価と複素次数vはサポートされていません。

  `besselexpand`が`true`の時、 次数vが奇数の1/2の時`hankel_2`は初等関数の項に展開されます。 `besselexpand`を参照してください。

  Maximaは`hankel_2`の独立変数zに関する導関数を知っています。

  例は`hankel_1`を参照してください。

  Bessel functions ·Special functions ·

オプション変数: besselexpand

  デフォルト値: `false`

  次数が半奇数の時のベッセル関数の展開を制御します。 この場合、ベッセル関数は他の初等関数で展開することができます。 `besselexpand`が`true`の時、 ベッセル関数は展開されます。

      (%i1) besselexpand: false$
      (%i2) bessel_j (3/2, z);
                                          3
      (%o2)                      bessel_j(-, z)
                                          2
      (%i3) besselexpand: true$
      (%i4) bessel_j (3/2, z);
                                              sin(z)   cos(z)
                             sqrt(2) sqrt(z) (------ - ------)
                                                 2       z
                                                z
      (%o4)                  ---------------------------------
                                         sqrt(%pi)

  Bessel functions ·Simplification flags and variables ·Special functions ·

関数: scaled_bessel_i (v, z)

  次数v、独立変数zのスケールされた第一種変形ベッセル関数。 すなわち、scaled_bessel_i(v,z) = exp(-abs(z))*bessel_i(v, z)。 この関数は、大きなzに関するbessel_i―これはおおきくなりますーの計算に 特に役に立ちます。 しかしながら、そうでなければ、Maximaはこの関数についてあまり知りません。 数式処理のためには、式`exp(-abs(z))*bessel_i(v, z)`を使って取り組むのが多分望ましいです。

  Bessel functions ·

関数: scaled_bessel_i0 (z)

  `scaled_bessel_i(0,z)`と同一です。

  Bessel functions ·Special functions ·

関数: scaled_bessel_i1 (z)

  `scaled_bessel_i(1,z)`と同一です。

  Bessel functions ·Special functions ·

関数: %s [u,v] (z)

  Lommelの小s[u,v](z)関数。 多分Gradshteyn & Ryzhik 8.570.1.

  Bessel functions ·Special functions ·

Next: Gamma and factorial Functions, Previous: Bessel Functions, Up: Special Functions [Contents][Index]

### 15.3 Airy Functions

エアリー関数Ai(x)とBi(x)は、Abramowitz and Stegun, Handbook of Mathematical Functions, Section 10.4の中で定義されています。

`y = Ai(x)`と`y = Bi(x)`は、 エアリー微分方程式`diff (y(x), x, 2) - x y(x) = 0`の ２つの線形独立な解です。

もし引数`x`が実数もしくは複素数の浮動小数点数なら、 関数の数値が返されます。

関数: airy_ai (x)

  エアリー関数Ai(x)。 (A&S 10.4.2)

  導関数`diff (airy_ai(x), x)`は、`airy_dai(x)`です。

  `airy_bi`, `airy_dai`, `airy_dbi`も参照してください。

  Airy functions ·Special functions ·

関数: airy_dai (x)

  エアリー関数Ai `airy_ai(x)`の導関数。

  `airy_ai`を参照してください。

  Airy functions ·Special functions ·

関数: airy_bi (x)

  エアリー関数Bi(x)。 (A&S 10.4.3)

  導関数`diff (airy_bi(x), x)`は`airy_dbi(x)`です。

  `airy_ai`, `airy_dbi`を参照してください。

  Airy functions ·Special functions ·

関数: airy_dbi (x)

  エアリーBi関数`airy_bi(x)`の導関数。

  `airy_ai`と`airy_bi`を参照してください。

  Airy functions ·Special functions ·

Next: Exponential Integrals, Previous: Airy Functions, Up: Special Functions [Contents][Index]

### 15.4 Gamma and factorial Functions

ガンマ関数と、関連したベータ、プサイ、不完全ガンマ関数は Abramowitz and Stegun, Handbook of Mathematical Functions, Chapter 6の中で定義されています。

関数: bffac (expr, n)

  階乗（シフトガンマ）関数の多倍長浮動小数点バージョン。 ２番目の引数は、保持し返すディジットの数です。 少しの余分を要請するのはいい考えです。

  Gamma and factorial functions ·Numerical evaluation ·

関数: bfpsi (n, z, fpprec)
関数: bfpsi0 (z, fpprec)

  `bfpsi`は、実引数zと整数次数nの多ガンマ関数です。 `bfpsi0`はディガンマ関数です。 `bfpsi0 (z, fpprec)`は`bfpsi (0, z, fpprec)`と同値です。

  これらの関数は多倍長浮動小数点値を返します。 fpprecは戻り値の多倍長浮動小数点精度です。

  Gamma and factorial functions ·Numerical evaluation ·

関数: cbffac (z, fpprec)

  複素多倍長浮動小数点の階乗です。

  `load ("bffac")`はこの関数をロードします。

  Gamma and factorial functions ·Complex variables ·Numerical evaluation ·

関数: gamma (z)

  ガンマ関数の基本的な定義 (A&S 6.1.1) は、

                               inf
                              /
                              [     z - 1   - t
                   gamma(z) = I    t      %e    dt
                              ]
                              /
                               0

  です。

  Maximaは、正の整数と正負の有理数に関して、`gamma`を整理します。 半整数値に関して、結果は有理数掛ける`sqrt(%pi)`です。 整数値に関する整理は、`factlim`によって制御されます。

  `factlim`より大きな整数に関して、 階乗関数ー`gamma`を計算するのに使われますーの数値的な結果はオーバーフローします。 有理数に関する整理は、内部オーバーフローを避けるために、 `gammalim`によって制御されます。 `factlim`と`gammalim`も参照してください。

  負の整数に関して、`gamma`は未定義です。

  Maximaは、浮動小数点および多倍長浮動小数点の実数値および複素数値に関して、 `gamma`を数値的に評価できます。

  `gamma`は鏡像対称性を持ちます。

  `gamma_expand`が`true`の時、 Maximaは、 引数`z+n`と`z-n`―`n`は整数―の`gamma`を 展開します。

  Maximaは、`gamma`の導関数を知っています。

  例:

  整数、半整数、有理数に関する整理:

      (%i1) map('gamma,[1,2,3,4,5,6,7,8,9]);
      (%o1)        [1, 1, 2, 6, 24, 120, 720, 5040, 40320]
      (%i2) map('gamma,[1/2,3/2,5/2,7/2]);
                          sqrt(%pi)  3 sqrt(%pi)  15 sqrt(%pi)
      (%o2)   [sqrt(%pi), ---------, -----------, ------------]
                              2           4            8
      (%i3) map('gamma,[2/3,5/3,7/3]);
                                        2           1
                                2 gamma(-)  4 gamma(-)
                            2           3           3
      (%o3)          [gamma(-), ----------, ----------]
                            3       3           9

  実数と複素数の数値評価:

      (%i4) map('gamma,[2.5,2.5b0]);
      (%o4)     [1.329340388179137, 1.329340388179137b0]
      (%i5) map('gamma,[1.0+%i,1.0b0+%i]);
      (%o5) [.4980156681183558 - .1549498283018108 %i,
               4.980156681183561b-1 - 1.549498283018107b-1 %i]

  `gamma`は鏡像対称性を持ちます:

      (%i6) declare(z,complex)$
      (%i7) conjugate(gamma(z));
      (%o7)                  gamma(conjugate(z))

  `gamma_expand`が`true`の時 Maximaは、`gamma(z+n)`と`gamma(z-n)`を展開します:

      (%i8) gamma_expand:true$

      (%i9) [gamma(z+1),gamma(z-1),gamma(z+2)/gamma(z+1)];
                                     gamma(z)
      (%o9)             [z gamma(z), --------, z + 1]
                                      z - 1

  `gamma`の導関数:

      (%i10) diff(gamma(z),z);
      (%o10)                  psi (z) gamma(z)
                                 0

  `makegamma`も参照してください。

  オイラー-マスケローニ定数は`%gamma`です。

  Gamma and factorial functions ·Special functions ·

関数: log_gamma (z)

  ガンマ関数の自然対数。

  Gamma and factorial functions ·Special functions ·

関数: gamma_incomplete (a,z)

  第二種不完全ガンマ関数 A&S 6.5.2:

                                    inf
                                   /
                                   [     a - 1   - t
          gamma_incomplete(a, z) = I    t      %e    dt
                                   ]
                                   /
                                    z

  Gamma and factorial functions ·Special functions ·

関数: gamma_incomplete_regularized (a, z)

  正則第二種不完全ガンマ関数 A&S 6.5.1:

      gamma_incomplete_regularized(a, z) =
                                              gamma_incomplete(a, z)
                                              ----------------------
                                                     gamma(a)

  Gamma and factorial functions ·Special functions ·

関数: gamma_incomplete_generalized (a,z1,z1 )

  一般化不完全ガンマ関数

      gamma_incomplete_generalized(a, z1, z2) =
                                                     z2
                                                    /
                                                    [    a - 1   - t
                                                    I   t      %e    dt
                                                    ]
                                                    /
                                                     z1

  Gamma and factorial functions ·Special functions ·

オプション変数: gammalim

  デフォルト値: 1000000

  `gammalim`は、整数と有理数引数に関してガンマ関数の整理を制御します。 もし引数の絶対値が`gammalim`よりも大きくないなら、 整理が行われます。 `factlim`スイッチは、 整数引数の`gamma`の結果の整理を制御します。 `factlim`スイッチは、 整数引数の`gamma`の結果の整理も制御することに注意してください。

  Gamma and factorial functions ·Simplification flags and variables ·

関数: makegamma (expr)

  exprの中の２項、階乗、ベータ関数のインスタンスをガンマ関数に変換します。

  `makefact`も参照してください。

  Gamma and factorial functions ·

関数: beta (a, b)

  ベータ関数は、`gamma(a) gamma(b)/gamma(a+b)` (A&S 6.2.1)として定義されます。

  Maximaは、正の整数と、合計すると整数になる有理数についてベータ関数を整理します。 `beta_args_sum_to_integer`が`true`の時、 Maximaは、和が整数になる一般式も整理します。

  aもしくはbがゼロに等しい時には、ベータ関数は未定義です。

  一般にベータ関数は、負の整数の引数で未定義です。 例外は、a=-n―nは正の整数―かつbがb<=nの正の整数で、 解析接続を定義することが可能です。 Maximaはこの場合結果を与えます。

  `beta_expand`が`true`の時、 `n`を整数とする`beta(a+n,b)`と`beta(a-n,b)`、 もしくは`beta(a,b+n)`と`beta(a,b-n)` のような式は整理されます。

  Maximaは、実数値と複素数値のベータ関数を浮動小数点と多倍長浮動小数点精度で評価できます。 数値評価のために、Maximaは`log_gamma`を使います:

                 - log_gamma(b + a) + log_gamma(b) + log_gamma(a)
               %e

  Maximaは、ベータ関数が対称で、鏡像対称性を持つことを知っています。

  Maximaは、aまたはbに関するベータ関数の導関数を知っています。

  ベータ関数をガンマ関数の比として表現するには、`makegamma`を参照してください。

  例:

  引数の１つが整数の時の整理:

      (%i1) [beta(2,3),beta(2,1/3),beta(2,a)];
                                     1   9      1
      (%o1)                         [--, -, ---------]
                                     12  4  a (a + 1)

  ２つの有理数引数の和が整数になる時の整理:

      (%i2) [beta(1/2,5/2),beta(1/3,2/3),beta(1/4,3/4)];
                                3 %pi   2 %pi
      (%o2)                    [-----, -------, sqrt(2) %pi]
                                  8    sqrt(3)

  `beta_args_sum_to_integer`を`true`に設定した時、 引数の和が整数の時、さらに一般的な式が整理されます:

      (%i3) beta_args_sum_to_integer:true$
      (%i4) beta(a+1,-a+2);
                                      %pi (a - 1) a
      (%o4)                         ------------------
                                    2 sin(%pi (2 - a))

  引数の１つが負の整数の時、可能な結果:

      (%i5) [beta(-3,1),beta(-3,2),beta(-3,3)];
                                          1  1    1
      (%o5)                            [- -, -, - -]
                                          3  6    3

  `beta_expand`が`true`の時、 `n`が整数の`beta(a+n,b)`または`beta(a-n)`は整理されます:

      (%i6) beta_expand:true$
      (%i7) [beta(a+1,b),beta(a-1,b),beta(a+1,b)/beta(a,b+1)];
                          a beta(a, b)  beta(a, b) (b + a - 1)  a
      (%o7)              [------------, ----------------------, -]
                             b + a              a - 1           b

  引数の１つがゼロの時、ベータは未定義です:

      (%i7) beta(0,b);
      beta: expected nonzero arguments; found 0, b
       -- an error.  To debug this try debugmode(true);

  実数値と複素数値の浮動小数点または多倍長浮動小数点精度での数値評価:

      (%i8) beta(2.5,2.3);
      (%o8) .08694748611299981

      (%i9) beta(2.5,1.4+%i);
      (%o9) 0.0640144950796695 - .1502078053286415 %i

      (%i10) beta(2.5b0,2.3b0);
      (%o10) 8.694748611299969b-2

      (%i11) beta(2.5b0,1.4b0+%i);
      (%o11) 6.401449507966944b-2 - 1.502078053286415b-1 %i

  ベータは対称で、鏡像対称性を持ちます:

      (%i14) beta(a,b)-beta(b,a);
      (%o14)                                 0
      (%i15) declare(a,complex,b,complex)$
      (%i16) conjugate(beta(a,b));
      (%o16)                 beta(conjugate(a), conjugate(b))

  `a`に関するベータ関数の導関数:

      (%i17) diff(beta(a,b),a);
      (%o17)               - beta(a, b) (psi (b + a) - psi (a))
                                            0             0

  Gamma and factorial functions ·

関数: beta_incomplete (a, b, z)

  不完全ベータ関数の基本定義(A&S 6.6.1)は、以下の通りです。

              z
             /
             [         b - 1  a - 1
             I  (1 - t)      t      dt
             ]
             /
              0

  この定義は、realpart(a)>0かつrealpart(b)>0かつabs(z)<1で可能です。 他の値では不完全ベータ関数は一般化超幾何関数を通じて定義することができます。

         gamma(a) hypergeometric_generalized([a, 1 - b], [a + 1], z) z

  (不完全ベータ関数の完全な定義については、functions.wolfram.comを参照してください。 )

  負の整数a = -nと正の整数b=mで、m<=nの場合、 不完全ベータ関数は以下を通して定義されます。

                                  m - 1           k
                                  ====  (1 - m)  z
                            n - 1 \            k
                           z       >    -----------
                                  /     k! (n - k)
                                  ====
                                  k = 0

  Maximaは、 負の整数aに関する`beta_incomplete`を整理するために、この定義を使います。

  aが正の整数の時、 任意の引数b, zに関して、 bが正の整数の時、 非負の整数a, 任意のzに関して、 `beta_incomplete`は整理されます。

  z=0かつrealpart(a)>0の時、`beta_incomplete`は特別な値ゼロを取ります。 z=1かつrealpart(b)>0の時、 `beta_incomplete`はベータ関数`beta(a,b)`に整理されます。

  Maximaは、浮動小数点か多倍長浮動小数点精度の実数値と複素数値に対して、 `beta_incomplete`を数値的に評価します。 数値評価に関して、 不完全ベータ函数の連分数展開を使います。

  オプション変数`beta_expand`が`true`の時、 Maximaは`beta_incomplete(a+n,b,z)`や`beta_incomplete(a-n,b,z)`のような式を展開します。ここでnは正の整数です。

  Maximaは`beta_incomplete`の変数a, b, zについての導関数と 変数zについての積分を知っています。

  例:

  正の整数aに関する整理:

      (%i1) beta_incomplete(2,b,z);
                                             b
                                  1 - (1 - z)  (b z + 1)
      (%o1)                       ----------------------
                                        b (b + 1)

  正の整数bに関する整理:

      (%i2) beta_incomplete(a,2,z);
                                                     a
                                    (a (1 - z) + 1) z
      (%o2)                         ------------------
                                        a (a + 1)

  正の整数a, bに関する整理:

      (%i3) beta_incomplete(3,2,z);

                                                     3
                                    (3 (1 - z) + 1) z
      (%o3)                         ------------------
                                            12

  aが負の整数かつb<=(-a)の時、Maximaは整理します:

      (%i4) beta_incomplete(-3,1,z);
                                             1
      (%o4)                              - ----
                                              3
                                           3 z

  特定の値z=0とz=1に関して, Maximaは整理します:

      (%i5) assume(a>0,b>0)$
      (%i6) beta_incomplete(a,b,0);
      (%o6)                                 0
      (%i7) beta_incomplete(a,b,1);
      (%o7)                            beta(a, b)

  浮動小数点または多倍長浮動小数点精度の数値評価:

      (%i8) beta_incomplete(0.25,0.50,0.9);
      (%o8)                          4.594959440269333
      (%i9)  fpprec:25$
      (%i10) beta_incomplete(0.25,0.50,0.9b0);
      (%o10)                    4.594959440269324086971203b0

  abs(z)>1の時、`beta_incomplete`は複素数を返します:

      (%i11) beta_incomplete(0.25,0.50,1.7);
      (%o11)              5.244115108584249 - 1.45518047787844 %i

  もっと一般的な複素引数に関する結果:

      (%i14) beta_incomplete(0.25+%i,1.0+%i,1.7+%i);
      (%o14)             2.726960675662536 - .3831175704269199 %i
      (%i15) beta_incomplete(1/2,5/4*%i,2.8+%i);
      (%o15)             13.04649635168716 %i - 5.802067956270001
      (%i16)

  `beta_expand`が`true`の時の展開:

      (%i23) beta_incomplete(a+1,b,z),beta_expand:true;
                                                             b  a
                         a beta_incomplete(a, b, z)   (1 - z)  z
      (%o23)             -------------------------- - -----------
                                   b + a                 b + a

      (%i24) beta_incomplete(a-1,b,z),beta_expand:true;
                                                                 b  a - 1
                 beta_incomplete(a, b, z) (- b - a + 1)   (1 - z)  z
      (%o24)     -------------------------------------- - ---------------
                                 1 - a                         1 - a

  `beta_incomplete`の微分と積分:

      (%i34) diff(beta_incomplete(a, b, z), z);

                                    b - 1  a - 1
      (%o34)                 (1 - z)      z

      (%i35) integrate(beta_incomplete(a, b, z), z);
                    b  a
             (1 - z)  z
      (%o35) ----------- + beta_incomplete(a, b, z) z
                b + a
                                             a beta_incomplete(a, b, z)
                                           - --------------------------
                                                       b + a
      (%i36) factor(diff(%, z));
      (%o36)              beta_incomplete(a, b, z)

  Gamma and factorial functions ·

関数: beta_incomplete_regularized (a, b, z)

      beta_incomplete_regularized(a, b, z) =
                                            beta_incomplete(a, b, z)
                                            ------------------------
                                                   beta(a, b)

  として定義された正則不完全ベータ関数 A&S 6.6.2。

  `beta_incomplete`同様、この定義は完全ではありません。 `beta_incomplete_regularized`の完全な定義については、functions.wolfram.comを参照してください。

  `beta_incomplete_regularized`は、aまたはbが正の整数の時 整理されます。

  z=0かつrealpart(a)>0の時、 `beta_incomplete_regularized`は、具体的な値0を持ちます。 z=1かつrealpart(b)>0の時、 `beta_incomplete_regularized`は、1に整理されます。

  Maximaは、実数と複素数の引数について、 浮動小数点と多倍長浮動小数点精度で`beta_incomplete_regularized`を評価します。

  `beta_expand`が`true`の時、 Maximaは、 nは整数として、引数a+nまたはa-nに関して `beta_incomplete_regularized`を展開します。

  Maximaは、変数a, b, zに関する `beta_incomplete_regularized`の導関数と、 変数zに関する積分を知っています。

  例:

  aまたはbが正の整数の時の整理:

      (%i1) beta_incomplete_regularized(2,b,z);
                                             b
      (%o1)                       1 - (1 - z)  (b z + 1)

      (%i2) beta_incomplete_regularized(a,2,z);
                                                     a
      (%o2)                         (a (1 - z) + 1) z

      (%i3) beta_incomplete_regularized(3,2,z);
                                                     3
      (%o3)                         (3 (1 - z) + 1) z

  特定の値z=0, z=1について、Maximaは整理します:

      (%i4) assume(a>0,b>0)$
      (%i5) beta_incomplete_regularized(a,b,0);
      (%o5)                                 0
      (%i6) beta_incomplete_regularized(a,b,1);
      (%o6)                                 1

  実数と複素数引数に関する浮動小数点または多倍長浮動小数点精度の数値評価:

      (%i7) beta_incomplete_regularized(0.12,0.43,0.9);
      (%o7)                         .9114011367359802
      (%i8) fpprec:32$
      (%i9) beta_incomplete_regularized(0.12,0.43,0.9b0);
      (%o9)               9.1140113673598075519946998779975b-1
      (%i10) beta_incomplete_regularized(1+%i,3/3,1.5*%i);
      (%o10)             .2865367499935403 %i - 0.122995963334684
      (%i11) fpprec:20$
      (%i12) beta_incomplete_regularized(1+%i,3/3,1.5b0*%i);
      (%o12)      2.8653674999354036142b-1 %i - 1.2299596333468400163b-1

  `beta_expand`が`true`の時の展開:

      (%i13) beta_incomplete_regularized(a+1,b,z);
                                                           b  a
                                                    (1 - z)  z
      (%o13) beta_incomplete_regularized(a, b, z) - ------------
                                                    a beta(a, b)
      (%i14) beta_incomplete_regularized(a-1,b,z);
      (%o14) beta_incomplete_regularized(a, b, z)
                                                           b  a - 1
                                                    (1 - z)  z
                                               - ----------------------
                                                 beta(a, b) (b + a - 1)

  zに関する微分と積分:

      (%i15) diff(beta_incomplete_regularized(a,b,z),z);
                                    b - 1  a - 1
                             (1 - z)      z
      (%o15)                 -------------------
                                 beta(a, b)
      (%i16) integrate(beta_incomplete_regularized(a,b,z),z);
      (%o16) beta_incomplete_regularized(a, b, z) z
                                                                 b  a
                                                          (1 - z)  z
                a (beta_incomplete_regularized(a, b, z) - ------------)
                                                          a beta(a, b)
              - -------------------------------------------------------
                                         b + a

  Gamma and factorial functions ·

関数: beta_incomplete_generalized (a, b, z1, z2)

  一般化不完全ベータ関数の基本的な定義は、以下の通りです。

                   z2
                 /
                 [          b - 1  a - 1
                 I   (1 - t)      t      dt
                 ]
                 /
                  z1

  Maximaは、 aとbが正の整数の時、 `beta_incomplete_regularized`を整理します。

  realpart(a)>0かつz1=0またはz2=0の時、 Maximaは、 `beta_incomplete_generalized`を`beta_incomplete`に整理します。 realpart(b)>0かつz1=1またはz2=1の時、 Maximaは、`beta`と`beta_incomplete`を含む式に整理します。

  Maximaは、実数値と複素数値に関して、浮動小数点と多倍長浮動小数点精度で `beta_incomplete_regularized`を評価します。

  `beta_expand`が`true`の時、 nを正の整数とすると、 Maximaは、a+nやa-nに関して`beta_incomplete_generalized` を整理します。

  Maximaは、 変数a, b, z1, z2に関する `beta_incomplete_generalized`の微分を知っており、 変数z1やz2に関する積分を知っています。

  例:

  Maximaは、aとbが正の整数の時、 `beta_incomplete_generalized`を整理します:

      (%i1) beta_incomplete_generalized(2,b,z1,z2);
                         b                      b
                 (1 - z1)  (b z1 + 1) - (1 - z2)  (b z2 + 1)
      (%o1)      -------------------------------------------
                                  b (b + 1)
      (%i2) beta_incomplete_generalized(a,2,z1,z2);

                                    a                      a
                 (a (1 - z2) + 1) z2  - (a (1 - z1) + 1) z1
      (%o2)      -------------------------------------------
                                  a (a + 1)

      (%i3) beta_incomplete_generalized(3,2,z1,z2);
                    2      2                       2      2
            (1 - z1)  (3 z1  + 2 z1 + 1) - (1 - z2)  (3 z2  + 2 z2 + 1)
      (%o3) -----------------------------------------------------------
                                        12

  特定の値z1=0, z2=0, z1=1またはz2=1に関する整理:

      (%i4) assume(a > 0, b > 0)$
      (%i5) beta_incomplete_generalized(a,b,z1,0);
      (%o5)                    - beta_incomplete(a, b, z1)

      (%i6) beta_incomplete_generalized(a,b,0,z2);
      (%o6)                    - beta_incomplete(a, b, z2)

      (%i7) beta_incomplete_generalized(a,b,z1,1);
      (%o7)              beta(a, b) - beta_incomplete(a, b, z1)

      (%i8) beta_incomplete_generalized(a,b,1,z2);
      (%o8)              beta_incomplete(a, b, z2) - beta(a, b)

  浮動小数点もしくは多倍長浮動小数点精度での実数値引数に関する数値評価:

      (%i9) beta_incomplete_generalized(1/2,3/2,0.25,0.31);
      (%o9)                        .09638178086368676

      (%i10) fpprec:32$
      (%i10) beta_incomplete_generalized(1/2,3/2,0.25,0.31b0);
      (%o10)               9.6381780863686935309170054689964b-2

  浮動小数点もしくは多倍長浮動小数点精度での複素数値引数に関する数値評価:

      (%i11) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31);
      (%o11)           - .09625463003205376 %i - .003323847735353769
      (%i12) fpprec:20$
      (%i13) beta_incomplete_generalized(1/2+%i,3/2+%i,0.25,0.31b0);
      (%o13)     - 9.6254630032054178691b-2 %i - 3.3238477353543591914b-3

  `beta_expand`が`true`の時、 nを正の整数とする、 a+nまたはa-nに関する整理:

      (%i14) beta_expand:true$

      (%i15) beta_incomplete_generalized(a+1,b,z1,z2);

                     b   a           b   a
             (1 - z1)  z1  - (1 - z2)  z2
      (%o15) -----------------------------
                         b + a
                            a beta_incomplete_generalized(a, b, z1, z2)
                          + -------------------------------------------
                                               b + a
      (%i16) beta_incomplete_generalized(a-1,b,z1,z2);

             beta_incomplete_generalized(a, b, z1, z2) (- b - a + 1)
      (%o16) -------------------------------------------------------
                                      1 - a
                                          b   a - 1           b   a - 1
                                  (1 - z2)  z2      - (1 - z1)  z1
                                - -------------------------------------
                                                  1 - a

  変数z1に関する微分とz1やz2に関する積分:

      (%i17) diff(beta_incomplete_generalized(a,b,z1,z2),z1);
                                     b - 1   a - 1
      (%o17)               - (1 - z1)      z1
      (%i18) integrate(beta_incomplete_generalized(a,b,z1,z2),z1);
      (%o18) beta_incomplete_generalized(a, b, z1, z2) z1
                                        + beta_incomplete(a + 1, b, z1)
      (%i19) integrate(beta_incomplete_generalized(a,b,z1,z2),z2);
      (%o19) beta_incomplete_generalized(a, b, z1, z2) z2
                                        - beta_incomplete(a + 1, b, z2)

  Gamma and factorial functions ·

オプション変数: beta_expand

  デフォルト値: false

  `beta_expand`が`true`の時、 a+nやa-nのような引数に対して `beta(a,b)` と、関連した関数は展開されます。 ここでnは整数です。

  Gamma and factorial functions ·Simplification flags and variables ·

オプション変数: beta_args_sum_to_integer

  デフォルト値: false

  `beta_args_sum_to_integer`が`true`の時、 引数aとbの和が整数の時、 Maximaは`beta(a,b)`を整理します。

  Gamma and factorial functions ·Simplification flags and variables ·

関数: psi [n](x)

  `log (gamma (x))`の次数`n+1`の導関数。 例えば、 `psi[0](x)`は１階微分、 `psi[1](x)`は２階微分など。

  Maximaは、一般に、`psi`の数値を計算する方法を知りませんが、 有理数の引数に関してはいくつかの厳密な値を計算することができます。 いくつの変数は、`psi`が可能なら厳密な値を返す有理数の引数の範囲を制御します。 `maxpsiposint`, `maxpsinegint`, `maxpsifracnum`, `maxpsifracdenom`を参照してください。 すなわち、xは、`maxpsinegint`と`maxpsiposint`の間になければいけません。 もしxの小数部分の絶対値が有理数で、かつ分子が`maxpsifracnum`より小さく、 分母が`maxpsifracdenom`より小さければ、 `psi`は厳密な値を返します。

  `bffac`パッケージの中の 関数`bfpsi`は数値を計算できます。

  Gamma and factorial functions ·

オプション変数: maxpsiposint

  デフォルト値: 20

  `maxpsiposint`は、 `psi[n](x)`が厳密な値を計算しようとする 最も大きな正の値です。

  Gamma and factorial functions ·

オプション変数: maxpsinegint

  デフォルト値: -10

  `maxpsinegint` `psi[n](x)`が厳密な値を計算しようとする 最も大きな負の値です。 従って、もし xが`maxnegint`よりも小さければ、 たとえ可能でも、 `psi[n](x)`は整理された答えを返しません。

  Gamma and factorial functions ·

オプション変数: maxpsifracnum

  デフォルト値: 6

  xを１より小さい、形式`p/q`の有理数とします。 もし`p`が`maxpsifracnum`より大きいなら `psi[n](x)`は、 整理された値を返そうとしません。

  Gamma and factorial functions ·

オプション変数: maxpsifracdenom

  デフォルト値: 6

  xを１より小さい、形式`p/q`の有理数とします。 もし`q`が`maxpsifracdenom`より大きいなら `psi[n](x)`は、 整理された値を返そうとしません。

  Gamma and factorial functions ·

関数: makefact (expr)

  exprの中の二項、ガンマ、ベータ関数のインスタンスを階乗に変換します。

  `makegamma`も参照してください。

  Gamma and factorial functions ·

関数: numfactor (expr)

  式exprを掛ける数値因子を返します。 式exprは単一項でなければいけません。

  `content`は、輪の中のすべての項の最大公約数を返します。

      (%i1) gamma (7/2);
                                15 sqrt(%pi)
      (%o1)                     ------------
                                     8
      (%i2) numfactor (%);
                                     15
      (%o2)                          --
                                     8

  Expressions ·

Next: Error Function, Previous: Gamma and factorial Functions, Up: Special Functions [Contents][Index]

### 15.5 Exponential Integrals

指数積分と、関連した関数は、 Abramowitz and Stegun, Handbook of Mathematical Functions, 5章の中で定義されています。

関数: expintegral_e1 (z)

  指数積分E1(z) (A&S 5.1.1)

  Exponential Integrals ·Special functions ·

関数: expintegral_ei (z)

  指数積分Ei(z) (A&S 5.1.2)

  Exponential Integrals ·Special functions ·

関数: expintegral_li (z)

  指数積分Li(z) (A&S 5.1.3)

  Exponential Integrals ·Special functions ·

関数: expintegral_e (n,z)

  指数積分 En(z) (A&S 5.1.4)

  Exponential Integrals ·Special functions ·

関数: expintegral_si (z)

  指数積分 Si(z) (A&S 5.2.1)

  Exponential Integrals ·Special functions ·

関数: expintegral_ci (z)

  指数積分 Ci(z) (A&S 5.2.2)

  Exponential Integrals ·Special functions ·

関数: expintegral_shi (z)

  指数積分 Shi(z) (A&S 5.2.3)

  Exponential Integrals ·Special functions ·

関数: expintegral_chi (z)

  指数積分 Chi(z) (A&S 5.2.4)

  Exponential Integrals ·Special functions ·

オプション変数: expintrep

  デフォルト値: false

  指数積分の表現を、 gamma_incomplete, expintegral_e1, expintegral_ei, expintegral_li, expintegral_trig, expintegral_hyp に変えます。

  Exponential Integrals ·

オプション変数: expintexpand

  デフォルト値: false

  Expand the Exponential Integral 半整数値の指数積分E[n](z)をErfcもしくはErfの項で展開し、 整数値のそれをEiの項で展開します。

  Exponential Integrals ·

Next: Struve Functions, Previous: Exponential Integrals, Up: Special Functions [Contents][Index]

### 15.6 Error Function

誤差関数と、関連した関数は、 Abramowitz and Stegun, Handbook of Mathematical Functions, 7章で定義されています。

関数: erf (z)

  誤差関数erf(z) (A&S 7.1.1)

  See also flag `erfflag`.

  Special functions ·

関数: erfc (z)

  相補誤差関数erfc(z) (A&S 7.1.2)

  `erfc(z) = 1-erf(z)`

  Special functions ·

関数: erfi (z)

  虚数誤差関数

  `erfi(z) = -%i*erf(%i*z)`

  Special functions ·

関数: erf_generalized (z1,z2)

  一般化誤差関数Erf(z1,z2)

  Special functions ·

関数: fresnel_c (z)

  フレネル積分C(z) = integrate(cos((%pi/2)*t^2),t,0,z) (A&S 7.3.1)

  フラグ`trigsign`が`true`の時、 整理 fresnel_c(-x) = -fresnel_c(x) が適用されます。

  フラグ`%iargs`が`true`の時、 整理 fresnel_c(%i*x) = %i*fresnel_c(x) が適用されます。

  フラグ`erf_representation`と`hypergeometric_representation`を参照してください。

  Special functions ·

関数: fresnel_s (z)

  フレネル積分S(z) = integrate(sin((%pi/2)*t^2),t,0,z). (A&S 7.3.2)

  フラグ`trigsign`が`true`の時、 整理fresnel_s(-x) = -fresnel_s(x) が適用されます。

  フラグ`%iargs`が`true`の時、 整理 fresnel_s(%i*x) = %i*fresnel_s(x) が適用されます。

  フラグ`erf_representation`と`hypergeometric_representation`を参照してください。

  Special functions ·

オプション変数: erf_representation

  デフォルト値: false

  `true`の時、 erfc, erfi, erf_generalized, fresnel_s, fresnel_c は、erfに変換されます。

オプション変数: hypergeometric_representation

  デフォルト値: false

  fresnel_sとfresnel_cに関して超幾何表現への変換を可能にします。

Next: Hypergeometric Functions, Previous: Error Function, Up: Special Functions [Contents][Index]

### 15.7 Struve Functions

シュトルーベ関数はAbramowitz and Stegun, Handbook of Mathematical Functions, 12章で定義されています。

Maximaは、これらの関数の非常に限られた知識を持っています。 それらは、関数`hgfred`から返されることができます。

関数: struve_h (v, z)

  次数v, 独立変数zのシュトルーベ関数H (A&S 12.1.1)

  Special functions ·

関数: struve_l (v, z)

  次数v、独立変数zの変形シュトルーベ関数L (A&S 12.2.1)

  Special functions ·

Next: Parabolic Cylinder Functions, Previous: Struve Functions, Up: Special Functions [Contents][Index]

### 15.8 Hypergeometric Functions

超幾何関数はAbramowitz and Stegun, Handbook of Mathematical Functions, 13章15章で定義されています。

Maximaは、これらの関数の非常に限られた知識を持っています。 それらは、関数`hgfred`から返されることができます。

関数: %m [k,u] (z)

  Whittaker M関数 `M[k,u](z) = exp(-z/2)*z^(1/2+u)*M(1/2+u-k,1+2*u,z)`. (A&S 13.1.32)

  Special functions ·

関数: %w [k,u] (z)

  Whittaker W関数 (A&S 13.1.33)

  Special functions ·

関数: %f [p,q] ([a],[b],z)

  pFq(a1,a2,..ap;b1,b2,..bq;z)超幾何関数。 ここで、`a`は長さ`p`のリストで、 `b`は長さ`q`のリストです。

  Bessel functions ·Special functions ·

関数: hypergeometric ([a1, ..., ap],[b1, ... ,bq], x)

  超幾何関数。 Maximaの`%f`超幾何関数と違って， 関数`hypergeometric`は整理関数です; `hypergeometric`は複素倍精度と多倍長浮動小数点評価もサポートします。 ガウスの超幾何関数、すなわち、p = 2かつq = 1、 に関しては、 単位円の外側の浮動小数点評価はサポートされていますが、 一般にはサポートされていません。

  オプション変数`expand_hypergeometric`がtrue(デフォルトはfalse)で、 独立変数`a1`から`ap`の１つが負の整数の時(多項式の場合)、 `hypergeometric`は展開された多項式を返します。

  例:

      (%i1)  hypergeometric([],[],x);
      (%o1) %e^x

  `expand_hypergeometric`がtrueの時、多項式の場合は自動的に展開されます:

      (%i2) hypergeometric([-3],[7],x);
      (%o2) hypergeometric([-3],[7],x)

      (%i3) hypergeometric([-3],[7],x), expand_hypergeometric : true;
      (%o3) -x^3/504+3*x^2/56-3*x/7+1

  倍精度と多倍長浮動小数点評価の両方がサポートされています:

      (%i4) hypergeometric([5.1],[7.1 + %i],0.42);
      (%o4)       1.346250786375334 - 0.0559061414208204 %i
      (%i5) hypergeometric([5,6],[8], 5.7 - %i);
      (%o5)     .00737582400977495 - 0.001049813688578674 %i
      (%i6) hypergeometric([5,6],[8], 5.7b0 - %i), fpprec : 30;
      (%o6) 7.37582400977494674506442010824b-3
                                - 1.04981368857867315858055393376b-3 %i

Next: Functions and Variables for Special Functions, Previous: Hypergeometric Functions, Up: Special Functions [Contents][Index]

### 15.9 Parabolic Cylinder Functions

放物円筒関数はAbramowitz and Stegun, Handbook of Mathematical Functions, 19章で定義されています。

Maximaは、これらの関数の非常に限られた知識を持っています。 それらは、関数`hgfred`から返されることができます。

関数: parabolic_cylinder_d (v, z)

  放物円筒関数`parabolic_cylinder_d(v,z)`. (A&s 19.3.1)

  Special functions ·

Previous: Parabolic Cylinder Functions, Up: Special Functions [Contents][Index]

### 15.10 Functions and Variables for Special Functions

関数: specint (exp(- s*t) * expr, t)

  exprの変数tに関するラプラス変換を計算します。 以下の特殊関数は`specint`で扱われます: 不完全ベータ関数、誤差関数 （誤差関数`erfi`ではないです。`erfi`は例えば、`erf`に変換することは簡単です。）、 指数積分、（ベッセル関数の積を含む）ベッセル関数、ハンケル関数、エルミートおよびラーゲル多項式。

  更に、`specint`は、超幾何関数`%f[p,q]([],[],z)`、 第一種Whittaker関数`%m[u,k](z)`第二種Whittaker関数`%w[u,k](z)`を 扱うことができます。

  結果は、特殊関数の項になるかもしれませんし、未整理の超幾何関数を含むかもしれません。

  `laplace`がラプラス変換を見つけることに失敗した時、 `specint`がコールされます。 `laplace`はラプラス変換に関するもっと一般的な規則を知っているので、 `specint`ではなく`laplace`を使うのが望ましいです。

  `demo(hypgeo)`は、`specint`によって計算されたラプラス変換のいくつかの例を表示します。

  例:

      (%i1) assume (p > 0, a > 0)$
      (%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
                                 sqrt(%pi)
      (%o2)                     ------------
                                       a 3/2
                                2 (p + -)
                                       4
      (%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2))
                    * exp(-p*t), t);
                                         - a/p
                               sqrt(a) %e
      (%o3)                    ---------------
                                      2
                                     p

  指数積分の例:

      (%i4) assume(s>0,a>0,s-a>0)$
      (%i5) ratsimp(specint(%e^(a*t)
                            *(log(a)+expintegral_e1(a*t))*%e^(-s*t),t));
                                   log(s)
      (%o5)                        ------
                                   s - a
      (%i6) logarc:true$

      (%i7) gamma_expand:true$

      (%i8) radcan(specint((cos(t)*expintegral_si(t)
                           -sin(t)*expintegral_ci(t))*%e^(-s*t),t));
                                   log(s)
      (%o8)                        ------
                                    2
                                   s  + 1
      (%i9) ratsimp(specint((2*t*log(a)+2/a*sin(a*t)
                            -2*t*expintegral_ci(a*t))*%e^(-s*t),t));
                                     2    2
                                log(s  + a )
      (%o9)                     ------------
                                      2
                                     s

  `gamma_incomplete`の展開を使った時と、 `expintegral_e1`への表現の変形を使った時のの結果:

      (%i10) assume(s>0)$
      (%i11) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
                                                  1
                                  gamma_incomplete(-, k s)
                                                  2
      (%o11)                      ------------------------
                                     sqrt(%pi) sqrt(s)

      (%i12) gamma_expand:true$
      (%i13) specint(1/sqrt(%pi*t)*unit_step(t-k)*%e^(-s*t),t);
                                    erfc(sqrt(k) sqrt(s))
      (%o13)                        ---------------------
                                           sqrt(s)

      (%i14) expintrep:expintegral_e1$
      (%i15) ratsimp(specint(1/(t+a)^2*%e^(-s*t),t));
                                    a s
                              a s %e    expintegral_e1(a s) - 1
      (%o15)                - ---------------------------------
                                              a

  Laplace transform ·

関数: hgfred (a, b, t)

  一般化超幾何関数を他のより簡単な形式に整理します。 aは分子パラメータのリストで、bは分母パラメータのリストです。

  もし`hgfred`が超幾何関数を整理できなければ、 形式`%f[p,q]([a], [b], x)`の式を返します。 ここでpはaの中の要素の数で、 qはbの中の要素の数です。 これは、通常の`pFq`一般化超幾何関数です。

      (%i1) assume(not(equal(z,0)));
      (%o1)                          [notequal(z, 0)]
      (%i2) hgfred([v+1/2],[2*v+1],2*%i*z);

                           v/2                               %i z
                          4    bessel_j(v, z) gamma(v + 1) %e
      (%o2)               ---------------------------------------
                                             v
                                            z
      (%i3) hgfred([1,1],[2],z);

                                         log(1 - z)
      (%o3)                            - ----------
                                             z
      (%i4) hgfred([a,a+1/2],[3/2],z^2);

                                     1 - 2 a          1 - 2 a
                              (z + 1)        - (1 - z)
      (%o4)                   -------------------------------
                                       2 (1 - 2 a) z

  以下の例が示すように、orthopolyもロードすることは有益なことがあります。 Lは、一般化ラーゲル多項式であることに注意してください。

      (%i5) load("orthopoly")$
      (%i6) hgfred([-2],[a],z);

                                          (a - 1)
                                       2 L       (z)
                                          2
      (%o6)                            -------------
                                         a (a + 1)

      (%i7) ev(%);

                                        2
                                       z        2 z
      (%o7)                         --------- - --- + 1
                                    a (a + 1)    a

関数: lambert_w (z)

  ランバートW関数W(z)の主枝、 `z = W(z) * exp(W(z))`の解。

  Special functions ·

関数: nzeta (z)

  プラズマ分散関数 `nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z))`

  Special functions ·

関数: nzetar (z)

  `realpart(nzeta(z))`を返します。

  Special functions ·

関数: nzetai (z)

  `imagpart(nzeta(z))`を返します。

  Special functions ·

Next: Limits, Previous: Special Functions, Up: Top [Contents][Index]

## 16 Elliptic Functions

Next: Functions and Variables for Elliptic Functions, Up: Top [Contents][Index]

### 16.1 Introduction to Elliptic Functions and Integrals

Maximaは、Jacobiの楕円関数と不完全楕円積分のサポートを含みます。 これは、数値評価はもちろんこれらの関数のシンボル操作を含みます。 これらの関数の定義と、プロパティの多くは Abramowitz and Stegun, 16–17章にあります。 可能な限り、そこれで与えられた定義と関係を使います。

特に、すべての楕円関数と積分は、 法kや率角\alphaの代わりにパラメータmを使います。

これは、 楕円関数のために率角を使うAbramowitz and Stegunと違っているところです。 以下の関係は真です:

楕円関数と積分は、主としてシンボル計算をサポートするように意図されています。 それ故に、関数と積分の導関数のほとんどが知られています。 しかしながら、もし浮動小数点値が与えられたなら、 浮動小数点の結果が返されます。

楕円関数と積分の他の性質のほとんどのサポートはまだ書かれていません。

楕円関数のいくつかの例:

    (%i1) jacobi_sn (u, m);
    (%o1)                    jacobi_sn(u, m)
    (%i2) jacobi_sn (u, 1);
    (%o2)                        tanh(u)
    (%i3) jacobi_sn (u, 0);
    (%o3)                        sin(u)
    (%i4) diff (jacobi_sn (u, m), u);
    (%o4)            jacobi_cn(u, m) jacobi_dn(u, m)
    (%i5) diff (jacobi_sn (u, m), m);
    (%o5) jacobi_cn(u, m) jacobi_dn(u, m)

          elliptic_e(asin(jacobi_sn(u, m)), m)
     (u - ------------------------------------)/(2 m)
                         1 - m

                2
       jacobi_cn (u, m) jacobi_sn(u, m)
     + --------------------------------
                  2 (1 - m)

楕円積分のいくつかの例:

    (%i1) elliptic_f (phi, m);
    (%o1)                  elliptic_f(phi, m)
    (%i2) elliptic_f (phi, 0);
    (%o2)                          phi
    (%i3) elliptic_f (phi, 1);
                                   phi   %pi
    (%o3)                  log(tan(--- + ---))
                                    2     4
    (%i4) elliptic_e (phi, 1);
    (%o4)                       sin(phi)
    (%i5) elliptic_e (phi, 0);
    (%o5)                          phi
    (%i6) elliptic_kc (1/2);
                                         1
    (%o6)                    elliptic_kc(-)
                                         2
    (%i7) makegamma (%);
                                     2 1
                                gamma (-)
                                       4
    (%o7)                      -----------
                               4 sqrt(%pi)
    (%i8) diff (elliptic_f (phi, m), phi);
                                    1
    (%o8)                 ---------------------
                                        2
                          sqrt(1 - m sin (phi))
    (%i9) diff (elliptic_f (phi, m), m);
           elliptic_e(phi, m) - (1 - m) elliptic_f(phi, m)
    (%o9) (-----------------------------------------------
                                  m

                                     cos(phi) sin(phi)
                                 - ---------------------)/(2 (1 - m))
                                                 2
                                   sqrt(1 - m sin (phi))

楕円関数と積分のサポートは、Raymond Toyによって書かれました。 Maximaの配布を管理するGeneral Public License (GPL)の条件のもと置かれています。

Elliptic functions ·

Next: Functions and Variables for Elliptic Integrals, Previous: Introduction to Elliptic Functions and Integrals, Up: Top [Contents][Index]

### 16.2 Functions and Variables for Elliptic Functions

関数: jacobi_sn (u, m)

  Jacobiの楕円関数sn(u,m)

  Elliptic functions ·

関数: jacobi_cn (u, m)

  Jacobiの楕円関数cn(u,m).

  Elliptic functions ·

関数: jacobi_dn (u, m)

  Jacobiの楕円関数dn(u,m).

  Elliptic functions ·

関数: jacobi_ns (u, m)

  Jacobiの楕円関数ns(u,m) = 1/sn(u,m).

  Elliptic functions ·

関数: jacobi_sc (u, m)

  Jacobiの楕円関数sc(u,m) = sn(u,m)/cn(u,m).

  Elliptic functions ·

関数: jacobi_sd (u, m)

  Jacobiの楕円関数sd(u,m) = sn(u,m)/dn(u,m).

  Elliptic functions ·

関数: jacobi_nc (u, m)

  Jacobiの楕円関数nc(u,m) = 1/cn(u,m).

  Elliptic functions ·

関数: jacobi_cs (u, m)

  Jacobiの楕円関数cs(u,m) = cn(u,m)/sn(u,m).

  Elliptic functions ·

関数: jacobi_cd (u, m)

  Jacobiの楕円関数cd(u,m) = cn(u,m)/dn(u,m).

  Elliptic functions ·

関数: jacobi_nd (u, m)

  Jacobiの楕円関数nc(u,m) = 1/cn(u,m).

  Elliptic functions ·

関数: jacobi_ds (u, m)

  Jacobiの楕円関数ds(u,m) = dn(u,m)/sn(u,m).

  Elliptic functions ·

関数: jacobi_dc (u, m)

  Jacobiの楕円関数dc(u,m) = dn(u,m)/cn(u,m).

  Elliptic functions ·

関数: inverse_jacobi_sn (u, m)

  Jacobiの楕円関数の逆関数sn(u,m).

  Elliptic functions ·

関数: inverse_jacobi_cn (u, m)

  Jacobiの楕円関数の逆関数cn(u,m).

  Elliptic functions ·

関数: inverse_jacobi_dn (u, m)

  Jacobiの楕円関数の逆関数dn(u,m).

  Elliptic functions ·

関数: inverse_jacobi_ns (u, m)

  Jacobiの楕円関数の逆関数ns(u,m).

  Elliptic functions ·

関数: inverse_jacobi_sc (u, m)

  Jacobiの楕円関数の逆関数sc(u,m).

  Elliptic functions ·

関数: inverse_jacobi_sd (u, m)

  Jacobiの楕円関数の逆関数sd(u,m).

  Elliptic functions ·

関数: inverse_jacobi_nc (u, m)

  Jacobiの楕円関数の逆関数nc(u,m).

  Elliptic functions ·

関数: inverse_jacobi_cs (u, m)

  Jacobiの楕円関数の逆関数cs(u,m).

  Elliptic functions ·

関数: inverse_jacobi_cd (u, m)

  Jacobiの楕円関数の逆関数cd(u,m).

  Elliptic functions ·

関数: inverse_jacobi_nd (u, m)

  Jacobiの楕円関数の逆関数nc(u,m).

  Elliptic functions ·

関数: inverse_jacobi_ds (u, m)

  Jacobiの楕円関数の逆関数ds(u,m).

  Elliptic functions ·

関数: inverse_jacobi_dc (u, m)

  Jacobiの楕円関数の逆関数dc(u,m).

  Elliptic functions ·

Previous: Functions and Variables for Elliptic Functions, Up: Top [Contents][Index]

### 16.3 Functions and Variables for Elliptic Integrals

関数: elliptic_f (phi, m)

  以下のように定義された第一種不完全楕円積分

  integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi)

  elliptic_eとelliptic_kcも参照してください。

  Elliptic integrals ·

関数: elliptic_e (phi, m)

  以下のように定義された第二種不完全楕円積分

  elliptic_e(phi, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi)

  elliptic_eとelliptic_ecも参照してください。

  Elliptic integrals ·

関数: elliptic_eu (u, m)

  以下のように定義された第二種不完全楕円積分

  integrate(dn(v,m)^2,v,0,u) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2), t, 0, tau)

  ここで、tau = sn(u,m).

  これは、

  elliptic_eu(u, m) = elliptic_e(asin(sn(u,m)),m) によってelliptic_eと関連付けられます。

  elliptic_eも参照してください。

  Elliptic integrals ·

関数: elliptic_pi (n, phi, m)

  以下のように定義された第三種不完全楕円積分

  integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi)

  Maximaが知っているphiに関する唯一の導関数

  Elliptic integrals ·

関数: elliptic_kc (m)

  以下のように定義された第一種完全楕円積分

  integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2)

  mのある値に関して 積分の値はGamma関数で表されることが知られています。 それらを評価するには`makegamma`を使ってください。

  Elliptic integrals ·

関数: elliptic_ec (m)

  以下のように定義された第二種完全楕円積分

  integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2)

  mのある値に関して 積分の値はGamma関数で表されることが知られています。 それらを評価するには`makegamma`を使ってください。

  Elliptic integrals ·

Next: Differentiation, Previous: Elliptic Functions, Up: Top [Contents][Index]

## 17 Limits

Previous: Limits, Up: Limits [Contents][Index]

### 17.1 Functions and Variables for Limits

オプション変数: lhospitallim

  Default: 4

  `lhospitallim`は、 `limit`の中で使われるロピタルの規則の回数の最大数です。 これは `limit (cot(x)/csc(x), x, 0)`のような場合の 無限ループを防ぎます。

  Limits ·

関数: limit (expr, x, val, dir)
関数: limit (expr, x, val)
関数: limit (expr)

  実変数xが値valに方向dirに近づく時の exprの極限を計算します。 dirは、上からの極限には値`plus`を、下からの極限には`minus`を持ち、 また、 (両側極限が計算されることを暗示して)省略することもあります。

  `limit`は以下の特殊シンボルを使います: `inf` (正の無限大)と`minf` (負の無限大) 出力時には、`und` (未定義), `ind` (不定しかし有界), `infinity` (複素無限大)も使うことがあります。

  式の絶対値の極限は正の無限大ですが、式自体の極限は正の無限大でも負の無限大でもない時、 `infinity`(複素数の無限大)が返されます。 これは、`limit(log(x), x, minf)`のように複素偏角の極限が定数である場合、 `limit((-2)^x, x, inf)`のように複素偏角が振動する場合、 `limit(1/x, x, 0)`や`limit(log(x), x, 0)`のように複素偏角が左右の極限のいずれかで異なる場合を、 を含みます。

  `lhospitallim`は、 `limit`の中で使われるロピタルの規則の回数の最大数です。 これは `limit (cot(x)/csc(x), x, 0)`のような場合の 無限ループを防ぎます。

  `tlimswitch`が`true`の時、 必要な時`limit`コマンドがテイラー級数展開を使うことを許します。

  `limsubst`は、 `limit`が未知の形式の上の代入を試みることを防ぎます。 これは、1を与える`limit (f(n)/f(n+1), n, inf)`のようなバグを避けるためです。 `limsubst`を`true`に設定することはそんな代入を許します。

  例えば、`limit (inf-1)`のように、 定数式を整理するために、引数１つの`limit`がしばしばコールされます。

  `example (limit)`はいくつかの例を表示します。

  方法に関して、 Wang, P., "Evaluation of Definite Integrals by Symbolic Manipulation", Ph.D. thesis, MAC TR-92, October 1971を参照してください。

  Limits ·

オプション変数: limsubst

  デフォルト値: `false` - `limit`が未知の形式の上の代入を試みることを防ぎます。

  これは、1を与える`limit (f(n)/f(n+1), n, inf)`のようなバグを避けるためです。 `limsubst`を`true`に設定することはそんな代入を許します。 `limit`が未知の形式上で代入をしようとするのを防ぎます。

  Limits ·

関数: tlimit (expr, x, val, dir)
関数: tlimit (expr, x, val)
関数: tlimit (expr)

  `expr`の`x`に関する`val` でのテイラー級数展開の方向`dir`からの極限を取ります。

  Limits ·

オプション変数: tlimswitch

  デフォルト値: `true`

  `tlimswitch`が`true`の時、 `limit`コマンドは もし入力式が直接計算できないなら、 テイラー級数展開を使います。 これは、`limit(x/(x-1)-1/log(x),x,1,plus)`のような 極限の評価を許します。 `tlimswitch`が`false`で、 入力式の極限は直接には計算できない時は、 `limit`は、未評価の極限式を返します。

  Limits ·

Next: Integration, Previous: Limits, Up: Top [Contents][Index]

## 18 Differentiation

Previous: Differentiation, Up: Differentiation [Contents][Index]

### 18.1 Functions and Variables for Differentiation

関数: antid (expr, x, u(x))

  exprのxに関する不定積分がリストから構成できるような、 ２要素リストを返します。 式exprは、未知の関数uとその導関数を含むことができます。

  Let ２要素リストLが`antid`の戻り値だとします。 `L[1] + 'integrate (L[2], x)`は exprのxに関する不定積分です。

  `antid`が完全に成功した時、 戻り値の２番目の要素はゼロです。 そうでなければ、２番目の要素は非ゼロで、最初の要素は非ゼロまたはゼロです。 もし`antid`が全く進展できなければ、 最初の要素はゼロで、２番目は非ゼロです。

  `load ("antid")`はこの関数をロードします。 `antid`パッケージは、関数`nonzeroandfreeof`と`linear`も定義します。

  `antid`は、以下のように`antidiff`と関係します。 ２要素リストLが`antid`の戻り値とします。 `antidiff`の戻り値は、`L[1] + 'integrate (L[2], x)`に 等しいです。 ここで、xは積分変数です。

  例:

      (%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
                        /

  Integral calculus ·

関数: antidiff (expr, x, u(x))

  exprのxに関する不定積分を返します。 式exprは、未知の関数uとその導関数を含むことができます。

  `antidiff`が完全に成功した時、 結果の式は、積分記号を含みません(すなわち、`integrate`名詞を含みません)。 そうでなければ、`antidiff`は 部分的にまたは完全に積分記号内にある式を返します。 もし`antidiff`が全く進展ができないなら、 戻り値は完全に積分記号内にあります。

  `load ("antid")`はこの関数をロードします。 `antid`パッケージは、関数`nonzeroandfreeof`と`linear`も定義します。

  `antidiff`は、以下のように`antid`と関係します。 ２要素リストLが`antid`の戻り値とします。 `antidiff`の戻り値は、`L[1] + 'integrate (L[2], x)`に 等しいです。 ここで、xは積分変数です。

  例:

      (%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
                        /

  Integral calculus ·

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

  等式のリスト`[eqn_1, ..., eqn_n]` もしくは１つの等式eqnの中で指定されたように値を仮定された変数で、 式exprを評価します。

  もしも部分式が、値が指定される変数のいずれかに依存するが 指定の`atvalue`がなく、他の方法で評価できないなら、 `at`の名詞形が返され、２次元形式で表示されます。

  `at`は多重代入を並列に実行します。

  `atvalue`も参照してください。 代入を実行する他の関数に関しては、`subst`や`ev`も参照してください。

  例:

      (%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

  Evaluation ·Differential equations ·

Property: atomgrad

  `atomgrad`は、式のアトムのグラディエントプロパティです。 このプロパティは`gradef`で割り当てられます。

  Differential calculus ·

関数: atvalue (expr, [x_1 = a_1, ..., x_m = a_m], c)
関数: atvalue (expr, x_1 = a_1, c)

  値cを 点`x = a`のexprに割り当てます。 典型的には、境界値はこのメカニズムによって確立されます。

  exprは、関数引数が陽に現れる 関数評価 `f(x_1, ..., x_m)`または 導関数 `diff (f(x_1, ..., x_m), x_1, n_1, ..., x_n, n_m)` です。 n_iは、x_iに関する微分の階数です。

  atvalueが確立される点は、等式のリスト`[x_1 = a_1, ..., x_m = a_m]` によって与えられます。 もし１変数x_1なら、 リストとしてくくられることなしに１つの等式は与えられます。

  `printprops ([f_1, f_2, ...], atvalue)`は `atvalue`コールによって指定されるような 関数`f_1, f_2, ...`のatvalueを表示します。

  `printprops (f, atvalue)`は、 １関数fのatvalueを表示します。 `printprops (all, atvalue)`は、 atvaluesが定義された関数すべてのatvalueを表示します。

  atvaluesが表示される時、 シンボル`@1`, `@2`, … は 変数x_1, x_2, …を表します。

  `atvalue`は引数を評価します。 `atvalue`はatvaluecを返します。

  例:

      (%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

  Differential equations ·Declarations and inferences ·

関数: cartan

  微分形式の外積代数は エリーカルタンによって開発された微分幾何の基本ツールであり、 偏微分方程式論での有用な応用を持ちます。 `cartan`パッケージは、 演算子`~` (ウェッジ積)と`|` (形式のベクトルとの縮約)と一緒に、 関数`ext_diff`と`lie_diff`を実装します。 例と一緒にこれらのコマンドの簡潔な記述を見るには、`demo (tensor)`を実行してください。

  `cartan`は、F.B. EstabrookとH.D. Wahlquistによって実装されました。

  Differential geometry ·

関数: del (x)

  `del (x)`は、変数xの微分を表します。

  もし独立変数が指定されないなら、 `diff`は、`del`を含む式を返します。 この場合、戻り値は「全微分」と呼ばれるものです。

  例:

      (%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)

  Differential calculus ·

関数: delta (t)

  Diracのデルタ関数

  今のところ、`laplace`だけが`delta`を知っています。

  例:

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

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

  Mathematical functions ·Laplace transform ·

システム変数: dependencies

  デフォルト値: `[]`

  `dependencies`は、 `depends`や`gradef`によって割り当てられた、関数依存を持つアトムのリストです。 `dependencies`リストは累積的です: each call to `depends`や`gradef`のコールそれぞれは、上乗せの項目を追加します。

  `depends`と`gradef`を参照してください。

  Declarations and inferences ·Global variables ·

関数: depends (f_1, x_1, ..., f_n, x_n)

  導関数を計算するために、変数の間の関数依存を宣言します。 宣言された依存関係なしでは、 `diff (f, x)`はゼロをもたらします。 もし`depends (f, x)`が宣言されたら、 `diff (f, x)`はシンボリックな導関数(すなわち、`diff`名詞)をもたらします。

  それぞれの引数f_1, x_1, などは、 変数や配列の名前、または名前のリストをとり得ます。 f_i (多分ただ１つの要素)のすべての要素は、 x_i (多分ただ１つの要素)のすべての要素に依存するように宣言されます。 もしいくつかのf_iが、配列名だったり、配列名を含むなら、 配列の要素すべてはx_iに依存します。

  `diff`は、`depends`によって確立された間接的依存関係を認識し、 これらの場合に連鎖規則を適用します。

  `remove (f, dependency)`は、fに関して宣言された 依存関係すべてを取り除きます。

  `depends`は、確立された依存関係のリストを返します。 依存関係はグローバル変数`dependencies`に適用されます。 `depends`は引数を評価します。

  `diff`は、 `depends`によって確立された依存関係を認識する唯一のMaximaコマンドです。 他の関数(`integrate`, `laplace`, など)は、 引数によって陽に表現された依存関係だけを認識します。 例えば、`integrate`は、 `integrate (f(x), x)`のように陽に表現されないなら、 `f`の`x`への依存性を認識しません。

      (%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

  Differential calculus ·Declarations and inferences ·

オプション変数: derivabbrev

  デフォルト値: `false`

  `derivabbrev`が`true`の時、 シンボリックな導関数(すなわち、`diff`名詞)が下付き添字として表示されます。 そうでなければ、導関数はライプニッツ表記`dy/dx`で表示されます。

  Differential calculus ·Global flags ·

関数: derivdegree (expr, y, x)

  exprに現れる独立変数xに関する 従属変数yの微分の最高階数を返します。

  例:

      (%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

  Differential calculus ·Expressions ·

関数: derivlist (var_1, …, var_k)

  `ev`コマンド内にて、指摘された変数に関する微分のみを起こします。

  Differential calculus ·Evaluation ·

オプション変数: derivsubst

  デフォルト値: `false`

  `derivsubst`が`true`の時、 `subst (x, 'diff (y, t), 'diff (y, t, 2))` のような非構文法的代入は`'diff (x, t)`をもらします。

  Differential calculus ·Expressions ·

関数: diff (expr, x_1, n_1, …, x_m, n_m)
関数: diff (expr, x, n)
関数: diff (expr, x)
関数: diff (expr)

  exprの中のすべての変数の中のいくつかに関する、exprの導関数すなわち微分を返します。

  `diff (expr, x, n)`はxに関するexprのn階微分を返します。

  `diff (expr, x_1, n_1, ..., x_m, n_m)`は x_1, ..., x_mに関するexprの偏微分を返します。 これは、`diff (... (diff (expr, x_m, n_m) ...), x_1, n_1)`と同値です。

  `diff (expr, x)`は変数xに関するexprの1階微分を返します。

  `diff (expr)`はexprの全微分を返します。 すなわち、それぞれの変数に関するexprの微分に変数それぞれの微分`del`を掛けたものの和を返します。 `del`の更なる整理は提供されません。

  `diff`の名詞形式が、微分方程式を記述する時など、いくつかの文脈で要求されます。 これらの場合、`diff`は、微分が実行される代わりに名詞形式を出力するために (`'diff`として)クォートされるかもしれません。

  `derivabbrev`が`true`の時、導関数は下付き添字として表示されます。 そうでなければ、導関数はライブニツ記法の`dy/dx`で表示されます。

  例:

      (%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)

  テンソルパッケージのために、以下の変更が取り込まれています:

  (1) exprの中の任意のインデックスされたオブジェクトの導関数は、追加された引数として添えられた変数x_iを持ちます。 そして導関数のインデックスはすべてソートされます。

  (2) x_iは、1から変数`dimension` [デフォルト値: 4]の値までの整数を取ります。 これにより、例えば `[x, y, z, t]`など 座標名のリストして設定されたリスト`coordinates`のx_i番目のメンバーに関する微分が実行されます。 もし`coordinates`がアトムの変数にバインドされているなら、x_iで下付き添字された変数が、微分の変数として使われます。 これにより、座標名や`X[1]`, `X[2]`, …のような下付き添字された名前の配列が使えることになります。 もし`coordinates`に値が割り当てられていないなら、変数は上の(1)のように扱われます。

  Differential calculus ·

特殊シンボル: diff

  `ev`コールの中で、`evflag`として`diff`が存在する時、 `expr`の中で表現されたすべての微分は実行されます。

関数: dscalar (f)

  スカラーのダランベルシアンをスカラー関数にfに適用します。

  `load ("ctensor")`はこの関数をロードします。

  Differential calculus ·Package ctensor ·

関数: express (expr)

  微分演算子名詞を偏微分を使った式に展開します。 `express`は、演算子`grad`, `div`, `curl`, `laplacian`を 認識します。 `express`は、外積`~`も展開します。

  expressの戻り値の中のシンボリックな導関数(すなわち、`diff`名詞)は、 `ev`関数コールまたはコマンドラインに`diff`を含むことによって、評価されることができます。 この文脈では、`diff`は`evfun`として振る舞います。

  `load ("vect")`はこの関数をロードします。

  例:

      (%i1) load ("vect")$
      (%i2) grad (x^2 + y^2 + z^2);
                                    2    2    2
      (%o2)                  grad (z  + y  + x )
      (%i3) express (%);
             d    2    2    2   d    2    2    2   d    2    2    2
      (%o3) [-- (z  + y  + x ), -- (z  + y  + x ), -- (z  + y  + x )]
             dx                 dy                 dz
      (%i4) ev (%, diff);
      (%o4)                    [2 x, 2 y, 2 z]
      (%i5) div ([x^2, y^2, z^2]);
                                    2   2   2
      (%o5)                   div [x , y , z ]
      (%i6) express (%);
                         d    2    d    2    d    2
      (%o6)              -- (z ) + -- (y ) + -- (x )
                         dz        dy        dx
      (%i7) ev (%, diff);
      (%o7)                    2 z + 2 y + 2 x
      (%i8) curl ([x^2, y^2, z^2]);
                                     2   2   2
      (%o8)                   curl [x , y , z ]
      (%i9) express (%);
             d    2    d    2   d    2    d    2   d    2    d    2
      (%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )]
             dy        dz       dz        dx       dx        dy
      (%i10) ev (%, diff);
      (%o10)                      [0, 0, 0]
      (%i11) laplacian (x^2 * y^2 * z^2);
                                        2  2  2
      (%o11)                laplacian (x  y  z )
      (%i12) express (%);
               2                2                2
              d     2  2  2    d     2  2  2    d     2  2  2
      (%o12)  --- (x  y  z ) + --- (x  y  z ) + --- (x  y  z )
                2                2                2
              dz               dy               dx
      (%i13) ev (%, diff);
                            2  2      2  2      2  2
      (%o13)             2 y  z  + 2 x  z  + 2 x  y
      (%i14) [a, b, c] ~ [x, y, z];
      (%o14)                [a, b, c] ~ [x, y, z]
      (%i15) express (%);
      (%o15)          [b z - c y, c x - a z, a y - b x]

  Differential calculus ·Vectors ·Operators ·

関数: gradef (f(x_1, …, x_n), g_1, ..., g_m)
関数: gradef (a, x, expr)

  関数fもしくは変数aの偏微分（すなわち、勾配の成分）を定義します。

  `gradef (f(x_1, ..., x_n), g_1, ..., g_m)`は、 `df/dx_i`をg_iとして定義します。 ここで、g_iは式です; g_iは関数コールでもあり得ますが、関数名ではありません。 偏微分の数mは、引数の数nよりもちいさいかもしれません。 その場合、微分はx_1からx_mまでのみに関して定義されます。

  `gradef (a, x, expr)`は、 変数aのxに関する微分をexprと定義します。 これは、 (`depends (a, x)`を介して) aのxへの依存性を確立もします。

  最初の引数`f(x_1, ..., x_n)`またはaはクォートされますが、 残りの引数g_1, ..., g_mは評価されます。 `gradef`は偏微分が定義された関数や変数を返します。

  `gradef`は、Maximaの組み込み関数の微分を再定義できます。 例えば、`gradef (sin(x), sqrt (1 - sin(x)^2))`は、 `sin`の微分を再定義します。

  `gradef`は、添字付き関数の偏微分を定義できません。

  `printprops ([f_1, ..., f_n], gradef)`は、 関数f_1, ..., f_nの偏微分を `gradef`で定義されたように、表示します。

  `printprops ([a_n, ..., a_n], atomgrad)`は、 変数a_n, ..., a_nの偏微分を `gradef`で定義されたように、表示します。

  `gradefs`は、偏微分が`gradef`によって定義された 関数のリストです。 `gradefs`は、 偏微分が`gradef`によって定義されたいかなる変数も含みません。

  例えば、関数が陽に知られていないが、一階微分が知られていて、 高階の微分を得ることが望まれる時、勾配が必要です。

  Differential calculus ·Declarations and inferences ·

システム変数: gradefs

  デフォルト値: `[]`

  `gradefs`は、偏微分が`gradef`によって定義された 関数のリストです。 `gradefs`は、 偏微分が`gradef`によって定義されたいかなる変数も含みません。

  Differential calculus ·Declarations and inferences ·

関数: laplace (expr, t, s)

  変数tに関するラブラス変換exprを計算し、パラメータsに変換しようとします。

  `laplace`は、 exprの中で、 `derivative`, `integrate`, `sum`, `ilt`はもちろん、 関数`delta`, `exp`, `log`, `sin`, `cos`, `sinh`, `cosh`, and `erf` を認識します。 もし、laplaceが変換を見つけられなかったら、 関数`specint`がコールされます。 `specint`は、 ベッセル関数`bessel_j`, `bessel_i`, …のような 特殊関数を含む式のラプラス変換を見つけることができ、 `unit_step`関数を扱うことができます。 `specint`も参照してください。

  もし`specint`も解を見つけられないなら、 名詞`laplace`が返されます。

  exprは、従属変数の`atvalue`が使われる線形定数係数微分方程式であるかもしれません。 要求されるatvalueは、 変換が計算される前か後に供給されるかもしれません。 初期条件がゼロで指定されなければいけないので、 もし他に課される境界条件を持つなら 一般解にそれらを課すことができ、それらに関して一般解を解き、それらの値を代入し返すことによって、 定数を消去できます。

  `laplace`は、形式 `integrate (f(x) * g(t - x), x, 0, t)`の畳み込み積分を認識します; 他の種類の畳み込みは認識されません。

  関数関係は、 exprで陽に表現されなければいけません; `depends`で確立した暗黙の関係は認識されません。 例えば、もしfがxとyに依存するなら、 `f (x, y)`がexprの中に現れなければいけません。

  逆ラプラス変換`ilt`も参照してください。

  例:

      (%i1) laplace (exp (2*t + a) * sin(t) * t, t, s);
                                  a
                                %e  (2 s - 4)
      (%o1)                    ---------------
                                 2           2
                               (s  - 4 s + 5)
      (%i2) laplace ('diff (f (x), x), x, s);
      (%o2)             s laplace(f(x), x, s) - f(0)
      (%i3) diff (diff (delta (t), t), t);
                                2
                               d
      (%o3)                    --- (delta(t))
                                 2
                               dt
      (%i4) laplace (%, t, s);
                                  !
                     d            !         2
      (%o4)        - -- (delta(t))!      + s  - delta(0) s
                     dt           !
                                  !t = 0
      (%i5) assume(a>0)$
      (%i6) laplace(gamma_incomplete(a,t),t,s),gamma_expand:true;
                                                    - a - 1
                               gamma(a)   gamma(a) s
      (%o6)                    -------- - -----------------
                                  s            1     a
                                              (- + 1)
                                               s
      (%i7) factor(laplace(gamma_incomplete(1/2,t),t,s));
                                                    s + 1
                            sqrt(%pi) (sqrt(s) sqrt(-----) - 1)
                                                      s
      (%o7)                 -----------------------------------
                                      3/2      s + 1
                                     s    sqrt(-----)
                                                 s
      (%i8) assume(exp(%pi*s)>1)$
      (%i9) laplace(sum((-1)^n*unit_step(t-n*%pi)*sin(t),n,0,inf),t,s),
               simpsum;

                               %i                         %i
                    ------------------------ - ------------------------
                                    - %pi s                    - %pi s
                    (s + %i) (1 - %e       )   (s - %i) (1 - %e       )
      (%o9)         ---------------------------------------------------
                                             2

      (%i9) factor(%);
                                            %pi s
                                          %e
      (%o9)                   -------------------------------
                                                   %pi s
                              (s - %i) (s + %i) (%e      - 1)

  Laplace transform ·Differential equations ·

Next: Equations, Previous: Differentiation, Up: Top [Contents][Index]

## 19 Integration

Next: Functions and Variables for Integration, Previous: Integration, Up: Integration [Contents][Index]

### 19.1 Introduction to Integration

Maximaは、積分を扱うためのいくつかのルーチンを持っています。 `integrate`関数はそれらのほとんどを利用します。 指定されていない関数（ともちろんその導関数）を扱う`antid`パッケージもあります。 数値目的のためには、 `quad_qag`, `quad_qags`などと名付けられたQUADPACKから適応積分器一式があります。 それらは見出し`QUADPACK`の下で記述されています。 超幾何関数を扱うことができます。詳細は`specint`を参照してください。 一般的に言って、Maximaは 「初等関数」（有理関数、三角関数、対数、指数関数、根号など）と２、３の拡張（誤差関数、二重対数関数）を使った積分可能な積分だけを扱います。 `g(x)`や`h(x)`と言った未知の関数を使った積分を扱いません。

Next: Introduction to QUADPACK, Previous: Introduction to Integration, Up: Integration [Contents][Index]

### 19.2 Functions and Variables for Integration

関数: changevar (expr, f(x,y), y, x)

  xに関する積分を含むexprの中に現れるすべての積分に関して、 `f(x,y) = 0`で与えられる変数変換を生成します。 新しい変数はyです。

      (%i1) assume(a > 0)$

      (%i2) 'integrate (%e**sqrt(a*y), y, 0, 4);
                            4
                           /
                           [    sqrt(a) sqrt(y)
      (%o2)                I  %e                dy
                           ]
                           /
                            0

      (%i3) changevar (%, y-z^2/a, z, y);
                            0
                           /
                           [                abs(z)
                         2 I            z %e       dz
                           ]
                           /
                            - 2 sqrt(a)
      (%o3)            - ----------------------------
                                      a

  上の`'integrate`のインスタンスのように、名詞形を含む式は `nouns`フラグありの`ev`によって評価されるかもしれません。 例えば、上の`changevar`が返す式は`ev (%o3, nouns)`で評価することができます。

  `changevar`は、 和や積のインデックスに関する変更にも使えます。 しかしながら、 変更が和や積の中でなされる時、 この変更はシフトすなわち`i = j+ ...` でなければならず、高階関数ではなことをはっきり理解しなければいけません。 例えば、

      (%i4) sum (a[i]*x^(i-2), i, 0, inf);
                               inf
                               ====
                               \         i - 2
      (%o4)                     >    a  x
                               /      i
                               ====
                               i = 0

      (%i5) changevar (%, i-2-n, n, i);
                              inf
                              ====
                              \               n
      (%o5)                    >      a      x
                              /        n + 2
                              ====
                              n = - 2

  Integral calculus ·

関数: dblint (f, r, s, a, b)

  トップレベルMaximaで書かれ、翻訳され機械語にコンパイルされた二重積分ルーチン。 このパッケージをアクセスするには`load ("dblint")`を使ってください。 以下を計算するため、xとy方向に関して シンプソンの規則方法を使います。

      /b /s(x)
      |  |
      |  |    f(x,y) dy dx
      |  |
      /a /r(x)

  関数fは、２つの変数の翻訳されコンパイルされた関数でなければいけなく、 rとsはそれぞれ、翻訳されコンパイルされた変数でなければいけません。 一方で、aとbは浮動小数点数でなければいけません。 ルーチンは、 xとyの区間の分割の数を決める２つのグローバル変数を持ちます: `dblint_x`と`dblint_y`, 両方とも初期は10で、他の整数値（x方向に計算される`2*dblint_x+1`点があり、 y方向に計算される`2*dblint_y+1`点があります）に独立に変えることができます。 ルーチンは、X軸を更に分割します。 Xのそれぞれの値に関して、最初、 `r(x)`と`s(x)`を計算します; そして`r(x)`と`s(x)`の間でY軸が更に分割され、 シンプソン規則を使ってY軸に沿っての積分が実行されます; そして、 シンプソン規則を使って Y積分である関数値を用いてX軸に沿っての積分が実行されます; この手続きは、様々な理由のため数値的に不安定かもしれませんが、 かなり速いです: 非常に振動的な関数や特異点（領域内の極や分岐点）を持つ関数にこれを使うことは避けてください。 Y積分は、`r(x)`と`s(x)`がどこくらい離れているかに依存します。 だから、もし距離`s(x) - r(x)`がXに関して急速に変化するなら、 様々なY積分での異なるステップサイズでの切り詰めから起こる本質的なエラーがあるかもしれません。 領域の範囲を改善するために、計算時間という犠牲を払って、`dblint_x`と`dblint_y`を増やすことができます。 関数値は保存されないので、もし関数が非常に時間がかかるものなら、 もし何か変えたら再計算を待たなければいけません（すいません）。 関数f, r, sは、 `dblint`コールの前に、翻訳されるかコンパイルされるかどちらかが要求されます。 これは、多くの場合、インタープリタコードに対して桁違いの速度改善がなされるでしょう！

  `demo (dblint)`は、 例の問題に適用された`dblint`のデモンストレーションを実行します。

  Integral calculus ·

関数: defint (expr, x, a, b)

  定積分を計算しようとします。 `integrate`は、 積分の範囲が指定されている時、 すなわち、`integrate`が `integrate (expr, x, a, b)`としてコールされた時、 `defint`をコールします。

  このように、ユーザーの観点からは、`integrate`をコールすることは十分です。

  `defint`は、シンボリック式、計算された積分または積分の名詞形、 を返します。 定積分の数値近似に関しては、`quad_qag`と関連関数を参照してください。

  Integral calculus ·

オプション変数: erfflag

  デフォルト値: `true`

  `erfflag`が`false`の時、 `risch`が もしまず第一に被積分になにもないなら、 答えの中に`erf`関数を導入することを妨げます。

  Integral calculus ·

関数: ilt (expr, s, t)

  exprのsとパラメータtに関する逆ラプラス変換を計算します。 exprは、 分子は線形２次因子だけを持つ多項式の比でなければいけません。 `solve`または`linsolve`と合わせて 関数`laplace`や`ilt`を使うことによって ユーザーは１つの微分または畳み込み積分方程式やそれらの組を解くことができます。

      (%i1) 'integrate (sinh(a*x)*f(t-x), x, 0, t) + b*f(t) = t**2;
                    t
                   /
                   [                                    2
      (%o1)        I  f(t - x) sinh(a x) dx + b f(t) = t
                   ]
                   /
                    0

      (%i2) laplace (%, t, s);
                                     a laplace(f(t), t, s)   2
      (%o2)  b laplace(f(t), t, s) + --------------------- = --
                                             2    2           3
                                            s  - a           s

      (%i3) linsolve ([%], ['laplace(f(t), t, s)]);
                                              2      2
                                           2 s  - 2 a
      (%o3)     [laplace(f(t), t, s) = --------------------]
                                          5         2     3
                                       b s  + (a - a  b) s

      (%i4) ilt (rhs (first (%)), s, t);
      Is  a b (a b - 1)  positive, negative, or zero?

      pos;
                     sqrt(a b (a b - 1)) t
              2 cosh(---------------------)       2
                               b               a t
      (%o4) - ----------------------------- + -------
                    3  2      2               a b - 1
                   a  b  - 2 a  b + a

                                                             2
                                                   + ------------------
                                                      3  2      2
                                                     a  b  - 2 a  b + a

  Laplace transform ·

オプション変数: intanalysis

  デフォルト値: `true`

  `true`の時、定積分は、積分区間内の被積分関数の極を見つけようとします。 もしあれば、積分は主値積分として適切に評価されます。 もしintanalysisが`false`なら、 このチェックは実行されず、積分は極がないことを仮定して実行されます。

  `ldefint`も参照してください。

  例:

  `intanalysis`が`false`に設定されている時 Maximaは以下の積分を解くことができます:

      (%i1) integrate(1/(sqrt(x)+1),x,0,1);
                                      1
                                     /
                                     [       1
      (%o1)                          I  ----------- dx
                                     ]  sqrt(x) + 1
                                     /
                                      0

      (%i2) integrate(1/(sqrt(x)+1),x,0,1),intanalysis:false;
      (%o2)                            2 - 2 log(2)

      (%i3) integrate(cos(a)/sqrt((tan(a))^2 +1),a,-%pi/2,%pi/2);
      The number 1 isn't in the domain of atanh
       -- an error. To debug this try: debugmode(true);

      (%i4) intanalysis:false$
      (%i5) integrate(cos(a)/sqrt((tan(a))^2+1),a,-%pi/2,%pi/2);
                                            %pi
      (%o5)                                 ---
                                             2

  Integral calculus ·

関数: integrate (expr, x)
関数: integrate (expr, x, a, b)

  xに関するexprの積分をシンボリックに計算しようとします。 `integrate (expr, x)`は不定積分で、 `integrate (expr, x, a, b)`はa,bの上限下限を持つ定積分です。 `integrate`はこの制限を強制しませんが、上限下限はxを含んではいけません。 aはbより小さい必要はありません。 bがaと等しいなら、`integrate`は0を返します。

  定積分の数値近似に関しては`quad_qag`と関連関数を参照してください。 （複素積分）留数の計算に関しては`residue`を参照してください。 不定積分の代替計算方法に関しては`antid`を参照してください。

  `integrate`が成功すれば、積分（`integrate`を含まない式）を返します。 そうでなければ、積分の名詞形式（クォートされた演算子`'integrate`)もしくは１つ以上の名詞形式を含む式を返します。 `integrate`の名詞形式は積分記号で表示されます。

  いくつかの環境では、（例えば、`'integrate (expr, x)`のように、 シングルクオートされた`integrate`で手動で名詞形式を構成することが役に立ちます。 例えば、積分が、また計算されていないいくつかのパラメータに依存しているかもしれません。 名詞は、iが注目の名詞形式であるところの`ev (i, nouns)`によって、引数に適用されるかもしれません。

  `integrate`は不定積分とは別に、定積分を扱います。 それぞれの場合を扱うため、ある範囲の発見法を用意しています。 定積分の特別な場合は、0や無限大に等しい積分の下限上限を含んだり、 0や`%pi`や`2 %pi`に等しい下限上限を持つ三角関数を含んだり、 有理関数やベータやプサイ関数の定義に関連した積分やいくつかの対数的な積分、三角関数積分を含んだりします。 有理関数の処理は、留数の計算を含むかもしれません。 もし適用可能な特殊な場合が見つからなければ、不定積分を計算し、下限上限でそれを評価しようとするでしょう。 これは、下限上限に無限大の極限を取ることを含みます。`ldefint`も参照してください。

  不定積分の特殊な場合は、三角関数、指数対数関数、有理関数を含みます。 `integrate`は初等積分の短いテーブルもまた利用しています。

  もし非積分関数が形式`f(g(x)) * diff(g(x), x)`を持つなら、`integrate`は、変数の交換を実行します。 `integrate`は、`g(x)`の導関数が非積分関数を割るような部分式`g(x)`を見つけようとします。 この探索は、`gradef`関数によって定義された導関数を利用します。 `changevar`や`antid`も参照ください。

  もしこれまでの発見法のどれも不定積分を見つけられなければ、リッシュのアルゴリズムが実行されます。 フラグ`risch`が、`ev`のコールやコマンドライン上で`evflag`として設定されるかもしれません。 例えば、`ev (integrate (expr, x), risch)`や `integrate (expr, x), risch`というように。 もし`risch`が`true`なら、`integrate`は、発見法を最初に試さずに、`risch`関数をコールします。 `risch`も参照ください。

  `integrate`は`f(x)`記法で陽に表現された関数関係のみに動作します。 `integrate`は`depends`関数で規定された陰の依存性を考慮しません。

  `integrate`は非積分関数のパラメータのある性質を知っている必要がある場合があります。 `integrate`は`assume`データベースを最初に参照し、 注目の変数がそこになければ、`integrate`はユーザーに問い合わせます。 質問に依存して、適切な応答は、`yes;`や`no;`や`pos;`, `zero;`, `neg;`など。

  `integrate`は線形には宣言されていません。`declare`と`linear`を参照ください。

  `integrate`は２、３の特集な場合だけ、部分積分を企てます。

  例:

  - 初等不定積分、定積分

        (%i1) integrate (sin(x)^3, x);
                                   3
                                cos (x)
        (%o1)                   ------- - cos(x)
                                   3

        (%i2) integrate (x/ sqrt (b^2 - x^2), x);
                                         2    2
        (%o2)                    - sqrt(b  - x )

        (%i3) integrate (cos(x)^2 * exp(x), x, 0, %pi);
                                       %pi
                                   3 %e      3
        (%o3)                      ------- - -
                                      5      5

        (%i4) integrate (x^2 * exp(-x^2), x, minf, inf);
                                    sqrt(%pi)
        (%o4)                       ---------
                                        2

  - `assume`と対話的問い合わせの利用

        (%i1) assume (a > 1)$

        (%i2) integrate (x**a/(x+1)**(5/2), x, 0, inf);
            2 a + 2
        Is  -------  an integer?
               5

        no;
        Is  2 a - 3  positive, negative, or zero?

        neg;
                                           3
        (%o2)                  beta(a + 1, - - a)
                                           2

  - 変数変換。この例では２回変数変換があります。 `gradef`で規定された導関数を使ったものと未知関数`r(x)`の微分`diff(r(x))`を使ったもの。

        (%i3) gradef (q(x), sin(x**2));
        (%o3)                         q(x)

        (%i4) diff (log (q (r (x))), x);
                              d               2
                             (-- (r(x))) sin(r (x))
                              dx
        (%o4)                ----------------------
                                    q(r(x))

        (%i5) integrate (%, x);
        (%o5)                     log(q(r(x)))

  - `'integrate`名詞形を含む戻り値。 この例では、Maximaは有理関数の分母の因子を抽出できますが、剰余を因数分解できないか積分をみつけられません。 `grind`は、結果として名詞形`'integrate`を示します。 積分や有理関数について更に知るには`integrate_use_rootsof`も参照ください。

        (%i1) expand ((x-4) * (x^3+2*x+1));
                            4      3      2
        (%o1)              x  - 4 x  + 2 x  - 7 x - 4

        (%i2) integrate (1/%, x);
                                      /  2
                                      [ x  + 4 x + 18
                                      I ------------- dx
                                      ]  3
                         log(x - 4)   / x  + 2 x + 1
        (%o2)            ---------- - ------------------
                             73               73

        (%i3) grind (%);
        log(x-4)/73-('integrate((x^2+4*x+18)/(x^3+2*x+1),x))/73$

  - 積分を使った関数の定義。 関数の本体は、関数が定義された時には評価されません。 この例では、`f_1`の本体は、`integrate`の名詞形を含みます。 クォートクォート演算子`''`があると、積分が評価され、結果が`f_2`の本体になります。

        (%i1) f_1 (a) := integrate (x^3, x, 1, a);
                                             3
        (%o1)           f_1(a) := integrate(x , x, 1, a)

        (%i2) ev (f_1 (7), nouns);
        (%o2)                          600

        (%i3) /* Note parentheses around integrate(...) here */
              f_2 (a) := ''(integrate (x^3, x, 1, a));
                                           4
                                          a    1
        (%o3)                   f_2(a) := -- - -
                                          4    4

        (%i4) f_2 (7);
        (%o4)                          600

  Integral calculus ·

システム変数: integration_constant

  デフォルト値: `%c`

  積分定数は、等式の不定積分によって導入され、 定数名は、 `integration_constant`と`integration_constant_counter`を連結することで構成されます。

  `integration_constant`は、任意のシンボルに割り当てられます。

  例:

      (%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

  Integral calculus ·

システム変数: integration_constant_counter

  デフォルト値: 0

  積分定数が等式の不定積分によって導入された時、 定数名は、 `integration_constant`と`integration_constant_counter`を連結することで構成されます。

  `integration_constant_counter`は、 次の積分定数を構成する前に増分されます。

  例:

      (%i1) integrate (x^2 = 1, x);
                                 3
                                x
      (%o1)                     -- = x + %c1
                                3

      (%i2) integrate (x^2 = 1, x);
                                 3
                                x
      (%o2)                     -- = x + %c2
                                3

      (%i3) integrate (x^2 = 1, x);
                                 3
                                x
      (%o3)                     -- = x + %c3
                                3

      (%i4) reset (integration_constant_counter);
      (%o4)            [integration_constant_counter]

      (%i5) integrate (x^2 = 1, x);
                                 3
                                x
      (%o5)                     -- = x + %c1
                                3

  Integral calculus ·

オプション変数: integrate_use_rootsof

  デフォルト値: `false`

  `integrate_use_rootsof`が`true`かつ有理関数の分子が因数分解できない時、 `integrate`は、 分子の（まだ知られていない）根上の和という形式で積分を返します。

  例えば、 `integrate_use_rootsof`を`false`に設定すると、 `integrate`は、有理関数の未解決積分を名詞形で返します:

      (%i1) integrate_use_rootsof: false$

      (%i2) integrate (1/(1+x+x^5), x);
              /  2
              [ x  - 4 x + 5
              I ------------ dx                            2 x + 1
              ]  3    2                2            5 atan(-------)
              / x  - x  + 1       log(x  + x + 1)          sqrt(3)
      (%o2)   ----------------- - --------------- + ---------------
                      7                 14             7 sqrt(3)

  さて、フラグを`true`に設定し、 積分の未解決部分を 有理関数の分子の根上の和として表現しましょう:

      (%i3) integrate_use_rootsof: true$

      (%i4) integrate (1/(1+x+x^5), x);
            ====        2
            \       (%r4  - 4 %r4 + 5) log(x - %r4)
             >      -------------------------------
            /                    2
            ====            3 %r4  - 2 %r4
                              3      2
            %r4 in rootsof(%r4  - %r4  + 1, %r4)
      (%o4) ----------------------------------------------------------
                     7

                                                            2 x + 1
                                        2            5 atan(-------)
                                   log(x  + x + 1)          sqrt(3)
                                 - --------------- + ---------------
                                         14             7 sqrt(3)

  代わりにユーザーは別々に分子の根を計算できます。 例えば、もし分子が3次多項式なら `1/((x - a)*(x - b)*(x - c))`または`1/((x^2 - (a+b)*x + a*b)*(x - c))` というように これらの根を使って被積分関数を表現できます。 時々、これはMaximaがもっと役立つ結果を得るのを助けます。

  Integral calculus ·

関数: ldefint (expr, x, a, b)

  exprのxに関する不定積分を上限bと下限aで評価するために `limit`を使うことによってexprの定積分を計算しようとします。 もし定積分を計算するのに失敗したなら、 `ldefint`は、名詞形として極限を含む式を返します。

  `ldefint`は、`integrate`からコールされないので、 o executing `ldefint (expr, x, a, b)` を実行することは、 `integrate (expr, x, a, b)` とは違った結果をもたらすかもしれません。 `ldefint`は、定積分を評価するためにいつも同じ方法を使いますが、 `integrate`は、様々な発見的方法を利用し、いくつかの特殊な場合を認識することもあります。

  Integral calculus ·

関数: potential (givengradient)

  計算は、 `nonlist`または形式

      [indeterminatej=expressionj, indeterminatek=expressionk, ...]

  でなければならないグローバル変数`potentialzeroloc[0]`を利用します。 ここで、前者は後者の中のすべての右辺のnonlist式と同値です（訳者無理解）。 示された右辺は、積分の下限として使われます。 積分の成功は、 それらの値と順序に依存するかもしれません。 `potentialzeroloc`は、0に初期化されます。

関数: residue (expr, z, z_0)

  変数zが値z_0を仮定する時、 式exprの複素平面での留数を計算します。 留数は、 exprのローラン級数における `(z - z_0)^(-1)`の係数です。

      (%i1) residue (s/(s**2+a**2), s, a*%i);
                                      1
      (%o1)                           -
                                      2

      (%i2) residue (sin(a*x)/x**4, x, 0);
                                       3
                                      a
      (%o2)                         - --
                                      6

  Integral calculus ·Complex variables ·

関数: risch (expr, x)

  リッシュアルゴリズムの超越な場合を使って、 exprを xに関して積分します。 （リッシュアルゴリズムの代数的な場合は実装されていません。） これは、現在、`integrate`の主要部ができない入れ子の指数関数や対数関数の場合を扱います。 `integrate`は、これらの場合が与えられたなら、自動的に`risch`を適用します。

  `erfflag`がもし`false`なら、 もしまず第一に被積分関数になにもないなら、 `risch`が 答えの中に`erf`関数を導入することを妨げます。

      (%i1) risch (x^2*erf(x), x);
                                                              2
                   3                      2                - x
              %pi x  erf(x) + (sqrt(%pi) x  + sqrt(%pi)) %e
      (%o1)   -------------------------------------------------
                                    3 %pi

      (%i2) diff(%, x), ratsimp;
                                   2
      (%o2)                       x  erf(x)

  Integral calculus ·

関数: tldefint (expr, x, a, b)

  `tlimswitch`が`true`に設定されている`ldefint`と同値です。

  Integral calculus ·

Next: Functions and Variables for QUADPACK, Previous: Functions and Variables for Integration, Up: Integration [Contents][Index]

### 19.3 Introduction to QUADPACK

QUADPACKは、１次元定積分の数値計算のための関数のコレクションです。 R. Piessens 1, E. de Doncker 2, C. Ueberhuber 3, D. Kahaner 4. の合同プロジェクトから始まりました。

Maximaに含まれるQUADPACKライブラリは、 SLATEC共通数学ライブラリ バージョン4.15 に現れる QUADPACKのFortranのソースコードの (プログラム`f2cl`による)自動翻訳です。

SLATECライブラリは1993年7月付ですが、QUADPACK関数は何年か前に書かれました。 QUADPACKももう１つのバージョンが Netlib 6に あります; このバージョンがSLATECバージョンとどう違うのかはっきりしません。

Maximaに含まれるQUADPACK関数は、 これらの関数が、不特定の回数の関数の評価を要求し、 指定された精度まで結果を計算しようとする意味で、 すべて自動的です。 Maximaの、QUADPACKのLisp翻訳は、いくつかの自動的でない関数も含みますが、 それらは、Maximaレベルで公開されていません。

QUADPACKについての更なる情報は、 QUADPACK本 7 の中に見つけることができます。

#### 19.3.1 Overview

`quad_qag`

  一般関数の有限の区間上の積分。 `quad_qag`は、Aind(Piessens, 1973)の戦略を使った 簡単な大域的適応積分器を実装しています。 呼び出し側は、ルール評価コンポーネントのための ガウスークロンロッドの求積公式の6つのペアの中から選ぶことができます。 強く振動する非積分関数には高次のルールが適切です。

`quad_qags`

  一般関数の有限の区間上の積分。 `quad_qags`は、イプシロンアルゴリズム(Wynn, 1956)による外挿(de Doncker,1978)を 使った大域的適応積分器を実装しています。

`quad_qagi`

  一般関数の無限のもしくは半無限の区間上の積分。 区間は、有限の区間上に写像され、`quad_qags`の中で使われるのと同じ戦略が適用されます。

`quad_qawo`

  cos(omega x) f(x) や sin(omega x) f(x) の有限の区間上の積分。 ここで、 omega は定数です。 規則評価構成要素は、変形Clenshaw-Curtis手法に基づいています。 `quad_qawo`は、 `quad_qags`に似て、外挿とともに適応再分割を適用します。

`quad_qawf`

  フーリエコサイン変換またはフーリエサイン変換を半無限区間上で計算します。 `quad_qawo`で使われるのと同じアプローチが、連続する区間に適用され、 イプシロンアルゴリズム(Wynn, 1956)を使った収束の促進が積分寄与の級数に適用されます。

`quad_qaws`

  w(x) f(x) の有限区間 [a, b] 上の積分。 ここで、 w は形式 (x - a)^alpha (b - x)^beta v(x) の関数で、 v(x) は、 1, log(x - a), log(b - x), log(x - a) log(b - x) のいずれかであり、 alpha > -1 かつ beta > -1 です。

  大域的適応再分割戦略が適用され、 aまたはbを含む部分区間上では、 変形Clenshaw-Curtis積分を使います。

`quad_qawc`

  f(x)/(x - c)のコーシーの主値を 有限の区間(a, b)上で指定されたcを用いて 計算します。 戦略は、大域的適応的で、 点x = cを含む部分範囲上で変形Clenshaw-Curtis積分が使われます。

Integral calculus ·Numerical methods ·Share packages ·Package quadpack ·

Previous: Introduction to QUADPACK, Up: Integration [Contents][Index]

### 19.4 Functions and Variables for QUADPACK

関数: quad_qag (f(x), x, a, b, key, [epsrel, epsabs, limit])
関数: quad_qag (f, x, a, b, key, [epsrel, epsabs, limit])

  一般関数の有限の区間上の積分。 `quad_qag`は、Aind(Piessens, 1973)の戦略を使った 簡単な大域的適応積分器を実装しています。 呼び出し側は、ルール評価コンポーネントのための ガウスークロンロッドの求積公式の6つのペアの中から選ぶことができます。 強く振動する非積分関数には高次のルールが適切です。

  quad_qagは積分 integrate (f(x), x, a, b) を計算します。

  非積分関数は依存変数xのf(x)であり、 関数は下限a上限bの間で積分されます。 keyは利用される積分器で、1から6までのいずれかの整数でなければなりません。 keyの値は、ガウスークロンロッドの積分ルールの次数を選びます。 高次のルールが、強く振動する非積分関数には適切です。

  非積分関数は、MaximaもしくはLisp関数もしくは演算子の名前もしくMaximaのラムダ式か、 一般的なMaximaの式として指定されます。

  数値積分は、望まれる精度が達成されるまで、 積分領域を部分区間に分割することによって適応的に実行されます。

  キーワード引数はオプションで、どの次数においても指定できます。 それらは形式`key=val`を取ります。キーワード引数は：

  `epsrel`

    望まれる近似の相対誤差。デフォルトは1d-8。

  `epsabs`

    望まれる近似の絶対誤差。デフォルトは0。

  `limit`

    内部の作業配列のサイズ。limitは使用する部分区間の最大数。デフォルトは200。

  `quad_qag`は４つの要素のリストを返します:

  - 積分の近似
  - 見積もられた近似の絶対誤差
  - 非積分関数の評価数
  - エラーコード

  エラーコード（戻り値の４番目の要素）は以下の値を取ります:

  `0`

    問題が発生しなかった場合;

  `1`

    部分区間の数が上限を超えた場合;

  `2`

    丸め誤差が超過した場合;

  `3`

    非積分関数の振る舞いが極端に悪い場合;

  `6`

    入力が無効な場合;

  例:

      (%i1) quad_qag (x^(1/2)*log(1/x), x, 0, 1, 3, 'epsrel=5d-8);
      (%o1)    [.4444444444492108, 3.1700968502883E-9, 961, 0]

      (%i2) integrate (x^(1/2)*log(1/x), x, 0, 1);
                                      4
      (%o2)                           -
                                      9

  Numerical methods ·Package quadpack ·

関数: quad_qags (f(x), x, a, b, [epsrel, epsabs, limit])
関数: quad_qags (f, x, a, b, [epsrel, epsabs, limit])

  一般関数の有限の区間上の積分。 `quad_qags`は、イプシロンアルゴリズム(Wynn, 1956)による外挿(de Doncker,1978)を 使った大域的適応積分器を実装しています。

  `quad_qags`は、積分

  integrate (f(x), x, a, b) を計算します。

  非積分関数は依存変数xのf(x)であり、 関数は下限a上限bの間で積分されます。

  非積分関数は、MaximaもしくはLisp関数もしくは演算子の名前もしくMaximaのラムダ式か、一般的なMaximaの式として指定されます。

  キーワード引数はオプションで、どの次数においても指定できます。 それらは形式`key=val`を取ります。キーワード引数は：

  `epsrel`

    望まれる近似の相対誤差。デフォルトは1d-8。

  `epsabs`

    望まれる近似の絶対誤差。デフォルトは0。

  `limit`

    内部の作業配列のサイズ。limitは使用する部分区間の最大数。デフォルトは200。

  `quad_qags`は４つの要素のリストを返します:

  - 積分の近似
  - 見積もられた近似の絶対誤差
  - 非積分関数の評価数
  - エラーコード

  エラーコード（戻り値の４番目の要素）は以下の値を取ります:

  `0`

    問題が発生しなかった場合;

  `1`

    部分区間の数が上限を超えた場合;

  `2`

    丸め誤差が超過した場合;

  `3`

    非積分関数の振る舞いが極端に悪い場合;

  `4`

    収束に失敗した場合;

  `5`

    積分が発散しているか収束が遅い場合;

  `6`

    入力が無効な場合;

  例:

      (%i1) quad_qags (x^(1/2)*log(1/x), x, 0, 1, 'epsrel=1d-10);
      (%o1)   [.4444444444444448, 1.11022302462516E-15, 315, 0]

  この積分に関しては、`quad_qags`は、`quad_qag`よりも精確で 効率的であることに注意してください。

  Numerical methods ·Package quadpack ·

関数: quad_qagi (f(x), x, a, b, [epsrel, epsabs, limit])
関数: quad_qagi (f, x, a, b, [epsrel, epsabs, limit])

  一般関数の無限のもしくは半無限の区間上の積分。 区間は、有限の区間上に写像され、`quad_qags`の中で使われるのと同じ戦略が適用されます。

  `quad_qagi`は、Quadpack QAGIルーチンを使って以下の積分の１つを評価します。

  integrate (f(x), x, a, inf)

  integrate (f(x), x, minf, a)

  integrate (f(x), x, minf, inf)

  被積分関数は、f(x)であり、 従属変数xを使って、 関数は無限範囲上で積分されます。

  被積分関数は、MaximaまたはLispの関数または演算子の名前、 Maximaのラムダ式またはMaximaの一般式として指定されるかもしれません。

  積分の境界の１つは、無限でなければいけません。 もしそうでなければ、 `quad_qagi`はただ名詞形を返します。

  キーワード引数は随意で、任意の順序で指定できます。 それらすべては形式`key=val`を取ります。 キーワード引数は:

  `epsrel`

    望まれる近似の相対誤差。デフォルトは1d-8。

  `epsabs`

    望まれる近似の絶対誤差。デフォルトは0。

  `limit`

    内部の作業配列のサイズ。limitは使用する部分区間の最大数。デフォルトは200。

  `quad_qagi`は、４つの要素のリストを返します:

  - 積分の近似
  - 見積もられた近似の絶対誤差
  - 非積分関数の評価数
  - エラーコード

  エラーコード(戻り値の４番目の要素)は以下の値を取ります:

  `0`

    問題が発生しなかった場合;

  `1`

    部分区間の数が上限を超えた場合;

  `2`

    丸め誤差が超過した場合;

  `3`

    非積分関数の振る舞いが極端に悪い場合;

  `4`

    収束に失敗した場合;

  `5`

    積分が発散しているか収束が遅い場合;

  `6`

    入力が無効な場合;

  例:

      (%i1) quad_qagi (x^2*exp(-4*x), x, 0, inf, 'epsrel=1d-8);
      (%o1)        [0.03125, 2.95916102995002E-11, 105, 0]

      (%i2) integrate (x^2*exp(-4*x), x, 0, inf);
                                     1
      (%o2)                          --
                                     32

  Numerical methods ·Package quadpack ·

関数: quad_qawc (f(x), x, c, a, b, [epsrel, epsabs, limit])
関数: quad_qawc (f, x, c, a, b, [epsrel, epsabs, limit])

  f(x)/(x - c)のコーシーの主値を 有限の区間(a, b)上で指定されたcを用いて 計算します。 戦略は、大域的適応的で、 点x = cを含む部分範囲上で変形Clenshaw-Curtis積分が使われます。

  `quad_qawc`は、 Quadpack QAWCルーチンを使って、 integrate (f(x)/(x - c), x, a, b)

  のコーシーの主値を計算します。

  被積分関数は、 `f(x)/(x - c)`で、 従属変数xを使って、 関数はaからbまでの区間上で積分されます。

  被積分関数は、MaximaまたはLispの関数または演算子の名前、 Maximaのラムダ式またはMaximaの一般式として指定されるかもしれません。

  キーワード引数は随意で、任意の順序で指定できます。 それらすべては形式`key=val`を取ります。 キーワード引数は:

  `epsrel`

    望まれる近似の相対誤差。デフォルトは1d-8。

  `epsabs`

    望まれる近似の絶対誤差。デフォルトは0。

  `limit`

    内部の作業配列のサイズ。limitは使用する部分区間の最大数。デフォルトは200。

  `quad_qagc`は、４つの要素のリストを返します:

  - 積分の近似
  - 見積もられた近似の絶対誤差
  - 非積分関数の評価数
  - エラーコード

  エラーコード(戻り値の４番目の要素)は以下の値を取ります:

  `0`

    問題が発生しなかった場合;

  `1`

    部分区間の数が上限を超えた場合;

  `2`

    丸め誤差が超過した場合;

  `3`

    非積分関数の振る舞いが極端に悪い場合;

  `4`

    収束に失敗した場合;

  `5`

    積分が発散しているか収束が遅い場合;

  `6`

    入力が無効な場合;

  例:

      (%i1) quad_qawc (2^(-5)*((x-1)^2+4^(-5))^(-1), x, 2, 0, 5,
                       'epsrel=1d-7);
      (%o1)    [- 3.130120337415925, 1.306830140249558E-8, 495, 0]

      (%i2) integrate (2^(-alpha)*(((x-1)^2 + 4^(-alpha))*(x-2))^(-1),
            x, 0, 5);
      Principal Value
                             alpha
              alpha       9 4                 9
             4      log(------------- + -------------)
                            alpha           alpha
                        64 4      + 4   64 4      + 4
      (%o2) (-----------------------------------------
                              alpha
                           2 4      + 2

             3 alpha                       3 alpha
             -------                       -------
                2            alpha/2          2          alpha/2
          2 4        atan(4 4       )   2 4        atan(4       )   alpha
        - --------------------------- - -------------------------)/2
                    alpha                        alpha
                 2 4      + 2                 2 4      + 2

      (%i3) ev (%, alpha=5, numer);
      (%o3)                    - 3.130120337415917

  Numerical methods ·Package quadpack ·

関数: quad_qawf (f(x), x, a, omega, trig, [epsabs, limit, maxp1, limlst])
関数: quad_qawf (f, x, a, omega, trig, [epsabs, limit, maxp1, limlst])

  フーリエコサイン変換またはフーリエサイン変換を、 Quadpack QAWF関数を使って、半無限区間上で計算します。 `quad_qawo`で使われるのと同じアプローチが、連続する区間に適用され、 イプシロンアルゴリズム(Wynn, 1956)を使った収束の促進が積分寄与の級数に適用されます。

  `quad_qawf`は積分 integrate (f(x)*w(x), x, a, inf) を計算します。

  重み関数wはtrigによって選択されます:

  `cos`

    w(x) = cos (omega x)

  `sin`

    w(x) = sin (omega x)

  被積分関数は、MaximaまたはLispの関数または演算子の名前、 Maximaのラムダ式またはMaximaの一般式として指定されるかもしれません。

  キーワード引数は随意で、任意の順序で指定できます。 それらすべては形式`key=val`を取ります。 キーワード引数は:

  `epsrel`

    望まれる近似の相対誤差。デフォルトは1d-8。

  `epsabs`

    望まれる近似の絶対誤差。デフォルトは0。

  `limit`

    内部の作業配列のサイズ。(limit - limlst)/2は使用する部分区間の最大数。デフォルトは200。

  `maxp1`

    チェビシェフ積率の最大数。 0より大きくなければいけません。 デフォルトは100です。

  `limlst`

    サイクル数に関する上限。 3以上でなければいけません。 デフォルトは10です。

  `quad_qawf`は、４つの要素のリストを返します:

  - 積分の近似
  - 見積もられた近似の絶対誤差
  - 非積分関数の評価数
  - エラーコード

  エラーコード(戻り値の４番目の要素)は以下の値を取ります:

  `0`

    問題が発生しなかった場合;

  `1`

    部分区間の数が上限を超えた場合;

  `2`

    丸め誤差が超過した場合;

  `3`

    非積分関数の振る舞いが極端に悪い場合;

  `4`

    収束に失敗した場合;

  `5`

    積分が発散しているか収束が遅い場合;

  `6`

    入力が無効な場合;

  例:

      (%i1) quad_qawf (exp(-x^2), x, 0, 1, 'cos, 'epsabs=1d-9);
      (%o1)   [.6901942235215714, 2.84846300257552E-11, 215, 0]

      (%i2) integrate (exp(-x^2)*cos(x), x, 0, inf);
                                - 1/4
                              %e      sqrt(%pi)
      (%o2)                   -----------------
                                      2

      (%i3) ev (%, numer);
      (%o3)                   .6901942235215714

  Numerical methods ·Package quadpack ·

関数: quad_qawo (f(x), x, a, b, omega, trig, [epsrel, epsabs, limit, maxp1, limlst])
関数: quad_qawo (f, x, a, b, omega, trig, [epsrel, epsabs, limit, maxp1, limlst])

  cos(omega x) f(x) や sin(omega x) f(x) の有限の区間上の積分。 ここで、 omega は定数です。 規則評価構成要素は、変形Clenshaw-Curtis手法に基づいています。 `quad_qawo`は、 `quad_qags`に似て、外挿とともに適応再分割を適用します。

  `quad_qawo`は、 Quadpack QAWOルーチンを使って 積分を計算します:

  integrate (f(x)*w(x), x, a, b)

  重み関数wは、trigによって選択されます:

  `cos`

    w(x) = cos (omega x)

  `sin`

    w(x) = sin (omega x)

  被積分関数は、MaximaまたはLispの関数または演算子の名前、 Maximaのラムダ式またはMaximaの一般式として指定されるかもしれません。

  キーワード引数は随意で、任意の順序で指定できます。 それらすべては形式`key=val`を取ります。 キーワード引数は:

  `epsrel`

    望まれる近似の相対誤差。デフォルトは1d-8。

  `epsabs`

    望まれる近似の絶対誤差。デフォルトは0。

  `limit`

    内部の作業配列のサイズ。limit/2は使用する部分区間の最大数。デフォルトは200。

  `maxp1`

    チェビシェフ積率の最大数。 0より大きくなければいけません。 デフォルトは100です。

  `limlst`

    サイクル数に関する上限。 3以上でなければいけません。 デフォルトは10です。

  `quad_qawo`は、４つの要素のリストを返します:

  - 積分の近似
  - 見積もられた近似の絶対誤差
  - 非積分関数の評価数
  - エラーコード

  エラーコード(戻り値の４番目の要素)は以下の値を取ります:

  `0`

    問題が発生しなかった場合;

  `1`

    部分区間の数が上限を超えた場合;

  `2`

    丸め誤差が超過した場合;

  `3`

    非積分関数の振る舞いが極端に悪い場合;

  `4`

    収束に失敗した場合;

  `5`

    積分が発散しているか収束が遅い場合;

  `6`

    入力が無効な場合;

  例:

      (%i1) quad_qawo (x^(-1/2)*exp(-2^(-2)*x), x, 1d-8, 20*2^2, 1, cos);
      (%o1)     [1.376043389877692, 4.72710759424899E-11, 765, 0]

      (%i2) rectform (integrate (x^(-1/2)*exp(-2^(-alpha)*x) * cos(x),
            x, 0, inf));
                         alpha/2 - 1/2            2 alpha
              sqrt(%pi) 2              sqrt(sqrt(2        + 1) + 1)
      (%o2)   -----------------------------------------------------
                                     2 alpha
                               sqrt(2        + 1)

      (%i3) ev (%, alpha=2, numer);
      (%o3)                     1.376043390090716

  Numerical methods ·Package quadpack ·

関数: quad_qaws (f(x), x, a, b, alpha, beta, wfun, [epsrel, epsabs, limit])
関数: quad_qaws (f, x, a, b, alpha, beta, wfun, [epsrel, epsabs, limit])

  w(x) f(x)の有限の区間上の積分。 ここで、w(x)は、ある代数的または対数関数です。 大域的適応最分割戦略が適用されます。 積分の区間の端点を含む部分区間上で変形Clenshaw-Curtis積分を使います。

  `quad_qaws`は、 Quadpack QAWSルーチンを使って 積分を計算します:

  integrate (f(x)*w(x), x, a, b)

  重み関数wはwfunによって選択されます:

  `1`

    w(x) = (x - a)^alpha (b - x)^beta

  `2`

    w(x) = (x - a)^alpha (b - x)^beta log(x - a)

  `3`

    w(x) = (x - a)^alpha (b - x)^beta log(b - x)

  `4`

    w(x) = (x - a)^alpha (b - x)^beta log(x - a) log(b - x)

  被積分関数は、MaximaまたはLispの関数または演算子の名前、 Maximaのラムダ式またはMaximaの一般式として指定されるかもしれません。

  キーワード引数は随意で、任意の順序で指定できます。 それらすべては形式`key=val`を取ります。 キーワード引数は:

  `epsrel`

    望まれる近似の相対誤差。デフォルトは1d-8。

  `epsabs`

    望まれる近似の絶対誤差。デフォルトは0。

  `limit`

    内部の作業配列のサイズ。limitは使用する部分区間の最大数。デフォルトは200。

  `quad_qaws`は、４つの要素のリストを返します:

  - 積分の近似
  - 見積もられた近似の絶対誤差
  - 非積分関数の評価数
  - エラーコード

  エラーコード(戻り値の４番目の要素)は以下の値を取ります:

  `0`

    問題が発生しなかった場合;

  `1`

    部分区間の数が上限を超えた場合;

  `2`

    丸め誤差が超過した場合;

  `3`

    非積分関数の振る舞いが極端に悪い場合;

  `4`

    収束に失敗した場合;

  `5`

    積分が発散しているか収束が遅い場合;

  `6`

    入力が無効な場合;

  例:

      (%i1) quad_qaws (1/(x+1+2^(-4)), x, -1, 1, -0.5, -0.5, 1,
                       'epsabs=1d-9);
      (%o1)     [8.750097361672832, 1.24321522715422E-10, 170, 0]

      (%i2) integrate ((1-x*x)^(-1/2)/(x+1+2^(-alpha)), x, -1, 1);
             alpha
      Is  4 2      - 1  positive, negative, or zero?

      pos;
                                alpha         alpha
                         2 %pi 2      sqrt(2 2      + 1)
      (%o2)              -------------------------------
                                     alpha
                                  4 2      + 2

      (%i3) ev (%, alpha=4, numer);
      (%o3)                     8.750097361672829

  Numerical methods ·Package quadpack ·

Next: Differential Equations, Previous: Integration, Up: Top [Contents][Index]

## 20 Equations

Previous: Equations, Up: Equations [Contents][Index]

### 20.1 Functions and Variables for Equations

システム変数: %rnum_list

  デフォルト値: `[]`

  `%rnum_list`は、 `solve`や`algsys`による解で導入された 変数のリストです。 `%r`変数は、それらが生成された順に `%rnum_list`に追加されます。 これは、あとで解への代入を行うのに便利です。 `concat ('%r, j)`をするよりこのリストを使うことを推奨します。

      (%i1) solve ([x + y = 3], [x,y]);
      (%o1)              [[x = 3 - %r1, y = %r1]]

      (%i2) %rnum_list;
      (%o2)                       [%r1]

      (%i3) sol : solve ([x + 2*y + 3*z = 4], [x,y,z]);
      (%o3)   [[x = - 2 %r3 - 3 %r2 + 4, y = %r3, z = %r2]]

      (%i4) %rnum_list;
      (%o4)                     [%r2, %r3]

      (%i5) for i : 1 thru length (%rnum_list) do
              sol : subst (t[i], %rnum_list[i], sol)$

      (%i6) sol;
      (%o6)     [[x = - 2 t  - 3 t  + 4, y = t , z = t ]]
                           2      1           2       1

  Algebraic equations ·

オプション変数: algepsilon

  デフォルト値: 10^8

  `algsys`が `algepsilon`を使います。

  Algebraic equations ·

オプション変数: algexact

  デフォルト値: `false`

  `algexact`は、以下のように`algsys`の振る舞いに影響を与えます:

  もし`algexact`が`true`なら、 `algsys`はいつも`solve`をコールし、 `solve`の失敗時には`realroots`を使います。

  もし`algexact`が`false`なら、 問題が１変数でないときだけ、 もしくは、方程式が二次もしくは四次なら `solve`がコールされます。

  このように、`algexact: true`は、 厳密解だけを保証せず、ただ、 `algsys`は最初に厳密解を与えるように最大限努力して、 他のすべてが失敗した時近似をもたらすことだけを保証します。

  Algebraic equations ·

関数: algsys ([expr_1, …, expr_m], [x_1, …, x_n])
関数: algsys ([eqn_1, …, eqn_m], [x_1, …, x_n])

  同時多項式expr_1, …, expr_m または多項式方程式eqn_1, …, eqn_m を変数x_1, …, x_nについて解きます。 式exprは、等式`expr = 0`と同値です。 変数より等式が多い場合も逆もあります。

  `algsys`は、解のリストを返します。 ここで、それぞれの解は、 方程式系を満たす変数x_1, …, x_nの値を指定する等式のリストとして 与えられます。 もし`algsys`が解を見つけられなければ、 空のリスト`[]`が返されます。

  シンボル`%r1`, `%r2`, …, が、解の任意パラメータを表すために、必要に応じて導入されます; これらの変数は、リスト `%rnum_list`にも追加されます。

  方法は以下の通りです:

  1. 最初に、方程式は因数分解され、サブシステムに分割されます。
  2. それぞれのサブシステムS_iに関して、等式Eと変数xが選択されます。 変数はゼロでない最低次を持つよう選ばれます。 そして、 xに関するEとE_jの終結式が サブシステムS_iの中の残っている等式群E_jのそれぞれに関して計算されます。

     これは、xが消去されるので、 １つ変数の少ない新しいサブシステムS_i’をもたらします ここでプロセスは(1)に戻ります。

  3. いつか、１つの等式から成るサブシステムが得られます。 もし等式が多変数なら、浮動小数点数の形式の近似は導入されず、 厳密解を見つけるために`solve`がコールされます。

     いくつかの場合、`solve`は解を見つけることができないか、 もし見つけたら、絵が非常に大きな式になるかもしれません。

     もし等式が１変数で、線形か二次か四次なら、 もし近似が導入されないなら、再び`solve`がコールされます。 もし近似が導入されるか、等式が１変数でなく、線形でも二次でも、四次でもないなら、 もしスイッチ`realonly`が`true`なら、 実数解を見つけるため関数`realroots`がコールされます。 もし`realonly`が`false`なら、 実数解と複素数解を探す`allroots`がコールされます。

     もし`algsys`が 要求よりも有効数字が少ない解を生成するなら、 ユーザーは`algepsilon`の値をより高い値に変更できます。

     もし`algexact`が`true`に設定されているなら、 いつも`solve`がコールされます。

  4. 最終的に、ステップ(3)で得られた解は以前のレベルに代入され、解処理は(1)に戻ります。

  `algsys`が（通常、初期の段階での厳密解発見の失敗による）浮動小数点近似を含む多変数方程式に出会う時、 厳密な方法をそんな方程式に適用しようとせず、かわりにメッセージを表示します: "`algsys` cannot solve - system too complicated."

  `radcan`との対話は、多きなもしくは複雑な式を生成することができます。 この場合、`pickapart`または `reveal`を使って結果の一部を分離することができるかもしれません。

  時々、`radcan`は、実際には実数値の解に虚数単位`%i`を導入するかもしれません。

  例:

      (%i1) e1: 2*x*(1 - a1) - 2*(x - 1)*a2;
      (%o1)              2 (1 - a1) x - 2 a2 (x - 1)
      (%i2) e2: a2 - a1;
      (%o2)                        a2 - a1
      (%i3) e3: a1*(-y - x^2 + 1);
                                         2
      (%o3)                   a1 (- y - x  + 1)
      (%i4) e4: a2*(y - (x - 1)^2);
                                             2
      (%o4)                   a2 (y - (x - 1) )
      (%i5) algsys ([e1, e2, e3, e4], [x, y, a1, a2]);
      (%o5) [[x = 0, y = %r1, a1 = 0, a2 = 0],

                                        [x = 1, y = 0, a1 = 1, a2 = 1]]
      (%i6) e1: x^2 - y^2;
                                    2    2
      (%o6)                        x  - y
      (%i7) e2: -1 - y + 2*y^2 - x + x^2;
                               2        2
      (%o7)                 2 y  - y + x  - x - 1
      (%i8) algsys ([e1, e2], [x, y]);
                       1            1
      (%o8) [[x = - -------, y = -------],
                    sqrt(3)      sqrt(3)

              1              1             1        1
      [x = -------, y = - -------], [x = - -, y = - -], [x = 1, y = 1]]
           sqrt(3)        sqrt(3)          3        3

  Algebraic equations ·

関数: allroots (expr)
関数: allroots (eqn)

  1変数多項式exprもしくは1変数多項式方程式eqnの実数と複素数の根の数値近似を 計算する。

  フラグ`polyfactor`が`true`の時、 `allroots`は、多項式が実数なら多項式を実数上で因数分解し、 多項式が複素数なら複素数上で因数分解します。

  `allroots`は、多重根の場合、不正確な結果をもたらすことがあります。 もし多項式が実数なら、`allroots (%i*p)`は、 `allroots (p)`より精確な近似を生成します。 `allroots`はこの場合異なるアルゴリズムを呼ぶので。

  `allroots`は非多項式を却下します。 `rat`された分子が多項式であることを要求し、 分母はせいぜい複素数であることを要求します。 この結果、もし`polyfactor`が`true`なら、 `allroots`はいつも（因数分解された）同値の式を返します。

  複素多項式のために、JenkinsとTraubのアルゴリズムが使われます （Algorithm 419, Comm. ACM, vol. 15, (1972), .97)。 実多項式のために、Jenkinsのアルゴリズム (Algorithm 493, ACM TOMS, vol. 1, (1975), p.178)が使われます。

  例:

      (%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
                                  3          5
      (%o1)              (2 x + 1)  = 13.5 (x  + 1)
      (%i2) soln: allroots (eqn);
      (%o2) [x = .8296749902129361, x = - 1.015755543828121,

      x = .9659625152196369 %i - .4069597231924075,

      x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
      (%i3) for e in soln
              do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
                            - 3.5527136788005E-15

                           - 5.32907051820075E-15

               4.44089209850063E-15 %i - 4.88498130835069E-15

              - 4.44089209850063E-15 %i - 4.88498130835069E-15

                             3.5527136788005E-15

      (%o3)                         done
      (%i4) polyfactor: true$
      (%i5) allroots (eqn);
      (%o5) - 13.5 (x - 1.0) (x - .8296749902129361)

                                 2
       (x + 1.015755543828121) (x  + .8139194463848151 x

       + 1.098699797110288)

  Polynomials ·Numerical methods ·

関数: bfallroots (expr)
関数: bfallroots (eqn)

  １変数の多項式exprまたは多項式等式eqnの実数根と複素数根の数値近似 を計算します。

  `bfallroots`は多倍長浮動小数点を使って根を計算する以外の すべての点で、`bfallroots`は`allroots`と同一です。 詳しい情報については`allroots`を参照してください。

  Polynomials ·Numerical methods ·

オプション変数: backsubst

  デフォルト値: `true`

  `backsubst`が`false`の時、 方程式が三角行列化された後、`linsolve`の後退代入を妨げます。 これは、後退代入が極端に大きな式の生成のもととなる非常に大きな問題に関して役立つかもしれません。

      (%i1) eq1 : x + y + z = 6$
      (%i2) eq2 : x - y + z = 2$
      (%i3) eq3 : x + y - z = 0$
      (%i4) backsubst : false$

      (%i5) linsolve ([eq1, eq2, eq3], [x,y,z]);
      (%o5)             [x = z - y, y = 2, z = 3]

      (%i6) backsubst : true$

      (%i7) linsolve ([eq1, eq2, eq3], [x,y,z]);
      (%o7)               [x = 1, y = 2, z = 3]

  Algebraic equations ·

オプション変数: breakup

  デフォルト値: `true`

  `breakup`が`true`の時、 `solve`は、三次と四次の方程式の解を共通部分式を使って表現します。 共通部分式は、中間式ラベル(`%t1`, `%t2`, など)に割り当てられます。 そうでなければ、共通部分式は同定されません。

  `breakup: true`は、 `programmode`が`false`の時だけ、効果を持ちます。

  例:

      (%i1) programmode: false$
      (%i2) breakup: true$
      (%i3) solve (x^3 + x^2 - 1);

                              sqrt(23)    25 1/3
      (%t3)                  (--------- + --)
                              6 sqrt(3)   54
      Solution:

                                            sqrt(3) %i   1
                                            ---------- - -
                      sqrt(3) %i   1            2        2   1
      (%t4)    x = (- ---------- - -) %t3 + -------------- - -
                          2        2            9 %t3        3

                                            sqrt(3) %i   1
                                          - ---------- - -
                    sqrt(3) %i   1              2        2   1
      (%t5)    x = (---------- - -) %t3 + ---------------- - -
                        2        2             9 %t3         3

                                         1     1
      (%t6)                  x = %t3 + ----- - -
                                       9 %t3   3
      (%o6)                    [%t4, %t5, %t6]
      (%i6) breakup: false$
      (%i7) solve (x^3 + x^2 - 1);
      Solution:

                   sqrt(3) %i   1
                   ---------- - -
                       2        2        sqrt(23)    25 1/3
      (%t7) x = --------------------- + (--------- + --)
                   sqrt(23)    25 1/3    6 sqrt(3)   54
                9 (--------- + --)
                   6 sqrt(3)   54

                                                    sqrt(3) %i   1    1
                                                 (- ---------- - -) - -
                                                        2        2    3

                 sqrt(23)    25 1/3  sqrt(3) %i   1
      (%t8) x = (--------- + --)    (---------- - -)
                 6 sqrt(3)   54          2        2

                                                  sqrt(3) %i   1
                                                - ---------- - -
                                                      2        2      1
                                            + --------------------- - -
                                                 sqrt(23)    25 1/3   3
                                              9 (--------- + --)
                                                 6 sqrt(3)   54

                  sqrt(23)    25 1/3             1             1
      (%t9)  x = (--------- + --)    + --------------------- - -
                  6 sqrt(3)   54          sqrt(23)    25 1/3   3
                                       9 (--------- + --)
                                          6 sqrt(3)   54
      (%o9)                    [%t7, %t8, %t9]

  Algebraic equations ·

関数: dimension (eqn)
関数: dimension (eqn_1, ..., eqn_n)

  `dimen`は、次元解析パッケージです。 `load ("dimen")`はこのパッケージをロードします。 `demo ("dimen")`は短いデモンストレーションを表示します。

  Share packages ·

オプション変数: dispflag

  デフォルト値: `true`

  もし`block`内で`false`に設定されたら `block`内でコールされた解法関数が生成する出力の表示を抑制します。 `block`をドル記号$で終端すると、 `dispflag`を`false`に設定します。

  Algebraic equations ·Display flags and variables ·

関数: funcsolve (eqn, g(t))

  eqnを満たす有理関数`g(t)`が存在するかどうかに依存して、 `[g(t) = ...]`または`[]`を返します。 ここで、eqnは（この場合） `g(t)`と`g(t+1)`に関して 一次、線形多項式でなければいけません。

      (%i1) eqn: (n + 1)*f(n) - (n + 3)*f(n + 1)/(n + 1) =
            (n - 1)/(n + 2);
                                  (n + 3) f(n + 1)   n - 1
      (%o1)        (n + 1) f(n) - ---------------- = -----
                                       n + 1         n + 2
      (%i2) funcsolve (eqn, f(n));

      Dependent equations eliminated:  (4 3)
                                         n
      (%o2)                f(n) = ---------------
                                  (n + 1) (n + 2)

  警告: これはとても未熟な実装です – 多くの安全性チェックや 明らかな一般化が忘れられています。

  Algebraic equations ·

オプション変数: globalsolve

  デフォルト値: `false`

  `globalsolve`が`true`の時、 ２つ以上の線形方程式を解く時、 解くべき変数が、`linsolve`や`solve`が見つけた解の値に割り当てられます。

  `globalsolve`が`false`の時、 ２つ以上の線形方程式を解く時、 `linsolve`や`solve`が見つけた解は、 等式として表現され、 解くべき変数は割り当てられません。

  ２つ以上の線形方程式以外の何かを解く時には、 `solve`は`globalsolve`を無視します。 方程式を解く他の関数(例えば`algsys`)はいつも`globalsolve`を無視します。

  例:

      (%i1) globalsolve: true$
      (%i2) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
      Solution

                                       17
      (%t2)                        x : --
                                       7

                                         1
      (%t3)                        y : - -
                                         7
      (%o3)                     [[%t2, %t3]]
      (%i3) x;
                                     17
      (%o3)                          --
                                     7
      (%i4) y;
                                       1
      (%o4)                          - -
                                       7
      (%i5) globalsolve: false$
      (%i6) kill (x, y)$
      (%i7) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
      Solution

                                       17
      (%t7)                        x = --
                                       7

                                         1
      (%t8)                        y = - -
                                         7
      (%o8)                     [[%t7, %t8]]
      (%i8) x;
      (%o8)                           x
      (%i9) y;
      (%o9)                           y

  Linear equations ·

関数: ieqn (ie, unk, tech, n, guess)

  `inteqn`は、積分方程式を解くためのパッケージです。 `load ("inteqn")`はこのパッケージをロードします。

  ieは、積分方程式です; unkは、未知の関数です; techは、上で与えられたこれらから試される手法です; is the technique to be tried from those given above (tech = `first`は以下を意味します: 解を見つける最初の手法を試みる; tech = `all`は以下を意味します: 適用可能な手法すべてを試みる); nは、 `taylor`, `neumann`, `firstkindseries`, または`fredseries` に関して扱う項の最大数です (微分法に関する再帰の最大深度でもあります); guessは、`neumann`または`firstkindseries`に関する 初期の推測です。

  ２番目から５番目までのパラメータのデフォルト値は、以下の通りです:

  unk: `p(x)`。 ここで、pは被積分関数の中で出会うMaximaが知らない最初の関数であり、 xは、`secondkind`方程式の場合の積分の外側で見つかったp の最初の出現時の引数、または、`firstkind`方程式の中の積分変数を除いた唯一の残りの変数 です。 もしxを探す企てが失敗したら、ユーザーは独立変数を供給するよう尋ねられるでしょう。

  tech: `first`

  n: 1

  guess: `neumann`と`firstkindseries`が 初期推測として`f(x)`を使うようにする`none`

  Integral equations ·

オプション変数: ieqnprint

  デフォルト値: `true`

  `ieqnprint`は、`ieqn`コマンドが返す結果の振る舞いを決めます。 `ieqnprint`が`false`の時、 `ieqn`関数が返すリストは、形式

  [solution, technique used, nterms, flag]

  を取ります。

  ここで、もし解が厳密ならflagはありません。

  そうでなければ、厳密でない解か閉じていない形の解かに対応して、それぞれ、単語`approximate`または`incomplete`です。 もし級数法が使われたら、 ntermsは、取った項の数を与えます。 （項の数は、もしエラーが更なる項の生成を防いだなら、`ieqn`に与えられたnよりも小さいこともあり得ます。）

  Integral equations ·

関数: lhs (expr)

  exprの演算子が関係演算子`< <= = # equal notequal >= >`の１つ、 割り当て演算子`:= ::= : ::`の１つ、 または`infix`で宣言されたユーザー定義の二項中置演算子の時、 式exprの左辺(すなわち、最初の項) を返します。

  exprがアトムか、演算子が上で記載したもの以外の何かの時、 `lhs`はexprを返します。

  `rhs`も参照してください。

  例:

      (%i1) e: aa + bb = cc;
      (%o1)                     bb + aa = cc
      (%i2) lhs (e);
      (%o2)                        bb + aa
      (%i3) rhs (e);
      (%o3)                          cc
      (%i4) [lhs (aa < bb), lhs (aa <= bb), lhs (aa >= bb),
             lhs (aa > bb)];
      (%o4)                   [aa, aa, aa, aa]
      (%i5) [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)),
             lhs (notequal (aa, bb))];
      (%o5)                   [aa, aa, aa, aa]
      (%i6) e1: '(foo(x) := 2*x);
      (%o6)                     foo(x) := 2 x
      (%i7) e2: '(bar(y) ::= 3*y);
      (%o7)                    bar(y) ::= 3 y
      (%i8) e3: '(x : y);
      (%o8)                         x : y
      (%i9) e4: '(x :: y);
      (%o9)                        x :: y
      (%i10) [lhs (e1), lhs (e2), lhs (e3), lhs (e4)];
      (%o10)               [foo(x), bar(y), x, x]
      (%i11) infix ("][");
      (%o11)                         ][
      (%i12) lhs (aa ][ bb);
      (%o12)                         aa

  Expressions ·

関数: linsolve ([expr_1, …, expr_m], [x_1, …, x_n])

  変数のリストに関して同時線形方程式のリストを解きます。 それぞれの式は変数に関する多項式でなければならず、等式も取り得ます。

  `globalsolve`が`true`の時、 解くべき変数それぞれは、方程式の解の値にバインドされます。

  `backsubst`が`false`の時、 `linsolve`は、方程式が三角行列化された後、後退代入を実行しません。 これは、後退代入が極端に大きな式の生成の原因となる非常に大きな問題に関して 必要とされるかもしれません。

  `linsolve_params`が`true`の時、 `linsolve`は `algsys`の下のマニュアルの中で記述された任意のパラメータを表すのに使われる `%r`シンボルも生成します。 そうでなければ、 `linsolve`は、他を使って表現されたいくつかの変数を持つ 決定中の方程式系を解きます。

  `programmode`が`false`の時、 `linsolve`は、中間式(`%t`)ラベルを使って解を表示し、 ラベルのリストを返します。

      (%i1) e1: x + z = y;
      (%o1)                       z + x = y
      (%i2) e2: 2*a*x - y = 2*a^2;
                                             2
      (%o2)                   2 a x - y = 2 a
      (%i3) e3: y - 2*z = 2;
      (%o3)                      y - 2 z = 2
      (%i4) [globalsolve: false, programmode: true];
      (%o4)                     [false, true]
      (%i5) linsolve ([e1, e2, e3], [x, y, z]);
      (%o5)            [x = a + 1, y = 2 a, z = a - 1]
      (%i6) [globalsolve: false, programmode: false];
      (%o6)                    [false, false]
      (%i7) linsolve ([e1, e2, e3], [x, y, z]);
      Solution

      (%t7)                       z = a - 1

      (%t8)                        y = 2 a

      (%t9)                       x = a + 1
      (%o9)                    [%t7, %t8, %t9]
      (%i9) ''%;
      (%o9)            [z = a - 1, y = 2 a, x = a + 1]
      (%i10) [globalsolve: true, programmode: false];
      (%o10)                    [true, false]
      (%i11) linsolve ([e1, e2, e3], [x, y, z]);
      Solution

      (%t11)                      z : a - 1

      (%t12)                       y : 2 a

      (%t13)                      x : a + 1
      (%o13)                 [%t11, %t12, %t13]
      (%i13) ''%;
      (%o13)           [z : a - 1, y : 2 a, x : a + 1]
      (%i14) [x, y, z];
      (%o14)                 [a + 1, 2 a, a - 1]
      (%i15) [globalsolve: true, programmode: true];
      (%o15)                    [true, true]
      (%i16) linsolve ([e1, e2, e3], '[x, y, z]);
      (%o16)           [x : a + 1, y : 2 a, z : a - 1]
      (%i17) [x, y, z];
      (%o17)                 [a + 1, 2 a, a - 1]

  Linear equations ·

オプション変数: linsolvewarn

  デフォルト値: `true`

  `linsolvewarn`が`true`の時、 `linsolve`はメッセージ"Dependent equations eliminated"を表示します。

  Linear equations ·

オプション変数: linsolve_params

  デフォルト値: `true`

  `linsolve_params`が`true`の時、 `linsolve`は、 `algsys`の下のマニュアルに記述された任意のパラメータを表すのに使われる`%r`シンボルも生成します。 それでなければ、`linsolve`は、 他を使って表現されたいくつかの変数を使った 決定中の方程式系を解きます。

  Linear equations ·

システム変数: multiplicities

  デフォルト値: `not_set_yet`

  `multiplicities`は、 `solve`や`realroots`が返す個々の解の多様性のリストに設定されます。

  Algebraic equations ·Polynomials ·

関数: nroots (p, low, high)

  半開区間`(low, high]`の中の 実数一変数多項式pの実根の数を返します。 区間の端点は`minf`もしくは`inf`、無限大かもしれません。 マイナス無限大とプラス無限大。

  `nroots`は、Sturm列の方法を使います。

      (%i1) p: x^10 - 2*x^4 + 1/2$
      (%i2) nroots (p, -6, 9.1);
      (%o2)                           4

  Polynomials ·Numerical methods ·

関数: nthroot (p, n)

  pは整数係数多項式で、 nは正の整数ですが、 q^n=pのような整数上の多項式qを返すか、 pが完全なn番目のべきでないことを示すエラーメッセージを表示します。 このルーチンは、`factor`より、また`sqfr`よりさえもっと速いです。

  Polynomials ·

オプション変数: polyfactor

  デフォルト値: `false`

  オプション変数`polyfactor`が`true`の時、 `allroots`と`bfallroots`は もし多項式が実数なら実数上で、もし多項式が複素数なら複素数上で多項式を因数分解します。

  例は`allroots`を参照してください。

  Polynomials ·Numerical methods ·

オプション変数: programmode

  デフォルト値: `true`

  `programmode`が`true`の時、 `solve`, `realroots`, `allroots`, `linsolve`は、 リストの中の要素として解を返します。 (`backsubst`が`false`設定されている時― その場合、`programmode: false`が仮定されます―を除いて)

  `programmode`が`false`の時、 `solve`などは、中間式ラベル`%t1`, `t2`など生成し、 解をそれらに割り当てます。

  Algebraic equations ·Polynomials ·

オプション変数: realonly

  デフォルト値: `false`

  `realonly`が`true`の時、 `algsys`は、 `%i`を含まないそれらの解だけを返します。

  Algebraic equations ·

関数: realroots (expr, bound)
関数: realroots (eqn, bound)
関数: realroots (expr)
関数: realroots (eqn)

  変数多項式exprもしくは1変数多項方程式eqnの実根の有理近似を、 `bound`の許容誤差の範囲内で計算します。 exprもしくはeqnの係数はリテラル数でなければなりません。 `%pi`のようなシンボル定数は却下されます。

  `realroots`は、みつけた根の多様性を グローバル変数`multiplicities`に割り当てます。

  `realroots`は、それぞれの根を囲むためSturm列を構成し、 近似を精密化するため二分法を適用します。 根を探索する前に、すべての係数は同値の有理数に変換され、 正確な有理算術によって計算が実行されます。 たとえ係数が浮動小数点でも、 （`float`もしくは`numer`フラグによって浮動小数点が強要されない限り）結果は有理数です。

  boundが1よりも小さい時、全ての整数根は正確に計算されます。 boundがしてされない時、グローバル変数`rootsepsilon`と等しいと仮定されます。

  グローバル変数`programmode`が`true`の時、 `realroots`は形式`[x = x_1, x = x_2, …]`のリストを 返します。 `programmode`が`false`の時、`realroots`は 中間式ラベル`%t1`, `%t2`, …を生成し、 結果をそれらに割り当て、ラベルのリストを返します。

  例:

      (%i1) realroots (-1 - x + x^5, 5e-6);
                                     612003
      (%o1)                     [x = ------]
                                     524288
      (%i2) ev (%[1], float);
      (%o2)                 x = 1.167303085327148
      (%i3) ev (-1 - x + x^5, %);
      (%o3)                - 7.396496210176905E-6

      (%i1) realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20);
      (%o1)                 [x = 1, x = 2, x = 3]
      (%i2) multiplicities;
      (%o2)                       [5, 3, 1]

  Polynomials ·Numerical methods ·

関数: rhs (expr)

  exprの演算子が関係演算子`< <= = # equal notequal >= >`の１つ、 割り当て演算子`:= ::= : ::`の１つ、または、 `infix`で宣言されたユーザー定義の二項中置演算子の時 式exprの右辺(すなわち、二番目の項)を返します。

  exprがアトムか、演算子が上で記載したもの以外の何かの時、 `rhs`はexprを返します。

  `lhs`も参照してください。

  例:

      (%i1) e: aa + bb = cc;
      (%o1)                     bb + aa = cc
      (%i2) lhs (e);
      (%o2)                        bb + aa
      (%i3) rhs (e);
      (%o3)                          cc
      (%i4) [rhs (aa < bb), rhs (aa <= bb), rhs (aa >= bb),
             rhs (aa > bb)];
      (%o4)                   [bb, bb, bb, bb]

      (%i5) [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)),
             rhs (notequal (aa, bb))];

      (%o5)                   [bb, bb, bb, bb]
      (%i6) e1: '(foo(x) := 2*x);
      (%o6)                     foo(x) := 2 x
      (%i7) e2: '(bar(y) ::= 3*y);
      (%o7)                    bar(y) ::= 3 y
      (%i8) e3: '(x : y);
      (%o8)                         x : y
      (%i9) e4: '(x :: y);
      (%o9)                        x :: y
      (%i10) [rhs (e1), rhs (e2), rhs (e3), rhs (e4)];
      (%o10)                  [2 x, 3 y, y, y]
      (%i11) infix ("][");
      (%o11)                         ][
      (%i12) rhs (aa ][ bb);
      (%o12)                         bb

  Expressions ·

オプション変数: rootsconmode

  デフォルト値: `true`

  `rootsconmode`は、`rootscontract`コマンドの振る舞いを決定します。 詳細は`rootscontract`を参照してください。

  Expressions ·Simplification flags and variables ·

関数: rootscontract (expr)

  根の積を積の根に変換します。 例えば、 `rootscontract (sqrt(x)*y^(3/2))`は`sqrt(x*y^3)`をもたらします。

  `radexpand`が`true`かつ`domain`が`real`の時、 `rootscontract`は、 converts `abs`を`sqrt`に変換します。 例えば、`rootscontract (abs(x)*sqrt(y))`は`sqrt(x^2*y)`をもたらします。

  以下のように`rootscontract`に影響するオプション`rootsconmode`があります:

      問題               rootsconmodeの値　rootscontractを適用した値

      x^(1/2)*y^(3/2)      false          (x*y^3)^(1/2)
      x^(1/2)*y^(1/4)      false          x^(1/2)*y^(1/4)
      x^(1/2)*y^(1/4)      true           (x*y^(1/2))^(1/2)
      x^(1/2)*y^(1/3)      true           x^(1/2)*y^(1/3)
      x^(1/2)*y^(1/4)      all            (x^2*y)^(1/4)
      x^(1/2)*y^(1/3)      all            (x^3*y^2)^(1/6)

  `rootsconmode`が`false`の時、 `rootscontract`は、分母が同じ有理数指数に関してだけ短縮します。 `rootsconmode: true`の例のキーは、 単に、4は2で割り切れますが、4は2で割り切れないということです。 `rootsconmode: all`は、指数の分母の最小公倍数を取ることを伴います。

  `rootscontract`は、 `logcontract`と似た方法で、`ratsimp`を使います。

  例:

      (%i1) rootsconmode: false$
      (%i2) rootscontract (x^(1/2)*y^(3/2));
                                         3
      (%o2)                      sqrt(x y )
      (%i3) rootscontract (x^(1/2)*y^(1/4));
                                         1/4
      (%o3)                     sqrt(x) y
      (%i4) rootsconmode: true$
      (%i5) rootscontract (x^(1/2)*y^(1/4));
      (%o5)                    sqrt(x sqrt(y))
      (%i6) rootscontract (x^(1/2)*y^(1/3));
                                         1/3
      (%o6)                     sqrt(x) y
      (%i7) rootsconmode: all$
      (%i8) rootscontract (x^(1/2)*y^(1/4));
                                    2   1/4
      (%o8)                       (x  y)
      (%i9) rootscontract (x^(1/2)*y^(1/3));
                                   3  2 1/6
      (%o9)                      (x  y )
      (%i10) rootsconmode: false$
      (%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
                          *sqrt(sqrt(1 + x) - sqrt(x)));
      (%o11)                          1
      (%i12) rootsconmode: true$
      (%i13) rootscontract (sqrt(5+sqrt(5)) - 5^(1/4)*sqrt(1+sqrt(5)));
      (%o13)                          0

  Simplification functions ·

オプション変数: rootsepsilon

  デフォルト値: 1.0e-7

  `rootsepsilon`は、 `realroots`関数が見つけた根に関する信頼区間を確立する許容誤差です。

  Polynomials ·Numerical methods ·

関数: solve (expr, x)
関数: solve (expr)
関数: solve ([eqn_1, …, eqn_n], [x_1, …, x_n])

  代数等式exprをxについて解き、xの解等式のリストを返します。 もしexprの等式でなければ、等式`expr = 0`が仮定されます。 xは関数(例えば`f(x)`)でも他のアトムでない式でも問題ありません。 （sumやproductは除きます。）exprが変数を１つだけ含む場合、xは省略できます。 exprは有理式でも、三角関数や指数関数を含むことができます。

  以下の方法が使われます:

  Eを式、Xを変数とします。 もしEがXに関して線形なら、Xについて自明に解かれます。 そうでなければ、もしEが`A*X^N + B`の形なら、 結果は、`(-B/A)^(1/N)`かける1の`N`乗根です。

  もしEがXについて線形でなければ、 Eの中のXの指数のgcd(以下Nとする）が指数に割られ、 根にNがかけられます。 その後、結果に対して`solve`が再びコールされます。 もしEが因数分解されるなら、`solve`は因子のそれぞれに対してコールされます。 最後に、`solve`は２次方程式、３次方程式、4次方程式の解の公式を必要に応じて使います。

  Eが解くべき変数のある関数（以下`F(X)`)の多項式の場合， 最初に`F(X)`について解かれ（結果をCと呼ぶ）、 関数Fの逆関数がわかっている場合、等式`F(X)=C`がXについて解かれます。

  `breakup`が`false`なら、 `solve`は３次もしくは４次方程式の解を、 デフォルトであるいくつかの共通部分式から成る表現ではなく、 単一の式で表現されます。

  `multiplicities`は、`solve`や`realroots`, `allroots`が返した 多数の独立の解のリストに設定されます。 `slove`に影響するスイッチについては、`apropos (solve)`を試してください。 もしスイッチの目的がはっきりしないなら、 個々のスイッチ名について`describe`を使うことができます。

  `solve ([eqn_1, ..., eqn_n], [x_1, ..., x_n])` は、`linsolve`もしくは`algsys`をコールすることで， 同時（線形もしくは非線形）代数方程式系を解き、変数の解リストのリストを返します。 `linsolve`の場合、このリストは解の単一リストを含みます。 引数に２つのリストをとります。 最初のリストは解くべき等式を示し、２番目のリストは決定すべき未知数のリストです。 もし等式の変数の総数が等式の数に等しいなら、２番目の引数リストは省略できます。

  `programmode`が`false`の時、 `solve`は中間式(`%t`)ラベルを持つ解を表示し、ラベルのリストを返します。

  `globalsolve`が`true`、かつ、問題が２つ以上の線形方程式を解くことである場合、 それぞれの解くべき変数は方程式の解の値にバインドされます。

  例:

      (%i1) solve (asin (cos (3*x))*(f(x) - 1), x);

      solve: using arc-trig functions to get a solution.
      Some solutions will be lost.
                                  %pi
      (%o1)                  [x = ---, f(x) = 1]
                                   6
      (%i2) ev (solve (5^f(x) = 125, f(x)), solveradcan);
                                      log(125)
      (%o2)                   [f(x) = --------]
                                       log(5)
      (%i3) [4*x^2 - y^2 = 12, x*y - x = 2];
                            2    2
      (%o3)             [4 x  - y  = 12, x y - x = 2]

      (%i4) solve (%, [x, y]);
      (%o4) [[x = 2, y = 2], [x = .5202594388652008 %i
       - .1331240357358706, y = .07678378523787788
       - 3.608003221870287 %i], [x = - .5202594388652008 %i
       - .1331240357358706, y = 3.608003221870287 %i
       + .07678378523787788], [x = - 1.733751846381093,
      y = - .1535675710019696]]

      (%i5) solve (1 + a*x + x^3, x);

                                             3
                    sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
      (%o5) [x = (- ---------- - -) (--------------- - -)
                        2        2      6 sqrt(3)      2

              sqrt(3) %i   1
             (---------- - -) a
                  2        2
       - --------------------------, x =
                    3
            sqrt(4 a  + 27)   1 1/3
         3 (--------------- - -)
               6 sqrt(3)      2

                                3
       sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
      (---------- - -) (--------------- - -)
           2        2      6 sqrt(3)      2

               sqrt(3) %i   1
            (- ---------- - -) a
                   2        2
       - --------------------------, x =
                    3
            sqrt(4 a  + 27)   1 1/3
         3 (--------------- - -)
               6 sqrt(3)      2

               3
       sqrt(4 a  + 27)   1 1/3               a
      (--------------- - -)    - --------------------------]
          6 sqrt(3)      2                  3
                                    sqrt(4 a  + 27)   1 1/3
                                 3 (--------------- - -)
                                       6 sqrt(3)      2
      (%i6) solve (x^3 - 1);
                   sqrt(3) %i - 1        sqrt(3) %i + 1
      (%o6)   [x = --------------, x = - --------------, x = 1]
                         2                     2
      (%i7) solve (x^6 - 1);
                 sqrt(3) %i + 1      sqrt(3) %i - 1
      (%o7) [x = --------------, x = --------------, x = - 1,
                       2                   2

                           sqrt(3) %i + 1        sqrt(3) %i - 1
                     x = - --------------, x = - --------------, x = 1]
                                 2                     2
      (%i8) ev (x^6 - 1, %[1]);

                                            6
                            (sqrt(3) %i + 1)
      (%o8)                 ----------------- - 1
                                   64

      (%i9) expand (%);
      (%o9)                           0
      (%i10) x^2 - 1;
                                    2
      (%o10)                       x  - 1
      (%i11) solve (%, x);
      (%o11)                  [x = - 1, x = 1]
      (%i12) ev (%th(2), %[1]);
      (%o12)                          0

  シンボル`%r`は、解の中で任意定数を示すのに使われます。

      (%i1) solve([x+y=1,2*x+2*y=2],[x,y]);

      solve: dependent equations eliminated: (2)
      (%o1)                      [[x = 1 - %r1, y = %r1]]

  更に知るには、`algsys`と `%rnum_list`.

  Algebraic equations ·

オプション変数: solvedecomposes

  デフォルト値: `true`

  `solvedecomposes`が`true`の時、 もし多項式を解くように頼まれたなら、 `solve`は、`polydecomp`をコールします。

  Algebraic equations ·

オプション変数: solveexplicit

  デフォルト値: `false`

  `solveexplicit`が`true`の時、 `solve`が 陰解―すなわち、`F`がある関数である形式`F(x) = 0`の解― を返すことを妨げます。

  Algebraic equations ·

オプション変数: solvefactors

  デフォルト値: `true`

  `solvefactors`が`false`の時、 `solve`は、式を因数分解しようとしません。 `false`設定は、 因数分解が不要ないくつかの場合に望まれるかもしれません。

  Algebraic equations ·

オプション変数: solvenullwarn

  デフォルト値: `true`

  `solvenullwarn`が`true`の時、 もし空の等式リストか空の変数リストを引数にコールされたら `solve`は、警告メッセージを表示します。 例えば、`solve ([], [])`は、２つの警告メッセージを表示し、 `[]`を返します。

  Algebraic equations ·

オプション変数: solveradcan

  デフォルト値: `false`

  `solveradcan`が`true`の時、 `solve`は`radcan`をコールし、`solve`は遅くなりますが、 指数と対数を含むある問題が解けるようになります。

  Algebraic equations ·

オプション変数: solvetrigwarn

  デフォルト値: `true`

  `solvetrigwarn`が`true`の時、 `solve`は、 方程式を解くために逆三角関数を使い、ゆえに解を失っていることを示す メッセージを表示するかもしれません。

  Algebraic equations ·

Next: Numerical, Previous: Equations, Up: Top [Contents][Index]

## 21 Differential Equations

Next: Functions and Variables for Differential Equations, Previous: Differential Equations, Up: Differential Equations [Contents][Index]

### 21.1 Introduction to Differential Equations

この節は、 一次と二次方程式のいくつかの特定のタイプの解析解を得るためのMaximaで利用可能な関数を 記述します。 微分方程式系の数値解を得るには、 付加パッケージ`dynamics`を参照してください。 位相空間でのグラフィカルな表現に関して、 付加パッケージ`plotdf`を参照してください。

Previous: Introduction to Differential Equations, Up: Differential Equations [Contents][Index]

### 21.2 Functions and Variables for Differential Equations

関数: bc2 (solution, xval1, yval1, xval2, yval2)

  二階微分方程式の境界値問題を解きます。 ここで: solutionは、`ode2`が見つけるような方程式の一般解です; xval1は、独立変数の最初の点の値を、形式`x = x1`で指定し、 yval1は、その点の従属変数の値を、形式`y = y1`で与えます。 式xval2とyval2は、 それらの変数の二番目の点での値を、同じ形式を使って与えます。

  用法の例については`ode2`を参照してください。

  Differential equations ·

関数: desolve (eqn, x)
関数: desolve ([eqn_1, ..., eqn_n], [x_1, ..., x_n])

  関数`desolve`は、ラプラス変換を使って線形常微分方程式系を解きます。 ここで、eqn群は、従属変数x_1, ..., x_nに関する微分方程式です。 x_1, ..., x_nの独立変数、例えばx、への関数依存性は、 変数や導関数の中で陽に示されなければいけません。 例えば、これは、２つの方程式を定義する正しい方法ではありません:

      eqn_1: 'diff(f,x,2) = sin(x) + 'diff(g,x);
      eqn_2: 'diff(f,x) + x^2 - f = 2*'diff(g,x,2);

  正しい方法は以下の通りです:

      eqn_1: 'diff(f(x),x,2) = sin(x) + 'diff(g(x),x);
      eqn_2: 'diff(f(x),x) + x^2 - f(x) = 2*'diff(g(x),x,2);

  関数`desolve`のコールは、

      desolve([eqn_1, eqn_2], [f(x),g(x)]);

  です。

  もし`x=0`の初期条件が既知なら、 それらは、`atvalue`を使って、`desolve`コールの前に供給することができます。

      (%i1) 'diff(f(x),x)='diff(g(x),x)+sin(x);
                       d           d
      (%o1)            -- (f(x)) = -- (g(x)) + sin(x)
                       dx          dx
      (%i2) 'diff(g(x),x,2)='diff(f(x),x)-cos(x);

                        2
                       d            d
      (%o2)            --- (g(x)) = -- (f(x)) - cos(x)
                         2          dx
                       dx

      (%i3) atvalue('diff(g(x),x),x=0,a);
      (%o3)                           a
      (%i4) atvalue(f(x),x=0,1);
      (%o4)                           1
      (%i5) desolve([%o1,%o2],[f(x),g(x)]);
                        x
      (%o5) [f(x) = a %e  - a + 1, g(x) =

                                                      x
                                         cos(x) + a %e  - a + g(0) - 1]
      (%i6) [%o1,%o2],%o5,diff;
                   x       x      x                x
      (%o6)   [a %e  = a %e , a %e  - cos(x) = a %e  - cos(x)]

  もし`desolve`が解を得られないなら、 `false`を返します。

  Differential equations ·Laplace transform ·

関数: ic1 (solution, xval, yval)

  一階微分方程式の初期値問題を解きます。 ここで、solutionは、`ode2`が見つけるような、方程式の一般解であり、 xvalは、独立変数の初期値を、形式`x = x0`で与え、 yvalは、従属変数の初期値を、形式`y = y0`で与えます。

  用法の例については`ode2`を参照してください。

  Differential equations ·

関数: ic2 (solution, xval, yval, dval)

  二階微分方程式の初期値を解きます。 ここで、 solutionは、`ode2`が見つけるような、 方程式の一般解のであり、 xvalは、独立変数の初期値を、形式`x = x0`で与え、 yvalは、従属変数の初期値を、形式`y = y0`で与え、 dvalは、従属変数の独立変数に関する一階導関数の初期値を、 形式`diff(y,x) = dy0`で、与えます。 (`diff`はクォートされる必要はありません。)

  用法の例については、`ode2`を参照してください。

  Differential equations ·

関数: ode2 (eqn, dvar, ivar)

  関数`ode2`は、一階または二階常微分方程式(ODE)を解きます。 ３つの引数を取ります: eqnで与えられるODE、従属変数dvar、独立変数ivar。 成功した時、従属変数に関する陽解または陰解を返します。 一階方程式の場合、`%c`が積分定数を表し、 二階方程式の場合、`%k1`と`%k2`が定数を表します。 従属変数の独立変数への依存性は、 `desolve`の場合のように、陽に書かれる必要はありませんが、 独立変数はいつも三番目の引数として与えられなければいけません。

  たとえどんな理由でも、もし`ode2`が解を得られなかったら、 おそらく、エラーメッセージを表示した後、`false`を返します。 一階方程式用に実装された方法は、試される順番に、線形、分離、厳密―おそらく因子の積分を要求します―、斉次、ベルヌーイの等式、一般化斉次法、です。 解ける二階方程式のタイプは、定係数、厳密、定数係数に変換可能な非定数係数線形斉次、 オイラーまたは等次元方程式、パラメータ変動法で解ける方程式、 独立変数または従属変数を含まなくて、順に解かれる２つの一階線形方程式に換算できる方程式、 です。

  ODEを解く間、いくつかの変数が純粋に参考目的で設定されます: `method`は、使われた解法(例えば、`linear`)を示し、 `intfactor`は、任意の使われた積分因子を示し、 `odeindex`は、ベルヌーイ法または一般化斉次法のインデックスを示し、 `yp`は、パラメータ変動手法の特殊解を示します。

  初期値問題(IVP)を解くためには、 一階と二階方程式のためには関数`ic1`と`ic2`が利用可能であり、 二階境界値問題(BVP)を解くためには、 `bc2`を使うことができます。

  例:

      (%i1) x^2*'diff(y,x) + 3*y*x = sin(x)/x;
                            2 dy           sin(x)
      (%o1)                x  -- + 3 x y = ------
                              dx             x
      (%i2) ode2(%,y,x);
                                   %c - cos(x)
      (%o2)                    y = -----------
                                        3
                                       x
      (%i3) ic1(%o2,x=%pi,y=0);
                                    cos(x) + 1
      (%o3)                   y = - ----------
                                         3
                                        x
      (%i4) 'diff(y,x,2) + y*'diff(y,x)^3 = 0;
                               2
                              d y      dy 3
      (%o4)                   --- + y (--)  = 0
                                2      dx
                              dx
      (%i5) ode2(%,y,x);
                            3
                           y  + 6 %k1 y
      (%o5)                ------------ = x + %k2
                                6
      (%i6) ratsimp(ic2(%o5,x=0,y=0,'diff(y,x)=2));

                                   3
                                2 y  - 3 y
      (%o6)                   - ---------- = x
                                    6

      (%i7) bc2(%o5,x=0,y=1,x=1,y=3);
                               3
                              y  - 10 y       3
      (%o7)                   --------- = x - -
                                  6           2

  Differential equations ·

Next: Matrices and Linear Algebra, Previous: Differential Equations, Up: Top [Contents][Index]

## 22 Numerical

Next: Functions and Variables for fast Fourier transform, Previous: Numerical, Up: Numerical [Contents][Index]

### 22.1 Introduction to fast Fourier transform

`fft`パッケージは、高速Fourier変換の（数式計算ではなく）数値計算に関する関数を含みます。

Fourier transform ·Numerical methods ·Share packages ·Package fft ·

Next: Introduction to Fourier series, Previous: Introduction to fast Fourier transform, Up: Numerical [Contents][Index]

### 22.2 Functions and Variables for fast Fourier transform

関数: polartorect (r, t)

  形式`r %e^(%i t)`の複素値を形式`a + b %i`に変換します。 ここで、rは大きさで、tは位相です。 rとtは、同じサイズの１次元配列です。 配列のサイズは2のべき乗である必要はありません。

  関数が戻ると、入力配列の元の値は、実部`a`と虚部`b`に置き換えられます。 出力は、以下のように計算されます。

      a = r cos(t)
      b = r sin(t)

  `polartorect`は、`recttopolar`の逆関数です。

  `load("fft")`はこの関数をロードします。 `fft`も参照してください。

  Package fft ·Complex variables ·

関数: recttopolar (a, b)

  形式`a + b %i`の複素値を形式`r %e^(%i t)`に変換します。 ここで、aは実部で、bは虚部です。 aとbは同じサイズの１次元配列です。 配列のサイズは2のべき乗である必要はありません。

  関数が戻ると、入力配列の元の値は、大きさ`r`と偏角`t`に置き換えられます。 出力は、以下のように計算されます。

      r = sqrt(a^2 + b^2)
      t = atan2(b, a)

  計算された偏角は、`-%pi`から`%pi`の範囲の中にあります。

  `recttopolar`は`polartorect`の逆関数です。

  `load("fft")`はこの関数をロードします。 `fft`も参照してください。

  Package fft ·Complex variables ·

関数: inverse_fft (y)

  複素逆高速Fourier変換を計算します。 yは、変換されるデータを含むリストもしくは配列です。 要素の数は2のべき乗でなければいけません。 要素は、数リテラル（整数、有理数、浮動小数点、多倍長浮動小数点）、シンボル定数、 もしくは、`a`と`b`が数リテラルもしくはシンボル定数である式`a + b*%i` でなければいけません。

  `inverse_fft`は、yと同じタイプの新しいオブジェクトを返します。 yは変更されません。 結果はいつも浮動小数点、もしくは`a`と`b`が浮動小数点であるところの式 `a + b*%i`として計算されます。

  逆離散Fourier変換は、以下のように定義されます。 `x`を逆変換の出力とします。 `j`が0から`n - 1`まで変わる中、

      x[j] = sum(y[k] exp(+2 %i %pi j k / n), k, 0, n - 1)

  `load("fft")`はこの関数をロードします。

  `fft` (正変換), `recttopolar`, `polartorect`も参照してください。

  例:

  実数データ。

      (%i1) load ("fft") $
      (%i2) fpprintprec : 4 $
      (%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $
      (%i4) L1 : inverse_fft (L);
      (%o4) [0.0, 14.49 %i - .8284, 0.0, 2.485 %i + 4.828, 0.0,
                             4.828 - 2.485 %i, 0.0, - 14.49 %i - .8284]
      (%i5) L2 : fft (L1);
      (%o5) [1.0, 2.0 - 2.168L-19 %i, 3.0 - 7.525L-20 %i,
      4.0 - 4.256L-19 %i, - 1.0, 2.168L-19 %i - 2.0,
      7.525L-20 %i - 3.0, 4.256L-19 %i - 4.0]
      (%i6) lmax (abs (L2 - L));
      (%o6)                       3.545L-16

  複素数データ

      (%i1) load ("fft") $
      (%i2) fpprintprec : 4 $
      (%i3) L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $
      (%i4) L1 : inverse_fft (L);
      (%o4) [4.0, 2.711L-19 %i + 4.0, 2.0 %i - 2.0,
      - 2.828 %i - 2.828, 0.0, 5.421L-20 %i + 4.0, - 2.0 %i - 2.0,
      2.828 %i + 2.828]
      (%i5) L2 : fft (L1);
      (%o5) [4.066E-20 %i + 1.0, 1.0 %i + 1.0, 1.0 - 1.0 %i,
      1.55L-19 %i - 1.0, - 4.066E-20 %i - 1.0, 1.0 - 1.0 %i,
      1.0 %i + 1.0, 1.0 - 7.368L-20 %i]
      (%i6) lmax (abs (L2 - L));
      (%o6)                       6.841L-17

  Package fft ·

関数: fft (x)

  複素高速Fourier変換を計算します。 xは、変換されるデータを含むリストもしくは配列です。 要素の数は2のべき乗でなければいけません。 要素は、数リテラル（整数、有理数、浮動小数点、多倍長浮動小数点）、シンボル定数、 もしくは、`a`と`b`が数リテラルもしくはシンボル定数である式`a + b*%i` でなければいけません。

  `fft`は、xと同じタイプの新しいオブジェクトを返します。 xは変更されません。 結果はいつも浮動小数点、もしくは`a`と`b`が浮動小数点であるところの式 `a + b*%i`として計算されます。

  離散Fourier変換は、以下のように定義されます。 `y`を変換の出力とします。 `k`が0から`n - 1`まで変わる中、

      y[k] = (1/n) sum(x[j] exp(-2 %i %pi j k / n), j, 0, n - 1)

  データxが実数の時、 実係数`a`と`b`は以下のように計算することができます。

      x[j] = sum(a[k]*cos(2*%pi*j*k/n)+b[k]*sin(2*%pi*j*k/n), k, 0, n/2)

  ここで、

      a[0] = realpart (y[0])
      b[0] = 0

  そして、`k`が1からn/2 - 1まで変わる中、

      a[k] = realpart (y[k] + y[n - k])
      b[k] = imagpart (y[n - k] - y[k])

  そして、

      a[n/2] = realpart (y[n/2])
      b[n/2] = 0

  `load("fft")`はこの関数をロードします。

  `inverse_fft` (逆変換), `recttopolar`, `polartorect`も参照してください。

  例:

  実数データ。

      (%i1) load ("fft") $
      (%i2) fpprintprec : 4 $
      (%i3) L : [1, 2, 3, 4, -1, -2, -3, -4] $
      (%i4) L1 : fft (L);
      (%o4) [0.0, - 1.811 %i - .1036, 0.0, .6036 - .3107 %i, 0.0,
                               .3107 %i + .6036, 0.0, 1.811 %i - .1036]
      (%i5) L2 : inverse_fft (L1);
      (%o5) [1.0, 2.168L-19 %i + 2.0, 7.525L-20 %i + 3.0,
      4.256L-19 %i + 4.0, - 1.0, - 2.168L-19 %i - 2.0,
      - 7.525L-20 %i - 3.0, - 4.256L-19 %i - 4.0]
      (%i6) lmax (abs (L2 - L));
      (%o6)                       3.545L-16

  複素数データ

      (%i1) load ("fft") $
      (%i2) fpprintprec : 4 $
      (%i3) L : [1, 1 + %i, 1 - %i, -1, -1, 1 - %i, 1 + %i, 1] $
      (%i4) L1 : fft (L);
      (%o4) [0.5, .3536 %i + .3536, - 0.25 %i - 0.25,
      0.5 - 6.776L-21 %i, 0.0, - .3536 %i - .3536, 0.25 %i - 0.25,
      0.5 - 3.388L-20 %i]
      (%i5) L2 : inverse_fft (L1);
      (%o5) [1.0 - 4.066E-20 %i, 1.0 %i + 1.0, 1.0 - 1.0 %i,
      - 1.008L-19 %i - 1.0, 4.066E-20 %i - 1.0, 1.0 - 1.0 %i,
      1.0 %i + 1.0, 1.947L-20 %i + 1.0]
      (%i6) lmax (abs (L2 - L));
      (%o6)                       6.83L-17

  サインとコサイン係数の計算。

      (%i1) load ("fft") $
      (%i2) fpprintprec : 4 $
      (%i3) L : [1, 2, 3, 4, 5, 6, 7, 8] $
      (%i4) n : length (L) $
      (%i5) x : make_array (any, n) $
      (%i6) fillarray (x, L) $
      (%i7) y : fft (x) $
      (%i8) a : make_array (any, n/2 + 1) $
      (%i9) b : make_array (any, n/2 + 1) $
      (%i10) a[0] : realpart (y[0]) $
      (%i11) b[0] : 0 $
      (%i12) for k : 1 thru n/2 - 1 do
         (a[k] : realpart (y[k] + y[n - k]),
          b[k] : imagpart (y[n - k] - y[k]));
      (%o12)                        done
      (%i13) a[n/2] : y[n/2] $
      (%i14) b[n/2] : 0 $
      (%i15) listarray (a);
      (%o15)          [4.5, - 1.0, - 1.0, - 1.0, - 0.5]
      (%i16) listarray (b);
      (%o16)           [0, - 2.414, - 1.0, - .4142, 0]
      (%i17) f(j) := sum (a[k]*cos(2*%pi*j*k/n) + b[k]*sin(2*%pi*j*k/n),
                          k, 0, n/2) $
      (%i18) makelist (float (f (j)), j, 0, n - 1);
      (%o18)      [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]

  Package fft ·

オプション変数: fortindent

  デフォルト値: 0

  `fortindent`は、`fortran`コマンドが表示する式の 式の左マージンインデントを制御します。 0は、標準のプリントアウト(すなわち6スペース)を与え、 正の値は、式を更に右に印字するようにします。

  Translation and compilation ·

関数: fortran (expr)

  Fortran文としてexprを印字します。 出力行は、スペースでインデントされます。 もし行が長過ぎるなら、 `fortran`は継続行を印字します。 `fortran`は、指数演算子`^`を`**`として印字し、 複素数`a + b %i`を形式`(a,b)`で印字します。

  exprは等式も取り、もしそうなら、`fortran`は、 等式の右辺を左辺に割り当てる割り当て文を印字します。 特に、もしexprの右辺が行列名なら、 `fortran`は、行列の要素それぞれに対する割り当て文を印字します。

  もしexprが`fortran`が認識する何かでないなら、 エラーなしに、式が`grind`フォーマットで印字されます。 `fortran`は、リスト、配列、関数について知りません。

  `fortindent`は、`fortran`コマンドが表示する式の 式の左マージンインデントを制御します。 0は、標準のプリントアウト(すなわち6スペース)を与え、 正の値は、式を更に右に印字するようにします。

  `fortspaces`が`true`の時、 `fortran`は、印字行それぞれを80カラムまでスペースで埋めます。

  `fortran`は引数を評価します; 引数のクォートは評価を無効にします。 `fortran`はいつも`done`を返します。

  例:

      (%i1) expr: (a + b)^12$
      (%i2) fortran (expr);
            (b+a)**12
      (%o2)                         done
      (%i3) fortran ('x=expr);
            x = (b+a)**12
      (%o3)                         done
      (%i4) fortran ('x=expand (expr));
            x = b**12+12*a*b**11+66*a**2*b**10+220*a**3*b**9+495*a**4*b**8+792
           1   *a**5*b**7+924*a**6*b**6+792*a**7*b**5+495*a**8*b**4+220*a**9*b
           2   **3+66*a**10*b**2+12*a**11*b+a**12
      (%o4)                         done
      (%i5) fortran ('x=7+5*%i);
            x = (7,5)
      (%o5)                         done
      (%i6) fortran ('x=[1,2,3,4]);
            x = [1,2,3,4]
      (%o6)                         done
      (%i7) f(x) := x^2$
      (%i8) fortran (f);
            f
      (%o8)                         done

  Translation and compilation ·

オプション変数: fortspaces

  デフォルト値: `false`

  `fortspaces`が`true`の時、 `fortran`は、印字行それぞれを80カラムまでスペースで埋めます。

  Translation and compilation ·

関数: horner (expr, x)
関数: horner (expr)

  Horner規則に従って、もし指定されないならxを主変数として使い、 exprの再配列された表現を返します。 `x`は、exprの標準有理式形の主変数が使われる場合には、省略できます。

  もし`expr`が数値的に評価されるものなら、 `horner`は、時々、安定性が改善されます。 また、もしMaximaがFortranで走らせるプログラムを生成するのに使われるなら、 役に立ちます。 `stringout`も参照してください。

      (%i1) expr: 1e-155*x^2 - 5.5*x + 5.2e155;
                                 2
      (%o1)            1.0E-155 x  - 5.5 x + 5.2E+155
      (%i2) expr2: horner (%, x), keepfloat: true;
      (%o2)            (1.0E-155 x - 5.5) x + 5.2E+155
      (%i3) ev (expr, x=1e155);
      Maxima encountered a Lisp error:

       floating point overflow

      Automatically continuing.
      To reenable the Lisp debugger set *debugger-hook* to nil.
      (%i4) ev (expr2, x=1e155);
      (%o4)                       7.0E+154

  Numerical methods ·

関数: find_root (expr, x, a, b, [abserr, relerr])
関数: find_root (f, a, b, [abserr, relerr])
関数: bf_find_root (expr, x, a, b, [abserr, relerr])
関数: bf_find_root (f, a, b, [abserr, relerr])
オプション変数: find_root_error
オプション変数: find_root_abs
オプション変数: find_root_rel

  式exprもしくは関数fの根を、閉区間[a, b]上で見つけます。 式exprは等式でも問題ありません。 その場合、`find_root`は`lhs(expr) - rhs(expr)`の根を探します。

  Maximaはexprもしくはfを[a, b]上で評価可能であり、 exprもしくはfは連続と仮定して、`find_root`は根もしくは、 もし複数の根があるなら、根の１つを見つけることを保証します。

  `find_root`は初め、２分木探索を適用します。 もし対象の関数が十分滑らかなら，`find_root`は代わりに線形内挿を適用します。

  `f_find_root`は`find_root`の多倍長浮動小数点版です。 関数は多倍長浮動小数点数値を使って計算され、多倍長浮動小数点の結果が返されます。 そうでなければ、`bf_find_root`は`find_root`と同一で、以下の記述は`bf_find_root`に同様に適用されます。

  `find_root`の精度は`abserr`と`relerr`に支配されます。 それらは`fine_root`へのオプションのキーワード引数です。 これらのキーワード引数は形式`key=val`を取ります。 キーワード引数は

  `abserr`

    根での関数値の望まれる絶対エラー。デフォルトは、`find_root_abs`です。

  `relerr`

    根の望まれる相対エラー。デフォルトは`find_root_rel`です。

  懸案の関数が`abserr`以下の何かに評価される時、または、 近似値x_0, x_1の差が`relerr * max(abs(x_0), abs(x_1))`以下になるなら、`find_root`は停止します。

  `find_root_abs`と`find_root_rel`のデフォルト値はともに零です。

  `find_root`は、探索区間の端で対象の関数が異なる符号を持つことを期待します。 関数が両方の終端での数に評価されて、それらの数が同じ符号を持つ時、 `find_root`の振る舞いは、`find_root_error`に支配されます。 `find_root_error`が`true`の時、 `find_root`はエラーメッセージを出力します。 そうでなければ、`find_root`は`find_root_error`の値を返します。 `find_root_error`のデフォルト値は`true`です。

  もしfが探索アルゴリズムの中の任意のステップで、数以外の何かに評価するなら、 `find_root`は、部分的に評価された`find_root`式を返します。 aとbの順序は無視されます; 根が探索される区間は[min(a, b), max(a, b)]です。

  例:

      (%i1) f(x) := sin(x) - x/2;
                                              x
      (%o1)                  f(x) := sin(x) - -
                                              2
      (%i2) find_root (sin(x) - x/2, x, 0.1, %pi);
      (%o2)                   1.895494267033981
      (%i3) find_root (sin(x) = x/2, x, 0.1, %pi);
      (%o3)                   1.895494267033981
      (%i4) find_root (f(x), x, 0.1, %pi);
      (%o4)                   1.895494267033981
      (%i5) find_root (f, 0.1, %pi);
      (%o5)                   1.895494267033981
      (%i6) find_root (exp(x) = y, x, 0, 100);
                                  x
      (%o6)           find_root(%e  = y, x, 0.0, 100.0)
      (%i7) find_root (exp(x) = y, x, 0, 100), y = 10;
      (%o7)                   2.302585092994046
      (%i8) log (10.0);
      (%o8)                   2.302585092994046
      (%i9) fpprec:32;
      (%o9)                           32
      (%i10) bf_find_root (exp(x) = y, x, 0, 100), y = 10;
      (%o10)                  2.3025850929940456840179914546844b0
      (%i11) log(10b0);
      (%o11)                  2.3025850929940456840179914546844b0

  Algebraic equations ·Numerical methods ·

関数: newton (expr, x, x_0, eps)

  exprをxの１変数関数と考えて、 Newton法による、`expr = 0`の近似解を返します。 探索は、`x = x_0`で始まり、 (xの現在値で評価されたexprを使った)`abs(expr) < eps`が成り立つまで続きます。

  終了テスト`abs(expr) < eps`が`true`または`false`に評価される限り、 `newton`は、未定義変数がexprの中に現れることを許します。

  このように、 exprは数に評価される必要はありません。

  `load("newton1")`はこの関数をロードします。

  `realroots`, `allroots`, `find_root`, `mnewton`も参照してください。

  例:

      (%i1) load ("newton1");
      (%o1) /usr/share/maxima/5.10.0cvs/share/numeric/newton1.mac
      (%i2) newton (cos (u), u, 1, 1/100);
      (%o2)                   1.570675277161251
      (%i3) ev (cos (u), u = %);
      (%o3)                 1.2104963335033528E-4
      (%i4) assume (a > 0);
      (%o4)                        [a > 0]
      (%i5) newton (x^2 - a^2, x, a/2, a^2/100);
      (%o5)                  1.00030487804878 a
      (%i6) ev (x^2 - a^2, x = %);
                                                 2
      (%o6)                6.098490481853958E-4 a

  Algebraic equations ·Numerical methods ·

Next: Functions and Variables for Fourier series, Previous: Functions and Variables for fast Fourier transform, Up: Numerical [Contents][Index]

### 22.3 Introduction to Fourier series

`fourie`パッケージは、Fourier級数のシンボル計算のための関数を含みます。

`fourie`パッケージの中には Fourier積分係数を計算する関数や、式の操作のためのいくつかの関数があります。

Fourier transform ·Share packages ·Package fourie ·

Previous: Introduction to Fourier series, Up: Numerical [Contents][Index]

### 22.4 Functions and Variables for Fourier series

関数: equalp (x, y)

  もし`equal (x, y)`なら、`true`を返し、 そうでないなら、`false`を返します。 (この場合、`equal (x, y)`がするようなエラーメッセージを与えません。)

  Package fourie ·

関数: remfun (f, expr)
関数: remfun (f, expr, x)

  `remfun (f, expr)`は、 exprの中の`f (arg)`すべてをargで置き換えます。

  `remfun (f, expr, x)`は、 exprの中の`f (arg)`を argが変数xを含むときだけ argで置き換えます。

  Package fourie ·

関数: funp (f, expr)
関数: funp (f, expr, x)

  `funp (f, expr)`は、 もしexprが関数fを含むなら `true`を返します。

  `funp (f, expr, x)`は、 もしexprが関数fを含み、変数 xがfのインスタンスの１つの引数のどこかにあるなら、 `true`を返します。

  Package fourie ·

関数: absint (f, x, halfplane)
関数: absint (f, x)
関数: absint (f, x, a, b)

  `absint (f, x, halfplane)`は、 与えられた半平面(`pos`, `neg`, または`both`)での fのxに関する不定積分を返します。 fは、形式 `abs (x)`, `abs (sin (x))`, `abs (a) * exp (-abs (b) * abs (x))` の式を含むことができます。

  `absint (f, x)`は`absint (f, x, pos)`と同値です。

  `absint (f, x, a, b)`は、 fの xに関する aからbまでの定積分 を返します。

  fは、絶対値を含むことができます。

  Package fourie ·Integral calculus ·

関数: fourier (f, x, p)

  区間`[-p, p]`上で定義された`f(x)`のFourier係数のリストを返します。

  Package fourie ·

関数: foursimp (l)

  もし`sinnpiflag`が`true`なら、`sin (n %pi)`を0に整理します。 もし`cosnpiflag`が`true`なら、`cos (n %pi)`を`(-1)^n`に整理します。

  Package fourie ·Trigonometric functions ·Simplification functions ·

オプション変数: sinnpiflag

  デフォルト値: `true`

  `foursimp`を参照してください。

  Package fourie ·

オプション変数: cosnpiflag

  デフォルト値: `true`

  `foursimp`を参照してください。

  Package fourie ·

関数: fourexpand (l, x, p, limit)

  Fourier係数lのリストから limit項までのFourier級数を構成し、返します。 (limitは`inf`もあり得ます。) xとpは、`fourier`におけるものと同じ意味を持ちます。

  Package fourie ·

関数: fourcos (f, x, p)

  `[0, p]`上で定義された `f(x)`のFourierコサイン係数を返します。

  Package fourie ·

関数: foursin (f, x, p)

  `[0, p]`上で定義された `f(x)`のFourierサイン係数を返します。

  Package fourie ·

関数: totalfourier (f, x, p)

  `fourexpand (foursimp (fourier (f, x, p)), x, p, 'inf)`を返します。

  Package fourie ·

関数: fourint (f, x)

  `[minf, inf]`上で定義された `f(x)`のFourier積分係数のリストを構成し、返します。

  Package fourie ·

関数: fourintcos (f, x)

  `[0, inf]`上の`f(x)`のFourierコサイン積分係数を返します。

  Package fourie ·

関数: fourintsin (f, x)

  `[0, inf]`上の`f(x)`のFourierサイン積分係数を返します。

  Package fourie ·

Next: Affine, Previous: Numerical, Up: Top [Contents][Index]

## 23 Matrices and Linear Algebra

Next: Functions and Variables for Matrices and Linear Algebra, Previous: Matrices and Linear Algebra, Up: Matrices and Linear Algebra [Contents][Index]

### 23.1 Introduction to Matrices and Linear Algebra

Next: Vectors, Previous: Introduction to Matrices and Linear Algebra, Up: Introduction to Matrices and Linear Algebra [Contents][Index]

#### 23.1.1 Dot

演算子`.`は、非可換乗算とスカラー積を表します。 オペランドが、1列行列または1行行列`a`と`b`の時、 式`a.b`は、`sum (a[i]*b[i], i, 1, length(a))`と同値です。 もし`a`と`b`が複素数でないなら、これはスカラー積であり、 `a`と`b`の内積すなわちドット積もコールされます。 `a`と`b`が複素数の時、スカラー積は `conjugate(a).b`として定義されます; `eigen`パッケージの`innerproduct`は、複素スカラー積を供給します。

オペランドがもっと一般的な行列の時、 積は、`a`と`b`の行列積です。

`b`の行数は、`a`の列数と等しくなければいけなく、 結果は、`a`の行数と等しい行数と `b`の列数と等しい列数を持ちます。

`.`を算術演算子として 浮動小数点数の小数点と区別するために、 どちらかの側にスペースを残す必要があるかもしれません。 例えば、`5.e3`は`5000.0`ですが、`5 . e3`は`5`掛ける`e3`です。

`.`を含む式の整理を支配する いくつかのフラグがあります。 すなわち、`dot0nscsimp`, `dot0simp`, `dot1simp`, `dotassoc`, `dotconstrules`, `dotdistrib`, `dotexptsimp`, `dotident`, `dotscrules`。

Next: eigen, Previous: Dot, Up: Introduction to Matrices and Linear Algebra [Contents][Index]

#### 23.1.2 Vectors

`vect`は、ベクトル解析のための関数のパッケージです。 `load ("vect")`は、このパッケージをロードし、 `demo ("vect")`は、デモンストレーションを表示します。

ベクトル解析パッケージは、 グラディエント、ダイバージェンス、カール、ラプラシアン演算子と一緒に、 ドット積やクロス積を含むシンボリックな式を結合したり整理したりすることができます。 これらの演算子の和や積上の分配は、 任意の特定の直交座標系の成分への展開を含む、様々な他の展開と同様に、 いくつかのフラグで決定されます。 場のスカラーポテンシャルやベクトルポテンシャルを演繹するための関数もあります。

The `vect`パッケージは以下の関数を含みます: `vectorsimp`, `scalefactors`, `express`, `potential`, `vectorpotential`.

デフォルトでは、`vect`パッケージはドット演算子`.`を可換演算子とは宣言しません。 可換ドット演算子`.`を得るには、コマンド`declare(".", commutative)`を実行しなければいけません。

Vectors ·Share packages ·Package vect ·

Previous: Vectors, Up: Introduction to Matrices and Linear Algebra [Contents][Index]

#### 23.1.3 eigen

パッケージ`eigen`は、 固有値や固有ベクトルのシンボリックな計算に充てられた いくつかの関数を含みます。 もし`eigenvalues`または`eigenvectors`の１つが呼び出されたなら、 Maximaは、パッケージを自動的にロードします。 パッケージは`load ("eigen")`として陽にロードすることもできます。

`demo ("eigen")`は、このパッケージの能力のデモンストレーションを表示します。 `batch ("eigen")`は、 連続する計算の間のユーザープロンプトなしに、 同じデモンストレーションを実行します。

`eigen`パッケージの関数は、 `innerproduct`, `unitvector`, `columnvector`, `gramschmidt`, `eigenvalues`, `eigenvectors`, `uniteigenvectors`, `similaritytransform`です。

Vectors ·Matrices ·Share packages ·Package eigen ·

Previous: Introduction to Matrices and Linear Algebra, Up: Matrices and Linear Algebra [Contents][Index]

### 23.2 Functions and Variables for Matrices and Linear Algebra

関数: addcol (M, list_1, ..., list_n)

  １つまたは複数のリスト(または行列)が与える列を 行列Mに追加します。

  Matrices ·

関数: addrow (M, list_1, ..., list_n)

  １つまたは複数のリスト(または行列)が与える行を 行列Mに追加します。

  Matrices ·

関数: adjoint (M)

  行列Mの余因子行列を返します。 余因子行列は、Mの余因子の行列の転置です。

  Matrices ·

関数: augcoefmatrix ([eqn_1, …, eqn_m], [x_1, …, x_n])

  線形方程式系eqn_1, …, eqn_mの 変数x_1, …, x_nに関する拡大係数行列を返します。 これは、 それぞれの方程式の定数項(x_1, …, x_nに依存しないそれらの項) に関して隣接した列を持つ係数行列です。

      (%i1) m: [2*x - (a - 1)*y = 5*b, c + b*y + a*x = 0]$
      (%i2) augcoefmatrix (m, [x, y]);
                             [ 2  1 - a  - 5 b ]
      (%o2)                  [                 ]
                             [ a    b      c   ]

  Linear equations ·Matrices ·

関数: cauchy_matrix ([x_1,x_2, …, x_m], [y_1,y_2, …, y_n])
関数: cauchy_matrix ([x_1,x_2, …, x_n])

  要素a[i,j] = 1/(x_i+y_i)を持つ、 `n`掛けるmのCauchy行列を返します。 `cauchy_matrix`の第二引数はオプションです。 この場合、Cauchy行列の要素はa[i,j] = 1/(x_i+x_j)です。

  注意: 文献によると、Cauchy行列は2つの形式で定義されたものが見られます。 2つ目の定義はa[i,j] = 1/(x_i-y_i)です。

  例:

      (%i1) cauchy_matrix([x1,x2],[y1,y2]);

                            [    1        1    ]
                            [ -------  ------- ]
                            [ y1 + x1  y2 + x1 ]
      (%o1)                 [                  ]
                            [    1        1    ]
                            [ -------  ------- ]
                            [ y1 + x2  y2 + x2 ]

      (%i2) cauchy_matrix([x1,x2]);
                            [   1         1    ]
                            [  ----    ------- ]
                            [  2 x1    x2 + x1 ]
      (%o2)                 [                  ]
                            [    1       1     ]
                            [ -------   ----   ]
                            [ x2 + x1   2 x2   ]

  Matrices ·

関数: charpoly (M, x)

  行列Mの変数xに関する特性多項式を返します。 すなわち、 `determinant (M - diagmatrix (length (M), x))`です。

      (%i1) a: matrix ([3, 1], [2, 4]);
                                  [ 3  1 ]
      (%o1)                       [      ]
                                  [ 2  4 ]
      (%i2) expand (charpoly (a, lambda));
                                 2
      (%o2)                lambda  - 7 lambda + 10
      (%i3) (programmode: true, solve (%));
      (%o3)               [lambda = 5, lambda = 2]
      (%i4) matrix ([x1], [x2]);
                                   [ x1 ]
      (%o4)                        [    ]
                                   [ x2 ]
      (%i5) ev (a . % - lambda*%, %th(2)[1]);
                                [ x2 - 2 x1 ]
      (%o5)                     [           ]
                                [ 2 x1 - x2 ]
      (%i6) %[1, 1] = 0;
      (%o6)                     x2 - 2 x1 = 0
      (%i7) x2^2 + x1^2 = 1;
                                  2     2
      (%o7)                     x2  + x1  = 1
      (%i8) solve ([%th(2), %], [x1, x2]);

                        1               2
      (%o8) [[x1 = - -------, x2 = - -------],
                     sqrt(5)         sqrt(5)

                                                   1             2
                                          [x1 = -------, x2 = -------]]
                                                sqrt(5)       sqrt(5)

  Matrices ·

関数: coefmatrix ([eqn_1, …, eqn_m], [x_1, …, x_n])

  線形方程式系eqn_1, …, eqn_mの 変数x_1, …, x_nに関する係数行列を返します。

      (%i1) coefmatrix([2*x-(a-1)*y+5*b = 0, b*y+a*x = 3], [x,y]);
                                       [ 2  1 - a ]
      (%o1)                            [          ]
                                       [ a    b   ]

  Linear equations ·Matrices ·

関数: col (M, i)

  行列Mのi番目の列を返します。 戻り値は行列です。

  Matrices ·

関数: columnvector (L)
関数: covect (L)

  リストLの要素を含む１列`length (L)`行の行列を返します。

  `covect`は、`columnvector`と同義です。

  `load ("eigen")`はこの関数をロードします。

  もしこのパッケージの関数の出力の一部を行列計算で使いたいなら、これは役に立ちます。

  例:

      (%i1) load ("eigen")$
      Warning - you are redefining the Macsyma function eigenvalues
      Warning - you are redefining the Macsyma function eigenvectors
      (%i2) columnvector ([aa, bb, cc, dd]);
                                   [ aa ]
                                   [    ]
                                   [ bb ]
      (%o2)                        [    ]
                                   [ cc ]
                                   [    ]
                                   [ dd ]

  Matrices ·

関数: copymatrix (M)

  行列Mのコピーを返します。 これは、Mを要素毎にコピーすることは別にして、コピーを作る唯一の方法です。

  `m2: m1`のように、１つの行列のもう１つへの割り当ては`m1`をコピーしない ことに注意してください。 An assignment 割り当て`m2 [i,j]: x`または`setelmx (x, i, j, m2`は、 `m1 [i,j]`も変更します。 Creating a copy with `copymatrix`を使ってコピーを生成し、割り当てを使うことは、 別個の変更されたコピーを生成します。

  Matrices ·

関数: determinant (M)

  Mの行列式をガウスの消去法と似た方法で計算します。

  結果の形式は、スイッチ`ratmx`の設定に依ります。

  スイッチ`ratmx`と`sparse`がともに`true`の時コールされる 粗な行列式を計算するための特殊なルーチンがあります。

  Matrices ·

オプション変数: detout

  デフォルト値: `false`

  `detout`が`true`の時、 逆行列が計算された行列の行列式は、逆行列から因子として外に出されます。

  このスイッチが効果を持つには、 `doallmxops`と`doscmxops`は、`false`でなければいけません。 (それらの記述を参照してください。) `ev`は他の２つを正しく設定するので、 代わりに、このスイッチを`ev`に与えるという方法もあります。

  例:

      (%i1) m: matrix ([a, b], [c, d]);
                                  [ a  b ]
      (%o1)                       [      ]
                                  [ c  d ]
      (%i2) detout: true$
      (%i3) doallmxops: false$
      (%i4) doscmxops: false$
      (%i5) invert (m);
                                [  d   - b ]
                                [          ]
                                [ - c   a  ]
      (%o5)                     ------------
                                 a d - b c

  Matrices ·Evaluation flags ·

関数: diagmatrix (n, x)

  対角要素すべてがxに等しい、 サイズがn掛けるnの対角線行列を返します。 `diagmatrix (n, 1)`は、 (`ident (n)`と同じように)単位行列を返します。

  nは、整数に評価されなければいけなく、そうでなければ、 `diagmatrix`はエラーメッセージを出力します。

  xは、別の行列を含む、任意の種類の式を取り得ます もしxが行列なら、それはコピーされません; 対角要素すべては、同じインスタンスxを参照します。

  Matrices ·

オプション変数: doallmxops

  デフォルト値: `true`

  `doallmxops`が`true`の時、 行列に関係する演算すべてが実行されます。 `false`の時、 then the setting of the 個々の`dot`スイッチの設定が、どの演算を実行するか決めます。

  Matrices ·

オプション変数: domxexpt

  デフォルト値: `true`

  `domxexpt`が`true`の時、 行列の指数関数, `exp (M)` ただしMは行列, は、要素`[i,j`が`exp (m[i,j])`に等しい行列として解釈されます。

  そうでなければ、`exp (M)`は、`exp (ev(M)`に評価されます。

  `domxexpt`は、 形式`base^power`の式すべてに影響します。 ここで、baseはスカラーまたは定数と仮定された式、 powerは、リストまたは行列です。

  例:

      (%i1) m: matrix ([1, %i], [a+b, %pi]);
                               [   1    %i  ]
      (%o1)                    [            ]
                               [ b + a  %pi ]
      (%i2) domxexpt: false$
      (%i3) (1 - c)^m;
                                   [   1    %i  ]
                                   [            ]
                                   [ b + a  %pi ]
      (%o3)                 (1 - c)
      (%i4) domxexpt: true$
      (%i5) (1 - c)^m;
                        [                      %i  ]
                        [    1 - c      (1 - c)    ]
      (%o5)             [                          ]
                        [        b + a         %pi ]
                        [ (1 - c)       (1 - c)    ]

  Matrices ·

オプション変数: domxmxops

  デフォルト値: `true`

  `domxmxops`が`true`の時、 行列-行列演算、行列-リスト演算すべてが実行されます (しかし、スカラー-行列演算は実行されません); もしこのスイッチが`false`なら、 演算は実行されません。

  Matrices ·

オプション変数: domxnctimes

  デフォルト値: `false`

  `domxnctimes`が`true`の時、 行列の非可換積が実行されます。

  Matrices ·

オプション変数: dontfactor

  デフォルト値: `[]`

  ある変数に関する因数分解が起こらないよう、 `dontfactor`をその変数のリストに設定することができます。 (リストは初期には空です。) 標準有理式(CRE)形で仮定される変数順序に従って、 `dontfactor`リスト上のそれらよりも重要でない変数に関しても 因数分解は、 行われなくなります。

  Expressions ·

オプション変数: doscmxops

  デフォルト値: `false`

  `doscmxops`が`true`の時、 スカラー-行列演算が実行されます。

  Matrices ·

オプション変数: doscmxplus

  デフォルト値: `false`

  `doscmxplus`が`true`の時、 スカラー-行列演算は、行列の結果をもたらします。 このスイッチは、`doallmxops`の下に包括されません。

  Matrices ·

オプション変数: dot0nscsimp

  デフォルト値: `true`

  `dot0nscsimp`が`true`の時、 ゼロと非スカラー項の非可換積は、可換積に整理されます。

  Simplification flags and variables ·

オプション変数: dot0simp

  デフォルト値: `true`

  `dot0simp`が`true`の時、 ゼロとスカラー項の非可換積は、 可換積に整理されます。

  Simplification flags and variables ·

オプション変数: dot1simp

  デフォルト値: `true`

  `dot1simp`が`true`の時、 １ともう１つの項の非可換積は、可換積に整理されます。

  Simplification flags and variables ·

オプション変数: dotassoc

  デフォルト値: `true`

  `dotassoc`が`true`の時、 式`(A.B).C`は`A.(B.C)`に整理されます。

  Simplification flags and variables ·

オプション変数: dotconstrules

  デフォルト値: `true`

  `dotconstrules`が`true`の時、 定数ともう１つの項の非可換積は、可換積に整理されます。 このフラグをオンにすることは、事実上、 `dot1simp`はもちろん、`dot0simp`, `dot0nscsimp`もオンにします。

  Simplification flags and variables ·

オプション変数: dotdistrib

  デフォルト値: `false`

  `dotdistrib`が`true`の時、 式`A.(B + C)`は`A.B + A.C`に整理されます。

  Simplification flags and variables ·

オプション変数: dotexptsimp

  デフォルト値: `true`

  `dotexptsimp`が`true`の時、 式`A.A`は`A^^2`に整理されます。

  Simplification flags and variables ·

オプション変数: dotident

  デフォルト値: 1

  `dotident`は`X^^0`が返す値です。

  Simplification flags and variables ·

オプション変数: dotscrules

  デフォルト値: `false`

  `dotscrules`が`true`の時、 式`A.SC`または`SC.A`は、`SC*A`に整理され、 `A.(SC*B)`は`SC*(A.B)`に整理されます。

  Simplification flags and variables ·

関数: echelon (M)

  ガウスの消去法で生成される、行列Mの階段形を返します。 階段形は、Mから初等行演算によって計算され、 それぞれの行の最初の非ゼロ要素が１で、 その要素の下の列要素がすべてゼロであるような行列です。

  `triangularize`もガウスの消去法を実行しますが、 それぞれの行の先頭の非ゼロ要素を規格化しません。

  `lu_factor`と`cholesky`は、他の、三角行列をもたらす関数です。

      (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
                             [  3   7  aa  bb ]
                             [                ]
      (%o1)                  [ - 1  8  5   2  ]
                             [                ]
                             [  9   2  11  4  ]
      (%i2) echelon (M);
                        [ 1  - 8  - 5      - 2     ]
                        [                          ]
                        [         28       11      ]
                        [ 0   1   --       --      ]
      (%o2)             [         37       37      ]
                        [                          ]
                        [              37 bb - 119 ]
                        [ 0   0    1   ----------- ]
                        [              37 aa - 313 ]

  Linear equations ·Matrices ·

関数: eigenvalues (M)
関数: eivals (M)

  行列Mの固有値を含む２つのリストのリストを返します。 戻り値の最初の部分リストは、行列の固有値のリストで、 二番目の部分リストは、対応する順序で固有値の重複度のリストです。

  `eivals`は、`eigenvalues`と同義です。

  `eigenvalues`は、 行列の特性多項式の根を見つけるために、 関数`solve`をコールします。 時々、 `solve`は、多項式の根を見つけられないかもしれません; その場合、このパッケージの (`innerproduct`, `unitvector`, `columnvector`, `gramschmidt`を除いた)いくつかの他の関数はうまく動かないでしょう。

  いくつかの場合、`solve`が見つける固有値は、 複雑な式かもしれません。 (これは、 `solve`が 実数とわかっている固有値について 見てもすぐにはわからない実数式を返す時、起こることがあります。) 他のいくつかの関数を使って固有値を整理することが可能なことがあります。

  パッケージ`eigen.mac`は、 `eigenvalues`や`eigenvectors`が参照された時、 自動的にロードされます。 もし`eigen.mac`がまだロードされていないなら、 `load ("eigen")`はそれをロードします。 ロードした後は、パッケージの中の関数と変数すべてが利用可能です。

  Package eigen ·

関数: eigenvectors (M)
関数: eivects (M)

  行列Mの固有ベクトルを計算します。 戻り値は、２つの要素のリストです。 最初のものは、Mの固有値のリストと固有値の重複度のリストです。 二番目のものは、固有ベクトルのリストのリストです。 固有値それぞれに対して固有ベクトルのリストが１つあります。 リストそれぞれの中には、固有ベクトルが１つの時も複数のときもあります。

  `eivects`は、`eigenvectors`と同義です。

  パッケージ`eigen.mac`は、 `eigenvalues`や`eigenvectors`が参照された時、 自動的にロードされます。 もし`eigen.mac`がまだロードされていないなら、 `load ("eigen")`はそれをロードします。 ロードした後は、パッケージの中の関数と変数すべてが利用可能です。

  この関数に影響するフラグは以下の通りです:

  `nondiagonalizable`は、 `eigenvectors`が戻った後、行列が対角化不可能か可能かに依って `true`か`false`に設定されます。

  `hermitianmatrix`が`true`の時、 エルミート行列の縮退した固有ベクトルが、グラム-シュミットアルゴリズムを使って直交化されるようにします。

  `knowneigvals`が`true`の時、 causes the `eigen`パッケージが、 行列の固有値がユーザーに知られていて、グローバル名`listeigvals`の下記憶されていることを仮定するようにします。 `listeigvals`は、 出力`eigenvalues`に似たリストに設定されなければいけません。

  ここで、関数`algsys`が固有ベクトルについて解くために使われます。 もし固有値がごちゃごちゃしているなら、 `algsys`は、時々、解を見つけられないかもしれません。 いくつかの場合、 最初に`eigenvalues`コマンドを使って固有値を見つけ、 それらをもっと簡潔な何かに換算するために他の関数を使うことによって、 固有値を整理することが可能かもしれません。 整理に続いて、 `true`に設定された`knowneigvals`フラグとともに 再び`eigenvectors`をコールすることができます。

  `eigenvalues`も参照してください。

  例:

  固有値１つにただ１つの固有ベクトルを持つ行列。

      (%i1) M1 : matrix ([11, -1], [1, 7]);
                                 [ 11  - 1 ]
      (%o1)                      [         ]
                                 [ 1    7  ]
      (%i2) [vals, vecs] : eigenvectors (M1);
      (%o2) [[[9 - sqrt(3), sqrt(3) + 9], [1, 1]],
                              [[[1, sqrt(3) + 2]], [[1, 2 - sqrt(3)]]]]
      (%i3) for i thru length (vals[1]) do disp (val[i] = vals[1][i],
        mult[i] = vals[2][i], vec[i] = vecs[i]);
                             val  = 9 - sqrt(3)
                                1

                                  mult  = 1
                                      1

                          vec  = [[1, sqrt(3) + 2]]
                             1

                             val  = sqrt(3) + 9
                                2

                                  mult  = 1
                                      2

                          vec  = [[1, 2 - sqrt(3)]]
                             2

      (%o3)                         done

  １つの固有値(ここでは2)に２つの固有ベクトルを持つ行列。

      (%i1) M1 : matrix ([0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0],
                         [0, 0, 0, 2]);
                               [ 0  1  0  0 ]
                               [            ]
                               [ 0  0  0  0 ]
      (%o1)                    [            ]
                               [ 0  0  2  0 ]
                               [            ]
                               [ 0  0  0  2 ]
      (%i2) [vals, vecs] : eigenvectors (M1);
      (%o2) [[[0, 2], [2, 2]], [[[1, 0, 0, 0]],
                                         [[0, 0, 1, 0], [0, 0, 0, 1]]]]
      (%i3) for i thru length (vals[1]) do disp (val[i] = vals[1][i],
        mult[i] = vals[2][i], vec[i] = vecs[i]);
                                  val  = 0
                                     1

                                  mult  = 2
                                      1

                            vec  = [[1, 0, 0, 0]]
                               1

                                  val  = 2
                                     2

                                  mult  = 2
                                      2

                     vec  = [[0, 0, 1, 0], [0, 0, 0, 1]]
                        2

      (%o3)                         done

  Package eigen ·

関数: ematrix (m, n, x, i, j)

  値がxの`[i, j]`要素を除いて、すべての要素がゼロの m行n列行列を返します。

  Matrices ·

関数: entermatrix (m, n)

  対話的に要素を読み、m行n列行列を返します。

  もしnがmと等しいなら、 Maximaは、行列のタイプ(対角、対称、反対称、一般)の入力を促し、 それぞれの要素の入力を促します。 応答それぞれは、セミコロン`;`かドル記号`$`で終了させます。

  もしnがmと等しくなければ、 Maximaは、それぞれの要素の入力を促します。

  要素は、任意の式を取り得、また、その式は評価されます。 `entermatrix`は引数を評価します。

      (%i1) n: 3$
      (%i2) m: entermatrix (n, n)$

      Is the matrix  1. Diagonal  2. Symmetric  3. Antisymmetric
      4. General
      Answer 1, 2, 3 or 4 :
      1$
      Row 1 Column 1:
      (a+b)^n$
      Row 2 Column 2:
      (a+b)^(n+1)$
      Row 3 Column 3:
      (a+b)^(n+2)$

      Matrix entered.
      (%i3) m;
                      [        3                     ]
                      [ (b + a)      0         0     ]
                      [                              ]
      (%o3)           [                  4           ]
                      [    0      (b + a)      0     ]
                      [                              ]
                      [                            5 ]
                      [    0         0      (b + a)  ]

  Console interaction ·Matrices ·

関数: genmatrix (a, i_2, j_2, i_1, j_1)
関数: genmatrix (a, i_2, j_2, i_1)
関数: genmatrix (a, i_2, j_2)

  aから生成される行列を返します。 返される行列は、要素`a[i_1,j_1]`を 左上の要素として取り、 `a[i_2,j_2]`を 右下の要素として取ります。 ここで、aは、 (`make_array`ではなく`array`が生成する)宣言配列か、 未宣言配列か、配列関数か、２つの引数を持つラムダ式のいずれかです。 (配列関数は、他の関数のように、`:=`や`define`で生成されますが、 引数は括弧の代わりにカギ括弧でくくられます。)

  もしj_1が省略されたら、 それは、i_1と等しいと仮定されます。 もしj_1とi_1両方が省略されたら、 両方とも1と等しいと仮定されます。

  もし配列の選択された要素`i,j`が未定義なら、 行列は、シンボル要素`a[i,j]`を含みます。

  例:

      (%i1) h [i, j] := 1 / (i + j - 1);
                                          1
      (%o1)                  h     := ---------
                              i, j    i + j - 1
      (%i2) genmatrix (h, 3, 3);
                                 [    1  1 ]
                                 [ 1  -  - ]
                                 [    2  3 ]
                                 [         ]
                                 [ 1  1  1 ]
      (%o2)                      [ -  -  - ]
                                 [ 2  3  4 ]
                                 [         ]
                                 [ 1  1  1 ]
                                 [ -  -  - ]
                                 [ 3  4  5 ]
      (%i3) array (a, fixnum, 2, 2);
      (%o3)                           a
      (%i4) a [1, 1] : %e;
      (%o4)                          %e
      (%i5) a [2, 2] : %pi;
      (%o5)                          %pi
      (%i6) genmatrix (a, 2, 2);
                                 [ %e   0  ]
      (%o6)                      [         ]
                                 [ 0   %pi ]
      (%i7) genmatrix (lambda ([i, j], j - i), 3, 3);
                               [  0    1   2 ]
                               [             ]
      (%o7)                    [ - 1   0   1 ]
                               [             ]
                               [ - 2  - 1  0 ]
      (%i8) genmatrix (B, 2, 2);
                              [ B      B     ]
                              [  1, 1   1, 2 ]
      (%o8)                   [              ]
                              [ B      B     ]
                              [  2, 1   2, 2 ]

  Matrices ·

関数: gramschmidt (x)
関数: gramschmidt (x, F)

  xに対してグラム-シュミット直交化アルゴリズムを実行します。 xは、行列かリストのリストのいずれかです。 `gramschmidt`はxを変更しません。 もし引数にあれば、`gramschmidt`はFを内積として使います。 そうでなければ、内積は関数`innerproduct`です。

  もしxが行列なら、 アルゴリズムは xの行に適用されます。 もしxがリストのリストなら、 アルゴリズムは部分リストに適用されます。 部分リストは、要素数が同じでなければいけません。 いずれの場合も、 戻り値は、リストのリストです。 この部分リストは互いに直交し、xと同じ空間を埋めます。 もし、xの全範囲の次元が行や部分リストの数よりちいさいなら、 戻り値の部分リストのいくつかはゼロです。

  中間結果を整理するために、アルゴリズムのそれぞれの段階で`factor`がコールされます。 結果として、戻り値は、素因数分解された整数を含みます。

  `load("eigen")`はこの関数をロードします。

  例:

  デフォルトの内積関数を使ったグラム-シュミットアルゴリズム。

      (%i1) load ("eigen")$
      (%i2) x: matrix ([1, 2, 3], [9, 18, 30], [12, 48, 60]);
                               [ 1   2   3  ]
                               [            ]
      (%o2)                    [ 9   18  30 ]
                               [            ]
                               [ 12  48  60 ]
      (%i3) y: gramschmidt (x);
                             2      2            4     3
                            3      3   3 5      2  3  2  3
      (%o3)  [[1, 2, 3], [- ---, - --, ---], [- ----, ----, 0]]
                            2 7    7   2 7       5     5
      (%i4) map (innerproduct, [y[1], y[2], y[3]], [y[2], y[3], y[1]]);
      (%o4)                       [0, 0, 0]

  指定した内積関数を使ったグラム-シュミットアルゴリズム。

      (%i1) load ("eigen")$
      (%i2) ip (f, g) := integrate (f * g, u, a, b);
      (%o2)          ip(f, g) := integrate(f g, u, a, b)
      (%i3) y : gramschmidt([1, sin(u), cos(u)], ip), a= -%pi/2, b=%pi/2;
                                     %pi cos(u) - 2
      (%o3)              [1, sin(u), --------------]
                                          %pi
      (%i4) map (ip, [y[1], y[2], y[3]], [y[2], y[3], y[1]]),
                                                      a= -%pi/2, b=%pi/2;
      (%o4)                       [0, 0, 0]

  Package eigen ·

関数: ident (n)

  n行n列の単位行列を返します。

  Matrices ·

関数: innerproduct (x, y)
関数: inprod (x, y)

  xとyの(スカラー積やドット積とも呼ばれる)内積を返します。 xとyは、等しい長さのリストか、ともに等しい長さの1列行列か1行行列です。 戻り値は、`conjugate (x) . y`です。 ここで、`.`は非可換乗算演算子です。

  `load ("eigen")`はこの関数をロードします。

  `inprod`は、`innerproduct`と同義です。

  Package eigen ·

関数: invert (M)

  行列Mの逆行列を返します。 逆行列は随伴法で計算されます。

  これは、ユーザーが 要素が多倍長浮動小数点の行列や 要素が浮動小数点係数多項式の行列の逆行列を、 CRE形に変換することなしに計算することを可能にします。

  余因子は、`determinant`関数で計算されるので、 もし`ratmx`が`false`なら、 要素の表現を変えることなしに、逆行列が計算されます。

  現在の実装は、高次の行列には非効率的です。

  `detout`が`true`の時、 行列式は、逆行列から係数として外に出されます。

  逆行列の要素は自動的には展開されません。 もしMが多項式の要素を持つなら、 `expand (invert (m)), detout`が、見た目がよりよい出力を生成することができます。 もし全体を行列式で割られたものが望ましいなら、 `xthru (%)`で達成することができます。 また、代わりに最初から以下のようにしても達成できます。

      expand (adjoint (m)) / expand (determinant (m))
      invert (m) := adjoint (m) / determinant (m)

  行列の逆を計算する別の方法について`^^` (非可換べき乗)を参照してください。

  Matrices ·

関数: list_matrix_entries (M)

  行列Mの要素を含むリストを返します。

  例:

      (%i1) list_matrix_entries(matrix([a,b],[c,d]));
      (%o1)                     [a, b, c, d]

  Matrices ·

オプション変数: lmxchar

  デフォルト値: `[`

  `lmxchar`は、行列の左区切り記号として表示される文字です。 `rmxchar`も参照してください。

  例:

      (%i1) lmxchar: "|"$
      (%i2) matrix ([a, b, c], [d, e, f], [g, h, i]);
                                 | a  b  c ]
                                 |         ]
      (%o2)                      | d  e  f ]
                                 |         ]
                                 | g  h  i ]

  Display flags and variables ·Matrices ·

関数: matrix (row_1, ..., row_n)

  行row_1, ..., row_nを持つ長方形行列を返します。 行それぞれは、式のリストです。 すべての行は同じ長さでなければいけません。

  オペランドが、２つの行列、スカラーと行列、行列とスカラーのいずれかの時、 演算`+` (足し算), `-` (引き算), `*` (掛け算), `/` (割り算)は要素毎に実行されます。 もしオペランドが、スカラーと行列、行列とスカラーのいずれかなら、 演算`^` (べき乗, `**`と同値)は、要素毎に実行されますが、 もしオペランドが２つの行列なら要素毎には実行されません。 `.` (非可換乗算)を含むすべての演算は、通常、完全に実行されます。

  行列の掛け算は、非可換乗算演算子`.`で表されます。 対応する非可換べき乗演算子は`^^`です。 行列 `A`に関して、 `A.A = A^^2`であり、 もし存在するなら、`A^^-1`はAの逆行列です。

  ドット演算や行列-リスト演算を含む式の整理を制御するためのスイッチがあります。 それらは、 `doallmxops`, `domxexpt` `domxmxops`, `doscmxops`, `doscmxplus`です。

  行列に関係する付加的なオプションがあります。 それらは以下の通りです: `lmxchar`, `rmxchar`, `ratmx`, `listarith`, `detout`, `scalarmatrix`, `sparse`

  行列を引数として取ったり、行列を戻り値としてもたらしたりするたくさんの関数があります。 `eigenvalues`, `eigenvectors`, `determinant`, `charpoly`, `genmatrix`, `addcol`, `addrow`, `copymatrix`, `transpose`, `echelon`, `rank`を参照してください。

  例:

  - リストからの行列の組み立て。

      (%i1) x: matrix ([17, 3], [-8, 11]);
                                 [ 17   3  ]
      (%o1)                      [         ]
                                 [ - 8  11 ]
      (%i2) y: matrix ([%pi, %e], [a, b]);
                                 [ %pi  %e ]
      (%o2)                      [         ]
                                 [  a   b  ]

  - 足し算、要素毎に。

      (%i3) x + y;
                            [ %pi + 17  %e + 3 ]
      (%o3)                 [                  ]
                            [  a - 8    b + 11 ]

  - 引き算、要素毎に。

      (%i4) x - y;
                            [ 17 - %pi  3 - %e ]
      (%o4)                 [                  ]
                            [ - a - 8   11 - b ]

  - 掛け算。要素毎に。

      (%i5) x * y;
                              [ 17 %pi  3 %e ]
      (%o5)                   [              ]
                              [ - 8 a   11 b ]

  - 割り算。要素毎に。

      (%i6) x / y;
                              [ 17       - 1 ]
                              [ ---  3 %e    ]
                              [ %pi          ]
      (%o6)                   [              ]
                              [   8    11    ]
                              [ - -    --    ]
                              [   a    b     ]

  - 行列のスカラーべき、要素毎に。

      (%i7) x ^ 3;
                               [ 4913    27  ]
      (%o7)                    [             ]
                               [ - 512  1331 ]

  - スカラー基数の行列べき、要素毎に。

      (%i8) exp(y);
                               [   %pi    %e ]
                               [ %e     %e   ]
      (%o8)                    [             ]
                               [    a     b  ]
                               [  %e    %e   ]

  - 行列基数の行列べき。これは要素毎には実行されません。

      (%i9) x ^ y;
                                      [ %pi  %e ]
                                      [         ]
                                      [  a   b  ]
                           [ 17   3  ]
      (%o9)                [         ]
                           [ - 8  11 ]

  - 非可換行列乗算。

      (%i10) x . y;
                        [ 3 a + 17 %pi  3 b + 17 %e ]
      (%o10)            [                           ]
                        [ 11 a - 8 %pi  11 b - 8 %e ]
      (%i11) y . x;
                      [ 17 %pi - 8 %e  3 %pi + 11 %e ]
      (%o11)          [                              ]
                      [  17 a - 8 b     11 b + 3 a   ]

  - 非可換行列べき乗 スカラー基数bの行列べきMは、要素毎に実行され、 `b^^m`は`b^m`と同じです。

      (%i12) x ^^ 3;
                              [  3833   1719 ]
      (%o12)                  [              ]
                              [ - 4584  395  ]
      (%i13) %e ^^ y;

                               [   %pi    %e ]
                               [ %e     %e   ]
      (%o13)                   [             ]
                               [    a     b  ]
                               [  %e    %e   ]

  - 行列の-1指数の非可換べき乗は存在するなら、逆行列のことです。

      (%i14) x ^^ -1;
                               [ 11      3  ]
                               [ ---  - --- ]
                               [ 211    211 ]
      (%o14)                   [            ]
                               [  8    17   ]
                               [ ---   ---  ]
                               [ 211   211  ]
      (%i15) x . (x ^^ -1);
                                  [ 1  0 ]
      (%o15)                      [      ]
                                  [ 0  1 ]

  Matrices ·

関数: matrixmap (f, M)

  `f(M[i,j])`に等しい要素`i,j`を持つ行列を返します。

  `map`, `fullmap`, `fullmapl`, `apply`も参照してください。

  Matrices ·

関数: matrixp (expr)

  もしexprが行列なら`true`を返し，そうでなければ、`false`を返します。

  Predicate functions ·Matrices ·

オプション変数: matrix_element_add

  デフォルト値: `+`

  `matrix_element_add`は、 行列乗算の中で足し算の代わりに呼び出される演算です。 `matrix_element_add`は、 任意のn項演算子(すなわち、任意の数の引数を扱う関数)に割り当てられます。 割り当てられた値は、クォートマークでくくられた演算子の名前か、 関数名かラムダ式を取り得ます。

  `matrix_element_mult`と`matrix_element_transpose`も参照してください。

  例:

      (%i1) matrix_element_add: "*"$
      (%i2) matrix_element_mult: "^"$
      (%i3) aa: matrix ([a, b, c], [d, e, f]);
                                 [ a  b  c ]
      (%o3)                      [         ]
                                 [ d  e  f ]
      (%i4) bb: matrix ([u, v, w], [x, y, z]);

                                 [ u  v  w ]
      (%o4)                      [         ]
                                 [ x  y  z ]

      (%i5) aa . transpose (bb);
                           [  u  v  w   x  y  z ]
                           [ a  b  c   a  b  c  ]
      (%o5)                [                    ]
                           [  u  v  w   x  y  z ]
                           [ d  e  f   d  e  f  ]

  Matrices ·

オプション変数: matrix_element_mult

  デフォルト値: `*`

  `matrix_element_mult`は、 行列乗算の中で掛け算の代わりに呼び出される演算です。 `matrix_element_mult`は、 任意の二項演算子に割り当てられます。 割り当てられた値は、クォートマークでくくられた演算子の名前か、関数名か、 ラムダ式を取り得ます。

  ドット演算子`.`は、いくつかの文脈で役に立つ選択です。

  `matrix_element_add`と`matrix_element_transpose`も参照してください。

  例:

      (%i1) matrix_element_add: lambda ([[x]], sqrt (apply ("+", x)))$
      (%i2) matrix_element_mult: lambda ([x, y], (x - y)^2)$
      (%i3) [a, b, c] . [x, y, z];
                                2          2          2
      (%o3)         sqrt((c - z)  + (b - y)  + (a - x) )
      (%i4) aa: matrix ([a, b, c], [d, e, f]);
                                 [ a  b  c ]
      (%o4)                      [         ]
                                 [ d  e  f ]
      (%i5) bb: matrix ([u, v, w], [x, y, z]);
                                 [ u  v  w ]
      (%o5)                      [         ]
                                 [ x  y  z ]
      (%i6) aa . transpose (bb);
                     [             2          2          2  ]
                     [ sqrt((c - w)  + (b - v)  + (a - u) ) ]
      (%o6)  Col 1 = [                                      ]
                     [             2          2          2  ]
                     [ sqrt((f - w)  + (e - v)  + (d - u) ) ]

                               [             2          2          2  ]
                               [ sqrt((c - z)  + (b - y)  + (a - x) ) ]
                       Col 2 = [                                      ]
                               [             2          2          2  ]
                               [ sqrt((f - z)  + (e - y)  + (d - x) ) ]

  Matrices ·

オプション変数: matrix_element_transpose

  デフォルト値: `false`

  `matrix_element_transpose`は、 転置される時、行列のそれぞれの要素に適用される演算です。 `matrix_element_mult`は、任意の単項演算子に割り当てられます。 割り当てられた値はクォートマークでくくられた演算子の名前か、 関数名か、ラムダ式を取り得ます。

  `matrix_element_transpose`が`transpose`に等しい時、 `transpose`関数が要素すべてに適用されます。 `matrix_element_transpose`が`nonscalars`に等しい時、 `transpose`関数は非スカラー要素すべてに適用されます。 もしある要素がアトムなら、`nonscalars`オプションは アトムが宣言された非スカラーの時だけ`transpose`を適用します。 一方、`transpose`オプションはいつも`transpose`を適用します。

  デフォルト値, `false`,はいかなる演算も適用しないことを意味します。

  `matrix_element_add`と`matrix_element_mult`も参照してください。

  例:

      (%i1) declare (a, nonscalar)$
      (%i2) transpose ([a, b]);
                              [ transpose(a) ]
      (%o2)                   [              ]
                              [      b       ]
      (%i3) matrix_element_transpose: nonscalars$
      (%i4) transpose ([a, b]);
                              [ transpose(a) ]
      (%o4)                   [              ]
                              [      b       ]
      (%i5) matrix_element_transpose: transpose$
      (%i6) transpose ([a, b]);
                              [ transpose(a) ]
      (%o6)                   [              ]
                              [ transpose(b) ]
      (%i7) matrix_element_transpose: lambda ([x], realpart(x)
            - %i*imagpart(x))$
      (%i8) m: matrix ([1 + 5*%i, 3 - 2*%i], [7*%i, 11]);
                           [ 5 %i + 1  3 - 2 %i ]
      (%o8)                [                    ]
                           [   7 %i       11    ]
      (%i9) transpose (m);
                            [ 1 - 5 %i  - 7 %i ]
      (%o9)                 [                  ]
                            [ 2 %i + 3    11   ]

  Matrices ·

関数: mattrace (M)

  正方行列Mの跡(すなわち、主対角上の要素の和)を返します。

  `mattrace`は、`ncharpoly`―Maximaの`charpoly`の代わり― によってコールされます。

  `load ("nchrpl")`はこの関数をロードします。

  Matrices ·Package nchrpl ·

関数: minor (M, i, j)

  行列Mのi, j小行列を返します。 すなわち、行iと列jを除いたMです。

  Matrices ·

関数: ncharpoly (M, x)

  行列Mの xに関する特性多項式を返します。 これはMaximaの`charpoly`の代わりです。

  `ncharpoly`は、与えられた行列のべきの跡を計算することで機能します。 それは、特性多項式の根のべきの和に等しいことが知られています。 それらの量から根の対称関数を計算することができます。 それらは、特性多項式の係数以上のなにものでもありません。 `charpoly`は、 `x * ident [n] - a`の行列式を形成することで機能します。 このように、 `ncharpoly` は完全に多項式算術を避けるので、 例えば、整数で埋められた大きな密な行列の場合、`ncharpoly`が勝ります。

  `load ("nchrpl")`はこのファイルをロードします。

  Matrices ·Package nchrpl ·

関数: newdet (M)

  行列Mの行列式を ジョンソン-ジェントルマンのtree minorアルゴリズムを使って計算します。 `newdet`はCRE形式で結果を返します。

  Matrices ·

宣言: nonscalar

  アトムをドット演算子に関してリストか行列のように振る舞うようにします。

  Declarations and inferences ·Vectors ·Matrices ·

関数: nonscalarp (expr)

  もしexprが非スカラー、すなわち、 非スカラーとして宣言されたアトムかリスト、行列を含むなら、 `true`を返します。

  Predicate functions ·Vectors ·Matrices ·

関数: permanent (M, n)

  行列Mのパーマネントを計算します。 パーマネントは行列式のようですが、符号が変わりません。 `permanent`はCRE形式で結果を返します。

  `newdet`も参照してください。

  Matrices ·

関数: rank (M)

  行列Mのランクを計算します。 すなわち、Mの、最も大きな非特異な小行列式の次数です。

  もしrankがゼロと同値の行列要素が確かにそうであることを決定することができないなら、 、間違った答えを返します。

  Matrices ·

オプション変数: ratmx

  デフォルト値: `false`

  `ratmx`が`false`の時、 行列要素の表現で、行列式と行列の足し算、引き算、掛け算が実行され、 逆行列の結果は一般表現のまま残されます。

  `ratmx`が`true`の時、 上で述べた４つの演算は、CRE形式で実行され、 逆行列の結果もCRE形式になります。 これは、(`ratfac`の設定に依って) いつも望まれているわけではないですが、 要素が展開されるようになるかもしれないことに注意してください。

  Matrices ·Rational expressions ·

関数: row (M, i)

  行列Mのi番目の行を返します。 戻り値は行列です。

  Matrices ·

オプション変数: rmxchar

  デフォルト値: `]`

  `rmxchar`は、行列の右辺に描かれる文字です。

  `lmxchar`も参照してください。

  Display flags and variables ·

オプション変数: scalarmatrixp

  デフォルト値: `true`

  `scalarmatrixp`が`true`の時、 1 x 1行列が行列のドット積を計算した結果として生成される時はいつでも、 スカラー、すなわち、行列の唯一の要素、に整理されます。

  `scalarmatrixp`が`all`の時、 すべての1 x 1行列はスカラーに整理されます。

  `scalarmatrixp`が`false`の時、 1 x 1行列はスカラーに整理されません。

  Matrices ·Simplification flags and variables ·

関数: scalefactors (coordinatetransform)

  ここで、 coordinatetransformは、形式 [[expression1, expression2, ...], indeterminate1, indeterminat2, ...] に評価されます。また、 indeterminate1, indeterminate2, などは曲線座標変数であり、 直交カーテシアン成分の集合は、 [expression1, expression2, ...]によって、曲線座標を使って与えられます。

  `coordinates`が ベクトル[indeterminate1, indeterminate2,...]に設定され、 `dimension`がこのベクトルの長さに設定されます。 SF[1], SF[2], …, SF[DIMENSION]は、座標スケールファクタに設定され、 `sfprod`は、これらのスケールファクタの積に設定されます。 初期には、3次元直交カーテシアン座標に対応して、 `coordinates`は[X, Y, Z]であり、 `dimension`は3であり、SF[1]=SF[2]=SF[3]=SFPROD=1です。 式を現在の座標形の物理成分に展開するために、 形式?を利用する関数があります。

  Package vect ·

関数: setelmx (x, i, j, M)

  xを行列Mの(i, j)番目の要素に割り当て、 変わった行列を返します。

  `M [i, j]: x`は同じ効果を持ちますが、 Mの代わりにxを返します。

  Matrices ·

関数: similaritytransform (M)
関数: simtran (M)

  `similaritytransform`は、 行列`M`の相似変換を計算します。 `uniteigenvectors`コマンドの出力であるリストを返します。 更に、もしフラグ`nondiagonalizable`が`false`なら、 ２つのグローバル行列`leftmatrix`と`rightmatrix`が計算されます。 これらの行列は、 `leftmatrix . M . rightmatrix`が Mの固有値を対角上に持つ対角行列となるという性質を持ちます。 もし`nondiagonalizable`が`true`なら、 左右の行列は計算されません。

  もしフラグ`hermitianmatrix`が`true`なら、 `leftmatrix`は、`rightmatrix`の転置の複素共役です。 そうでなければ、`leftmatrix`は`rightmatrix`の逆行列です。

  `rightmatrix`は、列がMの単位固有ベクトルである行列です。 他のフラグ(`eigenvalues`と`eigenvectors`を参照してください)は、 `similaritytransform`は、 `rightmatrix`を形成することができるようになるために、パッケージの中の他の関数をコールするので、 同じ効果を持ちます。

  `load ("eigen")`はこの関数をロードします。

  `simtran`は、`similaritytransform`と同義です。

  Package eigen ·

オプション変数: sparse

  デフォルト値: `false`

  `sparse`が`true`の時、 かつ、もし`ratmx`が`true`なら、 `determinant`は、粗な行列式を計算するために特別なルーチンを使います。

  Matrices ·

関数: submatrix (i_1, …, i_m, M, j_1, …, j_n)
関数: submatrix (i_1, …, i_m, M)
関数: submatrix (M, j_1, …, j_n)

  行i_1, …, i_mが取り除かれ、 列j_1, …, j_nが取り除かれた 行列Mから構成された新しい行列を返します。

  Matrices ·

関数: transpose (M)

  Mの転置を返します。

  もしMが行列なら、 戻り値は、`N[i,j] = M[j,i]`であるような別の行列Nです。

  もしMがリストなら、 返し値は、`N[i,1] = M[i]`であるような、`length (m)`行1列の行列Nです。

  そうでなければMはシンボルで、 戻り値は、名詞式`'transpose (M)`です。

  Matrices ·

関数: triangularize (M)

  ガウスの消去法で生成されるような、行列`M`の右上三角化行列を返します。 戻り値は、 それぞれの行の先頭の非ゼロ係数が1に規格化されないことを除いて、 `echelon`と同じです。

  `lu_factor`と`cholesky`は、三角化行列をもらたす他の関数です。

      (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
                             [  3   7  aa  bb ]
                             [                ]
      (%o1)                  [ - 1  8  5   2  ]
                             [                ]
                             [  9   2  11  4  ]
      (%i2) triangularize (M);
                   [ - 1   8         5            2      ]
                   [                                     ]
      (%o2)        [  0   - 74     - 56         - 22     ]
                   [                                     ]
                   [  0    0    626 - 74 aa  238 - 74 bb ]

  Linear equations ·Matrices ·

関数: uniteigenvectors (M)
関数: ueivects (M)

  行列Mの単位固有ベクトルを計算します。 戻り値は、リストのリストです。 最初の部分リストは`eigenvalues`コマンドの出力であり、 他の部分リストは、固有値それぞれに対応する行列の単位固有ベクトルです。

  `eigenvectors`コマンドでの記述で言及されたフラグは、 これに関しても同じ効果を持ちます。

  `knowneigvects`が`true`の時、 `eigen`パッケージは、 行列の固有ベクトルがユーザーに知られていて、 グローバル名`listeigvects`の下に記憶されていることを仮定します。 `listeigvects`は、 `eigenvectors`コマンドの出力に似たリストに設定されなければいけません。

  もし`knowneigvects`が`true`に設定されていて、 固有ベクトルのリストが与えれているなら、 フラグ`nondiagonalizable`の設定は正しくないかもしれません。 もしこの場合に該当するなら、正しい値に設定してください。 作者は、ユーザーがしていることを知っていること、 固有値が適切な次元のベクトル空間を作り出さない行列を対角化しようとはしないことを 仮定しています。

  `load ("eigen")`はこの関数をロードします。

  `ueivects`は`uniteigenvectors`と同義です。

  Package eigen ·

関数: unitvector (x)
関数: uvect (x)

  x/norm(x)を返します; これは、xと同じ向きの単位ベクトルです。

  `load ("eigen")`はこの関数をロードします。

  `uvect`は、`unitvector`と同義です。

  Package eigen ·

関数: vectorpotential (givencurl)

  現在の座標系で与えられた回転ベクトルのベクトルポテンシャルを返します。 `potentialzeroloc`が `potential`に対して似たような役割を持ちますが、 等式の左辺側の次数は座標変数の巡回置換でなければいけません。

  Package vect ·

関数: vectorpotential (givencurl)

  現在の座標系で、与えられた回転ベクトルのベクトルポテンシャルを返します。 `potentialzeroloc`は、`potential`と同様の役割を持ちますが、 等式の左辺の順序が座標の巡回置換でなければいけません。

  Package vect ·

関数: vectorsimp (expr)

  以下のグローバルフラグに従って整理と展開を適用します:

  `expandall`, `expanddot`, `expanddotplus`, `expandcross`, `expandcrossplus`, `expandcrosscross`, `expandgrad`, `expandgradplus`, `expandgradprod`, `expanddiv`, `expanddivplus`, `expanddivprod`, `expandcurl`, `expandcurlplus`, `expandcurlcurl`, `expandlaplacian`, `expandlaplacianplus`, `expandlaplacianprod`.

  これらのフラグすべては、デフォルト値`false`を持ちます。 `plus`接尾辞は、加算性や分配性の利用に関係します。 `prod`接尾辞は、任意の種類の積のオペランドに関する展開に関係します。

  `expandcrosscross`

    p ~ (q ~ r)を(p . r)*q - (p . q)*rに整理します。

  `expandcurlcurl`

    curl curl pをgrad div p + div grad pに整理します。

  `expandlaplaciantodivgrad`

    laplacian pをdiv grad pに整理します。

  `expandcross`

    `expandcrossplus`と`expandcrosscross`を有効にします。

  `expandplus`

    `expanddotplus`, `expandcrossplus`, `expandgradplus`, `expanddivplus`, `expandcurlplus`, `expandlaplacianplus`を有効にします。

  `expandprod`

    `expandgradprod`, `expanddivprod`, `expandlaplacianprod`を有効にします。

  これらのフラグはすべて`evflag`として宣言されています。

  Package vect ·Simplification functions ·

オプション変数: vect_cross

  デフォルト値: `false`

  `vect_cross`が`true`の時、 ~がSHARE;VECTの中で定義されているところ (とにかく、VECT_CROSSが`true`に設定されているところ) でDIFF(X~Y,T)が機能するようにします。

  Package vect ·Differential calculus ·

関数: zeromatrix (m, n)

  要素すべてがゼロのm行n列行列を返します。

  Matrices ·

Next: itensor, Previous: Matrices and Linear Algebra, Up: Top [Contents][Index]

## 24 Affine

Next: Functions and Variables for Affine, Previous: Affine, Up: Affine [Contents][Index]

### 24.1 Introduction to Affine

`affine`は多項式の群を扱うパッケージです。

Polynomials ·Groebner bases ·Share packages ·Package affine ·

Previous: Introduction to Affine, Up: Affine [Contents][Index]

### 24.2 Functions and Variables for Affine

関数: fast_linsolve ([expr_1, ..., expr_m], [x_1, ..., x_n])

  変数x_1, ..., x_nに関する連立線形方程式expr_1, ..., expr_m を解きます。 expr_iそれぞれは、等式か一般式を取り得ます; もし一般式として与えられたら、 形式`expr_i = 0`の等式として扱われます。

  戻り値は、 形式`[x_1 = a_1, ..., x_n = a_n]` の等式のリストです。 ここで、a_1, ..., a_nはすべてx_1, ..., x_nを含みません。

  `fast_linsolve`は、 粗な方程式系に対して`linsolve`より速いです。

  `load("affine")`はこの関数をロードします。

  Package affine ·

関数: grobner_basis ([expr_1, ..., expr_m])

  等式expr_1, ..., expr_mのグレブナー基底を返します。 等式に関係する他の関数を整理するためには、 その後、関数`polysimp`を使うことができます。

      grobner_basis ([3*x^2+1, y*x])$

      polysimp (y^2*x + x^3*9 + 2) ==> -3*x + 2

  `polysimp(f)`は、 fがexpr_1, ..., expr_mによって生成されたイデアルに含まれるときだけ、 すなわち、fがexpr_1, ..., expr_mの要素の多項式結合の時だけ、 0をもたらします。

  `load("affine")`はこの関数をロードします。

  Package affine ·

関数: set_up_dot_simplifications (eqns, check_through_degree)
関数: set_up_dot_simplifications (eqns)

  The eqnsは、非可換変数を含む多項式方程式です `current_variables`の値は、次数を計算するために使われる変数のリストです。 手続きが終了するためには、方程式は斉次でなければいけません。

  もし fの次数上の`dot_simplifications`に関する重複整理をチェックしたら、 以下は真です: fが方程式によって生成されたイデアルに含まれる時だけ、 すなわち、fが方程式の要素の多項式結合の時だけ、 `dotsimp (f)`は、0をもたらします。

  次数は`nc_degree`で返されるものです。 これは、さらに、個々の変数の重みに影響されます。

  `load("affine")`はこの関数をロードします。

  Package affine ·

関数: declare_weights (x_1, w_1, ..., x_n, w_n)

  重み w_1, ..., w_n それぞれをx_1, ..., x_nに割り当てます。 これらは、`nc_degree`を計算する時に使われる重みです。

  `load("affine")`はこの関数をロードします。

  Package affine ·

関数: nc_degree (p)

  非可換多項式pの次数を返します。 `declare_weights`を参照してください。

  `load("affine")`はこの関数をロードします。

  Package affine ·

関数: dotsimp (f)

  fが方程式によって生成されたイデアルに含まれる時だけ、 すなわち、fが方程式の要素の多項式結合の時だけ、 0を返します。

  `load("affine")`はこの関数をロードします。

  Package affine ·

関数: fast_central_elements ([x_1, ..., x_n], n)

  もし`set_up_dot_simplifications`が以前に実行されていたら、 与えられた次数nでの変数x_1, ..., x_nに関する中心多項式 を見つけます。

  例えば:

      set_up_dot_simplifications ([y.x + x.y], 3);
      fast_central_elements ([x, y], 2);
      [y.y, x.x];

  `load("affine")` loads this function.

  Package affine ·

関数: check_overlaps (n, add_to_simps)

  次数nまでの重複をチェックします。 すなわち、`dotsimp`が正しく機能するように、 それぞれの次数で十分な整理規則を持つことを確認します。 もしあらかじめ単項式の空間次元が何か知っているなら、 このプロセスは、スピードアップできます。 もし有限グローバル次元なら、 `hilbert`が使われるべきです。 もし単項式次元を知らないなら、 `rank_function`を指定しないでください。 オプションの三番目の引数`reset`は、 `false`は、物事の再設定についてわざわざ問い合わせないように言います。

  `load("affine")`はこの関数をロードします。

  Package affine ·

関数: mono ([x_1, ..., x_n], n)

  次数nの変数x_1, ..., x_nに関する現在のドット整理に関係した 独立な単項式のリストを返します。

  `load("affine")` loads this function.

  Package affine ·

関数: monomial_dimensions (n)

  カレント代数に関する次数nまでのヒルベルト級数を計算します。

  `load("affine")`はこの関数をロードします。

  Package affine ·

関数: extract_linear_equations ([p_1, ..., p_n], [m_1, ..., m_n])

  非可換単項式m_1, ..., m_nの 非可換多項式p_1, ..., p_n の係数のリストを作ります。 係数はスカラーでなければいけません。 単項式のリストを組み立てるには、`list_nc_monomials`を使ってください。

  `load("affine")`はこの関数をロードします。

  Package affine ·

関数: list_nc_monomials ([p_1, ..., p_n])
関数: list_nc_monomials (p)

  多項式pまたは多項式のリストp_1, ..., p_n の中に現れる非可換単項式のリストを返します。

  `load("affine")`はこの関数をロードします。

  Package affine ·

オプション変数: all_dotsimp_denoms

  デフォルト値: `false`

  `all_dotsimp_denoms`がリストの時、 `dotsimp`が出会う分母がリストに追加されます。 `all_dotsimp_denoms`は、 `dotsimp`をコールする前に 空のリスト`[]`に初期化されるかもしれません。

  デフォルトでは、`dotsimp`は分母を集めません。

  Package affine ·

Next: ctensor, Previous: Affine, Up: Top [Contents][Index]

## 25 itensor

Next: Functions and Variables for itensor, Previous: itensor, Up: itensor [Contents][Index]

### 25.1 Introduction to itensor

Maximaは、記号的なテンソル操作を２つの異なったタイプで実装しています: 成分テンソル操作(`ctensor`パッケージ)と添字テンソル操作(`itensor`パッケージ)。

注意せよ: 以下の’新しいテンソル表記’に関するノートを参照してください。

成分テンソル操作は、 幾何学的テンソルオブジェクトが配列または行列で表現されることを意味します。 縮約や共変微分のようなテンソル演算は実際に、 `do`文を伴う繰り返し用(ダミー)添字上の和によって実行されます。 すなわち、配列や行列に記憶された適切なテンソル成分上で陽に演算を実行します。

添字テンソル操作は、 共変、反変、そして微分添字の関数としてテンソルを表現することで実装されています。 縮約や共変微分のようなテンソル演算は、 対応する成分よりむしろ添字それ自身を操作することで実行されます。

Riemann幾何の文脈での微分的、代数的、解析的処理へのこれらの２つのアプローチは、 ユーザーの問題の個々の性質と難しさを通してだけ明らかにされる様々な利点と欠点を持ちます。 しかしながら、２つの実装の以下の特性を心にとどめて置くべきです:

成分を陽に使ったテンソルとテンソル演算の表現は、 `ctensor`を使いやすくします。 軽量の指定と、帰納されたテンソルと不変量の計算は容易です。 Maximaの強力な整理能力すべてはいつでも使えますが、 入り組んだ関数的、座標依存性を持つ複雑な計量は、簡単に、サイズが極端で、構造が隠された式に 至ります。 さらに、たくさんの計算は、増大する中間式を含み、プログラムが完了前に終了する原因となります。 経験を通して、ユーザーはこれらの難しさの多くを避けることができます。

テンソルとテンソル演算が添字上の記号演算を使って表される特別な方法のために、 成分表現では処理できなかった式が、時々、 `itensor`の中の対称オブジェクトに関する特別なルーチンを使うことで、 たいそう整理することができます。 この方法で、大きな式の構造がもっと明白になるかもしれません。 他方で、 `itensor`の中の特別な添字表現のために、 いくつかの場合、 ユーザーは、計量の指定や関数の定義、微分された「添字付き」オブジェクトの評価に 難しさを見いだすかもしれません。

`itensor`パッケージは、添字付き変数に関する微分を実行できます。 それは、ラグランジアンとハミルトニアン形式を扱う時にパッケージを使うことができます。 (添字付き)場の変数に関する場のラグランジアンを微分することが可能なので、 Maximaを、対応するEuler-Lagrange方程式を添字形式で得るのに使うことができます。 これらの方程式は、 `ic_convert`関数を使って、成分テンソル(`ctensor`)プログラムに翻訳することができ、 それは場の方程式を個別の座標表現で解くことや、 ハミルトニアン形式の運動方程式を計算し直すことを可能にします。 ２つの包括的な例として、`einhil.dem`と`bradic.dem`を参照してください。 最初の`einhil.dem`は、 斉次で等方的な場合(Friedmann方程式)と 球対称で静的な場合(Schwarzschild解)に のEinsteinの場テンソルを得るために Einstein-Hilbert作用を使います。 二番目の`bradic.dem`は、 Brans-Dicke重力理論の作用からFriedmann方程式を計算する方法を示し、 理論のスカラー場に関連したハミルトニアンも演繹します。

Tensors ·Share packages ·Package itensor ·

#### 25.1.1 New tensor notation

Maximaの`itensor`パッケージの初期のバージョンは、 時々、間違った添字順序に至る表記を使いました。 例えば、以下を考えてください:

    (%i2) imetric(g);
    (%o2)                                done
    (%i3) ishow(g([],[j,k])*g([],[i,l])*a([i,j],[]))$
                                     i l  j k
    (%t3)                           g    g    a
                                               i j
    (%i4) ishow(contract(%))$
                                          k l
    (%t4)                                a

`a`が偶然対称テンソルでなければ、 この結果は間違っています これが起こる理由は、 `itensor`は正しく共変添字と反変添字の集合の中の順序を保つけれども、 一旦、添字が上がったり、下がったりすると、 添字の他の集合に関する位置が失われるからです。

この問題を避けるため、 存在する表記と完全に互換性を残し、相互に使うことが可能な新しい表記が開発されました。 この表記では、反変添字は、共変添字リストの中の適切な位置に挿入されますが、 マイナス記号が前に付けられます。 現在、`contract`や`ishow`のような関数は、 この新しい添字表記に通じており、 テンソルを適切に処理することができます。

この新しい表記では、以前の例は正しい結果をもたらします:

    (%i5) ishow(g([-j,-k],[])*g([-i,-l],[])*a([i,j],[]))$
                                     i l       j k
    (%t5)                           g    a    g
                                          i j
    (%i6) ishow(contract(%))$
                                          l k
    (%t6)                                a

現在、 この表記を使う唯一のコードは、`lc2kdt`関数です。 数値添字に頼らずLevi-Civita記号を決定するために計量テンソルを用いる時、 この表記を通じて、一貫した結果を達成します。

このコードはできたばかりなので、おそらくバグを含みます。 「古い」テンソル表記を使った何かを壊さないことを確認するためにテストされている一方、 「新しい」テンソルが 特定の関数や特徴と相互運営するのに失敗する相当な可能性があります。 これらのバグは、出会った時修正されるでしょう。それまでは、利用者責任！

#### 25.1.2 Indicial tensor manipulation

添字テンソル操作パッケージは`load("itensor")`でロードできます。 デモも利用可能です: `demo(tensor)`を試してください。

`itensor`では、 テンソルは「添字付きオブジェクト」として表されます。 これは 共変、反変、微分添字を表す添字の3つのグループの関数です。 共変添字は添字付きオブジェクトの最初の引数としてリストで指定され、 半変添字は二番目の引数としてリストで指定されます。 もし添字付きオブジェクトが添字のグループのいずれかを欠いているなら、 空のリスト`[]`が対応する引数として与えられます。 例えば、`g([a,b],[c])`は、 ２つの共変添字`(a,b)`と１つの反変添字(`c`)を持ち、微分添字を持たない `g`と呼ばれる添字付きオブジェクトを表します。

もし存在するなら、微分添字は、テンソルを表すシンボル関数の追加の引数として添えられます。 それらは、ユーザーによって陽に指定されたり、ある座標変数に関する微分の処理の中で生成されたりします。 常微分は可換なので、 フレーム計量が使われることを示す`iframe_flag`が`true`に設定されない限り、 微分添字はアルファベット順に並び替えられます。 この標準オーダーは、Maximaが、例えば、`t([a],[b],i,j)`が`t([a],[b],j,i)`と同じだと認識することを可能にします。 添字付きオブジェクトの引数として現れない添字の座標に関する 添字付きオブジェクトの微分は、通常ゼロをもたらします。 これは、Maximaが添字付きオブジェクトで表されたテンソルが対応する座標に陰に依存するかもしれないことを知らないためです。 `itensor`現在のMaxima関数`diff`を修正したことで、 そうでなければ記述されない限り、Maximaは、添字付きオブジェクトすべてが微分の任意の変数に依存することを現在仮定します。 これは、和の慣例が微分添字に拡張されることを可能にします。 `itensor`は微分添字を上げる能力を所有しないこと、そしてそれらは常に共変として扱われることに注意すべきです。

以下の関数が添字付きオブジェクトを操作するためにテンソルパッケージの中で利用可能です。 現在、整理ルーチンに関して、添字付きオブジェクトがデフォルトで対称性を持たないことを仮定します。 これは、変数`allsym[false]`を`true`に設定することで上書きすることができます。 これによって、すべての添字付きオブジェクトを共変添字のリストと反変添字のリストに関して完全に対称に扱うようになります。

`itensor`パッケージは、一般にテンソルを不透明なオブジェクトとして扱います。 テンソル等式は、代数ルール、特に対称性と縮約ルールに基づいて操作されます。 加えて、`itensor`パッケージは、共変微分、曲率、ねじれ率を理解します。 計算は、`iframe_flag`変数の設定に依存して動枠の計量に関して実行されます。

以下のサンプルセッションは、 `itensor`パッケージをロードし、計量名を指定し、いくつかの簡単な計算を実行する仕方を 例示します。

    (%i1) load("itensor");
    (%o1)      /share/tensor/itensor.lisp
    (%i2) imetric(g);
    (%o2)                                done
    (%i3) components(g([i,j],[]),p([i,j],[])*e([],[]))$
    (%i4) ishow(g([k,l],[]))$
    (%t4)                               e p
                                           k l
    (%i5) ishow(diff(v([i],[]),t))$
    (%t5)                                  0
    (%i6) depends(v,t);
    (%o6)                               [v(t)]
    (%i7) ishow(diff(v([i],[]),t))$
                                        d
    (%t7)                               -- (v )
                                        dt   i
    (%i8) ishow(idiff(v([i],[]),j))$
    (%t8)                                v
                                          i,j
    (%i9) ishow(extdiff(v([i],[]),j))$
    (%t9)                             v    - v
                                       j,i    i,j
                                      -----------
                                           2
    (%i10) ishow(liediff(v,w([i],[])))$
                                   %3          %3
    (%t10)                        v   w     + v   w
                                       i,%3    ,i  %3
    (%i11) ishow(covdiff(v([i],[]),j))$
                                                  %4
    (%t11)                        v    - v   ichr2
                                   i,j    %4      i j
    (%i12) ishow(ev(%,ichr2))$
                    %4 %5
    (%t12) v    - (g      v   (e p       + e   p     - e p       - e    p
            i,j            %4     j %5,i    ,i  j %5      i j,%5    ,%5  i j

                                             + e p       + e   p    ))/2
                                                  i %5,j    ,j  i %5
    (%i13) iframe_flag:true;
    (%o13)                               true
    (%i14) ishow(covdiff(v([i],[]),j))$
                                                 %6
    (%t14)                        v    - v   icc2
                                   i,j    %6     i j
    (%i15) ishow(ev(%,icc2))$
                                                 %6
    (%t15)                        v    - v   ifc2
                                   i,j    %6     i j
    (%i16) ishow(radcan(ev(%,ifc2,ifc1)))$
                 %6 %7                    %6 %7
    (%t16) - (ifg      v   ifb       + ifg      v   ifb       - 2 v
                        %6    j %7 i             %6    i j %7      i,j

                                                 %6 %7
                                            - ifg      v   ifb      )/2
                                                        %6    %7 i j
    (%i17) ishow(canform(s([i,j],[])-s([j,i])))$
    (%t17)                            s    - s
                                       i j    j i
    (%i18) decsym(s,2,0,[sym(all)],[]);
    (%o18)                               done
    (%i19) ishow(canform(s([i,j],[])-s([j,i])))$
    (%t19)                                 0
    (%i20) ishow(canform(a([i,j],[])+a([j,i])))$
    (%t20)                            a    + a
                                       j i    i j
    (%i21) decsym(a,2,0,[anti(all)],[]);
    (%o21)                               done
    (%i22) ishow(canform(a([i,j],[])+a([j,i])))$
    (%t22)                                 0

Previous: Introduction to itensor, Up: itensor [Contents][Index]

### 25.2 Functions and Variables for itensor

#### 25.2.1 Managing indexed objects

関数: dispcon (tensor_1, tensor_2, ...)
関数: dispcon (all)

  `defcon`に与えられたような引数の縮約プロパティを表示します。 `dispcon (all)`は、定義された縮約プロパティすべてを表示します。

  Display functions ·

関数: entertensor (name)

  プロンプトによって、 任意の数のテンソル添字や微分添字を持つnameと呼ばれる添字付きオブジェクトを生成することを許す関数です。 単一添字または(nullもありえる)添字のリストが容認可能な入力です。 (`covdiff`の下の例を参照してください。)

  Package itensor ·

関数: changename (old, new, expr)

  exprの中のoldと呼ばれるすべての添字付きオブジェクトの名前をnewに変えます。 oldはシンボルまたは形式`[name, m, n]`のリストであり得ます。 後者の場合、m個の共変添字とn個の反変添字を持つ nameと呼ばれるそれらの添字付きオブジェクトだけがnewにリネームされます。

  Package itensor ·

関数: listoftens

  テンソル式の中のすべてのテンソルを添字が完備した形でリストします。 例えば、

      (%i6) ishow(a([i,j],[k])*b([u],[],v)+c([x,y],[])*d([],[])*e)$
                                               k
      (%t6)                        d e c    + a    b
                                        x y    i j  u,v
      (%i7) ishow(listoftens(%))$
                                     k
      (%t7)                        [a   , b   , c   , d]
                                     i j   u,v   x y

  Package itensor ·

関数: ishow (expr)

  下付き添字としての共変添字と上付き添字としての反変添字を持つように 添字付きオブジェクトを持つ形でexprを表示します。 微分添字は、共変添字からコンマで区切られた下付き添字として表示されます。 (このドキュメント至る所の例を参照してください。)

  Package itensor ·

関数: indices (expr)

  2つの要素のリストを返します。 以下の例が例示するように、 一番目は、exprの中の自由添字(一度だけ現れるもの)のリストです。 二番目は、exprの中のダミー添字(正確に二回現れるもの)のリストです。

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) ishow(a([i,j],[k,l],m,n)*b([k,o],[j,m,p],q,r))$
                                      k l      j m p
      (%t2)                          a        b
                                      i j,m n  k o,q r
      (%i3) indices(%);
      (%o3)                 [[l, p, i, n, o, q, r], [k, j, m]]

  同じ添字を二回以上含むテンソル積は構文的に認められていません。 `indices`は、これらの式を合理的な方法で扱おうとします; しかしながら、そんな非合法な式上で動くようにコールされた時、その振る舞いは未定義と考えなければいけません。

  Package itensor ·

関数: rename (expr)
関数: rename (expr, count)

  もしオプションの二番目の引数が省略されたら、 exprと同値な、 しかし、各項に対して、集合`[%1, %2,...]`から選ばれたダミー添字を持つ式を返します。 そうでなければ、ダミー添字はcountの値で始まるようインデックスされます。 積の中のそれぞれのダミー添字は異なります。 和に関しては、`rename`は各項毎にカウンタが再設定されるように和の中の各項上で作用します。 この方法で、`rename`はテンソル整理器として利用できます。 加えて、 (もし`allsym`が`true`なら、) 添字は、 `flipflag`の値に依存して共変または反変添字に関して、 英数字順に並び替えられます。 もし`flipflag`が`false`なら、 添字は反変添字の順に従ってリネームされます。 もし`flipflag`が`true`なら、 リネームは共変添字の順に従って起こるでしょう。 ２つのリネームの組み合わせた効果が、それ自身によって、 どちらか１つよりも更に式を簡単にすることがしばしば起こります。

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) allsym:true;
      (%o2)                                true
      (%i3) g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%4],[%3])*
      ichr2([%2,%3],[u])*ichr2([%5,%6],[%1])*ichr2([%7,r],[%2])-
      g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%2],[u])*
      ichr2([%3,%5],[%1])*ichr2([%4,%6],[%3])*ichr2([%7,r],[%2]),noeval$
      (%i4) expr:ishow(%)$

             %4 %5  %6 %7      %3         u          %1         %2
      (%t4) g      g      ichr2      ichr2      ichr2      ichr2
                               %1 %4      %2 %3      %5 %6      %7 r

              %4 %5  %6 %7      u          %1         %3         %2
           - g      g      ichr2      ichr2      ichr2      ichr2
                                %1 %2      %3 %5      %4 %6      %7 r

      (%i5) flipflag:true;
      (%o5)                                true
      (%i6) ishow(rename(expr))$
             %2 %5  %6 %7      %4         u          %1         %3
      (%t6) g      g      ichr2      ichr2      ichr2      ichr2
                               %1 %2      %3 %4      %5 %6      %7 r

              %4 %5  %6 %7      u          %1         %3         %2
           - g      g      ichr2      ichr2      ichr2      ichr2
                                %1 %2      %3 %4      %5 %6      %7 r
      (%i7) flipflag:false;
      (%o7)                                false
      (%i8) rename(%th(2));
      (%o8)                                  0
      (%i9) ishow(rename(expr))$
             %1 %2  %3 %4      %5         %6         %7        u
      (%t9) g      g      ichr2      ichr2      ichr2     ichr2
                               %1 %6      %2 %3      %4 r      %5 %7

              %1 %2  %3 %4      %6         %5         %7        u
           - g      g      ichr2      ichr2      ichr2     ichr2
                                %1 %3      %2 %6      %4 r      %5 %7

  Package itensor ·

関数: show (expr)

  下付き添字として共変インデックス、上付き添字として反変インデックスを持つよう、 インデックスされたオブジェクトと一緒に`expr`を表示します。 微分インデックスは下付き添字として表示され、 コンマによって共変インデックスと区別されます。

  Package itensor ·Display functions ·

オプション変数: flipflag

  デフォルト: `false`. もし`false`なら反変添字の順に従って、 そうでなければ、共変添字の順に従って、 添字がリネームされます。

  もし`flipflag`が`false`なら、 `rename`は 左から右に現れるよう反変添字のリストを形成します (もし`true`なら共変添字について同様に)。 リストの最初のダミー添字は`%1`に、次は`%2`にというように、リネームされます。 そして、`rename`の後、並び替えが起こります。 (`rename`の下の例を参照してください。)

  Package itensor ·

関数: defcon (tensor_1)
関数: defcon (tensor_1, tensor_2, tensor_3)

  tensor_1に、 tensor_1とtensor_2の積の縮約が 適切な添字を持つtensor_3に帰着するという プロパティを与えます。 もし引数がtensor_1１つだけ与えれたなら、 , then the contraction of the product of 適切な添字を持つ任意の添字付きオブジェクト(`my_tensor`とします)とのtensor_1の積の縮約はその名前、すなわち、`my_tensor`と、実行された縮約を反映した添字の新しい集合を持つ添字付きオブジェクトをもたらします。 例えば、もし`imetric:g`なら、`defcon(g)`は 計量テンソルとの縮約を通して添字の上げ下げを実行します。 １つ以上の`defcon`を同じ添字付きオブジェクトに関して与えることができます; 特定の縮約に関して適用する最新のものが使われます。 `contractions`は、 `defcon`で縮約プロパティを与えられたそれら添字付きオブジェクトのリストです。

  Package itensor ·

関数: remcon (tensor_1, ..., tensor_n)
関数: remcon (all)

  tensor_1, ..., tensor_nからすべての縮約プロパティを取り除きます。 `remcon(all)`は、すべての添字付きオブジェクトから すべての縮約プロパティを取り除きます。

  Package itensor ·

関数: contract (expr)

  和と積の任意の組み合わせであり得る exprに関して テンソル縮約を実行します。 この関数は `defcon`関数に与えられた情報を使います。 最高の結果として、 `expr`は完全に展開されなければいけません。 もし項の分母の中に変数がないなら、 `ratexpand`は 和の積やべきを展開する 最速の方法です。 もしGCD消去が不要なら、 `gcd`スイッチは`false`でなければいけません。

  Package itensor ·

関数: indexed_tensor (tensor)

  値に関する美しい姿が既に `ichr1`, `ichr2`, `icurvature`とともにあるように存在する tensorに成分を割り当てる前に実行されなければいけません。 `icurvature`の下の例を参照してください。

  Package itensor ·

関数: components (tensor, expr)

  tensorの成分の値を与える式exprに添字値を割り当てることを許します。 その添字のすべてとともに起こるときはいつでも、これらは自動的にテンソルに代入されます。 テンソルは、形式`t([...],[...])`でなければいけません。 ここで形式`t([...],[...])`の中のリストのいずれかは空であり得えます。 exprは、 tensorと同じ自由添字を持つ他のオブジェクトを含む任意の添字付き式であり得ます。 成分がダミー添字を含む計量テンソルへ値を割り当てるのに使われる時、 複数のダミー添字の生成を避けるようにこれらの添字を定義するように注意しなければいけません。 この割り当ての削除は関数`remcomps`に与えられます。

  It is important to keep in mind that `components`はテンソル価についてだけ知る必要があり、特別な添字順序について知る必要がないことを覚えておくことは重要です。 このように、成分を、例えば、`x([i,-j],[])`, `x([-j,i],[])`または `x([i],[j])`すべてに割り当てることは、同じ結果、 すなわち、 価`(1,1)`を持つ`x`と名付けられたテンソルに割り当てられた 成分を生成します。

  成分を、4つの方法で添字付き式に割り当てることができます。 そのうちの2つは`components`コマンドの使用を含みます:

  1) 添字付き式として。例えば:

      (%i2) components(g([],[i,j]),e([],[i])*p([],[j]))$
      (%i3) ishow(g([],[i,j]))$
                                            i  j
      (%t3)                                e  p

  2) 行列として:

      (%i5) lg:-ident(4)$lg[1,1]:1$lg;

                                  [ 1   0    0    0  ]
                                  [                  ]
                                  [ 0  - 1   0    0  ]
      (%o5)                       [                  ]
                                  [ 0   0   - 1   0  ]
                                  [                  ]
                                  [ 0   0    0   - 1 ]

      (%i6) components(g([i,j],[]),lg);
      (%o6)                                done
      (%i7) ishow(g([i,j],[]))$
      (%t7)                                g
                                            i j
      (%i8) g([1,1],[]);
      (%o8)                                  1
      (%i9) g([4,4],[]);
      (%o9)                                 - 1

  3) 関数として。Maxima関数を使って、添字に基づいたテンソルの成分を指定することができます。 例えば、以下のコードは、 もし`h`が同じ数の共変添字と反変添字を持ち、微分添字を持たないなら、`kdelta`を`h`に割り当て、そうでなければ、`g`を割り当てます:

      (%i4) h(l1,l2,[l3]):=if length(l1)=length(l2) and length(l3)=0
        then kdelta(l1,l2) else apply(g,append([l1,l2], l3))$
      (%i5) ishow(h([i],[j]))$
                                                j
      (%t5)                               kdelta
                                                i
      (%i6) ishow(h([i,j],[k],l))$
                                           k
      (%t6)                               g
                                           i j,l

  4) Maximaのパターンマッチング機能、特に`defrule`と`applyb1`コマンド を使って:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) matchdeclare(l1,listp);
      (%o2)                                done
      (%i3) defrule(r1,m(l1,[]),(i1:idummy(),
            g([l1[1],l1[2]],[])*q([i1],[])*e([],[i1])))$

      (%i4) defrule(r2,m([],l1),(i1:idummy(),
            w([],[l1[1],l1[2]])*e([i1],[])*q([],[i1])))$

      (%i5) ishow(m([i,n],[])*m([],[i,m]))$

                                          i m
      (%t5)                              m    m
                                               i n

      (%i6) ishow(rename(applyb1(%,r1,r2)))$
                                 %1  %2  %3 m
      (%t6)                     e   q   w     q   e   g
                                               %1  %2  %3 n

  Package itensor ·

関数: remcomps (tensor)

  `components`関数で割り当てられたすべての値を tensorからアンバインドします。

  Package itensor ·

関数: showcomps (tensor)

  `components`コマンドを使って作られたように テンソルの成分割り当てを表示します。 以下の例で明示されるように、 行列が、`components`を使って 添字テンソルに割り当てられている時、 この関数は特に役に立ちます:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) load("itensor");
      (%o2)      /share/tensor/itensor.lisp
      (%i3) lg:matrix([sqrt(r/(r-2*m)),0,0,0],[0,r,0,0],
                      [0,0,sin(theta)*r,0],[0,0,0,sqrt((r-2*m)/r)]);
                     [         r                                     ]
                     [ sqrt(-------)  0       0              0       ]
                     [      r - 2 m                                  ]
                     [                                               ]
                     [       0        r       0              0       ]
      (%o3)          [                                               ]
                     [       0        0  r sin(theta)        0       ]
                     [                                               ]
                     [                                      r - 2 m  ]
                     [       0        0       0        sqrt(-------) ]
                     [                                         r     ]
      (%i4) components(g([i,j],[]),lg);
      (%o4)                                done
      (%i5) showcomps(g([i,j],[]));
                        [         r                                     ]
                        [ sqrt(-------)  0       0              0       ]
                        [      r - 2 m                                  ]
                        [                                               ]
                        [       0        r       0              0       ]
      (%t5)      g    = [                                               ]
                  i j   [       0        0  r sin(theta)        0       ]
                        [                                               ]
                        [                                      r - 2 m  ]
                        [       0        0       0        sqrt(-------) ]
                        [                                         r     ]
      (%o5)                                false

  `showcomps`コマンドは 2よりも高い階数のテンソルの成分も表示することができます。

  Package itensor ·

関数: idummy ()

  Increments `icounter`を1つ増やし、 形式`%n`の添字を値として返します。ここでnは正の整数です。 これは式を形成する際必要なダミー添字が既に使用中の添字とぶつからないことを保証します。 (`indices`の下の例を参照してください。)

  Package itensor ·

オプション変数: idummyx

  デフォルト値: `%`

  ダミー添字の接頭辞です。 (`indices`の下の例を参照してください。)

  Package itensor ·

オプション変数: icounter

  デフォルト値: `1`

  テンソルパッケージで次のダミー添字を生成する際使われる数値接尾を決定します。 接頭辞はオプション`idummy` (デフォルト: `%`)で決定されます。

  Package itensor ·

関数: kdelta (L1, L2)

  共変添字のリストL1と反変添字のリストL2を使って `itensor`パッケージで定義された 一般化されたKroneckerのデルタ関数です。 `kdelta([i],[j])`は通常のKroneckerデルタを返します。 コマンド`ev(expr,kdelta)`は `kdelta([],[])`を多様体の次元に含む 式の評価をもたらします。

  この表記法の乱用となることですが、 `itensor`は `kdelta`が2つの共変添字だけ、または、2つの反変添字だけを持つことも許し、 事実上、共(反)変「単位行列」を供給します。 これは厳密にはプログラミング目的としてみなされ、 `kdelta([i,j],[])`が有効なテンソルオブジェクトだということを意味するつもりではありません。

  Package itensor ·

関数: kdels (L1, L2)

  いくつかの計算で使われる、対称化されたKroneckerデルタ。 例えば:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) kdelta([1,2],[2,1]);
      (%o2)                                 - 1
      (%i3) kdels([1,2],[2,1]);
      (%o3)                                  1
      (%i4) ishow(kdelta([a,b],[c,d]))$
                                   c       d         d       c
      (%t4)                  kdelta  kdelta  - kdelta  kdelta
                                   a       b         a       b
      (%i4) ishow(kdels([a,b],[c,d]))$
                                   c       d         d       c
      (%t4)                  kdelta  kdelta  + kdelta  kdelta
                                   a       b         a       b

  Package itensor ·

関数: levi_civita (L)

  もしリストLが整数の偶置換から成るなら1を返し、 Lが奇置換なら成るなら-1を返し、 Lのいくつかの添字が繰り返しなら0を返す 置換(別名Levi-Civita)テンソルです。

  Package itensor ·

関数: lc2kdt (expr)

  Levi-Civitaシンボルを含む式を整理し、可能ならこれらをKroneckerデルタ式に変換します。 この関数と単にLevi-Civitaシンボルを評価することの主な違いは、 直接評価はしばしば数値添字を含むKronecker式に帰着することです。 これは、更なる整理を妨げるので、しばしば望ましくないことです。 `lc2kdt`関数はこの問題を避けて、 `rename`や`contract`を使って更に容易に整理される式をもたらします。

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) expr:ishow('levi_civita([],[i,j])
                       *'levi_civita([k,l],[])*a([j],[k]))$
                                        i j  k
      (%t2)                  levi_civita    a  levi_civita
                                             j            k l
      (%i3) ishow(ev(expr,levi_civita))$
                                        i j  k       1 2
      (%t3)                       kdelta    a  kdelta
                                        1 2  j       k l
      (%i4) ishow(ev(%,kdelta))$
                   i       j         j       i   k
      (%t4) (kdelta  kdelta  - kdelta  kdelta ) a
                   1       2         1       2   j

                                     1       2         2       1
                              (kdelta  kdelta  - kdelta  kdelta )
                                     k       l         k       l
      (%i5) ishow(lc2kdt(expr))$
                           k       i       j    k       j       i
      (%t5)               a  kdelta  kdelta  - a  kdelta  kdelta
                           j       k       l    j       k       l
      (%i6) ishow(contract(expand(%)))$
                                       i           i
      (%t6)                           a  - a kdelta
                                       l           l

  `lc2kdt`関数は時々計量テンソルを利用します。 もし前もって計量テンソルが`imetric`で定義されていなかったなら、 これはエラーになります。

      (%i7) expr:ishow('levi_civita([],[i,j])
                       *'levi_civita([],[k,l])*a([j,k],[]))$

                                       i j            k l
      (%t7)                 levi_civita    levi_civita    a
                                                           j k

      (%i8) ishow(lc2kdt(expr))$
      Maxima encountered a Lisp error:

       Error in $IMETRIC [or a callee]:
       $IMETRIC [or a callee] requires less than two arguments.

      Automatically continuing.
      To reenable the Lisp debugger set *debugger-hook* to nil.
      (%i9) imetric(g);
      (%o9)                                done
      (%i10) ishow(lc2kdt(expr))$
               %3 i       k   %4 j       l     %3 i       l   %4 j
      (%t10) (g     kdelta   g     kdelta   - g     kdelta   g
                          %3             %4               %3
                    k
              kdelta  ) a
                    %4   j k
      (%i11) ishow(contract(expand(%)))$
                                        l i    l i  j
      (%t11)                           a    - g    a
                                                    j

  Package itensor ·

関数: lc_l

  未評価のLevi-Civitaシンボル(`levi_civita`)を含む式のために使われる整理ルール。 `lc_u`と組み合わせて、 たくさんの式を、`levi_civita`の評価より、より効率的に整理するのに使うことができます。

  例えば:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) el1:ishow('levi_civita([i,j,k],[])*a([],[i])*a([],[j]))$
                                   i  j
      (%t2)                       a  a  levi_civita
                                                   i j k
      (%i3) el2:ishow('levi_civita([],[i,j,k])*a([i])*a([j]))$
                                             i j k
      (%t3)                       levi_civita      a  a
                                                    i  j
      (%i4) canform(contract(expand(applyb1(el1,lc_l,lc_u))));
      (%t4)                                  0
      (%i5) canform(contract(expand(applyb1(el2,lc_l,lc_u))));
      (%t5)                                  0

  Package itensor ·

関数: lc_u

  未評価のLevi-Civitaシンボル(`levi_civita`)を含む式のために使われる整理ルール。 `lc_l`と組み合わせて、 たくさんの式を、`levi_civita`の評価より、より効率的に整理するのに使うことができます。 詳しくは、`lc_l`を参照してください。

  Package itensor ·

関数: canten (expr)

  名前を変えて(`rename`を参照してください)、ダミー添字を置換することで、 exprを整理します。 `rename`は 微分がないテンソル積の和に制限されます。 本当に限定されていて、 もし`canform`が要求された整理を実行する能力がない時だけ使われるはずです。

  `canten`関数は、 引数が添字が完全に対称な式の時だけ数学的に正確な結果を返します。 この理由から、`canten`は、 もし`allsym`が`true`に設定されてないなら エラーを返します。

  Package itensor ·

関数: concan (expr)

  `canten`に似ていますが、添字縮約も実行します。

  Package itensor ·

#### 25.2.2 Tensor symmetries

オプション変数: allsym

  デフォルト: `false`。 もし`true`なら、すべての添字付きオブジェクトは共変、反変添字のすべてに関して対称と仮定されます。 もし`false`なら、これらの添字に関して、いかなる種類の対称性も仮定されません。 `iframe_flag`が`true`に設定されない限り、 微分添字はいつも対称と取られます。

  Package itensor ·

関数: decsym (tensor, m, n, [cov_1, cov_2, ...], [contr_1, contr_2, ...])

  m個の共変添字とn個の反変添字を持つtensorに関する 対称プロパティを宣言します。 cov_iとcontr_iは それぞれ、共変添字と反変添字の間の対称関係を表す擬似関数です。 これらは contravariant indices respectively. These are of the form 形式`symoper(index_1, index_2,...)`を取ります。 ここで`symoper`は `sym`, `anti`もしくは`cyc`のいずれかで、 and the index_iは tensorの添字の位置を示す整数です。 これは、tensorがindex_iに関してそれぞれ対称、反対称、巡回であると宣言します。 `symoper(all)`も対称条件に従う添字すべてを示す有効な形式です。 例えば、 5つの共変添字を持つオブジェクト`b`が与えられたとして、 `decsym(b,5,3,[sym(1,2),anti(3,4)],[cyc(all)])`は、 `b`が一番目と二番目の共変添字に対して対称であり、三番目、四番目の共変添字に対して反対称であり、反変添字すべてに対して巡回的であると宣言します。 対称宣言のリストのどれかは空であり得ます。 式整理を実行する関数は 以下の例で示すように`canform`です。

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) expr:contract( expand( a([i1, j1, k1], [])
                 *kdels([i, j, k], [i1, j1, k1])))$
      (%i3) ishow(expr)$

      (%t3)         a      + a      + a      + a      + a      + a
                     k j i    k i j    j k i    j i k    i k j    i j k

      (%i4) decsym(a,3,0,[sym(all)],[]);
      (%o4)                                done
      (%i5) ishow(canform(expr))$
      (%t5)                              6 a
                                            i j k
      (%i6) remsym(a,3,0);
      (%o6)                                done
      (%i7) decsym(a,3,0,[anti(all)],[]);
      (%o7)                                done
      (%i8) ishow(canform(expr))$
      (%t8)                                  0
      (%i9) remsym(a,3,0);
      (%o9)                                done
      (%i10) decsym(a,3,0,[cyc(all)],[]);
      (%o10)                               done
      (%i11) ishow(canform(expr))$
      (%t11)                        3 a      + 3 a
                                       i k j      i j k
      (%i12) dispsym(a,3,0);
      (%o12)                     [[cyc, [[1, 2, 3]], []]]

  Package itensor ·

関数: remsym (tensor, m, n)

  m個の共変添字とn個の反変添字を持つtensorから すべての対称プロパティを取り除きます。

  Package itensor ·

関数: canform (expr)
関数: canform (expr, rename)

  ダミー添字をリネームして、 それらに課せられた対称条件によって指令されたようにすべての添字を並べ替えることで、 exprを整理します。 もし`allsym`が`true`なら、 すべての添字は対称と仮定され、 そうでなければ、`decsym`宣言が提供する対称情報が使われます。 ダミー添字は`rename`関数に関するものと同じ方法でリネームされます。 `canform`が大きな式に適用される時、 計算にかなりの時間が費やされるかもしれません。 この時間は最初に式に対して`rename`をコールすることで短くできます。 `decsym`の下の例も参照してください。 注意: `canform`は いつも数学的に正しい結果を返しますが、 式を最も簡単な形式に完全に整理できないかもしれません。

  オプションの二番目のパラメータrenameは、 もし`false`に設定されたなら、リネームを抑制します。

  Package itensor ·

#### 25.2.3 Indicial tensor calculus

関数: diff (expr, v_1, [n_1, [v_2, n_2] ...])

  `itensor`のための能力に関して拡張された 通常のMaxima微分関数です。 It takes the derivative of v_1に関して n_1階、 v_2に関して n_2階、 というexprの微分を取ります。 テンソルパッケージでは、 v_iが1から変数 `dim`の値までの整数であるように 関数が修正されています。 これによって、 微分がリスト `vect_coords`の v_i番目の要素に関して実行されます。 もし `vect_coords`がアトム変数にバインドされているなら、 v_iが下付きしたその変数が 微分変数として使われます。 これは 座標名や、`x[1]`, `x[2]`, ... のような下付き名の配列を使うことを可能にします。

  更なる拡張は、 添字付き変数に関する微分を計算する能力を`diff`に追加します。 特にテンソルパッケージは 計量テンソルと、計量テンソルやその一階微分、二階微分に関する微分を含む 式を微分する方法を知っています。 この能力は 重力理論のLagrange形式を考える時、 特に役に立ちます。 作用原理からEinsteinテンソルと場の方程式を演繹することを可能にします。

  Package itensor ·

関数: idiff (expr, v_1, [n_1, [v_2, n_2] ...])

  添字微分。 独立変数に関して微分する`diff`と異なり、 `idiff)`は座標に関して微分するのにつかうことができます。 添字付きオブジェクトに関して， 結果的に、これは v_iを微分添字として追加することになります。 `iframe_flag`が `true`に設定されていない限り 続いて，微分添字が並び替えられます。

  `idiff`は計量テンソルの行列式も微分することができます。 従って、もし `imetric`が `G`にバインドされていたら、 `idiff(determinant(g),k)`は ダミー添字 `%i`が適当に選ばれて `2 * determinant(g) * ichr2([%i,k],[%i])`を返します。

  Package itensor ·

関数: liediff (v, ten)

  ベクトル場 vに対してテンソル式 tenのLie微分を計算します。 tenは任意の添字付きテンソル式でなければいけません; vはベクトル場の(添字なしの)名前でなければいけません。 例えば:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) ishow(liediff(v,a([i,j],[])*b([],[k],l)))$
             k    %2            %2          %2
      (%t2) b   (v   a       + v   a     + v   a    )
             ,l       i j,%2    ,j  i %2    ,i  %2 j

                                %1  k        %1  k      %1  k
                            + (v   b      - b   v    + v   b   ) a
                                    ,%1 l    ,l  ,%1    ,l  ,%1   i j

  Package itensor ·

関数: rediff (ten)

  テンソル式 tenの中の`idiff`コマンドすべてを評価します。

  Package itensor ·

関数: undiff (expr)

  exprと同値な、 添字付きオブジェクトの微分すべてが`idiff`関数の名詞形で置き換えられた 式を返します。 引数はもし微分が実行されていたらその添字付きオブジェクトをもたらします。 微分された添字付きオブジェクトを exprを生じるある関数定義で置き換えて、 `ev(expr, idiff)`で微分を実行したい時、 これは役に立ちます。

  Package itensor ·

関数: evundiff (expr)

  `undiff`の実行と同値ですが、`ev`と `rediff`が続きます。

  この演算のポイントは 微分形式で直接評価できない式を簡単に評価することです。 例えば、以下はエラーをもたらします:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) icurvature([i,j,k],[l],m);
      Maxima encountered a Lisp error:

       Error in $ICURVATURE [or a callee]:
       $ICURVATURE [or a callee] requires less than three arguments.

      Automatically continuing.
      To reenable the Lisp debugger set *debugger-hook* to nil.

  しかし、もし `icurvature`は名詞形で入っているなら、 `evundiff`を使って評価できます:

      (%i3) ishow('icurvature([i,j,k],[l],m))$
                                               l
      (%t3)                          icurvature
                                               i j k,m
      (%i4) ishow(evundiff(%))$
                   l              l         %1           l           %1
      (%t4) - ichr2        - ichr2     ichr2      - ichr2       ichr2
                   i k,j m        %1 j      i k,m        %1 j,m      i k

                   l              l         %1           l           %1
            + ichr2        + ichr2     ichr2      + ichr2       ichr2
                   i j,k m        %1 k      i j,m        %1 k,m      i j

  注意: Maximaの以前のバージョンでは、 Christoffel記号の微分形式も評価できませんでした。 これは現在修正されています。 だから `evundiff`はもはやこのような式に関しては不要です:

      (%i5) imetric(g);
      (%o5)                                done
      (%i6) ishow(ichr2([i,j],[k],l))$
             k %3
            g     (g         - g         + g        )
                    j %3,i l    i j,%3 l    i %3,j l
      (%t6) -----------------------------------------
                                2

                               k %3
                              g     (g       - g       + g      )
                               ,l     j %3,i    i j,%3    i %3,j
                            + -----------------------------------
                                               2

  Package itensor ·

関数: flush (expr, tensor_1, tensor_2, ...)

  exprにおいて、 微分添字を持たない tensor_iをすべて0にします。

  Package itensor ·

関数: flushd (expr, tensor_1, tensor_2, ...)

  exprにおいて、 微分添字を持つ tensor_iをすべて0にします。

  Package itensor ·

関数: flushnd (expr, tensor, n)

  以下の例で例示されるように、 exprにおいて、 n以上の微分添字を持つ微分されたオブジェクト tensorをすべて0にします。

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) ishow(a([i],[J,r],k,r)+a([i],[j,r,s],k,r,s))$
                                      J r      j r s
      (%t2)                          a      + a
                                      i,k r    i,k r s
      (%i3) ishow(flushnd(%,a,3))$
                                           J r
      (%t3)                               a
                                           i,k r

  Package itensor ·

関数: coord (tensor_1, tensor_2, ...)

  tensor_iに、 その名前がtensor_iの1つである反変ベクトルの微分がKroneckerデルタをもたらす 座標微分プロパティを与えます。 例えば、 もし `coord(x)`が実行されたら、 `idiff(x([],[i]),j)`は `kdelta([i],[j])`を与えます。 `coord`はこのプロパティを持つ添字付きオブジェクトすべてのリストです。

  Package itensor ·

関数: remcoord (tensor_1, tensor_2, ...)
関数: remcoord (all)

  `tensor_i`から 関数 `coord`がもたらした座標微分プロパティを削除します。 `remcoord(all)`は添字付きオブジェクトすべてからこのプロパティを削除します。

  Package itensor ·

関数: makebox (expr)

  `show`と同じように exprを表示します; しかし、 exprに現れるテンソル d’Alembert演算子はすべて記号 `[]`を使って示されます。 例えば、 `[]p([m],[n])`は `g([],[i,j])*p([m],[n],i,j)`を表します。

  Package itensor ·

関数: conmetderiv (expr, tensor)

  計量テンソルの共変と反変形式両方(現在の制約)の常微分を含む式を整理します。 例えば、 以下に見られるように、 `conmetderiv`は 反変計量テンソルの微分をChristoffelシンボルに結びつけます:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) ishow(g([],[a,b],c))$
                                            a b
      (%t2)                                g
                                            ,c
      (%i3) ishow(conmetderiv(%,g))$
                               %1 b      a       %1 a      b
      (%t3)                 - g     ichr2     - g     ichr2
                                         %1 c              %1 c

  Package itensor ·

関数: simpmetderiv (expr)
関数: simpmetderiv (expr[, stop])

  計量テンソルの微分の積を含む式を整理します。 特に、 `simpmetderiv`は2つの恒等式を知っています:

         ab        ab           ab                 a
        g   g   + g   g     = (g   g  )   = (kdelta )   = 0
         ,d  bc        bc,d         bc ,d          c ,d

  従って、

         ab          ab
        g   g   = - g   g
         ,d  bc          bc,d

  と

        ab          ab
       g   g     = g   g
        ,j  ab,i    ,i  ab,j

  これはChristoffel記号の対称性の結果です。

  `simpmetderiv`関数はオプションパラメータを1つ取ります。 それは、与えられた時、 積式の中の最初にうまくいった代入の後、関数が停止するようにします。 `simpmetderiv`関数は “正準”順序を積添字に適用する方法を決めるグローバル変数 flipflagも利用します。

  まとめると、 これらの機能は そうでなければ遂行困難か不可能な強力な式整理を達成するのに使うことができます。 これは、 縮約式を得るために`simpmetderiv`の部分的な整理の特長を明示的に使う 以下の例を通じて例示されます:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) imetric(g);
      (%o2)                                done
      (%i3) ishow(g([],[a,b])*g([],[b,c])*g([a,b],[],d)*g([b,c],[],e))$
                                   a b  b c
      (%t3)                       g    g    g      g
                                             a b,d  b c,e
      (%i4) ishow(canform(%))$

      errexp1 has improper indices
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i5) ishow(simpmetderiv(%))$
                                   a b  b c
      (%t5)                       g    g    g      g
                                             a b,d  b c,e
      (%i6) flipflag:not flipflag;
      (%o6)                                true
      (%i7) ishow(simpmetderiv(%th(2)))$
                                     a b  b c
      (%t7)                         g    g    g    g
                                     ,d   ,e   a b  b c
      (%i8) flipflag:not flipflag;
      (%o8)                                false
      (%i9) ishow(simpmetderiv(%th(2),stop))$
                                     a b  b c
      (%t9)                       - g    g    g      g
                                          ,e   a b,d  b c
      (%i10) ishow(contract(%))$
                                          b c
      (%t10)                           - g    g
                                          ,e   c b,d

  Weylテンソルの縮約を整理するために `simpmetderiv`と `conmetderiv`を一緒に使う例として、 `weyl.dem`も参照してください。

  Package itensor ·

関数: flush1deriv (expr, tensor)

  exprにおいて、 微分添字を1つだけ持つ tensorをすべて0にします。

  Package itensor ·

#### 25.2.4 Tensors in curved spaces

関数: imetric (g)
システム変数: imetric

  変数 `imetric:g`を割り当てることで計量を指定します。 加えて、 コマンド `defcon(g),defcon(g, g, kdelta)`を実行することで 計量 gの縮約プロパティが設定されます。 (デフォルトではバインドされていない)変数 `imetric`は `imetric(g)`コマンドが割り当てる計量にバインドされます。

  Package itensor ·

関数: idim (n)

  計量の次元を設定します。 与えられた次元でLevi-Civita記号の反対称プロパティも初期化します。

  Package itensor ·

関数: ichr1 ([i, j, k])

  以下の定義を介して第一種Christoffel記号をもたらします。

             (g      + g      - g     )/2 .
               ik,j     jk,i     ij,k

  特定の計量で Christoffel記号を評価するには、 `chr2`の下の例のように 変数 `imetric`が名前を割り当てられなければいけません。

  Package itensor ·

関数: ichr2 ([i, j], [k])

  以下の定義を介して第二種Christoffel記号をもたらします。

                             ks
         ichr2([i,j],[k]) = g    (g      + g      - g     )/2
                                   is,j     js,i     ij,s

  Package itensor ·

関数: icurvature ([i, j, k], [h])

  第二種Christoffel記号(`ichr2`)を使った Riemann曲率テンソルをもたらします。 以下の表記法が使われます:

                  h             h            h         %1         h
        icurvature     = - ichr2      - ichr2     ichr2    + ichr2
                  i j k         i k,j        %1 j      i k        i j,k
                                  h          %1
                           + ichr2      ichr2
                                  %1 k       i j

  Package itensor ·

関数: covdiff (expr, v_1, v_2, ...)

  第二種Christoffel記号(`ichr2`)を使って、 変数 v_iに対する exprの共変微分をもたらします。 これらを評価するには、 `ev(expr,ichr2)`を使わなければ行けません。

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) entertensor()$
      Enter tensor name: a;
      Enter a list of the covariant indices: [i,j];
      Enter a list of the contravariant indices: [k];
      Enter a list of the derivative indices: [];
                                            k
      (%t2)                                a
                                            i j
      (%i3) ishow(covdiff(%,s))$
                   k         %1     k         %1     k
      (%t3)     - a     ichr2    - a     ichr2    + a
                   i %1      j s    %1 j      i s    i j,s

                   k     %1
            + ichr2     a
                   %1 s  i j
      (%i4) imetric:g;
      (%o4)                                  g
      (%i5) ishow(ev(%th(2),ichr2))$
               %1 %4  k
              g      a     (g       - g       + g      )
                      i %1   s %4,j    j s,%4    j %4,s
      (%t5) - ------------------------------------------
                                  2

          %1 %3  k
         g      a     (g       - g       + g      )
                 %1 j   s %3,i    i s,%3    i %3,s
       - ------------------------------------------
                             2
          k %2  %1
         g     a    (g        - g        + g       )
                i j   s %2,%1    %1 s,%2    %1 %2,s     k
       + ------------------------------------------- + a
                              2                         i j,s

      (%i6)

  Package itensor ·

関数: lorentz_gauge (expr)

  反変添字と同一の微分添字を持つ exprの中で 添字付きオブジェクトすべてに0を代入することで、 Lorentz条件を課します。

  Package itensor ·

関数: igeodesic_coords (expr, name)

  expr内の、未微分 Christoffel記号と 計量テンソルの一階微分を消すようにします。 `igeodesic_coords`関数での nameは (もし expr)の中で現れるなら) 計量 nameを参照します。 一方で、接続係数は 名前 `ichr1`か `ichr2`でコールされなければいけません。 以下の例は、 `igeodesic_coords`関数を使った、 Riemann曲率テンソルが満たす巡回恒等式の検証を例示します。

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) ishow(icurvature([r,s,t],[u]))$
                   u            u         %1         u
      (%t2) - ichr2      - ichr2     ichr2    + ichr2
                   r t,s        %1 s      r t        r s,t

                                                    u         %1
                                             + ichr2     ichr2
                                                    %1 t      r s
      (%i3) ishow(igeodesic_coords(%,ichr2))$
                                       u            u
      (%t3)                       ichr2      - ichr2
                                       r s,t        r t,s
      (%i4) ishow(igeodesic_coords(icurvature([r,s,t],[u]),ichr2)+
                  igeodesic_coords(icurvature([s,t,r],[u]),ichr2)+
                  igeodesic_coords(icurvature([t,r,s],[u]),ichr2))$
                   u            u            u            u
      (%t4) - ichr2      + ichr2      + ichr2      - ichr2
                   t s,r        t r,s        s t,r        s r,t

                                                   u            u
                                            - ichr2      + ichr2
                                                   r t,s        r s,t
      (%i5) canform(%);
      (%o5)                                  0

  Package itensor ·

#### 25.2.5 Moving frames

今ではMaximaは 動標構(moving frame)を使って計算を実行する能力があります。 これらは直交標構(テトラド、四脚場)か任意系であり得ます。

標構(frame)を使うには、 最初に`iframe_flag`を `true`に設定しなければいけません。 これにより、 計算内で、 Christoffel記号, `ichr1`と `ichr2`が もっと一般的な標構(frame)の接続係数 `icc1`と `icc2`に置き換えられることになります。 特に、 `covdiff`と `icurvature`の振る舞いが変わります。

系は2つのテンソルで定義されます: 逆標枠場 (`ifri`, 双対基底四脚場)と 標構計量(frame metric) `ifg`。 標構計量は直交標構の単位行列、すなわち、 Minkowski時空での直交標構のLorentz計量です。 逆標枠場は標構基底(単位ベクトル)を定義します。 標枠と標構計量に縮約プロパティが定義されます。

`iframe_flag`がtrueなら、 たくさんの `itensor`式が、 `imetric`が上付き添字と下付き添字に関して定義する計量の代わりに 標構計量 `ifg`を使います。

重要: 変数 `iframe_flag`を `true`に設定することは `defcon`や `imetric`のコールによって定義された計量の縮約プロパティを 未定義に戻しません。 もし標枠場が使われるなら、 `imetric`関数を呼び出さず、 変数 `imetric`に名前を割り当てて計量を定義することが最良です。

Maximaはこれら2つのテンソルを使って、 接続係数 (`icc1`と `icc2`)の一部を形成する 標構係数 (`ifc1`と `ifc2`)を定義します。 以下の例がそれを例示します:

    (%i1) load("itensor");
    (%o1)      /share/tensor/itensor.lisp
    (%i2) iframe_flag:true;
    (%o2)                                true
    (%i3) ishow(covdiff(v([],[i]),j))$
                                   i        i     %1
    (%t3)                         v   + icc2     v
                                   ,j       %1 j
    (%i4) ishow(ev(%,icc2))$
                                   %1     i       i
    (%t4)                         v   ifc2     + v
                                          %1 j    ,j
    (%i5) ishow(ev(%,ifc2))$
                              %1    i %2                i
    (%t5)                    v   ifg     ifc1        + v
                                             %1 j %2    ,j
    (%i6) ishow(ev(%,ifc1))$

                %1    i %2
               v   ifg     (ifb        - ifb        + ifb       )
                               j %2 %1      %2 %1 j      %1 j %2     i
    (%t6)      -------------------------------------------------- + v
                                       2                             ,j

    (%i7) ishow(ifb([a,b,c]))$
                                                       %3    %4
    (%t7)               (ifri        - ifri       ) ifr   ifr
                             a %3,%4       a %4,%3     b     c

もし `iframe_bracket_form`フラグが `false`に設定されているなら 標構ブラケット(frame bracket) (`ifb`)を計算するのに代わりの方法が使われます:

    (%i8) block([iframe_bracket_form:false],ishow(ifb([a,b,c])))$
                                    %6    %5        %5      %6
    (%t8)              ifri     (ifr   ifr     - ifr     ifr  )
                           a %5     b     c,%6      b,%6    c

関数: iframes ()

  Maximaのこのバージョン以来、 `ifr`と `ifri`に関する縮約恒等式がいつも定義されます。 as is the frame bracket (`ifb`), この関数は何もしません。

  Package itensor ·

変数: ifb

  標構ブラケット(frame bracket)。 標構計量の接続係数への寄与が標構ブラケットを使って表されます:

                - ifb      + ifb      + ifb
                     c a b      b c a      a b c
      ifc1    = --------------------------------
          abc                  2

  標構ブラケット自身は 標枠と標構計量を使って定義されます。 `frame_bracket_form`の値に依存して 2つの代わりの計算方法が使われます。 もし true (デフォルト)か、もし `itorsion_flag`が `true`なら:

                d      e                                      f
      ifb =  ifr    ifr   (ifri      - ifri      - ifri    itr   )
         abc    b      c       a d,e       a e,d       a f    d e

  そうでないなら:

                   e      d        d      e
      ifb    = (ifr    ifr    - ifr    ifr   ) ifri
         abc       b      c,e      b,e    c        a d

  Package itensor ·

変数: icc1

  第一種接続係数。 `itensor`では、以下のように定義されます。

      icc1    = ichr1    - ikt1    - inmc1
          abc        abc       abc        abc

  この式では、 もし `iframe_flag`が trueなら、 Christoffel記号 `ichr1`が 標構接続係数 `ifc1`に置き換えられます。 もし `itorsion_flag`が `false`なら、 `ikt1`は省略されます。 もし標構基底が使われるなら、 ねじれが標構ブラケットの一部として既に計算されているので、 その時にも `ikt1`は省略されます。 最後に、 `inonmet_flag`が `false`なら、 `inmc1`は存在しません。

  Package itensor ·

変数: icc2

  第二種接続係数。 `itensor`では、以下のように定義されます。

          c         c        c         c
      icc2   = ichr2   - ikt2   - inmc2
          ab        ab       ab        ab

  この式では、 もし `iframe_flag`が trueなら、 Christoffel記号 `ichr2`が 標構接続係数 `ifc2`に置き換えられます。 もし `itorsion_flag`が `false`なら、 `ikt2`は省略されます。 もし標構基底が使われるなら、 ねじれが標構ブラケットの一部として既に計算されているので、 その時にも `ikt1`は省略されます。 最後に、 `inonmet_flag`が `false`なら、 `inmc1`は存在しません。

  Package itensor ·

変数: ifc1

  (Ricci回転係数としても知られている)第一種標構係数。 このテンソルは 標構計量の第一種接続係数への寄与を表します。 以下のように定義されます:

                - ifb      + ifb      + ifb
                     c a b      b c a      a b c
      ifc1    = --------------------------------
          abc                   2

  Package itensor ·

変数: ifc2

  第二種標構係数。 このテンソルは標構計量の第一種接続係数への寄与を表します。 必要に応じて、標構ブラケット (`ifb`)の、 適切な上付き、下付き添字での置換として定義されます:

          c       cd
      ifc2   = ifg   ifc1
          ab             abd

  Package itensor ·

変数: ifr

  標枠。 標構計量(`ifg`)を形成するために 逆標構場 (`ifri`)を 縮約します。

  Package itensor ·

変数: ifri

  逆標構場。 (双対基底ベクトル)標構基底を指定します。 標構計量と一緒に、 標構に基づいた計算すべての基底を形成します。

  Package itensor ·

変数: ifg

  標構計量。 `kdelta`のデフォルトですが、 `components`を使って変えることができます。

  Package itensor ·

変数: ifgi

  逆標構計量。 標構計量 (`ifg`)を `kdelta`に縮約します。

  Package itensor ·

オプション変数: iframe_bracket_form

  デフォルト値: `true`

  標構ブラケット (`ifb`)が如何に計算されるか指定します。

  Package itensor ·

#### 25.2.6 Torsion and nonmetricity

Maximaは今では、ねじれと非計量性を考慮することができます。 フラグ `itorsion_flag`が `true`に設定されている時、 ねじれの寄与が 接続係数に加えられます。 同様に、 フラグ `inonmet_flag`が trueの時、 非計量性成分が含まれます。

変数: inm

  非計量性ベクトル。 共形非計量性は計量テンソルの共変微分を通して定義されます。 `inonmet_flag`が `true`に設定されている時 通常零の計量テンソルの共変微分は以下のように評価されます:

      g     =- g  inm
       ij;k     ij   k

  Package itensor ·

変数: inmc1

  非計量ベクトル成分の共変置換。 以下のように定義されます:

                 g   inm  - inm  g   - g   inm
                  ab    c      a  bc    ac    b
      inmc1    = ------------------------------
           abc                 2

  (もし標構計量を使うなら、`ifg`を `g`に代入します。)

  Package itensor ·

変数: inmc2

  非計量ベクトル成分の反変置換。 もし `inonmet_flag`が `true`なら 接続係数で使われます。 以下のように定義されます:

                            c         c         cd
                -inm  kdelta  - kdelta  inm  + g   inm  g
           c        a       b         a    b          d  ab
      inmc2   = -------------------------------------------
           ab                        2

  (もし標構計量を使うなら、`ifg`を `g`に代入します。)

  Package itensor ·

変数: ikt1

  (コントーションとしても知られる)ねじれテンソルの共変置換。 以下のように定義されます:

                        d           d       d
                -g   itr  - g    itr   - itr   g
                  ad    cb    bd    ca      ab  cd
      ikt1    = ----------------------------------
          abc                   2

  (もし標構計量を使うなら、`ifg`を `g`に代入します。)

  Package itensor ·

変数: ikt2

  (コントーションとしても知られる)ねじれテンソルの共変置換。 以下のように定義されます:

          c     cd
      ikt2   = g   ikt1
          ab           abd

  (もし標構計量を使うなら、`ifg`を `g`に代入します。)

  Package itensor ·

変数: itr

  ねじれテンソル。 以下の例で例示されるように、 ねじれを伴う計量に関してスカラー関数上の繰り返される共変微分は計算されません:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) imetric:g;
      (%o2)                                  g
      (%i3) covdiff( covdiff( f( [], []), i), j)
                            - covdiff( covdiff( f( [], []), j), i)$
      (%i4) ishow(%)$
                                         %4              %2
      (%t4)                    f    ichr2    - f    ichr2
                                ,%4      j i    ,%2      i j
      (%i5) canform(%);
      (%o5)                                  0
      (%i6) itorsion_flag:true;
      (%o6)                                true
      (%i7) covdiff( covdiff( f( [], []), i), j)
                            - covdiff( covdiff( f( [], []), j), i)$
      (%i8) ishow(%)$
                                 %8             %6
      (%t8)             f    icc2    - f    icc2    - f     + f
                         ,%8     j i    ,%6     i j    ,j i    ,i j
      (%i9) ishow(canform(%))$
                                         %1             %1
      (%t9)                     f    icc2    - f    icc2
                                 ,%1     j i    ,%1     i j
      (%i10) ishow(canform(ev(%,icc2)))$
                                         %1             %1
      (%t10)                    f    ikt2    - f    ikt2
                                 ,%1     i j    ,%1     j i
      (%i11) ishow(canform(ev(%,ikt2)))$
                            %2 %1                    %2 %1
      (%t11)          f    g      ikt1       - f    g      ikt1
                       ,%2            i j %1    ,%2            j i %1
      (%i12) ishow(factor(canform(rename(expand(ev(%,ikt1))))))$
                                 %3 %2            %1       %1
                           f    g      g      (itr    - itr   )
                            ,%3         %2 %1     j i      i j
      (%t12)               ------------------------------------
                                            2
      (%i13) decsym(itr,2,1,[anti(all)],[]);
      (%o13)                               done
      (%i14) defcon(g,g,kdelta);
      (%o14)                               done
      (%i15) subst(g,nounify(g),%th(3))$
      (%i16) ishow(canform(contract(%)))$
                                                 %1
      (%t16)                           - f    itr
                                          ,%1    i j

  Package itensor ·

#### 25.2.7 Exterior algebra

`itensor`パッケージは 完全反対称共変テンソル場上の 演算を実行できます。 回数 (0,L)の完全反対称テンソル場は 微分L形式に対応します。 これらのオブジェクト上で、 外積やウェッジ積として知られる乗算が定義されます。

不運にも、 すべての作者がウェッジ積の定義に同意しません。 何人の作者は反対称の概念に対応した定義を好みます: これらの仕事では、 2つのベクトル場のウェッジ積は 例えば、以下のように定義されます。

                a a  - a a
                 i j    j i
     a  /\ a  = -----------
      i     j        2

もっと一般的に、 p形式や q形式の積は以下のように定義されます。

                           1     k1..kp l1..lq
    A       /\ B       = ------ D              A       B
     i1..ip     j1..jq   (p+q)!  i1..ip j1..jq  k1..kp  l1..lq

ここで、 `D`はKroneckerのデルタを表します。

しかし、他の作者は容積要素の概念に対応する “幾何的”定義を好みます:

    a  /\ a  = a a  - a a
     i     j    i j    j i

そいて、一般的な場合，

                           1    k1..kp l1..lq
    A       /\ B       = ----- D              A       B
     i1..ip     j1..jq   p! q!  i1..ip j1..jq  k1..kp  l1..lq

`itensor`はテンソル代数パッケージなので、 これら2つの定義の前者がより自然なもののようです。 しかし、多くの応用は後者の定義を使います。 このジレンマを解決するに、 ウェッジ積の振る舞いを制御するフラグが実装されました: もし `igeowedge_flag`が `false` (デフォルト)なら、 前者の "テンソル的"定義が使われ、 層でないなら，後者の"幾何的"定義が適用されます。

演算子: ~

  ウェッジ積演算子は ティルデ `~`で示されれます。 これは二項演算子です。 引数は、 スカラ、階数1の共変テンソル、 共変添字すべてに関して反対称と宣言された階数 `l`の共変テンソルを含む式 でなければいけません。

  以下の例のように、 ウェッジ積演算子の振る舞いは `igeowedge_flag` フラグで制御されます:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) ishow(a([i])~b([j]))$
                                       a  b  - b  a
                                        i  j    i  j
      (%t2)                            -------------
                                             2
      (%i3) decsym(a,2,0,[anti(all)],[]);
      (%o3)                                done
      (%i4) ishow(a([i,j])~b([k]))$
                                a    b  + b  a    - a    b
                                 i j  k    i  j k    i k  j
      (%t4)                     ---------------------------
                                             3
      (%i5) igeowedge_flag:true;
      (%o5)                                true
      (%i6) ishow(a([i])~b([j]))$
      (%t6)                            a  b  - b  a
                                        i  j    i  j
      (%i7) ishow(a([i,j])~b([k]))$
      (%t7)                     a    b  + b  a    - a    b
                                 i j  k    i  j k    i k  j

  Package itensor ·Operators ·

演算子: |

  縦線 `|`は "ベクトルの縮約"二項演算子を示します。 完全反対称共変テンソルが反変ベクトルと縮約される時、 結果は、どの添字が縮約に使われるかに関わらず同じです。 このように、 添字に無関係な方法で縮約演算子を定義することが可能です。

  `itensor`パッケージでは、 ベクトルとの縮約は常に 文字通りの並べ順で最初の添字に対して実行されます。 これは `|`演算子を含む式のより良い整理を保証します。 例えば:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) decsym(a,2,0,[anti(all)],[]);
      (%o2)                                done
      (%i3) ishow(a([i,j],[])|v)$
                                          %1
      (%t3)                              v   a
                                              %1 j
      (%i4) ishow(a([j,i],[])|v)$
                                           %1
      (%t4)                             - v   a
                                               %1 j

  `|`演算子で使われるテンソルは は共変添字に対して完全反対称と宣言されなければいけないことが 本質的であることに注意してください。 そうでないなら、結果は正しくありません。

  Package itensor ·Operators ·

関数: extdiff (expr, i)

  添字 iに対する exprの外積を計算します。 外微分は形式的に 偏微分演算子のウェッジ積で微分形式として定義されます。 そんなように、 演算子も `igeowedge_flag`の設定で制御されます。 例えば:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) ishow(extdiff(v([i]),j))$
                                        v    - v
                                         j,i    i,j
      (%t2)                             -----------
                                             2
      (%i3) decsym(a,2,0,[anti(all)],[]);
      (%o3)                                done
      (%i4) ishow(extdiff(a([i,j]),k))$
                                 a      - a      + a
                                  j k,i    i k,j    i j,k
      (%t4)                      ------------------------
                                            3
      (%i5) igeowedge_flag:true;
      (%o5)                                true
      (%i6) ishow(extdiff(v([i]),j))$
      (%t6)                             v    - v
                                         j,i    i,j
      (%i7) ishow(extdiff(a([i,j]),k))$
      (%t7)                    - (a      - a      + a     )
                                   k j,i    k i,j    j i,k

  Package itensor ·

関数: hodge (expr)

  exprのHodge双対を計算します。 例えば:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) imetric(g);
      (%o2)                            done
      (%i3) idim(4);
      (%o3)                            done
      (%i4) icounter:100;
      (%o4)                             100
      (%i5) decsym(A,3,0,[anti(all)],[])$

      (%i6) ishow(A([i,j,k],[]))$
      (%t6)                           A
                                       i j k
      (%i7) ishow(canform(hodge(%)))$
                                %1 %2 %3 %4
                     levi_civita            g        A
                                             %1 %102  %2 %3 %4
      (%t7)          -----------------------------------------
                                         6
      (%i8) ishow(canform(hodge(%)))$
                       %1 %2 %3 %8            %4 %5 %6 %7
      (%t8) levi_civita            levi_civita            g
                                                           %1 %106
                                   g        g        g      A         /6
                                    %2 %107  %3 %108  %4 %8  %5 %6 %7
      (%i9) lc2kdt(%)$

      (%i10) %,kdelta$

      (%i11) ishow(canform(contract(expand(%))))$
      (%t11)                     - A
                                    %106 %107 %108

  Package itensor ·

オプション変数: igeowedge_flag

  デフォルト値: `false`

  ウェッジ積と外微分の振る舞いを制御します。 `false` (デフォルト)に設定された時、 微分形式の概念は 完全反対称共変テンソル場のそれに対応します。 `true`に設定された時、 微分形式は容積要素の概念に一致します。

  Package itensor ·

#### 25.2.8 Exporting TeX expressions

`itensor`パッケージは テンソル式をTexにエクスポートするための限定サポートを提供します。 `itensor`式は関数コールとして現れるので、 いつもの Maxima `tex`コマンドは 期待された出力を生成しません。 代わりに`tentex`コマンドを試すことができます。 これは、テンソル式を適切に添字が付けられたTeXオブジェクトに翻訳しようとします。

関数: tentex (expr)

  以下の例のように、 `tentex`関数を使うには、 最初に`tentex`をロードしなければいけません:

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) load("tentex");
      (%o2)       /share/tensor/tentex.lisp
      (%i3) idummyx:m;
      (%o3)                                  m
      (%i4) ishow(icurvature([j,k,l],[i]))$
                  m1       i           m1       i           i
      (%t4)  ichr2    ichr2     - ichr2    ichr2     - ichr2
                  j k      m1 l        j l      m1 k        j l,k

                                                            i
                                                     + ichr2
                                                            j k,l
      (%i5) tentex(%)$
      $$\Gamma_{j\,k}^{m_1}\,\Gamma_{l\,m_1}^{i}-\Gamma_{j\,l}^{m_1}\,
       \Gamma_{k\,m_1}^{i}-\Gamma_{j\,l,k}^{i}+\Gamma_{j\,k,l}^{i}$$

  コンパイルエラーに導かれるTeX式でのパーセント符号の出現を避けるための、 `idummyx`割り当ての使用に注意してください。

  注意せよ: このバージョンの`tentex`関数は幾分実験的です。

  Package itensor ·TeX output ·

#### 25.2.9 Interfacing with ctensor

`itensor`パッケージは `ctensor`パッケージの文脈で実行することができる Maximaコードを生成する能力があります。 この仕事を実行する関数は `ic_convert`です。

関数: ic_convert (eqn)

  `itensor`方程式 eqnを `ctensor`割り当て文に変換します。 添字付きオブジェクトが配列に変換される一方で、 ダミー添字上の暗黙の和は明示的にされます。

  (配列下付き添字は添字付きオブジェクトの反変添字が続く共変の順です。) 添字付きオブジェクトの微分は、 微分添字で下に添えられた `ct_coords`に対して取られる `diff`の名詞形に 置き換えられます。 Christoffel記号 `ichr1`と `ichr2`は それぞれ、`lcs`と `mcs`に翻訳されます。 もし `metricconvert`が `true`なら、 2つの共変(反変)添字を持つ計量はすべて `lg` (`ug`)にリネームされます。 更に、 自由添字すべての上で足される`do`ループが導入されます。 なので、 ただ `ev`するだけで 変換される割り当て分を評価することができます。 以下の例はこの関数の特長を例示します。

      (%i1) load("itensor");
      (%o1)      /share/tensor/itensor.lisp
      (%i2) eqn:ishow(t([i,j],[k])=f([],[])*g([l,m],[])*a([],[m],j)
            *b([i],[l,k]))$
                                   k        m   l k
      (%t2)                       t    = f a   b    g
                                   i j      ,j  i    l m
      (%i3) ic_convert(eqn);
      (%o3) for i thru dim do (for j thru dim do (
             for k thru dim do
              t        : f sum(sum(diff(a , ct_coords ) b
               i, j, k                   m           j   i, l, k

       g    , l, 1, dim), m, 1, dim)))
        l, m
      (%i4) imetric(g);
      (%o4)                                done
      (%i5) metricconvert:true;
      (%o5)                                true
      (%i6) ic_convert(eqn);
      (%o6) for i thru dim do (for j thru dim do (
             for k thru dim do
              t        : f sum(sum(diff(a , ct_coords ) b
               i, j, k                   m           j   i, l, k

       lg    , l, 1, dim), m, 1, dim)))
         l, m

  Package itensor ·Package ctensor ·

#### 25.2.10 Reserved words

以下の Maximaワードは `itensor`パッケージで内部的に使われているので、 再定義してはいけません:

      Keyword    Comments
      ------------------------------------------
      indices2() Internal version of indices()
      conti      Lists contravariant indices
      covi       Lists covariant indices of a indexed object
      deri       Lists derivative indices of an indexed object
      name       Returns the name of an indexed object
      concan
      irpmon
      lc0
      _lc2kdt0
      _lcprod
      _extlc

Next: atensor, Previous: itensor, Up: Top [Contents][Index]

## 26 ctensor

Next: Functions and Variables for ctensor, Previous: ctensor, Up: ctensor [Contents][Index]

### 26.1 Introduction to ctensor

`ctensor`は、成分テンソル操作パッケージです。 `ctensor`パッケージを使うには、`load("ctensor")`をタイプしてください。 `ctensor`と対話的セッションを始めるには、`csetup()`をタイプしてください。 最初に、多様体の次元を指定するよう尋ねられます。 もし次元が、2, 3, 4のいずれかなら、 座標のリストがそれぞれ、`[x,y]`, `[x,y,z]`, `[x,y,z,t]`に設定されます。 これらの名前は、座標の新しいリストを(以下で記述する)変数`ct_coords` に 割り当てることで変えることができ、ユーザーは、これについて尋ねられます。 座標名が他のオブジェクト定義と衝突することを避けるように、注意が払われなければいけません。

次に、ユーザーは計量を直接、または順序位置(ordinal position)を指定してファイルから、入力します。 計量は行列`lg`に保存されます。 最後に、計量の逆元が計算され、 行列`ug`に保存されます。 すべての計算を冪級数で実行するオプションがあります。

サンプルプロトコルは、 例として、(Schwarzschild解に至る)Einsteinの真空方程式を導出する問題に適用される 静的な球対称計量(標準座標)に関して、以下のように開始されます。 `ctensor`の関数の多くは例のように標準計量に対して表示されます。

    (%i1) load("ctensor");
    (%o1)      /share/tensor/ctensor.mac
    (%i2) csetup();
    Enter the dimension of the coordinate system:
    4;
    Do you wish to change the coordinate names?
    n;
    Do you want to
    1. Enter a new metric?

    2. Enter a metric from a file?

    3. Approximate a metric with a Taylor series?
    1;

    Is the matrix  1. Diagonal  2. Symmetric  3. Antisymmetric  4. General
    Answer 1, 2, 3 or 4
    1;
    Row 1 Column 1:
    a;
    Row 2 Column 2:
    x^2;
    Row 3 Column 3:
    x^2*sin(y)^2;
    Row 4 Column 4:
    -d;

    Matrix entered.
    Enter functional dependencies with the DEPENDS function or 'N' if none
    depends([a,d],x);
    Do you wish to see the metric?
    y;
                              [ a  0       0        0  ]
                              [                        ]
                              [     2                  ]
                              [ 0  x       0        0  ]
                              [                        ]
                              [         2    2         ]
                              [ 0  0   x  sin (y)   0  ]
                              [                        ]
                              [ 0  0       0       - d ]
    (%o2)                                done
    (%i3) christof(mcs);
                                                a
                                                 x
    (%t3)                          mcs        = ---
                                      1, 1, 1   2 a

                                                 1
    (%t4)                           mcs        = -
                                       1, 2, 2   x

                                                 1
    (%t5)                           mcs        = -
                                       1, 3, 3   x

                                                d
                                                 x
    (%t6)                          mcs        = ---
                                      1, 4, 4   2 d

                                                  x
    (%t7)                          mcs        = - -
                                      2, 2, 1     a

                                               cos(y)
    (%t8)                         mcs        = ------
                                     2, 3, 3   sin(y)

                                                   2
                                              x sin (y)
    (%t9)                      mcs        = - ---------
                                  3, 3, 1         a

    (%t10)                   mcs        = - cos(y) sin(y)
                                3, 3, 2

                                                d
                                                 x
    (%t11)                         mcs        = ---
                                      4, 4, 1   2 a
    (%o11)                               done

Tensors ·Share packages ·Package ctensor ·

Previous: Introduction to ctensor, Up: ctensor [Contents][Index]

### 26.2 Functions and Variables for ctensor

#### 26.2.1 Initialization and setup

関数: csetup ()

  パッケージを初期化し、ユーザーに計量を対話的に入力可能にする `ctensor`(成分テンソル)パッケージの関数 より詳細は`ctensor`を参照してください。

  Package ctensor ·

関数: cmetric (dis)
関数: cmetric ()

  計量の逆元を計算し、将来の計算のためパッケージを設定する `ctensor`(成分テンソル)パッケージの関数

  もし`cframe_flag`が`false`なら、 関数は逆計量`ug`を(ユーザー定義の)行列`lg`から計算します。 計量の行列式も計算され、変数`gdet`に保存されます。 更に、パッケージは計量が対角的か調べ、結果に従って`diagmetric`の値を設定します。 もしオプション引数disが渡されて、それが`false`でないなら、 ユーザーは計量の逆元を見るように促されます。

  もし`cframe_flag`が`true`なら、 関数は`fri` (逆標構行列)と`lfg`(標構計量)の値が定義されていると考えます。 これらから、標構行列`fr`と逆標構計量`ufg`が計算されます。

  Package ctensor ·

関数: ct_coordsys (coordinate_system, extra_arg)
関数: ct_coordsys (coordinate_system)

  あらかじめ定義された座標系と計量を設定します。 引数coordinate_systemは以下のシンボルのいずれかです:

       SYMBOL             Dim Coordinates     Description/comments
       ------------------------------------------------------------------
       cartesian2d           2  [x,y]             Cartesian 2D 座標系
       polar                 2  [r,phi]           極座標系
       elliptic              2  [u,v]             楕円座標系
       confocalelliptic      2  [u,v]             共焦点楕円座標
       bipolar               2  [u,v]             二極座標系
       parabolic             2  [u,v]             放物座標系
       cartesian3d           3  [x,y,z]           Cartesian 3D 座標系
       polarcylindrical      3  [r,theta,z]       円筒z極2D
       ellipticcylindrical   3  [u,v,z]           円筒z楕円2D
       confocalellipsoidal   3  [u,v,w]           共焦点楕円
       bipolarcylindrical    3  [u,v,z]           円筒z二極2D
       paraboliccylindrical  3  [u,v,z]           円筒z放物2D
       paraboloidal          3  [u,v,phi]         Paraboloidal coords.
       conical               3  [u,v,w]           円錐座標
       toroidal              3  [u,v,phi]         環状座標
       spherical             3  [r,theta,phi]     球座標系
       oblatespheroidal      3  [u,v,phi]         偏球座標系
       oblatespheroidalsqrt  3  [u,v,phi]
       prolatespheroidal     3  [u,v,phi]         長形球座標系
       prolatespheroidalsqrt 3  [u,v,phi]
       ellipsoidal           3  [r,theta,phi]     楕円体座標系
       cartesian4d           4  [x,y,z,t]         Cartesian 4D 座標系
       spherical4d           4  [r,theta,eta,phi] 球 4D 座標系
       exteriorschwarzschild 4  [t,r,theta,phi]   Schwarzschild 計量
       interiorschwarzschild 4  [t,z,u,v]         内部 Schwarzschild 計量
       kerr_newman           4  [t,r,theta,phi]   荷電軸対称計量

  `coordinate_system`は 座標変数を含むリストが続く変換関数のリストでもあり得ます。 例えば、 以下のように球計量を指定できます:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
            r*sin(theta),[r,theta,phi]]);
      (%o2)                                done
      (%i3) lg:trigsimp(lg);
                                 [ 1  0         0        ]
                                 [                       ]
                                 [     2                 ]
      (%o3)                      [ 0  r         0        ]
                                 [                       ]
                                 [         2    2        ]
                                 [ 0  0   r  cos (theta) ]
      (%i4) ct_coords;
      (%o4)                           [r, theta, phi]
      (%i5) dim;
      (%o5)                                  3

  `cframe_flag`が `true`の時 変換関数も使うことができます:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) cframe_flag:true;
      (%o2)                                true
      (%i3) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
            r*sin(theta),[r,theta,phi]]);
      (%o3)                                done
      (%i4) fri;
      (%o4)
       [cos(phi)cos(theta) -cos(phi) r sin(theta) -sin(phi) r cos(theta)]
       [                                                                ]
       [sin(phi)cos(theta) -sin(phi) r sin(theta)  cos(phi) r cos(theta)]
       [                                                                ]
       [    sin(theta)           r cos(theta)                0          ]

      (%i5) cmetric();
      (%o5)                                false
      (%i6) lg:trigsimp(lg);
                                 [ 1  0         0        ]
                                 [                       ]
                                 [     2                 ]
      (%o6)                      [ 0  r         0        ]
                                 [                       ]
                                 [         2    2        ]
                                 [ 0  0   r  cos (theta) ]

  オプションの引数 extra_argは以下のいずれかです:

  `cylindrical`は `ct_coordsys`に追加の極座標を結びつけるように言います。

  `minkowski`は `ct_coordsys`に 負の計量符号を持つ追加の座標を結びつけるように言います。

  `all`は `ct_coordsys`に 計量を設定した後、 `cmetric`と `christof(false)`をコールするように言います。

  もしグローバル変数 `verbose`が `true`に設定されているなら、 `ct_coordsys`は、 `cframe_flag`の値に依存して、 `dim`, `ct_coords`と、 `lg`か `lfg`のいずれかと `fri`の値を表示します。

  Package ctensor ·

関数: init_ctensor ()

  `ctensor`パッケージを初期化します。

  `init_ctensor`関数は`ctensor`パッケージを再初期化します。 それは`ctensor`が使う配列、行列すべてを削除し、 フラグすべてをリセットし、 `dim`を4にリセットし、 標構計量を Lorentz標構にリセットします。

  Package ctensor ·

#### 26.2.2 The tensors of curved space

`ctensor`パッケージの 主な目的は曲がった空間(時間)のテンソル、 最も顕著には一般相対性理論で使われるテンソルを計算することです。

計量基底が使われる時、 `ctensor`は以下のテンソルを計算できます:

     lg  -- ug
       \      \
        lcs -- mcs -- ric -- uric
                  \      \       \
                   \      tracer - ein -- lein
                    \
                     riem -- lriem -- weyl
                         \
                          uriem

`ctensor`は動標構を使って機能することもできます。 `cframe_flag`が `true`に設定されている時、 以下のテンソルを計算できます:

     lfg -- ufg
         \
     fri -- fr -- lcs -- mcs -- lriem -- ric -- uric
          \                       |  \      \       \
           lg -- ug               |   weyl   tracer - ein -- lein
                                  |\
                                  | riem
                                  |
                                  \uriem

関数: christof (dis)

  `ctensor` (成分テンソル)パッケージの関数。 各種Christoffel記号を計算します。 引数 disは どの結果をすぐに表示するか決めます。 第一種と第二種Christoffel記号は それぞれ配列 `lcs[i,j,k]`と `mcs[i,j,k]`に格納され、 最初の2つの添字に対して対称と定義されます。 もし `christof`の引数が `lcs`か `mcs`なら それぞれ、`lcs[i,j,k]`か `mcs[i,j,k]`の固有の非零値が 表示されます。 もし引数が `all`なら、 `lcs[i,j,k]`と `mcs[i,j,k]`の固有の非零値が表示されます。 もし引数が `false`なら、 要素の表示はされません。 配列要素 `mcs[i,j,k]`は 最後の添字が反変であるような方法で定義されます。

  Package ctensor ·

関数: ricci (dis)

  `ctensor` (成分テンソル)パッケージの関数。 `ricci`は Ricciテンソルの共変(対称)成分 `ric[i,j]`を計算します。 もし引数 disが `true`なら、 非零成分が表示されます。

  Package ctensor ·

関数: uricci (dis)

  この関数は最初にRicciテンソルの共変成分 `ric[i,j]`を計算します。 そして、混合 Ricciテンソルが反変計量テンソルを使って計算されます。 もし引数 disの値が `true`なら これらの(添字 `i`は共変で、添字 `j`は反変の)混合成分 `uric[i,j]` は直接表示されます。 そうでないなら、 `ricci(false)`は 結果を表示することなく、単に配列 `uric[i,j]`の要素を計算します。

  Package ctensor ·

関数: scurvature ()

  与えられた計量を持つ Riemannian多様体の (Ricciテンソルを縮約することで得られる)スカラ曲率を返します。

  Package ctensor ·

関数: einstein (dis)

  `ctensor` (成分テンソル)パッケージの関数。 `einstein`は、 (関数 `christof`と `ricci`を使って) Christoffel記号と Ricciテンソルを得られた後、 混合 Einsteinテンソルを計算します。 もし引数 disが `true`なら、 混合 Einsteinテンソル `ein[i,j]`の非零値が表示されます。 ここで `j`は反変添字です。 変数 `rateinstein`は これらの成分上の有理整理をもたらします。 もし `ratfac`が `true`なら、 成分は因数分解もされます。

  Package ctensor ·

関数: leinstein (dis)

  共変 Einsteinテンソル。 `leinstein`は 配列 `lein`に共変 Einsteinテンソルの値を格納します。 共変 Einsteinテンソルは、 計量テンソルを掛けることで 混合 Einsteinテンソル `ein`から計算されます。 もし引数 disが `true`なら、 共変 Einsteinテンソルの非零値が表示されます。

  Package ctensor ·

関数: riemann (dis)

  `ctensor` (成分テンソル)パッケージの関数。 `riemann`は 与えられた計量と対応するChristoffel記号から Riemann曲率テンソルを計算します。 以下の添字慣例が使われます:

                      l      _l       _l       _l   _m    _l   _m
       R[i,j,k,l] =  R    = |      - |      + |    |   - |    |
                      ijk     ij,k     ik,j     mk   ij    mj   ik

  この表記法は `itensor`パッケージとその `icurvature`関数で使われる表記法と 一致しています。 もしオプション引数 disが `true`なら、 固有の非零成分 `riem[i,j,k,l]`が表示されます。 Einsteinテンソルと同様に ユーザーが設定する様々なスイッチが Riemannテンソルの成分の整理を制御します。 もし `ratriemann`が `true`なら、 有理整理がされます。 もし `ratfac`が `true`なら、 成分のそれぞれは因数分解もされます。

  もし変数 `cframe_flag`が `false`なら、 Riemannテンソルは Christoffel記号から直接計算されます。 もし `cframe_flag`が `true`なら、 共変 Riemannテンソルは 標構場係数から最初に計算されます。

  Package ctensor ·

関数: lriemann (dis)

  共変 Riemannテンソル (`lriem[]`).

  配列 `lriem`として 共変 Riemannテンソルを計算します。 もし引数 disが `true`なら、 固有の非零値が表示されます。

  もし変数 `cframe_flag`が `true`なら、 共変 Riemannテンソルは 標構場係数から直接計算されます。 そうでないなら、 (3,1) Riemannテンソルが最初に計算されます。

  添字順序の情報は `riemann`を参照してください。

  Package ctensor ·

関数: uriemann (dis)

  配列要素 `uriem[i,j,k,l]`として Riemann曲率テンソルの反変成分を計算します。 もし disが `true`なら、これらが表示されます。

  Package ctensor ·

関数: rinvariant ()

  テンソル

      lriem[i,j,k,l]*uriem[i,j,k,l].

  を縮約することで得られるKretschmann不変量 (`kinvariant`)を形成します。

  このオブジェクトは非常に大きくなるかもしれないので、 自動的には整理されません。

  Package ctensor ·

関数: weyl (dis)

  Weylの共形テンソルを計算します。 もし引数 disが `true`なら、 非零成分 `weyl[i,j,k,l]`がユーザーに表示されます。 そうでないなら、これらの成分は 単に計算され、格納されます。 もしスイッチ `ratweyl`が `true`に設定されているなら、 成分は有理整理されます; もし `ratfac`が `true`なら、 結果は因数分解もされます。

  Package ctensor ·

#### 26.2.3 Taylor series expansion

`ctensor`パッケージは 結果が Taylor級数近似であると仮定することで、結果を切り詰める機能を持ちます。 この振る舞いは `ctayswitch`変数で制御されます; trueに設定されている時、 結果を整理する際に `ctensor`は内部的に関数 `ctaylor`を利用します。

以下の `ctensor`関数が `ctaylor`関数を呼び出します:

        Function     Comments
        ---------------------------------
        christof()   For mcs only
        ricci()
        uricci()
        einstein()
        riemann()
        weyl()
        checkdiv()

関数: ctaylor ()

  `ctaylor`関数は、 `taylor`を使ってその後`ratdisrep`をコールすることで 引数をTaylor級数に変換することで、 引数を切り詰めます。 これは 展開変数 `ctayvar`に関してより高い項を落とす合わせ効果を持ちます。 落とす項の次数は`ctaypov`で定義されます; 級数展開が実行される点は `ctaypt`で指定されます。

  例として、 Minkowski計量の置換である簡単な計量を考えます。 追加の制約なしでは、 対角計量でさえ はるかに複雑すぎるEinsteinテンソルの式を生成します:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) ratfac:true;
      (%o2)                                true
      (%i3) derivabbrev:true;
      (%o3)                                true
      (%i4) ct_coords:[t,r,theta,phi];
      (%o4)                         [t, r, theta, phi]
      (%i5) lg:matrix([-1,0,0,0],[0,1,0,0],[0,0,r^2,0],
                      [0,0,0,r^2*sin(theta)^2]);
                              [ - 1  0  0         0        ]
                              [                            ]
                              [  0   1  0         0        ]
                              [                            ]
      (%o5)                   [          2                 ]
                              [  0   0  r         0        ]
                              [                            ]
                              [              2    2        ]
                              [  0   0  0   r  sin (theta) ]
      (%i6) h:matrix([h11,0,0,0],[0,h22,0,0],[0,0,h33,0],[0,0,0,h44]);
                                  [ h11   0    0    0  ]
                                  [                    ]
                                  [  0   h22   0    0  ]
      (%o6)                       [                    ]
                                  [  0    0   h33   0  ]
                                  [                    ]
                                  [  0    0    0   h44 ]
      (%i7) depends(l,r);
      (%o7)                               [l(r)]
      (%i8) lg:lg+l*h;
            [ h11 l - 1      0          0                 0            ]
            [                                                          ]
            [     0      h22 l + 1      0                 0            ]
            [                                                          ]
      (%o8) [                        2                                 ]
            [     0          0      r  + h33 l            0            ]
            [                                                          ]
            [                                    2    2                ]
            [     0          0          0       r  sin (theta) + h44 l ]
      (%i9) cmetric(false);
      (%o9)                                done
      (%i10) einstein(false);
      (%o10)                               done
      (%i11) ntermst(ein);
      [[1, 1], 62]
      [[1, 2], 0]
      [[1, 3], 0]
      [[1, 4], 0]
      [[2, 1], 0]
      [[2, 2], 24]
      [[2, 3], 0]
      [[2, 4], 0]
      [[3, 1], 0]
      [[3, 2], 0]
      [[3, 3], 46]
      [[3, 4], 0]
      [[4, 1], 0]
      [[4, 2], 0]
      [[4, 3], 0]
      [[4, 4], 46]
      (%o12)                               done

  しかし、もしこの例を 変数 `l`に対して線形という近似として 再研鑽するなら、 もっと簡潔な式を得ます:

      (%i14) ctayswitch:true;
      (%o14)                               true
      (%i15) ctayvar:l;
      (%o15)                                 l
      (%i16) ctaypov:1;
      (%o16)                                 1
      (%i17) ctaypt:0;
      (%o17)                                 0
      (%i18) christof(false);
      (%o18)                               done
      (%i19) ricci(false);
      (%o19)                               done
      (%i20) einstein(false);
      (%o20)                               done
      (%i21) ntermst(ein);
      [[1, 1], 6]
      [[1, 2], 0]
      [[1, 3], 0]
      [[1, 4], 0]
      [[2, 1], 0]
      [[2, 2], 13]
      [[2, 3], 2]
      [[2, 4], 0]
      [[3, 1], 0]
      [[3, 2], 2]
      [[3, 3], 9]
      [[3, 4], 0]
      [[4, 1], 0]
      [[4, 2], 0]
      [[4, 3], 0]
      [[4, 4], 9]
      (%o21)                               done
      (%i22) ratsimp(ein[1,1]);
                               2      2  4               2     2
      (%o22) - (((h11 h22 - h11 ) (l )  r  - 2 h33 l    r ) sin (theta)
                                    r               r r

                                  2               2      4    2
                    - 2 h44 l    r  - h33 h44 (l ) )/(4 r  sin (theta))
                             r r                r

  この能力は 例えば、 重力源から遠く、弱い場極限で取り組む時に 役に立つかもしれません。

  Package ctensor ·

#### 26.2.4 Frame fields

変数 `cframe_flag`が trueに設定している時、 `ctensor`パッケージは 動標構(moving frame)を使って計算を実行します。

関数: frame_bracket (fr, fri, diagframe)

  標構(frame)ブラケット (`fb[]`).

  以下の定義に従って標構ブラケットを計算します:

         c          c         c        d     e
      ifb   = ( ifri    - ifri    ) ifr   ifr
         ab         d,e       e,d      a     b

  Package ctensor ·

#### 26.2.5 Algebraic classification

`ctensor`の(2004年11月時点で)新しい特長は 4次元時空計量のPetrov分類を計算する能力です。 この機能のデモンストレーションは、 ファイル `share/tensor/petrov.dem`参照してください。

関数: nptetrad ()

  Newman-Penroseヌルテトラド(null tetrad) (`np`)と上付き添字対応物 (`npi`)を計算します。 例えば、 `petrov`を参照してください。

  ヌルテトラドは 計量符号 (-,+,+,+)を持つ4次元直交標構計量が使われいるという仮定の上で 構成されます。 ヌルテトラドの成分は、 以下のように、 逆標構行列に関係します:

      np  = (fri  + fri ) / sqrt(2)
        1       1      2

      np  = (fri  - fri ) / sqrt(2)
        2       1      2

      np  = (fri  + %i fri ) / sqrt(2)
        3       3         4

      np  = (fri  - %i fri ) / sqrt(2)
        4       3         4

  Package ctensor ·

関数: psi (dis)

  5つの Newman-Penrose係数 `psi[0]`...`psi[4]`を計算します。 もし `dis`が `true`に設定されているなら、 係数が表示されます。 例は `petrov`を参照してください。

  これらの係数は 座標基底に関して、Weylテンソルから計算されます。 もし標構基底が使われるなら、 最初にWeylテンソルが座標基底に変換されます。 座標基底は計算に関して高価な手続きであり得ます。 この理由で、 いくつかの場合、 Weylテンソルを計算する前に まず座標基底を使うことはより都合がいいかも知れません。 しかし、 Newman-Penroseヌルテトラドを構成することは標構基底を要求することに注意してください。 それ故に、 重要な一連の計算は、標構基底で始めることができます。 標構基底は、後で (`cmetric`が自動的に計算する) `lg`と `ug`を計算するのに使われます。 この時点で、 Christoffel記号を計算し始める前に `cframe_flag`を falseに設定することで 座標基底に戻ることができます。 後の段階で標構基底に変えることは、 標構基底で計算したいくつか、座標基底でのいくつかと 2つを識別する方法がないまま、テンソルの混ざった状態で終わるかもしれないので、 矛盾する結果をもたらすかもしれません。

  Package ctensor ·

関数: petrov ()

  `psi[0]`...`psi[4]`で特徴付けられる 計量のPetrov分類を計算します。

  例えば、以下は Kerr計量の Petrov分類を得る方法を例示します:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) (cframe_flag:true,gcd:spmod,ctrgsimp:true,ratfac:true);
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) ug:invert(lg)$
      (%i5) weyl(false);
      (%o5)                                done
      (%i6) nptetrad(true);
      (%t6) np =

      [ sqrt(r - 2 m)           sqrt(r)                                 ]
      [---------------   ---------------------    0            0        ]
      [sqrt(2) sqrt(r)   sqrt(2) sqrt(r - 2 m)                          ]
      [                                                                 ]
      [ sqrt(r - 2 m)            sqrt(r)                                ]
      [---------------  - ---------------------   0            0        ]
      [sqrt(2) sqrt(r)    sqrt(2) sqrt(r - 2 m)                         ]
      [                                                                 ]
      [                                          r      %i r sin(theta) ]
      [       0                    0          -------   --------------- ]
      [                                       sqrt(2)       sqrt(2)     ]
      [                                                                 ]
      [                                          r       %i r sin(theta)]
      [       0                    0          -------  - ---------------]
      [                                       sqrt(2)        sqrt(2)    ]

                                   sqrt(r)         sqrt(r - 2 m)
      (%t7) npi = matrix([- ---------------------,---------------, 0, 0],
                            sqrt(2) sqrt(r - 2 m) sqrt(2) sqrt(r)

                sqrt(r)            sqrt(r - 2 m)
      [- ---------------------, - ---------------, 0, 0],
         sqrt(2) sqrt(r - 2 m)    sqrt(2) sqrt(r)

                 1               %i
      [0, 0, ---------, --------------------],
             sqrt(2) r  sqrt(2) r sin(theta)

                 1                 %i
      [0, 0, ---------, - --------------------])
             sqrt(2) r    sqrt(2) r sin(theta)

      (%o7)                                done
      (%i7) psi(true);
      (%t8)                              psi  = 0
                                            0

      (%t9)                              psi  = 0
                                            1

                                                m
      (%t10)                             psi  = --
                                            2    3
                                                r

      (%t11)                             psi  = 0
                                            3

      (%t12)                             psi  = 0
                                            4
      (%o12)                               done
      (%i12) petrov();
      (%o12)                                 D

  Petrov分類関数は以下の文献で発表されたアルゴリズムに基づいています。

  "Classifying geometries in general relativity: III Classification in practice" by Pollney, Skea, and d’Inverno, Class. Quant. Grav. 17 2885-2902 (2000).

  いくつかの簡単なテストケースを除いて、 2004年12月19日時点、実装はテストされていなく、 エラーを含みそうです。

  Package ctensor ·

#### 26.2.6 Torsion and nonmetricity

`ctensor`は ねじれ係数と非計量性係数を計算し、接続係数内に含める能力を持ちます。

ねじれ係数はゆーざーが供給するテンソル `tr`から計算されます。 `tr`は階数 (2,1)テンソルでなければいけません。 これから、 ねじれ係数 `kt`は以下の公式に従って計算されます:

                  m          m      m
           - g  tr   - g   tr   - tr   g
              im  kj    jm   ki     ij  km
    kt   = -------------------------------
      ijk                 2

      k     km
    kt   = g   kt
      ij         ijm

混合添字テンソルだけが計算され、配列 `kt`に格納されることに注意してください。

非計量性係数はユーザーが供給する非計量性ベクトル `nm`から計算されます。 これから、 非計量性係数 `nmc`は以下のように計算されます:

                 k    k        km
           -nm  D  - D  nm  + g   nm  g
       k      i  j    i   j         m  ij
    nmc  = ------------------------------
       ij                2

ここで、DはKroneckerのデルタを表します。

`ctorsion_flag`が `true`に設定されている時、 `kt`の値が `christof`で計算された 混合添字付き接続係数から引かれ、 `mcs`に格納されます。 同様に、もし `cnonmet_flag`が `true`に設定されているなら、 `nmc`の値が 混合添字付き接続係数から引かれます。

もし必要なら、 `christof`は、 `kt`と `nm`を計算するために 関数 `contortion`と `nonmetricity`をコールします。

関数: contortion (tr)

  ねじれテンソル trから(2,1)コントーション(contortion)係数を計算します。

  Package ctensor ·

関数: nonmetricity (nm)

  非計量性ベクトル nmから(2,1)非計量性係数を計算します。

  Package ctensor ·

#### 26.2.7 Miscellaneous features

関数: ctransform (M)

  任意の平方対称行列 M上で座標変換を実行する `ctensor` (成分テンソル)パッケージの関数。 ユーザーは変換を定義する函数を入力しなければいけません。 (以前`transform`と呼ばれていました。)

  Package ctensor ·

関数: findde (A, n)

  n次元の平方配列 A要素に対応する 独自の(unique)微分方程式(式)のリストを返します。 現在、 nは2か3を指定できます `deindex`は これらの独自の微分方程式に従う Aの添字を含む グローバルリストです。 2次元配列であるEinsteinテンソル (`ein`)に関して、 もし以下の例で計量に関して計算するなら、 `findde`は以下の独立微分方程式を与えます:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) derivabbrev:true;
      (%o2)                                true
      (%i3) dim:4;
      (%o3)                                  4
      (%i4) lg:matrix([a, 0, 0, 0], [ 0, x^2, 0, 0],
                                    [0, 0, x^2*sin(y)^2, 0], [0,0,0,-d]);
                                [ a  0       0        0  ]
                                [                        ]
                                [     2                  ]
                                [ 0  x       0        0  ]
      (%o4)                     [                        ]
                                [         2    2         ]
                                [ 0  0   x  sin (y)   0  ]
                                [                        ]
                                [ 0  0       0       - d ]
      (%i5) depends([a,d],x);
      (%o5)                            [a(x), d(x)]
      (%i6) ct_coords:[x,y,z,t];
      (%o6)                            [x, y, z, t]
      (%i7) cmetric();
      (%o7)                                done
      (%i8) einstein(false);
      (%o8)                                done
      (%i9) findde(ein,2);
                                                  2
      (%o9) [d  x - a d + d, 2 a d d    x - a (d )  x - a  d d  x
              x                     x x         x        x    x

                                                    2          2
                                + 2 a d d   - 2 a  d , a  x + a  - a]
                                         x       x      x
      (%i10) deindex;
      (%o10)                     [[1, 1], [2, 2], [4, 4]]

  Package ctensor ·

関数: cograd ()

  スカラ関数の 共変勾配を計算します。 `contragrad`が以下で例示する例のように ユーザーは対応するベクトル名を選べます。

  Package ctensor ·

関数: contragrad ()

  スカラ関数の反変勾配を計算します。 Computes the contravariant gradient of a scalar function allowing Schwarzschild計量に関する以下の例が例示するように ユーザーは対応するベクトル名を選べます:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) derivabbrev:true;
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) depends(f,r);
      (%o4)                               [f(r)]
      (%i5) cograd(f,g1);
      (%o5)                                done
      (%i6) listarray(g1);
      (%o6)                            [0, f , 0, 0]
                                            r
      (%i7) contragrad(f,g2);
      (%o7)                                done
      (%i8) listarray(g2);
                                     f  r - 2 f  m
                                      r        r
      (%o8)                      [0, -------------, 0, 0]
                                           r

  Package ctensor ·

関数: dscalar ()

  依存性が関数に宣言されるとすぐ、 スカラ関数のテンソルd’Alembert演算子を計算します。 例えば:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) derivabbrev:true;
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) depends(p,r);
      (%o4)                               [p(r)]
      (%i5) factor(dscalar(p));

                                2
                          p    r  - 2 m p    r + 2 p  r - 2 m p
                           r r           r r        r          r
      (%o5)               --------------------------------------
                                             2
                                            r

  Package ctensor ·

関数: checkdiv ()

  ベクトル場(発散)の対応するn個の成分を印字することで (最初の添字が共変でなければいけない)混合二階テンソルの共変発散を計算します。 ここでn = `dim`です。 もし関数の引数が `g`なら、 Einsteinテンソルの発散が形成され、零にならなければいけません。 加えて、発散(ベクトル)は 配列名 `div`を与えられます。

  Package ctensor ·

関数: cgeodesic (dis)

  `ctensor` (成分テンソル)パッケージの関数。 `cgeodesic`は 与えられた計量での運動の測地方程式を計算します。 それらは配列 `geod[i]`に格納されます。 もし引数 disが `true`なら、 これらの方程式が表示されます。

  Package ctensor ·

関数: bdvac (f)

  Brans- Dicke重力理論の 真空場の方程式の 共変成分を生成します。 スカラ場は引数 fで指定されます。 fは、 例えば、`'p(x)`のように、 関数依存性を持つ(クォートされた)関数名でなければいけません。

  二階共変場テンソルの成分は配列 `bd`で表されます。

  Package ctensor ·

関数: invariant1 ()

  R^2の不変密度に関する 混合Euler- Lagrangeテンソル(場の方程式)を生成します。 場の方程式は `inv1`と名付けられた配列の成分です。

  Package ctensor ·

関数: invariant2 ()

  *** NOT YET IMPLEMENTED ***

  `ric[i,j]*uriem[i,j]`の不変密度に関する 混合Euler- Lagrangeテンソル(場の方程式)を生成します。 場の方程式は `inv2`と名付けられた配列の成分です。

  Package ctensor ·

関数: bimetric ()

  *** NOT YET IMPLEMENTED ***

  Rosenの二計量(bimetric)理論の場の方程式を生成します。 場の方程式は `rosen`と名付けられた配列の成分です。

  Package ctensor ·

#### 26.2.8 Utility functions

関数: diagmatrixp (M)

  もし Mが対角行列か対角 (2D) 配列なら `true`を返します。

  Package ctensor ·Predicate functions ·

関数: symmetricp (M)

  もし Mが対称行列か対称 (2D) 配列なら `true`を返します。

  Package ctensor ·Predicate functions ·

関数: ntermst (f)

  ユーザーに 二重に下付き添字テンソル(配列) fの「サイズ」のquick pictureを与えます。 二番目の要素が 一番目の要素が指定する成分のNTERMSに対応する2つの要素のリストを印字します。 この方法で、 非零式をすばやく見つけて整理を試みることが可能です。

  Package ctensor ·

関数: cdisplay (ten)

  多次元配列で表されるように、 テンソル tenの要素すべてを表示します。 他のタイプの変数はもちろん、 階数0と1のテンソルが `ldisplay`を使ったように表示されます。 階数2のテンソルは 2次元行列として表示され、 より高い階数のテンソルは2次元行列のリストとして表示されます。 例えば、 Schwarzschild計量のRiemannテンソルは以下のように見ることができます:

      (%i1) load("ctensor");
      (%o1)       /share/tensor/ctensor.mac
      (%i2) ratfac:true;
      (%o2)                                true
      (%i3) ct_coordsys(exteriorschwarzschild,all);
      (%o3)                                done
      (%i4) riemann(false);
      (%o4)                                done
      (%i5) cdisplay(riem);
                [ 0               0                   0           0     ]
                [                                                       ]
                [                              2                        ]
                [      3 m (r - 2 m)   m    2 m                         ]
                [ 0  - ------------- + -- - ----      0           0     ]
                [            4          3     4                         ]
                [           r          r     r                          ]
                [                                                       ]
      riem    = [                                m (r - 2 m)            ]
          1, 1  [ 0               0              -----------      0     ]
                [                                     4                 ]
                [                                    r                  ]
                [                                                       ]
                [                                           m (r - 2 m) ]
                [ 0               0                   0     ----------- ]
                [                                                4      ]
                [                                               r       ]

                                      [    2 m (r - 2 m)       ]
                                      [ 0  -------------  0  0 ]
                                      [          4             ]
                                      [         r              ]
                           riem     = [                        ]
                               1, 2   [ 0        0        0  0 ]
                                      [                        ]
                                      [ 0        0        0  0 ]
                                      [                        ]
                                      [ 0        0        0  0 ]

                                      [         m (r - 2 m)    ]
                                      [ 0  0  - -----------  0 ]
                                      [              4         ]
                                      [             r          ]
                           riem     = [                        ]
                               1, 3   [ 0  0        0        0 ]
                                      [                        ]
                                      [ 0  0        0        0 ]
                                      [                        ]
                                      [ 0  0        0        0 ]

                                      [            m (r - 2 m) ]
                                      [ 0  0  0  - ----------- ]
                                      [                 4      ]
                                      [                r       ]
                           riem     = [                        ]
                               1, 4   [ 0  0  0        0       ]
                                      [                        ]
                                      [ 0  0  0        0       ]
                                      [                        ]
                                      [ 0  0  0        0       ]

                                     [       0         0  0  0 ]
                                     [                         ]
                                     [       2 m               ]
                                     [ - ------------  0  0  0 ]
                          riem     = [    2                    ]
                              2, 1   [   r  (r - 2 m)          ]
                                     [                         ]
                                     [       0         0  0  0 ]
                                     [                         ]
                                     [       0         0  0  0 ]

                   [     2 m                                         ]
                   [ ------------  0        0               0        ]
                   [  2                                              ]
                   [ r  (r - 2 m)                                    ]
                   [                                                 ]
                   [      0        0        0               0        ]
                   [                                                 ]
        riem     = [                         m                       ]
            2, 2   [      0        0  - ------------        0        ]
                   [                     2                           ]
                   [                    r  (r - 2 m)                 ]
                   [                                                 ]
                   [                                         m       ]
                   [      0        0        0         - ------------ ]
                   [                                     2           ]
                   [                                    r  (r - 2 m) ]

                                      [ 0  0       0        0 ]
                                      [                       ]
                                      [            m          ]
                                      [ 0  0  ------------  0 ]
                           riem     = [        2              ]
                               2, 3   [       r  (r - 2 m)    ]
                                      [                       ]
                                      [ 0  0       0        0 ]
                                      [                       ]
                                      [ 0  0       0        0 ]

                                      [ 0  0  0       0       ]
                                      [                       ]
                                      [               m       ]
                                      [ 0  0  0  ------------ ]
                           riem     = [           2           ]
                               2, 4   [          r  (r - 2 m) ]
                                      [                       ]
                                      [ 0  0  0       0       ]
                                      [                       ]
                                      [ 0  0  0       0       ]

                                            [ 0  0  0  0 ]
                                            [            ]
                                            [ 0  0  0  0 ]
                                            [            ]
                                 riem     = [ m          ]
                                     3, 1   [ -  0  0  0 ]
                                            [ r          ]
                                            [            ]
                                            [ 0  0  0  0 ]

                                            [ 0  0  0  0 ]
                                            [            ]
                                            [ 0  0  0  0 ]
                                            [            ]
                                 riem     = [    m       ]
                                     3, 2   [ 0  -  0  0 ]
                                            [    r       ]
                                            [            ]
                                            [ 0  0  0  0 ]

                                     [   m                      ]
                                     [ - -   0   0       0      ]
                                     [   r                      ]
                                     [                          ]
                                     [        m                 ]
                                     [  0   - -  0       0      ]
                          riem     = [        r                 ]
                              3, 3   [                          ]
                                     [  0    0   0       0      ]
                                     [                          ]
                                     [              2 m - r     ]
                                     [  0    0   0  ------- + 1 ]
                                     [                 r        ]

                                          [ 0  0  0    0   ]
                                          [                ]
                                          [ 0  0  0    0   ]
                                          [                ]
                               riem     = [            2 m ]
                                   3, 4   [ 0  0  0  - --- ]
                                          [             r  ]
                                          [                ]
                                          [ 0  0  0    0   ]

                                      [       0        0  0  0 ]
                                      [                        ]
                                      [       0        0  0  0 ]
                                      [                        ]
                           riem     = [       0        0  0  0 ]
                               4, 1   [                        ]
                                      [      2                 ]
                                      [ m sin (theta)          ]
                                      [ -------------  0  0  0 ]
                                      [       r                ]

                                      [ 0        0        0  0 ]
                                      [                        ]
                                      [ 0        0        0  0 ]
                                      [                        ]
                           riem     = [ 0        0        0  0 ]
                               4, 2   [                        ]
                                      [         2              ]
                                      [    m sin (theta)       ]
                                      [ 0  -------------  0  0 ]
                                      [          r             ]

                                    [ 0  0          0          0 ]
                                    [                            ]
                                    [ 0  0          0          0 ]
                                    [                            ]
                         riem     = [ 0  0          0          0 ]
                             4, 3   [                            ]
                                    [                2           ]
                                    [         2 m sin (theta)    ]
                                    [ 0  0  - ---------------  0 ]
                                    [                r           ]

                 [        2                                             ]
                 [   m sin (theta)                                      ]
                 [ - -------------         0                0         0 ]
                 [         r                                            ]
                 [                                                      ]
                 [                         2                            ]
                 [                    m sin (theta)                     ]
      riem     = [        0         - -------------         0         0 ]
          4, 4   [                          r                           ]
                 [                                                      ]
                 [                                          2           ]
                 [                                   2 m sin (theta)    ]
                 [        0                0         ---------------  0 ]
                 [                                          r           ]
                 [                                                      ]
                 [        0                0                0         0 ]

      (%o5)                                done

  Package ctensor ·

関数: deleten (L, n)

  n番目の要素を削除したLから成る新しいリストを返します。

  Package ctensor ·

#### 26.2.9 Variables used by `ctensor`

オプション変数: dim

  デフォルト値: 4

  `ctensor` (成分テンソル)パッケージのオプション。 `dim`は デフォルト4の多様体の次元です。 コマンド `dim: n`は 次元を任意の別の値 `n`に再設定します。

  Package ctensor ·

オプション変数: diagmetric

  デフォルト値: `false`

  `ctensor` (成分テンソル)パッケージのオプション。 もし `diagmetric`が `true`なら、 特殊なルーチンが 計量の対角性を考慮して (計量テンソルを明示的に含む)幾何的オブジェクトすべてを 計算します。 もちろん、実行時間短縮になります。 注意: もし対角計量が指定されたら、 `csetup`は自動的にこのオプションを設定します。

  Package ctensor ·

オプション変数: ctrgsimp

  テンソルを計算する時、三角関数整理を使うようにします。 現在、 `ctrgsimp`は 動標構を含む計算だけに影響します。

  Package ctensor ·Simplification flags and variables ·

オプション変数: cframe_flag

  計算を ホロノミック(holonomic)計量と対比して動標構に関係して実行するようにします。 標構は逆標構配列 `fri`と標構計量 `lfg`で定義されます。 Cartesian標構を使う計算に関して、 `lfg`は適切な次元の単位行列でなければいけません; Lorentz標構での計算に関して、 `lfg`は適切な符号を持たなければいけません。

  Package ctensor ·

オプション変数: ctorsion_flag

  コントーションテンソルが 接続係数の計算に含まれるようにします。 コントーションテンソル自体は ユーザーが提供するテンソル `tr`から `contortion`によって計算されます。

  Package ctensor ·

オプション変数: cnonmet_flag

  非計量性係数が 接続係数の計算に含まれるようにします。 コントーションテンソルは ユーザーが提供する非計量性ベクトル `nm`から 関数 `nonmetricity`によって計算されます。

  Package ctensor ·

オプション変数: ctayswitch

  もし `true`に設定されているなら、 いくつかの `ctensor`計算が Taylor級数展開を使って実行されるようにします。 現在、 `christof`, `ricci`, `uricci`, `einstein`, `weyl`がこの設定を考慮します。

  Package ctensor ·

オプション変数: ctayvar

  `ctayswitch`が `true`に設定されているなら Taylor級数展開で使われる変数。

  Package ctensor ·

オプション変数: ctaypov

  `ctayswitch`が `true`に設定されている時 Taylor級数展開で使われる最大べき数

  Package ctensor ·

オプション変数: ctaypt

  `ctayswitch`が `true`に設定されている時 Taylor級数展開が実行される点。

  Package ctensor ·

システム変数: gdet

  計量テンソル `lg`の行列式。 `cframe_flag`が `false`に設定されている時、 `cmetric`によって計算されます。

  Package ctensor ·

オプション変数: ratchristof

  `christof`が有理整理を適用するようにします。

  Package ctensor ·

オプション変数: rateinstein

  デフォルト値: `true`

  もし `true`なら、 Einsteinテンソルの非零成分上で 有理整理が実行されます; もし `ratfac`が `true`なら、 成分は因数分解もされます。

  Package ctensor ·

オプション変数: ratriemann

  デフォルト値: `true`

  Riemannテンソルの整理を制御するスイッチの1つです; もし `true`なら、 有理整理がされます; もし `ratfac`が `true`なら、 成分それぞれは因数分解もされます。

  Package ctensor ·

オプション変数: ratweyl

  デフォルト値: `true`

  もし `true`なら、 このスイッチは, `weyl`関数が Weylテンソルの値に有理整理を適用するようにします。 もし`ratfac`が `true`なら、 成分は因数分解もされます。

  Package ctensor ·

変数: lfg

  共変標構計量。 デフォルトでは、 符号 (+,+,+,-)を持つ4次元Lorentz標構に初期化されます。 `cframe_flag`が `true`の時使われます。

  Package ctensor ·

変数: ufg

  逆標構計量。 `cframe_flag`が `true`に設定されているなら、 `cmetric`がコールされた時 `lfg`から計算されます。

  Package ctensor ·

変数: riem

  (3,1) Riemannテンソル。 関数 `riemann`が呼び出された時計算されます。 添字順序についての情報については、 `riemann`の記述を参照してください。

  もし `cframe_flag`が `true`なら、 `riem`は 共変Riemannテンソル `lriem`から計算されます。

  Package ctensor ·

変数: lriem

  共変Riemannテンソル。 `lriemann`が計算します。

  Package ctensor ·

変数: uriem

  反変Riemannテンソル。

  Package ctensor ·

変数: ric

  混合Ricciテンソル。 `ricci`が計算します。

  Package ctensor ·

変数: uric

  反変Ricciテンソル。 `ricci`が計算します。

  Package ctensor ·

変数: lg

  計量テンソル。 このテンソルは 他の計算が実行される前に (`dim`掛け `dim`行列として)指定されなければいけません。

  Package ctensor ·

変数: ug

  計量テンソルの逆元。 `cmetric`が計算します。

  Package ctensor ·

変数: weyl

  Weylテンソル。 `weyl`が計算します。

  Package ctensor ·

変数: fb

  `frame_bracket`によって計算される、 標構ブラケット係数。

  Package ctensor ·

変数: kinvariant

  Kretchmann不変量。 `rinvariant`が計算します。

  Package ctensor ·

変数: np

  Newman-Penroseヌルテトラド。 `nptetrad`が計算します。

  Package ctensor ·

変数: npi

  上付き添字 Newman-Penroseヌルテトラド。 `nptetrad`が計算します。 `ug.np`として定義されます。 積 `np.transpose(npi)`は定数です:

      (%i39) trigsimp(np.transpose(npi));
                                    [  0   - 1  0  0 ]
                                    [                ]
                                    [ - 1   0   0  0 ]
      (%o39)                        [                ]
                                    [  0    0   0  1 ]
                                    [                ]
                                    [  0    0   1  0 ]

  Package ctensor ·

変数: tr

  ユーザーが提供するねじれを表す階数3のテンソル `contortion`が使います。

  Package ctensor ·

変数: kt

  コントーションテンソル。 `contortion`が `tr`から計算します。

  Package ctensor ·

変数: nm

  ユーザーが提供する非計量性ベクトル。 `nonmetricity`が使います。

  Package ctensor ·

変数: nmc

  `nonmetricity`が `nm`から計算する 非計量性係数。

  Package ctensor ·

システム変数: tensorkill

  テンソルパッケージが初期化されたかを示す変数。 `csetup`が設定し使います。 `init_ctensor`が再設定します。

  Package ctensor ·

オプション変数: ct_coords

  デフォルト値: `[]`

  `ctensor` (成分テンソル)パッケージのオプション。 `ct_coords`は座標のリストを含みます。 関数 `csetup`がコールされる時通常定義される一方、 割り当て `ct_coords: [j1, j2, ..., jn]`で座標を再定義できます。 ここで、jは新しい座標名です。 `csetup`も参照してください。

  Package ctensor ·

#### 26.2.10 Reserved names

`ctensor`パッケージによって 以下の名前が内部的に使われます。 なので再定義してはいけません:

      Name         Description
      ---------------------------------------------------------------------
      _lg()        Evaluates to lfg if frame metric used, lg otherwise
      _ug()        Evaluates to ufg if frame metric used, ug otherwise
      cleanup()    Removes items drom the deindex list
      contract4()  Used by psi()
      filemet()    Used by csetup() when reading the metric from a file
      findde1()    Used by findde()
      findde2()    Used by findde()
      findde3()    Used by findde()
      kdelt()      Kronecker-delta (not generalized)
      newmet()     Used by csetup() for setting up a metric interactively
      setflags()   Used by init_ctensor()
      readvalue()
      resimp()
      sermet()     Used by csetup() for entering a metric as Taylor-series
      txyzsum()
      tmetric()    Frame metric, used by cmetric() when cframe_flag:true
      triemann()   Riemann-tensor in frame base, used when cframe_flag:true
      tricci()     Ricci-tensor in frame base, used when cframe_flag:true
      trrc()       Ricci rotation coefficients, used by christof()
      yesp()

#### 26.2.11 Changes

2004年11月に `ctensor`パッケージは広範囲に渡って書き直されました。 多くの関数と変数は、パッケージにMacsymaの商用版との互換性を持たせるために、 リネームされました。

      New Name     Old Name        Description
      ---------------------------------------------------------------------
      ctaylor()    DLGTAYLOR()     Taylor-series expansion of an expression
      lgeod[]      EM              Geodesic equations
      ein[]        G[]             Mixed Einstein-tensor
      ric[]        LR[]            Mixed Ricci-tensor
      ricci()      LRICCICOM()     Compute the mixed Ricci-tensor
      ctaypov      MINP            Maximum power in Taylor-series expansion
      cgeodesic()  MOTION          Compute geodesic equations
      ct_coords    OMEGA           Metric coordinates
      ctayvar      PARAM           Taylor-series expansion variable
      lriem[]      R[]             Covariant Riemann-tensor
      uriemann()   RAISERIEMANN()  Compute the contravariant Riemann-tensor
      ratriemann   RATRIEMAN       Rational simplif. of the Riemann-tensor
      uric[]       RICCI[]         Contravariant Ricci-tensor
      uricci()     RICCICOM()      Compute the contravariant Ricci-tensor
      cmetric()    SETMETRIC()     Set up the metric
      ctaypt       TAYPT           Point for Taylor-series expansion
      ctayswitch   TAYSWITCH       Taylor-series setting switch
      csetup()     TSETUP()        Start interactive setup session
      ctransform() TTRANSFORM()    Interactive coordinate transformation
      uriem[]      UR[]            Contravariant Riemann-tensor
      weyl[]       W[]             (3,1) Weyl-tensor

Next: Sums Products and Series, Previous: ctensor, Up: Top [Contents][Index]

## 27 atensor

Next: Functions and Variables for atensor, Previous: atensor, Up: atensor [Contents][Index]

### 27.1 Introduction to atensor

`atensor`は、代数テンソル操作パッケージです。 `atensor`を使うには、`load("atensor")`をタイプしてください。 続いて、`init_atensor`関数コールしてください。

`atensor`の本質は非可換(ドット)積演算子 ("`.`")の整理ルール一式です `atensor`はいくつかの代数型を認識します; `init_atensor`関数がコールされた時、 対応する整理ルールが有効になります。

`atensor`の能力は、 四元数代数を2つの基底ベクトルを持つClifford代数 Cl(0,2)として 定義することで実演することができます。 3つの四元数虚数単位は2つの基底ベクトルとその積、すなわち以下の通りです:

        i = v     j = v     k = v  . v
             1         2         1    2

`atensor`パッケージは 四元数代数に関する組み込みの定義を持ちますが、 この例では使わず、四元数乗算表を行列として組むよう試みます:

    (%i1) load("atensor");
    (%o1)       /share/tensor/atensor.mac
    (%i2) init_atensor(clifford,0,0,2);
    (%o2)                                done
    (%i3) atensimp(v[1].v[1]);
    (%o3)                                 - 1
    (%i4) atensimp((v[1].v[2]).(v[1].v[2]));
    (%o4)                                 - 1
    (%i5) q:zeromatrix(4,4);
                                    [ 0  0  0  0 ]
                                    [            ]
                                    [ 0  0  0  0 ]
    (%o5)                           [            ]
                                    [ 0  0  0  0 ]
                                    [            ]
                                    [ 0  0  0  0 ]
    (%i6) q[1,1]:1;
    (%o6)                                  1
    (%i7) for i thru adim do q[1,i+1]:q[i+1,1]:v[i];
    (%o7)                                done
    (%i8) q[1,4]:q[4,1]:v[1].v[2];
    (%o8)                               v  . v
                                         1    2
    (%i9) for i from 2 thru 4 do for j from 2 thru 4 do
          q[i,j]:atensimp(q[i,1].q[1,j]);
    (%o9)                                done
    (%i10) q;

                       [    1        v         v      v  . v  ]
                       [              1         2      1    2 ]
                       [                                      ]
                       [   v         - 1     v  . v    - v    ]
                       [    1                 1    2      2   ]
    (%o10)             [                                      ]
                       [   v      - v  . v     - 1      v     ]
                       [    2        1    2              1    ]
                       [                                      ]
                       [ v  . v      v        - v       - 1   ]
                       [  1    2      2          1            ]

`atensor`は 添字付きシンボルを基底ベクトルと認識します。 シンボルは`asymbol`の中に記憶されたものであり、 添字は1から`adim`まで間です。 添字付きシンボルだけに関して 双一次形式 `sf`, `af`, `av`が評価されます。 評価は `fun(v[i],v[j])`に `aform[i,j]`の値を代入します ここで、`v`は `asymbol`の値を表し、 `fun`は `af`か `sf`を示します; あるいは、 `av(v[i],v[j])`に `v[aform[i,j]]`を代入します。

言うまでもなく、関数 `sf`, `af`, `av`は再定義するこができます。

`atensor`パッケージがロードされる時、以下のフラグが設定されます:

    dotscrules:true;
    dotdistrib:true;
    dotexptsimp:false;

もし非結合代数で実験したいなら、 `dotassoc`を `false`に設定することも考えるかもしれません。 しかし、この場合、 `atensimp`はいつも 望みの整理を得ることができるわけではありません。

Tensors ·Share packages ·Package atensor ·

Previous: Introduction to atensor, Up: atensor [Contents][Index]

### 27.2 Functions and Variables for atensor

関数: init_atensor (alg_type, opt_dims)
関数: init_atensor (alg_type)

  特定の代数型で `atensor`パッケージを初期化します。 alg_typeは以下のいずれかであり得ます:

  `universal`: 普遍代数は交換規則を持ちません。

  `grassmann`: Grassman代数は交換関係 `u.v+v.u=0`で定義されます。

  `clifford`: Clifford代数は 交換関係 `u.v+v.u=-2*sf(u,v)`で定義されます。 ここで、 `sf`は対称スカラ値函数です。 この代数では、 opt_dimsは、 代数の正の次元数、縮退次元数、負の次元数をそれぞれ表す3つの非負整数までありえます。 もしいずれかの opt_dims値が供給されたら、 `atensor`は `adim`と `aform`の値を適切に構成します。 そうでなければ、 `adim`はデフォルトが0で、 `aform`は未定義です。

  `symmetric`: 対称代数は交換関係 `u.v-v.u=0`で定義されます。

  `symplectic`: シンプレクティック代数は 交換関係 `u.v-v.u=2*af(u,v)`で定義されます。 ここで、 `af`は反対称スカラ値函数です。 シンプレクティック代数では、 opt_dimsは 非縮退次元数、縮退次元数をそれぞれ表す2つの非負整数までありえます。 もしいずれかの opt_dims値が供給されたら、 `atensor`は `adim`と `aform`の値を適切に構成します。 そうでなければ、 `adim`はデフォルトが0で、 `aform`は未定義です。

  `lie_envelop`: Lie包絡代数は交換関係 `u.v-v.u=2*av(u,v)`で定義されます。 ここで、 `av`は反対称函数です。

  `init_atensor`関数はいくつかの予め定義された代数型も認識します:

  `complex`は複素数代数をClifford代数 Cl(0,1)として実装します。 `init_atensor(complex)`をコールすることは `init_atensor(clifford,0,0,1)`と同値です。

  `quaternion`は四元数代数を実装します。 `init_atensor (quaternion)`をコールすることは `init_atensor (clifford,0,0,2)`と同値です。

  `pauli`はPauliスピノール代数をClifford代数 Cl(3,0)として実装します。 `init_atensor(pauli)`をコールすることは `init_atensor(clifford,3)`と同値です。

  `dirac`はDiracスピノール代数をClifford代数 Cl(3,1)として実装します。 `init_atensor(dirac)`をコールすることは `init_atensor(clifford,3,0,1)`と同値です。

  Package atensor ·

関数: atensimp (expr)

  `init_atensor`のコールで構成された規則に従って、 代数テンソル式 exprを整理します。 整理は、 適用可能な場所への 交換関係の再帰的な適用と`sf`, `af`, `av`のコールの決定を含みます。 複雑な式に関してさえ、 関数がいつでも終了することを確実にするために 保護手段が使われます。

  Package atensor ·Simplification functions ·

変数: adim

  デフォルト値: 0

  代数の次元。 `atensor`は 添字付きオブジェクトが有効な基底ベクトルか決定するのに `adim`の値を使います。 `abasep`を参照してください。

  Package atensor ·Global variables ·

変数: aform

  デフォルト値: `ident(3)`

  双一次形式`sf`, `af`, `av`のデフォルト値。 デフォルトは、単位行列 `ident(3)`です。

  Package atensor ·Global variables ·

変数: asymbol

  デフォルト値: `v`

  基底ベクトルのシンボル。

  Package atensor ·Global variables ·

関数: sf (u, v)

  交換関係で使われる対称スカラ関数。 デフォルトの実装は 両方の引数が`abasep`を使った基底ベクトルかチェックし、 もしそうなら、行列 `aform`から対応する値を代入します。

  Package atensor ·

関数: af (u, v)

  交換関係で使われる反対称スカラ関数。 デフォルトの実装は 両方の引数が`abasep`を使った基底ベクトルかチェックし、 もしそうなら、行列 `aform`から対応する値を代入します。

  Package atensor ·

関数: av (u, v)

  交換関係で使われる反対称スカラ関数。 デフォルトの実装は 両方の引数が`abasep`を使った基底ベクトルかチェックし、 もしそうなら、行列 `aform`から対応する値を代入します。

  例えば:

      (%i1) load("atensor");
      (%o1)       /share/tensor/atensor.mac
      (%i2) adim:3;
      (%o2)                                  3
      (%i3) aform:matrix([0,3,-2],[-3,0,1],[2,-1,0]);
                                     [  0    3   - 2 ]
                                     [               ]
      (%o3)                          [ - 3   0    1  ]
                                     [               ]
                                     [  2   - 1   0  ]
      (%i4) asymbol:x;
      (%o4)                                  x
      (%i5) av(x[1],x[2]);
      (%o5)                                 x
                                             3

  Package atensor ·

関数: abasep (v)

  引数が `atensor`基底ベクトルかチェックします。 すなわち、`asymbol`の値と同じシンボルと 1と `adim`の間の数値の添字を持つ添字付きシンボルかどうか、チェックします。

  Package atensor ·Predicate functions ·

Next: Number Theory, Previous: atensor, Up: Top [Contents][Index]

## 28 Sums, Products, and Series

Next: Introduction to Series, Previous: Sums Products and Series, Up: Sums Products and Series [Contents][Index]

### 28.1 Sums and Products

関数: bashindices (expr)

  それぞれの和や積に独自のインデックスを与えることで、 式exprを変換します。 これは、 和や積と一緒に機能する時 `changevar`によりよい精度を与えます。 独自のインデックスの形式は`jnumber`です。 量numberは、`gensumnum`に参照することで決定されます。 これを、ユーザーは変更することができます。 例えば、`gensumnum:0$`はそれを再設定します。

  Sums and products ·

関数: lsum (expr, x, L)

  Lの中のそれぞれの要素xに関するexprの和を表します。 もし引数Lがリストに評価されなければ、名詞形`'lsum`が返されます。

  例:

      (%i1) lsum (x^i, i, [1, 2, 7]);
                                  7    2
      (%o1)                      x  + x  + x
      (%i2) lsum (i^2, i, rootsof (x^3 - 1, x));

                           ====
                           \      2
      (%o2)                 >    i
                           /
                           ====
                                         3
                           i in rootsof(x  - 1, x)

  Sums and products ·

関数: intosum (expr)

  和の外側の掛け算因子を内側に移動します。 もし外側の式でインデックスが使われているなら、 関数は、`sumcontract`に関してするのと同じように、合理的なインデックスを見つけようとします。 これは、本質的に、和の`outative`プロパティの逆の考えですが、 このプロパティを取り除かず、ただ無視するだけであることに注意してください。

  いくつかの場合、 `intosum`の前に、`scanmap (multthru, expr)`が必要になるかもしれません。

  Expressions ·

関数: product (expr, i, i_0, i_1)

  インデックスiがi_0からi_1まで変えたexprの値の積を返します。 名詞形`'product`は、大文字Πとして表示されます。

  `product`は、exprと下限上限i_0、i_1を評価し、 `product`は、インデックスiをクォートします（評価しません）。

  もし上限と下限が整数差だけ違うなら、 exprは、インデックスiのそれぞれの値に関して評価され、 結果は陽な積です。

  そうでなければ、インデックスの範囲は不定です。 積を整理するためにいくつかの規則が適用されます。 グローバル変数`simpproduct`が`true`の時、 更なる規則が適用されます。 いくつかの場合、式整理は、積でない結果を出力します; そうでなければ、結果は名詞形`'product`です。

  `nouns`と`evflag`も参照してください。

  例:

      (%i1) product (x + i*(i+1)/2, i, 1, 4);
      (%o1)           (x + 1) (x + 3) (x + 6) (x + 10)
      (%i2) product (i^2, i, 1, 7);
      (%o2)                       25401600
      (%i3) product (a[i], i, 1, 7);
      (%o3)                 a  a  a  a  a  a  a
                             1  2  3  4  5  6  7
      (%i4) product (a(i), i, 1, 7);
      (%o4)          a(1) a(2) a(3) a(4) a(5) a(6) a(7)
      (%i5) product (a(i), i, 1, n);
                                   n
                                 /===\
                                  ! !
      (%o5)                       ! !  a(i)
                                  ! !
                                 i = 1
      (%i6) product (k, k, 1, n);
                                     n
                                   /===\
                                    ! !
      (%o6)                         ! !  k
                                    ! !
                                   k = 1
      (%i7) product (k, k, 1, n), simpproduct;
      (%o7)                          n!
      (%i8) product (integrate (x^k, x, 0, 1), k, 1, n);
                                   n
                                 /===\
                                  ! !    1
      (%o8)                       ! !  -----
                                  ! !  k + 1
                                 k = 1
      (%i9) product (if k <= 5 then a^k else b^k, k, 1, 10);
                                    15  40
      (%o9)                        a   b

  Sums and products ·

オプション変数: simpsum

  デフォルト値: `false`

  `simpsum`が`true`の時、 `sum`の結果は、整理されます。 この整理は、時々、閉形式を生成することができるかもしれません。 もし`simpsum`が`false`もしくは、もしクォートされた形`'sum`が使われたなら、 値は、数学で使われるΣ表示の表現である和の名詞形です。

  Sums and products ·Simplification flags and variables ·

関数: sum (expr, i, i_0, i_1)

  インデックスiがi_0からi_1まで変えたexprの値の和を返します。 名詞形`'sum`は、大文字Σとして表示されます。

  `sum`は、被和exprと下限上限i_0、i_1を評価し、 `sum`は、インデックスiをクォートします（評価しません）。

  もし上限と下限が整数差だけ違うなら、 被和exprは、インデックスiのそれぞれの値に関して評価され、 結果は陽な和です。

  そうでなければ、インデックスの範囲は不定です。 積を整理するためにいくつかの規則が適用されます。 グローバル変数`simpsum`が`true`の時、 更なる規則が適用されます。 いくつかの場合、式整理は、和でない結果を出力します; そうでなければ、結果は名詞形`'sum`です。

  `evflag`(評価フラグ) `cauchysum`が`true`の時、 和の積は、コーシー積として表現されます。 コーシー積では、内側の和のインデックスは、独立に変化するのではなく、外側の和のインデックスの関数になります。

  グローバル変数`genindex`は、 和の次のインデックスを生成するのに使われるアルファベット前置です。

  `gensumnum`は、 自動生成されるインデックスが必要な時、 和の次のインデックスを生成するのに使われる数値接尾です。 `gensumnum`が`false`の時, 自動生成されるインデックスは、接尾なしの`genindex`のみです。

  `sumcontract`, `intosum`, `bashindices`, `niceindices`, `nouns`, `evflag`, `zeilberger`も参照してください。

  例:

      (%i1) sum (i^2, i, 1, 7);
      (%o1)                          140
      (%i2) sum (a[i], i, 1, 7);
      (%o2)           a  + a  + a  + a  + a  + a  + a
                       7    6    5    4    3    2    1
      (%i3) sum (a(i), i, 1, 7);
      (%o3)    a(7) + a(6) + a(5) + a(4) + a(3) + a(2) + a(1)
      (%i4) sum (a(i), i, 1, n);
                                  n
                                 ====
                                 \
      (%o4)                       >    a(i)
                                 /
                                 ====
                                 i = 1
      (%i5) sum (2^i + i^2, i, 0, n);
                                n
                               ====
                               \       i    2
      (%o5)                     >    (2  + i )
                               /
                               ====
                               i = 0
      (%i6) sum (2^i + i^2, i, 0, n), simpsum;
                                    3      2
                         n + 1   2 n  + 3 n  + n
      (%o6)             2      + --------------- - 1
                                        6
      (%i7) sum (1/3^i, i, 1, inf);
                                  inf
                                  ====
                                  \     1
      (%o7)                        >    --
                                  /      i
                                  ====  3
                                  i = 1
      (%i8) sum (1/3^i, i, 1, inf), simpsum;
                                      1
      (%o8)                           -
                                      2
      (%i9) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf);
                                    inf
                                    ====
                                    \     1
      (%o9)                      30  >    --
                                    /      2
                                    ====  i
                                    i = 1
      (%i10) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf), simpsum;
                                        2
      (%o10)                       5 %pi
      (%i11) sum (integrate (x^k, x, 0, 1), k, 1, n);
                                  n
                                 ====
                                 \       1
      (%o11)                      >    -----
                                 /     k + 1
                                 ====
                                 k = 1
      (%i12) sum (if k <= 5 then a^k else b^k, k, 1, 10);
                10    9    8    7    6    5    4    3    2
      (%o12)   b   + b  + b  + b  + b  + a  + a  + a  + a  + a

  Sums and products ·

関数: sumcontract (expr)

  定数だけ異なる上限と下限を持つ足し算の和すべてを結合します。 結果は、 そんな和のそれぞれの集合が、この和を形成するよう抽出されなければならないすべての適切な余分の項に加えられた１つの和を含む式です。 `sumcontract`は、互換性のある和すべてを結合し、 可能なら和の１つからインデックスの１つを使い、もし供給されたどれもが使えないなら、合理的なインデックスを形成するよう試みます。

  `sumcontract`の前に、`intosum (expr)`を実行する必要があるかもしれません。

  Sums and products ·

オプション変数: sumexpand

  デフォルト値: `false`

  `sumexpand`が`true`の時、 和の積と、指数和は、入れ子の和に整理されます。

  `cauchysum`も参照してください。

  例:

      (%i1) sumexpand: true$
      (%i2) sum (f (i), i, 0, m) * sum (g (j), j, 0, n);

                           m      n
                          ====   ====
                          \      \
      (%o2)                >      >     f(i1) g(i2)
                          /      /
                          ====   ====
                          i1 = 0 i2 = 0

      (%i3) sum (f (i), i, 0, m)^2;
                           m      m
                          ====   ====
                          \      \
      (%o3)                >      >     f(i3) f(i4)
                          /      /
                          ====   ====
                          i3 = 0 i4 = 0

  Sums and products ·Simplification flags and variables ·

Next: Functions and Variables for Series, Previous: Sums and Products, Up: Sums Products and Series [Contents][Index]

### 28.2 Introduction to Series

Maximaは、微分可能な関数の級数を見つけるために、 関数`taylor`と`powerseries`を含みます。 ある級数の閉形式を見つける性能がある`nusum`のようなツールも持ちます。 足し算や掛け算のような演算は、級数上で普通に機能します。 この節は、展開を制御するグローバル変数を提供します。

Next: Poisson series, Previous: Introduction to Series, Up: Sums Products and Series [Contents][Index]

### 28.3 Functions and Variables for Series

オプション変数: cauchysum

  デフォルト値: `false`

  上限として`inf`を持つ和同士を掛ける時、 もし`sumexpand`が`true`、かつ、`cauchysum`が`true`なら、 通常の積ではなくCauchy積が使われます。 Cauchy積では、 内側の和のインデックスは、独立に変化するのではなく、外側のインデックスの関数です。

  例:

      (%i1) sumexpand: false$
      (%i2) cauchysum: false$
      (%i3) s: sum (f(i), i, 0, inf) * sum (g(j), j, 0, inf);
                            inf         inf
                            ====        ====
                            \           \
      (%o3)                ( >    f(i))  >    g(j)
                            /           /
                            ====        ====
                            i = 0       j = 0
      (%i4) sumexpand: true$
      (%i5) cauchysum: true$
      (%i6) ''s;
                       inf     i1
                       ====   ====
                       \      \
      (%o6)             >      >     g(i1 - i2) f(i2)
                       /      /
                       ====   ====
                       i1 = 0 i2 = 0

  Sums and products ·

関数: deftaylor (f_1(x_1), expr_1, …, f_n(x_n), expr_n)

  `deftaylor`は、 ある変数x_iの関数f_iそれぞれに関して、 expr_iをゼロの回りのTaylor級数と定義します。 expr_iは、典型的には、x_iの多項式か和です; `deftaylor`は、もっと一般的な式も問題なく受け付けます。

  `powerseries (f_i(x_i), x_i, 0)`は、 `deftaylor`で定義された級数を返します。

  `deftaylor`は、 関数f_1, ..., f_nのリストを返します。 `deftaylor`は、引数を評価します。

  例:

      (%i1) deftaylor (f(x), x^2 + sum(x^i/(2^i*i!^2), i, 4, inf));
      (%o1)                          [f]
      (%i2) powerseries (f(x), x, 0);
                            inf
                            ====      i1
                            \        x         2
      (%o2)                  >     -------- + x
                            /       i1    2
                            ====   2   i1!
                            i1 = 4
      (%i3) taylor (exp (sqrt (f(x))), x, 0, 4);
                            2         3          4
                           x    3073 x    12817 x
      (%o3)/T/     1 + x + -- + ------- + -------- + . . .
                           2     18432     307200

  Power series ·

オプション変数: maxtayorder

  デフォルト値: `true`

  `maxtayorder`が`true`の時、 (切り詰められた)Taylor級数の代数操作の間、 `taylor`は、厳密とわかっているできるだけ多くの項を保とうとします。

  Power series ·

関数: niceindices (expr)

  exprの中の和や積のインデックスを改名します。 `niceindices`は、 その名前が被加数や非積数の中に現れないなら、 インデックスそれぞれを`niceindicespref[1]`の値に改名しようとします。 現れた場合、 `niceindices`は、 未使用の変数が見つかるまで`niceindicespref`の次の要素を順に試します。 もしリスト全部が使い果たされたら、 例えば, `i0`, `i1`, `i2`, ....というように、 `niceindicespref[1]`の値に整数を追加することで、 追加のインデックスが構成されます。

  `niceindices`は式を返します。 `niceindices`は引数を評価します。

  例:

      (%i1) niceindicespref;
      (%o1)                  [i, j, k, l, m, n]
      (%i2) product (sum (f (foo + i*j*bar), foo, 1, inf), bar, 1, inf);
                       inf    inf
                      /===\   ====
                       ! !    \
      (%o2)            ! !     >      f(bar i j + foo)
                       ! !    /
                      bar = 1 ====
                              foo = 1
      (%i3) niceindices (%);

                           inf  inf
                          /===\ ====
                           ! !  \
      (%o3)                ! !   >    f(i j l + k)
                           ! !  /
                          l = 1 ====
                                k = 1

  Sums and products ·

オプション変数: niceindicespref

  デフォルト値: `[i, j, k, l, m, n]`

  `niceindicespref`は、 `niceindices`が和や積のインデックスの名前を取ってくる リストです。

  The elements of `niceindicespref`の要素は、 `niceindices`によって強制されませんが、 通常、変数名です。

  例:

      (%i1) niceindicespref: [p, q, r, s, t, u]$
      (%i2) product (sum (f (foo + i*j*bar), foo, 1, inf), bar, 1, inf);
                       inf    inf
                      /===\   ====
                       ! !    \
      (%o2)            ! !     >      f(bar i j + foo)
                       ! !    /
                      bar = 1 ====
                              foo = 1
      (%i3) niceindices (%);
                           inf  inf
                          /===\ ====
                           ! !  \
      (%o3)                ! !   >    f(i j q + p)
                           ! !  /
                          q = 1 ====
                                p = 1

  Sums and products ·

関数: nusum (expr, x, i_0, i_1)

  R.W. Gosperによる決定手続きを使って、 xに関するexprの不定超幾何総和を実行します。 exprと結果は、 整数べき、階乗、二項式、有理関数の積として表現可能でなければいけません。

  用語「定」と「不定和」は、 「定」と「不定積分」へ類似して使われています。 不定に和を取ることは、 ただ、例えば0からinfまででなく、 変数の長さの区間上の和に関して、シンボリックな結果を与えることを意味します。 例えば、二項級数の一般的な部分和に関する公式はないので、 `nusum`はそれができません。

  `nusum`と`unsum`は、有限積の和と差について少し知っています。 `unsum`も参照してください。

  例:

      (%i1) nusum (n*n!, n, 0, n);

      Dependent equations eliminated:  (1)
      (%o1)                     (n + 1)! - 1
      (%i2) nusum (n^4*4^n/binomial(2*n,n), n, 0, n);
                           4        3       2              n
            2 (n + 1) (63 n  + 112 n  + 18 n  - 22 n + 3) 4      2
      (%o2) ------------------------------------------------ - ------
                          693 binomial(2 n, n)                 3 11 7
      (%i3) unsum (%, n);
                                    4  n
                                   n  4
      (%o3)                   ----------------
                              binomial(2 n, n)
      (%i4) unsum (prod (i^2, i, 1, n), n);
                          n - 1
                          /===\
                           ! !   2
      (%o4)              ( ! !  i ) (n - 1) (n + 1)
                           ! !
                          i = 1
      (%i5) nusum (%, n, 1, n);

      Dependent equations eliminated:  (2 3)
                                  n
                                /===\
                                 ! !   2
      (%o5)                      ! !  i  - 1
                                 ! !
                                i = 1

  Sums and products ·

関数: pade (taylor_series, numer_deg_bound, denom_deg_bound)

  分子と分母の次数の和がべき級数の切り詰めレベル以下の 与えられたTaylor級数展開、すなわち、「最良」近似を持ち 加えて指定された次数範囲を満たす、有理関数すべてのリストを返します。

  taylor_seriesは１変数Taylor級数です。 numer_deg_boundとdenom_deg_boundは、 分子と分母上の次数範囲を指定する 正の整数です。

  taylor_seriesは Laurent級数も可能です。 次数範囲は、`inf`も可能で、 総次数が、冪級数の長さ以下の有理関数すべてを返すことになります。 総次数は `numer_deg_bound + denom_deg_bound`として定義されます。 べき級数の長さは `"truncation level" + 1 - min(0, "order of series")`として定義されます。

      (%i1) taylor (1 + x + x^2 + x^3, x, 0, 3);
                                    2    3
      (%o1)/T/             1 + x + x  + x  + . . .
      (%i2) pade (%, 1, 1);
                                       1
      (%o2)                       [- -----]
                                     x - 1
      (%i3) t: taylor(-(83787*x^10 - 45552*x^9 - 187296*x^8
                         + 387072*x^7 + 86016*x^6 - 1507328*x^5
                         + 1966080*x^4 + 4194304*x^3 - 25165824*x^2
                         + 67108864*x - 134217728)
             /134217728, x, 0, 10);
                          2    3       4       5       6        7
                   x   3 x    x    15 x    23 x    21 x    189 x
      (%o3)/T/ 1 - - + ---- - -- - ----- + ----- - ----- - ------
                   2    16    32   1024    2048    32768   65536

                                        8         9          10
                                  5853 x    2847 x    83787 x
                                + ------- + ------- - --------- + . . .
                                  4194304   8388608   134217728
      (%i4) pade (t, 4, 4);
      (%o4)                          []

  このべき級数展開を持つ次数4の 分子/分母の有理関数はありません。 一般的に、 解くのに十分な数の未知の係数を持つために、 その和が少なくともべき級数の次数になるまで 分子の次数と分母の次数を増やさなければいけません。

      (%i5) pade (t, 5, 5);
                           5                4                 3
      (%o5) [- (520256329 x  - 96719020632 x  - 489651410240 x

                        2
       - 1619100813312 x  - 2176885157888 x - 2386516803584)

                     5                 4                  3
      /(47041365435 x  + 381702613848 x  + 1360678489152 x

                        2
       + 2856700692480 x  + 3370143559680 x + 2386516803584)]

  Power series ·

関数: powerseries (expr, x, a)

  変数xに関する点a (無限大のためには`inf`かもしれません) の回りのexprのべき級数展開の一般形式を返します:

                 inf
                 ====
                 \               n
                  >    b  (x - a)
                 /      n
                 ====
                 n = 0

  もし`powerseries`がexprを展開することができないなら、 `taylor`が、級数の最初のいくつかの項を与えることができます。

  `verbose`が`true`の時、 `powerseries`は進捗メッセージを印字します。

      (%i1) verbose: true$
      (%i2) powerseries (log(sin(x)/x), x, 0);
      can't expand
                                       log(sin(x))
      so we'll try again after applying the rule:
                                              d
                                            / -- (sin(x))
                                            [ dx
                              log(sin(x)) = i ----------- dx
                                            ]   sin(x)
                                            /
      in the first simplification we have returned:
                                   /
                                   [
                                   i cot(x) dx - log(x)
                                   ]
                                   /
                          inf
                          ====        i1  2 i1             2 i1
                          \      (- 1)   2     bern(2 i1) x
                           >     ------------------------------
                          /                i1 (2 i1)!
                          ====
                          i1 = 1
      (%o2)                -------------------------------------
                                            2

  Power series ·

オプション変数: psexpand

  デフォルト値: `false`

  `psexpand`が`true`の時、 拡張有理関数展開が完全に展開されて表示されます。 スイッチ`ratexpand`は同じ効果を持ちます。

  `psexpand`が`false`の時、 多変数式がちょうど有理関数パッケージにあるかのように表示されます。

  `psexpand`が`multi`の時、 変数に関する同じ総次数の項は一緒にまとめられます。

  Display flags and variables ·

関数: revert (expr, x)
関数: revert2 (expr, x, n)

  これらの関数は、 変数xに関するゼロの回りのTaylor級数exprの反転を返します。 `revert`は、 exprの最高次数と等しい次数の多項式を返します。 `revert2`は、次数nの多項式を返します。 nは、exprの次数よりも大きい値も小さい値も同じ値も取り得ます。

  `load ("revert")`はこれらの関数をロードします。

  例:

      (%i1) load ("revert")$
      (%i2) t: taylor (exp(x) - 1, x, 0, 6);
                         2    3    4    5     6
                        x    x    x    x     x
      (%o2)/T/      x + -- + -- + -- + --- + --- + . . .
                        2    6    24   120   720
      (%i3) revert (t, x);
                     6       5       4       3       2
                 10 x  - 12 x  + 15 x  - 20 x  + 30 x  - 60 x
      (%o3)/R/ - --------------------------------------------
                                      60
      (%i4) ratexpand (%);
                           6    5    4    3    2
                          x    x    x    x    x
      (%o4)             - -- + -- - -- + -- - -- + x
                          6    5    4    3    2
      (%i5) taylor (log(x+1), x, 0, 6);
                          2    3    4    5    6
                         x    x    x    x    x
      (%o5)/T/       x - -- + -- - -- + -- - -- + . . .
                         2    3    4    5    6
      (%i6) ratsimp (revert (t, x) - taylor (log(x+1), x, 0, 6));
      (%o6)                           0
      (%i7) revert2 (t, x, 4);
                                4    3    2
                               x    x    x
      (%o7)                  - -- + -- - -- + x
                               4    3    2

  Power series ·

関数: taylor (expr, x, a, n)
関数: taylor (expr, [x_1, x_2, ...], a, n)
関数: taylor (expr, [x, a, n, 'asymp])
関数: taylor (expr, [x_1, x_2, ...], [a_1, a_2, ...], [n_1, n_2, ...])
関数: taylor (expr, [x_1, a_1, n_1], [x_2, a_2, n_2], ...)

  `taylor (expr, x, a, n)`は、 式exprを、変数xのaの周りのTaylorもしくはLaurent級数を `(x - a)^n`まで展開します。

  もしexprが形式`f(x)/g(x)` の形であり、 `g(x)`がn次まで項を持たないなら、 `taylor`は`g(x)`を`2 n`次まで展開しようとします。 もしまだ0でない項がないなら、 `taylor`は、展開の次数が`n 2^taylordepth`以下である限り `g(x)`の展開の次数を倍にしていきます。

  `taylor (expr, [x_1, x_2, ...], a, n)` は、すべての変数x_1, x_2, ...について 点`(a, a, , ...)`の周りでn次までのべき級数を返します。

  `taylor (expr, [x_1, a_1, n_1], [x_2, a_2, n_2], ...)`は、変数x_1, x_2, ...について 点`(a_1, a_2, ...)`の回りで n_1次, n_2次, ....まで展開したべき級数を返します。

  `taylor (expr, [x_1, x_2, ...], [a_1, a_2, ...], [n_1, n_2, ...])`は、 変数x_1, x_2, ...について、 点`(a_1, a_2, ...)`の回りで n_1次, n_2次, ....まで展開したべき級数を返します。

  `taylor (expr, [x, a, n, 'asymp])`は、 exprの`x - a`の負のべき乗展開を返します。 最高次の項は`(x - a)^-n`です。

  `maxtaylorder`が`true`の時、 （丸められた）Taylor級数の代数操作の間、 `talyor`は正確とわかっている限り多くの項を保とうとします。

  `psexpand`が`true`の時、 拡張有理関数式は、フルに展開されて表示されます。 スイッチ`ratexpand`は同じ効果を持ちます。 `psexpand`が`false`の時、 有理関数パッケージかのように多変数式が表示されます。 `psexpand`が`multi`なら、同じ総次数の項が一緒にグループ化されます。

  展開を制御するには、`taylor_logexpand`スイッチも参照してください。

  例:

      (%i1) taylor (sqrt (sin(x) + a*x + 1), x, 0, 3);
                                 2             2
                   (a + 1) x   (a  + 2 a + 1) x
      (%o1)/T/ 1 + --------- - -----------------
                       2               8

                                         3      2             3
                                     (3 a  + 9 a  + 9 a - 1) x
                                   + -------------------------- + . . .
                                                 48
      (%i2) %^2;
                                          3
                                         x
      (%o2)/T/           1 + (a + 1) x - -- + . . .
                                         6
      (%i3) taylor (sqrt (x + 1), x, 0, 5);
                             2    3      4      5
                        x   x    x    5 x    7 x
      (%o3)/T/      1 + - - -- + -- - ---- + ---- + . . .
                        2   8    16   128    256
      (%i4) %^2;
      (%o4)/T/                  1 + x + . . .
      (%i5) product ((1 + x^i)^2.5, i, 1, inf)/(1 + x^2);

                               inf
                              /===\
                               ! !    i     2.5
                               ! !  (x  + 1)
                               ! !
                              i = 1
      (%o5)                   -----------------
                                    2
                                   x  + 1

      (%i6) ev (taylor(%, x,  0, 3), keepfloat);
                                     2           3
      (%o6)/T/    1 + 2.5 x + 3.375 x  + 6.5625 x  + . . .
      (%i7) taylor (1/log (x + 1), x, 0, 3);
                                     2       3
                       1   1   x    x    19 x
      (%o7)/T/         - + - - -- + -- - ----- + . . .
                       x   2   12   24    720
      (%i8) taylor (cos(x) - sec(x), x, 0, 5);
                                      4
                                 2   x
      (%o8)/T/                - x  - -- + . . .
                                     6
      (%i9) taylor ((cos(x) - sec(x))^3, x, 0, 5);
      (%o9)/T/                    0 + . . .
      (%i10) taylor (1/(cos(x) - sec(x))^3, x, 0, 5);
                                                     2          4
                  1     1       11      347    6767 x    15377 x
      (%o10)/T/ - -- + ---- + ------ - ----- - ------- - --------
                   6      4        2   15120   604800    7983360
                  x    2 x    120 x

                                                                + . . .
      (%i11) taylor (sqrt (1 - k^2*sin(x)^2), x, 0, 6);
                     2  2       4      2   4
                    k  x    (3 k  - 4 k ) x
      (%o11)/T/ 1 - ----- - ----------------
                      2            24

                                          6       4       2   6
                                     (45 k  - 60 k  + 16 k ) x
                                   - -------------------------- + . . .
                                                720
      (%i12) taylor ((x + 1)^n, x, 0, 4);

                            2       2     3      2         3
                          (n  - n) x    (n  - 3 n  + 2 n) x
      (%o12)/T/ 1 + n x + ----------- + --------------------
                               2                 6

                                     4      3       2         4
                                   (n  - 6 n  + 11 n  - 6 n) x
                                 + ---------------------------- + . . .
                                                24

      (%i13) taylor (sin (y + x), x, 0, 3, y, 0, 3);
                     3                 2
                    y                 y
      (%o13)/T/ y - -- + . . . + (1 - -- + . . .) x
                    6                 2

                          3                       2
                     y   y            2      1   y            3
                + (- - + -- + . . .) x  + (- - + -- + . . .) x  + . . .
                     2   12                  6   12
      (%i14) taylor (sin (y + x), [x, y], 0, 3);
                           3        2      2      3
                          x  + 3 y x  + 3 y  x + y
      (%o14)/T/   y + x - ------------------------- + . . .
                                      6
      (%i15) taylor (1/sin (y + x), x, 0, 3, y, 0, 3);
                1   y              1    1               1            2
      (%o15)/T/ - + - + . . . + (- -- + - + . . .) x + (-- + . . .) x
                y   6               2   6                3
                                   y                    y

                                                 1            3
                                            + (- -- + . . .) x  + . . .
                                                  4
                                                 y
      (%i16) taylor (1/sin (y + x), [x, y], 0, 3);
                                   3         2       2        3
                  1     x + y   7 x  + 21 y x  + 21 y  x + 7 y
      (%o16)/T/ ----- + ----- + ------------------------------- + . . .
                x + y     6                   360

  Power series ·

オプション変数: taylordepth

  デフォルト値: 3

  もしまだ非ゼロ項がないなら、 展開の次数が`n 2^taylordepth`以下である限り、 `taylor`は、 `g(x)`の展開の次数を倍にします。

  Power series ·

関数: taylorinfo (expr)

  Taylor級数exprについての情報を返します。 戻り値はリストのリストです。 リストそれぞれは、変数名、展開点、展開次数から成ります。

  もしexprがTaylor級数でないなら、 `taylorinfo`は`false`を返します。

  例:

      (%i1) taylor ((1 - y^2)/(1 - x), x, 0, 3, [y, a, inf]);
                        2                       2
      (%o1)/T/ - (y - a)  - 2 a (y - a) + (1 - a )

               2                        2
       + (1 - a  - 2 a (y - a) - (y - a) ) x

               2                        2   2
       + (1 - a  - 2 a (y - a) - (y - a) ) x

               2                        2   3
       + (1 - a  - 2 a (y - a) - (y - a) ) x  + . . .
      (%i2) taylorinfo(%);
      (%o2)               [[y, a, inf], [x, 0, 3]]

  Power series ·

関数: taylorp (expr)

  もしexprがTaylor級数なら、`true`を、 そうでないなら、`false`を返します。

  Predicate functions ·Power series ·

オプション変数: taylor_logexpand

  デフォルト値: `true`

  `taylor_logexpand`は、 `taylor`級数の中の対数の展開を制御します。

  `taylor_logexpand`が`true`の時、 対数すべては完全に展開されるので、対数的恒等式を含むゼロ認識問題は 展開プロセスを邪魔しません。 しかしながら、分岐情報を無視するので、この方法はいつも数学的にただしいわけではありません。

  `taylor_logexpand`が`false`に設定されている時、 生じる対数の唯一の展開は、 形式的なべき級数を得るのに必要なものです。

  Power series ·Exponential and logarithm functions ·

オプション変数: taylor_order_coefficients

  デフォルト値: `true`

  `taylor_order_coefficients`は、 Taylor級数の中の係数の順序付けを制御します。

  `taylor_order_coefficients`が`true`の時、 Taylor級数の係数は標準に順序付けられます。

  Power series ·

関数: taylor_simplifier (expr)

  べき級数exprの係数を整理します。 `taylor`はこの関数をコールします。

  Power series ·

オプション変数: taylor_truncate_polynomials

  デフォルト値: `true`

  `taylor_truncate_polynomials`が`true`の時、 多項式は入力切り詰めレベルを基礎に切り詰められます。

  そうでないなら、 `taylor`への多項式入力は、 不定の精度を持つと考えられます。

  Power series ·

関数: taytorat (expr)

  `taylor`形式から標準有理式(CRE)形式に exprを変換します。 効果は`rat (ratdisrep (expr))`と同じですが、より速いです。

  Power series ·Rational expressions ·

関数: trunc (expr)

  一般式exprの内部表現をアノテートするので、まるでその和が切り詰められたTaylor級数かのように表示されます。 exprは別に変更されません。

  例:

      (%i1) expr: x^2 + x + 1;
                                  2
      (%o1)                      x  + x + 1
      (%i2) trunc (expr);
                                      2
      (%o2)                  1 + x + x  + . . .
      (%i3) is (expr = trunc (expr));
      (%o3)                         true

  Power series ·

関数: unsum (f, n)

  最初の後方差`f(n) - f(n - 1)`を返します。 従って、 `unsum`は、ある意味、`sum`の逆です。

  `nusum`も参照してください。

  例:

      (%i1) g(p) := p*4^n/binomial(2*n,n);
                                           n
                                        p 4
      (%o1)               g(p) := ----------------
                                  binomial(2 n, n)
      (%i2) g(n^4);
                                    4  n
                                   n  4
      (%o2)                   ----------------
                              binomial(2 n, n)
      (%i3) nusum (%, n, 0, n);
                           4        3       2              n
            2 (n + 1) (63 n  + 112 n  + 18 n  - 22 n + 3) 4      2
      (%o3) ------------------------------------------------ - ------
                          693 binomial(2 n, n)                 3 11 7
      (%i4) unsum (%, n);
                                    4  n
                                   n  4
      (%o4)                   ----------------
                              binomial(2 n, n)

  Sums and products ·

オプション変数: verbose

  デフォルト値: `false`

  `verbose`が`true`の時、 `powerseries`は進捗メッセージを印字します。

  Power series ·

Previous: Functions and Variables for Series, Up: Sums Products and Series [Contents][Index]

### 28.4 Poisson series

関数: intopois (a)

  aをPoisson符号に変換します。

  Poisson series ·

関数: outofpois (a)

  aをPoisson符号から一般表現に変換します。 もしaがPoisson形式でないなら、 `outofpois`は変換を実行し、 すなわち、その戻り値は、`outofpois (intopois (a))`です。 例えば、この関数は、 特定のタイプのサインやコサイン項のべきの和に関する 標準整理器です。

  Poisson series ·

関数: poisdiff (a, b)

  aをbに関して微分します。 bは三角関数の引数の中だけ、または係数の中だけにいなければいけません。

  Poisson series ·

関数: poisexpt (a, b)

  関数的に`intopois (a^b)`と同一です。 bは正の整数でなければいけません。

  Poisson series ·

関数: poisint (a, b)

  (`poisdiffと`)似て制限された意味で積分します。 もしbが三角関数の引数の中にあるなら、 bの中の非周期的項は落とされます。

  Poisson series ·

オプション変数: poislim

  デフォルト値: 5

  `poislim`は、三角関数の引数の中の係数の領域を決定します。 初期値5は 区間[-2^(5-1)+1,2^(5-1)]、すなわち[-15,16]に対応しますが、 [-2^(n-1)+1, 2^(n-1)]に設定することができます。

  Poisson series ·

関数: poismap (series, sinfn, cosfn)

  関数sinfnを与えられたPoisson級数のサイン項に、 cosfnをコサイン項に マップします。 sinfnと cosfnは、２引数関数です。 引数それぞれは、級数の中の項の係数と三角関数部です。

  Poisson series ·

関数: poisplus (a, b)

  関数的に`intopois (a + b)`と同一です。

  Poisson series ·

関数: poissimp (a)

  aを、一般表現のaに関するPoisson級数に変換します。

  Poisson series ·

特殊シンボル: poisson

  シンボル`/P/`は、Poisson級数式の行ラベルに続きます。

  Poisson series ·

関数: poissubst (a, b, c)

  aをcの中のbに代入します。 cはPoisson級数です。

  (1) bが変数u, v, w, x, y, zのいずれかの場合、 aはそれらの変数に関して線形の式(例えば、`6*u + 4*v`)でなければいけません。

  (2) bはそれらの変数以外の場合、 aもまたそれらの変数を含んではいけなく、さらに、サインもコサインも含んではいけません。

  `poissubst (a, b, c, d, n)`は、 上のタイプ(1)のようにaとbに関して演算しますが、 dがPoisson級数の場合、 cの中でbに`a + d`を代入した結果を供給するために、 `cos(d)`と`sin(d)`を次数nに展開する 特殊なタイプの代入です。 アイデアは、 dが小さなパラメータの項に関する展開だということです。 例えば、 `poissubst (u, v, cos(v), %e, 3)`は`cos(u)*(1 - %e^2/2) - sin(u)*(%e - %e^3/6)`をもたらします。

  Poisson series ·

関数: poistimes (a, b)

  `intopois (a*b)`と同じ機能です。

  Poisson series ·

関数: poistrim ()

  (もしユーザーがそれを定義したら) Poisson乗算の間、適用する予約関数です。 項の中のu, v, ..., zの係数を引数とする６引数の述語論理関数です。 (この項の係数に関して)`poistrim`が`true`の項は、 乗算の間に消去されます。

  Poisson series ·

関数: printpois (a)

  可読フォーマットでPoisson級数を印字します。 `outofpois`と共通で、 もし必要なら、aを最初にPoisson符号に変換します。

  Poisson series ·Display functions ·

Next: Symmetries, Previous: Sums Products and Series, Up: Top [Contents][Index]

## 29 Number Theory

Previous: Number Theory, Up: Number Theory [Contents][Index]

### 29.1 Functions and Variables for Number Theory

関数: bern (n)

  整数nについてn番目のBernoulli数を返します。 もし`zerobern`が`false`なら ゼロに等しいBernoulli数は抑制されます。

  `burn`も参照してください。

      (%i1) zerobern: true$
      (%i2) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
                        1  1       1      1        1
      (%o2)       [1, - -, -, 0, - --, 0, --, 0, - --]
                        2  6       30     42       30
      (%i3) zerobern: false$
      (%i4) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
                  1  1    1   5     691   7    3617  43867
      (%o4) [1, - -, -, - --, --, - ----, -, - ----, -----]
                  2  6    30  66    2730  6    510    798

  Number theory ·

関数: bernpoly (x, n)

  変数xに関するn番目のBernoulli多項式を返します。

  Number theory ·

関数: bfzeta (s, n)

  引数sに関するRiemannのゼータ関数を返します。 戻り値は多倍長浮動小数点(bfloat)です; nは戻り値の小数点以下の桁数です。

  Number theory ·Numerical evaluation ·

関数: bfhzeta (s, h, n)

  引数sとhに関するHurwitzのゼータ関数を返します。 戻り値は多倍長浮動小数点(bfloat)です; nは戻り値の小数点以下の桁数です。

  Hurwitzゼータ関数は以下のように定義されます。

                              inf
                              ====
                              \        1
               zeta (s,h)  =   >    --------
                              /            s
                              ====  (k + h)
                              k = 0

  `load ("bffac")`はこの関数をロードします。

  Number theory ·Numerical evaluation ·

関数: burn (n)

  n番目のBernoulli数の近似の有理数をを返します。 `burn`は、(有理)Bernoulli数が まあまあの効率で(超越的)ゼータによって近似できるという観察を利用します。

                         n - 1  1 - 2 n
                    (- 1)      2        zeta(2 n) (2 n)!
           B(2 n) = ------------------------------------
                                      2 n
                                   %pi

  `bern`は、返す前にインデックスnまでのBernoulli数すべてを計算するので、 `burn`は、大きな、孤立したn(たぶん105以上のn) に対して`bern`より効率的かもしれません。 `burn`は、255よりおおきな偶数nに対して近似を呼び出します。 奇数と255以下のnに対しては、関数`bern`が呼び出されます。

  `load ("bffac")`はこの関数をロードします。`bern`も参照してください。

  Number theory ·

関数: cf (expr)

  exprを連分数に変換します。 exprは、 連分数と整数の平方根から成る式です。 式の中のオペランドは　代数演算子を組み合わせられます。 連分数と平方根は別にして、式の中の因子は整数か有理数でなければいけません。 Maximaは、 `cf`の外側で連分数に関する演算について知りません。

  `listarith`を`false`にバインドした後、 `cf`は、引数を評価します。 `cf`は、リストとして表現された連分数を返します。

  連分数`a + 1/(b + 1/(c + ...))`は、 リスト`[a, b, c, ...]`で表現されます。 リストの要素`a`, `b`, `c`, ...は、 整数に評価されなければいけません。 exprは、 may also contain `sqrt (n)`も含むかもしれません。`n`は整数です。 この場合、`cf`は、 変数`cflength`の値掛ける周期と同じ数の連分数の項を与えます。

  連分数は、 `cfdisrep`が返す代数表現を評価することで、 数に評価することができます。 連分数を評価する別の方法に関しては、 `cfexpand`も参照してください。

  `cfdisrep`, `cfexpand`, `cflength`も参照してください。

  例:

  - exprは、連分数と整数の平方根から成る式です。

        (%i1) cf ([5, 3, 1]*[11, 9, 7] + [3, 7]/[4, 3, 2]);
        (%o1)               [59, 17, 2, 1, 1, 1, 27]
        (%i2) cf ((3/17)*[1, -2, 5]/sqrt(11) + (8/13));
        (%o2)        [0, 1, 1, 1, 3, 2, 1, 4, 1, 9, 1, 9, 2]

  - `cflength`は、 連分数の何周期を代数的無理数のために計算するかを制御します。

        (%i1) cflength: 1$
        (%i2) cf ((1 + sqrt(5))/2);
        (%o2)                    [1, 1, 1, 1, 2]
        (%i3) cflength: 2$
        (%i4) cf ((1 + sqrt(5))/2);
        (%o4)               [1, 1, 1, 1, 1, 1, 1, 2]
        (%i5) cflength: 3$
        (%i6) cf ((1 + sqrt(5))/2);
        (%o6)           [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]

  - 連分数は、`cfdisrep`が返す代数的表現を評価することによって評価されることができます。

        (%i1) cflength: 3$
        (%i2) cfdisrep (cf (sqrt (3)))$
        (%i3) ev (%, numer);
        (%o3)                   1.731707317073171

  - Maximaは、 `cf`の外側で連分数に関する演算について知りません。

        (%i1) cf ([1,1,1,1,1,2] * 3);
        (%o1)                     [4, 1, 5, 2]
        (%i2) cf ([1,1,1,1,1,2]) * 3;
        (%o2)                  [3, 3, 3, 3, 3, 6]

  Continued fractions ·

関数: cfdisrep (list)

  連分数`[a, b, c, ...]`のリスト表現から、 形式`a + 1/(b + 1/(c + ...))`の通常の代数式を構成し返します。

      (%i1) cf ([1, 2, -3] + [1, -2, 1]);
      (%o1)                     [1, 1, 1, 2]
      (%i2) cfdisrep (%);
                                        1
      (%o2)                     1 + ---------
                                          1
                                    1 + -----
                                            1
                                        1 + -
                                            2

  Continued fractions ·

関数: cfexpand (x)

  連分数xのコンバージェントの 最後(列1)とその１つ前(列2)の 分子と分母の行列を返します。

      (%i1) cf (rat (ev (%pi, numer)));

      `rat' replaced 3.141592653589793 by 103993/33102 =3.141592653011902
      (%o1)                  [3, 7, 15, 1, 292]
      (%i2) cfexpand (%);
                               [ 103993  355 ]
      (%o2)                    [             ]
                               [ 33102   113 ]
      (%i3) %[1,1]/%[2,1], numer;
      (%o3)                   3.141592653011902

  Continued fractions ·

オプション変数: cflength

  デフォルト値: 1

  `cflength`は、 値`cflength`掛ける周期として 関数`cf`が与える連分数の項の数を制御します。 従って、デフォルトは1周期を与えます。

      (%i1) cflength: 1$
      (%i2) cf ((1 + sqrt(5))/2);
      (%o2)                    [1, 1, 1, 1, 2]
      (%i3) cflength: 2$
      (%i4) cf ((1 + sqrt(5))/2);
      (%o4)               [1, 1, 1, 1, 1, 1, 1, 2]
      (%i5) cflength: 3$
      (%i6) cf ((1 + sqrt(5))/2);
      (%o6)           [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]

  Continued fractions ·

関数: divsum (n, k)
関数: divsum (n)

  `divsum (n, k)`は、 nの約数のk乗した和を返します。

  `divsum (n)`は nの約数の和を返します。

      (%i1) divsum (12);
      (%o1)                          28
      (%i2) 1 + 2 + 3 + 4 + 6 + 12;
      (%o2)                          28
      (%i3) divsum (12, 2);
      (%o3)                          210
      (%i4) 1^2 + 2^2 + 3^2 + 4^2 + 6^2 + 12^2;
      (%o4)                          210

  Number theory ·

関数: euler (n)

  非負の整数nに対して n番目のEuler数を返します。

  Euler-Mascheroni定数に関しては、`%gamma`を参照してください。

      (%i1) map (euler, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
      (%o1)    [1, 0, - 1, 0, 5, 0, - 61, 0, 1385, 0, - 50521]

  Number theory ·

関数: fib (n)

  第n項のFibonacci数を返します。 `fib(0)`は0に等しく、`fib(1)`は1に等しく、 `fib (-n)`は`(-1)^(n + 1) * fib(n)`に等しい。

  `fib`をコールした後， `prevfib`は`fib (x - 1)`、 計算された最後の１つ前のFibonacci数に等しい。

      (%i1) map (fib, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
      (%o1)         [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

  Number theory ·

関数: fibtophi (expr)

  exprに関するFibonacci数を 定数`%phi`を使って表現します。 `%phi`は、`(1 + sqrt(5))/2`, 近似的に1.61803399です。

  例:

      (%i1) fibtophi (fib (n));
                                 n             n
                             %phi  - (1 - %phi)
      (%o1)                  -------------------
                                 2 %phi - 1
      (%i2) fib (n-1) + fib (n) - fib (n+1);
      (%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
      (%i3) fibtophi (%);
                  n + 1             n + 1       n             n
              %phi      - (1 - %phi)        %phi  - (1 - %phi)
      (%o3) - --------------------------- + -------------------
                      2 %phi - 1                2 %phi - 1
                                                n - 1             n - 1
                                            %phi      - (1 - %phi)
                                          + ---------------------------
                                                    2 %phi - 1
      (%i4) ratsimp (%);
      (%o4)                           0

  Number theory ·

関数: ifactors (n)

  正の整数nに対して、 nの素因数分解を返します。 もし`n=p1^e1..pk^nk`が nの素因数への分解なら、 ifactorsは`[[p1, e1], ... , [pk, ek]]`を返します。

  使われる素因数分解法は9973までの素数による試行除算と、 Pollardのロー法、楕円曲線法です。

      (%i1) ifactors(51575319651600);
      (%o1)     [[2, 4], [3, 2], [5, 2], [1583, 1], [9050207, 1]]
      (%i2) apply("*", map(lambda([u], u[1]^u[2]), %));
      (%o2)                        51575319651600

  Number theory ·

関数: igcdex (n, k)

  リスト `[a, b, u]`を返します。 ここで、 uはnと kの最大公約数で、 uは `a n + b k`に等しいです。 引数 nと kは整数でなければいけません。

  `igcdex`はユークリッドのアルゴリズムを実装します。 `gcdex`.も参照してください。

  コマンド `load("gcdex")`はこの関数をロードします。

  例:

      (%i1) load("gcdex")$

      (%i2) igcdex(30,18);
      (%o2)                      [- 1, 2, 6]
      (%i3) igcdex(1526757668, 7835626735736);
      (%o3)            [845922341123, - 164826435, 4]
      (%i4) igcdex(fib(20), fib(21));
      (%o4)                   [4181, - 2584, 1]

  Number theory ·

関数: inrt (x, n)

  xの絶対値の整数n乗根を返します。

      (%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$
      (%i2) map (lambda ([a], inrt (10^a, 3)), l);
      (%o2) [2, 4, 10, 21, 46, 100, 215, 464, 1000, 2154, 4641, 10000]

  Number theory ·

関数: inv_mod (n, m)

  mを法とするnの逆元を計算します。 もしnがmを法とするゼロ因子なら、 `inv_mod (n,m)`は`false`を返します。

      (%i1) inv_mod(3, 41);
      (%o1)                           14
      (%i2) ratsimp(3^-1), modulus=41;
      (%o2)                           14
      (%i3) inv_mod(3, 42);
      (%o3)                          false

  Number theory ·

関数: isqrt (x)

  整数 xの絶対値の「整数平方根」を返します。

  Mathematical functions ·

関数: jacobi (p, q)

  pとqのJacobi記号を返します。

      (%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$
      (%i2) map (lambda ([a], jacobi (a, 9)), l);
      (%o2)         [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0]

  Number theory ·

関数: lcm (expr_1, ..., expr_n)

  引数の最小公倍数を返します。 引数は、整数はもちろん一般式を取り得ます。

  `load ("functs")`はこの関数をロードします。

  Number theory ·

関数: mod (x, y)

  もしxとyが実数で、yがゼロでないなら、 `x - y * floor(x / y)`を返します。 さらにすべての実数xに関して、`mod (x, 0) = x`が成り立ちます。 定義`mod (x, 0) = x`の議論に関しては、 Graham, Knuth, Patashnik著の「コンピュータの数学」の3.4節を参照してください。 関数`mod (x, 1)` は、周期が1で`mod (1, 1) = 0`、`mod (0, 1) = 0`ののこぎり波関数です。

  複素数の偏角の主値（区間`(-%pi, %pi]`での数）を見つけるためには、 関数`x |-> %pi - mod (%pi - x, 2*%pi)`を使います。 xは引数です。

  xとyが定数式(例えば、`10 * %pi`)の時、 `mod`は、`floor`や`ceiling`が使うのと同じ多倍長浮動小数点評価スキームを 使います。 再び同様に、まれですが、`mod`は間違った値を返すことがありえます。

  数値でない引数xやyに関して,`mod`は、いくつかの式整理規則を知っています:

      (%i1) mod (x, 0);
      (%o1)                           x
      (%i2) mod (a*x, a*y);
      (%o2)                      a mod(x, y)
      (%i3) mod (0, x);
      (%o3)                           0

  Mathematical functions ·

関数: next_prime (n)

  nよりも大きな最も小さな素数を返します。

      (%i1) next_prime(27);
      (%o1)                       29

  Number theory ·

関数: partfrac (expr, var)

  主変数varに関する部分分数式exprを展開します。 `partfrac`は、完全な部分分数分解を行います。 利用したアルゴリズムは、 部分分数展開(元の分母の因子)の分母は互いに素であるという事実に基づいています。 分子は分母の線形結合として書け、結果が展開ということになります。

      (%i1) 1/(1+x)^2 - 2/(1+x) + 2/(2+x);
                            2       2        1
      (%o1)               ----- - ----- + --------
                          x + 2   x + 1          2
                                          (x + 1)
      (%i2) ratsimp (%);
                                       x
      (%o2)                 - -------------------
                               3      2
                              x  + 4 x  + 5 x + 2
      (%i3) partfrac (%, x);
                            2       2        1
      (%o3)               ----- - ----- + --------
                          x + 2   x + 1          2
                                          (x + 1)

関数: power_mod (a, n, m)

  `a^n mod m`を計算するために 剰余アルゴリズムを使います。 ここで、aとnは整数で、mは正の整数です。 もしnが負なら、`inv_mod`が剰余逆元を見つけるために使われます。

      (%i1) power_mod(3, 15, 5);
      (%o1)                          2
      <(%i2) mod(3^15,5);
      (%o2)                          2
      (%i3) power_mod(2, -1, 5);
      (%o3)                          3
      (%i4) inv_mod(2,5);
      (%o4)                          3

  Number theory ·

関数: primep (n)

  素数テスト。 もし`primep (n)`が`false`を返すなら、 nは合成数であり、 もし`true`を返すなら、nは非常に高い確立で素数です。

  341550071728321より小さなnに対して、 Miller-Rabinのテストの決定的バージョンが使われます。 もし`primep (n)`が`true`を返すなら、 nは素数です。

  341550071728321よりの大きなnに対して、 `primep`は、 `primep_number_of_tests`個のMiller-Rabinの疑似素数テストと 1つのLucasの疑似素数テストを使います。 nがMiller-Rabinのテスト１つを通過する確率は 1/4より小さいです。 `primep_number_of_tests`に関してデフォルト値25を使うと、 通過したnが合成である確率は 10^-15よりもはるかに小さいです。

  Predicate functions ·Number theory ·

オプション変数: primep_number_of_tests

  デフォルト値: 25

  `primep`の中で使われるMiller-Rabinのテストの回数。

  Predicate functions ·Number theory ·

関数: prev_prime (n)

  nよりも小さな最大の素数を返します。

      (%i1) prev_prime(27);
      (%o1)                       23

  Number theory ·

関数: qunit (n)

  実二次数体`sqrt (n)`の基本単数、 すなわち、ノルムが1の要素を返します。 ここで、nは整数です。 これは、結果的にペル方程式`a^2 - n b^2 = 1`を解くことになります。

      (%i1) qunit (17);
      (%o1)                     sqrt(17) + 4
      (%i2) expand (% * (sqrt(17) - 4));
      (%o2)                           1

  Number theory ·

関数: totient (n)

  n以下の、 nと互いに素な整数の数を返します。

  Number theory ·

オプション変数: zerobern

  デフォルト値: `true`

  `zerobern`が`false`の時、 `bern`はBernoulli数を除外し、`euler`はゼロに等しいEuler数を除外します。 `bern`と`euler`を参照してください。

  Number theory ·

関数: zeta (n)

  Riemannのゼータ関数を返します。 もしxが負の整数、0, 1,または、正の偶数なら、 Reimannのゼータ関数は厳密な値に整理されます。 正の偶数に対しては、 加えて、オプション変数`zeta%pi`は`true`でなければいけません。 (`zeta%pi`を参照してください。) 浮動小数点または多倍長浮動小数点数に対して、Reimannゼータ関数は数値的に評価されます。 Maximaは、 有理非整数、浮動小数点数、複素数の引数を含む 他の引数すべてに対して、また、もし`zeta%pi`が値`false`なら偶数に対して、 名詞形`zeta (n)`を返します。

  `zeta(1)`は未定義ですが、 Maximaは上からと下からの極限`limit(zeta(x), x, ,1)`を知っています。

  `bfzeta`と`zeta%pi`も参照してください。

  例：

      (%i1) zeta([-2, -1, 0, 0.5, 2, 3, 1+%i]);
                                                   2
                  1     1                       %pi
      (%o1) [0, - --, - -, - 1.460354508809586, ----, zeta(3),
                  12    2                        6
                                                          zeta(%i + 1)]
      (%i2) limit(zeta(x),x,1,plus);
      (%o2)                          inf
      (%i3) limit(zeta(x),x,1,minus);
      (%o3)                         minf

  Number theory ·

オプション変数: zeta%pi

  デフォルト値: `true`

  `zeta%pi`が`true`の時、 偶数`n`に対して、`zeta`は`%pi^n`に比例する式を返します。 そうでないなら、 偶数`n`に対して、`zeta`は名詞形`zeta (n)`を返します。

  例:

      (%i1) zeta%pi: true$
      (%i2) zeta (4);
                                       4
                                    %pi
      (%o2)                         ----
                                     90
      (%i3) zeta%pi: false$
      (%i4) zeta (4);
      (%o4)                        zeta(4)

  Number theory ·

Next: Groups, Previous: Number Theory, Up: Top [Contents][Index]

## 30 Symmetries

Next: Functions and Variables for Symmetries, Previous: Symmetries, Up: Symmetries [Contents][Index]

### 30.1 Introduction to Symmetries

`sym`は、多項式の対称群を扱うパッケージです。

これは、 Annick Valibouze (http://www-calfor.lip6.fr/~avb/) によって Macsyma-Symbolicsのために書かれました。 アルゴリズムは、以下の論文に記載されています:

1. Fonctions symétriques et changements de bases. Annick Valibouze. EUROCAL’87 (Leipzig, 1987), 323–332, Lecture Notes in Comput. Sci 378. Springer, Berlin, 1989.
   http://www.stix.polytechnique.fr/publications/1984-1994.html
2. Résolvantes et fonctions symétriques. Annick Valibouze. Proceedings of the ACM-SIGSAM 1989 International Symposium on Symbolic and Algebraic Computation, ISSAC’89 (Portland, Oregon). ACM Press, 390-399, 1989.
   http://www-calfor.lip6.fr/~avb/DonneesTelechargeables/MesArticles/issac89ACMValibouze.pdf
3. Symbolic computation with symmetric polynomials, an extension to Macsyma. Annick Valibouze. Computers and Mathematics (MIT, USA, June 13-17, 1989), Springer-Verlag, New York Berlin, 308-320, 1989.
   http://www.stix.polytechnique.fr/publications/1984-1994.html
4. Théorie de Galois Constructive. Annick Valibouze. Mémoire d’habilitation à diriger les recherches (HDR), Université P. et M. Curie (Paris VI), 1994.

Group theory ·Polynomials ·Share packages ·Package sym ·

Previous: Introduction to Symmetries, Up: Symmetries [Contents][Index]

### 30.2 Functions and Variables for Symmetries

#### 30.2.1 Changing bases

関数: comp2pui (n, L)

  リストLで与えられた与えられた完全対称関数から 0からnまでの基本対称関数にパスすることを実装します。 もしリストLが n+1個より少ない要素を含むなら、 タイプh1, h2などの 形式的な値で完成されます。 もし リストLの最初の要素が存在するなら、 それはアルファベットのサイズを指定します。 そうでないなら、サイズはnに設定されます。

      (%i1) comp2pui (3, [4, g]);
                              2                    2
      (%o1)    [4, g, 2 h2 - g , 3 h3 - g h2 + g (g  - 2 h2)]

  Package sym ·

関数: ele2pui (m, L)

  基本対称関数から完全関数に行きます。 `comp2ele`や`comp2comp`に似ています。

  基数を変える他の関数: `comp2ele`.

  Package sym ·

関数: ele2comp (m, L)

  基本対称関数から完全関数に行きます。 `comp2ele`や`comp2pui`に似ています。

  基数を変える他の関数: `comp2ele`.

  Package sym ·

関数: elem (ele, sym, lvar)

  リストlvarに含まれる変数に関して、 リストeleで与えられた基本対称関数を使って、 対称多項式symを分解します。 もしeleの最初の要素が与えられたら、 アルファベットのサイズで、 そうでないなら、サイズは多項式symの次数です。 もし値がリストeleになければ、 タイプe1, e2などの形式的値が加えられます。 多項式symは３つの異なる形式で与えられます: contracted (`elem`はその時、デフォルト値1であるべきです), partitioned (`elem`は3であるべきです),または extended(すなわち、多項式全体, かつ、`elem`は2であるべきです)。 関数`pui`は同じ方法で使われます。

  サイズ3のアルファベットと値7を持つ最初の基本対称関数e1上で、 (ここで変数の２つにだけ依存する)短縮された形式がx^4-2*x*yである 3変数の対称多項式が以下のように基本対称関数で分解されます:

      (%i1) elem ([3, 7], x^4 - 2*x*y, [x, y]);
      (%o1) 7 (e3 - 7 e2 + 7 (49 - e2)) + 21 e3

                                               + (- 2 (49 - e2) - 2) e2

      (%i2) ratsimp (%);
                                    2
      (%o2)             28 e3 + 2 e2  - 198 e2 + 2401

  基数を変える他の関数: `comp2ele`.

  Package sym ·

関数: mon2schur (L)

  リストLは Schur関数S_Lを表します: we have i_1 <= i_2 <= ... <= i_q成るL = [i_1, i_2, ..., i_q] を持ちます。 Schur関数S_[i_1, i_2, ..., i_q]は、 最初のq個の行と列1 + i_1, 2 + i_2, ..., q + i_q から成る無限行列h_[i-j], i <= 1, j <= 1 の小行列式です。

  このSchur関数は `treinat`と`kostka`を使うことで 単項式の項で書かれることができます。 返される形式は、 変数 x_1,x_2,... の短縮表現の対称多項式です。

      (%i1) mon2schur ([1, 1, 1]);
      (%o1)                       x1 x2 x3

      (%i2) mon2schur ([3]);
                                        2        3
      (%o2)                x1 x2 x3 + x1  x2 + x1

      (%i3) mon2schur ([1, 2]);
                                            2
      (%o3)                  2 x1 x2 x3 + x1  x2

  以上は、3つの変数に関してこれが与えることを意味します:

         2 x1 x2 x3 + x1^2 x2 + x2^2 x1 + x1^2 x3 + x3^2 x1
          + x2^2 x3 + x3^2 x2

  基数を変えるための他の関数: `comp2ele`.

  Package sym ·

関数: multi_elem (l_elem, multi_pc, l_var)

  l_elemに含まれる基本対称関数を使って、リストl_varのリストに含まれる 変数のグループに関して、 多重対称多項式を 多重短縮形multi_pcに分解します。

      (%i1) multi_elem ([[2, e1, e2], [2, f1, f2]], a*x + a^2 + x^3,
            [[x, y], [a, b]]);
                                                        3
      (%o1)         - 2 f2 + f1 (f1 + e1) - 3 e1 e2 + e1

      (%i2) ratsimp (%);
                               2                       3
      (%o2)         - 2 f2 + f1  + e1 f1 - 3 e1 e2 + e1

  基数を変えるための他の関数: `comp2ele`.

  Package sym ·

関数: multi_pui

  関数`multi_elem`が関数`elem`に対するものであるように、 関数`pui`に対するものです。

      (%i1) multi_pui ([[2, p1, p2], [2, t1, t2]], a*x + a^2 + x^3,
            [[x, y], [a, b]]);
                                                  3
                                      3 p1 p2   p1
      (%o1)              t2 + p1 t1 + ------- - ---
                                         2       2

  Package sym ·

関数: pui (L, sym, lvar)

  リストLの中のべき関数を使って、 リストlvarの中の変数に関して、 対称多項式symを分解します。 もしLの最初の要素が与えられるなら、 アルファベットのサイズです。 そうでないなら、サイズは多項式symの次数になります。 もしリストLの中に値がないなら、 タイプp1, p2 , などの形式的な値が加えられます。 多項式symは、 ３つの異なる形式で与えられることができます: contracted (`elem`は1でなければならず、デフォルト値です), partitioned (`elem`は3でなければいけません), extended (すなわち、多項式全体、そして`elem`は2でなければいけません)。 関数`pui`は同じ方法で使われます。

      (%i1) pui;
      (%o1)                           1

      (%i2) pui ([3, a, b], u*x*y*z, [x, y, z]);
                             2
                         a (a  - b) u   (a b - p3) u
      (%o2)              ------------ - ------------
                              6              3

      (%i3) ratsimp (%);
                                             3
                            (2 p3 - 3 a b + a ) u
      (%o3)                 ---------------------
                                      6

  Other functions for changing bases: `comp2ele`.

  Package sym ·

関数: pui2comp (n, lpui)

  リストlpuiで与えられたべき関数を使って、 (最初に長さを持ち)最初のn個の完全関数のリストを返します。 もしリストlpuiが空なら、 基数はnで、 そうでないなら、基数は(`comp2ele`や`comp2pui`同様) 最初の要素です。

      (%i1) pui2comp (2, []);
                                             2
                                      p2 + p1
      (%o1)                   [2, p1, --------]
                                         2

      (%i2) pui2comp (3, [2, a1]);
                                                  2
                                       a1 (p2 + a1 )
                               2  p3 + ------------- + a1 p2
                        p2 + a1              2
      (%o2)     [2, a1, --------, --------------------------]
                           2                  3

      (%i3) ratsimp (%);
                                  2                     3
                           p2 + a1   2 p3 + 3 a1 p2 + a1
      (%o3)        [2, a1, --------, --------------------]
                              2               6

  基数を変えるための他の関数: `comp2ele`.

  Package sym ·

関数: pui2ele (n, lpui)

  べき関数から基本対称関数への変転に影響します。 もしフラグ`pui2ele`が`girard`なら、 1からnまでの基本対称関数のリストを返し、 もしフラグが`close`なら、 n番目の基本対称関数を返します。

  基数を変えるための他の関数: `comp2ele`.

  Package sym ·

関数: puireduc (n, lpui)

  lpuiは 最初の要素が整数mのリストです。 `puireduc`は 最初のm個を使って最初のn個のべき関数を与えます。

      (%i1) puireduc (3, [2]);
                                               2
                                         p1 (p1  - p2)
      (%o1)          [2, p1, p2, p1 p2 - -------------]
                                               2

      (%i2) ratsimp (%);
                                                 3
                                     3 p1 p2 - p1
      (%o2)              [2, p1, p2, -------------]
                                           2

  Package sym ·

関数: schur2comp (P, l_var)

  Pはリストl_varの変数の多項式です。 これらの変数のそれぞれは完全対称関数を表します。 l_varの中で、 i番目の完全対称関数は 文字`h`と整数iの連結`hi`によって表されます。 この関数は PをSchur関数を使って表現します。

      (%i1) schur2comp (h1*h2 - h3, [h1, h2, h3]);
      (%o1)                         s
                                     1, 2

      (%i2) schur2comp (a*h3, [h3]);
      (%o2)                         s  a
                                     3

  Package sym ·

#### 30.2.2 Changing representations

関数: cont2part (pc, lvar)

  変数がlvarの中に含まれている短縮形pcに 関連付けられた分割多項式を返します。

      (%i1) pc: 2*a^3*b*x^4*y + x^5;
                                 3    4      5
      (%o1)                   2 a  b x  y + x

      (%i2) cont2part (pc, [x, y]);
                                         3
      (%o2)              [[1, 5, 0], [2 a  b, 4, 1]]

  Package sym ·

関数: contract (psym, lvar)

  リストlvarに含まれる変数に関する 多項式psymの 短縮形(すなわち、対称群の作用の下での単項軌道)を返します。 関数`explose`は逆演算を実行します。 関数`tcontract`は多項式の対称性をテストします。

      (%i1) psym: explose (2*a^3*b*x^4*y, [x, y, z]);
               3      4      3      4      3    4        3    4
      (%o1) 2 a  b y z  + 2 a  b x z  + 2 a  b y  z + 2 a  b x  z

                                                 3      4      3    4
                                            + 2 a  b x y  + 2 a  b x  y

      (%i2) contract (psym, [x, y, z]);
                                    3    4
      (%o2)                      2 a  b x  y

  Package sym ·

関数: explose (pc, lvar)

  短縮形pcに関連付けられた対称多項式を返します。 リストlvarは変数を含みます。

      (%i1) explose (a*x + 1, [x, y, z]);
      (%o1)                  a z + a y + a x + 1

  Package sym ·

関数: part2cont (ppart, lvar)

  対称式を分割形から短縮形に変換します。 短縮形はlvarの中の変数で表されます。

      (%i1) part2cont ([[2*a^3*b, 4, 1]], [x, y]);
                                    3    4
      (%o1)                      2 a  b x  y

  Package sym ·

関数: partpol (psym, lvar)

  psymは リストlvarの変数に関する対称多項式です。 この関数は分割表現を返します。

      (%i1) partpol (-a*(x + y) + 3*x*y, [x, y]);
      (%o1)               [[3, 1, 1], [- a, 1, 0]]

  Package sym ·

関数: tcontract (pol, lvar)

  多項式polが リストlvarの変数に関して対称かテストします。 もしそうなら、関数`contract`のように短縮表現を返します。

  Package sym ·

関数: tpartpol (pol, lvar)

  多項式polが リストlvarの中の変数に関して 対称かテストします。 もしそうなら 関数`partpol`のように 分割表現を返します。

  Package sym ·

#### 30.2.3 Groups and orbits

関数: direct ([p_1, ..., p_n], y, f, [lvar_1, ..., lvar_n])

  変数lvar_1, ..., lvar_nのリストと 変数yについての多項式p_1, ..., p_nに関して、 関数fに関連付けられた順像 (M. Giusti, D. Lazard et A. Valibouze, ISSAC 1988, Romeを参照してください) を計算します。 関数fのアリティが計算にとって重要です。 例えば、 fについての式がある変数に依存しないなら、 この変数を含むことは役に立たず、含めなければ、 計算量を相当に減らすことにもなるでしょう。

      (%i1) direct ([z^2  - e1* z + e2, z^2  - f1* z + f2],
                    z, b*v + a*u, [[u, v], [a, b]]);
             2
      (%o1) y  - e1 f1 y

                                       2            2             2   2
                        - 4 e2 f2 - (e1  - 2 e2) (f1  - 2 f2) + e1  f1
                      + -----------------------------------------------
                                               2

      (%i2) ratsimp (%);
                    2                2                   2
      (%o2)        y  - e1 f1 y + (e1  - 4 e2) f2 + e2 f1

      (%i3) ratsimp (direct ([z^3-e1*z^2+e2*z-e3,z^2  - f1* z + f2],
                    z, b*v + a*u, [[u, v], [a, b]]));
             6            5         2                        2    2   4
      (%o3) y  - 2 e1 f1 y  + ((2 e1  - 6 e2) f2 + (2 e2 + e1 ) f1 ) y

                                3                               3   3
       + ((9 e3 + 5 e1 e2 - 2 e1 ) f1 f2 + (- 2 e3 - 2 e1 e2) f1 ) y

               2       2        4    2
       + ((9 e2  - 6 e1  e2 + e1 ) f2

                          2       2       2                   2    4
       + (- 9 e1 e3 - 6 e2  + 3 e1  e2) f1  f2 + (2 e1 e3 + e2 ) f1 )

        2          2                      2     3          2
       y  + (((9 e1  - 27 e2) e3 + 3 e1 e2  - e1  e2) f1 f2

                       2            2    3                5
       + ((15 e2 - 2 e1 ) e3 - e1 e2 ) f1  f2 - 2 e2 e3 f1 ) y

                 2                   3           3     2   2    3
       + (- 27 e3  + (18 e1 e2 - 4 e1 ) e3 - 4 e2  + e1  e2 ) f2

               2      3                   3    2   2
       + (27 e3  + (e1  - 9 e1 e2) e3 + e2 ) f1  f2

                         2    4        2   6
       + (e1 e2 e3 - 9 e3 ) f1  f2 + e3  f1

  根が和a+uである多項式を見つけること。 ただし、aはz^2 - e_1 z + e_2の根で、 uはz^2 - f_1 z + f_2の根です。

      (%i1) ratsimp (direct ([z^2 - e1* z + e2, z^2 - f1* z + f2],
                                z, a + u, [[u], [a]]));
             4                    3             2
      (%o1) y  + (- 2 f1 - 2 e1) y  + (2 f2 + f1  + 3 e1 f1 + 2 e2

           2   2                              2               2
       + e1 ) y  + ((- 2 f1 - 2 e1) f2 - e1 f1  + (- 2 e2 - e1 ) f1

                        2                     2            2
       - 2 e1 e2) y + f2  + (e1 f1 - 2 e2 + e1 ) f2 + e2 f1  + e1 e2 f1

           2
       + e2

  `direct`は２つのフラグを受け付けます: `elementaires`と`puissances` (デフォルト) これらは、計算の中に現れる対称多項式を それぞれ基本対称関数またはべき関数に分解することを許します。

  この関数で使われる`sym`の関数は以下の通りです:

  `multi_orbit` (だから`orbit`), `pui_direct`, `multi_elem` (だから`elem`), `multi_pui` (だから`pui`), `pui2ele`, `ele2pui` (もしフラグ`direct`が`puissances`の中にあれば)。

  Package sym ·

関数: multi_orbit (P, [lvar_1, lvar_2,..., lvar_p])

  Pは リストlvar_1, lvar_2, ..., lvar_pに含まれる 変数の集合に関する 多項式です。 この関数は これらpリストで表された変数の集合の対称群の積の作用の下で 多項式Pの 軌道を返します。

      (%i1) multi_orbit (a*x + b*y, [[x, y], [a, b]]);
      (%o1)                [b y + a x, a y + b x]

      (%i2) multi_orbit (x + y + 2*a, [[x, y], [a, b, c]]);
      (%o2)        [y + x + 2 c, y + x + 2 b, y + x + 2 a]

  以下も参照してください: 単対称群の作用に関する`orbit`。

  Package sym ·

関数: multsym (ppart_1, ppart_2, n)

  次数nの対称群の作用を法としてのみ働くことで、 n個の変数に関する２つの対称多項式の積を返します。 多項式は分割形式です。

  x, yに関する鵜２つの対称多項式: 分割形式が`[[3, 1], [2, 1, 1]]`と`[[5, 2]]`である `3*(x + y) + 2*x*y`と`5*(x^2 + y^2)` が与えられたとして、それらの積は、

      (%i1) multsym ([[3, 1], [2, 1, 1]], [[5, 2]], 2);
      (%o1)         [[10, 3, 1], [15, 3, 0], [15, 2, 1]]

  、すなわち、`10*(x^3*y + y^3*x) + 15*(x^2*y + y^2*x) + 15*(x^3 + y^3)`です。

  対称多項式の表現を変える関数は以下の通りです:

  `contract`, `cont2part`, `explose`, `part2cont`, `partpol`, `tcontract`, `tpartpol`。

  Package sym ·

関数: orbit (P, lvar)

  リストlvarの変数の集合の対称群の作用の下で リストlvarの変数に関する多項式Pの軌道を計算します。

      (%i1) orbit (a*x + b*y, [x, y]);
      (%o1)                [a y + b x, b y + a x]

      (%i2) orbit (2*x + x^2, [x, y]);
                              2         2
      (%o2)                 [y  + 2 y, x  + 2 x]

  多項式に関する対称群の積の作用に関しては`multi_orbit`も参照してください。

  Package sym ·

関数: pui_direct (orbite, [lvar_1, ..., lvar_n], [d_1, d_2, ..., d_n])

  fを 変数のn個のブロックlvar_1, ..., lvar_nに関する多項式とします。 c_iを lvar_iの中の変数の数とし、 SCを 次数c_1, ..., c_nの n個の対称群の積とします。 この群は自然にfに作用します。 リストorbiteは SCの作用の下での関数fの軌道で、`SC(f)`を意味します。 (このリストは 関数`multi_orbit`によって得られます。) diは c_1 <= d_1, c_2 <= d_2, ..., c_n <= d_n. を満たすような整数です。

  SDを 対称群 S_[d_1] x S_[d_2] x ... x S_[d_n] の積とします。 関数`pui_direct`は `SC(f)`のべき関数から演繹された `SD(f)`の 最初のn個のべき関数を返します。 ここで、nは`SD(f)`のサイズです。

  結果はSDに関する多重短縮された形式です。 すなわち、SDの作用の下で、軌道毎にただ１つの要素が保持されます。

      (%i1) l: [[x, y], [a, b]];
      (%o1)                   [[x, y], [a, b]]

      (%i2) pui_direct (multi_orbit (a*x + b*y, l), l, [2, 2]);
                                             2  2
      (%o2)               [a x, 4 a b x y + a  x ]

      (%i3) pui_direct (multi_orbit (a*x + b*y, l), l, [3, 2]);
                                   2  2     2    2        3  3
      (%o3) [2 a x, 4 a b x y + 2 a  x , 3 a  b x  y + 2 a  x ,

          2  2  2  2      3    3        4  4
      12 a  b  x  y  + 4 a  b x  y + 2 a  x ,

          3  2  3  2      4    4        5  5
      10 a  b  x  y  + 5 a  b x  y + 2 a  x ,

          3  3  3  3       4  2  4  2      5    5        6  6
      40 a  b  x  y  + 15 a  b  x  y  + 6 a  b x  y + 2 a  x ]

      (%i4) pui_direct ([y + x + 2*c, y + x + 2*b, y + x + 2*a],
            [[x, y], [a, b, c]], [2, 3]);
                                   2              2
      (%o4) [3 x + 2 a, 6 x y + 3 x  + 4 a x + 4 a ,

                       2                   3        2       2        3
                    9 x  y + 12 a x y + 3 x  + 6 a x  + 12 a  x + 8 a ]

  Package sym ·

#### 30.2.4 Partitions

関数: kostka (part_1, part_2)

  P. Esperetによって書かれ、 分割part_1とpart_2のKostka数を計算します。

      (%i1) kostka ([3, 3, 3], [2, 2, 2, 1, 1, 1]);
      (%o1)                           6

  Package sym ·

関数: lgtreillis (n, m)

  重みnと長さmの分割のリストを返します。

      (%i1) lgtreillis (4, 2);
      (%o1)                   [[3, 1], [2, 2]]

  以下も参照してください: `ltreillis`, `treillis`, `treinat`。

  Package sym ·

関数: ltreillis (n, m)

  重みnとm以下の長さの分割のリストを返します。

      (%i1) ltreillis (4, 2);
      (%o1)               [[4, 0], [3, 1], [2, 2]]

  以下も参照してください: `lgtreillis`, `treillis`, `treinat`。

  Package sym ·

関数: treillis (n)

  重みnの分割すべてを返します。

      (%i1) treillis (4);
      (%o1)    [[4], [3, 1], [2, 2], [2, 1, 1], [1, 1, 1, 1]]

  以下も参照してください: `lgtreillis`, `ltreillis`, `treinat`。

  Package sym ·

関数: treinat (part)

  自然な順序に関する分割partより低い分割のリストを返します。

      (%i1) treinat ([5]);
      (%o1)                         [[5]]

      (%i2) treinat ([1, 1, 1, 1, 1]);
      (%o2) [[5], [4, 1], [3, 2], [3, 1, 1], [2, 2, 1], [2, 1, 1, 1],

                                                       [1, 1, 1, 1, 1]]

      (%i3) treinat ([3, 2]);
      (%o3)                 [[5], [4, 1], [3, 2]]

  以下も参照してください: `lgtreillis`, `ltreillis`, `treillis`。

  Package sym ·

#### 30.2.5 Polynomials and their roots

関数: ele2polynome (L, z)

  根の基本対称関数が リスト`L = [n, e_1, ..., e_n]`の中にあるような zに関する多項式を返します。 ここでnは多項式の次数であり、 e_iはi番目の基本対称関数です。

      (%i1) ele2polynome ([2, e1, e2], z);
                                2
      (%o1)                    z  - e1 z + e2

      (%i2) polynome2ele (x^7 - 14*x^5 + 56*x^3  - 56*x + 22, x);
      (%o2)          [7, 0, - 14, 0, 56, 0, - 56, - 22]

      (%i3) ele2polynome ([7, 0, -14, 0, 56, 0, -56, -22], x);
                        7       5       3
      (%o3)            x  - 14 x  + 56 x  - 56 x + 22

  The inverse: `polynome2ele (P, z)`.

  Also see: `polynome2ele`, `pui2polynome`.

  Package sym ·

関数: polynome2ele (P, x)

  リスト`l = [n, e_1, ..., e_n]`を与えます。 ここでnは 変数xに関する多項式Pの次数であり、 e_iは Pの根のi番目の基本対称関数です。

      (%i1) polynome2ele (x^7 - 14*x^5 + 56*x^3 - 56*x + 22, x);
      (%o1)          [7, 0, - 14, 0, 56, 0, - 56, - 22]

      (%i2) ele2polynome ([7, 0, -14, 0, 56, 0, -56, -22], x);
                        7       5       3
      (%o2)            x  - 14 x  + 56 x  - 56 x + 22

  逆: `ele2polynome (l, x)`

  Package sym ·

関数: prodrac (L, k)

  Lは 集合A上の基本対称関数を含む リストです。 `prodrac`は、 根が Aの要素の k掛けるkの積の 多項式を返します。

  `somrac`も参照してください。

  Package sym ·

関数: pui2polynome (x, lpui)

  根のべき関数がリストlpuiで与えられる xに関する多項式を計算します。

      (%i1) pui;
      (%o1)                           1

      (%i2) kill(labels);
      (%o0)                         done

      (%i1) polynome2ele (x^3 - 4*x^2 + 5*x - 1, x);
      (%o1)                     [3, 4, 5, 1]

      (%i2) ele2pui (3, %);
      (%o2)                     [3, 4, 6, 7]

      (%i3) pui2polynome (x, %);
                              3      2
      (%o3)                  x  - 4 x  + 5 x - 1

  以下も参照してください: `polynome2ele`, `ele2polynome`。

  Package sym ·

関数: somrac (L, k)

  リストLは 多項式Pの基本対称関数を含みます。 関数は 根がPの根のk掛けるkの別個の和である 多項式を計算します。

  `prodrac`も参照してください。

  Package sym ·

#### 30.2.6 Resolvents

関数: resolvante (P, x, f, [x_1,..., x_d])

  変数x_1, ..., x_dで表現された関数fによって 次数n >= dの xに関する多項式P の解核を計算します。 計算の効率のため、 変換関数fに現れない変数の リスト`[x_1, ..., x_d]`に含まれないことが重要です。

  計算の効率を増すためには、 適切なアルゴリズムを使うように `resolvante`に関するフラグを設定することができます:

  もし関数fがユニタリなら:

  - 単変数の多項式,
  - 線形,
  - 交互の,
  - 和,
  - 対照的,
  - 積,
  - (次数5まで使用に向く)Cayley解核の関数

        (x1*x2 + x2*x3 + x3*x4 + x4*x5 + x5*x1 -
             (x1*x3 + x3*x5 + x5*x2 + x2*x4 + x4*x1))^2

    一般的,

  `resolvante`のフラグはそれぞれ:

  - unitaire,
  - lineaire,
  - alternee,
  - somme,
  - produit,
  - cayley,
  - generale.

      (%i1) resolvante: unitaire$

      (%i2) resolvante (x^7 - 14*x^5 + 56*x^3 - 56*x + 22, x, x^3 - 1,
            [x]);

      " resolvante unitaire " [7, 0, 28, 0, 168, 0, 1120, - 154, 7840,
                               - 2772, 56448, - 33880,

      413952, - 352352, 3076668, - 3363360, 23114112, - 30494464,

      175230832, - 267412992, 1338886528, - 2292126760]
        3       6      3       9      6      3
      [x  - 1, x  - 2 x  + 1, x  - 3 x  + 3 x  - 1,

       12      9      6      3       15      12       9       6      3
      x   - 4 x  + 6 x  - 4 x  + 1, x   - 5 x   + 10 x  - 10 x  + 5 x

             18      15       12       9       6      3
       - 1, x   - 6 x   + 15 x   - 20 x  + 15 x  - 6 x  + 1,

       21      18       15       12       9       6      3
      x   - 7 x   + 21 x   - 35 x   + 35 x  - 21 x  + 7 x  - 1]
      [- 7, 1127, - 6139, 431767, - 5472047, 201692519, - 3603982011]
             7      6        5         4          3           2
      (%o2) y  + 7 y  - 539 y  - 1841 y  + 51443 y  + 315133 y

                                                    + 376999 y + 125253

      (%i3) resolvante: lineaire$

      (%i4) resolvante (x^4 - 1, x, x1 + 2*x2 + 3*x3, [x1, x2, x3]);

      " resolvante lineaire "
             24       20         16            12             8
      (%o4) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                          4
                                             + 344489984 y  + 655360000

      (%i5) resolvante: general$

      (%i6) resolvante (x^4 - 1, x, x1 + 2*x2 + 3*x3, [x1, x2, x3]);

      " resolvante generale "
             24       20         16            12             8
      (%o6) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                          4
                                             + 344489984 y  + 655360000

      (%i7) resolvante (x^4 - 1, x, x1 + 2*x2 + 3*x3, [x1, x2, x3, x4]);

      " resolvante generale "
             24       20         16            12             8
      (%o7) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                          4
                                             + 344489984 y  + 655360000

      (%i8) direct ([x^4 - 1], x, x1 + 2*x2 + 3*x3, [[x1, x2, x3]]);
             24       20         16            12             8
      (%o8) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                          4
                                             + 344489984 y  + 655360000

      (%i9) resolvante :lineaire$

      (%i10) resolvante (x^4 - 1, x, x1 + x2 + x3, [x1, x2, x3]);

      " resolvante lineaire "
                                    4
      (%o10)                       y  - 1

      (%i11) resolvante: symetrique$

      (%i12) resolvante (x^4 - 1, x, x1 + x2 + x3, [x1, x2, x3]);

      " resolvante symetrique "
                                    4
      (%o12)                       y  - 1

      (%i13) resolvante (x^4 + x + 1, x, x1 - x2, [x1, x2]);

      " resolvante symetrique "
                                 6      2
      (%o13)                    y  - 4 y  - 1

      (%i14) resolvante: alternee$

      (%i15) resolvante (x^4 + x + 1, x, x1 - x2, [x1, x2]);

      " resolvante alternee "
                  12      8       6        4        2
      (%o15)     y   + 8 y  + 26 y  - 112 y  + 216 y  + 229

      (%i16) resolvante: produit$

      (%i17) resolvante (x^7 - 7*x + 3, x, x1*x2*x3, [x1, x2, x3]);

      " resolvante produit "
              35      33         29        28         27        26
      (%o17) y   - 7 y   - 1029 y   + 135 y   + 7203 y   - 756 y

               24           23          22            21           20
       + 1323 y   + 352947 y   - 46305 y   - 2463339 y   + 324135 y

                19           18             17              15
       - 30618 y   - 453789 y   - 40246444 y   + 282225202 y

                   14              12             11            10
       - 44274492 y   + 155098503 y   + 12252303 y   + 2893401 y

                    9            8            7             6
       - 171532242 y  + 6751269 y  + 2657205 y  - 94517766 y

                  5             3
       - 3720087 y  + 26040609 y  + 14348907

      (%i18) resolvante: symetrique$

      (%i19) resolvante (x^7 - 7*x + 3, x, x1*x2*x3, [x1, x2, x3]);

      " resolvante symetrique "
              35      33         29        28         27        26
      (%o19) y   - 7 y   - 1029 y   + 135 y   + 7203 y   - 756 y

               24           23          22            21           20
       + 1323 y   + 352947 y   - 46305 y   - 2463339 y   + 324135 y

                19           18             17              15
       - 30618 y   - 453789 y   - 40246444 y   + 282225202 y

                   14              12             11            10
       - 44274492 y   + 155098503 y   + 12252303 y   + 2893401 y

                    9            8            7             6
       - 171532242 y  + 6751269 y  + 2657205 y  - 94517766 y

                  5             3
       - 3720087 y  + 26040609 y  + 14348907

      (%i20) resolvante: cayley$

      (%i21) resolvante (x^5 - 4*x^2 + x + 1, x, a, []);

      " resolvante de Cayley "
              6       5         4          3            2
      (%o21) x  - 40 x  + 4080 x  - 92928 x  + 3772160 x  + 37880832 x

                                                             + 93392896

  Cayley解核に関して、最後の2つの引数は中立で、 入力多項式は必然的に次数5でなければいけません。

  以下も参照してください:

  `resolvante_bipartite`, `resolvante_produit_sym`, `resolvante_unitaire`, `resolvante_alternee1`, `resolvante_klein`, `resolvante_klein3`, `resolvante_vierer`, `resolvante_diedrale`。

  Package sym ·

関数: resolvante_alternee1 (P, x)

  関数 product(x_i - x_j, 1 <= i < j <= n - 1). によって 次数nの 変換`P(x)`を計算します。 以下も参照してください:

  `resolvante_produit_sym`, `resolvante_unitaire`, `resolvante` , `resolvante_klein`, `resolvante_klein3`, `resolvante_vierer`, `resolvante_diedrale`, `resolvante_bipartite`。

  Package sym ·

関数: resolvante_bipartite (P, x)

  関数 によって 偶次数nの`P(x)`の変換を計算します。 x_1 x_2 ... x_[n/2] + x_[n/2 + 1] ... x_n.

      (%i1) resolvante_bipartite (x^6 + 108, x);
                    10        8           6             4
      (%o1)        y   - 972 y  + 314928 y  - 34012224 y

  以下も参照してください:

  `resolvante_produit_sym`, `resolvante_unitaire`, `resolvante`, `resolvante_klein`, `resolvante_klein3`, `resolvante_vierer`, `resolvante_diedrale`, `resolvante_alternee1`.

  Package sym ·

関数: resolvante_diedrale (P, x)

  関数`x_1 x_2 + x_3 x_4`によって `P(x)`の変換を計算します。

      (%i1) resolvante_diedrale (x^5 - 3*x^4 + 1, x);
             15       12       11       10        9         8         7
      (%o1) x   - 21 x   - 81 x   - 21 x   + 207 x  + 1134 x  + 2331 x

              6         5          4          3          2
       - 945 x  - 4970 x  - 18333 x  - 29079 x  - 20745 x  - 25326 x

       - 697

  以下も参照してください:

  `resolvante_produit_sym`, `resolvante_unitaire`, `resolvante_alternee1`, `resolvante_klein`, `resolvante_klein3`, `resolvante_vierer`, `resolvante`。

  Package sym ·

関数: resolvante_klein (P, x)

  関数`x_1 x_2 x_4 + x_4`によって `P(x)`の変換を計算します。

  以下も参照してください:

  `resolvante_produit_sym`, `resolvante_unitaire`, `resolvante_alternee1`, `resolvante`, `resolvante_klein3`, `resolvante_vierer`, `resolvante_diedrale`。

  Package sym ·

関数: resolvante_klein3 (P, x)

  関数`x_1 x_2 x_4 + x_4`によって `P(x)`の変換を計算します。

  以下も参照してください:

  `resolvante_produit_sym`, `resolvante_unitaire`, `resolvante_alternee1`, `resolvante_klein`, `resolvante`, `resolvante_vierer`, `resolvante_diedrale`。

  Package sym ·

関数: resolvante_produit_sym (P, x)

  多項式`P(x)`のすべての積解核のリストを計算します。

      (%i1) resolvante_produit_sym (x^5 + 3*x^4 + 2*x - 1, x);
              5      4             10      8       7       6       5
      (%o1) [y  + 3 y  + 2 y - 1, y   - 2 y  - 21 y  - 31 y  - 14 y

          4       3      2       10      8       7    6       5       4
       - y  + 14 y  + 3 y  + 1, y   + 3 y  + 14 y  - y  - 14 y  - 31 y

             3      2       5      4
       - 21 y  - 2 y  + 1, y  - 2 y  - 3 y - 1, y - 1]

      (%i2) resolvante: produit$

      (%i3) resolvante (x^5 + 3*x^4 + 2*x - 1, x, a*b*c, [a, b, c]);

      " resolvante produit "
             10      8       7    6        5       4       3     2
      (%o3) y   + 3 y  + 14 y  - y  - 14 y  - 31 y  - 21 y  - 2 y  + 1

  以下も参照してください:

  `resolvante`, `resolvante_unitaire`, `resolvante_alternee1`, `resolvante_klein`, `resolvante_klein3`, `resolvante_vierer`, `resolvante_diedrale`。

  Package sym ·

関数: resolvante_unitaire (P, Q, x)

  多項式`Q(x)`によって 多項式`P(x)`の解核を計算します。

  以下も参照してください:

  `resolvante_produit_sym`, `resolvante`, `resolvante_alternee1`, `resolvante_klein`, `resolvante_klein3`, `resolvante_vierer`, `resolvante_diedrale`。

  Package sym ·

関数: resolvante_vierer (P, x)

  関数`x_1 x_2 - x_3 x_4`によって `P(x)`の変換を計算します。

  以下も参照してください:

  `resolvante_produit_sym`, `resolvante_unitaire`, `resolvante_alternee1`, `resolvante_klein`, `resolvante_klein3`, `resolvante`, `resolvante_diedrale`。

  Package sym ·

#### 30.2.7 Miscellaneous

関数: multinomial (r, part)

  ここでrは分割partの重みです。 この関数は、同類の多項係数を返します: もしpartの部分が i_1, i_2, ..., i_kなら、 結果は `r!/(i_1! i_2! ... i_k!)` です。

  Package sym ·

関数: permut (L)

  リストLの置換のリストを返します。

  Package sym ·Lists ·

Next: Runtime Environment, Previous: Symmetries, Up: Top [Contents][Index]

## 31 Groups

Previous: Groups, Up: Groups [Contents][Index]

### 31.1 Functions and Variables for Groups

関数: todd_coxeter (relations, subgroup)
関数: todd_coxeter (relations)

  G/Hの次数を見つけます。 ここで、Gは法relationsに関する自由群で、 Hは、subgroupが生成するGの部分群です。 subgroupは、オプションの引数であり、 省略すると[]になります。 これをする時には、 GのG/H上の右作用に関する乗算テーブルを生成します。 ここで、剰余類が[H,Hg2,Hg3,...]と数え上げられます。 これは、内部的に変数`todd_coxeter_state`で見ることができます。

  例:

      (%i1) symet(n):=create_list(
              if (j - i) = 1 then (p(i,j))^^3 else
                  if (not i = j) then (p(i,j))^^2 else
                      p(i,i) , j, 1, n-1, i, 1, j);
                                                             <3>
      (%o1) symet(n) := create_list(if j - i = 1 then p(i, j)

                                      <2>
       else (if not i = j then p(i, j)    else p(i, i)), j, 1, n - 1,

      i, 1, j)
      (%i2) p(i,j) := concat(x,i).concat(x,j);
      (%o2)        p(i, j) := concat(x, i) . concat(x, j)
      (%i3) symet(5);
               <2>           <3>    <2>           <2>           <3>
      (%o3) [x1   , (x1 . x2)   , x2   , (x1 . x3)   , (x2 . x3)   ,

                  <2>           <2>           <2>           <3>    <2>
                x3   , (x1 . x4)   , (x2 . x4)   , (x3 . x4)   , x4   ]
      (%i4) todd_coxeter(%o3);

      Rows tried 426
      (%o4)                          120
      (%i5) todd_coxeter(%o3,[x1]);

      Rows tried 213
      (%o5)                          60
      (%i6) todd_coxeter(%o3,[x1,x2]);

      Rows tried 71
      (%o6)                          20

  Group theory ·

Next: Miscellaneous Options, Previous: Groups, Up: Top [Contents][Index]

## 32 Runtime Environment

Next: Interrupts, Previous: Runtime Environment, Up: Runtime Environment [Contents][Index]

### 32.1 Introduction for Runtime Environment

`maxima-init.mac`は、Maximaがスタートする時自動的にロードされるファイルです。 自分のMaxima環境をカスタマイズするために `maxima-init.mac`を使うことができます。 `maxima-init.mac`は、もし存在するなら、 関数`file_search`が検索する任意のディレクトリで大丈夫ですが、 通常は、 `maxima_userdir`で名付けらたディレクトリの中に置かれます。

これは、`maxima-init.mac`ファイルの例です:

    setup_autoload ("specfun.mac", ultraspherical, assoc_legendre_p);
    showtime:all;

この例では、`setup_autoload`は、Maximaに もし関数(`ultraspherical`, `assoc_legendre_p`)のいずれかがコールされて、まだ定義されていなかったら、 指定されたファイル(`specfun.mac`)をロードするように命じます。 このように、関数をコールする前にファイルをロードすることを覚えておく必要はありません。

文`showtime: all`は、Maximaに`showtime`変数を設定することを命じます。 `maxima-init.mac`ファイルは、 他の任意の割り当てやMaxima文を含むことができます。

Session management ·

Next: Functions and Variables for Runtime Environment, Previous: Introduction for Runtime Environment, Up: Runtime Environment [Contents][Index]

### 32.2 Interrupts

ユーザーは、時間のかかる計算を^C (control-C)文字で止めることができます。 デフォルトの動作は、計算を止めて、別のユーザープロンプトを印字することでです。 この場合、止められた計算の再開することはできません。

もし

    :lisp (setq *debugger-hook* nil)

を実行することによって、 Lisp変数`*debugger-hook*`が`nil`に設定されているなら、 ^Cを受け取ると、Maximaは、Lispデバッガに入り、 ユーザーは、Lisp環境を検査するためにデバッガを使うことができます。 止められた計算は、Lispデバッガの中で、 `continue`を入力することで、再開することができます。 (計算を完了まで走らせる以外に) LispデバッガからMaximaに戻る方法は、 Lispのバージョンそれぞれで異なります。

Unixシステム上では、文字^Z (control-Z)は、 Maximaが完全に止まるようにし、 制御は、シェルスクリプトに戻ります。 `fg`コマンドは、Maximaが 止められた点から再開するようにします。

Console interaction ·

Previous: Interrupts, Up: Runtime Environment [Contents][Index]

### 32.3 Functions and Variables for Runtime Environment

宣言: feature

  Maximaは、システムフィーチャと数学式に適用されるフィーチャの、 ２つの異なるタイプのフィーチャを理解します。 See also システムフィーチャについての情報に関しては、`status`も参照してください。 数学的フィーチャについての情報に関しては、 `features`と`featurep`も参照してください。

  `feature`それ自身は、関数名でも変数名でもありません。

関数: featurep (a, f)

  現在のデータベースの中の事実に基づいて オブジェクトaが フィーチャfを持つかどうか を決定しようとします。 もしそうなら、`true`を返し、そうでなければ`false`を返します。

  `featurep`は、 fもfの否定も確立できない時は、 `false`を返すことに注意してください。

  `featurep`は、引数を評価します。

  `declare`と`features`も参照してください。

      (%i1) declare (j, even)$
      (%i2) featurep (j, integer);
      (%o2)                           true

  Predicate functions ·Declarations and inferences ·

システム変数: maxima_tempdir

  `maxima_tempdir`は、Maximaが一時的なファイルを生成するディレクトリを 指名します。 特に、プロットのための一時ファイルが `maxima_tempdir`に生成されます。

  `maxima_tempdir`の初期値は、 もしMaximaが置くことができるなら、ユーザーのホームディレクトリです; そうでなければ、Maximaは適切なディレクトリについて推量します。

  `maxima_tempdir`は、ディレクトリを指名する文字列に割り当てられます。

  Global variables ·

システム変数: maxima_userdir

  `maxima_userdir`は、 Maximaが、MaximaやLispファイルを見つけるために検索するディレクトリを指名します。 (Maximaは、他のディレクトリも検索します; `file_search_maxima`と`file_search_lisp`は、完全なリストです。)

  `maxima_userdir`の初期値は、 もしMaximaが置くことができなら、 ユーザーのホームディレクトリのサブディレクトリです; そうでなければ、Maximaは適切なディレクトリについて推量します。

  `maxima_userdir`は、ディレクトリを指名する文字列に割り当てられます。 しかしながら、 `maxima_userdir`への割り当ては、自動的には `file_search_maxima`と`file_search_lisp`を変えません; それらの変数は、別々に変更しなければいけません。

  Global variables ·

関数: room ()
関数: room (true)
関数: room (false)

  Maximaの記憶装置とスタックマネージメントの状態の描写を印字します。 `room`は、同じ名前のLisp関数をコールします。

  - `room ()`は、適度の描写を印字します。
  - `room (true)`は、言葉数の多い描写を印字します。
  - `room (false)`は、簡潔な描写を印字します。
  Debugging ·

関数: sstatus (keyword, item)

  keywordがシンボル`feature`の時、itemがシステムフィーチャのリスト上に追加されます。 `sstatus (keyword, item)`が実行された後、 `status (feature, item)`は`true`を返します。 もしkeywordがシンボル`nofeature`なら、 itemはシステムフィーチャのリストから削除されます。 これはパッケージ作者が、搭載したフィーチャの追跡をするのに役に立つかもしれません。

  `status`も参照してください。

  Programming ·

関数: status (`feature`)
関数: status (`feature`, item)

  いくつかのシステム依存のフィーチャの存在と不在についての情報を返す。

  - `status (feature)`は、システムフィーチャのリストを返します。 これらは、Lispのバージョン、オペレーティングシステムのタイプなどを含みます。 リストは、１つのLispタイプからもう１つに変わるかもしれません。
  - `status (feature, item)`は、 もしitemが`status (feature)`が返す項目のリスト上にあるなら、 `true`を返し、そうでなければ、`false`を返します。 `status`は、引数itemをクォートします。 クォート-クォート演算子`''`は、クォーテーションに優先されます。 名前が、ハイフンのように特殊文字を含むフィーチャは、 文字列引数として与えられなければいけません。例えば、 `status (feature, "ansi-cl")`。

  `sstatus`も参照してください。

  変数`features`は、 数式に適用される フィーチャのリストを含みます。 もっと情報を知るには、`features`と`featurep`を参照してください。

  Programming ·

関数: system (command)

  別のプロセスとしてcommandを実行します。 コマンドは実行のためデフォルトのシェルに渡されます。 `system`は、オペレーティングシステムすべてではサポートされませんが、 一般にUnixとUnixライクな環境では存在します。

  `_hist.out`が、 `xgraph`を使ってバーグラフとしてプロットしたい頻度のリストだと仮定します。

      (%i1) (with_stdout("_hist.out",
                 for i:1 thru length(hist) do (
                   print(i,hist[i]))),
             system("xgraph -bar -brw .7 -nl < _hist.out"));

  プロットをバックグラウンドで（Maximaに制御を戻すように）させるようにし、終了した後、一次ファルを削除するようにするためには、以下のようにします:

      system("(xgraph -bar -brw .7 -nl < _hist.out;  rm -f _hist.out)&")

関数: time (%o1, %o2, %o3, …)

  出力行`%o1`, `%o2`, `%o3`, …を計算するために使った 時間のリストを秒で返します。 返された時間は、内部計算時間のMaximaの概算であって、経過時間ではありません。 `time`は、出力行変数にだけ適用されます; 他の変数に関して、`time`は`unknown`を返します。

  Maximaに出力行それぞれに計算時間と経過時間を印字させるには、 `showtime: true`を設定してください。

  Debugging ·

関数: timedate ()
関数: timedate (T)

  引数なしの`timedate()`は現在時刻と日付を表す文字列を返します。 文字列は、フォーマット`YYYY-MM-DD HH:MM:SS[+|-]ZZ:ZZ`を持ちます。 ここで、欄は、年、月、日、時、分、秒、時間と分のタイムゾーンオフセットです。

  `timedate(T)`は フォーマット`YYYY-MM-DD HH:MM:SS[+|-]ZZ:ZZ`の文字列として 時刻Tを返します。 Tは `absolute_real_time`が返すような 1990年1月1日の真夜中以来の秒数として解釈されます。

  例:

  引数なしの`timedate()`は現在時刻と日付を表す文字列を返します。

      (%i1) d : timedate ();
      (%o1)                      2010-06-08 04:08:09+01:00
      (%i2) print ("timedate reports current time", d) $
      timedate reports current time 2010-06-08 04:08:09+01:00

  引数ありの`timedate`は引数を表す文字列を返します。

      (%i1) timedate (0);
      (%o1)                      1900-01-01 01:00:00+01:00
      (%i2) timedate (absolute_real_time () - 7*24*3600);
      (%o2)                      2010-06-01 04:19:51+01:00

  Time and date functions ·

関数: absolute_real_time ()

  協定世界時で1900年1月1日の深夜以来の 秒数を返します。 戻り値は整数です。

  `elapsed_real_time`と`elapsed_run_time`も参照してください。

  例:

      (%i1) absolute_real_time ();
      (%o1)                      3385045277
      (%i2) 1900 + absolute_real_time () / (365.25 * 24 * 3600);
      (%o2)                   2007.265612087104

  Time and date functions ·

関数: elapsed_real_time ()

  Maximaがもっとも最近スタートしたか再スタートして以来の (1秒の小数を含む)秒数を返します。 戻り値は浮動小数点数です。

  `absolute_real_time`と`elapsed_run_time`も参照してください。

  例:

      (%i1) elapsed_real_time ();
      (%o1)                       2.559324
      (%i2) expand ((a + b)^500)$
      (%i3) elapsed_real_time ();
      (%o3)                       7.552087

  Time and date functions ·

関数: elapsed_run_time ()

  Maximaがもっとも最近スタートしたか再スタートして以来 Maximaが計算に費やした (1秒の小数を含む)秒数の概算を返します。 戻り値は浮動小数点数です。

  `absolute_real_time`と`elapsed_real_time`も参照してください。

  例:

      (%i1) elapsed_run_time ();
      (%o1)                         0.04
      (%i2) expand ((a + b)^500)$
      (%i3) elapsed_run_time ();
      (%o3)                         1.26

  Time and date functions ·

Next: Rules and Patterns, Previous: Runtime Environment, Up: Top [Contents][Index]

## 33 Miscellaneous Options

Next: Share, Previous: Miscellaneous Options, Up: Miscellaneous Options [Contents][Index]

### 33.1 Introduction to Miscellaneous Options

この節では、Maximaの操作上、グローバルな効果を持つ様々なオプションが論じられます。 すべてのユーザー定義関数のリストのような様々なリストも論じられます。

Next: Functions and Variables for Miscellaneous Options, Previous: Introduction to Miscellaneous Options, Up: Miscellaneous Options [Contents][Index]

### 33.2 Share

Maximaの「共有」ディレクトリは、Maximaユーザーのためのものですが、 Maximaのコア実装の部分ではない、プログラムと他のファイルを含みます。 これらのプログラムは、通常、 `load`や `setup_autoload`によってロードされます。

`:lisp *maxima-sharedir*`は、 ユーザーのファイルシステム内の共有ディレクトリの位置を表示します。

`printfile ("share.usg")`は、 共有パッケージの期限切れリストを印字します。 ユーザーは、 ファイルシステムブラウザを使って共有ディレクトリをブラウズすることがもっと情報が得られることを知るでしょう。

Previous: Share, Up: Miscellaneous Options [Contents][Index]

### 33.3 Functions and Variables for Miscellaneous Options

宣言: alphabetic

  `alphabetic`は、 `declare`が認識する宣言タイプです。 式 `declare(s, alphabetic)`は、Maximaに s―は文字列でなければいけません―の中の文字のすべてをalphabeticとして認識するように 命じます。

  Identifiersも参照してください。

  例:

      (%i1) xx\~yy\`\@ : 1729;
      (%o1)                         1729
      (%i2) declare ("~`@", alphabetic);
      (%o2)                         done
      (%i3) xx~yy`@ + @yy`xx + `xx@@yy~;
      (%o3)               `xx@@yy~ + @yy`xx + 1729
      (%i4) listofvars (%);
      (%o4)                  [@yy`xx, `xx@@yy~]

  Declarations and inferences ·

オプション変数: genindex

  デフォルト値: `i`

  `genindex`は、 必要な時、和の次の変数を生成するために使われる アルファベットの接頭辞です。

  Sums and products ·

オプション変数: gensumnum

  デフォルト値: 0

  `gensumnum`は、 和の次の変数を生成するために使われる 数値接尾辞です。 もし`false`に設定されているなら、 インデックスは数値接尾辞なしで`genindex`だけから成ります。

  Sums and products ·

関数: gensym ()
関数: gensym (x)

  `gensym()`は新鮮なシンボルを生成し、返します。

  新しいシンボルの名前は、 デフォルトでは"g"の接頭辞と Lisp内部カウンタの値がデフォルトの数の十進表現である接尾辞の連結です。

  もしxが供給されて、それが文字列なら、 このgensymへの呼び出しに限って、 その文字列は"g"の代わりに接頭辞として使われます。

  もしxが供給されて、それが整数なら、 このgensymへの呼び出しに限って、 内部Lisp整数の値の代わりに接尾辞として使われます。

  もし陽な接尾辞が供給されないなら、また、その時だけ、 Lisp内部整数は、使われた後1だけ増分されます。

  例:

      (%i1) gensym();
      (%o1)                         g887
      (%i2) gensym("new");
      (%o2)                        new888
      (%i3) gensym(123);
      (%o3)                         g123

関数: properties (a)

  アトムaに関連づけられたプロパティすべての名前のリストを返します。

  Declarations and inferences ·

特殊シンボル: props

  `props`は、 `declare`関数で指定されたプロパティはもちろん、 `atvalue`, `matchdeclare`, などが指定したような、 `infolists`で陽に言及されたもの以外の任意のプロパティ、を持つアトムです。

  Declarations and inferences ·Global variables ·

関数: propvars (prop)

  `props`リスト上の、 propが示すプロパティを持つアトムのリストを返します。 従って， `propvars (atvalue)`は、atvalueを持つアトムのリストを返します。

  Declarations and inferences ·

関数: put (atom, value, indicator)

  valueをatomの(indicatorが指定する)プロパティに割り当てます。 indicatorは、任意のプロパティの名前を取り得ますが、 システム定義のプロパティは取りません。

  `rem`は`put`の効果をひっくり返します。

  `put`は引数を評価します。 `put`はvalueを返します。

  例:

      (%i1) put (foo, (a+b)^5, expr);
                                         5
      (%o1)                       (b + a)
      (%i2) put (foo, "Hello", str);
      (%o2)                         Hello
      (%i3) properties (foo);
      (%o3)            [[user properties, str, expr]]
      (%i4) get (foo, expr);
                                         5
      (%o4)                       (b + a)
      (%i5) get (foo, str);
      (%o5)                         Hello

  Declarations and inferences ·

関数: qput (atom, value, indicator)

  valueをatomの(indicatorが指定する)プロパティに割り当てます。 これは、引数がクォートされることを除いて、`put`と同じです。

  例:

      (%i1) foo: aa$
      (%i2) bar: bb$
      (%i3) baz: cc$
      (%i4) put (foo, bar, baz);
      (%o4)                          bb
      (%i5) properties (aa);
      (%o5)                [[user properties, cc]]
      (%i6) get (aa, cc);
      (%o6)                          bb
      (%i7) qput (foo, bar, baz);
      (%o7)                          bar
      (%i8) properties (foo);
      (%o8)            [value, [user properties, baz]]
      (%i9) get ('foo, 'baz);
      (%o9)                          bar

  Declarations and inferences ·

関数: rem (atom, indicator)

  atomから、indicatorが示すプロパティを取り除きます。 `rem`は`put`の効果をひっくり返します。

  `rem`が呼び出された時、もしatomがindicatorプロパティを持っていたなら、`rem`は`done`を返します。もしそんなプロパティを持っていなかったら`false`を返します。

  Declarations and inferences ·

関数: remove (a_1, p_1, ..., a_n, p_n)
関数: remove ([a_1, …, a_m], [p_1, …, p_n], ...)
関数: remove ("a", operator)
関数: remove (a, transfun)
関数: remove (all, p)

  アトムに関連づけられたプロパティを取り除きます。

  `remove (a_1, p_1, ..., a_n, p_n)` は、アトム`a_k`からプロパティ`p_k`を取り除きます。

  `remove ([a_1, ..., a_m], [p_1, ..., p_n], ...)` は、 アトムa_1, …, a_mから プロパティ`p_1, ..., p_n`を 取り除きます。 リストのペアは複数を取り得ます。

  `remove (all, p)`は、 プロパティpを、それを持つアトムすべてから取り除きます。

  取り除かれるプロパティは、 `function`, `macro`, `mode_declare`のようなシステム定義のプロパティ かもしれません。 `remove`は`put`で定義されたプロパティを取り除きません。

  翻訳されたLispバージョンの関数を取り除くために プロパティは、`transfun`を取ることができます。 これを実行した後は、翻訳バージョンでなく、Maximaバージョンの関数が実行されます。

  `remove ("a", operator)`または、同値な, `remove ("a", op)` は、 aから `prefix`, `infix`, `nary`, `postfix`, `matchfix`, `nofix`が宣言した演算子プロパティを取り除きます。 演算子名はクォートされた文字列として書かれなければいけないことに注意してください。

  アトムが指定されたプロパティを持とうが持ちまいが、 `remove`は、いつも`done`を返します。 この振る舞いは、もっと具体的な削除関数`remvalue`, `remarray`, `remfunction`, `remrule`と似ていません。

  `remove`は引数をクォートします。

  Declarations and inferences ·

関数: remvalue (name_1, ..., name_n)
関数: remvalue (all)

  (添字付きもありえる)ユーザー変数name_1, ..., name_nの値をシステムから 取り除きます。

  `remvalue (all)`は、 removes the values of all variables in `values`―(Maximaが自動的に割り当てたものと対照的に) ユーザーが名前を与えた変数すべてのリスト― の中の変数すべての値を取り除きます。

  `values`も参照してください。

  Evaluation ·

関数: rncombine (expr)

  同一の分母や、たがいに数値因子だけことなる分母を持つ exprのすべての項を結合することで、 exprを変換します。 これは、`combine`の振る舞いとわずかに違います。 `combine`は、同一分母を持つ項を集めます。

  `pfeformat: true`を設定し、`combine`を使うことは、 `rncombine`を使って得られるものと似た結果をもたらしますが、 `rncombine`は、 クロス積の数値的分母因子のおまけのステップを実行します。 これは、きれいな形式と、いくつかの相殺を認識する可能性を生みます。

  `load("rncomb")`はこの関数をロードします。

  Expressions ·

関数: scalarp (expr)

  もしexprが、数か、定数、 `declare`で`scalar`と宣言された変数、 数と定数とそんな変数から完全に構成され、行列やリストを含まない変数なら、 `true`を返します。

  Predicate functions ·Vectors ·Matrices ·

関数: setup_autoload (filename, function_1, ..., function_n)

  もしfunction_1, ..., function_nのいずれかが、 参照されたがまだ定義されていないなら、 `load`を通じてfilenameがロードされるように指定します。 filenameは、 強制はされませんが、普通、指定された関数の定義を含みます。

  `setup_autoload`は配列関数については機能しません。

  `setup_autoload`は引数をクォートします。

  例:

      (%i1) legendre_p (1, %pi);
      (%o1)                  legendre_p(1, %pi)
      (%i2) setup_autoload ("specfun.mac", legendre_p, ultraspherical);
      (%o2)                         done
      (%i3) ultraspherical (2, 1/2, %pi);
      Warning - you are redefining the Macsyma function ultraspherical
      Warning - you are redefining the Macsyma function legendre_p
                                  2
                       3 (%pi - 1)
      (%o3)            ------------ + 3 (%pi - 1) + 1
                            2
      (%i4) legendre_p (1, %pi);
      (%o4)                          %pi
      (%i5) legendre_q (1, %pi);
                                    %pi + 1
                            %pi log(-------)
                                    1 - %pi
      (%o5)                 ---------------- - 1
                                   2

  Function definition ·File input ·

Next: Sets, Previous: Miscellaneous Options, Up: Top [Contents][Index]

## 34 Rules and Patterns

Next: Functions and Variables for Rules and Patterns, Previous: Rules and Patterns, Up: Rules and Patterns [Contents][Index]

### 34.1 Introduction to Rules and Patterns

この節ではユーザー定義のパターンマッチングと整理ルールを記述します。 幾分違ったパターンマッチング体系を実装した２つの関数グループがあります。 １つのグループは、`tellsimp`, `tellsimpafter`, `defmatch`, `defrule`, `apply1`, `applyb1`, `apply2`です。 他のグループは、`let`, `letsimp`です。 どちらの体系も、 `matchdeclare`が宣言したパターン変数を使ってパターンを定義します。

`tellsimp`と`tellsimpafter`が定義するパターンマッチングルールは、 Maximaの整理器によって自動的に適用されます。 `defmatch`, `defrule`, `let`によって定義されたルールは、 明示的に関数をコールすることで適用されます。

更に、`tellrat`が多項式に適用するルール用メカニズムと、 `affine`パッケージの可換/非可換代数用メカニズムがあります。

Simplification ·Rules and patterns ·

Previous: Introduction to Rules and Patterns, Up: Rules and Patterns [Contents][Index]

### 34.2 Functions and Variables for Rules and Patterns

関数: apply1 (expr, rule_1, ..., rule_n)

  rule_1を exprに、失敗するまで繰り返し適用して、 それから同じルールを exprの部分式すべてに左から右へ、 部分式すべてで rule_1が失敗するまで繰り返し適用します。

  この方法で exprを変換した結果を expr_2と呼ぶことにします。 次に、 rule_2を expr_2の最上部から始めて同じ方法で適用します。 rule_nが最後の部分式上で失敗する時、結果が返されます。

  `maxapplydepth`は、 `apply1`と `apply2`が処理する最も深い部分式の深さです。

  `applyb1`, `apply2`, `let`も参照してください。

  Rules and patterns ·

関数: apply2 (expr, rule_1, ..., rule_n)

  もしrule_1が与えられた部分式上で失敗したら、 rule_2が繰り返し適用されます、などなど。 すべてのルールが与えられた部分式上で失敗した時だけ、 ルールの全組が次の部分式に繰り返し適用されます。 もしルールの１つが成功したら、 同じ部分式が最初のルールから再処理されます。

  `maxapplydepth`は、 `apply1`と`apply2`が処理する最も深い部分式の深さです。

  `apply1`と`let`も参照してください。

  Rules and patterns ·

関数: applyb1 (expr, rule_1, ..., rule_n)

  失敗するまで、繰り返し exprの最も深い部分式に rule_1を適用し、 その後、 rule_1がトップレベルの式で失敗するまで、 同じルールを１つ高いレベル(すなわち、より大きな部分式)に適用します。 その後、rule_2がrule_1の結果に 同様に適用されます。 rule_nがトップレベルの式に適用された後、結果が返されます。

  `applyb1`は `apply1`に似ていますが、 トップダウンからの代わりにボトムアップから働きます。

  `maxapplyheight`は `applyb1`が、あきらめる前に届く 最大の高さです

  `apply1`, `apply2`, `let`も参照してください。

  Rules and patterns ·

オプション変数: current_let_rule_package

  デフォルト値: `default_let_rule_package`

  `current_let_rule_package`は、 もし他のルールパッケージが指定されないなら、 (`letsimp`など)`let`パッケージの関数で使われる ルールパッケージの名前です。 この変数は、`let`コマンドを介して定義された任意の規格パッケージの名前を 割り当てられます。

  もし `letsimp (expr, rule_pkg_name)`のようなコールがされたら、 ルールパッケージ`rule_pkg_name`は その関数コールだけのために使われ、 `current_let_rule_package`の値は変わりません。

  Rules and patterns ·

オプション変数: default_let_rule_package

  デフォルト値: `default_let_rule_package`

  `default_let_rule_package`は、 `let`でユーザーによって、 また、`current_let_rule_package`の値を変更することによって、 陽に設定されない時使われる ルールルールの名前です。

  Rules and patterns ·

関数: defmatch (progname, pattern, x_1, …, x_n)
関数: defmatch (progname, pattern)

  patternにマッチするか見るために exprをテストする 関数`progname(expr, x_1, ..., x_n)` を定義します。

  patternは、 (引数として与えられているなら) パターン引数 x_1, ..., x_nを含む式です。 パターン引数は `defmatch`の引数として明示的に与えます。 一方、`matchdeclare`関数がパターン変数を宣言します。 `matchdeclare`のパターン変数か `defmatch`のパターン引数として宣言されていない 任意の変数はそれ自身とのみマッチします。

  生成関数prognameの最初の引数はパターンに対してマッチされる式であり、 他の引数は、パターンの中のダミー変数x_1, ..., x_nに対応する 実際の引数です。

  もしマッチが成功したなら、 prognameは、 左辺がパターン引数やパターン変数で、右辺がパターン引数や変数がマッチした部分式の 等式のリストを返します。 パターン変数はそれらがマッチした部分式に割り当てられますが、 パターン引数には割り当てられません。 もしマッチが失敗したら、 prognameは `false`を返します。

  リテラルパターン(すなわち、パターン引数もパターン変数も含まないパターン)は、 もしマッチが成功したら、 `true`を返します。

  `matchdeclare`, `defrule`, `tellsimp`, `tellsimpafter`も 参照してください。

  例:

  `a`と`b`は`x`を含まず、 `a`が非ゼロであるような 形式`a*x + b`かどうか見るために `expr`をテストする 関数`linearp(expr, x)`を定義します。 パターン引数`x`が`defmatch`に与えられているので、 このマッチ関数は、 任意の変数に関する線形式にマッチします。

      (%i1) matchdeclare (a, lambda ([e], e#0 and freeof(x, e)), b,
                          freeof(x));
      (%o1)                         done
      (%i2) defmatch (linearp, a*x + b, x);
      (%o2)                        linearp
      (%i3) linearp (3*z + (y + 1)*z + y^2, z);
                               2
      (%o3)              [b = y , a = y + 4, x = z]
      (%i4) a;
      (%o4)                         y + 4
      (%i5) b;
                                      2
      (%o5)                          y
      (%i6) x;
      (%o6)                           x

  `a`と`b`は`x`を含まず、 `a`が非ゼロであるような 形式`a*x + b`かどうか見るために `expr`をテストする 関数`linearp(expr, x)`を定義します。 `defmatch`にパターン引数が与えられていないので、 このマッチ関数は、 他の任意の変数ではなく変数`x`に関する線形式にマッチします。

      (%i1) matchdeclare (a, lambda ([e], e#0 and freeof(x, e)), b,
                          freeof(x));
      (%o1)                         done
      (%i2) defmatch (linearp, a*x + b);
      (%o2)                        linearp
      (%i3) linearp (3*z + (y + 1)*z + y^2);
      (%o3)                         false
      (%i4) linearp (3*x + (y + 1)*x + y^2);
                                   2
      (%o4)                  [b = y , a = y + 4]

  定積分かどうか見るために `expr`をテストする 関数`checklimits(expr)`を定義します。

      (%i1) matchdeclare ([a, f], true);
      (%o1)                         done
      (%i2) constinterval (l, h) := constantp (h - l);
      (%o2)        constinterval(l, h) := constantp(h - l)
      (%i3) matchdeclare (b, constinterval (a));
      (%o3)                         done
      (%i4) matchdeclare (x, atom);
      (%o4)                         done
      (%i5) simp : false;
      (%o5)                         false
      (%i6) defmatch (checklimits, 'integrate (f, x, a, b));
      (%o6)                      checklimits
      (%i7) simp : true;
      (%o7)                         true
      (%i8) 'integrate (sin(t), t, %pi + x, 2*%pi + x);

                             x + 2 %pi
                            /
                            [
      (%o8)                 I          sin(t) dt
                            ]
                            /
                             x + %pi

      (%i9) checklimits (%);
      (%o9)    [b = x + 2 %pi, a = x + %pi, x = t, f = sin(t)]

  Rules and patterns ·

関数: defrule (rulename, pattern, replacement)

  与えられたパターンに関する置き換えルールを定義し、名付けます。 もしrulenameと名付けられたルールが (`apply1`, `applyb1`, `apply2`によって) 式に適用されるなら、 パターンにマッチするすべての部分式はreplacementで置き換えられます。 パターンマッチが値を割り当てるreplacementの中の変数すべては その後整理される置き換えの中のそれらの値を割り当てられます。

  ルールそれ自身は、 パターンマッチと置き換えの１演算で式を変換する 関数として扱うことができます。 マッチが失敗したら、ルール関数は`false`を返します。

  Rules and patterns ·

関数: disprule (rulename_1, ..., rulename_2)
関数: disprule (all)

  `defrule`, `tellsimp`, `tellsimpafter`が返すような、または `defmatch`が定義するパターンのような、 名前rulename_1, ..., rulename_nを持つルールを 表示します。 ルールそれぞれは中間式ラベル(`%t`)と一緒に表示されます。

  `disprule (all)`は、ルールすべてを表示します。

  `disprule`は引数をクォートします。 `disprule`は、 表示されたルールに対応する中間式ラベルのリストを返します。

  `let`が定義したルールを表示する `letrules`も参照してください。

  例:

      (%i1) tellsimpafter (foo (x, y), bar (x) + baz (y));
      (%o1)                   [foorule1, false]
      (%i2) tellsimpafter (x + y, special_add (x, y));
      (%o2)                   [+rule1, simplus]
      (%i3) defmatch (quux, mumble (x));
      (%o3)                         quux
      (%i4) disprule (foorule1, "+rule1", quux);
      (%t4)        foorule1 : foo(x, y) -> baz(y) + bar(x)

      (%t5)          +rule1 : y + x -> special_add(x, y)

      (%t6)                quux : mumble(x) -> []

      (%o6)                    [%t4, %t5, %t6]
      (%i6) ''%;
      (%o6) [foorule1 : foo(x, y) -> baz(y) + bar(x),
           +rule1 : y + x -> special_add(x, y), quux : mumble(x) -> []]

  Rules and patterns ·Display functions ·

関数: let (prod, repl, predname, arg_1, ..., arg_n)
関数: let ([prod, repl, predname, arg_1, ..., arg_n], package_name)

  prodはreplで置き換えられるような `letsimp`のための代入ルールを定義します。 prodは、以下の項の正または負のべきの積です:

  - `letsimp`をコールする以前に`matchdeclare`関数が 述語論理をアトムと関連づけるために使われないなら、 `letsimp`が文字通りに検索するアトム。 この場合、`letsimp`はアトムを述語論理を満たす積の任意の項にマッチさせます。
  - `sin(x)`, `n!`, `f(x,y)`などのようなカーネル。 上のアトムと同様に、 述語論理をカーネルの引数に関連づけるために `matchdeclare`が使われないなら `letsimp`は文字通りのマッチを検索します。

  正のべきの項は、少なくともそのべきを持つ項だけにマッチするでしょう。 一方、負のべきの項は、少なくとも負としてのべきをもつ項だけにマッチするでしょう。 prodの中の負のべきの場合、 スイッチ`letrat`を`true`に設定しなければいけません。 `letrat`も参照してください。

  もし述語論理が 引数のリストが続く`let`関数に含まれるなら、 arg_i’がarg_iにマッチした値である場合、 `predname (arg_1', ..., arg_n')`が`true`に評価される時だけ 試験的なマッチ(すなわち、述語論理が省略されたなら受け入れられるもの) が受け入れられます。 arg_iは、任意のアトム名や prodの中に現れる任意の核の引数を取り得ます。 replは、任意の有理式を取り得ます。 もし 任意のアトムやprodからの引数がreplの中に現れるなら、 適切な代入が行われます。

  グローバルフラグ`letrat`は、 `letsimp`による商の整理を制御します。 `letrat`が`false`の時、 `letsimp`は、 exprの分子と分母をそれぞれ整理し、章を整理はしません。 `n!/n`のような代入は`(n-1)!`に進み失敗します。 `letrat`が`true`の時、 分子、分母、商がその順番で整理されます。

  これらの代入関数は、同時にいくつかのルールパッケージを使うことを許します。 ルールパッケージそれぞれは、 任意の数の`let`ルールを含むことができ、ユーザー定義名で参照されます。 コマンド`let ([prod, repl, predname, arg_1, ..., arg_n], package_name)`は、 ルールprednameをルールパッケージpackage_nameに加えます。 コマンド`letsimp (expr, package_name)` は、 package_nameの中でルールを適用します。 `letsimp (expr, package_name1, package_name2, ...)`は、 `letsimp (%, package_name2)`, …が続く `letsimp (expr, package_name1)`と同値です。

  `current_let_rule_package`は、 現在使われているルールパッケージの名前です。 この変数は、 `let`コマンドを介して定義された任意のルールパッケージの名前に割れ当てられます。 `let`パッケージを構成する関数のいずれかがパッケージ名なしでコールされた時はいつでも `current_let_rule_package`が指定したパッケージが使われます。 もし `letsimp (expr, rule_pkg_name)`のようなコールがされたら、 ルールパッケージrule_pkg_nameは、 その`letsimp`コマンドだけで使われ、 `current_let_rule_package`は変わりません。 もし他に指定されないなら、 `current_let_rule_package`は`default_let_rule_package`をデフォルト値とします。

      (%i1) matchdeclare ([a, a1, a2], true)$
      (%i2) oneless (x, y) := is (x = y-1)$
      (%i3) let (a1*a2!, a1!, oneless, a2, a1);
      (%o3)         a1 a2! --> a1! where oneless(a2, a1)
      (%i4) letrat: true$
      (%i5) let (a1!/a1, (a1-1)!);
                              a1!
      (%o5)                   --- --> (a1 - 1)!
                              a1
      (%i6) letsimp (n*m!*(n-1)!/m);
      (%o6)                      (m - 1)! n!
      (%i7) let (sin(a)^2, 1 - cos(a)^2);
                              2               2
      (%o7)                sin (a) --> 1 - cos (a)
      (%i8) letsimp (sin(x)^4);
                              4           2
      (%o8)                cos (x) - 2 cos (x) + 1

  Rules and patterns ·

オプション変数: letrat

  デフォルト値: `false`

  `letrat`が`false`の時、 `letsimp`は 比の分子と分母それぞれを整理し、 商を整理しません。

  `letrat`が`true`の時、 分子、分母、商はその順番に整理されます。

      (%i1) matchdeclare (n, true)$
      (%i2) let (n!/n, (n-1)!);
                               n!
      (%o2)                    -- --> (n - 1)!
                               n
      (%i3) letrat: false$
      (%i4) letsimp (a!/a);
                                     a!
      (%o4)                          --
                                     a
      (%i5) letrat: true$
      (%i6) letsimp (a!/a);
      (%o6)                       (a - 1)!

  Rules and patterns ·

関数: letrules ()
関数: letrules (package_name)

  ルールパッケージのルールを表示します。 `letrules ()`は現在のルールパッケージのルールを表示します。 `letrules (package_name)`は package_nameのルールを表示します。

  現在のルールパッケージは `current_let_rule_package`によって指名されます。 もし他に指定されないなら、 `current_let_rule_package`は`default_let_rule_package`がデフォルト値になります。

  `disprule`も参照してください それは、 `tellsimp`と`tellsimpafter`が定義するルールを表示します。

  Rules and patterns ·

関数: letsimp (expr)
関数: letsimp (expr, package_name)
関数: letsimp (expr, package_name_1, …, package_name_n)

  exprに変化がなくなるまで 繰り返し、`let`が定義する代入ルールを適用します。

  `letsimp (expr)`は `current_let_rule_package`からルールを使います。

  `letsimp (expr, package_name)`は、 `current_let_rule_package`を変えることなしに package_nameからルールを使います。

  `letsimp (expr, package_name_1, ..., package_name_n)`は、 quivalent to `letsimp (%, package_name_2)`などが続く `letsimp (expr, package_name_1`と同値です。

  Rules and patterns ·

オプション変数: let_rule_packages

  デフォルト値: `[default_let_rule_package]`

  `let_rule_packages`は、 デフォルトパッケージ`default_let_rule_package`に加える ユーザー定義のletルールパッケージすべてのリストです。

  Rules and patterns ·

関数: matchdeclare (a_1, pred_1, ..., a_n, pred_n)

  述語論理 pred_kを変数 a_kの変数やリストに関連づけます。 なので、 a_kは述語論理が `false`以外の何かを返す式にマッチします。

  述語論理は関数の名前、ラムダ式、関数コール、最後の引数のないラムダコール、 `true`または `all`です。 任意の式が `true`や `all`にマッチします。 もし述語論理が関数コールかラムダコールとして指定されるなら、 テストされる式が引数のリストに追加されます; マッチが評価される時引数が評価されます。 そうでないなら、述語論理は関数名またはラムダ式として指定され、 テストされる式が唯一の引数です。 `matchdeclare`がコールされた時、述語論理関数は定義されている必要はありません; 述語論理はマッチが試みられるまで評価されません。

  述語論理は、 `true`か `false`はもちろん、ブーリアン式を返すかもしれません。 ブーリアン式は、構成されたルール関数内で `is`によって評価されるので、 述語論理内部で `is`をコールする必要はありません。

  もし式がマッチ述語論理を満たすなら、 マッチ変数が式に割り当てられます。 例外は足し算 `+`や掛け算 `*`のオペランドのマッチ変数です。 足し算と掛け算だけは特別に扱われます; 他のn項演算子(組み込みもユーザー定義も)は通常の関数のように扱われます。

  足し算と掛け算の場合、 マッチ変数はマッチ述語論理を満たす唯一の式か、 そんな式の(それぞれ)和または積に割り当てられます。 そんな多項マッチングはどん欲(greedy)です: 述語論理群はそれらの関連変数がマッチパターンの中で現れる順に評価され、 複数の述語論理を満たす項は、それが満たす最初の述語論理によってマッチされます。 述語論理それぞれは、 次の述語論理が評価される前に 和や積のオペランドすべてに対してテストされます。 加えて、 もし(それぞれ)0か1がマッチ述語論理を満たし、かつ、 述語論理を満たす他の項がないなら、 0か1が述語論理の関連マッチ変数に割り当てられます。

  足し算と掛け算パターンを処理するアルゴリズムは、 (例えば、「任意のものにマッチする」変数が現れるパターンのように) マッチパターンの中やマッチされる式の中の項の順序付けに依存したいくつかのマッチ結果をもたらします。 しかしながら、もしマッチ述語論理すべてが相互に排他的なら、 １つのマッチ述語論理はべつのものがマッチした項を受け入れられないので、 マッチ結果は順序付けに影響されません。

  変数 aを引数として `matchdeclare`をコールすると、 もし既に宣言されているなら、 aに関する `matchdeclare`プロパティが変わります: ルールが定義された時、直近の `matchdeclare`だけが効果を持ちます。 (`matchdeclare`か `remove`を介した) `matchdeclare`プロパティへの後の変更は、存在するルールに影響しません。

  `propvars (matchdeclare)`は `matchdeclare`プロパティを持つ変数すべてのリストを返します。 `printprops (a, matchdeclare)`は、 変数 `a`に関する述語論理を返します。 `printprops (all, matchdeclare)`は、 すべての `matchdeclare`変数に関する述語論理のリストを返します。 `remove (a, matchdeclare)`は、 aから `matchdeclare`プロパティを削除します。

  関数 `defmatch`, `defrule`, `tellsimp`, `tellsimpafter`, `let`は、パターンに対して式をテストするルールを構成します。

  `matchdeclare`は引数をクォートします。 `matchdeclare`はいつも `done`を返します。

  例:

  述語論理は、関数名か、ラムダ式か、最後の引数がない関数コールかラムダコールか、 `true`か `all`です。

      (%i1) matchdeclare (aa, integerp);
      (%o1)                         done
      (%i2) matchdeclare (bb, lambda ([x], x > 0));
      (%o2)                         done
      (%i3) matchdeclare (cc, freeof (%e, %pi, %i));
      (%o3)                         done
      (%i4) matchdeclare (dd, lambda ([x, y], gcd (x, y) = 1) (1728));
      (%o4)                         done
      (%i5) matchdeclare (ee, true);
      (%o5)                         done
      (%i6) matchdeclare (ff, all);
      (%o6)                         done

  もし式がマッチ述語論理を満たすなら、 マッチ変数は式に割り当てられます。

      (%i1) matchdeclare (aa, integerp, bb, atom);
      (%o1)                         done
      (%i2) defrule (r1, bb^aa, ["integer" = aa, "atom" = bb]);
                          aa
      (%o2)        r1 : bb   -> [integer = aa, atom = bb]
      (%i3) r1 (%pi^8);
      (%o3)               [integer = 8, atom = %pi]

  足し算と掛け算の場合、 マッチ変数は、マッチ述語論理を満たす１つの式か、 そんな式の(それぞれ)和か積に割り当てられるかもしれません。

      (%i1) matchdeclare (aa, atom, bb, lambda ([x], not atom(x)));
      (%o1)                         done
      (%i2) defrule (r1, aa + bb, ["all atoms" = aa, "all nonatoms" =
                     bb]);
      bb + aa partitions `sum'
      (%o2)  r1 : bb + aa -> [all atoms = aa, all nonatoms = bb]
      (%i3) r1 (8 + a*b + sin(x));
      (%o3)     [all atoms = 8, all nonatoms = sin(x) + a b]
      (%i4) defrule (r2, aa * bb, ["all atoms" = aa, "all nonatoms" =
                     bb]);
      bb aa partitions `product'
      (%o4)   r2 : aa bb -> [all atoms = aa, all nonatoms = bb]
      (%i5) r2 (8 * (a + b) * sin(x));
      (%o5)    [all atoms = 8, all nonatoms = (b + a) sin(x)]

  `+`と `*`の引数をマッチする時、 もしマッチ述語論理すべてが相互に排他的なら、 １つのマッチ述語論理は別のものがマッチした項を受け入れられないので、 マッチ結果は順序付けに影響されません。

      (%i1) matchdeclare (aa, atom, bb, lambda ([x], not atom(x)));
      (%o1)                         done
      (%i2) defrule (r1, aa + bb, ["all atoms" = aa, "all nonatoms" =
                     bb]);
      bb + aa partitions `sum'
      (%o2)  r1 : bb + aa -> [all atoms = aa, all nonatoms = bb]
      (%i3) r1 (8 + a*b + %pi + sin(x) - c + 2^n);
                                                           n
      (%o3) [all atoms = %pi + 8, all nonatoms = sin(x) + 2  - c + a b]
      (%i4) defrule (r2, aa * bb, ["all atoms" = aa, "all nonatoms" =
                     bb]);
      bb aa partitions `product'
      (%o4)   r2 : aa bb -> [all atoms = aa, all nonatoms = bb]
      (%i5) r2 (8 * (a + b) * %pi * sin(x) / c * 2^n);
                                                        n
                                               (b + a) 2  sin(x)
      (%o5) [all atoms = 8 %pi, all nonatoms = -----------------]
                                                       c

  関数 `propvars`と `printprops`はマッチ変数についての情報を返します。

      (%i1) matchdeclare ([aa, bb, cc], atom, [dd, ee], integerp);
      (%o1)                         done
      (%i2) matchdeclare (ff, floatnump, gg, lambda ([x], x > 100));
      (%o2)                         done
      (%i3) propvars (matchdeclare);
      (%o3)             [aa, bb, cc, dd, ee, ff, gg]
      (%i4) printprops (ee, matchdeclare);
      (%o4)                    [integerp(ee)]
      (%i5) printprops (gg, matchdeclare);
      (%o5)              [lambda([x], x > 100, gg)]
      (%i6) printprops (all, matchdeclare);
      (%o6) [lambda([x], x > 100, gg), floatnump(ff), integerp(ee),
                            integerp(dd), atom(cc), atom(bb), atom(aa)]

  Rules and patterns ·Declarations and inferences ·

オプション変数: maxapplydepth

  デフォルト値: 10000

  `maxapplydepth`は `apply1`と `apply2`が探索する 最大深さです。

  Function application ·

オプション変数: maxapplyheight

  デフォルト値: 10000

  `maxapplyheight`は `applyb1`があきらめる前に到達する 最大高さです。

  Function application ·

関数: remlet (prod, name)
関数: remlet ()
関数: remlet (all)
関数: remlet (all, name)

  `let`関数で直近に定義された 代入ルールprod –> replを削除します。 もし名前が供給されるなら、ルールはルールパッケージ名から削除されます。

  `remlet()`や`remlet(all)`は 現在のルールパッケージから代入ルールすべてを削除します。 もし例えば、`remlet (all, name)`にように、ルールパッケージ名が供給されるなら、 ルールパッケージnameも削除されます。

  もし代入が同じ積を使って変更されるなら、 `remlet`はコールされる必要はなく、 `let`関数と新しい置き換え　かつ/または述語論理名で、文字通りに同じ積を使って代入を再定義だけです。 さて、`remlet (prod)`がコールされると、 元の代入ルールが生き返ります。

  `remrule`も参照してください。 `tellsimp`や`tellsimpafter`で定義されたルールを削除します。

  Rules and patterns ·

関数: remrule (op, rulename)
関数: remrule (op, all)

  `tellsimp`や`tellsimpafter`で定義されたルールを削除します。

  `remrule (op, rulename)`は、 演算子opから 名前rulenameを持つ ルールを削除します。 opが組み込みか (`infix`, `prefix`, などで定義されたような)ユーザー定義演算子の時、 opとrulenameはダブルクォートマークでくくられないといけません。

  `remrule (op, all)`は 演算子opに関するルールすべてを削除します。

  `remlet`も参照してください。 `let`で定義されたルールを削除します。

  例:

      (%i1) tellsimp (foo (aa, bb), bb - aa);
      (%o1)                   [foorule1, false]
      (%i2) tellsimpafter (aa + bb, special_add (aa, bb));
      (%o2)                   [+rule1, simplus]
      (%i3) infix ("@@");
      (%o3)                          @@
      (%i4) tellsimp (aa @@ bb, bb/aa);
      (%o4)                   [@@rule1, false]
      (%i5) tellsimpafter (quux (%pi, %e), %pi - %e);
      (%o5)                  [quuxrule1, false]
      (%i6) tellsimpafter (quux (%e, %pi), %pi + %e);
      (%o6)             [quuxrule2, quuxrule1, false]
      (%i7) [foo (aa, bb), aa + bb, aa @@ bb, quux (%pi, %e),
             quux (%e, %pi)];
                                           bb
      (%o7) [bb - aa, special_add(aa, bb), --, %pi - %e, %pi + %e]
                                           aa
      (%i8) remrule (foo, foorule1);
      (%o8)                          foo
      (%i9) remrule ("+", ?\+rule1);
      (%o9)                           +
      (%i10) remrule ("@@", ?\@\@rule1);
      (%o10)                         @@
      (%i11) remrule (quux, all);
      (%o11)                        quux
      (%i12) [foo (aa, bb), aa + bb, aa @@ bb, quux (%pi, %e),
              quux (%e, %pi)];
      (%o12) [foo(aa, bb), bb + aa, aa @@ bb, quux(%pi, %e),
                                               quux(%e, %pi)]

  Rules and patterns ·

関数: tellsimp (pattern, replacement)

  `tellsimpafter`に似ていますが、 古いものの前に新しい情報を置くので、 組み込み整理ルールの前に適用されます。

  整理器が働く前に式を変更することが重要な時 例えば、整理器が式について何か「知っている」が、それが返すものが好みでないなら、 `tellsimp`が使われます。 もし整理器が式の主演算子について何かを「知っている」が、単に十分でないなら、 たぶん`tellsimpafter`を使いたいでしょう。

  パターンは和、積、変数１つ、または、数は取れません。

  システム変数`rules`は、 `defrule`, `defmatch`, `tellsimp`, `tellsimpafter`で 定義されたルールのリストです。

  例:

      (%i1) matchdeclare (x, freeof (%i));
      (%o1)                         done
      (%i2) %iargs: false$
      (%i3) tellsimp (sin(%i*x), %i*sinh(x));
      (%o3)                 [sinrule1, simp-%sin]
      (%i4) trigexpand (sin (%i*y + x));
      (%o4)         sin(x) cos(%i y) + %i cos(x) sinh(y)
      (%i5) %iargs:true$
      (%i6) errcatch(0^0);
       0
      0  has been generated
      (%o6)                          []
      (%i7) ev (tellsimp (0^0, 1), simp: false);
      (%o7)                  [^rule1, simpexpt]
      (%i8) 0^0;
      (%o8)                           1
      (%i9) remrule ("^", %th(2)[1]);
      (%o9)                           ^
      (%i10) tellsimp (sin(x)^2, 1 - cos(x)^2);
      (%o10)                 [^rule2, simpexpt]
      (%i11) (1 + sin(x))^2;
                                            2
      (%o11)                    (sin(x) + 1)
      (%i12) expand (%);
                                         2
      (%o12)               2 sin(x) - cos (x) + 2
      (%i13) sin(x)^2;
                                        2
      (%o13)                     1 - cos (x)
      (%i14) kill (rules);
      (%o14)                        done
      (%i15) matchdeclare (a, true);
      (%o15)                        done
      (%i16) tellsimp (sin(a)^2, 1 - cos(a)^2);
      (%o16)                 [^rule3, simpexpt]
      (%i17) sin(y)^2;
                                        2
      (%o17)                     1 - cos (y)

  Rules and patterns ·

関数: tellsimpafter (pattern, replacement)

  組み込み整理ルールの後、適Maxima整理器が適用する 整理ルールを定義します。 patternは (`matchdeclare`で宣言された) パターン変数や他のアトムや演算子から成る、 パターンマッチングの目的でリテラルと考えられる式です。 replacementは、 patternにマッチする実際の式に代入されます; replacementの中のパターン変数は 実際の式の中でマッチした値に割り当てられます。

  patternは、 主演算子がパターン変数でない任意の非アトム式を取り得ます; 整理ルールは主演算子に関連付けられます。 (以下で記述する１つの例外がありますが、)関数、リスト、配列の名前が、 (パターン変数でなく)ただリテラルとして、 主演算子としてpatternの中で現れることができます; これは、 パターンとして もし`aa`や`bb`がパターン変数なら `aa(x)`や`bb[y]`のような式を除外します。 パターン変数である関数、リスト、配列の名前は、 patternの中で、主演算子以外の演算子として現れることができます。

  上の関数名に関するルールに１つ例外があります。 `aa[x](y)`のような式の中の添字付き関数の名前は 主演算子が`aa`でなくLispアトム`mqapply`だから、 パターン変数にできます。 これは、添字付き関数を含む式の表現の結果です。

  (もしクォートやフラグ`noeval`を通して抑制されないなら) 整理ルールは、 評価の後、適用されます。 `tellsimpafter`で確立されたルールは、 組み込みルールの後、それらが定義された順に適用されます。 ルールはボトムアップに適用されます。すなわち、 式全体への適用の前に、最初、部分式に適用されます。 ルールすべてが適用されることを保証するために、 (例えば、クォートクォート演算子`''`やフラグ`infeval`を介して) 結果を繰り返し整理する必要があるかもしれません。

  パターン変数は、整理ルールの中でローカル変数として扱われます。 一旦ルールが定義されると、パターン変数の値は、 ルールに影響せず、ルールによって影響されません。 成功したルールマッチの結果となるパターン変数への割り当ては、 パターン変数の現在の割り当て(またはその欠落)に影響しません。 しかしながら、Maximaの中のアトムすべてで、 (`put`や関連関数で定義された)パターン変数のプロパティはグローバルです。

  `tellsimpafter`によって構成されたルールは、 patternの主演算子に由来します。 組み込み演算子や `infix`, `prefix`, `postfix`, `matchfix`, `nofix`で 定義されたユーザー定義演算子に関するルールは、 Lisp識別子である名前を持ちます。 他の関数に関するルールは、Maxima識別子である名前を持ちます。

  名詞と動詞形の扱いは少し混乱しています。 もしルールが名詞(または動詞)形に関して定義されて、 対応する動詞(または名詞)形に関するルールが既に存在しているなら、 新しく定義されたルールは両方の形式(名詞と動詞)に適用されます。 もし対応する動詞(名詞)形に関するルールが存在しないなら、 新しく定義されたルールは名詞(または動詞)形にだけ適用されます。

  `tellsimpafter`で構成されたルールは通常のLisp関数です。 もしルール名が`$foorule1`なら、 構成子`:lisp (trace $foorule1)`は関数をトレースし、 `:lisp (symbol-function '$foorule1)`は定義を表示します。

  `tellsimpafter`は引数をクォートします。 `tellsimpafter`は 新しく確立されたルールを含む、 patternの主演算子に関する ルールのリストを返します。

  `matchdeclare`, `defmatch`, `defrule`, `tellsimp`, `let`, `kill`, `remrule`, `clear_rules`も参照してください。

  例:

  patternは、 主演算子がパターン変数でない任意の非アトム式を取り得ます。

      (%i1) matchdeclare (aa, atom, [ll, mm], listp, xx, true)$
      (%i2) tellsimpafter (sin (ll), map (sin, ll));
      (%o2)                 [sinrule1, simp-%sin]
      (%i3) sin ([1/6, 1/4, 1/3, 1/2, 1]*%pi);
                          1  sqrt(2)  sqrt(3)
      (%o3)              [-, -------, -------, 1, 0]
                          2     2        2
      (%i4) tellsimpafter (ll^mm, map ("^", ll, mm));
      (%o4)                  [^rule1, simpexpt]
      (%i5) [a, b, c]^[1, 2, 3];
                                      2   3
      (%o5)                      [a, b , c ]
      (%i6) tellsimpafter (foo (aa (xx)), aa (foo (xx)));
      (%o6)                   [foorule1, false]
      (%i7) foo (bar (u - v));
      (%o7)                    bar(foo(u - v))

  ルールはそれらが定義された順に適用されます。 もし２つのルールが式にマッチできるなら、 最初に定義されたルールが適用されます。

      (%i1) matchdeclare (aa, integerp);
      (%o1)                         done
      (%i2) tellsimpafter (foo (aa), bar_1 (aa));
      (%o2)                   [foorule1, false]
      (%i3) tellsimpafter (foo (aa), bar_2 (aa));
      (%o3)              [foorule2, foorule1, false]
      (%i4) foo (42);
      (%o4)                       bar_1(42)

  整理ルールの中で、パターン変数はローカル変数として扱われます。 (`defmatch`と比較してください。 パターン変数をグローバル変数として扱います。)

      (%i1) matchdeclare (aa, integerp, bb, atom);
      (%o1)                         done
      (%i2) tellsimpafter (foo(aa, bb), bar('aa=aa, 'bb=bb));
      (%o2)                   [foorule1, false]
      (%i3) bb: 12345;
      (%o3)                         12345
      (%i4) foo (42, %e);
      (%o4)                 bar(aa = 42, bb = %e)
      (%i5) bb;
      (%o5)                         12345

  アトムすべてには、 パターン変数のプロパティは、たとえ値がローカルでも、 グローバルです。 この例では、割り当てプロパティは `define_variable`を介して宣言されます。 Maximaの至る所で、これはアトム`bb`のプロパティです。

      (%i1) matchdeclare (aa, integerp, bb, atom);
      (%o1)                         done
      (%i2) tellsimpafter (foo(aa, bb), bar('aa=aa, 'bb=bb));
      (%o2)                   [foorule1, false]
      (%i3) foo (42, %e);
      (%o3)                 bar(aa = 42, bb = %e)
      (%i4) define_variable (bb, true, boolean);
      (%o4)                         true
      (%i5) foo (42, %e);
      Error: bb was declared mode boolean, has value: %e
       -- an error.  Quitting.  To debug this try debugmode(true);

  ルールは主演算子に由来します。 組み込みやユーザー定義の演算子に関するルール名はLisp識別子で、 一方、他の関数に関する名前はMaxima識別子です。

      (%i1) tellsimpafter (foo (%pi + %e), 3*%pi);
      (%o1)                   [foorule1, false]
      (%i2) tellsimpafter (foo (%pi * %e), 17*%e);
      (%o2)              [foorule2, foorule1, false]
      (%i3) tellsimpafter (foo (%i ^ %e), -42*%i);
      (%o3)         [foorule3, foorule2, foorule1, false]
      (%i4) tellsimpafter (foo (9) + foo (13), quux (22));
      (%o4)                   [+rule1, simplus]
      (%i5) tellsimpafter (foo (9) * foo (13), blurf (22));
      (%o5)                  [*rule1, simptimes]
      (%i6) tellsimpafter (foo (9) ^ foo (13), mumble (22));
      (%o6)                  [^rule1, simpexpt]
      (%i7) rules;
      (%o7) [foorule1, foorule2, foorule3, +rule1, *rule1, ^rule1]
      (%i8) foorule_name: first (%o1);
      (%o8)                       foorule1
      (%i9) plusrule_name: first (%o4);
      (%o9)                        +rule1
      (%i10) remrule (foo, foorule1);
      (%o10)                         foo
      (%i11) remrule ("^", ?\^rule1);
      (%o11)                          ^
      (%i12) rules;
      (%o12)        [foorule2, foorule3, +rule1, *rule1]

  加工された例: 反可換乗算。

      (%i1) gt (i, j) := integerp(j) and i < j;
      (%o1)           gt(i, j) := integerp(j) and i < j
      (%i2) matchdeclare (i, integerp, j, gt(i));
      (%o2)                         done
      (%i3) tellsimpafter (s[i]^^2, 1);
      (%o3)                 [^^rule1, simpncexpt]
      (%i4) tellsimpafter (s[i] . s[j], -s[j] . s[i]);
      (%o4)                   [.rule1, simpnct]
      (%i5) s[1] . (s[1] + s[2]);
      (%o5)                    s  . (s  + s )
                                1     2    1
      (%i6) expand (%);
      (%o6)                      1 - s  . s
                                      2    1
      (%i7) factor (expand (sum (s[i], i, 0, 9)^^5));
      (%o7) 100 (s  + s  + s  + s  + s  + s  + s  + s  + s  + s )
                  9    8    7    6    5    4    3    2    1    0

  Rules and patterns ·

関数: clear_rules ()

  `kill (rules)`を実行し、 足し算`+`, 掛け算`*`, べき`^`に関して 次のルール番号を1に再設定します。

  Rules and patterns ·

Next: Function Definition, Previous: Rules and Patterns, Up: Top [Contents][Index]

## 35 Sets

Next: Functions and Variables for Sets, Previous: Sets, Up: Sets [Contents][Index]

### 35.1 Introduction to Sets

Maximaは、 陽な列挙によって定義された有限集合のために、 積集合や和集合のような、集合関数を提供します。 Maximaは、リストと集合を別のオブジェクトとして扱います。 この特長は、 リストまたは集合であるメンバーがリストであったり集合であったりする集合を扱うことを可能にします。

有限集合のための関数に加えて、 Maximaは、 組み合わせ論に関係したいくつかの関数を提供します; これらは、第一種と第二種スターリング数、ベル数、第一種と第二種の多項係数、 非負整数の分割、と2,3の他の関数です。 Maximaは、クロネッカーのデルタ関数も定義します。

#### 35.1.1 Usage

メンバー`a_1, ..., a_n`の集合を構成するには、 `set(a_1, ..., a_n)`または`{a_1, ..., a_n}`を書いてください; 空集合を構成するには、 `set()`または`{}`を書いてください。 入力では、 `set(...)`と`{ ... }`は同値です。 集合は、いつも中括弧で表示されます。

もしメンバーが一度以上リストされているなら、 整理は、冗長なメンバーを消去します。

    (%i1) set();
    (%o1)                          {}
    (%i2) set(a, b, a);
    (%o2)                        {a, b}
    (%i3) set(a, set(b));
    (%o3)                       {a, {b}}
    (%i4) set(a, [b]);
    (%o4)                       {a, [b]}
    (%i5) {};
    (%o5)                          {}
    (%i6) {a, b, a};
    (%o6)                        {a, b}
    (%i7) {a, {b}};
    (%o7)                       {a, {b}}
    (%i8) {a, [b]};
    (%o8)                       {a, [b]}

２つの要素志望xとyは、 `is(x = y)`が`true`をもたらす (すなわち、集合構成の目的で同じと見なされる) 時だけ 冗長です。 `is(x = y)`が`false`をもたらす一方、 `is(equal(x, y))`は、`true`をもたらす可能性があることに 注意してください; その場合、要素xとyは異なったものと見なされます。

    (%i1) x: a/c + b/c;
                                  b   a
    (%o1)                         - + -
                                  c   c
    (%i2) y: a/c + b/c;
                                  b   a
    (%o2)                         - + -
                                  c   c
    (%i3) z: (a + b)/c;
                                  b + a
    (%o3)                         -----
                                    c
    (%i4) is (x = y);
    (%o4)                         true
    (%i5) is (y = z);
    (%o5)                         false
    (%i6) is (equal (y, z));
    (%o6)                         true
    (%i7) y - z;
                               b + a   b   a
    (%o7)                    - ----- + - + -
                                 c     c   c
    (%i8) ratsimp (%);
    (%o8)                           0
    (%i9) {x, y, z};
                              b + a  b   a
    (%o9)                    {-----, - + -}
                                c    c   c

リストの要素から集合を構成するには、`setify`を使ってください。

    (%i1) setify ([b, a]);
    (%o1)                        {a, b}

もし`is(x = y)`が`true`に評価されるなら、 集合の元`x`と`y`は等しいです。 従って、`rat(x)`と`x`は集合の元として等しいです; 結果として、

    (%i1) {x, rat(x)};
    (%o1)                          {x}

さらに、 `is((x - 1)*(x + 1) = x^2 - 1)`は`false`に評価されるので、 `(x - 1)*(x + 1)`と`x^2 - 1`は集合の異なる元です; 従って、

    (%i1) {(x - 1)*(x + 1), x^2 - 1};
                                           2
    (%o1)               {(x - 1) (x + 1), x  - 1}

この集合を1元集合に縮小するには、 `rat`を集合の元それぞれに適用してください:

    (%i1) {(x - 1)*(x + 1), x^2 - 1};
                                           2
    (%o1)               {(x - 1) (x + 1), x  - 1}
    (%i2) map (rat, %);
                                  2
    (%o2)/R/                    {x  - 1}

他の集合から冗長性を取り除くために、 他の整理関数を使う必要があるかもしれません。 以下は、`trigsimp`を使った例です:

    (%i1) {1, cos(x)^2 + sin(x)^2};
                                2         2
    (%o1)                {1, sin (x) + cos (x)}
    (%i2) map (trigsimp, %);
    (%o2)                          {1}

元が、冗長でなく、並べ換えられている時 集合は整理されてます。 集合関数の現在のバージョンは、 集合を順に並べるためにMaxima関数`orderlessp`を使います; しかしながら、 集合関数の将来のバージョンは、違う並び替え関数を使うかもしれません。

代入のような、集合に関するいくつかの演算は、 再整理を自動的に強制します; 例えば、

    (%i1) s: {a, b, c}$
    (%i2) subst (c=a, s);
    (%o2)                        {a, b}
    (%i3) subst ([a=x, b=x, c=x], s);
    (%o3)                          {x}
    (%i4) map (lambda ([x], x^2), set (-1, 0, 1));
    (%o4)                        {0, 1}

Maximaは、リストと集合を異なるオブジェクトとして扱います; `union`や`intersection`のような関数は、 もし引数のいずれかがしゅうごうでないなら、文句を言います。 もしリストに集合関数を適用する必要があるなら、 集合に変換するために、 `setify`関数を使ってください。 例えば、

    (%i1) union ([1, 2], {a, b});
    Function union expects a set, instead found [1,2]
     -- an error.  Quitting.  To debug this try debugmode(true);
    (%i2) union (setify ([1, 2]), {a, b});
    (%o2)                     {1, 2, a, b}

集合`s`の集合要素のうち述語論理`f`を満たすすべての要素を抽出するためには、 use `subset(s, f)`を使ってください。 (述語論理はブーリアン値関数です。) 例えば、 与えられた集合の中で、変数`z`に依存しない等式を見つけるには、 以下を使ってください。

    (%i1) subset ({x + y + z, x - y + 4, x + y - 5},
                                        lambda ([e], freeof (z, e)));
    (%o1)               {- y + x + 4, y + x - 5}

節Functions and Variables for Setsは、 Maximaの集合関数の完全なリストを持ちます。

Sets ·

#### 35.1.2 Set Member Iteration

集合の元上を反復する２つの方法があります。 １つの方法は`map`の使用です; 例えば:

    (%i1) map (f, {a, b, c});
    (%o1)                  {f(a), f(b), f(c)}

他の方法は、 `for x in s do`を使うことです。

    (%i1) s: {a, b, c};
    (%o1)                       {a, b, c}
    (%i2) for si in s do print (concat (si, 1));
    a1
    b1
    c1
    (%o2)                         done

Maxima関数`first`と`rest`は、 集合に対して正しく機能します。 集合に適用されると、 `first`は、最初に表示される集合の要素を返します; それは、実装依存かもしれません。 もし`s`が集合なら `rest(s)`は、`disjoin(first(s), s)`と同値です。 現在、 集合に対して正しく機能する他のMaxima関数があります。 集合関数の将来のバージョンでは、 `first`と`rest`は、違うように機能するかもしれませんし、そうでないかもしれません。

#### 35.1.3 Bugs

集合関数は、 集合の元を並び換えるために、 Maxima関数`orderlessp`を使い、 集合の元の同一性をテストするために(Lispレベルの)関数`like`を使います。 これらの関数の両方は、 もし標準有理式(CRE)形式の式を含むリストや行列が元の集合を使おうとするなら、現れる既知のバグを持ちます。 例は以下の通りです。

    (%i1) {[x], [rat (x)]};
    Maxima encountered a Lisp error:

      The value #:X1440 is not of type LIST.

    Automatically continuing.
    To reenable the Lisp debugger set *debugger-hook* to nil.

この式は、Maximaがエラーで停止する原因となります。 (エラーメッセージはMaximaが使うLispのバージョンに依ります。) もう１つの例は、以下の通りです。

    (%i1) setify ([[rat(a)], [rat(b)]]);
    Maxima encountered a Lisp error:

      The value #:A1440 is not of type LIST.

    Automatically continuing.
    To reenable the Lisp debugger set *debugger-hook* to nil.

これらのバグは、 `orderlessp`と`like`の中にあるバグに原因します; それらは、集合関数の中のバグが原因ではありません。 例証するには、以下の式を試してください。

    (%i1) orderlessp ([rat(a)], [rat(b)]);
    Maxima encountered a Lisp error:

      The value #:B1441 is not of type LIST.

    Automatically continuing.
    To reenable the Lisp debugger set *debugger-hook* to nil.
    (%i2) is ([rat(a)] = [rat(a)]);
    (%o2)                         false

これらのバグが直されるまで、 CRE形式の式を含むリストや行を元に持つ集合を構成しないでください; しかしながら、CRE形式の元を持つ集合は、問題ないはずです:

    (%i1) {x, rat (x)};
    (%o1)                          {x}

Maximaの`orderlessp`は、 集合関数で問題の原因となる可能性がある もう１つのバグを持ちます。 それは、すなわち、順序付け述語論理`orderlessp`が推移的でないことです。 これを示す最も簡単な既知の例は、以下の通りです。

    (%i1) q: x^2$
    (%i2) r: (x + 1)^2$
    (%i3) s: x*(x + 2)$
    (%i4) orderlessp (q, r);
    (%o4)                         true
    (%i5) orderlessp (r, s);
    (%o5)                         true
    (%i6) orderlessp (q, s);
    (%o6)                         false

このバグは、一般的にMaximaの関数はもちろん、集合関数すべてにおいて、 問題の原因となる可能性があります。 確実ではありませんが、 もし集合の元すべてがCRE形式であるか、`ratsimp`を使って整理されていれば、 このバグはたぶん避けられます。

Maximaの`orderless`と`ordergreat`メカニズムは、 集合関数と互換性がありません。 もし、`orderless`か`ordergreat`のいずれかを使う必要があるなら、 いかなる集合を構成する前に、これらの関数をコールしてください。 そして、`unorder`をコールしないでください。

もし集合関数のバグかもしれないと思う何かを見つけたら、 どうかMaximaのバグデータベースに報告してください。 `bug_report`を参照してください。

#### 35.1.4 Authors

マサチューセッツ州ケンブリッジ市のStavros Macrakisと、 ネブラスカ大学カーニー校(UNK)のBarton Willisが、 Maximaの集合関数とそれらのドキュメンテーションを書きました。

Previous: Introduction to Sets, Up: Sets [Contents][Index]

### 35.2 Functions and Variables for Sets

関数: adjoin (x, a)

  集合aに要素`{x}`を加えた集合を返します。

  もしaが集合リテラルでないなら、 `adjoin`は文句を言います。

  `adjoin(x, a)`と`union(set(x), a)`は同値です; しかしながら、`adjoin`は`union`より幾分早いかもしれません。

  `disjoin`も参照してください。

  例:

      (%i1) adjoin (c, {a, b});
      (%o1)                       {a, b, c}
      (%i2) adjoin (a, {a, b});
      (%o2)                        {a, b}

  Sets ·

関数: belln (n)

  n番目のベル数を返します。 `belln(n)`はn個のメンバーを持つ集合の分割の数です。

  非負整数nに対して、 `belln(n)`はn番目のベル数に整理されます。 `belln`は他のいかなる引数に関して整理されません。

  `belln`は等式、リスト、行列、集合上に分配されます。

  例:

  非負整数に適用された`belln`。

      (%i1) makelist (belln (i), i, 0, 6);
      (%o1)               [1, 1, 2, 5, 15, 52, 203]
      (%i2) is (cardinality (set_partitions ({})) = belln (0));
      (%o2)                         true
      (%i3) is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6})) =
                             belln (6));
      (%o3)                         true

  非負整数でない引数に適用された`belln`。

      (%i1) [belln (x), belln (sqrt(3)), belln (-9)];
      (%o1)        [belln(x), belln(sqrt(3)), belln(- 9)]

  Sets ·

関数: cardinality (a)

  集合aの異なる要素の数を返します。

  整理がディセーブルされた時でも、 `cardinality`は冗長な要素を無視します。

  例:

      (%i1) cardinality ({});
      (%o1)                           0
      (%i2) cardinality ({a, a, b, c});
      (%o2)                           3
      (%i3) simp : false;
      (%o3)                         false
      (%i4) cardinality ({a, a, b, c});
      (%o4)                           3

  Sets ·

関数: cartesian_product (b_1, ... , b_n)

  Returns a set of lists of the form 形式`[x_1, ..., x_n]`のリストの集合を返します。 ここで、x_1, ..., x_nはそれぞれ、 集合b_1, ... , b_nの要素です。

  もし任意の引数が集合リテラルでないなら、 `cartesian_product`は文句を言います。

  例:

      (%i1) cartesian_product ({0, 1});
      (%o1)                      {[0], [1]}
      (%i2) cartesian_product ({0, 1}, {0, 1});
      (%o2)           {[0, 0], [0, 1], [1, 0], [1, 1]}
      (%i3) cartesian_product ({x}, {y}, {z});
      (%o3)                      {[x, y, z]}
      (%i4) cartesian_product ({x}, {-1, 0, 1});
      (%o4)              {[x, - 1], [x, 0], [x, 1]}

  Sets ·

関数: disjoin (x, a)

  元xを持たない集合aを返します。 もしxがaのメンバーでないなら、 変更なしにaを返します。

  もしaが集合リテラルでないなら、 `disjoin`は文句を言います。

  `disjoin(x, a)`, `delete(x, a)`, `setdifference(a, set(x))`はすべて同値です。 これらの中で、 `disjoin`は一般的に他より速いです。

  例:

      (%i1) disjoin (a, {a, b, c, d});
      (%o1)                       {b, c, d}
      (%i2) disjoin (a + b, {5, z, a + b, %pi});
      (%o2)                      {5, %pi, z}
      (%i3) disjoin (a - b, {5, z, a + b, %pi});
      (%o3)                  {5, %pi, b + a, z}

  Sets ·

関数: disjointp (a, b)

  集合aとbがばらばらなら、 `true`を返します。

  もしaかbが集合リテラルでないなら、 `disjointp`は文句を言います。

  例:

      (%i1) disjointp ({a, b, c}, {1, 2, 3});
      (%o1)                         true
      (%i2) disjointp ({a, b, 3}, {1, 2, 3});
      (%o2)                         false

  Sets ·Predicate functions ·

関数: divisors (n)

  nの約数の集合を表します。

  nがゼロでない整数の時、 `divisors(n)`は整数の集合に整理されます。 約数の集合は元1とnを含みます。 負の整数の約数は、その絶対値の約数です。

  `divisors`は、等式、リスト、行列、集合上に分配されます。

  例:

  28は完全数であることを検証できます: (自身を除いた)約数が28です。

      (%i1) s: divisors(28);
      (%o1)                 {1, 2, 4, 7, 14, 28}
      (%i2) lreduce ("+", args(s)) - 28;
      (%o2)                          28

  `divisors`は整理関数です。 `divisors(a)`の中で`a`に8を代入することは、 `divisors(8)`を再評価せずに約数をもたらします。

      (%i1) divisors (a);
      (%o1)                      divisors(a)
      (%i2) subst (8, a, %);
      (%o2)                     {1, 2, 4, 8}

  `divisors`は、等式、リスト、行列、集合上に分配されます。

      (%i1) divisors (a = b);
      (%o1)               divisors(a) = divisors(b)
      (%i2) divisors ([a, b, c]);
      (%o2)        [divisors(a), divisors(b), divisors(c)]
      (%i3) divisors (matrix ([a, b], [c, d]));
                        [ divisors(a)  divisors(b) ]
      (%o3)             [                          ]
                        [ divisors(c)  divisors(d) ]
      (%i4) divisors ({a, b, c});
      (%o4)        {divisors(a), divisors(b), divisors(c)}

  Integers ·

関数: elementp (x, a)

  xが集合aの元の時だけ`true`を返します。

  もしaが集合リテラルでないなら、 `elementp`は文句を言います。

  例:

      (%i1) elementp (sin(1), {sin(1), sin(2), sin(3)});
      (%o1)                         true
      (%i2) elementp (sin(1), {cos(1), cos(2), cos(3)});
      (%o2)                         false

  Sets ·Predicate functions ·

関数: emptyp (a)

  aが空の集合か空のリストの時だけ、`true`を返します。

  例:

      (%i1) map (emptyp, [{}, []]);
      (%o1)                     [true, true]
      (%i2) map (emptyp, [a + b, {{}}, %pi]);
      (%o2)                 [false, false, false]

  Sets ·Predicate functions ·

関数: equiv_classes (s, F)

  集合sの 同値関係Fに関する 同値クラスの集合を返します。

  Fはsのsとの直積集合上の２変数関数です。 The return value of Fの戻り値は、`true`か`false`、もしくは、 `is(expr)`が`true`か`false`のような 式exprです。

  Fが同値関数でない時、 `equiv_classes`は不平なくそれを受け入れますが、 その場合、結果は、一般に正しくありません。

  例:

  同値関係が `true`か`false`を返すラムダ式です。

      (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0},
                              lambda ([x, y], is (equal (x, y))));
      (%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}

  同値関係が、`is`が`true`か`false`に評価される 関係関数の名前です。

      (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
      (%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}

  同値クラスが3の倍数だけ違う数です。

      (%i1) equiv_classes ({1, 2, 3, 4, 5, 6, 7},
                           lambda ([x, y], remainder (x - y, 3) = 0));
      (%o1)              {{1, 4, 7}, {2, 5}, {3, 6}}

  Sets ·

関数: every (f, s)
関数: every (f, L_1, ..., L_n)

  もし述語論理fが与えられた引数すべてで`true`なら、 `true`を返します。

  ある集合が二番目の引数として与えられたとして、 もし`is(f(a_i))`が sの中のa_iすべてに関して `true`を返すなら `every(f, s)`は`true`です。 `every`は、 sの中のa_iすべてに関してfを評価するかもしれないししないかもしれません。 集合は順序付けされていないので、 `every`は任意の順序で`f(a_i)`を評価します。

  非キスとして１つか複数のリストが与えられたとして、 もし`is(f(x_1, ..., x_n))`が L_1, ..., L_nそれぞれの中のx_1, ..., x_nすべてに対して `true`を返すなら、 `every(f, L_1, ..., L_n)`は`true`を返します。 `every`は、 x_1, ..., x_nのすべての組み合わせに対してfを評価するかもしれないししないかもしれません。 `every`はインデックスを増やす順序でリストを評価します。

  空の集合`{}`または空のリスト`[]`が引数として与えられたとして、 `every`は`false`を返します。

  グローバルフラグ`maperror`が`true`の時、 リストL_1, ..., L_nすべては等しい長さを持たなければいけません。 `maperror`が`false`の時、 リスト引数は、最短のリストの長さに効果的に切り詰められます。

  (`is`を介して) `true`か`false`以外の何かに評価される述語論理fの戻り値は、 `prederror`によって決定されます。 `prederror`が`true`の時、 そんな値は`false`として扱われ、 `every`の戻り値は`false`です。 `prederror`が`false`の時、 そんな値は`unknown`として扱われ、 `every`の戻り値は`unknown`です。

  例:

  １つの集合に適用された`every`。 述語論理は１引数関数です。

      (%i1) every (integerp, {1, 2, 3, 4, 5, 6});
      (%o1)                         true
      (%i2) every (atom, {1, 2, sin(3), 4, 5 + y, 6});
      (%o2)                         false

  ２つのリストに適用された`every`。 述語論理は２引数関数です。

      (%i1) every ("=", [a, b, c], [a, b, c]);
      (%o1)                         true
      (%i2) every ("#", [a, b, c], [a, b, c]);
      (%o2)                         false

  `true`か`false`以外の何かに評価される 述語論理fの戻り値は、 グローバルフラグ`prederror`によって決定されます。

      (%i1) prederror : false;
      (%o1)                         false
      (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
                         [x^2, y^2, z^2]);
      (%o2)              [unknown, unknown, unknown]
      (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
      (%o3)                        unknown
      (%i4) prederror : true;
      (%o4)                         true
      (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
      (%o5)                         false

  Sets ·

関数: extremal_subset (s, f, max)
関数: extremal_subset (s, f, min)

  関数fが最大または最小値を取る、 sの部分集合を返します。

  `extremal_subset(s, f, max)`は、 実数値関数fが最大値を取る、 集合またはリストsの部分集合を返します。

  `extremal_subset(s, f, min)`は、 実数値関数fが最小値を取る、 集合またはリストsの部分集合を返します。

  例:

      (%i1) extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
      (%o1)                       {- 2, 2}
      (%i2) extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
      (%o2)                       {sqrt(2)}

  Sets ·

関数: flatten (expr)

  exprと同じ演算子を持つ部分式の引数を集め、 これらの集めた引数から式を構成します。

  `expr`の主演算子と違った演算子の部分式は、 たとえそれらが、逆に`expr`に関するものと同じ演算子の部分式を含んだとしても、 変更なしにコピーされます。

  引数の数が演算子に関して宣言された引数と違う 式を`flatten`が構成する可能性があるかもしれません; これは、整理器や評価器からのエラーメッセージを起こさせるかもしれません。 `flatten`はそんな状況を検出しようとしません。

  特別な表現の式、例えば、標準有理式(CRE)、はflattenできません; そんな場合、`flatten`は引数を変更なしに返します。

  例:

  リストに適用すると、`flatten`はリストの要素すべてを集めます。

      (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
      (%o1)            [a, b, c, d, e, f, g, h, i, j]

  集合に適用すると、`flatten`は集合の元すべてを集めます。

      (%i1) flatten ({a, {b}, {{c}}});
      (%o1)                       {a, b, c}
      (%i2) flatten ({a, {[a], {a}}});
      (%o2)                       {a, [a]}

  `flatten`は、主演算子をn項に宣言する効果に似ています。 しかしながら、`flatten`は、 主演算子と違う演算子を持つ部分式上に影響を持ちません。 一方、n項宣言はそれらに影響します。

      (%i1) expr: flatten (f (g (f (f (x)))));
      (%o1)                     f(g(f(f(x))))
      (%i2) declare (f, nary);
      (%o2)                         done
      (%i3) ev (expr);
      (%o3)                      f(g(f(x)))

  `flatten`は、他の任意の演算子と同じように添字付き関数を扱います。

      (%i1) flatten (f[5] (f[5] (x, y), z));
      (%o1)                      f (x, y, z)
                                  5

  引数の数が演算子に関して宣言された引数と違う 式を`flatten`が構成する可能性があるかもしれません;

      (%i1) 'mod (5, 'mod (7, 4));
      (%o1)                   mod(5, mod(7, 4))
      (%i2) flatten (%);
      (%o2)                     mod(5, 7, 4)
      (%i3) ''%, nouns;
      Wrong number of arguments to mod
       -- an error.  Quitting.  To debug this try debugmode(true);

  Sets ·Lists ·

関数: full_listify (a)

  aの中のすべての集合演算子をリスト演算子で置き換え、 結果を返します。 `full_listify`は、 たとえ主演算子が`set`でなくても 入れ子の部分式の中の集合演算子を置き換えます。

  `listify`は主演算子だけを置き換えます。

  例:

      (%i1) full_listify ({a, b, {c, {d, e, f}, g}});
      (%o1)               [a, b, [c, [d, e, f], g]]
      (%i2) full_listify (F (G ({a, b, H({c, d, e})})));
      (%o2)              F(G([a, b, H([c, d, e])]))

  Sets ·

関数: fullsetify (a)

  aがリストの時、 リスト演算子を集合演算子で置き換え、 `fullsetify`を集合であるメンバーそれぞれに適用します。 aがリストでない時、変更なしで返します。

  `setify`は主演算子だけを置き換えます。

  例:

  `f([b])`の主演算子はリストでないので、 行`(%o2)`で、 `f`の引数は集合に変換されません。

      (%i1) fullsetify ([a, [a]]);
      (%o1)                       {a, {a}}
      (%i2) fullsetify ([a, f([b])]);
      (%o2)                      {a, f([b])}

  Lists ·

関数: identity (x)

  任意の引数xに対してxを返します。

  例:

  `identity`は、 引数が既にブーリアン値の時、 述語論理として使うことができます。

      (%i1) every (identity, [true, true]);
      (%o1)                         true

関数: integer_partitions (n)
関数: integer_partitions (n, len)

  nの整数分割を返します。 すなわち、和がnになる整数のリストです。

  `integer_partitions(n)`は、 整数nの分割すべての集合を返します。 分割それぞれは、大きい順に並べられたリストです。

  `integer_partitions(n, len)`は、 長さlen以下の分割すべてを返します; この場合、 lenより少ない項を持つ分割それぞれには、 厳密にlen項持つ分割にするように、ゼロが足されます。 分割それぞれは、大きい順に並べられたリストです。

  リスト[a_1, ..., a_m]は、 (1) a_iそれぞれが非ゼロ整数、かつ、 (2) a_1 + ... + a_m = n. の時、非負整数nの分割です。 従って0は分割を持ちません。

  例:

      (%i1) integer_partitions (3);
      (%o1)               {[1, 1, 1], [2, 1], [3]}
      (%i2) s: integer_partitions (25)$
      (%i3) cardinality (s);
      (%o3)                         1958
      (%i4) map (lambda ([x], apply ("+", x)), s);
      (%o4)                         {25}
      (%i5) integer_partitions (5, 3);
      (%o5) {[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]}
      (%i6) integer_partitions (5, 2);
      (%o6)               {[3, 2], [4, 1], [5, 0]}

  条件を満たす分割すべてを見つけるには、 関数`subset`を使ってください; 以下は素数から成る10の分割すべてを見つける例です。

      (%i1) s: integer_partitions (10)$
      (%i2) cardinality (s);
      (%o2)                          42
      (%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
      (%i4) subset (s, lambda ([x], every (xprimep, x)));
      (%o4) {[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]}

  Integers ·

関数: intersect (a_1, ..., a_n)

  `intersect`は、以下に見る`intersection`と同じです。

  Sets ·

関数: intersection (a_1, ..., a_n)

  集合a_1からa_nまでに共通な 要素を含む 集合を返します。

  もし引数のいずれかが集合リテラルでないなら、 `intersection`は文句を言います。

  例:

      (%i1) S_1 : {a, b, c, d};
      (%o1)                     {a, b, c, d}
      (%i2) S_2 : {d, e, f, g};
      (%o2)                     {d, e, f, g}
      (%i3) S_3 : {c, d, e, f};
      (%o3)                     {c, d, e, f}
      (%i4) S_4 : {u, v, w};
      (%o4)                       {u, v, w}
      (%i5) intersection (S_1, S_2);
      (%o5)                          {d}
      (%i6) intersection (S_2, S_3);
      (%o6)                       {d, e, f}
      (%i7) intersection (S_1, S_2, S_3);
      (%o7)                          {d}
      (%i8) intersection (S_1, S_2, S_3, S_4);
      (%o8)                          {}

  Sets ·

関数: kron_delta (x, y, …, xp)

  クロネッカーのデルタ関数を表します。

  `kron_delta`は、 xiとyjが引数のすべての対で等しい時 1に整理され、 xiとyjが引数のある対で等しくない時 0に整理されます。 等号は`is(equal(xi,j))`を使って決定され、 不等号は`is(notsqual(xi,xj))`を使って決定されます。 厳密に1つの引数に対して、`kron_delta`はエラーをシグナルします。

  例:

      (%i1) kron_delta(a,a);
      (%o1)                                  1
      (%i2) kron_delta(a,b,a,b);
      (%o2)                          kron_delta(a, b)
      (%i3) kron_delta(a,a,b,a+1);
      (%o3)                                  0
      (%i4) assume(equal(x,y));
      (%o4)                            [equal(x, y)]
      (%i5) kron_delta(x,y);
      (%o5)                                  1

関数: listify (a)

  aが集合の時、 aの元を含む リストを返します。 そうでなければ、`listify`はaを返します。

  `full_listify`は aの中の集合演算子をリスト演算子に置き換えます。

  例:

      (%i1) listify ({a, b, c, d});
      (%o1)                     [a, b, c, d]
      (%i2) listify (F ({a, b, c, d}));
      (%o2)                    F({a, b, c, d})

  Sets ·

関数: lreduce (F, s)
関数: lreduce (F, s, s_0)

  二項関数Fを合成によってn項関数に拡張します。 ここでsはリストです。

  `lreduce(F, s)`は`F(... F(F(s_1, s_2), s_3), ... s_n)`を返します。

  オプション引数s_0が存在する時、 結果は`lreduce(F, cons(s_0, s))`と同値です。

  関数Fは、最初のleftmostの元に適用されます。 だから、"lreduce"と名付けられています。

  `rreduce`, `xreduce`, `tree_reduce`も参照してください。

  例:

  オプション引数なしの`lreduce`。

      (%i1) lreduce (f, [1, 2, 3]);
      (%o1)                     f(f(1, 2), 3)
      (%i2) lreduce (f, [1, 2, 3, 4]);
      (%o2)                  f(f(f(1, 2), 3), 4)

  オプション引数ありの`lreduce`。

      (%i1) lreduce (f, [1, 2, 3], 4);
      (%o1)                  f(f(f(4, 1), 2), 3)

  組み込み二項演算子に適用された`lreduce`。 `/`は割り算演算子。

      (%i1) lreduce ("^", args ({a, b, c, d}));
                                     b c d
      (%o1)                       ((a ) )
      (%i2) lreduce ("/", args ({a, b, c, d}));
                                      a
      (%o2)                         -----
                                    b c d

  Lists ·

関数: makeset (expr, x, s)

  式exprから生成された元を持つ集合を返します。 ここで、xはexprの中の変数のリストであり、 sはリストの集合かリストです。 集合の元それぞれを生成するために、 exprは、 sの元に並列にバインドされた変数xで評価されます。

  sの元それぞれは xと同じ長さを持たなければいけません。 変数xのリストは、添字の付かないシンボルのリストでなければいけません。 たとえシンボルが１つしかない場合でも、xは１要素のリストでなければいけなく、 sの元それぞれは１要素のリストでなければいけません。

  `makelist`も参照してください。

  例:

      (%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
                                 1  2  3  4
      (%o1)                     {-, -, -, -}
                                 a  b  c  d
      (%i2) S : {x, y, z}$
      (%i3) S3 : cartesian_product (S, S, S);
      (%o3) {[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
      [x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
      [y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
      [y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
      [z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
      [z, z, y], [z, z, z]}
      (%i4) makeset (i + j + k, [i, j, k], S3);
      (%o4) {3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
                                             z + 2 y, 2 z + x, 2 z + y}
      (%i5) makeset (sin(x), [x], {[1], [2], [3]});
      (%o5)               {sin(1), sin(2), sin(3)}

  Sets ·

関数: moebius (n)

  メビウス関数を表します。

  nがk個の異なる素数の積の時、 `moebius(n)`は(-1)^kに整理されます; n = 1の時、1に整理されます; 他の正の数すべてに対して、0に整理されます。

  `moebius`は等式、リスト、行列、集合上に分配されます。

  例:

      (%i1) moebius (1);
      (%o1)                           1
      (%i2) moebius (2 * 3 * 5);
      (%o2)                          - 1
      (%i3) moebius (11 * 17 * 29 * 31);
      (%o3)                           1
      (%i4) moebius (2^32);
      (%o4)                           0
      (%i5) moebius (n);
      (%o5)                      moebius(n)
      (%i6) moebius (n = 12);
      (%o6)                    moebius(n) = 0
      (%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
      (%o7)                      [- 1, 1, 1]
      (%i8) moebius (matrix ([11, 12], [13, 14]));
                                 [ - 1  0 ]
      (%o8)                      [        ]
                                 [ - 1  1 ]
      (%i9) moebius ({21, 22, 23, 24});
      (%o9)                      {- 1, 0, 1}

  Integers ·

関数: multinomial_coeff (a_1, ..., a_n)
関数: multinomial_coeff ()

  多項係数を返します。

  a_kそれぞれが非負の整数の時、 多項係数は、 `a_1 + ... + a_n`個の別々のオブジェクトを k番目の枠の中にa_kの要素を持つn個の枠に置く方法の数を与えます。

  一般に、`multinomial_coeff (a_1, ..., a_n)`は `(a_1 + ... + a_n)!/(a_1! ... a_n!)`と同値です。

  `multinomial_coeff()` (引数なし)は1に評価されます。

  `minfactorial`は`multinomial_coeff`が返す値を整理することができます。

  例:

      (%i1) multinomial_coeff (1, 2, x);
                                  (x + 3)!
      (%o1)                       --------
                                    2 x!
      (%i2) minfactorial (%);
                           (x + 1) (x + 2) (x + 3)
      (%o2)                -----------------------
                                      2
      (%i3) multinomial_coeff (-6, 2);
                                   (- 4)!
      (%o3)                       --------
                                  2 (- 6)!
      (%i4) minfactorial (%);
      (%o4)                          10

  Integers ·

関数: num_distinct_partitions (n)
関数: num_distinct_partitions (n, list)

  nが非負の整数の時、 nの異なる整数分割の数を返します。 そうでなければ、`num_distinct_partitions`は名詞形を返します。

  `num_distinct_partitions(n, list)`は、 1, 2, 3, ..., nの異なる分割の数のリストを返します。

  nの異なる分割は、 n = k_1 + ... + k_mとなるような 異なる正の整数k_1, ..., k_mのリストです。

  例:

      (%i1) num_distinct_partitions (12);
      (%o1)                          15
      (%i2) num_distinct_partitions (12, list);
      (%o2)      [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15]
      (%i3) num_distinct_partitions (n);
      (%o3)              num_distinct_partitions(n)

  Integers ·

関数: num_partitions (n)
関数: num_partitions (n, list)

  nが非負の整数の時、 nの整数分割の数を返します。 そうでなければ、`num_partitions`は名詞式を返します。

  `num_partitions(n, list)`は、 1, 2, 3, ..., nの整数分割の数のリストを返します。

  非負の整数nに対して、 `num_partitions(n)`は `cardinality(integer_partitions(n))`と等しいです; しかしながら、`num_partitions`は、 分割の集合を実際には構成しないので、はるかに速いです。

  例:

      (%i1) num_partitions (5) = cardinality (integer_partitions (5));
      (%o1)                         7 = 7
      (%i2) num_partitions (8, list);
      (%o2)            [1, 1, 2, 3, 5, 7, 11, 15, 22]
      (%i3) num_partitions (n);
      (%o3)                   num_partitions(n)

  Integers ·

関数: partition_set (a, f)

  集合aを述語論理fに従って分割します。

  `partition_set`は２つの集合のリストを返します。 最初の集合は fが`false`に評価される aの要素から成り、 二番目はaの他の要素すべてから成ります。 `partition_set`は `is`をfの戻り値に適用しません。

  もしaが集合リテラルなら `partition_set`は文句を言います。

  `subset`も参照してください。

  例:

      (%i1) partition_set ({2, 7, 1, 8, 2, 8}, evenp);
      (%o1)                   [{1, 7}, {2, 8}]
      (%i2) partition_set ({x, rat(y), rat(y) + z, 1},
                           lambda ([x], ratp(x)));
      (%o2)/R/              [{1, x}, {y, y + z}]

  Sets ·

関数: permutations (a)

  リストまたは集合aの元の異なる順列すべての集合を返します。 順列それぞれは、集合でなくリストです。

  aがリストの時、 aの重複した元が順列の中に含まれます。

  もしaがリストリテラルや集合リテラルでないなら、 `permutations`は文句を言います。

  `random_permutation`も参照してください。

  例:

      (%i1) permutations ([a, a]);
      (%o1)                       {[a, a]}
      (%i2) permutations ([a, a, b]);
      (%o2)           {[a, a, b], [a, b, a], [b, a, a]}

  Sets ·Lists ·

関数: powerset (a)
関数: powerset (a, n)

  aの部分集合すべての集合、または、その集合の部分集合を返します。

  `powerset(a)`は 集合aの部分集合すべての集合を返します。 `powerset(a)`は`2^cardinality(a)`個の元を持ちます。

  `powerset(a, n)`は、 濃度nを持つaの部分集合すべての集合を返します。

  もしaが集合リテラルでないか、 nが非負の整数でないなら、 `powerset`は文句を言います。

  例:

      (%i1) powerset ({a, b, c});
      (%o1) {{}, {a}, {a, b}, {a, b, c}, {a, c}, {b}, {b, c}, {c}}
      (%i2) powerset ({w, x, y, z}, 4);
      (%o2)                    {{w, x, y, z}}
      (%i3) powerset ({w, x, y, z}, 3);
      (%o3)     {{w, x, y}, {w, x, z}, {w, y, z}, {x, y, z}}
      (%i4) powerset ({w, x, y, z}, 2);
      (%o4)   {{w, x}, {w, y}, {w, z}, {x, y}, {x, z}, {y, z}}
      (%i5) powerset ({w, x, y, z}, 1);
      (%o5)                 {{w}, {x}, {y}, {z}}
      (%i6) powerset ({w, x, y, z}, 0);
      (%o6)                         {{}}

  Sets ·

関数: random_permutation (a)

  クヌースのシャッフルアルゴリズムで構成されるような、 集合またはリストaのランダムな順列を返します。

  戻り値は、たとえ要素すべてが偶然同じでも 引数とは別の新しいリストです。 しかしながら、引数の要素はコピーされません。

  例:

      (%i1) random_permutation ([a, b, c, 1, 2, 3]);
      (%o1)                  [c, 1, 2, 3, a, b]
      (%i2) random_permutation ([a, b, c, 1, 2, 3]);
      (%o2)                  [b, 3, 1, c, a, 2]
      (%i3) random_permutation ({x + 1, y + 2, z + 3});
      (%o3)                 [y + 2, z + 3, x + 1]
      (%i4) random_permutation ({x + 1, y + 2, z + 3});
      (%o4)                 [x + 1, y + 2, z + 3]

  Sets ·Lists ·

関数: rreduce (F, s)
関数: rreduce (F, s, s_{n + 1})

  合成によって二項関数Fをn項関数に拡張します。 ここで、sはリストです。

  `rreduce(F, s)`は `F(s_1, ... F(s_{n - 2}, F(s_{n - 1}, s_n)))`を返します。 オプション引数s_{n + 1}が存在する時、 結果は、`rreduce(F, endcons(s_{n + 1}, s))` と同値です。

  関数Fは、最初rightmostのリスト要素に適用されます。 だから名前が"rreduce"です。

  `lreduce`, `tree_reduce`, `xreduce`も参照してください。

  例:

  オプション引数なしの`rreduce`。

      (%i1) rreduce (f, [1, 2, 3]);
      (%o1)                     f(1, f(2, 3))
      (%i2) rreduce (f, [1, 2, 3, 4]);
      (%o2)                  f(1, f(2, f(3, 4)))

  オプション引数ありの`rreduce`。

      (%i1) rreduce (f, [1, 2, 3], 4);
      (%o1)                  f(1, f(2, f(3, 4)))

  組み込み二項演算子に適用された`rreduce`。 `/`は割り算演算子。

      (%i1) rreduce ("^", args ({a, b, c, d}));
                                       d
                                      c
                                     b
      (%o1)                         a
      (%i2) rreduce ("/", args ({a, b, c, d}));
                                     a c
      (%o2)                          ---
                                     b d

  Lists ·

関数: setdifference (a, b)

  集合aの中の、集合bにない要素を含む集合を返します。

  もしaかbが集合リテラルでないなら、 `setdifference`は文句を言います。

  例:

      (%i1) S_1 : {a, b, c, x, y, z};
      (%o1)                  {a, b, c, x, y, z}
      (%i2) S_2 : {aa, bb, c, x, y, zz};
      (%o2)                 {aa, bb, c, x, y, zz}
      (%i3) setdifference (S_1, S_2);
      (%o3)                       {a, b, z}
      (%i4) setdifference (S_2, S_1);
      (%o4)                     {aa, bb, zz}
      (%i5) setdifference (S_1, S_1);
      (%o5)                          {}
      (%i6) setdifference (S_1, {});
      (%o6)                  {a, b, c, x, y, z}
      (%i7) setdifference ({}, S_1);
      (%o7)                          {}

  Sets ·

関数: setequalp (a, b)

  集合aとbが同じ要素数を持ち、 `listify`が決定した順序で考えて aの要素の中の`x`と bの要素の中の`y`に対して `is(x = y)`が`true`なら、 `true`を返します。 そうでなければ、`setequalp`は`false`を返します。

  例:

      (%i1) setequalp ({1, 2, 3}, {1, 2, 3});
      (%o1)                         true
      (%i2) setequalp ({a, b, c}, {1, 2, 3});
      (%o2)                         false
      (%i3) setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
      (%o3)                         false

  Sets ·Predicate functions ·

関数: setify (a)

  リストaの要素から集合を構成します。 リストaの重複した要素は削除され、 要素は、述語論理`orderlessp`に従って並び替えられます。

  もしaが集合リテラルでないなら、 `setify`は文句を言います。

  例:

      (%i1) setify ([1, 2, 3, a, b, c]);
      (%o1)                  {1, 2, 3, a, b, c}
      (%i2) setify ([a, b, c, a, b, c]);
      (%o2)                       {a, b, c}
      (%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
      (%o3)                {1, 3, 5, 7, 9, 11, 13}

  Lists ·

関数: setp (a)

  aがMaximaの集合の時だけ、`true`を返します。

  `setp`は、 整理された集合はもちろん、未整理の集合(すなわち、冗長な元を持つ集合)に対して、 `true`を返します。

  `setp`はMaxima関数 `setp(a) := not atom(a) and op(a) = 'set` と同値です。

  例:

      (%i1) simp : false;
      (%o1)                         false
      (%i2) {a, a, a};
      (%o2)                       {a, a, a}
      (%i3) setp (%);
      (%o3)                         true

  Sets ·Predicate functions ·

関数: set_partitions (a)
関数: set_partitions (a, n)

  aの分割すべての集合、または、その集合の部分集合を返します。

  `set_partitions(a, n)`は n個の空でないばらばらの部分集合への aの分解すべての集合を返します。

  `set_partitions(a)`は分割すべての集合を返します。

  `stirling2`は集合の分割の集合の濃度を返します。

  集合の集合Pは

  1. Pの元それぞれが空でない集合
  2. Pの別の元はばらばらである。
  3. Pの元の和集合がSに等しい

  時、 集合Sの分割です。

  例:

  条件1と2が空ゆえに真なので、空集合はそれ自身の分割です。

      (%i1) set_partitions ({});
      (%o1)                         {{}}

  集合の分割の集合の濃度は、 `stirling2`を使って見つけられます。

      (%i1) s: {0, 1, 2, 3, 4, 5}$
      (%i2) p: set_partitions (s, 3)$
      (%i3) cardinality(p) = stirling2 (6, 3);
      (%o3)                        90 = 90

  `p`の元それぞれは n = 3個の元を持たなければいけません; チェックしましょう。

      (%i1) s: {0, 1, 2, 3, 4, 5}$
      (%i2) p: set_partitions (s, 3)$
      (%i3) map (cardinality, p);
      (%o3)                          {3}

  最後に、 `p`の元それぞれに対して、 元の和集合は`s`に等しくなければいけません; チェックしましょう。

      (%i1) s: {0, 1, 2, 3, 4, 5}$
      (%i2) p: set_partitions (s, 3)$
      (%i3) map (lambda ([x], apply (union, listify (x))), p);
      (%o3)                 {{0, 1, 2, 3, 4, 5}}

  Sets ·

関数: some (f, a)
関数: some (f, L_1, ..., L_n)

  もし与えられた引数のうち１つ以上で述語論理fが`true`なら `true`を返します。

  二番目の引数として集合１つが与えられたとして、 もし sの中の１つ以上のa_iに対して `is(f(a_i))`が`true`を返すなら、 `some(f, s)`は`true`を返します。 `some`は sの中のa_iすべてに対して fを評価するかどうかわかりません。 集合は順序がないので、 `some`は任意の順序で`f(a_i)`評価するかもしれません。

  引数として２つ以上のリストが与えられたとして、 `some(f, L_1, ..., L_n)`は`true`を返します。 もし L_1, ..., L_nそれぞれの中の１つ以上のx_1, ..., x_nで `is(f(x_1, ..., x_n))`が`true`を返すなら、 `some`は いくつかの組み合わせx_1, ..., x_nに対して fを評価するかどうかわかりません。 `some`はインデックスを増加する順序でリストを評価します。

  引数として空集合`{}`または空のリスト`[]`が与えられたとして、 `some`は`false`を返します。

  グローバルフラグ`maperror`が`true`の時、 すべてのリストL_1, ..., L_nは同じ長さを持たなければいけません。 `maperror`が`false`の時、 リスト引数は、最短のリストの長さに効果的に切り詰められます。

  (`is`を介して)`true`か`false`以外の何かに評価される 述語論理fの戻り値は、 グローバルフラグ`prederror`によって決定されます。 `prederror`が`true`の時、 そんな値は`false`として扱われます。 `prederror`が`false`の時、 そんな値は`unknown`として扱われます。

  例:

  集合１つに適用された`some`。 述語論理は引数１つの関数です。

      (%i1) some (integerp, {1, 2, 3, 4, 5, 6});
      (%o1)                         true
      (%i2) some (atom, {1, 2, sin(3), 4, 5 + y, 6});
      (%o2)                         true

  ２つのリストに適用された`some`。 述語論理は引数２つの関数です。

      (%i1) some ("=", [a, b, c], [a, b, c]);
      (%o1)                         true
      (%i2) some ("#", [a, b, c], [a, b, c]);
      (%o2)                         false

  `true`か`false`以外の何かに評価される述語論理fの戻り値は、 グローバルフラグ`prederror`によって決定されます。

      (%i1) prederror : false;
      (%o1)                         false
      (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
                 [x^2, y^2, z^2]);
      (%o2)              [unknown, unknown, unknown]
      (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
      (%o3)                        unknown
      (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
      (%o4)                         true
      (%i5) prederror : true;
      (%o5)                         true
      (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
      (%o6)                         false
      (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
      (%o7)                         true

  Sets ·Lists ·

関数: stirling1 (n, m)

  第一種のスターリング数を表します。

  nとmが非負の整数の時、 `stirling1 (n, m)`の大きさは m個の巡回置換を持つn個の元を持つ集合の順列の数です。 詳細はGraham, Knuth and Patashnik Concrete Mathematicsを参照してください。 Maximaは、 0より小さいmに対して `stirling1 (n, m)`を定義するために 再帰関係を使います; 0より小さいnと非整数引数に対して未定義です。

  `stirling1`は整理関数です。 Maximaは以下の恒等式を知っています。

  1. stirling1(0, n) = kron_delta(0, n) (Ref. [1])
  2. stirling1(n, n) = 1 (Ref. [1])
  3. stirling1(n, n - 1) = binomial(n, 2) (Ref. [1])
  4. stirling1(n + 1, 0) = 0 (Ref. [1])
  5. stirling1(n + 1, 1) = n! (Ref. [1])
  6. stirling1(n + 1, 2) = 2^n - 1 (Ref. [1])

  これらの恒等式は 引数が、整数リテラルまたは整数と宣言されたシンボルで、かつ、 最初の引数が非負の時、 適用されます。 `stirling1`は、非整数引数に対して整理しません。

  参考文献:

  [1] Donald Knuth, The Art of Computer Programming, third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.

  例:

      (%i1) declare (n, integer)$
      (%i2) assume (n >= 0)$
      (%i3) stirling1 (n, n);
      (%o3)                           1

  `stirling1`は非整数引数に対して整理しません。

      (%i1) stirling1 (sqrt(2), sqrt(2));
      (%o1)              stirling1(sqrt(2), sqrt(2))

  Maximaは `stirling1`に恒等式を適用します。

      (%i1) declare (n, integer)$
      (%i2) assume (n >= 0)$
      (%i3) stirling1 (n + 1, n);
                                  n (n + 1)
      (%o3)                       ---------
                                      2
      (%i4) stirling1 (n + 1, 1);
      (%o4)                          n!

  Integers ·

関数: stirling2 (n, m)

  第二種スターリング数を表します。

  nとmが非負の整数の時、 `stirling2 (n, m)`は、 濃度nの集合がm個のばらばらの部分集合に分割できる方法の数です。 Maximaは、 0より小さいmに対して `stirling2 (n, m)`を定義するために 再帰関係を使います; 0より小さいnと非整数の引数に対して未定義です。

  `stirling2`は整理関数です。 Maximaは以下の恒等式を知っています。

  1. stirling2(0, n) = kron_delta(0, n) (Ref. [1])
  2. stirling2(n, n) = 1 (Ref. [1])
  3. stirling2(n, n - 1) = binomial(n, 2) (Ref. [1])
  4. stirling2(n + 1, 1) = 1 (Ref. [1])
  5. stirling2(n + 1, 2) = 2^n - 1 (Ref. [1])
  6. stirling2(n, 0) = kron_delta(n, 0) (Ref. [2])
  7. stirling2(n, m) = 0 when m > n (Ref. [2])
  8. stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m! when m and n are integers, and n is nonnegative. (Ref. [3])

  引数が整数リテラルまたは整数と宣言されたシンボルで、かつ、最初の引数が非負の時、 これらの恒等式が適用されます。 `stirling2`は非整数引数に対して整理されません。

  参考文献:

  [1] Donald Knuth. The Art of Computer Programming, third edition, Volume 1, Section 1.2.6, Equations 48, 49, and 50.

  [2] Graham, Knuth, and Patashnik. Concrete Mathematics, Table 264.

  [3] Abramowitz and Stegun. Handbook of Mathematical Functions, Section 24.1.4.

  例:

      (%i1) declare (n, integer)$
      (%i2) assume (n >= 0)$
      (%i3) stirling2 (n, n);
      (%o3)                           1

  `stirling2`は非整数引数に対して整理されません。

      (%i1) stirling2 (%pi, %pi);
      (%o1)                  stirling2(%pi, %pi)

  Maximaは `stirling2`に恒等式を適用します。

      (%i1) declare (n, integer)$
      (%i2) assume (n >= 0)$
      (%i3) stirling2 (n + 9, n + 8);
                               (n + 8) (n + 9)
      (%o3)                    ---------------
                                      2
      (%i4) stirling2 (n + 1, 2);
                                    n
      (%o4)                        2  - 1

  Integers ·

関数: subset (a, f)

  述語論理fを満たす 集合aの部分集合を返します。

  `subset`は、 fが`false`以外の何かを返す、aの要素から成る集合を返します。 `subset`は `is`をfの戻り値に適用しません。

  もしaが集合リテラルでないなら `subset`は文句を言います。

  `partition_set`も参照してください。

  例:

      (%i1) subset ({1, 2, x, x + y, z, x + y + z}, atom);
      (%o1)                     {1, 2, x, z}
      (%i2) subset ({1, 2, 7, 8, 9, 14}, evenp);
      (%o2)                      {2, 8, 14}

  Sets ·

関数: subsetp (a, b)

  集合aがbの部分集合の時だけ、 `true`を返します。

  もしaかbのいずれかが集合リテラルでないなら、 `subsetp`は文句を言います。

  例:

      (%i1) subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
      (%o1)                         true
      (%i2) subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
      (%o2)                         false

  Sets ·Predicate functions ·

関数: symmdifference (a_1, …, a_n)

  集合a_1, …, a_nの対称差を返します。

  ２つの引数が与えられたとして、 `symmdifference ( a, b)`は `union (setdifference ( a, b), setdifference (b, a))`と同じです。

  もし引数が集合リテラルでないなら、 `symmdifference`は文句を言います。

  例:

      (%i1) S_1 : {a, b, c};
      (%o1)                       {a, b, c}
      (%i2) S_2 : {1, b, c};
      (%o2)                       {1, b, c}
      (%i3) S_3 : {a, b, z};
      (%o3)                       {a, b, z}
      (%i4) symmdifference ();
      (%o4)                          {}
      (%i5) symmdifference (S_1);
      (%o5)                       {a, b, c}
      (%i6) symmdifference (S_1, S_2);
      (%o6)                        {1, a}
      (%i7) symmdifference (S_1, S_2, S_3);
      (%o7)                        {1, b, z}
      (%i8) symmdifference ({}, S_1, S_2, S_3);
      (%o8)                        {1,b, z}

  Sets ·

関数: tree_reduce (F, s)
関数: tree_reduce (F, s, s_0)

  合成によって二項関数Fをn項関数に拡張します。 ここでsは集合かリストです。

  `tree_reduce`は以下と同値です: 新しいリスト`[F(s_1, s_2), F(s_3, s_4), ...]`を形成するために Fを要素の連続する対に適用します。 もし奇数個の要素があるなら、 最後の要素は変化なしに通過させます。 そして、リストが１つの要素になるまで繰り返します。１つの要素になった時、それが戻り値です。

  オプションの引数s_0がある時， 結果は `tree_reduce(F, cons(s_0, s)`と同値です。

  浮動小数点数の足し算に関して、 `tree_reduce`は、 `rreduce`や`lreduce`よりも小さな丸め誤差を持つ和を返します。

  sの要素と部分的な結果は 最小深度の二項木の中に配列されます。 だから名前が"tree_reduce"です。

  例:

  偶数個の要素を持つリストに適用された`tree_reduce`。

      (%i1) tree_reduce (f, [a, b, c, d]);
      (%o1)                  f(f(a, b), f(c, d))

  奇数個の要素を持つリストに適用された`tree_reduce`。

      (%i1) tree_reduce (f, [a, b, c, d, e]);
      (%o1)               f(f(f(a, b), f(c, d)), e)

  Sets ·Lists ·

関数: union (a_1, ..., a_n)

  集合a_1からa_nの和集合を返します。

  `union()` (引数なし)は空集合を返します。

  もし引数が集合リテラルでないなら、 `union`は文句を言います。

  例:

      (%i1) S_1 : {a, b, c + d, %e};
      (%o1)                   {%e, a, b, d + c}
      (%i2) S_2 : {%pi, %i, %e, c + d};
      (%o2)                 {%e, %i, %pi, d + c}
      (%i3) S_3 : {17, 29, 1729, %pi, %i};
      (%o3)                {17, 29, 1729, %i, %pi}
      (%i4) union ();
      (%o4)                          {}
      (%i5) union (S_1);
      (%o5)                   {%e, a, b, d + c}
      (%i6) union (S_1, S_2);
      (%o6)              {%e, %i, %pi, a, b, d + c}
      (%i7) union (S_1, S_2, S_3);
      (%o7)       {17, 29, 1729, %e, %i, %pi, a, b, d + c}
      (%i8) union ({}, S_1, S_2, S_3);
      (%o8)       {17, 29, 1729, %e, %i, %pi, a, b, d + c}

  Sets ·

関数: xreduce (F, s)
関数: xreduce (F, s, s_0)

  合成によって関数Fをn項関数に拡張します。 または、もしFが既にn項関数ならFをsに適用します。 Fがn項関数でない時、 `xreduce`は`lreduce`と同じです。 引数sはリストです。

  n項関数として知られている関数は、 足し算`+`, 掛け算`*`, `and`, `or`, `max`, `min`, `append`を含みます。 関数は、 `declare(F, nary)`によってもn項と宣言されるかもしれません。 これらの関数に対して、 `xreduce`は `rreduce`や`lreduce`よりも速いことが期待されます。

  オプション引数s_0がある時、 結果は、`xreduce(s, cons(s_0, s))`と同値です。

  浮動小数点の足し算は、厳密には結合的ではありません; そうはそうかもしれませんが、 sが浮動小数点を含む時、 `xreduce`はMaximaのn項足し算を適用します。

  例:

  n項と知られている関数に適用された`xreduce`。 `F`は引数すべてで、一度コールされます。

      (%i1) declare (F, nary);
      (%o1)                         done
      (%i2) F ([L]) := L;
      (%o2)                      F([L]) := L
      (%i3) xreduce (F, [a, b, c, d, e]);
      (%o3)         [[[[[("[", simp), a], b], c], d], e]

  n項とわかっていない関数に適用された`xreduce`。 `G`は、 毎回２つの引数で複数回コールされます。

      (%i1) G ([L]) := L;
      (%o1)                      G([L]) := L
      (%i2) xreduce (G, [a, b, c, d, e]);
      (%o2)         [[[[[("[", simp), a], b], c], d], e]
      (%i3) lreduce (G, [a, b, c, d, e]);
      (%o3)                 [[[[a, b], c], d], e]

  Sets ·Lists ·

Next: Program Flow, Previous: Sets, Up: Top [Contents][Index]

## 36 Function Definition

Next: Function, Previous: Function Definition, Up: Function Definition [Contents][Index]

### 36.1 Introduction to Function Definition

Next: Macros, Previous: Introduction to Function Definition, Up: Function Definition [Contents][Index]

### 36.2 Function

Function definition ·Programming ·

#### 36.2.1 Ordinary functions

Maximaの中で関数を定義するためには、 `:=`演算子を使います。 例えば、

    f(x) := sin(x)

は関数 `f`を定義します。 匿名関数も `lambda`を使って生成することができます。 例えば、

    f(i,j) := block ([], ...);
    map (lambda ([i], i+1), l)

は、項それぞれに1を足したリストを返しますが、

    lambda ([i, j], ...)

を`f`の代わりに使うことができます。

(訳注: 元マニュアルの編集ミスでしょうか。以下の内容が一貫すると思います。

    f(i) := i+1;
    map (f, l)

は、項それぞれに1を足したリストを返しますが、

    lambda ([i], i+1)

を`f`の代わりに使うことができます。)

余分な引数のリストに割り当てられる最後の引数を持つことで、 引数が可変の関数も定義できます:

(訳注: 最後の引数変数を`[]`でくくると、残りの引数のリストがその引数変数に割り当てられます。)

    (%i1) f ([u]) := u;
    (%o1)                      f([u]) := u
    (%i2) f (1, 2, 3, 4);
    (%o2)                     [1, 2, 3, 4]
    (%i3) f (a, b, [u]) := [a, b, u];
    (%o3)               f(a, b, [u]) := [a, b, u]
    (%i4) f (1, 2, 3, 4, 5, 6);
    (%o4)                 [1, 2, [3, 4, 5, 6]]

関数の右辺は式です。 従って、もし一連の式が欲しいなら、

    f(x) := (expr1, expr2, ...., exprn);

とします。 exprnの値が関数が返すものになります。

もし関数内部のある式から`return`したいなら、 `block`と`return`を使わなければいけません。

    block ([], expr1, ..., if (a > 10) then return(a), ..., exprn)

はそれ自身式で、関数定義の右辺にとって代わることができます。 この際、最後の式よりも早くreturnが起こるかもしれません。

ブロックの中の最初の`[]`は、 `[a: 3, b, c: []]`のように、変数と変数割り当てのリストを含むかもしれません。 `[a: 3, b, c: []]`は、３つの変数`a`,`b`,`c`が コードが、`block`内部や`block`内部からコールされた関数内部で実行される限り、 グローバル値を参照しないように、しかしむしろ特別な値を持つようにします。 変数がブロックの開始から抜ける時間まで続くので、これは、動的バインドと呼ばれます。 一旦`block`から戻るか、そこから出ると、(もし存在するなら）変数の古い値が戻されます。 この方法で変数を保護することは確かによい考えです。 ブロック変数に関する割り当ては、並列に行われることに注意してください。 これは、もし先に`c: a`を使ったら、`c`の値はブロックにちょうど入った時、まだ `a`がバインドされる前の`a`の値であることを意味します。 例えば、

    block ([a: a], expr1, ... a: a+3, ..., exprn)

のような何かを実行することは、 `a`の外部の値を変更されないよう保護しますが、その値がなんだったかアクセス可能にします。 割り当ての右辺は、バインドが起こる前に入る文脈の中で評価されます。 Using just ただ`block ([x], ...`を使うことは、 ちょうどまるで新しいMaximaセッションに入ったかのように、`x`がそれ自身を値として持つようにします。

関数の実際の引数は、ブロックの変数と厳密に同じ方法で扱われます。 例えば、

    f(x) := (expr1, ..., exprn);

と

    f(1);

では、式の評価に関して、まるで

    block ([x: 1], expr1, ..., exprn)

を実行したかのような類似の文脈を持ちます。

定義の右辺がランタイムで計算される時、 関数内部では、`define`とたぶん`buildq`を使うことが役に立ちます。

Inside functions, when the right hand side of a definition, may be computed at runtime, it is useful to use `define` and possibly `buildq`.

#### 36.2.2 Array functions

配列関数は、初めて与えられた引数でコールされた時、関数値を記憶し、 同じ引数が与えられた時、再計算することなしに記憶した値を返します。 そんな関数はしばしばメモ化関数と呼ばれます。

配列関数名は、(グローバルリスト`functions`ではなく) グローバルリスト`arrays`に追加されます。

`arrayinfo`は 記憶された値を持つ引数のリストを返し、 `listarray`は記憶された値を返します。 `dispfun`と`fundef`は配列関数の定義を返します。

`arraymake`は、通常の関数に対する`funmake`のように、 配列関数コールを構成します。 `arrayapply`は、 通常の関数に対する`apply`のように、 配列関数をその引数に適用します。 配列関数に対して、`map`に厳密に似たものはありません。 `map(lambda([x], a[x]), L)`または `makelist(a[x], x, L)` ―Lはリストです―は、目的からそれほど遠くありませんけれども。

`remarray`は、 通常の関数に対する`remfunction`のように、 (記憶された関数値も含めて、)配列関数の定義を削除します。

`kill(a[x])`は、配列関数aの引数xに関して記憶された 値を削除します; 次回、引数xでaがコールされた時、 関数値は再計算されます。 しかしながら、 関数定義も削除する`kill(a)`または`remarray(a)`を除いて、 記憶された値すべてを一度に削除する方法はありません。

Next: Functions and Variables for Function Definition, Previous: Function, Up: Function Definition [Contents][Index]

### 36.3 Macros

関数: buildq (L, expr)

  リストLで指名された変数を式 exprに 並列に代入します。exprは評価しません。 `buildq`が代入を実行した後、 結果の式は整理はされますが、評価されません。

  Lの要素はシンボルまたは割り当て式`symbol: value`です。 割り当て式は並列に評価されます。 すなわち、ある変数が割り当ての右辺へバインドされるのは、 `buildq`がコールされた文脈でのバインドです。 変数リストL内でその変数がバインドされるのではありません。 もしLの中のある変数に明示的な割り当てがないなら、 `buildq`でのバインドは、 `buildq`がコールされた文脈でのそれと同じです。

  そして、Lで指名された変数は並列にexprに代入されます。 すなわち、すべての変数への代入は他の代入がされる前に決まります。 だから、１つの変数の代入は他には一切効果を持ちません。

  もし 任意の変数 xが exprの中で `splice (x)`のように現れるなら、 xはリストにバインドされなければいけませんし、 リストは、代入の代わりにexpr に接合(内挿)されます。

  exprの中のLに現れない任意の変数は、 たとえそれらが`buildq`がコールされた文脈の中でバインドを持っていても、 逐語的に結果に繰り越されます。

  例

  `a`は明示的に `x`にバインドされ、 一方で `b`は、コールする文脈で同じバインド(すなわち29)を持ち、 `c`は逐語的に繰り越されます。 結果の式は、明示的な評価 `''%`まで評価されません。

      (%i1) (a: 17, b: 29, c: 1729)$
      (%i2) buildq ([a: x, b], a + b + c);
      (%o2)                      x + c + 29
      (%i3) ''%;
      (%o3)                       x + 1758

  `e`はリストにバインドされ、 `foo`の引数の中でそのように現れ、 `bar`の引数の中に内挿されます。

      (%i1) buildq ([e: [a, b, c]], foo (x, e, y));
      (%o1)                 foo(x, [a, b, c], y)
      (%i2) buildq ([e: [a, b, c]], bar (x, splice (e), y));
      (%o2)                  bar(x, a, b, c, y)

  代入の後、結果は整理されます。 もし代入の前に整理が適用されたら、これら２つの結果は同じになったはずです。

      (%i1) buildq ([e: [a, b, c]], splice (e) + splice (e));
      (%o1)                    2 c + 2 b + 2 a
      (%i2) buildq ([e: [a, b, c]], 2 * splice (e));
      (%o2)                        2 a b c

  Lの中の変数は並列にバインドされます; もし順次バインドされたなら、 最初の結果は、`foo (b, b)`になったはずです。 代入は並列に実行されます; 二番目の結果を`subst`の結果と比較してください。 `subst`は代入を順次実行します。

      (%i1) buildq ([a: b, b: a], foo (a, b));
      (%o1)                       foo(b, a)
      (%i2) buildq ([u: v, v: w, w: x, x: y, y: z, z: u],
                    bar (u, v, w, x, y, z));
      (%o2)                 bar(v, w, x, y, z, u)
      (%i3) subst ([u=v, v=w, w=x, x=y, y=z, z=u],
                   bar (u, v, w, x, y, z));
      (%o3)                 bar(u, u, u, u, u, u)

  変数や式が左辺に、それらの値が右辺にある等式のリストを構成します。 `macroexpand`は`show_values`が返す式を表示します。

      (%i1) show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
      (%o1)   show_values([L]) ::= buildq([L], map("=", 'L, L))
      (%i2) (a: 17, b: 29, c: 1729)$
      (%i3) show_values (a, b, c - a - b);
      (%o3)          [a = 17, b = 29, c - b - a = 1683]
      (%i4) macroexpand (show_values (a, b, c - a - b));
      (%o4)    map(=, '([a, b, c - b - a]), [a, b, c - b - a])

  複数の引数を持つ関数が与えられたとして、 引数のいくつかが固定されたもう１つの関数を生成します。

      (%i1) curry (f, [a]) :=
              buildq ([f, a], lambda ([[x]], apply (f, append (a, x))))$
      (%i2) by3 : curry ("*", 3);
      (%o2)        lambda([[x]], apply(*, append([3], x)))
      (%i3) by3 (a + b);
      (%o3)                       3 (b + a)

  Function definition ·

関数: macroexpand (expr)

  `expr`がマクロ関数コールの時、 exprのマクロ展開を、評価はせずに、返します。 そうでなければ、`macroexpand`はexprを返します。

  もしexprの展開が別のマクロ関数コールをもたらすなら、 そのマクロ関数コールも展開されます。

  `macroexpand`は引数をクォートします。 しかしながら、もしマクロ関数コールの展開が副作用を持つなら， それらの副作用が実行されます。

  `::=`, `macros`, `macroexpand1`も参照してください。

  例

      (%i1) g (x) ::= x / 99;
                                          x
      (%o1)                      g(x) ::= --
                                          99
      (%i2) h (x) ::= buildq ([x], g (x - a));
      (%o2)            h(x) ::= buildq([x], g(x - a))
      (%i3) a: 1234;
      (%o3)                         1234
      (%i4) macroexpand (h (y));
                                    y - a
      (%o4)                         -----
                                     99
      (%i5) h (y);
                                  y - 1234
      (%o5)                       --------
                                     99

  Function application ·

関数: macroexpand1 (expr)

  `expr`がマクロ関数コールの時、 exprのマクロ展開を、評価せずに、返します。 そうでなければ、`macroexpand1`はexprを返します。

  `macroexpand`は引数をクォートします。 しかしながら、もしマクロ関数コールの展開が副作用を持つなら， それらの副作用が実行されます。

  もしexprの展開が別のマクロ関数コールをもたらすなら、 そのマクロ関数コールは展開されません。

  `::=`, `macros`, `macroexpand`も参照してください。

  例

      (%i1) g (x) ::= x / 99;
                                          x
      (%o1)                      g(x) ::= --
                                          99
      (%i2) h (x) ::= buildq ([x], g (x - a));
      (%o2)            h(x) ::= buildq([x], g(x - a))
      (%i3) a: 1234;
      (%o3)                         1234
      (%i4) macroexpand1 (h (y));
      (%o4)                       g(y - a)
      (%i5) h (y);
                                  y - 1234
      (%o5)                       --------
                                     99

  Function application ·

Global variable: macros

  デフォルト値: `[]`

  `macros`は、ユーザー定義のマクロ関数のリストです。 マクロ関数定義演算子`::=`は、このリストに新しいマクロ関数を入れ、 `kill`, `remove`, `remfunction`はリストからマクロ関数を削除します。

  `infolists`も参照してください。

  Function definition ·Global variables ·

関数: splice (a)

  `splice`が`buildq`内部に現れた時だけ、 アトムaで指名されたリストを式に接合(内挿)します; そうでなければ、`splice`は未定義関数として扱われます。 もし `buildq`内部で a単独として(`splice`なしに)現れたら、 aはリストとして、結果の中に代入されます(内挿されません)。 `splice`の引数はアトムだけを取り得ます; リストリテラルやリストをもたらす式を取ることはできません。

  通常、`splice`は、関数や演算子の引数を提供します。 関数`f`に対して、 `buildq`内部の式`f (splice (a))`は、 `f (a[1], a[2], a[3], ...)`に展開されます。 演算子`o`に対して、 `buildq`内部の式`"o" (splice (a)`は、 `"o" (a[1], a[2], a[3], ...)`に展開されます。 ここで`o`は、任意のタイプの演算子を取り得ます(通常は複数の引数を取るものです)。 演算子はダブルクォート`"`でくくられなければいけないことに注意してください。

  例

      (%i1) buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
                             foo(1, %pi, z - y)
      (%o1)                -----------------------
                           length([1, %pi, z - y])
      (%i2) buildq ([x: [1, %pi]], "/" (splice (x)));
                                      1
      (%o2)                          ---
                                     %pi
      (%i3) matchfix ("<>", "<>");
      (%o3)                          <>
      (%i4) buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
      (%o4)                   <>1, %pi, z - y<>

  Function definition ·

Previous: Macros, Up: Function Definition [Contents][Index]

### 36.4 Functions and Variables for Function Definition

関数: apply (F, [x_1, ..., x_n])

  `F(x_1, ..., x_n)`を構成、評価します。

  `apply`は、配列関数を通常の関数と区別しようとはしません; Fが配列関数の名前の時、`apply`は`F(...)`(カギ括弧の代わりに括弧での関数コール）を評価します。 `arrayapply`は、この場合、カギ括弧ありで関数コールを評価します。

  例:

  `apply`は、引数を評価します。 この例では、`min`が`L`の値に適用されます。

      (%i1) L : [1, 5, -10.2, 4, 3];
      (%o1)                 [1, 5, - 10.2, 4, 3]
      (%i2) apply (min, L);
      (%o2)                        - 10.2

  `apply`は、たとえ関数Fが引数をクォートする場合でも、引数を評価します。

      (%i1) F (x) := x / 1729;
                                         x
      (%o1)                     F(x) := ----
                                        1729
      (%i2) fname : F;
      (%o2)                           F
      (%i3) dispfun (F);
                                         x
      (%t3)                     F(x) := ----
                                        1729

      (%o3)                         [%t3]
      (%i4) dispfun (fname);
      fname is not the name of a user function.
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i5) apply (dispfun, [fname]);

                                         x
      (%t5)                     F(x) := ----
                                        1729

      (%o5)                         [%t5]

  `apply`は関数名Fを評価します。 シングルクオート`'`は評価を無効にします。 `demoivre`はグローバル変数の名前であり、また、関数でもあります。

      (%i1) demoivre;
      (%o1)                         false
      (%i2) demoivre (exp (%i * x));
      (%o2)                  %i sin(x) + cos(x)
      (%i3) apply (demoivre, [exp (%i * x)]);
      demoivre evaluates to false
      Improper name or value in functional position.
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i4) apply ('demoivre, [exp (%i * x)]);
      (%o4)                  %i sin(x) + cos(x)

  Function application ·

関数: block ([v_1, ..., v_m], expr_1, ..., expr_n)
関数: block (expr_1, ..., expr_n)

  `block`はexpr_1, ..., expr_nを順に評価し、評価された最後の式の値を返します。 順序は`go`, `throw`, `return`関数によって変更することができます。 最後の式は、`return`もしくは`throw`を含む式が評価されないなら、expr_nです。 いくつかの変数v_1, ..., v_mがブロックにローカルに宣言できます; これらは同じ名前のグローバル変数と区別されます。 変数がローカルに宣言されないなら、リストは省略できます。 ブロック内では、v_1, ..., v_m以外の変数はグローバル変数です。

  `block`は（存在するなら）変数v_1, ..., v_mの現在の値を保存し、 変数がそれ自身に評価されるよう変数のバインドを解除します。 ローカル変数はブロック内部で任意の値にバインドできますが、 ブロックが終了するとき保存された値が戻され、 ブロック内で割り当てられた値は失われます。

  `block`内部の宣言`local(v_1, ..., v_m)`は シンボルv_1, ..., v_mに関連付けられた性質を保存し、 他の式を評価する前に、性質を取り除き、ブロック終了時に元に戻します。 いくつかの宣言は、`:=`、`array`, `dependencies`, `atvalue`, `matchdeclare`, `atomgrad`, `constant`, `nonscalar`その他を含むシンボルの性質として実装されます。 `local`の効果は、ブロック内部のみで有効な宣言を作ります; そうでなければ、ブロック内部の宣言は実際にグローバル宣言となります。

  `block`は他の`block`内部でも現れます。 ローカル変数が、新しいブロックが評価されるたびに確立されます。 ローカル変数は、内包するブロックではグローバルです。 ブロックの中で、変数がローカルでないなら、その値は内包するブロックによって割り当てられた最新の値です。 そうでなければ、グローバル環境の変数の値になります。 このポリシーは「動的スコープ」の普通の理解と一致します。

  ブロックの値は、最後の文もしくはブロックから陽に終了するのに使われる関数`function`の引数の値です。 関数`go`は、`go`の引数でタグされたブロックの文に制御を移すのに使われます。 例えば、`block ([x], x:1, loop, x: x+1, ..., go(loop), ...)`。 `go`の引数はブロック内部に現れるタグの名前でなければなりません。 `go`を含んだブロック以外のブロック内部のタグへ飛ぶのに`go`を使うことはできません。

  ブロックは、典型的な場合、関数定義の右辺に現れますが、他の場所でも使うことができます。

  Expressions ·Programming ·

関数: break (expr_1, ..., expr_n)

  expr_1, ..., expr_nを評価し、印字し、それから ユーザーが環境を検査し変更できるところでMaximaブレイクを引き起こします。 `exit;`をタイプすると、計算が再開されます。

  Debugging ·

関数: catch (expr_1, ..., expr_n)

  expr_1, ..., expr_nを１つずつ評価します; もしどれかが形式`throw (arg)`の式の評価に至るなら、 `catch`の値は`throw (arg)`の値であり、もう式は評価されません。 これの「非局所的リターン」は 入れ子の任意の深さを通過して、`throw`を含む最も近い`catch`に飛びます。 もし`throw`を含む`catch`がないなら、 エラーメッセージが印字されます。

  もし引数の評価が いかなる`throw`の評価にも至らないなら、 `catch`の値はexpr_nの値です。

      (%i1) lambda ([x], if x < 0 then throw(x) else f(x))$
      (%i2) g(l) := catch (map (''%, l))$
      (%i3) g ([1, 2, 3, 7]);
      (%o3)               [f(1), f(2), f(3), f(7)]
      (%i4) g ([1, 2, -3, 7]);
      (%o4)                          - 3

  もし`l`が非負数だけから成るなら、 `l`の要素それぞれの`f`のリストを返します; そうでなければ、`g`は "catches" the first negative element of `l`の最初の負の要素を「キャッチ」して、それを「スロー」します。

  Programming ·

関数: compfile (filename, f_1, …, f_n)
関数: compfile (filename, functions)
関数: compfile (filename, all)

  Maxima関数をLispに翻訳し、翻訳したコードをファイルfilenameに書き込みます。

  `compfile(filename, f_1, ..., f_n)`は 指定された関数を翻訳します。 `compfile (filename, functions)`と `compfile (filename, all)`はユーザー定義関数をすべて翻訳します。

  Lisp翻訳は評価されず、出力ファイルはLispコンパイラによって処理もされません。 `translate`はLisp翻訳を生成し評価します。 `compile_file`はMaximaをLispに翻訳し、Lispコンパイラを実行します。

  `translate`, `translate_file`, `compile_file`も参照してください。

  Translation and compilation ·

関数: compile (f_1, ..., f_n)
関数: compile (functions)
関数: compile (all)

  Maxima関数f_1, ..., f_nをLispに翻訳し、 Lisp翻訳を評価し、 翻訳された関数それぞれについてLisp関数`COMPILE`をコールします。 `compile`は、コンパイルされた関数名のリストを返します。

  `compile (all)`や`compile (functions)`は、 ユーザー定義関数すべてをコンパイルします。

  `compile`は引数をクォートします; クォートクォート演算子`''`はクォートに優先します。

  Translation and compilation ·

関数: define (f(x_1, …, x_n), expr)
関数: define (f[x_1, …, x_n], expr)
関数: define (funmake (f, [x_1, …, x_n]), expr)
関数: define (arraymake (f, [x_1, …, x_n]), expr)
関数: define (ev (expr_1), expr_2)

  引数x_1, …, x_nを持ち、 exprの中身を持つfという名前の関数を定義します。 `define`は、いつも（陽にクオートされていない限り）、２番目の引数を評価します。 定義された関数は、（かっこでくくられた引数を持つ）通常のMaxima関数 もしくは（カギ括弧でくくられた引数を持つ）配列関数です。

  最後の関数の引数x_nが要素１つのリストの時、 `define`によって定義される関数は、可変な数の引数を受け入れます。 実際の引数は、形式的な引数, x_1, ..., x_(n - 1)に１対１に割り当てられます。 実際の引数がさらに存在するならx_nにリストとして割り当てられます。

  `define`の最初の引数が`f(x_1, ..., x_n)`もしくは `f[x_1, ..., x_n]`の形の式の時、 関数の引数は評価されますが、既にその名前の関数や変数があったとしてもfは評価されません。

  最初の引数が演算子`funmake`もしくは`arraymake`, `ev`を伴う式の時、 最初の引数は評価されます；これは、本体だけでなく、関数名が計算されることを許します。

  すべての関数定義は同じ名前空間で現れます; 関数gの中で関数`f`を定義することは、`f`のスコープを`g`に自動的に限定することにはなりません。 しかしながら、`local(f)`は、関数`f`の定義を、 `local`が現れたブロックや他の合成式内部でのみ有効とします。

  もしある形式的な引数x_kが（評価の後）クォートされたシンボルならば、 `define`によって定義される関数は、対応する実際の引数を評価しません。 そうでければ、すべての実際の引数は評価されます。

  `:=`や`::=`も参照してください。

  例:

  `define`は、(陽にクォートされない限り)いつも二番目の引数を評価します

      (%i1) expr : cos(y) - sin(x);
      (%o1)                    cos(y) - sin(x)
      (%i2) define (F1 (x, y), expr);
      (%o2)              F1(x, y) := cos(y) - sin(x)
      (%i3) F1 (a, b);
      (%o3)                    cos(b) - sin(a)
      (%i4) F2 (x, y) := expr;
      (%o4)                   F2(x, y) := expr
      (%i5) F2 (a, b);
      (%o5)                    cos(y) - sin(x)

  `define`が定義する関数は、通常のMaxima関数も配列関数も取り得ます。

      (%i1) define (G1 (x, y), x.y - y.x);
      (%o1)               G1(x, y) := x . y - y . x
      (%i2) define (G2 [x, y], x.y - y.x);
      (%o2)                G2     := x . y - y . x
                             x, y

  最後の、または唯一の引数x_nが１要素のリストの時、 `define`が定義した関数は可変の数の引数を受け付けます。

      (%i1) define (H ([L]), '(apply ("+", L)));
      (%o1)                H([L]) := apply("+", L)
      (%i2) H (a, b, c);
      (%o2)                       c + b + a

  最初の引数が 演算子`funmake`, `arraymake`, または`ev`を含む式なら、 最初の引数は評価されます。

      (%i1) [F : I, u : x];
      (%o1)                        [I, x]
      (%i2) funmake (F, [u]);
      (%o2)                         I(x)
      (%i3) define (funmake (F, [u]), cos(u) + 1);
      (%o3)                  I(x) := cos(x) + 1
      (%i4) define (arraymake (F, [u]), cos(u) + 1);
      (%o4)                   I  := cos(x) + 1
                               x
      (%i5) define (foo (x, y), bar (y, x));
      (%o5)                foo(x, y) := bar(y, x)
      (%i6) define (ev (foo (x, y)), sin(x) - cos(y));
      (%o6)             bar(y, x) := sin(x) - cos(y)

  Function definition ·

関数: define_variable (name, default_value, mode)

  グローバル変数をMaxima環境に導入します。 `define_variable`は、ユーザーが書いたパッケージで役に立ちます。 パッケージはしばしば翻訳されたりコンパイルされたりします。

  `define_variable`は以下のステップを実行します:

  1. `mode_declare (name, mode)`は、 nameのモードを翻訳器に宣言します。 可能なモードのリストについては、`mode_declare`を参照してください。
  2. もし変数がバインドされていなければ、default_valueがnameに割り当てられます。
  3. `declare (name, special)`はそれをspecialと宣言します。
  4. nameが宣言されたモードのただ１つの割り当てられた値であることを 保証するために、 nameをテスト関数に関連づけます。

  `value_check`プロパティは、 `define_variable`を介して `any`以外のモードに定義された任意の変数に割り当てられることができます。 `value_check`プロパティは、１変数のラムダ式または関数名です。 それは値を変数に割り当てようとする時にコールされます。 `value_check`関数の引数は期待値です。

  `define_variable`は`default_value`を評価し、 `name`と`mode`をクォートします。 `define_variable`は`name`の現在値を返します。 それは、もし`name`がそこでバインドされてないなら`default_value`で そうでないなら`name`の以前の値です。

  例:

  `foo`はブーリアン変数で、初期値`true`を持ちます。

      (%i1) define_variable (foo, true, boolean);
      (%o1)                         true
      (%i2) foo;
      (%o2)                         true
      (%i3) foo: false;
      (%o3)                         false
      (%i4) foo: %pi;
      Error: foo was declared mode boolean, has value: %pi
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i5) foo;
      (%o5)                         false

  `bar`は整数変数で、素数でなければいけません。

      (%i1) define_variable (bar, 2, integer);
      (%o1)                           2
      (%i2) qput (bar, prime_test, value_check);
      (%o2)                      prime_test
      (%i3) prime_test (y) := if not primep(y) then
                                 error (y, "is not prime.");
      (%o3) prime_test(y) := if not primep(y)

                                         then error(y, "is not prime.")
      (%i4) bar: 1439;
      (%o4)                         1439
      (%i5) bar: 1440;
      1440 is not prime.
      #0: prime_test(y=1440)
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i6) bar;
      (%o6)                         1439

  `baz_quux`は、値を割り当てられない変数です。 モード`any_check`は`any`のようですが、 `any_check`は`value_check`メカニズムを可能にしますが、 `any`はそうしません。

      (%i1) define_variable (baz_quux, 'baz_quux, any_check);
      (%o1)                       baz_quux
      (%i2) F: lambda ([y], if y # 'baz_quux then
                       error ("Cannot assign to `baz_quux'."));
      (%o2) lambda([y], if y # 'baz_quux

                              then error(Cannot assign to `baz_quux'.))
      (%i3) qput (baz_quux, ''F, value_check);
      (%o3) lambda([y], if y # 'baz_quux

                              then error(Cannot assign to `baz_quux'.))
      (%i4) baz_quux: 'baz_quux;
      (%o4)                       baz_quux
      (%i5) baz_quux: sqrt(2);
      Cannot assign to `baz_quux'.
      #0: lambda([y],if y # 'baz_quux then
                       error("Cannot assign to `baz_quux'."))(y=sqrt(2))
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i6) baz_quux;
      (%o6)                       baz_quux

  Translation and compilation ·

関数: dispfun (f_1, …, f_n)
関数: dispfun (all)

  ユーザー定義関数f_1, ..., f_nの定義を表示します。 引数それぞれは、(`::=`で定義された)マクロ名、 (`:=`や`define`で定義された)通常の関数、 (`:=`y`define`で定義された、しかし引数をカギ括弧`[ ]`でくくった) 配列関数、 (`:=`y`define`で定義された、しかしいくつかの引数をカギ括弧`[ ]`で、他の引数を括弧`( )`でくくった)添字付き関数、 特別な添字の値で選択された添字付き関数の族の１つ、 定数添字で定義された添字付き関数、 のいずれかを取り得ます。

  `dispfun (all)`は、 `functions`, `arrays`, `macros`リストで与えられた中で、 定数添字で定義された添字付き関数を除いたユーザー定義関数すべてを表示します。

  `dispfun`は 表示された関数それぞれのために (`%t1`, `%t2`, など) 中間式ラベルを生成し、関数定義をラベルに割り当てます。 対照的に、`fundef`は関数定義を返します。

  `dispfun`は引数をクォートします; クォートクォート演算子`''`はクォートに優先します。 `dispfun`は表示された関数に対応する中間式ラベルのリストを返します。

  例:

      (%i1) m(x, y) ::= x^(-y);
                                           - y
      (%o1)                   m(x, y) ::= x
      (%i2) f(x, y) :=  x^(-y);
                                           - y
      (%o2)                    f(x, y) := x
      (%i3) g[x, y] :=  x^(-y);
                                          - y
      (%o3)                     g     := x
                                 x, y
      (%i4) h[x](y) :=  x^(-y);
                                          - y
      (%o4)                     h (y) := x
                                 x
      (%i5) i[8](y) :=  8^(-y);
                                          - y
      (%o5)                     i (y) := 8
                                 8
      (%i6) dispfun (m, f, g, h, h[5], h[10], i[8]);
                                           - y
      (%t6)                   m(x, y) ::= x

                                           - y
      (%t7)                    f(x, y) := x

                                          - y
      (%t8)                     g     := x
                                 x, y

                                          - y
      (%t9)                     h (y) := x
                                 x

                                          1
      (%t10)                     h (y) := --
                                  5        y
                                          5

                                           1
      (%t11)                    h  (y) := ---
                                 10         y
                                          10

                                          - y
      (%t12)                    i (y) := 8
                                 8

      (%o12)       [%t6, %t7, %t8, %t9, %t10, %t11, %t12]
      (%i12) ''%;
                           - y              - y            - y
      (%o12) [m(x, y) ::= x   , f(x, y) := x   , g     := x   ,
                                                  x, y
                        - y           1              1             - y
              h (y) := x   , h (y) := --, h  (y) := ---, i (y) := 8   ]
               x              5        y   10         y   8
                                      5             10

  Function definition ·Display functions ·

関数: fullmap (f, expr_1, …)

  `map`と似ていますが、`fullmap`は、主演算子が同じでなくなるまで、 部分式すべてに再帰的にマッピングを続けます。

  `fullmap`は、ある行列操作のための整理に使われています; このように、Maximaは時々、たとえ`fullmap`がユーザーに陽にコールされなくても、 `fullmap`に関係したエラーメッセージを生成します。

  例:

      (%i1) a + b * c;
      (%o1)                        b c + a
      (%i2) fullmap (g, %);
      (%o2)                   g(b) g(c) + g(a)
      (%i3) map (g, %th(2));
      (%o3)                     g(b c) + g(a)

  Function application ·Expressions ·

関数: fullmapl (f, list_1, …)

  `fullmap`に似ていますが、`fullmapl`はリストや行列にのみマップします。

  例:

      (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
      (%o1)                [[a + 3, 4], [4, 3.5]]

  Function application ·Expressions ·

システム変数: functions

  デフォルト値: `[]`

  `functions`は、現在のセッションでの通常のMaxima関数のリストです。 通常の関数は、`define`や`:=`で構成された関数であり、 括弧`()`でコールされます。 関数はMaximaプロンプトで定義することができ、また、 `load`や`batch`がロードするMaximaファイルの中で定義することができます。

  (例えば`F[x]`のように、カギ括弧でコールされる)配列関数と (例えば`F[x](y)`のように、カギ括弧と括弧でコールされる)添字付き関数は、 `functions`ではなくグローバル変数`arrays`にリストされます。

  Lisp関数はどのリストにも保持されません。

  例:

      (%i1) F_1 (x) := x - 100;
      (%o1)                   F_1(x) := x - 100
      (%i2) F_2 (x, y) := x / y;
                                            x
      (%o2)                    F_2(x, y) := -
                                            y
      (%i3) define (F_3 (x), sqrt (x));
      (%o3)                   F_3(x) := sqrt(x)
      (%i4) G_1 [x] := x - 100;
      (%o4)                    G_1  := x - 100
                                  x
      (%i5) G_2 [x, y] := x / y;
                                           x
      (%o5)                     G_2     := -
                                   x, y    y
      (%i6) define (G_3 [x], sqrt (x));
      (%o6)                    G_3  := sqrt(x)
                                  x
      (%i7) H_1 [x] (y) := x^y;
                                            y
      (%o7)                     H_1 (y) := x
                                   x
      (%i8) functions;
      (%o8)              [F_1(x), F_2(x, y), F_3(x)]
      (%i9) arrays;
      (%o9)                 [G_1, G_2, G_3, H_1]

  Function definition ·Global variables ·

関数: fundef (f)

  関数fの定義を返します。

  引数は、(`::=`で定義された）マクロの名前か、 (`:=`もしくは`define`で定義された）通常の関数か、 (`:=`や`define`で定義され、引数がカギ括弧でくくられた）配列関数か、 (`:=`や`define`で定義され、いくつかの引数がカギ括弧でくくられ、残りがかっこでくくられた）添字関数か、 特別な添字の値によって選択された添字関数族の１つか、一定の添字で定義された添字関数です。

  `fundef`は引数をクォートします; クォートクォート演算子`''`はクォートに優先します。

  `fundef (f)`はfの定義を返します。 対照的に、`dispfun (f)`は中間式ラベルを生成し、ラベルに定義を割り当てます。

  Function definition ·

関数: funmake (F, [arg_1, …, arg_n])

  式`F(arg_1, ..., arg_n)`を返します。 戻り値は整理されますが、評価されません。 だから関数Fはたとえ存在してもコールされません。

  `funmake`は配列関数と通常の関数を区別しようとしません; Fが配列関数名の時、 `funmake`は`F(...)`を返します (すなわち、カギ括弧の代わりに括弧での関数コール)。 `arraymake`は、この場合，カギ括弧での関数コールを返します。

  `funmake`は引数を評価します。

  例:

  通常のMaxima関数に適用された`funmake`。

      (%i1) F (x, y) := y^2 - x^2;
                                         2    2
      (%o1)                  F(x, y) := y  - x
      (%i2) funmake (F, [a + 1, b + 1]);
      (%o2)                    F(a + 1, b + 1)
      (%i3) ''%;
                                    2          2
      (%o3)                  (b + 1)  - (a + 1)

  マクロに適用された`funmake`。

      (%i1) G (x) ::= (x - 1)/2;
                                        x - 1
      (%o1)                    G(x) ::= -----
                                          2
      (%i2) funmake (G, [u]);
      (%o2)                         G(u)
      (%i3) ''%;
                                    u - 1
      (%o3)                         -----
                                      2

  添字付き関数に適用された`funmake`。

      (%i1) H [a] (x) := (x - 1)^a;
                                              a
      (%o1)                   H (x) := (x - 1)
                               a
      (%i2) funmake (H [n], [%e]);
                                             n
      (%o2)               lambda([x], (x - 1) )(%e)
      (%i3) ''%;
                                          n
      (%o3)                       (%e - 1)
      (%i4) funmake ('(H [n]), [%e]);
      (%o4)                        H (%e)
                                    n
      (%i5) ''%;
                                          n
      (%o5)                       (%e - 1)

  いかなる種類の関数にも定義されていないシンボルへ適用された `funmake`

      (%i1) funmake (A, [u]);
      (%o1)                         A(u)
      (%i2) ''%;
      (%o2)                         A(u)

  `funmake`は引数を評価しますが、戻り値を評価しません。

      (%i1) det(a,b,c) := b^2 -4*a*c;
                                          2
      (%o1)              det(a, b, c) := b  - 4 a c
      (%i2) (x : 8, y : 10, z : 12);
      (%o2)                          12
      (%i3) f : det;
      (%o3)                          det
      (%i4) funmake (f, [x, y, z]);
      (%o4)                    det(8, 10, 12)
      (%i5) ''%;
      (%o5)                         - 284

  Maximaは`funmake`の戻り値を整理します。

      (%i1) funmake (sin, [%pi / 2]);
      (%o1)                           1

  Function application ·Expressions ·

関数: lambda ([x_1, ..., x_m], expr_1, ..., expr_n)
関数: lambda ([[L]], expr_1, ..., expr_n)
関数: lambda ([x_1, ..., x_m, [L]], expr_1, ..., expr_n)

  ラムダ式 (すなわち、匿名関数)を定義し返します。 関数は要求された引数x_1, ..., x_mを持ち、 また、オプション引数Lを持つかもしれません。オプション引数は関数本体の中にリストとして現れます。 関数の戻り値はexpr_nです。 ラムダ式は変数に割り当てることができ、通常の関数のように評価できます。 ラムダ式は関数名が期待されるいくつかのコンテキストで現れるかもしれません。

  関数が評価される時、 バインドされていないローカル変数x_1, ..., x_mが生成されます。 `lambda`は `block`の中や別の`lambda`の中で現れるかもしれません; ローカル変数は、別の`block`や`lambda`が評価される度に毎回確立されます。 ローカル変数は内包する`block`や`lambda`にはグローバルのように見えます。 もし変数がローカルでないなら、 その値は、(もし割り当てられたなら)内包する`block`や`lambda`で直近に割り当てられた値です。 そうでなければ、グローバル環境での変数の値です。 このポリシーは「動的スコープ」の普通の理解と一致するかもしれません。

  ローカル変数が確立された後、 expr_1からexpr_nまでが順に評価されます。 特殊変数`%%`―直前の式の値を表します―が認識されます。 `throw`と`catch`も式のリストの中に現れるかもしれません。

  `block`で囲まれない限り `return`はラムダ式の中には現れません。 `block`で囲まれた場合、 ブロックがたまたま expr_nに至るということでない限り、 `return`はラムダ式の戻り値ではなくブロックの戻り値を定義します。 同様に、`go`は、`block`で囲まれない限りラムダ式の中に現れません。

  `lambda`は引数をクォートします; クォートクォート演算子`''`はクォートに優先します。

  例:

  - ラムダ式は変数に割り当てることができ、通常の関数のように評価できます。

      (%i1) f: lambda ([x], x^2);
                                            2
      (%o1)                    lambda([x], x )
      (%i2) f(a);
                                      2
      (%o2)                          a

  - ラムダ式は 関数評価が期待される文脈で現れるかもしれません。

      (%i3) lambda ([x], x^2) (a);
                                      2
      (%o3)                          a
      (%i4) apply (lambda ([x], x^2), [a]);
                                      2
      (%o4)                          a
      (%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
                              2   2   2   2   2
      (%o5)                 [a , b , c , d , e ]

  - 引数変数はローカル変数です。 他の変数はグローバル変数のように見えます。 ある特殊な評価が`''`のようにある方法で強制されない限り、 グローバル変数はラムダ式が評価される時評価されます。

      (%i6) a: %pi$
      (%i7) b: %e$
      (%i8) g: lambda ([a], a*b);
      (%o8)                   lambda([a], a b)
      (%i9) b: %gamma$
      (%i10) g(1/2);
                                   %gamma
      (%o10)                       ------
                                     2
      (%i11) g2: lambda ([a], a*''b);
      (%o11)                lambda([a], a %gamma)
      (%i12) b: %e$
      (%i13) g2(1/2);
                                   %gamma
      (%o13)                       ------
                                     2

  - ラムダ式は入れ子にできます。 外側のラムダ式の中のローカル変数は、 同じ名前のローカル変数がマスクしない限り、 内側の式にはグローバルに見えます。

      (%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
                                                         1
      (%o14)    lambda([a, b], h2 : lambda([a], a b), h2(-))
                                                         2
      (%i15) h(%pi, %gamma);
                                   %gamma
      (%o15)                       ------
                                     2

  - `lambda`は引数をクォートするので、 以下のラムダ式`i`は "`a`を掛ける"関数を定義しません。 以下のラムダ式`i2`のように、 そんな関数は`buildq`を介して定義することができます。

      (%i16) i: lambda ([a], lambda ([x], a*x));
      (%o16)            lambda([a], lambda([x], a x))
      (%i17) i(1/2);
      (%o17)                  lambda([x], a x)
      (%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x)));
      (%o18)    lambda([a], buildq([a : a], lambda([x], a x)))
      (%i19) i2(1/2);
                                           x
      (%o19)                   lambda([x], -)
                                           2
      (%i20) i2(1/2)(%pi);
                                     %pi
      (%o20)                         ---
                                      2

  - ラムダ式は、可変の数の引数を取ることができます。 それは、唯一のまたは最後の引数として`[L]`で指定されます。 引数は関数本体の中にリストとして現れます。

      (%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb);
      (%o1)          lambda([aa, bb, [cc]], aa cc + bb)
      (%i2) f (foo, %i, 17, 29, 256);
      (%o2)       [17 foo + %i, 29 foo + %i, 256 foo + %i]
      (%i3) g : lambda ([[aa]], apply ("+", aa));
      (%o3)             lambda([[aa]], apply(+, aa))
      (%i4) g (17, 29, x, y, z, %e);
      (%o4)                  z + y + x + %e + 46

  Function definition ·

関数: local (v_1, …, v_n)

  シンボルv_1, ..., v_nに関連付けられた性質を保存し、 他の式を評価する前にすべての性質を取り除き、 `local`が現れたブロックや他の合成式の終了時に保存した性質を元に戻します。

  いくつかの宣言は、`:=`、`array`, `dependencies`, `atvalue`, `matchdeclare`, `atomgrad`, `constant`, `nonscalar`その他を含むシンボルの性質として実装されます。 `local`の効果は、ブロック内部のみで有効な宣言を作ります; そうでなければ、ブロック内部の宣言は実際にグローバル宣言となります。

  `local`は、`block`や関数定義の本体や`lambda`式の中に現れます。 それぞれの中で１カ所だけ許されます。

  `local`は引数をクォートします。 `local`は`done`を返します。

  例:

  ローカル関数定義。

      (%i1) foo (x) := 1 - x;
      (%o1)                    foo(x) := 1 - x
      (%i2) foo (100);
      (%o2)                         - 99
      (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
      (%o3)                          200
      (%i4) foo (100);
      (%o4)                         - 99

  Function definition ·Programming ·

オプション変数: macroexpansion

  デフォルト値: `false`

  `macroexpansion`は マクロ関数コールを マクロ関数の展開(すなわち戻り値)で 置き換えるかどうかを制御します。 展開を記憶する代価で、置き換えは次の式評価をスピードアップするかもしれません。

  `false`

    マクロ関数コールをマクロ関数の展開で置き換えられません。

  `expand`

    マクロ関数コールが初めて評価された時、展開が記憶されます。 展開は次のコール時に再計算されません; (`print`やグローバル変数への割り当てのような)いかなる副作用も 最初にマクロ関数コールが評価された時だけ起こります。 式の中の展開は、同じマクロ関数コールを持つ他の式に影響を与えません。

  `displace`

    マクロ関数コールが初めて評価された時、展開でコールを置き換え、 マクロ関数がコールされた式を変更します。 展開は次のコールで再計算されません; (`print`やグローバル変数への割り当てのような)いかなる副作用も 最初にマクロ関数コールが評価された時だけ起こります。 式の中の展開は、同じマクロ関数コールを持つ他の式に影響を与えません。

  例

  `macroexpansion`が`false`の時、 コールする式が評価される時毎回マクロ関数がコールされ、 コールする式は変更されません。

      (%i1) f (x) := h (x) / g (x);
                                        h(x)
      (%o1)                     f(x) := ----
                                        g(x)
      (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
                             return (x + 99));
      (%o2) g(x) ::= block(print("x + 99 is equal to", x),
                                                        return(x + 99))
      (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
                             return (x - 99));
      (%o3) h(x) ::= block(print("x - 99 is equal to", x),
                                                        return(x - 99))
      (%i4) macroexpansion: false;
      (%o4)                         false
      (%i5) f (a * b);
      x - 99 is equal to x
      x + 99 is equal to x
                                  a b - 99
      (%o5)                       --------
                                  a b + 99
      (%i6) dispfun (f);
                                        h(x)
      (%t6)                     f(x) := ----
                                        g(x)

      (%o6)                         done
      (%i7) f (a * b);
      x - 99 is equal to x
      x + 99 is equal to x
                                  a b - 99
      (%o7)                       --------
                                  a b + 99

  `macroexpansion`が`expand`の時、 マクロ関数は一度コールされ、 コールする式は変更されません。

      (%i1) f (x) := h (x) / g (x);
                                        h(x)
      (%o1)                     f(x) := ----
                                        g(x)
      (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
                             return (x + 99));
      (%o2) g(x) ::= block(print("x + 99 is equal to", x),
                                                        return(x + 99))
      (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
                             return (x - 99));
      (%o3) h(x) ::= block(print("x - 99 is equal to", x),
                                                        return(x - 99))
      (%i4) macroexpansion: expand;
      (%o4)                        expand
      (%i5) f (a * b);
      x - 99 is equal to x
      x + 99 is equal to x
                                  a b - 99
      (%o5)                       --------
                                  a b + 99
      (%i6) dispfun (f);
                                        h(x)
      (%t6)                     f(x) := ----
                                        g(x)

      (%o6)                         done
      (%i7) f (a * b);
                                  a b - 99
      (%o7)                       --------
                                  a b + 99

  `macroexpansion`が`expand`の時、 マクロ関数は一度コールされ、 コールする式が変更されます。

      (%i1) f (x) := h (x) / g (x);
                                        h(x)
      (%o1)                     f(x) := ----
                                        g(x)
      (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
                             return (x + 99));
      (%o2) g(x) ::= block(print("x + 99 is equal to", x),
                                                        return(x + 99))
      (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
                             return (x - 99));
      (%o3) h(x) ::= block(print("x - 99 is equal to", x),
                                                        return(x - 99))
      (%i4) macroexpansion: displace;
      (%o4)                       displace
      (%i5) f (a * b);
      x - 99 is equal to x
      x + 99 is equal to x
                                  a b - 99
      (%o5)                       --------
                                  a b + 99
      (%i6) dispfun (f);
                                       x - 99
      (%t6)                    f(x) := ------
                                       x + 99

      (%o6)                         done
      (%i7) f (a * b);
                                  a b - 99
      (%o7)                       --------
                                  a b + 99

  Function application ·Global flags ·

オプション変数: mode_checkp

  デフォルト値: `true`

  `mode_checkp`が`true`の時、 `mode_declare`はバインドされた変数のモードをチェックします。

  Translation flags and variables ·

オプション変数: mode_check_errorp

  デフォルト値: `false`

  `mode_check_errorp`が`true`の時、 `mode_declare`はエラーをコールします。

  Translation flags and variables ·

オプション変数: mode_check_warnp

  デフォルト値: `true`

  `mode_check_warnp`が`true`の時、 モードエラーが記述されます。

  Translation flags and variables ·

関数: mode_declare (y_1, mode_1, …, y_n, mode_n)

  `mode_declare`は、 その後の関数の翻訳やコンパイルのために 変数と関数のモードを宣言するのに使われます。 `mode_declare`は、通常、 関数定義の始めやMaximaスクリプトの始めに置かれたり、対話プロンプトで実行されたりします。

  `mode_declare`の引数は、 変数とモードから成る対です。 モードは `boolean`, `fixnum`, `number`, `rational`, `float`のいずれか１つです。 変数それぞれは、 同じモードを持つように宣言される変数すべてのリストも取り得ます。

  もし変数が配列で、かつ、参照される配列のすべての要素が値を持つなら、 なら、

      array(yi, dim1, dim2, ...)

  よりむしろ`array (yi, complete, dim1, dim2, …)`を 最初に配列のバインドを宣言する時に使うべきです。 もし配列の要素すべてが モード`fixnum` (`float`)なら、 `complete`の代わりに`fixnum` (`float`)を使ってください。 もし配列のすべての要素が同じモード―`m`としましょう―なら、 効率的な翻訳のためには、

      mode_declare (completearray (yi), m))

  を使うべきです。

  配列を使う数値コードは、例えば、10 x 10の浮動小数点配列のために

      mode_declare (completearray (a [10, 10]), float)

  というように、期待される配列サイズを宣言することでより速く実行されるかもしれません

  引数として`function (f_1, f_2, ...)`を使うことで 関数の結果のモードを宣言することができます; ここで`f_1`, `f_2`, …は関数名です。 例えば、式

      mode_declare ([function (f_1, f_2, ...)], fixnum)

  は、 `f_1`, `f_2`, ...が返す値が1ワード整数であることを宣言します。

  `modedeclare`は`mode_declare`と同義です。

  Translation and compilation ·

関数: mode_identity (arg_1, arg_2)

  `mode_declare`と`macros`で 例えば、flonumsのリストのリストや他の合成データオブジェクトを宣言するのに 使われる特殊形式。 `mode_identity`の最初の引数は、`mode_declare`に与えられるような プリミティブな値モード名(すなわち、`float`, `fixnum`, `number`, `list`, `any`のいずれか)であり、 二番目の引数は、評価され、`mode_identity`の値として返される式です。 しかしながら、もし戻り値が最初の引数で宣言されたモードによって許されていないなら、 エラーか警告がシグナルされます。 重要なことは、MaximaによってLisp翻訳器に命じた式のモードが、二番目の引数のなかで続く一切から独立して、最初の引数として与えられるそれだということです。 例えば、`x: 3.3; mode_identity (fixnum, x);`はエラーをもたらします。 `mode_identity (flonum, x)`は3.3を返します。 これは多くの使い道があります。例えば、もし`first (l)`が数を返すと知っていたなら、 `mode_identity (number, first (l))`と書くかもしれません。 しかしながら、それをするもっと効率的な方法は、

      firstnumb (x) ::= buildq ([x], mode_identity (number, first(x)));

  のように新しいプリミティブを定義し、 そして数のリストの最初の要素を取る時毎回`firstnumb`を使うことです。

  Translation and compilation ·

関数: remfunction (f_1, ..., f_n)
関数: remfunction (all)

  シンボルf_1, ..., f_nの関数定義をアンバインドします。 引数は、（`:=`もしくは`define`で生成された）通常の関数名もしくは（`::=`で生成された）マクロ関数をとります。

  `remfunction (all)`は関数定義すべてをアンバインドします。

  `remfunction`は引数をクォートします。

  `remfunction`は、関数定義はアンバインドされたシンボルのリストを返します。 シンボルに関数定義がなければ、シンボルの代わりに`false`を返します。

  `remfunction`は配列関数すなわち添字付き関数には適用されません。 これらのタイプの関数には`remarray`を適用します。

  Function definition ·

オプション変数: savedef

  デフォルト値: `true`

  `savedef`が`true`の時、 関数が解釈される時に ユーザー関数のMaximaバージョンが保持されます。 これは、定義が`dispfun`によって表示されることを許し、 関数が編集されることを許します。

  `savedef`が`false`の時、 解釈された関数の名前は、`functions`リストから取り除かれます。

  Translation flags and variables ·

オプション変数: transcompile

  デフォルト値: `true`

  `transcompile`が`true`の時、 `translate`と`translate_file`は 翻訳コードをコンパイルにより適したものにする宣言を生成します。

  `compfile`は実行中`transcompile: true`を設定します。

  Translation flags and variables ·

関数: translate (f_1, …, f_n)
関数: translate (functions)
関数: translate (all)

  ユーザー定義関数f_1, …, f_nをMaxima言語からLispに翻訳し、 Lisp翻訳を評価します。 通常、翻訳された関数は元の関数より速く実行されます。

  `translate (all)`や`translate (functions)`は、 ユーザー定義関数すべてを翻訳します。

  翻訳される関数は、 より効率的なコードを生成するために可能な時は 先頭に`mode_declare`コールを含むべきです。 例えば:

      f (x_1, x_2, ...) := block ([v_1, v_2, ...],
          mode_declare (v_1, mode_1, v_2, mode_2, ...), ...)

  ここで、x_1, x_2, ... は関数のパラメータであり、 v_1, v_2, ...はローカル変数です。

  もし`savedef`が`false`なら(以下を参照してください) 翻訳された関数の名前は、`functions`リストから削除され、 `props`リストに加えられます。

  完全にデバッグされない限り、関数は翻訳すべきではありません。

  式は整理されていると仮定されます; もしされていないなら、厳密ですが、最適でないコードが生成されます。 従って、 ユーザーは `simp`スイッチを`false`―翻訳される式の整理を抑制します― に設定すべきではありません。

  スイッチ`translate`は、もし`true`なら、 ユーザー関数のLispへの自動翻訳をもたらします。

  LispとMaximaのバージョンの間である非互換性が存在する可能性があるので、 翻訳された関数は 翻訳前にした方法を同一に動作するわけではないことに注意してください。 原則として、 もし変数のいずれかが`mode_declare`された標準有理式(CRE)なら 複数の引数を取る`rat`関数と`ratvars`関数は使うべきではありません。 また、 `prederror: false`設定は翻訳されません。

  `savedef` - もし`true`なら、 関数が`translate`された時、Maximaバージョンのユーザー関数を残すようにします。 これは、定義を`dispfun`で表示することを可能にし、 関数を編集することを可能にします。

  `transrun` - もし`false`なら、 すべての関数について、翻訳バージョンではなく、 インタープリトされるバージョン(まだあると仮定して)が実行されるようにします。

  `translate`が返す結果は、翻訳された関数名のリストです。

  Translation and compilation ·

関数: translate_file (maxima_filename)
関数: translate_file (maxima_filename, lisp_filename)

  MaximaコードのファイルをLispコードのファイルに翻訳します。 `translate_file`は３つのファイル名のリストを返します: Maximaファイル名、Lispファイル名、翻訳についての追加情報を含むファイル名。 `translate_file`は引数を評価します。

  `translate_file ("foo.mac"); load("foo.LISP")`は、 例えば、`''`と`%`の利用といった若干の制約を除いて、 コマンド`batch ("foo.mac")`と同じです。

  `translate_file (maxima_filename)`は Maximaファイルmaxima_filenameを 同様に名付けらたLispファイルに翻訳します。 例えば、`foo.mac`は`foo.LISP`に翻訳されます。 Maximaのファイル名はディレクトリ名を含むかもしれません。 その場合、Lisp出力ファイルは、Maxima入力が来たのと同じディレクトリに書かれます。

  `translate_file (maxima_filename, lisp_filename)`は、 Maximaファイルmaxima_filenameをLispファイルlisp_filenameに翻訳します。 `translate_file`は、どんなものでも、`lisp_filename`の ファイル名の拡張子を無視します; Lisp出力ファイルのファイル名の拡張子は、いつも`LISP`です。 Lispファイル名はディレクトリ名を含むかもしれません。 その場合、Lisp出力ファイルは指定されたディレクトリに書かれます。

  `translate_file`は、翻訳器のファイル 様々な度合いの厳しさの翻訳器警告メッセージのファイルも書き出します。 このファイルのファイル名拡張子は `UNLISP`です。 このファイルは、翻訳されたコードの中のバグを追跡するために、 あいまいかもしれませんが、価値ある情報を含むかもしれません。 `UNLISP`ファイルはいつもMaxima入力が来るのと同じディレクトリに書かれます。

  `translate_file`は Lispコードがコンパイルされるすぐに宣言や定義が効力を発揮するようにするLispコードを発行します。 このトピックに関してさらに知るには`compile_file`を参照してください。

  `tr_array_as_ref`, `tr_bound_function_applyp`, `tr_exponent`, `tr_file_tty_messagesp`, `tr_float_can_branch_complex`, `tr_function_call_default`, `tr_numer`, `tr_optimize_max_loop`, `tr_semicompile`, `tr_state_vars`, `tr_warnings_get`, `tr_warn_bad_function_calls`, `tr_warn_fexpr`, `tr_warn_meval`, `tr_warn_mode`, `tr_warn_undeclared`, `tr_warn_undefined_variable`

  も参照してください。

  Translation and compilation ·

オプション変数: transrun

  デフォルト値: `true`

  `transrun`が`false`の時、 すべての関数について、翻訳バージョンではなく、 インタープリトされるバージョン(まだあると仮定して)が実行されるようにします。

  Translation flags and variables ·

オプション変数: tr_array_as_ref

  デフォルト値: `true`

  もし`translate_fast_arrays`が`false`なら、 `translate_file`が発行するLispコードの中の配列参照は、 `tr_array_as_ref`によって影響されます。 `tr_array_as_ref`が`true`の時、 配列名は評価されます。 そうでなければ、配列名は翻訳されたコードの中で文字リテラルとして現れます。

  もし`translate_fast_arrays`が`true`なら、 `tr_array_as_ref`は効果を持ちません。

  Translation flags and variables ·

オプション変数: tr_bound_function_applyp

  デフォルト値: `true`

  `tr_bound_function_applyp`が`true`の時、 もし(関数引数のような)バインドされた変数が関数として使われていることが見つかったら Maximaは警告を与えます。 `tr_bound_function_applyp`は、 そんな場合に生成されたコードに影響しません。

  例えば、 `g (f, x) := f (x+1)`のような式は警告メッセージをトリガーします。

  Translation flags and variables ·

オプション変数: tr_file_tty_messagesp

  デフォルト値: `false`

  `tr_file_tty_messagesp`が`true`の時、 ファイルの翻訳中に `translate_file`が生成するメッセージがコンソールに表示され、 `false`の時、ファイルの翻訳に関するメッセージは UNLISPファイルに挿入されるだけです。

  Translation flags and variables ·

オプション変数: tr_float_can_branch_complex

  デフォルト値: `true`

  Maxima-to-Lisp翻訳器に translator to assume that 関数`acos`, `asin`, `asec`, `acsc`が複素数の結果を返すことができることを仮定するように命じます。

  `tr_float_can_branch_complex`の表面上の効果は以下の通りです。 しかしながら、このフラグは翻訳器出力上の効果を持ちません。

  `true`の時、 たとえ (`mode_declare`が設定したように)`x`がモード`float`でも `acos(x)`はモード`any`です。 `false`の時、 `x`がモード`float`の時だけ `acos(x)`はモード`float`です。

  Translation flags and variables ·

オプション変数: tr_function_call_default

  デフォルト値: `general`

  `false`は、あきらめて`meval`をコールすることを意味し、 `expr`は、引数が固定されたLisp関数を仮定することを意味します。 `general`、デフォルトは `mexprs`や`mlexprs`にはよいが`macros`にはよくないコードを与えます。 `general`は、コンパイルされたコードの中で変数バインドが正確であることを保証します。 `general`モードでは、 F(X)を翻訳する時、もしFがバインドされた変数なら、 `apply (f, [x])`を意味すると仮定され、適切な警告と合わせてそのように翻訳されます。 これをオフにする必要はありません。 デフォルト設定で警告メッセージがないことは、 Maximaインタープリタと、翻訳、コンパイルされたコードの完全互換性を意味します。

  Translation flags and variables ·

オプション変数: tr_numer

  デフォルト値: `false`

  `tr_numer`が`true`の時、 `numer`プロパティは それらを持つアトム、例えば、`%pi`に使われます。

  Translation flags and variables ·

オプション変数: tr_optimize_max_loop

  デフォルト値: 100

  `tr_optimize_max_loop`は、 翻訳器のマクロ展開と最適化パスが形式を検討する際繰り返す最大回数です。 これはマクロ展開エラーや終了しない最適化プロパティをキャッチします。

  Translation flags and variables ·

オプション変数: tr_semicompile

  デフォルト値: `false`

  `tr_semicompile`が`true`の時、 `translate_file`と`compfile`は、 マクロ展開されたが、Lispコンパイラによって機械語にコンパイルされない形式を出力します。

  Translation flags and variables ·

システム変数: tr_state_vars

  デフォルト値:

      [transcompile, tr_semicompile, tr_warn_undeclared, tr_warn_meval,
      tr_warn_fexpr, tr_warn_mode, tr_warn_undefined_variable,
      tr_function_call_default, tr_array_as_ref,tr_numer]

  翻訳された出力の形式に影響するスイッチのリスト。 翻訳器をデバッグしようとする時 この情報はシステムの人たちに役に立ちます。 翻訳された生成物を与えられた状態で生成されるべきだったものと比較することによって、 バグを追跡することが可能です。

  Translation flags and variables ·

関数: tr_warnings_get ()

  現在の翻訳の間に翻訳器が与える警告のリストを印字します。

  Translation and compilation ·

オプション変数: tr_warn_bad_function_calls

  デフォルト値: `true`

  - 翻訳時にされた不適切な宣言のせいで正確でないかもしれない関数コールが行われている時、 警告を与えます。

  Translation flags and variables ·

オプション変数: tr_warn_fexpr

  デフォルト値: `compfile`

  - もしFEXPRに遭遇したら、警告を与えます。 FEXPRは、通常、翻訳コードの中で出力されるべきではありません。 合法で特殊なプログラム形式はすべて翻訳されます。

  Translation flags and variables ·

オプション変数: tr_warn_meval

  デフォルト値: `compfile`

  - もし関数`meval`がコールされたら、警告を与えます。 もし`meval`がコールされたら、それは翻訳の中の問題を示します。

  Translation flags and variables ·

オプション変数: tr_warn_mode

  デフォルト値: `all`

  - 変数がそのモードに不適切な値を割り当てられた時、警告を与えます。

  Translation flags and variables ·

オプション変数: tr_warn_undeclared

  デフォルト値: `compile`

  - 未宣言変数についての警告をいつTTYに送るかを決めます。

  Translation flags and variables ·

オプション変数: tr_warn_undefined_variable

  デフォルト値: `all`

  - 未定義のグローバル変数が見られた時、警告を与えます。

  Translation flags and variables ·

関数: compile_file (filename)
関数: compile_file (filename, compiled_filename)
関数: compile_file (filename, compiled_filename, lisp_filename)

  MaximaファイルfilenameをLispに翻訳し、Lispコンパイラを実行し、 もし翻訳とコンパイルが成功したら、コンパイルされたコードをMaximaにロードします。

  `compile_file`は４つのファイル名のリストを返します: 元のMaximaファイル、Lisp翻訳、翻訳時ノート、コンパイルされたコード。 もしコンパイルが失敗したら、4番目の項目は`false`です。

  Lispコードがコンパイルされると(コンパイルされたコードをロードすることなしに)すぐに いくつかの宣言と定義は効力を発揮します。 これらは`:=`演算子で定義された関数、 `::=`演算子で定義されたマクロ、 `alias`, `declare`, `define_variable`, `mode_declare`, `infix`, `matchfix`, `nofix`, `postfix`, `prefix`, `compfile` を含みます。

  コンパイルされたコードがロードされるまで 割り当てと関数コールは評価されません。 特に、Maximaファイルの中で、 (`tr_numer`, など)翻訳フラグへの割り当ては翻訳時に効果を持ちません。

  filenameは`:lisp`文を含むことができません。

  `compile_file`は引数を評価します。

  Translation and compilation ·

関数: declare_translated (f_1, f_2, …)

  MaximaコードのファイルをLispに翻訳する時、 ファイルの中で見る関数が翻訳された関数としてコールされるか、コンパイルされた関数としてコールされるか、また、どの関数がMaxima関数か未定義なのか、翻訳器が知ることは重要です。 この宣言をファイルの先頭に置くことは、 たとえまだLisp関数値を持たないシンボルがコール時にそれを持つだろうが、 それを知らせます。 `fn`がLisp関数になるつもりであることを翻訳器が知らない時、 `(MFUNCTION-CALL fn arg1 arg2 ...)`が生成されます。

  Translation and compilation ·

Next: Debugging, Previous: Function Definition, Up: Top [Contents][Index]

## 37 Program Flow

Next: Garbage Collection, Previous: Program Flow, Up: Program Flow [Contents][Index]

### 37.1 Lisp and Maxima

MaximaはLispで書かれており、 Lisp関数や変数をMaximaからアクセスしたり、その逆が簡単にできます。 LispとMaximaのシンボルは命名の慣例で区別されます。 ドル記号`$`で始まるLispシンボルは、ドル記号なしのMaximaシンボルに対応します。 クエスチョンマーク`?`で始まるMaximaシンボルは、クエスチョンマークなしのLispシンボルに対応します。 例えば、Maximaシンボル`foo`はLispシンボル`$FOO`に対応し、 Maximaシンボル`?foo`はLispシンボル`FOO`に対応します。 `?foo`は、`?`と`foo`の間にスペースを入れずに書くことに注意してください。でないと、それは`describe ("foo")`に間違えられます。

Lispシンボルの中に、ハイフン`-`やアスタリスク`*`、他の特殊文字があれば、 Maximaのコードの中では、バックスラッシュ`\`でエスケープしないといけません。 例えば、Lispの識別子 `*foo-bar*`は、Maximaでは、`?\*foo\-bar\*`と書きます。

Maximaセッションの中で、Lispコードを実行できます。 特殊コマンド`:lisp`を使って、 （１つか複数のフォームを含む）Lispの一行を実行できます。例えば、

    (%i1) :lisp (foo $x $y)

は、Lisp関数`foo`をMaxima変数`x`, `y`を引数としてコールします。 `:lisp`構成子は 対話プロンプトや`batch`や`demo`によって処理されるファイルの中で使えますが、 `load`, `batchload`, `translate_file`, `compile_file`が 処理するファイルの中では使えません。

関数`to_lisp()`を実行すると、対話的なLispセッションが始まります。 `(to-maxima)`を入力すると、Lispセッションを終了してMaximaに戻ります。

Lispの関数や変数を、Maximaで通常の関数名、変数名(特殊な句読点のない名前)に見せるには、 Lispの名前をドル記号`$`で始めなければなりません。

Maximaでは、識別子の中の大文字、小文字が区別されます。 LispとMaximaの間の名前変換を決めるルールがあります。

1. 縦棒で囲まれていないLisp識別子は、Maximaの小文字の識別子に対応します。 Lisp識別子が大文字でも小文字でも混ざっていても無視されます。 例えば、Lispの`$foo`や`$FOO`、`$Foo`はすべて Maximaの`foo`に対応します。 でも、これはデフォルトで、 Lispリーダが`$foo`, `$FOO`, `$Foo`を Lispシンボル`$FOO`に変換するからです。
2. すべて大文字かすべて小文字で、縦棒で囲まれたLisp識別子は、大文字小文字を逆にしたMaximaの識別子に対応します。 例えば、Lispの`|$FOO|`, `|$foo|`はそれぞれ、Maximaの`foo`, `FOO`に対応します。
3. 大文字小文字が混ざっていて、縦棒で囲まれたLisp識別子は、そのままMaximaの識別子に対応します。 例えば、Lispの`|$Foo|`はMaximaの`Foo`に対応します。

`#$`Lispマクロを使うと、Maximaの式をLispコードの中で使うことができます。 `#$expr$`はMaximaの式exprと同値なLispの式に展開されます。

    (msetq $foo #$[x, y]$)

これは以下のように入力するのと同じ効果です。

    (%i1) foo: [x, y];

Lisp関数`displa`は、Maximaフォーマットで式を表示します。

    (%i1) :lisp #$[x, y, z]$
    ((MLIST SIMP) $X $Y $Z)
    (%i1) :lisp (displa '((MLIST SIMP) $X $Y $Z))
    [x, y, z]
    NIL

Maximaで定義された関数は、通常のLisp関数ではありません。 Lisp関数`mfuncall`は、Maxima関数をコールします。 例えば:

    (%i1) foo(x,y) := x*y$
    (%i2) :lisp (mfuncall '$foo 'a 'b)
    ((MTIMES SIMP) A B)

以下のLisp関数は、Maximaパッケージの中でシャドウされています。

       complement     continue      //
       float          functionp     array
       exp            listen        signum
       atan           asin          acos
       asinh          acosh         atanh
       tanh           cosh          sinh
       tan            break         gcd

Programming ·

Next: Introduction to Program Flow, Previous: Lisp and Maxima, Up: Program Flow [Contents][Index]

### 37.2 Garbage Collection

数式処理は膨大なゴミ(最終的には使われない一時的な、もしくは中間の結果)を生む傾向があり、 ゴミの効率的な取り扱いは、プログラムをうまく完了させるために非常に重要な場合があります。

(SunOS 4.0やBSDの幾つかを含む)mprotectシステムコールが利用可能なUNIXシステム 上でのGCLでは、階層化(stratified)ガーベッジコレクションが利用可能です。 これは、ガーベッジコレクションを最近書き込まれたページに限定します。 GCLドキュメントのALLOCATEやGBCを参照してください。 Lispレベルで(setq si::*notify-gbc* t)を実行すると、どの領域がより多くの空間を必要としているか決めるのに役立つでしょう。

Maximaを走らせる他のLispについては、 そのLispのGCの制御の仕方に関するドキュメントを調べてください。

Next: Functions and Variables for Program Flow, Previous: Garbage Collection, Up: Program Flow [Contents][Index]

### 37.3 Introduction to Program Flow

Maximaは、 `go`のようなもっとプリミティブな構成子はもちろん、 繰り返しのために`do`ループを提供します。

Previous: Introduction to Program Flow, Up: Program Flow [Contents][Index]

### 37.4 Functions and Variables for Program Flow

関数: backtrace ()
関数: backtrace (n)

  コールスタック、すなわち、 現在アクティブな関数をコールした関数のリスト、を印字します。

  `backtrace()`はコールスタック全体を印字します。

  `backtrace (n)`は、 現在アクティブな関数を含めて、n個の直近の関数を印字します。

  `backtrace`は、 (デバッグの文脈でだけでなく、) スクリプト、関数、対話プロンプトからコールすることができます。

  例:

  - `backtrace()`はコールスタック全体を印字します。

        (%i1) h(x) := g(x/7)$
        (%i2) g(x) := f(x-11)$
        (%i3) f(x) := e(x^2)$
        (%i4) e(x) := (backtrace(), 2*x + 13)$
        (%i5) h(10);
        #0: e(x=4489/49)
        #1: f(x=-67/7)
        #2: g(x=10/7)
        #3: h(x=10)
                                      9615
        (%o5)                         ----
                                       49

  - `backtrace (n)`は、 現在アクティブな関数を含めて、n個の直近の関数を印字します。

        (%i1) h(x) := (backtrace(1), g(x/7))$
        (%i2) g(x) := (backtrace(1), f(x-11))$
        (%i3) f(x) := (backtrace(1), e(x^2))$
        (%i4) e(x) := (backtrace(1), 2*x + 13)$
        (%i5) h(10);
        #0: h(x=10)
        #0: g(x=10/7)
        #0: f(x=-67/7)
        #0: e(x=4489/49)
                                      9615
        (%o5)                         ----
                                       49

  Debugging ·

特殊演算子: do

  `do`文は繰り返しを実行するために使われます。 その強力な一般性のために、 `do`文は２編で記述されます。 最初、通常の形式が (Fortran, Algol, PL/I, など)いくつかの他のプログラミング言語の中で使われるそれ との類似で与えられます; それから、他の特長が言及されます。

  この形式の、終了条件に関してだけ違う３つの別形があります。 それらは:

  - `for variable: initial_value step increment thru limit do body`
  - `for variable: initial_value step increment while condition do body`
  - `for variable: initial_value step increment unless condition do body`

  (代わりに、`step`は終了条件や範囲の後与えられるかもしれません。)

  initial_value, increment, limit, bodyは、 任意の式を取り得ます。 もし増分が1なら、 "`step 1`"は省略できます。

  `do`文の実行は、最初 initial_valueを variable (今後、制御変数と呼びます) に割り当てることによって処理されます。 そして: (1) もし制御変数が `thru`指定の範囲を越えたら、もしくは、 `unless`の条件が `true`なら、 もしくは、 `while`の条件が `false`なら、 `do`は終了します。 (2) bodyが評価されます。 (3) 増分が制御変数に足されます。 終了条件が満たされるまで、 いずれかが満たされる時 `do`が終了する複数の終了条件を与えることもできます。

  一般的に、 `thru`テストは、 もし incrementが非負なら、制御変数が limitよりも大きい時、 または、もし incrementが負なら、制御変数が limitよりも小さい時、 満たされます。 incrementと limitは、この不等式が決定できる限り、数値でない式も取り得ます。 しかしながら、 `do`文が入力された時 incrementが構文法的に負(例えば負の数)でない限り、 Maximaは、 `do`が実行される時、正と仮定します。 もし正でないなら、 `do`は適切に終了しないかもしれません。

  limit, increment, 終了条件は、ループを通して毎回評価されることに注意してください。 もしこれらのいずれかがおおくの計算を含み、 bodyの実行中すべてで変わらない結果をもたらすなら、 `do`に先立って変数をそれらの値に設定し、その変数を `do`形式の中で使うことはもっと効率的です。

  `do`文が通常返す値は、アトム `done`です。 しかしながら、 早い時点で `do`から抜けて任意の望みの値を与えるために、 関数 `return`を bodyの中で使うことができます。 しかしながら、 `block`の中で起こる `do`の中の `return`は、 `do`だけから抜けて、 `block`からは抜けないことに注意してください。 `do`から囲んでいる `block`に抜けるために、 `go`関数は使えないことにも注意してください。

  制御変数はいつも `do`にローカルです。

  従って、 `do`の外側の同じ名前を持つ変数の値に影響することなく、任意の変数が使えます。 制御変数は、 `do`が終了した後、バインドされていません。

      (%i1) for a:-3 thru 26 step 7 do display(a)$
                                   a = - 3

                                    a = 4

                                   a = 11

                                   a = 18

                                   a = 25

      (%i1) s: 0$
      (%i2) for i: 1 while i <= 10 do s: s+i;
      (%o2)                         done
      (%i3) s;
      (%o3)                          55

  条件`while i <= 10`は、 `unless i > 10`と、また、`thru 10`と同値であることに注意してください。

      (%i1) series: 1$
      (%i2) term: exp (sin (x))$
      (%i3) for p: 1 unless p > 7 do
                (term: diff (term, x)/p,
                 series: series + subst (x=0, term)*x^p)$
      (%i4) series;
                        7    6     5    4    2
                       x    x     x    x    x
      (%o4)            -- - --- - -- - -- + -- + x + 1
                       90   240   15   8    2

  以上は、`e^sin(x)`のTaylor級数の8項を与えます。

      (%i1) poly: 0$
      (%i2) for i: 1 thru 5 do
                for j: i step -1 thru 1 do
                    poly: poly + i*x^j$
      (%i3) poly;
                        5      4       3       2
      (%o3)          5 x  + 9 x  + 12 x  + 14 x  + 15 x
      (%i4) guess: -3.0$
      (%i5) for i: 1 thru 10 do
                (guess: subst (guess, x, 0.5*(x + 10/x)),
                 if abs (guess^2 - 10) < 0.00005 then return (guess));
      (%o5)                  - 3.162280701754386

  この例は、 Newton-Raphson反復を最大10回使って、 10の負の平方根を計算します。 もし収束基準が満たされないなら、 戻り値は`done`になります。

  いつもある量を制御変数に加える代わりに、 繰り返しそれぞれで量をある他の方法で換えたい時があるかもしれません。 この場合、 `step increment`の代わりに `next expression`を使うことができます。 これは、ループの間、 制御変数が毎回expressionの評価結果に設定されるようにします。

      (%i6) for count: 2 next 3*count thru 20 do display (count)$
                                  count = 2

                                  count = 6

                                 count = 18

  `for variable: value ...do...`の代わりとして、 構文法`for variable from value ...do...`が使えます。 これは、 `from value`を `step`や`next`値の後や終了条件の後に置くことを許します。 もし`from value`が省略されたら、 初期値として1が使われます。

  制御変数が実際には決して使われないような繰り返しを実行することに興味があることがあるかもしれません。 それゆえに、 貧弱な初期推測を使って5の平方根を計算する以下の例にあるように、 初期化と更新情報を省略して終了条件だけ与えることが許されます。

      (%i1) x: 1000$
      (%i2) thru 20 do x: 0.5*(x + 5.0/x)$
      (%i3) x;
      (%o3)                   2.23606797749979
      (%i4) sqrt(5), numer;
      (%o4)                   2.23606797749979

  もし望むなら、終了条件さえ完全に省略し、 無限にbodyを評価し続ける`do body`だけを与えることもできます。 この場合、関数`return`が`do`の実行を終了するのに使われるべきです。

      (%i1) newton (f, x):= ([y, df, dfx], df: diff (f ('x), 'x),
                do (y: ev(df), x: x - f(x)/y,
                    if abs (f (x)) < 5e-6 then return (x)))$
      (%i2) sqr (x) := x^2 - 5.0$
      (%i3) newton (sqr, 1000);
      (%o3)                   2.236068027062195

  (`return`が実行された時、 `x`の現在値を `do`の値として返そうとすることに注意してください。 `do`がブロックの最後の文なので、 `block`から抜けて、 `do`の値が `block`の値として返されます。)

  `do`のもう１つ別の形式がMaximaで利用可能です。構文法は:

      for variable in list end_tests do body

  listの要素は、 bodyの繰り返しのそれぞれで `variable`に連続的に割り当てられる任意の式です。 オプションの終了テストend_testsは、 `do`の実行を終了するのに使うことができます; そうでなければ、 listが使い果たされた時、または、 bodyの中で `return`が実行された時、 終了します。 (実際には、`list`は非アトムの任意の式を取り得えて、連続的な部分が取られます。)

      (%i1)  for f in [log, rho, atan] do ldisp(f(1))$
      (%t1)                                  0
      (%t2)                                rho(1)
                                           %pi
      (%t3)                                 ---
                                            4
      (%i4) ev(%t3,numer);
      (%o4)                             0.78539816

  Programming ·

関数: errcatch (expr_1, …, expr_n)

  expr_1, …, expr_nを１つずつ評価し、 もしエラーが起こらないなら、`[expr_n]` (リスト)を返します。 もしいずれかの引数の評価中にエラーが起こったら、 `errcatch` はエラーが伝搬することを抑制し、 引数をこれ以上評価せずに空のリスト`[]`を返します。

  `errcatch`は もしエラーがチャッチされないなら`batch`を終了させるエラーが起こるかもしれないと疑うような `batch`ファイルで役立ちます。

  Programming ·

関数: error (expr_1, ..., expr_n)
システム変数: error

  expr_1, ..., expr_nを評価して印字します。 そして、エラーがあれば、トップレベルMaximaか直近の`errcatch`に戻るようにします。

  変数`error`はエラーを記述するリストに設定されます。 `error`の最初の要素はフォーマット文字列です。 引数expr_1, ..., expr_nの中の文字列すべてを結合したものです。 残りの要素は文字列でない引数の値です。

  `errormsg()`は`error`をフォーマットし印字します。 これは直近のエラーメッセージを効果的に再印字します。

  Programming ·

オプション変数: error_size

  デフォルト値: 10

  `error_size`は、 現れる式のサイズに従って、エラーメッセージを変更します。 もし式のサイズが、Lisp関数`ERROR-SIZE`によって決定されるように） `error_size`より大きいなら、 式は、メッセージの中で、シンボルで置き換えられ、 シンボルは式に割り当てられます。 シンボルはリスト`error_syms`から取られます。

  そうでなければ、式は`error_size`より小さく、 メッセージの中に式が表示されます。

  `error`と`error_syms`も参照してください。

  例:

  `U`のサイズは、`ERROR-SIZE`で決められるように、24です。

      (%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$

      (%i2) error_size: 20$

      (%i3) error ("Example expression is", U);

      Example expression is errexp1
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i4) errexp1;
                                  E
                                 D
                                C   + B + A
      (%o4)                    --------------
                               cos(X - 1) + 1
      (%i5) error_size: 30$

      (%i6) error ("Example expression is", U);

                               E
                              D
                             C   + B + A
      Example expression is --------------
                            cos(X - 1) + 1
       -- an error.  Quitting.  To debug this try debugmode(true);

  Debugging ·Display flags and variables ·

オプション変数: error_syms

  デフォルト値: `[errexp1, errexp2, errexp3]`

  エラーメッセージの中で、 `error_size`より大きな式はシンボルで置き換えられ、 シンボルは式に設定されます。 シンボルはリスト`error_syms`から取られます。 最初の大きすぎる式は、`error_syms[1]`で置き換えられ、 ２番目は、`error_syms[2]`で置き換えられ、などなど。

  もし大きすぎる式が`error_syms`の要素よりもあれば、 シンボルは自動的に構成されます。 n番目のシンボルは`concat ('errexp, n)`と同値です。

  `error`と`error_size`も参照してください。

  Debugging ·Display flags and variables ·

関数: errormsg ()

  直近のエラーメッセージを再印字します。 変数`error`はメッセージを保持し、 `errormsg`はそれをフォーマットし印字します。

  Programming ·

オプション変数: errormsg

  デフォルト値: `true`

  `false`の時、エラーメッセージの出力は抑制されます。

  オプション変数`errormsg`は ブロックの中でローカル値に設定することはできません。 `errormsg`のグローバル値が常に存在します。

      (%i1) errormsg;
      (%o1)                                true
      (%i2) sin(a,b);
      Wrong number of arguments to sin
       -- an error. To debug this try: debugmode(true);
      (%i3) errormsg:false;
      (%o3)                                false
      (%i4) sin(a,b);

       -- an error. To debug this try: debugmode(true);

  オプション変数`errormsg`はブロックの中でローカル値に設定できません。

      (%i1) f(bool):=block([errormsg:bool],
                           print ("value of errormsg is",errormsg))$
      (%i2) errormsg:true;
      (%o2)                                true
      (%i3) f(false);
      value of errormsg is true
      (%o3)                                true
      (%i4) errormsg:false;
      (%o4)                                false
      (%i5) f(true);
      value of errormsg is false
      (%o5)                                false

  Programming ·

特殊演算子: for

  繰り返しで使われます。 Maximaの繰り返し機能の記述に関しては、`do`を参照してください。

  Programming ·

関数: go (tag)

  制御を `go`の引数でタグ付けされたブロックの文に移すために `block`内部で使われます。 文をタグ付けするには、 その文の前に、 アトムの引数を `block`の中の別の文として 先行させてください。 例えば:

      block ([x], x:1, loop, x+1, ..., go(loop), ...)

  `go`の引数は、同じ`block`の中に現れるタグの名前でなければいけません。 `go`を含む`block`以外の`block`の中のタグに移るために、 `go`を使うことはできません。

  Programming ·

特殊演算子: if

  条件評価を表します。 `if`式の様々な形が認識されます。

  `if cond_1 then expr_1 else expr_0` は、 もしcond_1が`true`評価されたらexpr_1に*評*価*され、 そうでなければ式はexpr_0に評価されます。

  コマンド `if cond_1 then expr_1 elseif cond_2 then expr_2 elseif ... else expr_0`は、 もしcond_kが`true`、かつ、先行する条件がすべて`false`なら、 expr_kに評価されます。 もし条件のいずれも`true`でないなら、式は`expr_0`に評価されます。

  もし`else`がないなら、 最後に`else false`が仮定されます。 すなわち、コマンド `if cond_1 then expr_1`は、 `if cond_1 then expr_1 else false`と同値で、 コマンド `if cond_1 then expr_1 elseif ... elseif cond_n then expr_n`は、 `if cond_1 then expr_1 elseif ... elseif cond_n then expr_n else false`と同値です。

  選択肢expr_0, …, expr_nは、任意のMaxima式を取り得ます。 入れ子の`if`式もあり得ます。 選択肢は、 対応する条件が`true`でない限り、 整理も評価もされません。

  条件cond_1, ..., cond_nは、潜在的に、また、実際に `true`か`false`に評価される式です。 条件が実際には`true`にも`false`にも評価されない時、 `if`の振る舞いはグローバルフラグ`prederror`で決定されます。 `prederror`が`true`の時、 もし評価された条件のいずれかが`true`にも`false`にもならなかったら 、エラーになります。 そうでなければ、`true`にも`false`にも評価されない条件が受け入れられ、 結果は条件式になります。

  条件は以下のように、他の要素間の関係演算子と論理演算子からなります。

      演算                 シンボル     タイプ

      小なり                <           関係 中置
      以下                  <=          関係 中置
      等号 (構文法的)        =           関係 中置
      不等号 (構文法的)      #           関係 中置
      等号 (値)             equal       関係 関数
      不等号 (値)           notequal    関係 関数
      以上                  >=          関係 中置
      大なり                >           関係 中置
      かつ                  and         論理 中置
      または                or          論理 中置
      否定                  not         論理 前置

  Programming ·Predicate functions ·

関数: map (f, expr_1, …, expr_n)

  `map`は、主演算子（訳注：内部表現の最上位階層のリストに対応する演算子）は 式expr_1, ..., expr_nのそれと同じ演算子を使い、 そのサブパーツは、引数式の対応するサブパーツにfを適用した結果である式を返します。 fはn個の引数の関数名か、n個の引数のラムダ形式です。 (訳注：また、expr_1, …, expr_nは内部表現に階層リスト構造を持つ式です。）

  `maperror` - もし`maperror`が`fals`eなら、 マッピング関数のすべては、(1)もしexpr_iのすべてが同じ長さでなければ、 最も短いexpr_iが完了した時点で停止し、 (2)もしexpr_iが同じタイプのオブジェクトでなければ、 fをリスト[expr_1, expr_2, ...]に適用します。 もし`maperror`が`true`なら、上の２つの場合、エラーメッセージを出力します。

  この関数の用法の１つは、ある関数（例えば、`partfrac`)を非常に長い式に適用する際、 計算の間にリスト保存領域を枯渇させるため式全体に適応するのが不可能な場合に、 それぞれの項に関数をマップすることです。

      (%i1) map(f,x+a*y+b*z);
      (%o1)                        f(b z) + f(a y) + f(x)
      (%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
                                 1       1        1
      (%o2)                     ----- - ----- + -------- + x
                               x + 2   x + 1          2
                                               (x + 1)
      (%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
                                            1
      (%o3)                            y + ----- + 1
                                          x + 1
      (%i4) map("=",[a,b],[-0.5,3]);
      (%o4)                          [a = - 0.5, b = 3]

  Function application ·

関数: mapatom (expr)

  exprがマップルーチンでアトムとして扱われる時だけ`true`を返します。 "Mapatoms"はアトム、(有理数を含む)数、添字付き変数です。

  Predicate functions ·

オプション変数: maperror

  デフォルト値: `true`

  `maperror`が`false`の時は、 マップ関数すべてに、以下の例のようにさせます。

      map (f, expr_1, expr_2, …)

  に対しては、 (1) もしexpr_iのすべてが同じ長さでないなら、 最も短いexpr_iの終わりまで完了した時、停止するようにさせ、 (2) もしexpr_iすべてが同じタイプのオブジェクトでないなら、 fを[expr_1, expr_2, ...]に適用するようにさせます。

  もし`maperror`が`true`なら、 上の２つの例に関して、エラーメッセージが表示されます。

  Function application ·

オプション変数: mapprint

  デフォルト値: `true`

  `mapprint`が`true`の時、 `map`, `mapl`, `fullmap`からの様々な情報メッセージが 一定の状況で生成されます。 これらは `map`が`apply`を使ったり、`map`が 最短のリストで切り詰めているような状況を含みます。

  もし`mapprint`が`false`なら、これらのメッセージは抑制されます

  Function application ·

関数: maplist (f, expr_1, …, expr_n)

  式expr_1, …, expr_nのパーツにfを適用した結果のリストを返します。 fは、関数名かラムダ式です。

  `maplist`は`map (f, expr_1, ..., expr_n)`とは違います。 mapは主演算子がexpr_iと同じ式を返します。 (整理と`map`が`apply`を行う場合は例外です。)

  Function application ·

オプション変数: prederror

  デフォルト値: `false`

  `prederror`が`true`の時、 `if`文の述語論理か`is`関数が `true`か`false`に評価されるのに失敗した時はいつでも エラーメッセージが表示されます。

  もし`false`なら、この場合，代わりに`unknown`が返されます。 `prederror: false`モードは翻訳コードではサポートされません; しかしながら、`maybe`は翻訳コードでサポートされます。

  `is`と`maybe`も参照してください。

  Programming ·Predicate functions ·

関数: return (value)

  引数を連れて、陽にブロックから抜けるために使われます。 もっと情報を知るには、`block`も参照してください。

  Programming ·

関数: scanmap (f, expr)
関数: scanmap (f, expr, bottomup)

  トップダウン法で、fをexprに再帰的に適用します。 完全な因数分解が望まれる時、これは最も役に立ちます。 例えば:

      (%i1) exp:(a^2+2*a+1)*y + x^2$
      (%i2) scanmap(factor,exp);
                                          2      2
      (%o2)                         (a + 1)  y + x

  Note the way in which `scanmap`が与えられた関数`factor`を exprの構成部分式に適用する方法に注意してください; もし exprの別の形がscanmapに適用されるなら、結果は異なるかもしれません。 従って、 `scanmap`が `exp`の展開形に適用される時、 `%o2`が再現されません:

      (%i3) scanmap(factor,expand(exp));
                                 2                  2
      (%o3)                      a  y + 2 a y + y + x

  `scanmap`が 与えられた関数を指数関数を含む部分式すべてに再帰的に適用する方法の別の例です:

      (%i4) expr : u*v^(a*x+b) + c$
      (%i5) scanmap('f, expr);
                          f(f(f(a) f(x)) + f(b))
      (%o5) f(f(f(u) f(f(v)                      )) + f(c))

  `scanmap (f, expr, bottomup)`は、 ボトムアップ法で fを exprに適用します。 例えば、未定義`f`に関して、

      scanmap(f,a*x+b) ->
         f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b))
      scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b)
          -> f(f(a)*f(x))+f(b) ->
           f(f(f(a)*f(x))+f(b))

  この場合、両方の方法で同じ答えを得ます。

  Function application ·

関数: throw (expr)

  exprを評価し、 直近の`catch`に値を投げ戻します。 `throw`は、 `catch`と一緒に、非ローカルリターンメカニズムとして使われます。

  Programming ·

特殊演算子: while
特殊演算子: unless

  `do`を参照してください。

  Programming ·

関数: outermap (f, a_1, …, a_n)

  関数fを 外積a_1掛けるa_2 ... 掛けるa_nの要素のそれぞれに適用します。

  fは n個の引数の関数の名前か、 n個の引数のラムダ式 です。

  それぞれの引数a_kは、 リストか、入れ子のリストか、行列か、他の任意の種類の式を取り得ます。

  `outermap`戻り値は、入れ子の構造です。 xを戻り値とします。 すると、 xは最初のリストか入れ子のリストか行列引数と同じ構造を持ち、 `x[i_1]...[i_m]`は、 二番目のリストか入れ子のリストか行列引数と同じ構造を持ち、 `x[i_1]...[i_m][j_1]...[j_n]`は、 三番目のリストか入れ子のリストか行列引数と同じ構造を持ち、 以下同様。 ここで、m, n, ...は、 引数それぞれの要素 をアクセスするために要求される インデックスの数(リストには１つ、行列には２つ、入れ子のリストには１つ以上)です。 リストや行列でない引数は戻り値の構造に影響を与えません。

  Note that the effect of `outermap`の効果は fを `cartesian_product`によって返される 外積の要素のそれぞれに適用することのそれと違います。

  `outermap`は、戻り値で引数の構造を保ちますが、 `cartesian_product`は違います。

  `outermap`は引数を評価します。

  `map`, `maplist`, `apply`も参照してください。

  例:

  `outermap`の初等的な例。 よりはっきり引数の組み合わせを示すために、 `F`は未定義のままです。

      (%i1) outermap(F, [a, b, c], [1, 2, 3]);
      (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
                                           [F(c, 1), F(c, 2), F(c, 3)]]
      (%i2) outermap(F, matrix([a, b],[c, d]), matrix([1, 2],[3, 4]));
               [ [ F(a, 1)  F(a, 2) ]  [ F(b, 1)  F(b, 2) ] ]
               [ [                  ]  [                  ] ]
               [ [ F(a, 3)  F(a, 4) ]  [ F(b, 3)  F(b, 4) ] ]
      (%o2)    [                                            ]
               [ [ F(c, 1)  F(c, 2) ]  [ F(d, 1)  F(d, 2) ] ]
               [ [                  ]  [                  ] ]
               [ [ F(c, 3)  F(c, 4) ]  [ F(d, 3)  F(d, 4) ] ]
      (%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
             [ F(a, x, 1)  F(a, x, 2) ]  [ F(b, x, 1)  F(b, x, 2) ]
      (%o3) [[                        ], [                        ]]
             [ F(a, x, 3)  F(a, x, 4) ]  [ F(b, x, 3)  F(b, x, 4) ]
      (%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
             [ [ F(a, 1, x) ]  [ F(a, 2, x) ] ]
      (%o4) [[ [            ]  [            ] ],
             [ [ F(a, 1, y) ]  [ F(a, 2, y) ] ]
                                    [ [ F(b, 1, x) ]  [ F(b, 2, x) ] ]
                                    [ [            ]  [            ] ]]
                                    [ [ F(b, 1, y) ]  [ F(b, 2, y) ] ]
      (%i5) outermap ("+", [a, b, c], [1, 2, 3]);
      (%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3],
                                                 [c + 1, c + 2, c + 3]]

  `outermap`の戻り値のより密な検査。 最初の、二番目の、三番目の引数は、それぞれ、行列、リスト、行列です。 戻り値は行列です。 その行列の要素それぞれはリストで、 それぞれのリストの要素それぞれは行列です。

      (%i1) arg_1 :  matrix ([a, b], [c, d]);
                                  [ a  b ]
      (%o1)                       [      ]
                                  [ c  d ]
      (%i2) arg_2 : [11, 22];
      (%o2)                       [11, 22]
      (%i3) arg_3 : matrix ([xx, yy]);
      (%o3)                      [ xx  yy ]
      (%i4) xx_0 : outermap(lambda([x, y, z], x / y + z), arg_1,
                                                         arg_2, arg_3);
                     [  [      a        a  ]  [      a        a  ]  ]
                     [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                     [  [      11       11 ]  [      22       22 ]  ]
      (%o4)  Col 1 = [                                              ]
                     [  [      c        c  ]  [      c        c  ]  ]
                     [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                     [  [      11       11 ]  [      22       22 ]  ]

                       [  [      b        b  ]  [      b        b  ]  ]
                       [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                       [  [      11       11 ]  [      22       22 ]  ]
               Col 2 = [                                              ]
                       [  [      d        d  ]  [      d        d  ]  ]
                       [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                       [  [      11       11 ]  [      22       22 ]  ]

      (%i5) xx_1 : xx_0 [1][1];
                 [      a        a  ]  [      a        a  ]
      (%o5)     [[ xx + --  yy + -- ], [ xx + --  yy + -- ]]
                 [      11       11 ]  [      22       22 ]
      (%i6) xx_2 : xx_0 [1][1] [1];
                            [      a        a  ]
      (%o6)                 [ xx + --  yy + -- ]
                            [      11       11 ]
      (%i7) xx_3 : xx_0 [1][1] [1] [1][1];
                                        a
      (%o7)                        xx + --
                                        11
      (%i8) [op (arg_1), op (arg_2), op (arg_3)];
      (%o8)                  [matrix, [, matrix]
      (%i9) [op (xx_0), op (xx_1), op (xx_2)];
      (%o9)                  [matrix, [, matrix]

  `outermap`は、戻り値の中で引数の構造を保持します。 `cartesian_product`は保持しません。

      (%i1) outermap (F, [a, b, c], [1, 2, 3]);
      (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
                                           [F(c, 1), F(c, 2), F(c, 3)]]
      (%i2) setify (flatten (%));
      (%o2) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
                                             F(c, 1), F(c, 2), F(c, 3)}
      (%i3) map(lambda([L], apply(F, L)),
                           cartesian_product({a, b, c}, {1, 2, 3}));
      (%o3) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
                                             F(c, 1), F(c, 2), F(c, 3)}
      (%i4) is (equal (%, %th (2)));
      (%o4)                         true

  Function application ·

Next: asympa, Previous: Program Flow, Up: Top [Contents][Index]

## 38 Debugging

Next: Keyword Commands, Up: Debugging [Contents][Index]

### 38.1 Source Level Debugging

Maximaは、組み込みのソースレベルデバッガを持っています。 ユーザーは、関数にブレイクポイントを設定でき、 そこから行毎に実行することができます。 そのレベルでバインドされた変数と一緒にコールスタックを検査することができます。

コマンド`:help`または`:h`は、 デバッガーコマンドのリストを示します。 (一般的に、 もし略字がただ１つなら、コマンドは略せます。 もしただ１つでないなら、選択肢がリストされます。) デバッガー内では、 変数と式を検査し、定義し、操作するために、ユーザーは任意の通常のMaxima関数も使うことができます。

Maximaプロンプトで、 `:br`コマンドで ブレイクポイントが設定できます。 デバッガー内では、 ユーザーは、 `:n` (“next”)コマンドを使って１度に１行進むことができます。 `:bt` (“backtrace”)コマンドは、スタックフレームのリストを示します。 `:r` (“resume”)コマンドは、デバッガーから抜けて、実行を続けます。 以下の例で、これらのコマンドを例示します。

    (%i1) load ("/tmp/foobar.mac");

    (%o1)                           /tmp/foobar.mac

    (%i2) :br foo
    Turning on debugging debugmode(true)
    Bkpt 0 for foo (in /tmp/foobar.mac line 1)

    (%i2) bar (2,3);
    Bkpt 0:(foobar.mac 1)
    /tmp/foobar.mac:1::

    (dbm:1) :bt                        <-- :bt typed here gives a backtrace
    #0: foo(y=5)(foobar.mac line 1)
    #1: bar(x=2,y=3)(foobar.mac line 9)

    (dbm:1) :n                         <-- Here type :n to advance line
    (foobar.mac 2)
    /tmp/foobar.mac:2::

    (dbm:1) :n                         <-- Here type :n to advance line
    (foobar.mac 3)
    /tmp/foobar.mac:3::

    (dbm:1) u;                         <-- Investigate value of u
    28

    (dbm:1) u: 33;                     <-- Change u to be 33
    33

    (dbm:1) :r                         <-- Type :r to resume the computation

    (%o2)                                1094

ファイル`/tmp/foobar.mac`は以下の通りです:

    foo(y) := block ([u:y^2],
      u: u+3,
      u: u^2,
      u);

    bar(x,y) := (
      x: x+2,
      y: y+2,
      x: foo(y),
      x+y);

EMACSを通してのデバッガーの使用

もしユーザーがシェルウィンドウ(dblシェル)で、GNU emacsの下でコードを走らせているか、 グラフィカルならインターフェイスバージョンXmaximaを走らせているなら、 もしブレイクポイントで停止させたら、 ウィンドウの他の半面に表示されるソースファイルの中に、 赤でハイライトされたか、右行を示す小さな矢印で 現在位置を見るでしょう。 M-n (Alt-n)をタイプすることで、一度に一行進めることができます。

Emacsの下では、 `dbl`シェルの中で走らせなければいけません。 `dbl`シェルは、elispディレクトリの中に `dbl.el`ファイルを要求します。 elispファイルをインストールしたか、Maxima elispディレクトリをパスに足したかを確認してください: 例えば、以下を `.emacs`ファイルか`site-init.el`に足してください。

    (setq load-path (cons "/usr/share/maxima/5.9.1/emacs" load-path))
    (autoload 'dbl "dbl")

すると、emacsの中で、

    M-x dbl

は、例えば、Maxima, gcl, gbbなどのプログラムを走らせることができるシェルウィンドウを開始するでしょう。 このシェルウィンドウはソースレベルデバッグや 他のウィンドウのソースコードの表示についても知っています。

ユーザーは、 `C-x space`をタイプすることで ファイルのある行に ブレイクポイントを設定できます。 これは、カーソルがどの関数の中かがわかり、 カーソルが示すその関数のどの行かわかります。 もしカーソルが、例えば、`foo`の行2なら、 `foo`を二番目の行でブレイクするために、 他のウィンドウの中で、コマンド“`:br foo 2`”を挿入します。 これをイネーブルにするには、 ユーザーは ファイル`foobar.mac`が訪れるウィンドウの中で maxima-mode.elを機能させなければいけません。 `Alt-Control-x`をタイプすることで 関数をMaximaに評価ような、 そのファイルウィンドウで利用可能な追加のコマンドがあります。

Debugging ·

Next: Functions and Variables for Debugging, Previous: Source Level Debugging, Up: Debugging [Contents][Index]

### 38.2 Keyword Commands

キーワードコマンドは、Maxima式として解釈(interpret)されない特殊キーワードです。 キーワードコマンドは、ブレイクプロンプトではできませんが、Maximaプロンプトやデバッガープロンプトで入力できます。 キーワードコマンドはコロン’`:`’で始まります。 例えば、Lisp形を評価するには、 may type `:lisp`の後に評価される形式をタイプします。

    (%i1) :lisp (+ 2 3)
    5

取られる引数の数は、特定のコマンドに依存します。 コマンド全体をタイプする必要はありません、ただブレイクキーワードの中で唯一であれば十分です。 例えば、`:br`は `:break`のために十分です。

キーワードコマンドは以下にリストされます。

`:break F n`

  関数`F`の中に関数の頭から行オフセット`n`で ブレイクポイントを設定します。 もし`F`が文字列として与えられたら、 ファイルと仮定され、`n`はファイルの頭からのオフセットです。 オフセットはオプションです。 もし与えられないなら、ゼロと仮定されます。 (関数かファイルの最初の行。)

`:bt`

  スタックフレームのバックトレイスを印字します。

`:continue`

  計算を継続します。

`:delete`

  指定されたブレイクポイントを、もし指定されないならすべてのブレイクポイントを削除します。

`:disable`

  指定されたブレイクポイントを、もし指定されないならすべてのブレイクポイントをディセーブルにします。

`:enable`

  指定されたブレイクポイントを、もし指定されないならすべてのブレイクポイントをイネーブルにします。

`:frame n`

  スタックフレーム`n`を、もし指定されないなら現在のフレームを印字します。

`:help`

  デバッガーコマンドに関するヘルプを印字します。 もし指定されないなら、コマンドすべてのヘルプを印字します。

`:info`

  項目についての情報を印字します。

`:lisp some-form`

  `some-form`をLisp形式として評価します。

`:lisp-quiet some-form`

  Lisp形式`some-form`を出力せずに評価します。

`:next`

  `:next`は関数コールをステップオーバーする点を除いて、 `:step`のようなものです。

`:quit`

  計算を完了せずに、 現在のデバッガーレベルから抜けます。

`:resume`

  計算を継続します。

`:step`

  新しいソー行に至るまで計算を継続します。

`:top`

  計算を完了せずに(任意のデバッガーレベルから)Maximaプロンプトに戻ります。

Debugging ·

Previous: Keyword Commands, Up: Debugging [Contents][Index]

### 38.3 Functions and Variables for Debugging

オプション変数: debugmode

  デフォルト値: `false`

  もし`debugmode`が `true`なら、 Maximaのエラーが起こった時Maximaはデバッガーを開始します。 ユーザーはコールバックを検査したり、ブレイクポイントを設定したり、Maximaコードをステップ実行したりなど コマンドを入力することができます。 デバッガーコマンドのリストに関しては、 `debugging`を参照してください。

  `debugmode`をイネーブルにしても、Lispのエラーは捕らえられません。

  Debugging ·Global flags ·

オプション変数: refcheck

  デフォルト値: `false`

  `refcheck`が`true`の時、 Maximaは 計算の中で、バイドされた変数が最初に使われる度にメッセージを印字します。

  Evaluation ·Console interaction ·Global flags ·

オプション変数: setcheck

  デフォルト値: `false`

  もし`setcheck`が(添字付きでもよい)変数のリストに設定されているなら、 Maximaは 変数またはそれらの添字付き出現が通常の割り当て演算子`:`、`::`割り当て演算子、 または関数引数バインドでバインドされた時 (しかし関数割り当て`:=`やマクロ割り当て`::=`演算子でバインドされた時以外) はいつでも、 メッセージを印字します。 メッセージは変数名とバインドされた値から構成されます。

  `setcheck`は、 `all`または`true`に設定することができ、 それによって、すべての変数を含みます。

  `setcheck`の新しい要素のそれぞれは、 チェックする変数の新しいリストを確立し、 以前`setcheck`に割り当てられたいかなる変数も忘れられます。

  もし自身以外の何かに評価されるなら、 `setcheck`に割り当てられた名前はクォートしなければいけません。 例えば、もし`x`, `y`, `z`が既にバインドされているなら、 チェックする変数のリストに置くには、

      setcheck: ['x, 'y, 'z]$

  をタイプしてください。

  `setcheck`リスト上の変数が、例えば、`X: 'X`のように、 それ自身に割り当てられた時は、なにも印字されません。

  Console interaction ·Global flags ·

オプション変数: setcheckbreak

  デフォルト値: `false`

  `setcheckbreak`が`true`の時、 `setcheck`リスト上の変数が新しい値を割り当てられた時はいつでも Maximaはブレイクプロンプトを出します。 ブレイクは、割り当てが実行される前に起こります。 この時点で、`setval`が変数が割り当てられようとしている値を保持します。 ゆえに、 `setval`に割り当てることで、違う値を割り当てることができます。

  `setcheck`と`setval`も参照してください。

  Console interaction ·Global flags ·

システム変数: setval

  `setcheckbreak`が起こった時、変数が設定されようとしている値を保持します。 ゆえに、 `setval`に割り当てることで、違う値を割り当てることができます。

  `setcheck`と`setcheckbreak`も参照してください。

  Console interaction ·Global variables ·

関数: timer (f_1, …, f_n)
関数: timer (all)
関数: timer ()

  `timer`は、 タイミング統計が収集される関数のリストに与えられた関数f_1, …, f_n それぞれを入れます。 `timer(f)$ timer(g)$`は、リストに`f`を入れ、その後`g`を入れます; リストはあるコールから次へ累積されます。

  `timer(all)`は、計測される関数のリストに (グローバル変数`functions`で指名されたように) ユーザー定義関数すべてを入れます。

  引数なしでは、 `timer`は計測される関数のリストを返します。

  Maximaは、計測される関数のリストに関して、 関数それぞれを実行するのに費やされる時間を記録します。 `timer_info`は、タイミング統計を返します。 関数コール毎に経過した平均時間、コール回数、総経過時間を含みます。 `untimer`は、計測される関数のリストから関数を削除します。

  `timer`は引数をクォートします。 `f(x) := x^2$ g:f$ timer(g)$`は、`f`をタイマーリストに入れません。

  もし`trace(f)`が有効なら、`timer(f)`は有効ではないです; `trace`と`timer`が同時に有効にはできません。

  `timer_devalue`も参照してください。

  Debugging ·

関数: untimer (f_1, …, f_n)
関数: untimer ()

  `untimer`はタイマーリストから 与えられた関数f_1, …, f_nそれぞれを削除します。

  引数なしの時、 `untimer`は、現在、タイマーリスト上の関数すべてを削除します。

  `untimer (f)`が実行された後、 `timer_info()` (引数なし)は、 現在タイマーリスト上にない関数についての情報を返しませんけれども、 `timer_info (f)`は、まだ以前に集計されたタイミング統計を返します。 `timer (f)`は、 タイミング統計すべてをゼロに再設定し、 `f`をタイマーリストに再び入れます。

  Debugging ·

オプション変数: timer_devalue

  デフォルト値: `false`

  `timer_devalue`が`true`の時、 Maximaは、計られる関数から 他の計測される関数で費やされた時間を引きます。 そうでなければ、関数それぞれについて報告された時間は、 他の関数で計測される時間を含みます。 計測されない関数で費やされた時間は、総時間から引かれないことに注意してください。

  `timer`と`timer_info`も参照してください。

  Debugging ·Global flags ·

関数: timer_info (f_1, ..., f_n)
関数: timer_info ()

  与えられた関数f_1, ..., f_n, `timer_info`は、 関数それぞれのタイミング情報を含む 行列を返します。 引数なしでは、 `timer_info`は、 現在タイマーリスト上の関数すべてについての タイミング情報を返します。 The matrix returned by `timer_info`が返す行列は、関数名、 関数コール毎の時間、関数コールの回数、総時間、 `gctime` を含みます。 `gctime`は、元のMacymaの「ガーベッジコレクション時間」を意味しましたが、 今はいつもゼロです。

  `timer_info`が戻り値を構成するデータは、 `get`関数によっても得られることができます:

      get(f, 'calls);  get(f, 'runtime);  get(f, 'gctime);

  `timer`も参照してください。

  Debugging ·

関数: trace (f_1, …, f_n)
関数: trace (all)
関数: trace ()

  関数 f_1, …, f_nが与えられたとして、 `trace`は、Maximaに、 それらの関数がコールされたときはいつでも デバッグ情報を印字するよう指示します。 `trace(f)$ trace(g)$`は、トレースする関数のリストに `f`を、それから`g`を入れます; リストは１回のコールから次へ累積します。

  `trace(all)`は、(グローバル変数`functions`で指名されたように) ユーザー定義関数すべてをトレースする関数のリストに入れます。

  引数なしでは、 `trace`は、現在とレースする関数すべてのリストを返します。

  `untrace`関数はトレースをディセーブルします。 `trace_options`も参照してください。

  `trace`は引数をクォートします。 例えば、 `f(x) := x^2$ g:f$ trace(g)$`は、 `f`をトレースリストに入れません。

  関数が再定義された時、 タイマーリストから削除されます。 例えば、 `timer(f)$ f(x) := x^2$`の後、 関数`f`はもはやタイマーリストにありません。

  もし`timer (f)`が有効なら、 `trace (f)`は有効ではありません; `trace`と`timer`は、同じ関数で同時には有効にできません。

  Debugging ·

関数: trace_options (f, option_1, …, option_n)
関数: trace_options (f)

  関数fについてトレースオプションを設定します。 いかなる以前のオプションも破棄されます。 `trace_options (f, ...)`は、 もし(`trace_options`の前でも後でも). `trace (f)`もコールされないなら、 有効になりません。

  `trace_options (f)`は、 オプションすべてをデフォルト値に再設定します。

  オプションキーワードは以下の通りです:

  - `noprint` 関数の入り口と出口でメッセージを印字しません。
  - `break` 関数に入る前と関数を抜けた後、ブレイクポイントを置きます。 `break`を参照してください。
  - `lisp_print` 引数を表示し、Lispオブジェクトとして値を返します。
  - `info` 関数の入れ口と出口で`-> true`を印字します
  - `errorcatch` エラーをチャッチし、 エラーを知らせるためのオプションに応じて、 関数コールを再試行するか、戻り値を指定します。

  トレースオプションは、２つの形式で指定されます。 オプションキーワード単体の存在は、 オプションを無条件に実行します。 (`foo: true`か似た形式を指定することでは、 オプションfooは実行されないことに注意してください; キーワードはクォートする必要はないことにも注意してください。) オプションキーワードを述語論理関数で指定することは、 オプションを述語論理上の条件付きにします。

  述語論理関数の引数リストは、いつも `[level, direction, function, item]`です。 ここで、`level`は関数の再帰レベルで、 `direction`は`enter`か`exit`、`function`は、 関数名、 name of the function, and `item`は(入るときの)引数リストか(出るときの)戻り値です。

  以下は無条件とレースオプションの例です:

      (%i1) ff(n) := if equal(n, 0) then 1 else n * ff(n - 1)$

      (%i2) trace (ff)$

      (%i3) trace_options (ff, lisp_print, break)$

      (%i4) ff(3);

  以下は述語論理上の条件の`break`オプションを持つ同じ関数です:

      (%i5) trace_options (ff, break(pp))$

      (%i6) pp (level, direction, function, item) := block (print (item),
          return (function = 'ff and level = 3 and direction = exit))$

      (%i7) ff(6);

  Debugging ·

関数: untrace (f_1, …, f_n)
関数: untrace ()

  `untrace`は、 与えられた関数f_1, …, f_nについて、 `trace`関数でイネーブルされたトレースをディセーブルします。 引数なしでは、`untrace`は関数すべてのトレースをディセーブルします。

  `untrace`はトレースをディセーブルした関数のリストを返します。

  Debugging ·

Next: augmented_lagrangian, Previous: Debugging, Up: Top [Contents][Index]

## 39 asympa

Next: Functions and variables for asympa, Previous: asympa, Up: asympa [Contents][Index]

### 39.1 Introduction to asympa

関数: asympa

  `asympa`は漸近解析パッケージです。 パッケージは、 複雑性解析と数値解析で広く使われている“ビッグO”と“リトルo”関数を含む、 漸近解析のための式整理関数を含みます。

  `load ("asympa")`はこのパッケージをロードします。

  Package asympa ·

Previous: Introduction to asympa, Up: asympa [Contents][Index]

### 39.2 Functions and variables for asympa

Next: Bernstein, Previous: asympa, Up: Top [Contents][Index]

## 40 augmented_lagrangian

Previous: augmented_lagrangian, Up: augmented_lagrangian [Contents][Index]

### 40.1 Functions and Variables for augmented_lagrangian

関数: augmented_lagrangian_method (FOM, xx, C, yy)
関数: augmented_lagrangian_method (FOM, xx, C, yy, optional_args)
関数: augmented_lagrangian_method ([FOM, grad], xx, C, yy)
関数: augmented_lagrangian_method ([FOM, grad], xx, C, yy, optional_args)

  ゼロに等しい制約Cを保ちながら、 式FOMの変数xxに関する近似最小を返します。 yyは xxの初期推量のリストです。 利用した方法は拡張Lagrange法です。(文献[1]と[2]を参照してください。)

  もしあるなら、gradは FOMのxxに関するグラディエントであり、 xxの変数それぞれに関する式のリストとして表されます。 もしないなら、グラディエントは自動的に構成されます。

  FOMと、もしあるならgradの要素それぞれは、 関数名やラムダ式ではなく、通常の式でなければいけません。

  `optional_args`は、 `symbol = value`として指定される、 追加の引数を表します。 認識されるオプション引数は以下の通りです:

  `niter`

    拡張Lagrangeアルゴリズムの繰り返しの回数

  `lbfgs_tolerance`

    LBFGSに供給される許容誤差

  `iprint`

    LBFGSに供給される IPRINTパラメータ(メッセージ出力を制御する２つの整数のリスト)

  `%lambda`

    拡張Lagrangeを計算するために使われる `%lambda`の初期値

  この実装は 擬似Newtonアルゴリズムであるメモリ制限付きBFGS (LBFGS)アルゴリズムを適用することで 拡張Lagraneを最小化します。

  `load("augmented_lagrangian")`はこの関数をロードします。

  `lbfgs`も参照してください。

  参考文献:

  [1] http://www-fp.mcs.anl.gov/otc/Guide/OptWeb/continuous/constrained/nonlinearcon/auglag.html

  [2] http://www.cs.ubc.ca/spider/ascher/542/chap10.pdf

  例:

      (%i1) load ("lbfgs");
      (%o1)     /maxima/share/lbfgs/lbfgs.mac
      (%i2) load ("augmented_lagrangian");
      (%o2)
         /maxima/share/contrib/augmented_lagrangian.mac
      (%i3) FOM: x^2 + 2*y^2;
                                     2    2
      (%o3)                       2 y  + x
      (%i4) xx: [x, y];
      (%o4)                        [x, y]
      (%i5) C: [x + y - 1];
      (%o5)                      [y + x - 1]
      (%i6) yy: [1, 1];
      (%o6)                        [1, 1]
      (%i7) augmented_lagrangian_method(FOM, xx, C, yy, iprint=[-1,0]);
      (%o7) [[x = 0.66665984108002, y = 0.33334027245545],
                                       %lambda = [- 1.333337940892525]]

  前と同じ例ですが、今回は グラディエントが引数として供給されます。

      (%i1) load ("lbfgs")$
      (%i2) load ("augmented_lagrangian")$
      (%i3) FOM: x^2 + 2*y^2;
                                     2    2
      (%o3)                       2 y  + x
      (%i4) FOM: x^2 + 2*y^2;
                                     2    2
      (%o4)                       2 y  + x
      (%i5) xx: [x, y];
      (%o5)                        [x, y]
      (%i6) grad : [2*x, 4*y];
      (%o6)                      [2 x, 4 y]
      (%i7) C: [x + y - 1];
      (%o7)                      [y + x - 1]
      (%i8) yy: [1, 1];
      (%o8)                        [1, 1]
      (%i9) augmented_lagrangian_method ([FOM, grad], xx, C, yy,
                                         iprint = [-1, 0]);
      (%o9) [[x = 0.666659841080025, y = .3333402724554462],
                                       %lambda = [- 1.333337940892543]]

  Numerical methods ·Optimization ·Share packages ·Package augmented_lagrangian ·

Next: bode, Previous: augmented_lagrangian, Up: Top [Contents][Index]

## 41 Bernstein

Previous: Bernstein, Up: Bernstein [Contents][Index]

### 41.1 Functions and Variables for Bernstein

関数: bernstein_poly (k, n, x)

  `k`が負の整数でないと仮定すると、 Bernstein多項式は `bernstein_poly(k,n,x) = binomial(n,k) x^k (1-x)^(n-k)`で定義されます; 負の整数`k`に対しては、Bernstein多項式 `bernstein_poly(k,n,x)`は零です。 `k`か `n`のどちらかが非整数の時、 オプション変数 `bernstein_explicit`は Bernstein多項式の明示形式への展開を制御します。 例:

      (%i1) load("bernstein")$

      (%i2) bernstein_poly(k,n,x);
      (%o2)                bernstein_poly(k, n, x)
      (%i3) bernstein_poly(k,n,x), bernstein_explicit : true;
                                             n - k  k
      (%o3)            binomial(n, k) (1 - x)      x

  Bernstein多項式はgradefプロパティとintegrateプロパティの両方を持ちます:

      (%i4) diff(bernstein_poly(k,n,x),x);
      (%o4) (bernstein_poly(k - 1, n - 1, x)
                                       - bernstein_poly(k, n - 1, x)) n
      (%i5) integrate(bernstein_poly(k,n,x),x);
      (%o5)
                                                                  k + 1
       hypergeometric([k + 1, k - n], [k + 2], x) binomial(n, k) x
       ----------------------------------------------------------------
                                    k + 1

  実数と複素数両方の数値入力に対して、 Bernstein多項式は数値結果に評価されます:

      (%i6) bernstein_poly(5,9, 1/2 + %i);
                              39375 %i   39375
      (%o6)                   -------- + -----
                                128       256
      (%i7) bernstein_poly(5,9, 0.5b0 + %i);
      (%o7)           3.076171875b2 %i + 1.5380859375b2

  `bernstein_poly`を使うには、最初に `load("bernstein")`。

変数: bernstein_explicit

  デフォルト値: `false`

  `k`か `n`のどちらかが非整数の時、 オプション変数 `bernstein_explicit`は Bernstein多項式の明示形式への展開を制御します; 例えば:

      (%i1) bernstein_poly(k,n,x);
      (%o1)                bernstein_poly(k, n, x)
      (%i2) bernstein_poly(k,n,x), bernstein_explicit : true;
                                             n - k  k
      (%o2)            binomial(n, k) (1 - x)      x

  `k`と `n`の両方が明示的に整数の時、 `bernstein(k,n,x)`は いつも明示形式に展開されます。

関数: multibernstein_poly ([k1,k2,…, kp], [n1,n2,…, np], [x1,x2,…, xp])

  マルチBernstein多項式 `multibernstein_poly ([k1, k2, ..., kp], [n1, n2, ..., np], [x1, x2, ..., xp])` Bernstein多項式 `bernstein_poly(k1, n1, x1) bernstein_poly(k2, n2, x2) ... bernstein_poly(kp, np, xp)`の積です。

  `multibernstein_poly`を使うには、最初に `load("bernstein")`。

関数: bernstein_approx (f, [x1, x1, …, xn], n)

  関数 `(x1, x2, ..., xn) |--> f`の `n`次の一様Bernstein多項式近似を返します。

  例

      (%i1) bernstein_approx(f(x),[x], 2);
                       2       1                          2
      (%o1)      f(1) x  + 2 f(-) (1 - x) x + f(0) (1 - x)
                               2
      (%i2) bernstein_approx(f(x,y),[x,y], 2);
                     2  2       1                2
      (%o2) f(1, 1) x  y  + 2 f(-, 1) (1 - x) x y
                                2
                        2  2          1   2
       + f(0, 1) (1 - x)  y  + 2 f(1, -) x  (1 - y) y
                                      2
             1  1                               1         2
       + 4 f(-, -) (1 - x) x (1 - y) y + 2 f(0, -) (1 - x)  (1 - y) y
             2  2                               2
                  2        2       1                      2
       + f(1, 0) x  (1 - y)  + 2 f(-, 0) (1 - x) x (1 - y)
                                   2
                        2        2
       + f(0, 0) (1 - x)  (1 - y)

  `bernstein_approx`を使うには、最初に `load("bernstein")`。

関数: bernstein_expand (e, [x1, x1, …, xn])

  多項式 `e`を 多変数Bernstein多項式の線形結合として厳密に表します。

      (%i1) bernstein_expand(x*y+1,[x,y]);
      (%o1)    2 x y + (1 - x) y + x (1 - y) + (1 - x) (1 - y)
      (%i2) expand(%);
      (%o2)                        x y + 1

  一番目の引数が多項式でない時、Maximaはエラーをシグナルします。

  `bernstein_expand`を使うには、最初に `load("bernstein")`。

Next: cobyla, Previous: Bernstein, Up: Top [Contents][Index]

## 42 bode

Previous: bode, Up: bode [Contents][Index]

### 42.1 Functions and Variables for bode

関数: bode_gain (H, range, ...plot_opts...)

  Bodeのゲイン線図を描く関数。

  例 (1から7までは

      http://www.swarthmore.edu/NatSci/echeeve1/Ref/Bode/BodeHow.html,

  から、8はRon Crummettから):

      (%i1) load("bode")$

      (%i2) H1 (s) := 100 * (1 + s) / ((s + 10) * (s + 100))$

      (%i3) bode_gain (H1 (s), [w, 1/1000, 1000])$

      (%i4) H2 (s) := 1 / (1 + s/omega0)$

      (%i5) bode_gain (H2 (s), [w, 1/1000, 1000]), omega0 = 10$

      (%i6) H3 (s) := 1 / (1 + s/omega0)^2$

      (%i7) bode_gain (H3 (s), [w, 1/1000, 1000]), omega0 = 10$

      (%i8) H4 (s) := 1 + s/omega0$

      (%i9) bode_gain (H4 (s), [w, 1/1000, 1000]), omega0 = 10$

      (%i10) H5 (s) := 1/s$

      (%i11) bode_gain (H5 (s), [w, 1/1000, 1000])$

      (%i12) H6 (s) := 1/((s/omega0)^2 + 2 * zeta * (s/omega0) + 1)$

      (%i13) bode_gain (H6 (s), [w, 1/1000, 1000]),
                        omega0 = 10, zeta = 1/10$

      (%i14) H7 (s) := (s/omega0)^2 + 2 * zeta * (s/omega0) + 1$

      (%i15) bode_gain (H7 (s), [w, 1/1000, 1000]),
                        omega0 = 10, zeta = 1/10$

      (%i16) H8 (s) := 0.5 / (0.0001 * s^3 + 0.002 * s^2 + 0.01 * s)$

      (%i17) bode_gain (H8 (s), [w, 1/1000, 1000])$

  この関数を使うためには、最初に`load("bode")`を書いてください。 `bode_phase`も参照してください。

  Plotting ·Package bode ·

関数: bode_phase (H, range, ...plot_opts...)

  Bodeの位相線図を描く関数。

  例 (1から7までは

      http://www.swarthmore.edu/NatSci/echeeve1/Ref/Bode/BodeHow.html,

  から、8はRon Crummettから):

      (%i1) load("bode")$

      (%i2) H1 (s) := 100 * (1 + s) / ((s + 10) * (s + 100))$

      (%i3) bode_phase (H1 (s), [w, 1/1000, 1000])$

      (%i4) H2 (s) := 1 / (1 + s/omega0)$

      (%i5) bode_phase (H2 (s), [w, 1/1000, 1000]), omega0 = 10$

      (%i6) H3 (s) := 1 / (1 + s/omega0)^2$

      (%i7) bode_phase (H3 (s), [w, 1/1000, 1000]), omega0 = 10$

      (%i8) H4 (s) := 1 + s/omega0$

      (%i9) bode_phase (H4 (s), [w, 1/1000, 1000]), omega0 = 10$

      (%i10) H5 (s) := 1/s$

      (%i11) bode_phase (H5 (s), [w, 1/1000, 1000])$

      (%i12) H6 (s) := 1/((s/omega0)^2 + 2 * zeta * (s/omega0) + 1)$

      (%i13) bode_phase (H6 (s), [w, 1/1000, 1000]),
                         omega0 = 10, zeta = 1/10$

      (%i14) H7 (s) := (s/omega0)^2 + 2 * zeta * (s/omega0) + 1$

      (%i15) bode_phase (H7 (s), [w, 1/1000, 1000]),
                         omega0 = 10, zeta = 1/10$

      (%i16) H8 (s) := 0.5 / (0.0001 * s^3 + 0.002 * s^2 + 0.01 * s)$

      (%i17) bode_phase (H8 (s), [w, 1/1000, 1000])$

      (%i18) block ([bode_phase_unwrap : false],
                    bode_phase (H8 (s), [w, 1/1000, 1000]));

      (%i19) block ([bode_phase_unwrap : true],
                    bode_phase (H8 (s), [w, 1/1000, 1000]));

  この関数を使うためには、最初に`load("bode")`を書いてください。 `bode_gain`も参照してください。

  Plotting ·Package bode ·

Next: contrib_ode, Previous: bode, Up: Top [Contents][Index]

## 43 cobyla

Next: Functions and Variables for cobyla, Previous: cobyla, Up: cobyla [Contents][Index]

### 43.1 Introduction to cobyla

`fmin_cobyla`は Powell[1][2][3]による Fortran制約最適化ルーチンCOBYLAの(`f2cl`による)Common Lisp翻訳です。

COBYLAは X上の形式g(X) >= 0のM個の不等式制約を条件として目的函数F(X)を最小化します。 ここで、XはN個の成分を持つ変数のベクトルです。

等式制約g(X)=0は、 よく、不等式制約の組g(X)>=0と-g(X)>= 0で実装することができます。 MaximaのCOBYLAインターフェースは等式制約を受け入れ、 内部的に等式制約を不等式制約の組に変換します。

アルゴリズムは目的函数や制約函数の線形近似を用います。 変数空間内のN+1点での線形補間で形成された近似です。 補間点は単体の頂点としてみなされます。 パラメータRHOは単体のサイズを制御し、 RHOBEGからEHOENDに自動的に減らされます。 それぞれのRHOで、 サブルーチンは 現在のサイズにとって変数の良いベクトルを達成しようとし、 そして、RHOは値RHOENDに達するまで減らされます。 それゆえに、RHOBEGとRHOENDはそれぞれ、変数への合理的な初期変化と 変数に要求される精度に設定されるべきですが、 この精度は、保証はないので、実験の対象として見るべきです。 ルーチンは、 変数の変化を計算する時、 制約を単一のペナルティ函数にひとまとめにせずに、 制約それぞれを個別に扱います。 サブルーチン名は the phrase Constrained Optimization BY Linear Approximations(線形近似による位相制約下最適化)に由来します。

参考文献:

[1] Fortran Codeはhttp://plato.asu.edu/sub/nlores.html#generalから

[2] M. J. D. Powell, "A direct search optimization method that models the objective and constraint functions by linear interpolation," in Advances in Optimization and Numerical Analysis, eds. S. Gomez and J.-P. Hennart (Kluwer Academic: Dordrecht, 1994), p. 51-67.

[3] M. J. D. Powell, "Direct search algorithms for optimization calculations," Acta Numerica 7, 287-336 (1998). Also available as University of Cambridge, Department of Applied Mathematics and Theoretical Physics, Numerical Analysis Group, Report NA1998/04 from http://www.damtp.cam.ac.uk/user/na/reports.html

Numerical methods ·Optimization ·Share packages ·Package cobyla ·

Next: Examples for cobyla, Previous: Introduction to cobyla, Up: cobyla [Contents][Index]

### 43.2 Functions and Variables for cobyla

関数: fmin_cobyla (F, X, Y)
関数: fmin_cobyla (F, X, Y, optional_args)

  オプションの制約の組を条件として多変数Xに関する式Fの近似的最小を返します。 YはXに対する初期推測のリストです。

  Fは関数名やラムダ式ではなく、通常の式でなければいけません。

  `optional_args`は、 `symbol = value`のように指定される付加的な引数を表します。 認識されるオプションの引数は以下の通りです:

  `constraints`

    Xが満たさなければいけない不等式と等式の制約のリスト。 不等式制約は、 形式`g(X) >= h(X)`もしくは`g(X) <= h(X)`の 実際の不等式でなければいけません。 等式制約は 形式`g(X) = h(X)`のものでなければいけません。

  `rhobeg`

    単体のサイズを制御する内部RHO変数の初期値(デフォルトは1.0)。

  `rhoend`

    要望される最終値rhoパラメータ。 近似的に変数の精度です。(デフォルトは1d-6)

  `iprint`

    冗長な出力レベル(デフォルトは0)。

    - 0 - 出力なし
    - 1 - 計算終了時にまとめ
    - 2 - 変数のベクトルやRHOが減らされる時のある函数情報と一緒に、 RHOとSIGMAのそれぞれの新しい値が印字されます。
    - 3 - 2と同様ですが、F(X)が計算される時情報が印字されます。
  `maxfun`

    函数評価の最大回数(デフォルトは1000)。

  返す時、ベクトルが与えられます:

  1. 最小を与える変数の値。 これは Xの中にリストされた変数のそれぞれに関する 形式`var = value`の 要素のリストです。
  2. 最小化された函数値
  3. 函数評価の回数
  4. 以下の意味を持つリターンコード
     1. 0 - エラーなし。
     2. 1 - 函数評価の最大回数の上限に到達した。
     3. 2 - 進行を妨げる丸め誤差。

  `load("fmin_cobyla")`はこの関数をロードします。

関数: bf_fmin_cobyla (F, X, Y)
関数: bf_fmin_cobyla (F, X, Y, optional_args)

  この関数は、 多倍長浮動小数点演算が使われること、 rhoendのデフォルト値が`10^(fpprec/2)`であることを除いて、 `fmin_cobyla`と同一です。

  更に知るには`fmin_cobyla`を参照してください。

  `load("fmin_cobyla")`はこの関数をロードします。

Previous: Functions and Variables for cobyla, Up: cobyla [Contents][Index]

### 43.3 Examples for cobyla

x1*x2を1-x1^2-x2^2 >= 0の条件で最小化します。 理論的解はx1 = 1/sqrt(2), x2 = -1/sqrt(2)です。

    (%i1) load("fmin_cobyla")$

    (%i2) fmin_cobyla(x1*x2, [x1, x2], [1,1],
                      constraints = [x1^2+x2^2<=1], iprint=1);

       Normal return from subroutine COBYLA

       NFVALS =   66   F =-5.000000E-01    MAXCV = 1.999845E-12
       X = 7.071058E-01  -7.071077E-01
    (%o2) [[x1 = 0.70710584934848, x2 = - 0.7071077130248],
           - 0.49999999999926, [[-1.999955756559757e-12],[]], 66]

追加の例はshare/cobyla/exディレクトリにあります。

Next: descriptive, Previous: cobyla, Up: Top [Contents][Index]

## 44 contrib_ode

Next: Functions and Variables for contrib_ode, Previous: contrib_ode, Up: contrib_ode [Contents][Index]

### 44.1 Introduction to contrib_ode

Maximaの常微分方程式(ODE)ソルバ`ode2`は 一階と二階の初等線形ODEを解きます。 関数`contrib_ode`は 線形と非線形一階ODEと線形斉次二階ODEに関する追加の方法で `ode2`を拡張します。 コードは、まだ開発中で、コールの順序は将来のリリースで変わるかもしれません。 一旦コードが安定化したら、投稿ディレクトリから移して、Maximaに統合されるかもしれません。

このパッケージは、 使用前に コマンド`load("contrib_ode")`でロードしなければいけません。

`contrib_ode`のコール取り決めは `ode2`と同一です。 ３つの引数を取ります: ODE (右辺が0なら左辺だけでもいいです)、 従属変数、独立変数。 成功した時、解のリストを返します。

解の形式は `ode2`と異なります。 非線形方程式は複数解を持つので、 `contrib_ode`は解のリストを返します。 解それぞれは複数の形式を持ちます:

- 従属変数の陽解、
- 従属変数の陰解、
- 変数`%t`を使ったパラメトリック解、または、
- 変数`%u`に関する別のODEへの変換

`%c`は 一階方程式の積分定数を表すのに使われます。 `%k1`と`%k2`は 二階方程式の定数を表すのに使われます。 もし`contrib_ode`が いかなる理由でも解を得られないなら、 たぶんエラーメッセージを印字した後、 `false`を返します。

一階非線形ODEは複数解を持ち得るので、 解のリストを返す必要があります。 例えば:

    (%i1) load("contrib_ode")$

    (%i2) eqn:x*'diff(y,x)^2-(1+x*y)*'diff(y,x)+y=0;

                        dy 2             dy
    (%o2)            x (--)  - (x y + 1) -- + y = 0
                        dx               dx
    (%i3) contrib_ode(eqn,y,x);

                                                 x
    (%o3)             [y = log(x) + %c, y = %c %e ]
    (%i4) method;

    (%o4)                        factor

以下の例の二番目の解のように、 非線形ODEは積分定数を持たない特異解を持ち得ます:

    (%i1) load("contrib_ode")$

    (%i2) eqn:'diff(y,x)^2+x*'diff(y,x)-y=0;

                           dy 2     dy
    (%o2)                 (--)  + x -- - y = 0
                           dx       dx
    (%i3) contrib_ode(eqn,y,x);

                                               2
                                     2        x
    (%o3)              [y = %c x + %c , y = - --]
                                              4
    (%i4) method;

    (%o4)                       clairault

以下のODEは ダミー変数`%t`を使った ２つのパラメトリック解を持ちます。 この場合、パラメトリック解を操作して、陽解を与えることができます。

    (%i1) load("contrib_ode")$

    (%i2) eqn:'diff(y,x)=(x+y)^2;

                              dy          2
    (%o2)                     -- = (y + x)
                              dx
    (%i3) contrib_ode(eqn,y,x);

    (%o3) [[x = %c - atan(sqrt(%t)), y = - x - sqrt(%t)],
                         [x = atan(sqrt(%t)) + %c, y = sqrt(%t) - x]]
    (%i4) method;

    (%o4)                       lagrange

以下の例(Kamke 1.112)は、陰解を例示します。

    (%i1) load("contrib_ode")$

    (%i2) assume(x>0,y>0);

    (%o2)                    [x > 0, y > 0]
    (%i3) eqn:x*'diff(y,x)-x*sqrt(y^2+x^2)-y;

                         dy           2    2
    (%o3)              x -- - x sqrt(y  + x ) - y
                         dx
    (%i4) contrib_ode(eqn,y,x);

                                      y
    (%o4)                  [x - asinh(-) = %c]
                                      x
    (%i5) method;

    (%o5)                          lie

以下のRiccati方程式は 変数`%u`に関する線形二階ODEに変換されます。 Maximaは 新しいODEを解くことができません。 だから、未評価で返されます。

    (%i1) load("contrib_ode")$

    (%i2) eqn:x^2*'diff(y,x)=a+b*x^n+c*x^2*y^2;

                        2 dy      2  2      n
    (%o2)              x  -- = c x  y  + b x  + a
                          dx
    (%i3) contrib_ode(eqn,y,x);

                   d%u
                   ---                            2
                   dx        2     n - 2   a     d %u
    (%o3)  [[y = - ----, %u c  (b x      + --) + ---- c = 0]]
                   %u c                     2      2
                                           x     dx
    (%i4) method;

    (%o4)                        riccati

一階ODEに対して、`contrib_ode`は`ode2`をコールします。 その後、以下の方法を試します: 因数分解、Clairault, Lagrange, Riccati, Abel, Lie対称性を使った方法 もしAbel方法が失敗したら、 Lie方法はAbel方程式には試みられませんが、 もしRiccati方法が未解決二階ODEを返したら、 Lie方法が試みられます。

二階ODEに対して、`contrib_ode`は`ode2`をコールし、その後`odelin`をコールします。

もしコマンド `put('contrib_ode,true,'verbose)`が実行されたら、 長いデバッグトレースとメッセージが表示されます。

Differential equations ·Share packages ·Package contrib_ode ·

Next: Possible improvements to contrib_ode, Previous: Introduction to contrib_ode, Up: contrib_ode [Contents][Index]

### 44.2 Functions and Variables for contrib_ode

関数: contrib_ode (eqn, y, x)

  独立変数xと従属変数yに関するODE eqnの解のリストを返します。

  Package contrib_ode ·

関数: odelin (eqn, y, x)

  `odelin`は 独立変数xと従属変数yに関する 一階および二階線形斉次ODEを解きます。 ODEの基本的な解一式を返します。

  二階ODEに対して、`odelin`は、 与えられた特殊関数を使って解を探索する BronsteinとLafailleによる方法 を使います。

      (%i1) load("contrib_ode");

      (%i2) odelin(x*(x+1)*'diff(y,x,2)+(x+5)*'diff(y,x,1)+(-4)*y,y,x);
      ...trying factor method
      ...solving 7 equations in 4 variables
      ...trying the Bessel solver
      ...solving 1 equations in 2 variables
      ...trying the F01 solver
      ...solving 1 equations in 3 variables
      ...trying the spherodial wave solver
      ...solving 1 equations in 4 variables
      ...trying the square root Bessel solver
      ...solving 1 equations in 2 variables
      ...trying the 2F1 solver
      ...solving 9 equations in 5 variables
             gauss_a(- 6, - 2, - 3, - x)  gauss_b(- 6, - 2, - 3, - x)
      (%o2) {---------------------------, ---------------------------}
                          4                            4
                         x                            x

  Package contrib_ode ·

関数: ode_check (eqn, soln)

  可能な解solnを代入した後、 ODE eqnの値を返します。 もしsolnがeqnの解なら 値はゼロと同値です。

      (%i1) load("contrib_ode")$

      (%i2) eqn:'diff(y,x,2)+(a*x+b)*y;

                               2
                              d y
      (%o2)                   --- + (a x + b) y
                                2
                              dx
      (%i3) ans:[y = bessel_y(1/3,2*(a*x+b)^(3/2)/(3*a))*%k2*sqrt(a*x+b)
               +bessel_j(1/3,2*(a*x+b)^(3/2)/(3*a))*%k1*sqrt(a*x+b)];

                                        3/2
                          1  2 (a x + b)
      (%o3) [y = bessel_y(-, --------------) %k2 sqrt(a x + b)
                          3       3 a
                                                3/2
                                  1  2 (a x + b)
                       + bessel_j(-, --------------) %k1 sqrt(a x + b)]
                                  3       3 a
      (%i4) ode_check(eqn,ans[1]);

      (%o4)                           0

  Package contrib_ode ·

システム変数: method

  変数`method`は成功した解法に設定されます。

  Package contrib_ode ·

変数: %c

  `%c`は一階ODEの積分定数です。

  Package contrib_ode ·

変数: %k1

  `%k1`は二階ODEの最初の積分定数です。

  Package contrib_ode ·

変数: %k2

  `%k2`は二階ODEの二番目の積分定数です。

  Package contrib_ode ·

関数: gauss_a (a, b, c, x)

  `gauss_a(a,b,c,x)`と`gauss_b(a,b,c,x)`は2F1幾何関数です。 それらは超幾何微分方程式 `x(1-x) diff(y,x,2) + [c-(a+b+1)x diff(y,x) - aby = 0` の任意の２つの独立解を表します(A&S 15.5.1)。

  これらの関数は `odelin`と`contrib_ode`が返すODEの解の中でだけ使われます。 これらの関数の定義と使用はMaimaの将来のリリースで変わるかもしれません。

  `gauss_b`, `dgauss_a`, `gauss_b`も参照してください。

  Package contrib_ode ·

関数: gauss_b (a, b, c, x)

  See `gauss_a`.

  Package contrib_ode ·

関数: dgauss_a (a, b, c, x)

  `gauss_a(a, b, c, x)`のxに関する導関数。

  Package contrib_ode ·

関数: dgauss_b (a, b, c, x)

  `gauss_b(a, b, c, x)`のxに関する導関数。

  Package contrib_ode ·

関数: kummer_m (a, b, x)

  Abramowitz and Stegun, Handbook of Mathematical Functions, Section 13.1.2の中で定義される KummerのM関数

  この関数は `odelin`と`contrib_ode`が返すODEの解の中でだけ使われます。 この関数の定義と使用はMaimaの将来のリリースで変わるかもしれません。

  `kummer_u`, `dkummer_m`, `dkummer_u`も参照してください。

  Package contrib_ode ·

関数: kummer_u (a, b, x)

  Abramowitz and Stegun, Handbook of Mathematical Functions, Section 13.1.3の中で定義される KummerのU関数

  `kummer_m`を参照してください。

  Package contrib_ode ·

関数: dkummer_m (a, b, x)

  `kummer_m(a, b, x)`のxに関する導関数。

  Package contrib_ode ·

関数: dkummer_u (a, b, x)

  `kummer_u(a, b, x)`のxに関する導関数。

  Package contrib_ode ·

Next: Test cases for contrib_ode, Previous: Functions and Variables for contrib_ode, Up: contrib_ode [Contents][Index]

### 44.3 Possible improvements to contrib_ode

これらのルーチンは開発進行中です。まだ以下をする必要があります:

- FACTOR方法`ode1_factor`を多重根で機能するように拡張すること。
- FACTOR方法`ode1_factor`を より高次因子を解こうとするように拡張すること。 現在、線形因子を解こうとするだけです。
- LAGRANGEルーチン`ode1_lagrange`を複素根より実根を優先するように直すこと。
- Riccati方程式のための他の方法を追加すること。
- 第二種Abel方程式の検出を改善すること。 今のパターンマッチングは弱いです。
- Work on the Lie対称群ルーチン`ode1_lie`に関する仕事。 2,3の相当な問題があります: いくつかの部分が未実装です; いくつかのテストケースが無限ループのようです; 他のテストケースではクラッシュします; さらに他では非常に複雑な「解」を返します。 本当にリリースの準備ができていたか疑っています。
- もっとテストケースを追加すること。

Next: References for contrib_ode, Previous: Possible improvements to contrib_ode, Up: contrib_ode [Contents][Index]

### 44.4 Test cases for contrib_ode

Murphy, Kamke, Zwillingerと他で ルーチンはおおよそ千のテストケース上でテストされています。 これらはテストサブディレクトリに含まれています。

- The Clairaultルーチン`ode1_clairault`は、 特異解を含み、 MurphyとKamkeの中のClairault方程式の 知られている解すべてを見つけます。
- 他のルーチンは、多重解が存在する時に しばしば単一界を返します。
- `ode1_lie`の「解」のいくつかは過度に複雑でチェックが不可能です。
- いくつかのクラッシュがあります。

Previous: Test cases for contrib_ode, Up: contrib_ode [Contents][Index]

### 44.5 References for contrib_ode

1. E. Kamke, Differentialgleichungen Losungsmethoden und Losungen, Vol 1, Geest & Portig, Leipzig, 1961
2. G. M. Murphy, Ordinary Differential Equations and Their Solutions, Van Nostrand, New York, 1960
3. D. Zwillinger, Handbook of Differential Equations, 3rd edition, Academic Press, 1998
4. F. Schwarz, Symmetry Analysis of Abel’s Equation, Studies in Applied Mathematics, 100:269-294 (1998)
5. F. Schwarz, Algorithmic Solution of Abel’s Equation, Computing 61, 39-49 (1998)
6. E. S. Cheb-Terrab, A. D. Roche, Symmetries and First Order ODE Patterns, Computer Physics Communications 113 (1998), p 239. (http://lie.uwaterloo.ca/papers/ode_vii.pdf)
7. E. S. Cheb-Terrab, T. Kolokolnikov, First Order ODEs, Symmetries and Linear Transformations, European Journal of Applied Mathematics, Vol. 14, No. 2, pp. 231-246 (2003). (http://arxiv.org/abs/math-ph/0007023,
   http://lie.uwaterloo.ca/papers/ode_iv.pdf)
8. G. W. Bluman, S. C. Anco, Symmetry and Integration Methods for Differential Equations, Springer, (2002)
9. M. Bronstein, S. Lafaille, Solutions of linear ordinary differential equations in terms of special functions, Proceedings of ISSAC 2002, Lille, ACM Press, 23-28. (http://www-sop.inria.fr/cafe/Manuel.Bronstein/publications/issac2002.pdf)

Next: diag, Previous: contrib_ode, Up: Top [Contents][Index]

## 45 descriptive

Next: Functions and Variables for data manipulation, Previous: descriptive, Up: descriptive [Contents][Index]

### 45.1 Introduction to descriptive

パッケージ`descriptive`は記述統計計算とグラフ作成を行うための関数一式を含みます。 ソースコードと一緒にMaximaツリーに３つのデータセットがあります: `pidigits.data`, `wind.data`, `biomed.data`

パッケージ`descriptive`の関数の参考文献として、 どんな統計マニュアルでも使うことができます。

コメント、バグ、提案は、 ’mario AT edu DOT xunta DOT es’にコンタクトしてください。

以下は、 `descriptive`の中の記述関数が 引数やリスト、行列の性質に依存して如何に機能するかを示す 簡単な例です。

    (%i1) load ("descriptive")$

    (%i2) /* univariate sample */   mean ([a, b, c]);
                                c + b + a
    (%o2)                       ---------
                                    3

    (%i3) matrix ([a, b], [c, d], [e, f]);
                                [ a  b ]
                                [      ]
    (%o3)                       [ c  d ]
                                [      ]
                                [ e  f ]

    (%i4) /* multivariate sample */ mean (%);
                          e + c + a  f + d + b
    (%o4)                [---------, ---------]
                              3          3

多変数標本では、平均は列それぞれに関して計算されることに注意してください。

異なるサイズかもしれない複数の標本の場合、 Maxima関数`map`が標本それぞれに対して望みの結果を得るのに使うことができます。

    (%i1) load ("descriptive")$

    (%i2) map (mean, [[a, b, c], [d, e]]);
                            c + b + a  e + d
    (%o2)                  [---------, -----]
                                3        2

この場合、サイズ３と２の２つの標本がリストに格納されました。

１変数標本は以下のようにリストに格納されなければいけません。

    (%i1) s1 : [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
    (%o1)           [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

多変数標本は以下のように行列に格納されなければいけません。

    (%i1) s2 : matrix ([13.17, 9.29], [14.71, 16.88], [18.50, 16.88],
                 [10.58, 6.63], [13.33, 13.25], [13.21,  8.12]);
                            [ 13.17  9.29  ]
                            [              ]
                            [ 14.71  16.88 ]
                            [              ]
                            [ 18.5   16.88 ]
    (%o1)                   [              ]
                            [ 10.58  6.63  ]
                            [              ]
                            [ 13.33  13.25 ]
                            [              ]
                            [ 13.21  8.12  ]

この場合、 列の数は確率変数次元に等しく、行の数はサプルのサイズです。

データは手で入力することができますが、 大きな標本は普通プレインテキストファイルの中に格納されています。 例えば、ファイル`pidigits.data`は 数`%pi`の最初の100桁を含みます:

          3
          1
          4
          1
          5
          9
          2
          6
          5
          3 ...

Maximaでこれらの桁をロードするためには、

    (%i1) s1 : read_list (file_search ("pidigits.data"))$

    (%i2) length (s1);
    (%o2)                          100

他方、ファイル`wind.data`は アイルランド共和国の５つの気象台の毎日の平均風速を含みます。 (これは１２の気象台で取得されたデータセットの一部です。 元のファイルはStatLib Data Repositoryから無料でダウンロードでき、 その分析はHaslett, J., Raftery, A. E. (1989) Space-time Modelling with Long-memory Dependence: Assessing Ireland’s Wind Power Resource, with Discussion. Applied Statistics 38, 1-50 で議論されてます。) 以下ではデータをロードします:

    (%i1) s2 : read_matrix (file_search ("wind.data"))$

    (%i2) length (s2);
    (%o2)                          100

    (%i3) s2 [%]; /* last record */
    (%o3)            [3.58, 6.0, 4.58, 7.62, 11.25]

いくつかの標本は数値でないデータを含みます。 例えば、ファイル`biomed.data` (StatLib Data Repositoryからダウンロードされた別のもっと大きなものの一部)は、 異なる年齢の、２つのグループ`A`と`B`の患者から測定された４つの血圧を含みます。

    (%i1) s3 : read_matrix (file_search ("biomed.data"))$

    (%i2) length (s3);
    (%o2)                          100

    (%i3) s3 [1]; /* first record */
    (%o3)            [A, 30, 167.0, 89.0, 25.6, 364]

最初の個人はグループ`A`に属し、30歳で、血圧は167.0, 89.0, 25.6 and 364でした。

カテゴリデータを扱う時には気をつけなければいけません。 次の例では、シンボル`a`が以前のある時点で値に割り当てられ、 その後、カテゴリ値`a`を持つ標本が取られます。

    (%i1) a : 1$

    (%i2) matrix ([a, 3], [b, 5]);
                                [ 1  3 ]
    (%o2)                       [      ]
                                [ b  5 ]

Descriptive statistics ·Share packages ·Package descriptive ·

Next: Functions and Variables for descriptive statistics, Previous: Introduction to descriptive, Up: descriptive [Contents][Index]

### 45.2 Functions and Variables for data manipulation

関数: continuous_freq (list)
関数: continuous_freq (list, m)

  `continuous_freq`の引数は数のリストでなければいけません。 範囲を区間に分割し、それらの中に値がいくつあるか数えます。 二番目の引数はオプションで、 欲しいクラス数(デフォルトが10)か、 クラス境界と欲しいクラスを含むリストか 境界だけ含むリストのいずれかです。 引数 listは(2個か3個の)実数のリストでなければいけません。 もしサンプル値がすべて等しいなら、この関数は振幅2の1クラスだけ返します。

  例:

  オプション引数は欲しいクラス数を示します。 出力の最初のリストは区間境界を含み、二番目は対応する個数を含みます: 区間`[0, 1.8]`すなわち0か1である桁が16あり、 `(1.8, 3.6]`すなわち2か3である桁が24あり、など。

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$
      (%i3) continuous_freq (s1, 5);
      (%o3) [[0, 1.8, 3.6, 5.4, 7.2, 9.0], [16, 24, 18, 17, 25]]

  オプション引数は、境界-2と12を持つクラスを7個欲しいことを示します。

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$
      (%i3) continuous_freq (s1, [-2,12,7]);
      (%o3) [[- 2, 0, 2, 4, 6, 8, 10, 12], [8, 20, 22, 17, 20, 13, 0]]

  オプション引数は、境界-2と12を持つクラスをデフォルト個欲しいことを示します:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$
      (%i3) continuous_freq (s1, [-2,12]);
                      3  4  11  18     32  39  46  53
      (%o3)  [[- 2, - -, -, --, --, 5, --, --, --, --, 12],
                      5  5  5   5      5   5   5   5
                     [0, 8, 20, 12, 18, 9, 8, 25, 0, 0]]

  Package descriptive ·

関数: discrete_freq (list)

  数値的、記述的両方の離散標本の中の絶対頻度を数えます。 唯一の引数はリストです。

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) discrete_freq (s1);
      (%o3) [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
                                   [8, 8, 12, 12, 10, 8, 9, 8, 12, 13]]

  最初のリストは標本値を与え、二番目はそれらの絶対頻度を与えます。 コマンド`? col`と`? transpose`は最後の入力を理解するのを助けるはずです。

  Package descriptive ·

関数: subsample (data_matrix, predicate_function)
関数: subsample (data_matrix, predicate_function, col_num1, col_num2, ...)

  これはMaxima `submatrix`関数の変形の一種です。 最初の引数はデータ行列であり、二番目は述語関数であり、 オプションの付加引数は返す列の番号です。 その振る舞いは例を使ってよりよく理解されます。

  以下は最初の測候所での風速が18より大きかった多変量レコードです。 ラムダ式の中でi番目の成分は`v[i]`として参照されることを参考にしてください。

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix (file_search ("wind.data"))$

      (%i3) subsample (s2, lambda([v], v[1] > 18));
                    [ 19.38  15.37  15.12  23.09  25.25 ]
                    [                                   ]
                    [ 18.29  18.66  19.08  26.08  27.63 ]
      (%o3)         [                                   ]
                    [ 20.25  21.46  19.95  27.71  23.38 ]
                    [                                   ]
                    [ 18.79  18.96  14.46  26.38  21.84 ]

  以下の例では、測候所番号1で16以上で、かつ、測候所番号4で25ノットより小さな風速 のレコードの一番目、二番目、五番目の成分だけをリクエストします。 標本は、測候所1, 2, 5からのデータだけを含みます。 この場合、述語関数は通常のMaxima関数として定義されます。

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix (file_search ("wind.data"))$
      (%i3) g(x):= x[1] >= 16 and x[4] < 25$

      (%i4) subsample (s2, g, 1, 2, 5);
                           [ 19.38  15.37  25.25 ]
                           [                     ]
                           [ 17.33  14.67  19.58 ]
      (%o4)                [                     ]
                           [ 16.92  13.21  21.21 ]
                           [                     ]
                           [ 17.25  18.46  23.87 ]

  以下は`biomed.data`のカテゴリ変数の例です。 38歳より年上のグループ`B`の患者に対応するレコードが欲しいです。

      (%i1) load ("descriptive")$
      (%i2) s3 : read_matrix (file_search ("biomed.data"))$
      (%i3) h(u):= u[1] = B and u[2] > 38 $

      (%i4) subsample (s3, h);
                      [ B  39  28.0  102.3  17.1  146 ]
                      [                               ]
                      [ B  39  21.0  92.4   10.3  197 ]
                      [                               ]
                      [ B  39  23.0  111.5  10.0  133 ]
                      [                               ]
                      [ B  39  26.0  92.6   12.3  196 ]
      (%o4)           [                               ]
                      [ B  39  25.0  98.7   10.0  174 ]
                      [                               ]
                      [ B  39  21.0  93.2   5.9   181 ]
                      [                               ]
                      [ B  39  18.0  95.0   11.3  66  ]
                      [                               ]
                      [ B  39  39.0  88.5   7.6   168 ]

  統計解析には血圧だけを使うかもしれません。

      (%i1) load ("descriptive")$
      (%i2) s3 : read_matrix (file_search ("biomed.data"))$

      (%i3) subsample (s3, lambda([v], v[1] = B and v[2] > 38),
                       3, 4, 5, 6);
                         [ 28.0  102.3  17.1  146 ]
                         [                        ]
                         [ 21.0  92.4   10.3  197 ]
                         [                        ]
                         [ 23.0  111.5  10.0  133 ]
                         [                        ]
                         [ 26.0  92.6   12.3  196 ]
      (%o3)              [                        ]
                         [ 25.0  98.7   10.0  174 ]
                         [                        ]
                         [ 21.0  93.2   5.9   181 ]
                         [                        ]
                         [ 18.0  95.0   11.3  66  ]
                         [                        ]
                         [ 39.0  88.5   7.6   168 ]

  いかは`s3`の多変量平均です。

      (%i1) load ("descriptive")$
      (%i2) s3 : read_matrix (file_search ("biomed.data"))$

      (%i3) mean (s3);
             65 B + 35 A  317          6 NA + 8144.999999999999
      (%o3) [-----------, ---, 87.178, ------------------------,
                 100      10                     100
                                                          3 NA + 19587
                                                  18.123, ------------]
                                                              100

  ここで、一番目の成分は、`A`と`B`はカテゴリなので意味がなく、 二番目の成分は個々人の平均の歳の有理表現であり、 四番目と最後の値はある奇妙な振る舞いを示しています。 これは、 This is because symbol シンボル`NA`がnon availableデータを示すようにここで使われているからで、 二つの平均は無意味です。 情報のある種の喪失を意味しますが、 可能な解は`NA`シンボルを持つ行を行列から取り除くことです。

      (%i1) load ("descriptive")$
      (%i2) s3 : read_matrix (file_search ("biomed.data"))$
      (%i3) g(v):= v[4] # NA and v[6] # NA $

      (%i4) mean (subsample (s3, g, 3, 4, 5, 6));
      (%o4) [79.4923076923077, 86.2032967032967, 16.93186813186813,
                                                                  2514
                                                                  ----]
                                                                   13

  Package descriptive ·

Next: Functions and Variables for statistical graphs, Previous: Functions and Variables for data manipulation, Up: descriptive [Contents][Index]

### 45.3 Functions and Variables for descriptive statistics

関数: mean (list)
関数: mean (matrix)

  これは標本平均です。以下のように定義されます。

                             n
                           ====
                   _   1   \
                   x = -    >    x
                       n   /      i
                           ====
                           i = 1

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) mean (s1);
                                     471
      (%o3)                          ---
                                     100

      (%i4) %, numer;
      (%o4)                         4.71

      (%i5) s2 : read_matrix (file_search ("wind.data"))$

      (%i6) mean (s2);
      (%o6)     [9.9485, 10.1607, 10.8685, 15.7166, 14.8441]

  Package descriptive ·

関数: var (list)
関数: var (matrix)

  これは標本分散です。以下のように定義されます。

                           n
                         ====
                 2   1   \          _ 2
                s  = -    >    (x - x)
                     n   /       i
                         ====
                         i = 1

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) var (s1), numer;
      (%o3)                   8.425899999999999

  関数`var1`も参照してください。

  Package descriptive ·

関数: var1 (list)
関数: var1 (matrix)

  これは標本分散です。以下のように定義されます。

                           n
                         ====
                     1   \          _ 2
                    ---   >    (x - x)
                    n-1  /       i
                         ====
                         i = 1

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) var1 (s1), numer;
      (%o3)                    8.5110101010101

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) var1 (s2);
      (%o5) [17.39586540404041, 15.13912778787879, 15.63204924242424,
                                  32.50152569696971, 24.66977392929294]

  関数`var`も参照してください。

  Package descriptive ·

関数: std (list)
関数: std (matrix)

  これは分母nの分散である関数`var`の平方根です。

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) std (s1), numer;
      (%o3)                   2.902740084816414

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) std (s2);
      (%o5) [4.149928523480858, 3.871399812729241, 3.933920277534866,
                                  5.672434260526957, 4.941970881136392]

  関数`var`と`std1`も参照してください。

  Package descriptive ·

関数: std1 (list)
関数: std1 (matrix)

  これは分母n-1の分散である関数`var1`の平方根です。

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) std1 (s1), numer;
      (%o3)                   2.917363553109228

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) std1 (s2);
      (%o5) [4.170835096721089, 3.89090320978032, 3.953738641137555,
                                  5.701010936401517, 4.966867617451963]

  See also functions `var1` and `std`.

  Package descriptive ·

関数: noncentral_moment (list, k)
関数: noncentral_moment (matrix, k)

  次数kの非中心モーメントです。以下のように定義されます。

                             n
                           ====
                       1   \      k
                       -    >    x
                       n   /      i
                           ====
                           i = 1

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) noncentral_moment (s1, 1), numer; /* the mean */
      (%o3)                         4.71

      (%i5) s2 : read_matrix (file_search ("wind.data"))$

      (%i6) noncentral_moment (s2, 5);
      (%o6) [319793.8724761505, 320532.1923892463,
            391249.5621381556, 2502278.205988911, 1691881.797742255]

  関数`central_moment`も参照してください。

  Package descriptive ·

関数: central_moment (list, k)
関数: central_moment (matrix, k)

  次数kの中心モーメントです。以下のように定義されます。

                          n
                        ====
                    1   \          _ k
                    -    >    (x - x)
                    n   /       i
                        ====
                        i = 1

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) central_moment (s1, 2), numer; /* the variance */
      (%o3)                   8.425899999999999

      (%i5) s2 : read_matrix (file_search ("wind.data"))$

      (%i6) central_moment (s2, 3);
      (%o6) [11.29584771375004, 16.97988248298583, 5.626661952750102,
                                   37.5986572057918, 25.85981904394192]

  関数`noncentral_moment`と`mean`も参照してください。

  Package descriptive ·

関数: cv (list)
関数: cv (matrix)

  変動係数は標本標準偏差(`std`)を平均`mean`で割った商です。

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) cv (s1), numer;
      (%o3)                   .6193977819764815

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) cv (s2);
      (%o5) [.4192426091090204, .3829365309260502, 0.363779605385983,
                                  .3627381836021478, .3346021393989506]

  関数`std`と`mean`も参照してください。

  Package descriptive ·

関数: smin (list)
関数: smin (matrix)

  これは標本listの最小値です。 引数が行列の時、 `smin`は 統計変数に関連付けられた列の最小値を含むリストを返します。

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) smin (s1);
      (%o3)                           0

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) smin (s2);
      (%o5)             [0.58, 0.5, 2.67, 5.25, 5.17]

  See also function `smax`.

  Package descriptive ·

関数: smax (list)
関数: smax (matrix)

  これは標本listの最大値です。 引数が行列の時、 `smax`は 統計変数に関連付けられた列の最大値を含むリストを返します。

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) smax (s1);
      (%o3)                           9

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) smax (s2);
      (%o5)          [20.25, 21.46, 20.04, 29.63, 27.63]

  関数`smin`も参照してください。

  Package descriptive ·

関数: range (list)
関数: range (matrix)

  範囲は極値の差です。

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) range (s1);
      (%o3)                           9

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) range (s2);
      (%o5)          [19.67, 20.96, 17.37, 24.38, 22.46]

  Package descriptive ·

関数: quantile (list, p)
関数: quantile (matrix, p)

  これは標本listのp分位数です。pは[0, 1]の範囲の数です。 標本分位数にはいくつかの定義がありますが (Hyndman, R. J., Fan, Y. (1996) Sample quantiles in statistical packages. American Statistician, 50, 361-365)、 パッケージ`descriptive`では線形内挿に基づいたものが実装されています。

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) /* 1st and 3rd quartiles */
               [quantile (s1, 1/4), quantile (s1, 3/4)], numer;
      (%o3)                      [2.0, 7.25]

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) quantile (s2, 1/4);
      (%o5)    [7.2575, 7.477500000000001, 7.82, 11.28, 11.48]

  Package descriptive ·

関数: median (list)
関数: median (matrix)

  一旦標本が順に並べられると、 もし標本サイズが奇数ならメジアンは中央値であり、 そうでなければ2つの中央値の平均です。

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) median (s1);
                                      9
      (%o3)                           -
                                      2

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) median (s2);
      (%o5)         [10.06, 9.855, 10.73, 15.48, 14.105]

  メジアンは1/2分位数です。

  関数`quantile`も参照してください。

  Package descriptive ·

関数: qrange (list)
関数: qrange (matrix)

  四分位範囲は 三番目と一番目の分位数の差 `quantile(list,3/4) - quantile(list,1/4)` です。

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) qrange (s1);
                                     21
      (%o3)                          --
                                     4

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) qrange (s2);
      (%o5) [5.385, 5.572499999999998, 6.022500000000001,
                                  8.729999999999999, 6.649999999999999]

  関数`quantile`も参照してください。

  Package descriptive ·

関数: mean_deviation (list)
関数: mean_deviation (matrix)

  平均偏差です。以下のように定義されます。

                           n
                         ====
                     1   \          _
                     -    >    |x - x|
                     n   /       i
                         ====
                         i = 1

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) mean_deviation (s1);
                                     51
      (%o3)                          --
                                     20

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) mean_deviation (s2);
      (%o5) [3.287959999999999, 3.075342, 3.23907, 4.715664000000001,
                                                     4.028546000000002]

  関数`mean`も参照してください。

  Package descriptive ·

関数: median_deviation (list)
関数: median_deviation (matrix)

  メジアン偏差です。以下のように定義されます。

                       n
                     ====
                 1   \
                 -    >    |x - med|
                 n   /       i
                     ====
                     i = 1

  ここで`med`はlistのメジアンです。

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) median_deviation (s1);
                                      5
      (%o3)                           -
                                      2

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) median_deviation (s2);
      (%o5)           [2.75, 2.755, 3.08, 4.315, 3.31]

  関数`mean`も参照してください。

  Package descriptive ·

関数: harmonic_mean (list)
関数: harmonic_mean (matrix)

  調和平均です。以下のように定義されます。

                        n
                     --------
                      n
                     ====
                     \     1
                      >    --
                     /     x
                     ====   i
                     i = 1

  例:

      (%i1) load ("descriptive")$
      (%i2) y : [5, 7, 2, 5, 9, 5, 6, 4, 9, 2, 4, 2, 5]$

      (%i3) harmonic_mean (y), numer;
      (%o3)                   3.901858027632205

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) harmonic_mean (s2);
      (%o5) [6.948015590052786, 7.391967752360356, 9.055658197151745,
                                  13.44199028193692, 13.01439145898509]

  関数`mean`と`geometric_mean`も参照してください。

  Package descriptive ·

関数: geometric_mean (list)
関数: geometric_mean (matrix)

  幾何平均です。以下のように定義されます。

                       /  n      \ 1/n
                       | /===\   |
                       |  ! !    |
                       |  ! !  x |
                       |  ! !   i|
                       | i = 1   |
                       \         /

  例:

      (%i1) load ("descriptive")$
      (%i2) y : [5, 7, 2, 5, 9, 5, 6, 4, 9, 2, 4, 2, 5]$

      (%i3) geometric_mean (y), numer;
      (%o3)                   4.454845412337012

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) geometric_mean (s2);
      (%o5) [8.82476274347979, 9.22652604739361, 10.0442675714889,
                                  14.61274126349021, 13.96184163444275]

  関数`mean`と`harmonic_mean`も参照してください。

  Package descriptive ·

関数: kurtosis (list)
関数: kurtosis (matrix)

  尖度係数です。以下のように定義されます。

                          n
                        ====
                  1     \          _ 4
                 ----    >    (x - x)  - 3
                    4   /       i
                 n s    ====
                        i = 1

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) kurtosis (s1), numer;
      (%o3)                  - 1.273247946514421

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) kurtosis (s2);
      (%o5) [- .2715445622195385, 0.119998784429451,
           - .4275233490482861, - .6405361979019522, - .4952382132352935]

  関数`mean`, `var`, `skewness`も参照してください。

  Package descriptive ·

関数: skewness (list)
関数: skewness (matrix)

  歪度係数です。以下のように定義されます。

                          n
                        ====
                  1     \          _ 3
                 ----    >    (x - x)
                    3   /       i
                 n s    ====
                        i = 1

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) skewness (s1), numer;
      (%o3)                  .009196180476450424

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) skewness (s2);
      (%o5) [.1580509020000978, .2926379232061854, .09242174416107717,
                                  .2059984348148687, .2142520248890831]

  関数`mean`, `var`, `kurtosis`も参照してください。

  Package descriptive ·

関数: pearson_skewness (list)
関数: pearson_skewness (matrix)

  Pearsonの歪度係数です。以下のように定義されます。

                      _
                   3 (x - med)
                   -----------
                        s

  ここで medはlistのメジアンです。

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) pearson_skewness (s1), numer;
      (%o3)                   .2159484029093895

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) pearson_skewness (s2);
      (%o5) [- .08019976629211892, .2357036272952649,
               .1050904062491204, .1245042340592368, .4464181795804519]

  関数`mean`, `var`, `median`も参照してください。

  Package descriptive ·

関数: quartile_skewness (list)
関数: quartile_skewness (matrix)

  分位歪度係数です。以下のように定義されます。

                     c    - 2 c    + c
                      3/4      1/2    1/4
                     --------------------
                         c    - c
                          3/4    1/4

  ここでc_pは標本listのp分位数です。

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$

      (%i3) quartile_skewness (s1), numer;
      (%o3)                  .04761904761904762

      (%i4) s2 : read_matrix (file_search ("wind.data"))$

      (%i5) quartile_skewness (s2);
      (%o5) [- 0.0408542246982353, .1467025572005382,
             0.0336239103362392, .03780068728522298, .2105263157894735]

  関数`quantile`も参照してください。

  Package descriptive ·

関数: cov (matrix)

  多変量標本の共分散行列です。以下のように定義されます。

                    n
                   ====
                1  \           _        _
            S = -   >    (X  - X) (X  - X)'
                n  /       j        j
                   ====
                   j = 1

  ここでX_jは標本行列のj番目の行です。

  例:

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix (file_search ("wind.data"))$
      (%i3) fpprintprec : 7$  /* change precision for pretty output */

      (%i4) cov (s2);
            [ 17.22191  13.61811  14.37217  19.39624  15.42162 ]
            [                                                  ]
            [ 13.61811  14.98774  13.30448  15.15834  14.9711  ]
            [                                                  ]
      (%o4) [ 14.37217  13.30448  15.47573  17.32544  16.18171 ]
            [                                                  ]
            [ 19.39624  15.15834  17.32544  32.17651  20.44685 ]
            [                                                  ]
            [ 15.42162  14.9711   16.18171  20.44685  24.42308 ]

  関数`cov1`も参照してください。

  Package descriptive ·

関数: cov1 (matrix)

  多変量標本の共分散行列です。以下のように定義されます。

                    n
                   ====
               1   \           _        _
         S  = ---   >    (X  - X) (X  - X)'
          1   n-1  /       j        j
                   ====
                   j = 1

  ここでX_jは標本行列のj番目の行です。

  例:

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix (file_search ("wind.data"))$
      (%i3) fpprintprec : 7$ /* change precision for pretty output */

      (%i4) cov1 (s2);
            [ 17.39587  13.75567  14.51734  19.59216  15.5774  ]
            [                                                  ]
            [ 13.75567  15.13913  13.43887  15.31145  15.12232 ]
            [                                                  ]
      (%o4) [ 14.51734  13.43887  15.63205  17.50044  16.34516 ]
            [                                                  ]
            [ 19.59216  15.31145  17.50044  32.50153  20.65338 ]
            [                                                  ]
            [ 15.5774   15.12232  16.34516  20.65338  24.66977 ]

  関数`cov`も参照してください。

  Package descriptive ·

関数: global_variances (matrix)
関数: global_variances (matrix, logical_value)

  関数`global_variances`は大域分散尺度のリストを返します:

  - total variance: `trace(S_1)`,
  - mean variance: `trace(S_1)/p`,
  - generalized variance: `determinant(S_1)`,
  - generalized standard deviation: `sqrt(determinant(S_1))`,
  - efective variance `determinant(S_1)^(1/p)`, (以下の文献で定義されています: Peña, D. (2002) Análisis de datos multivariantes; McGraw-Hill, Madrid.)
  - efective standard deviation: `determinant(S_1)^(1/(2*p))`.

  ここでpは多変量確率変数の次元であり、 S_1は`cov1`が返す共分散行列です。

  例:

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix (file_search ("wind.data"))$

      (%i3) global_variances (s2);
      (%o3) [105.338342060606, 21.06766841212119, 12874.34690469686,
               113.4651792608501, 6.636590811800795, 2.576158149609762]

  関数`global_variances`はオプションの論理引数を取ります: `global_variances(x,true)`は、 Maximaに`x`がデータ行列であることを伝え、`global_variances(x)`と同様に作られます。 一方、`global_variances(x,false)`は `x`がデータ行列ではなく、共分散行列であることを意味し、再計算は避けられます。

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix (file_search ("wind.data"))$
      (%i3) s : cov1 (s2)$

      (%i4) global_variances (s, false);
      (%o4) [105.338342060606, 21.06766841212119, 12874.34690469686,
               113.4651792608501, 6.636590811800795, 2.576158149609762]

  `cov`と`cov1`も参照してください。

  Package descriptive ·

関数: cor (matrix)
関数: cor (matrix, logical_value)

  多変量標本の相関行列です。

  例:

      (%i1) load ("descriptive")$
      (%i2) fpprintprec : 7 $
      (%i3) s2 : read_matrix (file_search ("wind.data"))$

      (%i4) cor (s2);
            [   1.0     .8476339  .8803515  .8239624  .7519506 ]
            [                                                  ]
            [ .8476339    1.0     .8735834  .6902622  0.782502 ]
            [                                                  ]
      (%o4) [ .8803515  .8735834    1.0     .7764065  .8323358 ]
            [                                                  ]
            [ .8239624  .6902622  .7764065    1.0     .7293848 ]
            [                                                  ]
            [ .7519506  0.782502  .8323358  .7293848    1.0    ]

  関数`cor`はオプションの論理引数を取ります: `cor(x,true)`は、 Maximaに`x`がデータ行列であることを伝え、`cor(x)`と同様に作られます。 一方、`cor(x,false)`は `x`がデータ行列ではなく、共分散行列であることを意味し、再計算は避けられます。

      (%i1) load ("descriptive")$
      (%i2) fpprintprec : 7 $
      (%i3) s2 : read_matrix (file_search ("wind.data"))$
      (%i4) s : cov1 (s2)$

      (%i5) cor (s, false); /* this is faster */
            [   1.0     .8476339  .8803515  .8239624  .7519506 ]
            [                                                  ]
            [ .8476339    1.0     .8735834  .6902622  0.782502 ]
            [                                                  ]
      (%o5) [ .8803515  .8735834    1.0     .7764065  .8323358 ]
            [                                                  ]
            [ .8239624  .6902622  .7764065    1.0     .7293848 ]
            [                                                  ]
            [ .7519506  0.782502  .8323358  .7293848    1.0    ]

  `cov`と`cov1`も参照してください。

  Package descriptive ·

関数: list_correlations (matrix)
関数: list_correlations (matrix, logical_value)

  関数`list_correlations`は相関尺度のリストを返します:

  - precision matrix: 共分散行列S_1の逆行列,

               -1     ij
              S   = (s  )
               1         i,j = 1,2,...,p

  - multiple correlation vector: (R_1^2, R_2^2, ..., R_p^2),

               2          1
              R  = 1 - -------
               i        ii
                       s   s
                            ii

    変数の残りが独立変数として使われるとき これらはX_i上の線形多変量回帰モデルの適合度の指標です。

  - partial correlation matrix: (i, j)成分が以下の行列

                                 ij
                                s
              r        = - ------------
               ij.rest     / ii  jj\ 1/2
                           |s   s  |
                           \       /

  例:

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix (file_search ("wind.data"))$
      (%i3) z : list_correlations (s2)$
      (%i4) fpprintprec : 5$ /* for pretty output */

      (%i5) z[1];  /* precision matrix */
            [  .38486   - .13856   - .15626   - .10239    .031179  ]
            [                                                      ]
            [ - .13856   .34107    - .15233    .038447   - .052842 ]
            [                                                      ]
      (%o5) [ - .15626  - .15233    .47296    - .024816  - .10054  ]
            [                                                      ]
            [ - .10239   .038447   - .024816   .10937    - .034033 ]
            [                                                      ]
            [ .031179   - .052842  - .10054   - .034033   .14834   ]

      (%i6) z[2];  /* multiple correlation vector */
      (%o6)      [.85063, .80634, .86474, .71867, .72675]

      (%i7) z[3];  /* partial correlation matrix */
            [  - 1.0     .38244   .36627   .49908   - .13049 ]
            [                                                ]
            [  .38244    - 1.0    .37927  - .19907   .23492  ]
            [                                                ]
      (%o7) [  .36627    .37927   - 1.0    .10911    .37956  ]
            [                                                ]
            [  .49908   - .19907  .10911   - 1.0     .26719  ]
            [                                                ]
            [ - .13049   .23492   .37956   .26719    - 1.0   ]

  関数`list_correlations`もオプションの論理引数を取ります: `list_correlations(x,true)`は、 Maximaに`x`がデータ行列であることを伝え、 `list_correlations(x)`と同様に作られます。 一方、`list_correlations(x,false)`は `x`がデータ行列ではなく、共分散行列であることを意味し、再計算は避けられます。

  `cov`と`cov1`も参照してください。

  Package descriptive ·

Previous: Functions and Variables for descriptive statistics, Up: descriptive [Contents][Index]

### 45.4 Functions and Variables for statistical graphs

関数: barsplot (data1, data2, …, option_1, option_2, …)
関数: barsplot_description (…)

  1変量、多変量どちらの標本でも離散統計変数の棒グラフをプロットします

  dataは1標本を意味する結果のリストかもしれませんし、 それぞれサイズmのn個の標本を意味するm行n列の行列かもしれません。

  利用可能なオプションは以下のものです:

  - `draw`パッケージで定義されたもの。
  - box_width (デフォルト, `3/4`): 長方形の相対幅。 値は範囲`[0,1]`内でなければいけません。
  - grouping (デフォルト, `clustered`): 複数の標本をいかに表示するか示します。 有効な値: `clustered`と `stacked`。
  - groups_gap (デフォルト, `1`): 棒の2つの隣り合うグループの隙間を表す正の整数。
  - bars_colors (デフォルト, `[]`): 複数の標本のための色のリスト。 指定された色よりもたくさん標本がある時は、 追加で必要な色はランダムに選ばれます。 更に詳しくは`color`を参照してください。
  - frequency (デフォルト, `absolute`): 縦座標のスケールを示します。 可能な値: `absolute`, `relative`, `percent`。
  - ordering (デフォルト, `orderlessp`): 可能な値は`orderlessp`か`ordergreatp`です。 統計的結果がどちら向きにx軸に並んでいるかを示します。
  - sample_keys (デフォルト, `[]`): 凡例に使われる文字列のリスト。 リストの長さが0か標本の長さ以外なら、 エラーメッセージを返します。
  - start_at (デフォルト, `0`): x軸上のどこからプロットされるか示します。
  - `barsplot`が内部で割り当てる `xtics`を除くすべてのグローバル `draw`オプション もしこのオプションに自分の値を設定し、複雑なシーンを構築したいなら、 `barsplot_description`を使用してください。 以下の例を参照してください。
  - 以下のローカル `draw`オプション: `key`, `color`, `fill_color`, `fill_density`, `line_width`。 `bars`も参照してください。

  関数`barsplot_description`は 他のグラフィックオブジェクトと一緒に複雑なシーンを生成するために グラフィックオブジェクトを生成します。 wxMaximaとiMaximaインターフェイスで埋め込みヒストグラムを生成するための 関数`wxbarsplot`もあります。

  例:

  行列形式での1変量標本。絶対頻度。

      (%i1) load ("descriptive")$
      (%i2) m : read_matrix (file_search ("biomed.data"))$

      (%i3) barsplot(
              col(m,2),
              title        = "Ages",
              xlabel       = "years",
              box_width    = 1/2,
              fill_density = 3/4)$

  異なるサイズの2つの標本。 相対頻度とユーザー宣言の色を使って。

      (%i1) load ("descriptive")$
      (%i2) l1:makelist(random(10),k,1,50)$
      (%i3) l2:makelist(random(10),k,1,100)$

      (%i4) barsplot(
              l1,l2,
              box_width    = 1,
              fill_density = 1,
              bars_colors  = [black, grey],
              frequencies = relative,
              sample_keys = ["A", "B"])$

  サイズが等しい4つの非数標本。

      (%i1) load ("descriptive")$

      (%i2) barsplot(
              makelist([Yes, No, Maybe][random(3)+1],k,1,50),
              makelist([Yes, No, Maybe][random(3)+1],k,1,50),
              makelist([Yes, No, Maybe][random(3)+1],k,1,50),
              makelist([Yes, No, Maybe][random(3)+1],k,1,50),
              title  = "Asking for something to four groups",
              ylabel = "# of individuals",
              groups_gap   = 3,
              fill_density = 0.5,
              ordering     = ordergreatp)$

  スタックバー。

      (%i1) load ("descriptive")$

      (%i2) barsplot(
              makelist([Yes, No, Maybe][random(3)+1],k,1,50),
              makelist([Yes, No, Maybe][random(3)+1],k,1,50),
              makelist([Yes, No, Maybe][random(3)+1],k,1,50),
              makelist([Yes, No, Maybe][random(3)+1],k,1,50),
              title  = "Asking for something to four groups",
              ylabel = "# of individuals",
              grouping     = stacked,
              fill_density = 0.5,
              ordering     = ordergreatp)$

  複数プロット文脈での`barsplot`。

      (%i1) load ("descriptive")$
      (%i2) l1:makelist(random(10),k,1,50)$
      (%i3) l2:makelist(random(10),k,1,100)$
      (%i4) bp1 :
              barsplot_description(
               l1,
               box_width = 1,
               fill_density = 0.5,
               bars_colors = [blue],
               frequency = relative)$
      (%i5) bp2 :
              barsplot_description(
               l2,
               box_width = 1,
               fill_density = 0.5,
               bars_colors = [red],
               frequency = relative)$
      (%i6) draw(gr2d(bp1), gr2d(bp2))$

  棒グラフ関連オプションについては、パッケージ`draw`の`bars`を参照してください。 関数`histogram`と`piechart`も参照してください。

  Package descriptive ·Plotting ·

関数: boxplot (data)
関数: boxplot (data, option_1, option_2, …)
関数: boxplot_description ( …)

  この関数は箱ひげ図をプロットします。 引数dataはリストだったり行列だったりします。 箱ひげ図は主に異なる標本の比較に使われるので、リストはあまり興味深くありません。 行列の場合には多変量統計変数の複数成分おw比較することが可能です。 しかし、できる限り異なる標本サイズの標本のリストも許すようにしています。 実際、これは、パッケージ`descriptive`の中で この種のデータ構造を許容する唯一の関数です

  利用可能なオプションは以下のものです:

  - box_width (デフォルト, `3/4`): 箱の相対幅。 この値は範囲`[0,1]`内でなければいけません。
  - box_orientation (デフォルト, `vertical`): 可能な値: `vertical` と `horizontal`。
  - `boxplot`が内部で割り当てる `points_joined`, `point_size`, `point_type`, `xtics`, `ytics`, `xrange`, `yrange`を除く すべての `draw`オプション。 もしこのオプションに自分の値を設定し、複雑なシーンを構築したいなら、 `boxplot_description`を使用してください。
  - 以下のローカル `draw`オプション: `key`, `color`, `line_width`。

  関数`boxplot_description`は 他のグラフィックオブジェクトと一緒に複雑なシーンを生成するために グラフィックオブジェクトを生成します。 wxMaximaとiMaximaインターフェイスで埋め込みヒストグラムを生成するための 関数`wxbarsplot`もあります。

  例:

  多変量標本の箱ひげ図。

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix(file_search("wind.data"))$

      (%i3) boxplot(s2,
              box_width  = 0.2,
              title      = "Windspeed in knots",
              xlabel     = "Stations",
              color      = red,
              line_width = 2)$

  異なるサイズの3つの標本の箱ひげ図。

      (%i1) load ("descriptive")$

      (%i2) A :
             [[6, 4, 6, 2, 4, 8, 6, 4, 6, 4, 3, 2],
              [8, 10, 7, 9, 12, 8, 10],
              [16, 13, 17, 12, 11, 18, 13, 18, 14, 12]]$

      (%i3) boxplot (A, box_orientation = horizontal)$

  Package descriptive ·Plotting ·

関数: histogram (list)
関数: histogram (list, option_1, option_2, …)
関数: histogram (one_column_matrix)
関数: histogram (one_column_matrix, option_1, option_2, …)
関数: histogram (one_row_matrix)
関数: histogram (one_row_matrix, option_1, option_2, …)
関数: histogram_description (…)

  この関数は一連の標本からヒストグラムをプロットします。 標本データは数のリストか一次元行列に保存しなければいけません。

  利用可能なオプションは以下のものです:

  - nclasses (デフォルト, `10`): ヒストグラムのクラス数、もしくは クラスの境界と数か境界だけを含むリスト。
  - frequency (デフォルト, `absolute`): 縦座標のスケールを示します。 可能な値: `absolute`, `relative`, `percent`。
  - htics (デフォルト, `auto`): ヒストグラムチックのフォーマット。 可能な値: `auto`, `endpoints`, `intervals`, かラベルのリスト。
  - `histogram`が内部で割り当てる`xrange`, `yrange`, `xtics`を除く すべてのグローバル `draw`オプション。 もしこれらのオプションに自分の値を設定したいなら、 `histogram_description`を利用してください。 以下の例を参照してください。
  - 以下のローカル `draw`オプション: `key`, `color`, `fill_color`, `fill_density`と `line_width`. `bars`も参照してください。

  関数 `histogram_description`は他のグラフィックオブジェクトと一緒に 複雑なシーンを生成するのに適したグラフィックオブジェクトを生成します。 wxMaximaと iMaximaインターフェイスで埋め込みヒストグラムを生成する 関数`wxhistogram`もあります。

  例:

  8クラスを持つ簡単なヒストグラム。

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$
      (%i3) histogram (
                 s1,
                 nclasses     = 8,
                 title        = "pi digits",
                 xlabel       = "digits",
                 ylabel       = "Absolute frequency",
                 fill_color   = grey,
                 fill_density = 0.6)$

  ヒストグラムの境界を-2と12に、クラス数を3に設定します。 また予め定義されたチックを導入します:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$
      (%i3) histogram (
                 s1,
                 nclasses     = [-2,12,3],
                 htics        = ["A", "B", "C"],
                 terminal     = png,
                 fill_color   = "#23afa0",
                 fill_density = 0.6)$

  `xrange`を設定しシーンの中に明示的な曲線を足すのに `histogram_description`を利用します:

      (%i1) load ("descriptive")$
      (%i2) ( load("distrib"),
              m: 14, s: 2,
              s2: random_normal(m, s, 1000) ) $
      (%i3) draw2d(
              grid   = true,
              xrange = [5, 25],
              histogram_description(
                s2,
                nclasses     = 9,
                frequency    = relative,
                fill_density = 0.5),
              explicit(pdf_normal(x,m,s), x, m - 3*s, m + 3* s))$

  Package descriptive ·Plotting ·

関数: piechart (list)
関数: piechart (list, option_1, option_2, …)
関数: piechart (one_column_matrix)
関数: piechart (one_column_matrix, option_1, option_2, …)
関数: piechart (one_row_matrix)
関数: piechart (one_row_matrix, option_1, option_2, …)
関数: piechart_description (…)

  `barsplot`に似ていますが、長方形の代わりに扇をプロットします。

  利用可能なオプションは以下のものです:

  - sector_colors (デフォルト, `[]`): セクタの色のリスト。 指定した色よりも多くセクタがあるときは、必要な色の超過分がランダムに選ばれます。 それらについて更に知るには `color`を参照してください。
  - pie_center (デフォルト, `[0,0]`): 円グラフの中心。
  - pie_radius(デフォルト, `1`): 円グラフの半径。
  - `piechart`が内部で割り当てる`key`を除いたすべてのグローバル `draw`オプション。 もしこのオプションに自分の値を設定し、複雑なシーンを構築したいなら、 `piechart_description`を利用してください。
  - 以下のローカル `draw`オプション: `key`, `color`, `fill_display`, `line_width`。 `ellipse`も参照してください。

  関数 `piechart_description`は他のグラフィックオブジェクトと一緒に 複雑なシーンを生成するのに適したグラフィックオブジェクトを生成します。 wxMaximaと iMaximaインターフェイスで埋め込みヒストグラムを生成する 関数`wxhistogram`もあります。

  例:

      (%i1) load ("descriptive")$
      (%i2) s1 : read_list (file_search ("pidigits.data"))$
      (%i3) piechart(
              s1,
              xrange = [-1.1, 1.3],
              yrange = [-1.1, 1.1],
              title  = "Digit frequencies in pi")$

  関数`barsplot`も参照してください。

  Package descriptive ·Plotting ·

関数: scatterplot (list)
関数: scatterplot (list, option_1, option_2, …)
関数: scatterplot (matrix)
関数: scatterplot (matrix, option_1, option_2, …)
関数: scatterplot_description (…)

  1変量(list)や多変量(matrix)の標本の散布図をプロットします。

  利用可能なオプションは `histogram`が許すものと同じです。

  関数 `scatterplot_description`は他のグラフィックオブジェクトと一緒に 複雑なシーンを生成するのに適したグラフィックオブジェクトを生成します。 wxMaximaと iMaximaインターフェイスで埋め込みヒストグラムを生成する 関数`wxscatterplot`もあります。

  例:

  シミュレーティッドGauss標本の1変量散布図。

      (%i1) load ("descriptive")$
      (%i2) load ("distrib")$

      (%i3) scatterplot(
              random_normal(0,1,200),
              xaxis      = true,
              point_size = 2,
              dimensions = [600,150])$

  二次元散布図。

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix (file_search ("wind.data"))$

      (%i3) scatterplot(
             submatrix(s2, 1,2,3),
             title      = "Data from stations #4 and #5",
             point_type = diamant,
             point_size = 2,
             color      = blue)$

  3次元散布図。

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix (file_search ("wind.data"))$
      (%i3) scatterplot(submatrix (s2, 1,2), nclasses=4)$

  5つのクラスのヒストグラムと5次元散布図。

      (%i1) load ("descriptive")$
      (%i2) s2 : read_matrix (file_search ("wind.data"))$

      (%i3) scatterplot(
              s2,
              nclasses     = 5,
              frequency    = relative,
              fill_color   = blue,
              fill_density = 0.3,
              xtics        = 5)$

  2次元か3次元で孤立点か線で結んだ点をプロットすることについては、 `points`を参照してください。 `histogram`も参照してください。

  Package descriptive ·Plotting ·

関数: starplot (data1, data2, …, option_1, option_2, …)
関数: starplot_description (…)

  1変量、多変量どちらの標本でも離散統計変数のスターダイアグラムをプロットします

  dataは1標本を意味する結果のリストかもしれませんし、 それぞれサイズmのn個の標本を意味するm行n列の行列かもしれません。

  利用可能なオプションは以下のものです:

  - stars_colors (デフォルト, `[]`): 多変量標本の色のリスト。 指定した色よりも多くセクタがあるときは、必要な色の超過分がランダムに選ばれます。 それらについて更に知るには `color`を参照してください。
  - frequency (デフォルト, `absolute`): 半径のスケールを示します。 可能な値: `absolute`, `relative`, `percent`。
  - ordering (デフォルト, `orderlessp`): 可能な値は`orderlessp`か`ordergreatp`です。 統計的結果がどちら向きにx軸に並んでいるかを示します。
  - sample_keys (デフォルト, `[]`): 凡例に使われる文字列のリスト。 リストの長さが0か標本の長さ以外なら、 エラーメッセージを返します。
  - star_center (デフォルト, `[0,0]`): ダイアグラムの中心。
  - star_radius (デフォルト, `1`): ダイアグラムの半径。
  - `starplot`が内部で割り当てる`points_joined`, `point_type`, `key`を除いたすべてのグローバル `draw`オプション。 もしこのオプションに自分の値を設定し、複雑なシーンを構築したいなら、 `starplot_description`を利用してください。
  - 以下のローカル `draw`オプション: `line_width`。

  関数 `starplot_description`は他のグラフィックオブジェクトと一緒に 複雑なシーンを生成するのに適したグラフィックオブジェクトを生成します。 wxMaximaと iMaximaインターフェイスで埋め込みヒストグラムを生成する 関数`wxstarplot`もあります。

  例:

  絶対頻度に基づいたプロット。 ユーザーが定義した位置と半径。

      (%i1) load ("descriptive")$
      (%i2) l1: makelist(random(10),k,1,50)$
      (%i3) l2: makelist(random(10),k,1,200)$

      (%i4) starplot(
              l1, l2,
              stars_colors = [blue,red],
              sample_keys = ["1st sample", "2nd sample"],
              star_center = [1,2],
              star_radius = 4,
              proportional_axes = xy,
              line_width = 2 ) $

  Package descriptive ·Plotting ·

関数: stemplot (data)
関数: stemplot (data, option)

  幹葉図をプロットします。

  固有の利用可能なオプションは:

  - leaf_unit (デフォルト, `1`): 葉の単位を示します; 10のべきでなければいけません。

  例:

      (%i1) load ("descriptive")$
      (%i2) load("distrib")$

      (%i3) stemplot(
              random_normal(15, 6, 100),
              leaf_unit = 0.1);
      -5|4
       0|37
       1|7
       3|6
       4|4
       5|4
       6|57
       7|0149
       8|3
       9|1334588
      10|07888
      11|01144467789
      12|12566889
      13|24778
      14|047
      15|223458
      16|4
      17|11557
      18|000247
      19|4467799
      20|00
      21|1
      22|2335
      23|01457
      24|12356
      25|455
      27|79
      key: 6|3 =  6.3
      (%o3)                  done

  Package descriptive ·Plotting ·

Next: distrib, Previous: descriptive, Up: Top [Contents][Index]

## 46 diag

Previous: diag, Up: diag [Contents][Index]

### 46.1 Functions and Variables for diag

関数: diag (lm)

  lmの行列を対角に持つ平方行列を構成します。 lmは行列かスカラーのリストです。

  例:

      (%i1) load("diag")$

      (%i2) a1:matrix([1,2,3],[0,4,5],[0,0,6])$

      (%i3) a2:matrix([1,1],[1,0])$

      (%i4) diag([a1,x,a2]);
                         [ 1  2  3  0  0  0 ]
                         [                  ]
                         [ 0  4  5  0  0  0 ]
                         [                  ]
                         [ 0  0  6  0  0  0 ]
      (%o4)              [                  ]
                         [ 0  0  0  x  0  0 ]
                         [                  ]
                         [ 0  0  0  0  1  1 ]
                         [                  ]
                         [ 0  0  0  0  1  0 ]

  この関数を使うためには、最初に`load("diag")`を書いてください。

  Matrices ·Share packages ·Package diag ·

関数: JF (lambda,n)

  固有値lambdaを持つ次数nのJordan細胞を返します。

  例:

      (%i1) load("diag")$

      (%i2) JF(2,5);
                          [ 2  1  0  0  0 ]
                          [               ]
                          [ 0  2  1  0  0 ]
                          [               ]
      (%o2)               [ 0  0  2  1  0 ]
                          [               ]
                          [ 0  0  0  2  1 ]
                          [               ]
                          [ 0  0  0  0  2 ]
      (%i3) JF(3,2);
                               [ 3  1 ]
      (%o3)                    [      ]
                               [ 0  3 ]

  この関数を使うためには、最初に`load("diag")`を書いてください。

  Package diag ·

関数: jordan (mat)

  行列matのJordan形を返しますが、それはMaximaリストでコード化されます。 対応する行列を得るには、 `jordan`の出力を引数として使って関数`dispJordan`をコールしてください。

  例:

      (%i1) load("diag")$

      (%i3) a:matrix([2,0,0,0,0,0,0,0],
                     [1,2,0,0,0,0,0,0],
                     [-4,1,2,0,0,0,0,0],
                     [2,0,0,2,0,0,0,0],
                     [-7,2,0,0,2,0,0,0],
                     [9,0,-2,0,1,2,0,0],
                     [-34,7,1,-2,-1,1,2,0],
                     [145,-17,-16,3,9,-2,0,3])$

      (%i34) jordan(a);
      (%o4)             [[2, 3, 3, 1], [3, 1]]
      (%i5) dispJordan(%);
                      [ 2  1  0  0  0  0  0  0 ]
                      [                        ]
                      [ 0  2  1  0  0  0  0  0 ]
                      [                        ]
                      [ 0  0  2  0  0  0  0  0 ]
                      [                        ]
                      [ 0  0  0  2  1  0  0  0 ]
      (%o5)           [                        ]
                      [ 0  0  0  0  2  1  0  0 ]
                      [                        ]
                      [ 0  0  0  0  0  2  0  0 ]
                      [                        ]
                      [ 0  0  0  0  0  0  2  0 ]
                      [                        ]
                      [ 0  0  0  0  0  0  0  3 ]

  この関数を使うためには、最初に`load("diag")`を書いてください。 `dispJordan`と`minimalPoly`も参照してください。

  Package diag ·

関数: dispJordan (l)

  関数`jordan`によって与えられる出力である Maximaリストlで与えられたコードに関連付けられた Jordan行列を返します。

  例:

      (%i1) load("diag")$

      (%i2) b1:matrix([0,0,1,1,1],
                      [0,0,0,1,1],
                      [0,0,0,0,1],
                      [0,0,0,0,0],
                      [0,0,0,0,0])$

      (%i3) jordan(b1);
      (%o3)                  [[0, 3, 2]]
      (%i4) dispJordan(%);
                          [ 0  1  0  0  0 ]
                          [               ]
                          [ 0  0  1  0  0 ]
                          [               ]
      (%o4)               [ 0  0  0  0  0 ]
                          [               ]
                          [ 0  0  0  0  1 ]
                          [               ]
                          [ 0  0  0  0  0 ]

  この関数を使うためには、最初に`load("diag")`を書いてください。 `jordan`と`minimalPoly`も参照してください。

  Package diag ·

関数: minimalPoly (l)

  関数`jordan`によって与えられる出力である Maximaリストlで与えられたコードに関連付けられた 最小多項式を返します。

  例:

      (%i1) load("diag")$

      (%i2) a:matrix([2,1,2,0],
                     [-2,2,1,2],
                     [-2,-1,-1,1],
                     [3,1,2,-1])$

      (%i3) jordan(a);
      (%o3)               [[- 1, 1], [1, 3]]
      (%i4) minimalPoly(%);
                                  3
      (%o4)                (x - 1)  (x + 1)

  この関数を使うためには、最初に`load("diag")`を書いてください。 `jordan`と`dispJordan`も参照してください。

  Package diag ·

関数: ModeMatrix (A,l)

  Returns the matrix (M^^-1).A.M=J― ただしJはAのJordan形とする― のような 行列Mを返します。 Maximaリストlは 関数`jordan`が返すようなJordan形のコード化された形式です。

  例:

      (%i1) load("diag")$

      (%i2) a:matrix([2,1,2,0],
                [-2,2,1,2],
                [-2,-1,-1,1],
                [3,1,2,-1])$

      (%i3) jordan(a);
      (%o3)               [[- 1, 1], [1, 3]]
      (%i4) M: ModeMatrix(a,%);
                        [  1    - 1   1   1 ]
                        [                   ]
                        [   1               ]
                        [ - -   - 1   0   0 ]
                        [   9               ]
                        [                   ]
      (%o4)             [   13              ]
                        [ - --   1   - 1  0 ]
                        [   9               ]
                        [                   ]
                        [  17               ]
                        [  --   - 1   1   1 ]
                        [  9                ]
      (%i5) is(  (M^^-1).a.M = dispJordan(%o3)  );
      (%o5)                      true

  `dispJordan(%o3)`は 行列`a`のJordan形であることに注意してください。

  この関数を使うためには、最初に`load("diag")`を書いてください。 `jordan`と`dispJordan`も参照してください。

  Package diag ·

関数: mat_function (f,mat)

  f(mat)を返します。 ここで、fは解析関数でmatは行列です。 この計算はCauchyの積分公式に基づきます。 積分公式は、 もし`f(x)`が解析的、かつ、

      mat = diag([JF(m1,n1),...,JF(mk,nk)]),

  なら、

      f(mat) = ModeMatrix*diag([f(JF(m1,n1)), ..., f(JF(mk,nk))])
                                                    *ModeMatrix^^(-1)

  をはっきり述べます。

  この計算に関して約6か8の別の方法があることに注意してください。

  いくつかの例が続きます。

  例 1:

      (%i1) load("diag")$

      (%i2) b2:matrix([0,1,0], [0,0,1], [-1,-3,-3])$

      (%i3) mat_function(exp,t*b2);
                     2   - t
                    t  %e          - t     - t
      (%o3) matrix([-------- + t %e    + %e   ,
                       2
              - t     - t                           - t
       2    %e      %e        - t           - t   %e
      t  (- ----- - ----- + %e   ) + t (2 %e    - -----)
              t       2                             t
                     t
                               - t          - t     - t
             - t       - t   %e        2  %e      %e
       + 2 %e   , t (%e    - -----) + t  (----- - -----)
                               t            2       t
                     2   - t            - t     - t
           - t      t  %e        2    %e      %e        - t
       + %e   ], [- --------, - t  (- ----- - ----- + %e   ),
                       2                t       2
                                               t
              - t     - t      2   - t
         2  %e      %e        t  %e          - t
      - t  (----- - -----)], [-------- - t %e   ,
              2       t          2
              - t     - t                           - t
       2    %e      %e        - t           - t   %e
      t  (- ----- - ----- + %e   ) - t (2 %e    - -----),
              t       2                             t
                     t
            - t     - t                 - t
       2  %e      %e            - t   %e
      t  (----- - -----) - t (%e    - -----)])
            2       t                   t
      (%i4) ratsimp(%);
                     [   2              - t ]
                     [ (t  + 2 t + 2) %e    ]
                     [ -------------------- ]
                     [          2           ]
                     [                      ]
                     [         2   - t      ]
      (%o4)  Col 1 = [        t  %e         ]
                     [      - --------      ]
                     [           2          ]
                     [                      ]
                     [     2          - t   ]
                     [   (t  - 2 t) %e      ]
                     [   ----------------   ]
                     [          2           ]
               [      2        - t    ]
               [    (t  + t) %e       ]
               [                      ]
       Col 2 = [     2            - t ]
               [ - (t  - t - 1) %e    ]
               [                      ]
               [     2          - t   ]
               [   (t  - 3 t) %e      ]
               [        2   - t       ]
               [       t  %e          ]
               [       --------       ]
               [          2           ]
               [                      ]
               [      2          - t  ]
       Col 3 = [    (t  - 2 t) %e     ]
               [  - ----------------  ]
               [           2          ]
               [                      ]
               [   2              - t ]
               [ (t  - 4 t + 2) %e    ]
               [ -------------------- ]
               [          2           ]

  例 2:

      (%i5) b1:matrix([0,0,1,1,1],
                      [0,0,0,1,1],
                      [0,0,0,0,1],
                      [0,0,0,0,0],
                      [0,0,0,0,0])$

      (%i6) mat_function(exp,t*b1);
                        [              2     ]
                        [             t      ]
                        [ 1  0  t  t  -- + t ]
                        [             2      ]
                        [                    ]
      (%o6)             [ 0  1  0  t    t    ]
                        [                    ]
                        [ 0  0  1  0    t    ]
                        [                    ]
                        [ 0  0  0  1    0    ]
                        [                    ]
                        [ 0  0  0  0    1    ]
      (%i7) minimalPoly(jordan(b1));
                                   3
      (%o7)                       x
      (%i8) ident(5)+t*b1+1/2*(t^2)*b1^^2;
                        [              2     ]
                        [             t      ]
                        [ 1  0  t  t  -- + t ]
                        [             2      ]
                        [                    ]
      (%o8)             [ 0  1  0  t    t    ]
                        [                    ]
                        [ 0  0  1  0    t    ]
                        [                    ]
                        [ 0  0  0  1    0    ]
                        [                    ]
                        [ 0  0  0  0    1    ]
      (%i9) mat_function(exp,%i*t*b1);
                   [                           2 ]
                   [                          t  ]
                   [ 1  0  %i t  %i t  %i t - -- ]
                   [                          2  ]
                   [                             ]
      (%o9)        [ 0  1   0    %i t    %i t    ]
                   [                             ]
                   [ 0  0   1     0      %i t    ]
                   [                             ]
                   [ 0  0   0     1        0     ]
                   [                             ]
                   [ 0  0   0     0        1     ]
      (%i10) mat_function(cos,t*b1)+%i*mat_function(sin,t*b1);
                    [                           2 ]
                    [                          t  ]
                    [ 1  0  %i t  %i t  %i t - -- ]
                    [                          2  ]
                    [                             ]
      (%o10)        [ 0  1   0    %i t    %i t    ]
                    [                             ]
                    [ 0  0   1     0      %i t    ]
                    [                             ]
                    [ 0  0   0     1        0     ]
                    [                             ]
                    [ 0  0   0     0        1     ]

  例 3:

      (%i11) a1:matrix([2,1,0,0,0,0],
                       [-1,4,0,0,0,0],
                       [-1,1,2,1,0,0],
                       [-1,1,-1,4,0,0],
                       [-1,1,-1,1,3,0],
                       [-1,1,-1,1,1,2])$

      (%i12) fpow(x):=block([k],declare(k,integer),x^k)$

      (%i13) mat_function(fpow,a1);
                      [  k      k - 1 ]         [      k - 1    ]
                      [ 3  - k 3      ]         [   k 3         ]
                      [               ]         [               ]
                      [       k - 1   ]         [  k      k - 1 ]
                      [  - k 3        ]         [ 3  + k 3      ]
                      [               ]         [               ]
                      [       k - 1   ]         [      k - 1    ]
                      [  - k 3        ]         [   k 3         ]
      (%o13)  Col 1 = [               ] Col 2 = [               ]
                      [       k - 1   ]         [      k - 1    ]
                      [  - k 3        ]         [   k 3         ]
                      [               ]         [               ]
                      [       k - 1   ]         [      k - 1    ]
                      [  - k 3        ]         [   k 3         ]
                      [               ]         [               ]
                      [       k - 1   ]         [      k - 1    ]
                      [  - k 3        ]         [   k 3         ]
               [       0       ]         [       0       ]
               [               ]         [               ]
               [       0       ]         [       0       ]
               [               ]         [               ]
               [  k      k - 1 ]         [      k - 1    ]
               [ 3  - k 3      ]         [   k 3         ]
               [               ]         [               ]
       Col 3 = [       k - 1   ] Col 4 = [  k      k - 1 ]
               [  - k 3        ]         [ 3  + k 3      ]
               [               ]         [               ]
               [       k - 1   ]         [      k - 1    ]
               [  - k 3        ]         [   k 3         ]
               [               ]         [               ]
               [       k - 1   ]         [      k - 1    ]
               [  - k 3        ]         [   k 3         ]
               [    0    ]
               [         ]         [ 0  ]
               [    0    ]         [    ]
               [         ]         [ 0  ]
               [    0    ]         [    ]
               [         ]         [ 0  ]
       Col 5 = [    0    ] Col 6 = [    ]
               [         ]         [ 0  ]
               [    k    ]         [    ]
               [   3     ]         [ 0  ]
               [         ]         [    ]
               [  k    k ]         [  k ]
               [ 3  - 2  ]         [ 2  ]

  この関数を使うためには、最初に`load("diag")`を書いてください。

  Package diag ·

Next: draw, Previous: diag, Up: Top [Contents][Index]

## 47 distrib

Next: Functions and Variables for continuous distributions, Previous: distrib, Up: distrib [Contents][Index]

### 47.1 Introduction to distrib

パッケージ `distrib`には 離散と連続両方の単変量モデル上の確率計算を行う関数一式が入っています。

以下は基本的な確率関連の定義の短い復習です。

f(x)を 絶対連続確率変数 Xの density function, 密度函数とします。 distribution function, 分布函数は以下のように定義されます。

                           x
                          /
                          [
                   F(x) = I     f(u) du
                          ]
                          /
                           minf

これは確率 Pr(X <= x)に等しいです。

mean, 平均値は局所化パラメータで、以下のように定義されます。

                         inf
                        /
                        [
               E[X]  =  I   x f(x) dx
                        ]
                        /
                         minf

variance, 分散は変動の測度です。

                     inf
                    /
                    [                    2
             V[X] = I     f(x) (x - E[X])  dx
                    ]
                    /
                     minf

これは正の実数です。 分散の平方根は standard deviation, 標準偏差, D[X]=sqrt(V[X])で、 変動の別の測度です。

skewness coefficient, 歪度係数は非対称性の測度です。

                     inf
                    /
                1   [                    3
      SK[X] = ----- I     f(x) (x - E[X])  dx
                  3 ]
              D[X]  /
                     minf

kurtosis coefficient, 尖度係数は分布のとんがり具合を評価します。

                     inf
                    /
                1   [                    4
      KU[X] = ----- I     f(x) (x - E[X])  dx - 3
                  4 ]
              D[X]  /
                     minf

もし Xがガウシアンなら、 KU[X]=0です。 実際、歪度と尖度は分布の非ガウシアン性を評価するのに使われる形状パラメータです。

もし確率変数 Xが離散的なら、密度すなわち probability, 確率函数 f(x)は 数 x_iのある可算集合内で正値を取り、それ以外で0を取ります。 この場合、分布函数は以下の通りです。

                           ====
                           \
                    F(x) =  >    f(x )
                           /        i
                           ====
                          x <= x
                           i

平均、分散、標準偏差、歪度係数、尖度係数はそれぞれ以下の形を取ります。

                           ====
                           \
                    E[X] =  >  x  f(x ) ,
                           /    i    i
                           ====
                            x
                             i

                    ====
                    \                     2
            V[X] =   >    f(x ) (x - E[X])  ,
                    /        i    i
                    ====
                     x
                      i

                   D[X] = sqrt(V[X]),

                         ====
                  1      \                     3
      SK[X] =  -------    >    f(x ) (x - E[X])
               D[X]^3    /        i    i
                         ====
                          x
                           i

and

                         ====
                  1      \                     4
      KU[X] =  -------    >    f(x ) (x - E[X])   - 3 ,
               D[X]^4    /        i    i
                         ====
                          x
                           i

以下はパッケージ `distrib`での命名規則です。 すべての関数名は2つの部分を持ちます。 一番目の部分は計算したい函数やパラメータへの参照となります。

    Functions:
       Density function            (pdf_*)
       Distribution function       (cdf_*)
       Quantile                    (quantile_*)
       Mean                        (mean_*)
       Variance                    (var_*)
       Standard deviation          (std_*)
       Skewness coefficient        (skewness_*)
       Kurtosis coefficient        (kurtosis_*)
       Random variate              (random_*)

二番目の部分は確率モデルの明示的な参照になります。

    Continuous distributions:
       Normal              (*normal)
       Student             (*student_t)
       Chi^2               (*chi2)
       Noncentral Chi^2    (*noncentral_chi2)
       F                   (*f)
       Exponential         (*exp)
       Lognormal           (*lognormal)
       Gamma               (*gamma)
       Beta                (*beta)
       Continuous uniform  (*continuous_uniform)
       Logistic            (*logistic)
       Pareto              (*pareto)
       Weibull             (*weibull)
       Rayleigh            (*rayleigh)
       Laplace             (*laplace)
       Cauchy              (*cauchy)
       Gumbel              (*gumbel)

    Discrete distributions:
       Binomial             (*binomial)
       Poisson              (*poisson)
       Bernoulli            (*bernoulli)
       Geometric            (*geometric)
       Discrete uniform     (*discrete_uniform)
       hypergeometric       (*hypergeometric)
       Negative binomial    (*negative_binomial)
       Finite discrete      (*general_finite_discrete)

例えば、 `pdf_student_t(x,n)`はn個の自由度を持つStudent分布の密度函数で、 `std_pareto(a,b)`は パラメータ aと bを持つPareto分布の標準偏差であり、 `kurtosis_poisson(m)`は平均値 mを持つPoisson分布の尖度係数です。

パッケージ `distrib`を利用するには、初めに

    (%i1) load("distrib")$

とタイプしてそれをロードする必要があります。

ご意見、バグ、提案は著者 ’mario AT edu DOT xunta DOT es’に連絡ください。

Statistical functions ·Share packages ·Package distrib ·

Next: Functions and Variables for discrete distributions, Previous: Introduction to distrib, Up: distrib [Contents][Index]

### 47.2 Functions and Variables for continuous distributions

関数: pdf_normal (x,m,s)

  s>0で Normal(m,s)(正規)確率変数の密度函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_normal (x,m,s)

  s>0で Normal(m,s)(正規)確率変数の密度函数の xでの値を返します。 この関数はMaximaの組み込み誤差関数 `erf`を使って定義されます。

      (%i1) load ("distrib")$
      (%i2) assume(s>0)$ cdf_normal(x,m,s);
                                   x - m
                             erf(---------)
                                 sqrt(2) s    1
      (%o3)                  -------------- + -
                                   2          2

  `erf`も参照してください。

  Package distrib ·

関数: quantile_normal (q,m,s)

  s>0で Normal(m,s)(正規)確率変数の q分位数を返します。 言い換えると、これは `cdf_normal`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

      (%i1) load ("distrib")$
      (%i2) quantile_normal(95/100,0,1);
                                            9
      (%o2)             sqrt(2) inverse_erf(--)
                                            10
      (%i3) float(%);
      (%o3)               1.644853626951472

  Package distrib ·

関数: mean_normal (m,s)

  s>0で Normal(m,s)(正規)確率変数の平均、すなわち mを返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_normal (m,s)

  s>0で Normal(m,s)(正規)確率変数の分散、すなわち s^2を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_normal (m,s)

  s>0で Normal(m,s)(正規)確率変数の分散、すなわち sを返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_normal (m,s)

  s>0で Normal(m,s)(正規)確率変数の歪度を返します。それは常に0に等しいです。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_normal (m,s)

  s>0で Normal(m,s)(正規)確率変数の尖度を返します。それは常に0に等しいです。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_normal (m,s)
関数: random_normal (m,s,n)

  s>0で Normal(m,s)(正規)確率変量を返します。 三番目の引数 nとともに`random_normal`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  これはBox-Muellerアルゴリズムの実装です。 Knuth, D.E. (1981) Seminumerical Algorithms. The Art of Computer Programming. Addison-Wesleyに記載されています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_student_t (x,n)

  n>0自由度のStudent確率変数 t(n)の密度函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_student_t (x,n)

  n>0自由度のStudent確率変数 t(n)の分布函数の xでの値を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_student_t(1/2, 7/3);
                                               7  1  28
                   beta_incomplete_regularized(-, -, --)
                                               6  2  31
      (%o2)    1 - -------------------------------------
                                     2
      (%i3) float(%);
      (%o3)                .6698450596140415

  Package distrib ·

関数: quantile_student_t (q,n)

  n>0自由度のStudent確率変数 t(n)の q-分位数を返します。 言い換えると、これは `cdf_student_t`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_student_t (n)

  n>0自由度のStudent確率変数 t(n)の平均を返します。 それはいつも0に等しいです。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_student_t (n)

  n>2自由度のStudent確率変数 t(n)の分散を返します。

      (%i1) load ("distrib")$
      (%i2) assume(n>2)$  var_student_t(n);
                                      n
      (%o3)                         -----
                                    n - 2

  Package distrib ·

関数: std_student_t (n)

  n>2自由度のStudent確率変数 t(n)の標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_student_t (n)

  n>3自由度のStudent確率変数 t(n)の歪度係数を返します。 それはいつも0に等しいです。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_student_t (n)

  n>4自由度のStudent確率変数 t(n)の尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_student_t (n)
関数: random_student_t (n,m)

  n>0自由度のStudent確率変量 t(n)を返します。 三番目の引数 mとともに`random_student_t`をコールすると、 サイズ mのランダムな標本がシミュレートされます。

  実装アルゴリズムは、 もし Zが正規確率変数 N(0,1)で、 S^2がn自由度のカイ二乗確率変数 Chi^2(n)なら、

                                 Z
                       X = -------------
                           /   2  \ 1/2
                           |  S   |
                           | ---  |
                           \  n   /

  は n自由度のStudent確率変数 t(n)であるという事実に基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_noncentral_student_t (x,n,ncp)

  n>0自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数 nc_t(n,ncp)の密度函数のxでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  時々、最終結果を得るために余分な仕事が必要となります。

      (%i1) load ("distrib")$
      (%i2) expand(pdf_noncentral_student_t(3,5,0.1));
             .01370030107589574 sqrt(5)
      (%o2)  --------------------------
             sqrt(2) sqrt(14) sqrt(%pi)
         1.654562884111515E-4 sqrt(5)
       + ----------------------------
                  sqrt(%pi)
         .02434921505438663 sqrt(5)
       + --------------------------
                    %pi
      (%i3) float(%);
      (%o3)          .02080593159405669

  Package distrib ·

関数: cdf_noncentral_student_t (x,n,ncp)

  n>0自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数 nc_t(n,ncp)の分布函数のxでの値を返します。 この函数は閉形式を持たず、 もしグローバル変数`numer`が`true`に等しいか 引数の少なくとも1つが浮動小数点数なら、数値的に計算されます。 そうでなければ、名目上の式を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_noncentral_student_t(-2,5,-5);
      (%o2) cdf_noncentral_student_t(- 2, 5, - 5)
      (%i3) cdf_noncentral_student_t(-2.0,5,-5);
      (%o3)          .9952030093319743

  Package distrib ·

関数: quantile_noncentral_student_t (q,n,ncp)

  n>0自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数 nc_t(n,ncp)のq-分位数を返します。 言い換えると、これは `cdf_noncentral_student_t`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_noncentral_student_t (n,ncp)

  n>0自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数 nc_t(n,ncp)の平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

      (%i1) load ("distrib")$
      (%i2) (assume(df>1), mean_noncentral_student_t(df,k));
                         df - 1
                   gamma(------) sqrt(df) k
                           2
      (%o2)        ------------------------
                                    df
                      sqrt(2) gamma(--)
                                    2

  Package distrib ·

関数: var_noncentral_student_t (n,ncp)

  n>2自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数 nc_t(n,ncp)の分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_noncentral_student_t (n,ncp)

  n>2自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数 nc_t(n,ncp)の標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_noncentral_student_t (n,ncp)

  n>3自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数 nc_t(n,ncp)の歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_noncentral_student_t (n,ncp)

  n>3自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数 nc_t(n,ncp)の尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_noncentral_student_t (n,ncp)
関数: random_noncentral_student_t (n,ncp,m)

  n>0自由度で非中心度パラメータ ncpを持つ 非中心Student確率変量 nc_t(n,ncp)を返します。 三番目の引数 mとともに`random_noncentral_student_t`をコールすると、 サイズ mのランダムな標本がシミュレートされます。

  もし Xが正規確率変数 N(ncp,1)で、 S^2がn自由度のカイ二乗確率変数 Chi^2(n)なら、

                                 X
                       U = -------------
                           /   2  \ 1/2
                           |  S   |
                           | ---  |
                           \  n   /

  は n自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数 nc_t(n,ncp)であるという事実に基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_chi2 (x,n)

  n>0でカイ二乗確率変数 Chi^2(n)の密度函数の xでの値を返します。

  Chi^2(n)確率変数は Gamma(n/2,2)と同値です。 だから Maximaは結果を得るのに充分な情報を持っていない時 ガンマ密度に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) pdf_chi2(x,n);
                                          n
      (%o2)                  pdf_gamma(x, -, 2)
                                          2
      (%i3) assume(x>0, n>0)$  pdf_chi2(x,n);
                               n/2 - 1   - x/2
                              x        %e
      (%o4)                   ----------------
                                n/2       n
                               2    gamma(-)
                                          2

  Package distrib ·

関数: cdf_chi2 (x,n)

  n>0で、カイ二乗確率変数 Chi^2(n)の分布函数の xでの値を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_chi2(3,4);
                                                     3
      (%o2)      1 - gamma_incomplete_regularized(2, -)
                                                     2
      (%i3) float(%);
      (%o3)               .4421745996289256

  Package distrib ·

関数: quantile_chi2 (q,n)

  n>0で、カイ二乗確率変数 Chi^2(n)の q-分位数を返します; 言い換えると、これは `cdf_chi2`の逆函数です。 引数 qは [0,1]の要素でなければいけません。

  この函数は閉形式を持たず、 もしグローバル変数`numer`が`true`に等しいか 引数の少なくとも1つが浮動小数点数なら、数値的に計算されます。 そうでなければ、 Chi^2(n)確率変数は Gamma(n/2,2)と同値なので、 ガンマ分位函数に基づいた名目上の式を返します。

      (%i1) load ("distrib")$
      (%i2) quantile_chi2(0.99,9);
      (%o2)                   21.66599433346194
      (%i3) quantile_chi2(0.99,n);
                                              n
      (%o3)              quantile_gamma(0.99, -, 2)
                                              2

  Package distrib ·

関数: mean_chi2 (n)

  n>0で、カイ二乗確率変数 Chi^2(n)の平均を返します。

  Chi^2(n)確率変数は Gamma(n/2,2)に同値なので、 Maximaが結果を得るのに充分な情報を持たない時には、 ガンマ平均に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) mean_chi2(n);
                                         n
      (%o2)                   mean_gamma(-, 2)
                                         2
      (%i3) assume(n>0)$ mean_chi2(n);
      (%o4)                           n

  Package distrib ·

関数: var_chi2 (n)

  n>0で、カイ二乗確率変数 Chi^2(n)の分散を返します。

  Chi^2(n)確率変数は Gamma(n/2,2)に同値なので、 Maximaが結果を得るのに充分な情報を持たない時には、 ガンマ分散に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) var_chi2(n);
                                         n
      (%o2)                    var_gamma(-, 2)
                                         2
      (%i3) assume(n>0)$ var_chi2(n);
      (%o4)                          2 n

  Package distrib ·

関数: std_chi2 (n)

  n>0で、カイ二乗確率変数 Chi^2(n)の標準偏差を返します。

  Chi^2(n)確率変数は Gamma(n/2,2)に同値なので、 Maximaが結果を得るのに充分な情報を持たない時には、 ガンマ標準偏差に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) std_chi2(n);
                                         n
      (%o2)                    std_gamma(-, 2)
                                         2
      (%i3) assume(n>0)$ std_chi2(n);
      (%o4)                    sqrt(2) sqrt(n)

  Package distrib ·

関数: skewness_chi2 (n)

  n>0で、カイ二乗確率変数 Chi^2(n)の歪度係数を返します。

  Chi^2(n)確率変数は Gamma(n/2,2)に同値なので、 Maximaが結果を得るのに充分な情報を持たない時には、 ガンマ歪度係数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) skewness_chi2(n);
                                           n
      (%o2)                 skewness_gamma(-, 2)
                                           2
      (%i3) assume(n>0)$ skewness_chi2(n);
                                  2 sqrt(2)
      (%o4)                       ---------
                                   sqrt(n)

  Package distrib ·

関数: kurtosis_chi2 (n)

  n>0で、カイ二乗確率変数 Chi^2(n)の尖度係数を返します。

  Chi^2(n)確率変数は Gamma(n/2,2)に同値なので、 Maximaが結果を得るのに充分な情報を持たない時には、 ガンマ尖度係数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) kurtosis_chi2(n);
                                           n
      (%o2)                 kurtosis_gamma(-, 2)
                                           2
      (%i3) assume(n>0)$ kurtosis_chi2(n);
                                     12
      (%o4)                          --
                                     n

  Package distrib ·

関数: random_chi2 (n)
関数: random_chi2 (n,m)

  n>0で、カイ二乗確率変量 Chi^2(n)を返します。 二番目の引数 mとともに`random_chi2`をコールすると、 サイズ mのランダムな標本がシミュレートされます。

  シミュレーションはAhrens-Chengアルゴリズムに基づきます。 詳細は`random_gamma`を参照してください。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_noncentral_chi2 (x,n,ncp)

  n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数 nc_Chi^2(n,ncp)の 密度函数の xでの値を返します。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_noncentral_chi2 (x,n,ncp)

  n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数 nc_Chi^2(n,ncp)の 分布函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_noncentral_chi2 (q,n,ncp)

  n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数 nc_Chi^2(n,ncp)の q-分位数を返します; 言い換えると、これは `cdf_noncentral_chi2`の逆函数です。 引数 qは [0,1]の要素でなければいけません。

  この関数は閉形式を持たず、 もしグローバル変数 `numer`が `true`に等しいなら、 数値的に計算され、 そうでなければ、名目上の式を返します。

  Package distrib ·

関数: mean_noncentral_chi2 (n,ncp)

  n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数 nc_Chi^2(n,ncp)の 平均を返します。

  Package distrib ·

関数: var_noncentral_chi2 (n,ncp)

  n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数 nc_Chi^2(n,ncp)の 分散を返します。

  Package distrib ·

関数: std_noncentral_chi2 (n,ncp)

  n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数 nc_Chi^2(n,ncp)の 標準偏差を返します。

  Package distrib ·

関数: skewness_noncentral_chi2 (n,ncp)

  n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数 nc_Chi^2(n,ncp)の 歪度係数を返します。

  Package distrib ·

関数: kurtosis_noncentral_chi2 (n,ncp)

  n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数 nc_Chi^2(n,ncp)の 尖度係数を返します。

  Package distrib ·

関数: random_noncentral_chi2 (n,ncp)
関数: random_noncentral_chi2 (n,ncp,m)

  n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変量 nc_Chi^2(n,ncp)を返します。 三番目の引数 mとともに`random_noncentral_chi2`をコールすると、 サイズ mのランダムな標本がシミュレートされます。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_f (x,m,n)

  m,n>0で、F確率変数 F(m,n)の密度関数の xの値を返します。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_f (x,m,n)

  m,n>0で、F確率変数 F(m,n)の 分布関数の xの値を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_f(2,3,9/4);
                                               9  3  3
      (%o2)    1 - beta_incomplete_regularized(-, -, --)
                                               8  2  11
      (%i3) float(%);
      (%o3)                 0.66756728179008

  Package distrib ·

関数: quantile_f (q,m,n)

  m,n>0で、F確率変数 F(m,n)の q-分位数を返します; 言い換えると、これは `cdf_f`の逆函数です。 引数 qは [0,1]の要素でなければいけません。

  この関数は閉形式を持たず、 もしグローバル変数 `numer`が `true`に等しいなら、 数値的に計算され、 そうでなければ、名目上の式を返します。

      (%i1) load ("distrib")$
      (%i2) quantile_f(2/5,sqrt(3),5);
                                     2
      (%o2)               quantile_f(-, sqrt(3), 5)
                                     5
      (%i3) %,numer;
      (%o3)                   0.518947838573693

  Package distrib ·

関数: mean_f (m,n)

  m,n>2で、F確率変数 F(m,n)の 平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_f (m,n)

  m,n>4で、F確率変数 F(m,n)の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_f (m,n)

  m,n>4で、F確率変数 F(m,n)の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_f (m,n)

  m,n>6で、F確率変数 F(m,n)の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_f (m,n)

  m,n>8で、F確率変数 F(m,n)の 尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_f (m,n)
関数: random_f (m,n,k)

  m,n>8で、F確率変量 F(m,n)を返します。 三番目の引数 kとともに`random_f`をコールすると、 サイズ kのランダムな標本がシミュレートされます。

  シミュレーションアルゴリズムは、 もし Xが Chi^2(m)確率変数で Yが Chi^2(n)確率変数なら

                              n X
                          F = ---
                              m Y

  は mと n自由度を持つ F確率変数 F(m,n)である という事実に基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_exp (x,m)

  m>0で、 Exponential(m)(指数)確率変数の 密度函数の xでの値を返します。

  Exponential(m)(指数)確率変数は Weibull(1,1/m)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull密度に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) pdf_exp(x,m);
                                              1
      (%o2)                 pdf_weibull(x, 1, -)
                                              m
      (%i3) assume(x>0,m>0)$  pdf_exp(x,m);
                                      - m x
      (%o4)                       m %e

  Package distrib ·

関数: cdf_exp (x,m)

  m>0で、 Exponential(m)(指数)確率変数の 分布函数の xでの値を返します。

  Exponential(m)(指数)確率変数は Weibull(1,1/m)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull分布に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_exp(x,m);
                                              1
      (%o2)                 cdf_weibull(x, 1, -)
                                              m
      (%i3) assume(x>0,m>0)$  cdf_exp(x,m);
                                       - m x
      (%o4)                      1 - %e

  Package distrib ·

関数: quantile_exp (q,m)

  m>0で、 Exponential(m)(指数)確率変数の q-分位数を返します; 言い換えると、これは`cdf_exp`の逆函数です。 引数 qは [0,1]の要素でなければいけません。

  Exponential(m)(指数)確率変数は Weibull(1,1/m)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull分位数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) quantile_exp(0.56,5);
      (%o2)                   .1641961104139661
      (%i3) quantile_exp(0.56,m);
                                                  1
      (%o3)             quantile_weibull(0.56, 1, -)
                                                  m

  Package distrib ·

関数: mean_exp (m)

  m>0で、 Exponential(m)(指数)確率変数の 平均を返します。

  Exponential(m)(指数)確率変数は Weibull(1,1/m)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull平均に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) mean_exp(m);
                                             1
      (%o2)                  mean_weibull(1, -)
                                             m
      (%i3) assume(m>0)$  mean_exp(m);
                                      1
      (%o4)                           -
                                      m

  Package distrib ·

関数: var_exp (m)

  m>0で、 Exponential(m)(指数)確率変数の 分散を返します。

  Exponential(m)(指数)確率変数は Weibull(1,1/m)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull分散に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) var_exp(m);
                                             1
      (%o2)                   var_weibull(1, -)
                                             m
      (%i3) assume(m>0)$  var_exp(m);
                                     1
      (%o4)                          --
                                      2
                                     m

  Package distrib ·

関数: std_exp (m)

  m>0で、 Exponential(m)(指数)確率変数の 標準偏差を返します。

  Exponential(m)(指数)確率変数は Weibull(1,1/m)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull標準偏差に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) std_exp(m);
                                             1
      (%o2)                   std_weibull(1, -)
                                             m
      (%i3) assume(m>0)$  std_exp(m);
                                      1
      (%o4)                           -
                                      m

  Package distrib ·

関数: skewness_exp (m)

  m>0で、 Exponential(m)(指数)確率変数の 歪度係数を返します。

  Exponential(m)(指数)確率変数は Weibull(1,1/m)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull歪度係数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) skewness_exp(m);
                                               1
      (%o2)                skewness_weibull(1, -)
                                               m
      (%i3) assume(m>0)$  skewness_exp(m);
      (%o4)                           2

  Package distrib ·

関数: kurtosis_exp (m)

  m>0で、 Exponential(m)(指数)確率変数の 尖度係数を返します。

  Exponential(m)(指数)確率変数は Weibull(1,1/m)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull尖度係数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) kurtosis_exp(m);
                                               1
      (%o2)                kurtosis_weibull(1, -)
                                               m
      (%i3) assume(m>0)$  kurtosis_exp(m);
      (%o4)                           6

  Package distrib ·

関数: random_exp (m)
関数: random_exp (m,k)

  m>0で、 Exponential(m)(指数)確率変量を返します。 二番目の引数 kとともに`random_exp`をコールすると、 サイズ kのランダムな標本がシミュレートされます。

  シミュレーションアルゴリズムは一般逆函数法です。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_lognormal (x,m,s)

  s>0で、Lognormal(m,s)(対数正規)確率変数の 密度函数の xでの値を返します。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_lognormal (x,m,s)

  s>0で、Lognormal(m,s)(対数正規)確率変数の 分布函数の xでの値を返します。 この関数はMaximaの組み込み誤差関数 `erf`を使って定義されます。

      (%i1) load ("distrib")$
      (%i2) assume(x>0, s>0)$  cdf_lognormal(x,m,s);
                                 log(x) - m
                             erf(----------)
                                 sqrt(2) s     1
      (%o3)                  --------------- + -
                                    2          2

  `erf`も参照してください。

  Package distrib ·

関数: quantile_lognormal (q,m,s)

  s>0で、Lognormal(m,s)(対数正規)確率変数の q-分位数を返します; 言い換えると、これは `cdf_lognormal`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

      (%i1) load ("distrib")$
      (%i2) quantile_lognormal(95/100,0,1);
                        sqrt(2) inverse_erf(9/10)
      (%o2)           %e
      (%i3) float(%);
      (%o3)               5.180251602233015

  Package distrib ·

関数: mean_lognormal (m,s)

  s>0で、Lognormal(m,s)(対数正規)確率変数の 平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_lognormal (m,s)

  s>0で、Lognormal(m,s)(対数正規)確率変数の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_lognormal (m,s)

  s>0で、Lognormal(m,s)(対数正規)確率変数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_lognormal (m,s)

  s>0で、Lognormal(m,s)(対数正規)確率変数の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_lognormal (m,s)

  s>0で、Lognormal(m,s)(対数正規)確率変数の 尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_lognormal (m,s)
関数: random_lognormal (m,s,n)

  s>0で、Lognormal(m,s)(対数正規)確率変量を返します。 三番目の引数 nとともに`random_lognormal`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  対数世紀変量は確率正規変量の平均によってシミュレートされます。 詳細は `random_normal`を見てください。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_gamma (x,a,b)

  a,b>0で、 Gamma(a,b)確率変数の 密度函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_gamma (x,a,b)

  a,b>0で、 Gamma(a,b)確率変数の 分布函数の xでの値を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_gamma(3,5,21);
                                                    1
      (%o2)     1 - gamma_incomplete_regularized(5, -)
                                                    7
      (%i3) float(%);
      (%o3)              4.402663157376807E-7

  Package distrib ·

関数: quantile_gamma (q,a,b)

  a,b>0で、 Gamma(a,b)確率変数の p-分位数を返します; 言い換えれば、これは `cdf_gamma`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_gamma (a,b)

  a,b>0で、 Gamma(a,b)確率変数の 平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_gamma (a,b)

  a,b>0で、 Gamma(a,b)確率変数の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_gamma (a,b)

  a,b>0で、 Gamma(a,b)確率変数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_gamma (a,b)

  a,b>0で、 Gamma(a,b)確率変数の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_gamma (a,b)

  a,b>0で、 Gamma(a,b)確率変数の 尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_gamma (a,b)
関数: random_gamma (a,b,n)

  a,b>0で、 Gamma(a,b)確率変量を返します。 三番目の引数 nとともに`random_gamma`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  実装アルゴリズムはパラメータ aの値に依存して、2つの手続きの組み合わせです:

  a>=1に対して, Cheng, R.C.H. and Feast, G.M. (1979). Some simple gamma variate generators. Appl. Stat., 28, 3, 290-295.

  0<a<1に対して, Ahrens, J.H. and Dieter, U. (1974). Computer methods for sampling from gamma, beta, poisson and binomial cdf_tributions. Computing, 12, 223-246.

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_beta (x,a,b)

  a,b>0で、 Beta(a,b)確率変数の 密度函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_beta (x,a,b)

  a,b>0で、 Beta(a,b)確率変数の 分布函数の xでの値を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_beta(1/3,15,2);
                                   11
      (%o2)                     --------
                                14348907
      (%i3) float(%);
      (%o3)              7.666089131388195E-7

  Package distrib ·

関数: quantile_beta (q,a,b)

  a,b>0で、 Beta(a,b)確率変数の q-分位数を返します; 言い換えると、これは`cdf_beta`の逆函数です。 引数 q [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_beta (a,b)

  a,b>0で、 Beta(a,b)確率変数の 平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_beta (a,b)

  a,b>0で、 Beta(a,b)確率変数の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_beta (a,b)

  a,b>0で、 Beta(a,b)確率変数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_beta (a,b)

  a,b>0で、 Beta(a,b)確率変数の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_beta (a,b)

  a,b>0で、 Beta(a,b)確率変数の 尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_beta (a,b)
関数: random_beta (a,b,n)

  a,b>0で、 Beta(a,b)確率変量を返します。 三番目の引数 nとともに`random_gamma`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  実装アルゴリズムは Cheng, R.C.H. (1978). Generating Beta Variates with Nonintegral Shape Parameters. Communications of the ACM, 21:317-322 に定義されています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_continuous_uniform (x,a,b)

  a<bで、 Continuous Uniform(a,b)確率変数の密度函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_continuous_uniform (x,a,b)

  a<bで、 Continuous Uniform(a,b)確率変数の分布函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_continuous_uniform (q,a,b)

  a<bで、 Continuous Uniform(a,b)確率変数の分布函数の q-分位数を返します。 言い換えると、これは `cdf_continuous_uniform`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_continuous_uniform (a,b)

  a<bで、 Continuous Uniform(a,b)確率変数の分布函数の 平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_continuous_uniform (a,b)

  a<bで、 Continuous Uniform(a,b)確率変数の分布函数の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_continuous_uniform (a,b)

  a<bで、 Continuous Uniform(a,b)確率変数の分布函数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_continuous_uniform (a,b)

  a<bで、 Continuous Uniform(a,b)確率変数の分布函数の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_continuous_uniform (a,b)

  a<bで、 Continuous Uniform(a,b)確率変数の分布函数の 尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_continuous_uniform (a,b)
関数: random_continuous_uniform (a,b,n)

  a<bで、 Continuous Uniform(a,b)確率変量を返します。 三番目の引数 nとともに`random_gamma`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  これは `random`組み込みMaxima関数の直接の応用です。

  `random`も参照してください。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_logistic (x,a,b)

  b>0で、 Logistic(a,b)確率変数の 密度函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_logistic (x,a,b)

  b>0で、 Logistic(a,b)確率変数の 分布函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_logistic (q,a,b)

  b>0で、 Logistic(a,b)確率変数の q-分位数を返します。 言い換えると、これは `cdf_logistic`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_logistic (a,b)

  b>0で、 Logistic(a,b)確率変数の平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_logistic (a,b)

  b>0で、 Logistic(a,b)確率変数の分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_logistic (a,b)

  b>0で、 Logistic(a,b)確率変数の標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_logistic (a,b)

  b>0で、 Logistic(a,b)確率変数の歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_logistic (a,b)

  b>0で、 Logistic(a,b)確率変数の尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_logistic (a,b)
関数: random_logistic (a,b,n)

  b>0で、 Logistic(a,b)確率変量を返します。 三番目の引数 nとともに`random_logistic`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  実装アルゴリズムは一般逆函数法に基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_pareto (x,a,b)

  a,b>0で、 Pareto(a,b)確率変数の 密度函数の xの値を返します。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_pareto (x,a,b)

  a,b>0で、 Pareto(a,b)確率変数の 分布函数の xの値を返します。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_pareto (q,a,b)

  a,b>0で、 Pareto(a,b)確率変数の q-分位数を返します; 言い換えると、これは `cdf_pareto`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_pareto (a,b)

  a,b>0で、 Pareto(a,b)確率変数の 平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_pareto (a,b)

  a>2,b>0で、 Pareto(a,b)確率変数の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_pareto (a,b)

  a>2,b>0で、 Pareto(a,b)確率変数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_pareto (a,b)

  a>2,b>0で、 Pareto(a,b)確率変数の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_pareto (a,b)

  a>2,b>0で、 Pareto(a,b)確率変数の 尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_pareto (a,b)
関数: random_pareto (a,b,n)

  a>2,b>0で、 Pareto(a,b)確率変量を返します。 三番目の引数 nとともに`random_pareto`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  実装アルゴリズムは一般逆函数法に基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_weibull (x,a,b)

  a,b>0で、 Weibull(a,b)確率変数の 密度函数の xの値を返します。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_weibull (x,a,b)

  a,b>0で、 Weibull(a,b)確率変数の 分布函数の xの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_weibull (q,a,b)

  a,b>0で、 Weibull(a,b)確率変数の q-分位数を返します; 言い換えれば、これは `cdf_weibull`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_weibull (a,b)

  a,b>0で、 Weibull(a,b)確率変数の 平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_weibull (a,b)

  a,b>0で、 Weibull(a,b)確率変数の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_weibull (a,b)

  a,b>0で、 Weibull(a,b)確率変数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_weibull (a,b)

  a,b>0で、 Weibull(a,b)確率変数の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_weibull (a,b)

  a,b>0で、 Weibull(a,b)確率変数の 尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_weibull (a,b)
関数: random_weibull (a,b,n)

  a,b>0で、 Weibull(a,b)確率変量を返します。

  実装アルゴリズムは一般逆函数法に基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_rayleigh (x,b)

  b>0で、 Rayleigh(b)確率変数の 密度函数の xでの値を返します。

  Rayleigh(b)確率変数は Weibull(2,1/b)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull密度に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) pdf_rayleigh(x,b);
                                              1
      (%o2)                 pdf_weibull(x, 2, -)
                                              b
      (%i3) assume(x>0,b>0)$ pdf_rayleigh(x,b);
                                          2  2
                                 2     - b  x
      (%o4)                   2 b  x %e

  Package distrib ·

関数: cdf_rayleigh (x,b)

  b>0で、 Rayleigh(b)確率変数の 分布函数の xでの値を返します。

  Rayleigh(b)確率変数は Weibull(2,1/b)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull分布に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_rayleigh(x,b);
                                              1
      (%o2)                 cdf_weibull(x, 2, -)
                                              b
      (%i3) assume(x>0,b>0)$ cdf_rayleigh(x,b);
                                         2  2
                                      - b  x
      (%o4)                     1 - %e

  Package distrib ·

関数: quantile_rayleigh (q,b)

  Returns the q-quantile of a Rayleigh(b) random variable, with b>0; in other words, this is the inverse of `cdf_rayleigh`. Argument q must be an element of [0,1].

  Rayleigh(b)確率変数は Weibull(2,1/b)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull分位数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) quantile_rayleigh(0.99,b);
                                                  1
      (%o2)             quantile_weibull(0.99, 2, -)
                                                  b
      (%i3) assume(x>0,b>0)$ quantile_rayleigh(0.99,b);
                              2.145966026289347
      (%o4)                   -----------------
                                      b

  Package distrib ·

関数: mean_rayleigh (b)

  Returns the mean of a Rayleigh(b) random variable, with b>0.

  Rayleigh(b)確率変数は Weibull(2,1/b)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull平均に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) mean_rayleigh(b);
                                             1
      (%o2)                  mean_weibull(2, -)
                                             b
      (%i3) assume(b>0)$ mean_rayleigh(b);
                                  sqrt(%pi)
      (%o4)                       ---------
                                     2 b

  Package distrib ·

関数: var_rayleigh (b)

  b>0で、 Rayleigh(b)確率変数の分散を返します。

  Rayleigh(b)確率変数は Weibull(2,1/b)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull分散に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) var_rayleigh(b);
                                             1
      (%o2)                   var_weibull(2, -)
                                             b
      (%i3) assume(b>0)$ var_rayleigh(b);
                                       %pi
                                   1 - ---
                                        4
      (%o4)                        -------
                                      2
                                     b

  Package distrib ·

関数: std_rayleigh (b)

  b>0で、 Rayleigh(b)確率変数の標準偏差を返します。

  Rayleigh(b)確率変数は Weibull(2,1/b)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull標準偏差に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) std_rayleigh(b);
                                             1
      (%o2)                   std_weibull(2, -)
                                             b
      (%i3) assume(b>0)$ std_rayleigh(b);
                                         %pi
                                sqrt(1 - ---)
                                          4
      (%o4)                     -------------
                                      b

  Package distrib ·

関数: skewness_rayleigh (b)

  b>0で、 Rayleigh(b)確率変数の歪度係数を返します。

  Rayleigh(b)確率変数は Weibull(2,1/b)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull歪度係数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) skewness_rayleigh(b);
                                               1
      (%o2)                skewness_weibull(2, -)
                                               b
      (%i3) assume(b>0)$ skewness_rayleigh(b);
                               3/2
                            %pi      3 sqrt(%pi)
                            ------ - -----------
                              4           4
      (%o4)                 --------------------
                                     %pi 3/2
                                (1 - ---)
                                      4

  Package distrib ·

関数: kurtosis_rayleigh (b)

  b>0で、 Rayleigh(b)確率変数の尖度係数を返します。

  Rayleigh(b)確率変数は Weibull(2,1/b)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 Weibull尖度係数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) kurtosis_rayleigh(b);
                                               1
      (%o2)                kurtosis_weibull(2, -)
                                               b
      (%i3) assume(b>0)$ kurtosis_rayleigh(b);
                                        2
                                   3 %pi
                               2 - ------
                                     16
      (%o4)                    ---------- - 3
                                    %pi 2
                               (1 - ---)
                                     4

  Package distrib ·

関数: random_rayleigh (b)
関数: random_rayleigh (b,n)

  b>0で、 Rayleigh(b)確率変量を返します。 二番目の引数 nとともに`random_pareto`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  実装アルゴリズムは一般逆函数法に基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_laplace (x,a,b)

  b>0で、 Laplace(a,b)確率変数の密度函数の xでの値を返します。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_laplace (x,a,b)

  b>0で、 Laplace(a,b)確率変数の分布函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_laplace (q,a,b)

  b>0で、 Laplace(a,b)確率変数のq-分位数を返します; 言い換えれば、これは `cdf_laplace`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_laplace (a,b)

  b>0で、 Laplace(a,b)確率変数の平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_laplace (a,b)

  b>0で、 Laplace(a,b)確率変数の分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_laplace (a,b)

  b>0で、 Laplace(a,b)確率変数の標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_laplace (a,b)

  b>0で、 Laplace(a,b)確率変数の歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_laplace (a,b)

  b>0で、 Laplace(a,b)確率変数の尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_laplace (a,b)
関数: random_laplace (a,b,n)

  b>0で、 Laplace(a,b)確率変量を返します。 三番目の引数 nとともに`random_laplace`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  実装アルゴリズムは一般逆函数法に基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_cauchy (x,a,b)

  b>0で、 Cauchy(a,b)確率変数の密度函数のxでの値を返します。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_cauchy (x,a,b)

  b>0で、 Cauchy(a,b)確率変数の分布函数のxでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_cauchy (q,a,b)

  b>0で、 Cauchy(a,b)確率変数のq-分位数を返します; 言い換えると、これは `cdf_cauchy`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_cauchy (a,b)
関数: random_cauchy (a,b,n)

  b>0で、 Cauchy(a,b)確率変量を返します。 三番目の引数 nとともに`random_cauchy`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  実装アルゴリズムは一般逆函数法に基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_gumbel (x,a,b)

  b>0で、 Gumbel(a,b)確率変数の密度函数のxでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_gumbel (x,a,b)

  b>0で、 Gumbel(a,b)確率変数の分布函数のxでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_gumbel (q,a,b)

  b>0で、 Gumbel(a,b)確率変数のq-分位数を返します; 言い換えれば、これは `cdf_gumbel`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_gumbel (a,b)

  b>0で、 Gumbel(a,b)確率変数の平均を返します。

      (%i1) load ("distrib")$
      (%i2) assume(b>0)$  mean_gumbel(a,b);
      (%o3)                     %gamma b + a

  ここでシンボル `%gamma`は Euler-Mascheroni定数を表します。 `%gamma`も参照してください。

  Package distrib ·

関数: var_gumbel (a,b)

  b>0で、 Gumbel(a,b)確率変数の分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_gumbel (a,b)

  b>0で、 Gumbel(a,b)確率変数の標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_gumbel (a,b)

  b>0で、 Gumbel(a,b)確率変数の歪度係数を返します。

      (%i1) load ("distrib")$
      (%i2) assume(b>0)$ skewness_gumbel(a,b);
                             12 sqrt(6) zeta(3)
      (%o3)                  ------------------
                                       3
                                    %pi
      (%i4) numer:true$ skewness_gumbel(a,b);
      (%o5)                   1.139547099404649

  ここで、`zeta`はRiemannのゼータ函数を表します。

  Package distrib ·

関数: kurtosis_gumbel (a,b)

  b>0で、 Gumbel(a,b)確率変数の尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Package distrib ·

関数: random_gumbel (a,b)
関数: random_gumbel (a,b,n)

  b>0で、 Gumbel(a,b)確率変量を返します。 三番目の引数 nとともに`random_gumbel`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  実装アルゴリズムは一般逆函数法に基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

Previous: Functions and Variables for continuous distributions, Up: distrib [Contents][Index]

### 47.3 Functions and Variables for discrete distributions

関数: pdf_general_finite_discrete (x,v)

  `Pr(X=i) = v_i`のような ベクトル確率 vを持つ 一般有限離散確率変数の 確率函数の xでの値を返します。 ベクトル vは非負式のリストであり得ます。 その成分は確率のベクトルを得るために規格化されます。 この関数を利用するには、初めに `load("distrib")`を書いてください。

      (%i1) load ("distrib")$
      (%i2) pdf_general_finite_discrete(2, [1/7, 4/7, 2/7]);
                                      4
      (%o2)                           -
                                      7
      (%i3) pdf_general_finite_discrete(2, [1, 4, 2]);
                                      4
      (%o3)                           -
                                      7

  Package distrib ·

関数: cdf_general_finite_discrete (x,v)

  ベクトル確率 vを持つ 一般有限離散確率変数の 分布函数の xでの値を返します。

  さらなる詳細は `pdf_general_finite_discrete`を参照してください。

      (%i1) load ("distrib")$
      (%i2) cdf_general_finite_discrete(2, [1/7, 4/7, 2/7]);
                                      5
      (%o2)                           -
                                      7
      (%i3) cdf_general_finite_discrete(2, [1, 4, 2]);
                                      5
      (%o3)                           -
                                      7
      (%i4) cdf_general_finite_discrete(2+1/2, [1, 4, 2]);
                                      5
      (%o4)                           -
                                      7

  Package distrib ·

関数: quantile_general_finite_discrete (q,v)

  ベクトル確率 vを持つ 一般有限離散確率変数の q-分位数を返します。

  さらなる詳細は `pdf_general_finite_discrete`を参照してください。

  Package distrib ·

関数: mean_general_finite_discrete (v)

  ベクトル確率 vを持つ 一般有限離散確率変数の 平均を返します。

  さらなる詳細は `pdf_general_finite_discrete`を参照してください。

  Package distrib ·

関数: var_general_finite_discrete (v)

  ベクトル確率 vを持つ 一般有限離散確率変数の 分散を返します。

  さらなる詳細は `pdf_general_finite_discrete`を参照してください。

  Package distrib ·

関数: std_general_finite_discrete (v)

  ベクトル確率 vを持つ 一般有限離散確率変数の 標準偏差を返します。

  さらなる詳細は `pdf_general_finite_discrete`を参照してください。

  Package distrib ·

関数: skewness_general_finite_discrete (v)

  ベクトル確率 vを持つ 一般有限離散確率変数の 歪度係数を返します。

  さらなる詳細は `pdf_general_finite_discrete`を参照してください。

  Package distrib ·

関数: kurtosis_general_finite_discrete (v)

  ベクトル確率 vを持つ 一般有限離散確率変数の 尖度係数を返します。

  さらなる詳細は `pdf_general_finite_discrete`を参照してください。

  Package distrib ·

関数: random_general_finite_discrete (v)
関数: random_general_finite_discrete (v,m)

  ベクトル確率 vを持つ 一般有限離散確率変量を返します。 二番目の引数 mとともに`random_general_finite_discrete`をコールすると、 サイズ mのランダムな標本がシミュレートされます。

  さらなる詳細は `pdf_general_finite_discrete`を参照してください。

      (%i1) load ("distrib")$
      (%i2) random_general_finite_discrete([1,3,1,5]);
      (%o2)                          4
      (%i3) random_general_finite_discrete([1,3,1,5], 10);
      (%o3)           [4, 2, 2, 3, 2, 4, 4, 1, 2, 2]

  Package distrib ·Random numbers ·

関数: pdf_binomial (x,n,p)

  0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の確率函数のxでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。 4 (%o6) - 7

  Package distrib ·

関数: cdf_binomial (x,n,p)

  0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の分布函数のxでの値を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_binomial(5,7,1/6);
                                  7775
      (%o2)                       ----
                                  7776
      (%i3) float(%);
      (%o3)               .9998713991769548

  Package distrib ·

関数: quantile_binomial (q,n,p)

  0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数のq-分位数を返します; 言い換えれば、これは `cdf_binomial`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_binomial (n,p)

  0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_binomial (n,p)

  0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_binomial (n,p)

  0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_binomial (n,p)

  0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_binomial (n,p)

  0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_binomial (n,p)
関数: random_binomial (n,p,m)

  0<p<1かつ nは正の整数で、 Binomial(n,p)確率変量を返します。 三番目の引数 mとともに`random_binomial`をコールすると、 サイズ mのランダムな標本がシミュレートされます。

  実装アルゴリズムは Kachitvichyanukul, V. and Schmeiser, B.W. (1988) Binomial Random Variate Generation. Communications of the ACM, 31, Feb., 216.に 記載されているものに基づいています。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_poisson (x,m)

  m>0で、 Poisson(m)確率変数の確率函数の xでの値を返します。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_poisson (x,m)

  m>0で、 Poisson(m)確率変数の分布函数の xでの値を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_poisson(3,5);
      (%o2)       gamma_incomplete_regularized(4, 5)
      (%i3) float(%);
      (%o3)               .2650259152973623

  Package distrib ·

関数: quantile_poisson (q,m)

  m>0で、 Poisson(m)確率変数の q-分位数を返します; 言い換えると、これは `cdf_poisson`の逆函数です。 引数 qは [0,1]の要素でなればいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_poisson (m)

  m>0で、 Poisson(m)確率変数の平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_poisson (m)

  m>0で、 Poisson(m)確率変数の分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_poisson (m)

  m>0で、 Poisson(m)確率変数の標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_poisson (m)

  m>0で、 Poisson(m)確率変数の歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_poisson (m)

  m>0で、 Poisson(m)確率変数の尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_poisson (m)
関数: random_poisson (m,n)

  m>0で、 Poisson(m)確率変量を返します。 二番目の引数 nとともに`random_binomial`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  実装アルゴリズムは Ahrens, J.H. and Dieter, U. (1982) Computer Generation of Poisson Deviates From Modified Normal Distributions. ACM Trans. Math. Software, 8, 2, June,163-179.に記述されたものです。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_bernoulli (x,p)

  0<p<1で、 Bernoulli(p)確率変数の確率函数の xでの値を返します。

  Bernoulli(p)確率変数は Binomial(1,p)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 二項確率函数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) pdf_bernoulli(1,p);
      (%o2)                 pdf_binomial(1, 1, p)
      (%i3) assume(0<p,p<1)$ pdf_bernoulli(1,p);
      (%o4)                           p

  Package distrib ·

関数: cdf_bernoulli (x,p)

  0<p<1で、 Bernoulli(p)確率変数の分布函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_bernoulli (q,p)

  0<p<1で、 Bernoulli(p)確率変数のq-分位数を返します; 言い換えると、これは `cdf_bernoulli`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_bernoulli (p)

  0<p<1で、 Bernoulli(p)確率変数の平均を返します。

  Bernoulli(p)確率変数は Binomial(1,p)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 二項平均に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) mean_bernoulli(p);
      (%o2)                  mean_binomial(1, p)
      (%i3) assume(0<p,p<1)$ mean_bernoulli(p);
      (%o4)                           p

  Package distrib ·

関数: var_bernoulli (p)

  0<p<1で、 Bernoulli(p)確率変数の分散を返します。

  Bernoulli(p)確率変数は Binomial(1,p)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 二項分散に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) var_bernoulli(p);
      (%o2)                  var_binomial(1, p)
      (%i3) assume(0<p,p<1)$ var_bernoulli(p);
      (%o4)                       (1 - p) p

  Package distrib ·

関数: std_bernoulli (p)

  0<p<1で、 Bernoulli(p)確率変数の標準偏差を返します。

  Bernoulli(p)確率変数は Binomial(1,p)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 二項標準偏差に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) std_bernoulli(p);
      (%o2)                  std_binomial(1, p)
      (%i3) assume(0<p,p<1)$ std_bernoulli(p);
      (%o4)                  sqrt(1 - p) sqrt(p)

  Package distrib ·

関数: skewness_bernoulli (p)

  0<p<1で、 Bernoulli(p)確率変数の歪度係数を返します。

  Bernoulli(p)確率変数は Binomial(1,p)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 二項歪度係数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) skewness_bernoulli(p);
      (%o2)                skewness_binomial(1, p)
      (%i3) assume(0<p,p<1)$ skewness_bernoulli(p);
                                   1 - 2 p
      (%o4)                  -------------------
                             sqrt(1 - p) sqrt(p)

  Package distrib ·

関数: kurtosis_bernoulli (p)

  0<p<1で、 Bernoulli(p)確率変数の尖度係数を返します。

  Bernoulli(p)確率変数は Binomial(1,p)と同値です。 なので、 Maximaが結果を得るのに十分な情報を持たない時は、 二項尖度係数に基づいた名詞形を返します。

      (%i1) load ("distrib")$
      (%i2) kurtosis_bernoulli(p);
      (%o2)                kurtosis_binomial(1, p)
      (%i3) assume(0<p,p<1)$ kurtosis_bernoulli(p);
                               1 - 6 (1 - p) p
      (%o4)                    ---------------
                                  (1 - p) p

  Package distrib ·

関数: random_bernoulli (p)
関数: random_bernoulli (p,n)

  0<p<1で、 Bernoulli(p)確率変量を返します。 二番目の引数 nとともに`random_bernoulli`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  これは `random`組み込みMaxima関数の直接の応用です。

  `random`も参照してください。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_geometric (x,p)

  0<p<1で、 Geometric(p)(幾何)確率変数の確率函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_geometric (x,p)

  0<p<1で、 Geometric(p)(幾何)確率変数の分布函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_geometric (q,p)

  0<p<1で、 Geometric(p)(幾何)確率変数の q-分位数を返します; 言い換えると、これは `cdf_geometric`の逆函数です。 引数 qは [0,1]の要素でなければいけません。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_geometric (p)

  0<p<1で、 Geometric(p)(幾何)確率変数の 平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_geometric (p)

  0<p<1で、 Geometric(p)(幾何)確率変数の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_geometric (p)

  0<p<1で、 Geometric(p)(幾何)確率変数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_geometric (p)

  0<p<1で、 Geometric(p)(幾何)確率変数の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_geometric (p)

  0<p<1で、 Geometric(p)(幾何)確率変数の 尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_geometric (p)
関数: random_geometric (p,n)

  0<p<1で、 Geometric(p)(幾何)確率変量を返します。 二番目の引数 nとともに`random_geometric`をコールすると、 サイズ nのランダムな標本がシミュレートされます。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_discrete_uniform (x,n)

  nが厳密に正の整数で、 Discrete Uniform(n)確率変数の確率函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_discrete_uniform (x,n)

  nが厳密に正の整数で、 Discrete Uniform(n)確率変数の分風函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_discrete_uniform (q,n)

  nが厳密に正の整数で、 Discrete Uniform(n)確率変数の q-分位数を返します; 言い換えると、これは `cdf_discrete_uniform`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_discrete_uniform (n)

  Returns the mean of a Discrete Uniform(n) random variable, with n a strictly positive integer. この関数を利用するには、初めに `load("distrib")`を書いてください。 To make use of this function, write first `load("distrib")`.

  Package distrib ·

関数: var_discrete_uniform (n)

  nが厳密に正の整数で、 Discrete Uniform(n)確率変数の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_discrete_uniform (n)

  nが厳密に正の整数で、 Discrete Uniform(n)確率変数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_discrete_uniform (n)

  nが厳密に正の整数で、 Discrete Uniform(n)確率変数の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_discrete_uniform (n)

  nが厳密に正の整数で、 Discrete Uniform(n)確率変数の 尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_discrete_uniform (n)
関数: random_discrete_uniform (n,m)

  nが厳密に正の整数で、 Discrete Uniform(n)確率変量を返します。 二番目の引数 mとともに`random_discrete_unform`をコールすると、 サイズ mのランダムな標本がシミュレートされます。

  これは `random`組み込みMaxima関数の直接の応用です。

  `random`も参照してください。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_hypergeometric (x,n1,n2,n)

  n1, n2, nが非負整数でかつ n<=n1+n2で、 Hypergeometric(n1,n2,n)確率変数の 確率函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_hypergeometric (x,n1,n2,n)

  n1, n2, nが非負整数でかつ n<=n1+n2で、 Hypergeometric(n1,n2,n)確率変数の 分布函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: quantile_hypergeometric (q,n1,n2,n)

  n1, n2, nが非負整数でかつ n<=n1+n2で、 Hypergeometric(n1,n2,n)確率変数の q-分位数を返します。 言い換えると、これは `cdf_hypergeometric`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_hypergeometric (n1,n2,n)

  n1, n2, nが非負整数でかつ n<=n1+n2で、 Hypergeometric(n1,n2,n)確率変数の 平均を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: var_hypergeometric (n1,n2,n)

  n1, n2, nが非負整数でかつ n<=n1+n2で、 Hypergeometric(n1,n2,n)確率変数の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_hypergeometric (n1,n2,n)

  n1, n2, nが非負整数でかつ n<=n1+n2で、 Hypergeometric(n1,n2,n)確率変数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_hypergeometric (n1,n2,n)

  n1, n2, nが非負整数でかつ n<=n1+n2で、 Hypergeometric(n1,n2,n)確率変数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_hypergeometric (n1,n2,n)

  n1, n2, nが非負整数でかつ n<=n1+n2で、 Hypergeometric(n1,n2,n)確率変数の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_hypergeometric (n1,n2,n)
関数: random_hypergeometric (n1,n2,n,m)

  n1, n2, nが非負整数でかつ n<=n1+n2で、 Hypergeometric(n1,n2,n)確率変量を返します。 四番目の引数 mとともに`random_hypergeometric`をコールすると、 サイズ mのランダムな標本がシミュレートされます。

  Kachitvichyanukul, V., Schmeiser, B.W. (1985) Computer generation of hypergeometric random variates. Journal of Statistical Computation and Simulation 22, 127-145.に記述されたアルゴリズム。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

関数: pdf_negative_binomial (x,n,p)

  0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の確率函数の xでの値を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: cdf_negative_binomial (x,n,p)

  0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の分布函数の xでの値を返します。

      (%i1) load ("distrib")$
      (%i2) cdf_negative_binomial(3,4,1/8);
                                  3271
      (%o2)                      ------
                                 524288
      (%i3) float(%);
      (%o3)              .006238937377929687

  Package distrib ·

関数: quantile_negative_binomial (q,n,p)

  0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の q-分位数を返します; 言い換えると、これは `cdf_negative_binomial`の逆函数です。 引数 qは [0,1]の要素でなければいけません。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: mean_negative_binomial (n,p)

  Returns the mean of a Negative Binomial(n,p) random variable, with 0<p<1 and n a positive integer. この関数を利用するには、初めに `load("distrib")`を書いてください。 To make use of this function, write first `load("distrib")`.

  Package distrib ·

関数: var_negative_binomial (n,p)

  0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の 分散を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: std_negative_binomial (n,p)

  0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の 標準偏差を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: skewness_negative_binomial (n,p)

  0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の 歪度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: kurtosis_negative_binomial (n,p)

  0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の 尖度係数を返します。 この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·

関数: random_negative_binomial (n,p)
関数: random_negative_binomial (n,p,m)

  0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変量を返します。 三番目の引数 mとともに`random_negative_binomial`をコールすると、 サイズ mのランダムな標本がシミュレートされます。

  Devroye, L. (1986) Non-Uniform Random Variate Generation. Springer Verlag, p. 480.に記載されたアルゴリズム。

  この関数を利用するには、初めに `load("distrib")`を書いてください。

  Package distrib ·Random numbers ·

Next: drawdf, Previous: distrib, Up: Top [Contents][Index]

## 48 draw

Next: Functions and Variables for draw, Previous: draw, Up: draw [Contents][Index]

### 48.1 Introduction to draw

`draw`はMaxima-Gnuplotインターフェイスです。

Maximaレベルで使われる３つの主な関数があります: `draw2d`, `draw3d`, `draw`。

このパッケージのさらに磨きかけられた例のために以下のリンクに従ってください:

http://riotorto.users.sourceforge.net/gnuplot

このプログラムを走らせるにはGnuplot 4.2以上が必要です。

Plotting ·Share packages ·Package draw ·

Next: Functions and Variables for pictures, Previous: Introduction to draw, Up: draw [Contents][Index]

### 48.2 Functions and Variables for draw

#### 48.2.1 Scenes

シーン構成子: gr2d (graphic option, ..., graphic object, ...)

  関数`gr2d`は 2Dシーンを記述するオブジェクトを作ります。 引数はグラフィックオプション、グラフィックオブジェクト、または、 グラフィックオプションとオブジェクト両方を含むリストです。 このシーンは順に解釈されます: グラフィックオプションはその右に置かれたそれらのグラフィックオブジェクトに影響します。 いくつかのグラフィックオプションはシーンのグローバルな外観に影響します。

  以下は2次元のシーンで利用可能なグラフィックオブジェクトのリストです: `bars`, `ellipse`, `explicit`, `image`, `implicit`, `label`, `parametric`, `points`, `polar`, `polygon`, `quadrilateral`, `rectangle`, `triangle`, `vector`, `geomap` (パッケージ`worldmap`で定義されるもの)。

  `draw`と`draw2d`も参照してください。

  このオブジェクトを利用するには、最初に`load("draw")`を書いてください。

  Package draw ·

シーン構成子: gr3d (graphic option, ..., graphic object, ...)

  関数`gr3d`は3dシーンを記述するオブジェクトを作ります。 引数はグラフィックオプション、グラフィックオブジェクト、または グラフィックオプションとオブジェクト両方を含むリストです。 このシーンは順に解釈されます: グラフィックオプションはその右に置かれたそれらのグラフィックオブジェクトに影響します。 いくつかのグラフィックオプションはシーンのグローバルな外観に影響します。

  以下は3次元のシーンで利用可能なグラフィックオブジェクトのリストです: `cylindrical`, `elevation_grid`, `explicit`, `implicit`, `label`, `mesh`, `parametric`,
  `parametric_surface`, `points`, `quadrilateral`, `spherical`, `triangle`, `tube`,
  `vector`, `geomap` (パッケージ`worldmap`で定義されるもの)。

  `draw`と`draw3d`も参照してください。

  このオブジェクトを利用するには、最初に`load("draw")`を書いてください。

  Package draw ·

#### 48.2.2 Functions

関数: draw (gr2d, ..., gr3d, ..., options, ...)

  一連のシーンをプロットします; 引数は`gr2d`や`gr3d`のオブジェクトといくつかのオプションです。 デフォルトでは、シーンは1列の中に一緒に置かれます。

  関数`draw`は以下のグローバルオプションを受け付けます: `terminal`, `columns`, `dimensions`, `file_name`, `delay`.

  関数`draw2d`や`draw3d`は それぞれ、2次元と3次元に関して、１つのシーンだけが要求される時に使われる ショートカットです。

  `gr2d`と`gr3d`も参照してください。

  この関数を利用するには、最初に`load("draw")`を書いてください。

  例:

      (%i1) load("draw")$
      (%i2) scene1: gr2d(title="Ellipse",
                         nticks=30,
                         parametric(2*cos(t),5*sin(t),t,0,2*%pi))$
      (%i3) scene2: gr2d(title="Triangle",
                         polygon([4,5,7],[6,4,2]))$
      (%i4) draw(scene1, scene2, columns = 2)$

  2つの描画文は同値です:

      (%i1) load("draw")$
      (%i2) draw(gr3d(explicit(x^2+y^2,x,-1,1,y,-1,1)));
      (%o2)                          [gr3d(explicit)]
      (%i3) draw3d(explicit(x^2+y^2,x,-1,1,y,-1,1));
      (%o3)                          [gr3d(explicit)]

  アニメーティドgifファイル:

      (%i1) load("draw")$
      (%i2) draw(
              delay     = 100,
              file_name = "zzz",
              terminal  = 'animated_gif,
              gr2d(explicit(x^2,x,-1,1)),
              gr2d(explicit(x^3,x,-1,1)),
              gr2d(explicit(x^4,x,-1,1)));
      End of animation sequence
      (%o2)          [gr2d(explicit), gr2d(explicit), gr2d(explicit)]

  `gr2d`, `gr3d`, `draw2d`, `draw3d`も参照してください。

  Package draw ·File output ·

関数: draw2d (option, graphic_object, ...)

  この関数は `draw(gr2d(options, ..., graphic_object, ...))`. のショートカットです。

  2dで唯一のシーンをプロットするのに使うことができます。

  この関数を利用するには、最初に`load("draw")`を書いてください。

  `draw`と`gr2d`も参照してください。

  Package draw ·File output ·

関数: draw3d (option, graphic_object, ...)

  この関数は `draw(gr3d(options, ..., graphic_object, ...))` のショートカットです。

  3dでユニークなシーンをプロットするのに使うことができます。

  この関数を利用するには、最初に`load("draw")`を書いてください。

  `draw`と`gr3d`も参照してください。

  Package draw ·File output ·

関数: draw_file (graphic option, ..., graphic object, ...)

  現在のプロットをファイルに保存します。 受け付けられるグラフィックオプションは以下です: `terminal`, `dimensions`, `file_name`, `file_bgcolor`.

  例:

      (%i1) load("draw")$
      (%i2) /* screen plot */
            draw(gr3d(explicit(x^2+y^2,x,-1,1,y,-1,1)))$
      (%i3) /* same plot in eps format */
            draw_file(terminal  = eps,
                      dimensions = [5,5]) $

  Package draw ·File output ·

関数: multiplot_mode (term)

  この関数を使って、Maximaは 端末termで1ウィンドウマルチプロットモードで機能することができます; この関数が受け入れる引数は、`screen`, `wxt`, `aquaterm`, `none`です。

  マルチプロットモードがイネーブルの時、 `draw`へのそれぞれのコールは、 同じウィンドウに以前のものを消すことなく新しいプロットを送ります。 マルチモードをディセーブルにするには、 `multiplot_mode(none)`を書いてください。

  マルチプロットモードがイネーブルの時、 グローバルオプション`terminal`はブロックされます。 別の端末に変更する前に、この機能中のモードをディセーブルしなければいけません。

  この特長はWindowsプラットフォームでは機能しません。

  例:

      (%i1) load("draw")$
      (%i2) set_draw_defaults(
               xrange = [-1,1],
               yrange = [-1,1],
               grid   = true,
               title  = "Step by step plot" )$
      (%i3) multiplot_mode(screen)$
      (%i4) draw2d(color=blue,  explicit(x^2,x,-1,1))$
      (%i5) draw2d(color=red,   explicit(x^3,x,-1,1))$
      (%i6) draw2d(color=brown, explicit(x^4,x,-1,1))$
      (%i7) multiplot_mode(none)$

  Package draw ·File output ·

関数: set_draw_defaults (graphic option, ..., graphic object, ...)

  ユーザーグラフィックオプションを設定します。 この関数は 共通のグラフィックスオプションで一連のグラフィックスをプロットするのに 役に立ちます。 引数なしにこの関数を呼ぶと、ユーザーデフォルトを取り除きます。

  例:

      (%i1) load("draw")$
      (%i2) set_draw_defaults(
               xrange = [-10,10],
               yrange = [-2, 2],
               color  = blue,
               grid   = true)$
      (%i3) /* plot with user defaults */
            draw2d(explicit(((1+x)**2/(1+x*x))-1,x,-10,10))$
      (%i4) set_draw_defaults()$
      (%i5) /* plot with standard defaults */
            draw2d(explicit(((1+x)**2/(1+x*x))-1,x,-10,10))$

  この関数を利用するには、 最初に`load("draw")`を書いてください。

  Package draw ·

#### 48.2.3 Graphic options

グラフィックオプション: adapt_depth

  デフォルト値: 10

  `adapt_depth`は適応プロットルーチンが使う分割の最大数です。

  このオプションは2d`explicit`関数に対してだけ有効です。

  Package draw ·

グラフィックオプション: axis_3d

  デフォルト値: `true`

  もし`axis_3d`が`true`なら、 x, y z軸が3dシーンで表示されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(axis_3d = false,
                   explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$

  2dでの軸に関しては、 `axis_bottom`, `axis_left`, `axis_top`, `axis_right`も 参照してください。

  Package draw ·

グラフィックオプション: axis_bottom

  デフォルト値: `true`

  もし`axis_bottom`が`true`なら、 底の軸は2dシーンで表示されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(axis_bottom = false,
                   explicit(x^3,x,-1,1))$

  `axis_left`, `axis_top`, `axis_right`, `axis_3d`も参照してください。

  Package draw ·

グラフィックオプション: axis_left

  デフォルト値: `true`

  もし`axis_left`が`true`なら、 左の軸が2dシーンで表示されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(axis_left = false,
                   explicit(x^3,x,-1,1))$

  `axis_bottom`, `axis_top`, `axis_right`, `axis_3d`も参照してください。

  Package draw ·

グラフィックオプション: axis_right

  デフォルト値: `true`

  もし`axis_right`が`true`なら、 2dシーンで右軸が表示されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(axis_right = false,
                   explicit(x^3,x,-1,1))$

  `axis_bottom`, `axis_left`, `axis_top`, `axis_3d`も 参照してください。

  Package draw ·

グラフィックオプション: axis_top

  デフォルト値: `true`

  もし`axis_top`が`true`なら、 上部の軸が2dシーンで表示されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(axis_top = false,
                   explicit(x^3,x,-1,1))$

  `axis_bottom`, `axis_left`, `axis_right`, `axis_3d`も参照してください。

  Package draw ·

グラフィックオプション: background_color

  デフォルト値: `white`

  端末`gif`, `png`, `jpg`, `gif`のための背景色を設定します。 デフォルト背景色は白です。

  `color`も参照してください。

  Package draw ·

グラフィックオプション: border

  デフォルト値: `true`

  もし`border`が`true`なら、 ポリゴンの境界は`line_type`と`line_width`に従って塗られます。

  このオプションは以下のグラフィックオブジェクトに影響します:

  - `gr2d`: `polygon`, `rectangle`, と`ellipse`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(color       = brown,
                   line_width  = 8,
                   polygon([[3,2],[7,2],[5,5]]),
                   border      = false,
                   fill_color  = blue,
                   polygon([[5,2],[9,2],[7,5]]) )$

  Package draw ·

グラフィックオプション: cbrange

  デフォルト値: `auto`

  もし`cbrange`が`auto`なら `enhanced3d`が`false`でない時 色付けられる値の範囲は自動的に計算されます。 カラー範囲外の値は、最も近い端の色を使います。

  `enhanced3d`や`colorbox`が`false`の時、 オプション`cbrange`は効果を持ちません。

  もしユーザーが 色付けられた値の特定の区間が欲しいなら、 `cbrange=[-2, 3]`のようにMaximaリストとして与えられなければいけません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d (
              enhanced3d     = true,
              color          = green,
              cbrange = [-3,10],
              explicit(x^2+y^2, x,-2,2,y,-2,2)) $

  `enhanced3d`, `colorbox`, `cbtics`も参照してください。

  Package draw ·

グラフィックオプション: cbtics

  デフォルト値: `auto`

  このグラフィックオプションは、 オプション`enhanced3d`が`false`でない時、 カラーボックス上にチックマークを描く方法を制御します。

  `enhanced3d`か`colorbox`が`false`の時、 オプション`cbtics`は効果を持ちません。

  完全な記述に関しては、`xtics`を参照してください。

  例:

      (%i1) load("draw")$
      (%i2) draw3d (
              enhanced3d = true,
              color      = green,
              cbtics  = {["High",10],["Medium",05],["Low",0]},
              cbrange = [0, 10],
              explicit(x^2+y^2, x,-2,2,y,-2,2)) $

  `enhanced3d`, `colorbox`, `cbrange`も参照してください。

  Package draw ·

グラフィックオプション: color

  デフォルト値: `"blue"`

  `color`は、線や点、ポリゴンやラベルの境界をプロットする色を指定します。

  色は名前や16進数のrgbコードとして与えられます。

  利用可能な色の名前は以下のものです:

      white            black            gray0            grey0
      gray10           grey10           gray20           grey20
      gray30           grey30           gray40           grey40
      gray50           grey50           gray60           grey60
      gray70           grey70           gray80           grey80
      gray90           grey90           gray100          grey100
      gray             grey             light_gray       light_grey
      dark_gray        dark_grey        red              light_red
      dark_red         yellow           light_yellow     dark_yellow
      green            light_green      dark_green       spring_green
      forest_green     sea_green        blue             light_blue
      dark_blue        midnight_blue    navy             medium_blue
      royalblue        skyblue          cyan             light_cyan
      dark_cyan        magenta          light_magenta    dark_magenta
      turquoise        light_turquoise  dark_turquoise   pink
      light_pink       dark_pink        coral            light_coral
      orange_red       salmon           light_salmon     dark_salmon
      aquamarine       khaki            dark_khaki       goldenrod
      light_goldenrod  dark_goldenrod   gold             beige
      brown            orange           dark_orange      violet
      dark_violet      plum             purple

  16進コードでの色彩成分は形式`"#rrggbb"`で導入されます。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^2,x,-1,1), /* default is black */
                   color = "red",
                   explicit(0.5 + x^2,x,-1,1),
                   color = blue,
                   explicit(1 + x^2,x,-1,1),
                   color = "light-blue", /* double quotes if - is used */
                   explicit(1.5 + x^2,x,-1,1),
                   color = "#23ab0f",
                   label(["This is a label",0,1.2])  )$

  `fill_color`も参照してください。

  Package draw ·

グラフィックオプション: colorbox

  デフォルト値: `true`

  もし`colorbox`が`true`なら、 ラベルなしの色スケールが`image` 2Dオブジェクトか色付けされた3dオブジェクトと一緒に 描かれます。 もし`colorbox`が`false`なら、 色スケールは表示されません。 もし`colorbox`が文字列なら、ラベル付き色スケールが描かれます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) im: apply('matrix,
                       makelist(makelist(random(200),i,1,30),i,1,30))$
      (%i3) draw2d(image(im,0,0,30,30))$
      (%i4) draw2d(colorbox=false, image(im,0,0,30,30))$

  `palette`も参照してください。

  Package draw ·

グラフィックオプション: columns

  デフォルト値: 1

  `columns`は多重プロットでの列の数です。

  これはグローバルグラフィックオプションなので、 シーン記述での位置はかまいません。 関数`draw`の引数として使うこともできます。

  例:

      (%i1) load("draw")$
      (%i2) scene1: gr2d(title="Ellipse",
                         nticks=30,
                         parametric(2*cos(t),5*sin(t),t,0,2*%pi))$
      (%i3) scene2: gr2d(title="Triangle",
                         polygon([4,5,7],[6,4,2]))$
      (%i4) draw(scene1, scene2, columns = 2)$

  Package draw ·

グラフィックオプション: contour

  デフォルト値: `none`

  オプション`contour`を使うと、ユーザーは 等高線をプロットする場所を選択できます。 可能な値は以下の通りです:

  - `none`: 等高線がプロットされません。
  - `base`: 等高線がxy平面上に射影されます。
  - `surface`: 等高線が表面にプロットされます。
  - `both`: 2つの等高線がプロットされます:xy平面上と表面と。
  - `map`: 等高線がxy平面上に射影されて、観点がちょうど垂直に設定されます。

  これはグローバルグラフィックオプションなので、 シーン記述での位置はかまいません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3),
                   contour_levels = 15,
                   contour        = both,
                   surface_hide   = true) $

  Package draw ·

グラフィックオプション: contour_levels

  デフォルト値: 5

  このグラフィックオプションは、 等高線が描かれる方法を制御します。 `contour_levels`は、正の整数、3つの数のリスト、または、 数の任意の集合に設定することができます:

  - オプション`contour_levels`が正の整数nにバインド(bounded)されている時、 nこの等高線が等しい間隔で描かれます。 デフォルトでは、 5つの等しく間隔の空けられた等高線がプロットされます。
  - オプション`contour_levels`が 形式`[lowest,s,highest]`の長さ3のリストにバインド(bounded)されている時、 等高線は `lowest`から`highest`へ`s`個のステップでプロットされます。
  - オプション`contour_levels`が 形式`{n1, n2, ...}`の数の集合にバインド(bounded)されている時、 等高線は 値`n1`, `n2`, ...にプロットされます。

  これはグローバルグラフィックオプションなので、 シーン記述での位置はかまいません。

  例:

  10の等しく間隔の空けられた等高線。 レベルの実際の数は簡単なラベルを与えるために調整することができます。

      (%i1) load("draw")$
      (%i2) draw3d(color = green,
                   explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3),
                   contour_levels = 10,
                   contour        = both,
                   surface_hide   = true) $

  -8から8まで4つのステップで。

      (%i1) load("draw")$
      (%i2) draw3d(color = green,
                   explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3),
                   contour_levels = [-8,4,8],
                   contour        = both,
                   surface_hide   = true) $

  レベル-7, -6, 0.8, 5での等値線。

      (%i1) load("draw")$
      (%i2) draw3d(color = green,
                   Explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3),
                   Contour_levels = {-7, -6, 0.8, 5},
                   Contour        = both,
                   Surface_hide   = true) $

  `contour`も参照してください。

  Package draw ·

グラフィックオプション: data_file_name

  デフォルト値: `"data.gnuplot"`

  これは、 リクエストされたプロットを構築するためにGnuplotが必要とする数値データを含む ファイルの名前です。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。 関数`draw`の引数としても使うことができます。

  `gnuplot_file_name`の中で例を参照してください。

  Package draw ·

グラフィックオプション: delay

  デフォルト値: 5

  これは アニメーションgifファイルにおけるフレームの1/100秒単位の遅延です。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。 関数`draw`の引数としても使うことができます。

  例:

      (%i1) load("draw")$
      (%i2) draw(
              delay     = 100,
              file_name = "zzz",
              terminal  = 'animated_gif,
              gr2d(explicit(x^2,x,-1,1)),
              gr2d(explicit(x^3,x,-1,1)),
              gr2d(explicit(x^4,x,-1,1)));
      End of animation sequence
      (%o2)          [gr2d(explicit), gr2d(explicit), gr2d(explicit)]

  オプション`delay`はアニメーションgifに関してだけアクティブです; 他のいかなる場合も無視されます。

  `terminal`, `dimensions`も参照してください。

  Package draw ·

グラフィックオプション: dimensions

  デフォルト値: `[600,500]`

  出力端末の寸法。 その値は、幅と高さで形成されるリストです。 2つの数の意味は使っている端末に依存します。

  端末`gif`, `animated_gif`, `png`, `jpg`, `svg`, `screen`, `wxt`, `aquaterm`では、 整数はそれぞれの方向の点の数を表します。 もし整数でないなら、丸められます。

  端末`eps`, `eps_color`, `pdf`, `pdfcairo`では、 両方の数は1/100cm単位の長さを表します。 デフォルトでは、これらのフォーマットでの画像は幅6cm、高さ5cmであることを意味します。

  これはグローバルグラフィックオプションなので、 シーン記述での位置は関係ありません。 関数`draw`の引数として使われることもあります。

  例:

  ファイル出力とwxtキャンバスに適用されたオプション`dimensions`。

      (%i1) load("draw")$
      (%i2) draw2d(
              dimensions = [300,300],
              terminal   = 'png,
              explicit(x^4,x,-1,1)) $
      (%i3) draw2d(
              dimensions = [300,300],
              terminal   = 'wxt,
              explicit(x^4,x,-1,1)) $

  eps出力に適用されたオプション`dimensions`。 A4縦寸法のepsファイルが欲しいです。

      (%i1) load("draw")$
      (%i2) A4portrait: 100*[21, 29.7]$
      (%i3) draw3d(
              dimensions = A4portrait,
              terminal   = 'eps,
              explicit(x^2-y^2,x,-2,2,y,-2,2)) $

  Package draw ·

グラフィックオプション: enhanced3d

  デフォルト値: `false`

  もし`enhanced3d`が`false`なら、 3dプロットで表面は色付けられません。 もし`enhanced3d`が`true`なら、 Gnuplotのpm3dモードを設定して表面が色付けられます。 もし式が`enhanced3d`に与えられるなら、 それは`palette`に従って色を割り当てるのに使われます; この式の中の変数は表面記述で使われるものと同じでなければいけません。

  如何にパレットが指定されるか知るためには、オプション`palette`を参照してください。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(
               surface_hide = true,
               enhanced3d   = true,
               palette      = gray,
               explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$
      (%i3) draw3d(
               surface_hide = true,
               /* same variables x and y as */
               /* in explicit below:        */
               enhanced3d   = sin(x*y),
               explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$
      (%i4) draw3d(
               color = blue,
               nticks = 60,
               line_width = 3,
               enhanced3d = (u-1)^2,
               parametric(cos(5*u)^2,sin(7*u),u-2,u,0,2))$

  Package draw ·

グラフィックオプション: error_type

  デフォルト値: `y`

  値は`x`, `y`, `xy`を取り得ますが、その値に依存して、 グラフィックオブジェクト`errors`は水平エラーバー、垂直エラーバー、その両方を伴って 点を描画します。 `error_type=boxes`の時、クロスの代わりにボックスが描かれます。

  `errors`も参照してください。

グラフィックオプション: file_name

  デフォルト値: `"maxima_out"`

  これは、 端末`png`, `jpg`, `eps`, `eps_color`, `pdf`, `pdfcairo`がグラフィックを保存する ファイルの名前です。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(file_name = "myfile",
                   explicit(x^2,x,-1,1),
                   terminal  = 'png)$

  `terminal`, `dimensions`も参照してください。

  Package draw ·

グラフィックオプション: fill_color

  デフォルト値: `"red"`

  `fill_color`はポリゴンと2d `explicit`関数を塗りつぶすための色を指定します。

  如何に色が指定されるかを知るには`color`を参照してください。

  Package draw ·

グラフィックオプション: fill_density

  デフォルト値: 0

  `fill_density`は、`bars`オブジェクトに関して`fill_color`の強度を指定する0と1の間の数です。

  例を見るには`bars`を参照してください。

グラフィックオプション: filled_func

  デフォルト値: `false`

  オプション`filled_func`は 関数によって制限された領域が如何に塗りつぶされるべきかを 制御します。 `filled_func`が`true`の時、 オブジェクト`explicit`とグラフィックウィンドウの底で定義された関数によって 閉ざされた領域は`fill_color`で塗りつぶされます。 `filled_func`が関数式を含む時、 この関数とオブジェクト`explicit` で定義された関数によって閉ざされた領域が 塗りつぶされます。 デフォルトでは、陽な関数は塗りつぶされません。

  このオプションは2dグラフィックオブジェクト`explicit`だけに影響します。

  例:

  `explicit`オブジェクトとグラフィックウィンドウによって閉ざされた領域。

      (%i1) load("draw")$
      (%i2) draw2d(fill_color  = red,
                   filled_func = true,
                   explicit(sin(x),x,0,10) )$

  `explicit`オブジェクト とオプション`filled_func`で定義された関数によって閉ざされた領域。 `filled_func`の中の変数は must be the same as that used in `explicit`の中で使われるものと同じでなければいけないことに注意してください。

      (%i1) load("draw")$
      (%i2) draw2d(fill_color  = grey,
                   filled_func = sin(x),
                   explicit(-sin(x),x,0,%pi));

  `fill_color`と`explicit`も参照してください。

  Package draw ·

グラフィックオプション: font

  デフォルト値: `""` (empty string)

  このオプションは 端末が使う書体を設定するために使うことができます。 プロットを通して書体とサイズは１つだけ使うことができます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  `font_size`も参照してください。

  Gnuplotはそれ自身フォントを扱いません。 異なる端末のサポートライブラリに任せます。 それぞれはフォントに関して独自の哲学を持っています。 簡単なまとめは以下の通りです:

  - x11: 通常のX11フォンとサーバーメカニズムを使います。

    例:

        (%i1) load("draw")$
        (%i2) draw2d(font      = "Arial",
                     font_size = 20,
                     label(["Arial font, size 20",1,1]))$

  - windows: Windows端末はプロット内部でフォントの変更をサポートしません。 一旦プロットが生成されると、グラフウィンドウのメニューを右クリックしてフォントを変更することができます。
  - png, jpeg, gif: libgdライブラリは 環境変数`GDFONTPATH`の中に保持されたフォントパスを使います; この場合、オプション`font`をフォント名に設定することだけが必要です。 フォントファイルへの完全なパスを与えることも可能です。

    例:

    オプション`font`はフォントファイルへの完全なパスを与えることができます:

        (%i1) load("draw")$
        (%i2) path: "/usr/share/fonts/truetype/freefont/" $
        (%i3) file: "FreeSerifBoldItalic.ttf" $
        (%i4) draw2d(
                font      = concat(path, file),
                font_size = 20,
                color     = red,
                label(["FreeSerifBoldItalic font, size 20",1,1]),
                terminal  = png)$

    もし環境変数`GDFONTPATH`が フォントファイルが配置されているパスに設定されているなら、 set グラフィックオプション`font`をフォント名に設定することが可能です。

        (%i1) load("draw")$
        (%i2) draw2d(
                font      = "FreeSerifBoldItalic",
                font_size = 20,
                color     = red,
                label(["FreeSerifBoldItalic font, size 20",1,1]),
                terminal  = png)$

  - Postscript: 標準ポストスクリプトフォントは以下の通りです:
    `"Times-Roman"`, `"Times-Italic"`, `"Times-Bold"`, `"Times-BoldItalic"`,
    `"Helvetica"`, `"Helvetica-Oblique"`, `"Helvetica-Bold"`,
    `"Helvetic-BoldOblique"`, `"Courier"`, `"Courier-Oblique"`, `"Courier-Bold"`,
    `"Courier-BoldOblique"`。

    例:

        (%i1) load("draw")$
        (%i2) draw2d(
                font      = "Courier-Oblique",
                font_size = 15,
                label(["Courier-Oblique font, size 15",1,1]),
                terminal = eps)$

  - pdf: Postscriptと同じフォントを使います。
  - pdfcairo: wxtと同じフォントを使います。
  - wxt: pangoライブラリは `fontconfig`ユーティリティを介してフォントを見つけます。
  - aqua: デフォルトは`"Times-Roman"`です。

  Gnuplotドキュメンテーションは端末とフォントに関する情報の重要なソースです。

  Package draw ·

グラフィックオプション: font_size

  デフォルト値: 10

  このオプションは、 フォントサイズを端末によって使われるように設定するために使うことができます。 １つの書体とサイズだけがプロットの間中で使うことができます。 オプション`font`が空の文字列に等しくない時だけ、 `font_size`はアクティブです。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  `font`も参照してください。

  Package draw ·

グラフィックオプション: gnuplot_file_name

  デフォルト値: `"maxout.gnuplot"`

  これは、 Gnuplotで処理される必要なコマンドを含む ファイルの名前です。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。 関数`draw`の引数としても使うことができます。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(
             file_name = "my_file",
             gnuplot_file_name = "my_commands_for_gnuplot",
             data_file_name    = "my_data_for_gnuplot",
             terminal          = png,
             explicit(x^2,x,-1,1)) $

  `data_file_name`も参照してください。

  Package draw ·

グラフィックオプション: grid

  デフォルト値: `false`

  もし`grid`が`true`なら、 xy平面上に格子が描かれます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(grid = true,
                   explicit(exp(u),u,-2,2))$

  Package draw ·

グラフィックオプション: head_angle

  デフォルト値: 45

  `head_angle`は矢印の頭と線分の間の角度を度の単位で示します。

  このオプションは`vector`オブジェクトに対してだけ有効です。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xrange      = [0,10],
                   yrange      = [0,9],
                   head_length = 0.7,
                   head_angle  = 10,
                   vector([1,1],[0,6]),
                   head_angle  = 20,
                   vector([2,1],[0,6]),
                   head_angle  = 30,
                   vector([3,1],[0,6]),
                   head_angle  = 40,
                   vector([4,1],[0,6]),
                   head_angle  = 60,
                   vector([5,1],[0,6]),
                   head_angle  = 90,
                   vector([6,1],[0,6]),
                   head_angle  = 120,
                   vector([7,1],[0,6]),
                   head_angle  = 160,
                   vector([8,1],[0,6]),
                   head_angle  = 180,
                   vector([9,1],[0,6]) )$

  `head_both`, `head_length`, `head_type`も参照してください。

  Package draw ·

グラフィックオプション: head_both

  デフォルト値: `false`

  もし`head_both`が`true`なら、 ベクトルは2つの矢先と共に描画されます。 もし`false`なら１つの矢だけが描かれます。

  このオプションは`vector`オブジェクトに対してだけ有効です。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xrange      = [0,8],
                   yrange      = [0,8],
                   head_length = 0.7,
                   vector([1,1],[6,0]),
                   head_both   = true,
                   vector([1,7],[6,0]) )$

  See also `head_length`, `head_angle`, and `head_type`.

  Package draw ·

グラフィックオプション: head_length

  デフォルト値: 2

  `head_length`は矢印の頭の長さをx-軸の単位で示します。

  このオプションは`vector`オブジェクトに対してだけ有効です。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xrange      = [0,12],
                   yrange      = [0,8],
                   vector([0,1],[5,5]),
                   head_length = 1,
                   vector([2,1],[5,5]),
                   head_length = 0.5,
                   vector([4,1],[5,5]),
                   head_length = 0.25,
                   vector([6,1],[5,5]))$

  `head_both`, `head_angle`, `head_type`も参照してください。

  Package draw ·

グラフィックオプション: head_type

  デフォルト値: `filled`

  `head_type`は矢印の頭を如何にプロットするかを指定するのに使われます。 可能な値は以下の通りです: `filled` (閉じていて塗りつぶされた矢印の頭), `empty` (閉じているが塗りつぶされていない矢印の頭), `nofilled` (開いた矢印の頭).

  このオプションは`vector`オブジェクトにだけ有効です。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xrange      = [0,12],
                   yrange      = [0,10],
                   head_length = 1,
                   vector([0,1],[5,5]), /* default type */
                   head_type = 'empty,
                   vector([3,1],[5,5]),
                   head_type = 'nofilled,
                   vector([6,1],[5,5]))$

  `head_both`, `head_angle`, `head_length`も参照してください。

  Package draw ·

グラフィックオプション: ip_grid

  デフォルト値: `[50, 50]`

  `ip_grid`はインプリシットなプロットでの最初のサンプリングのためにグリッドを設定します。

  このオプションは`implicit`オブジェクトに対してだけ関係があります。

  Package draw ·

グラフィックオプション: ip_grid_in

  デフォルト値: `[5, 5]`

  `ip_gridi_in`はインプリシットなプロットでの二番目のサンプリングのためにグリッドを設定します。

  このオプションは`implicit`オブジェクトに対してだけ関係があります。

  Package draw ·

グラフィックオプション: key

  デフォルト値: `""` (empty string)

  `key`は凡例の中の関数名です。 もし`key`が空の文字列なら、 関数にキーは割り当てられません。

  このオプションは以下のグラフィックオブジェクトに影響します:

  - `gr2d`: `points`, `polygon`, `rectangle`, `ellipse`, `vector`, `explicit`, `implicit`, `parametric`, と`polar`。
  - `gr3d`: `points`, `explicit`, `parametric`, と`parametric_surface`

  例:

      (%i1) load("draw")$
      (%i2) draw2d(key   = "Sinus",
                   explicit(sin(x),x,0,10),
                   key   = "Cosinus",
                   color = red,
                   explicit(cos(x),x,0,10) )$

  Package draw ·

グラフィックオプション: label_alignment

  デフォルト値: `center`

  `label_alignment`は 与えられた座標に関するラベルを書く場所を指定するのに使われます。 可能な値は以下のものです: `center`, `left`, `right`.

  このオプションは`label`オブジェクトに対してだけ有効です。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xrange          = [0,10],
                   yrange          = [0,10],
                   points_joined   = true,
                   points([[5,0],[5,10]]),
                   color           = blue,
                   label(["Centered alignment (default)",5,2]),
                   label_alignment = 'left,
                   label(["Left alignment",5,5]),
                   label_alignment = 'right,
                   label(["Right alignment",5,8]))$

  `label_orientation`, `color`も参照してください。

  Package draw ·

グラフィックオプション: label_orientation

  デフォルト値: `horizontal`

  `label_orientation`はラベルの向きを指定するのに使われます。 可能な値は以下のものです: `horizontal`, `vertical`.

  このオプションは`label`オブジェクトに対してだけ有効です。

  例:

  この例では、ダミーの点がイメージを得るために加えられます。 パッケージ`draw`はいつもシーンを描くのにデータを必要とします。

      (%i1) load("draw")$
      (%i2) draw2d(xrange     = [0,10],
                   yrange     = [0,10],
                   point_size = 0,
                   points([[5,5]]),
                   color      = navy,
                   label(["Horizontal orientation (default)",5,2]),
                   label_orientation = 'vertical,
                   color             = "#654321",
                   label(["Vertical orientation",1,5]))$

  `label_alignment`と`color`も参照してください。

  Package draw ·

グラフィックオプション: line_type

  デフォルト値: `solid`

  `line_type`は線が如何に表示されるかを示します; 可能な値は`solid`と`dots`です。

  このオプションは以下のグラフィックオブジェクトに鋭意供します:

  - `gr2d`: `points`, `polygon`, `rectangle`, `ellipse`, `vector`, `explicit`, `implicit`, `parametric`と`polar`。
  - `gr3d`: `points`, `explicit`, `parametric`と`parametric_surface`。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(line_type = dots,
                   explicit(1 + x^2,x,-1,1),
                   line_type = solid, /* default */
                   explicit(2 + x^2,x,-1,1))$

  See also `line_width`.

  Package draw ·

グラフィックオプション: line_width

  デフォルト値: 1

  `line_width`はプロットされる線の幅です。 その値は正の数でなければいけません。

  このオプションは以下のグラフィックオブジェクトに影響します:

  - `gr2d`: `points`, `polygon`, `rectangle`, `ellipse`, `vector`, `explicit`, `implicit`, `parametric` と`polar`.
  - `gr3d`: `points`と`parametric`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^2,x,-1,1), /* default width */
                   line_width = 5.5,
                   explicit(1 + x^2,x,-1,1),
                   line_width = 10,
                   explicit(2 + x^2,x,-1,1))$

  `line_type`も参照してください。

  Package draw ·

グラフィックオプション: logcb

  デフォルト値: `false`

  もし`logcb`が`true`なら、 カラーボックスのチックは対数スケールで描かれます。

  `enhanced3d`か`colorbox`が`false`の時、 オプション`logcb`は効果を持ちません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d (
              enhanced3d = true,
              color      = green,
              logcb = true,
              logz  = true,
              palette = [-15,24,-9],
              explicit(exp(x^2-y^2), x,-2,2,y,-2,2)) $

  `enhanced3d`, `colorbox`, `cbrange`も参照してください。

  Package draw ·

グラフィックオプション: logx

  デフォルト値: `false`

  もし`logx`が`true`なら、 x軸は対数スケールで描かれます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(log(x),x,0.01,5),
                   logx = true)$

  `logy`, `logz`も参照してください。

  Package draw ·

グラフィックオプション: logy

  デフォルト値: `false`

  もし`logy`が`true`なら、 y軸は対数スケールで描かれます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(logy = true,
                   explicit(exp(x),x,0,5))$

  `logx`, `logz`も参照してください。

  Package draw ·

グラフィックオプション: logz

  デフォルト値: `false`

  もし`logz`が`true`なら、 z軸は対数スケールで描かれます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(logz = true,
                   explicit(exp(u^2+v^2),u,-2,2,v,-2,2))$

  `logx`, `logy`も参照してください。

  Package draw ·

グラフィックオプション: nticks

  デフォルト値: 29

  2dでは、`nticks`は、 陽なオブジェクトに関する適応プロットルーチンによって使われる点の初期数を与えます。 それはパラメトリック曲線と極座標曲線で示される点の数でもあります。

  このオプションは以下のグラフィックオブジェクトに影響を与えます:

  - `gr2d`: `ellipse`, `explicit`, `parametric`と`polar`。
  - `gr3d`: `parametric`。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(transparent = true,
                   ellipse(0,0,4,2,0,180),
                   nticks = 5,
                   ellipse(0,0,4,2,180,180) )$

  Package draw ·

グラフィックオプション: palette

  デフォルト値: `color`

  `palette`はグレイレベルを色成分上にマップする仕方を示します。 3Dオブジェクトでのオプション`enhanced3d`と一緒に機能します。 3Dオブジェクトは表面のすべての点を実数かグレイレベルに関連付けます。 グレイイメージとも一緒に機能します。`palette`によってレベルは色に変換されます。

  これらの変換を定義するには2つの方法があります。

  1つ目の方法では、`palette`は、-36から+36までの範囲の成分の長さ3のベクトルです; それぞれの値は それぞれ赤、緑、青色上にレベルをマップする公式に関する添字です:

       0: 0               1: 0.5           2: 1
       3: x               4: x^2           5: x^3
       6: x^4             7: sqrt(x)       8: sqrt(sqrt(x))
       9: sin(90x)       10: cos(90x)     11: |x-0.5|
      12: (2x-1)^2       13: sin(180x)    14: |cos(180x)|
      15: sin(360x)      16: cos(360x)    17: |sin(360x)|
      18: |cos(360x)|    19: |sin(720x)|  20: |cos(720x)|
      21: 3x             22: 3x-1         23: 3x-2
      24: |3x-1|         25: |3x-2|       26: (3x-1)/2
      27: (3x-2)/2       28: |(3x-1)/2|   29: |(3x-2)/2|
      30: x/0.32-0.78125 31: 2*x-0.84     32: 4x;1;-2x+1.84;x/0.08-11.5
      33: |2*x - 0.5|    34: 2*x          35: 2*x - 0.5
      36: 2*x - 1

  負の数は負の色成分を意味します。 `palette = gray`と`palette = color`は、 それぞれ`palette = [3,3,3]`と`palette = [7,5,15]`の ショートカットです

  2つ目の方法では、`palette`はユーザー定義のルックアップテーブルです。 この場合、長さ`n`のルックアップテーブルを構成するフォーマットは `palette=[color_1, color_2, ..., color_n`です。 ここで、`color_i`は、`color_i`が最低のグレイレベルに割り当てられ、 `color_n`が最高に割り当てられるような均整のとれた色です (オプション`color`を参照してください)。 残りの色は内挿されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

  3Dオブジェクトでのオプション`enhanced3d`と一緒に機能します。

      (%i1) load("draw")$
      (%i2) draw3d(
              enhanced3d = [z-x+2*y,x,y,z],
              palette = [32, -8, 17],
              explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$

  グレイイメージとも一緒に機能します。

      (%i1) load("draw")$
      (%i2) im: apply(
                 'matrix,
                  makelist(makelist(random(200),i,1,30),i,1,30))$
      (%i3) /* palette = color, default */
            draw2d(image(im,0,0,30,30))$
      (%i4) draw2d(palette = gray, image(im,0,0,30,30))$
      (%i5) draw2d(palette = [15,20,-4],
                   colorbox=false,
                   image(im,0,0,30,30))$

  `palette`はユーザー定義のルックアップテーブルの場合があります。 この例では、ple, low values of `x`の低いレベルは赤に割り当てられ、高いレベルは黄色に割り当てられています。

      (%i1) load("draw")$
      (%i2) draw3d(
               palette = [red, blue, yellow],
               enhanced3d = x,
               explicit(x^2+y^2,x,-1,1,y,-1,1)) $

  `colorbox`も参照してください。

  Package draw ·

グラフィックオプション: point_size

  デフォルト値: 1

  `point_size`はプロットされる点のサイズを設定します。 非負数でなければいけません。

  グラフィックオプション`point_type`が`dot`に設定される時 このオプションは効果を持ちません。

  このオプションは以下のグラフィックオブジェクトに影響します:

  - `gr2d`: `points`.
  - `gr3d`: `points`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(points(makelist([random(20),random(50)],k,1,10)),
              point_size = 5,
              points(makelist(k,k,1,20),makelist(random(30),k,1,20)))$

  Package draw ·

グラフィックオプション: point_type

  デフォルト値: 1

  `point_type`は、いかに孤立した点が表示されるかを示します; このオプションの値は、-1以上の整数インデックスもしくは点スタイルの名前であり得ます: `$none` (-1), `dot` (0), `plus` (1), `multiply` (2), `asterisk` (3), `square` (4), `filled_square` (5), `circle` (6), `filled_circle` (7), `up_triangle` (8), `filled_up_triangle` (9), `down_triangle` (10), `filled_down_triangle` (11), `diamant` (12),`filled_diamant` (13).

  このオプションは以下のグラフィックオブジェクトに影響します:

  - `gr2d`: `points`.
  - `gr3d`: `points`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xrange = [0,10],
                   yrange = [0,10],
                   point_size = 3,
                   point_type = diamant,
                   points([[1,1],[5,1],[9,1]]),
                   point_type = filled_down_triangle,
                   points([[1,2],[5,2],[9,2]]),
                   point_type = asterisk,
                   points([[1,3],[5,3],[9,3]]),
                   point_type = filled_diamant,
                   points([[1,4],[5,4],[9,4]]),
                   point_type = 5,
                   points([[1,5],[5,5],[9,5]]),
                   point_type = 6,
                   points([[1,6],[5,6],[9,6]]),
                   point_type = filled_circle,
                   points([[1,7],[5,7],[9,7]]),
                   point_type = 8,
                   points([[1,8],[5,8],[9,8]]),
                   point_type = filled_diamant,
                   points([[1,9],[5,9],[9,9]]) )$

  Package draw ·

グラフィックオプション: points_joined

  デフォルト値: `false`

  `points_joined`が`true`の時、 点は線で結ばれます; `false`の時、孤立した点が描かれます。 このグラフィックオプションの三番目の可能な値は`impulses`です; この場合、点からx軸(2D)もしくはxy平面(3D)へ垂直の線分が描かれます。

  このオプションは以下のグラフィックオブジェクトに影響します:

  - `gr2d`: `points`.
  - `gr3d`: `points`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xrange        = [0,10],
                   yrange        = [0,4],
                   point_size    = 3,
                   point_type    = up_triangle,
                   color         = blue,
                   points([[1,1],[5,1],[9,1]]),
                   points_joined = true,
                   point_type    = square,
                   line_type     = dots,
                   points([[1,2],[5,2],[9,2]]),
                   point_type    = circle,
                   color         = red,
                   line_width    = 7,
                   points([[1,3],[5,3],[9,3]]) )$

  Package draw ·

グラフィックオプション: proportional_axes

  デフォルト値: `none`

  `proportional_axes`が`xy`に等しい時、 それらの相対的な長さに比例する軸で2Dシーンが描かれます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  このオプションは2Dプロットでだけ機能します。 一旦Gnuplot 4.3が公式にリリースされたら、 `proportional_axes`は3Dプロットに拡張させるでしょう。

  例:

  単プロット。

      (%i1) load("draw")$
      (%i2) draw2d(
              ellipse(0,0,1,1,0,360),
              transparent=true,
              color = blue,
              line_width = 4,
              ellipse(0,0,2,1/2,0,360),
              proportional_axes = xy) $

  多重プロット。

      (%i1) load("draw")$
      (%i2) draw(
              terminal = wxt,
              gr2d(proportional_axes = xy,
                   explicit(x^2,x,0,1)),
              gr2d(explicit(x^2,x,0,1),
                   xrange = [0,1],
                   yrange = [0,2],
                   proportional_axes=xy),
              gr2d(explicit(x^2,x,0,1))

  Package draw ·

グラフィックオプション: surface_hide

  デフォルト値: `false`

  もし`surface_hide`が`true`なら、 隠れた部分は3d表面にプロットされません。

  これはグローバルグラフィックオプションなので、 シーン記述での位置はかまいません。

  例:

      (%i1) load("draw")$
      (%i2) draw(columns=2,
                 gr3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3)),
                 gr3d(surface_hide = true,
                      explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3)) )$

  Package draw ·

グラフィックオプション: terminal

  デフォルト値: `screen`

  Gnuplotが使う端末を選択します; 可能な値は: `screen` (デフォルト), `png`, `pngcairo`, `jpg`, `eps`, `eps_color`, `pdf`, `pdfcairo`, `gif`, `animated_gif`, `wxt`, `aquaterm`.

  端末`screen`, `wxt`, `aquaterm`は２つの要素を持つリストとしても定義できます: 端末自身の名前と非負の整数。 この形式では、それぞれ対応する番号を持つ複数のウィンドウを同時に開くことができます。 この特長はWindowsプラットフォームでは機能しません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。 関数`draw`の引数としても使われます。

  注意せよ―pdfcairoはGnuplot 4.3を必要とします。 (2008年11月)現在、Gnuplot 4.3は開発バージョンです。 pdfは、 Gnuplot 4.2/4.3を オプション`--enable-pdf`でコンパイルすることを 必要とし、libpdfがインストールされていなければいけません。 pdfライブラリは以下で利用可能です: http://www.pdflib.com/en/download/pdflib-family/pdflib-lite/

  例:

      (%i1) load("draw")$
      (%i2) /* screen terminal (default) */
            draw2d(explicit(x^2,x,-1,1))$
      (%i3) /* png file */
            draw2d(terminal  = 'png,
                   explicit(x^2,x,-1,1))$
      (%i4) /* jpg file */
            draw2d(terminal   = 'jpg,
                   dimensions = [300,300],
                   explicit(x^2,x,-1,1))$
      (%i5) /* eps file */
            draw2d(file_name = "myfile",
                   explicit(x^2,x,-1,1),
                   terminal  = 'eps)$
      (%i6) /* pdf file */
            draw2d(file_name = "mypdf",
                   dimensions = 100*[12.0,8.0],
                   explicit(x^2,x,-1,1),
                   terminal  = 'pdf)$
      (%i7) /* wxwidgets window */
            draw2d(explicit(x^2,x,-1,1),
                   terminal  = 'wxt)$

  複数のウィンドウ。

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^5,x,-2,2), terminal=[screen, 3])$
      (%i3) draw2d(explicit(x^2,x,-2,2), terminal=[screen, 0])$

  動画gifファイル。

      (%i1) load("draw")$
      (%i2) draw(
              delay     = 100,
              file_name = "zzz",
              terminal  = 'animated_gif,
              gr2d(explicit(x^2,x,-1,1)),
              gr2d(explicit(x^3,x,-1,1)),
              gr2d(explicit(x^4,x,-1,1)));
      End of animation sequence
      (%o2)          [gr2d(explicit), gr2d(explicit), gr2d(explicit)]

  オプション`delay`は動画gifでだけ有効です; 他のいかなる場合も無視されます。

  `file_name`, `dimensions`, `delay`も参照してください。

  Package draw ·

グラフィックオプション: title

  デフォルト値: `""` (empty string)

  オプション`title`、文字列は、シーンのメインタイトルです。 デフォルトではタイトルは書かれません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(exp(u),u,-2,2),
                   title = "Exponential function")$

  Package draw ·

グラフィックオプション: transform

  デフォルト値: `none`

  もし`transform`が`none`なら、 空間は変換されず、グラフィックオブジェクトは定義の通り描画されます。 空間変換が望まれた時、リストがオプション`transform`に割り当てられなければいけません。 2Dシーンの場合、 リストは形式`[f1(x,y), f2(x,y), x, y]`を取ります。 3Dシーンの場合、 リストは形式`[f1(x,y,z), f2(x,y,z), f3(x,y,z), x, y, z]`を取ります。 リストの中で定義されている変数名は グラフィックオブジェクトの定義の中で使われるものと異なるかもしれません。

  例:

  2Dの回転。

      (%i1) load("draw")$
      (%i2) th : %pi / 4$
      (%i3) draw2d(
              color = "#e245f0",
              proportional_axes = 'xy,
              line_width = 8,
              triangle([3,2],[7,2],[5,5]),
              border     = false,
              fill_color = yellow,
              transform  = [cos(th)*x - sin(th)*y,
                            sin(th)*x + cos(th)*y, x, y],
              triangle([3,2],[7,2],[5,5]) )$

  3Dでの変形。

      (%i1) load("draw")$
      (%i2) draw3d(
              color     = "#a02c00",
              explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3),
              transform = [x+10,y+10,z+10,x,y,z],
              color     = blue,
              explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3) )$

  Package draw ·

グラフィックオプション: transparent

  デフォルト値: `false`

  もし`transparent`が`true`なら、 ポリゴンの内側の領域は`fill_color`に従って塗りつぶされます。

  このオプションは以下のグラフィックオブジェクトに影響します:

  - `gr2d`: `polygon`, `rectangle`, と`ellipse`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(polygon([[3,2],[7,2],[5,5]]),
                   transparent = true,
                   color       = blue,
                   polygon([[5,2],[9,2],[7,5]]) )$

  Package draw ·

グラフィックオプション: tube_extremes

  デフォルト値: `[open, open]`

  グラフィックオブジェクト`tube`の極値が開いたままか 閉じていなければいけないかを示唆する 2つの可能性のある要素`open`と`closed`を持つリスト。 デフォルトでは、どちらの極値も開いたままです。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(
              tube_extremes = [open, closed],
              tube(0, 0, a, 1,
                   a, 0, 8) )$

  Package draw ·

グラフィックオプション: unit_vectors

  デフォルト値: `false`

  もし`unit_vectors`が`true`なら、 ベクトルは単位1でプロットされます。 これはベクトル場をプロットするのに役に立ちます。 もし`unit_vectors`が`false`なら、 ベクトルは元の長さでプロットされます。

  このオプションは`vector`オブジェクトに対してだけ有効です。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xrange      = [-1,6],
                   yrange      = [-1,6],
                   head_length = 0.1,
                   vector([0,0],[5,2]),
                   unit_vectors = true,
                   color        = red,
                   vector([0,3],[5,2]))$

  Package draw ·

グラフィックオプション: user_preamble

  デフォルト値: `""` (empty string)

  熟練Gnuplotユーザーは、 `plot`や`splot`コマンドの前に送られる設定を書くことで、 このオプションを利用して、 Gnuplotの振る舞いを微調整することができます。

  このオプションの値は文字列か(行毎に１つの)文字列のリスト でなければいけません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

  ダム端末は、パッケージ`draw`でサポートされていませんが、 オプション`user_preamble`の利用によって、それを設定することが可能です。

      (%i1) load("draw")$
      (%i2) draw2d(explicit(exp(x)-1,x,-1,1),
                   parametric(cos(u),sin(u),u,0,2*%pi),
                   user_preamble="set terminal dumb")$

  Package draw ·

グラフィックオプション: view

  デフォルト値: `[60,30]`

  3Dシーンでビュー方向を示す度数で測られた角度の対。 最初の角度はx軸回りの垂直回転であり、[0, 180]の範囲です。 二番目はz回りの水平回転であり、[0, 360]の範囲です。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(view = [170, 360],
                   explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$

  Package draw ·

グラフィックオプション: x_voxel

  デフォルト値: 10

  `x_voxel`は 3d `暗黙の`オブジェクトで実装されたマーチングキューブアルゴリズム x方向のボクセルの数です。 グラフィックオブジェクト`region`でも使われます。

  Package draw ·

グラフィックオプション: xaxis

  デフォルト値: `false`

  もし`xaxis`が`true`なら、 x軸が描かれます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^3,x,-1,1),
                   xaxis       = true,
                   xaxis_color = blue)$

  `xaxis_width`, `xaxis_type`, `xaxis_color`も参照してください。

  Package draw ·

グラフィックオプション: xaxis_color

  デフォルト値: `"black"`

  `xaxis_color`はx軸の色を指定します。 いかに色が定義されるかを知るには`color`を参照してください。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^3,x,-1,1),
                   xaxis       = true,
                   xaxis_color = red)$

  `xaxis`, `xaxis_width`, `xaxis_type`も参照してください。

  Package draw ·

グラフィックオプション: xaxis_secondary

  デフォルト値: `false`

  もし`xaxis_secondary`が`true`なら、 関数値が、二番目のx軸に関してプロットされるかもしれません。 二番目のx軸はシーンのトップに描かれます。

  これは、2dプロットにだけ影響する局所的なグラフィックオプションであることに注意してください。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(
               key   = "Bottom x-axis",
               explicit(x+1,x,1,2),
               color = red,
               key   = "Above x-axis",
               xtics_secondary = true,
               xaxis_secondary = true,
               explicit(x^2,x,-1,1)) $

  `xrange_secondary`, `xtics_secondary`, `xtics_rotate_secondary`, `xtics_axis_secondary`, `xaxis_secondary`も参照してください。

  Package draw ·

グラフィックオプション: xaxis_type

  デフォルト値: `dots`

  `xaxis_type`はx軸がいかに表示されるかを示します; 可能な値は`solid`と`dots`です。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^3,x,-1,1),
                   xaxis       = true,
                   xaxis_type  = solid)$

  `xaxis`, `xaxis_width`, `xaxis_color`も参照してください。

  Package draw ·

グラフィックオプション: xaxis_width

  デフォルト値: 1

  `xaxis_width`はx軸の幅です。 その値は正数でなければいけません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^3,x,-1,1),
                   xaxis       = true,
                   xaxis_width = 3)$

  `xaxis`, `xaxis_type`, `xaxis_color`も参照してください。

  Package draw ·

グラフィックオプション: xlabel

  デフォルト値: `""` (empty string)

  オプション`xlabel`、文字列は x軸のラベルです。 デフォルトでは、ラベルは書かれません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xlabel = "Time",
                   explicit(exp(u),u,-2,2),
                   ylabel = "Population")$

  `ylabel`と`zlabel`も参照してください。

  Package draw ·

グラフィックオプション: xrange

  デフォルト値: `auto`

  もし`xrange`が`auto`なら、 x座標の範囲は自動的に計算されます。

  もしユーザーが xに関して特定の区間が欲しいなら、 `xrange=[-2, 3]`のように、Maximaリストとして与えられなければいけません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xrange = [-3,5],
                   explicit(x^2,x,-1,1))$

  `yrange`と`zrange`も参照してください。

  Package draw ·

グラフィックオプション: xrange_secondary

  デフォルト値: `auto`

  もし`xrange_secondary`が`auto`なら、 二番目のx軸の範囲は自動的に計算されます。

  もしユーザーが 二番目のx軸の特定した区間が欲しいなら、 `xrange_secondary=[-2, 3]`のように、Maximaリストとして与えられなければいけません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  `xrange`, `yrange`, `zrange`, `yrange_secondary`も参照してください。

  Package draw ·

グラフィックオプション: xtics

  デフォルト値: `auto`

  このグラフィックオプション制御は チックマークをx軸上に描く方法を制御します。

  - オプション`xtics`がシンボルautoにバインドされている時 チックマークは自動的に描かれます。
  - オプション`xtics`がシンボルnoneにバインドされている時 チックマークは描かれません。
  - オプション`xtics`が正の数にバインドされている時、 これは２つの連続するチックマークの間の距離になります。
  - オプション`xtics`が 形式`[start,incr,end]`の長さ３のリストにバインドされている時、 チックマークは `start`から`end`まで 長さ`incr`の間隔でプロットされます。
  - オプション`xtics`が 形式`{n1, n2, ...}`の数の集合にバインドされている時、 チックマークは 値`n1`, `n2`, ...にプロットされます。
  - オプション`xtics`が 形式`{["label1", n1], ["label2", n2], ...}`の対の集合にバインドされている時、 値`n1`, `n2`, ...に対応する チックマークはそれぞれ、 `"label1"`, `"label2"`, ...にラベルされます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

  チックをディセーブルします。

      (%i1) load("draw")$
      (%i2) draw2d(xtics = 'none,
                   explicit(x^3,x,-1,1)  )$

  1/4単位毎のチック。

      (%i1) load("draw")$
      (%i2) draw2d(xtics = 1/4,
                   explicit(x^3,x,-1,1)  )$

  -3/4から3/4まで 1/8のステップでチック。

      (%i1) load("draw")$
      (%i2) draw2d(xtics = [-3/4,1/8,3/4],
                   explicit(x^3,x,-1,1)  )$

  点-1/2, -1/4, 3/4にチック。

      (%i1) load("draw")$
      (%i2) draw2d(xtics = {-1/2,-1/4,3/4},
                   explicit(x^3,x,-1,1)  )$

  ラベルされたチック。

      (%i1) load("draw")$
      (%i2) draw2d(xtics = {["High",0.75],["Medium",0],["Low",-0.75]},
                   explicit(x^3,x,-1,1)  )$

  `ytics`, `ztics`も参照してください。

  Package draw ·

グラフィックオプション: xtics_axis

  デフォルト値: `false`

  もし`xtics_axis`が`true`なら、 チックマークとそれらのラベルが x軸に沿ってだけプロットされます。 もし`false`なら、チックは境界上にプロットされます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  Package draw ·

グラフィックオプション: xtics_rotate

  デフォルト値: `false`

  もし`xtics_rotate`が`true`なら、 x軸上のチックマークが90度回転されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  Package draw ·

グラフィックオプション: xtics_rotate_secondary

  デフォルト値: `false`

  もし`xtics_rotate_secondary`が`true`なら、 補助的なx軸上のチックマークが90度回転されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  Package draw ·

グラフィックオプション: xtics_secondary

  デフォルト値: `auto`

  このグラフィックオプションは、 二番目のx軸上にチックマークを描く方法を制御します。

  完全な記述に関しては、`xtics`を参照してください。

  Package draw ·

グラフィックオプション: xtics_secondary_axis

  デフォルト値: `false`

  もし`xtics_secondary_axis`が`true`なら、 チックマークとそれらのラベルは補助的なx軸に沿ってだけプロットされ、 もし`false`なら、境界上にプロットされます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  Package draw ·

グラフィックオプション: xu_grid

  デフォルト値: 30

  `xu_grid`は サンプル点のグリッドを構築するための一番目の変数 (陽での`x`、パラメトリック3d表面での`u`)の座標の数です。

  このオプションは以下のグラフィックオブジェクトに影響を与えます:

  - `gr3d`: `explicit`と`parametric_surface`.

  例:

      (%i1) load("draw")$
      (%i2) draw3d(xu_grid = 10,
                   yv_grid = 50,
                   explicit(x^2+y^2,x,-3,3,y,-3,3) )$

  `yv_grid`も参照してください。

  Package draw ·

グラフィックオプション: xy_file

  デフォルト値: `""` (empty string)

  `xy_file`は、 マウスでクリックし、’x’キーを叩いた後、座標が保存される ファイルの名前です。 デフォルトでは、座標は保存されません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  Package draw ·

グラフィックオプション: xyplane

  デフォルト値: `false`

  3Dシーンの中にxy平面を配置します。 `xyplane`が`false`の時、 xy平面は自動的に置かれます; 実数の時、xy平面はこのレベルでz軸と交わります。 このオプションは2Dシーンでは効果を持ちません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(xyplane = %e-2,
                   explicit(x^2+y^2,x,-1,1,y,-1,1))$

  Package draw ·

グラフィックオプション: y_voxel

  デフォルト値: 10

  `y_voxel`は 3d`暗黙の`オブジェクトで実装されたマーチングキューブアルゴリズム で使われるy方向のボクセルの数です。 グラフィックオブジェクト`region`でも使われます。

  Package draw ·

グラフィックオプション: yaxis

  デフォルト値: `false`

  もし`yaxis`が`true`なら、y軸が描かれます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^3,x,-1,1),
                   yaxis       = true,
                   yaxis_color = blue)$

  `yaxis_width`, `yaxis_type`, `yaxis_color`も参照してください。

  Package draw ·

グラフィックオプション: yaxis_color

  デフォルト値: `"black"`

  `yaxis_color`はy軸の色を指定します。 色がどのように定義されているか知るには `color`を参照してください。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^3,x,-1,1),
                   yaxis       = true,
                   yaxis_color = red)$

  `yaxis`, `yaxis_width`, `yaxis_type`も参照してください。

  Package draw ·

グラフィックオプション: yaxis_secondary

  デフォルト値: `false`

  もし`yaxis_secondary`が`true`なら、 関数値は二番目のy軸に関してプロットされるかもしれません。 二番目のy軸はシーンの右側に描かれます。

  これは、2dプロットにだけ影響する局所的なグラフィックオプションであることに注意してください。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(
               explicit(sin(x),x,0,10),
               yaxis_secondary = true,
               ytics_secondary = true,
               color = blue,
               explicit(100*sin(x+0.1)+2,x,0,10));

  `yrange_secondary`, `ytics_secondary`, `ytics_rotate_secondary` , `ytics_axis_secondary`も参照してください。

  Package draw ·

グラフィックオプション: yaxis_type

  デフォルト値: `dots`

  `yaxis_type`はy軸がどのように表示されるか示します; 可能な値は`solid`と`dots`です。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^3,x,-1,1),
                   yaxis       = true,
                   yaxis_type  = solid)$

  `yaxis`, `yaxis_width`, `yaxis_color`も参照してください。

  Package draw ·

グラフィックオプション: yaxis_width

  デフォルト値: 1

  `yaxis_width`はy軸の幅です。 その値は正の数でなければいけません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(x^3,x,-1,1),
                   yaxis       = true,
                   yaxis_width = 3)$

  `yaxis`, `yaxis_type`, `yaxis_color`も参照してください。

  Package draw ·

グラフィックオプション: ylabel

  デフォルト値: `""` (empty string)

  オプション`ylabel`、文字列は y軸のラベルです。 デフォルトでは、ラベルは書かれません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xlabel = "Time",
                   ylabel = "Population",
                   explicit(exp(u),u,-2,2) )$

  `xlabel`と`zlabel`も参照してください。

  Package draw ·

グラフィックオプション: yrange

  デフォルト値: `auto`

  もし`yrange`が`auto`なら、 y座標の範囲は自動的に計算されます。

  もしユーザーがyの特定の区間が欲しいなら、 `yrange=[-2, 3]`のように、Maximaリストとして与えられなければいけません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(yrange = [-2,3],
                   explicit(x^2,x,-1,1),
                   xrange = [-3,3])$

  `xrange`, `yrange_secondary`, `zrange`も参照してください。

  Package draw ·

グラフィックオプション: yrange_secondary

  デフォルト値: `auto`

  もし`yrange_secondary`が`auto`なら、 二番目のy軸の範囲は自動的に計算されます。

  もしユーザーが二番目のy軸の特定の区間が欲しいなら、 `yrange_secondary=[-2, 3]`のように、Maximaリストとして与えられなければいけません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(
               explicit(sin(x),x,0,10),
               yaxis_secondary = true,
               ytics_secondary = true,
               yrange = [-3, 3],
               yrange_secondary = [-20, 20],
               color = blue,
               explicit(100*sin(x+0.1)+2,x,0,10)) $

  `xrange`, `yrange`, `zrange`も参照してください。

  Package draw ·

グラフィックオプション: ytics

  デフォルト値: `auto`

  このグラフィックオプションは、 y軸上にチックマークを描く方法を制御します。

  完全な記述に関しては、`xtics`を参照してください。

  Package draw ·

グラフィックオプション: ytics_axis

  デフォルト値: `false`

  もし`ytics_axis`が`true`なら、 チックマークとそれらのラベルはy軸に沿ってだけプロットされ、 もし`false`なら、境界上にプロットされます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  Package draw ·

グラフィックオプション: ytics_rotate

  デフォルト値: `false`

  もし`ytics_rotate`が`true`なら、 y軸上のチックマークが90度回転されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  Package draw ·

グラフィックオプション: ytics_rotate_secondary

  デフォルト値: `false`

  もし`ytics_rotate_secondary`が`true`なら、 補助的なy軸上のチックマークが90度回転されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  Package draw ·

グラフィックオプション: ytics_secondary

  デフォルト値: `auto`

  このグラフィックオプションは、 二番目のy軸上にチックマークを描く方法を制御します。

  完全な記述に関しては、`xtics`を参照してください。

  Package draw ·

グラフィックオプション: ytics_secondary_axis

  デフォルト値: `false`

  もし`ytics_secondary_axis`が`true`なら、 チックマークとそれらのラベルは補助的なy軸に沿ってだけプロットされ、 もし`false`なら、境界上にプロットされます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  Package draw ·

グラフィックオプション: yv_grid

  デフォルト値: 30

  `yv_grid`は サンプル点のグリッドを構築するための 二番目の変数(陽での`y`、パラメトリック3d表面での`v`)の座標の数です。

  このオプションは以下のグラフィックオブジェクトに影響を与えます:

  - `gr3d`: `explicit`と`parametric_surface`.

  例:

      (%i1) load("draw")$
      (%i2) draw3d(xu_grid = 10,
                   yv_grid = 50,
                   explicit(x^2+y^2,x,-3,3,y,-3,3) )$

  `xu_grid`も参照してください。

  Package draw ·

グラフィックオプション: z_voxel

  デフォルト値: 10

  `z_voxel`は 3d`implicit`オブジェクトで実装されたマーチングキューブアルゴリズム で使われるz方向のボクセルの数です。

  Package draw ·

グラフィックオプション: zaxis

  デフォルト値: `false`

  もし`zaxis`が`true`なら、3Dプロットでz軸が描かれます。 このオプションは2Dシーンでは効果を持ちません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(explicit(x^2+y^2,x,-1,1,y,-1,1),
                   zaxis       = true,
                   zaxis_type  = solid,
                   zaxis_color = blue)$

  `zaxis_width`, `zaxis_type`, `zaxis_color`も参照してください。

  Package draw ·

グラフィックオプション: zaxis_color

  デフォルト値: `"black"`

  `zaxis_color`はz軸の色を指定します。 色がどのように定義されているか知るには`color`を参照してください。 このオプションは2Dシーンでは効果を持ちません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(explicit(x^2+y^2,x,-1,1,y,-1,1),
                   zaxis       = true,
                   zaxis_type  = solid,
                   zaxis_color = red)$

  `zaxis`, `zaxis_width`, `zaxis_type`も参照してください。

  Package draw ·

グラフィックオプション: zaxis_type

  デフォルト値: `dots`

  `zaxis_type`はz軸がどのように表示されるか示します; 可能な値は`solid`と`dots`です。 このオプションは2Dシーンでは効果を持ちません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(explicit(x^2+y^2,x,-1,1,y,-1,1),
                   zaxis       = true,
                   zaxis_type  = solid)$

  `zaxis`, `zaxis_width`, `zaxis_color`も参照してください。

  Package draw ·

グラフィックオプション: zaxis_width

  デフォルト値: 1

  `zaxis_width`はz軸の幅です。 その値は正の数でなければいけません。 このオプションは2Dシーンでは効果を持ちません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題なりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(explicit(x^2+y^2,x,-1,1,y,-1,1),
                   zaxis       = true,
                   zaxis_type  = solid,
                   zaxis_width = 3)$

  `zaxis`, `zaxis_type`, `zaxis_color`も参照してください。

  Package draw ·

グラフィックオプション: zlabel

  デフォルト値: `""` (empty string)

  オプション`zlabel`文字列は z軸のラベルです。 デフォルトでは、ラベルは書かれません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(zlabel = "Z variable",
                   ylabel = "Y variable",
                   explicit(sin(x^2+y^2),x,-2,2,y,-2,2),
                   xlabel = "X variable" )$

  `xlabel`と`ylabel`も参照してください。

  Package draw ·

グラフィックオプション: zrange

  デフォルト値: `auto`

  もし`zrange`が`auto`なら、 z座標の範囲は自動的に計算されます。

  もしユーザーが zの特定の区間が欲しいなら、 `zrange=[-2, 3]`のようにMaximaリストとして与えられなければいけません。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(yrange = [-3,3],
                   zrange = [-2,5],
                   explicit(x^2+y^2,x,-1,1,y,-1,1),
                   xrange = [-3,3])$

  `xrange`, `yrange`も参照してください。

  Package draw ·

グラフィックオプション: ztics

  デフォルト値: `auto`

  このグラフィックオプションは、 z軸上にチックマークを描く方法を制御します。

  完全な記述に関しては、`xtics`を参照してください。

  Package draw ·

グラフィックオプション: ztics_axis

  デフォルト値: `false`

  もし`ztics_secondary_axis`が`true`なら、 チックマークとそれらのラベルは補助的なz軸に沿ってだけプロットされ、 もし`false`なら、境界上にプロットされます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  Package draw ·

グラフィックオプション: ztics_rotate

  デフォルト値: `false`

  もし`ztics_rotate`が`true`なら、 z軸上のチックマークが90度回転されます。

  これはグローバルグラフィックスオプションなので、 シーン記述の位置は問題になりません。

  Package draw ·

#### 48.2.4 Graphics objects

グラフィックオブジェクト: bars ([x1,h1,w1], [x2,h2,w2, ...])

  2D内に垂直バーを描画します。

  2D

  `bars ([x1,h1,w1], [x2,h2,w2, ...])` は 値x1, x2, ...に中心を持ち、高さh1, h2, ...と幅w1, w2, ...を持つバーを描画します。

  このオブジェクトは以下のgraphic optionsに影響されます: `key`, `fill_color`, `fill_density`, `line_width`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(
             key          = "Group A",
             fill_color   = blue,
             fill_density = 0.2,
             bars([0.8,5,0.4],[1.8,7,0.4],[2.8,-4,0.4]),
             key          = "Group B",
             fill_color   = red,
             fill_density = 0.6,
             line_width   = 4,
             bars([1.2,4,0.4],[2.2,-2,0.4],[3.2,5,0.4]),
             xaxis = true);

グラフィックオブジェクト: cylindrical (radius, z, minz, maxz, azi, minazi, maxazi)

  円柱座標で定義された3D関数を描画します。

  3D

  `cylindrical (radius, z, minz, maxz, azi, minazi, maxazi)`は minzからmaxzまでの値を取るzと minaziからmaxaziまで値を取る方位角 aziを伴う 円柱座標で定義された関数`radius(z,azi)` をプロットします。

  このオブジェクトは以下のグラフィックオプションに影響されます: `xu_grid`, `yv_grid`, `line_type`, `key` and `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw3d(cylindrical(1,z,-2,2,az,0,2*%pi))$

  Package draw ·

グラフィックオブジェクト: elevation_grid (mat,x0,y0,width,height)

  3D空間に行列matを描画します。 x0からx0 + widthまでの横座標範囲と y0からy0 + heightまでの縦座標範囲で、 z値はmatから取られます。 要素a(1,1)は点(x0,y0+height)上に射影され、 a(1,n)は(x0+width,y0+height)上に射影され、 a(m,1)は(x0,y0)上に射影され、 a(m,n)は(x0+width,y0)上に射影されます。

  このオブジェクトは以下のグラフィックオプションに影響されます: `line_type`, `line_width`, `key`, `enhanced3d`, `color`。

  Maximaの古いバージョンでは、`elevation_grid`は`mesh`と呼ばれました。 `mesh`も参照してください。

  例:

      (%i1) load("draw")$
      (%i2) m: apply(
                  matrix,
                  makelist(makelist(random(10.0),k,1,30),i,1,20)) $
      (%i3) draw3d(
               color = blue,
               elevation_grid(m,0,0,3,2),
               xlabel = "x",
               ylabel = "y",
               surface_hide = true);

  Package draw ·

グラフィックオブジェクト: ellipse (xc, yc, a, b, ang1, ang2)

  2D内で楕円や円を描画します。

  2D

  `ellipse (xc, yc, a, b, ang1, ang2)` は `[xc, yc]`を中心とし、水平と垂直半軸にそれぞれaとbを持ち、角度ang1から始まり、角度ang2に等しい振幅を持つ 楕円をプロットします。

  このオブジェクトは以下のgraphic optionsに影響されます: `nticks`, `transparent`, `fill_color`, `border`, `line_width`, `line_type`, `key`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(transparent = false,
                   fill_color  = red,
                   color       = gray30,
                   transparent = false,
                   line_width  = 5,
                   ellipse(0,6,3,2,270,-270),
                   /* center (x,y), a, b, start & end in degrees */
                   transparent = true,
                   color       = blue,
                   line_width  = 3,
                   ellipse(2.5,6,2,3,30,-90),
                   xrange      = [-3,6],
                   yrange      = [2,9] )$

  Package draw ·

グラフィックオブジェクト: errors ([x1, x2, …], [y1, y2, …])

  オプション`error_type`の値に依存して、 水平、垂直もしくは両方のエラーバーと共に点を描きます。

  2D

  もし`error_type = x`なら、 `errors`の引数は must be of the form 形式`[x, y, xdelta]`か`[x, y, xlow, xhigh]`でなければいけません。 もし`error_type = y`なら、 引数は形式`[x, y, ydelta]`か`[x, y, ylow, yhigh]`でなければいけません。 もし`error_type = xy`か`error_type = boxes`なら、 `errors`の引数は 形式`[x, y, xdelta, ydelta]`か`[x, y, xlow, xhigh, ylow, yhigh]`でなければいけません。

  `error_type`も参照してください。

  このオブジェクトは以下のグラフィックオブジェクトによって影響されます: `error_type`, `points_joined`, `line_width`, `key`, `line_type`, `color`, `fill_density`, `xaxis_secondary`, `yaxis_secondary`.

  オプション`fill_density`は、`error_type=boxes`の時だけ有効です。

  例:

  水平エラーバー。

      (%i1) load("draw")$
      (%i2) draw2d(
              error_type = y,
              errors([[1,2,1], [3,5,3], [10,3,1], [17,6,2]]))$

  垂直および水平エラーバー。

      (%i1) load("draw")$
      (%i2) draw2d(
              error_type = xy,
              points_joined = true,
              color = blue,
              errors([[1,2,1,2], [3,5,2,1], [10,3,1,1], [17,6,1/2,2]]));

  Package draw ·

グラフィックオブジェクト: explicit (fcn,var,minval,maxval)
グラフィックオブジェクト: explicit (fcn,var1,minval1,maxval1,var2,minval2,maxval2)

  2Dおよび3Dにて陽関数を描画します。

  2D

  `explicit(fcn,var,minval,maxval)`は minvalからmaxvalまで値を取る変数varを伴う 陽関数fcnをプロットします。

  このオブジェクトは以下のgraphic optionsに影響されます: `nticks`, `adapt_depth`, `line_width`, `line_type`, `key`, `filled_func`, `fill_color`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(line_width = 3,
                   color      = blue,
                   explicit(x^2,x,-3,3) )$
      (%i3) draw2d(fill_color  = brown,
                   filled_func = true,
                   explicit(x^2,x,-3,3) )$

  3D

  `explicit(fcn, var1, minval1, maxval1, var2, minval2, maxval2)`は minval1から maxval1まで値を取る変数 var1と minval2から maxval2まで値を取る変数 var2を伴う 陽関数 fcnをプロットします。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `xu_grid`, `yv_grid`, `line_type`, `line_width`, `key`, `enhanced3d`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw3d(key   = "Gauss",
                   color = "#a02c00",
                   explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3),
                   yv_grid     = 10,
                   color = blue,
                   key   = "Plane",
                   explicit(x+y,x,-5,5,y,-5,5),
                   surface_hide = true)$

  埋められた関数に関しては`filled_func`も参照してください。

  Package draw ·

グラフィックオブジェクト: image (im,x0,y0,width,height)

  2Dにてイメージを描写します。

  2D

  `image (im,x0,y0,width,height)`は 実平面上の 頂点`(x0,y0)`から`(x0+width,y0+height)`までの長方形領域に イメージimをプロットします。 引数imは実数の行列、長さ3のベクトルの行列もしくはpictureオブジェクトでなければいけません。

  もしimが実数の行列かlevels pictureオブジェクトなら、 ピクセル値は -36から+36に広がる成分を持つ長さ3のベクトルである グラフィックオプション`palette`に従って解釈されます; それぞれの値はレベルをそれぞれ赤、緑、青色にマップする公式のインデックスです。

       0: 0               1: 0.5           2: 1
       3: x               4: x^2           5: x^3
       6: x^4             7: sqrt(x)       8: sqrt(sqrt(x))
       9: sin(90x)       10: cos(90x)     11: |x-0.5|
      12: (2x-1)^2       13: sin(180x)    14: |cos(180x)|
      15: sin(360x)      16: cos(360x)    17: |sin(360x)|
      18: |cos(360x)|    19: |sin(720x)|  20: |cos(720x)|
      21: 3x             22: 3x-1         23: 3x-2
      24: |3x-1|         25: |3x-2|       26: (3x-1)/2
      27: (3x-2)/2       28: |(3x-1)/2|   29: |(3x-2)/2|
      30: x/0.32-0.78125                  31: 2*x-0.84
      32: 4x;1;-2x+1.84;x/0.08-11.5
      33: |2*x - 0.5|    34: 2*x          35: 2*x - 0.5
      36: 2*x - 1

  負の数は負の色成分を意味します。

  `palette = gray`と`palette = color`は それぞれ、 `palette = [3,3,3]`と`palette = [7,5,15]`へのショートカットです。

  もしimが長さ3のベクトルの行列かrgb pictureオブジェクトなら、 それらは赤、緑、青の色成分として解釈されます。

  例:

  もしimが実数の行列なら、ピクセル値は グラフィックオプション`palette`に従って解釈されます。

      (%i1) load("draw")$
      (%i2) im: apply(
                 'matrix,
                  makelist(makelist(random(200),i,1,30),i,1,30))$
      (%i3) /* palette = color, default */
            draw2d(image(im,0,0,30,30))$
      (%i4) draw2d(palette = gray, image(im,0,0,30,30))$
      (%i5) draw2d(palette = [15,20,-4],
                   colorbox=false,
                   image(im,0,0,30,30))$

  `colorbox`も参照してください。

  もしimが長さ3のベクトルの行列なら、 それらは赤、緑、青の色成分として解釈されます。

      (%i1) load("draw")$
      (%i2) im: apply(
                  'matrix,
                   makelist(
                     makelist([random(300),
                               random(300),
                               random(300)],i,1,30),i,1,30))$
      (%i3) draw2d(image(im,0,0,30,30))$

  パッケージ`draw`は自動的にパッケージ`picture`をロードします。 この例では、レベルピクチャオブジェクトは手動で組み立てられ、描画されます。

      (%i1) load("draw")$
      (%i2) im: make_level_picture([45,87,2,134,204,16],3,2);
      (%o2)       picture(level, 3, 2, {Array:  #(45 87 2 134 204 16)})
      (%i3) /* default color palette */
            draw2d(image(im,0,0,30,30))$
      (%i4) /* gray palette */
            draw2d(palette = gray,
                   image(im,0,0,30,30))$

  xpmファイルが読み込まれ、描写されます。

      (%i1) load("draw")$
      (%i2) im: read_xpm("myfile.xpm")$
      (%i3) draw2d(image(im,0,0,10,7))$

  `make_level_picture`, `make_rgb_picture`, `read_xpm`も参照してください。

  http://www.telefonica.net/web2/biomates/maxima/gpdraw/image
  には更に丹念な例があります。

  Package draw ·

グラフィックオブジェクト: implicit (fcn,x,xmin,xmax,y,ymin,ymax)
グラフィックオブジェクト: implicit (fcn,x,xmin,xmax,y,ymin,ymax,z,zmin,zmax)

  2Dおよび3Dにて陰関数を描画します。

  2D

  `implicit(fcn,x,xmin,xmax,y,ymin,ymax)`は xminからxmaxまでの値を取る変数xと yminからymaxまでの値を取る変数yを伴う fcnで定義された陰関数をプロットします。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `ip_grid`, `ip_grid_in`, `line_width`, `line_type`, `key`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(terminal  = eps,
                   grid      = true,
                   line_type = solid,
                   key       = "y^2=x^3-2*x+1",
                   implicit(y^2=x^3-2*x+1, x, -4,4, y, -4,4),
                   line_type = dots,
                   key       = "x^3+y^3 = 3*x*y^2-x-1",
                   implicit(x^3+y^3 = 3*x*y^2-x-1, x,-4,4, y,-4,4),
                   title     = "Two implicit functions" )$

  3D

  `implicit (fcn,x,xmin,xmax, y,ymin,ymax, z,zmin,zmax)`は xminからxmaxまでの値を取る変数xと yminからymaxまでの値を取る変数yと zminからzmaxまでの値を取る変数zを伴う fcnで定義された陰表面をプロットします。 このオブジェクトはマーチングキューブアルゴリズムを実装します。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `x_voxel`, `y_voxel`, `z_voxel`, `line_width`, `line_type`, `key` , `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw3d(
              color=blue,
              implicit((x^2+y^2+z^2-1)*(x^2+(y-1.5)^2+z^2-0.5)=0.015,
                       x,-1,1,y,-1.2,2.3,z,-1,1),
              surface_hide=true);

  Package draw ·

グラフィックオブジェクト: label ([string,x,y],...)
グラフィックオブジェクト: label ([string,x,y,z],...)

  2Dと3D内でラベルを書きます。

  色付けられたラベルはGnuplot 4.3でだけ機能します。 これはパッケージ`draw`に関して既知のバグです。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `label_alignment`, `label_orientation`, `color`.

  2D

  `label([string,x,y])`は 点`[x,y]`にstringを書きます。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(yrange = [0.1,1.4],
                   color = "red",
                   label(["Label in red",0,0.3]),
                   color = "#0000ff",
                   label(["Label in blue",0,0.6]),
                   color = "light-blue",
                   label(["Label in light-blue",0,0.9],
                         ["Another light-blue",0,1.2])  )$

  3D

  `label([string,x,y,z])`は、 点`[x,y,z]`にstringを書きます。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3),
                   color = red,
                   label(["UP 1",-2,0,3], ["UP 2",1.5,0,4]),
                   color = blue,
                   label(["DOWN 1",2,0,-3]) )$

  Package draw ·

グラフィックオブジェクト: mesh (mat,x0,y0,width,height)

  3D空間内に行列matを描画します。 z値はmatから取られます。 横座標範囲はx0からx0 + widthまでを取り、 座標はy0からy0 + heightまでを取ります。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `line_type`, `line_width`, `key`, `enhanced3d`, `color`.

  このグラフィックオブジェクトは `true`と`false`以外の値の`enhanced3d`値を無視します。

  例:

      (%i1) load("draw")$
      (%i2) m: apply(
                  matrix,
                  makelist(makelist(random(10.0),k,1,30),i,1,20)) $
      (%i3) draw3d(
               color = blue,
               mesh(m,0,0,3,2),
               xlabel = "x",
               ylabel = "y",
               surface_hide = true);

  Package draw ·

グラフィックオブジェクト: parametric (xfun,yfun,par,parmin,parmax)
グラフィックオブジェクト: parametric (xfun,yfun,zfun,par,parmin,parmax)

  2Dおよび3Dにてパラメトリック関数を描画します。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `nticks`, `line_width`, `line_type`, `key`, `color` and `enhanced3d`.

  2D

  コマンド `parametric(xfun, yfun, par, parmin, parmax)`は parminからparmaxまで値を取るパラメータparを伴う パラメトリック関数`[xfun, yfun]`をプロットします。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(explicit(exp(x),x,-1,3),
                   color = red,
                   key   = "This is the parametric one!!",
                   parametric(2*cos(rrr),rrr^2,rrr,0,2*%pi))$

  3D

  `parametric (xfun, yfun, zfun, par, parmin, parmax)`は parminからparmaxまで値を取るパラメータparを伴う パラメトリック曲線 `[xfun, yfun, zfun]`をプロットします。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3),
                   color = royalblue,
                   parametric(cos(5*u)^2,sin(7*u),u-2,u,0,2),
                   color      = turquoise,
                   line_width = 2,
                   parametric(t^2,sin(t),2+t,t,0,2),
                   surface_hide = true,
                   title = "Surface & curves" )$

  Package draw ·

グラフィックオブジェクト: parametric_surface (xfun, yfun, zfun, par1, par1min, par1max, par2, par2min, par2max)

  3Dにおいてパラメトリックな表面を描画します。

  3D

  コマンド `parametric_surface (xfun, yfun, zfun, par1, par1min, par1max, par2, par2min, par2max)`は par1minから par1maxまでを値として取るパラメータ par1と par2minから par2maxまでを値として取るパラメータ par2を伴う パラメトリックな表面 `[xfun, yfun, zfun]`を プロットします。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `xu_grid`, `yv_grid`, `line_type`, `line_width`, `key`, `enhanced3d`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw3d(title          = "Sea shell",
                   xu_grid        = 100,
                   yv_grid        = 25,
                   view           = [100,20],
                   surface_hide   = true,
                   parametric_surface(0.5*u*cos(u)*(cos(v)+1),
                                 0.5*u*sin(u)*(cos(v)+1),
                                 u*sin(v) - ((u+3)/8*%pi)^2 - 20,
                                 u, 0, 13*%pi, v, -%pi, %pi) )$

  Package draw ·

グラフィックオブジェクト: points ([[x1,y1], [x2,y2],...])
グラフィックオブジェクト: points ([x1,x2,...], [y1,y2,...])
グラフィックオブジェクト: points ([y1,y2,...])
グラフィックオブジェクト: points ([[x1,y1,z1], [x2,y2,z2],...])
グラフィックオブジェクト: points ([x1,x2,...], [y1,y2,...], [z1,z2,...])
グラフィックオブジェクト: points (matrix)
グラフィックオブジェクト: points (1d_y_array)
グラフィックオブジェクト: points (1d_x_array, 1d_y_array)
グラフィックオブジェクト: points (1d_x_array, 1d_y_array, 1d_z_array)
グラフィックオブジェクト: points (2d_xy_array)
グラフィックオブジェクト: points (2d_xyz_array)

  2Dや3Dの中で点を描画します。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `point_size`, `point_type`, `points_joined`, `line_width`, `key`, `line_type`, `color`. 3Dモードでは、`enhanced3d`の影響も受けます。

  2D

  `points ([[x1,y1], [x2,y2],...])`や `points ([x1,x2,...], [y1,y2,...])`は 点`[x1,y1]`, `[x2,y2]`,などをプロットします。 もし横座標が与えられないなら、 それらは連続する正の整数に設定されます。 だから、 `points ([y1,y2,...])`は、点`[1,y1]`, `[2,y2]`などを描画します。 もしmatrixが2列または2行行列なら、 `points (matrix)`は関連した点を描画します。 もしmatrixが1列または1行行列なら、 横座標が自動的に割り当てられます。

  もし1d_y_arrayが数の1Dのlisp配列なら、 `points (1d_y_array)`は 横座標を連続する正の整数に設定してそれらをプロットします。 `points (1d_x_array, 1d_y_array)`は 引数として渡された2つの配列から取られた座標を持つ点をプロットします。 もし2d_xy_arrayが2列の2D配列なら、 `points (2d_xy_array)`は平面上に対応する点をプロットします。

  例:

  `points`への2種類の引数、ペアのリストと分離した座標の2つのリスト。

      (%i1) load("draw")$
      (%i2) draw2d(
              key = "Small points",
              points(makelist([random(20),random(50)],k,1,10)),
              point_type    = circle,
              point_size    = 3,
              points_joined = true,
              key           = "Great points",
              points(makelist(k,k,1,20),makelist(random(30),k,1,20)),
              point_type    = filled_down_triangle,
              key           = "Automatic abscissas",
              color         = red,
              points([2,12,8]))$

  衝撃を描画。

      (%i1) load("draw")$
      (%i2) draw2d(
              points_joined = impulses,
              line_width    = 2,
              color         = red,
              points(makelist([random(20),random(50)],k,1,10)))$

  座標の配列。

      (%i1) load("draw")$
      (%i2) a: make_array (flonum, 100) $
      (%i3) for i:0 thru 99 do a[i]: random(1.0) $
      (%i4) draw2d(points(a)) $

  分離した座標の2つの配列。

      (%i1) load("draw")$
      (%i2) x: make_array (flonum, 100) $
      (%i3) y: make_array (fixnum, 100) $
      (%i4) for i:0 thru 99 do (
              x[i]: float(i/100),
              y[i]: random(10) ) $
      (%i5) draw2d(points(x, y)) $

  2列2D配列。

      (%i1) load("draw")$
      (%i2) xy: make_array(flonum, 100, 2) $
      (%i3) for i:0 thru 99 do (
              xy[i, 0]: float(i/100),
              xy[i, 1]: random(10) ) $
      (%i4) draw2d(points(xy)) $

  関数`read_array`で埋められた配列の描画。

      (%i1) load("draw")$
      (%i2) a: make_array(flonum,100) $
      (%i3) read_array (file_search ("pidigits.data"), a) $
      (%i4) draw2d(points(a)) $

  3D

  `points([[x1, y1, z1], [x2, y2, z2], ...])` や `points([x1, x2, ...], [y1, y2, ...], [z1, z2, ...])`は 点`[x1, y1, z1]`, `[x2, y2, z2]`などをプロットします。 もし matrixが3列または3行行列なら、 `points (matrix)`は関連した点を描画します。

  引数がlisp配列の時、 `points (1d_x_array, 1d_y_array, 1d_z_array)`は 3つの1D配列から座標を取ります。 もし2d_xyz_arrayが3列または3行を持つ2D配列なら、 `points (2d_xyz_array)`は対応する点をプロットします。

  例:

  3次元のサンプル１つ、

      (%i1) load("draw")$
      (%i2) load ("numericalio")$
      (%i3) s2 : read_matrix (file_search ("wind.data"))$
      (%i4) draw3d(title = "Daily average wind speeds",
                   point_size = 2,
                   points(args(submatrix (s2, 4, 5))) )$

  3次元のサンプル２つ、

      (%i1) load("draw")$
      (%i2) load ("numericalio")$
      (%i3) s2 : read_matrix (file_search ("wind.data"))$
      (%i4) draw3d(
               title = "Daily average wind speeds. Two data sets",
               point_size = 2,
               key        = "Sample from stations 1, 2 and 3",
               points(args(submatrix (s2, 4, 5))),
               point_type = 4,
               key        = "Sample from stations 1, 4 and 5",
               points(args(submatrix (s2, 2, 3))) )$

  1次元配列、

      (%i1) load("draw")$
      (%i2) x: make_array (fixnum, 10) $
      (%i3) y: make_array (fixnum, 10) $
      (%i4) z: make_array (fixnum, 10) $
      (%i5) for i:0 thru 9 do (
              x[i]: random(10),
              y[i]: random(10),
              z[i]: random(10) ) $
      (%i6) draw3d(points(x,y,z)) $

  2次元色付け配列、

      (%i1) load("draw")$
      (%i2) xyz: make_array(fixnum, 10, 3) $
      (%i3) for i:0 thru 9 do (
              xyz[i, 0]: random(10),
              xyz[i, 1]: random(10),
              xyz[i, 2]: random(10) ) $
      (%i4) draw3d(
               enhanced3d = true,
               points_joined = true,
               points(xyz)) $

  ユーザーが陽に指定した色数。

      (%i1) load("draw")$
      (%i2) pts: makelist([t,t^2,cos(t)], t, 0, 15)$
      (%i3) col_num: makelist(k, k, 1, length(pts))$
      (%i4) draw3d(
              enhanced3d = ['part(col_num,k),k],
              point_size = 3,
              point_type = filled_circle,
              points(pts))$

  Package draw ·

グラフィックオブジェクト: polar (radius,ang,minang,maxang)

  極座標で定義された2D関数を描画します。

  2D

  `polar (radius,ang,minang,maxang)`は minangからmaxangまで値を取る変数angを伴う 極座標で定義された関数 `radius(ang)` をプロットします。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `nticks`, `line_width`, `line_type`, `key`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(user_preamble = "set grid polar",
                   nticks        = 200,
                   xrange        = [-5,5],
                   yrange        = [-5,5],
                   color         = blue,
                   line_width    = 3,
                   title         = "Hyperbolic Spiral",
                   polar(10/theta,theta,1,10*%pi) )$

  Package draw ·

グラフィックオブジェクト: polygon ([[x1, y1], [x2, y2], …])
グラフィックオブジェクト: polygon ([x1, x2, …], [y1, y2, …])

  2D内でポリゴンを描画します。

  2D

  コマンド `polygon ([[x1, y1], [x2, y2],...])`や `polygon ([x1, x2,...], [y1, y2,...])`は 頂点`[x1, y1]`, `[x2, y2]`などを持つポリゴンを 平面上にプロットします。

  このオブジェクトは以下の グラフィックオプションの影響を受けます: `transparent`, `fill_color`, `border`, `line_width`, `key`, `line_type`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(color      = "#e245f0",
                   line_width = 8,
                   polygon([[3,2],[7,2],[5,5]]),
                   border      = false,
                   fill_color  = yellow,
                   polygon([[5,2],[9,2],[7,5]]) )$

  Package draw ·

グラフィックオブジェクト: quadrilateral (point_1, point_2, point_3, point_4)

  四辺形を描画します。

  2D

  `quadrilateral ([x1, y1], [x2, y2], [x3, y3], [x4, y4])`は 頂点`[x1, y1]`, `[x2, y2]`, `[x3, y3]`, `[x4, y4]`を持つ四辺形を描画します。

  このオブジェクトは以下のグラフィックオプションの影響を受けます:
  `transparent`, `fill_color`, `border`, `line_width`, `key`, `xaxis_secondary`, `yaxis_secondary`, `line_type`, `transform`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(
              quadrilateral([1,1],[2,2],[3,-1],[2,-2]))$

  3D

  `quadrilateral([x1, y1, z1], [x2, y2, z2], [x3, y3, z3], [x4, y4, z4])`は 頂点`[x1, y1, z1]`, `[x2, y2, z2]`, `[x3, y3, z3]`, `[x4, y4, z4]`を持つ 四辺形を描画します。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `line_type`, `line_width`, `color`, `key`, `enhanced3d`, `transform`.

  Package draw ·

グラフィックオブジェクト: rectangle ([x1,y1], [x2,y2])

  2D内で長方形を描画します。

  2D

  `rectangle ([x1,y1], [x2,y2])`は、 対角頂点 `[x1,y1]`と`[x2,y2]` を持つ長方形を描画します。

  このオブジェクトは以下の グラフィックオプションの影響を受けます: `transparent`, `fill_color`, `border`, `line_width`, `key`, `line_type`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(fill_color  = red,
                   line_width  = 6,
                   line_type   = dots,
                   transparent = false,
                   fill_color  = blue,
                   rectangle([-2,-2],[8,-1]), /* opposite vertices */
                   transparent = true,
                   line_type   = solid,
                   line_width  = 1,
                   rectangle([9,4],[2,-1.5]),
                   xrange      = [-3,10],
                   yrange      = [-3,4.5] )$

  Package draw ·

グラフィックオブジェクト: region (expr,var1,minval1,maxval1,var2,minval2,maxval2)

  平面上に不等式で定義された領域を描画します。

  2D exprは不等式とブーリアン演算子`and`, `or`, `not`で形成された式です。 領域は [minval1, maxval1]と[minval2, maxval2]で 定義された長方形で区切られています。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `fill_color`, `key`, `x_voxel`, `y_voxel`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(
              x_voxel = 30,
              y_voxel = 30,
              region(x^2+y^2<1 and x^2+y^2 > 1/2,
                     x, -1.5, 1.5, y, -1.5, 1.5));

グラフィックオブジェクト: spherical (radius, azi, minazi, maxazi, zen, minzen, maxzen)

  球座標で定義された3D関数を描画します。

  3D

  `spherical(radius, azi, minazi, maxazi, zen, minzen, maxzen)`は minaziから maxaziまで値を取る 方位角 aziと minzenから maxzenまで値を取る 天頂角 zenを伴う 球座標で定義された関数 `radius(azi, zen)` を描画します。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `xu_grid`, `yv_grid`, `line_type`, `key`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw3d(spherical(1,a,0,2*%pi,z,0,%pi))$

  Package draw ·

グラフィックオブジェクト: triangle (point_1, point_2, point_3)

  三角形を描画します。

  2D

  `triangle ([x1,y1], [x2,y2], [x3,y3])`は、頂点`[x1,y1]`, `[x2,y2]`, `[x3,y3]`を持つ三角形を描画します。

  このオブジェクトは、 以下のグラフィックオプションに影響されます:
  `transparent`, `fill_color`, `border`, `line_width`, `key`, `xaxis_secondary`, `yaxis_secondary`, `line_type`, `transform`, `color`.

  例:

      (%i1) load("draw")$
      (%i2) draw2d(
              triangle([1,1],[2,2],[3,-1]))$

  3D

  `triangle ([x1,y1,z1], [x2,y2,z2], [x3,y3,z3])`は 頂点`[x1,y1,z1]`, `[x2,y2,z2]`, `[x3,y3,z3]`を持つ三角形を描画します。

  このオブジェクトは以下のグラフィックオプションに影響されます: `line_type`, `line_width`, `color`, `key`, `enhanced3d`, `transform`.

  Package draw ·

グラフィックオブジェクト: tube (xfun,yfun,zfun,rfun,p,pmin,pmax)

  3Dにおいて 径が変化する管を描画します。

  3D

  `[xfun,yfun,zfun]`は pminからpmaxまで値を取るパラメータpを伴う パラメトリックな曲線です。 パラメトリックな曲線上に中心を持ち、曲線と垂直な半径rfunの円が置かれます。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `xu_grid`, `yv_grid`, `line_type`, `line_width`, `key`, `enhanced3d`, `color`, `tube_extremes`.

  例:

      (%i1) load("draw")$
      (%i2) draw3d(
              enhanced3d = true,
              xu_grid = 50,
              tube(cos(a), a, 0, cos(a/10)^2,
                   a, 0, 4*%pi) )$

  Package draw ·

グラフィックオブジェクト: vector ([x,y], [dx,dy])
グラフィックオブジェクト: vector ([x,y,z], [dx,dy,dz])

  2Dおよび3D内でベクトルを描画します。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `head_both`, `head_length`, `head_angle`, `head_type`, `line_width`, `line_type`, `key`, `color`.

  2D

  `vector([x,y], [dx,dy])`は `[x,y]`を原点とするベクトル`[dx,dy]`を プロットします。

  例:

      (%i1) load("draw")$
      (%i2) draw2d(xrange      = [0,12],
                   yrange      = [0,10],
                   head_length = 1,
                   vector([0,1],[5,5]), /* default type */
                   head_type = 'empty,
                   vector([3,1],[5,5]),
                   head_both = true,
                   head_type = 'nofilled,
                   line_type = dots,
                   vector([6,1],[5,5]))$

  3D

  `vector([x,y,z], [dx,dy,dz])`は `[x,y,z]`を原点とする ベクトル`[dx,dy,dz]`をプロットします。

  例:

      (%i1) load("draw")$
      (%i2) draw3d(color = cyan,
                   vector([0,0,0],[1,1,1]/sqrt(3)),
                   vector([0,0,0],[1,-1,0]/sqrt(2)),
                   vector([0,0,0],[1,1,-2]/sqrt(6)) )$

  Package draw ·

Next: Functions and Variables for worldmap, Previous: Functions and Variables for draw, Up: draw [Contents][Index]

### 48.3 Functions and Variables for pictures

関数: get_pixel (pic,x,y)

  ピクチャからピクセルを返します。 座標xとyは 0からそれぞれ`width-1`と`height-1`までの範囲を取ります。

  Package draw ·

関数: make_level_picture (data)
関数: make_level_picture (data,width,height)

  レベルpictureオブジェクトを返します。 `make_level_picture (data)`は 行列dataから pictureオブジェクトを作ります。 `make_level_picture (data,width,height)`は 数のリストからオブジェクトを作ります; この場合、widthとheight両方を与えなければいけません。

  返されたpictureオブジェクトは以下の4つの部分を含みます:

  1. シンボル `level`
  2. イメージの幅
  3. イメージの高さ
  4. 0から255までの範囲のピクセルデータを持つ整数配列 引数dataは0から255までの数のみを含まなければいけません; 負の数は0に置き換えられ、255よりも大きな数は255に設定されます。

  例:

  行列からのレベルピクチャ。

      (%i1) load("draw")$
      (%i2) make_level_picture(matrix([3,2,5],[7,-9,3000]));
      (%o2)         picture(level, 3, 2, {Array:  #(3 2 5 7 0 255)})

  数値リストからのレベルピクチャ

      (%i1) load("draw")$
      (%i2) make_level_picture([-2,0,54,%pi],2,2);
      (%o2)            picture(level, 2, 2, {Array:  #(0 0 54 3)})

  Package draw ·

関数: make_rgb_picture (redlevel,greenlevel,bluelevel)

  rgb色付けされたpictureオブジェクトを返します。 3つ引数すべては赤、緑、青のレベルを持つレベルピクチャでなければいけません;

  返されたpictureオブジェクトは以下の4つの部分を含みます:

  1. シンボル `rgb`
  2. イメージの幅
  3. イメージの高さ
  4. 0から255までの範囲のピクセルデータを持つ長さ3*width*heightの整数配列。 それぞれのピクセルは。3つの連続する数 (赤、緑、青)で表現されます。

  例:

      (%i1) load("draw")$
      (%i2) red: make_level_picture(matrix([3,2],[7,260]));
      (%o2)           picture(level, 2, 2, {Array:  #(3 2 7 255)})
      (%i3) green: make_level_picture(matrix([54,23],[73,-9]));
      (%o3)           picture(level, 2, 2, {Array:  #(54 23 73 0)})
      (%i4) blue: make_level_picture(matrix([123,82],[45,32.5698]));
      (%o4)          picture(level, 2, 2, {Array:  #(123 82 45 33)})
      (%i5) make_rgb_picture(red,green,blue);
      (%o5) picture(rgb, 2, 2,
                    {Array:  #(3 54 123 2 23 82 7 73 45 255 0 33)})

  Package draw ·

関数: negative_picture (pic)

  (levelまたはrgb)ピクチャの反転を返します。

  Package draw ·

関数: picture_equalp (x,y)

  等しいピクチャの場合`true`を、そうでなければ`false` を返します。

  Package draw ·Predicate functions ·

関数: picturep (x)

  もし引数が適正なイメージなら `true`を、そうでなければ`false`を返します。

  Package draw ·Predicate functions ·

関数: read_xpm (xpm_file)

  xpm形式のファイルを読み、ピクチャオブジェクトを返します。

  Package draw ·

関数: rgb2level (pic)

  rgbピクチャを 赤、緑、青チャンネルを平均することでlevelの１つに変換します。

  Package draw ·

関数: take_channel (im,color)

  もし引数colorが`red`, `green`または`blue`なら、 関数`take_channel`は ピクチャimの対応する色チャンネルを返します。 例:

      (%i1) load("draw")$
      (%i2) red: make_level_picture(matrix([3,2],[7,260]));
      (%o2)           picture(level, 2, 2, {Array:  #(3 2 7 255)})
      (%i3) green: make_level_picture(matrix([54,23],[73,-9]));
      (%o3)           picture(level, 2, 2, {Array:  #(54 23 73 0)})
      (%i4) blue: make_level_picture(matrix([123,82],[45,32.5698]));
      (%o4)          picture(level, 2, 2, {Array:  #(123 82 45 33)})
      (%i5) make_rgb_picture(red,green,blue);
      (%o5) picture(rgb, 2, 2,
                    {Array:  #(3 54 123 2 23 82 7 73 45 255 0 33)})
      (%i6) take_channel(%,'green);  /* simple quote!!! */
      (%o6)           picture(level, 2, 2, {Array:  #(54 23 73 0)})

  Package draw ·

Previous: Functions and Variables for pictures, Up: draw [Contents][Index]

### 48.4 Functions and Variables for worldmap

このパッケージは自動的にパッケージ`draw`をロードします。

#### 48.4.1 Variable and Functions

グローバル変数: boundaries_array

  デフォルト値: `false`

  `boundaries_array`は グラフィックオプション`geomap`が境界座標を探すところです。

  Each component of `boundaries_array`のそれぞれの成分は 浮動小数点量の配列であり、 多角形のセグメントかマップ境界の座標です。

  `geomap`も参照してください。

  Package draw ·

関数: numbered_boundaries (nlist)

  その数(`boundaries_array`座標)でラベルされた 多角形セグメント(境界)のリストを描画します。 これは新しい地理的なものを作る時に非常に役立ちます。

  例:

  `boundaries_array`内の成分数で境界をラベルされたヨーロッパの地図

      (%i1) load("worldmap")$
      (%i2) european_borders:
                 region_boundaries(-31.81,74.92,49.84,32.06)$
      (%i3) numbered_boundaries(european_borders)$

  Package draw ·

関数: make_poly_continent (continent_name)
関数: make_poly_continent (country_list)

  色付けられた大陸や国のリストを描画するのに必要なポリゴンを作ります。

  例:

      (%i1) load("worldmap")$
      (%i2) /* A continent */
            make_poly_continent(Africa)$
      (%i3) apply(draw2d, %)$
      (%i4) /* A list of countries */
            make_poly_continent([Germany,Denmark,Poland])$
      (%i5) apply(draw2d, %)$

  Package draw ·

関数: make_poly_country (country_name)

  色付けられた国を描画するのに必要なポリゴンを作ります。 もし島が存在するなら、1つの国はただ1つ以上のポリゴンで定義され得ます。

  例:

      (%i1) load("worldmap")$
      (%i2) make_poly_country(India)$
      (%i3) apply(draw2d, %)$

  Package draw ·

関数: make_polygon (nlist)

  境界添字から`polygon`オブジェクトを返します。 引数nlistは`boundaries_array`の成分のリストです。

  例:

  ブータンは境界番号171, 173, 1143で定義されます。 だから、`make_polygon([171,173,1143])`は appends arrays of coordinates 座標`boundaries_array[171]`, `boundaries_array[173]`, `boundaries_array[1143]`の配列を付加し、 `draw`でプロットされるのに適した`polygon`オブジェクトを返します． エラーメッセージを避けるには、 任意の連続する配列が端で共通の2つの座標を持つという意味で配列は互換性がなければいけません。 この例では、 `boundaries_array[171]`の最初の2つの成分は `boundaries_array[173]`の最後の2つの座標と等しく、 `boundaries_array[173]`の最初の2つは `boundaries_array[1143]`の最初の2つに等しいです; 結論として、境界番号171, 173, 1143は (この順で)互換性があり、色付けられたポリゴンは描画できます。

      (%i1) load("worldmap")$
      (%i2) Bhutan;
      (%o2)                        [[171, 173, 1143]]
      (%i3) boundaries_array[171];
      (%o3) {Array:
             #(88.750549 27.14727 88.806351 27.25305 88.901367 27.282221
               88.917877 27.321039)}
      (%i4) boundaries_array[173];
      (%o4) {Array:
             #(91.659554 27.76511 91.6008 27.66666 91.598022 27.62499
               91.631348 27.536381 91.765533 27.45694 91.775253 27.4161
               92.007751 27.471939 92.11441 27.28583 92.015259 27.168051
               92.015533 27.08083 92.083313 27.02277 92.112183 26.920271
               92.069977 26.86194 91.997192 26.85194 91.915253 26.893881
               91.916924 26.85416 91.8358 26.863331 91.712479 26.799999
               91.542191 26.80444 91.492188 26.87472 91.418854 26.873329
               91.371353 26.800831 91.307457 26.778049 90.682457 26.77417
               90.392197 26.903601 90.344131 26.894159 90.143044 26.75333
               89.98996 26.73583 89.841919 26.70138 89.618301 26.72694
               89.636093 26.771111 89.360786 26.859989 89.22081 26.81472
               89.110237 26.829161 88.921631 26.98777 88.873016 26.95499
               88.867737 27.080549 88.843307 27.108601 88.750549
               27.14727)}
      (%i5) boundaries_array[1143];
      (%o5) {Array:
             #(91.659554 27.76511 91.666924 27.88888 91.65831 27.94805
               91.338028 28.05249 91.314972 28.096661 91.108856 27.971109
               91.015808 27.97777 90.896927 28.05055 90.382462 28.07972
               90.396088 28.23555 90.366074 28.257771 89.996353 28.32333
               89.83165 28.24888 89.58609 28.139999 89.35997 27.87166
               89.225517 27.795 89.125793 27.56749 88.971077 27.47361
               88.917877 27.321039)}
      (%i6) Bhutan_polygon: make_polygon([171,173,1143])$
      (%i7) draw2d(Bhutan_polygon)$

  Package draw ·

関数: region_boundaries (x1,y1,x2,y2)

  頂点(x1,y1) -左上- と(x2,y2) -右下-の長方形に完全に含まれる グローバル変数`boundaries_array`の多角形セグメント検出します。

  例:

  南イタリアをプロットするためのセグメントの数を返します。

      (%i1) load("worldmap")$
      (%i2) region_boundaries(10.4,41.5,20.7,35.4);
      (%o2)                [1846, 1863, 1864, 1881, 1888, 1894]
      (%i3) draw2d(geomap(%))$

  Package draw ·

関数: region_boundaries_plus (x1,y1,x2,y2)

  頂点(x1,y1) -左上- と(x2,y2) -右下-で定義された長方形に少なくとも1つ頂点を含まれる グローバル変数`boundaries_array`の多角形セグメント検出します。 多角形セグメント検出します。

  例:

      (%i1) load("worldmap")$
      (%i2) region_boundaries_plus(10.4,41.5,20.7,35.4);
      (%o2) [1060, 1062, 1076, 1835, 1839, 1844, 1846, 1858,
             1861, 1863, 1864, 1871, 1881, 1888, 1894, 1897]
      (%i3) draw2d(geomap(%))$

  Package draw ·

#### 48.4.2 Graphic objects

グラフィックオブジェクト: geomap (numlist)
グラフィックオブジェクト: geomap (numlist,3Dprojection)

  2Dと3Dに関して地図を描画します。

  2D

  この関数はグローバル変数`boundaries_array`と一緒に機能します。

  引数numlistは 数や数のリストを含むリストです。 これらすべての数は、 グローバル配列`boundaries_array`の成分を表す 0以上の整数でなければいけません。

  Each component of `boundaries_array`のそれぞれの成分は 浮動小数点量の配列であり、多角形セグメントやマップ境界の座標です。

  `geomap (numlist)`は 引数を平坦化し、`boundaries_array`の中に関連した境界を描画します。

  このオブジェクトは以下のグラフィックオプションの影響を受けます: `line_width`, `line_type`, `color`.

  例:

  手で定義された簡単な地図:

      (%i1) load("draw")$
      (%i2) /* Vertices of boundary #0: {(1,1),(2,5),(4,3)} */
         ( bnd0: make_array(flonum,6),
           bnd0[0]:1.0, bnd0[1]:1.0, bnd0[2]:2.0,
           bnd0[3]:5.0, bnd0[4]:4.0, bnd0[5]:3.0 )$
      (%i3) /* Vertices of boundary #1: {(4,3),(5,4),(6,4),(5,1)} */
         ( bnd1: make_array(flonum,8),
           bnd1[0]:4.0, bnd1[1]:3.0, bnd1[2]:5.0, bnd1[3]:4.0,
           bnd1[4]:6.0, bnd1[5]:4.0, bnd1[6]:5.0, bnd1[7]:1.0)$
      (%i4) /* Vertices of boundary #2: {(5,1), (3,0), (1,1)} */
         ( bnd2: make_array(flonum,6),
           bnd2[0]:5.0, bnd2[1]:1.0, bnd2[2]:3.0,
           bnd2[3]:0.0, bnd2[4]:1.0, bnd2[5]:1.0 )$
      (%i5) /* Vertices of boundary #3: {(1,1), (4,3)} */
         ( bnd3: make_array(flonum,4),
           bnd3[0]:1.0, bnd3[1]:1.0, bnd3[2]:4.0, bnd3[3]:3.0)$
      (%i6) /* Vertices of boundary #4: {(4,3), (5,1)} */
         ( bnd4: make_array(flonum,4),
           bnd4[0]:4.0, bnd4[1]:3.0, bnd4[2]:5.0, bnd4[3]:1.0)$
      (%i7) /* Pack all together in boundaries_array */
         ( boundaries_array: make_array(any,5),
           boundaries_array[0]: bnd0, boundaries_array[1]: bnd1,
           boundaries_array[2]: bnd2, boundaries_array[3]: bnd3,
           boundaries_array[4]: bnd4 )$
      (%i8) draw2d(geomap([0,1,2,3,4]))$

  補助バッケージ `worldmap`は グローバル変数 `boundaries_array`を (経度、緯度)座標で 実世界境界に設定します。 これらのデータはパブリックドメインであり、 http://www-cger.nies.go.jp/grid-e/gridtxt/grid19.html に由来するものです。

  パッケージ`worldmap`は、国、大陸、海岸線の境界も `boundaries_array`の必要な成分を持つリストとして、 定義します。 (更に知るにはファイル`share/draw/worldmap.mac`を参照してください) パッケージ`draw`は自動的に`worldmap`をロードしません。

      (%i1) load("worldmap")$
      (%i2) c1: gr2d(geomap(Canada,United_States,
                            Mexico,Cuba))$
      (%i3) c2: gr2d(geomap(Africa))$
      (%i4) c3: gr2d(geomap(Oceania,China,Japan))$
      (%i5) c4: gr2d(geomap(France,Portugal,Spain,
                            Morocco,Western_Sahara))$
      (%i6) draw(columns  = 2,
                 c1,c2,c3,c4)$

  パッケージ`worldmap`は 国をポリゴンとしてプロットする時にも役に立ちます。 この場合、グラフィックオブジェクト`geomap`は もはや必要でなく、代わりに`polygon`オブジェクトが使われます。 配列ではなくリストが現在使われているので、 地図レンダリングはより遅いでしょう。 以下のコードを理解するためには、 `make_poly_country`と`make_poly_continent`も 参照してください。

      (%i1) load("worldmap")$
      (%i2) mymap: append(
         [color      = white],  /* borders are white */
         [fill_color = red],             make_poly_country(Bolivia),
         [fill_color = cyan],            make_poly_country(Paraguay),
         [fill_color = green],           make_poly_country(Colombia),
         [fill_color = blue],            make_poly_country(Chile),
         [fill_color = "#23ab0f"],       make_poly_country(Brazil),
         [fill_color = goldenrod],       make_poly_country(Argentina),
         [fill_color = "midnight-blue"], make_poly_country(Uruguay))$
      (%i3) apply(draw2d, mymap)$

  3D

  `geomap (numlist)`は地図境界を 中心が(0,0,0)で半径1の球上に射影します。 `geomap (numlist,3Dprojection)`を使うことで、 球や射影タイプを変えることが可能です。

  利用可能な3D射影:

  - `[spherical_projection,x,y,z,r]`: 地図境界を 中心(x,y,z)、半径rの球上に 射影します。

        (%i1) load("worldmap")$
        (%i2) draw3d(geomap(Australia), /* default projection */
                     geomap(Australia,
                            [spherical_projection,2,2,2,3]))$

  - `[cylindrical_projection,x,y,z,r,rc]`: 球地図境界を 中心(x,y,z)の半径rの地球の極を通る軸を持ち 半径rcの円柱に再射影します。

        (%i1) load("worldmap")$
        (%i2) draw3d(geomap([America_coastlines,Eurasia_coastlines],
                            [cylindrical_projection,2,2,2,3,4]))$

  - `[conic_projection,x,y,z,r,alpha]`: 球地図境界を 中心(x,y,z)の半径rの地球の極を通る軸を持ち 角度alphaの円錐上に 再射影します。 北円錐と南円錐両方が球に接触します。

        (%i1) load("worldmap")$
        (%i2) draw3d(geomap(World_coastlines,
                            [conic_projection,0,0,0,1,90]))$

  更に丹念な例を見るには、 http://www.telefonica.net/web2/biomates/maxima/gpdraw/geomap も参照してください。

  Package draw ·

Next: dynamics, Previous: draw, Up: Top [Contents][Index]

## 49 drawdf

Next: Functions and Variables for drawdf, Previous: drawdf, Up: drawdf [Contents][Index]

### 49.1 Introduction to drawdf

関数`drawdf`は 一階常微分方程式(ODE)や 二連立自律一階ODE系の方向場を描画します。

これは追加パッケージなので、利用するには、最初に `load("drawdf")`でロードしなければいけません。 Drawdfは`draw`パッケージ上に構築されています。これはGnuplot 4.2を要求します。

単一のODEの方向場をプロットするには、ODEを以下の形式で書かなければいけません:

           dy
           -- = F(x,y)
           dx

そして関数Fを`drawdf`の引数に与えなければいけません。 もし独立変数と従属変数が、上の式のようにxとyでないなら、 drawdfコマンドへの引数として与えられるリストの中に明示的に それら2つの変数を指名しなければいけません。 (例を見てください。)

2つの自励ODEの組の方向場をプロットするには、 それらを以下の形式で書かなければいけません。

           dx             dy
           -- = G(x,y)    -- = F(x,y)
           dt             dt

そして`drawdf`の引数は2つの関数GとFを その順に持つリストでなければいけません; すなわち、リストの最初の式は水平軸上に表された変数の時間導関数であり、 二番目の式は垂直軸上に表された変数の時間導関数です。 それら2つの変数はxとyである必要はありませんが、 もしそうでないなら、 drawdfに与えられる二番目の引数は 2つの変数を、最初のものが水平軸上のものを、その後垂直軸上のものを指定する別のリストでなければいけません。

もしただ1つのODEが与えられるなら、 `drawdf`は、 暗に`x=t`,`G(x,y)=1`と認め、 非自励方程式を2つの自励方程式系に変換します。

Differential equations ·Plotting ·Share packages ·Package drawdf ·Package draw ·

Previous: Introduction to drawdf, Up: drawdf [Contents][Index]

### 49.2 Functions and Variables for drawdf

#### 49.2.1 Functions

関数: drawdf (dydx, ...options and objects...)
関数: drawdf (dvdu, `[`u,v`]`, ...options and objects...)
関数: drawdf (dvdu, `[`u,umin,umax`]`, `[`v,vmin,vmax`]`, ...options and objects...)
関数: drawdf (`[`dxdt,dydt`]`, ...options and objects...)
関数: drawdf (`[`dudt,dvdt`]`, `[`u,v`]`, ...options and objects...)
関数: drawdf (`[`dudt,dvdt`]`, `[`u,umin,umax`]`, `[`v,vmin,vmax`]`, ...options and objects...)

  関数`drawdf`は、 オプションの解曲線や`draw`パッケージを使う他のグラフィックスと一緒に、 2D方向場を描きます。

  最初の引数は導関数を指定し、式か2つの式のリストでなければいけません。 dydx, dxdt, dydtはxとyに依存する式です。 dvdu, dudt, dvdtはuとvに依存する式です。

  もし独立変数と従属変数がxとyでないなら、 それらの名前を、導関数に続いてすぐに、 2つの名前のリスト`[`u,v`]`のとしてか、 形式`[`u,umin,umax`]`と `[`v,vmin,vmax`]`の2つのリストとしてのいずれか のように,指定しなければいけません。

  残りの引数はグラフィックオプションかグラフィックオブジェクト, 任意の深さで入れ子になったグラフィックオプションやオブジェクトを含むリストです。 `drawdf`がサポートするグラフィックオプションとオブジェクトの集合は `draw`パッケージの`draw2d`と`gr2d`がサポートするもの上位集合です。

  引数は順次解釈されます: グラフィックオプションは続くグラフィックオブジェクトすべてに影響します。 更に、グラフィックオブジェクトは指定された順にキャンバス上に描かれ、 先に描かれたグラフィックスを見えなくするかもしれません。 いくつかのグラフィックオプションはシーンのグローバルな外観に影響します。

  `drawdf`がサポートする追加のグラフィックオブジェクトは以下を含みます: `solns_at`, `points_at`, `saddles_at`, `soln_at`, `point_at`, `saddle_at`.

  `drawdf`がサポートする追加のグラフィックオプションは以下を含みます: `field_degree`, `soln_arrows`, `field_arrows`, `field_grid`, `field_color`, `show_field`, `tstep`, `nsteps`, `duration`, `direction`, `field_tstep`, `field_nsteps`, `field_duration`.

  `draw`パッケージから受け継がれた、共通に使われるグラフィックオブジェクトは 以下を含みます: `explicit`, `implicit`, `parametric`, `polygon`, `points`, `vector`, `label`, `draw2d`と`gr2d`がサポートする他のすべてのもの。

  `draw`パッケージから受け継がれた、共通に使われるグラフィックオプションは 以下を含みます:
  `points_joined`, `color`, `point_type`, `point_size`, `line_width`, `line_type`, `key`, `title`, `xlabel`, `ylabel`, `user_preamble`, `terminal`, `dimensions`, `file_name`, `draw2d`と`gr2d`がサポートする他のすべてのもの。

  `draw2d`も参照してください。

  wxMaximaやImaximaのユーザーは`wxdrawdf`を代わりに使うかもしれません。 それは、 グラフィックスが`wxdraw`を使うノートブック内で描かれることを除いて、 `drawdf`と同一です。

  この関数を利用するには、最初に`load("drawdf")`を書いてください。

  例:

      (%i1) load("drawdf")$
      (%i2) drawdf(exp(-x)+y)$        /* default vars: x,y */
      (%i3) drawdf(exp(-t)+y, [t,y])$ /* default range: [-10,10] */
      (%i4) drawdf([y,-9*sin(x)-y/5], [x,1,5], [y,-2,2])$

  下位互換のために、`drawdf`はplotdfがサポートしたパラメータのほとんどを 受け付けます。

      (%i5) drawdf(2*cos(t)-1+y, [t,y], [t,-5,10], [y,-4,9],
                   [trajectory_at,0,0])$

  `soln_at`と`solns_at`は、 少し強化された4次のRunge Kutta数値積分器を使って、 指定された点を通る解曲線を描きます。

      (%i6) drawdf(2*cos(t)-1+y, [t,-5,10], [y,-4,9],
                   solns_at([0,0.1],[0,-0.1]),
                   color=blue, soln_at(0,0))$

  `field_degree=2`とすると、 それぞれのグリッド点での1次と2次の導関数に基づいて、 場が二次のスプラインで構成されます。 `field_grid=[`COLS,ROWS`]`は グリッドの列と行の数を指定します。

      (%i7) drawdf(2*cos(t)-1+y, [t,-5,10], [y,-4,9],
                   field_degree=2, field_grid=[20,15],
                   solns_at([0,0.1],[0,-0.1]),
                   color=blue, soln_at(0,0))$

  `soln_arrows=true`は 解曲線に矢印を加え、 (デフォルトでは)方向場からそれらを削除します。 また、解曲線を強調するようにデフォルトの色を変えます。

      (%i8) drawdf(2*cos(t)-1+y, [t,-5,10], [y,-4,9],
                   soln_arrows=true,
                   solns_at([0,0.1],[0,-0.1],[0,0]))$

  `duration=40`は数値積分の時間間隔を指定します(デフォルトは10))。 もし解がプロット領域から遠くに移動し過ぎたり、 導関数が複素数や無限大になったりしても、積分は自動的に停止します。 ここでも、 `field_degree=2`を指定して二次スプラインをプロットします。 以下の方程式は捕食者-被食者系をモデル化します。

      (%i9) drawdf([x*(1-x-y), y*(3/4-y-x/2)], [x,0,1.1], [y,0,1],
                   field_degree=2, duration=40,
                   soln_arrows=true, point_at(1/2,1/2),
                   solns_at([0.1,0.2], [0.2,0.1], [1,0.8], [0.8,1],
                            [0.1,0.1], [0.6,0.05], [0.05,0.4],
                            [1,0.01], [0.01,0.75]))$

  `field_degree='solns`とすると、 場は、4次のRunge Kuttaで計算された多くの小さな解曲線で構成され、 この場合、より良い結果をもたらします。

      (%i10) drawdf([x*(1-x-y), y*(3/4-y-x/2)], [x,0,1.1], [y,0,1],
                    field_degree='solns, duration=40,
                    soln_arrows=true, point_at(1/2,1/2),
                    solns_at([0.1,0.2], [0.2,0.1], [1,0.8],
                             [0.8,1], [0.1,0.1], [0.6,0.05],
                             [0.05,0.4], [1,0.01], [0.01,0.75]))$

  `saddles_at`は 自動的にそれぞれの鞍部で方程式を線形化しようとし、 セパラトリクスを含む、それぞれの固有ベクトルに対応した数値解をプロットしようとします。 `tstep=0.05`は 数値積分器の最大時間ステップを指定します(デフォルトは0.1)。 xとyのステップを小さく保つために、小さ目の時間ステップが時々使われます。 以下の方程式は減衰振り子をモデル化します。

      (%i11) drawdf([y,-9*sin(x)-y/5], tstep=0.05,
                    soln_arrows=true, point_size=0.5,
                    points_at([0,0], [2*%pi,0], [-2*%pi,0]),
                    field_degree='solns,
                    saddles_at([%pi,0], [-%pi,0]))$

  `show_field=false`は場を完全に抑制します。

      (%i12) drawdf([y,-9*sin(x)-y/5], tstep=0.05,
                    show_field=false, soln_arrows=true,
                    point_size=0.5,
                    points_at([0,0], [2*%pi,0], [-2*%pi,0]),
                    saddles_at([3*%pi,0], [-3*%pi,0],
                               [%pi,0], [-%pi,0]))$

  `drawdf`は、認識しないパラメータすべてを`draw2d`や`gr2d`に渡します。 なので、`draw`パッケージのフルパワーを`drawdf`と組み合わせられます。

      (%i13) drawdf(x^2+y^2, [x,-2,2], [y,-2,2], field_color=gray,
                    key="soln 1", color=black, soln_at(0,0),
                    key="soln 2", color=red, soln_at(0,1),
                    key="isocline", color=green, line_width=2,
                    nticks=100, parametric(cos(t),sin(t),t,0,2*%pi))$

  `drawdf`はグラフィクオプションやオブジェクトの入れ子のリストを受け付けます。 なので、makelistやグラフィックスを生成する他の関数コールの便利な使用が可能です。

      (%i14) colors : ['red,'blue,'purple,'orange,'green]$
      (%i15) drawdf([x-x*y/2, (x*y - 3*y)/4],
                    [x,2.5,3.5], [y,1.5,2.5],
                    field_color = gray,
                    makelist([ key   = concat("soln",k),
                               color = colors[k],
                               soln_at(3, 2 + k/20) ],
                             k,1,5))$

  Package drawdf ·

Next: ezunits, Previous: drawdf, Up: Top [Contents][Index]

## 50 dynamics

Next: Functions and Variables for dynamics, Previous: dynamics, Up: dynamics [Contents][Index]

### 50.1 Introduction to dynamics

追加パッケージ`dynamics`には、 離散力学系とフラクタルの様々なグラフィックス表現を生成するためのいくつかの関数と、 微分方程式系を数値的に解くための4次Runge-Kutta法の実装が含まれています。

このパッケージの関数を使うには、 最初に`load("dynamics")`でパッケージをロードしなければいけません。

Maxima 5.12で導入された変更

Maxima 5.12以来、現在まで、dynamicsパッケージは グラフを処理するのに関数`plot2d`を使います。 (`julia`や`mandelbrot`を除いて) グラフィックスを生成するコマンドは`plot2d`のいかなるオプションも受け付けます。 オプションには、プロットスタイルや色を使ったり、 一方の、または両方の軸を対数スケールで表したり、 様々なグラフィカルインターフェイス全体に渡って変更を加えるものを含みます。 古いオプションdomain, pointsize, xcenter, xradius, ycenter, yradius, xaxislabel, yaxislabelは この新しいバージョンでは受け付けられません。

現在，すべてのプログラムは、 以前のバージョンのようにxとyだけでなく、 任意の変数名を受け付けます。 ２つの要求パラメータが2つのプログラムで変えられました: `evolution2d`は、現在、 ２つの独立変数を陽に指定するリストを要求し、 `orbits`の水平範囲はもはやステップサイズを要求しません; 範囲は、変数名と最小値、最大値だけを指定しなければいけません; ステップ数は、現在、オプションnticksで変えることができます。

Dynamical systems ·Share packages ·Package dynamics ·

Previous: Introduction to dynamics, Up: dynamics [Contents][Index]

### 50.2 Functions and Variables for dynamics

関数: chaosgame (`[[`x1, y1`]`...`[`xm, ym`]]`, `[`x0, y0`]`, b, n, ..., options, ...);

  いわゆるカオスゲームを実装します: 初期点(x0, y0)がプロットされ、 m個の点`[`x1, y1`]`...`[`xm, ym`]`の１つがランダムに選択されます。 プロットされる次の点はプロットされた以前の点からランダムに選ばれた点までの線分上で、 ランダム点からその線分の長さにbを掛けた距離にあります。 手続きは n回繰り返されます。

  Package dynamics ·Plotting ·

関数: evolution (F, y0, n, ..., options, ...);

  ２次元グラフに、 点の水平座標が整数0, 1, 2, ..., n、 垂直座標が再帰関係

              y(n+1) = F(y(n))

  で定義された数列の対応する値y(n)である n+1個の点を描きます。 ここで、初期値y(0)はy0に等しいです。 Fは１変数にだけ依存する式でなければいけません。 (例の中では、yに依存していますが、他のいかなる変数を使うことができます), y0は実数でなければいけなく、nは正の整数でなければいけません。

  Package dynamics ·Plotting ·

関数: evolution2d (`[`F, G`]`, `[`u, v`]`, `[`u0, y0`]`, n, ..., options, ...);

  再帰関係を伴う二次元離散力学系によって定義された点列の中の最初のn+1点を 二次元プロットで、 表示します。 初期値u0とv0を持つ

              u(n+1) = F(u(n), v(n))    v(n+1) = G(u(n), v(n))

  FとGは2変数uとvのみに依存する式2つでなければいけません。 変数はリストの中に明示的に指名されなければいけません。

  Package dynamics ·Plotting ·

関数: ifs (`[`r1, ..., rm`]`, `[`A1, ..., Am`]`, `[[`x1, y1`]`, ..., `[`xm, ym`]]`, `[`x0, y0`]`, n, ..., options, ...);

  反復関数系法を実装します。 この方法は関数`chaosgame`で記述した方法に似ていますが、 現在点からランダムに選ばれた点にセグメントを縮める代わりに、 そのセグメントの2成分はランダムに選ばれた点に対応する2行2列行列Aiを乗算されます。

  m個のアトラクティブな点の１つのランダムな選択を 重みr1,...,rmで定義された非均一な確率分布で作ることができます。 それらの重みは累積形で与えられます; 例えば、 もし確率0.2, 0.5, 0.3を持つ3点があるなら、 重みr1, r2とr3は2, 7, 10とできます。

  Package dynamics ·Plotting ·

関数: julia (x, y, ...options...)

  複素数(x + i y)に関するJulia集合の表現のグラフィックスファイルを生成します。 パラメータxとyは実数でなければいけません。 ファイルは、XPMグラフィックスフォーマットでカレントディレクトリかユーザーディレクトリに生成されます。 プログラムは走らせるのに数秒かかるかもしれません。終了後、生成したファイル名と共にメッセージが印字されます。

  Julia集合に属さない点には、異なる色が割り当てられます。 繰り返し回数に従って、その点から始まり、半径2の収束円から動く数列を取ります。 繰り返しの最大回数はオプションlevelsで設定されます; その回数の繰り返しの後、もし数列がまだ収束円内なら、 点はオプションcolorで定義された色で塗られます。

  Julia集合に属さない点に使われる色すべては、同じsaturationとvalueを持ちますが、 hueと(hue + huerange)の間に一様に分布する、違った色相角を持ちます。

  optionsはオプションの列です。 受け付けられるオプションのリストは以下の節で与えられます。

  Package dynamics ·Plotting ·

関数: mandelbrot (options)

  Mandelbrot集合の表現のグラフィックスファイルを生成します。 ファイルは、XPMグラフィックスフォーマットでカレントディレクトリかユーザーディレクトリに生成されます。 プログラムは走らせるのに数秒かかるかもしれません。終了後、生成したファイル名と共にメッセージが印字されます。

  Mandelbrot集合に属さない点には、異なる色が割り当てられます。 繰り返し回数に従って、その点から始まり、半径2の収束円から動く数列を取ります。 繰り返しの最大回数はオプションlevelsで設定されます; その回数の繰り返しの後、もし数列がまだ収束円内なら、 点はオプションcolorで定義された色で塗られます。

  Mandelbrot集合に属さない点に使われる色すべては、同じsaturationとvalueを持ちますが、 hueと(hue + huerange)の間に一様に分布する、違った色相角を持ちます。

  optionsはオプションの列です。 受け付けられるオプションのリストは以下の節で与えられます。

  Package dynamics ·Plotting ·

関数: orbits (F, y0, n1, n2, [x, x0, xf, xstep], ...options...);

  パラメータxを持つ一次元離散力学系の族に関する軌道図を描画します; この種の図は一次元離散系の分岐の研究に使われます。

  関数F(y)は、 関数`evolution`の場合と同様に値y0で始まる数列を定義しますが、 この場合、その関数は、x0からxfまでの区間内の値を取り、 xstepの増分を持つパラメータxにも依存します。 パラメータxに使われるそれぞれの値は水平軸に示されます。 垂直軸は、 数列にn1回の時間発展させた後得られる数列y(n1+1),..., y(n1+n2+1)のn2個の値を示します。

  Package dynamics ·Plotting ·

関数: rk (ODE, var, initial, domain)
関数: rk ([ODE1,...,ODEm], [v1,...,vm], [init1,...,initm], domain)

  4次のRunge-Kutta法を使って、最初の形式は一階常微分方程式一つを数値的に解き、二番目の形式はそれらm個の方程式系を解きます。 varは従属変数を表します。 ODEは独立変数と従属変数にだけ依存する式でなければいけません。 そして、独立変数に関する従属変数の導関数を定義します。

  独立変数は`domain`で指定されます。 それは4つの要素のリストでなければいけません。 例えば:

      [t, 0, 10, 0.1]

  リストの最初の要素は独立変数を特定し、二番目と三番目の要素はその変数の初期値と最終値であり、 最後の要素はその区間内で使用されるべき増加分を設定します。

  もしmこの方程式が解かれようとしているなら、 m個の従属変数v1, v2, ..., vmが存在しなければいけません。 それらの変数の初期値はinit1, init2, ..., initmとなります。 以前の場合と同様、`domain`で定義されたただ1つの独立変数が残っています。 ODE1, ..., ODEmは 独立変数に関する従属変数それぞれの導関数を定義する式です。 それらの式に現れるかもしれない変数は独立変数と任意の従属変数だけです。 従属変数と厳密に同じ順序でリストの中に導関数ODE1, ..., ODEmを与えることが重要です; 例えば、リストの三番目の要素は三番目の従属変数の導関数と解釈されます。

  プログラムは 方程式を独立変数の初期値から最終値まで一定の増加分を使って積分しようとします。 もしあるステップで従属変数の1つが大きすぎる絶対値を取ったら、 積分はその点で中断されます。 結果は、なされた繰り返しの回数と同じ数の要素を持つリストです。 結果リストの中のそれぞれの要素は、それ自身m+1個の要素を持つもう一つのリストです: 独立変数の値にその点に対応する従属変数の値が続きます。

  Package dynamics ·Differential equations ·Numerical methods ·

関数: staircase (F, y0, n, ...options...);

  再帰関係によって定義された数列に関する階段図形を描画します。

              y(n+1) = F(y(n))

  入力パラメータの解釈と許される値は 関数`evolution`に関するものと同じです。 階段図形は線G(y) `=` yと共に関数F(y)のプロットから構成されます。 垂直区間は、 その線上の点(y0, y0)から 関数Fと交差する点まで描画されます。 水平区間はその点から線上の点(y1, y1)に届くまで描画されます。 手続きは点(yn, yn)に届くまでn回繰り返されます。

  Package dynamics ·Plotting ·

オプション

それぞれのオプションは複数の項目のリストです。 最初の項目はオプション名で、残りはオプションの引数からなります。

関数`evolution`, `evolution2d`, `staircase`, `orbits`, `ifs`, `chaosgame`が受け付けるオプションは は`plot2d`に関するオプションと同じです。 `orbits`は、それらのオプションに加えて、 垂直方向に表される異なる点の最大数を設定する特別なオプションpixelsを受け付けます。

以下のオプションを 関数`julia`と`mandelbrot`は受け付けます:

- sizeは1つか2つの引数を取ります。 もし1つだけ引数が与えられたら、 生成されるグラフィックスファイルの幅と高さはピクセル単位でその値に等しくなります。 もし引数2つが与えられたら、それらは幅と高さを定義します。 デフォルト値は、幅と高さ両方に関して400ピクセルです。 もし2つの値が等しくないなら、集合は歪んで現れます。
- levelsは繰り返しの最大数を定義します。 これは集合に属さない点に使われる色の数にも等しいです。 デフォルト値は12です; 値が大きくなると、処理時間が長くなります。
- huerangeは 集合に属さない点の色相に使われる色相角の範囲を定義します。 デフォルト値は360です。これは色が色相のすべての範囲に広がることを意味します。 360より大きな値は、色相範囲の繰り返しを意味し、 負の値は、繰り返し回数が増えるにつれ、 色相角を減らすように使うことができます。
- hueは、 集合に属さない点に使われる最初の色の色相を度単位で設定します。 デフォルト値は300度です。これはマゼンダに対応します; 他の標準的な色の値は、赤には0、オレンジには45、黄には60、緑には120、シアンには180、 青には240です。 オプションhuerangeも参照してください。
- saturationは集合に属さない点に使われる飽和値を設定します。 0と1の間でなければいけません。 デフォルト値は、0.46です。
- valueは 集合に属さない点に使われる色の値を設定します。 0と1の間でなければいけません; 値が高くなると、色が明るくなります。 デフォルト値は、0.96です。
- colorには、 集合の点を表すのに使われる色の色相、飽和、値を定義する 3つのパラメータが続きます。 デフォルト値は３つのパラメータすべてが0であり、黒に対応します。 許される値の範囲の説明に関して、 オプションhue, saturation, valueを参照してください。
- centerには、2つの実パラメータが続きます。 これは、表示される領域の中心点の複素平面上の座標を与えます。 デフォルト値は両座標に関して0(原点)です。
- radiusは表示される正方形領域内の最大円の半径を設定します。 デフォルト値は2です。
- filenameは 結果のグラフが保存されるファイル名を与えます。 拡張子.xpmがその名前に加えられます。 もしファイルが既に存在しているなら、 関数が生成したファイルで置き換えられます。 デフォルト値はJulia集合にはjulia、 Mandelbrot集合にはmandelbrotです。

例

以下の数列のグファフィックス表現と階段図形: 2, cos(2), cos(cos(2)),...

    (%i1) load("dynamics")$

    (%i2) evolution(cos(y), 2, 11);

    (%i3) staircase(cos(y), 1, 11, [y, 0, 1.2]);

もしシステムが遅いなら、 以下の例のように繰り返し回数を減らさなければいけないでしょう。 そして、もしモニタ上のドットが小さすぎるなら、 `[`style,`[`points,0.8`]]`のように、 違ったスタイルを試したくなるかもしれません。

パラメータaを持つ二次写像の軌跡図。

            x(n+1) = a + x(n)^2

    (%i4) orbits(x^2+a, 0, 50, 200, [a, -2, 0.25], [style, dots]);

x `=` -1.25近くのより低い分岐の回りの領域を拡大するには、以下を使ってください:

    (%i5) orbits(x^2+a, 0, 100, 400, [a,-1,-1.53], [x,-1.6,-0.8],
                 [nticks, 400], [style,dots]);

フラクタルに導かれる二次元系の発展:

    (%i6) f: 0.6*x*(1+2*x)+0.8*y*(x-1)-y^2-0.9$

    (%i7) g: 0.1*x*(1-6*x+4*y)+0.1*y*(1+9*y)-0.4$

    (%i8) evolution2d([f,g], [x,y], [-0.5,0], 50000, [style,dots]);

そしてそのフラクタルの小さな領域の拡大:

    (%i9) evolution2d([f,g], [x,y], [-0.5,0], 300000, [x,-0.8,-0.6],
                      [y,-0.4,-0.2], [style, dots]);

カオスゲームで得られるSierpinski三角形のプロット:

    (%i9) chaosgame([[0, 0], [1, 0], [0.5, sqrt(3)/2]], [0.1, 0.1], 1/2,
                     30000, [style, dots]);

反復函数系で得られるBarnsleyのシダ:

    (%i10) a1: matrix([0.85,0.04],[-0.04,0.85])$

    (%i11) a2: matrix([0.2,-0.26],[0.23,0.22])$

    (%i12) a3: matrix([-0.15,0.28],[0.26,0.24])$

    (%i13) a4: matrix([0,0],[0,0.16])$

    (%i14) p1: [0,1.6]$

    (%i15) p2: [0,1.6]$

    (%i16) p3: [0,0.44]$

    (%i17) p4: [0,0]$

    (%i18) w: [85,92,99,100]$

    (%i19) ifs(w, [a1,a2,a3,a4], [p1,p2,p3,p4], [5,0], 50000, [style,dots]);

そして数(-0.55 + i 0.6)に関するJulia集合は以下で得られます:

    julia (-0.55, 0.6, [iterations, 36], [x, -0.3, 0.2],
          [y, 0.3, 0.9], [grid, 400, 400], [color_bar_tics, 0, 6, 36])$

x方向に-0.3から0.3まで、y方向に0.3から0.9までの領域を表示します。 青から始まり黄で終わる36色が使われます。

微分方程式

              dx/dt = t - x^2

を、初期値x(t=0) = 1で、0から8までのtの区間で0.1の増分で 数値的に解くには、以下を使ってください:

    (%i20) results: rk(t-x^2,x,1,[t,0,8,0.1])$

結果はリスト`results`に保存されます。

系

            dx/dt = 4-x^2-4*y^2     dy/dt = y^2-x^2+1

を、t=0のxとyの初期値がそれぞれ-1.25, 0.75で、0から4までの区間で、 数値的に解くには:

    (%i21) sol: rk([4-x^2-4*y^2,y^2-x^2+1],[x,y],[-1.25,0.75],[t,0,4,0.02])$

Next: f90, Previous: dynamics, Up: Top [Contents][Index]

## 51 ezunits

Next: Introduction to physical_constants, Previous: ezunits, Up: ezunits [Contents][Index]

### 51.1 Introduction to ezunits

`ezunits`は次元量を扱うためのパッケージです。 次元解析のいくつかの関数を含みます。 `ezunits`は 次元量と単位変換に関する算術演算を 実行できます。 組み込み単位は国際単位系(SI)とUS慣習単位系を含み、他の単位が宣言できます。 `physical_constants`、物理定数のコレクション、も参照してください。

`load("ezunits")`はこのパッケージをロードします。 `demo(ezunits)`はいくつかの例を表示します。 便利な関数`known_units`は組み込みとユーザー宣言単位のリストを返し、 そして、 `display_known_unit_conversions`は 可読性の高いフォーマットで既知の変換一式を表示します。

式a ` bは、無次元量を示す`a`と次元単位`b`で 次元量を表します。 そのように宣言することなしに、シンボルを単位として使うことができます; 単位シンボルはいかなる特別なプロパティを持つ必要はありません。 式a ` bの量と単位は、 それぞれ、`qty`関数と`units`関数で抽出することができます。

シンボルは、指定された量か指定された単位か両方を持つ次元量であると宣言することができます。

式a ` b `` cは 単位`b`から単位`c`に変換します。 `ezunits`は SI基本単位、SI組立単位、いくつかの非SI単位に関する組み込み変換を持っています。 まだ`ezunits`が知らない単位変換は、宣言することができます。 `ezunits`が知っている単位変換は 組み込み変換とユーザー定義の変換から構成される グローバル変数`known_unit_conversions`で指定されます。 単位の積や商、冪に関する変換は知られている単位変換の組から演繹されます。

Maximaは一般的に厳密でない数(浮動小数点数か多倍長浮動小数点数)より 厳密な数(整数か有理数)を好むので、 次元量でそれらが現れた時、`ezunits`は厳密な数を保護します。 組み込み単位変換すべては厳密な数で表現されます; 宣言された変換で厳密でない数は厳密なものに強制的に変換されます。

単位の表示のために優先される系はありません; 入力単位は、変換を明示的に示さない限り、他の単位には変換されません。 `ezunits`は 前置詞m-, k-, M, G-(ミリ-, キロ-, メガ-, ギガ-)を SI基本単位やSI組立単位に適用された際、 認識しますが、 そんな前置詞は明示的な変換で示された時だけ適用されます。

次元量に対する算術演算子は そんな演算子の慣例的な規則で実行されます。

- (x ` a) * (y ` b) is equal to (x * y) ` (a * b).
- (x ` a) + (y ` a) is equal to (x + y) ` a.
- (x ` a)^y is equal to x^y ` a^y when `y` is nondimensional.

`ezunits`は 和の中の単位が同じ次元を持つことを要求しません; そんな項は足さられず、エラーは報告されません。

`ezunits`は初等的な次元解析関数を含みます。 すなわち、次元量の基本的な次元と基本的な単位、無次元量と自然単位系の計算です。 次元解析の関数は Barton Willisが書いた別のパッケージの類似の関数から焼き直されました。

次元解析のために、 基本的な次元のリストと基本的な単位の連想リストは保持されます; デフォルトでは、 基本的な次元は、長さ、質量、時刻、電荷、温度、量であり、 基本的な単位は関連したSI単位で、 他の基本的な次元や単位を宣言できます。

Physical units ·Share packages ·Package ezunits ·

Next: Functions and Variables for ezunits, Previous: Introduction to ezunits, Up: ezunits [Contents][Index]

### 51.2 Introduction to physical_constants

`physical_constants`は物理定数のコレクションです。 CODATA 2006 推奨値からコピーしました。[1] `load("physical_constants")`はこのパッケージをロードし、 まだロードされていないなら、`ezunits`もロードします。

物理定数は定数値のプロパティを持つシンボルとして表されます。 定数値は、`ezunits`が表すように次元量です。 関数`constvalue`は定数値を取りに行きます; 定数値はシンボルの普通の値ではなく、 `constvalue`が値を取りに行くまで、 物理定数のシンボルは評価される式の中でシンボルのままです。

`physical_constants`はある補助情報、 すなわち、それぞれの定数の記述文字列、 数値の誤差の見積もり、TeX表示のためのプロパティを含みます。 物理定数を識別するために、それぞれのシンボルは `physical_constant`性質を持ちます; それ故に、`propvars(physical_constant)`はそんなシンボルすべてのリストを 表示します。

`physical_constants`以下の定数を含みます。

`%c`

  真空中の光速度

`%mu_0`

  真空の透磁率

`%e_0`

  真空の誘電率

`%Z_0`

  真空の特性インピーダンス

`%G`

  Newtonの重力定数

`%h`

  Planck定数

`%h_bar`

  Planck定数

`%m_P`

  Planck質量

`%T_P`

  Planck温度

`%l_P`

  Planck長

`%t_P`

  Planck時間

`%%e`

  電気素量

`%Phi_0`

  磁束量子

`%G_0`

  コンダクタンス量子

`%K_J`

  Josephson定数

`%R_K`

  von Klitzing定数

`%mu_B`

  Bohr磁子

`%mu_N`

  核磁子

`%alpha`

  微細構造定数

`%R_inf`

  Rydberg定数

`%a_0`

  Bohr半径

`%E_h`

  Hartreeエネルギー

`%ratio_h_me`

  循環量子

`%m_e`

  電子質量

`%N_A`

  Avogadro数

`%m_u`

  原子質量定数

`%F`

  Faraday定数

`%R`

  気体定数

`%%k`

  Boltzmann定数

`%V_m`

  理想気体のモル体積

`%n_0`

  Loschmidt定数

`%ratio_S0_R`

  Sackur-Tetrode定数 (絶対エントロピー定数)

`%sigma`

  Stefan-Boltzmann定数

`%c_1`

  第一放射定数

`%c_1L`

  スペクトル放射強度の第一放射定数

`%c_2`

  第二放射定数

`%b`

  Wien変位則定数

`%b_prime`

  Wien変位則定数

参考文献:

[1] http://physics.nist.gov/constants

例:

`physical_constant` プロパティを持つすべてのシンボルのリスト。

    (%i1) load ("physical_constants")$
    (%i2) propvars (physical_constant);
    (%o2) [%c, %mu_0, %e_0, %Z_0, %G, %h, %h_bar, %m_P, %T_P, %l_P,
    %t_P, %%e, %Phi_0, %G_0, %K_J, %R_K, %mu_B, %mu_N, %alpha,
    %R_inf, %a_0, %E_h, %ratio_h_me, %m_e, %N_A, %m_u, %F, %R, %%k,
    %V_m, %n_0, %ratio_S0_R, %sigma, %c_1, %c_1L, %c_2, %b, %b_prime]

物理定数`%c`のプロパティ。

    (%i1) load ("physical_constants")$
    (%i2) constantp (%c);
    (%o2)                         true
    (%i3) get (%c, description);
    (%o3)               speed of light in vacuum
    (%i4) constvalue (%c);
                                          m
    (%o4)                     299792458 ` -
                                          s
    (%i5) get (%c, RSU);
    (%o5)                           0
    (%i6) tex (%c);
    $$c$$
    (%o6)                         false

1ポンドの質量に等価なエネルギー。 シンボル `%c`は、 `constvalue`が値を取りにいくまでシンボルのままです。

    (%i1) load ("physical_constants")$
    (%i2) m * %c^2;
                                    2
    (%o2)                         %c  m
    (%i3) %, m = 1 ` lbm;
                                  2
    (%o3)                       %c  ` lbm
    (%i4) constvalue (%);
                                                2
                                           lbm m
    (%o4)              89875517873681764 ` ------
                                              2
                                             s
    (%i5) E : % `` J;
    Computing conversions to base units; may take a moment.
                         366838848464007200
    (%o5)                ------------------ ` J
                                 9
    (%i6) E `` GJ;
                          458548560580009
    (%o6)                 --------------- ` GJ
                             11250000
    (%i7) float (%);
    (%o7)              4.0759872051556356e+7 ` GJ

Physical units ·Share packages ·Package physical_constants ·

Previous: Introduction to physical_constants, Up: ezunits [Contents][Index]

### 51.3 Functions and Variables for ezunits

演算子: `

  次元量演算子。 式 a ` bは次元量を表します。 `a`は無次元量を表し、`b`は次元単位を表します。 シンボルは、宣言せずに単位として使うことができます; 単位シンボルは特別なプロパティを持つ必要はありません。 式 a ` bの量と単位はそれぞれ、 `qty`と `units`関数で抽出することができます。

  次元量の算術演算子は演算子の慣例規則に従って実行されます。

  - (x ` a) * (y ` b)は (x * y) ` (a * b)に等しい。
  - (x ` a) + (y ` a)は (x + y) ` aに等しい。
  - (x ` a)^yは `y`が無次元の時 x^y ` a^yに等しい。

  `ezunits`は和の中の単位が同じ次元であることを要求しません; そんな項は一緒には足されませんし、エラーは報告されません。

  `load("ezunits")`はこの演算子をイネーブルにします。

  例:

  SI (国際単位系) 単位。

      (%i1) load ("ezunits")$
      (%i2) foo : 10 ` m;
      (%o2)                        10 ` m
      (%i3) qty (foo);
      (%o3)                          10
      (%i4) units (foo);
      (%o4)                           m
      (%i5) dimensions (foo);
      (%o5)                        length

  "慣習"単位。

      (%i1) load ("ezunits")$
      (%i2) bar : x ` acre;
      (%o2)                       x ` acre
      (%i3) dimensions (bar);
                                         2
      (%o3)                        length
      (%i4) fundamental_units (bar);
                                      2
      (%o4)                          m

  アドホック単位。

      (%i1) load ("ezunits")$
      (%i2) baz : 3 ` sheep + 8 ` goat + 1 ` horse;
      (%o2)           8 ` goat + 3 ` sheep + 1 ` horse
      (%i3) subst ([sheep = 3*goat, horse = 10*goat], baz);
      (%o3)                       27 ` goat
      (%i4) baz2 : 1000`gallon/fortnight;
                                      gallon
      (%o4)                   1000 ` ---------
                                     fortnight
      (%i5) subst (fortnight = 14*day, baz2);
                                500   gallon
      (%o5)                     --- ` ------
                                 7     day

  次元量の算術演算子

      (%i1) load ("ezunits")$
      (%i2) 100 ` kg + 200 ` kg;
      (%o2)                       300 ` kg
      (%i3) 100 ` m^3 - 100 ` m^3;
                                        3
      (%o3)                        0 ` m
      (%i4) (10 ` kg) * (17 ` m/s^2);
                                       kg m
      (%o4)                      170 ` ----
                                         2
                                        s
      (%i5) (x ` m) / (y ` s);
                                    x   m
      (%o5)                         - ` -
                                    y   s
      (%i6) (a ` m)^2;
                                    2    2
      (%o6)                        a  ` m

  Package ezunits ·

演算子: ` `

  単位変換演算子。 式 a ` b `` cは単位 `b`を単位 `c`に変換します。 `ezunits`にはSI基本単位、SI組立単位、いくつかの非SI単位のための 組み込み変換があります。 `ezunits`がまだ知らない単位変換は宣言することができます。 `ezunits`が知っている単位変換はグローバル変数 `known_unit_conversions`に 明記されます。それは、組み込みとユーザー定義の変換を含みます。 単位の積、商、べきの変換は既知の単位変換一式から演繹されます。

  単位の表示のためにより好まれる系はありません; 変換が明示的に示されない限り、 入力単位は他の単位に変換されません。 `ezunits`は、 変換が明示的に示されない限り、 前置詞(milli-, centi-, deci-, etc)で単位を整理しようとしません。

  `load("ezunits")`はこの演算子を有効にします。

  例:

  既知の単位変換一式。

      (%i1) load ("ezunits")$
      (%i2) display2d : false$
      (%i3) known_unit_conversions;
      (%o3) {acre = 4840*yard^2,Btu = 1055*J,cfm = feet^3/minute,
             cm = m/100,day = 86400*s,feet = 381*m/1250,ft = feet,
             g = kg/1000,gallon = 757*l/200,GHz = 1000000000*Hz,
             GOhm = 1000000000*Ohm,GPa = 1000000000*Pa,
             GWb = 1000000000*Wb,Gg = 1000000*kg,Gm = 1000000000*m,
             Gmol = 1000000*mol,Gs = 1000000000*s,ha = hectare,
             hectare = 100*m^2,hour = 3600*s,Hz = 1/s,inch = feet/12,
             km = 1000*m,kmol = 1000*mol,ks = 1000*s,l = liter,
             lbf = pound_force,lbm = pound_mass,liter = m^3/1000,
             metric_ton = Mg,mg = kg/1000000,MHz = 1000000*Hz,
             microgram = kg/1000000000,micrometer = m/1000000,
             micron = micrometer,microsecond = s/1000000,
             mile = 5280*feet,minute = 60*s,mm = m/1000,
             mmol = mol/1000,month = 2629800*s,MOhm = 1000000*Ohm,
             MPa = 1000000*Pa,ms = s/1000,MWb = 1000000*Wb,
             Mg = 1000*kg,Mm = 1000000*m,Mmol = 1000000000*mol,
             Ms = 1000000*s,ns = s/1000000000,ounce = pound_mass/16,
             oz = ounce,Ohm = s*J/C^2,
             pound_force = 32*ft*pound_mass/s^2,
             pound_mass = 200*kg/441,psi = pound_force/inch^2,
             Pa = N/m^2,week = 604800*s,Wb = J/A,yard = 3*feet,
             year = 31557600*s,C = s*A,F = C^2/J,GA = 1000000000*A,
             GC = 1000000000*C,GF = 1000000000*F,GH = 1000000000*H,
             GJ = 1000000000*J,GK = 1000000000*K,GN = 1000000000*N,
             GS = 1000000000*S,GT = 1000000000*T,GV = 1000000000*V,
             GW = 1000000000*W,H = J/A^2,J = m*N,kA = 1000*A,
             kC = 1000*C,kF = 1000*F,kH = 1000*H,kHz = 1000*Hz,
             kJ = 1000*J,kK = 1000*K,kN = 1000*N,kOhm = 1000*Ohm,
             kPa = 1000*Pa,kS = 1000*S,kT = 1000*T,kV = 1000*V,
             kW = 1000*W,kWb = 1000*Wb,mA = A/1000,mC = C/1000,
             mF = F/1000,mH = H/1000,mHz = Hz/1000,mJ = J/1000,
             mK = K/1000,mN = N/1000,mOhm = Ohm/1000,mPa = Pa/1000,
             mS = S/1000,mT = T/1000,mV = V/1000,mW = W/1000,
             mWb = Wb/1000,MA = 1000000*A,MC = 1000000*C,
             MF = 1000000*F,MH = 1000000*H,MJ = 1000000*J,
             MK = 1000000*K,MN = 1000000*N,MS = 1000000*S,
             MT = 1000000*T,MV = 1000000*V,MW = 1000000*W,
             N = kg*m/s^2,R = 5*K/9,S = 1/Ohm,T = J/(m^2*A),V = J/C,
             W = J/s}

  基本単位変換。

      (%i1) load ("ezunits")$
      (%i2) 1 ` ft `` m;
      Computing conversions to base units; may take a moment.
                                  381
      (%o2)                       ---- ` m
                                  1250
      (%i3) %, numer;
      (%o3)                      0.3048 ` m
      (%i4) 1 ` kg `` lbm;
                                  441
      (%o4)                       --- ` lbm
                                  200
      (%i5) %, numer;
      (%o5)                      2.205 ` lbm
      (%i6) 1 ` W `` Btu/hour;
                                 720   Btu
      (%o6)                      --- ` ----
                                 211   hour
      (%i7) %, numer;
                                              Btu
      (%o7)               3.412322274881517 ` ----
                                              hour
      (%i8) 100 ` degC `` degF;
      (%o8)                      212 ` degF
      (%i9) -40 ` degF `` degC;
      (%o9)                     (- 40) ` degC
      (%i10) 1 ` acre*ft `` m^3;
                              60228605349    3
      (%o10)                  ----------- ` m
                               48828125
      (%i11) %, numer;
                                                3
      (%o11)                1233.48183754752 ` m

  フィートとメートルを相互に強制変換。

      (%i1) load ("ezunits")$
      (%i2) 100 ` m + 100 ` ft;
      (%o2)                  100 ` m + 100 ` ft
      (%i3) (100 ` m + 100 ` ft) `` ft;
      Computing conversions to base units; may take a moment.
                                 163100
      (%o3)                      ------ ` ft
                                  381
      (%i4) %, numer;
      (%o4)                428.0839895013123 ` ft
      (%i5) (100 ` m + 100 ` ft) `` m;
                                  3262
      (%o5)                       ---- ` m
                                   25
      (%i6) %, numer;
      (%o6)                      130.48 ` m

  基本次元と基本単位を見つけるための次元解析

      (%i1) load ("ezunits")$
      (%i2) foo : 1 ` acre * ft;
      (%o2)                      1 ` acre ft
      (%i3) dimensions (foo);
                                         3
      (%o3)                        length
      (%i4) fundamental_units (foo);
                                      3
      (%o4)                          m
      (%i5) foo `` m^3;
      Computing conversions to base units; may take a moment.
                              60228605349    3
      (%o5)                   ----------- ` m
                               48828125
      (%i6) %, numer;
                                                3
      (%o6)                 1233.48183754752 ` m

  宣言された単位変換。

      (%i1) load ("ezunits")$
      (%i2) declare_unit_conversion (MMBtu = 10^6*Btu, kW = 1000*W);
      (%o2)                         done
      (%i3) declare_unit_conversion (kWh = kW*hour, MWh = 1000*kWh,
                                     bell = 1800*s);
      (%o3)                         done
      (%i4) 1 ` kW*s `` MWh;
      Computing conversions to base units; may take a moment.
                                   1
      (%o4)                     ------- ` MWh
                                3600000
      (%i5) 1 ` kW/m^2 `` MMBtu/bell/ft^2;
                             1306449      MMBtu
      (%o5)                 ---------- ` --------
                            8242187500          2
                                         bell ft

  Package ezunits ·

関数: constvalue (x)
関数: declare_constvalue (a, x)
関数: remove_constvalue (a)

  シンボルの宣言された定数や、 シンボルに宣言された定数を代入した式の値をを返します。

  定数は`declare_constvalue`で宣言されます。 `constvalue`が認識する定数は `numerval`で宣言された値や`constantp`が認識する値と区別されることに 注意してください。

  `physical_units`パッケージはたくさんの物理定数の定数値を宣言します。

  `remove_constvalue`は `declare_constvalue`の効果を戻します。

  `load("ezunits")`はこれらの関数をロードします。

  例:

  物理定数の定数値。

      (%i1) load ("physical_constants")$
      (%i2) constvalue (%G);
                                           3
                                          m
      (%o2)                    6.67428 ` -----
                                             2
                                         kg s
      (%i3) get ('%G, 'description);
      (%o3)           Newtonian constant of gravitation

  新しい定数の宣言。

      (%i1) load ("ezunits")$
      (%i2) declare_constvalue (FOO, 100 ` lbm / acre);
                                       lbm
      (%o2)                      100 ` ----
                                       acre
      (%i3) FOO * (50 ` acre);
      (%o3)                     50 FOO ` acre
      (%i4) constvalue (%);
      (%o4)                      5000 ` lbm

  Package ezunits ·

関数: units (x)
関数: declare_units (a, u)

  次元量xの単位を返します。 もしxが無次元なら、1を返します。

  xは、文字通り次元式 a ` bかもしれませんし、 `declare_units`を介して宣言された単位を持つシンボルかもしれませんし、 それらの一方または両方を含む式かもしれません。

  `declare_units`は、 `units(a)`は式uを返さなければいけないことを宣言します。

  `load("ezunits")`はこれらの関数をロードします。

  例:

  文字通り次元式へ適用された`units`。

      (%i1) load ("ezunits")$
      (%i2) foo : 100 ` kg;
      (%o2)                       100 ` kg
      (%i3) bar : x ` m/s;
                                        m
      (%o3)                         x ` -
                                        s
      (%i4) units (foo);
      (%o4)                          kg
      (%i5) units (bar);
                                      m
      (%o5)                           -
                                      s
      (%i6) units (foo * bar);
                                    kg m
      (%o6)                         ----
                                     s
      (%i7) units (foo / bar);
                                    kg s
      (%o7)                         ----
                                     m
      (%i8) units (foo^2);
                                       2
      (%o8)                          kg

  宣言された単位を持つシンボルに適用された`units`。

      (%i1) load ("ezunits")$
      (%i2) units (aa);
      (%o2)                           1
      (%i3) declare_units (aa, J);
      (%o3)                           J
      (%i4) units (aa);
      (%o4)                           J
      (%i5) units (aa^2);
                                      2
      (%o5)                          J
      (%i6) foo : 100 ` kg;
      (%o6)                       100 ` kg
      (%i7) units (aa * foo);
      (%o7)                         kg J

  Package ezunits ·

関数: qty (x)
関数: declare_qty (a, x)

  `qty`は次元量xの無次元パーツを返します。 もし xが無次元なら、xを返します。 xは文字通り次元式 a ` bかも知れませんし、 宣言された量のシンボルかもしれませんし、 それらの一方または両方を含む式かもしれません。

  `declare_qty`は、 `qty(a)`は無次元量xを返さなければいけないことを宣言します。

  `load("ezunits")`はこれらの関数をロードします。

  例:

  文字通り次元式に適用された`qty`。

      (%i1) load ("ezunits")$
      (%i2) foo : 100 ` kg;
      (%o2)                       100 ` kg
      (%i3) qty (foo);
      (%o3)                          100
      (%i4) bar : v ` m/s;
                                        m
      (%o4)                         v ` -
                                        s
      (%i5) foo * bar;
                                        kg m
      (%o5)                     100 v ` ----
                                         s
      (%i6) qty (foo * bar);
      (%o6)                         100 v

  宣言された量のシンボルへ適用された`qty`。

      (%i1) load ("ezunits")$
      (%i2) declare_qty (aa, xx);
      (%o2)                          xx
      (%i3) qty (aa);
      (%o3)                          xx
      (%i4) qty (aa^2);
                                       2
      (%o4)                          xx
      (%i5) foo : 100 ` kg;
      (%o5)                       100 ` kg
      (%i6) qty (aa * foo);
      (%o6)                        100 xx

  Package ezunits ·

関数: unitp (x)

  もしxが文字通り次元式か、 次元的と宣言されたシンボルか、 主演算子が次元的宣言された式なら、 `true`を返します。 それ以外なら、`unitp`は `false`を返します。

  `load("ezunits")`はこの関数を返します。

  例:

  文字通り次元式へ適用された`unitp`。

      (%i1) load ("ezunits")$
      (%i2) unitp (100 ` kg);
      (%o2)                         true

  次元的と宣言されたシンボルへ適用された`unitp`。

      (%i1) load ("ezunits")$
      (%i2) unitp (foo);
      (%o2)                         false
      (%i3) declare (foo, dimensional);
      (%o3)                         done
      (%i4) unitp (foo);
      (%o4)                         true

  主演算子が次元的と宣言された式に適用された`unitp`。

      (%i1) load ("ezunits")$
      (%i2) unitp (bar (x, y, z));
      (%o2)                         false
      (%i3) declare (bar, dimensional);
      (%o3)                         done
      (%i4) unitp (bar (x, y, z));
      (%o4)                         true

  Package ezunits ·

関数: declare_unit_conversion (u = v, ...)

  式 u = v, ... を 単位変換演算子 ``が知っている単位変換のリストに追加します。 uと vはともにその中のいかなる変数も単位である乗法の項か、 文字通り次元式です。

  現在、 それぞれの式の左辺が(乗法式でなく)ただの単位か、 1に等しい量とただの単位である単位の文字通り次元式であるような 変換を表現する必要があります。 この限定は将来のバージョンで緩和されるかもしれません。

  `known_unit_conversions`は既知の単位変換のリストです。

  `load("ezunits")`はこの関数をロードします。

  例:

  乗法項の等式で表現された単位変換。

      (%i1) load ("ezunits")$
      (%i2) declare_unit_conversion (nautical_mile = 1852 * m,
                                     fortnight = 14 * day);
      (%o2)                         done
      (%i3) 100 ` nautical_mile / fortnight `` m/s;
      Computing conversions to base units; may take a moment.
                                  463    m
      (%o3)                       ---- ` -
                                  3024   s

  文字通り次元式の等式で表現された単位変換。

      (%i1) load ("ezunits")$
      (%i2) declare_unit_conversion (1 ` fluid_ounce = 2 ` tablespoon);
      (%o2)                         done
      (%i3) declare_unit_conversion (1 ` tablespoon = 3 ` teaspoon);
      (%o3)                         done
      (%i4) 15 ` fluid_ounce `` teaspoon;
      Computing conversions to base units; may take a moment.
      (%o4)                     90 ` teaspoon

  Package ezunits ·

関数: declare_dimensions (a_1, d_1, ..., a_n, d_n)
関数: remove_dimensions (a_1, ..., a_n)

  `declare_dimensions`は a_1, ..., a_nを それぞれ、次元d_1, ..., d_nを持つと 宣言します。

  a_kそれぞれはシンボルかシンボルのリストです。 もしリストなら、a_k内のすべてのシンボルは 次元 d_kを持つように宣言されます。

  `remove_dimensions`は `declare_dimensions`の効果を戻します。

  `load("ezunits")`はこれらの関数をロードします。

  例:

      (%i1) load ("ezunits") $
      (%i2) declare_dimensions ([x, y, z], length, [t, u], time);
      (%o2)                         done
      (%i3) dimensions (y^2/u);
                                         2
                                   length
      (%o3)                        -------
                                    time
      (%i4) fundamental_units (y^2/u);
      0 errors, 0 warnings
                                      2
                                     m
      (%o4)                          --
                                     s

  Package ezunits ·

関数: declare_fundamental_dimensions (d_1, d_2, d_3, ...)
関数: remove_fundamental_dimensions (d_1, d_2, d_3, ...)
グローバル変数: fundamental_dimensions

  `declare_fundamental_dimensions`は基本次元を宣言します。 シンボル d_1, d_2, d_3, ... は、 もしそれらがまだリストの中にないなら、基本次元のリストに追加されます。

  `remove_fundamental_dimensions`は `declare_fundamental_dimensions`の効果を戻します。

  `fundamental_dimensions`は基本次元のリストです。 デフォルトでは、リストはいくつかの物理次元から成ります。

  `load("ezunits")`はこれらの関数をロードします。

  例:

      (%i1) load ("ezunits") $
      (%i2) fundamental_dimensions;
      (%o2) [length, mass, time, current, temperature, quantity]
      (%i3) declare_fundamental_dimensions (money, cattle, happiness);
      (%o3)                         done
      (%i4) fundamental_dimensions;
      (%o4) [length, mass, time, current, temperature, quantity,
                                              money, cattle, happiness]
      (%i5) remove_fundamental_dimensions (cattle, happiness);
      (%o5)                         done
      (%i6) fundamental_dimensions;
      (%o6) [length, mass, time, current, temperature, quantity, money]

  Package ezunits ·

関数: declare_fundamental_units (u_1, d_1, ..., u_n, d_n)
関数: remove_fundamental_units (u_1, ..., u_n)

  `declare_fundamental_units`は u_1, ..., u_nを それぞれ、次元d_1, ..., d_nを持つように宣言します。 引数すべてはシンボルでなければいけません。

  `declare_fundamental_units`をコールした後、 `dimensions(u_k)`は 引数u_1, ..., u_nそれぞれに対して d_kを返し、 `fundamental_units(d_k)`は 引数d_1, ..., d_nそれぞれに対して u_kを返します。

  `remove_fundamental_units`は `declare_fundamental_units`の効果を戻します。

  `load("ezunits")`はこれらの関数をロードします。

  例:

      (%i1) load ("ezunits") $
      (%i2) declare_fundamental_dimensions (money, cattle, happiness);
      (%o2)                         done
      (%i3) declare_fundamental_units (dollar, money, goat, cattle, smile, happiness);
      (%o3)                 [dollar, goat, smile]
      (%i4) dimensions (100 ` dollar/goat/km^2);
                                   money
      (%o4)                    --------------
                                            2
                               cattle length
      (%i5) dimensions (x ` smile/kg);
                                  happiness
      (%o5)                       ---------
                                    mass
      (%i6) fundamental_units (money*cattle/happiness);
      0 errors, 0 warnings
                                 dollar goat
      (%o6)                      -----------
                                    smile

  Package ezunits ·

関数: dimensions (x)
関数: dimensions_as_list (x)

  `dimensions`は 基礎次元の積と冪で構成された式として 次元量xの次元を返します。

  `dimensions_as_list`は それぞれの要素がxの次元に関して対応する基礎次元の冪を示す整数であるようなリストとして次元量xの次元を返します。

  `load("ezunits")`はこれらの関数をロードします。

  例:

      (%i1) load ("ezunits")$
      (%i2) dimensions (1000 ` kg*m^2/s^3);
                                      2
                                length  mass
      (%o2)                     ------------
                                       3
                                   time
      (%i3) declare_units (foo, acre*ft/hour);
                                   acre ft
      (%o3)                        -------
                                    hour
      (%i4) dimensions (foo);
                                         3
                                   length
      (%o4)                        -------
                                    time

      (%i1) load ("ezunits")$
      (%i2) fundamental_dimensions;
      (%o2)  [length, mass, time, charge, temperature, quantity]
      (%i3) dimensions_as_list (1000 ` kg*m^2/s^3);
      (%o3)                 [2, 1, - 3, 0, 0, 0]
      (%i4) declare_units (foo, acre*ft/hour);
                                   acre ft
      (%o4)                        -------
                                    hour
      (%i5) dimensions_as_list (foo);
      (%o5)                 [3, 0, - 1, 0, 0, 0]

  Package ezunits ·

関数: fundamental_units (x)
関数: fundamental_units ()

  `fundamental_units(x)`は `dimensions(x)`が決定するように xの基本次元に関連付けられた 単位を返します。

  xは文字通り次元式a ` bか、 `declare_units`を介して宣言された単位を持つシンボルか それらのいずれかもしくは両方を含む式かもしれません。

  `fundamental_units()`は `declare_fundamental_units`が宣言するように、 既知の基本単位すべてのリストを返します。

  `load("ezunits")`はこの関数をロードします。

  例:

      (%i1) load ("ezunits")$
      (%i2) fundamental_units ();
      (%o2)                 [m, kg, s, A, K, mol]
      (%i3) fundamental_units (100 ` mile/hour);
                                      m
      (%o3)                           -
                                      s
      (%i4) declare_units (aa, g/foot^2);
                                      g
      (%o4)                         -----
                                        2
                                    foot
      (%i5) fundamental_units (aa);
                                     kg
      (%o5)                          --
                                      2
                                     m

  Package ezunits ·

関数: dimensionless (L)

  次元量のリストLから形成できる 無次元量の基底を返します。

  `load("ezunits")`はこの関数をロードします。

  例:

      (%i1) load ("ezunits") $
      (%i2) dimensionless ([x ` m, y ` m/s, z ` s]);
      0 errors, 0 warnings
      0 errors, 0 warnings
                                     y z
      (%o2)                         [---]
                                      x

  Dimensionless quantities derived from fundamental physical quantities. Note that the first element on the list is proportional to the fine-structure constant.

      (%i1) load ("ezunits") $
      (%i2) load ("physical_constants") $
      (%i3) dimensionless([%h_bar, %m_e, %m_P, %%e, %c, %e_0]);
      0 errors, 0 warnings
      0 errors, 0 warnings
                                    2
                                 %%e        %m_e
      (%o3)                [--------------, ----]
                            %c %e_0 %h_bar  %m_P

  Package ezunits ·

関数: natural_unit (expr, [v_1, ..., v_n])

  `dimension(expr) = dimension(v_1^e_1 ... v_n^e_n)`であるような 指数e_1, ..., e_nを見つけます。

  `load("ezunits")`はこの関数をロードします。

  例:

  Package ezunits ·

Next: finance, Previous: ezunits, Up: Top [Contents][Index]

## 52 f90

Previous: f90, Up: f90 [Contents][Index]

### 52.1 Functions and Variables for f90

関数: f90 (expr_1, ..., expr_n)

  １つ以上の式expr_1, ..., expr_nを Fortran 90プログラムとして印字します。 出力は標準出力に印字されます。

  `f90`は Fortran 90のいわゆる「自由形式」入力フォーマットで出力を印字します: 列位置に特別な注意はありません。 長い行は、 アンパサンド`&`継続文字で固定幅に分割されます。

  `load("f90")`はこの関数をロードします。

  例:

      (%i1) load ("f90")$
      (%i2) foo : expand ((xxx + yyy + 7)^4);
               4            3         3        2    2             2
      (%o2) yyy  + 4 xxx yyy  + 28 yyy  + 6 xxx  yyy  + 84 xxx yyy
                2        3             2
       + 294 yyy  + 4 xxx  yyy + 84 xxx  yyy + 588 xxx yyy + 1372 yyy
            4         3          2
       + xxx  + 28 xxx  + 294 xxx  + 1372 xxx + 2401
      (%i3) f90 ('foo = foo);
      foo = yyy**4+4*xxx*yyy**3+28*yyy**3+6*xxx**2*yyy**2+84*xxx*yyy**2&
      +294*yyy**2+4*xxx**3*yyy+84*xxx**2*yyy+588*xxx*yyy+1372*yyy+xxx**&
      4+28*xxx**3+294*xxx**2+1372*xxx+2401
      (%o3)                         false

  複数式。 `with_stdout`関数を介して標準出力をファイルにとらえます。

      (%i1) load ("f90")$
      (%i2) foo : sin (3*x + 1) - cos (7*x - 2);
      (%o2)              sin(3 x + 1) - cos(7 x - 2)
      (%i3) with_stdout ("foo.f90",
                         f90 (x = 0.25, y = 0.625, 'foo = foo, 'stop, 'end));
      (%o3)                         false
      (%i4) printfile ("foo.f90");
      x = 0.25
      y = 0.625
      foo = sin(3*x+1)-cos(7*x-2)
      stop
      end
      (%o4)                        foo.f90

  Translation and compilation ·Share packages ·Package f90 ·

Next: fractals, Previous: f90, Up: Top [Contents][Index]

## 53 finance

Next: Functions and Variables for finance, Previous: finance, Up: finance [Contents][Index]

### 53.1 Introduction to finance

これは金融パッケージ(第0.1版)です。

すべての関数において、 rateは複利率であり、 numは期間で正でなくてはいけません。 また、flowはキャッシュフローを示すので、 産出はフローが負になり、投入は正になります。

このパッケージで定義された関数を使う前に、 `load("finance")$`と書いてパッケージをロードしなければいけないことに 注意してください。

著者: Nicolas Guarin Zapata.

Previous: Introduction to finance, Up: finance [Contents][Index]

### 53.2 Functions and Variables for finance

関数: days360 (year1,month1,day1,year2,month2,day2)

  2つの日付の距離を、 1年が360日、1月は30日と仮定して計算します。

  例:

      (%i1) load("finance")$
      (%i2) days360(2008,12,16,2007,3,25);
      (%o2)                      - 621

  Package finance ·

関数: fv (rate,PV,num)

  ある利率を与えられたとして、現在価値の将来価値を計算します。 rateは利率で、PVは現在価値、 numは期間です。

  例:

      (%i1) load("finance")$
      (%i2) fv(0.12,1000,3);
      (%o2)                     1404.928

  Package finance ·

関数: pv (rate,FV,num)

  ある利率を与えられたとして、将来価値の現在価値を計算します。 rateは利率で、PVは現在価値、 numは期間です。

  例:

      (%i1) load("finance")$
      (%i2) pv(0.12,1000,3);
      (%o2)                711.7802478134108

  Package finance ·

関数: graph_flow (val)

  時間順でマネーフローを、 正の値は青で上に、負の値は赤で下に プロットします。 フローの向きは値の符号で与えられます。 valはフローの値のリストです。

  例:

      (%i1) load("finance")$
      (%i2) graph_flow([-5000,-3000,800,1300,1500,2000])$

  Package finance ·

関数: annuity_pv (rate,PV,num)

  (総額のような)現在価値がわかっている年金を計算できます。 年金は一定で定期払いです。 rateは利率で、PVは現在価値、 numは期間です。

  例:

      (%i1) load("finance")$
      (%i2) annuity_pv(0.12,5000,10);
      (%o2)                884.9208207992202

  Package finance ·

関数: annuity_fv (rate,FV,num)

  要望価値(将来価値)がわかっている年金を計算できます。 年金は一定で定期払いです。 rateは利率で、PVは将来価値、 numは期間です。

  例:

      (%i1) load("finance")$
      (%i2) annuity_fv(0.12,65000,10);
      (%o2)                3703.970670389863

  Package finance ·

関数: geo_annuity_pv (rate,growing_rate,PV,num)

  (総額のような)現在価値がわかっている年金を計算できます。 年金は割増定期払いです。 rateは利率で、growing_rateは成長率、 PVは現在価値、numは期間です。

  例:

      (%i1) load("finance")$
      (%i2) geo_annuity_pv(0.14,0.05,5000,10);
      (%o2)                802.6888176505123

  Package finance ·

関数: geo_annuity_fv (rate,growing_rate,FV,num)

  要望価値(将来価値)がわかっている年金を計算できます。 年金は割増定期払いです。 rateは利率で、growing_rateは成長率、 FVは将来価値、numは期間です。

  例:

      (%i1) load("finance")$
      (%i2) geo_annuity_fv(0.14,0.05,5000,10);
      (%o2)                216.5203395312695

  Package finance ·

関数: amortization (rate,ammount,num)

  特定率で決定された償却表。 rateは利率で、ammountは総価値、 numは期間です。

  例:

      (%i1) load("finance")$
      (%i2) amortization(0.05,56000,12)$
            "n"    "Balance"     "Interest"   "Amortization"  "Payment"
           0.000     56000.000         0.000         0.000         0.000
           1.000     52481.777      2800.000      3518.223      6318.223
           2.000     48787.643      2624.089      3694.134      6318.223
           3.000     44908.802      2439.382      3878.841      6318.223
           4.000     40836.019      2245.440      4072.783      6318.223
           5.000     36559.597      2041.801      4276.422      6318.223
           6.000     32069.354      1827.980      4490.243      6318.223
           7.000     27354.599      1603.468      4714.755      6318.223
           8.000     22404.106      1367.730      4950.493      6318.223
           9.000     17206.088      1120.205      5198.018      6318.223
          10.000     11748.170       860.304      5457.919      6318.223
          11.000      6017.355       587.408      5730.814      6318.223
          12.000         0.000       300.868      6017.355      6318.223

  Package finance ·

関数: arit_amortization (rate,increment,ammount,num)

  `arit_amortization`によって、特定率で決定された割増払いの償却表を計算することができます。 支払いは一定ではなく、算術級数的成長を示し、 増分は"Payment"列の連続する2行の差であることに注意してください。 rateは利率で、incrementは増分、ammountは総価値、 numは期間です。

  例:

      (%i1) load("finance")$
      (%i2) arit_amortization(0.05,1000,56000,12)$
            "n"    "Balance"     "Interest"   "Amortization"  "Payment"
           0.000     56000.000         0.000         0.000         0.000
           1.000     57403.679      2800.000     -1403.679      1396.321
           2.000     57877.541      2870.184      -473.863      2396.321
           3.000     57375.097      2893.877       502.444      3396.321
           4.000     55847.530      2868.755      1527.567      4396.321
           5.000     53243.586      2792.377      2603.945      5396.321
           6.000     49509.443      2662.179      3734.142      6396.321
           7.000     44588.594      2475.472      4920.849      7396.321
           8.000     38421.703      2229.430      6166.892      8396.321
           9.000     30946.466      1921.085      7475.236      9396.321
          10.000     22097.468      1547.323      8848.998     10396.321
          11.000     11806.020      1104.873     10291.448     11396.321
          12.000        -0.000       590.301     11806.020     12396.321

  Package finance ·

関数: geo_amortization (rate,growing_rate,ammount,num)

  `geo_amortization`によって、ある率、ある総額、ある期間で決定された償却表を見つけることができます。

  支払いは一定ではなく、幾何級数的成長を示し、 growing_rateは"Payment"列の連続する2行の比率であることに注意してください。 rateは利率で、ammountは総価値、 numは期間です。

  例:

      (%i1) load("finance")$
      (%i2) geo_amortization(0.05,0.03,56000,12)$
            "n"    "Balance"     "Interest"   "Amortization"  "Payment"
           0.000     56000.000         0.000         0.000         0.000
           1.000     53365.296      2800.000      2634.704      5434.704
           2.000     50435.816      2668.265      2929.480      5597.745
           3.000     47191.930      2521.791      3243.886      5765.677
           4.000     43612.879      2359.596      3579.051      5938.648
           5.000     39676.716      2180.644      3936.163      6116.807
           6.000     35360.240      1983.836      4316.475      6300.311
           7.000     30638.932      1768.012      4721.309      6489.321
           8.000     25486.878      1531.947      5152.054      6684.000
           9.000     19876.702      1274.344      5610.176      6884.520
          10.000     13779.481       993.835      6097.221      7091.056
          11.000      7164.668       688.974      6614.813      7303.787
          12.000         0.000       358.233      7164.668      7522.901

  Package finance ·

関数: saving (rate,ammount,num)

  `saving`によって、定額預金での価値を表すテーブルを見つけることができます。 ammountは要望量を、numは預金の期間を表します。

  例:

      (%i1) load("finance")$
      (%i2) saving(0.15,12000,15)$
            "n"    "Balance"     "Interest"   "Payment"
           0.000         0.000         0.000         0.000
           1.000       252.205         0.000       252.205
           2.000       542.240        37.831       252.205
           3.000       875.781        81.336       252.205
           4.000      1259.352       131.367       252.205
           5.000      1700.460       188.903       252.205
           6.000      2207.733       255.069       252.205
           7.000      2791.098       331.160       252.205
           8.000      3461.967       418.665       252.205
           9.000      4233.467       519.295       252.205
          10.000      5120.692       635.020       252.205
          11.000      6141.000       768.104       252.205
          12.000      7314.355       921.150       252.205
          13.000      8663.713      1097.153       252.205
          14.000     10215.474      1299.557       252.205
          15.000     12000.000      1532.321       252.205

  Package finance ·

関数: npv (rate,val)

  プロジェクトに関する存続可能性を評価するために、価値系列の正味現在価値を計算します。 flowValues es una lista con los valores para cada periodo.

  例:

      (%i1) load("finance")$
      (%i2) npv(0.25,[100,500,323,124,300]);
      (%o2)                714.4703999999999

  Package finance ·

関数: irr (val,IO)

  IRR (内部利益率)は正味現在価値をゼロにする割引率の値です。 flowValues los valores para cada periodo (para periodos mayores a 0) y I0 el valor para el periodo cero.

  例:

      (%i1) load("finance")$
      (%i2) res:irr([-5000,0,800,1300,1500,2000],0)$
      (%i3) rhs(res[1][1]);
      (%o3)                .03009250374237132

  Package finance ·

関数: benefit_cost (rate,input,output)

  便益コスト比を計算します。 便益は投入の正味現在価値(NPV)で、 コストは産出の正味現在価値(NPV)です。 もし特定の期間に関して投入価値か産出価値がゼロなら、 投入/産出比はその期間で0となることに注意してください。 rateは利率であり、 inputは投入価値のリスト、 outputは産出価値のリストです。

  例:

      (%i1) load("finance")$
      (%i2) benefit_cost(0.24,[0,300,500,150],[100,320,0,180]);
      (%o2)               1.427249324905784

  Package finance ·

Next: ggf, Previous: finance, Up: Top [Contents][Index]

## 54 fractals

Next: Definitions for IFS fractals, Previous: fractals, Up: fractals [Contents][Index]

### 54.1 Introduction to fractals

このパッケージはよく知られているフラクタルをいくつか定義します:

- ランダムIFS(反復函数系)を使って: Sierpinski三角形、木、シダ

- 複素フラクタル: MandelbrotとJulia集合

- Koch雪片集合

- Peano写像: SierpinskiとHilbert写像

著者: José Ramírez Labrador.

質問、提案、バグに関しては、 pepe DOT ramirez AAATTT uca DOT es まで、私に気兼ねせずコンタクトしてください。

Next: Definitions for complex fractals, Previous: Introduction to fractals, Up: fractals [Contents][Index]

### 54.2 Definitions for IFS fractals

いくつかのフラクタルは、 縮小アフィン変換をランダムに繰り返し適用することで生成することができます; Hoggar S. G., "Mathematics for computer graphics", Cambridge University Press 1994を参照してください。

いくつかの縮小アフィン変換のリストを定義して、 繰り返しの中で変換をランダムに選択します。 変換の選択の確率は縮小比に関係しなければいけません。

変換を変えて、別のフラクタルを見つけることができます。

関数: sierpinskiale (n)

  Sierpinski三角形: 3つの縮小写像; .5の縮小定数と変形; すべての写像は同じ縮小比です。 引数nは十分大きく、10000以上でなければいけません、

  例:

      (%i1) load("fractals")$
      (%i2) n: 10000$
      (%i3) plot2d([discrete,sierpinskiale(n)], [style,dots])$

  Package fractals ·

関数: treefale (n)

  すべて同じ縮小比を持つ3つの縮小写像。 引数nは十分大きく、10000以上でなければいけません、

  例:

      (%i1) load("fractals")$
      (%i2) n: 10000$
      (%i3) plot2d([discrete,treefale(n)], [style,dots])$

  Package fractals ·

関数: fernfale (n)

  変換を選択する確率が縮小比に関係する、4つの縮小写像。 引数nは十分大きく、10000以上でなければいけません、

  例:

      (%i1) load("fractals")$
      (%i2) n: 10000$
      (%i3) plot2d([discrete,fernfale(n)], [style,dots])$

  Package fractals ·

Next: Definitions for Koch snowflakes, Previous: Definitions for IFS fractals, Up: Top [Contents][Index]

### 54.3 Definitions for complex fractals

関数: mandelbrot_set (x, y)

  Mandelbrot集合。

  例:

  たくさんの演算を実行しなければいけないので、このプログラムは時間がかかります; 計算時間は格子点の数にも関係します。

      (%i1) load("fractals")$
      (%i2) plot3d (mandelbrot_set, [x, -2.5, 1], [y, -1.5, 1.5],
                      [gnuplot_preamble, "set view map"],
                      [gnuplot_pm3d, true],
                      [grid, 150, 150])$

  Package fractals ·

関数: julia_set (x, y)

  Julia集合。

  たくさんの演算を実行しなければいけないので、このプログラムは時間がかかります; 計算時間は格子点の数にも関係します。

  例:

      (%i1) load("fractals")$
      (%i2) plot3d (julia_set, [x, -2, 1], [y, -1.5, 1.5],
                      [gnuplot_preamble, "set view map"],
                      [gnuplot_pm3d, true],
                      [grid, 150, 150])$

  See also `julia_parameter`.

  Package fractals ·

オプション変数: julia_parameter

  デフォルト値: `%i`

  Juliaフラクタルの複素パラメータ。 デフォルト値は`%i`です; we suggest the values 値`-.745+%i*.113002`, `-.39054-%i*.58679`, `-.15652+%i*1.03225`, `-.194+%i*.6557`, `.011031-%i*.67037`を提案します。

  Package fractals ·

関数: julia_sin (x, y)

  関数`julia_set`が変換`julia_parameter+z^2`を実装する一方、 関数`julia_sin`は`julia_parameter*sin(z)`を実装します。 詳細はソースコードを参照してください。

  たくさんのsinを計算するので、このプログラムはゆっくり実行されます

  例:

  たくさんの演算を実行しなければいけないので、このプログラムは時間がかかります; 計算時間は格子点の数にも関係します。

      (%i1) load("fractals")$
      (%i2) julia_parameter:1+.1*%i$
      (%i3) plot3d (julia_sin, [x, -2, 2], [y, -3, 3],
                      [gnuplot_preamble, "set view map"],
                      [gnuplot_pm3d, true],
                      [grid, 150, 150])$

  See also `julia_parameter`.

  Package fractals ·

Next: Definitions for Peano maps, Previous: Definitions for complex fractals, Up: Top [Contents][Index]

### 54.4 Definitions for Koch snowflakes

関数: snowmap (ent, nn)

  Koch雪片集合。 関数`snowmap`は、 複素平面内の初期値の閉多角形の頂点上に雪Koch写像をプロットします。 ここで多角形の向きが重要です。 引数Argument nnはKoch変換の繰り返し適用の回数です; nnは小さく(5か6で)なければいけません。

  例:

      (%i1) load("fractals")$
      (%i2) plot2d([discrete,
                    snowmap([1,exp(%i*%pi*2/3),exp(-%i*%pi*2/3),1],4)])$
      (%i3) plot2d([discrete,
                    snowmap([1,exp(-%i*%pi*2/3),exp(%i*%pi*2/3),1],4)])$
      (%i4) plot2d([discrete, snowmap([0,1,1+%i,%i,0],4)])$
      (%i5) plot2d([discrete, snowmap([0,%i,1+%i,1,0],4)])$

  Package fractals ·

Previous: Definitions for Koch snowflakes, Up: fractals [Contents][Index]

### 54.5 Definitions for Peano maps

ある面積を覆う連続曲線。 警告: nと共に点の数は指数関数的に増加します。

関数: hilbertmap (nn)

  Hilbert写像。 nnは小さく(例えば5で)なければいけません。 もし7以上ならMaximaはクラッシュするかもしれません。

  例:

      (%i1) load("fractals")$
      (%i2) plot2d([discrete,hilbertmap(6)])$

  Package fractals ·

関数: sierpinskimap (nn)

  Sierpinski写像。 nnは小さく(例えば5で)なければいけません。 もし7以上ならMaximaはクラッシュするかもしれません。

  例:

      (%i1) load("fractals")$
      (%i2) plot2d([discrete,sierpinskimap(6)])$

  Package fractals ·

Next: graphs, Previous: fractals, Up: Top [Contents][Index]

## 55 ggf

Previous: ggf, Up: ggf [Contents][Index]

### 55.1 Functions and Variables for ggf

オプション変数: GGFINFINITY

  デフォルト値: 3

  これは関数`ggf`のオプション変数です。

  母関数の連分数を計算する時、 (厳密に)GGFINFINITYより大きな次数を持つ 部分商は捨てられます。 現在のコンバージェントは母関数の正確な値として考えられます; 部分商すべての次数はたいてい0か1です; もしより大きな値を使うなら、 十分精度の高い計算を行うために十分な項を与えるべきです。

  `ggf`も参照してください。

  Package ggf ·

オプション変数: GGFCFMAX

  デフォルト値: 3

  これは 関数`ggf`のオプション変数です。

  母関数の連分数を計算する時、 もし GGFCFMAX個の部分商を計算した後、よい結果が見つからないなら (GGFINFINITYフラグを参照してください)、 母関数は２つの多項式の分数でないように考えられ、 関数は抜けます。 もっと複雑な母関数のためにより大きな値を自由に入れてください。

  `ggf`も参照してください。

  Package ggf ·

関数: ggf (l)

  (もし母関数が２つの多項式の分数なら) 与えられた最初の数項に対する、 数列の母関数を計算します。 lは数のリストです。

  解は２つの多項式の分数として返されます。 解が見つからなかったら、`done`を返します。

  この関数は グローバル変数GGFINFINITYとGGFCFMAXで制御されます。 GGFINFINITYとGGFCFMAXも参照してください。

  この関数を使うには、最初に`load("ggf")`を書いてください。

  Generating functions ·Share packages ·Package ggf ·

Next: grobner, Previous: ggf, Up: Top [Contents][Index]

## 56 graphs

Next: Functions and Variables for graphs, Previous: graphs, Up: graphs [Contents][Index]

### 56.1 Introduction to graphs

`graphs`パッケージはMaximaにグラフと有向グラフデータ構造を提供します。 有向グラフはuからvへの有向辺とvからuへの有向辺を持つことができますが、グラフや有向グラフは単純です(多重辺もループも持ちません)。

内部的にはグラフは隣接リストで表現され、 lisp構造として実装されます。 頂点はそれらのid(idは整数)で識別されます。 辺/弧は長さ2のリストで表現されます。 グラフ/有向グラフの頂点にラベルを割り当てることができ、 グラフ/有向グラフの辺/弧に重みを割り当てることができます。

グラフを描画するためのの`draw_graph`関数があります。 グラフはforce based 頂点配置アルゴリズムを使って描画されます。 `draw_graph`は http://www.graphviz.orgから利用可能なgraphvizプログラムを使うこともできます。 `draw_graph`はMaxima `draw`パッケージに基づいています。

`graphs`パッケージを使うには、 最初に`load("graphs")`でロードしてください。

Share packages ·Package graphs ·

Previous: Introduction to graphs, Up: graphs [Contents][Index]

### 56.2 Functions and Variables for graphs

#### 56.2.1 Building graphs

関数: create_graph (v_list, e_list)
関数: create_graph (n, e_list)
関数: create_graph (v_list, e_list, directed)

  頂点の集合v_list上に辺e_listを使って新しいグラフを生成します。

  v_listは頂点のリスト(`[v1, v2,..., vn]`)もしくは 頂点ラベルを持つ頂点のリスト(`[[v1,l1], [v2,l2],..., [vn,ln]]`)です。

  nは頂点の数です。 頂点は0からn-1までの整数で識別されます。 (訳注: 1から始まるMaximaのリストの添字の慣例とは異なることに注意してください。)

  e_listは辺のリスト(`[e1, e2,..., em]`)もしくは 辺の重みを持つ辺のリスト(`[[e1, w1], ..., [em, wm]]`)です。

  もしdirectedが`false`でないなら、 有向グラフが返されます。

  例1: 頂点3つの循環を生成する。

      (%i1) load ("graphs")$
      (%i2) g : create_graph([1,2,3], [[1,2], [2,3], [1,3]])$
      (%i3) print_graph(g)$
      Graph on 3 vertices with 3 edges.
      Adjacencies:
        3 :  1  2
        2 :  3  1
        1 :  3  2

  例2: 辺の重みを持つ頂点3つの循環を生成する。

      (%i1) load ("graphs")$
      (%i2) g : create_graph([1,2,3], [[[1,2], 1.0], [[2,3], 2.0],
                                [[1,3], 3.0]])$
      (%i3) print_graph(g)$
      Graph on 3 vertices with 3 edges.
      Adjacencies:
        3 :  1  2
        2 :  3  1
        1 :  3  2

  例3: 有向グラフを生成する:

      (%i1) load ("graphs")$
      (%i2) d : create_graph(
              [1,2,3,4],
              [
               [1,3], [1,4],
               [2,3], [2,4]
              ],
              'directed = true)$
      (%i3) print_graph(d)$
      Digraph on 4 vertices with 4 arcs.
      Adjacencies:
        4 :
        3 :
        2 :  4  3
        1 :  4  3

  Package graphs ·

関数: copy_graph (g)

  グラフgのコピーを返します。

  Package graphs ·Package graphs - constructions ·

関数: circulant_graph (n, d)

  パラメータ nと dを持つ巡回グラフを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : circulant_graph(10, [1,3])$
      (%i3) print_graph(g)$
      Graph on 10 vertices with 20 edges.
      Adjacencies:
        9 :  2  6  0  8
        8 :  1  5  9  7
        7 :  0  4  8  6
        6 :  9  3  7  5
        5 :  8  2  6  4
        4 :  7  1  5  3
        3 :  6  0  4  2
        2 :  9  5  3  1
        1 :  8  4  2  0
        0 :  7  3  9  1

  Package graphs ·Package graphs - constructions ·

関数: clebsch_graph ()

  Clebschグラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: complement_graph (g)

  グラフ gの補グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: complete_bipartite_graph (n, m)

  n+mこの頂点上の完全2部グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: complete_graph (n)

  nこの頂点上の完全グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: cycle_digraph (n)

  n個の頂点上の有向グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: cycle_graph (n)

  nこの頂点上の閉路を返します。

  Package graphs ·Package graphs - constructions ·

関数: cuboctahedron_graph (n)

  立方八面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: cube_graph (n)

  n次元立方体を返します。

  Package graphs ·Package graphs - constructions ·

関数: dodecahedron_graph ()

  十二面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: empty_graph (n)

  n個の頂点上の空グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: flower_snark (n)

  4n個の頂点上の花グラフを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) f5 : flower_snark(5)$
      (%i3) chromatic_index(f5);
      (%o3)                           4

  Package graphs ·Package graphs - constructions ·

関数: from_adjacency_matrix (A)

  隣接行列 Aで表現されるグラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: frucht_graph ()

  Fruchtグラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: graph_product (g1, g1)

  グラフ g1と g2の直積を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) grid : graph_product(path_graph(3), path_graph(4))$
      (%i3) draw_graph(grid)$

  Package graphs ·Package graphs - constructions ·

関数: graph_union (g1, g1)

  グラフg1と g2の和を返します。

  Package graphs ·Package graphs - constructions ·

関数: grid_graph (n, m)

  n x mグリッドを返します。

  Package graphs ·Package graphs - constructions ·

関数: great_rhombicosidodecahedron_graph ()

  大菱形二十・十二面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: great_rhombicuboctahedron_graph ()

  大斜方立方八面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: grotzch_graph ()

  Grotzchグラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: heawood_graph ()

  Heawoodグラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: icosahedron_graph ()

  二十面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: icosidodecahedron_graph ()

  二十・十二面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: induced_subgraph (V, g)

  グラフ gの頂点の部分集合 V上の誘導部分グラフを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : petersen_graph()$
      (%i3) V : [0,1,2,3,4]$
      (%i4) g : induced_subgraph(V, p)$
      (%i5) print_graph(g)$
      Graph on 5 vertices with 5 edges.
      Adjacencies:
        4 :  3  0
        3 :  2  4
        2 :  1  3
        1 :  0  2
        0 :  1  4

  Package graphs ·Package graphs - constructions ·

関数: line_graph (g)

  グラフ gの折れ線グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: make_graph (vrt, f)
関数: make_graph (vrt, f, oriented)

  述語論理関数 fを使ってグラフを生成します。

  vrtは頂点か整数のリスト/集合です。 もし vrtが整数なら、 グラフの頂点は1から vrtまでの整数です。

  fは述語論理関数です。 2つの頂点 aと bは もし `f(a,b)=true`なら結合されます。

  もし directedが falseでないなら、 グラフは有向です。

  例 1:

      (%i1) load("graphs")$
      (%i2) g : make_graph(powerset({1,2,3,4,5}, 2), disjointp)$
      (%i3) is_isomorphic(g, petersen_graph());
      (%o3)                         true
      (%i4) get_vertex_label(1, g);
      (%o4)                        {1, 2}

  例 2:

      (%i1) load("graphs")$
      (%i2) f(i, j) := is (mod(j, i)=0)$
      (%i3) g : make_graph(20, f, directed=true)$
      (%i4) out_neighbors(4, g);
      (%o4)                    [8, 12, 16, 20]
      (%i5) in_neighbors(18, g);
      (%o5)                    [1, 2, 3, 6, 9]

  Package graphs ·Package graphs - constructions ·

関数: mycielski_graph (g)

  グラフ gのMycielskiグラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: new_graph ()

  頂点も辺も持たないグラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: path_digraph (n)

  n個の頂点上の有向道を返します。

  Package graphs ·Package graphs - constructions ·

関数: path_graph (n)

  n個の頂点上の道を返します。

  Package graphs ·Package graphs - constructions ·

関数: petersen_graph ()
関数: petersen_graph (n, d)

  Petersenグラフ P_{n,d}を返します。 nと dのデフォルト値は `n=5`と `d=2`です。

  Package graphs ·Package graphs - constructions ·

関数: random_bipartite_graph (a, b, p)

  `a+b`個の頂点上のランダムな2部グラフを返します。 辺それぞれは確率 pで存在します。

  Package graphs ·Package graphs - constructions ·

関数: random_digraph (n, p)

  `n`個の頂点上のランダムな有向グラフを返します。 弧それぞれは確率 pで存在します。

  Package graphs ·Package graphs - constructions ·

関数: random_regular_graph (n)
関数: random_regular_graph (n, d)

  n個の頂点上の ランダムなd正則グラフを返します。 dのデフォルト値は `d=3`です。

  Package graphs ·Package graphs - constructions ·

関数: random_graph (n, p)

  n個の頂点上のランダムグラフを返します。 辺それぞれは確率 pで存在します。

  Package graphs ·Package graphs - constructions ·

関数: random_graph1 (n, m)

  n個の頂点とランダムな m個の辺上のランダムグラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: random_network (n, p, w)

  n個の頂点上のランダムネットワークを返します。 弧それぞれは確率 pで存在し、 範囲 `[0,w]`の中に重みを持ちます。 関数はリスト `[network, source, sink]`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) [net, s, t] : random_network(50, 0.2, 10.0);
      (%o2)                   [DIGRAPH, 50, 51]
      (%i3) max_flow(net, s, t)$
      (%i4) first(%);
      (%o4)                   27.65981397932507

  Package graphs ·Package graphs - constructions ·

関数: random_tournament (n)

  n個の頂点上のランダムなトーナメントを返します。

  Package graphs ·Package graphs - constructions ·

関数: random_tree (n)

  n個の頂点上のランダムな木を返します。

  Package graphs ·Package graphs - constructions ·

関数: small_rhombicosidodecahedron_graph ()

  斜方二十・十二面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: small_rhombicuboctahedron_graph ()

  斜方立方八面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: snub_cube_graph ()

  変形立方体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: snub_dodecahedron_graph ()

  変形十二面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: truncated_cube_graph ()

  切頂六面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: truncated_dodecahedron_graph ()

  切頂十二面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: truncated_icosahedron_graph ()

  切頂二十面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: truncated_tetrahedron_graph ()

  切頂四面体グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: tutte_graph ()

  Tutteグラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: underlying_graph (g)

  有向グラフ gの台グラフを返します。

  Package graphs ·Package graphs - constructions ·

関数: wheel_graph (n)

  n+1個の頂点上の車輪グラフを返します。

  Package graphs ·Package graphs - constructions ·

#### 56.2.2 Graph properties

関数: adjacency_matrix (gr)

  グラフ grの隣接行列を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) c5 : cycle_graph(4)$
      (%i3) adjacency_matrix(c5);
                               [ 0  1  0  1 ]
                               [            ]
                               [ 1  0  1  0 ]
      (%o3)                    [            ]
                               [ 0  1  0  1 ]
                               [            ]
                               [ 1  0  1  0 ]

  Package graphs ·Package graphs - properties ·

関数: average_degree (gr)

  グラフ grに関する平均次数を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) average_degree(grotzch_graph());
                                     40
      (%o2)                          --
                                     11

  Package graphs ·Package graphs - properties ·

関数: biconnected_components (gr)

  グラフ grの2連結成分(の頂点集合)を返します

  例:

      (%i1) load ("graphs")$
      (%i2) g : create_graph(
                  [1,2,3,4,5,6,7],
                  [
                   [1,2],[2,3],[2,4],[3,4],
                   [4,5],[5,6],[4,6],[6,7]
                  ])$
      (%i3) biconnected_components(g);
      (%o3)        [[6, 7], [4, 5, 6], [1, 2], [2, 3, 4]]

  Package graphs ·Package graphs - properties ·

関数: bipartition (gr)

  グラフ grの頂点の2分割か、もし grが2部でないなら空のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) h : heawood_graph()$
      (%i3) [A,B]:bipartition(h);
      (%o3)  [[8, 12, 6, 10, 0, 2, 4], [13, 5, 11, 7, 9, 1, 3]]
      (%i4) draw_graph(h, show_vertices=A, program=circular)$

  Package graphs ·Package graphs - properties ·

関数: chromatic_index (gr)

  グラフ grの彩色指数を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : petersen_graph()$
      (%i3) chromatic_index(p);
      (%o3)                           4

  Package graphs ·Package graphs - properties ·

関数: chromatic_number (gr)

  グラフ grの彩色数を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) chromatic_number(cycle_graph(5));
      (%o2)                           3
      (%i3) chromatic_number(cycle_graph(6));
      (%o3)                           2

  Package graphs ·Package graphs - properties ·

関数: clear_edge_weight (e, gr)

  グラフ grの辺 eの重みを削除します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : create_graph(3, [[[0,1], 1.5], [[1,2], 1.3]])$
      (%i3) get_edge_weight([0,1], g);
      (%o3)                          1.5
      (%i4) clear_edge_weight([0,1], g)$
      (%i5) get_edge_weight([0,1], g);
      (%o5)                           1

  Package graphs ·Package graphs - properties ·

関数: clear_vertex_label (v, gr)

  グラフ grの頂点 vのラベルを削除します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : create_graph([[0,"Zero"], [1, "One"]], [[0,1]])$
      (%i3) get_vertex_label(0, g);
      (%o3)                         Zero
      (%i4) clear_vertex_label(0, g);
      (%o4)                         done
      (%i5) get_vertex_label(0, g);
      (%o5)                         false

  Package graphs ·Package graphs - properties ·

関数: connected_components (gr)

  グラフ grの連携成分(の頂点集合)を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g: graph_union(cycle_graph(5), path_graph(4))$
      (%i3) connected_components(g);
      (%o3)            [[1, 2, 3, 4, 0], [8, 7, 6, 5]]

  Package graphs ·Package graphs - properties ·

関数: diameter (gr)

  グラフ grの直径を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) diameter(dodecahedron_graph());
      (%o2)                           5

  Package graphs ·Package graphs - properties ·

関数: edge_coloring (gr)

  グラフ grの辺の最適色づけを返します。

  関数は彩色指数とgrの辺の色付けを表すリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : petersen_graph()$
      (%i3) [ch_index, col] : edge_coloring(p);
      (%o3) [4, [[[0, 5], 3], [[5, 7], 1], [[0, 1], 1], [[1, 6], 2],
      [[6, 8], 1], [[1, 2], 3], [[2, 7], 4], [[7, 9], 2], [[2, 3], 2],
      [[3, 8], 3], [[5, 8], 2], [[3, 4], 1], [[4, 9], 4], [[6, 9], 3],
      [[0, 4], 2]]]
      (%i4) assoc([0,1], col);
      (%o4)                           1
      (%i5) assoc([0,5], col);
      (%o5)                           3

  Package graphs ·Package graphs - properties ·

関数: degree_sequence (gr)

  グラフ grの頂点次数のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) degree_sequence(random_graph(10, 0.4));
      (%o2)            [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]

  Package graphs ·Package graphs - properties ·

関数: edge_connectivity (gr)

  グラフ grの辺連結性を返します。

  `min_edge_cut`も参照してください。

  Package graphs ·Package graphs - properties ·

関数: edges (gr)

  (有向)グラフ grの辺(弧)のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) edges(complete_graph(4));
      (%o2)   [[2, 3], [1, 3], [1, 2], [0, 3], [0, 2], [0, 1]]

  Package graphs ·Package graphs - properties ·

関数: get_edge_weight (e, gr)
関数: get_edge_weight (e, gr, ifnot)

  グラフ grの辺 eの重みを返します。

  もし辺に割り当てられた重みがないなら、 関数は1を返します。 もし辺がグラフの中に存在しないなら、 関数はエラーをシグナルするか、オプション引数 ifnotを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) c5 : cycle_graph(5)$
      (%i3) get_edge_weight([1,2], c5);
      (%o3)                           1
      (%i4) set_edge_weight([1,2], 2.0, c5);
      (%o4)                         done
      (%i5) get_edge_weight([1,2], c5);
      (%o5)                          2.0

  Package graphs ·Package graphs - properties ·

関数: get_vertex_label (v, gr)

  グラフ grの頂点 vのラベルを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : create_graph([[0,"Zero"], [1, "One"]], [[0,1]])$
      (%i3) get_vertex_label(0, g);
      (%o3)                         Zero

  Package graphs ·Package graphs - properties ·

関数: graph_charpoly (gr, x)

  グラフ grの(変数 xに関する)特性多項式を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : petersen_graph()$
      (%i3) graph_charpoly(p, x), factor;
                                         5        4
      (%o3)               (x - 3) (x - 1)  (x + 2)

  Package graphs ·Package graphs - properties ·

関数: graph_center (gr)

  グラフ grの中心を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : grid_graph(5,5)$
      (%i3) graph_center(g);
      (%o3)                         [12]

  Package graphs ·Package graphs - properties ·

関数: graph_eigenvalues (gr)

  グラフ grの固有値を返します。 関数は maxima `eigenvalue`関数と同じフォーマットで固有値を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : petersen_graph()$
      (%i3) graph_eigenvalues(p);
      (%o3)               [[3, - 2, 1], [1, 4, 5]]

  Package graphs ·Package graphs - properties ·

関数: graph_periphery (gr)

  グラフ grの外周を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : grid_graph(5,5)$
      (%i3) graph_periphery(g);
      (%o3)                    [24, 20, 4, 0]

  Package graphs ·Package graphs - properties ·

関数: graph_size (gr)

  グラフ grの辺の数を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : petersen_graph()$
      (%i3) graph_size(p);
      (%o3)                          15

  Package graphs ·Package graphs - properties ·

関数: graph_order (gr)

  グラフ grの頂点の数を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : petersen_graph()$
      (%i3) graph_order(p);
      (%o3)                          10

  Package graphs ·Package graphs - properties ·

関数: girth (gr)

  grの最短閉路の長さを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : heawood_graph()$
      (%i3) girth(g);
      (%o3)                           6

  Package graphs ·Package graphs - properties ·

関数: hamilton_cycle (gr)

  グラフ grのHamilton閉路を返します。 もし grがハミルトニアンでないなら、空のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) c : cube_graph(3)$
      (%i3) hc : hamilton_cycle(c);
      (%o3)              [7, 3, 2, 6, 4, 0, 1, 5, 7]
      (%i4) draw_graph(c, show_edges=vertices_to_cycle(hc))$

  Package graphs ·Package graphs - properties ·

関数: hamilton_path (gr)

  グラフ grのHamilton経路を返します。 もし grがHamilton経路を持たないなら、空のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : petersen_graph()$
      (%i3) hp : hamilton_path(p);
      (%o3)            [0, 5, 7, 2, 1, 6, 8, 3, 4, 9]
      (%i4) draw_graph(p, show_edges=vertices_to_path(hp))$

  Package graphs ·Package graphs - properties ·

関数: isomorphism (gr1, gr2)

  グラフ/有向グラフ gr1と gr2の間の同型写像を返します。 もし gr1と gr2が同型でないなら、空のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) clk5:complement_graph(line_graph(complete_graph(5)))$
      (%i3) isomorphism(clk5, petersen_graph());
      (%o3) [9 -> 0, 2 -> 1, 6 -> 2, 5 -> 3, 0 -> 4, 1 -> 5, 3 -> 6,
                                                4 -> 7, 7 -> 8, 8 -> 9]

  Package graphs ·Package graphs - properties ·

関数: in_neighbors (v, gr)

  有向グラフ grの頂点 vの内隣接点のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : path_digraph(3)$
      (%i3) in_neighbors(2, p);
      (%o3)                          [1]
      (%i4) out_neighbors(2, p);
      (%o4)                          []

  Package graphs ·Package graphs - properties ·

関数: is_biconnected (gr)

  もし grが2連結なら `true`を、 そうでないなら、 `false`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) is_biconnected(cycle_graph(5));
      (%o2)                         true
      (%i3) is_biconnected(path_graph(5));
      (%o3)                         false

  Package graphs ·Package graphs - properties ·

関数: is_bipartite (gr)

  もし grが2部(2彩色)なら `true`を、 そうでないなら、 `false`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) is_bipartite(petersen_graph());
      (%o2)                         false
      (%i3) is_bipartite(heawood_graph());
      (%o3)                         true

  Package graphs ·Package graphs - properties ·

関数: is_connected (gr)

  もしグラフ grが連結なら `true`を、 そうでないなら `false`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) is_connected(graph_union(cycle_graph(4), path_graph(3)));
      (%o2)                         false

  Package graphs ·Package graphs - properties ·

関数: is_digraph (gr)

  もし grが有向グラフなら `true`を、 そうでないなら `false`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) is_digraph(path_graph(5));
      (%o2)                         false
      (%i3) is_digraph(path_digraph(5));
      (%o3)                         true

  Package graphs ·Package graphs - properties ·

関数: is_edge_in_graph (e, gr)

  もし eが(有向)グラフ gの辺(弧)なら `true`を、 そうでないなら `false`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) c4 : cycle_graph(4)$
      (%i3) is_edge_in_graph([2,3], c4);
      (%o3)                         true
      (%i4) is_edge_in_graph([3,2], c4);
      (%o4)                         true
      (%i5) is_edge_in_graph([2,4], c4);
      (%o5)                         false
      (%i6) is_edge_in_graph([3,2], cycle_digraph(4));
      (%o6)                         false

  Package graphs ·Package graphs - properties ·

関数: is_graph (gr)

  もし grがグラフなら `true`を、 そうでないなら `false`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) is_graph(path_graph(5));
      (%o2)                         true
      (%i3) is_graph(path_digraph(5));
      (%o3)                         false

  Package graphs ·Package graphs - properties ·

関数: is_graph_or_digraph (gr)

  もし grがグラフか有向グラフなら `true`を、 そうでないなら `false`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) is_graph_or_digraph(path_graph(5));
      (%o2)                         true
      (%i3) is_graph_or_digraph(path_digraph(5));
      (%o3)                         true

  Package graphs ·Package graphs - properties ·

関数: is_isomorphic (gr1, gr2)

  もし グラフ/有向グラフ gr1と gr2が同型なら `true`を、 そうでないなら `false`を返します。

  `isomorphism`も参照してください。

  例:

      (%i1) load ("graphs")$
      (%i2) clk5:complement_graph(line_graph(complete_graph(5)))$
      (%i3) is_isomorphic(clk5, petersen_graph());
      (%o3)                         true

  Package graphs ·Package graphs - properties ·

関数: is_planar (gr)

  もし grが平面グラフなら `true`を、 そうでないなら `false`を返します。

  使われているアルゴリズムはDemoucronのアルゴリズムです。 これは二次時間アルゴリズムです。

  例:

      (%i1) load ("graphs")$
      (%i2) is_planar(dodecahedron_graph());
      (%o2)                         true
      (%i3) is_planar(petersen_graph());
      (%o3)                         false
      (%i4) is_planar(petersen_graph(10,2));
      (%o4)                         true

  Package graphs ·Package graphs - properties ·

関数: is_sconnected (gr)

  もし有向グラフ grが強連結なら `true`を、 そうでないなら `false`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) is_sconnected(cycle_digraph(5));
      (%o2)                         true
      (%i3) is_sconnected(path_digraph(5));
      (%o3)                         false

  Package graphs ·Package graphs - properties ·

関数: is_vertex_in_graph (v, gr)

  もし vがグラフ gの頂点なら `true`を、 そうでないなら `false`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) c4 : cycle_graph(4)$
      (%i3) is_vertex_in_graph(0, c4);
      (%o3)                         true
      (%i4) is_vertex_in_graph(6, c4);
      (%o4)                         false

  Package graphs ·Package graphs - properties ·

関数: is_tree (gr)

  もし grが木なら `true`を、 そうでないなら `false`を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) is_tree(random_tree(4));
      (%o2)                         true
      (%i3) is_tree(graph_union(random_tree(4), random_tree(5)));
      (%o3)                         false

  Package graphs ·Package graphs - properties ·

関数: laplacian_matrix (gr)

  グラフ grのLaplace行列を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) laplacian_matrix(cycle_graph(5));
                         [  2   - 1   0    0   - 1 ]
                         [                         ]
                         [ - 1   2   - 1   0    0  ]
                         [                         ]
      (%o2)              [  0   - 1   2   - 1   0  ]
                         [                         ]
                         [  0    0   - 1   2   - 1 ]
                         [                         ]
                         [ - 1   0    0   - 1   2  ]

  Package graphs ·Package graphs - properties ·

関数: max_clique (gr)

  グラフ grの最大クリークを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : random_graph(100, 0.5)$
      (%i3) max_clique(g);
      (%o3)          [6, 12, 31, 36, 52, 59, 62, 63, 80]

  Package graphs ·Package graphs - properties ·

関数: max_degree (gr)

  グラフ grの頂点の最大次数と最大次数の頂点を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : random_graph(100, 0.02)$
      (%i3) max_degree(g);
      (%o3)                        [6, 79]
      (%i4) vertex_degree(95, g);
      (%o4)                           2

  Package graphs ·Package graphs - properties ·

関数: max_flow (net, s, t)

  ソース sとシンク tを持ち ネットワーク netを通る最大フローを返します。

  関数は最大フローの値と 最適フローで弧の重みを表現するリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) net : create_graph(
        [1,2,3,4,5,6],
        [[[1,2], 1.0],
         [[1,3], 0.3],
         [[2,4], 0.2],
         [[2,5], 0.3],
         [[3,4], 0.1],
         [[3,5], 0.1],
         [[4,6], 1.0],
         [[5,6], 1.0]],
        directed=true)$
      (%i3) [flow_value, flow] : max_flow(net, 1, 6);
      (%o3) [0.7, [[[1, 2], 0.5], [[1, 3], 0.2], [[2, 4], 0.2],
      [[2, 5], 0.3], [[3, 4], 0.1], [[3, 5], 0.1], [[4, 6], 0.3],
      [[5, 6], 0.4]]]
      (%i4) fl : 0$
      (%i5) for u in out_neighbors(1, net)
           do fl : fl + assoc([1, u], flow)$
      (%i6) fl;
      (%o6)                          0.7

  Package graphs ·Package graphs - properties ·

関数: max_independent_set (gr)

  グラフ grの最大独立集合を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) d : dodecahedron_graph()$
      (%i3) mi : max_independent_set(d);
      (%o3)             [0, 3, 5, 9, 10, 11, 18, 19]
      (%i4) draw_graph(d, show_vertices=mi)$

  Package graphs ·Package graphs - properties ·

関数: max_matching (gr)

  グラフ grの最大マッチングを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) d : dodecahedron_graph()$
      (%i3) m : max_matching(d);
      (%o3) [[5, 7], [8, 9], [6, 10], [14, 19], [13, 18], [12, 17],
                                     [11, 16], [0, 15], [3, 4], [1, 2]]
      (%i4) draw_graph(d, show_edges=m)$

  Package graphs ·Package graphs - properties ·

関数: min_degree (gr)

  グラフ grの頂点の最小次数と最小次数の頂点を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : random_graph(100, 0.1)$
      (%i3) min_degree(g);
      (%o3)                        [3, 49]
      (%i4) vertex_degree(21, g);
      (%o4)                           9

  Package graphs ·Package graphs - properties ·

関数: min_edge_cut (gr)

  グラフ grの最小切断辺を返します。

  `edge_connectivity`も参照してください。

  Package graphs ·Package graphs - properties ·

関数: min_vertex_cover (gr)

  グラフ grの最小頂点被覆を返します。

  Package graphs ·Package graphs - properties ·

関数: min_vertex_cut (gr)

  Returns the minimum vertex cut in the graph グラフ grの最小頂点切断を返します。

  `vertex_connectivity`も参照してください。

  Package graphs ·Package graphs - properties ·

関数: minimum_spanning_tree (gr)

  グラフ grの最小全域木を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : graph_product(path_graph(10), path_graph(10))$
      (%i3) t : minimum_spanning_tree(g)$
      (%i4) draw_graph(g, show_edges=edges(t))$

  Package graphs ·Package graphs - properties ·

関数: neighbors (v, gr)

  グラフ grの頂点 vの隣接点のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : petersen_graph()$
      (%i3) neighbors(3, p);
      (%o3)                       [4, 8, 2]

  Package graphs ·Package graphs - properties ·

関数: odd_girth (gr)

  グラフ grの最短奇閉路の長さを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g : graph_product(cycle_graph(4), cycle_graph(7))$
      (%i3) girth(g);
      (%o3)                           4
      (%i4) odd_girth(g);
      (%o4)                           7

  Package graphs ·Package graphs - properties ·

関数: out_neighbors (v, gr)

  有向グラフ grの頂点 vの外隣接点のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p : path_digraph(3)$
      (%i3) in_neighbors(2, p);
      (%o3)                          [1]
      (%i4) out_neighbors(2, p);
      (%o4)                          []

  Package graphs ·Package graphs - properties ·

関数: planar_embedding (gr)

  grの平面埋め込みでのfacial walkのリストを返します。 もし grが平面グラフでないなら `false`を返します。

  グラフ grは2連結でなければいけません。

  使われるアルゴリズムはDemoucronのアルゴリズムです。 これは二次時間アルゴリズムです。

  例:

      (%i1) load ("graphs")$
      (%i2) planar_embedding(grid_graph(3,3));
      (%o2) [[3, 6, 7, 8, 5, 2, 1, 0], [4, 3, 0, 1], [3, 4, 7, 6],
                                            [8, 7, 4, 5], [1, 2, 5, 4]]

  Package graphs ·Package graphs - properties ·

関数: print_graph (gr)

  グラフ grについてのある情報を印字します。

  例:

      (%i1) load ("graphs")$
      (%i2) c5 : cycle_graph(5)$
      (%i3) print_graph(c5)$
      Graph on 5 vertices with 5 edges.
      Adjacencies:
        4 :  0  3
        3 :  4  2
        2 :  3  1
        1 :  2  0
        0 :  4  1
      (%i4) dc5 : cycle_digraph(5)$
      (%i5) print_graph(dc5)$
      Digraph on 5 vertices with 5 arcs.
      Adjacencies:
        4 :  0
        3 :  4
        2 :  3
        1 :  2
        0 :  1
      (%i6) out_neighbors(0, dc5);
      (%o6)                          [1]

  Package graphs ·

関数: radius (gr)

  グラフ grの半径を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) radius(dodecahedron_graph());
      (%o2)                           5

  Package graphs ·Package graphs - properties ·

関数: set_edge_weight (e, w, gr)

  グラフ grの辺 eに重み wを割り当てます。

  例:

      (%i1) load ("graphs")$
      (%i2) g : create_graph([1, 2], [[[1,2], 1.2]])$
      (%i3) get_edge_weight([1,2], g);
      (%o3)                          1.2
      (%i4) set_edge_weight([1,2], 2.1, g);
      (%o4)                         done
      (%i5) get_edge_weight([1,2], g);
      (%o5)                          2.1

  Package graphs ·Package graphs - properties ·

関数: set_vertex_label (v, l, gr)

  グラフ grの頂点 vにラベル lを割り当てます。

  例:

      (%i1) load ("graphs")$
      (%i2) g : create_graph([[1, "One"], [2, "Two"]], [[1,2]])$
      (%i3) get_vertex_label(1, g);
      (%o3)                          One
      (%i4) set_vertex_label(1, "oNE", g);
      (%o4)                         done
      (%i5) get_vertex_label(1, g);
      (%o5)                          oNE

  Package graphs ·Package graphs - properties ·

関数: shortest_path (u, v, gr)

  グラフ grの uから vまでの最短経路を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) d : dodecahedron_graph()$
      (%i3) path : shortest_path(0, 7, d);
      (%o3)                   [0, 1, 19, 13, 7]
      (%i4) draw_graph(d, show_edges=vertices_to_path(path))$

  Package graphs ·Package graphs - properties ·

関数: shortest_weighted_path (u, v, gr)

  グラフ grの uから vまでの最短重み付き経路とその長さを返します。

  重み付き経路の長さは経路内の辺の辺重みの和です。 もし辺に重みがないなら、辺はデフォルト重み1を持ちます。

  例:

      (%i1) load ("graphs")$
      (%i2) g: petersen_graph(20, 2)$
      (%i3) for e in edges(g) do set_edge_weight(e, random(1.0), g)$
      (%i4) shortest_weighted_path(0, 10, g);
      (%o4) [2.575143920268482, [0, 20, 38, 36, 34, 32, 30, 10]]

  Package graphs ·Package graphs - properties ·

関数: strong_components (gr)

  有向グラフ grの強成分を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) t : random_tournament(4)$
      (%i3) strong_components(t);
      (%o3)                 [[1], [0], [2], [3]]
      (%i4) vertex_out_degree(3, t);
      (%o4)                           3

  Package graphs ·Package graphs - properties ·

関数: topological_sort (dag)

  Returns a topological sorting of the vertices of a directed graph 有向グラフ dagの頂点のトポロジカルソートを返します。 もし dagが有向無閉路グラフなら空のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g:create_graph(
               [1,2,3,4,5],
               [
                [1,2], [2,5], [5,3],
                [5,4], [3,4], [1,3]
               ],
               directed=true)$
      (%i3) topological_sort(g);
      (%o3)                    [1, 2, 5, 3, 4]

  Package graphs ·Package graphs - properties ·

関数: vertex_connectivity (g)

  グラフ gの頂点連結性を返します。

  `min_vertex_cut`も参照してください。

  Package graphs ·Package graphs - properties ·

関数: vertex_degree (v, gr)

  グラフ grの頂点 vの次数を返します。

  Package graphs ·Package graphs - properties ·

関数: vertex_distance (u, v, gr)

  (有向)グラフ grの uと vの間の最短経路の長さを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) d : dodecahedron_graph()$
      (%i3) vertex_distance(0, 7, d);
      (%o3)                           4
      (%i4) shortest_path(0, 7, d);
      (%o4)                   [0, 1, 19, 13, 7]

  Package graphs ·Package graphs - properties ·

関数: vertex_eccentricity (v, gr)

  グラフ grの頂点 vの離心率を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) g:cycle_graph(7)$
      (%i3) vertex_eccentricity(0, g);
      (%o3)                           3

  Package graphs ·Package graphs - properties ·

関数: vertex_in_degree (v, gr)

  有向グラフ grの頂点 vの内次数を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p5 : path_digraph(5)$
      (%i3) print_graph(p5)$
      Digraph on 5 vertices with 4 arcs.
      Adjacencies:
        4 :
        3 :  4
        2 :  3
        1 :  2
        0 :  1
      (%i4) vertex_in_degree(4, p5);
      (%o4)                           1
      (%i5) in_neighbors(4, p5);
      (%o5)                          [3]

  Package graphs ·Package graphs - properties ·

関数: vertex_out_degree (v, gr)

  有向グラフ grの頂点 vの外次数を返します。

  例:

      (%i1) load ("graphs")$
      (%i2) t : random_tournament(10)$
      (%i3) vertex_out_degree(0, t);
      (%o3)                           2
      (%i4) out_neighbors(0, t);
      (%o4)                        [7, 1]

  Package graphs ·Package graphs - properties ·

関数: vertices (gr)

  グラフ grの頂点のリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) vertices(complete_graph(4));
      (%o2)                     [3, 2, 1, 0]

  Package graphs ·Package graphs - properties ·

関数: vertex_coloring (gr)

  グラフ grの頂点の最適色付けを返します。

  関数は、彩色数と grの頂点の色付けを表すリストを返します。

  例:

      (%i1) load ("graphs")$
      (%i2) p:petersen_graph()$
      (%i3) vertex_coloring(p);
      (%o3) [3, [[0, 2], [1, 3], [2, 2], [3, 3], [4, 1], [5, 3],
                                       [6, 1], [7, 1], [8, 2], [9, 2]]]

  Package graphs ·Package graphs - properties ·

関数: wiener_index (gr)

  グラフ grのWiener指数を返します。

  例:

      (%i2) wiener_index(dodecahedron_graph());
      (%o2)                          500

  Package graphs ·Package graphs - properties ·

#### 56.2.3 Modifying graphs

関数: add_edge (e, gr)

  辺 eをグラフ grに加えます。

  例:

      (%i1) load ("graphs")$
      (%i2) p : path_graph(4)$
      (%i3) neighbors(0, p);
      (%o3)                          [1]
      (%i4) add_edge([0,3], p);
      (%o4)                         done
      (%i5) neighbors(0, p);
      (%o5)                        [3, 1]

  Package graphs ·Package graphs - modifications ·

関数: add_edges (e_list, gr)

  リスト e_listの中の辺すべてをグラフ grに加えます。

  例:

      (%i1) load ("graphs")$
      (%i2) g : empty_graph(3)$
      (%i3) add_edges([[0,1],[1,2]], g)$
      (%i4) print_graph(g)$
      Graph on 3 vertices with 2 edges.
      Adjacencies:
        2 :  1
        1 :  2  0
        0 :  1

  Package graphs ·Package graphs - modifications ·

関数: add_vertex (v, gr)

  頂点 vをグラフ grに加えます。

  例:

      (%i1) load ("graphs")$
      (%i2) g : path_graph(2)$
      (%i3) add_vertex(2, g)$
      (%i4) print_graph(g)$
      Graph on 3 vertices with 1 edges.
      Adjacencies:
        2 :
        1 :  0
        0 :  1

  Package graphs ·Package graphs - modifications ·

関数: add_vertices (v_list, gr)

  リスト v_listの中の頂点すべてをグラフ grに加えます。

  Package graphs ·Package graphs - modifications ·

関数: connect_vertices (v_list, u_list, gr)

  グラフ grに関して、 リスト v_list内の頂点すべてを リスト u_list内の頂点に連結します。

  v_listと u_listは1つの頂点か、頂点のリストを取り得ます。

  例:

      (%i1) load ("graphs")$
      (%i2) g : empty_graph(4)$
      (%i3) connect_vertices(0, [1,2,3], g)$
      (%i4) print_graph(g)$
      Graph on 4 vertices with 3 edges.
      Adjacencies:
        3 :  0
        2 :  0
        1 :  0
        0 :  3  2  1

  Package graphs ·Package graphs - modifications ·

関数: contract_edge (e, gr)

  グラフ grの辺 eを縮約します。

  例:

      (%i1) load ("graphs")$
      (%i2) g: create_graph(
            8, [[0,3],[1,3],[2,3],[3,4],[4,5],[4,6],[4,7]])$
      (%i3) print_graph(g)$
      Graph on 8 vertices with 7 edges.
      Adjacencies:
        7 :  4
        6 :  4
        5 :  4
        4 :  7  6  5  3
        3 :  4  2  1  0
        2 :  3
        1 :  3
        0 :  3
      (%i4) contract_edge([3,4], g)$
      (%i5) print_graph(g)$
      Graph on 7 vertices with 6 edges.
      Adjacencies:
        7 :  3
        6 :  3
        5 :  3
        3 :  5  6  7  2  1  0
        2 :  3
        1 :  3
        0 :  3

  Package graphs ·Package graphs - modifications ·

関数: remove_edge (e, gr)

  グラフ grから辺 eを削除します。

  例:

      (%i1) load ("graphs")$
      (%i2) c3 : cycle_graph(3)$
      (%i3) remove_edge([0,1], c3)$
      (%i4) print_graph(c3)$
      Graph on 3 vertices with 2 edges.
      Adjacencies:
        2 :  0  1
        1 :  2
        0 :  2

  Package graphs ·Package graphs - modifications ·

関数: remove_vertex (v, gr)

  グラフ grから頂点 vを削除します。

  Package graphs ·

#### 56.2.4 Reading and writing to files

関数: dimacs_export (gr, fl)
関数: dimacs_export (gr, fl, comment1, ..., commentn)

  グラフをファイル flにDIMACSフォーマットでエクスポートします。 オプションのコメントはファイルの頭に加えられます。

  Package graphs ·Package graphs - io ·

関数: dimacs_import (fl)

  DIMACSフォーマットのファイル flからグラフを返します。

  Package graphs ·Package graphs - io ·

関数: graph6_decode (str)

  文字列 strにgraph6フォーマットで符号化されたグラフを返します。

  Package graphs ·Package graphs - io ·

関数: graph6_encode (gr)

  グラフ grをgraph6フォーマットに符号化した文字列を返します。

  Package graphs ·Package graphs - io ·

関数: graph6_export (gr_list, fl)

  リスト gr_list内のグラフをファイル flに graph6フォーマットでエクスポートします。

  Package graphs ·Package graphs - io ·

関数: graph6_import (fl)

  graph6フォーマットのファイル flからグラフのリストを返します。

  Package graphs ·Package graphs - io ·

関数: sparse6_decode (str)

  文字列 strにsparse6フォーマットで符号化されたグラフを返します。

  Package graphs ·Package graphs - io ·

関数: sparse6_encode (gr)

  グラフ grをsparse6フォーマットに符号化した文字列を返します。

  Package graphs ·Package graphs - io ·

関数: sparse6_export (gr_list, fl)

  リスト gr_list内のグラフを ファイル flにsparse6フォーマットでエクスポートします。

  Package graphs ·Package graphs - io ·

関数: sparse6_import (fl)

  sparse6フォーマットのファイル flからグラフのリストを返します。

  Package graphs ·Package graphs - io ·

#### 56.2.5 Visualization

関数: draw_graph (graph)
関数: draw_graph (graph, option1, ..., optionk)

  `draw`パッケージを使ってグラフを描画します。

  頂点を配置するのに使われるアルゴリズムは オプション引数 programで指定されます。 デフォルト値は `program=spring_embedding`です。 draw_graphは 頂点を配置するのにgraphvizプログラムも使うことができますが、 graphvizを別途インストールしなければいけません。

  例 1:

      (%i1) load ("graphs")$
      (%i2) g:grid_graph(10,10)$
      (%i3) m:max_matching(g)$
      (%i4) draw_graph(g,
         spring_embedding_depth=100,
         show_edges=m, edge_type=dots,
         vertex_size=0)$

  例 2:

      (%i1) load ("graphs")$
      (%i2) g:create_graph(16,
          [
           [0,1],[1,3],[2,3],[0,2],[3,4],[2,4],
           [5,6],[6,4],[4,7],[6,7],[7,8],[7,10],[7,11],
           [8,10],[11,10],[8,9],[11,12],[9,15],[12,13],
           [10,14],[15,14],[13,14]
          ])$
      (%i3) t:minimum_spanning_tree(g)$
      (%i4) draw_graph(
          g,
          show_edges=edges(t),
          show_edge_width=4,
          show_edge_color=green,
          vertex_type=filled_square,
          vertex_size=2
          )$

  例 3:

      (%i1) load ("graphs")$
      (%i2) g:create_graph(16,
          [
           [0,1],[1,3],[2,3],[0,2],[3,4],[2,4],
           [5,6],[6,4],[4,7],[6,7],[7,8],[7,10],[7,11],
           [8,10],[11,10],[8,9],[11,12],[9,15],[12,13],
           [10,14],[15,14],[13,14]
          ])$
      (%i3) mi : max_independent_set(g)$
      (%i4) draw_graph(
          g,
          show_vertices=mi,
          show_vertex_type=filled_up_triangle,
          show_vertex_size=2,
          edge_color=cyan,
          edge_width=3,
          show_id=true,
          text_color=brown
          )$

  例 4:

      (%i1) load ("graphs")$
      (%i2) net : create_graph(
          [0,1,2,3,4,5],
          [
           [[0,1], 3], [[0,2], 2],
           [[1,3], 1], [[1,4], 3],
           [[2,3], 2], [[2,4], 2],
           [[4,5], 2], [[3,5], 2]
          ],
          directed=true
          )$
      (%i3) draw_graph(
          net,
          show_weight=true,
          vertex_size=0,
          show_vertices=[0,5],
          show_vertex_type=filled_square,
          head_length=0.2,
          head_angle=10,
          edge_color="dark-green",
          text_color=blue
          )$

  例 5:

      (%i1) load("graphs")$
      (%i2) g: petersen_graph(20, 2);
      (%o2)                         GRAPH
      (%i3) draw_graph(g, redraw=true, program=planar_embedding);
      (%o3)                         done

  例 6:

      (%i1) load("graphs")$
      (%i2) t: tutte_graph();
      (%o2)                         GRAPH
      (%i3) draw_graph(t, redraw=true,
                          fixed_vertices=[1,2,3,4,5,6,7,8,9]);
      (%o3)                         done

  Package graphs ·

オプション変数: draw_graph_program

  デフォルト値: spring_embedding

  頂点を配置するのに使われるプログラムのデフォルト値は `draw_graph`プログラムです。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_id

  デフォルト値: false

  もし trueなら頂点のidが表示されます。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_label

  デフォルト値: false

  もし trueなら頂点のラベルが表示されます。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: label_alignment

  デフォルト値: center

  頂点のラベル/idをいかに整列させるか決めます。 `left`, `center`, `right`であり得ます。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_weight

  デフォルト値: false

  もし trueなら辺の重みを表示します。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: vertex_type

  デフォルト値: circle

  頂点をいかに表示するか定義します。 可能な値に関しては、 `draw`パッケージの point_typeオプションを参照してください。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: vertex_size

  頂点のサイズ。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: vertex_color

  頂点を表示するのに使う色。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_vertices

  デフォルト値: []

  選択された頂点を異なる色を使って表示。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_vertex_type

  show_verticesで指定された頂点をいかに表示するか定義します。 可能な値については、 `draw`パッケージの point_typeオプションを参照してください。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_vertex_size

  show_vertices内の頂点のサイズ

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_vertex_color

  show_verticesリスト内の頂点を表示するのに使う色。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: vertex_partition

  デフォルト値: []

  グラフの頂点の分割 `[[v1,v2,...],...,[vk,...,vn]]` 分割内のそれぞれのリストの頂点は異なる色で描画されます。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: vertex_coloring

  頂点の色付けを指定します。 色付け colは vertex_coloringが返すようなフォーマットで指定されなければいけません。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: edge_color

  辺を表示するのに使われる色。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: edge_width

  辺の幅。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: edge_type

  辺をいかに表示するか定義します。 `draw`パッケージのline_typeオプションを参照してください。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_edges

  異なる色を使ってリスト e_list内で指定された辺を表示する。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_edge_color

  show_edgesリスト内の辺を表示するのに使う色。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_edge_width

  show_edges内の辺の幅。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: show_edge_type

  show_edges内の辺を以下に表示するかを定義します。 `draw`パッケージのline_typeオプションを参照してください。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: edge_partition

  グラフの辺の分割 `[[e1,e2,...],...,[ek,...,em]]` 分割内のそれぞれのリストの辺は異なる色を使って描画されます。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: edge_coloring

  辺の色付け。 色付けは 関数 edge_coloringが返すようなフォーマットで指定しなければいけません。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: redraw

  デフォルト値: false

  もし `true`なら、 たとえ位置がグラフの以前の描画から保存されていても頂点位置が再計算されます。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: head_angle

  デフォルト値: 15

  (有向グラフの)弧に表示される矢印の角度。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: head_length

  デフォルト値: 0.1

  (有向グラフの)弧に表示される矢印の長さ。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: spring_embedding_depth

  デフォルト値: 50

  バネ埋め込みグラフ描画アルゴリズムでの繰り返し回数

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: terminal

  描画で使う端末。 (`draw`パッケージの terminalオプションを参照してください。)

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: file_name

  端末がスクリーンでないなら、描画のファイル名。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: program

  グラフの頂点を配置するのに使われるプログラムを定義します。 graphvizプログラム (dot, neato, twopi, circ, fdp)の1つ, circular, spring_embedding, planar_embeddingを取り得ます。 2連結平面グラフでは planar_embeddingだけが利用可能です。 `program=spring_embedding`の時、 固定位置の頂点の集合が fixed_verticesオプションで指定可能です。

  Package graphs ·Package graphs - draw_graphs options ·

draw_graphオプション: fixed_vertices

  正多角形沿いに固定された位置を持つ頂点のリストを指定します。 `program=spring_embedding`の時、使うことができます。

  Package graphs ·Package graphs - draw_graphs options ·

関数: vertices_to_path (v_list)

  頂点のリスト v_listを v_listで定義された経路の辺のリストに変換します。

  Package graphs ·

関数: vertices_to_cycle (v_list)

  頂点のリスト v_listを v_listで定義された閉路の辺のリストに変換します。

  Package graphs ·

Next: impdiff, Previous: graphs, Up: Top [Contents][Index]

## 57 grobner

Next: Functions and Variables for grobner, Previous: Top, Up: Top [Contents][Index]

### 57.1 Introduction to grobner

`grobner`は MaximaでGroebner基底を使うためのパッケージです。

Groebner基底に関するチュートリアルは以下で見つかります。

http://www.geocities.com/CapeCanaveral/Hall/3131/

以下の関数を使うには、`grobner.lisp`パッケージをロードしなければいけません。

    load("grobner");

    demo("grobner.demo");

もしくは

    batch("grobner.demo")

でデモを開始することができます。

デモの中の計算のいくつかは長い時間かかります。 だから、デモの出力 `grobner-demo.output`が デモファイルと同じディレクトリに見つかります。

#### 57.1.1 Notes on the grobner package

パッケージは

Marek Rychlik

http://alamos.math.arizona.edu

によって書かれ、 General Public License(GPL)の条件の下、2002-05-24にリリースされました。 (ファイル `grobner.lisp`を参照してください。) このドキュメントは、 ファイル

`README`, `grobner.lisp`, `grobner.demo`, `grobner-demo.output`

から

Günter Nowakによって抽出されました。

ドキュメントの改善に関する提案は maximaメーリングリスト maxima@math.utexas.eduで議論することができます。 現在、コードは若干古くなっています。 モダンな実装は 以下に記載されている高速の F4アルゴリズムを使います。

    A new efficient algorithm for computing Gröbner bases (F4)
    Jean-Charles Faugère
    LIP6/CNRS Université Paris VI
    January 20, 1999

Groebner bases ·Share packages ·Package grobner ·

#### 57.1.2 Implementations of admissible monomial orders in grobner

- `lex`

  純粋に辞書式の、 単項式比較のデフォルト順序

- `grlex`

  全次数順序。同点は辞書式で決めます。

- `grevlex`

  全次数。同点は逆辞書式で決めます。

- `invlex`

  逆時書式順序。

Previous: Introduction to grobner, Up: Top [Contents][Index]

### 57.2 Functions and Variables for grobner

#### 57.2.1 Global switches for grobner

オブション変数: poly_monomial_order

  デフォルト値: `lex`

  このグローバルスイッチは どの単項式順序が多項式とGroebner基底計算で使われるか制御します。 もし設定されないなら、 `lex`が使われます。

  Package grobner ·

オブション変数: poly_coefficient_ring

  デフォルト値: `expression_ring`

  このスイッチは grober計算で使われる多項式の係数環を示します。 もし設定されないなら、 maximaの 一般式環が使われます。 もし望むなら、この変数を `ring_of_integers`に設定できます。

  Package grobner ·

オブション変数: poly_primary_elimination_order

  デフォルト値: `false`

  消去ベース関数で消去される変数のデフォルト順序名。 設定されていないなら、 `lex`が使われます。

  Package grobner ·

オブション変数: poly_secondary_elimination_order

  デフォルト値: `false`

  消去ベース関数で保持される変数のデフォルト順序名。 設定されていないなら、 `lex`が使われます。

  Package grobner ·

オブション変数: poly_elimination_order

  デフォルト値: `false`

  消去計算で使われるデフォルト消去順序名。 設定されているなら、 変数 `poly_primary_elimination_order`と `poly_secondary_elimination_order`の設定を上書きします。 ユーザーは これが消去変数の数に有効な真の消去順序であることを保証しなければいけません。

  Package grobner ·

オブション変数: poly_return_term_list

  デフォルト値: `false`

  もし `true`に設定されているなら、 このパッケージの関数すべては maxima一般式ではなく、 それぞれの多項式を 現在の単項式順序で並べた項のリストとして返します。

  Package grobner ·

オブション変数: poly_grobner_debug

  デフォルト値: `false`

  もし `true`に設定されているなら、 デバッグ用、トレース用出力を生成します。

  Package grobner ·

オブション変数: poly_grobner_algorithm

  デフォルト値: `buchberger`

  可能な値:

  - `buchberger`
  - `parallel_buchberger`
  - `gebauer_moeller`

  Groebner基底を見つけるのに使われるアルゴリズム名。

  Package grobner ·

オブション変数: poly_top_reduction_only

  デフォルト値: `false`

  もし `false`でないなら、 可能な時はいつでも、頭項簡約を使います。 頭項簡約は、割り算アルゴリズムが最初の簡約後に停止することを意味します。

  Package grobner ·

#### 57.2.2 Simple operators in grobner

`poly_add`, `poly_subtract`, `poly_multiply`, `poly_expt`は 多項式の算出演算子です。 これらは 内部表現を使って実行されますが、 結果は maxima一般形式に変換されます。

関数: poly_add (poly1, poly2, varlist)

  2つの多項式 poly1と poly2を足します。

      (%i1) poly_add(z+x^2*y,x-z,[x,y,z]);
                                          2
      (%o1)                              x  y + x

  Package grobner ·

関数: poly_subtract (poly1, poly2, varlist)

  多項式 poly1から poly2を引きます。

      (%i1) poly_subtract(z+x^2*y,x-z,[x,y,z]);
                                            2
      (%o1)                          2 z + x  y - x

  Package grobner ·

関数: poly_multiply (poly1, poly2, varlist)

  多項式 poly1と poly2の積を返します。

      (%i2) poly_multiply(z+x^2*y,x-z,[x,y,z])-(z+x^2*y)*(x-z),expand;
      (%o1)                                  0

  Package grobner ·

関数: poly_s_polynomial (poly1, poly2, varlist)

  2つの多項式 poly1と poly2の シジジー多項式 (S多項式)を返します。

  Package grobner ·

関数: poly_primitive_part (poly1, varlist)

  多項式 poly1を係数のGCDで割ったものを返します。

      (%i1) poly_primitive_part(35*y+21*x,[x,y]);
      (%o1)                              5 y + 3 x

  Package grobner ·

関数: poly_normalize (poly, varlist)

  多項式 poly1を主係数で割ったものを返します。 割り算が可能であることを仮定しています。 これは、体の場合には大丈夫ですが、環の場合にはいつも可能なわけではありません。

  Package grobner ·

#### 57.2.3 Other functions in grobner

関数: poly_expand (poly, varlist)

  この関数は 多項式を内部形式にパースします。 もし polyが多項式を正確にパースしたら、 それは `expand(poly)`と同値です。 もし表現が変数 varlistの多項式と互換性がないなら、 結果はエラーです。 式が正確に内部表現にパースするかテストするのに使うことができます。 以下の例は添字付き変数と超越関数変数が許されることを例示します。

      (%i1) poly_expand((x-y)*(y+x),[x,y]);
                                           2    2
      (%o1)                               x  - y
      (%i2) poly_expand((y+x)^2,[x,y]);
                                      2            2
      (%o2)                          y  + 2 x y + x
      (%i3) poly_expand((y+x)^5,[x,y]);
                        5      4         2  3       3  2      4      5
      (%o3)            y  + 5 x y  + 10 x  y  + 10 x  y  + 5 x  y + x
      (%i4) poly_expand(-1-x*exp(y)+x^2/sqrt(y),[x]);
                                                2
                                        y      x
      (%o4)                       - x %e  + ------- - 1
                                             sqrt(y)

      (%i5) poly_expand(-1-sin(x)^2+sin(x),[sin(x)]);
                                      2
      (%o5)                      - sin (x) + sin(x) - 1

  Package grobner ·

関数: poly_expt (poly, number, varlist)

  polyの、正の整数 numberのべき乗を返します。 もし numberが正の整数でないなら、 エラーが生じます。

      (%i1) poly_expt(x-y,3,[x,y])-(x-y)^3,expand;
      (%o1)                                  0

  Package grobner ·

関数: poly_content (poly. varlist)

  `poly_content`は係数のGCDを抽出します。

      (%i1) poly_content(35*y+21*x,[x,y]);
      (%o1)                                  7

  Package grobner ·

関数: poly_pseudo_divide (poly, polylist, varlist)

  多項式 polyを n個の多項式のリスト polylistで擬似的に割ります。 複数の値を返します。 一番目の値は 商のリスト aです。 二番目の値は余り rです。 三番目の値は、 係数環(体である必要はありません)内でpolylistがc*polyを割れるような スカラ係数 cです。 最後に 四番目の値は実行された簡約の回数です。 結果のオブジェクトは以下の等式を満たします:

  c*poly=sum(a[i]*polylist[i],i=1...n)+r.

  Package grobner ·

関数: poly_exact_divide (poly1, poly2, varlist)

  多項式 poly1を多項式 poly2で割ります。 余りのない厳密な割り算が可能と仮定します。 商を返します。

  Package grobner ·

関数: poly_normal_form (poly, polylist, varlist)

  `poly_normal_form`は 多項式の集合 polylistに関して 多項式 polyの正規形を見つけます。

  Package grobner ·

関数: poly_buchberger_criterion (polylist, varlist)

  Buchberger判定(criterion)を使って もし polylistが現在の項順序に関して Groebner基底なら `true`を返します: Buchberger判定(criterion)は、 polylistの2つの多項式 h1と h2すべてに関して、 S多項式 S(h1,h2)が polylistを法として0に簡約されるというものです。

  Package grobner ·

関数: poly_buchberger (polylist_fl varlist)

  `poly_buchberger`は 多項式のリスト上でBuchbergerアルゴリズムを実行し、 結果の Groebner基底を返します。

  Package grobner ·

#### 57.2.4 Standard postprocessing of Groebner Bases

K[ x[1],...,x[n] ]上のイデアル Iの k番目の消去イデアル I_kは イデアル intersect(I, K[ x[k+1],...,x[n] ])です。
コロンイデアル I:Jは イデアル {h|for all w in J: w*h in I}です。.
イデアル I:p^infはイデアル {h| there is a n in N: p^n*h in I}です。
イデアル I:J^infはイデアル {h| there is a n in N and a p in J: p^n*h in I}です。
The 根基イデアル sqrt(I)はイデアル {h| there is a n in N : h^n in I }です。

関数: poly_reduction (polylist, varlist)

  `poly_reduction`は多項式のリスト polylistを簡約します。 それぞれの多項式は他の多項式で完全に簡約されます。

  Package grobner ·

関数: poly_minimization (polylist, varlist)

  polylistと同じ単項式イデアルの最小全域である、 多項式リスト polylistの部分リストを返します。 すなわち、部分リストの中の多項式の主単項式はすべて、他の多項式の主単項式を割りません。

  Package grobner ·

関数: poly_normalize_list (polylist, varlist)

  `poly_normalize_list`は `poly_normalize`をリストの中の多項式それぞれに適用します。 これは リスト polylistの中のすべての多項式を主係数で割ることを意味します。

  Package grobner ·

関数: poly_grobner (polylist, varlist)

  多項式リスト polylistで張られたイデアルのGroebner基底を返します。 グローバルフラグで影響を受けます。

  Package grobner ·

関数: poly_reduced_grobner (polylist, varlist)

  多項式リスト polylistで張られたイデアルの簡約Groebner基底を返します。

  Package grobner ·

関数: poly_depends_p (poly, var, varlist)

  `poly_depends`は多項式が変数 varに依存するかテストします。

  Package grobner ·Predicate functions ·

関数: poly_elimination_ideal (polylist, number, varlist)

  `poly_elimination_ideal`は、 (必ずしもGroebner基底である必要はない)生成多項式のリストとして指定されたイデアルの number番目の消去イデアルの Groebner基底を返します。

  Package grobner ·

関数: poly_colon_ideal (polylist1, polylist2, varlist)

  コロンイデアル

  I(polylist1):I(polylist2)

  の簡約Groebner基底を返します。

  ここで、 polylist1と polylist2は2つの多項式リストです。

  Package grobner ·

関数: poly_ideal_intersection (polylist1, polylist2, varlist)

  `poly_ideal_intersection`は2つのイデアルの交わりです。

  Package grobner ·

関数: poly_lcm (poly1, poly2, varlist)

  poly1と poly2の最小公倍数(式)を返します。

  Package grobner ·

関数: poly_gcd (poly1, poly2, varlist)

  poly1と poly2の最大公約数(式)を返します。

  `ezgcd`, `gcd`, `gcdex`, `gcdivide` も参照してください。

  例:

      (%i1) p1:6*x^3+19*x^2+19*x+6;
                              3       2
      (%o1)                6 x  + 19 x  + 19 x + 6
      (%i2) p2:6*x^5+13*x^4+12*x^3+13*x^2+6*x;
                        5       4       3       2
      (%o2)          6 x  + 13 x  + 12 x  + 13 x  + 6 x
      (%i3) poly_gcd(p1, p2, [x]);
                                  2
      (%o3)                    6 x  + 13 x + 6

  Package grobner ·

関数: poly_grobner_equal (polylist1, polylist2, varlist)

  `poly_grobner_equal`は 2つの Groebner基底が同じイデアルを生成するか テストします。 もし、Groebner基底と仮定された2つの多項式リスト polylist1と polylist2が 同じイデアルを生成するなら、`true`を返します。 そうでないなら、 `false`を返します。 これは、 一番目の基底のすべての多項式が二番目の基底を法として0に簡約されるかとその逆をチェックする ことと同値です。 以下の例では、一番目のリストがGroebner基底でないので 結果が `false`であることに注意してください。

      (%i1) poly_grobner_equal([y+x,x-y],[x,y],[x,y]);
      (%o1)                         false

  Package grobner ·

関数: poly_grobner_subsetp (polylist1, polylist2, varlist)

  `poly_grobner_subsetp`は polylist1が生成するイデアルが polylist2が生成するイデアルに含まれるかテストします。 このテストが常に成功するには、polylist2が Groebner基底でなければいけません。

  Package grobner ·Predicate functions ·

関数: poly_grobner_member (poly, polylist, varlist)

  もし多項式 polyが Groebner基底であると仮定された多項式リスト polylistが生成するイデアルに属するなら、 `true`を返します。 そうでないなら、 `false`を返します。

  `poly_grobner_member`は 多項式が Groebner基底であると仮定された多項式のリストが生成するイデアルに属するかテストします。 `normal_form`が0と同値です。

  Package grobner ·

関数: poly_ideal_saturation1 (polylist, poly, varlist)

  イデアル

  I(polylist):poly^inf のsaturationの簡約 Groebner基底を返します。

  幾何学的に、代数的閉体上で、 これは polyの多様体上で恒等的に0とならない polylistが生成するイデアルの中の 多項式の集合です。

  Package grobner ·

関数: poly_ideal_saturation (polylist1, polylist2, varlist)

  イデアル

  I(polylist1):I(polylist2)^inf のsaturationの簡約 Groebner基底を返します。

  幾何学的に、代数的閉体上で、 これは polylist2の多様体上で恒等的に0とならない polylist1が生成するイデアルの中の 多項式の集合です。

  Package grobner ·

関数: poly_ideal_polysaturation1 (polylist1, polylist2, varlist)

  polylist2は2個の多項式のリスト `[poly1,...,polyn]`です。 多項式リスト polylist1が生成するイデアルの 多項式リスト polylist2の多項式に関する連続saturationの列によって得られるイデアル

  I(polylist):poly1^inf:...:polyn^inf

  の簡約 Groebner基底を返します。

  Package grobner ·

関数: poly_ideal_polysaturation (polylist, polylistlist, varlist)

  polylistlistは多項式リストn個のリスト `[polylist1,...,polylistn]`です。 イデアル

  I(polylist):I(polylist_1)^inf:...:I(polylist_n)^inf のsaturationの簡約 Groebner基底を返します。

  Package grobner ·

関数: poly_saturation_extension (poly, polylist, varlist1, varlist2)

  `poly_saturation_extension`は有名な Rabinowitzのトリックを実装します。

  Package grobner ·

関数: poly_polysaturation_extension (poly, polylist, varlist1, varlist2)
  Package grobner ·

Next: implicit_plot, Previous: grobner, Up: Top [Contents][Index]

## 58 impdiff

Previous: impdiff, Up: impdiff [Contents][Index]

### 58.1 Functions and Variables for impdiff

関数: implicit_derivative (f,indvarlist,orderlist,depvar)

  このサブルーチンは多変数関数の陰導関数を計算します。 fは配列関数で、 インデックスはindvarlist順の微分の階数です; indvarlistは独立変数リストです; orderlistは望みの次数です; depvarは従属変数です。

  この関数を使うには、最初に`load("impdiff")`を書いてください。

  Differential calculus ·Share packages ·Package impdiff ·

Next: interpol, Previous: impdiff, Up: Top [Contents][Index]

## 59 implicit_plot

Previous: implicit_plot, Up: implicit_plot [Contents][Index]

### 59.1 Functions and Variables for implicit_plot

関数: implicit_plot (expr, x_range, y_range)
関数: implicit_plot ([expr_1, ..., expr_n], x_range, y_range)

  １つ以上の式のプロットを陰形式で表示します。 exprはプロットされる式で、 x_rangeは水平軸の範囲、 y_rangeは垂直軸の範囲です。 `implicit_plot`は set_plot_option関数が設定するgnuplotドライバのグローバル設定を考慮します。 オプションはオプション引数として`implicit_plot`関数にも渡されることができます。

  `implicit_plot`は x_rangeとy_rangeで与えられる領域上で符号の変化を辿ることで機能し、 複雑な式では失敗する可能性があります。

  `load("implicit_plot")`はこの関数をロードします。

  例:

      (%i1) implicit_plot (x^2 = y^3 - 3*y + 1, [x, -4, 4], [y, -4, 4],
       [gnuplot_preamble, "set zeroaxis"]);

  Plotting ·Share packages ·Package implicit_plot ·

Next: lapack, Previous: implicit_plot, Up: Top [Contents][Index]

## 60 interpol

Next: Functions and Variables for interpol, Previous: interpol, Up: interpol [Contents][Index]

### 60.1 Introduction to interpol

パッケージ`interpol`は 多項式内挿のためのLagrange、線形、三次スプライン法を定義します。

コメント、バグ、提案は’mario AT edu DOT xunta DOT es’にコンタクトを取ってください。

Numerical methods ·Share packages ·Package interpol ·

Previous: Introduction to interpol, Up: interpol [Contents][Index]

### 60.2 Functions and Variables for interpol

関数: lagrange (points)
関数: lagrange (points, option)

  Lagrange法で多項式内挿を計算します。 引数 pointsは以下のいずれかでなければいけません:

  - 2列行列, `p:matrix([2,4],[5,6],[9,3])`,
  - 対のリスト, `p: [[2,4],[5,6],[9,3]]`,
  - 数のリスト, `p: [4,6,3]`, この場合、横座標は自動的に1, 2, 3などに割り当てられます。

  最初の2つの場合には、 計算を行う前に、対は最初の座標に関して並び替えられます。

  option引数を使って、 独立変数の名前を選択することが可能です。 デフォルトでは `'x`です; 別のものを定義するには、 `varname='z`のようなものを書いてください。

  高次多項式を使って計算する時には、浮動小数点評価は不安定なことに注意してください。

  例:

      (%i1) load("interpol")$
      (%i2) p:[[7,2],[8,2],[1,5],[3,2],[6,7]]$
      (%i3) lagrange(p);
             (x - 7) (x - 6) (x - 3) (x - 1)
      (%o3)  -------------------------------
                           35
         (x - 8) (x - 6) (x - 3) (x - 1)
       - -------------------------------
                       12
         7 (x - 8) (x - 7) (x - 3) (x - 1)
       + ---------------------------------
                        30
         (x - 8) (x - 7) (x - 6) (x - 1)
       - -------------------------------
                       60
         (x - 8) (x - 7) (x - 6) (x - 3)
       + -------------------------------
                       84
      (%i4) f(x):=''%;
                     (x - 7) (x - 6) (x - 3) (x - 1)
      (%o4)  f(x) := -------------------------------
                                   35
         (x - 8) (x - 6) (x - 3) (x - 1)
       - -------------------------------
                       12
         7 (x - 8) (x - 7) (x - 3) (x - 1)
       + ---------------------------------
                        30
         (x - 8) (x - 7) (x - 6) (x - 1)
       - -------------------------------
                       60
         (x - 8) (x - 7) (x - 6) (x - 3)
       + -------------------------------
                       84
      (%i5) /* Evaluate the polynomial at some points */
            expand(map(f,[2.3,5/7,%pi]));
                                        4          3           2
                          919062  73 %pi    701 %pi    8957 %pi
      (%o5)  [- 1.567535, ------, ------- - -------- + ---------
                          84035     420       210         420
                                                   5288 %pi   186
                                                 - -------- + ---]
                                                     105       5
      (%i6) %,numer;
      (%o6) [- 1.567535, 10.9366573451538, 2.89319655125692]
      (%i7) load("draw")$  /* load draw package */
      (%i8) /* Plot the polynomial together with points */
            draw2d(
              color      = red,
              key        = "Lagrange polynomial",
              explicit(f(x),x,0,10),
              point_size = 3,
              color      = blue,
              key        = "Sample points",
              points(p))$
      (%i9) /* Change variable name */
            lagrange(p, varname=w);
             (w - 7) (w - 6) (w - 3) (w - 1)
      (%o9)  -------------------------------
                           35
         (w - 8) (w - 6) (w - 3) (w - 1)
       - -------------------------------
                       12
         7 (w - 8) (w - 7) (w - 3) (w - 1)
       + ---------------------------------
                        30
         (w - 8) (w - 7) (w - 6) (w - 1)
       - -------------------------------
                       60
         (w - 8) (w - 7) (w - 6) (w - 3)
       + -------------------------------
                       84

  Package interpol ·

関数: charfun2 (x, a, b)

  もし数 xが区間 [a, b)に属するなら、`true`を返し、 そうでないなら、 `false`を返します。

  Package interpol ·

関数: linearinterpol (points)
関数: linearinterpol (points, option)

  線形法で多項式内挿を計算します。 引数 pointsは以下のいずれかでなければいけません:

  - 2列行列, `p:matrix([2,4],[5,6],[9,3])`,
  - 対のリスト, `p: [[2,4],[5,6],[9,3]]`,
  - 数のリスト, `p: [4,6,3]`, この場合、横座標は自動的に1, 2, 3などに割り当てられます。

  最初の2つの場合には、 計算を行う前に、対は最初の座標に関して並び替えられます。

  option引数を使って、 独立変数の名前を選択することが可能です。 デフォルトでは `'x`です; 別のものを定義するには、 `varname='z`のようなものを書いてください。

  例:

      (%i1) load("interpol")$
      (%i2) p: matrix([7,2],[8,3],[1,5],[3,2],[6,7])$
      (%i3) linearinterpol(p);
              13   3 x
      (%o3)  (-- - ---) charfun2(x, minf, 3)
              2     2
       + (x - 5) charfun2(x, 7, inf) + (37 - 5 x) charfun2(x, 6, 7)
          5 x
       + (--- - 3) charfun2(x, 3, 6)
           3

      (%i4) f(x):=''%;
                      13   3 x
      (%o4)  f(x) := (-- - ---) charfun2(x, minf, 3)
                      2     2
       + (x - 5) charfun2(x, 7, inf) + (37 - 5 x) charfun2(x, 6, 7)
          5 x
       + (--- - 3) charfun2(x, 3, 6)
           3
      (%i5)  /* Evaluate the polynomial at some points */
             map(f,[7.3,25/7,%pi]);
                                  62  5 %pi
      (%o5)                 [2.3, --, ----- - 3]
                                  21    3
      (%i6) %,numer;
      (%o6)  [2.3, 2.952380952380953, 2.235987755982989]
      (%i7) load("draw")$  /* load draw package */
      (%i8)  /* Plot the polynomial together with points */
             draw2d(
               color      = red,
               key        = "Linear interpolator",
               explicit(f(x),x,-5,20),
               point_size = 3,
               color      = blue,
               key        = "Sample points",
               points(args(p)))$
      (%i9)  /* Change variable name */
             linearinterpol(p, varname='s);
             13   3 s
      (%o9) (-- - ---) charfun2(s, minf, 3)
             2     2
       + (s - 5) charfun2(s, 7, inf) + (37 - 5 s) charfun2(s, 6, 7)
          5 s
       + (--- - 3) charfun2(s, 3, 6)
           3

  Package interpol ·

関数: cspline (points)
関数: cspline (points, option1, option2, ...)

  三次スプライン法で多項式内挿を計算します。 引数 pointsは以下のいずれかでなければいけません:

  - 2列行列, `p:matrix([2,4],[5,6],[9,3])`,
  - 対のリスト, `p: [[2,4],[5,6],[9,3]]`,
  - 数のリスト, `p: [4,6,3]`, この場合、横座標は自動的に1, 2, 3などに割り当てられます。

  最初の2つの場合には、 計算を行う前に、対は最初の座標に関して並び替えられます。

  特定の必要性に合わせるため3つのオプションがあります:

  - `'d1`, デフォルトは `'unknown`, は x_1での一階導関数です; もし `'unknown`なら、 x_1での二階導関数は0に等しいとされます(自然な三次スプライン); もし数字だったら、二階導関数はこの数字に基づいて計算されます。
  - `'dn`, デフォルトは `'unknown`, は x_nでの一階導関数です; もし `'unknown`なら、 x_nでの二階導関数は0に等しいとされます(自然な三次スプライン); もし数字だったら、二階導関数はこの数字に基づいて計算されます。
  - `'varname`, デフォルトは `'x`, は 独立変数の名前です。

  例:

      (%i1) load("interpol")$
      (%i2) p:[[7,2],[8,2],[1,5],[3,2],[6,7]]$
      (%i3) /* Unknown first derivatives at the extremes
               is equivalent to natural cubic splines */
            cspline(p);
                    3         2
              1159 x    1159 x    6091 x   8283
      (%o3)  (------- - ------- - ------ + ----) charfun2(x, minf, 3)
               3288      1096      3288    1096
                  3         2
            2587 x    5174 x    494117 x   108928
       + (- ------- + ------- - -------- + ------) charfun2(x, 7, inf)
             1644       137       1644      137
                3          2
          4715 x    15209 x    579277 x   199575
       + (------- - -------- + -------- - ------) charfun2(x, 6, 7)
           1644       274        1644      274
                  3         2
            3287 x    2223 x    48275 x   9609
       + (- ------- + ------- - ------- + ----) charfun2(x, 3, 6)
             4932       274      1644     274

      (%i4) f(x):=''%$
      (%i5) /* Some evaluations */
            map(f,[2.3,5/7,%pi]), numer;
      (%o5) [1.991460766423356, 5.823200187269903, 2.227405312429507]
      (%i6) load("draw")$  /* load draw package */
      (%i7) /* Plotting interpolating function */
            draw2d(
              color      = red,
              key        = "Cubic splines",
              explicit(f(x),x,0,10),
              point_size = 3,
              color      = blue,
              key        = "Sample points",
              points(p))$
      (%i8) /* New call, but giving values at the derivatives */
            cspline(p,d1=0,dn=0);
                    3          2
              1949 x    11437 x    17027 x   1247
      (%o8)  (------- - -------- + ------- + ----) charfun2(x, minf, 3)
               2256       2256      2256     752
                  3          2
            1547 x    35581 x    68068 x   173546
       + (- ------- + -------- - ------- + ------) charfun2(x, 7, inf)
              564       564        141      141
               3          2
          607 x    35147 x    55706 x   38420
       + (------ - -------- + ------- - -----) charfun2(x, 6, 7)
           188       564        141      47
                  3         2
            3895 x    1807 x    5146 x   2148
       + (- ------- + ------- - ------ + ----) charfun2(x, 3, 6)
             5076       188      141      47
      (%i8) /* Defining new interpolating function */
            g(x):=''%$
      (%i9) /* Plotting both functions together */
            draw2d(
              color      = black,
              key        = "Cubic splines (default)",
              explicit(f(x),x,0,10),
              color      = red,
              key        = "Cubic splines (d1=0,dn=0)",
              explicit(g(x),x,0,10),
              point_size = 3,
              color      = blue,
              key        = "Sample points",
              points(p))$

  Package interpol ·

関数: ratinterpol (points, numdeg)
関数: ratinterpol (points, numdeg, option1, option2, ...)

  pointsで与えられたデータとnumdegに等しい分子の次数の関して、 有理形内挿を生成します; 分子の次数は自動的に計算されます。 引数 pointsは以下のいずれかでなければいけません:

  - 2列行列, `p:matrix([2,4],[5,6],[9,3])`,
  - 対のリスト, `p: [[2,4],[5,6],[9,3]]`,
  - 数のリスト, `p: [4,6,3]`, この場合、横座標は自動的に1, 2, 3などに割り当てられます。

  最初の2つの場合には、 計算を行う前に、対は最初の座標に関して並び替えられます。

  特定の必要性に合わせるため2つのオプションがあります:

  - `'denterm`, デフォルトは `1`, は 分子の中の多項式の独立項です。
  - `'varname`, デフォルトは `'x`, は 独立変数の名前です。

  例:

      (%i1) load("interpol")$
      (%i2) load("draw")$
      (%i3) p:[[7.2,2.5],[8.5,2.1],[1.6,5.1],[3.4,2.4],[6.7,7.9]]$
      (%i4) for k:0 thru length(p)-1 do
              draw2d(
                explicit(ratinterpol(p,k),x,0,9),
                point_size = 3,
                points(p),
                title = concat("Degree of numerator = ",k),
                yrange=[0,10])$

  Package interpol ·

Next: lbfgs, Previous: interpol, Up: Top [Contents][Index]

## 61 lapack

Next: Functions and Variables for lapack, Previous: lapack, Up: lapack [Contents][Index]

### 61.1 Introduction to lapack

`lapack`は SLATECプロジェクトから得られるようなFortranライブラリLAPACKの (プログラム `f2c`を介した) Common Lisp翻訳です。

(訳者注意書き: lapackを使用するには、load("lapack"); load("eigensys");を実行してください。load("lapack")には、初回だけコンパイルで時間がかかるかもしれません。)

Numerical methods ·Share packages ·Package lapack ·

Previous: Introduction to lapack, Up: lapack [Contents][Index]

### 61.2 Functions and Variables for lapack

関数: dgeev (A)
関数: dgeev (A, right_p, left_p)

  行列Aの固有値と、オプションで固有ベクトルを計算します。 Aの要素はすべて整数か浮動小数点数でなければいけません。 Aは平方(行と列が同じ数)でなければいけません。 Aは対称であってもなくてもいいです。

  `dgeev(A)`はAの固有値だけを計算します。 `dgeev(A, right_p, left_p)`は Aの固有値と、 right_p = `true`の時、右固有ベクトル、 left_p = `true`の時、左固有ベクトルを計算します。

  3項目のリストが返されます。 最初の項目は固有値のリストです。 二番目の項目は`false`か右固有ベクトルの行列です。 三番目の項目は`false`か左固有ベクトルの行列です。

  右固有ベクトルv(j) (右固有ベクトル行列のj番目の列)は

  A . v(j) = lambda(j) . v(j)

  を満たします。ここでlambda(j)は対応する固有値です。

  左固有ベクトルv(j) (左固有ベクトル行列のj番目の列)は

  u(j)**H . A = lambda(j) . u(j)**H

  を満たします。ここでu(j)**Hはu(j)の共役転置を意味します。 Maxima関数`ctranspose`が共役転置を計算します。

  計算された固有ベクトルは、 Euclideanノルムが1に等しく、 最大成分の虚部が0になるように規格化されます。

  例:

      (%i1) load ("lapack")$
      (%i2) fpprintprec : 6;
      (%o2)                           6
      (%i3) M : matrix ([9.5, 1.75], [3.25, 10.45]);
                               [ 9.5   1.75  ]
      (%o3)                    [             ]
                               [ 3.25  10.45 ]
      (%i4) dgeev (M);
      (%o4)          [[7.54331, 12.4067], false, false]
      (%i5) [L, v, u] : dgeev (M, true, true);
                                 [ - .666642  - .515792 ]
      (%o5) [[7.54331, 12.4067], [                      ],
                                 [  .745378   - .856714 ]
                                              [ - .856714  - .745378 ]
                                              [                      ]]
                                              [  .515792   - .666642 ]
      (%i6) D : apply (diag_matrix, L);
                            [ 7.54331     0    ]
      (%o6)                 [                  ]
                            [    0     12.4067 ]
      (%i7) M . v - v . D;
                      [      0.0       - 8.88178E-16 ]
      (%o7)           [                              ]
                      [ - 8.88178E-16       0.0      ]
      (%i8) transpose (u) . M - D . transpose (u);
                           [ 0.0  - 4.44089E-16 ]
      (%o8)                [                    ]
                           [ 0.0       0.0      ]

  Package lapack ·

関数: dgeqrf (A)

  行列 AのQR分解します。 All elements of Aのすべての要素は整数か浮動小数点数でなければいけません。 Aは行と列の数は同じかもしれませんし違うかもしれません。

  2つの項目のリストを返します。 一番目の項目は行列 Qで、それはAと同じ行数を持つ平方正規直交行列です。 二番目の項目は行列 Rで、それはAtお同じサイズで、 対角以下のすべての要素がが零に等しいものです。 積 `Q . R`は(浮動小数点の丸め誤差を除いて)Aに等しい。 ここで "."は非可換乗算演算子です。

      (%i1) load ("lapack") $
      (%i2) fpprintprec : 6 $
      (%i3) M : matrix ([1, -3.2, 8], [-11, 2.7, 5.9]) $
      (%i4) [q, r] : dgeqrf (M);
             [ - .0905357  .995893  ]
      (%o4) [[                      ],
             [  .995893    .0905357 ]
                                     [ - 11.0454   2.97863   5.15148 ]
                                     [                               ]]
                                     [     0      - 2.94241  8.50131 ]
      (%i5) q . r - M;
               [ - 7.77156E-16   1.77636E-15   - 8.88178E-16 ]
      (%o5)    [                                             ]
               [      0.0       - 1.33227E-15   8.88178E-16  ]
      (%i6) mat_norm (%, 1);
      (%o6)                      3.10862E-15

  Package lapack ·

関数: dgesv (A, b)

  線形方程式 A x = bの 解 xを計算します。 ここで、 Aは平方行列、 bはAと同じ数の行と任意の長さの列を持つ行列です。 戻り値 xは bと同じサイズです。

  Aと bの要素は `float`を介して実の浮動小数点数に評価されなければいけません; 従って、要素は任意の数値型か、数値定数のシンボルか、 浮動小数点に評価される式であり得ます。 xの要素はいつも浮動小数点数です。 すべての算術は浮動小数演算として実行されます。

  `dgesv`は AのLU分解を介して 解を計算します。

  例:

  `dgesv`は 線形方程式 A x = bの解を計算します。

      (%i1) A : matrix ([1, -2.5], [0.375, 5]);
                                     [   1    - 2.5 ]
      (%o1)                          [              ]
                                     [ 0.375    5   ]
      (%i2) b : matrix ([1.75], [-0.625]);
                                        [  1.75   ]
      (%o2)                             [         ]
                                        [ - 0.625 ]
      (%i3) x : dgesv (A, b);
                                  [  1.210526315789474  ]
      (%o3)                       [                     ]
                                  [ - 0.215789473684211 ]
      (%i4) dlange (inf_norm, b - A.x);
      (%o4)                                 0.0

  bはAと同じ数の行と任意の長さの列を持つ行列です。 xは bと同じサイズです。

      (%i1) A : matrix ([1, -0.15], [1.82, 2]);
                                     [  1    - 0.15 ]
      (%o1)                          [              ]
                                     [ 1.82    2    ]
      (%i2) b : matrix ([3.7, 1, 8], [-2.3, 5, -3.9]);
                                    [  3.7   1    8   ]
      (%o2)                         [                 ]
                                    [ - 2.3  5  - 3.9 ]
      (%i3) x : dgesv (A, b);
            [  3.103827540695117   1.20985481742191    6.781786185657722  ]
      (%o3) [                                                             ]
            [ - 3.974483062032557  1.399032116146062  - 8.121425428948527 ]
      (%i4) dlange (inf_norm, b - A . x);
      (%o4)                       1.1102230246251565E-15

  Aと bの要素は 実の浮動小数点数に評価されなければいけません;

      (%i1) A : matrix ([5, -%pi], [1b0, 11/17]);
                                     [   5    - %pi ]
                                     [              ]
      (%o1)                          [         11   ]
                                     [ 1.0b0   --   ]
                                     [         17   ]
      (%i2) b : matrix ([%e], [sin(1)]);
                                        [   %e   ]
      (%o2)                             [        ]
                                        [ sin(1) ]
      (%i3) x : dgesv (A, b);
                                   [ 0.690375643155986 ]
      (%o3)                        [                   ]
                                   [ 0.233510982552952 ]
      (%i4) dlange (inf_norm, b - A . x);
      (%o4)                        2.220446049250313E-16

  Package lapack ·Linear equations ·

関数: dgesvd (A)
関数: dgesvd (A, left_p, right_p)

  特異値から成る行列 Aの特異値分解(SVD)を計算します。 オプションで左および右特異ベクトルを取ります。

  Aの要素はすべて整数か浮動小数点数でなければいけません。 Aは(行と列が同じ数の)平方かもしれませんし、そうでないかもしれません。

  mを Aの行数、nを列数とします。 Aの特異値分解は A = U . Sigma . V^T のような3つの行列 U, Sigma, V^Tから構成されます。 ここで、 Uは m掛けmのユニタリ行列、 Sigmaは m掛けnの対角行列、 V^Tは n掛けnのユニタリ行列です。

  sigma[i]を Sigmaの対角要素、すなわち、 Sigma[i, i] = sigma[i]と します。 要素 sigma[i]は Aのいわゆる特異値です; これらは実数で、非負で、降順で返されます。 Uと Vの最初の min(m, n)列は Aの左と右特異ベクトルです。 `dgesvd`は、V自身ではなくVの転置を返すことに注意してください。

  `dgesvd(A)`は Aの特異値だけを計算します。 `dgesvd(A, left_p, right_p)`は Aの特異値と、 left_p = `true`の時、左特異ベクトル、 right_p = `true`の時、右特異ベクトルを計算します。

  3つの項目のリストが返されます。 一つ目の項目は特異値のリストです。 二つ目の項目は `false`か、左特異ベクトルの行列です。 三つ目の項目は `false`か、右特異ベクトルの行列です。

  例:

      (%i1) load ("lapack")$
      (%i2) fpprintprec : 6;
      (%o2)                           6
      (%i3) M: matrix([1, 2, 3], [3.5, 0.5, 8], [-1, 2, -3], [4, 9, 7]);
                              [  1    2    3  ]
                              [               ]
                              [ 3.5  0.5   8  ]
      (%o3)                   [               ]
                              [ - 1   2   - 3 ]
                              [               ]
                              [  4    9    7  ]
      (%i4) dgesvd (M);
      (%o4)      [[14.4744, 6.38637, .452547], false, false]
      (%i5) [sigma, U, VT] : dgesvd (M, true, true);
      (%o5) [[14.4744, 6.38637, .452547],
      [ - .256731  .00816168   .959029    - .119523 ]
      [                                             ]
      [ - .526456   .672116   - .206236   - .478091 ]
      [                                             ],
      [  .107997   - .532278  - .0708315  - 0.83666 ]
      [                                             ]
      [ - .803287  - .514659  - .180867    .239046  ]
      [ - .374486  - .538209  - .755044 ]
      [                                 ]
      [  .130623   - .836799   0.5317   ]]
      [                                 ]
      [ - .917986   .100488    .383672  ]
      (%i6) m : length (U);
      (%o6)                           4
      (%i7) n : length (VT);
      (%o7)                           3
      (%i8) Sigma:
              genmatrix(lambda ([i, j], if i=j then sigma[i] else 0),
                        m, n);
                        [ 14.4744     0        0    ]
                        [                           ]
                        [    0     6.38637     0    ]
      (%o8)             [                           ]
                        [    0        0     .452547 ]
                        [                           ]
                        [    0        0        0    ]
      (%i9) U . Sigma . VT - M;
                [  1.11022E-15        0.0       1.77636E-15 ]
                [                                           ]
                [  1.33227E-15    1.66533E-15       0.0     ]
      (%o9)     [                                           ]
                [ - 4.44089E-16  - 8.88178E-16  4.44089E-16 ]
                [                                           ]
                [  8.88178E-16    1.77636E-15   8.88178E-16 ]
      (%i10) transpose (U) . U;
             [     1.0      5.55112E-17    2.498E-16     2.77556E-17  ]
             [                                                        ]
             [ 5.55112E-17      1.0       5.55112E-17    4.16334E-17  ]
      (%o10) [                                                        ]
             [  2.498E-16   5.55112E-17       1.0       - 2.08167E-16 ]
             [                                                        ]
             [ 2.77556E-17  4.16334E-17  - 2.08167E-16       1.0      ]
      (%i11) VT . transpose (VT);
                [      1.0           0.0      - 5.55112E-17 ]
                [                                           ]
      (%o11)    [      0.0           1.0       5.55112E-17  ]
                [                                           ]
                [ - 5.55112E-17  5.55112E-17       1.0      ]

  Package lapack ·

関数: dlange (norm, A)
関数: zlange (norm, A)

  行列 Aのノルムもしくはノルムのような関数を計算します。

  `max`

    max(abs(A(i, j)))を計算します。 ここで iと jはそれぞれ行と列を行き渡ります。 この関数は適切な行列ノルムではないことに注意してください。

  `one_norm`

    Aの L[1]ノルム、 すなわち、それぞれの列の要素の絶対値の和の最大値 を計算します。

  `inf_norm`

    Aの L[inf]ノルム、 すなわち、それぞれの行の要素の絶対値の和の最大値 を計算します。

  `frobenius`

    AのFrobeniusノルム、すなわち、 行列要素の平方の和の平方根 を計算します。

  Package lapack ·

関数: dgemm (A, B)
関数: dgemm (A, B, options)

  2つの行列の積を計算します。オプションで積を三つ目の行列に足し算します。

  最も簡単な形式では、 `dgemm(A, B)`は 2つの実行列 Aと Bの積を計算します。

  二番目の形式では、 `dgemm`は alpha * A * B + beta * C を計算します。 ここで A, B, Cは 適当なサイズの実行列であり、 alphaと betaは実数です。 オプションで、 Aと/もしくは Bは 積を計算する前に転置を取ることができます。 追加のパラメータはオプションのキーワード引数で指定できます: キーワード引数はオプションで、 どんな順番でも指定できます。 それらはすべて、形式 `key=val`を取ります。 キーワード引数は以下の通りです:

  `C`

    足すべき行列 C。 デフォルトは `false`であり、行列を足さないことを意味します。

  `alpha`

    Aと Bの積がこの値に掛けられます。 デフォルトは1です。

  `beta`

    もし行列 Cが与えられたら、 この値は、足される前にCに掛けられます。 デフォルト値は0で、これは, たとえCが与えられても Cが足されないことを意味します。 故に、必ずbetaに零でない値を指定してください。

  `transpose_a`

    もし `true`なら、 Aの代わりにAの転置が積に使われます。 デフォルトは `false`です。

  `transpose_b`

    もし `true`なら Bの代わりにBの転置が積に使われます。 デフォルトは `false`です。

      (%i1) load ("lapack")$
      (%i2) A : matrix([1,2,3],[4,5,6],[7,8,9]);
                                        [ 1  2  3 ]
                                        [         ]
      (%o2)                             [ 4  5  6 ]
                                        [         ]
                                        [ 7  8  9 ]
      (%i3) B : matrix([-1,-2,-3],[-4,-5,-6],[-7,-8,-9]);
                                     [ - 1  - 2  - 3 ]
                                     [               ]
      (%o3)                          [ - 4  - 5  - 6 ]
                                     [               ]
                                     [ - 7  - 8  - 9 ]
      (%i4) C : matrix([3,2,1],[6,5,4],[9,8,7]);
                                        [ 3  2  1 ]
                                        [         ]
      (%o4)                             [ 6  5  4 ]
                                        [         ]
                                        [ 9  8  7 ]
      (%i5) dgemm(A,B);
                               [ - 30.0   - 36.0   - 42.0  ]
                               [                           ]
      (%o5)                    [ - 66.0   - 81.0   - 96.0  ]
                               [                           ]
                               [ - 102.0  - 126.0  - 150.0 ]
      (%i6) A . B;
                                  [ - 30   - 36   - 42  ]
                                  [                     ]
      (%o6)                       [ - 66   - 81   - 96  ]
                                  [                     ]
                                  [ - 102  - 126  - 150 ]
      (%i7) dgemm(A,B,transpose_a=true);
                               [ - 66.0  - 78.0   - 90.0  ]
                               [                          ]
      (%o7)                    [ - 78.0  - 93.0   - 108.0 ]
                               [                          ]
                               [ - 90.0  - 108.0  - 126.0 ]
      (%i8) transpose(A) . B;
                                 [ - 66  - 78   - 90  ]
                                 [                    ]
      (%o8)                      [ - 78  - 93   - 108 ]
                                 [                    ]
                                 [ - 90  - 108  - 126 ]
      (%i9) dgemm(A,B,c=C,beta=1);
                               [ - 27.0  - 34.0   - 41.0  ]
                               [                          ]
      (%o9)                    [ - 60.0  - 76.0   - 92.0  ]
                               [                          ]
                               [ - 93.0  - 118.0  - 143.0 ]
      (%i10) A . B + C;
                                  [ - 27  - 34   - 41  ]
                                  [                    ]
      (%o10)                      [ - 60  - 76   - 92  ]
                                  [                    ]
                                  [ - 93  - 118  - 143 ]
      (%i11) dgemm(A,B,c=C,beta=1, alpha=-1);
                                  [ 33.0   38.0   43.0  ]
                                  [                     ]
      (%o11)                      [ 72.0   86.0   100.0 ]
                                  [                     ]
                                  [ 111.0  134.0  157.0 ]
      (%i12) -A . B + C;
                                     [ 33   38   43  ]
                                     [               ]
      (%o12)                         [ 72   86   100 ]
                                     [               ]
                                     [ 111  134  157 ]

  Package lapack ·

Next: lindstedt, Previous: lapack, Up: Top [Contents][Index]

## 62 lbfgs

Next: Functions and Variables for lbfgs, Previous: Top, Up: Top [Contents][Index]

### 62.1 Introduction to lbfgs

`lbfgs`はL-BFGS algorithm [1]の実装であり、 限定メモリ準ニュートン(BFGS)アルゴリズムによって無制約な最小化問題を解きます。 Hessian行列の逆元全体の代わりに低ランク近似が保存されるので、限定メモリと呼ばれます。 プログラムは、 Jorge Nocedalによって、 Jorge J. MoréとDavid J. Thuenteが最初に書いたいくつかの関数を組み入れて 最初、Fortranで書かれ、 プログラム`f2cl`によってLispに自動翻訳されました。

Maximaパッケージ`lbfgs`は翻訳されたコードと いくつかの詳細を扱うインターフェース関数からなります。

参考文献:

[1] D. Liu and J. Nocedal. "On the limited memory BFGS method for large scale optimization". Mathematical Programming B 45:503–528 (1989)

[2] http://netlib.org/opt/lbfgs_um.shar

Numerical methods ·Optimization ·Share packages ·Package lbfgs ·

Previous: Introduction to lbfgs, Up: Top [Contents][Index]

### 62.2 Functions and Variables for lbfgs

関数: lbfgs (FOM, X, X0, epsilon, iprint)
関数: lbfgs ([FOM, grad], X, X0, epsilon, iprint)

  性能指標FOMの、 初期見積もりX0から始めて 変数リストX上での、 norm(grad(FOM)) < epsilon*max(1, norm(X))のような 無制約最小化の近似解を見つけます。

  もし与えられたなら、gradはFOMの多変数Xに関する勾配です。 gradはXの要素それぞれに対して1つの要素を持つリストです。 もし与えられなかったら、勾配は記号微分で自動的に計算されます。

  適用されるアルゴリズムは限定メモリ準Newton(BFGS)アルゴリズム [1]です。 Hessian行列の逆元全体の代わりに低ランク近似が保存されるので、限定メモリと呼ばれます。 アルゴリズムのそれぞれの繰り返しは直線探索です。 すなわち、変数Xに関して、近似Hessian逆元から計算される探索方向の線(ray)に沿っての探索です。 FOMはいつも直線探索でうまく減少します。 普通(しかしいつもではありません)FOMの勾配のノルムも減少します。

  iprintは`lbfgs`が印字する進捗メッセージを制御します。

  `iprint[1]`

    `iprint[1]` controls the frequency of progress messages.

    `iprint[1] < 0`

      進捗メッセージなし。

    `iprint[1] = 0`

      最初と最後の繰り返しでメッセージ。

    `iprint[1] > 0`

      毎`iprint[1]`回の繰り返してメッセージを印字する。

  `iprint[2]`

    `iprint[2]`は進捗メッセージの量を制御します。

    `iprint[2] = 0`

      繰り返し回数、FOMの評価回数、FOMの値、FOMの勾配のノルム、ステップ長 を印字します。

    `iprint[2] = 1`

      `iprint[2] = 0`に加えて、 X0とX0で評価されたFOMの勾配を印字します。

    `iprint[2] = 2`

      `iprint[2] = 1`に加えて、 繰り返しそれぞれでXの値を印字します。

    `iprint[2] = 3`

      `iprint[2] = 2`に加えて、 繰り返しそれぞれでFOMの勾配を印字します。

  `lbfgs`が印字する列は以下の通りです。

  `I`

    繰り返し関数。それぞれの直線探索で増えます。

  `NFN`

    性能指標の評価回数。

  `FUNC`

    最も最近の直線探索の最後での性能指標の値。

  `GNORM`

    最も最近の直線探索の最後での性能指標の勾配のノルム。

  `STEPLENGTH`

    探索アルゴリズムの内部パラメータ。

  アルゴリズムの詳細に関係する付加情報は、元々のFortranコード[2]のコメントに見つけられます。

  `lbfgs_nfeval_max`と`lbfgs_ncorrections`も参照してください。

  参考文献:

  [1] D. Liu and J. Nocedal. "On the limited memory BFGS method for large scale optimization". Mathematical Programming B 45:503–528 (1989)

  [2] http://netlib.org/opt/lbfgs_um.shar

  例:

  NetlibからのLBFGSパッケージの中で、プログラムsdrive.f中、 FGCOMPUTEが計算したのと同じFOM。 問題の変数が添字付き変数であることに注意してください。 FOMはu[k] = 1(k = 1, ..., 8)で0に等しい厳密な最小を持ちます。

      (%i1) load ("lbfgs");
      (%o1)   /usr/share/maxima/5.10.0cvs/share/lbfgs/lbfgs.mac
      (%i2) t1[j] := 1 - u[j];
      (%o2)                     t1  := 1 - u
                                  j         j
      (%i3) t2[j] := 10*(u[j + 1] - u[j]^2);
                                                2
      (%o3)                t2  := 10 (u      - u )
                             j         j + 1    j
      (%i4) n : 8;
      (%o4)                           8
      (%i5) FOM : sum (t1[2*j - 1]^2 + t2[2*j - 1]^2, j, 1, n/2);
                       2 2           2              2 2           2
      (%o5) 100 (u  - u )  + (1 - u )  + 100 (u  - u )  + (1 - u )
                  8    7           7           6    5           5
                           2 2           2              2 2           2
              + 100 (u  - u )  + (1 - u )  + 100 (u  - u )  + (1 - u )
                      4    3           3           2    1           1
      (%i6) lbfgs (FOM, '[u[1],u[2],u[3],u[4],u[5],u[6],u[7],u[8]],
             [-1.2, 1, -1.2, 1, -1.2, 1, -1.2, 1], 1e-3, [1, 0]);
      *************************************************
        N=    8   NUMBER OF CORRECTIONS=25
             INITIAL VALUES
       F=  9.680000000000000D+01   GNORM=  4.657353755084532D+02
      *************************************************

       I NFN   FUNC                    GNORM                   STEPLENGTH

       1   3   1.651479526340304D+01   4.324359291335977D+00   7.926153934390631D-04
       2   4   1.650209316638371D+01   3.575788161060007D+00   1.000000000000000D+00
       3   5   1.645461701312851D+01   6.230869903601577D+00   1.000000000000000D+00
       4   6   1.636867301275588D+01   1.177589920974980D+01   1.000000000000000D+00
       5   7   1.612153014409201D+01   2.292797147151288D+01   1.000000000000000D+00
       6   8   1.569118407390628D+01   3.687447158775571D+01   1.000000000000000D+00
       7   9   1.510361958398942D+01   4.501931728123680D+01   1.000000000000000D+00
       8  10   1.391077875774294D+01   4.526061463810632D+01   1.000000000000000D+00
       9  11   1.165625686278198D+01   2.748348965356917D+01   1.000000000000000D+00
      10  12   9.859422687859137D+00   2.111494974231644D+01   1.000000000000000D+00
      11  13   7.815442521732281D+00   6.110762325766556D+00   1.000000000000000D+00
      12  15   7.346380905773160D+00   2.165281166714631D+01   1.285316401779533D-01
      13  16   6.330460634066370D+00   1.401220851762050D+01   1.000000000000000D+00
      14  17   5.238763939851439D+00   1.702473787613255D+01   1.000000000000000D+00
      15  18   3.754016790406701D+00   7.981845727704576D+00   1.000000000000000D+00
      16  20   3.001238402309352D+00   3.925482944716691D+00   2.333129631296807D-01
      17  22   2.794390709718290D+00   8.243329982546473D+00   2.503577283782332D-01
      18  23   2.563783562918759D+00   1.035413426521790D+01   1.000000000000000D+00
      19  24   2.019429976377856D+00   1.065187312346769D+01   1.000000000000000D+00
      20  25   1.428003167670903D+00   2.475962450826961D+00   1.000000000000000D+00
      21  27   1.197874264861340D+00   8.441707983493810D+00   4.303451060808756D-01
      22  28   9.023848941942773D-01   1.113189216635162D+01   1.000000000000000D+00
      23  29   5.508226405863770D-01   2.380830600326308D+00   1.000000000000000D+00
      24  31   3.902893258815567D-01   5.625595816584421D+00   4.834988416524465D-01
      25  32   3.207542206990315D-01   1.149444645416472D+01   1.000000000000000D+00
      26  33   1.874468266362791D-01   3.632482152880997D+00   1.000000000000000D+00
      27  34   9.575763380706598D-02   4.816497446154354D+00   1.000000000000000D+00
      28  35   4.085145107543406D-02   2.087009350166495D+00   1.000000000000000D+00
      29  36   1.931106001379290D-02   3.886818608498966D+00   1.000000000000000D+00
      30  37   6.894000721499670D-03   3.198505796342214D+00   1.000000000000000D+00
      31  38   1.443296033051864D-03   1.590265471025043D+00   1.000000000000000D+00
      32  39   1.571766603154336D-04   3.098257063980634D-01   1.000000000000000D+00
      33  40   1.288011776581970D-05   1.207784183577257D-02   1.000000000000000D+00
      34  41   1.806140173752971D-06   4.587890233385193D-02   1.000000000000000D+00
      35  42   1.769004645459358D-07   1.790537375052208D-02   1.000000000000000D+00
      36  43   3.312164100763217D-10   6.782068426119681D-04   1.000000000000000D+00

       THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
       IFLAG = 0
      (%o6) [u  = 1.000005339815974, u  = 1.000009942839805,
              1                       2
      u  = 1.000005339815974, u  = 1.000009942839805,
       3                       4
      u  = 1.000005339815974, u  = 1.000009942839805,
       5                       6
      u  = 1.000005339815974, u  = 1.000009942839805]
       7                       8

  回帰問題。 FOMは、予言値F(X[i])と観測値Y[i]の二乗平均差です。 関数Fは有界な単調関数(いわゆる「シグモイド」函数)です。 この例では、Fのパラメータに関して`lbfgs`は近似値を計算し、 `plot2d`はFの観測データとの比較を表示します。

      (%i1) load ("lbfgs");
      (%o1)   /usr/share/maxima/5.10.0cvs/share/lbfgs/lbfgs.mac
      (%i2) FOM : '((1/length(X))*sum((F(X[i]) - Y[i])^2, i, 1,
                                                      length(X)));
                                     2
                     sum((F(X ) - Y ) , i, 1, length(X))
                             i     i
      (%o2)          -----------------------------------
                                  length(X)
      (%i3) X : [1, 2, 3, 4, 5];
      (%o3)                    [1, 2, 3, 4, 5]
      (%i4) Y : [0, 0.5, 1, 1.25, 1.5];
      (%o4)                [0, 0.5, 1, 1.25, 1.5]
      (%i5) F(x) := A/(1 + exp(-B*(x - C)));
                                         A
      (%o5)            F(x) := ----------------------
                               1 + exp((- B) (x - C))
      (%i6) ''FOM;
                      A               2            A                2
      (%o6) ((----------------- - 1.5)  + (----------------- - 1.25)
                - B (5 - C)                  - B (4 - C)
              %e            + 1            %e            + 1
                  A             2            A               2
       + (----------------- - 1)  + (----------------- - 0.5)
            - B (3 - C)                - B (2 - C)
          %e            + 1          %e            + 1
                   2
                  A
       + --------------------)/5
            - B (1 - C)     2
         (%e            + 1)
      (%i7) estimates : lbfgs (FOM, '[A, B, C], [1, 1, 1], 1e-4, [1, 0]);
      *************************************************
        N=    3   NUMBER OF CORRECTIONS=25
             INITIAL VALUES
       F=  1.348738534246918D-01   GNORM=  2.000215531936760D-01
      *************************************************

      I  NFN  FUNC                    GNORM                   STEPLENGTH
      1    3  1.177820636622582D-01   9.893138394953992D-02   8.554435968992371D-01
      2    6  2.302653892214013D-02   1.180098521565904D-01   2.100000000000000D+01
      3    8  1.496348495303005D-02   9.611201567691633D-02   5.257340567840707D-01
      4    9  7.900460841091139D-03   1.325041647391314D-02   1.000000000000000D+00
      5   10  7.314495451266917D-03   1.510670810312237D-02   1.000000000000000D+00
      6   11  6.750147275936680D-03   1.914964958023047D-02   1.000000000000000D+00
      7   12  5.850716021108205D-03   1.028089194579363D-02   1.000000000000000D+00
      8   13  5.778664230657791D-03   3.676866074530332D-04   1.000000000000000D+00
      9   14  5.777818823650782D-03   3.010740179797255D-04   1.000000000000000D+00

       THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
       IFLAG = 0
      (%o7) [A = 1.461933911464101, B = 1.601593973254802,
                                                 C = 2.528933072164854]
      (%i8) plot2d ([F(x), [discrete, X, Y]], [x, -1, 6]), ''estimates;
      (%o8)

  FOMの勾配が(自動的に計算される代わりに)指定されます。

      (%i1) load ("lbfgs")$
      (%i2) F(a, b, c) := (a - 5)^2 + (b - 3)^4 + (c - 2)^6;
                                     2          4          6
      (%o2)     F(a, b, c) := (a - 5)  + (b - 3)  + (c - 2)
      (%i3) F_grad : map (lambda ([x], diff (F(a, b, c), x)), [a, b, c]);
                                          3           5
      (%o3)          [2 (a - 5), 4 (b - 3) , 6 (c - 2) ]
      (%i4) estimates : lbfgs ([F(a, b, c), F_grad],
                               [a, b, c], [0, 0, 0], 1e-4, [1, 0]);
      *************************************************
        N=    3   NUMBER OF CORRECTIONS=25
             INITIAL VALUES
       F=  1.700000000000000D+02   GNORM=  2.205175729958953D+02
      *************************************************

         I  NFN     FUNC                    GNORM                   STEPLENGTH

         1    2     6.632967565917638D+01   6.498411132518770D+01   4.534785987412505D-03
         2    3     4.368890936228036D+01   3.784147651974131D+01   1.000000000000000D+00
         3    4     2.685298972775190D+01   1.640262125898521D+01   1.000000000000000D+00
         4    5     1.909064767659852D+01   9.733664001790506D+00   1.000000000000000D+00
         5    6     1.006493272061515D+01   6.344808151880209D+00   1.000000000000000D+00
         6    7     1.215263596054294D+00   2.204727876126879D+00   1.000000000000000D+00
         7    8     1.080252896385334D-02   1.431637116951849D-01   1.000000000000000D+00
         8    9     8.407195124830908D-03   1.126344579730013D-01   1.000000000000000D+00
         9   10     5.022091686198527D-03   7.750731829225274D-02   1.000000000000000D+00
        10   11     2.277152808939775D-03   5.032810859286795D-02   1.000000000000000D+00
        11   12     6.489384688303218D-04   1.932007150271008D-02   1.000000000000000D+00
        12   13     2.075791943844548D-04   6.964319310814364D-03   1.000000000000000D+00
        13   14     7.349472666162257D-05   4.017449067849554D-03   1.000000000000000D+00
        14   15     2.293617477985237D-05   1.334590390856715D-03   1.000000000000000D+00
        15   16     7.683645404048675D-06   6.011057038099201D-04   1.000000000000000D+00

       THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
       IFLAG = 0
      (%o4) [a = 5.000086823042934, b = 3.05239542970518,
                                                 c = 1.927980629919583]

  Package lbfgs ·

変数: lbfgs_nfeval_max

  デフォルト値: 100

  `lbfgs_nfeval_max`は、`lbfgs`がする性能指標(FOM)の評価の最大回数です。 `lbfgs_nfeval_max`に届いた時、 `lbfgs`は最後に成功した直線探索の結果を返します。

  Package lbfgs ·

変数: lbfgs_ncorrections

  デフォルト値: 25

  `lbfgs_ncorrections`は`lbfgs`が保つ近似逆Hessian行列に適用された修正回数です。

  Package lbfgs ·

Next: linearalgebra, Previous: lbfgs, Up: Top [Contents][Index]

## 63 lindstedt

Previous: lindstedt, Up: lindstedt [Contents][Index]

### 63.1 Functions and Variables for lindstedt

関数: Lindstedt (eq,pvar,torder,ic)

  これはLindstedtコードで最初のパスです。 摂動方程式上の初期条件が i>0に対して z[i]=0, z'[i]=0で、 入力した初期条件―(%k1と%k2だけでなく)任意の定数があり得ます―で問題を解くことができます。 icは初期条件のリストです。

  初期条件が与えられない時、 摂動方程式の中の定数がゼロ次方程式解と同じなので、問題が起こります。 また、Van der Pol方程式のように、摂動方程式の初期条件がi>0に対して z[i]=0, z'[i]=0でない時、問題が起こります。

  例:

      (%i1) load("makeOrders")$

      (%i2) load("lindstedt")$

      (%i3) Lindstedt('diff(x,t,2)+x-(e*x^3)/6,e,2,[1,0]);
                2
               e  (cos(5 T) - 24 cos(3 T) + 23 cos(T))
      (%o3) [[[---------------------------------------
                                36864
         e (cos(3 T) - cos(T))
       - --------------------- + cos(T)],
                  192
                2
             7 e    e
      T = (- ---- - -- + 1) t]]
             3072   16

  この関数を使うには、最初に`load("makeOrders")`と`load("lindstedt")`を書いてください。

  Differential equations ·Share packages ·Package lindstedt ·

Next: lsquares, Previous: lindstedt, Up: Top [Contents][Index]

## 64 linearalgebra

Next: Functions and Variables for linearalgebra, Previous: linearalgebra, Up: linearalgebra [Contents][Index]

### 64.1 Introduction to linearalgebra

`linearalgebra`は線形代数に関する関数のコレクションです。

例:

    (%i1) M : matrix ([1, 2], [1, 2]);
                                [ 1  2 ]
    (%o1)                       [      ]
                                [ 1  2 ]
    (%i2) nullspace (M);
                                   [  1  ]
                                   [     ]
    (%o2)                     span([   1 ])
                                   [ - - ]
                                   [   2 ]
    (%i3) columnspace (M);
                                    [ 1 ]
    (%o3)                      span([   ])
                                    [ 1 ]
    (%i4) ptriangularize (M - z*ident(2), z);
                             [ 1   2 - z   ]
    (%o4)                    [             ]
                             [           2 ]
                             [ 0  3 z - z  ]
    (%i5) M : matrix ([1, 2, 3], [4, 5, 6], [7, 8, 9]) - z*ident(3);
                         [ 1 - z    2      3   ]
                         [                     ]
    (%o5)                [   4    5 - z    6   ]
                         [                     ]
                         [   7      8    9 - z ]
    (%i6) MM : ptriangularize (M, z);
                  [ 4  5 - z            6            ]
                  [                                  ]
                  [                2                 ]
                  [     66        z    102 z   132   ]
                  [ 0   --      - -- + ----- + ---   ]
    (%o6)         [     49        7     49     49    ]
                  [                                  ]
                  [               3        2         ]
                  [           49 z    245 z    147 z ]
                  [ 0    0    ----- - ------ - ----- ]
                  [            264      88      44   ]
    (%i7) algebraic : true;
    (%o7)                         true
    (%i8) tellrat (MM [3, 3]);
                             3       2
    (%o8)                  [z  - 15 z  - 18 z]
    (%i9) MM : ratsimp (MM);
                   [ 4  5 - z           6           ]
                   [                                ]
                   [                2               ]
    (%o9)          [     66      7 z  - 102 z - 132 ]
                   [ 0   --    - ------------------ ]
                   [     49              49         ]
                   [                                ]
                   [ 0    0             0           ]
    (%i10) nullspace (MM);
                            [        1         ]
                            [                  ]
                            [   2              ]
                            [  z  - 14 z - 16  ]
                            [  --------------  ]
    (%o10)             span([        8         ])
                            [                  ]
                            [    2             ]
                            [   z  - 18 z - 12 ]
                            [ - -------------- ]
                            [         12       ]
    (%i11) M : matrix ([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12],
                       [13, 14, 15, 16]);
                           [ 1   2   3   4  ]
                           [                ]
                           [ 5   6   7   8  ]
    (%o11)                 [                ]
                           [ 9   10  11  12 ]
                           [                ]
                           [ 13  14  15  16 ]
    (%i12) columnspace (M);
                               [ 1  ]  [ 2  ]
                               [    ]  [    ]
                               [ 5  ]  [ 6  ]
    (%o12)                span([    ], [    ])
                               [ 9  ]  [ 10 ]
                               [    ]  [    ]
                               [ 13 ]  [ 14 ]
    (%i13) apply ('orthogonal_complement, args (nullspace (transpose (M))));
                               [ 0 ]  [  1  ]
                               [   ]  [     ]
                               [ 1 ]  [  0  ]
    (%o13)                span([   ], [     ])
                               [ 2 ]  [ - 1 ]
                               [   ]  [     ]
                               [ 3 ]  [ - 2 ]

Linear algebra ·Share packages ·Package linearalgebra ·

Previous: Introduction to linearalgebra, Up: linearalgebra [Contents][Index]

### 64.2 Functions and Variables for linearalgebra

関数: addmatrices (f, M_1, …, M_n)

  関数fを加算関数として使い、 行列M_1, …, M_nの和を返します。 関数fは任意の数の引数を受け付けなければいけません(Maxima n項関数)。

  例:

      (%i1) m1 : matrix([1,2],[3,4])$
      (%i2) m2 : matrix([7,8],[9,10])$
      (%i3) addmatrices('max,m1,m2);
      (%o3) matrix([7,8],[9,10])
      (%i4) addmatrices('max,m1,m2,5*m1);
      (%o4) matrix([7,10],[15,20])

  Package linearalgebra ·

関数: blockmatrixp (M)

  Mのエントリがすべて行列なら、その時に限って、 trueを返します。

  Package linearalgebra ·Predicate functions ·

関数: columnop (M, i, j, theta)

  もしMが行列なら、 列演算`C_i <- C_i - theta * C_j`を施すことで生じる行列を返します。 もしMが行iか行jを持たないなら エラーをシグナルします。

  Package linearalgebra ·

関数: columnswap (M, i, j)

  もし Mが行列なら、列 iと jを交換します。 もし Mに列 iか jがないなら、 エラーをシグナルします。

  Package linearalgebra ·

関数: columnspace (M)

  もし Mが行列なら、 `span (v_1, ..., v_n)`を返します。 ここで、集合 `{v_1, ..., v_n}`は Mの列空間の基底です。 空集合の包は `{0}`です。 従って、列空間が1員だけ持つ時、 `span ()`を返します。

  Package linearalgebra ·

関数: copy (e)

  Maxima式 eのコピーを返します。 eは任意のMaxima式であり得ますが、 eがリストか行列の時、 コピー関数はもっとも役立ちます; 以下を考えてください:

      (%i1) m : [1,[2,3]]$
      (%i2) mm : m$
      (%i3) mm[2][1] : x$
      (%i4) m;
      (%o4)                      [1,[x,3]]
      (%i5) mm;
      (%o5)                      [1,[x,3]]

  同じ実験を試みましょう。 しかし、今回 mmを mのコピーとします。

      (%i6) m : [1,[2,3]]$
      (%i7) mm : copy(m)$
      (%i8) mm[2][1] : x$
      (%i9) m;
      (%o9)                     [1,[2,3]]
      (%i10) mm;
      (%o10)                    [1,[x,3]]

  今回、 mmへの割り当てはmの値を変えません。

  Package linearalgebra ·

関数: cholesky (M)
関数: cholesky (M, field)

  自己共役(すなわちHermite)行列のCholesky分解を返します。

  二番目の引数はデフォルトでは’generalring’です。 fieldの取り得る値の説明については `lu_factor`を参照してください。

  Matrix decompositions ·Package linearalgebra ·

関数: ctranspose (M)

  行列 Mの複素共役転置を返します。 関数 `ctranspose`は それぞれの行列要素を転置するのに `matrix_element_transpose`を使います。

  Package linearalgebra ·

関数: diag_matrix (d_1, d_2,...,d_n)

  対角成分 d_1, d_2,...,d_nを持つ対角行列を返します。 対角成分が行列の時、 戻り値行列の零成分は 適切なサイズの零行列です; 例えば:

      (%i1) diag_matrix(diag_matrix(1,2),diag_matrix(3,4));

                                  [ [ 1  0 ]  [ 0  0 ] ]
                                  [ [      ]  [      ] ]
                                  [ [ 0  2 ]  [ 0  0 ] ]
      (%o1)                       [                    ]
                                  [ [ 0  0 ]  [ 3  0 ] ]
                                  [ [      ]  [      ] ]
                                  [ [ 0  0 ]  [ 0  4 ] ]
      (%i2) diag_matrix(p,q);

                                         [ p  0 ]
      (%o2)                              [      ]
                                         [ 0  q ]

  Package linearalgebra ·

関数: dotproduct (u, v)

  ベクトル uと vの内積を返します。 これは`conjugate (transpose (u)) . v`と同じです。 引数 uと vは列ベクトルでなければいけません。

  Package linearalgebra ·

関数: eigens_by_jacobi (A)
関数: eigens_by_jacobi (A, field_type)

  Aの固有値と固有ベクトルを Jacobi回転法で計算します。 Aは対称行列でなければいけません。 (しかし、正定値である必要も半正定値である必要もありません。) field_typeは計算上の体を示し、`floatfield`か `bigfloatfield`です。 もし field_typeが指定されないなら、 デフォルトは `floatfield`です。

  Aの要素は、数か、 (field_typeに依存して)`float`か `bfloat`を介して 数に評価される式でなければいけません。

  例:

      (%i1) S: matrix([1/sqrt(2), 1/sqrt(2)],[-1/sqrt(2), 1/sqrt(2)]);
                           [     1         1    ]
                           [  -------   ------- ]
                           [  sqrt(2)   sqrt(2) ]
      (%o1)                [                    ]
                           [      1        1    ]
                           [ - -------  ------- ]
                           [   sqrt(2)  sqrt(2) ]
      (%i2) L : matrix ([sqrt(3), 0], [0, sqrt(5)]);
                            [ sqrt(3)     0    ]
      (%o2)                 [                  ]
                            [    0     sqrt(5) ]
      (%i3) M : S . L . transpose (S);
                  [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
                  [ ------- + -------  ------- - ------- ]
                  [    2         2        2         2    ]
      (%o3)       [                                      ]
                  [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
                  [ ------- - -------  ------- + ------- ]
                  [    2         2        2         2    ]
      (%i4) eigens_by_jacobi (M);
      The largest percent change was 0.1454972243679
      The largest percent change was 0.0
      number of sweeps: 2
      number of rotations: 1
      (%o4) [[1.732050807568877, 2.23606797749979],
                              [  0.70710678118655   0.70710678118655 ]
                              [                                      ]]
                              [ - 0.70710678118655  0.70710678118655 ]
      (%i5) float ([[sqrt(3), sqrt(5)], S]);
      (%o5) [[1.732050807568877, 2.23606797749979],
                              [  0.70710678118655   0.70710678118655 ]
                              [                                      ]]
                              [ - 0.70710678118655  0.70710678118655 ]
      (%i6) eigens_by_jacobi (M, bigfloatfield);
      The largest percent change was 1.454972243679028b-1
      The largest percent change was 0.0b0
      number of sweeps: 2
      number of rotations: 1
      (%o6) [[1.732050807568877b0, 2.23606797749979b0],
                      [  7.071067811865475b-1   7.071067811865475b-1 ]
                      [                                              ]]
                      [ - 7.071067811865475b-1  7.071067811865475b-1 ]

  Matrix decompositions ·Package linearalgebra ·

関数: get_lu_factors (x)

  `x = lu_factor (A)`の時、 `get_lu_factors`は 形式 `[P, L, U]`のリストを返します。 ここで、 Pは置換行列、 Lは対角成分を含む下三角行列、 Uは上三角行列であり、 `A = P L U`が成り立ちます。

  Package linearalgebra ·

関数: hankel (col)
関数: hankel (col, row)

  Hankel行列 Hを返します。 Hの最初の列は colです; 最初の成分を除いて、 Hの最後の行は rowです。 rowのデフォルトは colと同じ長さを持つ零ベクトルです。

  Package linearalgebra ·

関数: hessian (f, x)

  変数 xのリストに関する fのHessian行列を返します。 Hessian行列の `(i, j)`成分は `diff(f, x[i], 1, x[j], 1)`です。

  例:

      (%i1) hessian (x * sin (y), [x, y]);
                           [   0       cos(y)   ]
      (%o1)                [                    ]
                           [ cos(y)  - x sin(y) ]
      (%i2) depends (F, [a, b]);
      (%o2)                       [F(a, b)]
      (%i3) hessian (F, [a, b]);
                              [   2      2   ]
                              [  d F    d F  ]
                              [  ---   ----- ]
                              [    2   da db ]
                              [  da          ]
      (%o3)                   [              ]
                              [   2      2   ]
                              [  d F    d F  ]
                              [ -----   ---  ]
                              [ da db     2  ]
                              [         db   ]

  Differential calculus ·Package linearalgebra ·

関数: hilbert_matrix (n)

  n掛けnのHilbert行列を返します。 nが正の整数でない時、エラーをシグナルします。

  Package linearalgebra ·

関数: identfor (M)
関数: identfor (M, fld)

  行列 Mと同じ形を持つ単位行列を返します。 単位行列の対角成分は体 fldの乗算単位元です; fldのデフォルトは generalringです。

  一番目の引数 Mは平方行列か非行列でなければいけません。 Mが行列の時、 Mのそれぞれの成分は平方行列であり得ます。 – 従って、 Mは区分されたMaxima行列であり得ます。 行列は、任意の(有限の)深さに区分できます。

  `zerofor`も参照してください。

  Package linearalgebra ·

関数: invert_by_lu (M, (rng generalring))

  LU分解を使って、 行列 Mの逆行列を返します。 LU分解は環 rngを使って実行されます。

  Package linearalgebra ·

関数: jacobian (f, x)

  変数のリスト xに関する 関数のリスト fのJacobi行列を返します。 Jacobi行列の `(i, j)`成分は `diff(f[i], x[j])`です。

  例:

      (%i1) jacobian ([sin (u - v), sin (u * v)], [u, v]);
                        [ cos(v - u)  - cos(v - u) ]
      (%o1)             [                          ]
                        [ v cos(u v)   u cos(u v)  ]
      (%i2) depends ([F, G], [y, z]);
      (%o2)                  [F(y, z), G(y, z)]
      (%i3) jacobian ([F, G], [y, z]);
                                 [ dF  dF ]
                                 [ --  -- ]
                                 [ dy  dz ]
      (%o3)                      [        ]
                                 [ dG  dG ]
                                 [ --  -- ]
                                 [ dy  dz ]

  Differential calculus ·Package linearalgebra ·

関数: kronecker_product (A, B)

  行列 Aと BのKronecker積を返します。

  Package linearalgebra ·

関数: listp (e, p)
関数: listp (e)

  オプションの引数 pが与えられたとして、 もし eがMaximaリストで、 pがすべてのリストの要素で `true`に評価されるなら、 `true`を返します。 `listp`がオプションの引数を与えられない時、 もし eがMaximaリストなら、 `true`を返します。 他のすべての場合、 `false`を返します。

  Package linearalgebra ·Predicate functions ·

関数: locate_matrix_entry (M, r_1, c_1, r_2, c_2, f, rel)

  一番目の引数は行列でなければいけません; 引数 r_1から c_2は 行 r_1から r_2と列 c_1から c_2から成る Mの部分行列を決定します。

  ある性質を満たす部分行列 Mの中の成分を見つけます。 3つのケース:

  (1) `rel = 'bool`で fが述語論理:

  左から右へ、そして上から下へ部分行列をスキャンし、 述語論理 fを満たす最初の成分のインデックスを返します。 もし fを満たす行列成分がないなら、 `false`を返します。

  (2) `rel = 'max`で fが実関数:

  fを最大にする成分を探して部分行列をスキャンします。 最大化の成分のインデックスを返します。

  (3) `rel = 'min`で fが実関数:

  fを最小にする成分を探して部分行列をスキャンします。 最小化の成分のインデックスを返します。

  Package linearalgebra ·

関数: lu_backsub (M, b)

  `M = lu_factor (A, field)`の時、 `lu_backsub (M, b)`は 線形系 `A x = b`を解きます。

  Package linearalgebra ·

関数: lu_factor (M, field)

  形式 `[LU, perm, fld]`か `[LU, perm, fld, lower-cnd upper-cnd]` のリストを返します。 ここで、

  (1) 行列 LUはMの分解をパックされた形式で含みます。 パックされた形式は3つのことを意味します; 第一に LUの行はリスト permに従って置換されます。 もし、例えば、 permがリスト `[3,2,1]`なら、 LU分解の実際の一番目の行は行列 LUの三番目の行です。 第二に、mの下三角因子はすべて1で置き換えられた対角成分を持つ LUの下三角部です。 第三に、 Mの上三角因子は LUの上三角部です。

  (2) 体が `floatfield`か `complexfield`の時、 数 lower-cndと upper-cndは Mの無限ノルム条件数の下限と上限です。 すべての体に対して条件数を見積ることができるわけではありません; そんな体に対しては `lu_factor`は2項目リストを返します。 下限と上限どちらも真の値から任意に大きな因子だけ異なる可能性があります。 (`mat_cond`も参照してください。)

  引数 Mは平方行列でなければいけません。

  オプション引数 fldは環か体かを決めるシンボルでなければいけません。 予め定義された体と環は以下のものがあります:

  (a) `generalring` – Maxima式の環, (b) `floatfield` – 倍精度浮動小数点数体, (c) `complexfield` – 倍精度浮動小数点複素数体, (d) `crering` – Maxima CRE式の環, (e) `rationalfield` – 有理数体, (f) `runningerror` – 浮動小数点の丸め誤差をトラック, (g) `noncommutingring` – 乗算が非可換ドット演算子のMaxima式の環

  体が `floatfield`か `complexfield`、`runningerror`のいずれかの時、 アルゴリズムは部分ピボットを使います; 他のすべての体に対しては、 零ピボットを避ける必要があるときだけ、行がスイッチされます。

  浮動小数点加算算術は結合的でなく、 ’体’の意味は数学的定義と異なります。

  体 `runningerror`の要素は 形式 `[x,n]`の2つの要素のMaximaリストです。 ここで、 xは浮動小数点数で、 `n`は整数です。 `x`の’真’の値と `x`の相対差は 計算機イプシロンに `n`をかけたもので近似的に抑えられます。 The running error bound drops some terms that of the order the square of the machine epsilon.

  新しい体を定義するユーザーインターフェースはありません。 Common Lispに精通しているユーザーは新しい体を定義することができるはずです。 これをするには、ユーザーは算術演算のための関数と 体表現とMaximaの相互変換のための関数を定義しなければいけません。 さらに、(部分ピボットが使われる)順序体に関しては、 ユーザーは大きさの関数と体の元の比較関数を定義しなければいけません。 あとは、Common Lisp 構造体 `mring`を定義することだけです。 ファイル `mring`に多くの例があります。

  分解を計算するために、 最初の仕事は 行列成分それぞれを指定された体の元に変換することです。 変換が不可能な時は、分解はエラーメッセージとともに停止します。 体の元はMaxima式である必要はありません。 例えば、`complexfield`の元はCommon Lisp複素数です。 そして、分解を計算した後には、行列成分はMaxima式に変換されなければいけません。

  `get_lu_factors`も参照してください。

  例:

      (%i1) w[i,j] := random (1.0) + %i * random (1.0);
      (%o1)          w     := random(1.) + %i random(1.)
                      i, j
      (%i2) showtime : true$
      Evaluation took 0.00 seconds (0.00 elapsed)
      (%i3) M : genmatrix (w, 100, 100)$
      Evaluation took 7.40 seconds (8.23 elapsed)
      (%i4) lu_factor (M, complexfield)$
      Evaluation took 28.71 seconds (35.00 elapsed)
      (%i5) lu_factor (M, generalring)$
      Evaluation took 109.24 seconds (152.10 elapsed)
      (%i6) showtime : false$

      (%i7) M : matrix ([1 - z, 3], [3, 8 - z]);
                              [ 1 - z    3   ]
      (%o7)                   [              ]
                              [   3    8 - z ]
      (%i8) lu_factor (M, generalring);
                [ 1 - z         3        ]
                [                        ]
      (%o8)    [[   3            9       ], [1, 2], generalring]
                [ -----  - z - ----- + 8 ]
                [ 1 - z        1 - z     ]
      (%i9) get_lu_factors (%);
                        [   1    0 ]  [ 1 - z         3        ]
              [ 1  0 ]  [          ]  [                        ]
      (%o9)  [[      ], [   3      ], [                9       ]]
              [ 0  1 ]  [ -----  1 ]  [   0    - z - ----- + 8 ]
                        [ 1 - z    ]  [              1 - z     ]
      (%i10) %[1] . %[2] . %[3];
                              [ 1 - z    3   ]
      (%o10)                  [              ]
                              [   3    8 - z ]

  Matrix decompositions ·Package linearalgebra ·

関数: mat_cond (M, 1)
関数: mat_cond (M, inf)

  行列 mのp-ノルムの行列条件数を返します。 pに許される値は1と infです。 この関数は、行列 mの逆元を計算するのにLU分解を使います。 このため、`mat_cond`の実行時間は行列サイズの三乗に比例します; `lu_factor`は、 行列サイズの二乗に比例する時間内に 無限大ノルム条件数の下限と上限を決定します。

  Package linearalgebra ·

関数: mat_norm (M, 1)
関数: mat_norm (M, inf)
関数: mat_norm (M, frobenius)

  行列 Mの行列 p-ノルムを返します。 . The allowed values for pに許される値は1か `inf`か `frobenius` (Frobenius行列ノルム)です。 行列 Mは区分されない行列でなければいけません。

  Package linearalgebra ·

関数: matrixp (e, p)
関数: matrixp (e)

  オプション引数 pが与えられたとして、 もし eが行列で、 pが行列成分すべてに対して `true`に評価されるなら、 `true`を返します。 `matrixp`がオプション引数を与えられない時は、 もし `e`が行列なら、 `true`を返します。 他のすべての場合には、 `false`を返します。

  `blockmatrixp`も参照してください。

  Package linearalgebra ·Predicate functions ·

関数: matrix_size (M)

  行列 Mの行数と列数をそれぞれ与える2要素リストを返します。

  Package linearalgebra ·

関数: mat_fullunblocker (M)

  もし Mが区分行列なら、 行列をすべてのレベルで区分解除します。 もし Mが行列なら、 Mを返します; それ以外ではエラーをシグナルします。

  Package linearalgebra ·

関数: mat_trace (M)

  行列 Mの跡を返します。 もし Mが行列でないなら、名詞形を返します。 Mが区分行列の時、 `mat_trace(M)`は `mat_trace(mat_unblocker(m))`するのと同じ値を返します。

  Package linearalgebra ·

関数: mat_unblocker (M)

  もし Mが区分行列なら、 Mを1レベル区分解除します。 もし Mが行列なら、 `mat_unblocker (M)`は Mを返します; それ以外ではエラーをシグナルします。

  このように、 もし Mの成分それぞれが行列なら、 `mat_unblocker (M)`は区分されていない行列を返しますが、 もし Mの成分それぞれが区分行列なら、 `mat_unblocker (M)`は 区分が1レベル少ない区分行列を返します。

  もし区分行列を使うなら、 おそらく、 `matrix_element_mult`を `"."`に、 `matrix_element_transpose`を `'transpose`に設定したくなるでしょう。 `mat_fullunblocker`も参照してください。

  例:

      (%i1) A : matrix ([1, 2], [3, 4]);
                                  [ 1  2 ]
      (%o1)                       [      ]
                                  [ 3  4 ]
      (%i2) B : matrix ([7, 8], [9, 10]);
                                  [ 7  8  ]
      (%o2)                       [       ]
                                  [ 9  10 ]
      (%i3) matrix ([A, B]);

                           [ [ 1  2 ]  [ 7  8  ] ]
      (%o3)                [ [      ]  [       ] ]
                           [ [ 3  4 ]  [ 9  10 ] ]

      (%i4) mat_unblocker (%);
                               [ 1  2  7  8  ]
      (%o4)                    [             ]
                               [ 3  4  9  10 ]

  Package linearalgebra ·

関数: nullspace (M)

  もし Mが行列なら、 `span (v_1, ..., v_n)`を返します。 ここで、, where the set 集合 `{v_1, ..., v_n}`は Mの零空間の基底です。 空集合のスパンは `{0}`です。 なので、零空間が要素を1つだけ持つときは、`span ()`を返します。

  Package linearalgebra ·

関数: nullity (M)

  もし Mが行列なら、 Mの零空間の次元を返します。

  Package linearalgebra ·

関数: orthogonal_complement (v_1, ..., v_n)

  `span (u_1, ..., u_m)`を返します。 ここで、, where the se 集合 `{u_1, ..., u_m}`は 集合 `(v_1, ..., v_n)`の直交補空間の基底です。

  ベクトル v_1から v_nそれぞれは列ベクトルでなければいけません。

  Package linearalgebra ·

関数: polynomialp (p, L, coeffp, exponp)
関数: polynomialp (p, L, coeffp)
関数: polynomialp (p, L)

  もし pがリスト Lの中の変数に関して多項式なら、 `true`を返します。 述語論理 coeffpは係数それぞれに対して `true`に評価されなければいけなく、 述語論理 exponpは Lの中の変数の指数すべてに対して `true`に評価されなければいけません。 もし exponpに対してデフォルトでない値を使いたいなら、 たとえcoeffpに関してデフォルトを使いたくても coeffpを値とともに供給しなければいけません。

  `polynomialp (p, L, coeffp)`は `polynomialp (p, L, coeffp, 'nonnegintegerp)`に同値です。

  `polynomialp (p, L)`は `polynomialp (p, L, 'constantp, 'nonnegintegerp)`に同値です。

  多項式は展開される必要はありません:

      (%i1) polynomialp ((x + 1)*(x + 2), [x]);
      (%o1)                         true
      (%i2) polynomialp ((x + 1)*(x + 2)^a, [x]);
      (%o2)                         false

  coeffpとexponpにデフォルトでない値を使う例:

      (%i1) polynomialp ((x + 1)*(x + 2)^(3/2), [x], numberp, numberp);
      (%o1)                         true
      (%i2) polynomialp ((x^(1/2) + 1)*(x + 2)^(3/2), [x], numberp,
                                                              numberp);
      (%o2)                         true

  2変数多項式:

      (%i1) polynomialp (x^2 + 5*x*y + y^2, [x]);
      (%o1)                         false
      (%i2) polynomialp (x^2 + 5*x*y + y^2, [x, y]);
      (%o2)                         true

  Package linearalgebra ·Predicate functions ·

関数: polytocompanion (p, x)

  もし pが xの多項式なら、 pのコンパニオン行列を返します。 次数 nのモニック多項式(最高次数の係数が1の多項式)に対しては、 `p = (-1)^n charpoly (polytocompanion (p, x))`. があります。

  pが xの多項式でないなら、エラーをシグナルします。

  Package linearalgebra ·

関数: ptriangularize (M, v)

  もし Mがそれぞれの成分がvの多項式の行列なら、 以下のような行列 M2を返します。

  (1) M2は上三角で、

  (2) `M2 = E_n ... E_1 M`, ここで、 E_1から E_nは成分がvの多項式の基本行列です。

  (3) `|det (M)| = |det (M2)|`,

  注意: この関数はすべての成分がvの多項式かチェックしません。

  Package linearalgebra ·

関数: rowop (M, i, j, theta)

  もし Mが行列なら、 行演算 `R_i <- R_i - theta * R_j`をすることで生じる 行列を返します。 もし Mに行iか jがないなら、 エラーをシグナルします。

  Package linearalgebra ·

関数: rank (M)

  行列 Mの階数を返します。 階数は列空間の次元です。

  例:

      (%i1) rank(matrix([1,2],[2,4]));
      (%o1)                                  1
      (%i2) rank(matrix([1,b],[c,d]));
      Proviso:  {d - b c # 0}
      (%o2)                                  2

  Package linearalgebra ·

関数: rowswap (M, i, j)

  もし Mが行列なら、行 iと jを入れ替えます。 もし Mに行iか jがないなら、エラーをシグナルします。

  Package linearalgebra ·

関数: toeplitz (col)
関数: toeplitz (col, row)

  Toeplitz行列 Tを返します。 Tの一番目の列は colです; 一番目の成分を除いて、 Tの最初の行は rowです。 rowのデフォルトは colの複素共役です。

  例:

      (%i1)  toeplitz([1,2,3],[x,y,z]);

                                        [ 1  y  z ]
                                        [         ]
      (%o1)                             [ 2  1  y ]
                                        [         ]
                                        [ 3  2  1 ]

      (%i2)  toeplitz([1,1+%i]);

                                    [   1     1 - %I ]
      (%o2)                         [                ]
                                    [ %I + 1    1    ]

  Package linearalgebra ·

関数: vandermonde_matrix ([x_1, ..., x_n])

  i番目の行が`[1, x_i, x_i^2, ... x_i^(n-1)]`の n掛けn行列を返します。

  Package linearalgebra ·

関数: zerofor (M)
関数: zerofor (M, fld)

  行列 Mと同じ形の零行列を返します。 零行列の成分すべては体 fldの加算の単位元です; fldのデフォルトは generalringです。

  一番目の引数 Mは 平方行列か行列以外でなければいけません。 Mが行列の時、 Mの成分それぞれは平方行列であり得ます。 – 従って Mは区分Maxima行列であり得ます。 行列は任意の(有限の)深さに区分できます。

  `identfor`も参照してください。

  Package linearalgebra ·

関数: zeromatrixp (M)

  Mが区分行列でない時、 もし行列 Mのそれぞれの要素 eに対して `is (equal (e, 0))`が真なら、 `true`を返します。 Mが区分行列の時、 もしeの要素それぞれに対して `zeromatrixp`が `true`に評価されるなら、 `true`を返します。

  Package linearalgebra ·Predicate functions ·

Next: minpack, Previous: linearalgebra, Up: Top [Contents][Index]

## 65 lsquares

Next: Functions and Variables for lsquares, Previous: lsquares, Up: lsquares [Contents][Index]

### 65.1 Introduction to lsquares

`lsquares`は 数値データからモデルのパラメータを見積もる 最小二乗法を実装するための関数のコレクションです。

Statistical estimation ·Share packages ·Package lsquares ·

Previous: Introduction to lsquares, Up: lsquares [Contents][Index]

### 65.2 Functions and Variables for lsquares

関数: lsquares_estimates (D, x, e, a)
関数: lsquares_estimates (D, x, e, a, initial = L, tol = t)

  最小二乗の方法で決定されるような 変数xとaの方程式eを データDに最良フィットする パラメータaを見積もります。 `lsquares_estimates`は最初に厳密な解を探し、 それが失敗したら、近似的な解を探します。

  戻り値は 形式 `[a = ..., b = ..., c = ...]`の等式のリストのリストです。 リストのそれぞれの要素は 二乗平均誤差の、個別の等価な最小です。

  データ Dは行列でなければいけません。 行それぞれは(文脈によって「レコード」とか「ケース」とか呼ばれる)1つのデータで、 列それぞれは すべてのデータに関するある変数の値を含みます。 変数のリスト xは Dの列それぞれの名前を与えます。 解析をしない列にも名前を与えます。

  パラメータのリスト aは 見積もられるパラメータの名前を与えます。 方程式 eは変数 xと aに関する式か等式です; もし eが等式でないなら、 `e = 0`と同様に扱われます。

  `lsquares_estimates`の付加引数は 等式として指定され、 厳密な結果が見つからなかった時 数値方法で見積もりを見つけるためにコールされる関数 `lbfgs`へそのまま渡されます。

  もしある厳密解が(`solve`を介して)見つけることができるなら、 データ Dは非数値を含むかもしれません。 しかし、もし厳密解が見つからないなら、 Dの要素それぞれは数値でなければいけません。 これは 数リテラル(整数、有理数、通常の浮動小数点、多倍長浮動小数点)はもちろん、 `%pi`や`%e`のような数値定数を含みます。 数値計算は通常の浮動小数点算出で実行されます。 他の種類の数値は計算のため、すべて通常の浮動小数点に変換されます。

  `load("lsquares")`はこの関数をロードします。

  `lsquares_estimates_exact`, `lsquares_estimates_approximate`,
  `lsquares_mse`, `lsquares_residuals`, `lsquares_residual_mse`も参照してください。

  例:

  厳密解が見つかる問題。

      (%i1) load ("lsquares")$
      (%i2) M : matrix (
              [1,1,1], [3/2,1,2], [9/4,2,1], [3,2,2], [2,2,1]);

                                        [ 1  1  1 ]
                                        [         ]
                                        [ 3       ]
                                        [ -  1  2 ]
                                        [ 2       ]
                                        [         ]
      (%o2)                             [ 9       ]
                                        [ -  2  1 ]
                                        [ 4       ]
                                        [         ]
                                        [ 3  2  2 ]
                                        [         ]
                                        [ 2  2  1 ]

      (%i3) lsquares_estimates (
               M, [z,x,y], (z+D)^2 = A*x+B*y+C, [A,B,C,D]);
                               59        27      10921        107
      (%o3)            [[A = - --, B = - --, C = -----, D = - ---]]
                               16        16      1024         32

  厳密解が見つからない問題。 だから `lsquares_estimates`は数値近似に頼ります。

      (%i1) load ("lsquares")$
      (%i2) M : matrix ([1, 1], [2, 7/4], [3, 11/4], [4, 13/4]);
                                         [ 1  1  ]
                                         [       ]
                                         [    7  ]
                                         [ 2  -  ]
                                         [    4  ]
                                         [       ]
      (%o2)                              [    11 ]
                                         [ 3  -- ]
                                         [    4  ]
                                         [       ]
                                         [    13 ]
                                         [ 4  -- ]
                                         [    4  ]
      (%i3) lsquares_estimates (
        M, [x,y], y=a*x^b+c, [a,b,c], initial=[3,3,3], iprint=[-1,0]);
      (%o3) [[a = 1.387365874920637, b = .7110956639593767,
                                              c = - .4142705622439105]]

  Package lsquares ·Numerical methods ·

関数: lsquares_estimates_exact (MSE, a)

  方程式系を構成し、`solve`を介して記号的にそれらを解くことを試みることで、 平均二乗誤差 MSEを最小化する パラメータ aを見積もります。 平均二乗誤差は `lsquares_mse`が返すような パラメータ aの式です。

  戻り値は 形式 `[a = ..., b = ..., c = ...]`の等式のリストのリストです。 戻り値は、0個か1個、2以上の要素を含むかもしれません。 もし複数の要素が返されたら、 それぞれは個別の、平均二乗誤差の等価最小を表します。

  `lsquares_estimates`, `lsquares_estimates_approximate`, `lsquares_mse`,
  `lsquares_residuals`, `lsquares_residual_mse`も参照してください。

  例:

      (%i1) load ("lsquares")$
      (%i2) M : matrix (
               [1,1,1], [3/2,1,2], [9/4,2,1], [3,2,2], [2,2,1]);
                                 [ 1  1  1 ]
                                 [         ]
                                 [ 3       ]
                                 [ -  1  2 ]
                                 [ 2       ]
                                 [         ]
      (%o2)                      [ 9       ]
                                 [ -  2  1 ]
                                 [ 4       ]
                                 [         ]
                                 [ 3  2  2 ]
                                 [         ]
                                 [ 2  2  1 ]
      (%i3) mse : lsquares_mse (M, [z, x, y], (z + D)^2 = A*x + B*y + C);
                 5
                ====
                \                 2                         2
                 >    ((D + M    )  - C - M     B - M     A)
                /            i, 1          i, 3      i, 2
                ====
                i = 1
      (%o3)     ---------------------------------------------
                                      5
      (%i4) lsquares_estimates_exact (mse, [A, B, C, D]);
                        59        27      10921        107
      (%o4)     [[A = - --, B = - --, C = -----, D = - ---]]
                        16        16      1024         32

  Package lsquares ·

関数: lsquares_estimates_approximate (MSE, a, initial = L, tol = t)

  平均二乗誤差 MSEを最小化する パラメータ aを 数値最小化関数 `lbfgs`を介して 見積もります。 平均二乗誤差は、 `lsquares_mse`が返すようなパラメータ aの式です。

  `lsquares_estimates_approximate`が返す解は 平均二乗誤差の(たぶん大域ですが)局所最小値です。 `lsquares_estimates_exact`との一貫性のため、 戻り値は 要素1つ、すなわち、形式 `[a = ..., b = ..., c = ...]`の等式のリスト を持つ入れ子のリストです。

  `lsquares_estimates_approximate`の付加引数は 等式として指定され、 数値方法で見積もりを見つけるためにコールされる関数 `lbfgs`へそのまま渡されます。

  パラメータが数値が割り当てられた時 MSEはは数に評価されなければいけません。 これは This requires that the data from which MSEが構成されるデータが `%pi`や`%e`、 数リテラル(整数、有理数、通常の浮動小数点、多倍長浮動小数点) のような数値定数を含みます。 数値計算は通常の浮動小数点算出で実行されます。 他の種類の数値は計算のため、すべて通常の浮動小数点に変換されます。

  `load("lsquares")`はこの関数をロードします。

  `lsquares_estimates`, `lsquares_estimates_exact`, `lsquares_mse`, `lsquares_residuals`, `lsquares_residual_mse`も参照してください。

  例:

      (%i1) load ("lsquares")$
      (%i2) M : matrix (
               [1,1,1], [3/2,1,2], [9/4,2,1], [3,2,2], [2,2,1]);
                                 [ 1  1  1 ]
                                 [         ]
                                 [ 3       ]
                                 [ -  1  2 ]
                                 [ 2       ]
                                 [         ]
      (%o2)                      [ 9       ]
                                 [ -  2  1 ]
                                 [ 4       ]
                                 [         ]
                                 [ 3  2  2 ]
                                 [         ]
                                 [ 2  2  1 ]
      (%i3) mse : lsquares_mse (M, [z, x, y], (z + D)^2 = A*x + B*y + C);
                 5
                ====
                \                 2                         2
                 >    ((D + M    )  - C - M     B - M     A)
                /            i, 1          i, 3      i, 2
                ====
                i = 1
      (%o3)     ---------------------------------------------
                                      5
      (%i4) lsquares_estimates_approximate (
                    mse, [A, B, C, D], iprint = [-1, 0]);
      (%o4) [[A = - 3.67850494740174, B = - 1.683070351177813,
                       C = 10.63469950148635, D = - 3.340357993175206]]

  Package lsquares ·Numerical methods ·

関数: lsquares_mse (D, x, e)

  平均二乗誤差 (MSE)、 変数 xの 方程式eに関する データ Dの和の式を返します。

  MSEは以下のように定義されます:

                          n
                         ====
                     1   \                        2
                     -    >    (lhs(e ) - rhs(e ))
                     n   /           i         i
                         ====
                         i = 1

  ここで、 nはデータ数で、 `e[i]`は、 `i`番目のデータ `D[i]`から値を割り当てられた xの中の変数に対して評価された方程式 eです。

  `load("lsquares")`はこの関数をロードします。

  例:

      (%i1) load ("lsquares")$
      (%i2) M : matrix (
               [1,1,1], [3/2,1,2], [9/4,2,1], [3,2,2], [2,2,1]);
                                 [ 1  1  1 ]
                                 [         ]
                                 [ 3       ]
                                 [ -  1  2 ]
                                 [ 2       ]
                                 [         ]
      (%o2)                      [ 9       ]
                                 [ -  2  1 ]
                                 [ 4       ]
                                 [         ]
                                 [ 3  2  2 ]
                                 [         ]
                                 [ 2  2  1 ]

      (%i3) mse : lsquares_mse (M, [z, x, y], (z + D)^2 = A*x + B*y + C);
                 5
                ====
                \                 2                         2
                 >    ((D + M    )  - C - M     B - M     A)
                /            i, 1          i, 3      i, 2
                ====
                i = 1
      (%o3)     ---------------------------------------------
                                      5

      (%i4) diff (mse, D);
               5
              ====
              \                             2
            4  >    (D + M    ) ((D + M    )  - C - M     B - M     A)
              /           i, 1         i, 1          i, 3      i, 2
              ====
              i = 1
      (%o4) ----------------------------------------------------------
                                        5

      (%i5) ''mse, nouns;

                     2                 2         9 2               2
      (%o5) (((D + 3)  - C - 2 B - 2 A)  + ((D + -)  - C - B - 2 A)
                                                 4
                 2               2         3 2               2
       + ((D + 2)  - C - B - 2 A)  + ((D + -)  - C - 2 B - A)
                                           2
                 2             2
       + ((D + 1)  - C - B - A) )/5

  Package lsquares ·

関数: lsquares_residuals (D, x, e, a)

  指定されたパラメータ aとデータ Dでの 方程式 eに関する残差を返します。

  Dは行列で、 xは変数のリスト、 eは方程式か一般式です; もし方程式でないなら、 eは `e = 0`であるかのように扱われます。 aは xを除いたeの任意の自由変数に値を指定する 方程式のリストです。

  残差は以下のように定義されます:

                              lhs(e ) - rhs(e )
                                   i         i

  ここで、 `e[i]`は、 aから任意の残りの自由変数を割り当てて、 `i`番目のデータ `D[i]`から値を割り当てられた xの中の変数に対して評価された方程式 eです。

  `load("lsquares")`はこの関数をロードします。

  例:

      (%i1) load ("lsquares")$
      (%i2) M : matrix (
               [1,1,1], [3/2,1,2], [9/4,2,1], [3,2,2], [2,2,1]);
                                        [ 1  1  1 ]
                                        [         ]
                                        [ 3       ]
                                        [ -  1  2 ]
                                        [ 2       ]
                                        [         ]
      (%o2)                             [ 9       ]
                                        [ -  2  1 ]
                                        [ 4       ]
                                        [         ]
                                        [ 3  2  2 ]
                                        [         ]
                                        [ 2  2  1 ]
      (%i3) a : lsquares_estimates (
                M, [z,x,y], (z+D)^2 = A*x+B*y+C, [A,B,C,D]);
                               59        27      10921        107
      (%o3)            [[A = - --, B = - --, C = -----, D = - ---]]
                               16        16      1024         32
      (%i4) lsquares_residuals (
                M, [z,x,y], (z+D)^2 = A*x+B*y+C, first(a));
                                  13    13    13  13  13
      (%o4)                      [--, - --, - --, --, --]
                                  64    64    32  64  64

  Package lsquares ·

関数: lsquares_residual_mse (D, x, e, a)

  指定されたパラメータ aとデータ Dでの 方程式 eに関する残差平均二乗誤差を返します。

  残差MSEは以下のように定義されます:

                          n
                         ====
                     1   \                        2
                     -    >    (lhs(e ) - rhs(e ))
                     n   /           i         i
                         ====
                         i = 1

  ここで、 `e[i]`は、 aから任意の残りの自由変数を割り当てて、 `i`番目のデータ `D[i]`から値を割り当てられた xの中の変数に対して評価された方程式 eです。

  `load("lsquares")`はこの関数をロードします。

  例:

      (%i1) load ("lsquares")$
      (%i2) M : matrix (
               [1,1,1], [3/2,1,2], [9/4,2,1], [3,2,2], [2,2,1]);
                                 [ 1  1  1 ]
                                 [         ]
                                 [ 3       ]
                                 [ -  1  2 ]
                                 [ 2       ]
                                 [         ]
      (%o2)                      [ 9       ]
                                 [ -  2  1 ]
                                 [ 4       ]
                                 [         ]
                                 [ 3  2  2 ]
                                 [         ]
                                 [ 2  2  1 ]
      (%i3) a : lsquares_estimates (
                   M, [z,x,y], (z+D)^2 = A*x+B*y+C, [A,B,C,D]);

                        59        27      10921        107
      (%o3)     [[A = - --, B = - --, C = -----, D = - ---]]
                        16        16      1024         32
      (%i4) lsquares_residual_mse (
                   M, [z,x,y], (z + D)^2 = A*x + B*y + C, first (a));
                                    169
      (%o4)                         ----
                                    2560

  Package lsquares ·

関数: plsquares (Mat,VarList,depvars)
関数: plsquares (Mat,VarList,depvars,maxexpon)
関数: plsquares (Mat,VarList,depvars,maxexpon,maxdegree)

  「最小二乗」法によるデータ表の多変数多項式調整。 Matはデータを含む行列であり、 VarListは変数名(Mat列それぞれの名前ですが、Mat列を無視する際には変数名の代わりに"-")のリストであり、 depvarsは従属変数の名前か、 従属変数の1つ以上の名前(その名前VarListの中になければいけません)のリストであり、 maxexponはオプションの、独立変数それぞれの最大指数(デフォルト1)であり、 maxdegreeはオプションの最大多項式次数(デフォルトでmaxexpon)です; それぞれの項の指数の和はmaxdegree以下でなければいけないことに注意してください。 もし `maxdgree = 0`なら制限は適用されません。

  もし depvarsが(リストではなく)従属変数の名前なら、 `plsquares`は調整された多項式を返します。 もし depvarsが1つ以上の従属変数のリストなら、 `plsquares`は調整された多項式のリストを返します。 適合度について知らせるために 決定係数が表示されます。 それは0 (無相関)から1 (厳密相関)までの範囲です。 これらの値は グローバル変数 DETCOEF(もし depvarsがリストならリスト)にも保管されます。

  多変数線形調整の簡単な例:

      (%i1) load("plsquares")$

      (%i2) plsquares(matrix([1,2,0],[3,5,4],[4,7,9],[5,8,10]),
                      [x,y,z],z);
           Determination Coefficient for z = .9897039897039897
                             11 y - 9 x - 14
      (%o2)              z = ---------------
                                    3

  次数制限のない同じ例:

      (%i3) plsquares(matrix([1,2,0],[3,5,4],[4,7,9],[5,8,10]),
                      [x,y,z],z,1,0);
           Determination Coefficient for z = 1.0
                          x y + 23 y - 29 x - 19
      (%o3)           z = ----------------------
                                    6

  N面ポリゴンは何本の対角線を持ちますか？ いくつの多項式次数を使うべきですか？

      (%i4) plsquares(matrix([3,0],[4,2],[5,5],[6,9],[7,14],[8,20]),
                      [N,diagonals],diagonals,5);
           Determination Coefficient for diagonals = 1.0
                                      2
                                     N  - 3 N
      (%o4)              diagonals = --------
                                        2
      (%i5) ev(%, N=9);   /* Testing for a 9 sides polygon */
      (%o5)                 diagonals = 27

  何通りの方法でn掛けnのチェス盤に2つのクィーンを取られないように置けますか？

      (%i6) plsquares(matrix([0,0],[1,0],[2,0],[3,8],[4,44]),
                      [n,positions],[positions],4);
           Determination Coefficient for [positions] = [1.0]

                               4       3      2
                            3 n  - 10 n  + 9 n  - 2 n
      (%o6)    [positions = -------------------------]
                                        6

      (%i7) ev(%[1], n=8); /* Testing for a (8 x 8) chessboard */
      (%o7)                positions = 1288

  6つの従属変数を持つ例:

      (%i8) mtrx:matrix([0,0,0,0,0,1,1,1],[0,1,0,1,1,1,0,0],
                        [1,0,0,1,1,1,0,0],[1,1,1,1,0,0,0,1])$
      (%i8) plsquares(mtrx,[a,b,_And,_Or,_Xor,_Nand,_Nor,_Nxor],
                           [_And,_Or,_Xor,_Nand,_Nor,_Nxor],1,0);
            Determination Coefficient for
      [_And, _Or, _Xor, _Nand, _Nor, _Nxor] =
      [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
      (%o2) [_And = a b, _Or = - a b + b + a,
      _Xor = - 2 a b + b + a, _Nand = 1 - a b,
      _Nor = a b - b - a + 1, _Nxor = 2 a b - b - a + 1]

  この関数を使うには、 最初に `load("lsquares")`を書いてください。

  Package lsquares ·Numerical methods ·

Next: makeOrders, Previous: lsquares, Up: Top [Contents][Index]

## 66 minpack

Next: Functions and Variables for minpack [Contents][Index]

### 66.1 Introduction to minpack

`Minpack`は Netlibから得られるFortranライブラリ MINPACKの (`f2cl`を介した)Common Lisp翻訳です。

Numerical methods ·Share packages ·Package minpack ·Package minpack ·

Previous: Introduction to minpack [Contents][Index]

### 66.2 Functions and Variables for minpack

関数: minpack_lsquares
`minpack_lsquares` (flist, varlist, guess)
`minpack_lsquares` (..., 'tolerance = tolerance)
`minpack_lsquares` (..., 'jacobian = jacobian)

  リスト flistの関数の平方の和を最小化する 点を計算します。 変数はリスト varlistの中にあります。 最適点の初期推測はguessで供給されなければいけません

  オプションのキーワード引数 toleranceと jacobianは アルゴリズム上のある制御を提供します。 toleranceは平方の和に関する相対誤差を見積もられます。 jacobianはJacobianを指定するのにつかうことができます。 もし jacobianが与えられず、l (デフォルト)`true` なら、 flistから計算されます。 もし jacobianが `false`なら数値近似が使われます。

  `minpack_lsquares`はリストを返します。 最初の項目は見積もられた解です; 二番目は平方の和で， 三番目はアルゴリズムの成功を示します。 可能な値は以下の通りです。

  `0`

    不適切な入力パラメータ。

  `1`

    アルゴリズムが平方の和の相対誤差がせいぜい`tolerance`と見積もります。

  `2`

    アルゴリズムがxと解の相対誤差がせいぜい `tolerance`と見積もります。

  `3`

    info = 1と info = 2の条件が両方とも成立します。

  `4`

    fvec が機械精度のjacobianの列に直交的です。

  `5`

    iflag = 1が100*(n+1)に至るfcnへのコールの回数

  `6`

    tolが小さすぎます。平方の和の更なる減少は不可能です。

  `7`

    tolが小さすぎます。近似解xの更なる改善は不可能です。

      /* Problem 6: Powell singular function */
      (%i1) powell(x1,x2,x3,x4) :=
               [x1+10*x2, sqrt(5)*(x3-x4), (x2-2*x3)^2,
                    sqrt(10)*(x1-x4)^2]$
      (%i2) minpack_lsquares(powell(x1,x2,x3,x4), [x1,x2,x3,x4],
                             [3,-1,0,1]);
      (%o2) [[1.652117596168394e-17, - 1.652117596168393e-18,
              2.643388153869468e-18, 2.643388153869468e-18],
             6.109327859207777e-34, 4]

      /* Same problem but use numerical approximation to Jacobian */
      (%i3) minpack_lsquares(powell(x1,x2,x3,x4), [x1,x2,x3,x4],
                             [3,-1,0,1], jacobian = false);
      (%o3) [[5.060282149485331e-11, - 5.060282149491206e-12,
              2.179447843547218e-11, 2.179447843547218e-11],
             3.534491794847031e-21, 5]

関数: minpack_solve
`minpack_solve` (flist, varlist, guess)
`minpack_solve` (..., 'tolerance = tolerance)
`minpack_solve` (..., 'jacobian = jacobian)

  `n`個の未知数に関する `n`個の方程式系を解きます。 `n`個の方程式形がリスト flistで 与えられます。 解の初期推測はguessの中で提供されます。

  オプションのキーワード引数、 toleranceと jacobianは アルゴリズム上のある制御を提供します。 toleranceは、平方の和に関して宣言された見積もられた相対誤差です。 jacobianはJacobianを指定するのに使うことができます。 もしjacobianが与えらないか、`true`(デフォルト)なら、 Jacobianをflistから計算します。 もしjacobianが`false`なら、数値近似が使われます。

  `minpack_solve`はリストを返します。 最初の項は見積もられた解です; 最初のエスティマート解であることが解されます。 最初の解が、最初の項は未つられた解と一緒なranmpolが渡り気味。 リストを返します。 評価された解の最初の案件はリストを返します。

  `0`

    不適切な入力パラメータ。

  `1`

    アルゴリズムが解の相対誤差がせいぜい`tolerance`と見積もります。

  `2`

    iflag = 1でfcnをコールした回数が100*(n+1)に達しました。

  `3`

    tolが小さ過ぎます。平方和の中で換算がこれ以上不可能です。

  `4`

    繰り返しがよい進捗を産んでいません。

Next: mnewton, Previous: minpack, Up: Top [Contents][Index]

## 67 makeOrders

Previous: makeOrders, Up: makeOrders [Contents][Index]

### 67.1 Functions and Variables for makeOrders

関数: makeOrders (indvarlist,orderlist)

  引数までの多項式のべきすべてのリストを返します。

      (%i1) load("makeOrders")$

      (%i2) makeOrders([a,b],[2,3]);
      (%o2) [[0, 0], [0, 1], [0, 2], [0, 3], [1, 0], [1, 1],
                  [1, 2], [1, 3], [2, 0], [2, 1], [2, 2], [2, 3]]
      (%i3) expand((1+a+a^2)*(1+b+b^2+b^3));
             2  3      3    3    2  2      2    2    2
      (%o3) a  b  + a b  + b  + a  b  + a b  + b  + a  b + a b
                                                        2
                                                 + b + a  + a + 1

  ここで、 `[0, 1]`は項bに関連づけられ、 `[2, 3]`はa^2 b^3に関連づけられます。

  この関数を使うには、最初に`load("makeOrders")`を書いてください。

  Polynomials ·Share packages ·Package makeOrders ·

Next: numericalio, Previous: makeOrders, Up: Top [Contents][Index]

## 68 mnewton

Next: Functions and Variables for mnewton, Previous: mnewton, Up: mnewton [Contents][Index]

### 68.1 Introduction to mnewton

`mnewton`は １変数または多変数の非線形方程式を解くための Newton法の実装です。

Numerical methods ·Share packages ·Package mnewton ·

Previous: Introduction to mnewton, Up: mnewton [Contents][Index]

### 68.2 Functions and Variables for mnewton

オプション変数: newtonepsilon

  デフォルト値: `10.0^(-fpprec/2)`

  `mnewton`関数が解に向かって収束した時を決定する精度。 もし`newtonepsilon`が多倍長浮動小数点なら、`mnewton`計算は多倍長浮動小数点でされます。 `mnewton`も参照してください。

  Package mnewton ·

オプション変数: newtonmaxiter

  デフォルト値: `50`

  もし収束しないか収束が遅すぎるなら `mnewton`関数を止める繰り返しの最大数。

  `mnewton`も参照してください。

  Package mnewton ·

関数: mnewton (FuncList,VarList,GuessList)

  Newton法を使った複数非線形関数の解。 FuncListは解くべき関数のリスト、 VarListは変数名のリスト、 GuessListは初期近似のリストです。

  解は `solve()`が返すのと同じフォーマットで返されます。 もし解が見つからないなら、`[]`が返されます。

  この関数は グローバル変数`newtonepsilon`と`newtonmaxiter`によって制御されます。

      (%i1) load("mnewton")$

      (%i2) mnewton([x1+3*log(x1)-x2^2, 2*x1^2-x1*x2-5*x1+1],
                    [x1, x2], [5, 5]);
      (%o2) [[x1 = 3.756834008012769, x2 = 2.779849592817897]]
      (%i3) mnewton([2*a^a-5],[a],[1]);
      (%o3)             [[a = 1.70927556786144]]
      (%i4) mnewton([2*3^u-v/u-5, u+2^v-4], [u, v], [2, 2]);
      (%o4) [[u = 1.066618389595407, v = 1.552564766841786]]

  変数`newtonepsilon`は近似の精度を制御します。 それはまた、計算が浮動小数点で実行されるか、多倍長浮動小数点で実行されるかを制御します。

      (%i1) (load("mnewton"), fpprec : 25, newtonepsilon : bfloat(10^(-fpprec+5)))$

      (%i2) mnewton([2*3^u-v/u-5, u+2^v-4], [u, v], [2, 2]);
      (%o2) [[u = 1.066618389595406772591173b0, v = 1.552564766841786450100418b0]]

  この関数を使うためには、最初に`load("mnewton")`を書いてください。 `newtonepsilon`と`newtonmaxiter`も参照してください。

  Package mnewton ·

Next: opsubst, Previous: mnewton, Up: Top [Contents][Index]

## 69 numericalio

Next: Functions and Variables for plain-text input and output, Previous: numericalio, Up: numericalio [Contents][Index]

### 69.1 Introduction to numericalio

`numericalio`は ファイルやストリームを読み書きする関数のコレクションです。 プレインテキスト入出力のための関数は、 数(整数、浮動小数点、多倍長浮動小数点)やシンボル、文字列を読み書きできます。 バイナリ入出力のための関数は、 浮動小数点数だけを読み書きできます。

もし既に入力データを記憶すべきリスト、行列、配列オブジェクトがあるなら、 `numericalio`入力関数群はデータをそのオブジェクトに書き込むことができます。 そうでなければ、 `numericalio`はデータを記憶するオブジェクトの構造をある程度推測し、 そのオブジェクトを返します。

File input ·File output ·Share packages ·Package numericalio ·

#### 69.1.1 Plain-text input and output

プレインテキスト入出力では、 読み書きする項目それぞれがアトムであることが仮定されます: 整数、浮動小数点数、多倍長浮動小数点、文字列、シンボルであり、 有理数や複素数や他のどんなアトムでない式でもありません。 `numericalio`関数群は、アトムでない式に直面した時、 何か適当なことを試みるかもしれませんが、 結果はここで規定されず、変更の対象となります。

入力ファイルと出力ファイルどちらのアトムも、 Maximaバッチファイルや対話コンソールでのものと同じフォーマットを持ちます。 特に、文字列はダブルクォートで括られ、 バックスラッシュ`\`は次の文字の任意の特殊解釈を抑制し、 クエスチョンマーク`?`は (Maximaシンボルではなく、)Lispシンボルを意味するシンボルの始まりとして認識されます。 (分割された行をつなぎ合わせる)いかなる継続文字も認識されません。

#### 69.1.2 Separator flag values for input

プレインテキスト入出力のための関数は、オプションの引数separator_flag を取ります。 それはどの文字がデータを分離するかを示します。

プレインテキスト入力では、 separator_flagの以下の値が認識されます: コンマで区切られた値のための`comma`、 垂直バー文字`|`で区切られた値のための`pipe`、 セミコロン`;`で区切られた値のための`semicolon`、 空白かタブ文字で区切られた値のための`space`。 もしファイル名が`.csv`で終わり、 separator_flagが指定されていないなら、 `comma`が仮定されます。 もしファイル名が`.csv`以外の何かで終わり、 `separator_flag`が指定されていないなら、 `space`が仮定されます。

プレインテキスト入力では、 複数続く空白とタブ文字は1つの区切り文字として数えられます． しかしながら、複数のコンマ、パイプまたはセミコロンは意味を持ちます。 連続するコンマ、パイプ、セミコロン文字は (空白やタブが間に入ろうが入るまいが) 区切り文字の間に`false`を持つと見なされます。 例えば、`1234,,Foo`は `1234,false,Foo`と同じと扱われます。

#### 69.1.3 Separator flag values for output

プレインテキスト出力では、 `comma`, `pipe`, `semicolon`, そして`space`はもちろん、 タブ文字で区切られた値のための`tab`も、 separator_flagの値として認識されます。

プレインテキスト出力では、 `false`アトムは以下のように書かれます: リスト`[1234, false, Foo]`は`1234,false,Foo`と書かれ、 出力を`1234,,Foo`につぶすことはありません。

#### 69.1.4 Binary floating-point input and output

`numericalio`関数群は8バイトIEEE754浮動小数点数を読み書きすることができます。 これらの数は、 `assume_external_byte_order`で設定されたグローバルフラグに従って、 最下位バイトから順でも最上位バイトから順でも記憶することができます。

もし指定されないなら、 `numericalio`は外部バイト順は最上位バイトからと仮定します。

他の種類の数は8バイト浮動小数点に強制変換されます; `numericalio`はアトムでないバイナリデータを読み書きできません。

いくつかのLisp実装は IEEE 754の特殊値(正負の無限大、非数値、指数表現でない数)を認識しません。 `numericalio`でそんな値を読み込むことの効果は未定義です。

`numericalio`は バイトストリームを読んだり書いたりするためのストリームを開く 関数を含みます。

Next: Functions and Variables for binary input and output, Previous: Introduction to numericalio, Up: numericalio [Contents][Index]

### 69.2 Functions and Variables for plain-text input and output

関数: read_matrix (S)
関数: read_matrix (S, M)
関数: read_matrix (S, separator_flag)
関数: read_matrix (S, M, separator_flag)

  `read_matrix(S)`は、 ソースSを読み込み、行列として内容全体を返します。 行列のサイズは入力データから推論されます; ファイルの行それぞれは行列の1行になります。 もし複数の行が異なる長さを持つなら、 `read_matrix`はエラーを出力します。

  `read_matrix(S, M)`は、 Mが一杯になるか、ソースが尽きるまで、 ソースSを行列Mに読み込みます。 入力データは行優先順に行列に読み込まれます; 入力はMと同じ行数と列数を持つ必要はありません。

  ソースSはファイル名かストリームかもしれません。

  separator_flagの認識される値は `comma`, `pipe`, `semicolon`, `space`です。 もしseparator_flagが指定されないなら、ファイルは空白で区切られていると仮定されます。

  Package numericalio ·File input ·

関数: read_array (S, A)
関数: read_array (S, A, separator_flag)

  Aが一杯になるか、ソースが尽きるまで、 ソースSを配列Aに読み込みます。 入力データは列優先順に配列に読み込まれます; 入力はAの次元に一致する必要はありません。

  ソースSはファイル名かストリームかもしれません。

  separator_flagの認識される値は `comma`, `pipe`, `semicolon`, `space`です。 もしseparator_flagが指定されないなら、ファイルは空白で区切られていると仮定されます。

  Package numericalio ·File input ·

関数: read_hashed_array (S, A)
関数: read_hashed_array (S, A, separator_flag)

  ソースSが読み込まれ、ハッシュ配列として内容全体が返されます。 ソースSはファイル名かストリームかもしれません。

  `read_hashed_array`は、 それぞれの行の最初の項目をハッシュキーとして扱い、 行の残りを(リストとして)キーと結合します。 例えば、 行`567 12 17 32 55`は `A[567]: [12, 17, 32, 55]$`と同値です。 行数は要素数と同じである必要はありません。

  separator_flagの認識される値は `comma`, `pipe`, `semicolon`, `space`です。 もしseparator_flagが指定されないなら、ファイルは空白で区切られていると仮定されます。

  Package numericalio ·File input ·

関数: read_nested_list (S)
関数: read_nested_list (S, separator_flag)

  ソースSを読み込み、 入れ子のリストとして内容全体を返します。 ソースSはファイル名かストリームかもしれません。

  `read_nested_list`は 入力のそれぞれの行について部分リストを持つリストを返します。 行数は要素数と同じである必要はありません。 空の行は無視されません: 空の行は空の部分リストをもたらします。

  separator_flagの認識される値は `comma`, `pipe`, `semicolon`, `space`です。 もしseparator_flagが指定されないなら、ファイルは空白で区切られていると仮定されます。

  Package numericalio ·File input ·

関数: read_list (S)
関数: read_list (S, L)
関数: read_list (S, separator_flag)
関数: read_list (S, L, separator_flag)

  `read_list(S)`は、 ソースSを読み込み、 フラットなリストとして内容全体を返します。

  `read_list(S, L)`は、 Lが一杯になるかソースが尽きるまで、 ソースSを リストLに読み込みます。

  ソースSはファイル名かストリームかもしれません。

  separator_flagの認識される値は `comma`, `pipe`, `semicolon`, `space`です。 もしseparator_flagが指定されないなら、ファイルは空白で区切られていると仮定されます。

  Package numericalio ·File input ·

関数: write_data (X, D)
関数: write_data (X, D, separator_flag)

  オブジェクトXをデスティネーションDに書き出します。

  `write_data`は行列を 行につき一行で行優先順に書き出します。

  `write_data`は `array`や`make_array`で生成された配列を 行優先順でスラブ毎に改行して書き出します。 高次元スラブは更に改行で分割されます。

  `write_data`はハッシュ配列を 1行に、キーそれぞれに結合したリストが続くように書き出します。

  `write_data`は入れ子のリストを それぞれの部分リストを1行に書き出します。

  `write_data`はフラットなリストすべてを1行に書き出します。

  デスティネーションDはファイル名かストリームかもしれません。 デスティネーションがファイル名の時、 グローバル変数`file_output_append`は 出力ファイルに追加されるか上書きされるか決定します。 デスティネーションがストリームの時、 `write_data`は データすべてが書かれた後、特殊なアクションを取ります; 特にストリームは開いたままとなります。

  separator_flagの認識される値は `comma`, `pipe`, `semicolon`, `space`です。 もしseparator_flagが指定されないなら、ファイルは空白で区切られていると仮定されます。

  Package numericalio ·File output ·

Previous: Functions and Variables for plain-text input and output, Up: numericalio [Contents][Index]

### 69.3 Functions and Variables for binary input and output

関数: assume_external_byte_order (byte_order_flag)

  `numericalio`に バイナリデータを読み書きするためのバイトオーダーを知らせます。 byte_order_flagの2つの値が認識されます: リトルエンディアンバイトオーダーとも呼ばれる最下位バイト優先を示す`lsb`; と ビッグエンディアンバイトオーダーとも呼ばれる最上位バイト優先を示す`msb`。

  もし指定されないなら、 `numericalio`は外部のバイトオーダーは最上位バイト優先を仮定します。

  Package numericalio ·

関数: openr_binary (file_name)

  file_nameという名前のファイルを読むための 8ビット符号なしバイトの入力ストリームを返します。

  Package numericalio ·File input ·

関数: openw_binary (file_name)

  file_nameという名前のファイルに書き込むための 8ビット符号なしバイトの出力ストリームを返します。

  Package numericalio ·File output ·

関数: opena_binary (file_name)

  file_nameという名前のファイルに追加するための 8ビット符号なしバイトの出力ストリームを返します。

  Package numericalio ·File output ·

関数: read_binary_matrix (S, M)

  Mが一杯になるかソースが尽きるまで、 ソースSから行列Mにバイナリの8バイト浮動小数点数を読み込みます。 Mの要素は行優先順で読み込まれます。

  ソースSはファイル名かストリームかもしれません。

  ソースの要素のバイトオーダーは `assume_external_byte_order`で指定されます。

  Package numericalio ·File input ·

関数: read_binary_array (S, A)

  Aが一杯になるかソースが尽きるまで、 ソースSから配列Aにバイナリの8バイト浮動小数点数を読み込みます。 Mの要素は行優先順で読み込まれます。

  ソースSはファイル名かストリームかもしれません。

  ソースの要素のバイトオーダーは `assume_external_byte_order`で指定されます。

  Package numericalio ·File input ·

関数: read_binary_list (S)
関数: read_binary_list (S, L)

  `read_binary_list(S)`は バイナリ8バイト浮動小数点数の数列として ソースSの内容全体を読み込み、それをリストとして返します。 ソースSはファイル名かストリームかもしれません。

  `read_binary_list(S, L)`は リストLが一杯になるかソースが尽きるまで、 ソースSから バイナリ8バイト浮動小数点数を読み込みます。

  ソースの要素のバイトオーダーは `assume_external_byte_order`で指定されます。

  Package numericalio ·File input ·

関数: write_binary_data (X, D)

  Writes the object バイナリ8バイトIEEE 754浮動小数点数で構成される オブジェクトXを ディスティネーションDに書き込みます。 他の種類の数は8バイト浮動小数点に強制変換されます。 `write_binary_data`は非数データを書くことはできません。

  The object オブジェクトXはリストか、入れ子のリスト、行列、 もしくは、`array`か`make_array`で生成された配列であり得ます; Xは未宣言配列や他のいかなる種類のオブジェクトもありえません。 `write_binary_data`は 入れ子のリスト、行列、配列を行優先順に書き込みます。

  デスティネーションDはファイル名かストリームかもしれません。 デスティネーションがファイル名の時、 グローバル変数`file_output_append`が 出力ファイルに追加されるか上書きされるか決めます。 デスティネーションがストリームの時、 データすべてが書かれた後`write_binary_data`は特別な動作は何もしません; 特に、ストリームは開かれたままです。

  デスティネーションの要素のバイトオーダーは `assume_external_byte_order`で指定されます。

  Package numericalio ·File output ·

Next: orthopoly, Previous: numericalio, Up: Top [Contents][Index]

## 70 opsubst

Previous: opsubst, Up: opsubst [Contents][Index]

### 70.1 Functions and Variables for opsubst

関数: opsubst (f,g,e)
関数: opsubst (g=f,e)
関数: opsubst ([g1=f1,g2=f2,..., gn=fn],e)

  関数`opsubst`は `opsubst`は式の中の演算子への代入だけをすることを除いて、 関数`subst`に似ています。 一般に、 fが式eの中の演算子の時、 式eの中でgをfに代入します。

  演算子を決定するために、 `opsubst`は`inflag`をtrueに設定します。 これは、 `opsubst`が式の中の表示演算子ではなく内部演算子への代入をすることを意味します。

  例:

      (%i1) load ("opsubst")$

      (%i2) opsubst(f,g,g(g(x)));
      (%o2)                     f(f(x))
      (%i3) opsubst(f,g,g(g));
      (%o3)                       f(g)
      (%i4) opsubst(f,g[x],g[x](z));
      (%o4)                       f(z)
      (%i5) opsubst(g[x],f, f(z));
      (%o5)                      g (z)
                                  x
      (%i6) opsubst(tan, sin, sin(sin));
      (%o6)                     tan(sin)
      (%i7) opsubst([f=g,g=h],f(x));
      (%o7)                       h(x)

  内部的にMaximaは単項否定や割り算、引き算演算子を使いません; 例えば:

      (%i8) opsubst("+","-",a-b);
      (%o8)                     a - b
      (%i9) opsubst("f","-",-a);
      (%o9)                      - a
      (%i10) opsubst("^^","/",a/b);
                                   a
      (%o10)                       -
                                   b

  -a*bの内部表現は*(-1,a,b)です; 例えば、

      (%i11) opsubst("[","*", -a*b);
      (%o11)                  [- 1, a, b]

  どちらかの演算子がMaximaシンボルでない時、 他のある関数は一般にエラーを知らせます:

      (%i12) opsubst(a+b,f, f(x));

      Improper name or value in functional position:
      b + a
       -- an error.  Quitting.  To debug this try debugmode(true);

  しかしながら、添字付き演算子は許されます:

      (%i13) opsubst(g[5],f, f(x));
      (%o13)                     g (x)
                                  5

  この関数を使うためには、最初に`load("opsubst")`を書いてください。

  Expressions ·Share packages ·Package opsubst ·

Next: plotdf, Previous: opsubst, Up: Top [Contents][Index]

## 71 orthopoly

Next: Functions and Variables for orthogonal polynomials, Previous: orthopoly, Up: orthopoly [Contents][Index]

### 71.1 Introduction to orthogonal polynomials

`orthopoly`は、 Chebyshev, Laguerre, Hermite, Jacobi, Legendre, 超球(Gegenbauer) 多項式を含むいくつかの種類の直交多項式のシンボリックな評価と数値評価のためのパッケージです。 さらに、`orthopoly`には球Bessel, 球Hankel, 球調和関数のサポートが含まれます。

ほとんどの部分に関して、 `orthopoly`は Abramowitz and StegunのHandbook of Mathematical Functions, Chapter 22 (10th printing, December 1972)の慣例に従います; 加えて、 Gradshteyn and RyzhikのTable of Integrals, Series, and Products (1980 corrected and enlarged edition)と Eugen MerzbacherのQuantum Mechanics (2nd edition, 1970)を使います。

University of Nebraska at Kearney (UNK)のBarton Willisが `orthopoly`パッケージとドキュメンテーションを書きました。 パッケージはGNU General Public License (GPL)の下で公開されています。

Orthogonal polynomials ·Share packages ·Package orthopoly ·

#### 71.1.1 Getting Started with orthopoly

`load ("orthopoly")`は`orthopoly`パッケージをロードします。

3次のLegendre多項式を見つけるには、

    (%i1) legendre_p (3, x);
                          3             2
                 5 (1 - x)    15 (1 - x)
    (%o1)      - ---------- + ----------- - 6 (1 - x) + 1
                     2             2

これをxの冪の和として表すには、 ratsimpかratを結果に適用してください。

    (%i2) [ratsimp (%), rat (%)];
                            3           3
                         5 x  - 3 x  5 x  - 3 x
    (%o2)/R/            [----------, ----------]
                             2           2

あるいはまた、 `legendre_p`の第二引数 (「主」変数)を正準有理形(CRE)にしてください。

    (%i1) legendre_p (3, rat (x));
                                  3
                               5 x  - 3 x
    (%o1)/R/                   ----------
                                   2

浮動小数点評価に関して、 `orthopoly`はランニング誤差解析を使って 誤差の上限を推定します。 例えば、

    (%i1) jacobi_p (150, 2, 3, 0.2);
    (%o1) interval(- 0.062017037936715, 1.533267919277521E-11)

区間(interval)は形式form `interval (c, r)`を取ります。 ここで、cは中央値、rは区間の半径です。 Maximaは区間上の算術をサポートしていないので、 グラフィックスなどいくつかの状況では 誤差を抑制し、区間の中央値だけ出力したいでしょう。 これをするには、オプション変数`orthopoly_returns_intervals`を `false`に設定してください。

    (%i1) orthopoly_returns_intervals : false;
    (%o1)                         false
    (%i2) jacobi_p (150, 2, 3, 0.2);
    (%o2)                  - 0.062017037936715

更に知るにはセクションsee Floating point Evaluationを参照してください。

`orthopoly`のほとんどの関数は`gradef`プロパティを持ちます; 例えば、

    (%i1) diff (hermite (n, x), x);
    (%o1)                     2 n H     (x)
                                   n - 1
    (%i2) diff (gen_laguerre (n, a, x), x);
                  (a)               (a)
               n L   (x) - (n + a) L     (x) unit_step(n)
                  n                 n - 1
    (%o2)      ------------------------------------------
                                   x

二番目の例の単位階段関数は、 nが0で評価することによって、そうでなければ生じる誤差を抑制します。

    (%i3) ev (%, n = 0);
    (%o3)                           0

`gradef`プロパティは「主」変数にのみ適用されます; 他の引数に関する導関数は、普通、エラーメッセージに帰着します; 例えば、

    (%i1) diff (hermite (n, x), x);
    (%o1)                     2 n H     (x)
                                   n - 1
    (%i2) diff (hermite (n, x), n);

    Maxima doesn't know the derivative of hermite with respect the first
    argument
     -- an error.  Quitting.  To debug this try debugmode(true);

一般に、`orthopoly`の関数はリストや行列上に写像します。 写像を完全に評価するには、 オプション変数`doallmxops`と`listarith`はともに `true`(デフォルト値)でなければいけません。 行列上への写像を見るには、以下を考えてください。

    (%i1) hermite (2, x);
                                         2
    (%o1)                    - 2 (1 - 2 x )
    (%i2) m : matrix ([0, x], [y, 0]);
                                [ 0  x ]
    (%o2)                       [      ]
                                [ y  0 ]
    (%i3) hermite (2, m);
                   [                             2  ]
                   [      - 2        - 2 (1 - 2 x ) ]
    (%o3)          [                                ]
                   [             2                  ]
                   [ - 2 (1 - 2 y )       - 2       ]

二番目の例では、値の`i, j`要素は`hermite (2, m[i,j])`です; 次の例で見るように、これは、 計算`-2 + 4 m . m`と同じではありません。

    (%i4) -2 * matrix ([1, 0], [0, 1]) + 4 * m . m;
                        [ 4 x y - 2      0     ]
    (%o4)               [                      ]
                        [     0      4 x y - 2 ]

定義域外の点で関数を評価すると、 一般に、`orthopoly`は未評価関数を返します。 例えば、

    (%i1) legendre_p (2/3, x);
    (%o1)                        P   (x)
                                  2/3

`orthopoly`はTexへの翻訳をサポートします; 端末上での2次元出力も行います。

    (%i1) spherical_harmonic (l, m, theta, phi);
                              m
    (%o1)                    Y (theta, phi)
                              l
    (%i2) tex (%);
    $$Y_{l}^{m}\left(\vartheta,\varphi\right)$$
    (%o2)                         false
    (%i3) jacobi_p (n, a, a - b, x/2);
                              (a, a - b) x
    (%o3)                    P          (-)
                              n          2
    (%i4) tex (%);
    $$P_{n}^{\left(a,a-b\right)}\left({{x}\over{2}}\right)$$
    (%o4)                         false

#### 71.1.2 Limitations

式がいくつかの直交多項式を記号順で含む時、 式が実際に0になる可能性がありますが、 まだMaximaはそれを零に整理することができません。 もしそんな量で割るなら、困ったことになるでしょう。 例えば、 以下の式は 1より大きな整数 nで零になりますが、 まだMaximaはそれを零に整理することができません。

    (%i1) (2*n - 1) * legendre_p (n - 1, x) * x - n * legendre_p (n, x)
          + (1 - n) * legendre_p (n - 2, x);
    (%o1)  (2 n - 1) P     (x) x - n P (x) + (1 - n) P     (x)
                      n - 1           n               n - 2

特定の nでは式を零に換算できます。

    (%i2) ev (% ,n = 10, ratsimp);
    (%o2)                           0

一般に、直交多項式の多項式形は 浮動小数点評価に関しては不適当です。 以下は例です。

    (%i1) p : jacobi_p (100, 2, 3, x)$

    (%i2) subst (0.2, x, p);
    (%o2)                3.4442767023833592E+35
    (%i3) jacobi_p (100, 2, 3, 0.2);
    (%o3)  interval(0.18413609135169, 6.8990300925815987E-12)
    (%i4) float(jacobi_p (100, 2, 3, 2/10));
    (%o4)                   0.18413609135169

真値は約0.184です; この計算は 極端な減算消去誤差に苦しみます。 多項式を展開し評価すると、よりよい結果を与えます。

    (%i5) p : expand(p)$
    (%i6) subst (0.2, x, p);
    (%o6) 0.18413609766122982

これは一般的な規則ではありません; 多項式を展開することはいつも、 数値評価により適した式を生じるわけではありません。 数値評価する最もよい方法は 断然、1つ以上の関数引数を浮動小数点数にすることです。 それをすることで、 特別な浮動小数点アルゴリズムが評価に使われます。

Maximaの `float`関数は幾分でたらめです; もし `float`を記号次数や順序パラメータを持つ直交多項式を含む式に適用するなら、 これらのパラメータは 浮動小数点に変換されるかもしれません; その後、式は完全には評価されません。 以下を考えてください。

    (%i1) assoc_legendre_p (n, 1, x);
                                   1
    (%o1)                         P (x)
                                   n
    (%i2) float (%);
                                  1.0
    (%o2)                        P   (x)
                                  n
    (%i3) ev (%, n=2, x=0.9);
                                 1.0
    (%o3)                       P   (0.9)
                                 2

(%o3)の式は浮動小数点に評価されません; `orthopoly`は 整数を要求するところで浮動小数点値を認識しません。 同様に、 数値評価 recognize floating point values where it requires an integer. Similarly, numerical evaluation of the `pochhammer_max_index`を越える位数の `pochhammer`関数は迷惑かもしれません; 以下を考えてください。

    (%i1) x :  pochhammer (1, 10), pochhammer_max_index : 5;
    (%o1)                         (1)
                                     10

`float`を適用することは xを浮動小数点に評価しません。

    (%i2) float (x);
    (%o2)                       (1.0)
                                     10.0

xを浮動小数点に評価するには、 `pochhammer_max_index`を11以上にバインドして、 `float`を xに適用する必要があります。

    (%i3) float (x), pochhammer_max_index : 11;
    (%o3)                       3628800.0

`pochhammer_max_index`のデフォルト値は100です; `orthopoly`をロードした後、値を変えてください。

最後に、参考書は直交多項式の定義を変えることを承知してください; 一般的にAbramowitz and Stegunの慣例を使っています。

orhtopolyのバグを疑う前に、 いくつかの特殊なケースをチェックして、 あなたの定義が`orthopoly`が使っているものと一致しているかを明らかにしてください。

定義はしばしば規格化について異なります; 時々、著者は (-1, 1)以外の区間上で直交な族を作る関数の「シフト」版を使います。 例えば、 (0, 1)上で直交するLegendre多項式を定義するのに、 以下を定義します。

    (%i1) shifted_legendre_p (n, x) := legendre_p (n, 2*x - 1)$

    (%i2) shifted_legendre_p (2, rat (x));
                                2
    (%o2)/R/                 6 x  - 6 x + 1
    (%i3) legendre_p (2, rat (x));
                                   2
                                3 x  - 1
    (%o3)/R/                    --------
                                   2

#### 71.1.3 Floating point Evaluation

`orthopoly`の関数のほとんどは 浮動小数点評価中の誤差を見積もるのに、 ランニング誤差解析を使います; 例外は球Bessel関数と第二種Legendreの陪多項式です。 数値評価のため、 球Bessel関数はSLATEC関数をコールします。 第二種Legendreの陪多項式の数値評価のために特別な方法は使われません。

ランニング誤差解析は (丸め単位としても知られている)計算機イプシロンの二次か高次の 誤差を無視します。 2,3の他の誤差も無視します。 (ありそうにありませんが、)実際の誤差は推定を越える可能性があります。

区間は形式 `interval (c, r)`を持ちます。 ここで、 cは区間の中心で、 rは半径です。 区間の中心は複素数であり得ますし、 半径はいつも正の実数です。

以下は例です。

    (%i1) fpprec : 50$

    (%i2) y0 : jacobi_p (100, 2, 3, 0.2);
    (%o2) interval(0.1841360913516871, 6.8990300925815987E-12)
    (%i3) y1 : bfloat (jacobi_p (100, 2, 3, 1/5));
    (%o3) 1.8413609135168563091370224958913493690868904463668b-1

実際の誤差が誤差推定よりも小さいことをテストしましょう。

    (%i4) is (abs (part (y0, 1) - y1) < part (y0, 2));
    (%o4)                         true

なるほど、この例では、 誤差推定は真の誤差の上限です。

Maximaは区間の算術をサポートしていません。

    (%i1) legendre_p (7, 0.1) + legendre_p (8, 0.1);
    (%o1) interval(0.18032072148437508, 3.1477135311021797E-15)
            + interval(- 0.19949294375000004, 3.3769353084291579E-15)

ユーザーは区間算数を行う計算をする演算子を定義できます。 区間の足し算を定義するには、 以下を定義できます。

    (%i1) infix ("@+")$

    (%i2) "@+"(x,y) := interval (part (x, 1) + part (y, 1), part (x, 2)
          + part (y, 2))$

    (%i3) legendre_p (7, 0.1) @+ legendre_p (8, 0.1);
    (%o3) interval(- 0.019172222265624955, 6.5246488395313372E-15)

引数が複素数の時、特殊な浮動小数点ルーチンがコールされます。 例えば、

    (%i1) legendre_p (10, 2 + 3.0*%i);
    (%o1) interval(- 3.876378825E+7 %i - 6.0787748E+7,
                                               1.2089173052721777E-6)

これを真値と比較しましょう。

    (%i1) float (expand (legendre_p (10, 2 + 3*%i)));
    (%o1)          - 3.876378825E+7 %i - 6.0787748E+7

更に、 引数が多倍長浮動小数点の時、 特殊な浮動小数点ルーチンがコールされます; しかしながら、多倍長浮動小数点は 倍精度浮動小数点に変換され、最終結果は倍精度です。

    (%i1) ultraspherical (150, 0.5b0, 0.9b0);
    (%o1) interval(- 0.043009481257265, 3.3750051301228864E-14)

#### 71.1.4 Graphics and `orthopoly`

直交多項式を含む式をプロットするには、 2つのことをしなければいけません:

1. オプション変数 `orthopoly_returns_intervals`を `false`に設定する。
2. `orthopoly`関数のすべてのコールをクォートする。

もし関数コールがクォートされていないなら、 Maximaはプロットする前にそれらを多項式に評価します; 結果として、 特殊な浮動小数点コードはコールされません。 以下は、Legendre多項式を含む式をどうやってプロットするかの例です。

    (%i1) plot2d ('(legendre_p (5, x)), [x, 0, 1]),
                            orthopoly_returns_intervals : false;
    (%o1)

式 `legendre_p (5, x)`全体をクォートします; これは `'legendre_p (5, x)`を使って関数名をクォートするだけとは違います。

Plotting ·

#### 71.1.5 Miscellaneous Functions

`orthopoly`パッケージは Pochhammerシンボルと単位階段函数を定義します。 `orthopoly`は`gradef`文の中で Kroneckerのデルタ函数と単位階段函数を使います。

Pochhammerシンボルをガンマ函数の商に変換するには、 `makegamma`を使ってください。

    (%i1) makegamma (pochhammer (x, n));
                              gamma(x + n)
    (%o1)                     ------------
                                gamma(x)
    (%i2) makegamma (pochhammer (1/2, 1/2));
                                    1
    (%o2)                       ---------
                                sqrt(%pi)

Pochhammerシンボルの導函数は `psi`函数を使って与えられます。

    (%i1) diff (pochhammer (x, n), x);
    (%o1)             (x)  (psi (x + n) - psi (x))
                         n     0             0
    (%i2) diff (pochhammer (x, n), n);
    (%o2)                   (x)  psi (x + n)
                               n    0

(%o1)の式に注意する必要があります; `psi`函数の差分は `x = -1, -2, .., -n`の時 多項式です。 これらの多項式は nが正の整数の時、 導函数を`n - 1`次多項式にするように、 `pochhammer (x, n)`の因子を相殺します。

Pochhammerシンボルは ガンマ函数の商としての表現を通して 負の位数で定義されます。 以下を考えてください。

    (%i1) q : makegamma (pochhammer (x, n));
                              gamma(x + n)
    (%o1)                     ------------
                                gamma(x)
    (%i2) sublis ([x=11/3, n= -6], q);
                                   729
    (%o2)                        - ----
                                   2240

代わりに、この結果を直接得ることができます。

    (%i1) pochhammer (11/3, -6);
                                   729
    (%o1)                        - ----
                                   2240

単位階段函数は左連続です; 従って、

    (%i1) [unit_step (-1/10), unit_step (0), unit_step (1/10)];
    (%o1)                       [0, 0, 1]

もし零で左連続でも右連続でもない単位階段函数が必要なら、 `signum`を使って自分のものを定義してください; 例えば、

    (%i1) xunit_step (x) := (1 + signum (x))/2$

    (%i2) [xunit_step (-1/10), xunit_step (0), xunit_step (1/10)];
                                    1
    (%o2)                       [0, -, 1]
                                    2

`unit_step`自身を再定義しないでください; `orthopoly`の中のあるコードは 単位階段函数が左連続であることを要求します。

#### 71.1.6 Algorithms

一般的に、 `orthopoly`は 直交多項式の超幾何表現を使うことで記号評価をします 超幾何函数は (ドキュメント化されていない)関数 `hypergeo11`と `hypergeo21`を使って 評価されます。 例外は半整数Bessel函数と第二種Legendreの陪函数です。 半整数Bessel函数は明示的な表現を使って評価されます。 第二種Legendreの陪函数は再帰を使って評価されます。

浮動小数点評価のために、 函数のほとんどを超幾何形式に再び変換します; 順方向再帰を使って超幾何函数を評価します。 ここでも、 例外は半整数Bessel函数と第二種Legendreの陪函数です。 数値的に、 半整数Bessel函数はSLATECコードを使って評価されます。

Previous: Introduction to orthogonal polynomials, Up: orthopoly [Contents][Index]

### 71.2 Functions and Variables for orthogonal polynomials

関数: assoc_legendre_p (n, m, x)

  次数 nと位数 mの第一種Legendre陪函数。

  参考文献: Abramowitz and Stegun, equations 22.5.37, page 779, 8.6.6 (second equation), page 334, and 8.2.5, page 333.

  Package orthopoly ·

関数: assoc_legendre_q (n, m, x)

  次数 nと位数 mの第二種Legendre陪函数。

  参考文献: Abramowitz and Stegun, equation 8.5.3 and 8.1.8.

  Package orthopoly ·

関数: chebyshev_t (n, x)

  第一種Chebyshev函数。

  参考文献: Abramowitz and Stegun, equation 22.5.47, page 779.

  Package orthopoly ·

関数: chebyshev_u (n, x)

  第二種Chebyshev函数。

  参考文献: Abramowitz and Stegun, equation 22.5.48, page 779.

  Package orthopoly ·

関数: gen_laguerre (n, a, x)

  次数 nの一般化Laguerre多項式。

  参考文献: Abramowitz and Stegun, equation 22.5.54, page 780.

  Package orthopoly ·

関数: hermite (n, x)

  Hermite多項式。

  参考文献: Abramowitz and Stegun, equation 22.5.55, page 780.

  Package orthopoly ·

関数: intervalp (e)

  もし入力が区間なら `true`を、 そうでないなら `false`を返します。

  Package orthopoly ·Predicate functions ·

関数: jacobi_p (n, a, b, x)

  Jacobiの多項式。

  Jacobiの多項式は実際には aと bすべてに対して定義されます; しかし、Jacobi多項式の重み `(1 - x)^a (1 + x)^b`は `a <= -1`か `b <= -1`で可積分でありません。

  参考文献: Abramowitz and Stegun, equation 22.5.42, page 779.

  Package orthopoly ·

関数: laguerre (n, x)

  Laguerre多項式。

  参考文献: Abramowitz and Stegun, equations 22.5.16 and 22.5.54, page 780.

  Package orthopoly ·

関数: legendre_p (n, x)

  第一種Legendre多項式。

  参考文献: Abramowitz and Stegun, equations 22.5.50 and 22.5.51, page 779.

  Package orthopoly ·

関数: legendre_q (n, x)

  第二種Legendre多項式。

  参考文献: Abramowitz and Stegun, equations 8.5.3 and 8.1.8.

  Package orthopoly ·

関数: orthopoly_recur (f, args)

  引数 argsを持つ直交函数族 fの漸化式を返します。 再帰は多項式次数に関してです。

      (%i1) orthopoly_recur (legendre_p, [n, x]);
                      (2 n - 1) P     (x) x + (1 - n) P     (x)
                                 n - 1                 n - 2
      (%o1)   P (x) = -----------------------------------------
               n                          n

  `orthopoly_recur`の二番目の引数は 関数 fの正しい数の引数のリストでなければいけません; もしそうでないなら、Maximaはエラーをシグナルします。

      (%i1) orthopoly_recur (jacobi_p, [n, x]);

      Function jacobi_p needs 4 arguments, instead it received 2
       -- an error.  Quitting.  To debug this try debugmode(true);

  更に、 fが直交多項式族の1つの名前でないなら、 エラーがシグナルされます。

      (%i1) orthopoly_recur (foo, [n, x]);

      A recursion relation for foo isn't known to Maxima
       -- an error.  Quitting.  To debug this try debugmode(true);

  Package orthopoly ·

変数: orthopoly_returns_intervals

  デフォルト値: `true`

  `orthopoly_returns_intervals`が `true`の時、 浮動小数点の結果が形式 `interval (c, r)` で返されます。 ここで、 cは区間の中心で、 rは半径です。 中心は複素数であり得ます; その場合、区間は複素平面上の円です。

  Package orthopoly ·

関数: orthopoly_weight (f, args)

  3つの要素のリストを返します; 一番目の要素は リスト argsが与える引数を持つ直交多項式族 fの重みの公式です; 二番目と三番目の要素は 直交性の区間の下限と上限を与えます。 例えば、

      (%i1) w : orthopoly_weight (hermite, [n, x]);
                                  2
                               - x
      (%o1)                 [%e    , - inf, inf]
      (%i2) integrate(w[1]*hermite(3, x)*hermite(2, x), x, w[2], w[3]);
      (%o2)                           0

  fの主変数はシンボルでなければいけません; そうでないなら、Maximaはエラーをシグナルします。

  Package orthopoly ·

関数: pochhammer (n, x)

  Pochhammerシンボル。 `n <= pochhammer_max_index`の非負整数 nに対して、 式 `pochhammer (x, n)`は `n > 0`の時、 積 `x (x + 1) (x + 2) ... (x + n - 1)` を評価します。 `n = 0`の時は1です。 負の nに対しては、 `pochhammer (x, n)`は `(-1)^n / pochhammer (1 - x, -n)`として定義されます。 従って、

      (%i1) pochhammer (x, 3);
      (%o1)                   x (x + 1) (x + 2)
      (%i2) pochhammer (x, -3);
                                       1
      (%o2)               - -----------------------
                            (1 - x) (2 - x) (3 - x)

  Pochhammerシンボルをガンマ函数の商に変換するには、 (Abramowitz and Stegun, equation 6.1.22を参照してください) `makegamma`を使ってください; 例えば、

      (%i1) makegamma (pochhammer (x, n));
                                gamma(x + n)
      (%o1)                     ------------
                                  gamma(x)

  nが `pochhammer_max_index`を越えるか、 nが記号の時、 `pochhammer`は名詞形を返します。

      (%i1) pochhammer (x, n);
      (%o1)                         (x)
                                       n

  Package orthopoly ·Gamma and factorial functions ·

変数: pochhammer_max_index

  デフォルト値: 100

  `pochhammer (n, x)`は `n <= pochhammer_max_index`の時だけ 積を展開します。

  例:

      (%i1) pochhammer (x, 3), pochhammer_max_index : 3;
      (%o1)                   x (x + 1) (x + 2)
      (%i2) pochhammer (x, 4), pochhammer_max_index : 3;
      (%o2)                         (x)
                                       4

  参考文献: Abramowitz and Stegun, equation 6.1.16, page 256.

  Package orthopoly ·Gamma and factorial functions ·

関数: spherical_bessel_j (n, x)

  第一種球Bessel函数。

  参考文献: Abramowitz and Stegun, equations 10.1.8, page 437 and 10.1.15, page 439.

  Package orthopoly ·Bessel functions ·

関数: spherical_bessel_y (n, x)

  第二種球Bessel函数。

  参考文献: Abramowitz and Stegun, equations 10.1.9, page 437 and 10.1.15, page 439.

  Package orthopoly ·Bessel functions ·

関数: spherical_hankel1 (n, x)

  第一種球Hankel函数。

  参考文献: Abramowitz and Stegun, equation 10.1.36, page 439.

  Package orthopoly ·Bessel functions ·

関数: spherical_hankel2 (n, x)

  第二種球Hankel函数。

  参考文献: Abramowitz and Stegun, equation 10.1.17, page 439.

  Package orthopoly ·Bessel functions ·

関数: spherical_harmonic (n, m, x, y)

  球調和函数。

  参考文献: Merzbacher 9.64.

  Package orthopoly ·

関数: unit_step (x)

  左連続の単位階段函数;なので `unit_step (x)`は`x <= 0`で0であり、 `x > 0`で1です。

  もし0で値1/2を取る単位階段函数が欲しいなら、 `(1 + signum (x))/2`を使ってください。

  Package orthopoly ·Mathematical functions ·

関数: ultraspherical (n, a, x)

  (Gegenbauer多項式としても知られている)超球多項式。

  参考文献: Abramowitz and Stegun, equation 22.5.46, page 779.

  Package orthopoly ·

Next: romberg, Previous: orthopoly, Up: Top [Contents][Index]

## 72 plotdf

Next: Functions and Variables for plotdf, Previous: plotdf, Up: plotdf [Contents][Index]

### 72.1 Introduction to plotdf

関数`plotdf`は、 1次常微分方程式(ODE)や2つの自励1次ODE系の (勾配場とも呼ばれる)方向場のプロットを生成します。

PlotdfはXmaximaを要求します。 コンソールや他のMaximaインターフェースから使うことができますが、 結果のファイルはXmaximaに送られ、プロットされます。 plotdfを使ってみる前にXmaximaをインストールしたことを確認してください。

単一のODEの方向場をプロットするには、ODEを以下の形式で書かなければいけません:

           dy
           -- = F(x,y)
           dx

そして関数Fを`plotdf`の引数に与えなければいけません。 もし独立変数と従属変数が、上の式のようにxとyでないなら、 plotdfコマンドへの引数として与えられるリストの中に明示的に それら2つの変数を指名しなければいけません。 (例を見てください。)

2つの自励ODEの組の方向場をプロットするには、 それらを以下の形式で書かなければいけません。

           dx             dy
           -- = G(x,y)    -- = F(x,y)
           dt             dt

そして`plotdf`の引数は2つの関数GとFを その順に持つリストでなければいけません; すなわち、リストの最初の式は水平軸上に表された変数の時間導関数であり、 二番目の式は垂直軸上に表された変数の時間導関数です。 それら2つの変数はxとyである必要はありませんが、 もしそうでないなら、 plotdfに与えられる二番目の引数は 2つの変数を、最初のものが水平軸上のものを、その後垂直軸上のものを指定する別のリストでなければいけません。

もしただ1つのODEが与えられるなら、 `plotdf`は、 暗に`x=t`,`G(x,y)=1`と認め、 非自励方程式を2つの自励方程式系に変換します。

Differential equations ·Share packages ·Package plotdf ·

Previous: Introduction to plotdf, Up: plotdf [Contents][Index]

### 72.2 Functions and Variables for plotdf

関数: plotdf (dydx, ...options...)
関数: plotdf (dvdu, `[`u,v`]`, ...options...)
関数: plotdf (`[`dxdt,dydt`]`, ...options...)
関数: plotdf (`[`dudt,dvdt`]`, `[`u,v`]`, ...options...)

  2次元xとyに方向場を表示します。

  最初の引数は導関数を指定し、式か2つの式のリストでなければいけません。 dydx, dxdt, dydtはxとyに依存する式です。 dvdu, dudt, dvdtはuとvに依存する式です。 それら2つの変数に加えて、 `parameters`オプションで与えられる数値を持つか(オプション構文法は以下に与えられます)、 slidersオプションで指定される許される値の範囲の パラメータ一式にも、式は依存するかもしれません。

  コマンド内やメニューで選択して、いくつかの他のオプションを与えることができます。 プロット上でクリックしたり、オプション`trajectory_at`を使って、 積分曲線を得ることができます。 `direction`オプションを使って、積分の方向を制御できます。 オプションは、forward, backward, bothのいずれかの値を取り得ます。 `nsteps`で積分ステップの数を与えることができ、 `tstep`オプションでそれらの間の時間間隔を設定できます。 積分にはAdams Moulton法が使われます; 4次の適応Runge-Kutta法に切り替えることも可能です。

  プロットウィンドウメニュー:

  プロットウィンドウのメニューには以下のオプションがあります: Zoom, はマウスの振る舞いを変えて、プロット領域上で左ボタンをクリックすることで ズームインできるようになります。 ある点近くをクリックする毎に、クリックした点を中心にしてプロットが拡大されます。 `Shift`キーを押しながらクリックすると、 以前の倍率にズームアウトします。 ある点をクリックした時、軌跡の計算を再開するには、 メニューからIntegrateを選択してください。

  メニューの中のオプションConfigを使って， 使用中のODE(s)や様々な他の設定を変えることができます。 構成の変更がされた後、新しい設定を稼働するには、 メニューオプションReplotを選択しなければいけません。 もし、座標の組を Configダイアログメニューの場Trajectory atに入れて、 `enter`キーを押したら、 既に示されているものに加えて、新しい積分曲線が表示されます。 Replotが選択された時は、 入れられた最後の積分曲線だけが表示されます。

  右マウスボタンを押しながらカーソルを動かすと、 プロットを横や上下にドラッグできます。 ステップ数やtの初期値、x, yの中心や範囲のような追加パラメータは、 Configメニューで設定できます。

  プロットのコピーは、メニューオプションSaveを使って、 ポストスクリプトファイルとして保存できます。

  プロットオプション:

  `plotdf`コマンドはいくつかのコマンドを含むかもしれません。 それぞれのコマンドは複数の項目のリストです。 最初の項目はオプション名で、 残りはオプションに割り当てられる値から成ります。

  `plotdf`が認識するオプションは以下の通りです:

  - tstepは、独立変数tに関する増分の長さを定義します。 積分曲線を計算するのに使われます。 もしただ1つの式dydxが`plotdf`に与えられたら、 x変数はtに直接比例することになります。 デフォルト値は0.1です。
  - nstepsは、 積分曲線を計算するのに、独立変数に対して使われる長さ`tstep`のステップ回数を定義します。 デフォルト値は100です。
  - directionは 積分曲線を計算する際に従う独立変数の方向を定義します。 可能な値は、 `forward`―これは増分`tstep`で独立変数を`nsteps`回増やします― `backward`―これは独立変数を減らします― または`both`―これは `nsteps`回前進、 `nsteps`回後進で拡げた積分曲線に導きます― キーワード`right`と`left`を、 `forward`と`backward`の別称として使うことができます。 デフォルト値は`both`です。
  - tinitialは 積分曲線を計算するために使われる変数tの初期値です。 微分方程式が自励なので、 その設定はtの関数として曲線のプロットでだけ現れます。 デフォルト値は0です。
  - versus_tは 独立変数tの2つの関数x, yとしての 積分曲線のプロットを使って二番目のプロットウィンドウを生成するために 使われます。 もし`versus_t`が0と異なる任意の値を与えられたら、 二番目のプロットウィンドウが表示されます。 二番目のプロットウィンドウは、 メインプロットウィンドウのメニューに似た別のメニューを含みます。 デフォルト値は0です。
  - trajectory_atは 積分曲線の開始点のための座標xinitialとyinitialを定義します。 オプションはデフォルトで空です。
  - parametersは 微分方程式の定義の中で使われるパラメータとその数値のリストを定義します。 パラメータの名前と値は、 コンマで分離された組`name=value`の列を持つ文字列で与えなければいけません。
  - slidersは スライダーボタンを使って対話的に変更されるパラメータと それらのパラメータの変動範囲のリストです。 パラメータの名前と範囲は、 コンマで分離された要素`name=min:max`の列を持つ文字列で与えなければいけません。
  - xfunは 方向場の上にセミコロンで分離された表示されるxの関数の列を持つ文字列を定義します。 これらの関数はMaximaではなくTclでパースされます。
  - xには2つの数が続かなければいけません。 2つの数は水平軸上で表示される最小値と最大値を設定します。 もし水平軸上の変数がxでないなら、 このオプションは水平軸上の変数名を持たなければいけません。 デフォルトの水平範囲は-10から10です。
  - yには2つの数が続かなければいけません。 2つの数は垂直軸上で表示される最小値と最大値を設定します。 もし垂直軸上の変数がyでないなら、 このオプションは垂直軸上の変数名を持たなければいけません。 デフォルトの垂直範囲は-10から10です。

  例:

  - 微分方程式y' = exp(-x) + yの方向場と(2, -0.1)を通過する解を表示するために:

        (%i1) plotdf(exp(-x)+y,[trajectory_at,2,-0.1])$

  - 方程式diff(y,x) = x - y^2の方向場と 初期条件y(-1) = 3の解を得るために、 以下のコマンドをつかうことができます:

        (%i1) plotdf(x-y^2,[xfun,"sqrt(x);-sqrt(x)"],
                 [trajectory_at,-1,3], [direction,forward],
                 [y,-5,5], [x,-4,16])$

    グラフは関数y = sqrt(x)も表示します。

  - 以下の例は、 2つの方程式dz/dt = vとdv/dt = -k*z/mで定義される調和振動子の方向場と、 (z,v) = (6,0)を通る積分曲線を、 (kは2に固定で)mの値を対話的に変えられるスライダーと一緒に、 表示します。

        (%i1) plotdf([v,-k*z/m], [z,v], [parameters,"m=2,k=2"],
                   [sliders,"m=1:5"], [trajectory_at,6,0])$

  - Duffing方程式m*x''+c*x'+k*x+b*x^3 = 0の方向場をプロットするために、 変数y=x'を導入し、以下のように使います:

        (%i1) plotdf([y,-(k*x + c*y + b*x^3)/m],
                     [parameters,"k=-1,m=1.0,c=0,b=1"],
                     [sliders,"k=-2:2,m=-1:1"],[tstep,0.1])$

  - 質量mの値を変更するのに使うことができるスライダーと一緒に 与えられた初期条件の解と減衰振り子の方向場と 時間の関数として2つの状態変数のプロットを一緒に:

        (%i1) plotdf([w,-g*sin(a)/l - b*w/m/l], [a,w],
                [parameters,"g=9.8,l=0.5,m=0.3,b=0.05"],
                [trajectory_at,1.05,-9],[tstep,0.01],
                [a,-10,2], [w,-14,14], [direction,forward],
                [nsteps,300], [sliders,"m=0.1:1"], [versus_t,1])$

  Package plotdf ·Plotting ·Numerical methods ·

Next: simplex, Previous: plotdf, Up: Top [Contents][Index]

## 73 romberg

Previous: Top, Up: Top [Contents][Index]

### 73.1 Functions and Variables for romberg

関数: romberg (expr, x, a, b)
関数: romberg (F, a, b)

  Romberg法による数値積分を計算します。

  `romberg(expr, x, a, b)`は 積分`integrate(expr, x, a, b)`の概算を返します。

  exprは、 xが浮動小数点値にバインドされた時 浮動小数点値に評価される 式でなければいけません。

  `romberg(F, a, b)`は 積分`integrate(F(x), x, a, b)`の概算を返します。 ここで、`x`はFの名付けられない唯一の引数を表します; 実際の引数は`x`と名付けられません。 Fは、 引数が浮動小数点値の時、浮動小数点値を返す MaximaかLispの関数でなければいけません。 Fは翻訳またはコンパイルされたMaxima関数を指定することができます。

  `romberg`の精度は グローバル変数`rombergabs`と`rombergtol`によって決定されます。 `romberg`は 連続する近似の間の絶対差が`rombergabs`よりも小さい時か、 連続する近似に関する相対差が`rombergtol`よりも小さい時、 成功のうちに終了します。 従って、 `rombergabs`が0.0 (デフォルト)の時、 相対誤差テストだけが`romberg`に効果を持ちます。

  `romberg`は あきらめる前に、せいぜい`rombergit`回、ステップサイズを半分にします; それゆえ、関数評価の最大回数は`2^rombergit`です。 もし `rombergabs`や`rombergtol`によって確立される誤差基準が満たされないなら、 `romberg`はエラーメッセージを印字します。 `romberg`はいつも、少なくとも`rombergmin`回の繰り返しを行います; これは、被積分関数が振動的な時、見せかけの終了を防ぐつもりの発見的方法です。

  `romberg`は、 積分変数を特定の値にバインド(する前ではなく)した後、 被積分関数を繰り返し評価します。 この評価ポリシーは、多次元積分を計算するための `romberg`の入れ子のコールを可能にします。 しかしながら、誤差計算は 入れ子の積分の誤差を考慮しないので、エラーは過小評価されるかもしれません。 また、多次元問題のために特別に工夫された方法はより少ない関数評価で同じ精度をもたらす可能性があります。

  `load("romberg")`はこの関数をロードします。

  `QUADPACK`、数値積分関数のコレクションも参照してください。

  例:

  1次元積分。

      (%i1) load ("romberg");
      (%o1)    /usr/share/maxima/5.11.0/share/numeric/romberg.lisp
      (%i2) f(x) := 1/((x - 1)^2 + 1/100) + 1/((x - 2)^2 + 1/1000)
                    + 1/((x - 3)^2 + 1/200);
                          1                 1                1
      (%o2) f(x) := -------------- + --------------- + --------------
                           2    1           2    1            2    1
                    (x - 1)  + ---   (x - 2)  + ----   (x - 3)  + ---
                               100              1000              200
      (%i3) rombergtol : 1e-6;
      (%o3)                 9.9999999999999995E-7
      (%i4) rombergit : 15;
      (%o4)                          15
      (%i5) estimate : romberg (f(x), x, -5, 5);
      (%o5)                   173.6730736617464
      (%i6) exact : integrate (f(x), x, -5, 5);
      (%o6) 10 sqrt(10) atan(70 sqrt(10))
       + 10 sqrt(10) atan(30 sqrt(10)) + 10 sqrt(2) atan(80 sqrt(2))
       + 10 sqrt(2) atan(20 sqrt(2)) + 10 atan(60) + 10 atan(40)
      (%i7) abs (estimate - exact) / exact, numer;
      (%o7)                7.5527060865060088E-11

  `romberg`の入れ子のコールで実装された 2次元積分。

      (%i1) load ("romberg");
      (%o1)    /usr/share/maxima/5.11.0/share/numeric/romberg.lisp
      (%i2) g(x, y) := x*y / (x + y);
                                          x y
      (%o2)                   g(x, y) := -----
                                         x + y
      (%i3) rombergtol : 1e-6;
      (%o3)                 9.9999999999999995E-7
      (%i4) estimate : romberg (romberg (g(x, y), y, 0, x/2), x, 1, 3);
      (%o4)                   0.81930239628356
      (%i5) assume (x > 0);
      (%o5)                        [x > 0]
      (%i6) integrate (integrate (g(x, y), y, 0, x/2), x, 1, 3);
                                                3
                                          2 log(-) - 1
                          9                     2        9
      (%o6)       - 9 log(-) + 9 log(3) + ------------ + -
                          2                    6         2
      (%i7) exact : radcan (%);
                          26 log(3) - 26 log(2) - 13
      (%o7)             - --------------------------
                                      3
      (%i8) abs (estimate - exact) / exact, numer;
      (%o8)                1.3711979871851024E-10

  Package romberg ·Numerical methods ·

オプション変数: rombergabs

  デフォルト値: 0.0

  `romberg`の精度は、 グローバル変数`rombergabs`と`rombergtol`で決定されます。 `romberg`は 連続する近似の間の絶対差が`rombergabs`よりも小さい時か、 連続する近似に関する相対差が`rombergtol`よりも小さい時、 成功のうちに終了します。 従って、 `rombergabs`が0.0 (デフォルト)の時、 相対誤差テストだけが`romberg`に効果を持ちます。

  `rombergit`と`rombergmin`も参照してください。

  Package romberg ·

オプション変数: rombergit

  デフォルト値: 11

  `romberg`は あきらめる前に、せいぜい`rombergit`回、ステップサイズを半分にします; それゆえ、関数評価の最大回数は`2^rombergit`です。 `romberg`はいつも、少なくとも`rombergmin`回の繰り返しを行います; これは、被積分関数が振動的な時、見せかけの終了を防ぐつもりの発見的方法です。

  `rombergabs`と`rombergtol`も参照してください。

  Package romberg ·

オプション変数: rombergmin

  デフォルト値: 0

  `romberg`はいつも、少なくとも`rombergmin`回の繰り返しを行います; これは、被積分関数が振動的な時、見せかけの終了を防ぐつもりの発見的方法です。

  `rombergit`, `rombergabs`, `rombergtol`も参照してください。

  Package romberg ·

オプション変数: rombergtol

  デフォルト値: 1e-4

  `romberg`の精度は グローバル変数`rombergabs`と`rombergtol`によって決定されます。 `romberg`は 連続する近似の間の絶対差が`rombergabs`よりも小さい時か、 連続する近似に関する相対差が`rombergtol`よりも小さい時、 成功のうちに終了します。 従って、 `rombergabs`が0.0 (デフォルト)の時、 相対誤差テストだけが`romberg`に効果を持ちます。

  `rombergit`と`rombergmin`も参照してください。

  Package romberg ·

Next: simplification, Previous: romberg, Up: Top [Contents][Index]

## 74 simplex

Next: Functions and Variables for simplex, Previous: simplex, Up: simplex [Contents][Index]

### 74.1 Introduction to simplex

`simplex`はシンプレックスアルゴリズムを使った線形最適化のパッケージです。

例:

    (%i1) load("simplex")$
    (%i2) minimize_lp(x+y, [3*x+2*y>2, x+4*y>3]);
                      9        7       1
    (%o2)            [--, [y = --, x = -]]
                      10       10      5

Numerical methods ·Optimization ·Share packages ·Package simplex ·

Previous: Introduction to simplex, Up: simplex [Contents][Index]

### 74.2 Functions and Variables for simplex

オプション変数: epsilon_lp

  デフォルト値: `10^-8`

  `linear_program`の数値計算で使われるイプシロン。

  以下も参照してください: `linear_program`

  Package simplex ·

関数: linear_program (A, b, c)

  `linear_program`は シンプレックスアルゴリズムの実装です。 `linear_program(A, b, c)`は、 `A.x = b`かつ`x >= 0`を満たすベクトルの中で`c.x`が可能な最小となる ベクトルxを計算します。 引数Aは行列で、引数bとcはリストです。

  `linear_program`は、 最小化ベクトルxと最小値`c.x`を含む リストを返します。 もし問題が有界でないなら、 "Problem not bounded!"を返し、 もし問題が実現可能でないなら、 "Problem not feasible!"を返します。

  この関数を使うためには、最初に`load("simplex");`で`simplex`パッケージをロードしてください。

  例:

      (%i2) A: matrix([1,1,-1,0], [2,-3,0,-1], [4,-5,0,0])$
      (%i3) b: [1,1,6]$
      (%i4) c: [1,-2,0,0]$
      (%i5) linear_program(A, b, c);
                         13     19        3
      (%o5)            [[--, 4, --, 0], - -]
                         2      2         2

  以下も参照してください: `minimize_lp`, `scale_lp`, `epsilon_lp`

  Package simplex ·Numerical methods ·

関数: maximize_lp (obj, cond, [pos])

  いくつかの線形制約condに従う線形目標関数objを最大化します。 引数と戻り値の詳細な記述に関しては、 `minimize_lp`を参照してください。

  以下も参照してください: `minimize_lp`.

  Package simplex ·Numerical methods ·

関数: minimize_lp (obj, cond, [pos])

  いくつかの線形制約condに従う線形目標関数objを最小化します。 condは線形等式や不等式のリストです。 厳密な不等式では、`>`は`>=`に、 `<`は`<=`に置き換えられます。 オプションの引数posは 正と仮定される決定変数のリストです。

  もし最小が存在するなら、 `minimize_lp`は 目標関数の最小値と最小が得られる決定変数値のリスト を含むリストです。 もし問題が有界でないなら、 `minimize_lp`は"Problem not bounded!"を返し、 もし問題が実現可能でないなら、 "Ploblem not feasible!"を返します。

  決定変数はデフォルトでは非負とは仮定されません。 もし決定変数すべてが正なら、 `nonegative_lp`を`true`に設定してください。 もし決定変数のいくつかだけが正なら、 オプション引数posの中でそれらをリストしてください。 (これは制約を足すより効率的だということに注意してください。)

  `minimize_lp`は Maximaの`linear_program`関数で実装された シンプレックスアルゴリズムを使います。

  この関数を使うためには、最初に`load("simplex");`で `simplex`パッケージをロードしてください。

  例:

      (%i1) minimize_lp(x+y, [3*x+y=0, x+2*y>2]);
                            4       6        2
      (%o1)                [-, [y = -, x = - -]]
                            5       5        5
      (%i2) minimize_lp(x+y, [3*x+y>0, x+2*y>2]), nonegative_lp=true;
      (%o2)                [1, [y = 1, x = 0]]
      (%i3) minimize_lp(x+y, [3*x+y=0, x+2*y>2]), nonegative_lp=true;
      (%o3)                Problem not feasible!
      (%i4) minimize_lp(x+y, [3*x+y>0]);
      (%o4)                Problem not bounded!

  いかも参照してください: `maximize_lp`, `nonegative_lp`, `epsilon_lp`。

  Package simplex ·Numerical methods ·

オプション変数: nonegative_lp

  デフォルト値: `false`

  もし`nonegative_lp`がtrueなら、 `minimize_lp`と`maximize_lp`の決定変数すべては正と仮定されます。

  以下も参照してください: `minimize_lp`。

  Package simplex ·

Next: solve_rec, Previous: simplex, Up: Top [Contents][Index]

## 75 simplification

Next: Package absimp, Previous: simplification, Up: simplification [Contents][Index]

### 75.1 Introduction to simplification

ディレクトリ`maxima/share/simplification`は 整理ルールと整理関数を実装するいくつかのスクリプトと整理に関係しないいくつかの関数を含みます。

Next: Package facexp, Previous: Introduction to simplification, Up: simplification [Contents][Index]

### 75.2 Package absimp

`absimp`パッケージは `abs`と`signum`関数のために 組み込み整理ルールを拡張する パターンマッチングルールを含みます。 `absimp`は、 組み込み`assume`関数で、また、 偶数や奇数に関して`modedeclare (m, even, n, odd)`のような宣言によって 確立された関係を考慮します。

`absimp`は `abs`と`signum`を使って `unitramp`と`unitstep`関数を定義します。

`load ("absimp")`はこのパッケージをロードします。 `demo (absimp)`はこのパッケージのデモを表示します。

例:

    (%i1) load ("absimp")$
    (%i2) (abs (x))^2;
                                           2
    (%o2)                                 x
    (%i3) diff (abs (x), x);
                                          x
    (%o3)                               ------
                                        abs(x)
    (%i4) cosh (abs (x));
    (%o4)                               cosh(x)

Simplification functions ·Rules and patterns ·Share packages ·Package absimp ·

Next: Package functs, Previous: Package absimp, Up: simplification [Contents][Index]

### 75.3 Package facexp

`facexp`パッケージは、 制御された展開によって式を構造化する能力をユーザーに与えるいくつかの関連関数を含みます。 式が物理的意味を持つ変数を含むとき、この能力は特に役に立ちます。 そんな式の最も簡潔な形式は、それらの変数に関して式を完全に展開し、 その後係数を因数分解することで得られることがしばしばあるからです。 この手続きは標準のMaxima関数を使って実行することは難しくありませんが、 追加の微調整も望まれていて、これらの仕上げは適用するのが更に難しくなることがあります。

関数`facsum`とその関連形式は、 この方法で式の構造を制御するための便利な手段を提供します。 別の関数`collectterms`は、 この形式に既に整理された複数の式を 式全体を再整理することなく、足し合わせるのに使うことができます。 式が非常に大きいとき、この関数は役に立つかもしれません。

`load ("facexp")`はこのパッケージをロードします。 `demo (facexp)`はこのパッケージのデモを見せます。

Expressions ·Share packages ·Package facexp ·

関数: facsum (expr, arg_1, ..., arg_n)

  引数arg_1, ..., arg_nに依存する exprの形式を返します。 引数は`ratvars`に適した任意の形式か、そんな形式のリストを取り得ます。 もし引数がリストでなければ、 返される形式は、引数に関して完全に展開され、引数の係数は因数分解されます。 これらの係数は、非合理的な意味合いを除いて引数に依存しません。

  引数のいずれかがリストなら、リストすべては1つのリストに結合されて、 引数の係数に対して`factor`をコールする代わりに `facsum`は、 これらの係数に対して自分自身をコールします。 この再帰コールに関しては、上記で新しく構成されたリストが新しい引数リストとして使われます。 この処理は、リストの中に望まれた要素を入れ子にすることで、任意の深さまで繰り返すことができます。

  It is possible that one may wish to `facsum` with respect to more complicated subexpressions, such as `log (x + y)`のような、より複雑な部分式に関して `facsum`したいかも知れません。 そんな引数も許されています。

  時々、ユーザーは 式に関して、先頭演算子によってのみ指定された上記形式いずれかが欲しいかもしれません。 例えば、 すべての`log`に関して`facsum`したかもしれません。 この場合、 この方法で扱われる特定の`log`か、 代わりに式`operator (log)`や`'operator (log)` を引数に含むことができます。 もし 演算子op_1, ..., op_nに関して 式exprを`facsum`したいなら、 `facsum (expr, operator (op_1, ..., op_n))`を評価します。 `operator`形式はリスト引数の中でも可能です。

  更に、 スイッチ`facsum_combine`と`nextlayerfactor`の設定は `facsum`の結果に影響するかもしれません。

  Package facexp ·Expressions ·

グローバル変数: nextlayerfactor

  デフォルト値: `false`

  `nextlayerfactor`が`true`の時、 `facsum`の再帰コールが 引数の係数の因数分解された形式の因子に適用されます。

  `false`の時、 `facsum`は、 `facsum`への再帰コールが起こる時はいつでも、全体としてそれぞれの係数に適用されます。

  `facsum`の引数リストに アトム`nextlayerfactor`を入れると、 `nextlayerfactor: true`の効果がありますが、 式の次のレベルだけに関してです。

  `nextlayerfactor`はいつも `true`か`false`にバインドされているので、 `facsum`の引数リストの中に現れる時はいつでも、 シングルクォートで表さなければいけません。

  Package facexp ·Expressions ·

グローバル変数: facsum_combine

  デフォルト値: `true`

  引数が多項式の商の時、 `facsum_combine`は `facsum`が返す最終結果の形式を制御します。 もし`facsum_combine`が`false`なら、 形式は既に記述したような完全に展開された和として返されますが、 もし`true`なら、 返される式は、既に記述した形式の多項式の比です。

  有理式の分子と分母両方を`facsum`したいが、 分母が分子の項ずつに掛けられたくない時、 このスイッチの`true`設定は役に立ちます。

  Package facexp ·Expressions ·

関数: factorfacsum (expr, arg_1, ... arg_n)

  exprの因子に関して引数として arg_1, ... arg_nを付けて`facsum`をコールすることで得られる exprの形式を返します。 もしexprの因子のいずれかがべきに累乗されるなら、 因子と指数と両方がこの方法で処理されます。

  Package facexp ·Expressions ·

関数: collectterms (expr, arg_1, ..., arg_n)

  もしいくつかの式が`facsum`もしくは`factorfacsum`, `factenexpand`, `facexpten`, `factorfacexpten`で整理されていて、それらが一緒に加算されているなら、 関数`collectterms`を使ってそれらを結合することが望まれる場合があります。 `collectterms`は、`nextlayerfactor`を除いてこれらの他の関連した関数に渡すことができる引数すべてを 引数として取ることができます。 `collectterms`の利点は、`facsum`と似た形式を返すことです。 しかし、既に`facsum`で処理された加算形式なのでこの処理を繰り返す必要はありません。 この能力は加算する式が非常に大きい時特に役立ちます。

  Package facexp ·Expressions ·

Next: Package ineq, Previous: Package facexp, Up: simplification [Contents][Index]

### 75.4 Package functs

Share packages ·Package functs ·

関数: rempart (expr, n)

  式exprからパーツnを取り除きます。

  もしnが形式`[l, m]`のリストなら、 パーツlからmまでが取り除かれます。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Expressions ·

関数: wronskian ([f_1, ..., f_n], x)

  変数xに関する式のリスト[f_1, ..., f_n]の Wronskian行列を返します。 Wronskian行列の行列式は、 式のリストのWronskian行列式です。

  `wronskian`を使うには、最初に`load("functs")`してください。例えば:

      (%i1) load("functs")$
      (%i2) wronskian([f(x), g(x)],x);
      (%o2) matrix([f(x),g(x)],['diff(f(x),x,1),'diff(g(x),x,1)])

  Package functs ·Differential calculus ·

関数: tracematrix (M)

  行列Mの跡(対角要素の和)を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Matrices ·

関数: rational (`z`)

  分母を有理化するように、 zの分子と分母に分母の複素共役を掛けます。 もし与えられたものがそうであれば、正準有理式(CRE)形式を返し、 そうでないなら、一般形式を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Expressions ·

関数: nonzeroandfreeof (x, expr)

  もし exprがゼロでなく、 `freeof (x, expr)`が`true`を返すなら、 `true`を返します。 そうでなければ、`false`を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Expressions ·

関数: linear (expr, x)

  exprが変数xに関して線形の式の時、 `linear`は`a*x + b`を返します。 ここで、aはゼロでなく、aとbはxに依存しません。 そうでなければ、`linear`はexprを返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Expressions ·

関数: gcdivide (p, q)

  `takegcd`が`true`の時、 `gcdivide`は多項式pとqを最大公約多項式で割り、 結果の比を返します。

  `takegcd`が`false`の時、 `gcdivide`は比`p/q`を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  `ezgcd`, `gcd`, `gcdex`, `poly_gcd`も参照してください。

  例:

      (%i1) load("functs")$

      (%i2) p1:6*x^3+19*x^2+19*x+6;
                              3       2
      (%o2)                6 x  + 19 x  + 19 x + 6
      (%i3) p2:6*x^5+13*x^4+12*x^3+13*x^2+6*x;
                        5       4       3       2
      (%o3)          6 x  + 13 x  + 12 x  + 13 x  + 6 x
      (%i4) gcdivide(p1, p2);
                                   x + 1
      (%o4)                        ------
                                    3
                                   x  + x
      (%i5) takegcd:false;
      (%o5)                         false
      (%i6) gcdivide(p1, p2);
                             3       2
                          6 x  + 19 x  + 19 x + 6
      (%o6)          ----------------------------------
                        5       4       3       2
                     6 x  + 13 x  + 12 x  + 13 x  + 6 x
      (%i7) ratsimp(%);
                                   x + 1
      (%o7)                        ------
                                    3
                                   x  + x

  Package functs ·Polynomials ·

関数: arithmetic (a, d, n)

  算術級数`a, a + d, a + 2*d, ..., a + (n - 1)*d`の第n項を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Sums and products ·

関数: geometric (a, r, n)

  幾何級数`a, a*r, a*r^2, ..., a*r^(n - 1)`の第n項を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Sums and products ·

関数: harmonic (a, b, c, n)

  調和級数`a/b, a/(b + c), a/(b + 2*c), ..., a/(b + (n - 1)*c)`の第n項を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Sums and products ·

関数: arithsum (a, d, n)

  算術級数の1からnまでの和を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Sums and products ·

関数: geosum (a, r, n)

  幾何級数の1からnまでの和を返します。 もしnが無限大(`inf`)なら、 rの絶対値が1未満でのみ、和は有限です。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Sums and products ·

関数: gaussprob (x)

  Gaussian確率函数`%e^(-x^2/2) / sqrt(2*%pi)`を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Mathematical functions ·

関数: gd (x)

  Gudermannian函数`2*atan(%e^x)-%pi/2`を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Mathematical functions ·

関数: agd (x)

  逆Gudermannian函数`log (tan (%pi/4 + x/2)))`を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Mathematical functions ·

関数: vers (x)

  正矢(せいし)`1 - cos (x)`を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Mathematical functions ·

関数: covers (x)

  余矢(よし)`1 - sin (x)`を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Mathematical functions ·

関数: exsec (x)

  外正割(exsecant)`sec (x) - 1`を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Mathematical functions ·

関数: hav (x)

  半正矢`(1 - cos(x))/2`を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Mathematical functions ·

関数: combination (n, r)

  一度にr個を取るn個のオブジェクトの組み合わせの数を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Mathematical functions ·

関数: permutation (n, r)

  n個のオブジェクトの集合から選択されたr個のオブジェクトの置換の数を返します。

  この関数を使うには、最初に`load("functs")`を書いてください。

  Package functs ·Mathematical functions ·

Next: Package rducon, Previous: Package functs, Up: simplification [Contents][Index]

### 75.5 Package ineq

`ineq`パッケージは不等式の整理規則を含みます。

セッション例:

    (%i1) load("ineq")$
    Warning: Putting rules on '+' or '*' is inefficient, and may not work.
    Warning: Putting rules on '+' or '*' is inefficient, and may not work.
    Warning: Putting rules on '+' or '*' is inefficient, and may not work.
    Warning: Putting rules on '+' or '*' is inefficient, and may not work.
    Warning: Putting rules on '+' or '*' is inefficient, and may not work.
    Warning: Putting rules on '+' or '*' is inefficient, and may not work.
    Warning: Putting rules on '+' or '*' is inefficient, and may not work.
    Warning: Putting rules on '+' or '*' is inefficient, and may not work.
    (%i2) a>=4;  /* a sample inequality */
    (%o2)                               a >= 4
    (%i3) (b>c)+%; /* add a second, strict inequality */
    (%o3)                            b + a > c + 4
    (%i4) 7*(x<y); /* multiply by a positive number */
    (%o4)                              7 x < 7 y
    (%i5) -2*(x>=3*z); /* multiply by a negative number */
    (%o5)                           - 2 x <= - 6 z
    (%i6) (1+a^2)*(1/(1+a^2)<=1); /* Maxima knows that 1+a^2 > 0 */
                                            2
    (%o6)                             1 <= a  + 1
    (%i7) assume(x>0)$ x*(2<3); /* assuming x>0 */
    (%o7)                              2 x < 3 x
    (%i8) a>=b; /* another inequality */
    (%o8)                               a >= b
    (%i9) 3+%; /* add something */
    (%o9)                           a + 3 >= b + 3
    (%i10) %-3; /* subtract it out */
    (%o10)                              a >= b
    (%i11) a>=c-b; /* yet another inequality */
    (%o11)                            a >= c - b
    (%i12) b+%; /* add b to both sides */
    (%o12)                            b + a >= c
    (%i13) %-c; /* subtract c from both sides */
    (%o13)                         - c + b + a >= 0
    (%i14) -%;  /* multiply by -1 */
    (%o14)                          c - b - a <= 0
    (%i15) (z-1)^2>-2*z; /* determining truth of assertion */
                                          2
    (%o15)                         (z - 1)  > - 2 z
    (%i16) expand(%)+2*z; /* expand this and add 2*z to both sides */
                                       2
    (%o16)                            z  + 1 > 0
    (%i17) %,pred;
    (%o17)                               true

不等式の回りで括弧を使うことについて注意してください; ユーザーが`(A > B) + (C = 5)`と入力した時、 結果は`A + C > B + 5`ですが、`A > B + C = 5`は構文エラーであり、 `(A > B + C) = 5`は完全に何か他のものです。

規則定義の完全なリストを見るには、 `disprule (all)`を実行してください。

Maximaが不等式に掛けられる量の符号を決定できない時、 ユーザーは問い合わせを受けるでしょう。

最もありふれた仕様の欠陥を以下に例示します:

    (%i1) eq: a > b;
    (%o1)                              a > b
    (%i2) 2*eq;
    (%o2)                            2 (a > b)
    (%i3) % - eq;
    (%o3)                              a > b

別の問題は0掛ける不等式です; これを0にするデフォルト動作はそのままです。 しかし、 もし`X*some_inequality`とタイプして、 Maximaが`X`の符号を尋ね、 `zero` (または`z`)と答えたなら、 プログラムは`X*some_inequality`を返し、 `X`が0という情報を使いません。 そんな時は、 データベースは、決定の際、`X`を評価する目的ではなく、比較目的のためだけに使われるので、 `ev (%, x: 0)`を実行すべきです。

パッケージがロードされた時、 整理器が、パッケージなしよりたくさんの規則を検証するよう強制されるので、 ユーザーはより遅い応答に気がつくかもしれません。 だから、これらを利用した後、規則を取り除きたいかもしれません。 (あなたが定義したかもしれないものすべてを含み)規則すべてを消すには、 `kill (rules)`してください; もしくは、もっと選択的にそれらのうちのいくつかだけ消すかもしれません; もしくは、特定の規則に`remrule`を使ってください。

もし自分の規則を定義した後、このパッケージをロードするなら、 同じ名前を持つあなたの規則をつぶすでしょう。 このパッケージの規則は以下の通りです: `*rule1`, ..., `*rule8`, `+rule1`, ..., `+rule18`, そして、それを参照するには、 `"+"`に関する最初の規則を限定して取り除くための`remrule ("+", "+rule1")`とか、 二番目の乗法規則の定義を表示するための`disprule ("*rule2")`とか、 規則名を引用符で囲まなければいけません。

Simplification functions ·Rules and patterns ·Share packages ·Package ineq ·

Next: Package scifac, Previous: Package ineq, Up: simplification [Contents][Index]

### 75.6 Package rducon

Expressions ·Share packages ·Package rducon ·

関数: reduce_consts (expr)

  exprの定部分式を構成された定アトムで置き換え、 これら構成された定数すべての定義を等式のリスト`const_eqns`に保存し、 修正されたexprを返します。 exprのそれらのパーツは、関数`constantp`が施された時`true`を返す 定数です。 それゆえ、 `reduce_consts`を呼び出す前に、

      declare ([objects to be given the constant property], constant)$

  をして、自分の式に現れる定数量のデータベースを設定すべきです。

  もしこれらの数式計算の後、Fortran出力を生成する予定があるなら、 最初のコードセクションの1つはすべての定数の計算であるべきです。 このコードセグメントを生成するには、

      map ('fortran, const_eqns)$

  を実行してください。

  `reduce_consts`に影響する`const_eqns` を除いた変数は以下の通りです: `const_prefix` (デフォルト値: `xx`) 定部分式を表すために`reduce_consts`が生成するシンボルすべてに接頭として付けるのに使われる文字列です。

  `const_counter` (デフォルト値: 1)は `reduce_consts`が見つける定部分式それぞれを表すためのユニークなシンボルを生成するのに使われる整数添字です。

  `load ("rducon")`はこの関数をロードします。 `demo (rducon)`はこの関数のデモを見せます。

  Package rducon ·Expressions ·

Next: Package sqdnst, Previous: Package rducon, Up: simplification [Contents][Index]

### 75.7 Package scifac

Expressions ·Share packages ·Package scifac ·

関数: gcfac (expr)

  `gcfac`は 科学者が式をより簡単にしようとする時に適用するのと同じ発見的方法の適用を試みる 因数分解関数です。 `gcfac`は単項式タイプの因数分解に限られます。 和に関しては、`gcfac`は以下を行います:

  1. 整数上で素因数分解します。
  2. 項の複雑さに関わらず、生じる項の最大の冪を係数として因数分解します。
  3. 項の隣同士の対を因数分解する時に、(1)と(2)を使います。
  4. 式がもはや変化しなくなるまで、 これらのテクニックを繰り返し、再帰的に適用します。

  対のすべての可能な再配列の中から最も簡潔な対因数分解された結果を産むものを見つけることの 組み合わせ的に困難な性質のため、 項目(3)は必ずしも、対での因数分解の最善の仕事をしません。

  `load ("scifac")`はこの関数をロードします。 `demo (scifac)`はこの関数のデモを見せます。

  Package scifac ·Expressions ·

Previous: Package scifac, Up: simplification [Contents][Index]

### 75.8 Package sqdnst

関数: sqrtdenest (expr)

  可能なら、簡単で、数値的で、二項無理数(binomial surds)の`sqrt`をdenestします。

  例えば、

      (%i1) load ("sqdnst")$
      (%i2) sqrt(sqrt(3)/2+1)/sqrt(11*sqrt(2)-12);
                                          sqrt(3)
                                     sqrt(------- + 1)
                                             2
      (%o2)                        ---------------------
                                   sqrt(11 sqrt(2) - 12)
      (%i3) sqrtdenest(%);
                                        sqrt(3)   1
                                        ------- + -
                                           2      2
      (%o3)                            -------------
                                          1/4    3/4
                                       3 2    - 2

  時々、 `(19601-13860 sqrt(2))^(7/4)`に対してのように、 `sqrtdenest`を複数回適用することが役立ちます。

  `load ("sqdnst")`はこの関数をロードします。

  Expressions ·Share packages ·Package sqdnst ·

Next: stats, Previous: simplification, Up: Top [Contents][Index]

## 76 solve_rec

Next: Functions and Variables for solve_rec, Previous: solve_rec, Up: solve_rec [Contents][Index]

### 76.1 Introduction to solve_rec

`solve_rec`は多項式係数を持つ線形漸化式を解くためのパッケージです。

デモが `demo(solve_rec);`で利用可能です。

例:

    (%i1) load("solve_rec")$

    (%i2) solve_rec((n+4)*s[n+2] + s[n+1] - (n+1)*s[n], s[n]);
                                        n
                     %k  (2 n + 3) (- 1)          %k
                       1                            2
    (%o2)       s  = -------------------- + ---------------
                 n     (n + 1) (n + 2)      (n + 1) (n + 2)

Linear recurrences ·Share packages ·Package solve_rec ·

Previous: Introduction to solve_rec, Up: solve_rec [Contents][Index]

### 76.2 Functions and Variables for solve_rec

関数: reduce_order (rec, sol, var)

  特殊解solが知られている時、 線形漸化式recの次数を減らします。

  例:

      (%i3) rec: x[n+2] = x[n+1] + x[n]/n;
                                            x
                                             n
      (%o3)               x      = x      + --
                           n + 2    n + 1   n

      (%i4) solve_rec(rec, x[n]);
      WARNING: found some hypergeometrical solutions!
      (%o4)                    x  = %k  n
                                n     1

      (%i5) reduce_order(rec, n, x[n]);
      (%t5)                    x  = n %z
                                n       n

                                 n - 1
                                 ====
                                 \
      (%t6)                %z  =  >     %u
                             n   /        %j
                                 ====
                                 %j = 0

      (%o6)             (- n - 2) %u     - %u
                                    n + 1     n

      (%i6) solve_rec((n+2)*%u[n+1] + %u[n], %u[n]);
                                           n
                                  %k  (- 1)
                                    1
      (%o6)                 %u  = ----------
                              n    (n + 1)!

      だから一般解は以下の通りです。

                   n - 1
                   ====        j
                   \      (- 1)
             %k  n  >    -------- + %k  n
               2   /     (j + 1)!     1
                   ====
                   j = 0

  Package solve_rec ·

オプション変数: simplify_products

  デフォルト値: `true`

  もし`simplify_products`が`true`なら、 `solve_rec`は答えの積をを整理しようとします。

  以下も参照してください: `solve_rec`.

  Package solve_rec ·

関数: simplify_sum (expr)

  exprに現れるすべての和を閉形式に整理しようとします。

  この関数を初めて使うには、 `load("simplify_sum")`で `simplify_sum`パッケージをロードしてください。

  例:

      (%i1) load("simplify_sum")$

      (%i2) sum(binomial(n+k,k)/2^k,k,1,n)+sum(binomial(2*n,2*k),k,1,n);
              n                          n
             ====                       ====
             ¥     binomial(n + k, k)   ¥
      (%o2)   >    ------------------ +  >    binomial(2 n, 2 k)
             /              k           /
             ====          2            ====
             k = 1                      k = 1

      (%i3) simplify_sum(%);

                               2 n - 1    n
      (%o3)                   2        + 2  - 2

  Package solve_rec ·Sums and products ·Simplification functions ·

関数: solve_rec (eqn, var, [init])

  変数varに関して多項式係数を持つ線形漸化式eqnの超幾何解について解きます。 オプション引数initは初期条件です。

  `solve_rec`は、 定数係数の線形漸化式を解くことができ、 多項式係数の斉次線形漸化式の超幾何解と多項式係数の有理解を見つけ、 Ricatti型漸化式を解くことができます。

  超幾何解を見つけるのに使われるアルゴリズムの実行時間は 主係数と最小次数(trailing)係数の次数に関して指数的であることに注意してください。

  この関数を使うには、 最初に `load("solve_rec");`で`solve_rec`パッケージをロードしてください。

  定係数の線形漸化式の例:

      (%i2) solve_rec(a[n]=a[n-1]+a[n-2]+n/2^n, a[n]);
                              n          n
                 (sqrt(5) - 1)  %k  (- 1)
                                  1           n
      (%o2) a  = ------------------------- - ----
             n               n                  n
                            2                5 2
                                                      n
                                         (sqrt(5) + 1)  %k
                                                          2    2
                                       + ------------------ - ----
                                                  n              n
                                                 2            5 2

  多項式係数の線形漸化式の例:

      (%i7) 2*x*(x+1)*y[x] - (x^2+3*x-2)*y[x+1] + (x-1)*y[x+2];
                               2
      (%o7) (x - 1) y      - (x  + 3 x - 2) y      + 2 x (x + 1) y
                     x + 2                   x + 1                x

      (%i8) solve_rec(%, y[x], y[1]=1, y[3]=3);
                                    x
                                 3 2    x!
      (%o9)                 y  = ---- - --
                             x    4     2

  Ricatti型漸化式の例:

      (%i2) x*y[x+1]*y[x] - y[x+1]/(x+2) + y[x]/(x-1) = 0;
                                  y         y
                                   x + 1     x
      (%o2)         x y  y      - ------ + ----- = 0
                       x  x + 1   x + 2    x - 1

      (%i3) solve_rec(%, y[x], y[3]=5)$

      (%i4) ratsimp(minfactorial(factcomb(%)));
                                         3
                                     30 x  - 30 x
      (%o4) y  = - -------------------------------------------------
             x        6      5       4       3       2
                   5 x  - 3 x  - 25 x  + 15 x  + 20 x  - 12 x - 1584

  以下も参照してください: `solve_rec_rat`, `simplify_products`, and `product_use_gamma`.

  Package solve_rec ·

関数: solve_rec_rat (eqn, var, [init])

  線形漸化式の有理解について解きます。 引数の記述についてはsolve_recを参照してください。

  この関数を使うには、 最初に `load("solve_rec");`で`solve_rec`パッケージをロードしてください。

  例:

      (%i1) (x+4)*a[x+3] + (x+3)*a[x+2] - x*a[x+1] + (x^2-1)*a[x];
      (%o1)  (x + 4) a      + (x + 3) a      - x a
                      x + 3            x + 2      x + 1
                                                         2
                                                     + (x  - 1) a
                                                                  x

      (%i2) solve_rec_rat(% = (x+2)/(x+1), a[x]);
                             1
      (%o2)      a  = ---------------
                  x   (x - 1) (x + 1)

  以下も参照してください: `solve_rec`.

  Package solve_rec ·

オプション変数: product_use_gamma

  デフォルト値: `true`

  積を整理する時、 もし`product_use_gamma`が`true`なら、 `solve_rec`は式の中にガンマ函数を導入します。

  以下も参照してください: `simplify_products`, `solve_rec`.

  Package solve_rec ·

関数: summand_to_rec (summand, k, n)
関数: summand_to_rec (summand, [k, lo, hi], n)

  和

           hi
          ====
          \
           >     summand
          /
          ====
        k = lo

  が満たす漸化式を返します。 ここで、被和(summand)はkとnに対して超幾何的です。 もしloとhiが省略されたら、 それらは`lo = -inf`、`hi = inf`と仮定されます。

  この関数を初めて使うには、 `load("simplify_sum")`で `simplify_sum`パッケージをロードしてください。

  例:

      (%i1) load("simplify_sum")$

      (%i2) summand: binom(n,k);
      (%o2)                           binomial(n, k)

      (%i3) summand_to_rec(summand,k,n);
      (%o3)                      2 sm  - sm      = 0
                                     n     n + 1

      (%i7) summand: binom(n, k)/(k+1);
                                      binomial(n, k)
      (%o7)                           --------------
                                          k + 1

      (%i8) summand_to_rec(summand, [k, 0, n], n);
      (%o8)               2 (n + 1) sm  - (n + 2) sm      = - 1
                                      n             n + 1

  Package solve_rec ·

Next: stirling, Previous: solve_rec, Up: Top [Contents][Index]

## 77 stats

Next: Functions and Variables for inference_result, Previous: Top, Up: Top [Contents][Index]

### 77.1 Introduction to stats

パッケージ`stats`は古典的な統計推定や仮説検定手続き一式を含みます。

これらの関数すべては、 母集団推定と意思決定のための必要な結果を含む `inference_result` Maximaオブジェクトを返します。

グローバル変数`stats_numer`は 結果が、浮動小数点やシンボル、有理フォーマットのいずれかで与えられるか制御します; デフォルト値は`true`で、結果は浮動小数点フォーマットで返されます。

パッケージ`descriptive`はデータ構造(リストと行列)を操作するためのいくつかのユーティリティを含みます; 例えば、部分サンプルを抽出するためのもの。 プレインテキストファイルからデータを読むためのパッケージ`numericalio`の使い方 に関するいくつかの例も含みます。 詳細は`descriptive`と`numericalio`を参照してください。

パッケージ`stats`は、パッケージ`descriptive`, `distrib`, `inference_result`をロードします。

コメント、バグ、提案は、作者’mario AT edu DOT xunta DOT es’にコンタクトしてください。

Statistical inference ·Share packages ·Package stats ·

Next: Functions and Variables for stats, Previous: Introduction to stats, Up: Top [Contents][Index]

### 77.2 Functions and Variables for inference_result

関数: inference_result (title, values, numbers)

  statsの関数が返す型の `inference_result`オブジェクトを構成します。 引数 titleは手続き名の文字列です; valuesは形式 `symbol = value`の要素を持つリストであり、 numbersは どの値がデフォルトで表示されるか示している 1から `length(values)`までの範囲の正の整数のリストです。

  例:

  これ 長方形に関する結果を示す簡単な例です。 このオブジェクトのタイトルは 文字列 `"Rectangle"`であり、 , it stores five results, named `'base`, `'height`, `'diagonal`, `'area`, `'perimeter` と名付けられた5つの結果を格納しますが、 一番目、二番目、五番目と四番目だけが表示されます。 `'diagonal`はこのオブジェクトに格納されますが、表示されません; その値にアクセスするには関数 `take_inference`を利用してください。

      (%i1) load("inference_result")$
      (%i2) b: 3$ h: 2$
      (%i3) inference_result("Rectangle",
                              ['base=b,
                               'height=h,
                               'diagonal=sqrt(b^2+h^2),
                               'area=b*h,
                               'perimeter=2*(b+h)],
                              [1,2,5,4] );
                              |   Rectangle
                              |
                              |    base = 3
                              |
      (%o3)                   |   height = 2
                              |
                              | perimeter = 10
                              |
                              |    area = 6
      (%i4) take_inference('diagonal,%);
      (%o4)                        sqrt(13)

  `take_inference`も参照してください。

  Package stats ·

関数: inferencep (obj)

  objが `inference_result`オブジェクトか否かに依存して、 `true`か `false`を返します。

  Package stats ·

関数: items_inference (obj)

  objに格納された項目名のリストを返します。 objは `inference_result`オブジェクトでなければいけません。

  例:

  `inference_result`オブジェクトは `'pi`と `'e`と名付けられた2つの値を格納しますが、 二番目だけが表示されます。 `items_inference`関数は、 表示されるされないに関係なく、項目すべての名前を返します。

      (%i1) load("inference_result")$
      (%i2) inference_result("Hi", ['pi=%pi,'e=%e],[2]);
                                  |   Hi
      (%o2)                       |
                                  | e = %e
      (%i3) items_inference(%);
      (%o3)                        [pi, e]

  Package stats ·

関数: take_inference (n, obj)
関数: take_inference (name, obj)
関数: take_inference (list, obj)

  もし nが正の整数なら、 objに格納された n番目の値を返します。 もし nameが項目名なら、そう名付けられた項目を返します。 もし一番目の引数が数やシンボルのリストなら、 関数 `take_inference`は対応する結果のリストを返します。

  例:

  `inference_result`オブジェクトが与えられたとして、 関数 `take_inference`は それに格納されたある情報を抽出するためにコールされます。

      (%i1) load("inference_result")$
      (%i2) b: 3$ h: 2$
      (%i3) sol: inference_result("Rectangle",
                                  ['base=b,
                                   'height=h,
                                   'diagonal=sqrt(b^2+h^2),
                                   'area=b*h,
                                   'perimeter=2*(b+h)],
                                  [1,2,5,4] );
                              |   Rectangle
                              |
                              |    base = 3
                              |
      (%o3)                   |   height = 2
                              |
                              | perimeter = 10
                              |
                              |    area = 6
      (%i4) take_inference('base,sol);
      (%o4)                           3
      (%i5) take_inference(5,sol);
      (%o5)                          10
      (%i6) take_inference([1,'diagonal],sol);
      (%o6)                     [3, sqrt(13)]
      (%i7) take_inference(items_inference(sol),sol);
      (%o7)                [3, 2, sqrt(13), 6, 10]

  `inference_result`と `take_inference`も参照してください。

  Package stats ·

Next: Functions and Variables for special distributions, Previous: Functions and Variables for inference_result, Up: Top [Contents][Index]

### 77.3 Functions and Variables for stats

オプション変数: stats_numer

  デフォルト値: `true`

  もし `stats_numer`が `true`なら、 推定統計的関数は浮動小数点数で結果を返します。 もし `false`なら、 結果は記号と有理フォーマットで与えられます。

  Package stats ·Numerical evaluation ·

関数: test_mean (x)
関数: test_mean (x, options ...)

  これは平均t検定です。 引数 xは1次元標本を含むリストか列行列です。 もしオプション `'asymptotic`が `true`なら、 中心極限定理に基づいた漸近検定も実行します。

  オプション:

  - `'mean`, デフォルト `0`, はチェックされる平均値です。
  - `'alternative`, デフォルト `'twosided`, は対立仮説です; 有効な値は次の通りです: `'twosided`, `'greater`, `'less`。
  - `'dev`, デフォルト `'unknown`, は既知の時の標準偏差値です; 有効な値は次の通りです: `'unknown`か正の式。
  - `'conflevel`, デフォルト `95/100`, は信頼区間の信頼度です; (0,1)内の値を取る式でなければいけません。
  - `'asymptotic`, デフォルト `false`, は正確確率t検定か、 中心極限定理に基づいた漸近検定かどちらを実行するかを示します; 有効な値は `true`と `false`です。

  関数 `test_mean`の出力は 以下の結果を示す`inference_result` Maximaオブジェクトです:

  1. `'mean_estimate`: 標本平均。
  2. `'conf_level`: ユーザーが選択した信頼度。
  3. `'conf_interval`: 母平均の信頼度。
  4. `'method`: 推定手続き。
  5. `'hypotheses`: 検定される帰無と対立仮説。
  6. `'statistic`: 帰無仮説を検定するために使われる標本統計の値。
  7. `'distribution`: パラメータと合わせて、標本統計分布。
  8. `'p_value`: 検定のp値

  例:

  未知の分散で正確確率 t検定を実行します。 片側対立 H_1: mean<50に対して 帰無仮説は H_0: mean=50です; 結果に従うと、p値が大きすぎ、 H_0を却下する証拠がありません。

      (%i1) load("stats")$
      (%i2) data: [78,64,35,45,45,75,43,74,42,42]$
      (%i3) test_mean(data,'conflevel=0.9,'alternative='less,'mean=50);
                |                 MEAN TEST
                |
                |            mean_estimate = 54.3
                |
                |              conf_level = 0.9
                |
                | conf_interval = [minf, 61.51314273502712]
                |
      (%o3)     |  method = Exact t-test. Unknown variance.
                |
                | hypotheses = H0: mean = 50 , H1: mean < 50
                |
                |       statistic = .8244705235071678
                |
                |       distribution = [student_t, 9]
                |
                |        p_value = .7845100411786889

  今回、Maximaは 中心極限定理に基づく漸近検定を実行します。 両側対立 H_1: not equal(mean, 50)に対して 帰無仮説は H_0: equal(mean, 50)です; 結果に従うと、 p値は非常に小さく、 対立 H_1を指示して、H_0は却下すべきです。 . Note that, as indicated by the `Method`成分が示すように、 この手続きは多くの標本に適用すべきです。

      (%i1) load("stats")$
      (%i2) test_mean([36,118,52,87,35,256,56,178,57,57,89,34,25,98,35,
                    98,41,45,198,54,79,63,35,45,44,75,42,75,45,45,
                    45,51,123,54,151],
                    'asymptotic=true,'mean=50);
                |                       MEAN TEST
                |
                |           mean_estimate = 74.88571428571429
                |
                |                   conf_level = 0.95
                |
                | conf_interval = [57.72848600856194, 92.04294256286663]
                |
      (%o2)     |    method = Large sample z-test. Unknown variance.
                |
                |       hypotheses = H0: mean = 50 , H1: mean # 50
                |
                |             statistic = 2.842831192874313
                |
                |             distribution = [normal, 0, 1]
                |
                |             p_value = .004471474652002261

  Package stats ·

関数: test_means_difference (x1, x2)
関数: test_means_difference (x1, x2, options ...)

  これは2つの標本の平均の差 t検定です。 引数 x1と x2は2つの独立標本を含むリストか列行列です。 異なる未知の分散の場合 (以下のオプション `'dev1`, `'dev2`, `'varequal`を参照してください)、 自由度の次数はWelch近似を使って計算されます。 もしオプション `'asymptotic`が `true`に設定されているなら 中心極限定理に基づく漸近検定も実行します。

  オプション:

  - `'alternative`, デフォルト `'twosided`, は対立仮説です; 有効な値は次の通りです: `'twosided`, `'greater`, `'less`。
  - `'dev1`, デフォルト `'unknown`, 既知の時、これはx1標本の標準偏差値です; 有効な値は次の通りです: `'unknown`もしくは正の式。
  - `'dev2`, デフォルト `'unknown`, 既知の時、これはx2標本の標準偏差値です; 有効な値は次の通りです: `'unknown`もしくは正の式。
  - `'varequal`, デフォルト `false`, 分散を等しいと考えるか等しくないと考えるか; このオプションは`'dev1`と `'dev2`の両方もしくはいずれかが `'unknown`の時だけ 有効です。
  - `'conflevel`, デフォルト `95/100`, 信頼区間の信頼度; (0,1)内の値を取る式でなければいけません。
  - `'asymptotic`, デフォルト `false`, 正確確率 t検定か 中心極限定理に基づく漸近検定どちらを実行するかを示します; 有効な値は `true`と `false`です。

  関数 `test_means_difference`の出力は 以下の結果を示す`inference_result` Maximaオブジェクトです:

  1. `'diff_estimate`: 平均差推定。
  2. `'conf_level`: ユーザーが選択した信頼度。
  3. `'conf_interval`: 平均差の信頼区間。
  4. `'method`: 推定手続き。
  5. `'hypotheses`: 検定される帰無、対立仮説。
  6. `'statistic`: 帰無仮説を検定するのに使われる標本統計値
  7. `'distribution`: パラメータを伴う標本統計分布。
  8. `'p_value`: 検定のp値。

  例:

  母平均 m_1と m_2で対立 H_1: m_1>m_2に対して 2つの小さな標本 x yで平均が等しいか検定します; 分散は未知で異なると仮定されます。

      (%i1) load("stats")$
      (%i2) x: [20.4,62.5,61.3,44.2,11.1,23.7]$
      (%i3) y: [1.2,6.9,38.7,20.4,17.2]$
      (%i4) test_means_difference(x,y,'alternative='greater);
                  |              DIFFERENCE OF MEANS TEST
                  |
                  |         diff_estimate = 20.31999999999999
                  |
                  |                 conf_level = 0.95
                  |
                  |    conf_interval = [- .04597417812882298, inf]
                  |
      (%o4)       |        method = Exact t-test. Welch approx.
                  |
                  | hypotheses = H0: mean1 = mean2 , H1: mean1 > mean2
                  |
                  |           statistic = 1.838004300728477
                  |
                  |    distribution = [student_t, 8.62758740184604]
                  |
                  |            p_value = .05032746527991905

  前と同じ検定、 しかし今回は分散が等しいと仮定されます。

      (%i1) load("stats")$
      (%i2) x: [20.4,62.5,61.3,44.2,11.1,23.7]$
      (%i3) y: matrix([1.2],[6.9],[38.7],[20.4],[17.2])$
      (%i4) test_means_difference(x,y,'alternative='greater,
                                                       'varequal=true);
                  |              DIFFERENCE OF MEANS TEST
                  |
                  |         diff_estimate = 20.31999999999999
                  |
                  |                 conf_level = 0.95
                  |
                  |     conf_interval = [- .7722627696897568, inf]
                  |
      (%o4)       |   method = Exact t-test. Unknown equal variances
                  |
                  | hypotheses = H0: mean1 = mean2 , H1: mean1 > mean2
                  |
                  |           statistic = 1.765996124515009
                  |
                  |           distribution = [student_t, 9]
                  |
                  |            p_value = .05560320992529344

  Package stats ·

関数: test_variance (x)
関数: test_variance (x, options, ...)

  これは分散 chi^2検定です。 引数 xは 正規母集団から取られた1次元標本を含む リストか列行列です。

  オプション:

  - `'mean`, デフォルト `'unknown`, は、既知の時、母平均です。
  - `'alternative`, デフォルト `'twosided`, 対立仮説です; 有効な値は次の通りです: `'twosided`, `'greater`, `'less`.
  - `'variance`, デフォルト `1`, これはチェックされる分散値(正)です。
  - `'conflevel`, デフォルト `95/100`, 信頼区間の信頼度; (0,1)内の値を取る式でなければいけません。

  関数 `test_variance`の出力は 以下の結果を示す`inference_result` Maximaオブジェクトです:

  1. `'var_estimate`: 標本分散。
  2. `'conf_level`: ユーザーが選択した信頼度。
  3. `'conf_interval`: 母分散の信頼区間。
  4. `'method`: 推定手続き。
  5. `'hypotheses`: 検定される帰無、対立仮説。
  6. `'statistic`: 帰無仮説を検定するのに使う標本統計値。
  7. `'distribution`: パラメータを伴う標本統計分布。
  8. `'p_value`: 検定の p値。

  例:

  平均が未知の母集団の分散が200以上か検定します。

      (%i1) load("stats")$
      (%i2) x: [203,229,215,220,223,233,208,228,209]$
      (%i3) test_variance(x,'alternative='greater,'variance=200);
                   |                  VARIANCE TEST
                   |
                   |              var_estimate = 110.75
                   |
                   |                conf_level = 0.95
                   |
                   |     conf_interval = [57.13433376937479, inf]
                   |
      (%o3)        | method = Variance Chi-square test. Unknown mean.
                   |
                   |    hypotheses = H0: var = 200 , H1: var > 200
                   |
                   |                 statistic = 4.43
                   |
                   |             distribution = [chi2, 8]
                   |
                   |           p_value = .8163948512777689

  Package stats ·

関数: test_variance_ratio (x1, x2)
関数: test_variance_ratio (x1, x2, options ...)

  これは2つの正規母集団の分散比 F検定です。 引数 x1と x2は 2つの独立標本を含むリストか列行列です。

  オプション:

  - `'alternative`, デフォルト `'twosided`, は対立仮説です; 有効な値は次の通りです: `'twosided`, `'greater`, `'less`.
  - `'mean1`, デフォルト `'unknown`, 既知の時、これはx1が取られた母集団の平均です。
  - `'mean2`, デフォルト `'unknown`, 既知の時、これはx2が取られた母集団の平均です。
  - `'conflevel`, デフォルト `95/100`, 比の信頼区間の信頼度; (0,1)内の値を取る式でなければいけません。

  関数 `test_variance_ratio`の出力は 以下の結果を示す`inference_result` Maximaオブジェクトです:

  1. `'ratio_estimate`: 標本分散比。
  2. `'conf_level`: ユーザーが選択した信頼度。
  3. `'conf_interval`: 分散比の信頼区間。
  4. `'method`: 推定手続き。
  5. `'hypotheses`: 検定される帰無、対立仮説。
  6. `'statistic`: 帰無仮説を検定するのに使われる標本統計値。
  7. `'distribution`: パラメータを伴う標本統計分布。
  8. `'p_value`: 検定のp値。

  例:

  前者が後者より大きいという対立仮説に対して、 2つの正規母集団の分散の等しさが

      (%i1) load("stats")$
      (%i2) x: [20.4,62.5,61.3,44.2,11.1,23.7]$
      (%i3) y: [1.2,6.9,38.7,20.4,17.2]$
      (%i4) test_variance_ratio(x,y,'alternative='greater);
                    |              VARIANCE RATIO TEST
                    |
                    |       ratio_estimate = 2.316933391522034
                    |
                    |               conf_level = 0.95
                    |
                    |    conf_interval = [.3703504689507268, inf]
                    |
      (%o4)         | method = Variance ratio F-test. Unknown means.
                    |
                    | hypotheses = H0: var1 = var2 , H1: var1 > var2
                    |
                    |         statistic = 2.316933391522034
                    |
                    |            distribution = [f, 5, 4]
                    |
                    |          p_value = .2179269692254457

  Package stats ·

関数: test_proportion (x, n)
関数: test_proportion (x, n, options ...)

  出現率推定。 引数 xは 未知の確率でのBernoulli実験のn回試行での成功回数です。

  オプション:

  - `'proportion`, デフォルト `1/2`, はチェックされる出現率の値です。
  - `'alternative`, デフォルト `'twosided`, は対立仮説です; 有効な値は次の通りです: `'twosided`, `'greater`, `'less`.
  - `'conflevel`, デフォルト `95/100`, 比の信頼区間の信頼度; (0,1)内の値を取る式でなければいけません。
  - `'asymptotic`, デフォルト `false`, 二項分布に基づく正確確率 t検定か 中心極限定理に基づく漸近検定どちらを実行するかを示します; 有効な値は `true`と `false`です。
  - `'correct`, デフォルト `true`, Yates補正が適用されるかどうかを示します。

  The output of function 関数 `test_proportion`の出力は 以下の結果を示す `inference_result` Maximaオブジェクトです:

  1. `'sample_proportion`: 標本出現率。
  2. `'conf_level`: ユーザーが選択した信頼度。
  3. `'conf_interval`: 出現率のWilson信頼区間。
  4. `'method`: 推定手続き。
  5. `'hypotheses`: 検定される帰無、対立仮説。
  6. `'statistic`: 帰無仮説を検定するのに使われる標本統計値。
  7. `'distribution`: パラメータを伴う標本統計分布。
  8. `'p_value`: 検定のp値。

  例:

  正確確率検定を実行します。 片側対立 H_1: p<1/2に対して、 帰無仮説は H_0: p=1/2です。

      (%i1) load("stats")$
      (%i2) test_proportion(45, 103, alternative = less);
               |            PROPORTION TEST
               |
               | sample_proportion = .4368932038834951
               |
               |           conf_level = 0.95
               |
               | conf_interval = [0, 0.522714149150231]
               |
      (%o2)    |     method = Exact binomial test.
               |
               | hypotheses = H0: p = 0.5 , H1: p < 0.5
               |
               |             statistic = 45
               |
               |  distribution = [binomial, 103, 0.5]
               |
               |      p_value = .1184509388901454

  両側漸近検定。信頼度は99/100です。

      (%i1) load("stats")$
      (%i2) fpprintprec:7$
      (%i3) test_proportion(45, 103,
                        conflevel = 99/100, asymptotic=true);
            |                 PROPORTION TEST
            |
            |           sample_proportion = .43689
            |
            |                conf_level = 0.99
            |
            |        conf_interval = [.31422, .56749]
            |
      (%o3) | method = Asympthotic test with Yates correction.
            |
            |     hypotheses = H0: p = 0.5 , H1: p # 0.5
            |
            |               statistic = .43689
            |
            |      distribution = [normal, 0.5, .048872]
            |
            |                p_value = .19662

  Package stats ·

関数: test_proportions_difference (x1, n1, x2, n2)
関数: test_proportions_difference (x1, n1, x2, n2, options ...)

  2つの出現率の差の推定。 引数 x1は 一番目の母集団でのBernoulli実験の n1回の試行での成功回数であり、 x2と n2は 二番目の母集団での対応する値です。 標本は独立で、検定は漸近です。

  オプション:

  - `'alternative`, デフォルト `'twosided`, は対立仮説です; 有効な値は次の通りです: `'twosided` (`p1 # p2`), `'greater` (`p1 > p2`), `'less` (`p1 < p2`).
  - `'conflevel`, デフォルト `95/100`, 比の信頼区間の信頼度; (0,1)内の値を取る式でなければいけません。
  - `'correct`, デフォルト `true`, はYates補正が適用されるかどうかを示します。

  関数 `test_proportions_difference`の出力は 以下の結果を示す `inference_result` Maximaオブジェクトです:

  1. `'proportions`: 2つの標本出現率のリスト。
  2. `'conf_level`: ユーザーが選択した信頼度。
  3. `'conf_interval`: 出現率の差 `p1 - p2`の信頼区間。
  4. `'method`: 推定手続きと 標本サイズのいずれかが10より小さい場合の警告メッセージ
  5. `'hypotheses`: 検定される帰無、対立仮説。
  6. `'statistic`: 帰無仮説を検定するのに使われる標本統計値。
  7. `'distribution`: パラメータを伴う標本統計分布。
  8. `'p_value`: 検定のp値。

  例:

  機械が250個のうち、10個の欠陥製品を製造しました。 その機械は、ある保守作業のあと、 150個のうち、4個の欠陥製品を製造しました。 機械が改善したか知るために、 対立 `H0:p1>p2`に対して 帰無仮説 `H0:p1=p2`を検定します。 ここで、 `p1`と `p2`は 保守の前と後で製造された製品が欠陥である確率です。 p値に従うと、対立を受け入れる十分な証拠はありません。

      (%i1) load("stats")$
      (%i2) fpprintprec:7$
      (%i3) test_proportions_difference(10, 250, 4, 150,
                                      alternative = greater);
            |       DIFFERENCE OF PROPORTIONS TEST
            |
            |       proportions = [0.04, .02666667]
            |
            |              conf_level = 0.95
            |
            |      conf_interval = [- .02172761, 1]
            |
      (%o3) | method = Asymptotic test. Yates correction.
            |
            |   hypotheses = H0: p1 = p2 , H1: p1 > p2
            |
            |            statistic = .01333333
            |
            |    distribution = [normal, 0, .01898069]
            |
            |             p_value = .2411936

  データが未知の時の漸近正規分布の正確確率標準偏差。

      (%i1) load("stats")$
      (%i2) stats_numer: false$
      (%i3) sol: test_proportions_difference(x1,n1,x2,n2)$
      (%i4) last(take_inference('distribution,sol));
                     1    1                  x2 + x1
                    (-- + --) (x2 + x1) (1 - -------)
                     n2   n1                 n2 + n1
      (%o4)    sqrt(---------------------------------)
                                 n2 + n1

  Package stats ·

関数: test_sign (x)
関数: test_sign (x, options ...)

  これは連続母集団のメジアンに関するノンパラメトリック符号検定です。 引数 xは1次元標本を含むリストか列行列です。

  オプション:

  - `'alternative`, デフォルト `'twosided`, は対立仮説です; 有効な値は次の通りです: `'twosided`, `'greater`, `'less`.
  - `'median`, デフォルト `0`, はチェックされるメジアン値です。

  関数 `test_sign`の出力は 以下の結果を示す `inference_result` Maximaオブジェクトです:

  1. `'med_estimate`: 標本メジアン。
  2. `'method`: 推定手続き。
  3. `'hypotheses`: 検定される帰無、対立仮説。
  4. `'statistic`: 帰無仮説を検定するのに使われる標本統計値。
  5. `'distribution`: パラメータを伴う標本統計分布。
  6. `'p_value`: 検定のp値。

  例:

  対立 H_1: median > 6に対して、 標本が採られた母集団がメジアン6を持つかどうかチェックします。

      (%i1) load("stats")$
      (%i2) x: [2,0.1,7,1.8,4,2.3,5.6,7.4,5.1,6.1,6]$
      (%i3) test_sign(x,'median=6,'alternative='greater);
                     |                  SIGN TEST
                     |
                     |              med_estimate = 5.1
                     |
                     |      method = Non parametric sign test.
                     |
      (%o3)          | hypotheses = H0: median = 6 , H1: median > 6
                     |
                     |                statistic = 7
                     |
                     |      distribution = [binomial, 10, 0.5]
                     |
                     |         p_value = .05468749999999989

  Package stats ·

関数: test_signed_rank (x)
関数: test_signed_rank (x, options ...)

  これは 連続母集団のメジアンに関する推定を行う Wilcoxonの符号順位検定です。 引数 xは 1次元標本を含む リストか列行列です。 もし標本サイズが20より大きいか、複数の零すなわち引き分けがあれば、 正規近似を実行します

  `pdf_rank_test`と `cdf_rank_test`も参照してください。

  オプション:

  - `'median`, デフォルト `0`, はチェックされるメジアン値です。
  - `'alternative`, デフォルト `'twosided`, は対立仮説です; 有効な値は次の通りです: `'twosided`, `'greater` and `'less`.

  関数 `test_signed_rank`の出力は 以下の結果を持つ `inference_result` Maximaオブジェクトです:

  1. `'med_estimate`: 標本メジアン。
  2. `'method`: 推定手続き。
  3. `'hypotheses`: 検定される帰無、対立仮説。
  4. `'statistic`: 帰無仮説を検定するのに使われる標本統計値。
  5. `'distribution`: パラメータを伴う標本統計分布。
  6. `'p_value`: 検定のp値。

  例:

  対立 H_1: median > 15に対して 帰無仮説 H_0: median = 15をチェックします。 引き分けがないので、これは正確確率検定です。

      (%i1) load("stats")$
      (%i2) x: [17.1,15.9,13.7,13.4,15.5,17.6]$
      (%i3) test_signed_rank(x,median=15,alternative=greater);
                       |             SIGNED RANK TEST
                       |
                       |           med_estimate = 15.7
                       |
                       |           method = Exact test
                       |
      (%o3)            | hypotheses = H0: med = 15 , H1: med > 15
                       |
                       |              statistic = 14
                       |
                       |     distribution = [signed_rank, 6]
                       |
                       |            p_value = 0.28125

  Checks the null hypothesis H_0: equal(median, 2.5) against the alternative H_1: not equal(median, 2.5). This is an approximated test, since there are ties.

      (%i1) load("stats")$
      (%i2) y:[1.9,2.3,2.6,1.9,1.6,3.3,4.2,4,2.4,2.9,1.5,3,2.9,4.2,3.1]$
      (%i3) test_signed_rank(y,median=2.5);
                   |                 SIGNED RANK TEST
                   |
                   |                med_estimate = 2.9
                   |
                   |          method = Asymptotic test. Ties
                   |
      (%o3)        |    hypotheses = H0: med = 2.5 , H1: med # 2.5
                   |
                   |                 statistic = 76.5
                   |
                   | distribution = [normal, 60.5, 17.58195097251724]
                   |
                   |           p_value = .3628097734643669

  Package stats ·

関数: test_rank_sum (x1, x2)
関数: test_rank_sum (x1, x2, option)

  これは 2つの連続母集団のメジアンを比較するWilcoxon-Mann-Whitney検定です。 最初の2つの引数 x1と x2は 2つの独立標本のデータを持つリストか列行列です。 もし標本サイズのいずれかが10より大きいか、 引き分けがあるなら、 正規近似を実行します。

  オプション:

  - `'alternative`, デフォルト `'twosided`, は対立仮説です; 有効な値は次の通りです: `'twosided`, `'greater` and `'less`.

  The output of function 関数 `test_rank_sum`の出力は 以下の結果を持つ `inference_result` Maximaオブジェクトです:

  1. `'method`: 推定手続き。
  2. `'hypotheses`: 検定される帰無、対立仮説。
  3. `'statistic`: 帰無仮説を検定するのに使われる標本統計値。
  4. `'distribution`: パラメータを伴う標本統計分布。
  5. `'p_value`: 検定のp値。

  例:

  母集団が似たメジアンを持つかチェックします。 標本サイズは小さく、正確確率検定がされます。

      (%i1) load("stats")$
      (%i2) x:[12,15,17,38,42,10,23,35,28]$
      (%i3) y:[21,18,25,14,52,65,40,43]$
      (%i4) test_rank_sum(x,y);
                    |                 RANK SUM TEST
                    |
                    |              method = Exact test
                    |
                    | hypotheses = H0: med1 = med2 , H1: med1 # med2
      (%o4)         |
                    |                 statistic = 22
                    |
                    |        distribution = [rank_sum, 9, 8]
                    |
                    |          p_value = .1995886466474702

  次は、 より大きな標本で引き分けを含み、 手続きは正規近似をします。 対立仮説は H_1: median1 < median2です。

      (%i1) load("stats")$
      (%i2) x: [39,42,35,13,10,23,15,20,17,27]$
      (%i3) y: [20,52,66,19,41,32,44,25,14,39,43,35,19,56,27,15]$
      (%i4) test_rank_sum(x,y,'alternative='less);
                   |                  RANK SUM TEST
                   |
                   |          method = Asymptotic test. Ties
                   |
                   |  hypotheses = H0: med1 = med2 , H1: med1 < med2
      (%o4)        |
                   |                 statistic = 48.5
                   |
                   | distribution = [normal, 79.5, 18.95419580097078]
                   |
                   |           p_value = .05096985666598441

  Package stats ·

関数: test_normality (x)

  正規性のShapiro-Wilk検定。 引数 xは 数のリストであり、 標本サイズは2より大きく、5000以下でなければいけません。 そうでないなら、関数 `test_normality`はエラーメッセージをシグナルします。

  参考文献:

  [1] Algorithm AS R94, Applied Statistics (1995), vol.44, no.4, 547-551

  関数 `test_normality`の出力は 以下の結果を持つ `inference_result` Maximaオブジェクトです:

  1. `'statistic`: W統計値
  2. `'p_value`: 正規仮定のp値。

  例:

  サイズ9の標本に基づいて母集団の正規性をチェックします。

      (%i1) load("stats")$
      (%i2) x:[12,15,17,38,42,10,23,35,28]$
      (%i3) test_normality(x);
                             |      SHAPIRO - WILK TEST
                             |
      (%o3)                  | statistic = .9251055695162436
                             |
                             |  p_value = .4361763918860381

  Package stats ·

関数: simple_linear_regression (x)
関数: simple_linear_regression (x option)

  単回帰 y_i=a+b x_i+e_i。 ここで、 e_iは N(0,sigma)の独立確率変数です 引数 xは2つの列行列か対のリストでなければいけません。

  オプション:

  - `'conflevel`, デフォルト `95/100`, 比の信頼区間の信頼度; (0,1)内の値を取る式でなければいけません。
  - `'regressor`, デフォルト `'x`, 独立変数名。

  関数 `simple_linear_regression`の出力は 以下の結果を持つ `inference_result` Maximaオブジェクトです:

  1. `'model`: 適合方程式。 新しい予測を行うのに役立ちます。 以下の例を参照してください。
  2. `'means`: 二変量平均。
  3. `'variances`: 両方の変数の分散。
  4. `'correlation`: 相関係数。
  5. `'adc`: 調整済み決定係数。
  6. `'a_estimation`: パラメータ aの推定。
  7. `'a_conf_int`: パラメータ aの信頼区間。
  8. `'b_estimation`: パラメータ bの推定。
  9. `'b_conf_int`:　パラメータ bの信頼区間。
  10. `'hypotheses`: パラメータ bについて検定される帰無、対立仮説。
  11. `'statistic`: 帰無仮説を検定するのに使われる標本統計値。
  12. `'distribution`: パラメータを伴う標本統計分布。
  13. `'p_value`: bについての検定のp値。
  14. `'v_estimation`: 不偏分散推定もしくは残差分散。
  15. `'v_conf_int`: 分散信頼区間。
  16. `'cond_mean_conf_int`: 条件付き平均の信頼区間。 以下の例を参照してください。
  17. `'new_pred_conf_int`: 新しい予測の信頼区間。 以下の例を参照してください。
  18. `'residuals`: 予測に関して並べ替えられた対(予測, 残差)のリスト これは適合度分析に役に立ちます。 以下の例を参照してください。

  Only items 上の項目 1, 4, 14, 9, 10, 11, 12, 13だけが この順で、デフォルトで表示されます。 残りは ユーザーが関数 `items_inference`と `take_inference`を利用するまで 隠されたままです。

  例:

  線形モデルの二変量標本へのフィッティング。 入力 `%i4`は 回帰線と一緒に標本をプロットします; 入力 `%i5`は `x=113`が与えられたとして `y`を計算します; `x=113`の時 平均と、新しい予測の信頼区間も計算されます。

      (%i1) load("stats")$
      (%i2) s:[[125,140.7], [130,155.1], [135,160.3], [140,167.2],
                                                      [145,169.8]]$
      (%i3) z:simple_linear_regression(s,conflevel=0.99);
                 |               SIMPLE LINEAR REGRESSION
                 |
                 |   model = 1.405999999999985 x - 31.18999999999804
                 |
                 |           correlation = .9611685255255155
                 |
                 |           v_estimation = 13.57966666666665
                 |
      (%o3)      | b_conf_int = [.04469633662525263, 2.767303663374718]
                 |
                 |          hypotheses = H0: b = 0 ,H1: b # 0
                 |
                 |            statistic = 6.032686683658114
                 |
                 |            distribution = [student_t, 3]
                 |
                 |             p_value = 0.0038059549413203
      (%i4) plot2d([[discrete, s], take_inference(model,z)],
              [x,120,150],
              [gnuplot_curve_styles, ["with points","with lines"]] )$
      (%i5) take_inference(model,z), x=133;
      (%o5)                         155.808
      (%i6) take_inference(means,z);
      (%o6)                     [135.0, 158.62]
      (%i7) take_inference(new_pred_conf_int,z), x=133;
      (%o7)              [132.0728595995113, 179.5431404004887]

  Package stats ·Statistical estimation ·

Previous: Functions and Variables for stats, Up: Top [Contents][Index]

### 77.4 Functions and Variables for special distributions

関数: pdf_signed_rank (x, n)

  符号順位統計の正確確率分布の確率密度関数。 引数 xは実数であり、 nは正の整数です。

  `test_signed_rank`も参照してください。

  Package stats ·

関数: cdf_signed_rank (x, n)

  符号順位統計の正確確率分布の累積密度関数。 引数 xは実数であり、 nは正の整数です。

  `test_signed_rank`も参照してください。

  Package stats ·

関数: pdf_rank_sum (x, n, m)

  順位和統計の正確確率分布の確率密度関数。 引数 xは実数であり、 nと mはともに正の整数です。

  `test_rank_sum`も参照してください。

  Package stats ·

関数: cdf_rank_sum (x, n, m)

  順位和統計の正確確率分布の累積密度関数。 引数 xは実数であり、 nと mはともに正の整数です。

  `test_rank_sum`も参照してください。

  Package stats ·

Next: stringproc, Previous: stats, Up: Top [Contents][Index]

## 78 stirling

Previous: stirling, Up: stirling [Contents][Index]

### 78.1 Functions and Variables for stirling

関数: stirling (z,n)
関数: stirling (z,n,pred)

  `gamma(x)`を O(1/x^(2n-1))Stirling公式で置き換えます。 nが非負の整数の時、エラーを知らせます。 オプションの三番目の引数`pred`があると、 `pred`がtrueの時だけ Stirling公式は適用されます。

  参照文献: Abramowitz & Stegun, " Handbook of mathematical functions", 6.1.40.

  例:

      (%i1) load ("stirling")$

      (%i2) stirling(gamma(%alpha+x)/gamma(x),1);
             1/2 - x             x + %alpha - 1/2
      (%o2) x        (x + %alpha)
                                         1           1
                                  --------------- - ---- - %alpha
                                  12 (x + %alpha)   12 x
                                %e
      (%i3) taylor(%,x,inf,1);
                          %alpha       2    %alpha
                %alpha   x       %alpha  - x       %alpha
      (%o3)/T/ x       + -------------------------------- + . . .
                                       2 x
      (%i4) map('factor,%);
                                             %alpha - 1
               %alpha   (%alpha - 1) %alpha x
      (%o4)   x       + -------------------------------
                                        2

  関数`stirling`は変数’gamma’と関数gammaの違いを知っています:

      (%i5) stirling(gamma + gamma(x),0);
                                          x - 1/2   - x
      (%o5)    gamma + sqrt(2) sqrt(%pi) x        %e
      (%i6) stirling(gamma(y) + gamma(x),0);
                               y - 1/2   - y
      (%o6) sqrt(2) sqrt(%pi) y        %e
                                                    x - 1/2   - x
                               + sqrt(2) sqrt(%pi) x        %e

  変数`k`を含む項だけに Stirling公式を適用するために オプションの三番目の引数を使います; 例えば、

      (%i7) makegamma(pochhammer(a,k)/pochhammer(b,k));
      (%o7) (gamma(b)*gamma(k+a))/(gamma(a)*gamma(k+b))
      (%i8) stirling(%,1, lambda([s], not(freeof(k,s))));
      (%o8) (%e^(b-a)*gamma(b)*(k+a)^(k+a-1/2)*(k+b)^(-k-b+1/2))/gamma(a)

  項`gamma(a)`と`gamma(b)`は、 `k`を含まないので、 Stirling公式はこれら２つの項に適用されませんでした。

  この関数を使うには、最初に`load("stirling")`を書いてください。

  Gamma and factorial functions ·Share packages ·Package stirling ·

Next: to_poly_solve, Previous: stirling, Up: Top [Contents][Index]

## 79 stringproc

Next: Functions and Variables for input and output, Previous: stringproc, Up: stringproc [Contents][Index]

### 79.1 Introduction to string processing

`stringproc.lisp`は、 enlarges Maximaの文字列を扱う機能を拡大し、 ファイル入出力に関するいくつかの役立つ関数を追加します。

質問とバグに関して、van.nek at arcor.deにメールしてください。

Maximaでは、 文字列は、"text"とタイプすることで簡単に構成することができます。 `stringp`は文字列かテストします。

    (%i1) m: "text";
    (%o1)                         text
    (%i2) stringp(m);
    (%o2)                         true

文字は長さ1の文字列として表されます。 これらはLisp文字ではありません。 テストは `charp`で行うことができます。 (関連として、`lcharp`と `cunlisp`を使ったLisp文字からMaxima文字への変換)

    (%i1) c: "e";
    (%o1)                           e
    (%i2) [charp(c),lcharp(c)];
    (%o2)                     [true, false]
    (%i3) supcase(c);
    (%o3)                           E
    (%i4) charp(%);
    (%o4)                         true

`stringproc.lisp`の中の、文字を返す関数すべては、Maxima文字を返します。 導入された文字が長さ1の文字列だという事実のおかげで、たくさんの文字列関数を文字にも使うことができます。 既に見たように、 `supcase`は１例です。

Maxima文字列の最初の文字は位置1にあることを知ることは重要です。 これは、Maximaリストの中の最初の要素も位置1にあるという事実によって設計されています。 例えば、`charat`や`charlist`の定義を見てください。

応用として、 文字列関数はしばしばファイルを扱う時に使われます。 `stringproc.lisp`の中に役立つストリーム関数、印字関数を見つけるでしょう。 以下の例はここで導入された関数のいくつかがいかに働くか示します。

例:

`openw`は、ファイルへの出力ストリームを返し、 `printf`は、このファイルへのフォーマットされた書き込みを可能にします。 詳細は`printf`を参照してください。

    (%i1) s: openw("E:/file.txt");
    (%o1)                    #<output stream E:/file.txt>
    (%i2) for n:0 thru 10 do printf( s, "~d ", fib(n) );
    (%o2)                                done
    (%i3) printf( s, "~%~d ~f ~a ~a ~f ~e ~a~%",
                  42,1.234,sqrt(2),%pi,1.0e-2,1.0e-2,1.0b-2 );
    (%o3)                                false
    (%i4) close(s);
    (%o4)                                true

ストリームを閉じた後、今度は入力方向で再び開くことができます。 `readline`は行全体を１つの文字列として返します。 現在、`stringproc`パッケージは 文字列を操作するたくさんの関数を提供しています。 `split`や`tokens`でトークン化できます。

    (%i5) s: openr("E:/file.txt");
    (%o5)                     #<input stream E:/file.txt>
    (%i6) readline(s);
    (%o6)                     0 1 1 2 3 5 8 13 21 34 55
    (%i7) line: readline(s);
    (%o7)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
    (%i8) list: tokens(line);
    (%o8)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
    (%i9) map( parse_string, list );
    (%o9)            [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
    (%i10) float(%);
    (%o10) [42.0, 1.234, 1.414213562373095, 3.141592653589793, 0.01,
                                                         0.01, 0.01]
    (%i11) readline(s);
    (%o11)                               false
    (%i12) close(s)$

ファイルの終わりに来ると、 `readline`は`false`を返します。

Strings ·Share packages ·Package stringproc ·

Next: Functions and Variables for characters, Previous: Introduction to string processing, Up: stringproc [Contents][Index]

### 79.2 Functions and Variables for input and output

例:

    (%i1) s: openw("E:/file.txt");
    (%o1)                     #<output stream E:/file.txt>
    (%i2) control:
    "~2tAn atom: ~20t~a~%~2tand a list: ~20t~{~r ~}~%~2t\
    and an integer: ~20t~d~%"$
    (%i3) printf( s,control, 'true,[1,2,3],42 )$
    (%o3)                                false
    (%i4) close(s);
    (%o4)                                true
    (%i5) s: openr("E:/file.txt");
    (%o5)                     #<input stream E:/file.txt>
    (%i6) while stringp( tmp:readline(s) ) do print(tmp)$
      An atom:          true
      and a list:       one two three
      and an integer:   42
    (%i7) close(s)$

関数: close (stream)

  streamを閉じて、 もしstreamが開いていたら `true`を返します。

  File input ·File output ·Package stringproc ·

関数: flength (stream)

  streamの中の要素の数を返します。

  File input ·File output ·Package stringproc ·

関数: fposition (stream)
関数: fposition (stream, pos)

  もしposが使われてないなら、 streamの中の現在位置を返します。 もしposが使われているなら、 `fposition`はstreamの中の位置を設定します。 posは正の数でなければいけません。 streamの最初の要素は位置1にあります。

  File input ·File output ·Package stringproc ·

関数: freshline ()
関数: freshline (stream)

  もし位置が行の最初でないなら (streamに)改行を書きます。 `newline`も参照してください。

  File output ·Package stringproc ·

関数: newline ()
関数: newline (stream)

  (streamに)改行を書きます。 `newline()`の使用の例に関しては、 `sprint`を参照してください。 `newline()`が期待通りに動かない いくつかの場合があることに注意してください。

  File output ·Package stringproc ·

関数: opena (file)

  fileへの出力ストリームを返します。 もし存在しているファイルを開いたら、 `opena`はファイルの終わりに要素を追加します。

  File output ·Package stringproc ·

関数: openr (file)

  fileへの入力ストリームを返します。 もしfileが存在しないなら、生成されます。

  File input ·Package stringproc ·

関数: openw (file)

  fileへの出力ストリームを返します。 もしfileが存在しないなら、生成されます。 もし存在しているファイルを開いたら、`openw`は fileを破壊的に変更します。

  File output ·Package stringproc ·

関数: printf (dest, string)
関数: printf (dest, string, expr_1, ..., expr_n)

  Common Lisp関数FORMATをMaximaで利用可能にします。 (gcl.infoから: 「フォーマットは 制御文字列の文字を出力し、波形記号がディレクティブを挿入することを守ることで、 フォーマットされた出力を生成します。 波形記号の後の文字は多分、前置パラメータと修飾語が先行し、 望まれるフォーマットの種類を指定します。 ほとんどのディレクティブは、出力を生成するために1つまたは複数の引数を使います。」)

  以下の記述と例は`printf`を使うアイデアを与えるかもしれません。 さらなる情報に関して、Lisp参考文献を参照してください。

         ~%       改行
         ~&       行のフレッシュ
         ~t       タブ
         ~$       通貨記号
         ~d       10進整数
         ~b       2進整数
         ~o       8進整数
         ~x       16進整数
         ~br      b進整数
         ~r       整数を一字一字
         ~p       複数形
         ~f       浮動小数点
         ~e       科学的記数法
         ~g       大きさに応じて~fまたは~e
         ~h       多倍長浮動小数点
         ~a       Maxima関数文字列を使う
         ~s       ~aと同様, しかし"ダブルコーテーション"で囲まれた出力
         ~~       ~
         ~<       行揃え, ~> 終端
         ~(       大文字小文字変換, ~) 終端
         ~[       選択, ~] 終端
         ~{       繰り返し, ~} 終端

  選択ディレクティブ`~[`は添字がゼロから始まることに注意してください。 ディレクティブ~*がサポートされていないことにも注意してください。

      (%i1) printf( false, "~a ~a ~4f ~a ~@r",
                    "String",sym,bound,sqrt(12),144), bound = 1.234;
      (%o1)                 String sym 1.23 2*sqrt(3) CXLIV
      (%i2) printf( false,"~{~a ~}",["one",2,"THREE"] );
      (%o2)                          one 2 THREE
      (%i3) printf(true,"~{~{~9,1f ~}~%~}",mat ),
                mat = args(matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]))$
            1.1       2.0       3.3
            4.0       5.0       6.0
            7.0       8.9       9.0
      (%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
      (%i5) printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
      (%o5)                    Two birds are singing.

  もしdestがストリームか`true`なら、 `printf`は`false`を返します。 そうでないなら、`printf`は出力を含む文字列を返します。

  File output ·Package stringproc ·

関数: readline (stream)

  streamの現在位置から行の終わりまでの文字を含む文字列か、 もしファイルの終わりが来たらfalseを返します。

  File input ·Package stringproc ·

関数: sprint (expr_1, …, expr_n)

  引数を順に評価し、一番左から始まる「一行」に表示します。 数は数の右隣に’-’と共に印字され、行の長さを無視します。 もし中間行ブレークを置きたいなら、 `newline()`―`stringproc.lisp` から自動ロードされます― が役に立つかもしれません。

  例:

      (%i1) for n:0 thru 19 do sprint( fib(n) )$
      0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
      (%i2) for n:0 thru 22 do (
               sprint(fib(n)), if mod(n,10)=9 then newline() )$
      0 1 1 2 3 5 8 13 21 34
      55 89 144 233 377 610 987 1597 2584 4181
      6765 10946 17711

  Package stringproc ·

Next: Functions and Variables for strings, Previous: Functions and Variables for input and output, Up: stringproc [Contents][Index]

### 79.3 Functions and Variables for characters

関数: alphacharp (char)

  もしcharがアルファベット文字なら`true`を返します。

  Predicate functions ·Package stringproc ·

関数: alphanumericp (char)

  もしcharがアルファベット文字か数字なら`true`を返します。

  Predicate functions ·Package stringproc ·

関数: ascii (int)

  ASCIIコードint( -1 < int < 256 )に対応する文字を返します。

      (%i1) for n from 0 thru 255 do (
         tmp: ascii(n), if alphacharp(tmp) then sprint(tmp),
            if n=96 then newline() )$
      A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
      a b c d e f g h i j k l m n o p q r s t u v w x y z

  Package stringproc ·

関数: cequal (char_1, char_2)

  もしchar_1とchar_2が同じなら`true`を返します。

  Predicate functions ·Package stringproc ·

関数: cequalignore (char_1, char_2)

  `cequal`と同様ですが、文字の大小を無視します。

  Predicate functions ·Package stringproc ·

関数: cgreaterp (char_1, char_2)

  もしchar_1のASCIIコードがchar_2のそれより大きいなら`true`を返します。

  Predicate functions ·Package stringproc ·

関数: cgreaterpignore (char_1, char_2)

  `cgreaterp`と同様ですが、文字の大小を無視します。

  Predicate functions ·Package stringproc ·

関数: charp (obj)

  もしobjがMaxima-文字なら`true`を返します。 例えばイントロダクションを参照してください。

  Predicate functions ·Package stringproc ·

関数: cint (char)

  charのASCIIコードを返します。

  Package stringproc ·

関数: clessp (char_1, char_2)

  もしchar_1のASCIIコードがchar_2のそれより小さいなら`true`を返します。

  Predicate functions ·Package stringproc ·

関数: clesspignore (char_1, char_2)

  `clessp`と同様ですが、文字の大小を無視します。

  Predicate functions ·Package stringproc ·

関数: constituent (char)

  もしcharがグラフィック文字であり、スペース文字でないなら、 `true`を返します。 グラフィック文字は見ることができる文字とスペース文字です。 (`constituent`は、Paul Graham, ANSI Common Lisp, 1996, page 67で定義されています。)

      (%i1) for n from 0 thru 255 do (
      tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
      ! " #  %  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B
      C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c
      d e f g h i j k l m n o p q r s t u v w x y z { | } ~

  Predicate functions ·Package stringproc ·

関数: cunlisp (lisp_char)

  Lisp文字をMaxima文字に変換します。 (必要としないでしょう。)

  Package stringproc ·

関数: digitcharp (char)

  もしcharが0から9までの数字なら、 `true`を返します。

  Predicate functions ·Package stringproc ·

関数: lcharp (obj)

  もし objがLisp文字なら、`true`を返します。 (必要としないでしょう。)

  Predicate functions ·Package stringproc ·

関数: lowercasep (char)

  もしcharが小文字なら、`true`を返します。

  Predicate functions ·Package stringproc ·

変数: newline

  改行文字。

  Global variables ·Package stringproc ·

変数: space

  スペース文字。

  Global variables ·Package stringproc ·

変数: tab

  タブ文字。

  Global variables ·Package stringproc ·

関数: uppercasep (char)

  もしcharが大文字なら、`true`を返します。

  Predicate functions ·Package stringproc ·

Previous: Functions and Variables for characters, Up: stringproc [Contents][Index]

### 79.4 Functions and Variables for strings

関数: stringp (obj)

  もしobjが文字列なら、`true`を返します。 例はイントロダクションを参照してください。

  Predicate functions ·Package stringproc ·

関数: charat (string, n)

  stringのn番目の文字を返します。 stringの一番目の文字はn = 1で返されます。

      (%i1) charat("Lisp",1);
      (%o1)                           L

  Package stringproc ·

関数: charlist (string)

  stringの文字すべてのリストを返します。

      (%i1) charlist("Lisp");
      (%o1)                     [L, i, s, p]
      (%i2) %[1];
      (%o2)                           L

  Package stringproc ·

関数: eval_string (str)

  文字列strをMaxima式としてパースし、評価します。 文字列strは終端子(ドル記号`$`またはセミコロン`;`) を持つかもしれませんし持たないかもしれません。

  もし複数あるなら、最初の式だけがパースされ、評価されます。

  もしstrが文字列でないならエラーが出力されます。

  例:

      (%i1) eval_string ("foo: 42; bar: foo^2 + baz");
      (%o1)                       42
      (%i2) eval_string ("(foo: 42, bar: foo^2 + baz)");
      (%o2)                   baz + 1764

  `parse_string`も参照してください。

  Package stringproc ·

関数: parse_string (str)

  文字列strをMaxima式としてパースします(評価しません)。 文字列strは終端子(ドル記号`$`またはセミコロン`;`) を持つかもしれませんし持たないかもしれません。

  もし複数あるなら、最初の式だけがパースされ、評価されます。

  もしstrが文字列でないならエラーが出力されます。

  例:

      (%i1) parse_string ("foo: 42; bar: foo^2 + baz");
      (%o1)                    foo : 42
      (%i2) parse_string ("(foo: 42, bar: foo^2 + baz)");
                                         2
      (%o2)          (foo : 42, bar : foo  + baz)

  `eval_string`も参照してください。

  Package stringproc ·

関数: scopy (string)

  stringのコピーを新しい文字列として返します。

  Package stringproc ·

関数: sdowncase (string)
関数: sdowncase (string, start)
関数: sdowncase (string, start, end)

  `supcase`と同様ですが、大文字が小文字に変換されます。

  Package stringproc ·

関数: sequal (string_1, string_2)

  もしstring_1とstring_2が同じ長さで、同じ文字を含むなら、 `true`を返します。

  Predicate functions ·Package stringproc ·

関数: sequalignore (string_1, string_2)

  `sequal`と同様ですが、文字の大小を無視します。

  Predicate functions ·Package stringproc ·

関数: sexplode (string)

  `sexplode`は関数`charlist`の別名です。

  Package stringproc ·

関数: simplode (list)
関数: simplode (list, delim)

  `simplode`は式のリストを取り、それらを結合して文字列にします。 もしデリミタdelimが指定されないなら、 `simplode`はデリミタを使いません。 delimは任意の文字列を取り得ます。

      (%i1) simplode(["xx[",3,"]:",expand((x+y)^3)]);
      (%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
      (%i2) simplode( sexplode("stars")," * " );
      (%o2)                   s * t * a * r * s
      (%i3) simplode( ["One","more","coffee."]," " );
      (%o3)                   One more coffee.

  Package stringproc ·

関数: sinsert (seq, string, pos)

  `substring (string, 1, pos - 1)`と 文字列seq、`substring (string, pos)` の結合となる文字列を返します。 stringの一番目の文字は位置1にあることに注意してください。

      (%i1) s: "A submarine."$
      (%i2) concat( substring(s,1,3),"yellow ",substring(s,3) );
      (%o2)                  A yellow submarine.
      (%i3) sinsert("hollow ",s,3);
      (%o3)                  A hollow submarine.

  Package stringproc ·

関数: sinvertcase (string)
関数: sinvertcase (string, start)
関数: sinvertcase (string, start, end)

  位置startからendまでのそれぞれの文字を逆順にすることを除いて stringを返します。 もしendが与えられないなら、 startから stringの終わりまでのすべての文字列が置き換えられます。

      (%i1) sinvertcase("sInvertCase");
      (%o1)                      SiNVERTcASE

  Package stringproc ·

関数: slength (string)

  stringの中の文字の数を返します。

  Package stringproc ·

関数: smake (num, char)

  num個の文字charを持つ新しい文字列を返します。

      (%i1) smake(3,"w");
      (%o1)                          www

  Package stringproc ·

関数: smismatch (string_1, string_2)
関数: smismatch (string_1, string_2, test)

  string_1とstring_2が異なるstring_1の最初の文字の位置、または `false`を返します。 マッチングのデフォルトのテスト関数は`sequal`です。 もし`smismatch`が文字の大小を無視なければいけないなら、 テストとして`sequalignore`を使ってください。

      (%i1) smismatch("seven","seventh");
      (%o1)                           6

  Package stringproc ·

関数: split (string)
関数: split (string, delim)
関数: split (string, delim, multiple)

  stringのすべてのトークンのリストを返します。 それぞれのトークンはパースされていない文字列です。 `split`はdelimをデリミタとして使います。 もしdelimが与えられないなら、 スペース文字がデフォルトのデリミタです。 multipleはデフォルトで`true`のブーリアン変数です。 重複デリミタが1つとして読まれます。 これは、 もしタブが複数スペース文字として保存されているなら、 役立ちます。 もしmultipleが`false`に設定されるなら、 それぞれのデリミタが有効です。

      (%i1) split("1.2   2.3   3.4   4.5");
      (%o1)                 [1.2, 2.3, 3.4, 4.5]
      (%i2) split("first;;third;fourth",";",false);
      (%o2)               [first, , third, fourth]

  Package stringproc ·

関数: sposition (char, string)

  stringの中で、charとマッチする最初の文字の位置を返します。 stringの一番目の文字は位置1にあります。 文字の大小を無視した文字のマッチに関しては， `ssearch`を参照してください。

  Package stringproc ·

関数: sremove (seq, string)
関数: sremove (seq, string, test)
関数: sremove (seq, string, test, start)
関数: sremove (seq, string, test, start, end)

  string同様文字列を返しますが、 seqとマッチする部分文字列すべてなしに返します。 マッチのデフォルトのテスト関数は`sequal`です。 もし`sremove`がseqを検索する間文字の大小を無視しなければいけないなら、 テストとして`sequalignore`を使ってください。 探索を限定するにはstartとendを使ってください。 stringの一番目の文字は位置1にあることに注意してください。

      (%i1) sremove("n't","I don't like coffee.");
      (%o1)                   I do like coffee.
      (%i2) sremove ("DO ",%,'sequalignore);
      (%o2)                    I like coffee.

  Package stringproc ·

関数: sremovefirst (seq, string)
関数: sremovefirst (seq, string, test)
関数: sremovefirst (seq, string, test, start)
関数: sremovefirst (seq, string, test, start, end)

  `seq`とマッチする最初の文字列だけが削除されることを除いて、 `sremove`同様です。

  Package stringproc ·

関数: sreverse (string)

  stringの文字すべてが逆順の文字列を返します。

  Package stringproc ·

関数: ssearch (seq, string)
関数: ssearch (seq, string, test)
関数: ssearch (seq, string, test, start)
関数: ssearch (seq, string, test, start, end)

  文字列seqとマッチするstringの最初の部分文字列の位置を返します。 マッチのためのデフォルトのテスト関数は`sequal`です。 もし`ssearch`が文字の大小を無視しなければいけないなら、 テストとして`sequalignore`を使ってください。 検索を限定するには、startとendを使ってください。 stringの一番目の文字は位置1にあることに注意してください。

      (%i1) ssearch("~s","~{~S ~}~%",'sequalignore);
      (%o1)                                  4

  Package stringproc ·

関数: ssort (string)
関数: ssort (string, test)

  `test (c, d)`が`false`、かつ、`test (d, c)`が`true`であるような2つの連続する文字cとdがないような順で stringの文字すべてを含む文字列を返します。

  ソートのためのデフォルトのテスト関数はclesspです。 テスト関数一式は`{clessp, clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore}`です。

      (%i1) ssort("I don't like Mondays.");
      (%o1)                    '.IMaddeiklnnoosty
      (%i2) ssort("I don't like Mondays.",'cgreaterpignore);
      (%o2)                 ytsoonnMlkIiedda.'

  Package stringproc ·

関数: ssubst (new, old, string)
関数: ssubst (new, old, string, test)
関数: ssubst (new, old, string, test, start)
関数: ssubst (new, old, string, test, start, end)

  stringの中のoldにマッチするすべての部分文字列を newで置き換えた文字列を返します。 oldとnewは同じ長さである必要はありません。 マッチのためのデフォルトのテスト関数は`sequal`です。 もし`ssubst`がoldを検索する間大文字小文字を無視すべきなら、 テストとして`sequalignore`を使ってください。 検索を制限するには、startとendを使ってください。 stringの一番目の文字は位置1にあることに注意してください。

      (%i1) ssubst("like","hate","I hate Thai food. I hate green tea.");
      (%o1)          I like Thai food. I like green tea.
      (%i2) ssubst("Indian","thai",%,'sequalignore,8,12);
      (%o2)         I like Indian food. I like green tea.

  Package stringproc ·

関数: ssubstfirst (new, old, string)
関数: ssubstfirst (new, old, string, test)
関数: ssubstfirst (new, old, string, test, start)
関数: ssubstfirst (new, old, string, test, start, end)

  oldとマッチする最初の部分文字列だけを置き換えることを除いて、 `subst`と同様です。

  Package stringproc ·

関数: strim (seq,string)

  stringの両端からseqに現れるすべての文字を除いた文字列を返します。

      (%i1) "/* comment */"$
      (%i2) strim(" /*",%);
      (%o2)                        comment
      (%i3) slength(%);
      (%o3)                           7

  Package stringproc ·

関数: striml (seq, string)

  stringの左端だけトリムすることを除いて `strim`と同様です。

  Package stringproc ·

関数: strimr (seq, string)

  stringの右端だけトリムすることを除いて `strim`と同様です。

  Package stringproc ·

関数: substring (string, start)
関数: substring (string, start, end)

  位置startで始まり位置endで終わる stringの部分文字列を返します。 位置endの文字は含まれません。 もしendが与えられないなら、部分文字列は文字列の残りを含みます。 stringの一番目の文字は位置1にあることに注意してください。

      (%i1) substring("substring",4);
      (%o1)                        string
      (%i2) substring(%,4,6);
      (%o2)                          in

  Package stringproc ·

関数: supcase (string)
関数: supcase (string, start)
関数: supcase (string, start, end)

  stringの位置startからendまでの小文字を対応する大文字に置き換えた 文字列を返します。 もしendが与えられないなら、 startからstringの終わりまでのすべての小文字が置き換えられます。

      (%i1) supcase("english",1,2);
      (%o1)                        English

  Package stringproc ·

関数: tokens (string)
関数: tokens (string, test)

  stringから抽出されたトークンのリストを返します。 トークンは、文字があるテスト関数を満たす部分文字列です。 もしテストが与えられないなら、 constituentがデフォルトテストとして使われます。 `{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp}`はテスト関数一式です。 (The Lisp-version of `tokens`のLispバージョンはPaul Grahamによって書かれました。 ANSI Common Lisp, 1996, page 67.)

      (%i1) tokens("24 October 2005");
      (%o1)                  [24, October, 2005]
      (%i2) tokens("05-10-24",'digitcharp);
      (%o2)                     [05, 10, 24]
      (%i3) map(parse_string,%);
      (%o3)                      [5, 10, 24]

  Package stringproc ·

Next: unit, Previous: stringproc, Up: Top [Contents][Index]

## 80 to_poly_solve

Previous: to_poly_solve, Up: to_poly_solve [Contents][Index]

### 80.1 Functions and Variables for to_poly_solve

パッケージ `to_poly`と `to_poly_solve`は実験的なものです; これらのパッケージの関数の仕様は変更の可能性があり、 これらのパッケージの関数のいくつかは他のMaxima関数にマージされるかもしれません。

Barton Willis (University of Nebraska at Kearneyの数学科の教授)が `to_poly`と `to_poly_solve`パッケージと これらのパッケージのための英語のユーザードキュメンテーションを書きました。

Operator: %and

  演算子 `%and`は整理化(simplifying)非短絡論理積です。 Maximaは `%and`式をtrueかfalseか論理的に同値ですが整理された式に整理します。 演算子 `%and`は結合的で可換でべき等的です。 そして、 `%and`が名詞形を返す時、 `%and`の引数は非冗長なソートされたリストを形成します; 例えば、

      (%i1) a %and (a %and b);
      (%o1)                       a %and b

  もし積の引数の1つが 明示的にもう一つの引数の否定なら、 `%and`はfalseを返します:

      (%i2) a %and (not a);
      (%o2)                         false

  積のいずれかのメンバーがfalseなら、 たとえ他のメンバーが明白に非ブーリアンでも積はfalseに整理されます; 例えば、

      (%i3) 42 %and false;
      (%o3)                         false

  inequation(すなわち、不等もしくは等式)の`%and`式の任意の引数は Fourier消去パッケージを使って整理されます。 Fourier消去整理器は すべてでないですがいくつかの非線形inequationを線形inequationに変換する プリプロセッサを持ちます; 例えば、Fourier消去コードは `abs(x) + 1 > 0`を trueに整理します。だから、

      (%i4) (x < 1) %and (abs(x) + 1 > 0);
      (%o4)                         x < 1

  注釈

  - オプション変数 `prederror`は `%and`式の整理を変えません。
  - 演算子の優先順位エラーを避けるため、 演算子 `%and, %or`と `not`を含む複合式は完全に括弧でくくらなくてはいけません。
  - Maxima演算子 `and`と `or`はどちらも短絡的です。 なので `and`は結合的でなかったり可換ではなかったりします。

  制限 積 `%and`はinequationを 大域的にではなく局所的に整理します。 これは以下のような積はfalseに整理されないことを意味します。

      (%i5) (x < 1) %and (x > 1);
      (%o5)                 (x > 1) %and (x < 1)

  また、 Fourier消去コードは事実データベースを無視します。

      (%i6) assume(x > 5);
      (%o6)                        [x > 5]
      (%i7) (x > 1) %and (x > 2);
      (%o7)                 (x > 1) %and (x > 2)

  最終的に、同値の線形inequationに容易に変換されない非線形inequationは整理されません。

  `%or`上に `%and`を分配するためのサポートはありません; `%and`上に論理否定を分配するサポートもありません。

  利用のためには `load("to_poly_solve")`

  関連関数 `%or, %if, and, or, not`

  状況 演算子 `%and`は実験的です; この関数の仕様は変更の可能性があり、 その機能は他のMaxima関数にマージされるかもしれません。

演算子: %if (bool, a, b)

  演算子 `%if`は整理化条件文です。 条件 boolはブーリアン値でなければいけません。 条件がtrueの時、二番目の引数を返します; 条件がfalseの時、三番目の引数を返します; その他の場合、名詞形を返します。

  Maxima inequations (不等式か等式)はブーリアン値ではありません; 例えば、 Maximaは 5 < 6をtrueに整理 しませんし、 5 = 6をfalseに整理しません; しかしながら、 to false; however, in the context of a conditional to an `%if`文への条件の文脈では、 Maximaは 自動的にinequationの真値を決定しようとします。 例:

      (%i1) f : %if(x # 1, 2, 8);
      (%o1)                 %if(x - 1 # 0, 2, 8)
      (%i2) [subst(x = -1,f), subst(x=1,f)];
      (%o2)                        [2, 8]

  もし条件がinequationを含むなら、 MaximaはFourier消去パッケージを使ってそれを整理します。

  注釈

  - もし条件が明白に非ブーリアンなら、Maximaは名詞形を返します:

      (%i3) %if(42,1,2);
      (%o3)                     %if(42, 1, 2)

  - Maxima演算子 `if`はn項演算子ですが、演算子 `%if`は n項演算子ではないです。

  制限 Fourier消去コードは 同値の線形inequationに容易に変換可能な非線形inequationだけを 整理します。

  利用には: `load("to_poly_solve")`

  状況: 演算子 `%if`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

演算子: %or

  演算子 `%or`は整理化非短絡論理和です。 Maximaは `%or`式をtrueかfalseか論理的に同値ですが整理された式に整理します。 演算子 `%or`は結合的で可換でべき等です。 そして `%or`が名詞形を返す時、 `%or`の引数は非冗長なソートされたリストを形成します; 例えば、

      (%i1) a %or (a %or b);
      (%o1)                        a %or b

  もし和のメンバーの１つが明示的に他のメンバーの否定なら、 `%or`はtrueを返します:

      (%i2) a %or (not a);
      (%o2)                         true

  もし和の任意のメンバーがtrueなら、 たとえ和の他のメンバーが明白に非ブーリアンでも和はtrueに整理されます。 例えば

      (%i3) 42 %or true;
      (%o3)                         true

  inequation(不等式か等式)である `%or`式の任意の引数は Fourier消去パッケージを使って整理されます。 Fourier消去コードは `abs(x) + 1 > 0`をtrueに整理します。 なので、

      (%i4) (x < 1) %or (abs(x) + 1 > 0);
      (%o4)                         true

  注釈

  - オプション変数 `prederror`は `%or`式の整理を変更しません。
  - 演算子 `%and, %or`, `not`を含む複合式は括弧でくくらなければいけません; これらの演算子の結合力は期待と一致しないことがあります。
  - Maxima演算子 `and`と `or`はどちらも短絡的です。 なので `or`は結合的でないか可換でないかです。

  制限 和 `%or`はinequationを 大域的にではなく、局所的に整理します。 これは以下のような和はtrueに整理されないことを意味します。

      (%i1) (x < 1) %or (x >= 1);
      (%o1) (x > 1) %or (x >= 1)

  更に Fourier消去コードは事実データベースを無視します:

      (%i2) assume(x > 5);
      (%o2)                        [x > 5]
      (%i3) (x > 1) %and (x > 2);
      (%o3)                 (x > 1) %and (x > 2)

  最終的に、同値の線形inequationに容易に変換されない非線形inequationは整理されません。

  両方ともfalseである項を探すアルゴリズムは弱いものです; また、`%and`上に `%or`を分配するためのサポートはありません; `%or`上に論理否定を分配するサポートもありません。

  利用のためには `load("to_poly_solve")`

  関連関数 `%or, %if, and, or, not`

  状況 演算子 `%or`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: complex_number_p (x)

  もし引数が `a + %i * b`, `a`, `%i b`, `%i`のいずれかなら、 述語論理 `complex_number_p`はtrueを返します。 ここで `a`と `b`は有理数か(多倍長浮動小数点数を含む)浮動小数点数です; 他のすべての入力に対して、 `complex_number_p`はfalseを返します; 例えば

      (%i1) map('complex_number_p,[2/3, 2 + 1.5 * %i, %i]);
      (%o1)                  [true, true, true]
      (%i2) complex_number_p((2+%i)/(5-%i));
      (%o2)                         false
      (%i3) complex_number_p(cos(5 - 2 * %i));
      (%o3)                         false

  関連関数 `isreal_p`

  利用するには `load("to_poly_solve")`

  状況 関数 `complex_number_p`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: compose_functions (l)

  関数コール `compose_functions(l)`は リスト lの中の関数の合成をラムダ形を返します。 関数は右から 左へ適用されます; 例えば

      (%i1) compose_functions([cos, exp]);
                                              %g151
      (%o1)             lambda([%g151], cos(%e     ))
      (%i2) %(x);
                                        x
      (%o2)                       cos(%e )

  関数リストが空のとき、恒等関数を返します:

      (%i3) compose_functions([]);
      (%o3)                lambda([%g152], %g152)
      (%i4)  %(x);
      (%o4)                           x

  注釈

  - Maximaがリストメンバーがシンボルやラムダ形でないか決める時、 (`compose_functions`ではなく) `funmake`がエラーをシグナルします:

      (%i5) compose_functions([a < b]);

      funmake: first argument must be a symbol, subscripted symbol,
      string, or lambda expression; found: a < b
      #0: compose_functions(l=[a < b])(to_poly_solve.mac line 40)
       -- an error. To debug this try: debugmode(true);

  - 名前の衝突を避けるために、独立変数は 関数 `new_variable`が決めます。

      (%i6) compose_functions([%g0]);
      (%o6)              lambda([%g154], %g0(%g154))
      (%i7) compose_functions([%g0]);
      (%o7)              lambda([%g155], %g0(%g155))

  - 独立変数が違っても、 Maximaはこれらのラムダ形が意味的に等しいことを演繹できます:

      (%i8) is(equal(%o6,%o7));
      (%o8)                         true

  利用するには `load("to_poly_solve")`

  状況 関数 `compose_functions`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: dfloat (x)

  関数 `dfloat`は `float`に似ていますが、 `float`が IEEE 倍精度浮動小数点数に評価するのを失敗した時、 関数 `dfloat`は `rectform`を適用します; 例えば

      (%i1) float(4.5^(1 + %i));
                                     %i + 1
      (%o1)                       4.5
      (%i2) dfloat(4.5^(1 + %i));
      (%o2)        4.48998802962884 %i + .3000124893895671

  注釈

  - 式の直交形は 数値評価には不完全で合わないかもしれません–例えば、 直交形は不必要に浮動小数点数の差(桁落ち)を含むかもしれません。
  - 識別子 `float`は(デフォルト値がfalseの)オプション変数であり かつ関数名です。

  関連関数 `float, bfloat`

  利用するには `load("to_poly_solve")`

  状況 関数 `dfloat`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: elim (l, x)

  関数 `elim`は 集合もしくはリスト `l`内の等式から 集合もしくはリスト`x`内の変数を消去します。 `x`のメンバーそれぞれはシンボルでなければいけません; must be a symbol; the members of `l`のメンバーは等式か零に等しいと仮定される式であり得ます。

  関数 `elim`は2つのリストのリストを返します; 一番目は変数が消去された式のリストです; 二番目はピボットのリストです; 二番目のリストは `elim`が変数を消去するのに使った式のリストです。

  以下は線形方程式を消去する例です:

      (%i1) elim(set(x + y + z = 1, x - y  - z = 8, x - z = 1),
                 set(x,y));
      (%o1)            [[2 z - 7], [y + 7, z - x + 1]]

  `x`と `y`の消去は一つの等式 `2 z - 7 = 0`をもたらします; 等式 `y + 7 = 0`と `z - z + 1 = 1`がピボットとして使われました。 これらの等式から3つの変数すべての消去は、線形系を三角化します:

      (%i2) elim(set(x + y + z = 1, x - y  - z = 8, x - z = 1),
                 set(x,y,z));
      (%o2)           [[], [2 z - 7, y + 7, z - x + 1]]

  もちろん、等式は線形である必要はありません:

      (%i3) elim(set(x^2 - 2 * y^3 = 1,  x - y = 5), [x,y]);
                           3    2
      (%o3)       [[], [2 y  - y  - 10 y - 24, y - x + 5]]

  ユーザーは変数が消去される順序を制御しません。 確かに、アルゴリズムは 最良のピボットと最良の消去順序を選ぼうとする発見的方法を使います。

  注釈

  - 関連関数 `eliminate`と違い、 等式の数が変数の数と等しい時、関数 `elim`は `solve`を呼び出しません。
  - 関数 `elim`は終結式を適用することで機能します; オプション変数 `resultant`は Maximaがどのアルゴリズムを使うか決めます。 `sqfr`を使って、 Maximaは それぞれの終結式を因数分解し、 多重零点を抑制します。
  - `elim`は多項式方程式の非線形一式を三角化します; 三角化された集合の解集合は 三角化されていない集合の解集合よりも大きいかもしれません。 例えば、、 三角化された方程式は見せかけの解を持ち得ます。

  関連関数 elim_allbut, eliminate_using, eliminate

  オプション変数 resultant

  利用するには `load("to_poly")`

  状況 関数 `elim`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: elim_allbut (l, x)

  この関数は `elim`に似ています。 等式のリスト `l`内の リスト `x`内の変数を 除いて 変数すべてを消去することを除いて

      (%i1) elim_allbut([x+y = 1, x - 5*y = 1],[]);
      (%o1)                 [[], [y, y + x - 1]]
      (%i2) elim_allbut([x+y = 1, x - 5*y = 1],[x]);
      (%o2)                [[x - 1], [y + x - 1]]

  利用するには `load("to_poly")`

  オプション変数 resultant

  関連関数 elim, eliminate_using, eliminate

  状況 関数 `elim_allbut`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: eliminate_using (l, e, x)

  Using `e` as the pivot, eliminate the symbol `x` from the list or set of equations in `l`. The function `eliminate_using` returns a set.

      (%i1) eq : [x^2 - y^2 - z^3 , x*y - z^2 - 5, x - y + z];
                     3    2    2     2
      (%o1)      [- z  - y  + x , - z  + x y - 5, z - y + x]
      (%i2) eliminate_using(eq,first(eq),z);
              3              2      2      3    2
      (%o2) {y  + (1 - 3 x) y  + 3 x  y - x  - x ,
                              4    3  3       2  2             4
                             y  - x  y  + 13 x  y  - 75 x y + x  + 125}
      (%i3) eliminate_using(eq,second(eq),z);
              2            2       4    3  3       2  2             4
      (%o3) {y  - 3 x y + x  + 5, y  - x  y  + 13 x  y  - 75 x y + x
                                                                 + 125}
      (%i4) eliminate_using(eq, third(eq),z);
              2            2       3              2      2      3    2
      (%o4) {y  - 3 x y + x  + 5, y  + (1 - 3 x) y  + 3 x  y - x  - x }

  オプション変数 resultant

  関連関数 elim, eliminate, elim_allbut

  利用するには `load("to_poly")`

  状況 関数 `elimimate_using`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: fourier_elim ([eq1, eq2, …], [var1, var, …])

  Fourier消去は Gauss消去の線形inequation(等式か不等式)に関する類似物です。 関数コール `fourier_elim([eq1, eq2, ...], [var1, var2, ...]`は 線形inequationsのリスト `[eq1, eq2, ...]`上の 変数 `[var1, var2, ...]`に関するFourier消去です; 例えば

      (%i1) fourier_elim([y-x < 5, x - y < 7, 10 < y],[x,y]);
      (%o1)            [y - 5 < x, x < y + 7, 10 < y]
      (%i2) fourier_elim([y-x < 5, x - y < 7, 10 < y],[y,x]);
      (%o2)        [max(10, x - 7) < y, y < x + 5, 5 < x]

  Eliminating first with respect to 最初に xを次に yを消去することは yに依存する、xに関する下限と上限、 そしてyに関する下限と上限(それらは数です)ををもたらします。 他の順序での消去は x依存のyの下限と上限、 そしてxの数値的下限と上限を与えます。

  必要な時、 `fourier_elim`はinequationのリストの論理和を返します:

      (%i3) fourier_elim([x # 6],[x]);
      (%o3)                  [x < 6] or [6 < x]

  解集合が空の時、 `fourier_elim`は `emptyset`を返し、 解集合が実数すべての時、 `fourier_elim`は `universalset`を返します; 例えば

      (%i4) fourier_elim([x < 1, x > 1],[x]);
      (%o4)                       emptyset
      (%i5) fourier_elim([minf < x, x < inf],[x]);
      (%o5)                     universalset

  非線形inequationに対して、 `fourier_elim`は (幾分) 整理されたinequationsのリストを返します:

      (%i6) fourier_elim([x^3 - 1 > 0],[x]);

                     2                             2
      (%o6) [1 < x, x  + x + 1 > 0] or [x < 1, - (x  + x + 1) > 0]

      (%i7) fourier_elim([cos(x) < 1/2],[x]);
      (%o7)                  [1 - 2 cos(x) > 0]

  inequationのリストの代わりに、 `fourier_elim`の一番目の引数は 論理和か論理積であるかもしれません:

      (%i8) fourier_elim((x + y < 5) and (x - y >8),[x,y]);
                                                    3
      (%o8)            [y + 8 < x, x < 5 - y, y < - -]
                                                    2
      (%i9) fourier_elim(((x + y < 5) and x < 1) or  (x - y >8),[x,y]);
      (%o9)          [y + 8 < x] or [x < min(1, 5 - y)]

  関数 `fourier_elim`は inequation演算子 `<, <=, >, >=, #`, `=`をサポートします。

  Fourier消去コードは 絶対値や最小、最大関数を含むいくつかの非線形inequationを 線形inequationに変換する プリプロセッサを持ちます． 加えて、プリプロセッサは 線形項の積か商であるいくつかの式を扱います:

      (%i10) fourier_elim([max(x,y) > 6, x # 8, abs(y-1) > 12],[x,y]);
      (%o10) [6 < x, x < 8, y < - 11] or [8 < x, y < - 11]
       or [x < 8, 13 < y] or [x = y, 13 < y] or [8 < x, x < y, 13 < y]
       or [y < x, 13 < y]
      (%i11) fourier_elim([(x+6)/(x-9) <= 6],[x]);
      (%o11)           [x = 12] or [12 < x] or [x < 9]
      (%i12) fourier_elim([x^2 - 1 # 0],[x]);
      (%o12)      [- 1 < x, x < 1] or [1 < x] or [x < - 1]

  利用するには `load("fourier_elim")`

関数: isreal_p (e)

  述語論理 `isreal_p`は、 Maximaが `e`が実数線全体上で実数値であることを 決められる時 trueを返します; Maximaが 実数線の空でないある部分集合上で`e`が実数値で ないことを 決められる時 falseを返します; 他の場合、名詞形を返します。

      (%i1) map('isreal_p, [-1, 0, %i, %pi]);
      (%o1)               [true, true, false, true]

  Maxima変数は実と仮定されます; たとえば

      (%i2) isreal_p(x);
      (%o2)                         true

  関数 `isreal_p`は事実データベースを検査します:

      (%i3) declare(z,complex)$

      (%i4) isreal_p(z);
      (%o4)                      isreal_p(z)

  制限 頻繁すぎるほど `isreal_p`は falseを返すことができる時に名詞形を返します; 対数函数は実数線全体で実数値ではありません。 だから `isreal_p(log(x))`はfalseを返すべきです; しかしながら

      (%i5) isreal_p(log(x));
      (%o5)                   isreal_p(log(x))

  利用するには `load("to_poly_solve")`

  関連関数 complex_number_p

  状況 関数 `real_p`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: new_variable (type)

  `%[z,n,r,c,g]k`という形のユニークなシンボルを返します。 ここで `k`は整数です typeに許される値は integer, natural_number, real, natural_number, generalです。 (自然数(natural number)は 非負整数を意味します; なので零は自然数です 自然数の定義のすべてではありませんがいくつかは零を除外します。)

  typeが許される値の１つでない時、 typeは generalにデフォルト設定されます。 整数、自然数、複素数に対して、 Maximaは自動的にこの情報を事実データベースに追加します。

      (%i1) map('new_variable,
                ['integer, 'natural_number, 'real, 'complex, 'general]);
      (%o1)          [%z144, %n145, %r146, %c147, %g148]
      (%i2) nicedummies(%);
      (%o2)               [%z0, %n0, %r0, %c0, %g0]
      (%i3) featurep(%z0, 'integer);
      (%o3)                         true
      (%i4) featurep(%n0, 'integer);
      (%o4)                         true
      (%i5) is(%n0 >= 0);
      (%o5)                         true
      (%i6) featurep(%c0, 'complex);
      (%o6)                         true

  注釈 一般に、`new_variable`の引数はクォートすべきです。 クォートは以下に似たエラーを防ぎます。

      (%i7) integer : 12$

      (%i8) new_variable(integer);
      (%o8)                         %g149
      (%i9) new_variable('integer);
      (%o9)                         %z150

  関連関数 nicedummies

  利用するには `load("to_poly_solve")`

  状況 関数 `new_variable`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: nicedummies

  関数 `nicedummies`は `new_variable`が導入した式の中の変数を零から再インデックスします;

      (%i1) new_variable('integer) + 52 * new_variable('integer);
      (%o1)                   52 %z136 + %z135
      (%i2) new_variable('integer) - new_variable('integer);
      (%o2)                     %z137 - %z138
      (%i3) nicedummies(%);
      (%o3)                       %z0 - %z1

  関連関数 new_variable

  利用するには `load("to_poly_solve")`

  状況 関数 `nicedummies`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: parg (x)

  関数 `parg`は 複素偏角関数 `carg`の整理化バージョンです; 例えば

      (%i1) map('parg,[1,1+%i,%i, -1 + %i, -1]);
                              %pi  %pi  3 %pi
      (%o1)               [0, ---, ---, -----, %pi]
                               4    2     4

  一般に非定数入力に対して `parg`は名詞形を返します;例えば

      (%i2) parg(x + %i * sqrt(x));
      (%o2)                 parg(x + %i sqrt(x))

  `sign`を使って入力が正の実数か負の実数か決めることができる時 `parg`は非定数入力に対して非名詞形を返します。 以下は2つの例です:

      (%i3) parg(abs(x));
      (%o3) 0
      (%i4) parg(-x^2-1);
      (%o4)                          %pi

  注釈 `sign`関数は 複素数と宣言された変数(`declare(x,complex)`)を ほとんど無視します; 複素数と宣言された変数に対して、 `parg`は間違った値を返す可能性があります; 例えば

      (%i1) declare(x,complex)$

      (%i2) parg(x^2 + 1);
      (%o2) 0

  Related function carg, isreal_p

  利用するには `load("to_poly_solve")`

  状況 関数 `parg`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: real_imagpart_to_conjugate (e)

  関数 `real_imagpart_to_conjugate`は `realpart`と `imagpart`をすべて `conjugate`を含む代数的に同値な式に置き換えます。

      (%i1) declare(x, complex)$

      (%i2) real_imagpart_to_conjugate(realpart(x) +  imagpart(x) = 3);
                conjugate(x) + x   %i (x - conjugate(x))
      (%o2)     ---------------- - --------------------- = 3
                       2                     2

  利用するには `load("to_poly_solve")`

  状況 関数 `real_imagpart_to_conjugate`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: rectform_log_if_constant (e)

  関数 `rectform_if_constant`は `log(c)`の形の項をすべて `rectform(log(c))`に変換します。 ここで `c`は宣言された定数式か明示的に宣言された定数です。

      (%i1) rectform_log_if_constant(log(1-%i) - log(x - %i));
                                       log(2)   %i %pi
      (%o1)            - log(x - %i) + ------ - ------
                                         2        4
      (%i2) declare(a,constant, b,constant)$

      (%i3) rectform_log_if_constant(log(a + %i*b));
                             2    2
                        log(b  + a )
      (%o3)             ------------ + %i atan2(b, a)
                             2

  利用するには `load("to_poly_solve")`

  状況 関数 `rectform_log_if_constant`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: simp_inequality (e)

  関数 `simp_inequality`は inequationの論理積と論理和にいくつかの整理を適用します。

  制限 関数 `simp_inequality`は少なくとも2つの点で制限されます; 第一に整理が局所的です; 例えば

      (%i1) simp_inequality((x > minf) %and (x < 0));
      (%o1) (x>1) %and (x<1)

  第二に `simp_inequality`は事実データベースを参照しません:

      (%i2) assume(x > 0)$

      (%i3) simp_inequality(x > 0);
      (%o3)                         x > 0

  利用するには `load("to_poly_solve")`

  状況 関数 `simp_inequality`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: standardize_inverse_trig (e)

  この関数は 恒等式 `cot(x) = atan(1/x), acsc(x) = asin(1/x),`と `asec, acoth, acsch` `asech`に関する類似 の恒等式を式に適応します。 Abramowitz and Stegun, Eqs. 4.4.6 から 4.4.8までと 4.6.4から 4.6.6までを参照してください。

  利用するには `load("to_poly_solve")`

  状況 関数 `standardize_inverse_trig`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: subst_parallel (l, e)

  `l`が単一の等式か等式のリストの時、 それぞれの等式の右辺側を左辺に代入します。 代入は並列に行われます; 例えば

      (%i1) load("to_poly_solve")$

      (%i2) subst_parallel([x=y,y=x], [x,y]);
      (%o2)                        [y, x]

  これを順にされる代入と比較します:

      (%i3) subst([x=y,y=x],[x,y]);
      (%o3)                        [x, x]

  関数 `subst_parallel`は `subst_parallel`は非アトムの代入を許すことを除いて `sublis`と似ています; 例えば

      (%i4) subst_parallel([x^2 = a, y = b], x^2 * y);
      (%o4)                          a b
      (%i5) sublis([x^2 = a, y = b], x^2 * y);

                                                                   2
      sublis: left-hand side of equation must be a symbol; found: x
       -- an error. To debug this try: debugmode(true);

  `subst_parallel`が行う代入は文字通りであり意味論的ではありません; なので `subst_parallel`は x * yが x^2 * yの部分式であることを認識しません

      (%i6) subst_parallel([x * y = a], x^2 * y);
                                     2
      (%o6)                         x  y

  関数 `subst_parallel`は整理の前にすべての代入を完了します。 これは、もし整理が前に行われていたらエラーが起こるような 条件式への代入を許します:

      (%i7) subst_parallel([x = 0], %if(x < 1, 5, log(x)));
      (%o7)                           5
      (%i8) subst([x = 0], %if(x < 1, 5, log(x)));

      log: encountered log(0).
       -- an error. To debug this try: debugmode(true);

  関連関数 subst, sublis, ratsubst

  利用するには `load("to_poly_solve_extra.lisp")`

  状況 関数 `subst_parallel`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: to_poly (e, l)

  関数 `to_poly`は 等式 `e`を inequation制約を伴う多項式系に変換しようとします; 制約を満たす多項式系の解は 等式 `e`の解です。 非公式には `to_poly`は 等式 eを多項式化しようとします; 例がわかりやすいかもしれません:

      (%i1) load("to_poly_solve")$

      (%i2) to_poly(sqrt(x) = 3, [x]);
                                  2
      (%o2) [[%g130 - 3, x = %g130 ],
                            %pi                               %pi
                         [- --- < parg(%g130), parg(%g130) <= ---], []]
                             2                                 2

  条件 `-%pi/2<parg(%g6),parg(%g6)<=%pi/2`は `%g6`が平方根関数の範囲内であることを告げます。 これがtrueの時、 `sqrt(x) = 3`に設定された解は `%g6-3,x=%g6^2`に設定された解と同じです。

  三角式を多項式化するには、 非代数的代入の導入が必要です; これらの非代数的代入は `to_poly`が返す三番目のリスト内で返されます; 例えば

      (%i3) to_poly(cos(x),[x]);
                      2                                 %i x
      (%o3)    [[%g131  + 1], [2 %g131 # 0], [%g131 = %e    ]]

  数字1が変数リストのメンバーでない限り定数項は多項式化されません; 例えば

      (%i4) to_poly(x = sqrt(5),[x]);
      (%o4)                [[x - sqrt(5)], [], []]
      (%i5) to_poly(x = sqrt(5),[1,x]);
                                  2
      (%o5) [[x - %g132, 5 = %g132 ],
                            %pi                               %pi
                         [- --- < parg(%g132), parg(%g132) <= ---], []]
                             2                                 2

  根の1つとしてsqrt(5) + sqrt(7)を持つ多項式を生成するには、 以下のコマンドを使います。

      (%i6) first(elim_allbut(first(to_poly(x = sqrt(5) + sqrt(7),
                                            [1,x])), [x]));
                                4       2
      (%o6)                   [x  - 24 x  + 4]

  関連関数 to_poly_solve

  利用するには `load("to_poly")`

  状況: 関数 `to_poly`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

関数: to_poly_solve (e, l, [options])

  関数 `to_poly_solve`は 等式 eを 変数 lについて解こうとします。 等式 eは単一の式か式の集合もしくはリストでありえます; 同様に lは単一のシンボルかシンボルの集合のリストでありえます; eのメンバーが明示的に等式でない時(例えば x^2 -1)、 ソルバは式は0に等しいと仮定します。

  `to_poly_solve`の基本戦略は 入力を多項式形に変換するために `to_poly`を使い、 多項式系上で `algsys`をコールします。 なので Thus user options that affect `algsys`に影響を与えるユーザーオプション、特に `algexact`は `to_poly_solve`にも影響を与えます。 `algexact`のデフォルト値はfalseですが、 `to_poly_solve`のためには、、一般的に `algexact`はtrueであるべきです。 関数 `to_poly_solve`は `algexact`を局所的にtrueに設定しません。 `algsys`が厳密は解を決定することができない時 trueに設定すると近似解を見つけることが不可能になるためです。

  `to_poly_solve`が解集合を決定できる時、 解集合のそれぞれのメンバーは `%union`オブジェクト内のリストです:

      (%i1) load("to_poly_solve")$

      (%i2) to_poly_solve(x*(x-1) = 0, x);
      (%o2)               %union([x = 0], [x = 1])

  `to_poly_solve`が解集合を決定できない時 `%solve`名詞形が返されます。(この場合、警告が印字されます。)

      (%i3) to_poly_solve(x^k + 2* x + 1 = 0, x);

      Nonalgebraic argument given to 'to_poly'
      unable to solve
                                k
      (%o3)            %solve([x  + 2 x + 1 = 0], [x])

  `%solve`名詞形への代入は時々解に帰着します。

      (%i4) subst(k = 2, %);
      (%o4)                   %union([x = - 1])

  特に三角等式の場合、 ソルバは時々任意整数の導入を必要とします。 これらの任意整数は `%zXXX`という形を持ちます。 ここで `XXX`は整数です; 例えば

      (%i5) to_poly_solve(sin(x) = 0, x);
      (%o5)   %union([x = 2 %pi %z33 + %pi], [x = 2 %pi %z35])

  これらの変数を零から再インデックスするには `nicedummies`を使います:

      (%i6) nicedummies(%);
      (%o6)    %union([x = 2 %pi %z0 + %pi], [x = 2 %pi %z1])

  時折、ソルバは `%cXXX`という形の任意複素数か `%rXXX`という形の任意実数を導入します。 関数 `nicedummies`はこれらの識別子を零から再インデックスします。

  解集合は時々 論理積、論理和、含意に関してそれぞれ `%and`か, `%or`, `%if`を含む様々な論理演算子の 整理化バージョンを含みます; 例えば

      (%i7) sol : to_poly_solve(abs(x) = a, x);
      (%o7) %union(%if(isnonnegative_p(a), [x = - a], %union()),
                            %if(isnonnegative_p(a), [x = a], %union()))
      (%i8) subst(a = 42, sol);
      (%o8)             %union([x = - 42], [x = 42])
      (%i9) subst(a = -42, sol);
      (%o9)                       %union()

  空集合は `%union`によって表現されます。

  関数 `to_poly_solve`は 有理数や非有理べき、絶対値、三角関数、最小最大を含む等式の(すべてではありませんが) いくつかを解くことができます。 Lambert W 函数を使って解くことができるいくつかの等式も解くことができます; 例:

      (%i1) load("to_poly_solve")$

      (%i2) to_poly_solve(set(max(x,y) = 5, x+y = 2), set(x,y));
      (%o2)      %union([x = - 3, y = 5], [x = 5, y = - 3])
      (%i3) to_poly_solve(abs(1-abs(1-x)) = 10,x);
      (%o3)             %union([x = - 10], [x = 12])
      (%i4) to_poly_solve(set(sqrt(x) + sqrt(y) = 5, x + y = 10),
                          set(x,y));
                           3/2               3/2
                          5    %i - 10      5    %i + 10
      (%o4) %union([x = - ------------, y = ------------],
                               2                 2
                                      3/2                 3/2
                                     5    %i + 10        5    %i - 10
                                [x = ------------, y = - ------------])
                                          2                   2
      (%i5) to_poly_solve(cos(x) * sin(x) = 1/2,x,
                          'simpfuncs = ['expand, 'nicedummies]);
                                               %pi
      (%o5)              %union([x = %pi %z0 + ---])
                                                4
      (%i6) to_poly_solve(x^(2*a) + x^a + 1,x);
                                              2 %i %pi %z81
                                              -------------
                                        1/a         a
                        (sqrt(3) %i - 1)    %e
      (%o6) %union([x = -----------------------------------],
                                        1/a
                                       2

                                                        2 %i %pi %z83
                                                        -------------
                                                  1/a         a
                                (- sqrt(3) %i - 1)    %e
                           [x = -------------------------------------])
                                                 1/a
                                                2

      (%i7) to_poly_solve(x * exp(x) = a, x);
      (%o7)              %union([x = lambert_w(a)])

  線形不等式に対して、 `to_poly_solve`は自動的にFourier消去を行います:

      (%i8) to_poly_solve([x + y < 1, x - y >= 8], [x,y]);
                                     7
      (%o8) %union([x = y + 8, y < - -],
                                     2
                                                                    7
                                       [y + 8 < x, x < 1 - y, y < - -])
                                                                    2

  `to_poly_solve`のオプション引数のそれぞれは等式でなければいけません; 一般にこれらのオプションの順序は問題になりません．

  - `simpfuncs = l`, ここで `l`は函数のリストです。 lのメンバーの合成をそれぞれの解に適用します。

      (%i1) to_poly_solve(x^2=%i,x);
                                     1/4             1/4
      (%o1)       %union([x = - (- 1)   ], [x = (- 1)   ])
      (%i2) to_poly_solve(x^2= %i,x, 'simpfuncs = ['rectform]);
                            %i         1             %i         1
      (%o2) %union([x = - ------- - -------], [x = ------- + -------])
                          sqrt(2)   sqrt(2)        sqrt(2)   sqrt(2)

  - 時々追加の整理は整理を戻すことがあります; 例えば

      (%i3) to_poly_solve(x^2=1,x);
      (%o3)              %union([x = - 1], [x = 1])
      (%i4) to_poly_solve(x^2= 1,x, 'simpfuncs = [polarform]);
                                              %i %pi
      (%o4)            %union([x = 1], [x = %e      ]

  - Maximaは 関数リスト `l`のそれぞれのメンバーが純粋に整理であるかチェックしようとしません; 例えば

      (%i5) to_poly_solve(x^2 = %i,x, 'simpfuncs = [lambda([s],s^2)]);
      (%o5)                   %union([x = %i])

  - それぞれの解を倍精度浮動小数点数に変換するには `simpfunc = ['dfloat]`を使います:

      (%i6) to_poly_solve(x^3 +x + 1 = 0,x,
                          'simpfuncs = ['dfloat]), algexact : true;
      (%o6) %union([x = - .6823278038280178],
      [x = .3411639019140089 - 1.161541399997251 %i],
      [x = 1.161541399997251 %i + .3411639019140089])

  - `use_grobner = true` このオプションを使うと 解を企てる前に関数 `poly_reduced_grobner`が 等式に適用されます 主として、このオプションは 関数 `algsys`の弱みに対する応急措置を提供します。 以下はそんな応急措置の例です:

      (%i7) to_poly_solve([x^2+y^2=2^2,(x-1)^2+(y-1)^2=2^2],[x,y],
                          'use_grobner = true);

                          sqrt(7) - 1      sqrt(7) + 1
      (%o7) %union([x = - -----------, y = -----------],
                               2                2

                                       sqrt(7) + 1        sqrt(7) - 1
                                  [x = -----------, y = - -----------])
                                            2                  2
      (%i8) to_poly_solve([x^2+y^2=2^2,(x-1)^2+(y-1)^2=2^2],[x,y]);
      (%o8)                       %union()

  - `maxdepth = k`, ここで `k`は正の整数です。 この関数はソルバの最大再帰深さを制御します。 `maxdepth`のデフォルト値は5です。 再帰深さを越えた時、ソルバはエラーをシグナルします:

      (%i9) to_poly_solve(cos(x) = x,x, 'maxdepth = 2);

      Unable to solve
      Unable to solve
      (%o9)        %solve([cos(x) = x], [x], maxdepth = 2)

  - `parameters = l`, ここで `l`はシンボルのリストです。 ソルバは リスト `l`のメンバーすべてに有効な解を返そうとします; 例えば:

      (%i10) to_poly_solve(a * x = x, x);
      (%o10)                   %union([x = 0])
      (%i11) to_poly_solve(a * x = x, x, 'parameters = [a]);
      (%o11) %union(%if(a - 1 = 0, [x = %c111], %union()),
                                     %if(a - 1 # 0, [x = 0], %union()))

  - `(%o2)`で、ソルバはダミー変数を導入しました; これらのダミー変数を再インデックスするには、 関数 `nicedummies`を使います:

      (%i12) nicedummies(%);
      (%o12) %union(%if(a - 1 = 0, [x = %c0], %union()),
                                     %if(a - 1 # 0, [x = 0], %union()))

  f(a) = f(b)という形の等式を解くために `to_poly_solve`は ハッシュ配列 `one_to_one_reduce`に記憶されたデータを使います。 割り当て `one_to_one_reduce['f,'f] : lambda([a,b], a=b)`は `to_poly_solve`に f(a) = f(b)の解集合がa=bの解集合に等しいことを告げます; 例えば

      (%i13) one_to_one_reduce['f,'f] : lambda([a,b], a=b)$

      (%i14) to_poly_solve(f(x^2-1) = f(0),x);
      (%o14)             %union([x = - 1], [x = 1])

  さらに一般的に、 割り当て `one_to_one_reduce['f,'g] : lambda([a,b], w(a, b) = 0`は `to_poly_solve`に f(a) = f(b)の解集合が w(a,b) = 0の解集合に等しいことを告げます; 例えば

      (%i15) one_to_one_reduce['f,'g] : lambda([a,b], a = 1 + b/2)$

      (%i16) to_poly_solve(f(x) - g(x),x);
      (%o16)                   %union([x = 2])

  加えて、f(a) = bという形の等式を解くために 関数 `to_poly_solve`は ハッシュ配列 `function_inverse`に記憶されたデータを使います。 割り当て `function_inverse['f] : lambda([s], g(s))`は `to_poly_solve`に `f(x) = b`に設定された解が `x = g(b)`に設定された解に等しいことを知らせます; 2つの例:

      (%i17) function_inverse['Q] : lambda([s], P(s))$

      (%i18) to_poly_solve(Q(x-1) = 2009,x);
      (%o18)              %union([x = P(2009) + 1])
      (%i19) function_inverse['G] : lambda([s], s+new_variable(integer));
      (%o19)       lambda([s], s + new_variable(integer))
      (%i20) to_poly_solve(G(x - a) = b,x);
      (%o20)             %union([x = b + a + %z125])

  注釈

  - 解く変数はシンボルである必要はありません; `fullratsubst`が適切に代入できる時、 解く変数は非シンボルであり得ます:

      (%i1) to_poly_solve([x^2 + y^2 + x * y = 5, x * y = 8],
                          [x^2 + y^2, x * y]);
                                        2    2
      (%o1)           %union([x y = 8, y  + x  = - 3])

  - 複素共役を含む等式に対して、 ソルバは自動的に共役等式を追加します; 例えば

      (%i1) declare(x,complex)$

      (%i2) to_poly_solve(x + (5 + %i) * conjugate(x) = 1, x);
                                         %i + 21
      (%o2)              %union([x = - -----------])
                                       25 %i - 125
      (%i3) declare(y,complex)$

      (%i4) to_poly_solve(set(conjugate(x) - y = 42 + %i,
                              x + conjugate(y) = 0), set(x,y));
                                 %i - 42        %i + 42
      (%o4)        %union([x = - -------, y = - -------])
                                    2              2

  - 絶対値関数を含む等式に対して、 `to_poly_solve`は 絶対値の引数が複素数値か決めるため 事実データベースに問い合わせます。

      (%i1) to_poly_solve(abs(x) = 6, x);
      (%o1)              %union([x = - 6], [x = 6])
      (%i2) declare(z,complex)$

      (%i3) to_poly_solve(abs(z) = 6, z);
      (%o3) %union(%if((%c11 # 0) %and (%c11 conjugate(%c11) - 36 =
                                             0), [z = %c11], %union()))

  - これはソルバが事実データベースを参照する唯一の状況です。例えば、もし解く変数が整数と宣言されていたら、`to_poly_solve`はこの宣言を無視します。

  Relevant option variables algexact, resultant, algebraic

  関連関数 to_poly

  利用するには `load("to_poly_solve")`

  状況: 関数 `to_poly_solve`は実験的です; 仕様は変更の可能性があり、 機能は他のMaxima関数にマージされるかもしれません。

Next: zeilberger, Previous: to_poly_solve, Up: Top [Contents][Index]

## 81 unit

Next: Functions and Variables for Units, Previous: unit, Up: unit [Contents][Index]

### 81.1 Introduction to Units

unitパッケージは、ユーザーが 任意の単位間での変換したり、方程式の中の次元を扱うことを可能にします。 このパッケージの機能はオリジナルのMaxima単位パッケージとは根本的に違います - オリジナルは定義の基本的なリストでしたが、 このパッケージは、ユーザーが 次元基底毎に最後の答えが翻訳される単位を選ぶことを可能にするようなルールセットを使います。 表示でそれらを混ぜる代わりに単位を分離し、 ユーザーが 個々の答えに関連付けられた単位を容易に識別することを可能にします。 演繹された単位に整理する間、巧みな制御を供給することはもちろん、 ユーザーが式を基本的な基底単位に整理することを可能にします。 次元解析が可能で、変換と整理オプションを管理するために様々なツールが利用可能です。 カスタマイズ可能な自動変換に加えて、 unitsはこれまでの手動変換オプションも提供します。

注意 - 単位変換が正確でない時、Maximaは 分数に帰着する近似を行います。 これは、単位を整理するのに使われる手法の結果です。 このタイプの代入を警告するメッセージは、 この状況はしばしば起こり、警告が出力を群れをなしておおうので、 (通常オンですが)単位の場合デフォルトでディセーブルにされています。 (単位変換の後、ratprintの存在している状態は復元されます。 だから、そうでなければ、ユーザーのその設定への変更は保持されます。) もしユーザーが単位に関するこの情報を必要とするなら、 単位変換プロセスからの警告の印字を再アクティベートするために unitverbose:onを設定できます。

unitはMaximaに、share/contrib/unitディレクトリに含まれます。 通常のMaximaのパッケージローディング慣例に従います：

    (%i1) load("unit")$
    *******************************************************************
    *                       Units version 0.50                        *
    *          Definitions based on the NIST Reference on             *
    *              Constants, Units, and Uncertainty                  *
    *       Conversion factors from various sources including         *
    *                   NIST and the GNU units package                *
    *******************************************************************

    Redefining necessary functions...
    WARNING: DEFUN/DEFMACRO: redefining function TOPLEVEL-MACSYMA-EVAL ...
    WARNING: DEFUN/DEFMACRO: redefining function MSETCHK ...
    WARNING: DEFUN/DEFMACRO: redefining function KILL1 ...
    WARNING: DEFUN/DEFMACRO: redefining function NFORMAT ...
    Initializing unit arrays...
    Done.

WARNINGメッセージが予想されますが、心配の原因ではありません - それらは unitパッケージが本来のMaximaで既に定義されている関数を再定義していることを示しています。 これは単位を適切には使うために必要です。 ユーザーは、もし他のパッケージがこれらの関数に他の変更を加えたならそれらの変更はこのロードプロセスによって上書きされることに気づくべきです。

unit.macファイルは、 パッケージに必要なlisp関数を含む lispファイルunit-functions.lispもロードします。

Clifford Yappは主作者です。 彼は、 Nebraska大学Kearney校(UNK)のBarton Willis, Robert Dodier, そしてMaximaメーリングリストの他の大胆不敵な人々から 価値ある援助を受けました。

たぶん多くのバグがあります。知らせてください。 `float`と`numer`は期待の動作をしません。

TODO : 次元機能、温度の扱い、略語表示、仲間。単位を含む量の足し算の例を示す。

Physical units ·Share packages ·Package unit ·

Previous: Introduction to Units, Up: unit [Contents][Index]

### 81.2 Functions and Variables for Units

関数: setunits (list)

  デフォルトでは、 unitパッケージは 組み立てられた次元はどんなものでも使いませんが、 MKS単位を使ってすべての単位を7つの基本的な次元に変換します。

      (%i2) N;
                                           kg m
      (%o2)                                ----
                                             2
                                            s

      (%i3) dyn;
                                         1      kg m
      (%o3)                           (------) (----)
                                       100000     2
                                                 s

      (%i4) g;
                                          1
      (%o4)                             (----) (kg)
                                         1000

      (%i5) centigram*inch/minutes^2;
                                        127        kg m
      (%o5)                       (-------------) (----)
                                   1800000000000     2
                                                    s

  いくつかの場合、これは望みの振る舞いです。 もしユーザーが他の単位を使いたいなら、 これは `setunits`コマンドで達成されます:

      (%i6) setunits([centigram,inch,minute]);
      (%o6)                                done

      (%i7) N;
                                  1800000000000   %in cg
      (%o7)                      (-------------) (------)
                                       127            2
                                                  %min

      (%i8) dyn;
                                     18000000   %in cg
      (%o8)                         (--------) (------)
                                       127          2
                                                %min

      (%i9) g;
      (%o9)                             (100) (cg)

      (%i10) centigram*inch/minutes^2;
                                          %in cg
      (%o10)                              ------
                                              2
                                          %min

  単位の設定は実に柔軟性があります。 例えば、もしキログラム、メータ、秒に、それらの次元のデフォルトとして戻りたいなら、 以下のようにできます:

      (%i11) setunits([kg,m,s]);
      (%o11)                               done

      (%i12) centigram*inch/minutes^2;
                                        127        kg m
      (%o12)                      (-------------) (----)
                                   1800000000000     2
                                                    s

  組立単位もこのコマンドで扱います:

      (%i17) setunits(N);
      (%o17)                               done

      (%i18) N;
      (%o18)                                 N

      (%i19) dyn;
                                          1
      (%o19)                           (------) (N)
                                        100000

      (%i20) kg*m/s^2;
      (%o20)                                 N

      (%i21) centigram*inch/minutes^2;
                                          127
      (%o21)                        (-------------) (N)
                                     1800000000000

  Notice that the unitパッケージは 質量、長さ、力として二乗された逆時間の非MKS組み合わせを認識し、 それをNewtonのものに変換したことに注目してください。 これは一般にMaximaがどのように働くかを示します。 例えば、もしNewtonのものよりダインを好むなら、 単に以下をします:

      (%i22) setunits(dyn);
      (%o22)                               done

      (%i23) kg*m/s^2;
      (%o23)                          (100000) (dyn)

      (%i24) centigram*inch/minutes^2;
                                        127
      (%o24)                         (--------) (dyn)
                                      18000000

  任意の力に整理することを中断するには、 uforgetコマンドを使います:

      (%i26) uforget(dyn);
      (%o26)                               false

      (%i27) kg*m/s^2;
                                           kg m
      (%o27)                               ----
                                             2
                                            s

      (%i28) centigram*inch/minutes^2;
                                        127        kg m
      (%o28)                      (-------------) (----)
                                   1800000000000     2
                                                    s

  これは、 `uforget(N)`か `uforget(%force)`を使って 同じようにうまく働きました。

  `uforget`も参照してください。 この関数を使うには、最初に `load("unit")`を書いてください。

  Package unit ·

関数: uforget (list)

  デフォルトでは、 unitパッケージは 、NKS単位を使って、単位すべてを7つの基本次元に変換します。 この振る舞いは `setunits`コマンドを使って変えることができます。 その後、ユーザーは、 `uforget`コマンドを使って， 特定の次元に関してデフォルトの振る舞いに戻すことができます:

      (%i13) setunits([centigram,inch,minute]);
      (%o13)                               done

      (%i14) centigram*inch/minutes^2;
                                          %in cg
      (%o14)                              ------
                                              2
                                          %min

      (%i15) uforget([cg,%in,%min]);
      (%o15)                      [false, false, false]

      (%i16) centigram*inch/minutes^2;
                                        127        kg m
      (%o16)                      (-------------) (----)
                                   1800000000000     2
                                                    s

  `uforget`は単位ではなく次元上で働きます。 だから、特定の次元の任意の単位は機能します。 次元それ自身も合法な引数です。

  `setunits`も参照してください。 この関数を使うには、最初に `load("unit")`を書いてください。

  Package unit ·

関数: convert (expr, list)

  グローバル環境をリセットすることがやりすぎの時、 `convert`コマンドがあります。 これは1回変換を許します。 変換に使うのに、1つの引数か単位のリストを受け付けることができます。 変換演算がされた時、 望みの結果が再変換されるのを避けるために 正常なグローバル評価系は迂回されます。 結果として、 もしこの振る舞いを制御しているグローバル環境(`ratprint`)が真なら、 不正確な計算に対して、"rat"警告が見られるでしょう。 これは グローバル変換の精度の抜き取り検査に 役に立ちます。 別の特長は たとえグローバル環境が組立次元に整理するように設定されても `convert`はユーザーに基本次元変換することを許すことです。

      (%i2) kg*m/s^2;
                                           kg m
      (%o2)                                ----
                                             2
                                            s

      (%i3) convert(kg*m/s^2,[g,km,s]);
                                           g km
      (%o3)                                ----
                                             2
                                            s

      (%i4) convert(kg*m/s^2,[g,inch,minute]);

      `rat' replaced 39.37007874015748 by 5000/127 = 39.37007874015748
                                    18000000000   %in g
      (%o4)                        (-----------) (-----)
                                        127           2
                                                  %min

      (%i5) convert(kg*m/s^2,[N]);
      (%o5)                                  N

      (%i6) convert(kg*m^2/s^2,[N]);
      (%o6)                                 m N

      (%i7) setunits([N,J]);
      (%o7)                                done

      (%i8) convert(kg*m^2/s^2,[N]);
      (%o8)                                 m N

      (%i9) convert(kg*m^2/s^2,[N,inch]);

      `rat' replaced 39.37007874015748 by 5000/127 = 39.37007874015748
                                       5000
      (%o9)                           (----) (%in N)
                                       127

      (%i10) convert(kg*m^2/s^2,[J]);
      (%o10)                                 J

      (%i11) kg*m^2/s^2;
      (%o11)                                 J

      (%i12) setunits([g,inch,s]);
      (%o12)                               done

      (%i13) kg*m/s^2;
      (%o13)                                 N

      (%i14) uforget(N);
      (%o14)                               false

      (%i15) kg*m/s^2;
                                      5000000   %in g
      (%o15)                         (-------) (-----)
                                        127       2
                                                 s

      (%i16) convert(kg*m/s^2,[g,inch,s]);

      `rat' replaced 39.37007874015748 by 5000/127 = 39.37007874015748
                                      5000000   %in g
      (%o16)                         (-------) (-----)
                                        127       2
                                                 s

  See also `setunits`と `uforget`も参照してください。 この関数を使うには、最初に `load("unit")`を書いてください。

  Package unit ·

オプション変数: usersetunits

  デフォルト値: none

  もしユーザーが 記述されたものよりもデフォルト単位の振る舞いを持ちたいなら、 それらは maxima-init.macと usersetunits変数を利用することができます。 unitパッケージは この変数がリストに割り当てられているかを見るためにスタートアップ時にチェックします。 もし割り当てられているなら、そのリスト上でsetunitsを使い、 そのリストからの単位をデフォルトに取ります。 `uforget`は 自身のデフォルト上にusersetunitsで定義された振る舞いに戻します。 例えば、 もし 以下を含むmaxima-init.macファイルを持っているなら:

      usersetunits : [N,J];

  we would see the following behavior:

      (%i1) load("unit")$
      *******************************************************************
      *                       Units version 0.50                        *
      *          Definitions based on the NIST Reference on             *
      *              Constants, Units, and Uncertainty                  *
      *       Conversion factors from various sources including         *
      *                   NIST and the GNU units package                *
      *******************************************************************

      Redefining necessary functions...
      WARNING: DEFUN/DEFMACRO: redefining function
       TOPLEVEL-MACSYMA-EVAL ...
      WARNING: DEFUN/DEFMACRO: redefining function MSETCHK ...
      WARNING: DEFUN/DEFMACRO: redefining function KILL1 ...
      WARNING: DEFUN/DEFMACRO: redefining function NFORMAT ...
      Initializing unit arrays...
      Done.
      User defaults found...
      User defaults initialized.

      (%i2) kg*m/s^2;
      (%o2)                                  N

      (%i3) kg*m^2/s^2;
      (%o3)                                  J

      (%i4) kg*m^3/s^2;
      (%o4)                                 J m

      (%i5) kg*m*km/s^2;
      (%o5)                             (1000) (J)

      (%i6) setunits([dyn,eV]);
      (%o6)                                done

      (%i7) kg*m/s^2;
      (%o7)                           (100000) (dyn)

      (%i8) kg*m^2/s^2;
      (%o8)                     (6241509596477042688) (eV)

      (%i9) kg*m^3/s^2;
      (%o9)                    (6241509596477042688) (eV m)

      (%i10) kg*m*km/s^2;
      (%o10)                   (6241509596477042688000) (eV)

      (%i11) uforget([dyn,eV]);
      (%o11)                           [false, false]

      (%i12) kg*m/s^2;
      (%o12)                                 N

      (%i13) kg*m^2/s^2;
      (%o13)                                 J

      (%i14) kg*m^3/s^2;
      (%o14)                                J m

      (%i15) kg*m*km/s^2;
      (%o15)                            (1000) (J)

  `usersetunits`なしでは、 初期の入力はMKSに変換されたでしょうし、 uforgetはMKS規則への復帰をもたらしたでしょう。 なるほど、 ユーザーの好みは両方のケースで考慮されます。 もし望まれるなら、これらはまだオーバーライドされることができることに注目してください。 この整理を完全に消すには - すなわち、ユーザーデフォルトを出荷デフォルトに再設定するには - `dontusedimension`コマンドをつかうことができます。 `usedimension`が`uforget`を使用上自由にする時だけ `uforget`はユーザー設定を再び戻すことができますが、 代わりに、 `kill(usersetunits)`は ユーザーデフォルトの知識すべてをセッションから完全に削除します。 以下は これらの様々なオプションがいかに働くかを示すいくつかの例です。

      (%i2) kg*m/s^2;
      (%o2)                                  N

      (%i3) kg*m^2/s^2;
      (%o3)                                  J

      (%i4) setunits([dyn,eV]);
      (%o4)                                done

      (%i5) kg*m/s^2;
      (%o5)                           (100000) (dyn)

      (%i6) kg*m^2/s^2;
      (%o6)                     (6241509596477042688) (eV)

      (%i7) uforget([dyn,eV]);
      (%o7)                          [false, false]

      (%i8) kg*m/s^2;
      (%o8)                                  N

      (%i9) kg*m^2/s^2;
      (%o9)                                  J

      (%i10) dontusedimension(N);
      (%o10)                             [%force]

      (%i11) dontusedimension(J);
      (%o11)                         [%energy, %force]

      (%i12) kg*m/s^2;
                                           kg m
      (%o12)                               ----
                                             2
                                            s

      (%i13) kg*m^2/s^2;
                                               2
                                           kg m
      (%o13)                               -----
                                             2
                                            s

      (%i14) setunits([dyn,eV]);
      (%o14)                               done

      (%i15) kg*m/s^2;
                                           kg m
      (%o15)                               ----
                                             2
                                            s

      (%i16) kg*m^2/s^2;
                                               2
                                           kg m
      (%o16)                               -----
                                             2
                                            s

      (%i17) uforget([dyn,eV]);
      (%o17)                         [false, false]

      (%i18) kg*m/s^2;
                                           kg m
      (%o18)                               ----
                                             2
                                            s

      (%i19) kg*m^2/s^2;
                                               2
                                           kg m
      (%o19)                               -----
                                             2
                                            s

      (%i20) usedimension(N);
      Done.  To have Maxima simplify to this dimension, use
      setunits([unit]) to select a unit.
      (%o20)                               true

      (%i21) usedimension(J);
      Done.  To have Maxima simplify to this dimension, use
      setunits([unit]) to select a unit.
      (%o21)                               true

      (%i22) kg*m/s^2;
                                           kg m
      (%o22)                               ----
                                             2
                                            s

      (%i23) kg*m^2/s^2;
                                               2
                                           kg m
      (%o23)                               -----
                                             2
                                            s

      (%i24) setunits([dyn,eV]);
      (%o24)                               done

      (%i25) kg*m/s^2;
      (%o25)                          (100000) (dyn)

      (%i26) kg*m^2/s^2;
      (%o26)                    (6241509596477042688) (eV)

      (%i27) uforget([dyn,eV]);
      (%o27)                           [false, false]

      (%i28) kg*m/s^2;
      (%o28)                                 N

      (%i29) kg*m^2/s^2;
      (%o29)                                 J

      (%i30) kill(usersetunits);
      (%o30)                               done

      (%i31) uforget([dyn,eV]);
      (%o31)                          [false, false]

      (%i32) kg*m/s^2;
                                           kg m
      (%o32)                               ----
                                             2
                                            s

      (%i33) kg*m^2/s^2;
                                               2
                                           kg m
      (%o33)                               -----
                                             2
                                            s

  不運にも、 このオプションの広い多様性は 最初は少し混乱するものですが、 一旦、ユーザーがそれらを使うのに成長すれば、 それらがワーキング環境上でまさに完全な制御を持つことをユーザーは見いだすに違いありません。

  Package unit ·

関数: metricexpandall (x)

  望みの計量単位すべてを自動的に生成するグローバル単位リストを再構築します。 xは ユーザーがいくつの計量接頭子の定義を望むか指定するのに使われる数値引数です。 引数は、より低い数字の単位を定義するより高い数字それぞれを持つような 以下のようなものです:

                 0 - none. Only base units
                 1 - kilo, centi, milli
      (default)  2 - giga, mega, kilo, hecto, deka, deci, centi, milli,
                     micro, nano
                 3 - peta, tera, giga, mega, kilo, hecto, deka, deci,
                     centi, milli, micro, nano, pico, femto
                 4 - all

  通常は、Maximaは これは非常にたくさんの数の単位をもたらすので、完全な展開を定義しませんが、 多少なりとも完全な方法でリストを再構築するのに `metricexpandall`を使うことができます。 unit.macファイルの中の適切な変数は %unitexpandです。

  Package unit ·

変数: %unitexpand

  デフォルト値: `2`

  これは unitの初期ロードの最中に `metricexpandall`に供給される 値です。

  Package unit ·

Next: Function and Variable Index, Previous: unit, Up: Top [Contents][Index]

## 82 zeilberger

Next: Functions and Variables for zeilberger, Previous: zeilberger, Up: zeilberger [Contents][Index]

### 82.1 Introduction to zeilberger

`zeilberger`は 超幾何定総和に関するZeilbergerのアルゴリズムと 超幾何不定総和に関するGosperのアルゴリズムの実装します。

`zeilberger`は Axel Rieseによって開発された「フィルタリング」最適化法を利用します。

`zeilberger`はFabrizio Carusoによって開発されました。

`load ("zeilberger")`はこのパッケージをロードします。

Sums and products ·Share packages ·Package zeilberger ·

#### 82.1.1 The indefinite summation problem

`zeilberger`は 超幾何不定総和に関するGosperのアルゴリズムの実装します。 kの超幾何項F_kが与えられたとして、 超幾何反差(anti-difference)、すなわち、以下のような超幾何項f_k を見つけることを望みます。

F_k = f_(k+1) - f_k.

#### 82.1.2 The definite summation problem

`zeilberger`は 超幾何定総和に関するGosperのアルゴリズムの実装します。 適当な(nとkに関する)超幾何項 F_(n,k) と正の整数dが与えられたとして、 F_(n,k) に関する(nに関する)多項式係数を持つd次の線形漸化式と、 a_0 F_(n,k) + ... + a_d F_(n+d),k = Delta_k(R(n,k) F_(n,k)), のようなnとkに関する有理函数Rを見つけることを望みます。

ここで、 Delta_k は k-順方向差分演算子です。すなわち、 Delta_k(t_k) := t_(k+1) - t_k.

#### 82.1.3 Verbosity levels

以下の接尾辞の1つを追加することでコールされる出力が冗長なバージョンのコマンドもあります:

`Summary`

  終わりにサマリだけが表示されます。

`Verbose`

  中間ステップでのある情報。

`VeryVerbose`

  更なる情報。

`Extra`

  Zeilbergerのアルゴリズムでの線形系上の情報を含む更なる情報。

例えば:
`GosperVerbose`, `parGosperVeryVerbose`, `ZeilbergerExtra`, `AntiDifferenceSummary`.

Previous: Introduction to zeilberger, Up: zeilberger [Contents][Index]

### 82.2 Functions and Variables for zeilberger

関数: AntiDifference (F_k, k)

  もし存在すれば、F_kの超幾何反差を返します。
  そうでなければ、 `AntiDifference`は `no_hyp_antidifference`を返します。

  Package zeilberger ·

関数: Gosper (F_k, k)

  もし存在すれば、 F_kに対する有理証(rational certificate)、 すなわち、 以下のような有理函数を返します。 F_k = R(k+1) F_(k+1) - R(k) F_k, そうでなければ、 `Gosper`は `no_hyp_sol`を返します。

  Package zeilberger ·

関数: GosperSum (F_k, k, a, b)

  もし F_kが超幾何反差を持つなら、 k = aから k = bまでの F_kの和を返します。 そうでなければ、 `GosperSum`は `nongosper_summable`を返します。

  例:

      (%i1) load ("zeilberger")$

      (%i2) GosperSum ((-1)^k*k / (4*k^2 - 1), k, 1, n);
      Dependent equations eliminated:  (1)
                                 3       n + 1
                            (n + -) (- 1)
                                 2               1
      (%o2)               - ------------------ - -
                                        2        4
                            2 (4 (n + 1)  - 1)

      (%i3) GosperSum (1 / (4*k^2 - 1), k, 1, n);
                                      3
                                - n - -
                                      2       1
      (%o3)                  -------------- + -
                                      2       2
                             4 (n + 1)  - 1

      (%i4) GosperSum (x^k, k, 1, n);
                                n + 1
                               x          x
      (%o4)                    ------ - -----
                               x - 1    x - 1

      (%i5) GosperSum ((-1)^k*a! / (k!*(a - k)!), k, 1, n);
                                      n + 1
                      a! (n + 1) (- 1)              a!
      (%o5)       - ------------------------- - ----------
                    a (- n + a - 1)! (n + 1)!   a (a - 1)!

      (%i6) GosperSum (k*k!, k, 1, n);
      Dependent equations eliminated:  (1)
      (%o6)                     (n + 1)! - 1

      (%i7) GosperSum ((k + 1)*k! / (k + 1)!, k, 1, n);
                        (n + 1) (n + 2) (n + 1)!
      (%o7)             ------------------------ - 1
                                (n + 2)!

      (%i8) GosperSum (1 / ((a - k)!*k!), k, 1, n);
      (%o8)                  NON_GOSPER_SUMMABLE

  Package zeilberger ·

関数: parGosper (F_(n,k), k, n, d)

  F_(n,k)に対して次数dの漸化式を見つけようとします。

  アルゴリズムは解の列 [s_1, s_2, ..., s_m]をもたらします。 解それぞれは形式

  [R(n, k), [a_0, a_1, ..., a_d]].

  を持ちます。

  もし漸化式を見つけられないなら、 `parGosper`は `[]`を返します。

  Package zeilberger ·

関数: Zeilberger (F_(n,k), k, n)

  F_(n,k)の超幾何不定総和を計算しようとします。

  `Zeilberger`は最初に `Gosper`を呼び出し、 もしそれが解を見つけるのに失敗したら、 次数 1, 2, 3, ..., から `MAX_ORD`までを使って `parGosper`を呼び出します。 もしZeilbergerが `MAX_ORD`に達する前に 停止して、解を返します。

  アルゴリズムは解の列 [s_1, s_2, ..., s_m]をもたらします。 解それぞれは形式

  [R(n,k), [a_0, a_1, ..., a_d]].

  を持ちます。

  もし解を見つけられなかったら、 `Zeilberger`は `[]`を返します。

  `Zeilberger`は `Gosper_in_Zeilberger`が `true`の時だけ `Gosper`を呼び出します。

  Package zeilberger ·

### 82.3 General global variables

グローバル変数: MAX_ORD

  デフォルト値: 5

  `MAX_ORD`は `Zeilberger`が試みる漸化式の最大次数です。

  Package zeilberger ·

グローバル変数: simplified_output

  デフォルト値: `false`

  `simplified_output`が `true`の時、 `zeilberger`パッケージの関数は 解の更なる整理を試みます。

  Package zeilberger ·

グローバル変数: linear_solver

  デフォルト値: `linsolve`

  `linear_solver`は Zeilbergerのアルゴリズムで方程式系を解くのに使うソルバを指定します。

  Package zeilberger ·

グローバル変数: warnings

  デフォルト値: `true`

  `warnings`が `true`の時、 `zeilberger`パッケージの関数は 実行中に警告メッッセージを印字します。

  Package zeilberger ·

グローバル変数: Gosper_in_Zeilberger

  デフォルト値: `true`

  `Gosper_in_Zeilberger`が `true`の時、 `Zeilberger`関数は `parGosper`をコールする前に `Gosper`をコールします。 そうでないなら、 `Zeilberger`はすぐに `parGosper`に向かいます。

  Package zeilberger ·

グローバル変数: trivial_solutions

  デフォルト値: `true`

  `trivial_solutions`が `true`の時、 `Zeilberger`は 零に等しい証を持つ解か、 すべての係数が零に等しい解 を返します。

  Package zeilberger ·

### 82.4 Variables related to the modular test

グローバル変数: mod_test

  デフォルト値: `false`

  `mod_test`が `true`の時、 `parGosper`は 解を持たない系を除くためにモジュラーテストを実行します。

  Package zeilberger ·

グローバル変数: modular_linear_solver

  デフォルト値: `linsolve`

  `modular_linear_solver`は `parGosper`でのモジュラーテストが使う線形ソルバを指定します。

  Package zeilberger ·

グローバル変数: ev_point

  デフォルト値: `big_primes[10]`

  `parGosper`でモジュラーテストを実行する時 `ev_point`で変数 nが評価されます。

  Package zeilberger ·

グローバル変数: mod_big_prime

  デフォルト値: `big_primes[1]`

  `mod_big_prime`は `parGosper`でモジュラーテストが使う法です。

  Package zeilberger ·

グローバル変数: mod_threshold

  デフォルト値: 4

  `mod_threshold`は `parGosper`でのモジュラーテストが試みられる際の最大次数です。

  Package zeilberger ·

Next: Translator's Comments, Previous: zeilberger, Up: Top [Contents][Index]

## 83 Indices

Jump to: | ! # % ' * + - . / : < = > ? @ [ ] ^ _ ` | ~ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

| Index Entry |  | Section
! |  |
| `!`: |  | Combinatorial Functions
| `!!`: |  | Combinatorial Functions
# |  |
| `#`: |  | Operators for Equations
% |  |
| %: |  | Functions and Variables for Command Line
| %%: |  | Functions and Variables for Command Line
| `%and`: |  | Functions and Variables for to_poly_solve
| %c: |  | Functions and Variables for contrib_ode
| %e: |  | Functions and Variables for Constants
| %edispflag: |  | Functions and Variables for Display
| %emode: |  | Root Exponential and Logarithmic Functions
| %enumer: |  | Root Exponential and Logarithmic Functions
| %e_to_numlog: |  | Root Exponential and Logarithmic Functions
| `%f`: |  | Hypergeometric Functions
| %gamma: |  | Functions and Variables for Constants
| %i: |  | Functions and Variables for Constants
| %iargs: |  | Functions and Variables for Trigonometric
| `%if`: |  | Functions and Variables for to_poly_solve
| %k1: |  | Functions and Variables for contrib_ode
| %k2: |  | Functions and Variables for contrib_ode
| `%m`: |  | Hypergeometric Functions
| `%or`: |  | Functions and Variables for to_poly_solve
| %phi: |  | Functions and Variables for Constants
| %pi: |  | Functions and Variables for Constants
| %piargs: |  | Functions and Variables for Trigonometric
| %rnum_list: |  | Functions and Variables for Equations
| `%s`: |  | Bessel Functions
| `%th`: |  | Functions and Variables for Command Line
| %unitexpand: |  | Functions and Variables for Units
| `%w`: |  | Hypergeometric Functions
' |  |
| `'`: |  | Functions and Variables for Evaluation
| `''`: |  | Functions and Variables for Evaluation
* |  |
| `*`: |  | Arithmetic operators
| `**`: |  | Arithmetic operators
+ |  |
| `+`: |  | Arithmetic operators
- |  |
| `-`: |  | Arithmetic operators
. |  |
| `.`: |  | Arithmetic operators
/ |  |
| `/`: |  | Arithmetic operators
: |  |
| `:`: |  | Assignment operators
| `::`: |  | Assignment operators
| `::=`: |  | Assignment operators
| `:=`: |  | Assignment operators
< |  |
| `<`: |  | Relational operators
| `<=`: |  | Relational operators
= |  |
| `=`: |  | Operators for Equations
> |  |
| `>`: |  | Relational operators
| `>=`: |  | Relational operators
? |  |
| `?`: |  | Functions and Variables for Command Line
| `??`: |  | Functions and Variables for Command Line
@ |  |
| `@`: |  | Functions and Variables for Structures
[ |  |
| [: |  | Functions and Variables for Lists
] |  |
| ]: |  | Functions and Variables for Lists
^ |  |
| `^`: |  | Arithmetic operators
| `^^`: |  | Arithmetic operators
_ |  |
| _: |  | Functions and Variables for Command Line
| __: |  | Functions and Variables for Command Line
` |  |
| ```: |  | Functions and Variables for ezunits
| ```: |  | Functions and Variables for ezunits
| |: |  | Functions and Variables for itensor
~ |  |
| ~: |  | Functions and Variables for itensor
A |  |
| `abasep`: |  | Functions and Variables for atensor
| `abs`: |  | Functions for Numbers
| absboxchar: |  | Functions and Variables for Display
| `absint`: |  | Functions and Variables for Fourier series
| `absint`: |  | Functions and Variables for Fourier series
| `absint`: |  | Functions and Variables for Fourier series
| `absolute_real_time`: |  | Functions and Variables for Runtime Environment
| `acos`: |  | Functions and Variables for Trigonometric
| `acosh`: |  | Functions and Variables for Trigonometric
| `acot`: |  | Functions and Variables for Trigonometric
| `acoth`: |  | Functions and Variables for Trigonometric
| `acsc`: |  | Functions and Variables for Trigonometric
| `acsch`: |  | Functions and Variables for Trigonometric
| `activate`: |  | Functions and Variables for Facts
| activecontexts: |  | Functions and Variables for Facts
| adapt_depth: |  | Plotting Options
| adapt_depth: |  | Functions and Variables for draw
| `addcol`: |  | Functions and Variables for Matrices and Linear Algebra
| additive: |  | Functions and Variables for Simplification
| `addmatrices`: |  | Functions and Variables for linearalgebra
| `addrow`: |  | Functions and Variables for Matrices and Linear Algebra
| `add_edge`: |  | Functions and Variables for graphs
| `add_edges`: |  | Functions and Variables for graphs
| `add_vertex`: |  | Functions and Variables for graphs
| `add_vertices`: |  | Functions and Variables for graphs
| adim: |  | Functions and Variables for atensor
| `adjacency_matrix`: |  | Functions and Variables for graphs
| `adjoin`: |  | Functions and Variables for Sets
| `adjoint`: |  | Functions and Variables for Matrices and Linear Algebra
| `af`: |  | Functions and Variables for atensor
| aform: |  | Functions and Variables for atensor
| `agd`: |  | Package functs
| `airy_ai`: |  | Airy Functions
| `airy_bi`: |  | Airy Functions
| `airy_dai`: |  | Airy Functions
| `airy_dbi`: |  | Airy Functions
| algebraic: |  | Functions and Variables for Polynomials
| algepsilon: |  | Functions and Variables for Equations
| algexact: |  | Functions and Variables for Equations
| `algsys`: |  | Functions and Variables for Equations
| `algsys`: |  | Functions and Variables for Equations
| `alias`: |  | Functions and Variables for Expressions
| `alias`: |  | Functions and Variables for Evaluation
| aliases: |  | Functions and Variables for Expressions
| allbut: |  | Functions and Variables for Expressions
| `allroots`: |  | Functions and Variables for Equations
| `allroots`: |  | Functions and Variables for Equations
| allsym: |  | Functions and Variables for itensor
| all_dotsimp_denoms: |  | Functions and Variables for Affine
| alphabetic: |  | Functions and Variables for Miscellaneous Options
| `alphacharp`: |  | Functions and Variables for characters
| `alphanumericp`: |  | Functions and Variables for characters
| `amortization`: |  | Functions and Variables for finance
| `and`: |  | Logical operators
| `annuity_fv`: |  | Functions and Variables for finance
| `annuity_pv`: |  | Functions and Variables for finance
| `antid`: |  | Functions and Variables for Differentiation
| `antidiff`: |  | Functions and Variables for Differentiation
| `AntiDifference`: |  | Functions and Variables for zeilberger
| antisymmetric: |  | Functions and Variables for Simplification
| `append`: |  | Functions and Variables for Lists
| `appendfile`: |  | Functions and Variables for File Input and Output
| `apply`: |  | Functions and Variables for Function Definition
| `apply1`: |  | Functions and Variables for Rules and Patterns
| `apply2`: |  | Functions and Variables for Rules and Patterns
| `applyb1`: |  | Functions and Variables for Rules and Patterns
| `apropos`: |  | Functions and Variables for Help
| `args`: |  | Functions and Variables for Expressions
| `arithmetic`: |  | Package functs
| `arithsum`: |  | Package functs
| `arit_amortization`: |  | Functions and Variables for finance
| `array`: |  | Functions and Variables for Arrays
| `array`: |  | Functions and Variables for Arrays
| `array`: |  | Functions and Variables for Arrays
| `arrayapply`: |  | Functions and Variables for Arrays
| `arrayinfo`: |  | Functions and Variables for Arrays
| `arraymake`: |  | Functions and Variables for Arrays
| arrays: |  | Functions and Variables for Arrays
| `ascii`: |  | Functions and Variables for characters
| `asec`: |  | Functions and Variables for Trigonometric
| `asech`: |  | Functions and Variables for Trigonometric
| `asin`: |  | Functions and Variables for Trigonometric
| `asinh`: |  | Functions and Variables for Trigonometric
| askexp: |  | Functions and Variables for Facts
| `askinteger`: |  | Functions and Variables for Facts
| `askinteger`: |  | Functions and Variables for Facts
| `askinteger`: |  | Functions and Variables for Facts
| `askinteger`: |  | Functions and Variables for Facts
| `asksign`: |  | Functions and Variables for Facts
| `assoc`: |  | Functions and Variables for Lists
| `assoc`: |  | Functions and Variables for Lists
| `assoc_legendre_p`: |  | Functions and Variables for orthogonal polynomials
| `assoc_legendre_q`: |  | Functions and Variables for orthogonal polynomials
| `assume`: |  | Functions and Variables for Facts
| assumescalar: |  | Functions and Variables for Facts
| `assume_external_byte_order`: |  | Functions and Variables for binary input and output
| assume_pos: |  | Functions and Variables for Facts
| assume_pos_pred: |  | Functions and Variables for Facts
| asymbol: |  | Functions and Variables for atensor
| `asympa`: |  | Introduction to asympa
| `at`: |  | Functions and Variables for Differentiation
| `at`: |  | Functions and Variables for Differentiation
| `atan`: |  | Functions and Variables for Trigonometric
| `atan2`: |  | Functions and Variables for Trigonometric
| `atanh`: |  | Functions and Variables for Trigonometric
| `atensimp`: |  | Functions and Variables for atensor
| `atom`: |  | Functions and Variables for Expressions
| atomgrad: |  | Functions and Variables for Differentiation
| atrig1: |  | Functions and Variables for Trigonometric
| `atvalue`: |  | Functions and Variables for Differentiation
| `atvalue`: |  | Functions and Variables for Differentiation
| `augcoefmatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `augmented_lagrangian_method`: |  | Functions and Variables for augmented_lagrangian
| `augmented_lagrangian_method`: |  | Functions and Variables for augmented_lagrangian
| `augmented_lagrangian_method`: |  | Functions and Variables for augmented_lagrangian
| `augmented_lagrangian_method`: |  | Functions and Variables for augmented_lagrangian
| `av`: |  | Functions and Variables for atensor
| `average_degree`: |  | Functions and Variables for graphs
| axes: |  | Plotting Options
| axis_3d: |  | Functions and Variables for draw
| axis_bottom: |  | Functions and Variables for draw
| axis_left: |  | Functions and Variables for draw
| axis_right: |  | Functions and Variables for draw
| axis_top: |  | Functions and Variables for draw
| azimuth: |  | Plotting Options
B |  |
| background_color: |  | Functions and Variables for draw
| backsubst: |  | Functions and Variables for Equations
| `backtrace`: |  | Functions and Variables for Program Flow
| `backtrace`: |  | Functions and Variables for Program Flow
| `bars`: |  | Functions and Variables for draw
| `barsplot`: |  | Functions and Variables for statistical graphs
| `barsplot_description`: |  | Functions and Variables for statistical graphs
| `bashindices`: |  | Sums and Products
| `batch`: |  | Functions and Variables for File Input and Output
| `batch`: |  | Functions and Variables for File Input and Output
| `batchload`: |  | Functions and Variables for File Input and Output
| `bc2`: |  | Functions and Variables for Differential Equations
| `bdvac`: |  | Functions and Variables for ctensor
| `belln`: |  | Functions and Variables for Sets
| `benefit_cost`: |  | Functions and Variables for finance
| berlefact: |  | Functions and Variables for Polynomials
| `bern`: |  | Functions and Variables for Number Theory
| `bernpoly`: |  | Functions and Variables for Number Theory
| `bernstein_approx`: |  | Functions and Variables for Bernstein
| `bernstein_expand`: |  | Functions and Variables for Bernstein
| bernstein_explicit: |  | Functions and Variables for Bernstein
| `bernstein_poly`: |  | Functions and Variables for Bernstein
| besselexpand: |  | Bessel Functions
| `bessel_i`: |  | Bessel Functions
| `bessel_j`: |  | Bessel Functions
| `bessel_k`: |  | Bessel Functions
| `bessel_y`: |  | Bessel Functions
| `beta`: |  | Gamma and factorial Functions
| beta_args_sum_to_integer: |  | Gamma and factorial Functions
| beta_expand: |  | Gamma and factorial Functions
| `beta_incomplete`: |  | Gamma and factorial Functions
| `beta_incomplete_generalized`: |  | Gamma and factorial Functions
| `beta_incomplete_regularized`: |  | Gamma and factorial Functions
| `bezout`: |  | Functions and Variables for Polynomials
| `bfallroots`: |  | Functions and Variables for Equations
| `bfallroots`: |  | Functions and Variables for Equations
| `bffac`: |  | Gamma and factorial Functions
| `bfhzeta`: |  | Functions and Variables for Number Theory
| `bfloat`: |  | Functions and Variables for Numbers
| `bfloatp`: |  | Functions and Variables for Numbers
| `bfpsi`: |  | Gamma and factorial Functions
| `bfpsi0`: |  | Gamma and factorial Functions
| bftorat: |  | Functions and Variables for Numbers
| bftrunc: |  | Functions and Variables for Numbers
| `bfzeta`: |  | Functions and Variables for Number Theory
| `bf_find_root`: |  | Functions and Variables for fast Fourier transform
| `bf_find_root`: |  | Functions and Variables for fast Fourier transform
| `bf_fmin_cobyla`: |  | Functions and Variables for cobyla
| `bf_fmin_cobyla`: |  | Functions and Variables for cobyla
| `biconnected_components`: |  | Functions and Variables for graphs
| `bimetric`: |  | Functions and Variables for ctensor
| `binomial`: |  | Combinatorial Functions
| `bipartition`: |  | Functions and Variables for graphs
| `block`: |  | Functions and Variables for Function Definition
| `block`: |  | Functions and Variables for Function Definition
| `blockmatrixp`: |  | Functions and Variables for linearalgebra
| `bode_gain`: |  | Functions and Variables for bode
| `bode_phase`: |  | Functions and Variables for bode
| border: |  | Functions and Variables for draw
| `bothcoef`: |  | Functions and Variables for Polynomials
| boundaries_array: |  | Functions and Variables for worldmap
| `box`: |  | Functions and Variables for Expressions
| `box`: |  | Functions and Variables for Expressions
| box: |  | Plotting Options
| boxchar: |  | Functions and Variables for Expressions
| `boxplot`: |  | Functions and Variables for statistical graphs
| `boxplot`: |  | Functions and Variables for statistical graphs
| `boxplot_description`: |  | Functions and Variables for statistical graphs
| `break`: |  | Functions and Variables for Function Definition
| breakup: |  | Functions and Variables for Equations
| `bug_report`: |  | Functions and Variables for Bug Detection and Reporting
| `buildq`: |  | Macros
| `build_info`: |  | Functions and Variables for Bug Detection and Reporting
| `burn`: |  | Functions and Variables for Number Theory
C |  |
| `cabs`: |  | Functions for Complex Numbers
| `canform`: |  | Functions and Variables for itensor
| `canform`: |  | Functions and Variables for itensor
| `canten`: |  | Functions and Variables for itensor
| `cardinality`: |  | Functions and Variables for Sets
| `carg`: |  | Functions for Complex Numbers
| `cartan`: |  | Functions and Variables for Differentiation
| `cartesian_product`: |  | Functions and Variables for Sets
| `catch`: |  | Functions and Variables for Function Definition
| cauchysum: |  | Functions and Variables for Series
| `cauchy_matrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `cauchy_matrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `cbffac`: |  | Gamma and factorial Functions
| cbrange: |  | Functions and Variables for draw
| cbtics: |  | Functions and Variables for draw
| `cdf_bernoulli`: |  | Functions and Variables for discrete distributions
| `cdf_beta`: |  | Functions and Variables for continuous distributions
| `cdf_binomial`: |  | Functions and Variables for discrete distributions
| `cdf_cauchy`: |  | Functions and Variables for continuous distributions
| `cdf_chi2`: |  | Functions and Variables for continuous distributions
| `cdf_continuous_uniform`: |  | Functions and Variables for continuous distributions
| `cdf_discrete_uniform`: |  | Functions and Variables for discrete distributions
| `cdf_exp`: |  | Functions and Variables for continuous distributions
| `cdf_f`: |  | Functions and Variables for continuous distributions
| `cdf_gamma`: |  | Functions and Variables for continuous distributions
| `cdf_general_finite_discrete`: |  | Functions and Variables for discrete distributions
| `cdf_geometric`: |  | Functions and Variables for discrete distributions
| `cdf_gumbel`: |  | Functions and Variables for continuous distributions
| `cdf_hypergeometric`: |  | Functions and Variables for discrete distributions
| `cdf_laplace`: |  | Functions and Variables for continuous distributions
| `cdf_logistic`: |  | Functions and Variables for continuous distributions
| `cdf_lognormal`: |  | Functions and Variables for continuous distributions
| `cdf_negative_binomial`: |  | Functions and Variables for discrete distributions
| `cdf_noncentral_chi2`: |  | Functions and Variables for continuous distributions
| `cdf_noncentral_student_t`: |  | Functions and Variables for continuous distributions
| `cdf_normal`: |  | Functions and Variables for continuous distributions
| `cdf_pareto`: |  | Functions and Variables for continuous distributions
| `cdf_poisson`: |  | Functions and Variables for discrete distributions
| `cdf_rank_sum`: |  | Functions and Variables for special distributions
| `cdf_rayleigh`: |  | Functions and Variables for continuous distributions
| `cdf_signed_rank`: |  | Functions and Variables for special distributions
| `cdf_student_t`: |  | Functions and Variables for continuous distributions
| `cdf_weibull`: |  | Functions and Variables for continuous distributions
| `cdisplay`: |  | Functions and Variables for ctensor
| `ceiling`: |  | Functions for Numbers
| `central_moment`: |  | Functions and Variables for descriptive statistics
| `central_moment`: |  | Functions and Variables for descriptive statistics
| `cequal`: |  | Functions and Variables for characters
| `cequalignore`: |  | Functions and Variables for characters
| `cf`: |  | Functions and Variables for Number Theory
| `cfdisrep`: |  | Functions and Variables for Number Theory
| `cfexpand`: |  | Functions and Variables for Number Theory
| cflength: |  | Functions and Variables for Number Theory
| cframe_flag: |  | Functions and Variables for ctensor
| `cgeodesic`: |  | Functions and Variables for ctensor
| `cgreaterp`: |  | Functions and Variables for characters
| `cgreaterpignore`: |  | Functions and Variables for characters
| `changename`: |  | Functions and Variables for itensor
| `changevar`: |  | Functions and Variables for Integration
| `chaosgame`: |  | Functions and Variables for dynamics
| `charat`: |  | Functions and Variables for strings
| `charfun`: |  | Functions and Variables for Predicates
| `charfun2`: |  | Functions and Variables for interpol
| `charlist`: |  | Functions and Variables for strings
| `charp`: |  | Functions and Variables for characters
| `charpoly`: |  | Functions and Variables for Matrices and Linear Algebra
| `chebyshev_t`: |  | Functions and Variables for orthogonal polynomials
| `chebyshev_u`: |  | Functions and Variables for orthogonal polynomials
| `checkdiv`: |  | Functions and Variables for ctensor
| `check_overlaps`: |  | Functions and Variables for Affine
| `cholesky`: |  | Functions and Variables for linearalgebra
| `cholesky`: |  | Functions and Variables for linearalgebra
| `christof`: |  | Functions and Variables for ctensor
| `chromatic_index`: |  | Functions and Variables for graphs
| `chromatic_number`: |  | Functions and Variables for graphs
| `cint`: |  | Functions and Variables for characters
| `circulant_graph`: |  | Functions and Variables for graphs
| `clear_edge_weight`: |  | Functions and Variables for graphs
| `clear_rules`: |  | Functions and Variables for Rules and Patterns
| `clear_vertex_label`: |  | Functions and Variables for graphs
| `clebsch_graph`: |  | Functions and Variables for graphs
| `clessp`: |  | Functions and Variables for characters
| `clesspignore`: |  | Functions and Variables for characters
| `close`: |  | Functions and Variables for input and output
| `closefile`: |  | Functions and Variables for File Input and Output
| `cmetric`: |  | Functions and Variables for ctensor
| `cmetric`: |  | Functions and Variables for ctensor
| cnonmet_flag: |  | Functions and Variables for ctensor
| `coeff`: |  | Functions and Variables for Polynomials
| `coeff`: |  | Functions and Variables for Polynomials
| `coefmatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `cograd`: |  | Functions and Variables for ctensor
| `col`: |  | Functions and Variables for Matrices and Linear Algebra
| `collapse`: |  | Functions and Variables for Expressions
| `collectterms`: |  | Package facexp
| color: |  | Plotting Options
| color: |  | Functions and Variables for draw
| colorbox: |  | Plotting Options
| colorbox: |  | Functions and Variables for draw
| `columnop`: |  | Functions and Variables for linearalgebra
| columns: |  | Functions and Variables for draw
| `columnspace`: |  | Functions and Variables for linearalgebra
| `columnswap`: |  | Functions and Variables for linearalgebra
| `columnvector`: |  | Functions and Variables for Matrices and Linear Algebra
| `combination`: |  | Package functs
| `combine`: |  | Functions and Variables for Simplification
| commutative: |  | Functions and Variables for Simplification
| `comp2pui`: |  | Functions and Variables for Symmetries
| `compare`: |  | Functions and Variables for Predicates
| `compfile`: |  | Functions and Variables for Function Definition
| `compfile`: |  | Functions and Variables for Function Definition
| `compfile`: |  | Functions and Variables for Function Definition
| `compile`: |  | Functions and Variables for Function Definition
| `compile`: |  | Functions and Variables for Function Definition
| `compile`: |  | Functions and Variables for Function Definition
| `compile_file`: |  | Functions and Variables for Function Definition
| `compile_file`: |  | Functions and Variables for Function Definition
| `compile_file`: |  | Functions and Variables for Function Definition
| `complement_graph`: |  | Functions and Variables for graphs
| `complete_bipartite_graph`: |  | Functions and Variables for graphs
| `complete_graph`: |  | Functions and Variables for graphs
| `complex_number_p`: |  | Functions and Variables for to_poly_solve
| `components`: |  | Functions and Variables for itensor
| `compose_functions`: |  | Functions and Variables for to_poly_solve
| `concan`: |  | Functions and Variables for itensor
| `concat`: |  | Functions and Variables for Strings
| `conjugate`: |  | Functions for Complex Numbers
| `conmetderiv`: |  | Functions and Variables for itensor
| `connected_components`: |  | Functions and Variables for graphs
| `connect_vertices`: |  | Functions and Variables for graphs
| `cons`: |  | Functions and Variables for Lists
| `constant`: |  | Functions and Variables for Predicates
| `constantp`: |  | Functions and Variables for Predicates
| `constituent`: |  | Functions and Variables for characters
| `constvalue`: |  | Functions and Variables for ezunits
| `cont2part`: |  | Functions and Variables for Symmetries
| `content`: |  | Functions and Variables for Polynomials
| context: |  | Functions and Variables for Facts
| contexts: |  | Functions and Variables for Facts
| `continuous_freq`: |  | Functions and Variables for data manipulation
| `continuous_freq`: |  | Functions and Variables for data manipulation
| `contortion`: |  | Functions and Variables for ctensor
| contour: |  | Functions and Variables for draw
| contour_levels: |  | Functions and Variables for draw
| `contour_plot`: |  | Functions and Variables for Plotting
| `contract`: |  | Functions and Variables for itensor
| `contract`: |  | Functions and Variables for Symmetries
| `contract_edge`: |  | Functions and Variables for graphs
| `contragrad`: |  | Functions and Variables for ctensor
| `contrib_ode`: |  | Functions and Variables for contrib_ode
| `convert`: |  | Functions and Variables for Units
| `coord`: |  | Functions and Variables for itensor
| `copy`: |  | Functions and Variables for linearalgebra
| `copylist`: |  | Functions and Variables for Lists
| `copymatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `copy_graph`: |  | Functions and Variables for graphs
| `cor`: |  | Functions and Variables for descriptive statistics
| `cor`: |  | Functions and Variables for descriptive statistics
| `cos`: |  | Functions and Variables for Trigonometric
| `cosh`: |  | Functions and Variables for Trigonometric
| cosnpiflag: |  | Functions and Variables for Fourier series
| `cot`: |  | Functions and Variables for Trigonometric
| `coth`: |  | Functions and Variables for Trigonometric
| `cov`: |  | Functions and Variables for descriptive statistics
| `cov1`: |  | Functions and Variables for descriptive statistics
| `covdiff`: |  | Functions and Variables for itensor
| `covect`: |  | Functions and Variables for Matrices and Linear Algebra
| `covers`: |  | Package functs
| `create_graph`: |  | Functions and Variables for graphs
| `create_graph`: |  | Functions and Variables for graphs
| `create_graph`: |  | Functions and Variables for graphs
| `create_list`: |  | Functions and Variables for Lists
| `csc`: |  | Functions and Variables for Trigonometric
| `csch`: |  | Functions and Variables for Trigonometric
| `csetup`: |  | Functions and Variables for ctensor
| `cspline`: |  | Functions and Variables for interpol
| `cspline`: |  | Functions and Variables for interpol
| `ctaylor`: |  | Functions and Variables for ctensor
| ctaypov: |  | Functions and Variables for ctensor
| ctaypt: |  | Functions and Variables for ctensor
| ctayswitch: |  | Functions and Variables for ctensor
| ctayvar: |  | Functions and Variables for ctensor
| ctorsion_flag: |  | Functions and Variables for ctensor
| `ctransform`: |  | Functions and Variables for ctensor
| `ctranspose`: |  | Functions and Variables for linearalgebra
| ctrgsimp: |  | Functions and Variables for ctensor
| ct_coords: |  | Functions and Variables for ctensor
| `ct_coordsys`: |  | Functions and Variables for ctensor
| `ct_coordsys`: |  | Functions and Variables for ctensor
| `cube_graph`: |  | Functions and Variables for graphs
| `cuboctahedron_graph`: |  | Functions and Variables for graphs
| `cunlisp`: |  | Functions and Variables for characters
| current_let_rule_package: |  | Functions and Variables for Rules and Patterns
| `cv`: |  | Functions and Variables for descriptive statistics
| `cv`: |  | Functions and Variables for descriptive statistics
| `cycle_digraph`: |  | Functions and Variables for graphs
| `cycle_graph`: |  | Functions and Variables for graphs
| `cylindrical`: |  | Functions and Variables for draw
D |  |
| data_file_name: |  | Functions and Variables for draw
| `days360`: |  | Functions and Variables for finance
| `dblint`: |  | Functions and Variables for Integration
| `deactivate`: |  | Functions and Variables for Facts
| debugmode: |  | Functions and Variables for Debugging
| `declare`: |  | Functions and Variables for Properties
| `declare_constvalue`: |  | Functions and Variables for ezunits
| `declare_dimensions`: |  | Functions and Variables for ezunits
| `declare_fundamental_dimensions`: |  | Functions and Variables for ezunits
| `declare_fundamental_units`: |  | Functions and Variables for ezunits
| `declare_qty`: |  | Functions and Variables for ezunits
| `declare_translated`: |  | Functions and Variables for Function Definition
| `declare_units`: |  | Functions and Variables for ezunits
| `declare_unit_conversion`: |  | Functions and Variables for ezunits
| `declare_weights`: |  | Functions and Variables for Affine
| `decsym`: |  | Functions and Variables for itensor
| default_let_rule_package: |  | Functions and Variables for Rules and Patterns
| `defcon`: |  | Functions and Variables for itensor
| `defcon`: |  | Functions and Variables for itensor
| `define`: |  | Functions and Variables for Function Definition
| `define`: |  | Functions and Variables for Function Definition
| `define`: |  | Functions and Variables for Function Definition
| `define`: |  | Functions and Variables for Function Definition
| `define`: |  | Functions and Variables for Function Definition
| `define_variable`: |  | Functions and Variables for Function Definition
| `defint`: |  | Functions and Variables for Integration
| `defmatch`: |  | Functions and Variables for Rules and Patterns
| `defmatch`: |  | Functions and Variables for Rules and Patterns
| `defrule`: |  | Functions and Variables for Rules and Patterns
| `defstruct`: |  | Functions and Variables for Structures
| `defstruct`: |  | Functions and Variables for Structures
| `deftaylor`: |  | Functions and Variables for Series
| `degree_sequence`: |  | Functions and Variables for graphs
| `del`: |  | Functions and Variables for Differentiation
| delay: |  | Functions and Variables for draw
| `delete`: |  | Functions and Variables for Lists
| `delete`: |  | Functions and Variables for Lists
| `deleten`: |  | Functions and Variables for ctensor
| `delta`: |  | Functions and Variables for Differentiation
| `demo`: |  | Functions and Variables for Help
| `demoivre`: |  | Functions and Variables for Simplification
| `demoivre`: |  | Functions and Variables for Simplification
| `denom`: |  | Functions and Variables for Polynomials
| dependencies: |  | Functions and Variables for Differentiation
| `depends`: |  | Functions and Variables for Differentiation
| derivabbrev: |  | Functions and Variables for Differentiation
| `derivdegree`: |  | Functions and Variables for Differentiation
| `derivlist`: |  | Functions and Variables for Differentiation
| derivsubst: |  | Functions and Variables for Differentiation
| `describe`: |  | Functions and Variables for Help
| `describe`: |  | Functions and Variables for Help
| `describe`: |  | Functions and Variables for Help
| `desolve`: |  | Functions and Variables for Differential Equations
| `desolve`: |  | Functions and Variables for Differential Equations
| `determinant`: |  | Functions and Variables for Matrices and Linear Algebra
| detout: |  | Functions and Variables for Matrices and Linear Algebra
| `dfloat`: |  | Functions and Variables for to_poly_solve
| `dgauss_a`: |  | Functions and Variables for contrib_ode
| `dgauss_b`: |  | Functions and Variables for contrib_ode
| `dgeev`: |  | Functions and Variables for lapack
| `dgeev`: |  | Functions and Variables for lapack
| `dgemm`: |  | Functions and Variables for lapack
| `dgemm`: |  | Functions and Variables for lapack
| `dgeqrf`: |  | Functions and Variables for lapack
| `dgesv`: |  | Functions and Variables for lapack
| `dgesvd`: |  | Functions and Variables for lapack
| `dgesvd`: |  | Functions and Variables for lapack
| `diag`: |  | Functions and Variables for diag
| `diagmatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `diagmatrixp`: |  | Functions and Variables for ctensor
| diagmetric: |  | Functions and Variables for ctensor
| `diag_matrix`: |  | Functions and Variables for linearalgebra
| `diameter`: |  | Functions and Variables for graphs
| diff: |  | Functions and Variables for Differentiation
| `diff`: |  | Functions and Variables for Differentiation
| `diff`: |  | Functions and Variables for Differentiation
| `diff`: |  | Functions and Variables for Differentiation
| `diff`: |  | Functions and Variables for Differentiation
| `diff`: |  | Functions and Variables for itensor
| `digitcharp`: |  | Functions and Variables for characters
| dim: |  | Functions and Variables for ctensor
| `dimacs_export`: |  | Functions and Variables for graphs
| `dimacs_export`: |  | Functions and Variables for graphs
| `dimacs_import`: |  | Functions and Variables for graphs
| `dimension`: |  | Functions and Variables for Equations
| `dimension`: |  | Functions and Variables for Equations
| `dimensionless`: |  | Functions and Variables for ezunits
| dimensions: |  | Functions and Variables for draw
| `dimensions`: |  | Functions and Variables for ezunits
| `dimensions_as_list`: |  | Functions and Variables for ezunits
| `direct`: |  | Functions and Variables for Symmetries
| `discrete_freq`: |  | Functions and Variables for data manipulation
| `disjoin`: |  | Functions and Variables for Sets
| `disjointp`: |  | Functions and Variables for Sets
| `disolate`: |  | Functions and Variables for Expressions
| `disp`: |  | Functions and Variables for Display
| `dispcon`: |  | Functions and Variables for itensor
| `dispcon`: |  | Functions and Variables for itensor
| dispflag: |  | Functions and Variables for Equations
| `dispform`: |  | Functions and Variables for Expressions
| `dispform`: |  | Functions and Variables for Expressions
| `dispfun`: |  | Functions and Variables for Function Definition
| `dispfun`: |  | Functions and Variables for Function Definition
| `dispJordan`: |  | Functions and Variables for diag
| `display`: |  | Functions and Variables for Display
| display2d: |  | Functions and Variables for Display
| display_format_internal: |  | Functions and Variables for Display
| `disprule`: |  | Functions and Variables for Rules and Patterns
| `disprule`: |  | Functions and Variables for Rules and Patterns
| `dispterms`: |  | Functions and Variables for Display
| `distrib`: |  | Functions and Variables for Simplification
| distribute_over: |  | Functions and Variables for Simplification
| `divide`: |  | Functions and Variables for Polynomials
| `divisors`: |  | Functions and Variables for Sets
| `divsum`: |  | Functions and Variables for Number Theory
| `divsum`: |  | Functions and Variables for Number Theory
| `dkummer_m`: |  | Functions and Variables for contrib_ode
| `dkummer_u`: |  | Functions and Variables for contrib_ode
| `dlange`: |  | Functions and Variables for lapack
| `do`: |  | Functions and Variables for Program Flow
| doallmxops: |  | Functions and Variables for Matrices and Linear Algebra
| `dodecahedron_graph`: |  | Functions and Variables for graphs
| domain: |  | Functions and Variables for Simplification
| domxexpt: |  | Functions and Variables for Matrices and Linear Algebra
| domxmxops: |  | Functions and Variables for Matrices and Linear Algebra
| domxnctimes: |  | Functions and Variables for Matrices and Linear Algebra
| dontfactor: |  | Functions and Variables for Matrices and Linear Algebra
| doscmxops: |  | Functions and Variables for Matrices and Linear Algebra
| doscmxplus: |  | Functions and Variables for Matrices and Linear Algebra
| dot0nscsimp: |  | Functions and Variables for Matrices and Linear Algebra
| dot0simp: |  | Functions and Variables for Matrices and Linear Algebra
| dot1simp: |  | Functions and Variables for Matrices and Linear Algebra
| dotassoc: |  | Functions and Variables for Matrices and Linear Algebra
| dotconstrules: |  | Functions and Variables for Matrices and Linear Algebra
| dotdistrib: |  | Functions and Variables for Matrices and Linear Algebra
| dotexptsimp: |  | Functions and Variables for Matrices and Linear Algebra
| dotident: |  | Functions and Variables for Matrices and Linear Algebra
| `dotproduct`: |  | Functions and Variables for linearalgebra
| dotscrules: |  | Functions and Variables for Matrices and Linear Algebra
| `dotsimp`: |  | Functions and Variables for Affine
| `dpart`: |  | Functions and Variables for Expressions
| `draw`: |  | Functions and Variables for draw
| `draw2d`: |  | Functions and Variables for draw
| `draw3d`: |  | Functions and Variables for draw
| `drawdf`: |  | Functions and Variables for drawdf
| `drawdf`: |  | Functions and Variables for drawdf
| `drawdf`: |  | Functions and Variables for drawdf
| `drawdf`: |  | Functions and Variables for drawdf
| `drawdf`: |  | Functions and Variables for drawdf
| `drawdf`: |  | Functions and Variables for drawdf
| `draw_file`: |  | Functions and Variables for draw
| `draw_graph`: |  | Functions and Variables for graphs
| `draw_graph`: |  | Functions and Variables for graphs
| draw_graph_program: |  | Functions and Variables for graphs
| `dscalar`: |  | Functions and Variables for Differentiation
| `dscalar`: |  | Functions and Variables for ctensor
E |  |
| `echelon`: |  | Functions and Variables for Matrices and Linear Algebra
| `edges`: |  | Functions and Variables for graphs
| edge_color: |  | Functions and Variables for graphs
| edge_coloring: |  | Functions and Variables for graphs
| `edge_coloring`: |  | Functions and Variables for graphs
| `edge_connectivity`: |  | Functions and Variables for graphs
| edge_partition: |  | Functions and Variables for graphs
| edge_type: |  | Functions and Variables for graphs
| edge_width: |  | Functions and Variables for graphs
| `eigens_by_jacobi`: |  | Functions and Variables for linearalgebra
| `eigens_by_jacobi`: |  | Functions and Variables for linearalgebra
| `eigenvalues`: |  | Functions and Variables for Matrices and Linear Algebra
| `eigenvectors`: |  | Functions and Variables for Matrices and Linear Algebra
| `eighth`: |  | Functions and Variables for Lists
| `einstein`: |  | Functions and Variables for ctensor
| `eivals`: |  | Functions and Variables for Matrices and Linear Algebra
| `eivects`: |  | Functions and Variables for Matrices and Linear Algebra
| `elapsed_real_time`: |  | Functions and Variables for Runtime Environment
| `elapsed_run_time`: |  | Functions and Variables for Runtime Environment
| `ele2comp`: |  | Functions and Variables for Symmetries
| `ele2polynome`: |  | Functions and Variables for Symmetries
| `ele2pui`: |  | Functions and Variables for Symmetries
| `elem`: |  | Functions and Variables for Symmetries
| `elementp`: |  | Functions and Variables for Sets
| elevation: |  | Plotting Options
| `elevation_grid`: |  | Functions and Variables for draw
| `elim`: |  | Functions and Variables for to_poly_solve
| `eliminate`: |  | Functions and Variables for Polynomials
| `eliminate_using`: |  | Functions and Variables for to_poly_solve
| `elim_allbut`: |  | Functions and Variables for to_poly_solve
| `ellipse`: |  | Functions and Variables for draw
| `elliptic_e`: |  | Functions and Variables for Elliptic Integrals
| `elliptic_ec`: |  | Functions and Variables for Elliptic Integrals
| `elliptic_eu`: |  | Functions and Variables for Elliptic Integrals
| `elliptic_f`: |  | Functions and Variables for Elliptic Integrals
| `elliptic_kc`: |  | Functions and Variables for Elliptic Integrals
| `elliptic_pi`: |  | Functions and Variables for Elliptic Integrals
| `ematrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `emptyp`: |  | Functions and Variables for Sets
| `empty_graph`: |  | Functions and Variables for graphs
| `endcons`: |  | Functions and Variables for Lists
| enhanced3d: |  | Functions and Variables for draw
| `entermatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `entertensor`: |  | Functions and Variables for itensor
| `entier`: |  | Functions for Numbers
| epsilon_lp: |  | Functions and Variables for simplex
| `equal`: |  | Functions and Variables for Predicates
| `equalp`: |  | Functions and Variables for Fourier series
| `equiv_classes`: |  | Functions and Variables for Sets
| `erf`: |  | Error Function
| `erfc`: |  | Error Function
| erfflag: |  | Functions and Variables for Integration
| `erfi`: |  | Error Function
| `erf_generalized`: |  | Error Function
| erf_representation: |  | Error Function
| `errcatch`: |  | Functions and Variables for Program Flow
| `error`: |  | Functions and Variables for Program Flow
| `error`: |  | Functions and Variables for Program Flow
| errormsg: |  | Functions and Variables for Program Flow
| `errormsg`: |  | Functions and Variables for Program Flow
| `errors`: |  | Functions and Variables for draw
| error_size: |  | Functions and Variables for Program Flow
| error_syms: |  | Functions and Variables for Program Flow
| error_type: |  | Functions and Variables for draw
| `euler`: |  | Functions and Variables for Number Theory
| `ev`: |  | Functions and Variables for Evaluation
| eval: |  | Functions and Variables for Evaluation
| `eval_string`: |  | Functions and Variables for strings
| evenfun: |  | Functions and Variables for Simplification
| `evenp`: |  | Functions and Variables for Numbers
| `every`: |  | Functions and Variables for Sets
| `every`: |  | Functions and Variables for Sets
| evflag: |  | Functions and Variables for Evaluation
| evfun: |  | Functions and Variables for Evaluation
| `evolution`: |  | Functions and Variables for dynamics
| `evolution2d`: |  | Functions and Variables for dynamics
| `evundiff`: |  | Functions and Variables for itensor
| ev_point: |  | Functions and Variables for zeilberger
| `example`: |  | Functions and Variables for Help
| `example`: |  | Functions and Variables for Help
| `exp`: |  | Root Exponential and Logarithmic Functions
| `expand`: |  | Functions and Variables for Simplification
| `expand`: |  | Functions and Variables for Simplification
| `expandwrt`: |  | Functions and Variables for Simplification
| expandwrt_denom: |  | Functions and Variables for Simplification
| `expandwrt_factored`: |  | Functions and Variables for Simplification
| `expintegral_chi`: |  | Exponential Integrals
| `expintegral_ci`: |  | Exponential Integrals
| `expintegral_e`: |  | Exponential Integrals
| `expintegral_e1`: |  | Exponential Integrals
| `expintegral_ei`: |  | Exponential Integrals
| `expintegral_li`: |  | Exponential Integrals
| `expintegral_shi`: |  | Exponential Integrals
| `expintegral_si`: |  | Exponential Integrals
| expintexpand: |  | Exponential Integrals
| expintrep: |  | Exponential Integrals
| `explicit`: |  | Functions and Variables for draw
| `explicit`: |  | Functions and Variables for draw
| `explose`: |  | Functions and Variables for Symmetries
| expon: |  | Functions and Variables for Simplification
| `exponentialize`: |  | Functions and Variables for Simplification
| `exponentialize`: |  | Functions and Variables for Simplification
| expop: |  | Functions and Variables for Simplification
| `express`: |  | Functions and Variables for Differentiation
| `expt`: |  | Functions and Variables for Display
| exptdispflag: |  | Functions and Variables for Display
| exptisolate: |  | Functions and Variables for Expressions
| exptsubst: |  | Functions and Variables for Expressions
| `exsec`: |  | Package functs
| `extdiff`: |  | Functions and Variables for itensor
| `extract_linear_equations`: |  | Functions and Variables for Affine
| `extremal_subset`: |  | Functions and Variables for Sets
| `extremal_subset`: |  | Functions and Variables for Sets
| `ezgcd`: |  | Functions and Variables for Polynomials
F |  |
| `f90`: |  | Functions and Variables for f90
| facexpand: |  | Functions and Variables for Polynomials
| `facsum`: |  | Package facexp
| facsum_combine: |  | Package facexp
| `factcomb`: |  | Combinatorial Functions
| factlim: |  | Combinatorial Functions
| `factor`: |  | Functions and Variables for Polynomials
| `factor`: |  | Functions and Variables for Polynomials
| `factorfacsum`: |  | Package facexp
| factorflag: |  | Functions and Variables for Polynomials
| `factorial`: |  | Combinatorial Functions
| factorial_expand: |  | Combinatorial Functions
| `factorout`: |  | Functions and Variables for Polynomials
| `factorsum`: |  | Functions and Variables for Polynomials
| `facts`: |  | Functions and Variables for Facts
| `facts`: |  | Functions and Variables for Facts
| false: |  | Functions and Variables for Constants
| `fasttimes`: |  | Functions and Variables for Polynomials
| `fast_central_elements`: |  | Functions and Variables for Affine
| `fast_linsolve`: |  | Functions and Variables for Affine
| fb: |  | Functions and Variables for ctensor
| feature: |  | Functions and Variables for Runtime Environment
| `featurep`: |  | Functions and Variables for Runtime Environment
| features: |  | Functions and Variables for Properties
| `fernfale`: |  | Definitions for IFS fractals
| `fft`: |  | Functions and Variables for fast Fourier transform
| `fib`: |  | Functions and Variables for Number Theory
| `fibtophi`: |  | Functions and Variables for Number Theory
| `fifth`: |  | Functions and Variables for Lists
| `filename_merge`: |  | Functions and Variables for File Input and Output
| file_name: |  | Functions and Variables for draw
| file_name: |  | Functions and Variables for graphs
| file_output_append: |  | Functions and Variables for File Input and Output
| `file_search`: |  | Functions and Variables for File Input and Output
| `file_search`: |  | Functions and Variables for File Input and Output
| file_search_demo: |  | Functions and Variables for File Input and Output
| file_search_lisp: |  | Functions and Variables for File Input and Output
| file_search_maxima: |  | Functions and Variables for File Input and Output
| file_search_tests: |  | Functions and Variables for File Input and Output
| file_search_usage: |  | Functions and Variables for File Input and Output
| `file_type`: |  | Functions and Variables for File Input and Output
| file_type_lisp: |  | Functions and Variables for File Input and Output
| file_type_maxima: |  | Functions and Variables for File Input and Output
| `fillarray`: |  | Functions and Variables for Arrays
| filled_func: |  | Functions and Variables for draw
| fill_color: |  | Functions and Variables for draw
| fill_density: |  | Functions and Variables for draw
| `findde`: |  | Functions and Variables for ctensor
| `find_root`: |  | Functions and Variables for fast Fourier transform
| `find_root`: |  | Functions and Variables for fast Fourier transform
| `find_root_abs`: |  | Functions and Variables for fast Fourier transform
| `find_root_error`: |  | Functions and Variables for fast Fourier transform
| `find_root_rel`: |  | Functions and Variables for fast Fourier transform
| `first`: |  | Functions and Variables for Lists
| `fix`: |  | Functions for Numbers
| fixed_vertices: |  | Functions and Variables for graphs
| `flatten`: |  | Functions and Variables for Sets
| `flength`: |  | Functions and Variables for input and output
| flipflag: |  | Functions and Variables for itensor
| `float`: |  | Functions and Variables for Numbers
| float2bf: |  | Functions and Variables for Numbers
| `floatnump`: |  | Functions and Variables for Numbers
| `floor`: |  | Functions for Numbers
| `flower_snark`: |  | Functions and Variables for graphs
| `flush`: |  | Functions and Variables for itensor
| `flush1deriv`: |  | Functions and Variables for itensor
| `flushd`: |  | Functions and Variables for itensor
| `flushnd`: |  | Functions and Variables for itensor
| `fmin_cobyla`: |  | Functions and Variables for cobyla
| `fmin_cobyla`: |  | Functions and Variables for cobyla
| font: |  | Functions and Variables for draw
| font_size: |  | Functions and Variables for draw
| `for`: |  | Functions and Variables for Program Flow
| `forget`: |  | Functions and Variables for Facts
| `forget`: |  | Functions and Variables for Facts
| fortindent: |  | Functions and Variables for fast Fourier transform
| `fortran`: |  | Functions and Variables for fast Fourier transform
| fortspaces: |  | Functions and Variables for fast Fourier transform
| `fourcos`: |  | Functions and Variables for Fourier series
| `fourexpand`: |  | Functions and Variables for Fourier series
| `fourier`: |  | Functions and Variables for Fourier series
| `fourier_elim`: |  | Functions and Variables for to_poly_solve
| `fourint`: |  | Functions and Variables for Fourier series
| `fourintcos`: |  | Functions and Variables for Fourier series
| `fourintsin`: |  | Functions and Variables for Fourier series
| `foursimp`: |  | Functions and Variables for Fourier series
| `foursin`: |  | Functions and Variables for Fourier series
| `fourth`: |  | Functions and Variables for Lists
| `fposition`: |  | Functions and Variables for input and output
| `fposition`: |  | Functions and Variables for input and output
| fpprec: |  | Functions and Variables for Numbers
| fpprintprec: |  | Functions and Variables for Numbers
| `frame_bracket`: |  | Functions and Variables for ctensor
| `freeof`: |  | Functions and Variables for Expressions
| `freshline`: |  | Functions and Variables for input and output
| `freshline`: |  | Functions and Variables for input and output
| `fresnel_c`: |  | Error Function
| `fresnel_s`: |  | Error Function
| `from_adjacency_matrix`: |  | Functions and Variables for graphs
| `frucht_graph`: |  | Functions and Variables for graphs
| `fullmap`: |  | Functions and Variables for Function Definition
| `fullmapl`: |  | Functions and Variables for Function Definition
| `fullratsimp`: |  | Functions and Variables for Polynomials
| `fullratsubst`: |  | Functions and Variables for Polynomials
| `fullsetify`: |  | Functions and Variables for Sets
| `full_listify`: |  | Functions and Variables for Sets
| `funcsolve`: |  | Functions and Variables for Equations
| functions: |  | Functions and Variables for Function Definition
| `fundamental_dimensions`: |  | Functions and Variables for ezunits
| `fundamental_units`: |  | Functions and Variables for ezunits
| `fundamental_units`: |  | Functions and Variables for ezunits
| `fundef`: |  | Functions and Variables for Function Definition
| `funmake`: |  | Functions and Variables for Function Definition
| `funp`: |  | Functions and Variables for Fourier series
| `funp`: |  | Functions and Variables for Fourier series
| `fv`: |  | Functions and Variables for finance
G |  |
| `gamma`: |  | Gamma and factorial Functions
| gammalim: |  | Gamma and factorial Functions
| `gamma_incomplete`: |  | Gamma and factorial Functions
| `gamma_incomplete_generalized`: |  | Gamma and factorial Functions
| `gamma_incomplete_regularized`: |  | Gamma and factorial Functions
| `gaussprob`: |  | Package functs
| `gauss_a`: |  | Functions and Variables for contrib_ode
| `gauss_b`: |  | Functions and Variables for contrib_ode
| `gcd`: |  | Functions and Variables for Polynomials
| `gcdex`: |  | Functions and Variables for Polynomials
| `gcdex`: |  | Functions and Variables for Polynomials
| `gcdivide`: |  | Package functs
| `gcfac`: |  | Package scifac
| `gcfactor`: |  | Functions and Variables for Polynomials
| `gd`: |  | Package functs
| gdet: |  | Functions and Variables for ctensor
| `genfact`: |  | Combinatorial Functions
| genindex: |  | Functions and Variables for Miscellaneous Options
| `genmatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `genmatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `genmatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| gensumnum: |  | Functions and Variables for Miscellaneous Options
| `gensym`: |  | Functions and Variables for Miscellaneous Options
| `gensym`: |  | Functions and Variables for Miscellaneous Options
| `gen_laguerre`: |  | Functions and Variables for orthogonal polynomials
| `geomap`: |  | Functions and Variables for worldmap
| `geomap`: |  | Functions and Variables for worldmap
| `geometric`: |  | Package functs
| `geometric_mean`: |  | Functions and Variables for descriptive statistics
| `geometric_mean`: |  | Functions and Variables for descriptive statistics
| `geosum`: |  | Package functs
| `geo_amortization`: |  | Functions and Variables for finance
| `geo_annuity_fv`: |  | Functions and Variables for finance
| `geo_annuity_pv`: |  | Functions and Variables for finance
| `get`: |  | Functions and Variables for Properties
| `get_edge_weight`: |  | Functions and Variables for graphs
| `get_edge_weight`: |  | Functions and Variables for graphs
| `get_lu_factors`: |  | Functions and Variables for linearalgebra
| `get_pixel`: |  | Functions and Variables for pictures
| `get_plot_option`: |  | Functions and Variables for Plotting
| `get_tex_environment`: |  | Functions and Variables for File Input and Output
| `get_tex_environment_default`: |  | Functions and Variables for File Input and Output
| `get_vertex_label`: |  | Functions and Variables for graphs
| `gfactor`: |  | Functions and Variables for Polynomials
| `gfactorsum`: |  | Functions and Variables for Polynomials
| `ggf`: |  | Functions and Variables for ggf
| GGFCFMAX: |  | Functions and Variables for ggf
| GGFINFINITY: |  | Functions and Variables for ggf
| `girth`: |  | Functions and Variables for graphs
| globalsolve: |  | Functions and Variables for Equations
| `global_variances`: |  | Functions and Variables for descriptive statistics
| `global_variances`: |  | Functions and Variables for descriptive statistics
| `gnuplot_close`: |  | Gnuplot_pipes Format Functions
| gnuplot_curve_styles: |  | Gnuplot Options
| gnuplot_curve_titles: |  | Gnuplot Options
| gnuplot_default_term_command: |  | Gnuplot Options
| gnuplot_dumb_term_command: |  | Gnuplot Options
| gnuplot_file_name: |  | Functions and Variables for draw
| gnuplot_out_file: |  | Gnuplot Options
| gnuplot_pm3d: |  | Gnuplot Options
| gnuplot_preamble: |  | Gnuplot Options
| gnuplot_ps_term_command: |  | Gnuplot Options
| `gnuplot_replot`: |  | Gnuplot_pipes Format Functions
| `gnuplot_replot`: |  | Gnuplot_pipes Format Functions
| `gnuplot_reset`: |  | Gnuplot_pipes Format Functions
| `gnuplot_restart`: |  | Gnuplot_pipes Format Functions
| `gnuplot_start`: |  | Gnuplot_pipes Format Functions
| gnuplot_term: |  | Gnuplot Options
| `go`: |  | Functions and Variables for Program Flow
| `Gosper`: |  | Functions and Variables for zeilberger
| `GosperSum`: |  | Functions and Variables for zeilberger
| Gosper_in_Zeilberger: |  | Functions and Variables for zeilberger
| `gr2d`: |  | Functions and Variables for draw
| `gr3d`: |  | Functions and Variables for draw
| `gradef`: |  | Functions and Variables for Differentiation
| `gradef`: |  | Functions and Variables for Differentiation
| gradefs: |  | Functions and Variables for Differentiation
| `gramschmidt`: |  | Functions and Variables for Matrices and Linear Algebra
| `gramschmidt`: |  | Functions and Variables for Matrices and Linear Algebra
| `graph6_decode`: |  | Functions and Variables for graphs
| `graph6_encode`: |  | Functions and Variables for graphs
| `graph6_export`: |  | Functions and Variables for graphs
| `graph6_import`: |  | Functions and Variables for graphs
| `graph_center`: |  | Functions and Variables for graphs
| `graph_charpoly`: |  | Functions and Variables for graphs
| `graph_eigenvalues`: |  | Functions and Variables for graphs
| `graph_flow`: |  | Functions and Variables for finance
| `graph_order`: |  | Functions and Variables for graphs
| `graph_periphery`: |  | Functions and Variables for graphs
| `graph_product`: |  | Functions and Variables for graphs
| `graph_size`: |  | Functions and Variables for graphs
| `graph_union`: |  | Functions and Variables for graphs
| `great_rhombicosidodecahedron_graph`: |  | Functions and Variables for graphs
| `great_rhombicuboctahedron_graph`: |  | Functions and Variables for graphs
| grid: |  | Plotting Options
| grid: |  | Functions and Variables for draw
| `grid_graph`: |  | Functions and Variables for graphs
| `grind`: |  | Functions and Variables for Display
| `grind`: |  | Functions and Variables for Display
| `grobner_basis`: |  | Functions and Variables for Affine
| `grotzch_graph`: |  | Functions and Variables for graphs
H |  |
| halfangles: |  | Functions and Variables for Trigonometric
| `hamilton_cycle`: |  | Functions and Variables for graphs
| `hamilton_path`: |  | Functions and Variables for graphs
| `hankel`: |  | Functions and Variables for linearalgebra
| `hankel`: |  | Functions and Variables for linearalgebra
| `hankel_1`: |  | Bessel Functions
| `hankel_2`: |  | Bessel Functions
| `harmonic`: |  | Package functs
| `harmonic_mean`: |  | Functions and Variables for descriptive statistics
| `harmonic_mean`: |  | Functions and Variables for descriptive statistics
| `hav`: |  | Package functs
| head_angle: |  | Functions and Variables for draw
| head_angle: |  | Functions and Variables for graphs
| head_both: |  | Functions and Variables for draw
| head_length: |  | Functions and Variables for draw
| head_length: |  | Functions and Variables for graphs
| head_type: |  | Functions and Variables for draw
| `heawood_graph`: |  | Functions and Variables for graphs
| `hermite`: |  | Functions and Variables for orthogonal polynomials
| `hessian`: |  | Functions and Variables for linearalgebra
| `hgfred`: |  | Functions and Variables for Special Functions
| `hilbertmap`: |  | Definitions for Peano maps
| `hilbert_matrix`: |  | Functions and Variables for linearalgebra
| `hipow`: |  | Functions and Variables for Polynomials
| `histogram`: |  | Functions and Variables for statistical graphs
| `histogram`: |  | Functions and Variables for statistical graphs
| `histogram`: |  | Functions and Variables for statistical graphs
| `histogram`: |  | Functions and Variables for statistical graphs
| `histogram`: |  | Functions and Variables for statistical graphs
| `histogram`: |  | Functions and Variables for statistical graphs
| `histogram_description`: |  | Functions and Variables for statistical graphs
| `hodge`: |  | Functions and Variables for itensor
| `horner`: |  | Functions and Variables for fast Fourier transform
| `horner`: |  | Functions and Variables for fast Fourier transform
| `hypergeometric`: |  | Hypergeometric Functions
| hypergeometric_representation: |  | Error Function
I |  |
| ibase: |  | Functions and Variables for Display
| `ic1`: |  | Functions and Variables for Differential Equations
| `ic2`: |  | Functions and Variables for Differential Equations
| icc1: |  | Functions and Variables for itensor
| icc2: |  | Functions and Variables for itensor
| `ichr1`: |  | Functions and Variables for itensor
| `ichr2`: |  | Functions and Variables for itensor
| `icosahedron_graph`: |  | Functions and Variables for graphs
| `icosidodecahedron_graph`: |  | Functions and Variables for graphs
| icounter: |  | Functions and Variables for itensor
| `icurvature`: |  | Functions and Variables for itensor
| `ic_convert`: |  | Functions and Variables for itensor
| `ident`: |  | Functions and Variables for Matrices and Linear Algebra
| `identfor`: |  | Functions and Variables for linearalgebra
| `identfor`: |  | Functions and Variables for linearalgebra
| `identity`: |  | Functions and Variables for Sets
| `idiff`: |  | Functions and Variables for itensor
| `idim`: |  | Functions and Variables for itensor
| `idummy`: |  | Functions and Variables for itensor
| idummyx: |  | Functions and Variables for itensor
| `ieqn`: |  | Functions and Variables for Equations
| ieqnprint: |  | Functions and Variables for Equations
| `if`: |  | Functions and Variables for Program Flow
| `ifactors`: |  | Functions and Variables for Number Theory
| ifb: |  | Functions and Variables for itensor
| ifc1: |  | Functions and Variables for itensor
| ifc2: |  | Functions and Variables for itensor
| ifg: |  | Functions and Variables for itensor
| ifgi: |  | Functions and Variables for itensor
| ifr: |  | Functions and Variables for itensor
| `iframes`: |  | Functions and Variables for itensor
| iframe_bracket_form: |  | Functions and Variables for itensor
| ifri: |  | Functions and Variables for itensor
| `ifs`: |  | Functions and Variables for dynamics
| `igcdex`: |  | Functions and Variables for Number Theory
| `igeodesic_coords`: |  | Functions and Variables for itensor
| igeowedge_flag: |  | Functions and Variables for itensor
| ikt1: |  | Functions and Variables for itensor
| ikt2: |  | Functions and Variables for itensor
| `ilt`: |  | Functions and Variables for Integration
| `image`: |  | Functions and Variables for draw
| `imagpart`: |  | Functions for Complex Numbers
| `imetric`: |  | Functions and Variables for itensor
| `imetric`: |  | Functions and Variables for itensor
| `implicit`: |  | Functions and Variables for draw
| `implicit`: |  | Functions and Variables for draw
| `implicit_derivative`: |  | Functions and Variables for impdiff
| `implicit_plot`: |  | Functions and Variables for implicit_plot
| `implicit_plot`: |  | Functions and Variables for implicit_plot
| inchar: |  | Functions and Variables for Command Line
| ind: |  | Functions and Variables for Constants
| `indexed_tensor`: |  | Functions and Variables for itensor
| `indices`: |  | Functions and Variables for itensor
| `induced_subgraph`: |  | Functions and Variables for graphs
| inf: |  | Functions and Variables for Constants
| `inferencep`: |  | Functions and Variables for inference_result
| `inference_result`: |  | Functions and Variables for inference_result
| infeval: |  | Functions and Variables for Evaluation
| infinity: |  | Functions and Variables for Constants
| `infix`: |  | User defined operators
| `infix`: |  | User defined operators
| `infix`: |  | User defined operators
| inflag: |  | Functions and Variables for Expressions
| infolists: |  | Functions and Variables for Command Line
| `init_atensor`: |  | Functions and Variables for atensor
| `init_atensor`: |  | Functions and Variables for atensor
| `init_ctensor`: |  | Functions and Variables for ctensor
| inm: |  | Functions and Variables for itensor
| inmc1: |  | Functions and Variables for itensor
| inmc2: |  | Functions and Variables for itensor
| `innerproduct`: |  | Functions and Variables for Matrices and Linear Algebra
| `inpart`: |  | Functions and Variables for Expressions
| `inprod`: |  | Functions and Variables for Matrices and Linear Algebra
| `inrt`: |  | Functions and Variables for Number Theory
| intanalysis: |  | Functions and Variables for Integration
| `integerp`: |  | Functions and Variables for Numbers
| `integer_partitions`: |  | Functions and Variables for Sets
| `integer_partitions`: |  | Functions and Variables for Sets
| `integrate`: |  | Functions and Variables for Integration
| `integrate`: |  | Functions and Variables for Integration
| integrate_use_rootsof: |  | Functions and Variables for Integration
| integration_constant: |  | Functions and Variables for Integration
| integration_constant_counter: |  | Functions and Variables for Integration
| `intersect`: |  | Functions and Variables for Sets
| `intersection`: |  | Functions and Variables for Sets
| `intervalp`: |  | Functions and Variables for orthogonal polynomials
| intfaclim: |  | Functions and Variables for Polynomials
| `intopois`: |  | Poisson series
| `intosum`: |  | Sums and Products
| `invariant1`: |  | Functions and Variables for ctensor
| `invariant2`: |  | Functions and Variables for ctensor
| `inverse_fft`: |  | Functions and Variables for fast Fourier transform
| `inverse_jacobi_cd`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_cn`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_cs`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_dc`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_dn`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_ds`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_nc`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_nd`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_ns`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_sc`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_sd`: |  | Functions and Variables for Elliptic Functions
| `inverse_jacobi_sn`: |  | Functions and Variables for Elliptic Functions
| `invert`: |  | Functions and Variables for Matrices and Linear Algebra
| `invert_by_lu`: |  | Functions and Variables for linearalgebra
| `inv_mod`: |  | Functions and Variables for Number Theory
| `in_neighbors`: |  | Functions and Variables for graphs
| ip_grid: |  | Functions and Variables for draw
| ip_grid_in: |  | Functions and Variables for draw
| `irr`: |  | Functions and Variables for finance
| `is`: |  | Functions and Variables for Facts
| `ishow`: |  | Functions and Variables for itensor
| `isolate`: |  | Functions and Variables for Expressions
| isolate_wrt_times: |  | Functions and Variables for Expressions
| `isomorphism`: |  | Functions and Variables for graphs
| `isqrt`: |  | Functions and Variables for Number Theory
| `isreal_p`: |  | Functions and Variables for to_poly_solve
| `is_biconnected`: |  | Functions and Variables for graphs
| `is_bipartite`: |  | Functions and Variables for graphs
| `is_connected`: |  | Functions and Variables for graphs
| `is_digraph`: |  | Functions and Variables for graphs
| `is_edge_in_graph`: |  | Functions and Variables for graphs
| `is_graph`: |  | Functions and Variables for graphs
| `is_graph_or_digraph`: |  | Functions and Variables for graphs
| `is_isomorphic`: |  | Functions and Variables for graphs
| `is_planar`: |  | Functions and Variables for graphs
| `is_sconnected`: |  | Functions and Variables for graphs
| `is_tree`: |  | Functions and Variables for graphs
| `is_vertex_in_graph`: |  | Functions and Variables for graphs
| `items_inference`: |  | Functions and Variables for inference_result
| itr: |  | Functions and Variables for itensor
J |  |
| `jacobi`: |  | Functions and Variables for Number Theory
| `jacobian`: |  | Functions and Variables for linearalgebra
| `jacobi_cd`: |  | Functions and Variables for Elliptic Functions
| `jacobi_cn`: |  | Functions and Variables for Elliptic Functions
| `jacobi_cs`: |  | Functions and Variables for Elliptic Functions
| `jacobi_dc`: |  | Functions and Variables for Elliptic Functions
| `jacobi_dn`: |  | Functions and Variables for Elliptic Functions
| `jacobi_ds`: |  | Functions and Variables for Elliptic Functions
| `jacobi_nc`: |  | Functions and Variables for Elliptic Functions
| `jacobi_nd`: |  | Functions and Variables for Elliptic Functions
| `jacobi_ns`: |  | Functions and Variables for Elliptic Functions
| `jacobi_p`: |  | Functions and Variables for orthogonal polynomials
| `jacobi_sc`: |  | Functions and Variables for Elliptic Functions
| `jacobi_sd`: |  | Functions and Variables for Elliptic Functions
| `jacobi_sn`: |  | Functions and Variables for Elliptic Functions
| `JF`: |  | Functions and Variables for diag
| `join`: |  | Functions and Variables for Lists
| `jordan`: |  | Functions and Variables for diag
| `julia`: |  | Functions and Variables for dynamics
| julia_parameter: |  | Definitions for complex fractals
| `julia_set`: |  | Definitions for complex fractals
| `julia_sin`: |  | Definitions for complex fractals
K |  |
| `kdels`: |  | Functions and Variables for itensor
| `kdelta`: |  | Functions and Variables for itensor
| keepfloat: |  | Functions and Variables for Polynomials
| key: |  | Functions and Variables for draw
| `kill`: |  | Functions and Variables for Command Line
| `kill`: |  | Functions and Variables for Command Line
| `kill`: |  | Functions and Variables for Command Line
| `kill`: |  | Functions and Variables for Command Line
| `kill`: |  | Functions and Variables for Command Line
| `kill`: |  | Functions and Variables for Command Line
| `kill`: |  | Functions and Variables for Command Line
| `kill`: |  | Functions and Variables for Command Line
| `killcontext`: |  | Functions and Variables for Facts
| kinvariant: |  | Functions and Variables for ctensor
| `kostka`: |  | Functions and Variables for Symmetries
| `kronecker_product`: |  | Functions and Variables for linearalgebra
| `kron_delta`: |  | Functions and Variables for Sets
| kt: |  | Functions and Variables for ctensor
| `kummer_m`: |  | Functions and Variables for contrib_ode
| `kummer_u`: |  | Functions and Variables for contrib_ode
| `kurtosis`: |  | Functions and Variables for descriptive statistics
| `kurtosis`: |  | Functions and Variables for descriptive statistics
| `kurtosis_bernoulli`: |  | Functions and Variables for discrete distributions
| `kurtosis_beta`: |  | Functions and Variables for continuous distributions
| `kurtosis_binomial`: |  | Functions and Variables for discrete distributions
| `kurtosis_chi2`: |  | Functions and Variables for continuous distributions
| `kurtosis_continuous_uniform`: |  | Functions and Variables for continuous distributions
| `kurtosis_discrete_uniform`: |  | Functions and Variables for discrete distributions
| `kurtosis_exp`: |  | Functions and Variables for continuous distributions
| `kurtosis_f`: |  | Functions and Variables for continuous distributions
| `kurtosis_gamma`: |  | Functions and Variables for continuous distributions
| `kurtosis_general_finite_discrete`: |  | Functions and Variables for discrete distributions
| `kurtosis_geometric`: |  | Functions and Variables for discrete distributions
| `kurtosis_gumbel`: |  | Functions and Variables for continuous distributions
| `kurtosis_hypergeometric`: |  | Functions and Variables for discrete distributions
| `kurtosis_laplace`: |  | Functions and Variables for continuous distributions
| `kurtosis_logistic`: |  | Functions and Variables for continuous distributions
| `kurtosis_lognormal`: |  | Functions and Variables for continuous distributions
| `kurtosis_negative_binomial`: |  | Functions and Variables for discrete distributions
| `kurtosis_noncentral_chi2`: |  | Functions and Variables for continuous distributions
| `kurtosis_noncentral_student_t`: |  | Functions and Variables for continuous distributions
| `kurtosis_normal`: |  | Functions and Variables for continuous distributions
| `kurtosis_pareto`: |  | Functions and Variables for continuous distributions
| `kurtosis_poisson`: |  | Functions and Variables for discrete distributions
| `kurtosis_rayleigh`: |  | Functions and Variables for continuous distributions
| `kurtosis_student_t`: |  | Functions and Variables for continuous distributions
| `kurtosis_weibull`: |  | Functions and Variables for continuous distributions
L |  |
| `label`: |  | Functions and Variables for draw
| `label`: |  | Functions and Variables for draw
| `labels`: |  | Functions and Variables for Command Line
| `labels`: |  | Functions and Variables for Command Line
| label_alignment: |  | Functions and Variables for draw
| label_alignment: |  | Functions and Variables for graphs
| label_orientation: |  | Functions and Variables for draw
| `lagrange`: |  | Functions and Variables for interpol
| `lagrange`: |  | Functions and Variables for interpol
| `laguerre`: |  | Functions and Variables for orthogonal polynomials
| `lambda`: |  | Functions and Variables for Function Definition
| `lambda`: |  | Functions and Variables for Function Definition
| `lambda`: |  | Functions and Variables for Function Definition
| `lambert_w`: |  | Functions and Variables for Special Functions
| `laplace`: |  | Functions and Variables for Differentiation
| `laplacian_matrix`: |  | Functions and Variables for graphs
| lassociative: |  | Functions and Variables for Simplification
| `last`: |  | Functions and Variables for Lists
| `lbfgs`: |  | Functions and Variables for lbfgs
| `lbfgs`: |  | Functions and Variables for lbfgs
| lbfgs_ncorrections: |  | Functions and Variables for lbfgs
| lbfgs_nfeval_max: |  | Functions and Variables for lbfgs
| `lc2kdt`: |  | Functions and Variables for itensor
| `lcharp`: |  | Functions and Variables for characters
| `lcm`: |  | Functions and Variables for Number Theory
| `lc_l`: |  | Functions and Variables for itensor
| `lc_u`: |  | Functions and Variables for itensor
| `ldefint`: |  | Functions and Variables for Integration
| `ldisp`: |  | Functions and Variables for Display
| `ldisplay`: |  | Functions and Variables for Display
| legend: |  | Plotting Options
| legend: |  | Plotting Options
| `legendre_p`: |  | Functions and Variables for orthogonal polynomials
| `legendre_q`: |  | Functions and Variables for orthogonal polynomials
| `leinstein`: |  | Functions and Variables for ctensor
| `length`: |  | Functions and Variables for Lists
| `let`: |  | Functions and Variables for Rules and Patterns
| `let`: |  | Functions and Variables for Rules and Patterns
| letrat: |  | Functions and Variables for Rules and Patterns
| `letrules`: |  | Functions and Variables for Rules and Patterns
| `letrules`: |  | Functions and Variables for Rules and Patterns
| `letsimp`: |  | Functions and Variables for Rules and Patterns
| `letsimp`: |  | Functions and Variables for Rules and Patterns
| `letsimp`: |  | Functions and Variables for Rules and Patterns
| let_rule_packages: |  | Functions and Variables for Rules and Patterns
| `levi_civita`: |  | Functions and Variables for itensor
| lfg: |  | Functions and Variables for ctensor
| `lfreeof`: |  | Functions and Variables for Expressions
| lg: |  | Functions and Variables for ctensor
| `lgtreillis`: |  | Functions and Variables for Symmetries
| lhospitallim: |  | Functions and Variables for Limits
| `lhs`: |  | Functions and Variables for Equations
| `li`: |  | Root Exponential and Logarithmic Functions
| `liediff`: |  | Functions and Variables for itensor
| `limit`: |  | Functions and Variables for Limits
| `limit`: |  | Functions and Variables for Limits
| `limit`: |  | Functions and Variables for Limits
| limsubst: |  | Functions and Variables for Limits
| `Lindstedt`: |  | Functions and Variables for lindstedt
| linear: |  | Functions and Variables for Simplification
| `linear`: |  | Package functs
| `linearinterpol`: |  | Functions and Variables for interpol
| `linearinterpol`: |  | Functions and Variables for interpol
| `linear_program`: |  | Functions and Variables for simplex
| linear_solver: |  | Functions and Variables for zeilberger
| linechar: |  | Functions and Variables for Command Line
| linel: |  | Functions and Variables for Display
| linenum: |  | Functions and Variables for Command Line
| `line_graph`: |  | Functions and Variables for graphs
| line_type: |  | Functions and Variables for draw
| line_width: |  | Functions and Variables for draw
| `linsolve`: |  | Functions and Variables for Equations
| linsolvewarn: |  | Functions and Variables for Equations
| linsolve_params: |  | Functions and Variables for Equations
| lispdisp: |  | Functions and Variables for Display
| listarith: |  | Functions and Variables for Lists
| `listarray`: |  | Functions and Variables for Arrays
| listconstvars: |  | Functions and Variables for Expressions
| listdummyvars: |  | Functions and Variables for Expressions
| `listify`: |  | Functions and Variables for Sets
| `listoftens`: |  | Functions and Variables for itensor
| `listofvars`: |  | Functions and Variables for Expressions
| `listp`: |  | Functions and Variables for Lists
| `listp`: |  | Functions and Variables for linearalgebra
| `listp`: |  | Functions and Variables for linearalgebra
| `list_correlations`: |  | Functions and Variables for descriptive statistics
| `list_correlations`: |  | Functions and Variables for descriptive statistics
| `list_matrix_entries`: |  | Functions and Variables for Matrices and Linear Algebra
| `list_nc_monomials`: |  | Functions and Variables for Affine
| `list_nc_monomials`: |  | Functions and Variables for Affine
| `lmax`: |  | Functions for Numbers
| `lmin`: |  | Functions for Numbers
| lmxchar: |  | Functions and Variables for Matrices and Linear Algebra
| `load`: |  | Functions and Variables for File Input and Output
| `loadfile`: |  | Functions and Variables for File Input and Output
| loadprint: |  | Functions and Variables for File Input and Output
| load_pathname: |  | Functions and Variables for File Input and Output
| `local`: |  | Functions and Variables for Function Definition
| `locate_matrix_entry`: |  | Functions and Variables for linearalgebra
| `log`: |  | Root Exponential and Logarithmic Functions
| logabs: |  | Root Exponential and Logarithmic Functions
| logarc: |  | Root Exponential and Logarithmic Functions
| logarc: |  | Root Exponential and Logarithmic Functions
| logcb: |  | Functions and Variables for draw
| logconcoeffp: |  | Root Exponential and Logarithmic Functions
| `logcontract`: |  | Root Exponential and Logarithmic Functions
| logexpand: |  | Root Exponential and Logarithmic Functions
| lognegint: |  | Root Exponential and Logarithmic Functions
| lognumer: |  | Root Exponential and Logarithmic Functions
| logsimp: |  | Root Exponential and Logarithmic Functions
| logx: |  | Plotting Options
| logx: |  | Functions and Variables for draw
| logy: |  | Plotting Options
| logy: |  | Functions and Variables for draw
| logz: |  | Functions and Variables for draw
| `log_gamma`: |  | Gamma and factorial Functions
| `lopow`: |  | Functions and Variables for Polynomials
| `lorentz_gauge`: |  | Functions and Variables for itensor
| `lowercasep`: |  | Functions and Variables for characters
| `lpart`: |  | Functions and Variables for Expressions
| `lratsubst`: |  | Functions and Variables for Polynomials
| `lreduce`: |  | Functions and Variables for Sets
| `lreduce`: |  | Functions and Variables for Sets
| lriem: |  | Functions and Variables for ctensor
| `lriemann`: |  | Functions and Variables for ctensor
| `lsquares_estimates`: |  | Functions and Variables for lsquares
| `lsquares_estimates`: |  | Functions and Variables for lsquares
| `lsquares_estimates_approximate`: |  | Functions and Variables for lsquares
| `lsquares_estimates_exact`: |  | Functions and Variables for lsquares
| `lsquares_mse`: |  | Functions and Variables for lsquares
| `lsquares_residuals`: |  | Functions and Variables for lsquares
| `lsquares_residual_mse`: |  | Functions and Variables for lsquares
| `lsum`: |  | Sums and Products
| `ltreillis`: |  | Functions and Variables for Symmetries
| `lu_backsub`: |  | Functions and Variables for linearalgebra
| `lu_factor`: |  | Functions and Variables for linearalgebra
M |  |
| m1pbranch: |  | Functions and Variables for Numbers
| `macroexpand`: |  | Macros
| `macroexpand1`: |  | Macros
| macroexpansion: |  | Functions and Variables for Function Definition
| macros: |  | Macros
| mainvar: |  | Functions and Variables for Expressions
| `makebox`: |  | Functions and Variables for itensor
| `makefact`: |  | Gamma and factorial Functions
| `makegamma`: |  | Gamma and factorial Functions
| `makelist`: |  | Functions and Variables for Lists
| `makelist`: |  | Functions and Variables for Lists
| `makeOrders`: |  | Functions and Variables for makeOrders
| `makeset`: |  | Functions and Variables for Sets
| `make_array`: |  | Functions and Variables for Arrays
| `make_graph`: |  | Functions and Variables for graphs
| `make_graph`: |  | Functions and Variables for graphs
| `make_level_picture`: |  | Functions and Variables for pictures
| `make_level_picture`: |  | Functions and Variables for pictures
| `make_polygon`: |  | Functions and Variables for worldmap
| `make_poly_continent`: |  | Functions and Variables for worldmap
| `make_poly_continent`: |  | Functions and Variables for worldmap
| `make_poly_country`: |  | Functions and Variables for worldmap
| `make_random_state`: |  | Random Numbers
| `make_random_state`: |  | Random Numbers
| `make_random_state`: |  | Random Numbers
| `make_random_state`: |  | Random Numbers
| `make_rgb_picture`: |  | Functions and Variables for pictures
| `make_transform`: |  | Functions and Variables for Plotting
| `mandelbrot`: |  | Functions and Variables for dynamics
| `mandelbrot_set`: |  | Definitions for complex fractals
| manual_demo: |  | Functions and Variables for Help
| `map`: |  | Functions and Variables for Program Flow
| `mapatom`: |  | Functions and Variables for Program Flow
| maperror: |  | Functions and Variables for Program Flow
| `maplist`: |  | Functions and Variables for Program Flow
| mapprint: |  | Functions and Variables for Program Flow
| `matchdeclare`: |  | Functions and Variables for Rules and Patterns
| `matchfix`: |  | User defined operators
| `matchfix`: |  | User defined operators
| `matrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `matrixmap`: |  | Functions and Variables for Matrices and Linear Algebra
| `matrixp`: |  | Functions and Variables for Matrices and Linear Algebra
| `matrixp`: |  | Functions and Variables for linearalgebra
| `matrixp`: |  | Functions and Variables for linearalgebra
| matrix_element_add: |  | Functions and Variables for Matrices and Linear Algebra
| matrix_element_mult: |  | Functions and Variables for Matrices and Linear Algebra
| matrix_element_transpose: |  | Functions and Variables for Matrices and Linear Algebra
| `matrix_size`: |  | Functions and Variables for linearalgebra
| `mattrace`: |  | Functions and Variables for Matrices and Linear Algebra
| `mat_cond`: |  | Functions and Variables for linearalgebra
| `mat_cond`: |  | Functions and Variables for linearalgebra
| `mat_fullunblocker`: |  | Functions and Variables for linearalgebra
| `mat_function`: |  | Functions and Variables for diag
| `mat_norm`: |  | Functions and Variables for linearalgebra
| `mat_norm`: |  | Functions and Variables for linearalgebra
| `mat_norm`: |  | Functions and Variables for linearalgebra
| `mat_trace`: |  | Functions and Variables for linearalgebra
| `mat_unblocker`: |  | Functions and Variables for linearalgebra
| `max`: |  | Functions for Numbers
| maxapplydepth: |  | Functions and Variables for Rules and Patterns
| maxapplyheight: |  | Functions and Variables for Rules and Patterns
| maxima_tempdir: |  | Functions and Variables for Runtime Environment
| maxima_userdir: |  | Functions and Variables for Runtime Environment
| `maximize_lp`: |  | Functions and Variables for simplex
| maxnegex: |  | Functions and Variables for Simplification
| maxposex: |  | Functions and Variables for Simplification
| maxpsifracdenom: |  | Gamma and factorial Functions
| maxpsifracnum: |  | Gamma and factorial Functions
| maxpsinegint: |  | Gamma and factorial Functions
| maxpsiposint: |  | Gamma and factorial Functions
| maxtayorder: |  | Functions and Variables for Series
| `max_clique`: |  | Functions and Variables for graphs
| `max_degree`: |  | Functions and Variables for graphs
| `max_flow`: |  | Functions and Variables for graphs
| `max_independent_set`: |  | Functions and Variables for graphs
| `max_matching`: |  | Functions and Variables for graphs
| MAX_ORD: |  | Functions and Variables for zeilberger
| `maybe`: |  | Functions and Variables for Facts
| `mean`: |  | Functions and Variables for descriptive statistics
| `mean`: |  | Functions and Variables for descriptive statistics
| `mean_bernoulli`: |  | Functions and Variables for discrete distributions
| `mean_beta`: |  | Functions and Variables for continuous distributions
| `mean_binomial`: |  | Functions and Variables for discrete distributions
| `mean_chi2`: |  | Functions and Variables for continuous distributions
| `mean_continuous_uniform`: |  | Functions and Variables for continuous distributions
| `mean_deviation`: |  | Functions and Variables for descriptive statistics
| `mean_deviation`: |  | Functions and Variables for descriptive statistics
| `mean_discrete_uniform`: |  | Functions and Variables for discrete distributions
| `mean_exp`: |  | Functions and Variables for continuous distributions
| `mean_f`: |  | Functions and Variables for continuous distributions
| `mean_gamma`: |  | Functions and Variables for continuous distributions
| `mean_general_finite_discrete`: |  | Functions and Variables for discrete distributions
| `mean_geometric`: |  | Functions and Variables for discrete distributions
| `mean_gumbel`: |  | Functions and Variables for continuous distributions
| `mean_hypergeometric`: |  | Functions and Variables for discrete distributions
| `mean_laplace`: |  | Functions and Variables for continuous distributions
| `mean_logistic`: |  | Functions and Variables for continuous distributions
| `mean_lognormal`: |  | Functions and Variables for continuous distributions
| `mean_negative_binomial`: |  | Functions and Variables for discrete distributions
| `mean_noncentral_chi2`: |  | Functions and Variables for continuous distributions
| `mean_noncentral_student_t`: |  | Functions and Variables for continuous distributions
| `mean_normal`: |  | Functions and Variables for continuous distributions
| `mean_pareto`: |  | Functions and Variables for continuous distributions
| `mean_poisson`: |  | Functions and Variables for discrete distributions
| `mean_rayleigh`: |  | Functions and Variables for continuous distributions
| `mean_student_t`: |  | Functions and Variables for continuous distributions
| `mean_weibull`: |  | Functions and Variables for continuous distributions
| `median`: |  | Functions and Variables for descriptive statistics
| `median`: |  | Functions and Variables for descriptive statistics
| `median_deviation`: |  | Functions and Variables for descriptive statistics
| `median_deviation`: |  | Functions and Variables for descriptive statistics
| `member`: |  | Functions and Variables for Lists
| `mesh`: |  | Functions and Variables for draw
| mesh_lines_color: |  | Plotting Options
| method: |  | Functions and Variables for contrib_ode
| `metricexpandall`: |  | Functions and Variables for Units
| `min`: |  | Functions for Numbers
| minf: |  | Functions and Variables for Constants
| `minfactorial`: |  | Combinatorial Functions
| `minimalPoly`: |  | Functions and Variables for diag
| `minimize_lp`: |  | Functions and Variables for simplex
| `minimum_spanning_tree`: |  | Functions and Variables for graphs
| `minor`: |  | Functions and Variables for Matrices and Linear Algebra
| `minpack_lsquares`: |  | Functions and Variables for minpack
| `minpack_solve`: |  | Functions and Variables for minpack
| `min_degree`: |  | Functions and Variables for graphs
| `min_edge_cut`: |  | Functions and Variables for graphs
| `min_vertex_cover`: |  | Functions and Variables for graphs
| `min_vertex_cut`: |  | Functions and Variables for graphs
| `mnewton`: |  | Functions and Variables for mnewton
| `mod`: |  | Functions and Variables for Number Theory
| `ModeMatrix`: |  | Functions and Variables for diag
| mode_checkp: |  | Functions and Variables for Function Definition
| mode_check_errorp: |  | Functions and Variables for Function Definition
| mode_check_warnp: |  | Functions and Variables for Function Definition
| `mode_declare`: |  | Functions and Variables for Function Definition
| `mode_identity`: |  | Functions and Variables for Function Definition
| modular_linear_solver: |  | Functions and Variables for zeilberger
| modulus: |  | Functions and Variables for Polynomials
| mod_big_prime: |  | Functions and Variables for zeilberger
| mod_test: |  | Functions and Variables for zeilberger
| mod_threshold: |  | Functions and Variables for zeilberger
| `moebius`: |  | Functions and Variables for Sets
| `mon2schur`: |  | Functions and Variables for Symmetries
| `mono`: |  | Functions and Variables for Affine
| `monomial_dimensions`: |  | Functions and Variables for Affine
| `multibernstein_poly`: |  | Functions and Variables for Bernstein
| `multinomial`: |  | Functions and Variables for Symmetries
| `multinomial_coeff`: |  | Functions and Variables for Sets
| `multinomial_coeff`: |  | Functions and Variables for Sets
| multiplicative: |  | Functions and Variables for Simplification
| multiplicities: |  | Functions and Variables for Equations
| `multiplot_mode`: |  | Functions and Variables for draw
| `multi_elem`: |  | Functions and Variables for Symmetries
| `multi_orbit`: |  | Functions and Variables for Symmetries
| `multi_pui`: |  | Functions and Variables for Symmetries
| `multsym`: |  | Functions and Variables for Symmetries
| `multthru`: |  | Functions and Variables for Simplification
| `multthru`: |  | Functions and Variables for Simplification
| `mycielski_graph`: |  | Functions and Variables for graphs
| myoptions: |  | Functions and Variables for Command Line
N |  |
| nary: |  | Functions and Variables for Simplification
| `nary`: |  | User defined operators
| `nary`: |  | User defined operators
| `natural_unit`: |  | Functions and Variables for ezunits
| `ncexpt`: |  | Functions and Variables for Display
| `ncharpoly`: |  | Functions and Variables for Matrices and Linear Algebra
| `nc_degree`: |  | Functions and Variables for Affine
| `negative_picture`: |  | Functions and Variables for pictures
| negdistrib: |  | Functions and Variables for Simplification
| negsumdispflag: |  | Functions and Variables for Display
| `neighbors`: |  | Functions and Variables for graphs
| `new`: |  | Functions and Variables for Structures
| `new`: |  | Functions and Variables for Structures
| `newcontext`: |  | Functions and Variables for Facts
| `newdet`: |  | Functions and Variables for Matrices and Linear Algebra
| newline: |  | Functions and Variables for characters
| `newline`: |  | Functions and Variables for input and output
| `newline`: |  | Functions and Variables for input and output
| `newton`: |  | Functions and Variables for fast Fourier transform
| newtonepsilon: |  | Functions and Variables for mnewton
| newtonmaxiter: |  | Functions and Variables for mnewton
| `new_graph`: |  | Functions and Variables for graphs
| `new_variable`: |  | Functions and Variables for to_poly_solve
| nextlayerfactor: |  | Package facexp
| `next_prime`: |  | Functions and Variables for Number Theory
| `nicedummies`: |  | Functions and Variables for to_poly_solve
| `niceindices`: |  | Functions and Variables for Series
| niceindicespref: |  | Functions and Variables for Series
| `ninth`: |  | Functions and Variables for Lists
| nm: |  | Functions and Variables for ctensor
| nmc: |  | Functions and Variables for ctensor
| noeval: |  | Functions and Variables for Evaluation
| `nofix`: |  | User defined operators
| `nofix`: |  | User defined operators
| nolabels: |  | Functions and Variables for Command Line
| `nonarray`: |  | Functions and Variables for Properties
| `noncentral_moment`: |  | Functions and Variables for descriptive statistics
| `noncentral_moment`: |  | Functions and Variables for descriptive statistics
| nonegative_lp: |  | Functions and Variables for simplex
| `nonmetricity`: |  | Functions and Variables for ctensor
| `nonnegintegerp`: |  | Functions and Variables for Numbers
| nonscalar: |  | Functions and Variables for Matrices and Linear Algebra
| `nonscalarp`: |  | Functions and Variables for Matrices and Linear Algebra
| `nonzeroandfreeof`: |  | Package functs
| `not`: |  | Logical operators
| `notequal`: |  | Functions and Variables for Predicates
| noun: |  | Functions and Variables for Expressions
| noundisp: |  | Functions and Variables for Expressions
| `nounify`: |  | Functions and Variables for Expressions
| nouns: |  | Functions and Variables for Evaluation
| np: |  | Functions and Variables for ctensor
| npi: |  | Functions and Variables for ctensor
| `nptetrad`: |  | Functions and Variables for ctensor
| `npv`: |  | Functions and Variables for finance
| `nroots`: |  | Functions and Variables for Equations
| `nterms`: |  | Functions and Variables for Expressions
| `ntermst`: |  | Functions and Variables for ctensor
| `nthroot`: |  | Functions and Variables for Equations
| nticks: |  | Plotting Options
| nticks: |  | Functions and Variables for draw
| ntrig: |  | Functions and Variables for Trigonometric
| `nullity`: |  | Functions and Variables for linearalgebra
| `nullspace`: |  | Functions and Variables for linearalgebra
| `num`: |  | Functions and Variables for Polynomials
| `numbered_boundaries`: |  | Functions and Variables for worldmap
| `numberp`: |  | Functions and Variables for Numbers
| numer: |  | Functions and Variables for Numbers
| `numerval`: |  | Functions and Variables for Numbers
| numer_pbranch: |  | Functions and Variables for Numbers
| `numfactor`: |  | Gamma and factorial Functions
| `num_distinct_partitions`: |  | Functions and Variables for Sets
| `num_distinct_partitions`: |  | Functions and Variables for Sets
| `num_partitions`: |  | Functions and Variables for Sets
| `num_partitions`: |  | Functions and Variables for Sets
| `nusum`: |  | Functions and Variables for Series
| `nzeta`: |  | Functions and Variables for Special Functions
| `nzetai`: |  | Functions and Variables for Special Functions
| `nzetar`: |  | Functions and Variables for Special Functions
O |  |
| obase: |  | Functions and Variables for Display
| oddfun: |  | Functions and Variables for Simplification
| `oddp`: |  | Functions and Variables for Numbers
| `odd_girth`: |  | Functions and Variables for graphs
| `ode2`: |  | Functions and Variables for Differential Equations
| `odelin`: |  | Functions and Variables for contrib_ode
| `ode_check`: |  | Functions and Variables for contrib_ode
| `op`: |  | Functions and Variables for Expressions
| `opena`: |  | Functions and Variables for input and output
| `opena_binary`: |  | Functions and Variables for binary input and output
| `openr`: |  | Functions and Variables for input and output
| `openr_binary`: |  | Functions and Variables for binary input and output
| `openw`: |  | Functions and Variables for input and output
| `openw_binary`: |  | Functions and Variables for binary input and output
| `operatorp`: |  | Functions and Variables for Expressions
| `operatorp`: |  | Functions and Variables for Expressions
| opproperties: |  | Functions and Variables for Simplification
| opsubst: |  | Functions and Variables for Expressions
| `opsubst`: |  | Functions and Variables for opsubst
| `opsubst`: |  | Functions and Variables for opsubst
| `opsubst`: |  | Functions and Variables for opsubst
| `optimize`: |  | Functions and Variables for Expressions
| optimprefix: |  | Functions and Variables for Expressions
| optionset: |  | Functions and Variables for Command Line
| `or`: |  | Logical operators
| `orbit`: |  | Functions and Variables for Symmetries
| `orbits`: |  | Functions and Variables for dynamics
| `ordergreat`: |  | Functions and Variables for Expressions
| `ordergreatp`: |  | Functions and Variables for Expressions
| `orderless`: |  | Functions and Variables for Expressions
| `orderlessp`: |  | Functions and Variables for Expressions
| `orthogonal_complement`: |  | Functions and Variables for linearalgebra
| `orthopoly_recur`: |  | Functions and Variables for orthogonal polynomials
| orthopoly_returns_intervals: |  | Functions and Variables for orthogonal polynomials
| `orthopoly_weight`: |  | Functions and Variables for orthogonal polynomials
| outative: |  | Functions and Variables for Simplification
| outchar: |  | Functions and Variables for Command Line
| `outermap`: |  | Functions and Variables for Program Flow
| `outofpois`: |  | Poisson series
| `out_neighbors`: |  | Functions and Variables for graphs
P |  |
| packagefile: |  | Functions and Variables for File Input and Output
| `pade`: |  | Functions and Variables for Series
| palette: |  | Plotting Options
| palette: |  | Plotting Options
| palette: |  | Functions and Variables for draw
| `parabolic_cylinder_d`: |  | Parabolic Cylinder Functions
| `parametric`: |  | Functions and Variables for draw
| `parametric`: |  | Functions and Variables for draw
| `parametric_surface`: |  | Functions and Variables for draw
| `parg`: |  | Functions and Variables for to_poly_solve
| `parGosper`: |  | Functions and Variables for zeilberger
| `parse_string`: |  | Functions and Variables for strings
| `part`: |  | Functions and Variables for Expressions
| `part2cont`: |  | Functions and Variables for Symmetries
| `partfrac`: |  | Functions and Variables for Number Theory
| `partition`: |  | Functions and Variables for Expressions
| `partition_set`: |  | Functions and Variables for Sets
| `partpol`: |  | Functions and Variables for Symmetries
| partswitch: |  | Functions and Variables for Expressions
| `pathname_directory`: |  | Functions and Variables for File Input and Output
| `pathname_name`: |  | Functions and Variables for File Input and Output
| `pathname_type`: |  | Functions and Variables for File Input and Output
| `path_digraph`: |  | Functions and Variables for graphs
| `path_graph`: |  | Functions and Variables for graphs
| `pdf_bernoulli`: |  | Functions and Variables for discrete distributions
| `pdf_beta`: |  | Functions and Variables for continuous distributions
| `pdf_binomial`: |  | Functions and Variables for discrete distributions
| `pdf_cauchy`: |  | Functions and Variables for continuous distributions
| `pdf_chi2`: |  | Functions and Variables for continuous distributions
| `pdf_continuous_uniform`: |  | Functions and Variables for continuous distributions
| `pdf_discrete_uniform`: |  | Functions and Variables for discrete distributions
| `pdf_exp`: |  | Functions and Variables for continuous distributions
| `pdf_f`: |  | Functions and Variables for continuous distributions
| `pdf_gamma`: |  | Functions and Variables for continuous distributions
| `pdf_general_finite_discrete`: |  | Functions and Variables for discrete distributions
| `pdf_geometric`: |  | Functions and Variables for discrete distributions
| `pdf_gumbel`: |  | Functions and Variables for continuous distributions
| `pdf_hypergeometric`: |  | Functions and Variables for discrete distributions
| `pdf_laplace`: |  | Functions and Variables for continuous distributions
| `pdf_logistic`: |  | Functions and Variables for continuous distributions
| `pdf_lognormal`: |  | Functions and Variables for continuous distributions
| `pdf_negative_binomial`: |  | Functions and Variables for discrete distributions
| `pdf_noncentral_chi2`: |  | Functions and Variables for continuous distributions
| `pdf_noncentral_student_t`: |  | Functions and Variables for continuous distributions
| `pdf_normal`: |  | Functions and Variables for continuous distributions
| `pdf_pareto`: |  | Functions and Variables for continuous distributions
| `pdf_poisson`: |  | Functions and Variables for discrete distributions
| `pdf_rank_sum`: |  | Functions and Variables for special distributions
| `pdf_rayleigh`: |  | Functions and Variables for continuous distributions
| `pdf_signed_rank`: |  | Functions and Variables for special distributions
| `pdf_student_t`: |  | Functions and Variables for continuous distributions
| `pdf_weibull`: |  | Functions and Variables for continuous distributions
| `pearson_skewness`: |  | Functions and Variables for descriptive statistics
| `pearson_skewness`: |  | Functions and Variables for descriptive statistics
| `permanent`: |  | Functions and Variables for Matrices and Linear Algebra
| `permut`: |  | Functions and Variables for Symmetries
| `permutation`: |  | Package functs
| `permutations`: |  | Functions and Variables for Sets
| `petersen_graph`: |  | Functions and Variables for graphs
| `petersen_graph`: |  | Functions and Variables for graphs
| `petrov`: |  | Functions and Variables for ctensor
| pfeformat: |  | Functions and Variables for Display
| `pickapart`: |  | Functions and Variables for Expressions
| `picturep`: |  | Functions and Variables for pictures
| `picture_equalp`: |  | Functions and Variables for pictures
| piece: |  | Functions and Variables for Expressions
| `piechart`: |  | Functions and Variables for statistical graphs
| `piechart`: |  | Functions and Variables for statistical graphs
| `piechart`: |  | Functions and Variables for statistical graphs
| `piechart`: |  | Functions and Variables for statistical graphs
| `piechart`: |  | Functions and Variables for statistical graphs
| `piechart`: |  | Functions and Variables for statistical graphs
| `piechart_description`: |  | Functions and Variables for statistical graphs
| `planar_embedding`: |  | Functions and Variables for graphs
| `playback`: |  | Functions and Variables for Command Line
| `playback`: |  | Functions and Variables for Command Line
| `playback`: |  | Functions and Variables for Command Line
| `playback`: |  | Functions and Variables for Command Line
| `playback`: |  | Functions and Variables for Command Line
| `playback`: |  | Functions and Variables for Command Line
| `playback`: |  | Functions and Variables for Command Line
| `playback`: |  | Functions and Variables for Command Line
| `plog`: |  | Root Exponential and Logarithmic Functions
| `plot2d`: |  | Functions and Variables for Plotting
| `plot2d`: |  | Functions and Variables for Plotting
| `plot2d`: |  | Functions and Variables for Plotting
| `plot3d`: |  | Functions and Variables for Plotting
| `plot3d`: |  | Functions and Variables for Plotting
| `plotdf`: |  | Functions and Variables for plotdf
| `plotdf`: |  | Functions and Variables for plotdf
| `plotdf`: |  | Functions and Variables for plotdf
| `plotdf`: |  | Functions and Variables for plotdf
| plot_format: |  | Plotting Options
| plot_options: |  | Functions and Variables for Plotting
| plot_real_part: |  | Plotting Options
| `plsquares`: |  | Functions and Variables for lsquares
| `plsquares`: |  | Functions and Variables for lsquares
| `plsquares`: |  | Functions and Variables for lsquares
| `pochhammer`: |  | Functions and Variables for orthogonal polynomials
| pochhammer_max_index: |  | Functions and Variables for orthogonal polynomials
| `points`: |  | Functions and Variables for draw
| `points`: |  | Functions and Variables for draw
| `points`: |  | Functions and Variables for draw
| `points`: |  | Functions and Variables for draw
| `points`: |  | Functions and Variables for draw
| `points`: |  | Functions and Variables for draw
| `points`: |  | Functions and Variables for draw
| `points`: |  | Functions and Variables for draw
| `points`: |  | Functions and Variables for draw
| `points`: |  | Functions and Variables for draw
| `points`: |  | Functions and Variables for draw
| points_joined: |  | Functions and Variables for draw
| point_size: |  | Functions and Variables for draw
| point_type: |  | Plotting Options
| point_type: |  | Functions and Variables for draw
| `poisdiff`: |  | Poisson series
| `poisexpt`: |  | Poisson series
| `poisint`: |  | Poisson series
| poislim: |  | Poisson series
| `poismap`: |  | Poisson series
| `poisplus`: |  | Poisson series
| `poissimp`: |  | Poisson series
| poisson: |  | Poisson series
| `poissubst`: |  | Poisson series
| `poistimes`: |  | Poisson series
| `poistrim`: |  | Poisson series
| `polar`: |  | Functions and Variables for draw
| `polarform`: |  | Functions for Complex Numbers
| `polartorect`: |  | Functions and Variables for fast Fourier transform
| `polar_to_xy`: |  | Functions and Variables for Plotting
| `polydecomp`: |  | Functions and Variables for Polynomials
| polyfactor: |  | Functions and Variables for Equations
| `polygon`: |  | Functions and Variables for draw
| `polygon`: |  | Functions and Variables for draw
| `polymod`: |  | Functions and Variables for Polynomials
| `polymod`: |  | Functions and Variables for Polynomials
| `polynome2ele`: |  | Functions and Variables for Symmetries
| `polynomialp`: |  | Functions and Variables for linearalgebra
| `polynomialp`: |  | Functions and Variables for linearalgebra
| `polynomialp`: |  | Functions and Variables for linearalgebra
| `polytocompanion`: |  | Functions and Variables for linearalgebra
| `poly_add`: |  | Functions and Variables for grobner
| `poly_buchberger`: |  | Functions and Variables for grobner
| `poly_buchberger_criterion`: |  | Functions and Variables for grobner
| poly_coefficient_ring: |  | Functions and Variables for grobner
| `poly_colon_ideal`: |  | Functions and Variables for grobner
| `poly_content`: |  | Functions and Variables for grobner
| `poly_depends_p`: |  | Functions and Variables for grobner
| `poly_elimination_ideal`: |  | Functions and Variables for grobner
| poly_elimination_order: |  | Functions and Variables for grobner
| `poly_exact_divide`: |  | Functions and Variables for grobner
| `poly_expand`: |  | Functions and Variables for grobner
| `poly_expt`: |  | Functions and Variables for grobner
| `poly_gcd`: |  | Functions and Variables for grobner
| `poly_grobner`: |  | Functions and Variables for grobner
| poly_grobner_algorithm: |  | Functions and Variables for grobner
| poly_grobner_debug: |  | Functions and Variables for grobner
| `poly_grobner_equal`: |  | Functions and Variables for grobner
| `poly_grobner_member`: |  | Functions and Variables for grobner
| `poly_grobner_subsetp`: |  | Functions and Variables for grobner
| `poly_ideal_intersection`: |  | Functions and Variables for grobner
| `poly_ideal_polysaturation`: |  | Functions and Variables for grobner
| `poly_ideal_polysaturation1`: |  | Functions and Variables for grobner
| `poly_ideal_saturation`: |  | Functions and Variables for grobner
| `poly_ideal_saturation1`: |  | Functions and Variables for grobner
| `poly_lcm`: |  | Functions and Variables for grobner
| `poly_minimization`: |  | Functions and Variables for grobner
| poly_monomial_order: |  | Functions and Variables for grobner
| `poly_multiply`: |  | Functions and Variables for grobner
| `poly_normalize`: |  | Functions and Variables for grobner
| `poly_normalize_list`: |  | Functions and Variables for grobner
| `poly_normal_form`: |  | Functions and Variables for grobner
| `poly_polysaturation_extension`: |  | Functions and Variables for grobner
| poly_primary_elimination_order: |  | Functions and Variables for grobner
| `poly_primitive_part`: |  | Functions and Variables for grobner
| `poly_pseudo_divide`: |  | Functions and Variables for grobner
| `poly_reduced_grobner`: |  | Functions and Variables for grobner
| `poly_reduction`: |  | Functions and Variables for grobner
| poly_return_term_list: |  | Functions and Variables for grobner
| `poly_saturation_extension`: |  | Functions and Variables for grobner
| poly_secondary_elimination_order: |  | Functions and Variables for grobner
| `poly_subtract`: |  | Functions and Variables for grobner
| `poly_s_polynomial`: |  | Functions and Variables for grobner
| poly_top_reduction_only: |  | Functions and Variables for grobner
| `pop`: |  | Functions and Variables for Lists
| posfun: |  | Functions and Variables for Properties
| `postfix`: |  | User defined operators
| `postfix`: |  | User defined operators
| `potential`: |  | Functions and Variables for Integration
| powerdisp: |  | Functions and Variables for Display
| `powers`: |  | Functions and Variables for Polynomials
| `powerseries`: |  | Functions and Variables for Series
| `powerset`: |  | Functions and Variables for Sets
| `powerset`: |  | Functions and Variables for Sets
| `power_mod`: |  | Functions and Variables for Number Theory
| pred: |  | Functions and Variables for Evaluation
| prederror: |  | Functions and Variables for Program Flow
| `prefix`: |  | User defined operators
| `prefix`: |  | User defined operators
| `prev_prime`: |  | Functions and Variables for Number Theory
| `primep`: |  | Functions and Variables for Number Theory
| primep_number_of_tests: |  | Functions and Variables for Number Theory
| `print`: |  | Functions and Variables for Display
| `printf`: |  | Functions and Variables for input and output
| `printf`: |  | Functions and Variables for input and output
| `printfile`: |  | Functions and Variables for File Input and Output
| `printpois`: |  | Poisson series
| `printprops`: |  | Functions and Variables for Properties
| `printprops`: |  | Functions and Variables for Properties
| `printprops`: |  | Functions and Variables for Properties
| `print_graph`: |  | Functions and Variables for graphs
| `prodrac`: |  | Functions and Variables for Symmetries
| `product`: |  | Sums and Products
| product_use_gamma: |  | Functions and Variables for solve_rec
| program: |  | Functions and Variables for graphs
| programmode: |  | Functions and Variables for Equations
| prompt: |  | Functions and Variables for Command Line
| `properties`: |  | Functions and Variables for Miscellaneous Options
| proportional_axes: |  | Functions and Variables for draw
| props: |  | Functions and Variables for Miscellaneous Options
| `propvars`: |  | Functions and Variables for Miscellaneous Options
| psexpand: |  | Functions and Variables for Series
| psfile: |  | Plotting Options
| `psi`: |  | Gamma and factorial Functions
| `psi`: |  | Functions and Variables for ctensor
| `psubst`: |  | Functions and Variables for Expressions
| `psubst`: |  | Functions and Variables for Expressions
| `ptriangularize`: |  | Functions and Variables for linearalgebra
| `pui`: |  | Functions and Variables for Symmetries
| `pui2comp`: |  | Functions and Variables for Symmetries
| `pui2ele`: |  | Functions and Variables for Symmetries
| `pui2polynome`: |  | Functions and Variables for Symmetries
| `puireduc`: |  | Functions and Variables for Symmetries
| `pui_direct`: |  | Functions and Variables for Symmetries
| `push`: |  | Functions and Variables for Lists
| `put`: |  | Functions and Variables for Miscellaneous Options
| `pv`: |  | Functions and Variables for finance
Q |  |
| `qput`: |  | Functions and Variables for Miscellaneous Options
| `qrange`: |  | Functions and Variables for descriptive statistics
| `qrange`: |  | Functions and Variables for descriptive statistics
| `qty`: |  | Functions and Variables for ezunits
| `quadrilateral`: |  | Functions and Variables for draw
| `quad_qag`: |  | Functions and Variables for QUADPACK
| `quad_qag`: |  | Functions and Variables for QUADPACK
| `quad_qagi`: |  | Functions and Variables for QUADPACK
| `quad_qagi`: |  | Functions and Variables for QUADPACK
| `quad_qags`: |  | Functions and Variables for QUADPACK
| `quad_qags`: |  | Functions and Variables for QUADPACK
| `quad_qawc`: |  | Functions and Variables for QUADPACK
| `quad_qawc`: |  | Functions and Variables for QUADPACK
| `quad_qawf`: |  | Functions and Variables for QUADPACK
| `quad_qawf`: |  | Functions and Variables for QUADPACK
| `quad_qawo`: |  | Functions and Variables for QUADPACK
| `quad_qawo`: |  | Functions and Variables for QUADPACK
| `quad_qaws`: |  | Functions and Variables for QUADPACK
| `quad_qaws`: |  | Functions and Variables for QUADPACK
| `quantile`: |  | Functions and Variables for descriptive statistics
| `quantile`: |  | Functions and Variables for descriptive statistics
| `quantile_bernoulli`: |  | Functions and Variables for discrete distributions
| `quantile_beta`: |  | Functions and Variables for continuous distributions
| `quantile_binomial`: |  | Functions and Variables for discrete distributions
| `quantile_cauchy`: |  | Functions and Variables for continuous distributions
| `quantile_chi2`: |  | Functions and Variables for continuous distributions
| `quantile_continuous_uniform`: |  | Functions and Variables for continuous distributions
| `quantile_discrete_uniform`: |  | Functions and Variables for discrete distributions
| `quantile_exp`: |  | Functions and Variables for continuous distributions
| `quantile_f`: |  | Functions and Variables for continuous distributions
| `quantile_gamma`: |  | Functions and Variables for continuous distributions
| `quantile_general_finite_discrete`: |  | Functions and Variables for discrete distributions
| `quantile_geometric`: |  | Functions and Variables for discrete distributions
| `quantile_gumbel`: |  | Functions and Variables for continuous distributions
| `quantile_hypergeometric`: |  | Functions and Variables for discrete distributions
| `quantile_laplace`: |  | Functions and Variables for continuous distributions
| `quantile_logistic`: |  | Functions and Variables for continuous distributions
| `quantile_lognormal`: |  | Functions and Variables for continuous distributions
| `quantile_negative_binomial`: |  | Functions and Variables for discrete distributions
| `quantile_noncentral_chi2`: |  | Functions and Variables for continuous distributions
| `quantile_noncentral_student_t`: |  | Functions and Variables for continuous distributions
| `quantile_normal`: |  | Functions and Variables for continuous distributions
| `quantile_pareto`: |  | Functions and Variables for continuous distributions
| `quantile_poisson`: |  | Functions and Variables for discrete distributions
| `quantile_rayleigh`: |  | Functions and Variables for continuous distributions
| `quantile_student_t`: |  | Functions and Variables for continuous distributions
| `quantile_weibull`: |  | Functions and Variables for continuous distributions
| `quartile_skewness`: |  | Functions and Variables for descriptive statistics
| `quartile_skewness`: |  | Functions and Variables for descriptive statistics
| `quit`: |  | Functions and Variables for Command Line
| `qunit`: |  | Functions and Variables for Number Theory
| `quotient`: |  | Functions and Variables for Polynomials
| `quotient`: |  | Functions and Variables for Polynomials
R |  |
| `radcan`: |  | Functions and Variables for Simplification
| radexpand: |  | Functions and Variables for Simplification
| `radius`: |  | Functions and Variables for graphs
| radsubstflag: |  | Functions and Variables for Polynomials
| `random`: |  | Random Numbers
| `random_bernoulli`: |  | Functions and Variables for discrete distributions
| `random_bernoulli`: |  | Functions and Variables for discrete distributions
| `random_beta`: |  | Functions and Variables for continuous distributions
| `random_beta`: |  | Functions and Variables for continuous distributions
| `random_binomial`: |  | Functions and Variables for discrete distributions
| `random_binomial`: |  | Functions and Variables for discrete distributions
| `random_bipartite_graph`: |  | Functions and Variables for graphs
| `random_cauchy`: |  | Functions and Variables for continuous distributions
| `random_cauchy`: |  | Functions and Variables for continuous distributions
| `random_chi2`: |  | Functions and Variables for continuous distributions
| `random_chi2`: |  | Functions and Variables for continuous distributions
| `random_continuous_uniform`: |  | Functions and Variables for continuous distributions
| `random_continuous_uniform`: |  | Functions and Variables for continuous distributions
| `random_digraph`: |  | Functions and Variables for graphs
| `random_discrete_uniform`: |  | Functions and Variables for discrete distributions
| `random_discrete_uniform`: |  | Functions and Variables for discrete distributions
| `random_exp`: |  | Functions and Variables for continuous distributions
| `random_exp`: |  | Functions and Variables for continuous distributions
| `random_f`: |  | Functions and Variables for continuous distributions
| `random_f`: |  | Functions and Variables for continuous distributions
| `random_gamma`: |  | Functions and Variables for continuous distributions
| `random_gamma`: |  | Functions and Variables for continuous distributions
| `random_general_finite_discrete`: |  | Functions and Variables for discrete distributions
| `random_general_finite_discrete`: |  | Functions and Variables for discrete distributions
| `random_geometric`: |  | Functions and Variables for discrete distributions
| `random_geometric`: |  | Functions and Variables for discrete distributions
| `random_graph`: |  | Functions and Variables for graphs
| `random_graph1`: |  | Functions and Variables for graphs
| `random_gumbel`: |  | Functions and Variables for continuous distributions
| `random_gumbel`: |  | Functions and Variables for continuous distributions
| `random_hypergeometric`: |  | Functions and Variables for discrete distributions
| `random_hypergeometric`: |  | Functions and Variables for discrete distributions
| `random_laplace`: |  | Functions and Variables for continuous distributions
| `random_laplace`: |  | Functions and Variables for continuous distributions
| `random_logistic`: |  | Functions and Variables for continuous distributions
| `random_logistic`: |  | Functions and Variables for continuous distributions
| `random_lognormal`: |  | Functions and Variables for continuous distributions
| `random_lognormal`: |  | Functions and Variables for continuous distributions
| `random_negative_binomial`: |  | Functions and Variables for discrete distributions
| `random_negative_binomial`: |  | Functions and Variables for discrete distributions
| `random_network`: |  | Functions and Variables for graphs
| `random_noncentral_chi2`: |  | Functions and Variables for continuous distributions
| `random_noncentral_chi2`: |  | Functions and Variables for continuous distributions
| `random_noncentral_student_t`: |  | Functions and Variables for continuous distributions
| `random_noncentral_student_t`: |  | Functions and Variables for continuous distributions
| `random_normal`: |  | Functions and Variables for continuous distributions
| `random_normal`: |  | Functions and Variables for continuous distributions
| `random_pareto`: |  | Functions and Variables for continuous distributions
| `random_pareto`: |  | Functions and Variables for continuous distributions
| `random_permutation`: |  | Functions and Variables for Sets
| `random_poisson`: |  | Functions and Variables for discrete distributions
| `random_poisson`: |  | Functions and Variables for discrete distributions
| `random_rayleigh`: |  | Functions and Variables for continuous distributions
| `random_rayleigh`: |  | Functions and Variables for continuous distributions
| `random_regular_graph`: |  | Functions and Variables for graphs
| `random_regular_graph`: |  | Functions and Variables for graphs
| `random_student_t`: |  | Functions and Variables for continuous distributions
| `random_student_t`: |  | Functions and Variables for continuous distributions
| `random_tournament`: |  | Functions and Variables for graphs
| `random_tree`: |  | Functions and Variables for graphs
| `random_weibull`: |  | Functions and Variables for continuous distributions
| `random_weibull`: |  | Functions and Variables for continuous distributions
| `range`: |  | Functions and Variables for descriptive statistics
| `range`: |  | Functions and Variables for descriptive statistics
| `rank`: |  | Functions and Variables for Matrices and Linear Algebra
| `rank`: |  | Functions and Variables for linearalgebra
| rassociative: |  | Functions and Variables for Simplification
| `rat`: |  | Functions and Variables for Polynomials
| `rat`: |  | Functions and Variables for Polynomials
| ratalgdenom: |  | Functions and Variables for Polynomials
| ratchristof: |  | Functions and Variables for ctensor
| `ratcoef`: |  | Functions and Variables for Polynomials
| `ratcoef`: |  | Functions and Variables for Polynomials
| `ratdenom`: |  | Functions and Variables for Polynomials
| ratdenomdivide: |  | Functions and Variables for Polynomials
| `ratdiff`: |  | Functions and Variables for Polynomials
| `ratdisrep`: |  | Functions and Variables for Polynomials
| rateinstein: |  | Functions and Variables for ctensor
| ratepsilon: |  | Functions and Variables for Numbers
| `ratexpand`: |  | Functions and Variables for Polynomials
| `ratexpand`: |  | Functions and Variables for Polynomials
| ratfac: |  | Functions and Variables for Polynomials
| `ratinterpol`: |  | Functions and Variables for interpol
| `ratinterpol`: |  | Functions and Variables for interpol
| `rational`: |  | Package functs
| `rationalize`: |  | Functions and Variables for Numbers
| ratmx: |  | Functions and Variables for Matrices and Linear Algebra
| `ratnumer`: |  | Functions and Variables for Polynomials
| `ratnump`: |  | Functions and Variables for Numbers
| `ratp`: |  | Functions and Variables for Polynomials
| ratprint: |  | Functions and Variables for Polynomials
| ratriemann: |  | Functions and Variables for ctensor
| `ratsimp`: |  | Functions and Variables for Polynomials
| `ratsimp`: |  | Functions and Variables for Polynomials
| ratsimpexpons: |  | Functions and Variables for Polynomials
| `ratsubst`: |  | Functions and Variables for Polynomials
| `ratvars`: |  | Functions and Variables for Polynomials
| `ratvars`: |  | Functions and Variables for Polynomials
| `ratvars`: |  | Functions and Variables for Polynomials
| ratvarswitch: |  | Functions and Variables for Polynomials
| `ratweight`: |  | Functions and Variables for Polynomials
| `ratweight`: |  | Functions and Variables for Polynomials
| ratweights: |  | Functions and Variables for Polynomials
| ratweyl: |  | Functions and Variables for ctensor
| ratwtlvl: |  | Functions and Variables for Polynomials
| `read`: |  | Functions and Variables for Command Line
| `readline`: |  | Functions and Variables for input and output
| `readonly`: |  | Functions and Variables for Command Line
| `read_array`: |  | Functions and Variables for plain-text input and output
| `read_array`: |  | Functions and Variables for plain-text input and output
| `read_binary_array`: |  | Functions and Variables for binary input and output
| `read_binary_list`: |  | Functions and Variables for binary input and output
| `read_binary_list`: |  | Functions and Variables for binary input and output
| `read_binary_matrix`: |  | Functions and Variables for binary input and output
| `read_hashed_array`: |  | Functions and Variables for plain-text input and output
| `read_hashed_array`: |  | Functions and Variables for plain-text input and output
| `read_list`: |  | Functions and Variables for plain-text input and output
| `read_list`: |  | Functions and Variables for plain-text input and output
| `read_list`: |  | Functions and Variables for plain-text input and output
| `read_list`: |  | Functions and Variables for plain-text input and output
| `read_matrix`: |  | Functions and Variables for plain-text input and output
| `read_matrix`: |  | Functions and Variables for plain-text input and output
| `read_matrix`: |  | Functions and Variables for plain-text input and output
| `read_matrix`: |  | Functions and Variables for plain-text input and output
| `read_nested_list`: |  | Functions and Variables for plain-text input and output
| `read_nested_list`: |  | Functions and Variables for plain-text input and output
| `read_xpm`: |  | Functions and Variables for pictures
| realonly: |  | Functions and Variables for Equations
| `realpart`: |  | Functions for Complex Numbers
| `realroots`: |  | Functions and Variables for Equations
| `realroots`: |  | Functions and Variables for Equations
| `realroots`: |  | Functions and Variables for Equations
| `realroots`: |  | Functions and Variables for Equations
| `real_imagpart_to_conjugate`: |  | Functions and Variables for to_poly_solve
| `rearray`: |  | Functions and Variables for Arrays
| `rectangle`: |  | Functions and Variables for draw
| `rectform`: |  | Functions for Complex Numbers
| `rectform_log_if_constant`: |  | Functions and Variables for to_poly_solve
| `recttopolar`: |  | Functions and Variables for fast Fourier transform
| `rediff`: |  | Functions and Variables for itensor
| redraw: |  | Functions and Variables for graphs
| `reduce_consts`: |  | Package rducon
| `reduce_order`: |  | Functions and Variables for solve_rec
| refcheck: |  | Functions and Variables for Debugging
| `region`: |  | Functions and Variables for draw
| `region_boundaries`: |  | Functions and Variables for worldmap
| `region_boundaries_plus`: |  | Functions and Variables for worldmap
| `rem`: |  | Functions and Variables for Miscellaneous Options
| `remainder`: |  | Functions and Variables for Polynomials
| `remainder`: |  | Functions and Variables for Polynomials
| `remarray`: |  | Functions and Variables for Arrays
| `remarray`: |  | Functions and Variables for Arrays
| `rembox`: |  | Functions and Variables for Expressions
| `rembox`: |  | Functions and Variables for Expressions
| `rembox`: |  | Functions and Variables for Expressions
| `remcomps`: |  | Functions and Variables for itensor
| `remcon`: |  | Functions and Variables for itensor
| `remcon`: |  | Functions and Variables for itensor
| `remcoord`: |  | Functions and Variables for itensor
| `remcoord`: |  | Functions and Variables for itensor
| `remfun`: |  | Functions and Variables for Fourier series
| `remfun`: |  | Functions and Variables for Fourier series
| `remfunction`: |  | Functions and Variables for Function Definition
| `remfunction`: |  | Functions and Variables for Function Definition
| `remlet`: |  | Functions and Variables for Rules and Patterns
| `remlet`: |  | Functions and Variables for Rules and Patterns
| `remlet`: |  | Functions and Variables for Rules and Patterns
| `remlet`: |  | Functions and Variables for Rules and Patterns
| `remove`: |  | Functions and Variables for Miscellaneous Options
| `remove`: |  | Functions and Variables for Miscellaneous Options
| `remove`: |  | Functions and Variables for Miscellaneous Options
| `remove`: |  | Functions and Variables for Miscellaneous Options
| `remove`: |  | Functions and Variables for Miscellaneous Options
| `remove_constvalue`: |  | Functions and Variables for ezunits
| `remove_dimensions`: |  | Functions and Variables for ezunits
| `remove_edge`: |  | Functions and Variables for graphs
| `remove_fundamental_dimensions`: |  | Functions and Variables for ezunits
| `remove_fundamental_units`: |  | Functions and Variables for ezunits
| `remove_vertex`: |  | Functions and Variables for graphs
| `rempart`: |  | Package functs
| `remrule`: |  | Functions and Variables for Rules and Patterns
| `remrule`: |  | Functions and Variables for Rules and Patterns
| `remsym`: |  | Functions and Variables for itensor
| `remvalue`: |  | Functions and Variables for Miscellaneous Options
| `remvalue`: |  | Functions and Variables for Miscellaneous Options
| `rename`: |  | Functions and Variables for itensor
| `rename`: |  | Functions and Variables for itensor
| `reset`: |  | Functions and Variables for Command Line
| `residue`: |  | Functions and Variables for Integration
| `resolvante`: |  | Functions and Variables for Symmetries
| `resolvante_alternee1`: |  | Functions and Variables for Symmetries
| `resolvante_bipartite`: |  | Functions and Variables for Symmetries
| `resolvante_diedrale`: |  | Functions and Variables for Symmetries
| `resolvante_klein`: |  | Functions and Variables for Symmetries
| `resolvante_klein3`: |  | Functions and Variables for Symmetries
| `resolvante_produit_sym`: |  | Functions and Variables for Symmetries
| `resolvante_unitaire`: |  | Functions and Variables for Symmetries
| `resolvante_vierer`: |  | Functions and Variables for Symmetries
| `rest`: |  | Functions and Variables for Lists
| `rest`: |  | Functions and Variables for Lists
| `resultant`: |  | Functions and Variables for Polynomials
| `resultant`: |  | Functions and Variables for Polynomials
| `return`: |  | Functions and Variables for Program Flow
| `reveal`: |  | Functions and Variables for Expressions
| `reverse`: |  | Functions and Variables for Lists
| `revert`: |  | Functions and Variables for Series
| `revert2`: |  | Functions and Variables for Series
| `rgb2level`: |  | Functions and Variables for pictures
| `rhs`: |  | Functions and Variables for Equations
| ric: |  | Functions and Variables for ctensor
| `ricci`: |  | Functions and Variables for ctensor
| riem: |  | Functions and Variables for ctensor
| `riemann`: |  | Functions and Variables for ctensor
| `rinvariant`: |  | Functions and Variables for ctensor
| `risch`: |  | Functions and Variables for Integration
| `rk`: |  | Functions and Variables for dynamics
| `rk`: |  | Functions and Variables for dynamics
| rmxchar: |  | Functions and Variables for Matrices and Linear Algebra
| `rncombine`: |  | Functions and Variables for Miscellaneous Options
| `romberg`: |  | Functions and Variables for romberg
| `romberg`: |  | Functions and Variables for romberg
| rombergabs: |  | Functions and Variables for romberg
| rombergit: |  | Functions and Variables for romberg
| rombergmin: |  | Functions and Variables for romberg
| rombergtol: |  | Functions and Variables for romberg
| `room`: |  | Functions and Variables for Runtime Environment
| `room`: |  | Functions and Variables for Runtime Environment
| `room`: |  | Functions and Variables for Runtime Environment
| rootsconmode: |  | Functions and Variables for Equations
| `rootscontract`: |  | Functions and Variables for Equations
| rootsepsilon: |  | Functions and Variables for Equations
| `round`: |  | Functions for Numbers
| `row`: |  | Functions and Variables for Matrices and Linear Algebra
| `rowop`: |  | Functions and Variables for linearalgebra
| `rowswap`: |  | Functions and Variables for linearalgebra
| `rreduce`: |  | Functions and Variables for Sets
| `rreduce`: |  | Functions and Variables for Sets
| `run_testsuite`: |  | Functions and Variables for Bug Detection and Reporting
| run_viewer: |  | Plotting Options
S |  |
| `save`: |  | Functions and Variables for File Input and Output
| `save`: |  | Functions and Variables for File Input and Output
| `save`: |  | Functions and Variables for File Input and Output
| `save`: |  | Functions and Variables for File Input and Output
| `save`: |  | Functions and Variables for File Input and Output
| `save`: |  | Functions and Variables for File Input and Output
| savedef: |  | Functions and Variables for Function Definition
| savefactors: |  | Functions and Variables for Polynomials
| `saving`: |  | Functions and Variables for finance
| scalarmatrixp: |  | Functions and Variables for Matrices and Linear Algebra
| `scalarp`: |  | Functions and Variables for Miscellaneous Options
| `scaled_bessel_i`: |  | Bessel Functions
| `scaled_bessel_i0`: |  | Bessel Functions
| `scaled_bessel_i1`: |  | Bessel Functions
| `scalefactors`: |  | Functions and Variables for Matrices and Linear Algebra
| `scanmap`: |  | Functions and Variables for Program Flow
| `scanmap`: |  | Functions and Variables for Program Flow
| `scatterplot`: |  | Functions and Variables for statistical graphs
| `scatterplot`: |  | Functions and Variables for statistical graphs
| `scatterplot`: |  | Functions and Variables for statistical graphs
| `scatterplot`: |  | Functions and Variables for statistical graphs
| `scatterplot_description`: |  | Functions and Variables for statistical graphs
| `schur2comp`: |  | Functions and Variables for Symmetries
| `sconcat`: |  | Functions and Variables for Strings
| `scopy`: |  | Functions and Variables for strings
| `scsimp`: |  | Functions and Variables for Simplification
| `scurvature`: |  | Functions and Variables for ctensor
| `sdowncase`: |  | Functions and Variables for strings
| `sdowncase`: |  | Functions and Variables for strings
| `sdowncase`: |  | Functions and Variables for strings
| `sec`: |  | Functions and Variables for Trigonometric
| `sech`: |  | Functions and Variables for Trigonometric
| `second`: |  | Functions and Variables for Lists
| `sequal`: |  | Functions and Variables for strings
| `sequalignore`: |  | Functions and Variables for strings
| setcheck: |  | Functions and Variables for Debugging
| setcheckbreak: |  | Functions and Variables for Debugging
| `setdifference`: |  | Functions and Variables for Sets
| `setelmx`: |  | Functions and Variables for Matrices and Linear Algebra
| `setequalp`: |  | Functions and Variables for Sets
| `setify`: |  | Functions and Variables for Sets
| `setp`: |  | Functions and Variables for Sets
| `setunits`: |  | Functions and Variables for Units
| `setup_autoload`: |  | Functions and Variables for Miscellaneous Options
| setval: |  | Functions and Variables for Debugging
| `set_draw_defaults`: |  | Functions and Variables for draw
| `set_edge_weight`: |  | Functions and Variables for graphs
| `set_partitions`: |  | Functions and Variables for Sets
| `set_partitions`: |  | Functions and Variables for Sets
| `set_plot_option`: |  | Functions and Variables for Plotting
| `set_random_state`: |  | Random Numbers
| `set_tex_environment`: |  | Functions and Variables for File Input and Output
| `set_tex_environment_default`: |  | Functions and Variables for File Input and Output
| `set_up_dot_simplifications`: |  | Functions and Variables for Affine
| `set_up_dot_simplifications`: |  | Functions and Variables for Affine
| `set_vertex_label`: |  | Functions and Variables for graphs
| `seventh`: |  | Functions and Variables for Lists
| `sexplode`: |  | Functions and Variables for strings
| `sf`: |  | Functions and Variables for atensor
| `shortest_path`: |  | Functions and Variables for graphs
| `shortest_weighted_path`: |  | Functions and Variables for graphs
| `show`: |  | Functions and Variables for itensor
| `showcomps`: |  | Functions and Variables for itensor
| `showratvars`: |  | Functions and Variables for Polynomials
| showtime: |  | Functions and Variables for Command Line
| show_edges: |  | Functions and Variables for graphs
| show_edge_color: |  | Functions and Variables for graphs
| show_edge_type: |  | Functions and Variables for graphs
| show_edge_width: |  | Functions and Variables for graphs
| show_id: |  | Functions and Variables for graphs
| show_label: |  | Functions and Variables for graphs
| show_vertex_color: |  | Functions and Variables for graphs
| show_vertex_size: |  | Functions and Variables for graphs
| show_vertex_type: |  | Functions and Variables for graphs
| show_vertices: |  | Functions and Variables for graphs
| show_weight: |  | Functions and Variables for graphs
| `sierpinskiale`: |  | Definitions for IFS fractals
| `sierpinskimap`: |  | Definitions for Peano maps
| `sign`: |  | Functions and Variables for Facts
| `signum`: |  | Functions for Numbers
| `similaritytransform`: |  | Functions and Variables for Matrices and Linear Algebra
| simp: |  | Functions and Variables for Simplification
| `simple_linear_regression`: |  | Functions and Variables for stats
| `simple_linear_regression`: |  | Functions and Variables for stats
| simplified_output: |  | Functions and Variables for zeilberger
| simplify_products: |  | Functions and Variables for solve_rec
| `simplify_sum`: |  | Functions and Variables for solve_rec
| `simplode`: |  | Functions and Variables for strings
| `simplode`: |  | Functions and Variables for strings
| `simpmetderiv`: |  | Functions and Variables for itensor
| `simpmetderiv`: |  | Functions and Variables for itensor
| simpsum: |  | Sums and Products
| `simp_inequality`: |  | Functions and Variables for to_poly_solve
| `simtran`: |  | Functions and Variables for Matrices and Linear Algebra
| `sin`: |  | Functions and Variables for Trigonometric
| `sinh`: |  | Functions and Variables for Trigonometric
| sinnpiflag: |  | Functions and Variables for Fourier series
| `sinsert`: |  | Functions and Variables for strings
| `sinvertcase`: |  | Functions and Variables for strings
| `sinvertcase`: |  | Functions and Variables for strings
| `sinvertcase`: |  | Functions and Variables for strings
| `sixth`: |  | Functions and Variables for Lists
| `skewness`: |  | Functions and Variables for descriptive statistics
| `skewness`: |  | Functions and Variables for descriptive statistics
| `skewness_bernoulli`: |  | Functions and Variables for discrete distributions
| `skewness_beta`: |  | Functions and Variables for continuous distributions
| `skewness_binomial`: |  | Functions and Variables for discrete distributions
| `skewness_chi2`: |  | Functions and Variables for continuous distributions
| `skewness_continuous_uniform`: |  | Functions and Variables for continuous distributions
| `skewness_discrete_uniform`: |  | Functions and Variables for discrete distributions
| `skewness_exp`: |  | Functions and Variables for continuous distributions
| `skewness_f`: |  | Functions and Variables for continuous distributions
| `skewness_gamma`: |  | Functions and Variables for continuous distributions
| `skewness_general_finite_discrete`: |  | Functions and Variables for discrete distributions
| `skewness_geometric`: |  | Functions and Variables for discrete distributions
| `skewness_gumbel`: |  | Functions and Variables for continuous distributions
| `skewness_hypergeometric`: |  | Functions and Variables for discrete distributions
| `skewness_laplace`: |  | Functions and Variables for continuous distributions
| `skewness_logistic`: |  | Functions and Variables for continuous distributions
| `skewness_lognormal`: |  | Functions and Variables for continuous distributions
| `skewness_negative_binomial`: |  | Functions and Variables for discrete distributions
| `skewness_noncentral_chi2`: |  | Functions and Variables for continuous distributions
| `skewness_noncentral_student_t`: |  | Functions and Variables for continuous distributions
| `skewness_normal`: |  | Functions and Variables for continuous distributions
| `skewness_pareto`: |  | Functions and Variables for continuous distributions
| `skewness_poisson`: |  | Functions and Variables for discrete distributions
| `skewness_rayleigh`: |  | Functions and Variables for continuous distributions
| `skewness_student_t`: |  | Functions and Variables for continuous distributions
| `skewness_weibull`: |  | Functions and Variables for continuous distributions
| `slength`: |  | Functions and Variables for strings
| `smake`: |  | Functions and Variables for strings
| `small_rhombicosidodecahedron_graph`: |  | Functions and Variables for graphs
| `small_rhombicuboctahedron_graph`: |  | Functions and Variables for graphs
| `smax`: |  | Functions and Variables for descriptive statistics
| `smax`: |  | Functions and Variables for descriptive statistics
| `smin`: |  | Functions and Variables for descriptive statistics
| `smin`: |  | Functions and Variables for descriptive statistics
| `smismatch`: |  | Functions and Variables for strings
| `smismatch`: |  | Functions and Variables for strings
| `snowmap`: |  | Definitions for Koch snowflakes
| `snub_cube_graph`: |  | Functions and Variables for graphs
| `snub_dodecahedron_graph`: |  | Functions and Variables for graphs
| `solve`: |  | Functions and Variables for Equations
| `solve`: |  | Functions and Variables for Equations
| `solve`: |  | Functions and Variables for Equations
| solvedecomposes: |  | Functions and Variables for Equations
| solveexplicit: |  | Functions and Variables for Equations
| solvefactors: |  | Functions and Variables for Equations
| solvenullwarn: |  | Functions and Variables for Equations
| solveradcan: |  | Functions and Variables for Equations
| solvetrigwarn: |  | Functions and Variables for Equations
| `solve_rec`: |  | Functions and Variables for solve_rec
| `solve_rec_rat`: |  | Functions and Variables for solve_rec
| `some`: |  | Functions and Variables for Sets
| `some`: |  | Functions and Variables for Sets
| `somrac`: |  | Functions and Variables for Symmetries
| `sort`: |  | Functions and Variables for Lists
| `sort`: |  | Functions and Variables for Lists
| space: |  | Functions and Variables for characters
| sparse: |  | Functions and Variables for Matrices and Linear Algebra
| `sparse6_decode`: |  | Functions and Variables for graphs
| `sparse6_encode`: |  | Functions and Variables for graphs
| `sparse6_export`: |  | Functions and Variables for graphs
| `sparse6_import`: |  | Functions and Variables for graphs
| `specint`: |  | Functions and Variables for Special Functions
| `spherical`: |  | Functions and Variables for draw
| `spherical_bessel_j`: |  | Functions and Variables for orthogonal polynomials
| `spherical_bessel_y`: |  | Functions and Variables for orthogonal polynomials
| `spherical_hankel1`: |  | Functions and Variables for orthogonal polynomials
| `spherical_hankel2`: |  | Functions and Variables for orthogonal polynomials
| `spherical_harmonic`: |  | Functions and Variables for orthogonal polynomials
| `spherical_to_xyz`: |  | Functions and Variables for Plotting
| `splice`: |  | Macros
| `split`: |  | Functions and Variables for strings
| `split`: |  | Functions and Variables for strings
| `split`: |  | Functions and Variables for strings
| `sposition`: |  | Functions and Variables for strings
| spring_embedding_depth: |  | Functions and Variables for graphs
| `sprint`: |  | Functions and Variables for input and output
| `sqfr`: |  | Functions and Variables for Polynomials
| `sqrt`: |  | Root Exponential and Logarithmic Functions
| `sqrtdenest`: |  | Package sqdnst
| sqrtdispflag: |  | Functions and Variables for Display
| `sremove`: |  | Functions and Variables for strings
| `sremove`: |  | Functions and Variables for strings
| `sremove`: |  | Functions and Variables for strings
| `sremove`: |  | Functions and Variables for strings
| `sremovefirst`: |  | Functions and Variables for strings
| `sremovefirst`: |  | Functions and Variables for strings
| `sremovefirst`: |  | Functions and Variables for strings
| `sremovefirst`: |  | Functions and Variables for strings
| `sreverse`: |  | Functions and Variables for strings
| `ssearch`: |  | Functions and Variables for strings
| `ssearch`: |  | Functions and Variables for strings
| `ssearch`: |  | Functions and Variables for strings
| `ssearch`: |  | Functions and Variables for strings
| `ssort`: |  | Functions and Variables for strings
| `ssort`: |  | Functions and Variables for strings
| `sstatus`: |  | Functions and Variables for Runtime Environment
| `ssubst`: |  | Functions and Variables for strings
| `ssubst`: |  | Functions and Variables for strings
| `ssubst`: |  | Functions and Variables for strings
| `ssubst`: |  | Functions and Variables for strings
| `ssubstfirst`: |  | Functions and Variables for strings
| `ssubstfirst`: |  | Functions and Variables for strings
| `ssubstfirst`: |  | Functions and Variables for strings
| `ssubstfirst`: |  | Functions and Variables for strings
| `staircase`: |  | Functions and Variables for dynamics
| `standardize_inverse_trig`: |  | Functions and Variables for to_poly_solve
| stardisp: |  | Functions and Variables for Display
| `starplot`: |  | Functions and Variables for statistical graphs
| `starplot_description`: |  | Functions and Variables for statistical graphs
| stats_numer: |  | Functions and Variables for stats
| `status`: |  | Functions and Variables for Runtime Environment
| `status`: |  | Functions and Variables for Runtime Environment
| `std`: |  | Functions and Variables for descriptive statistics
| `std`: |  | Functions and Variables for descriptive statistics
| `std1`: |  | Functions and Variables for descriptive statistics
| `std1`: |  | Functions and Variables for descriptive statistics
| `std_bernoulli`: |  | Functions and Variables for discrete distributions
| `std_beta`: |  | Functions and Variables for continuous distributions
| `std_binomial`: |  | Functions and Variables for discrete distributions
| `std_chi2`: |  | Functions and Variables for continuous distributions
| `std_continuous_uniform`: |  | Functions and Variables for continuous distributions
| `std_discrete_uniform`: |  | Functions and Variables for discrete distributions
| `std_exp`: |  | Functions and Variables for continuous distributions
| `std_f`: |  | Functions and Variables for continuous distributions
| `std_gamma`: |  | Functions and Variables for continuous distributions
| `std_general_finite_discrete`: |  | Functions and Variables for discrete distributions
| `std_geometric`: |  | Functions and Variables for discrete distributions
| `std_gumbel`: |  | Functions and Variables for continuous distributions
| `std_hypergeometric`: |  | Functions and Variables for discrete distributions
| `std_laplace`: |  | Functions and Variables for continuous distributions
| `std_logistic`: |  | Functions and Variables for continuous distributions
| `std_lognormal`: |  | Functions and Variables for continuous distributions
| `std_negative_binomial`: |  | Functions and Variables for discrete distributions
| `std_noncentral_chi2`: |  | Functions and Variables for continuous distributions
| `std_noncentral_student_t`: |  | Functions and Variables for continuous distributions
| `std_normal`: |  | Functions and Variables for continuous distributions
| `std_pareto`: |  | Functions and Variables for continuous distributions
| `std_poisson`: |  | Functions and Variables for discrete distributions
| `std_rayleigh`: |  | Functions and Variables for continuous distributions
| `std_student_t`: |  | Functions and Variables for continuous distributions
| `std_weibull`: |  | Functions and Variables for continuous distributions
| `stemplot`: |  | Functions and Variables for statistical graphs
| `stemplot`: |  | Functions and Variables for statistical graphs
| `stirling`: |  | Functions and Variables for stirling
| `stirling`: |  | Functions and Variables for stirling
| `stirling1`: |  | Functions and Variables for Sets
| `stirling2`: |  | Functions and Variables for Sets
| `strim`: |  | Functions and Variables for strings
| `striml`: |  | Functions and Variables for strings
| `strimr`: |  | Functions and Variables for strings
| `string`: |  | Functions and Variables for Strings
| stringdisp: |  | Functions and Variables for Strings
| `stringout`: |  | Functions and Variables for File Input and Output
| `stringout`: |  | Functions and Variables for File Input and Output
| `stringout`: |  | Functions and Variables for File Input and Output
| `stringout`: |  | Functions and Variables for File Input and Output
| `stringout`: |  | Functions and Variables for File Input and Output
| `stringp`: |  | Functions and Variables for strings
| `strong_components`: |  | Functions and Variables for graphs
| structures: |  | Functions and Variables for Structures
| `struve_h`: |  | Struve Functions
| `struve_l`: |  | Struve Functions
| style: |  | Plotting Options
| style: |  | Plotting Options
| `sublis`: |  | Functions and Variables for Expressions
| `sublist`: |  | Functions and Variables for Lists
| `sublist_indices`: |  | Functions and Variables for Lists
| sublis_apply_lambda: |  | Functions and Variables for Expressions
| `submatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `submatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `submatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| subnumsimp: |  | Functions and Variables for Expressions
| `subsample`: |  | Functions and Variables for data manipulation
| `subsample`: |  | Functions and Variables for data manipulation
| `subset`: |  | Functions and Variables for Sets
| `subsetp`: |  | Functions and Variables for Sets
| `subst`: |  | Functions and Variables for Expressions
| `substinpart`: |  | Functions and Variables for Expressions
| `substpart`: |  | Functions and Variables for Expressions
| `substring`: |  | Functions and Variables for strings
| `substring`: |  | Functions and Variables for strings
| `subst_parallel`: |  | Functions and Variables for to_poly_solve
| `subvar`: |  | Functions and Variables for Arrays
| `subvarp`: |  | Functions and Variables for Arrays
| `sum`: |  | Sums and Products
| `sumcontract`: |  | Sums and Products
| sumexpand: |  | Sums and Products
| `summand_to_rec`: |  | Functions and Variables for solve_rec
| `summand_to_rec`: |  | Functions and Variables for solve_rec
| sumsplitfact: |  | Combinatorial Functions
| `supcase`: |  | Functions and Variables for strings
| `supcase`: |  | Functions and Variables for strings
| `supcase`: |  | Functions and Variables for strings
| `supcontext`: |  | Functions and Variables for Facts
| `supcontext`: |  | Functions and Variables for Facts
| surface_hide: |  | Functions and Variables for draw
| `symbolp`: |  | Functions and Variables for Expressions
| `symmdifference`: |  | Functions and Variables for Sets
| symmetric: |  | Functions and Variables for Simplification
| `symmetricp`: |  | Functions and Variables for ctensor
| `system`: |  | Functions and Variables for Runtime Environment
T |  |
| t: |  | Plotting Options
| tab: |  | Functions and Variables for characters
| `take_channel`: |  | Functions and Variables for pictures
| `take_inference`: |  | Functions and Variables for inference_result
| `take_inference`: |  | Functions and Variables for inference_result
| `take_inference`: |  | Functions and Variables for inference_result
| `tan`: |  | Functions and Variables for Trigonometric
| `tanh`: |  | Functions and Variables for Trigonometric
| `taylor`: |  | Functions and Variables for Series
| `taylor`: |  | Functions and Variables for Series
| `taylor`: |  | Functions and Variables for Series
| `taylor`: |  | Functions and Variables for Series
| `taylor`: |  | Functions and Variables for Series
| taylordepth: |  | Functions and Variables for Series
| `taylorinfo`: |  | Functions and Variables for Series
| `taylorp`: |  | Functions and Variables for Series
| taylor_logexpand: |  | Functions and Variables for Series
| taylor_order_coefficients: |  | Functions and Variables for Series
| `taylor_simplifier`: |  | Functions and Variables for Series
| taylor_truncate_polynomials: |  | Functions and Variables for Series
| `taytorat`: |  | Functions and Variables for Series
| `tcl_output`: |  | Functions and Variables for File Input and Output
| `tcl_output`: |  | Functions and Variables for File Input and Output
| `tcl_output`: |  | Functions and Variables for File Input and Output
| `tcontract`: |  | Functions and Variables for Symmetries
| `tellrat`: |  | Functions and Variables for Polynomials
| `tellrat`: |  | Functions and Variables for Polynomials
| `tellsimp`: |  | Functions and Variables for Rules and Patterns
| `tellsimpafter`: |  | Functions and Variables for Rules and Patterns
| tensorkill: |  | Functions and Variables for ctensor
| `tentex`: |  | Functions and Variables for itensor
| `tenth`: |  | Functions and Variables for Lists
| terminal: |  | Functions and Variables for draw
| terminal: |  | Functions and Variables for graphs
| testsuite_files: |  | Functions and Variables for Bug Detection and Reporting
| `test_mean`: |  | Functions and Variables for stats
| `test_mean`: |  | Functions and Variables for stats
| `test_means_difference`: |  | Functions and Variables for stats
| `test_means_difference`: |  | Functions and Variables for stats
| `test_normality`: |  | Functions and Variables for stats
| `test_proportion`: |  | Functions and Variables for stats
| `test_proportion`: |  | Functions and Variables for stats
| `test_proportions_difference`: |  | Functions and Variables for stats
| `test_proportions_difference`: |  | Functions and Variables for stats
| `test_rank_sum`: |  | Functions and Variables for stats
| `test_rank_sum`: |  | Functions and Variables for stats
| `test_sign`: |  | Functions and Variables for stats
| `test_sign`: |  | Functions and Variables for stats
| `test_signed_rank`: |  | Functions and Variables for stats
| `test_signed_rank`: |  | Functions and Variables for stats
| `test_variance`: |  | Functions and Variables for stats
| `test_variance`: |  | Functions and Variables for stats
| `test_variance_ratio`: |  | Functions and Variables for stats
| `test_variance_ratio`: |  | Functions and Variables for stats
| `tex`: |  | Functions and Variables for File Input and Output
| `tex`: |  | Functions and Variables for File Input and Output
| `tex`: |  | Functions and Variables for File Input and Output
| `tex`: |  | Functions and Variables for File Input and Output
| `tex`: |  | Functions and Variables for File Input and Output
| `tex`: |  | Functions and Variables for File Input and Output
| `tex1`: |  | Functions and Variables for File Input and Output
| `texput`: |  | Functions and Variables for File Input and Output
| `texput`: |  | Functions and Variables for File Input and Output
| `texput`: |  | Functions and Variables for File Input and Output
| `texput`: |  | Functions and Variables for File Input and Output
| `texput`: |  | Functions and Variables for File Input and Output
| `third`: |  | Functions and Variables for Lists
| `throw`: |  | Functions and Variables for Program Flow
| `time`: |  | Functions and Variables for Runtime Environment
| `timedate`: |  | Functions and Variables for Runtime Environment
| `timedate`: |  | Functions and Variables for Runtime Environment
| `timer`: |  | Functions and Variables for Debugging
| `timer`: |  | Functions and Variables for Debugging
| `timer`: |  | Functions and Variables for Debugging
| timer_devalue: |  | Functions and Variables for Debugging
| `timer_info`: |  | Functions and Variables for Debugging
| `timer_info`: |  | Functions and Variables for Debugging
| title: |  | Functions and Variables for draw
| `tldefint`: |  | Functions and Variables for Integration
| `tlimit`: |  | Functions and Variables for Limits
| `tlimit`: |  | Functions and Variables for Limits
| `tlimit`: |  | Functions and Variables for Limits
| tlimswitch: |  | Functions and Variables for Limits
| `todd_coxeter`: |  | Functions and Variables for Groups
| `todd_coxeter`: |  | Functions and Variables for Groups
| `toeplitz`: |  | Functions and Variables for linearalgebra
| `toeplitz`: |  | Functions and Variables for linearalgebra
| `tokens`: |  | Functions and Variables for strings
| `tokens`: |  | Functions and Variables for strings
| `topological_sort`: |  | Functions and Variables for graphs
| `totaldisrep`: |  | Functions and Variables for Polynomials
| `totalfourier`: |  | Functions and Variables for Fourier series
| `totient`: |  | Functions and Variables for Number Theory
| `to_lisp`: |  | Functions and Variables for Command Line
| `to_poly`: |  | Functions and Variables for to_poly_solve
| `to_poly_solve`: |  | Functions and Variables for to_poly_solve
| `tpartpol`: |  | Functions and Variables for Symmetries
| tr: |  | Functions and Variables for ctensor
| `trace`: |  | Functions and Variables for Debugging
| `trace`: |  | Functions and Variables for Debugging
| `trace`: |  | Functions and Variables for Debugging
| `tracematrix`: |  | Package functs
| `trace_options`: |  | Functions and Variables for Debugging
| `trace_options`: |  | Functions and Variables for Debugging
| transcompile: |  | Functions and Variables for Function Definition
| transform: |  | Functions and Variables for draw
| transform_xy: |  | Plotting Options
| `translate`: |  | Functions and Variables for Function Definition
| `translate`: |  | Functions and Variables for Function Definition
| `translate`: |  | Functions and Variables for Function Definition
| `translate_file`: |  | Functions and Variables for Function Definition
| `translate_file`: |  | Functions and Variables for Function Definition
| transparent: |  | Functions and Variables for draw
| `transpose`: |  | Functions and Variables for Matrices and Linear Algebra
| transrun: |  | Functions and Variables for Function Definition
| `treefale`: |  | Definitions for IFS fractals
| `tree_reduce`: |  | Functions and Variables for Sets
| `tree_reduce`: |  | Functions and Variables for Sets
| `treillis`: |  | Functions and Variables for Symmetries
| `treinat`: |  | Functions and Variables for Symmetries
| `triangle`: |  | Functions and Variables for draw
| `triangularize`: |  | Functions and Variables for Matrices and Linear Algebra
| `trigexpand`: |  | Functions and Variables for Trigonometric
| trigexpandplus: |  | Functions and Variables for Trigonometric
| trigexpandtimes: |  | Functions and Variables for Trigonometric
| triginverses: |  | Functions and Variables for Trigonometric
| `trigrat`: |  | Functions and Variables for Trigonometric
| `trigreduce`: |  | Functions and Variables for Trigonometric
| `trigreduce`: |  | Functions and Variables for Trigonometric
| trigsign: |  | Functions and Variables for Trigonometric
| `trigsimp`: |  | Functions and Variables for Trigonometric
| trivial_solutions: |  | Functions and Variables for zeilberger
| true: |  | Functions and Variables for Constants
| `trunc`: |  | Functions and Variables for Series
| `truncated_cube_graph`: |  | Functions and Variables for graphs
| `truncated_dodecahedron_graph`: |  | Functions and Variables for graphs
| `truncated_icosahedron_graph`: |  | Functions and Variables for graphs
| `truncated_tetrahedron_graph`: |  | Functions and Variables for graphs
| tr_array_as_ref: |  | Functions and Variables for Function Definition
| tr_bound_function_applyp: |  | Functions and Variables for Function Definition
| tr_file_tty_messagesp: |  | Functions and Variables for Function Definition
| tr_float_can_branch_complex: |  | Functions and Variables for Function Definition
| tr_function_call_default: |  | Functions and Variables for Function Definition
| tr_numer: |  | Functions and Variables for Function Definition
| tr_optimize_max_loop: |  | Functions and Variables for Function Definition
| tr_semicompile: |  | Functions and Variables for Function Definition
| tr_state_vars: |  | Functions and Variables for Function Definition
| `tr_warnings_get`: |  | Functions and Variables for Function Definition
| tr_warn_bad_function_calls: |  | Functions and Variables for Function Definition
| tr_warn_fexpr: |  | Functions and Variables for Function Definition
| tr_warn_meval: |  | Functions and Variables for Function Definition
| tr_warn_mode: |  | Functions and Variables for Function Definition
| tr_warn_undeclared: |  | Functions and Variables for Function Definition
| tr_warn_undefined_variable: |  | Functions and Variables for Function Definition
| ttyoff: |  | Functions and Variables for Display
| `tube`: |  | Functions and Variables for draw
| tube_extremes: |  | Functions and Variables for draw
| `tutte_graph`: |  | Functions and Variables for graphs
U |  |
| `ueivects`: |  | Functions and Variables for Matrices and Linear Algebra
| ufg: |  | Functions and Variables for ctensor
| `uforget`: |  | Functions and Variables for Units
| ug: |  | Functions and Variables for ctensor
| `ultraspherical`: |  | Functions and Variables for orthogonal polynomials
| und: |  | Functions and Variables for Constants
| `underlying_graph`: |  | Functions and Variables for graphs
| `undiff`: |  | Functions and Variables for itensor
| `union`: |  | Functions and Variables for Sets
| `unique`: |  | Functions and Variables for Lists
| `uniteigenvectors`: |  | Functions and Variables for Matrices and Linear Algebra
| `unitp`: |  | Functions and Variables for ezunits
| `units`: |  | Functions and Variables for ezunits
| `unitvector`: |  | Functions and Variables for Matrices and Linear Algebra
| `unit_step`: |  | Functions and Variables for orthogonal polynomials
| unit_vectors: |  | Functions and Variables for draw
| `unknown`: |  | Functions and Variables for Predicates
| `unless`: |  | Functions and Variables for Program Flow
| `unorder`: |  | Functions and Variables for Expressions
| `unsum`: |  | Functions and Variables for Series
| `untellrat`: |  | Functions and Variables for Polynomials
| `untimer`: |  | Functions and Variables for Debugging
| `untimer`: |  | Functions and Variables for Debugging
| `untrace`: |  | Functions and Variables for Debugging
| `untrace`: |  | Functions and Variables for Debugging
| `uppercasep`: |  | Functions and Variables for characters
| uric: |  | Functions and Variables for ctensor
| `uricci`: |  | Functions and Variables for ctensor
| uriem: |  | Functions and Variables for ctensor
| `uriemann`: |  | Functions and Variables for ctensor
| usersetunits: |  | Functions and Variables for Units
| user_preamble: |  | Functions and Variables for draw
| use_fast_arrays: |  | Functions and Variables for Arrays
| `uvect`: |  | Functions and Variables for Matrices and Linear Algebra
V |  |
| values: |  | Functions and Variables for Command Line
| `vandermonde_matrix`: |  | Functions and Variables for linearalgebra
| `var`: |  | Functions and Variables for descriptive statistics
| `var`: |  | Functions and Variables for descriptive statistics
| `var1`: |  | Functions and Variables for descriptive statistics
| `var1`: |  | Functions and Variables for descriptive statistics
| `var_bernoulli`: |  | Functions and Variables for discrete distributions
| `var_beta`: |  | Functions and Variables for continuous distributions
| `var_binomial`: |  | Functions and Variables for discrete distributions
| `var_chi2`: |  | Functions and Variables for continuous distributions
| `var_continuous_uniform`: |  | Functions and Variables for continuous distributions
| `var_discrete_uniform`: |  | Functions and Variables for discrete distributions
| `var_exp`: |  | Functions and Variables for continuous distributions
| `var_f`: |  | Functions and Variables for continuous distributions
| `var_gamma`: |  | Functions and Variables for continuous distributions
| `var_general_finite_discrete`: |  | Functions and Variables for discrete distributions
| `var_geometric`: |  | Functions and Variables for discrete distributions
| `var_gumbel`: |  | Functions and Variables for continuous distributions
| `var_hypergeometric`: |  | Functions and Variables for discrete distributions
| `var_laplace`: |  | Functions and Variables for continuous distributions
| `var_logistic`: |  | Functions and Variables for continuous distributions
| `var_lognormal`: |  | Functions and Variables for continuous distributions
| `var_negative_binomial`: |  | Functions and Variables for discrete distributions
| `var_noncentral_chi2`: |  | Functions and Variables for continuous distributions
| `var_noncentral_student_t`: |  | Functions and Variables for continuous distributions
| `var_normal`: |  | Functions and Variables for continuous distributions
| `var_pareto`: |  | Functions and Variables for continuous distributions
| `var_poisson`: |  | Functions and Variables for discrete distributions
| `var_rayleigh`: |  | Functions and Variables for continuous distributions
| `var_student_t`: |  | Functions and Variables for continuous distributions
| `var_weibull`: |  | Functions and Variables for continuous distributions
| `vector`: |  | Functions and Variables for draw
| `vector`: |  | Functions and Variables for draw
| `vectorpotential`: |  | Functions and Variables for Matrices and Linear Algebra
| `vectorpotential`: |  | Functions and Variables for Matrices and Linear Algebra
| `vectorsimp`: |  | Functions and Variables for Matrices and Linear Algebra
| vect_cross: |  | Functions and Variables for Matrices and Linear Algebra
| `verbify`: |  | Functions and Variables for Expressions
| verbose: |  | Functions and Variables for Series
| `vers`: |  | Package functs
| vertex_color: |  | Functions and Variables for graphs
| vertex_coloring: |  | Functions and Variables for graphs
| `vertex_coloring`: |  | Functions and Variables for graphs
| `vertex_connectivity`: |  | Functions and Variables for graphs
| `vertex_degree`: |  | Functions and Variables for graphs
| `vertex_distance`: |  | Functions and Variables for graphs
| `vertex_eccentricity`: |  | Functions and Variables for graphs
| `vertex_in_degree`: |  | Functions and Variables for graphs
| `vertex_out_degree`: |  | Functions and Variables for graphs
| vertex_partition: |  | Functions and Variables for graphs
| vertex_size: |  | Functions and Variables for graphs
| vertex_type: |  | Functions and Variables for graphs
| `vertices`: |  | Functions and Variables for graphs
| `vertices_to_cycle`: |  | Functions and Variables for graphs
| `vertices_to_path`: |  | Functions and Variables for graphs
| view: |  | Functions and Variables for draw
W |  |
| warnings: |  | Functions and Variables for zeilberger
| weyl: |  | Functions and Variables for ctensor
| `weyl`: |  | Functions and Variables for ctensor
| `wheel_graph`: |  | Functions and Variables for graphs
| `while`: |  | Functions and Variables for Program Flow
| `wiener_index`: |  | Functions and Variables for graphs
| `with_stdout`: |  | Functions and Variables for File Input and Output
| `with_stdout`: |  | Functions and Variables for File Input and Output
| `writefile`: |  | Functions and Variables for File Input and Output
| `write_binary_data`: |  | Functions and Variables for binary input and output
| `write_data`: |  | Functions and Variables for plain-text input and output
| `write_data`: |  | Functions and Variables for plain-text input and output
| `wronskian`: |  | Package functs
X |  |
| x: |  | Plotting Options
| xaxis: |  | Functions and Variables for draw
| xaxis_color: |  | Functions and Variables for draw
| xaxis_secondary: |  | Functions and Variables for draw
| xaxis_type: |  | Functions and Variables for draw
| xaxis_width: |  | Functions and Variables for draw
| xlabel: |  | Plotting Options
| xlabel: |  | Functions and Variables for draw
| xrange: |  | Functions and Variables for draw
| xrange_secondary: |  | Functions and Variables for draw
| `xreduce`: |  | Functions and Variables for Sets
| `xreduce`: |  | Functions and Variables for Sets
| `xthru`: |  | Functions and Variables for Simplification
| xtics: |  | Functions and Variables for draw
| xtics_axis: |  | Functions and Variables for draw
| xtics_rotate: |  | Functions and Variables for draw
| xtics_rotate_secondary: |  | Functions and Variables for draw
| xtics_secondary: |  | Functions and Variables for draw
| xtics_secondary_axis: |  | Functions and Variables for draw
| xu_grid: |  | Functions and Variables for draw
| xyplane: |  | Functions and Variables for draw
| xy_file: |  | Functions and Variables for draw
| x_voxel: |  | Functions and Variables for draw
Y |  |
| y: |  | Plotting Options
| yaxis: |  | Functions and Variables for draw
| yaxis_color: |  | Functions and Variables for draw
| yaxis_secondary: |  | Functions and Variables for draw
| yaxis_type: |  | Functions and Variables for draw
| yaxis_width: |  | Functions and Variables for draw
| ylabel: |  | Plotting Options
| ylabel: |  | Functions and Variables for draw
| yrange: |  | Functions and Variables for draw
| yrange_secondary: |  | Functions and Variables for draw
| ytics: |  | Functions and Variables for draw
| ytics_axis: |  | Functions and Variables for draw
| ytics_rotate: |  | Functions and Variables for draw
| ytics_rotate_secondary: |  | Functions and Variables for draw
| ytics_secondary: |  | Functions and Variables for draw
| ytics_secondary_axis: |  | Functions and Variables for draw
| yv_grid: |  | Functions and Variables for draw
| y_voxel: |  | Functions and Variables for draw
Z |  |
| z: |  | Plotting Options
| zaxis: |  | Functions and Variables for draw
| zaxis_color: |  | Functions and Variables for draw
| zaxis_type: |  | Functions and Variables for draw
| zaxis_width: |  | Functions and Variables for draw
| `Zeilberger`: |  | Functions and Variables for zeilberger
| zeroa: |  | Functions and Variables for Constants
| zerob: |  | Functions and Variables for Constants
| zerobern: |  | Functions and Variables for Number Theory
| `zeroequiv`: |  | Functions and Variables for Predicates
| `zerofor`: |  | Functions and Variables for linearalgebra
| `zerofor`: |  | Functions and Variables for linearalgebra
| `zeromatrix`: |  | Functions and Variables for Matrices and Linear Algebra
| `zeromatrixp`: |  | Functions and Variables for linearalgebra
| `zeta`: |  | Functions and Variables for Number Theory
| zeta%pi: |  | Functions and Variables for Number Theory
| zlabel: |  | Plotting Options
| zlabel: |  | Functions and Variables for draw
| `zlange`: |  | Functions and Variables for lapack
| zrange: |  | Functions and Variables for draw
| ztics: |  | Functions and Variables for draw
| ztics_axis: |  | Functions and Variables for draw
| ztics_rotate: |  | Functions and Variables for draw
| z_voxel: |  | Functions and Variables for draw

Jump to: | ! # % ' * + - . / : < = > ? @ [ ] ^ _ ` | ~ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Previous: Function and Variable Index, Up: Top [Contents][Index]

## Appendix A Translator’s Comments

Next: About Terms in Japanese, Up: Translator's Comments [Contents][Index]

### A.1 Translation Policies

とにかく、質より量ということで訳を進めました。品質を高めるべく、少しずつ見直しを進めています。 訳者自身が意味を理解していない文もありましたので、誤訳、迷訳についてはご指摘いただければ幸いです。

できるだけ多くの人に参考になるようにと、章のレベルに応じて、訳語を変えたところがあります。 例えば、足し算と加算を使い分けたりしました。その結果、文体に一貫性が欠ける部分があるかと思いますが、意図を汲み取っていただければ幸いです。

章や節などのノード名は、訳すとtexi2htmlに不具合があるので、英文そのままとしました。

Previous: Translation Policies, Up: Translator's Comments [Contents][Index]

### A.2 About Terms in Japanese

simplification

  simplificationとevaluationがMaximaの基礎となっていますが、simplificationは、対応する日本語がないと思いました。Maximaに関する他の記事では、簡易化、簡素化、簡単化などと訳されているようです。一番近いニュアンスは、「式の整理をすること」と思いましたので、「整理」もしくは「式整理」と訳しました。 reduceの訳語には簡約を使いました。

function

  functionは、数学的な定義に基づく場合とプログラミング的な定義に基づく場合があるので、前者を函数、後者を関数と漢字を充てました。

Help ·

Previous: Function and Variable Index [Contents][Index]

## B Documentation Categories

Category: Airy functions

Introduction to Special Functions ·airy_ai ·airy_dai ·airy_bi ·airy_dbi

Category: Algebraic equations

%rnum_list ·algepsilon ·algexact ·algsys ·backsubst ·breakup ·dispflag ·funcsolve ·multiplicities ·programmode ·realonly ·solve ·solvedecomposes ·solveexplicit ·solvefactors ·solvenullwarn ·solveradcan ·solvetrigwarn ·find_root ·bf_find_root ·find_root_error ·find_root_abs ·find_root_rel ·newton ·eliminate

Category: Arrays

array ·arrayapply ·arrayinfo ·arraymake ·arrays ·fillarray ·listarray ·make_array ·rearray ·remarray ·subvar ·use_fast_arrays

Category: Bessel functions

spherical_bessel_j ·spherical_bessel_y ·spherical_hankel1 ·spherical_hankel2 ·Introduction to Special Functions ·bessel_j ·bessel_y ·bessel_i ·bessel_k ·hankel_1 ·hankel_2 ·besselexpand ·scaled_bessel_i ·scaled_bessel_i0 ·scaled_bessel_i1 ·%s ·%f

Category: Complex variables

Introduction to Numbers ·residue ·cabs ·carg ·conjugate ·imagpart ·polarform ·realpart ·rectform ·plog ·polartorect ·recttopolar ·demoivre ·exponentialize ·cbffac

Category: Console interaction

_ ·% ·%th ·? ·?? ·kill ·labels ·linenum ·myoptions ·optionset ·playback ·prompt ·quit ·read ·readonly ·to_lisp ·ibase ·obase ·refcheck ·setcheck ·setcheckbreak ·setval ·Documentation ·demo ·describe ·example ·appendfile ·closefile ·printfile ·writefile ·entermatrix ·ratprint ·Interrupts

Category: Constants

%e ·%i ·false ·%gamma ·ind ·inf ·infinity ·minf ·%phi ·%pi ·true ·und ·zeroa ·zerob ·constant ·constantp

Category: Continued fractions

cf ·cfdisrep ·cfexpand ·cflength

Category: Debugging

run_testsuite ·testsuite_files ·bug_report ·build_info ·showtime ·Source Level Debugging ·Keyword Commands ·debugmode ·timer ·untimer ·timer_devalue ·timer_info ·trace ·trace_options ·untrace ·break ·backtrace ·error_size ·error_syms ·room ·time

Category: Declarations and inferences

infolists ·declare ·features ·get ·posfun ·printprops ·activate ·activecontexts ·askexp ·askinteger ·asksign ·assume ·assumescalar ·assume_pos ·assume_pos_pred ·context ·contexts ·deactivate ·facts ·forget ·is ·killcontext ·maybe ·newcontext ·sign ·supcontext ·compare ·constant ·numerval ·atvalue ·dependencies ·depends ·gradef ·gradefs ·alias ·alias ·aliases ·mainvar ·nonscalar ·alphabetic ·properties ·props ·propvars ·put ·qput ·rem ·remove ·infix ·matchdeclare ·featurep ·additive ·antisymmetric ·commutative ·lassociative ·linear ·multiplicative ·outative ·rassociative ·symmetric

Category: Descriptive statistics

Introduction to descriptive

Category: Differential calculus

atomgrad ·del ·depends ·derivabbrev ·derivdegree ·derivlist ·derivsubst ·diff ·dscalar ·express ·gradef ·gradefs ·implicit_derivative ·hessian ·jacobian ·vect_cross ·wronskian

Category: Differential equations

Introduction to contrib_ode ·bc2 ·desolve ·ic1 ·ic2 ·ode2 ·at ·atvalue ·laplace ·Introduction to drawdf ·rk ·Lindstedt ·Introduction to plotdf

Category: Differential geometry

cartan

Category: Display flags and variables

inchar ·labels ·linechar ·linenum ·outchar ·showtime ·%edispflag ·absboxchar ·display2d ·display_format_internal ·exptdispflag ·grind ·linel ·lispdisp ·negsumdispflag ·obase ·pfeformat ·powerdisp ·sqrtdispflag ·stardisp ·ttyoff ·fpprintprec ·stringdisp ·dispflag ·noundisp ·lmxchar ·rmxchar ·error_size ·error_syms ·psexpand

Category: Display functions

labels ·playback ·disp ·display ·dispterms ·grind ·ldisp ·ldisplay ·print ·printprops ·reveal ·dispfun ·dispcon ·show ·showratvars ·disprule ·printpois

Category: Dynamical systems

Introduction to dynamics

Category: Elliptic functions

Introduction to Elliptic Functions and Integrals ·jacobi_sn ·jacobi_cn ·jacobi_dn ·jacobi_ns ·jacobi_sc ·jacobi_sd ·jacobi_nc ·jacobi_cs ·jacobi_cd ·jacobi_nd ·jacobi_ds ·jacobi_dc ·inverse_jacobi_sn ·inverse_jacobi_cn ·inverse_jacobi_dn ·inverse_jacobi_ns ·inverse_jacobi_sc ·inverse_jacobi_sd ·inverse_jacobi_nc ·inverse_jacobi_cs ·inverse_jacobi_cd ·inverse_jacobi_nd ·inverse_jacobi_ds ·inverse_jacobi_dc

Category: Elliptic integrals

elliptic_f ·elliptic_e ·elliptic_eu ·elliptic_pi ·elliptic_kc ·elliptic_ec

Category: Evaluation flags

float ·numer ·eval ·evflag ·evfun ·infeval ·noeval ·nouns ·pred ·%enumer ·detout ·simp

Category: Evaluation

kill ·values ·refcheck ·at ·derivlist ·’ ·” ·ev ·Nouns and Verbs ·remvalue ·: ·::

Category: Exponential and logarithm functions

%edispflag ·exptsubst ·polarform ·%e_to_numlog ·%emode ·%enumer ·exp ·li ·log ·logabs ·logarc ·logconcoeffp ·logcontract ·logexpand ·lognegint ·lognumer ·logsimp ·plog ·taylor_logexpand

Category: Exponential Integrals

expintegral_e1 ·expintegral_ei ·expintegral_li ·expintegral_e ·expintegral_si ·expintegral_ci ·expintegral_shi ·expintegral_chi ·expintrep ·expintexpand

Category: Expressions

arrayapply ·arraymake ·subvar ·exptdispflag ·nonarray ·m1pbranch ·concat ·sconcat ·derivdegree ·derivsubst ·lhs ·rhs ·rootsconmode ·args ·atom ·box ·boxchar ·collapse ·disolate ·dispform ·dpart ·exptisolate ·exptsubst ·freeof ·inflag ·inpart ·isolate ·isolate_wrt_times ·listconstvars ·listdummyvars ·listofvars ·lfreeof ·lpart ·mainvar ·nterms ·op ·opsubst ·optimize ·optimprefix ·ordergreat ·orderless ·ordergreatp ·orderlessp ·part ·partition ·partswitch ·pickapart ·piece ·psubst ·rembox ·reveal ·sublis ·sublis_apply_lambda ·subnumsimp ·subst ·substinpart ·substpart ·unorder ·block ·fullmap ·fullmapl ·funmake ·append ·assoc ·cons ·delete ·eighth ·endcons ·fifth ·first ·fourth ·last ·length ·member ·ninth ·pop ·push ·rest ·reverse ·second ·seventh ·sixth ·tenth ·third ·dontfactor ·rncombine ·opsubst ·denom ·factorout ·factorsum ·gfactorsum ·hipow ·lopow ·num ·powers ·intosum ·Package facexp ·facsum ·nextlayerfactor ·facsum_combine ·factorfacsum ·collectterms ·rempart ·rational ·nonzeroandfreeof ·linear ·Package rducon ·reduce_consts ·Package scifac ·gcfac ·sqrtdenest ·combine ·distrib ·expand ·expandwrt ·expandwrt_denom ·expandwrt_factored ·expon ·expop ·maxnegex ·maxposex ·multiplicative ·multthru ·xthru ·numfactor

Category: File input

demo ·batch ·batchload ·filename_merge ·file_search ·file_search_maxima ·file_search_lisp ·file_search_demo ·file_search_usage ·file_search_tests ·file_type ·load ·load_pathname ·loadfile ·loadprint ·pathname_directory ·pathname_name ·pathname_type ·printfile ·setup_autoload ·Introduction to numericalio ·read_matrix ·read_array ·read_hashed_array ·read_nested_list ·read_list ·openr_binary ·read_binary_matrix ·read_binary_array ·read_binary_list ·close ·flength ·fposition ·openr ·readline

Category: File output

draw ·draw2d ·draw3d ·draw_file ·multiplot_mode ·appendfile ·closefile ·file_output_append ·filename_merge ·save ·stringout ·tex ·with_stdout ·writefile ·Introduction to numericalio ·write_data ·openw_binary ·opena_binary ·write_binary_data ·close ·flength ·fposition ·freshline ·newline ·opena ·openw ·printf

Category: Fourier transform

Introduction to fast Fourier transform ·Introduction to Fourier series

Category: Function application

macroexpand ·macroexpand1 ·apply ·fullmap ·fullmapl ·funmake ·macroexpansion ·map ·maperror ·mapprint ·maplist ·scanmap ·outermap ·maxapplydepth ·maxapplyheight

Category: Function definition

Function ·buildq ·macros ·splice ·define ·dispfun ·functions ·fundef ·lambda ·local ·remfunction ·setup_autoload ·::= ·:=

Category: Gamma and factorial functions

!! ·factcomb ·factorial ·! ·factlim ·factorial_expand ·genfact ·sumsplitfact ·pochhammer ·pochhammer_max_index ·bffac ·bfpsi ·bfpsi0 ·cbffac ·gamma ·log_gamma ·gamma_incomplete ·gamma_incomplete_regularized ·gamma_incomplete_generalized ·gammalim ·makegamma ·beta ·beta_incomplete ·beta_incomplete_regularized ·beta_incomplete_generalized ·beta_expand ·beta_args_sum_to_integer ·psi ·maxpsiposint ·maxpsinegint ·maxpsifracnum ·maxpsifracdenom ·makefact ·stirling

Category: Generating functions

ggf

Category: Global flags

use_fast_arrays ·nolabels ·optionset ·m1pbranch ·debugmode ·refcheck ·setcheck ·setcheckbreak ·timer_devalue ·derivabbrev ·macroexpansion ·file_output_append ·loadprint ·listarith ·logabs ·ratvarswitch

Category: Global variables

arrays ·adim ·aform ·asymbol ·testsuite_files ·__ ·_ ·% ·%% ·infolists ·myoptions ·prompt ·values ·setval ·structures ·dependencies ·aliases ·macros ·functions ·manual_demo ·file_search_maxima ·file_search_lisp ·file_search_demo ·file_search_usage ·file_search_tests ·props ·maxima_tempdir ·maxima_userdir ·opproperties ·newline ·space ·tab

Category: Groebner bases

Introduction to Affine ·Introduction to grobner

Category: Group theory

todd_coxeter ·Introduction to Symmetries

Category: Help

? ·?? ·apropos ·demo ·describe ·example ·manual_demo ·About Terms in Japanese

Category: Hyperbolic functions

%iargs ·acosh ·acoth ·acsch ·asech ·asinh ·atanh ·cosh ·coth ·csch ·sech ·sinh ·tanh ·demoivre ·exponentialize

Category: Integers

divisors ·integer_partitions ·moebius ·multinomial_coeff ·num_distinct_partitions ·num_partitions ·stirling1 ·stirling2 ·gcfactor ·intfaclim ·modulus

Category: Integral calculus

antid ·antidiff ·changevar ·dblint ·defint ·erfflag ·intanalysis ·integrate ·integration_constant ·integration_constant_counter ·integrate_use_rootsof ·ldefint ·residue ·risch ·tldefint ·Introduction to QUADPACK ·logabs ·absint

Category: Integral equations

ieqn ·ieqnprint

Category: Laplace transform

desolve ·delta ·laplace ·ilt ·specint

Category: Limits

lhospitallim ·limit ·limsubst ·tlimit ·tlimswitch

Category: Linear algebra

Introduction to linearalgebra

Category: Linear equations

globalsolve ·linsolve ·linsolvewarn ·linsolve_params ·dgesv ·augcoefmatrix ·coefmatrix ·echelon ·triangularize

Category: Linear recurrences

Introduction to solve_rec

Category: Lists

[ ·] ·append ·assoc ·cons ·copylist ·create_list ·delete ·eighth ·endcons ·fifth ·first ·fourth ·join ·last ·length ·listarith ·listp ·makelist ·member ·ninth ·pop ·push ·rest ·reverse ·second ·seventh ·sixth ·sort ·sublist ·sublist_indices ·tenth ·third ·lmax ·lmin ·flatten ·fullsetify ·lreduce ·permutations ·random_permutation ·rreduce ·setify ·some ·tree_reduce ·xreduce ·permut

Category: Mathematical functions

sqrtdispflag ·charfun ·delta ·abs ·ceiling ·entier ·floor ·fix ·lmax ·lmin ·max ·min ·round ·signum ·sqrt ·isqrt ·mod ·unit_step ·gaussprob ·gd ·agd ·vers ·covers ·exsec ·hav ·combination ·permutation

Category: Matrices

diag ·eigen ·addcol ·addrow ·adjoint ·augcoefmatrix ·cauchy_matrix ·charpoly ·coefmatrix ·col ·columnvector ·covect ·copymatrix ·determinant ·detout ·diagmatrix ·doallmxops ·domxexpt ·domxmxops ·domxnctimes ·doscmxops ·doscmxplus ·echelon ·ematrix ·entermatrix ·genmatrix ·ident ·invert ·list_matrix_entries ·lmxchar ·matrix ·matrixmap ·matrixp ·matrix_element_add ·matrix_element_mult ·matrix_element_transpose ·mattrace ·minor ·ncharpoly ·newdet ·nonscalar ·nonscalarp ·permanent ·rank ·ratmx ·row ·scalarmatrixp ·setelmx ·sparse ·submatrix ·transpose ·triangularize ·zeromatrix ·scalarp ·tracematrix

Category: Matrix decompositions

cholesky ·eigens_by_jacobi ·lu_factor

Category: Nouns and verbs

nouns ·Nouns and Verbs ·noun ·noundisp ·nounify ·verbify

Category: Number theory

binomial ·minfactorial ·bern ·bernpoly ·bfzeta ·bfhzeta ·burn ·divsum ·euler ·fib ·fibtophi ·ifactors ·igcdex ·inrt ·inv_mod ·jacobi ·lcm ·next_prime ·power_mod ·primep ·primep_number_of_tests ·prev_prime ·qunit ·totient ·zerobern ·zeta ·zeta%pi

Category: Numerical evaluation

bfloat ·bfloatp ·bftorat ·bftrunc ·float ·float2bf ·floatnump ·fpprec ·fpprintprec ·numer ·numer_pbranch ·numerval ·ratepsilon ·rationalize ·lognumer ·bfzeta ·bfhzeta ·keepfloat ·ratprint ·bffac ·bfpsi ·bfpsi0 ·cbffac ·stats_numer

Category: Numerical methods

augmented_lagrangian_method ·Introduction to cobyla ·rk ·allroots ·bfallroots ·nroots ·polyfactor ·realroots ·rootsepsilon ·Introduction to QUADPACK ·quad_qag ·quad_qags ·quad_qagi ·quad_qawc ·quad_qawf ·quad_qawo ·quad_qaws ·Introduction to interpol ·Introduction to lapack ·Introduction to lbfgs ·lsquares_estimates ·lsquares_estimates_approximate ·plsquares ·random ·Introduction to minpack ·Introduction to mnewton ·Introduction to fast Fourier transform ·horner ·find_root ·bf_find_root ·find_root_error ·find_root_abs ·find_root_rel ·newton ·plotdf ·romberg ·Introduction to simplex ·linear_program ·maximize_lp ·minimize_lp

Category: Operators

posfun ·equal ·notequal ·@ ·express ·’ ·” ·op ·operatorp ·~ ·| ·[ ·] ·!! ·factorial ·! ·Introduction to operators ·+ ·- ·* ·/ ·^ ·** ·^^ ·. ·< ·<= ·>= ·> ·and ·not ·or ·# ·= ·: ·:: ·::= ·:= ·infix ·matchfix ·nary ·nofix ·postfix ·prefix ·additive ·antisymmetric ·commutative ·lassociative ·linear ·opproperties ·outative ·rassociative ·symmetric

Category: Optimization

augmented_lagrangian_method ·Introduction to cobyla ·Introduction to lbfgs ·Introduction to simplex

Category: Orthogonal polynomials

Introduction to orthogonal polynomials

Category: Package absimp

Package absimp

Category: Package affine

Introduction to Affine ·fast_linsolve ·grobner_basis ·set_up_dot_simplifications ·declare_weights ·nc_degree ·dotsimp ·fast_central_elements ·check_overlaps ·mono ·monomial_dimensions ·extract_linear_equations ·list_nc_monomials ·all_dotsimp_denoms

Category: Package asympa

asympa

Category: Package atensor

Introduction to atensor ·init_atensor ·atensimp ·adim ·aform ·asymbol ·sf ·af ·av ·abasep

Category: Package atrig1

atrig1

Category: Package augmented_lagrangian

augmented_lagrangian_method

Category: Package bode

bode_gain ·bode_phase

Category: Package cobyla

Introduction to cobyla

Category: Package contrib_ode

Introduction to contrib_ode ·contrib_ode ·odelin ·ode_check ·method ·%c ·%k1 ·%k2 ·gauss_a ·gauss_b ·dgauss_a ·dgauss_b ·kummer_m ·kummer_u ·dkummer_m ·dkummer_u

Category: Package ctensor

Introduction to ctensor ·csetup ·cmetric ·ct_coordsys ·init_ctensor ·christof ·ricci ·uricci ·scurvature ·einstein ·leinstein ·riemann ·lriemann ·uriemann ·rinvariant ·weyl ·ctaylor ·frame_bracket ·nptetrad ·psi ·petrov ·contortion ·nonmetricity ·ctransform ·findde ·cograd ·contragrad ·dscalar ·checkdiv ·cgeodesic ·bdvac ·invariant1 ·invariant2 ·bimetric ·diagmatrixp ·symmetricp ·ntermst ·cdisplay ·deleten ·dim ·diagmetric ·ctrgsimp ·cframe_flag ·ctorsion_flag ·cnonmet_flag ·ctayswitch ·ctayvar ·ctaypov ·ctaypt ·gdet ·ratchristof ·rateinstein ·ratriemann ·ratweyl ·lfg ·ufg ·riem ·lriem ·uriem ·ric ·uric ·lg ·ug ·weyl ·fb ·kinvariant ·np ·npi ·tr ·kt ·nm ·nmc ·tensorkill ·ct_coords ·dscalar ·ic_convert

Category: Package descriptive

Introduction to descriptive ·continuous_freq ·discrete_freq ·subsample ·mean ·var ·var1 ·std ·std1 ·noncentral_moment ·central_moment ·cv ·smin ·smax ·range ·quantile ·median ·qrange ·mean_deviation ·median_deviation ·harmonic_mean ·geometric_mean ·kurtosis ·skewness ·pearson_skewness ·quartile_skewness ·cov ·cov1 ·global_variances ·cor ·list_correlations ·barsplot ·barsplot_description ·boxplot ·boxplot_description ·histogram ·histogram_description ·piechart ·piechart_description ·scatterplot ·scatterplot_description ·starplot ·starplot_description ·stemplot

Category: Package diag

diag ·JF ·jordan ·dispJordan ·minimalPoly ·ModeMatrix ·mat_function

Category: Package distrib

Introduction to distrib ·pdf_normal ·cdf_normal ·quantile_normal ·mean_normal ·var_normal ·std_normal ·skewness_normal ·kurtosis_normal ·random_normal ·pdf_student_t ·cdf_student_t ·quantile_student_t ·mean_student_t ·var_student_t ·std_student_t ·skewness_student_t ·kurtosis_student_t ·random_student_t ·pdf_noncentral_student_t ·cdf_noncentral_student_t ·quantile_noncentral_student_t ·mean_noncentral_student_t ·var_noncentral_student_t ·std_noncentral_student_t ·skewness_noncentral_student_t ·kurtosis_noncentral_student_t ·random_noncentral_student_t ·pdf_chi2 ·cdf_chi2 ·quantile_chi2 ·mean_chi2 ·var_chi2 ·std_chi2 ·skewness_chi2 ·kurtosis_chi2 ·random_chi2 ·pdf_noncentral_chi2 ·cdf_noncentral_chi2 ·quantile_noncentral_chi2 ·mean_noncentral_chi2 ·var_noncentral_chi2 ·std_noncentral_chi2 ·skewness_noncentral_chi2 ·kurtosis_noncentral_chi2 ·random_noncentral_chi2 ·pdf_f ·cdf_f ·quantile_f ·mean_f ·var_f ·std_f ·skewness_f ·kurtosis_f ·random_f ·pdf_exp ·cdf_exp ·quantile_exp ·mean_exp ·var_exp ·std_exp ·skewness_exp ·kurtosis_exp ·random_exp ·pdf_lognormal ·cdf_lognormal ·quantile_lognormal ·mean_lognormal ·var_lognormal ·std_lognormal ·skewness_lognormal ·kurtosis_lognormal ·random_lognormal ·pdf_gamma ·cdf_gamma ·quantile_gamma ·mean_gamma ·var_gamma ·std_gamma ·skewness_gamma ·kurtosis_gamma ·random_gamma ·pdf_beta ·cdf_beta ·quantile_beta ·mean_beta ·var_beta ·std_beta ·skewness_beta ·kurtosis_beta ·random_beta ·pdf_continuous_uniform ·cdf_continuous_uniform ·quantile_continuous_uniform ·mean_continuous_uniform ·var_continuous_uniform ·std_continuous_uniform ·skewness_continuous_uniform ·kurtosis_continuous_uniform ·random_continuous_uniform ·pdf_logistic ·cdf_logistic ·quantile_logistic ·mean_logistic ·var_logistic ·std_logistic ·skewness_logistic ·kurtosis_logistic ·random_logistic ·pdf_pareto ·cdf_pareto ·quantile_pareto ·mean_pareto ·var_pareto ·std_pareto ·skewness_pareto ·kurtosis_pareto ·random_pareto ·pdf_weibull ·cdf_weibull ·quantile_weibull ·mean_weibull ·var_weibull ·std_weibull ·skewness_weibull ·kurtosis_weibull ·random_weibull ·pdf_rayleigh ·cdf_rayleigh ·quantile_rayleigh ·mean_rayleigh ·var_rayleigh ·std_rayleigh ·skewness_rayleigh ·kurtosis_rayleigh ·random_rayleigh ·pdf_laplace ·cdf_laplace ·quantile_laplace ·mean_laplace ·var_laplace ·std_laplace ·skewness_laplace ·kurtosis_laplace ·random_laplace ·pdf_cauchy ·cdf_cauchy ·quantile_cauchy ·random_cauchy ·pdf_gumbel ·cdf_gumbel ·quantile_gumbel ·mean_gumbel ·var_gumbel ·std_gumbel ·skewness_gumbel ·kurtosis_gumbel ·kurtosis_gumbel ·random_gumbel ·pdf_general_finite_discrete ·cdf_general_finite_discrete ·quantile_general_finite_discrete ·mean_general_finite_discrete ·var_general_finite_discrete ·std_general_finite_discrete ·skewness_general_finite_discrete ·kurtosis_general_finite_discrete ·random_general_finite_discrete ·pdf_binomial ·cdf_binomial ·quantile_binomial ·mean_binomial ·var_binomial ·std_binomial ·skewness_binomial ·kurtosis_binomial ·random_binomial ·pdf_poisson ·cdf_poisson ·quantile_poisson ·mean_poisson ·var_poisson ·std_poisson ·skewness_poisson ·kurtosis_poisson ·random_poisson ·pdf_bernoulli ·cdf_bernoulli ·quantile_bernoulli ·mean_bernoulli ·var_bernoulli ·std_bernoulli ·skewness_bernoulli ·kurtosis_bernoulli ·random_bernoulli ·pdf_geometric ·cdf_geometric ·quantile_geometric ·mean_geometric ·var_geometric ·std_geometric ·skewness_geometric ·kurtosis_geometric ·random_geometric ·pdf_discrete_uniform ·cdf_discrete_uniform ·quantile_discrete_uniform ·mean_discrete_uniform ·var_discrete_uniform ·std_discrete_uniform ·skewness_discrete_uniform ·kurtosis_discrete_uniform ·random_discrete_uniform ·pdf_hypergeometric ·cdf_hypergeometric ·quantile_hypergeometric ·mean_hypergeometric ·var_hypergeometric ·std_hypergeometric ·skewness_hypergeometric ·kurtosis_hypergeometric ·random_hypergeometric ·pdf_negative_binomial ·cdf_negative_binomial ·quantile_negative_binomial ·mean_negative_binomial ·var_negative_binomial ·std_negative_binomial ·skewness_negative_binomial ·kurtosis_negative_binomial ·random_negative_binomial

Category: Package drawdf

Introduction to drawdf ·drawdf

Category: Package draw

Introduction to drawdf ·Introduction to draw ·gr2d ·gr3d ·draw ·draw2d ·draw3d ·draw_file ·multiplot_mode ·set_draw_defaults ·adapt_depth ·axis_3d ·axis_bottom ·axis_left ·axis_right ·axis_top ·background_color ·border ·cbrange ·cbtics ·color ·colorbox ·columns ·contour ·contour_levels ·data_file_name ·delay ·dimensions ·enhanced3d ·file_name ·fill_color ·filled_func ·font ·font_size ·gnuplot_file_name ·grid ·head_angle ·head_both ·head_length ·head_type ·ip_grid ·ip_grid_in ·key ·label_alignment ·label_orientation ·line_type ·line_width ·logcb ·logx ·logy ·logz ·nticks ·palette ·point_size ·point_type ·points_joined ·proportional_axes ·surface_hide ·terminal ·title ·transform ·transparent ·tube_extremes ·unit_vectors ·user_preamble ·view ·x_voxel ·xaxis ·xaxis_color ·xaxis_secondary ·xaxis_type ·xaxis_width ·xlabel ·xrange ·xrange_secondary ·xtics ·xtics_axis ·xtics_rotate ·xtics_rotate_secondary ·xtics_secondary ·xtics_secondary_axis ·xu_grid ·xy_file ·xyplane ·y_voxel ·yaxis ·yaxis_color ·yaxis_secondary ·yaxis_type ·yaxis_width ·ylabel ·yrange ·yrange_secondary ·ytics ·ytics_axis ·ytics_rotate ·ytics_rotate_secondary ·ytics_secondary ·ytics_secondary_axis ·yv_grid ·z_voxel ·zaxis ·zaxis_color ·zaxis_type ·zaxis_width ·zlabel ·zrange ·ztics ·ztics_axis ·ztics_rotate ·cylindrical ·elevation_grid ·ellipse ·errors ·explicit ·image ·implicit ·label ·mesh ·parametric ·parametric_surface ·points ·polar ·polygon ·quadrilateral ·rectangle ·spherical ·triangle ·tube ·vector ·get_pixel ·make_level_picture ·make_rgb_picture ·negative_picture ·picture_equalp ·picturep ·read_xpm ·rgb2level ·take_channel ·boundaries_array ·numbered_boundaries ·make_poly_continent ·make_poly_country ·make_polygon ·region_boundaries ·region_boundaries_plus ·geomap

Category: Package dynamics

Introduction to dynamics ·chaosgame ·evolution ·evolution2d ·ifs ·julia ·mandelbrot ·orbits ·rk ·staircase

Category: Package eigen

eigen ·eigenvalues ·eivals ·eigenvectors ·eivects ·gramschmidt ·innerproduct ·inprod ·similaritytransform ·simtran ·uniteigenvectors ·ueivects ·unitvector ·uvect

Category: Package ezunits

Introduction to ezunits ·‘ ·‘‘ ·constvalue ·declare_constvalue ·remove_constvalue ·units ·declare_units ·qty ·declare_qty ·unitp ·declare_unit_conversion ·declare_dimensions ·remove_dimensions ·declare_fundamental_dimensions ·remove_fundamental_dimensions ·fundamental_dimensions ·declare_fundamental_units ·remove_fundamental_units ·dimensions ·dimensions_as_list ·fundamental_units ·dimensionless ·natural_unit

Category: Package f90

f90

Category: Package facexp

Package facexp ·facsum ·nextlayerfactor ·facsum_combine ·factorfacsum ·collectterms

Category: Package fft

Introduction to fast Fourier transform ·polartorect ·recttopolar ·inverse_fft ·fft

Category: Package finance

days360 ·fv ·pv ·graph_flow ·annuity_pv ·annuity_fv ·geo_annuity_pv ·geo_annuity_fv ·amortization ·arit_amortization ·geo_amortization ·saving ·npv ·irr ·benefit_cost

Category: Package fourie

Introduction to Fourier series ·equalp ·remfun ·funp ·absint ·fourier ·foursimp ·sinnpiflag ·cosnpiflag ·fourexpand ·fourcos ·foursin ·totalfourier ·fourint ·fourintcos ·fourintsin

Category: Package fractals

sierpinskiale ·treefale ·fernfale ·mandelbrot_set ·julia_set ·julia_parameter ·julia_sin ·snowmap ·hilbertmap ·sierpinskimap

Category: Package functs

Package functs ·rempart ·wronskian ·tracematrix ·rational ·nonzeroandfreeof ·linear ·gcdivide ·arithmetic ·geometric ·harmonic ·arithsum ·geosum ·gaussprob ·gd ·agd ·vers ·covers ·exsec ·hav ·combination ·permutation

Category: Package ggf

GGFINFINITY ·GGFCFMAX ·ggf

Category: Package graphs - constructions

copy_graph ·circulant_graph ·clebsch_graph ·complement_graph ·complete_bipartite_graph ·complete_graph ·cycle_digraph ·cycle_graph ·cuboctahedron_graph ·cube_graph ·dodecahedron_graph ·empty_graph ·flower_snark ·from_adjacency_matrix ·frucht_graph ·graph_product ·graph_union ·grid_graph ·great_rhombicosidodecahedron_graph ·great_rhombicuboctahedron_graph ·grotzch_graph ·heawood_graph ·icosahedron_graph ·icosidodecahedron_graph ·induced_subgraph ·line_graph ·make_graph ·mycielski_graph ·new_graph ·path_digraph ·path_graph ·petersen_graph ·random_bipartite_graph ·random_digraph ·random_regular_graph ·random_graph ·random_graph1 ·random_network ·random_tournament ·random_tree ·small_rhombicosidodecahedron_graph ·small_rhombicuboctahedron_graph ·snub_cube_graph ·snub_dodecahedron_graph ·truncated_cube_graph ·truncated_dodecahedron_graph ·truncated_icosahedron_graph ·truncated_tetrahedron_graph ·tutte_graph ·underlying_graph ·wheel_graph

Category: Package graphs - draw_graphs options

draw_graph_program ·show_id ·show_label ·label_alignment ·show_weight ·vertex_type ·vertex_size ·vertex_color ·show_vertices ·show_vertex_type ·show_vertex_size ·show_vertex_color ·vertex_partition ·vertex_coloring ·edge_color ·edge_width ·edge_type ·show_edges ·show_edge_color ·show_edge_width ·show_edge_type ·edge_partition ·edge_coloring ·redraw ·head_angle ·head_length ·spring_embedding_depth ·terminal ·file_name ·program ·fixed_vertices

Category: Package graphs - io

dimacs_export ·dimacs_import ·graph6_decode ·graph6_encode ·graph6_export ·graph6_import ·sparse6_decode ·sparse6_encode ·sparse6_export ·sparse6_import

Category: Package graphs - modifications

add_edge ·add_edges ·add_vertex ·add_vertices ·connect_vertices ·contract_edge ·remove_edge

Category: Package graphs - properties

adjacency_matrix ·average_degree ·biconnected_components ·bipartition ·chromatic_index ·chromatic_number ·clear_edge_weight ·clear_vertex_label ·connected_components ·diameter ·edge_coloring ·degree_sequence ·edge_connectivity ·edges ·get_edge_weight ·get_vertex_label ·graph_charpoly ·graph_center ·graph_eigenvalues ·graph_periphery ·graph_size ·graph_order ·girth ·hamilton_cycle ·hamilton_path ·isomorphism ·in_neighbors ·is_biconnected ·is_bipartite ·is_connected ·is_digraph ·is_edge_in_graph ·is_graph ·is_graph_or_digraph ·is_isomorphic ·is_planar ·is_sconnected ·is_vertex_in_graph ·is_tree ·laplacian_matrix ·max_clique ·max_degree ·max_flow ·max_independent_set ·max_matching ·min_degree ·min_edge_cut ·min_vertex_cover ·min_vertex_cut ·minimum_spanning_tree ·neighbors ·odd_girth ·out_neighbors ·planar_embedding ·radius ·set_edge_weight ·set_vertex_label ·shortest_path ·shortest_weighted_path ·strong_components ·topological_sort ·vertex_connectivity ·vertex_degree ·vertex_distance ·vertex_eccentricity ·vertex_in_degree ·vertex_out_degree ·vertices ·vertex_coloring ·wiener_index

Category: Package graphs

Introduction to graphs ·create_graph ·copy_graph ·circulant_graph ·clebsch_graph ·complement_graph ·complete_bipartite_graph ·complete_graph ·cycle_digraph ·cycle_graph ·cuboctahedron_graph ·cube_graph ·dodecahedron_graph ·empty_graph ·flower_snark ·from_adjacency_matrix ·frucht_graph ·graph_product ·graph_union ·grid_graph ·great_rhombicosidodecahedron_graph ·great_rhombicuboctahedron_graph ·grotzch_graph ·heawood_graph ·icosahedron_graph ·icosidodecahedron_graph ·induced_subgraph ·line_graph ·make_graph ·mycielski_graph ·new_graph ·path_digraph ·path_graph ·petersen_graph ·random_bipartite_graph ·random_digraph ·random_regular_graph ·random_graph ·random_graph1 ·random_network ·random_tournament ·random_tree ·small_rhombicosidodecahedron_graph ·small_rhombicuboctahedron_graph ·snub_cube_graph ·snub_dodecahedron_graph ·truncated_cube_graph ·truncated_dodecahedron_graph ·truncated_icosahedron_graph ·truncated_tetrahedron_graph ·tutte_graph ·underlying_graph ·wheel_graph ·adjacency_matrix ·average_degree ·biconnected_components ·bipartition ·chromatic_index ·chromatic_number ·clear_edge_weight ·clear_vertex_label ·connected_components ·diameter ·edge_coloring ·degree_sequence ·edge_connectivity ·edges ·get_edge_weight ·get_vertex_label ·graph_charpoly ·graph_center ·graph_eigenvalues ·graph_periphery ·graph_size ·graph_order ·girth ·hamilton_cycle ·hamilton_path ·isomorphism ·in_neighbors ·is_biconnected ·is_bipartite ·is_connected ·is_digraph ·is_edge_in_graph ·is_graph ·is_graph_or_digraph ·is_isomorphic ·is_planar ·is_sconnected ·is_vertex_in_graph ·is_tree ·laplacian_matrix ·max_clique ·max_degree ·max_flow ·max_independent_set ·max_matching ·min_degree ·min_edge_cut ·min_vertex_cover ·min_vertex_cut ·minimum_spanning_tree ·neighbors ·odd_girth ·out_neighbors ·planar_embedding ·print_graph ·radius ·set_edge_weight ·set_vertex_label ·shortest_path ·shortest_weighted_path ·strong_components ·topological_sort ·vertex_connectivity ·vertex_degree ·vertex_distance ·vertex_eccentricity ·vertex_in_degree ·vertex_out_degree ·vertices ·vertex_coloring ·wiener_index ·add_edge ·add_edges ·add_vertex ·add_vertices ·connect_vertices ·contract_edge ·remove_edge ·remove_vertex ·dimacs_export ·dimacs_import ·graph6_decode ·graph6_encode ·graph6_export ·graph6_import ·sparse6_decode ·sparse6_encode ·sparse6_export ·sparse6_import ·draw_graph ·draw_graph_program ·show_id ·show_label ·label_alignment ·show_weight ·vertex_type ·vertex_size ·vertex_color ·show_vertices ·show_vertex_type ·show_vertex_size ·show_vertex_color ·vertex_partition ·vertex_coloring ·edge_color ·edge_width ·edge_type ·show_edges ·show_edge_color ·show_edge_width ·show_edge_type ·edge_partition ·edge_coloring ·redraw ·head_angle ·head_length ·spring_embedding_depth ·terminal ·file_name ·program ·fixed_vertices ·vertices_to_path ·vertices_to_cycle

Category: Package grobner

Introduction to grobner ·poly_monomial_order ·poly_coefficient_ring ·poly_primary_elimination_order ·poly_secondary_elimination_order ·poly_elimination_order ·poly_return_term_list ·poly_grobner_debug ·poly_grobner_algorithm ·poly_top_reduction_only ·poly_add ·poly_subtract ·poly_multiply ·poly_s_polynomial ·poly_primitive_part ·poly_normalize ·poly_expand ·poly_expt ·poly_content ·poly_pseudo_divide ·poly_exact_divide ·poly_normal_form ·poly_buchberger_criterion ·poly_buchberger ·poly_reduction ·poly_minimization ·poly_normalize_list ·poly_grobner ·poly_reduced_grobner ·poly_depends_p ·poly_elimination_ideal ·poly_colon_ideal ·poly_ideal_intersection ·poly_lcm ·poly_gcd ·poly_grobner_equal ·poly_grobner_subsetp ·poly_grobner_member ·poly_ideal_saturation1 ·poly_ideal_saturation ·poly_ideal_polysaturation1 ·poly_ideal_polysaturation ·poly_saturation_extension ·poly_polysaturation_extension

Category: Package impdiff

implicit_derivative

Category: Package implicit_plot

implicit_plot

Category: Package ineq

Package ineq

Category: Package interpol

Introduction to interpol ·lagrange ·charfun2 ·linearinterpol ·cspline ·ratinterpol

Category: Package itensor

Introduction to itensor ·entertensor ·changename ·listoftens ·ishow ·indices ·rename ·show ·flipflag ·defcon ·remcon ·contract ·indexed_tensor ·components ·remcomps ·showcomps ·idummy ·idummyx ·icounter ·kdelta ·kdels ·levi_civita ·lc2kdt ·lc_l ·lc_u ·canten ·concan ·allsym ·decsym ·remsym ·canform ·diff ·idiff ·liediff ·rediff ·undiff ·evundiff ·flush ·flushd ·flushnd ·coord ·remcoord ·makebox ·conmetderiv ·simpmetderiv ·flush1deriv ·imetric ·idim ·ichr1 ·ichr2 ·icurvature ·covdiff ·lorentz_gauge ·igeodesic_coords ·iframes ·ifb ·icc1 ·icc2 ·ifc1 ·ifc2 ·ifr ·ifri ·ifg ·ifgi ·iframe_bracket_form ·inm ·inmc1 ·inmc2 ·ikt1 ·ikt2 ·itr ·~ ·| ·extdiff ·hodge ·igeowedge_flag ·tentex ·ic_convert

Category: Package lapack

Introduction to lapack ·dgeev ·dgeqrf ·dgesv ·dgesvd ·dlange ·zlange ·dgemm

Category: Package lbfgs

Introduction to lbfgs ·lbfgs ·lbfgs_nfeval_max ·lbfgs_ncorrections

Category: Package lindstedt

Lindstedt

Category: Package linearalgebra

nonnegintegerp ·Introduction to linearalgebra ·addmatrices ·blockmatrixp ·columnop ·columnswap ·columnspace ·copy ·cholesky ·ctranspose ·diag_matrix ·dotproduct ·eigens_by_jacobi ·get_lu_factors ·hankel ·hessian ·hilbert_matrix ·identfor ·invert_by_lu ·jacobian ·kronecker_product ·listp ·locate_matrix_entry ·lu_backsub ·lu_factor ·mat_cond ·mat_norm ·matrixp ·matrix_size ·mat_fullunblocker ·mat_trace ·mat_unblocker ·nullspace ·nullity ·orthogonal_complement ·polynomialp ·polytocompanion ·ptriangularize ·rowop ·rank ·rowswap ·toeplitz ·vandermonde_matrix ·zerofor ·zeromatrixp

Category: Package lsquares

Introduction to lsquares ·lsquares_estimates ·lsquares_estimates_exact ·lsquares_estimates_approximate ·lsquares_mse ·lsquares_residuals ·lsquares_residual_mse ·plsquares

Category: Package makeOrders

makeOrders

Category: Package minpack

Introduction to minpack ·Introduction to minpack

Category: Package mnewton

Introduction to mnewton ·newtonepsilon ·newtonmaxiter ·mnewton

Category: Package nchrpl

mattrace ·ncharpoly

Category: Package ntrig

ntrig

Category: Package numericalio

Introduction to numericalio ·read_matrix ·read_array ·read_hashed_array ·read_nested_list ·read_list ·write_data ·assume_external_byte_order ·openr_binary ·openw_binary ·opena_binary ·read_binary_matrix ·read_binary_array ·read_binary_list ·write_binary_data

Category: Package opsubst

opsubst

Category: Package orthopoly

Introduction to orthogonal polynomials ·assoc_legendre_p ·assoc_legendre_q ·chebyshev_t ·chebyshev_u ·gen_laguerre ·hermite ·intervalp ·jacobi_p ·laguerre ·legendre_p ·legendre_q ·orthopoly_recur ·orthopoly_returns_intervals ·orthopoly_weight ·pochhammer ·pochhammer_max_index ·spherical_bessel_j ·spherical_bessel_y ·spherical_hankel1 ·spherical_hankel2 ·spherical_harmonic ·unit_step ·ultraspherical

Category: Package physical_constants

Introduction to physical_constants

Category: Package plotdf

Introduction to plotdf ·plotdf

Category: Package quadpack

Introduction to QUADPACK ·quad_qag ·quad_qags ·quad_qagi ·quad_qawc ·quad_qawf ·quad_qawo ·quad_qaws

Category: Package rducon

Package rducon ·reduce_consts

Category: Package romberg

romberg ·rombergabs ·rombergit ·rombergmin ·rombergtol

Category: Package scifac

Package scifac ·gcfac

Category: Package simplex

Introduction to simplex ·epsilon_lp ·linear_program ·maximize_lp ·minimize_lp ·nonegative_lp

Category: Package solve_rec

Introduction to solve_rec ·reduce_order ·simplify_products ·simplify_sum ·solve_rec ·solve_rec_rat ·product_use_gamma ·summand_to_rec

Category: Package sqdnst

sqrtdenest

Category: Package stats

Introduction to stats ·inference_result ·inferencep ·items_inference ·take_inference ·stats_numer ·test_mean ·test_means_difference ·test_variance ·test_variance_ratio ·test_proportion ·test_proportions_difference ·test_sign ·test_signed_rank ·test_rank_sum ·test_normality ·simple_linear_regression ·pdf_signed_rank ·cdf_signed_rank ·pdf_rank_sum ·cdf_rank_sum

Category: Package stirling

stirling

Category: Package stringproc

Introduction to string processing ·close ·flength ·fposition ·freshline ·newline ·opena ·openr ·openw ·printf ·readline ·sprint ·alphacharp ·alphanumericp ·ascii ·cequal ·cequalignore ·cgreaterp ·cgreaterpignore ·charp ·cint ·clessp ·clesspignore ·constituent ·cunlisp ·digitcharp ·lcharp ·lowercasep ·newline ·space ·tab ·uppercasep ·stringp ·charat ·charlist ·eval_string ·parse_string ·scopy ·sdowncase ·sequal ·sequalignore ·sexplode ·simplode ·sinsert ·sinvertcase ·slength ·smake ·smismatch ·split ·sposition ·sremove ·sremovefirst ·sreverse ·ssearch ·ssort ·ssubst ·ssubstfirst ·strim ·striml ·strimr ·substring ·supcase ·tokens

Category: Package sym

Introduction to Symmetries ·comp2pui ·ele2pui ·ele2comp ·elem ·mon2schur ·multi_elem ·multi_pui ·pui ·pui2comp ·pui2ele ·puireduc ·schur2comp ·cont2part ·contract ·explose ·part2cont ·partpol ·tcontract ·tpartpol ·direct ·multi_orbit ·multsym ·orbit ·pui_direct ·kostka ·lgtreillis ·ltreillis ·treillis ·treinat ·ele2polynome ·polynome2ele ·prodrac ·pui2polynome ·somrac ·resolvante ·resolvante_alternee1 ·resolvante_bipartite ·resolvante_diedrale ·resolvante_klein ·resolvante_klein3 ·resolvante_produit_sym ·resolvante_unitaire ·resolvante_vierer ·multinomial ·permut

Category: Package unit

Introduction to Units ·setunits ·uforget ·convert ·usersetunits ·metricexpandall ·%unitexpand

Category: Package vect

Vectors ·scalefactors ·vectorpotential ·vectorpotential ·vectorsimp ·vect_cross

Category: Package zeilberger

Introduction to zeilberger ·AntiDifference ·Gosper ·GosperSum ·parGosper ·Zeilberger ·MAX_ORD ·simplified_output ·linear_solver ·warnings ·Gosper_in_Zeilberger ·trivial_solutions ·mod_test ·modular_linear_solver ·ev_point ·mod_big_prime ·mod_threshold

Category: Physical units

Introduction to ezunits ·Introduction to physical_constants ·Introduction to Units

Category: Plotting

bode_gain ·bode_phase ·barsplot ·barsplot_description ·boxplot ·boxplot_description ·histogram ·histogram_description ·piechart ·piechart_description ·scatterplot ·scatterplot_description ·starplot ·starplot_description ·stemplot ·Introduction to drawdf ·Introduction to draw ·chaosgame ·evolution ·evolution2d ·ifs ·julia ·mandelbrot ·orbits ·staircase ·implicit_plot ·Introduction to orthogonal polynomials ·plotdf ·Introduction to Plotting ·Plotting Formats ·contour_plot ·make_transform ·polar_to_xy ·plot2d ·plot3d ·plot_options ·set_plot_option ·spherical_to_xyz ·adapt_depth ·axes ·azimuth ·box ·color ·colorbox ·elevation ·grid ·legend ·logx ·logy ·mesh_lines_color ·nticks ·palette ·plot_format ·plot_real_part ·point_type ·psfile ·run_viewer ·style ·t ·transform_xy ·x ·xlabel ·y ·ylabel ·z ·zlabel ·gnuplot_term ·gnuplot_out_file ·gnuplot_pm3d ·gnuplot_preamble ·gnuplot_curve_titles ·gnuplot_curve_styles ·gnuplot_default_term_command ·gnuplot_dumb_term_command ·gnuplot_ps_term_command ·gnuplot_start ·gnuplot_close ·gnuplot_restart ·gnuplot_replot ·gnuplot_reset

Category: Poisson series

intopois ·outofpois ·poisdiff ·poisexpt ·poisint ·poislim ·poismap ·poisplus ·poissimp ·poisson ·poissubst ·poistimes ·poistrim ·printpois

Category: Polynomials

Introduction to Affine ·allroots ·bfallroots ·multiplicities ·nroots ·nthroot ·polyfactor ·programmode ·realroots ·rootsepsilon ·makeOrders ·Introduction to Polynomials ·berlefact ·bezout ·bothcoef ·coeff ·content ·divide ·eliminate ·ezgcd ·facexpand ·factor ·factorflag ·fasttimes ·gcd ·gcdex ·gfactor ·lratsubst ·polydecomp ·polymod ·powers ·quotient ·ratcoef ·remainder ·resultant ·savefactors ·sqfr ·tellrat ·untellrat ·gcdivide ·Introduction to Symmetries

Category: Power series

deftaylor ·maxtayorder ·pade ·powerseries ·revert ·revert2 ·taylor ·taylordepth ·taylorinfo ·taylorp ·taylor_logexpand ·taylor_order_coefficients ·taylor_simplifier ·taylor_truncate_polynomials ·taytorat ·trunc ·verbose

Category: Predicate functions

subvarp ·abasep ·diagmatrixp ·symmetricp ·is ·maybe ·constantp ·unknown ·zeroequiv ·bfloatp ·evenp ·floatnump ·integerp ·nonnegintegerp ·numberp ·oddp ·ratnump ·picture_equalp ·picturep ·atom ·operatorp ·ordergreatp ·orderlessp ·symbolp ·poly_depends_p ·poly_grobner_subsetp ·blockmatrixp ·listp ·matrixp ·polynomialp ·zeromatrixp ·listp ·member ·matrixp ·nonscalarp ·scalarp ·disjointp ·elementp ·emptyp ·setequalp ·setp ·subsetp ·primep ·primep_number_of_tests ·intervalp ·ratp ·if ·mapatom ·prederror ·featurep ·taylorp ·alphacharp ·alphanumericp ·cequal ·cequalignore ·cgreaterp ·cgreaterpignore ·charp ·clessp ·clesspignore ·constituent ·digitcharp ·lcharp ·lowercasep ·uppercasep ·stringp ·sequal ·sequalignore

Category: Programming

Function ·block ·catch ·local ·Lisp and Maxima ·do ·errcatch ·error ·errormsg ·errormsg ·for ·go ·if ·prederror ·return ·throw ·while ·unless ·sstatus ·status

Category: Random numbers

random_normal ·random_student_t ·random_noncentral_student_t ·random_chi2 ·random_noncentral_chi2 ·random_f ·random_exp ·random_lognormal ·random_gamma ·random_beta ·random_continuous_uniform ·random_logistic ·random_pareto ·random_weibull ·random_rayleigh ·random_laplace ·random_cauchy ·random_gumbel ·random_general_finite_discrete ·random_binomial ·random_poisson ·random_bernoulli ·random_geometric ·random_discrete_uniform ·random_hypergeometric ·random_negative_binomial ·make_random_state ·set_random_state ·random

Category: Rational expressions

ratepsilon ·ratnump ·ratmx ·Introduction to Polynomials ·fullratsimp ·fullratsubst ·gcd ·gcdex ·lratsubst ·rat ·ratcoef ·ratdenom ·ratdenomdivide ·ratdiff ·ratdisrep ·ratexpand ·ratfac ·ratnumer ·ratp ·ratprint ·ratsimp ·ratsimpexpons ·ratsubst ·ratvars ·ratvarswitch ·ratweight ·ratweights ·ratwtlvl ·showratvars ·tellrat ·totaldisrep ·untellrat ·taytorat

Category: Rules and patterns

Introduction to Rules and Patterns ·apply1 ·apply2 ·applyb1 ·current_let_rule_package ·default_let_rule_package ·defmatch ·defrule ·disprule ·let ·letrat ·letrules ·letsimp ·let_rule_packages ·matchdeclare ·remlet ·remrule ·tellsimp ·tellsimpafter ·clear_rules ·Package absimp ·Package ineq

Category: Session management

kill ·myoptions ·nolabels ·optionset ·reset ·batch ·batchload ·load ·loadfile ·save ·stringout ·Introduction for Runtime Environment

Category: Sets

lmax ·lmin ·Introduction to Sets ·adjoin ·belln ·cardinality ·cartesian_product ·disjoin ·disjointp ·elementp ·emptyp ·equiv_classes ·every ·extremal_subset ·flatten ·full_listify ·intersect ·intersection ·listify ·makeset ·partition_set ·permutations ·powerset ·random_permutation ·setdifference ·setequalp ·setp ·set_partitions ·some ·subset ·subsetp ·symmdifference ·tree_reduce ·union ·xreduce

Category: Share packages

Introduction to Affine ·Introduction to atensor ·augmented_lagrangian_method ·Introduction to cobyla ·Introduction to contrib_ode ·Introduction to ctensor ·Introduction to descriptive ·diag ·Introduction to distrib ·Introduction to drawdf ·Introduction to draw ·Introduction to dynamics ·dimension ·Introduction to ezunits ·Introduction to physical_constants ·f90 ·ggf ·Introduction to graphs ·Introduction to grobner ·implicit_derivative ·implicit_plot ·Introduction to QUADPACK ·Introduction to interpol ·Introduction to itensor ·Introduction to lapack ·Introduction to lbfgs ·Lindstedt ·Introduction to linearalgebra ·Introduction to lsquares ·makeOrders ·Vectors ·eigen ·Introduction to minpack ·Introduction to mnewton ·Introduction to numericalio ·Introduction to fast Fourier transform ·Introduction to Fourier series ·opsubst ·Introduction to orthogonal polynomials ·Introduction to plotdf ·Introduction to simplex ·Package absimp ·Package facexp ·Package functs ·Package ineq ·Package rducon ·Package scifac ·sqrtdenest ·Introduction to solve_rec ·Introduction to stats ·stirling ·Introduction to string processing ·Introduction to Symmetries ·Introduction to Units ·Introduction to zeilberger

Category: Simplification flags and variables

ctrgsimp ·rootsconmode ·evflag ·sumsplitfact ·%e_to_numlog ·%emode ·logarc ·logconcoeffp ·logexpand ·lognegint ·lognumer ·logsimp ·%piargs ·%iargs ·halfangles ·trigexpandplus ·trigexpandtimes ·triginverses ·trigsign ·dot0nscsimp ·dot0simp ·dot1simp ·dotassoc ·dotconstrules ·dotdistrib ·dotexptsimp ·dotident ·dotscrules ·scalarmatrixp ·algebraic ·ratalgdenom ·ratdenomdivide ·ratsimpexpons ·radsubstflag ·simpsum ·sumexpand ·distribute_over ·domain ·negdistrib ·radexpand ·besselexpand ·gammalim ·beta_expand ·beta_args_sum_to_integer

Category: Simplification functions

atensimp ·unknown ·rootscontract ·logarc ·trigexpand ·trigreduce ·trigsimp ·trigrat ·vectorsimp ·foursimp ·fullratsimp ·ratsimp ·Package absimp ·Package ineq ·radcan ·scsimp ·simplify_sum

Category: Simplification

Introduction to Rules and Patterns ·lassociative ·linear ·multiplicative

Category: Special functions

Introduction to Special Functions ·bessel_j ·bessel_y ·bessel_i ·bessel_k ·hankel_1 ·hankel_2 ·besselexpand ·scaled_bessel_i0 ·scaled_bessel_i1 ·%s ·airy_ai ·airy_dai ·airy_bi ·airy_dbi ·gamma ·log_gamma ·gamma_incomplete ·gamma_incomplete_regularized ·gamma_incomplete_generalized ·expintegral_e1 ·expintegral_ei ·expintegral_li ·expintegral_e ·expintegral_si ·expintegral_ci ·expintegral_shi ·expintegral_chi ·erf ·erfc ·erfi ·erf_generalized ·fresnel_c ·fresnel_s ·struve_h ·struve_l ·%m ·%w ·%f ·parabolic_cylinder_d ·lambert_w ·nzeta ·nzetar ·nzetai

Category: Statistical estimation

Introduction to lsquares ·simple_linear_regression

Category: Statistical functions

Introduction to distrib

Category: Statistical inference

Introduction to stats

Category: Strings

concat ·sconcat ·string ·Introduction to string processing

Category: Structures

structures ·defstruct ·new ·@

Category: Sums and products

genindex ·gensumnum ·bashindices ·lsum ·product ·simpsum ·sum ·sumcontract ·sumexpand ·cauchysum ·niceindices ·niceindicespref ·nusum ·unsum ·arithmetic ·geometric ·harmonic ·arithsum ·geosum ·simplify_sum ·Introduction to zeilberger

Category: Syntax

Introduction to Strings ·Identifiers ·Comments ·Introduction to operators ·infix ·matchfix ·nary ·nofix ·postfix ·prefix

Category: Tensors

Introduction to atensor ·Introduction to ctensor ·Introduction to itensor

Category: TeX output

tex ·texput ·get_tex_environment ·set_tex_environment ·get_tex_environment_default ·set_tex_environment_default ·tentex

Category: Time and date functions

timedate ·absolute_real_time ·elapsed_real_time ·elapsed_run_time

Category: Translation and compilation

f90 ·compfile ·compile ·define_variable ·mode_declare ·mode_identity ·translate ·translate_file ·tr_warnings_get ·compile_file ·declare_translated ·fortindent ·fortran ·fortspaces

Category: Translation flags and variables

mode_checkp ·mode_check_errorp ·mode_check_warnp ·savedef ·transcompile ·transrun ·tr_array_as_ref ·tr_bound_function_applyp ·tr_file_tty_messagesp ·tr_float_can_branch_complex ·tr_function_call_default ·tr_numer ·tr_optimize_max_loop ·tr_semicompile ·tr_state_vars ·tr_warn_bad_function_calls ·tr_warn_fexpr ·tr_warn_meval ·tr_warn_mode ·tr_warn_undeclared ·tr_warn_undefined_variable ·packagefile

Category: Trigonometric functions

Introduction to Trigonometric ·%piargs ·%iargs ·acos ·acot ·acsc ·asec ·asin ·atan ·atan2 ·atrig1 ·cos ·cot ·csc ·halfangles ·ntrig ·sec ·sin ·tan ·trigexpand ·trigexpandplus ·trigexpandtimes ·triginverses ·trigreduce ·trigsign ·trigsimp ·trigrat ·foursimp ·demoivre ·exponentialize

Category: Vectors

express ·Vectors ·eigen ·nonscalar ·nonscalarp ·scalarp

#### Footnotes

### (1)

Applied Mathematics and Programming Division, K.U. Leuven

### (2)

Applied Mathematics and Programming Division, K.U. Leuven

### (3)

Institut für Mathematik, T.U. Wien

### (4)

National Bureau of Standards, Washington, D.C., U.S.A

### (5)

http://www.netlib.org/slatec

### (6)

http://www.netlib.org/quadpack

### (7)

R. Piessens, E. de Doncker-Kapenga, C.W. Uberhuber, and D.K. Kahaner. QUADPACK: A Subroutine Package for Automatic Integration. Berlin: Springer-Verlag, 1983, ISBN 0387125531.