This is maxima.info, produced by makeinfo version 7.3 from maxima.texi.

This is a Texinfo Maxima Manual

   Copyright 1994,2001 William F. Schelter

INFO-DIR-SECTION Math
START-INFO-DIR-ENTRY
* Maxima: (maxima).     A computer algebra system.
END-INFO-DIR-ENTRY


File: maxima.info,  Node: Top,  Next: Introduction to Maxima,  Prev: (dir),  Up: (dir)

Maxima 5.50.0 Manual
********************

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と呼ばれています。

* Menu:

Maximaの基盤

* Introduction to Maxima::      Maximaセッションの実例
* Bug Detection and Reporting:: Maximaのバグの発見と報告
* Help::                        Maximaセッションの中でヘルプを見る
* Command Line::                Maximaコマンドライン構文法、入出力
* Data Types and Structures::   数、文字列、リスト、配列、構造体
* Expressions::                 Maximaにおける式
* Operators::                   Maxima式の中で使われる演算子
* Evaluation::                  式の評価
* Simplification::              式の整理
* Mathematical Functions::      Maximaの数学的関数
* Maximas Database::            宣言、文脈、事実、プロパティ
* Plotting::                    2次元と3次元のグラフィカル出力
* File Input and Output::       ファイル入出力

数学の特定分野のサポート

* Polynomials::                 多項式の標準形と操作関数
* Special Functions::           特殊函数
* Elliptic Functions::          楕円函数と楕円積分
* Limits::                      式の極限
* Differentiation::             微分法
* Integration::                 積分法
* Equations::                   方程式の定義と解法
* Differential Equations::      微分方程式の定義と解法
* Numerical::                   数値積分、Fourier変換など
* Matrices and Linear Algebra:: 行列演算
* Affine::
* itensor::                     添字テンソル操作
* ctensor::                     成分テンソル操作
* atensor::                     代数テンソル操作
* Sums Products and Series::    和、積、Tayler級数とべき級数
* Number Theory::               数論
* Symmetries::
* Groups::                      抽象代数

上級用機能とプログラミング

* Runtime Environment::         Maxima環境のカスタム化
* Miscellaneous Options::       Maximaでグローバルな効果を持つオプション
* Rules and Patterns::          ユーザー定義のパターンマッチングと整理ルール
* Sets::                        集合の操作
* Function Definition::         関数定義
* Program Flow::                Maximaプログラムの定義
* Debugging::                   Maximaプログラムのデバッグ

その他のパッケージ

* asympa::                      漸近解析パッケージ
* augmented_lagrangian::        拡張Lagrangeパッケージ
* Bernstein::                   ‘Bernstein’多項式
* bode::                        Bode線図
* cobyla::                      不等式制約を持つ非線形最適化
* contrib_ode::                 ODEのための追加ルーチン
* descriptive::                 記述統計
* diag::                        Jordan行列
* distrib::                     確率分布
* draw::                        Maxima-Gnuplotインターフェイス
* drawdf::                      Gnuplotを使った方向場
* dynamics::                    力学系とフラクタルのグラフィックス
* ezunits::                     次元量
* f90::                         MaximaからFortranへの翻訳器
* finance::                     金融パッケージ
* fractals::                    フラクタル
* ggf::                         数列の母函数
* graphs::                      グラフ理論パッケージ
* grobner::                     Groebner基底を扱う関数
* impdiff::                     陰導函数
* implicit_plot::               陰プロットパッケージ
* interpol::                    内挿バッケージ
* lapack::                      線形代数のためのLAPACK関数
* lbfgs::                       L-BFGS無制約最小化パッケージ
* lindstedt::                   Lindstedtパッケージ
* linearalgebra::               線形代数のための関数
* lsquares::                    最小二乗
* makeOrders::                  多項式ユーティリティ
* minpack::                     最小化と根のためのMINPACK関数
* mnewton::                     Newton法
* numericalio::                 ファイルの読み書き
* opsubst::                     代入ユーティリティ
* orthopoly::                   直交多項式
* plotdf::                      方向場プロット
* romberg::                     数値積分のRomberg法
* simplex::                     線形計画
* simplification::              整理のルールと関数
* solve_rec::                   線形漸化式
* stats::                       統計的推定パッケージ
* stirling::                    Stirling公式
* stringproc::                  文字列処理
* to_poly_solve::               ‘to_poly_solve’パッケージ
* unit::                        単位と次元パッケージ
* zeilberger::                  超幾何総和に関する関数


索引

* Function and Variable Index:: インデックス

訳者後書き

* Translator's Comments::       訳者のコメント

 -- The Detailed Node Listing --

手引き

* Introduction to Maxima::

バグ

* Bug Detection and Reporting::

ヘルプ

* Documentation::
* Functions and Variables for Help::

コマンドライン

* Introduction to Command Line::
* Functions and Variables for Command Line::
* Functions and Variables for Display::

データ型と構造体

* Numbers::
* Strings::
* Constants::
* Lists::
* Arrays::
* Structures::

式

* Introduction to Expressions::
* Nouns and Verbs::
* Identifiers::
* Inequality::
* Functions and Variables for Expressions::

演算子

* Introduction to operators::
* Arithmetic operators::
* Relational operators::
* Logical operators::
* Operators for Equations::
* Assignment operators::
* User defined operators::

評価

* Functions and Variables for Evaluation::

式整理

* Functions and Variables for Simplification::

数学的関数

* Functions for Numbers::
* Functions for Complex Numbers::
* Combinatorial Functions::
* Root Exponential and Logarithmic Functions::
* Trigonometric Functions::
* Random Numbers::

Maximaのデータベース

* Introduction to Maximas Database::
* Functions and Variables for Properties::
* Functions and Variables for Facts::
* Functions and Variables for Predicates::

プロット

* Introduction to Plotting::
* Plotting Formats::
* Functions and Variables for Plotting::
* Plotting Options::
* Gnuplot Options::
* Gnuplot_pipes Format Functions::

ファイル入出力

* Comments::
* Files::
* Functions and Variables for File Input and Output::

多項式

* Introduction to Polynomials::
* Functions and Variables for Polynomials::

特殊函数

* Introduction to Special Functions::
* Bessel Functions::
* Airy Functions::
* Gamma and factorial Functions::
* Exponential Integrals::
* Error Function::
* Struve Functions::
* Hypergeometric Functions::
* Parabolic Cylinder Functions::
* Functions and Variables for Special Functions::

楕円函数

* Introduction to Elliptic Functions and Integrals::
* Functions and Variables for Elliptic Functions::
* Functions and Variables for Elliptic Integrals::

極限

* Functions and Variables for Limits::

微分

* Functions and Variables for Differentiation::

積分

* Introduction to Integration::
* Functions and Variables for Integration::

方程式

* Functions and Variables for Equations::

微分方程式

* Introduction to Differential Equations::
* Functions and Variables for Differential Equations::

数値

* Introduction to fast Fourier transform::
* Functions and Variables for fast Fourier transform::
* Introduction to Fourier series::
* Functions and Variables for Fourier series::

行列と線形代数

* Introduction to Matrices and Linear Algebra::
* Dot::
* Vectors::
* eigen::
* Functions and Variables for Matrices and Linear Algebra::

アフィン

* Introduction to Affine::
* Functions and Variables for Affine::

指標テンソル

* Introduction to itensor::
* Functions and Variables for itensor::

成分テンソル

* Introduction to ctensor::
* Functions and Variables for ctensor::

代数テンソル

* Introduction to atensor::
* Functions and Variables for atensor::

和、積、級数

* Sums and Products::
* Introduction to Series::
* Functions and Variables for Series::
* Poisson series::

数論

* Functions and Variables for Number Theory::

対称群

* Introduction to Symmetries::
* Functions and Variables for Symmetries::

群

* Functions and Variables for Groups::

ランタイム環境

* Introduction for Runtime Environment::
* Interrupts::
* Functions and Variables for Runtime Environment::

様々なオプション

* Introduction to Miscellaneous Options::
* Share::
* Functions and Variables for Miscellaneous Options::

規則とパターン

* Introduction to Rules and Patterns::
* Functions and Variables for Rules and Patterns::

集合

* Introduction to Sets::
* Functions and Variables for Sets::

関数定義

* Introduction to Function Definition::
* Function::
* Macros::
* Functions and Variables for Function Definition::

プログラムフロー

* Lisp and Maxima::
* Garbage Collection::
* Introduction to Program Flow::
* Functions and Variables for Program Flow::

デバッグ

* Functions and Variables for Debugging::

asympa

* Introduction to asympa::
* Functions and variables for asympa::

augmented_lagrangian

* Functions and Variables for augmented_lagrangian::

Bernstein

* Functions and Variables for Bernstein::

bode

* Functions and Variables for bode::

cobyla

* Introduction to cobyla::
* Functions and Variables for cobyla::
* Examples for cobyla::

contrib_ode

* Introduction to contrib_ode::
* Functions and Variables for contrib_ode::
* Possible improvements to contrib_ode::
* Test cases for contrib_ode::
* References for contrib_ode::

descriptive

* Introduction to descriptive::
* Functions and Variables for data manipulation::
* Functions and Variables for descriptive statistics::
* Functions and Variables for statistical graphs::

diag

* Functions and Variables for diag::

distrib

* Introduction to distrib::
* Functions and Variables for continuous distributions::
* Functions and Variables for discrete distributions::

draw

* Introduction to draw::
* Functions and Variables for draw::
* Functions and Variables for pictures::
* Functions and Variables for worldmap::

drawdf

* Introduction to drawdf::
* Functions and Variables for drawdf::

dynamics

* Introduction to dynamics::
* Functions and Variables for dynamics::

ezunits

* Introduction to ezunits::
* Introduction to physical_constants::
* Functions and Variables for ezunits::

f90

* Functions and Variables for f90::

finance

* Introduction to finance::
* Functions and Variables for finance::

fractals

* Introduction to fractals::
* Definitions for IFS fractals::
* Definitions for complex fractals::
* Definitions for Koch snowflakes::
* Definitions for Peano maps::

ggf

* Functions and Variables for ggf::

graphs

* Introduction to graphs::
* Functions and Variables for graphs::

grobner

* Introduction to grobner::
* Functions and Variables for grobner::

impdiff

* Functions and Variables for impdiff::

implicit_plot

* Functions and Variables for implicit_plot::

interpol

* Introduction to interpol::
* Functions and Variables for interpol::

lapack

* Introduction to lapack::
* Functions and Variables for lapack::

lbfgs

* Introduction to lbfgs::
* Functions and Variables for lbfgs::

lindstedt

* Functions and Variables for lindstedt::

linearalgebra

* Introduction to linearalgebra::
* Functions and Variables for linearalgebra::

lsquares

* Introduction to lsquares::
* Functions and Variables for lsquares::

makeOrders

* Functions and Variables for makeOrders::

minpack

* Introduction to minpack::
* Functions and Variables for minpack::

mnewton

* Introduction to mnewton::
* Functions and Variables for mnewton::

numericalio

* Introduction to numericalio::
* Functions and Variables for plain-text input and output::
* Functions and Variables for binary input and output::

opsubst

* Functions and Variables for opsubst::

orthopoly

* Introduction to orthogonal polynomials::
* Functions and Variables for orthogonal polynomials::

plotdf

* Introduction to plotdf::
* Functions and Variables for plotdf::

romberg

* Functions and Variables for romberg::

simplex

* Introduction to simplex::
* Functions and Variables for simplex::

simplification

* Introduction to simplification::
* Package absimp::
* Package facexp::
* Package functs::
* Package ineq::
* Package rducon::
* Package scifac::
* Package sqdnst::

solve_rec

* Introduction to solve_rec::
* Functions and Variables for solve_rec::

stats

* Introduction to stats::
* Functions and Variables for inference_result::
* Functions and Variables for stats::
* Functions and Variables for special distributions::

stirling

* Functions and Variables for stirling::

stringproc

* Introduction to string processing::
* Functions and Variables for input and output::
* Functions and Variables for characters::
* Functions and Variables for strings::

to_poly_solve

* Functions and Variables for to_poly_solve::

unit

* Introduction to Units::
* Functions and Variables for Units::

zeilberger

* Introduction to zeilberger::
* Functions and Variables for zeilberger::


File: maxima.info,  Node: Introduction to Maxima,  Next: Bug Detection and Reporting,  Prev: Top,  Up: Top

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はインフォページを検索できます。 コマンドの情報や、文字列を含む
コマンドや変数すべてを表示させるには、 ‘*note describe::’コマンドを使っ
てください。 クエスチョンマーク‘*note ?::’ (完全一致検索)と 二重クエスチ
ョンマーク‘*note ??::’(部分一致検索)は‘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

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

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


File: maxima.info,  Node: Bug Detection and Reporting,  Next: Help,  Prev: Introduction to Maxima,  Up: Top

2 Bug Detection and Reporting
*****************************

* Menu:

* Functions and Variables for Bug Detection and Reporting::


File: maxima.info,  Node: Functions and Variables for Bug Detection and Reporting,  Up: Bug Detection and Reporting

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

 -- 関数: run_testsuite ([<options>])

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

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

     ‘display_all’
          テストすべてを表示します。 通常は、テストが失敗しない限りテス
          トを表示しません。 （デフォルトでは ‘false’に設定されます。）
     ‘display_known_bugs’
          既知のバグとしてマークされているテストを表示します。 （デフォ
          ルトでは ‘false’に設定されます。）
     ‘tests’
          これは、実行するテストのリストです。 それぞれのテストは文字列
          かシンボルで指定することができます。 デフォルトではテストすべ
          てを実行します。 テストの完全な組は ‘*note 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環境を変更します。 通常は、テストスクリプ
     トは 既知の環境（すなわちユーザー定義の関数や変数のない環境）を確立
     するために ‘*note kill::’を実行し、 それからテストにふさわしい関数
     や変数を定義します。

     ‘run_testsuite’は ‘done’を返します。

 -- オプション変数: testsuite_files

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

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

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

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

 -- 関数: bug_report ()

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

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

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

 -- 関数: build_info ()

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

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


File: maxima.info,  Node: Help,  Next: Command Line,  Prev: Bug Detection and Reporting,  Up: Top

3 Help
******

* Menu:

* Documentation::
* Functions and Variables for Help::


File: maxima.info,  Node: Documentation,  Next: Functions and Variables for Help,  Prev: Help,  Up: Help

3.1 Documentation
=================

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

   ‘*note 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

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


File: maxima.info,  Node: Functions and Variables for Help,  Prev: Documentation,  Up: Help

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]

 -- 関数: 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)

          _

 -- 関数: 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’を返します。

     *note 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’と省略形を使うことができます。

 -- 関数: example (<topic>)
 -- 関数: example ()

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

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

     例を含むファイル名は、グローバル変数‘*note 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

 -- オプション変数: manual_demo
     デフォルト値: ‘"manual.demo"’

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


File: maxima.info,  Node: Command Line,  Next: Data Types and Structures,  Prev: Help,  Up: Top

4 Command Line
**************

* Menu:

* Introduction to Command Line::
* Functions and Variables for Command Line::
* Functions and Variables for Display::


File: maxima.info,  Node: Introduction to Command Line,  Next: Functions and Variables for Command Line,  Prev: Command Line,  Up: Command Line

4.1 Introduction to Command Line
================================


File: maxima.info,  Node: Functions and Variables for Command Line,  Next: Functions and Variables for Display,  Prev: Introduction to Command Line,  Up: Command Line

4.2 Functions and Variables for Command Line
============================================

 -- システム変数: __

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

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

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

     ‘*note _::’や ‘*note %::’も参照してください。

     例:

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

 -- システム変数: _

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

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

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

     ‘*note __::’や ‘*note %::’も参照してください。

     例:

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

 -- システム変数: %

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

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

     ‘*note _::’, ‘*note %%::’, ‘*note %th::’も参照してください。

 -- システム変数: %%

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

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

     ‘%%’は、‘*note batch::’や ‘*note 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
          _

 -- 関数: %th (<i>)

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

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

     ‘*note %::’と ‘*note %%::’も参照してください。

     例:

     ‘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

 -- 特殊シンボル: ?

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

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

 -- 特殊シンボル: ??

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

 -- オプション変数: inchar
     デフォルト値: ‘%i’

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

     ‘inchar’は単一文字である必要はなく、 任意の文字列もしくはシンボルを
     割り当てられます。 Maximaは内部的に前置の最初の文字だけを考慮するの
     で、 前置‘inchar’, ‘*note outchar::’, ‘*note 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)

 -- システム変数: infolists
     デフォルト値: ‘[]’

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

     ‘labels’
          すべてのバインドされた‘%i’, ‘%o’, ‘%t’ラベル
     ‘values’
          ‘*note :::’や‘*note ::::’や関数バインドが生成する、 ユーザー変
          数であって、Maximaオプションやスイッチでない、 すべてのバイン
          ドされたアトム
     ‘functions’
          ‘*note :=::’や‘*note define::’が生成するすべてのユーザー定義関
          数
     ‘arrays’
          ‘:’, ‘::’, または‘:=’が生成するすべての宣言配列と未宣言配列
     ‘macros’
          ‘*note ::=::’が生成したすべてのユーザー定義マクロ関数
     ‘myoptions’
          (それらが後にデフォルト値に再設定されようがされまいが) ユーザ
          ーが再設定したすべてのオプション
     ‘rules’
          ‘*note tellsimp::’, ‘*note tellsimpafter::’, ‘*note
          defmatch::’, または‘*note defrule::’が生成するすべてのユーザー
          定義パターンマッチングと整理規則
     ‘aliases’
          ‘*note alias::’, ‘*note ordergreat::’, ‘*note orderless::’関数
          が生成するか、 ‘*note declare::’を使ってアトムを‘*note
          noun::’として宣言することで生成された、 ユーザー定義エーリアス
          を持つすべてのアトム
     ‘dependencies’
          ‘*note depends::’や‘*note gradef::’関数が生成する関数依存性を
          持つすべてのアトム
     ‘gradefs’
          ‘*note gradef::’関数が生成するユーザー定義の導関数を持つすべて
          の関数
     ‘props’
          ‘*note declare::’関数で確立されるプロパティはもちろん、 ‘*note
          atvalue::’や‘*note matchdeclare::’などが確立するプロパティで、
          上で述べたもの以外の任意のプロパティを持つすべてのアトム
     ‘let_rule_packages’
          特別パッケージ‘*note default_let_rule_package::’に加えて すべ
          てのユーザー定義‘*note let::’規則パッケージ
          (‘default_let_rule_package’は、 ユーザーが陽に設定していない時
          使われる規則パッケージの名前です。)

 -- 関数: 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)’は ‘*note inchar::’の現在の
     値で始まる入力ラベルのみをアンバインドします。 同様に、 ‘kill
     (outlabels)’は ‘*note outchar::’の現在の値で始まる出力ラベルのみを
     アンバインドし、 ‘kill (linelabels)’は ‘*note linechar::’の現在の値
     で始まる中間式ラベルのみをアンバインドします。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

     ‘*note inchar::’や‘*note outchar::’, ‘*note linechar::’, ‘*note
     infolists::’も参照してください。

 -- オプション変数: linechar
     デフォルト値: ‘%t’

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

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

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

 -- システム変数: linenum

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

 -- システム変数: myoptions
     デフォルト値: ‘[]’

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

 -- オプション変数: nolabels
     デフォルト値: ‘false’

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

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

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

     ‘*note batch::’や‘*note load::’、 ‘*note labels::’も参照してくださ
     い。

 -- オプション変数: 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

 -- オプション変数: outchar
     デフォルト値: ‘%o’

     ‘outchar’はMaximaが計算した式のラベルの前置です。 ‘outchar’と‘*note
     linenum::’を連結することで、 Maximaは計算された式それぞれのラベルを
     自動的に構成します。 ‘outchar’は、単一文字である必要はなく、 任意の
     文字列もしくはシンボルを割り当てられます。 Maximaは内部的に前置の最
     初の文字だけを考慮するので、 前置‘*note inchar::’, ‘outchar’,
     ‘*note 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)

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

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

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

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

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

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

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

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

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

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

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

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

 -- オプション変数: prompt
     デフォルト値: ‘_’

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

 -- 関数: quit ()

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

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

 -- 関数: read (<expr_1>, ..., <expr_n>)

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

     ‘*note 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)

 -- 関数: readonly (<expr_1>, ..., <expr_n>)

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

     ‘*note 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

 -- 関数: reset ()

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

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

 -- オプション変数: showtime
     デフォルト値: ‘false’

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

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

     ‘*note timer::’も参照してください。

 -- 関数: 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)

 -- システム変数: values
     初期値: ‘[]’

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

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

     ユーザー定義関数のリストに関しては ‘*note 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)                          []


File: maxima.info,  Node: Functions and Variables for Display,  Prev: Functions and Variables for Command Line,  Up: Command Line

4.3 Functions and Variables for Display
=======================================

 -- オプション変数: %edispflag
     デフォルト値: ‘false’

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

     例:

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

 -- オプション変数: absboxchar
     デフォルト値: ‘!’

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

     例:

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

 -- 関数: disp (<expr_1>, <expr_2>, ...)

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

     ‘*note ldisp::’と‘*note 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 (<expr_1>, <expr_2>, ...)

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

     ‘*note ldisplay::’, ‘*note disp::’, ‘*note 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

 -- オプション変数: 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_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

 -- 関数: 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)’）のように
     現れます。

 -- 関数: 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

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

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

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

     ‘*note 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)

 -- オプション変数: ibase
     デフォルト値: ‘10’

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

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

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

     ‘*note 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

 -- 関数: ldisp (<expr_1>, ..., <expr_n>)

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

     ‘*note disp::’, ‘*note display::’, ‘*note 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

 -- 関数: ldisplay (<expr_1>, ..., <expr_n>)

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

     ‘*note display::’, ‘*note 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

 -- オプション変数: linel
     デフォルト値: ‘79’

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

 -- オプション変数: lispdisp
     デフォルト値: ‘false’

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

     例:

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

 -- オプション変数: negsumdispflag
     デフォルト値: ‘true’

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

 -- オプション変数: obase
     デフォルト値: ‘10’

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

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

     ‘*note 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

 -- オプション変数: 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)

 -- オプション変数: powerdisp
     デフォルト値: ‘false’

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

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

 -- 関数: print (<expr_1>, ..., <expr_n>)

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

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

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

     ファイルの中身を表示するには ‘*note 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)

 -- オプション変数: sqrtdispflag
     デフォルト値: ‘true’

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

 -- オプション変数: stardisp
     デフォルト値: ‘false’

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

 -- オプション変数: ttyoff
     デフォルト値: ‘false’

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

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


File: maxima.info,  Node: Data Types and Structures,  Next: Expressions,  Prev: Command Line,  Up: Top

5 Data Types and Structures
***************************

* Menu:

* Numbers::
* Strings::
* Constants::
* Lists::
* Arrays::
* Structures::


File: maxima.info,  Node: Numbers,  Next: Strings,  Prev: Data Types and Structures,  Up: Data Types and Structures

5.1 Numbers
===========

* Menu:

* Introduction to Numbers::
* Functions and Variables for Numbers::


File: maxima.info,  Node: Introduction to Numbers,  Next: Functions and Variables for Numbers,  Prev: Numbers,  Up: Numbers

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’関数を使って達成するこ
とができます。


File: maxima.info,  Node: Functions and Variables for Numbers,  Prev: Introduction to Numbers,  Up: Numbers

5.1.2 Functions and Variables for Numbers
-----------------------------------------

 -- 関数: bfloat (<expr>)
     <expr>の中のすべての数や数の関数を多倍長浮動小数点に変換します。 戻
     り値の多倍長浮動小数点の有効桁数は、 グローバル変数‘*note
     fpprec::’によって規定されます。

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

 -- 関数: bfloatp (<expr>)

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

 -- オプション変数: bftorat
     デフォルト値: ‘false’

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

 -- オプション変数: bftrunc
     デフォルト値: ‘true’

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

 -- 関数: evenp (<expr>)

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

 -- 関数: float (<expr>)

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

 -- オプション変数: float2bf
     デフォルト値: ‘true’

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

 -- 関数: floatnump (<expr>)
     もし<expr>が浮動小数点なら ‘true’を返し、そうでないなら ‘false’を返
     します。

 -- オプション変数: fpprec
     デフォルト値: 16

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

     ‘*note bfloat::’と‘*note fpprintprec::’も参照してください。

 -- オプション変数: fpprintprec
     デフォルト値: 0

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

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

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

     ‘fpprintprec’は1にはできません。

 -- 関数: 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

 -- オプション変数: 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

 -- 関数: nonnegintegerp (<n>)

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

 -- 関数: 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]

 -- 特殊シンボル: numer

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

     ‘*note %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]

 -- オプション変数: numer_pbranch
     デフォルト値: ‘false’

     オプション変数‘numer_pbranch’は 負の整数、有理数、または浮動小数点
     数のべきの数値評価を制御します。 ‘numer_pbranch’が‘true’でかつ、指
     数が浮動小数点数であるか オプション変数‘*note 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

 -- 関数: numerval (<x_1>, <expr_1>, ..., <x_n>, <expr_n>)
     変数‘x_1’, ..., ‘x_n’を ‘expr_1’, ..., ‘expr_n’に等しい数値を持つ変
     数だと宣言します。 もし ‘numer’フラグが ‘true’なら、 変数が現れる任
     意の式にて、数値は評価され、変数に代入されます。 ‘*note ev::’も参照
     してください。

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

 -- 関数: oddp (<expr>)
     もしも<exp>が奇数であれば‘true’を返し、 それ以外では‘false’を返しま
     す。

 -- オプション変数: ratepsilon
     デフォルト値: 2.0e-8

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

 -- 関数: 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

 -- 関数: ratnump (<expr>)
     もし<expr>が整数リテラルもしくは整数リテラルの比なら ‘true’を返し、
     そうでなければ ‘false’を返します。


File: maxima.info,  Node: Strings,  Next: Constants,  Prev: Numbers,  Up: Data Types and Structures

5.2 Strings
===========

* Menu:

* Introduction to Strings::
* Functions and Variables for Strings::


File: maxima.info,  Node: Introduction to Strings,  Next: Functions and Variables for Strings,  Prev: Strings,  Up: Strings

5.2.1 Introduction to Strings
-----------------------------

文字列(クォートされた文字の列)は入力の際にはダブルクォートマーク ‘"’で括
り、 グローバル変数 ‘*note 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."


File: maxima.info,  Node: Functions and Variables for Strings,  Prev: Introduction to Strings,  Up: Strings

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’によって組み立てられたシンボルは値に割り当てられたり、式の
     中に現れたりします。 ‘*note ::::’ (ダブルコロン)割り当て演算子は左
     辺を評価します。

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

 -- 関数: sconcat (<arg_1>, <arg_2>, ...)

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

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

 -- 関数: string (<expr>)

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

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

 -- オプション変数: 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."


File: maxima.info,  Node: Constants,  Next: Lists,  Prev: Strings,  Up: Data Types and Structures

5.3 Constants
=============

* Menu:

* Functions and Variables for Constants::


File: maxima.info,  Node: Functions and Variables for Constants,  Prev: Constants,  Up: Constants

5.4 Functions and Variables for Constants
=========================================

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

 -- 定数: %i

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

 -- 定数: false

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

 -- 定数: %gamma

     Euler-Macheroni定数0.5772156649015329 ....

 -- 定数: ind

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

     ‘*note limit::’も参照してください。

     例:

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

 -- 定数: inf

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

 -- 定数: infinity

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

 -- 定数: minf

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

 -- 定数: %phi

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

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

     デフォルトでは、Maximaは ‘%phi’の代数的プロパティを知りません。
     ‘tellrat(%phi^2 - %phi - 1)’と‘algebraic: true’を評価した後、
     ‘*note 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

 -- 定数: %pi

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

 -- 定数: true

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

 -- 定数: und

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

     ‘*note limit::’も参照してください。

     例:

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

 -- 定数: zeroa

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

     ‘*note zerob::’と‘*note limit::’も参照してください。

     例:

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

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

 -- 定数: zerob

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

     ‘*note zeroa::’と‘*note limit::’も参照してください。


File: maxima.info,  Node: Lists,  Next: Arrays,  Prev: Constants,  Up: Data Types and Structures

5.5 Lists
=========

* Menu:

* Introduction to Lists::
* Functions and Variables for Lists::


File: maxima.info,  Node: Introduction to Lists,  Next: Functions and Variables for Lists,  Prev: Lists,  Up: Lists

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


File: maxima.info,  Node: Functions and Variables for Lists,  Prev: Introduction to Lists,  Up: Lists

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

 -- 関数: 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);’を実行してください。

 -- 関数: 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’に設定されます。

 -- 関数: cons (<expr>, <list>)

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

 -- 関数: copylist (<list>)

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

 -- 関数: 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’の現在値に依存することができることに注意
     してください。

 -- 関数: 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 ]

 -- 関数: eighth (<expr>)

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

 -- 関数: endcons (<expr>, <list>)

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

 -- 関数: fifth (<expr>)

     式またはリスト <expr>の5番目の項を返します。 詳細は ‘*note
     first::’を参照してください。

 -- 関数: first (<expr>)

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

 -- 関数: fourth (<expr>)

     式またはリスト <expr>の4番目の項を返します。 詳細は ‘*note
     first::’を参照してください。

 -- 関数: 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]

 -- 関数: last (<expr>)
     <expr>最後の(項、行、要素など）部分を返します。

 -- 関数: length (<expr>)

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

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

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

 -- 関数: listp (<expr>)

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

 -- 関数: 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]

 -- 関数: 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’を返すかもしれ
     ません。

     ‘*note 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

 -- 関数: ninth (<expr>)

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

 -- 関数: pop (<list>)

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

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

     例には ‘*note push::’も参照してください。

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

 -- 関数: push (<item>, <list>)

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

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

     リストから最初の項目を取り除くには ‘*note 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]

 -- 関数: rest (<expr>, <n>)
 -- 関数: rest (<expr>)

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

 -- 関数: reverse (<list>)

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

 -- 関数: second (<expr>)

     式またはリスト <expr>の二番目の項を返します。 詳細は ‘*note
     first::’を参照してください。

 -- 関数: seventh (<expr>)

     式またはリスト <expr>の7番目の項を返します。 詳細は ‘*note
     first::’を参照してください。

 -- 関数: sixth (<expr>)

     式またはリスト <expr>の6番目の項を返します。 詳細は ‘*note
     first::’を参照してください。

 -- 関数: 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)’と同値です。 すなわち、デフ
     ォルトソート順序は昇順です。‘*note 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]

 -- 関数: 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]

 -- 関数: 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]

 -- 関数: 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’を参照
     してください。

 -- 関数: third (<expr>)

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


File: maxima.info,  Node: Arrays,  Next: Structures,  Prev: Lists,  Up: Data Types and Structures

5.6 Arrays
==========

* Menu:

* Functions and Variables for Arrays::


File: maxima.info,  Node: Functions and Variables for Arrays,  Prev: Arrays,  Up: Arrays

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’関数は未宣言配列を宣言配列に変換するの
     に使うことができます。

 -- 関数: arrayapply (<A>, [<i_1>, ... <i_n>])
     ‘<A> [<i_1>, ..., <i_n>]’を評価します。 ここで、<A>は配列、<i_1>,
     ..., <i_n>は整数です。

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

 -- 関数: arrayinfo (<A>)

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

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

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

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

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

     ‘*note 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     )]

 -- 関数: arraymake (<A>, [<i_1>, ..., <i_n>])
     式‘<A>[<i_1>, ..., <i_n>]’を返します。 結果は未評価の配列参照です。

     ‘arraymake’は、 戻り値は、未評価関数コールの代わりに未評価の配列参
     照だということを除いて、 ‘*note 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

 -- システム変数: arrays
     デフォルト値: ‘[]’

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

     ‘*note array::’, ‘*note arrayapply::’, ‘*note arrayinfo::’, ‘*note
     arraymake::’, ‘*note fillarray::’, ‘*note listarray::’, ‘*note
     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]

 -- 関数: 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))}

 -- 関数: listarray (<A>)

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

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

     未宣言配列や、配列関数、添字付き関数では、 要素は‘*note
     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]]

 -- 関数: make_array (<type>, <dim_1>, ..., <dim_n>)

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

     ‘make_array’の‘*note 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

 -- 関数: rearray (<A>, <dim_1>, ..., <dim_n>)

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

 -- 関数: remarray (<A_1>, ..., <A_n>)
 -- 関数: remarray (all)

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

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

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

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

     ‘remarray’はクォートします。

 -- 関数: 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

 -- 関数: subvarp (<expr>)

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

 -- オプション変数: 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’に設定してく
     ださい。


File: maxima.info,  Node: Structures,  Prev: Arrays,  Up: Data Types and Structures

5.8 Structures
==============

* Menu:

* Introduction to Structures::
* Functions and Variables for Structures::


File: maxima.info,  Node: Introduction to Structures,  Next: Functions and Variables for Structures,  Prev: Structures,  Up: Structures

5.8.1 Introduction to Structures
--------------------------------

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

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

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

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


File: maxima.info,  Node: Functions and Variables for Structures,  Prev: Introduction to Structures,  Up: Structures

5.8.2 Functions and Variables for Structures
--------------------------------------------

 -- グローバル変数: structures

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

 -- 関数: 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)]

 -- 関数: 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)

 -- 演算子: @

     ‘@’構造体フィールドアクセス演算子です。 式‘<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


File: maxima.info,  Node: Expressions,  Next: Operators,  Prev: Data Types and Structures,  Up: Top

6 Expressions
*************

* Menu:

* Introduction to Expressions::
* Nouns and Verbs::
* Identifiers::
* Inequality::
* Functions and Variables for Expressions::


File: maxima.info,  Node: Introduction to Expressions,  Next: Nouns and Verbs,  Prev: Expressions,  Up: Expressions

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


File: maxima.info,  Node: Nouns and Verbs,  Next: Identifiers,  Prev: Introduction to Expressions,  Up: Expressions

6.2 Nouns and Verbs
===================

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

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

   ‘*note noun::’, ‘*note nouns::’, ‘*note nounify::’, や‘*note
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)


File: maxima.info,  Node: Identifiers,  Next: Inequality,  Prev: Nouns and Verbs,  Up: Expressions

6.3 Identifiers
===============

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

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

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

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

   Maximaの識別子は、ドル記号‘$’で始まるLispのシンボルです。 Maximaの中
で現れる時、他の任意のLispシンボルは、クエスチョンマーク‘?’で始まります
。 この点に関して*note 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


File: maxima.info,  Node: Inequality,  Next: Functions and Variables for Expressions,  Prev: Identifiers,  Up: Expressions

6.4 Inequality
==============

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


File: maxima.info,  Node: Functions and Variables for Expressions,  Prev: Inequality,  Up: Expressions

6.5 Functions and Variables for Expressions
===========================================

 -- 関数: alias (<new_name_1>, <old_name_1>, ..., <new_name_n>,
          <old_name_n>)

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

 -- システム変数: aliases
     デフォルト値: ‘[]’

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

 -- キーワード: allbut

     ‘part’コマンド(すなわち、‘*note part::’,‘*note inpart::’,‘*note
     substpart::’, ‘*note substinpart::’,‘*note dpart::’, ‘*note
     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

     ‘*note 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’の部分式は、要素として、または、引数のリストの要素の部分式と
     して現れます。

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

     ‘args (<expr>)’は、‘substpart ("[", <expr>, 0)’と同値です。 ‘*note
     substpart::’と‘*note op::’も参照してください。

 -- 関数: atom (<expr>)

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

 -- 関数: box (<expr>)
 -- 関数: box (<expr>, <a>)

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

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

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

     ‘*note boxchar::’は、‘box’, ‘*note dpart::’, ‘*note 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)-
                                  -----------------

 -- オプション変数: boxchar
     デフォルト値: ‘"’

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

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

 -- 関数: collapse (<expr>)

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

 -- 関数: disolate (<expr>, <x_1>, ..., <x_n>)

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

 -- 関数: dispform (<expr>)
 -- 関数: dispform (<expr>, all)

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

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

     ‘*note part::’, ‘*note inpart::’, ‘*note 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

 -- 関数: dpart (<expr>, <n_1>, ..., <n_k>)

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

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

 -- オプション変数: exptisolate
     デフォルト値: ‘false’

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

 -- オプション変数: exptsubst
     デフォルト値: ‘false’

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

 -- 関数: 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’によって認識されたダミー変数は、 和や積のインデックス
     、‘*note limit::’の中の極限変数、 ‘*note integrate::’の定積分形の中
     の積分変数、 ‘*note laplace::’の中のオリジナル変数、 ‘*note at::’式
     の中の形式変数、 ‘*note 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

 -- オプション変数: inflag
     デフォルト値: ‘false’

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

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

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

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

 -- 関数: 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)

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

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

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

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

 -- オプション変数: 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

 -- オプション変数: listconstvars
     デフォルト値: ‘false’

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

 -- オプション変数: listdummyvars
     デフォルト値: ‘true’

     ‘listdummyvars’が‘false’の時、 式の中の「ダミー変数」は、‘*note
     listofvars::’が返すリストの中に含まれません。 （「ダミー変数」の意
     味は‘*note 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]

 -- 関数: listofvars (<expr>)

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

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

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

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

 -- 関数: lfreeof (<list>, <expr>)

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

 -- 関数: lpart (<label>, <expr>, <n_1>, ..., <n_k>)

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

 -- 宣言: 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’もまた保存すべきです。）

 -- 宣言: noun

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

 -- オプション変数: noundisp
     デフォルト値: ‘false’

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

 -- 関数: nounify (<f>)

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

     ‘*note verbify::’も参照してください。

 -- 関数: nterms (<expr>)

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

 -- 関数: op (<expr>)

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

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

     ‘op’はグローバルフラグ‘*note inflag::’の値を見ています。

     ‘op’は引数を評価します。

     ‘*note 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

 -- 関数: 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’を返します。

 -- オプション変数: opsubst
     デフォルト値: ‘true’

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

 -- 関数: optimize (<expr>)

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

 -- オプション変数: optimprefix
     デフォルト値: ‘%’

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

 -- 関数: 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’によって確立される順序は、 ‘*note
     unorder::’によって解消されます。 ‘ordergreat’や‘orderless’は、
     ‘unorder’がコールされるまで、 それぞれ一度だけコールすることができ
     ます; ‘ordergreat’の‘orderless’の最後のコールだけが効果を持ちます。

     ‘*note ordergreatp::’も参照してください。

 -- 関数: 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’の下で比較
     可能です。これらの述語論理が推移的でないような式の孤立した例はある
     けれども; それはバグです。

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

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

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

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

     ‘*note 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

 -- 関数: 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’です。

     ‘*note piece::’は、‘part’関数を使ったとき、選択された最後の式を保持
     します。 それは関数の実行中にセットされ、以下で示すように、関数自身
     の中で参照されることもあります。

     もし‘*note partswitch::’が‘true’に設定されているなら、 式の選択され
     たパーツが存在しないとき、‘end’が返されます。 そうでなければ、エラ
     ーメッセージが出力されます。

     ‘*note inpart::’, ‘*note substpart::’, ‘*note substinpart::’,
     ‘*note dpart::’, ‘*note 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)’でさらに例を見ることができます。

 -- 関数: 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)]]

 -- オプション変数: partswitch
     デフォルト値: ‘false’

     ‘partswitch’が‘true’の時、 式の選択された部分が存在しない時、
     ‘end’が返されます。 そうでない時は、エラーメッセージが出力されます
     。

 -- 関数: pickapart (<expr>, <n>)

     中間式ラベルを、深さが整数<n>での<expr>の部分式に割り当てます。 よ
     り大きなもしくは小さな深さでの部分式はラベルに割り当てられません。
     ‘pickapart’は、元の式<expr>と同値の中間式の項による式を返します。

     ‘*note part::’, ‘*note dpart::’, ‘*note lpart::’, ‘*note inpart::’,
     ‘*note 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

 -- システム変数: piece

     ‘part’関数を使った時選択された最後の式を返します。 関数の実行中に設
     定され、関数そのものの中で参照されることもあります。

 -- 関数: psubst (<list>, <expr>)
 -- 関数: psubst (<a>, <b>, <expr>)

     ‘psubst(<a>, <b>, <expr>)’は‘subst’に似ています。 ‘subst’を参照して
     ください。

     ‘subst’とは違って、 もし最初の引数<list>が等式のリストなら、 関数
     ‘psubst’は平行代入します。

     並列代入するには、‘*note 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)

 -- 関数: rembox (<expr>, unlabelled)
 -- 関数: rembox (<expr>, <label>)
 -- 関数: rembox (<expr>)
     <expr>から枠を取り除きます。

     ‘rembox (<expr>, unlabelled)’は、 <expr>からラベルされていない枠す
     べてを取り除きます。

     ‘rembox (<expr>, <label>)’は、 <label>を負う枠のみを取り除きます。

     ‘rembox (<expr>)’は、ラベルされているか否か問わず、 枠すべてを取り
     除きます。

     枠は、‘*note box::’, ‘*note dpart::’, ‘*note 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

 -- 関数: 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

 -- 関数: sublis (<list>, <expr>)

     式に対して多重平行代入を行います。 <list>は等式のリストです。 等式
     の左辺はアトムでなければいけません。

     変数‘sublis_apply_lambda’は‘sublis’の後の式整理を制御します。

     平行代入を行うには、‘psubst’も参照してください。

     例:

          (%i1) sublis ([a=b, b=a], sin(a) + cos(b));
          (%o1)                    sin(b) + cos(a)

 -- オプション変数: sublis_apply_lambda
     デフォルト値: ‘true’

     ‘lambda’の代入が‘sublis’が使われた後の式整理の中で適用されるか 、も
     しくは、ユーザーが、ものに適用されるように‘*note ev::’を実行しなけ
     ればいけないかを決めます。 ‘true’は適用を意味します。

 -- オプション変数: 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

 -- 関数: subst (<a>, <b>, <c>)

     <c>の中の<b>に<a>を代入します。 <b>はアトムもしくは<c>の完全な部分
     式でなければなりません。 例えば、‘x+y+z’は‘2*(x+y+z)’の完全な部分式
     である一方、‘x+y’は完全な部分式ではありません。 <b>がこれらの性質を
     持たない時は、‘*note substpart::’もしくは‘*note 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’を参照してください。

     ‘*note 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)’を実行してください。

 -- 関数: substinpart (<x>, <expr>, <n_1>, ..., <n_k>)

     ‘*note 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’関数を使った時、‘*note piece::’は、最後の式の値を保持します。
     関数の実行の間に設定され、以下で示すように関数自身の中で参照される
     こともあります。 もし‘*note 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

     また、 オプション ‘*note inflag::’を ‘true’に設定し ‘*note part::’か
     ‘*note substpart::’をコールすることは ‘inpart’か ‘substinpart’をコ
     ールすることと同じです。

 -- 関数: 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

     また、オプション‘*note inflag::’を‘true’に設定し、 ‘*note part::’や
     ‘substpart’をコールすることは、 ‘inpart’や‘*note substinpart::’をコ
     ールすることと同じになります。

 -- 関数: symbolp (<expr>)

     もし<expr>がシンボルなら‘true’、そうでないなら‘false’を返します。 事
     実上、‘symbolp(x)’は、述語論理‘atom(x) and not numberp(x)’と同値で
     す。

     *note Identifiers::も参照してください。

 -- 関数: 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

 -- 関数: verbify (<f>)

     関数名<f>の動詞形を返します。 ‘verb’, ‘noun’, ‘nounify’も参照してく
     ださい。

     例:

          (%i1) verbify ('foo);
          (%o1)                          foo
          (%i2) :lisp $%
          $FOO
          (%i2) nounify (foo);
          (%o2)                          foo
          (%i3) :lisp $%
          %FOO


File: maxima.info,  Node: Operators,  Next: Evaluation,  Prev: Expressions,  Up: Top

7 Operators
***********

* Menu:

* Introduction to operators::
* Arithmetic operators::
* Relational operators::
* Logical operators::
* Operators for Equations::
* Assignment operators::
* User defined operators::


File: maxima.info,  Node: Introduction to operators,  Next: Arithmetic operators,  Prev: Operators,  Up: Operators

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

   ‘*note remove::’と ‘*note 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)


File: maxima.info,  Node: Arithmetic operators,  Next: Relational operators,  Prev: Introduction to operators,  Up: Operators

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 ]

 -- 演算子: **

     べき乗演算子。 Maximaは入力の中で ‘**’を ‘^’と同じ演算子と認識し、
     1次元出力の中では ‘^’として表示し、 また、2次元出力の中では指数を上
     付き添字として配置します。

     ‘*note 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

 -- 演算子: ^^

     非可換べき乗演算子。 ちょうど可換なかけ算 ‘*’に通常のべき乗演算子
     ‘^’が対応するように、 ‘^^’は非可換かけ算 ‘.’に対応するべき乗演算子
     です。

     非可換べき乗演算子は、１次元出力では ‘^^’で表示され、 ２次元出力で
     は、指数をかっこ ‘< >’で囲まれた上付き添字として置きます。

     例:

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

 -- 演算子: .

     行列（非可換）かけ算のためのドット演算子。 ‘"."’をこの意味で用いる
     時、 例えば ‘A . B’のように両側にスペースを置かなければいけません。
     これで浮動小数点の小数点と区別します。

     ‘dot’や ‘dot0nscsimp’, ‘dot0simp’, ‘dot1simp’, ‘dotassoc’,
     ‘dotconstrules’, ‘dotdistrib’, ‘dotexptsimp’, ‘dotident’,
     ‘dotscrules’.  も参照してください。


File: maxima.info,  Node: Relational operators,  Next: Logical operators,  Prev: Arithmetic operators,  Up: Operators

7.3 Relational operators
========================

 -- 演算子: <
 -- 演算子: <=
 -- 演算子: >=
 -- 演算子: >

     シンボル ‘<’ ‘<=’ ‘>=’ ‘>’はそれぞれ、小なり、以下、以上、大なり、
     を表します。 これらの演算子の名前は、 ‘"<"’、 ‘"<="’、 ‘">="’、
     ‘">"’です。 それらは関数や演算子の名前が求められるところで使われま
     す。

     これらの関係演算子はすべて二項演算子です; ‘a < b < c’のような構成を
     Maximaは認識しません。

     関数 ‘*note is::’や ‘*note maybe::’、 プログラミング構成子 ‘*note
     if::’, ‘*note while::’, ‘*note unless::’が 関係式をブーリアン値に評
     価します。 そうでなければ、関係式はブーリアン値に評価されたり整理さ
     れたりしませんが、 関係式の引数は（評価がクォーテーションによって妨
     げられないかぎり）評価されます。

     関係式が ‘true’もしくは ‘false’に評価できない時、 ‘is’や ‘if’の振る
     舞いは、グローバルフラグ ‘*note prederror::’が決定します。
     ‘prederror’が ‘true’の時、 ‘is’や ‘if’はエラーをトリガーします。
     ‘prederror’が ‘false’の時、 ‘is’は ‘unknown’を返し、 ‘if’は部分的に
     評価された条件式を返します。

     ‘maybe’はいつも、 ‘prederror’が ‘false’であるかのように振る舞い、
     ‘while’や ‘unless’はいつも、 ‘prederror’が ‘true’であるかのように振
     る舞います。

     関係演算子はリストやほかの集合上で展開されることはありません。

     ‘*note =::’や ‘*note #::’、 ‘*note equal::’、 ‘*note 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]


File: maxima.info,  Node: Logical operators,  Next: Operators for Equations,  Prev: Relational operators,  Up: Operators

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’と同値ではないかもしれません。

 -- 演算子: not

     論理否定演算子。 ‘not’は、接頭演算子です; オペランドはブーリアン値
     で、結果もブーリアン値です。

     ‘or’は、（‘is’のように）オペランドの評価を強制します。

     グローバルフラグ‘prederror’は、 評価されたオペランドが‘true’か
     ‘false’に決定できない時の‘not’の振る舞いを決定します。 ‘prederror’が
     ‘true’の時、‘not’は、エラーメッセージを出力します。 そうでなければ
     、‘true’か‘false’に評価されないオペランドを受け付け、 結果はブーリ
     アン式になります。

 -- 演算子: or

     論理和演算子。 ‘or’は、n項中置演算子です; オペランドはブーリアン値
     で、結果もブーリアン値です。

     ‘or’は、（‘is’のように）１以上のオペランドの評価を強制し、 すべての
     オペランドの評価を強制するかもしれません。

     オペランドは、出現順に評価されます。 ‘and’は、結果を決定するのに必
     要なだけオペランドを評価します。 もし任意のオペランドが‘true’なら、
     結果は‘true’であり、 ほかのオペランドは評価されません。

     グローバルフラグ‘prederror’は、 評価されたオペランドが‘true’か
     ‘false’に決定できない時の‘or’の振る舞いを決定します。 ‘prederror’が
     ‘true’の時、‘or’は、エラーメッセージを出力します。 そうでなければ、
     ‘true’か‘false’に評価されないオペランドを受け付け、 結果はブーリア
     ン式になります。

     ‘or’は可換ではありません: ‘a or b’は、不定のオペランドの扱いのため
     、‘b or a’と同値ではないかもしれません。


File: maxima.info,  Node: Operators for Equations,  Next: Assignment operators,  Prev: Logical operators,  Up: Operators

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

 -- 演算子: =

     等式演算子。

     式‘<a> = <b>’は、それ自身、未評価の等式を表します。 等式は成り立つ
     かもしれませんし、成り立たないかもしれません。 未評価の等式は、
     ‘*note solve::’や‘*note algsys::’や他の関数の引数として用いられます
     。

     関数‘*note 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’の式です。 式は、同値だが構文法的に等
     しくないことが起こりえます。

     ‘=’の否定は、‘*note #::’で表されます。 ‘=’と同様、式‘<a> # <b>’は、
     それ自身、評価されません。 ‘is(<a> # <b>)’は、‘<a> # <b>’を‘true’も
     しくは‘false’に評価します。

     ‘is’に加えて、他のいくつかの演算子が‘=’と‘#’を‘true’もしくは
     ‘false’に評価します。‘*note if::’, ‘*note and::’, ‘*note or::’,
     ‘*note not::’という演算子です。

     述語論理式の評価規則のため （特に、‘not <expr>’は<expr>の評価を起こ
     すため）、 ‘not <a> = <b>’は、‘<a> # <b>’ではなく、 ‘is(<a> #
     <b>)’と同値になります。

     ‘*note rhs::’と‘*note lhs::’は、それぞれ、等式、不等式の右辺と左辺
     を返します。

     ‘*note equal::’や‘*note 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


File: maxima.info,  Node: Assignment operators,  Next: User defined operators,  Prev: Operators for Equations,  Up: Operators

7.6 Assignment operators
========================

 -- 演算子: :

     割り当て演算子。

     左辺が（添字のない）単純変数の時、 ‘:’は右辺を評価し、その値を左辺
     に関連づけます。

     左辺がリストや行列、宣言されたMaxima配列、Lisp配列の添字指定された
     要素の時、 右辺がその要素に割り当てられます。 添字は存在している要
     素を示していなければなりません; 先に列挙した対象は、存在していない
     要素を名付けることで拡張することはできません。

     左辺が未宣言のMaxima配列の添字指定された要素の時、 もし既に存在して
     いるなら、右辺はその要素に割り当てられ、 もしまだ存在していなければ
     新しい要素が確保されます。

     左辺が単純変数や添字あり変数のリストの時、 右辺はリストに評価されな
     ければなりません。 そして、右辺の要素が左辺の要素に平行に割り当てら
     れます。

     ‘*note kill::’や‘*note 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

 -- 演算子: ::

     割り当て演算子。

     ‘::’は、‘::’は右辺はもちろん左辺も評価することを除いて、‘*note
     :::’と同じです。

     例:

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

 -- 演算子: ::=

     マクロ関数定義の演算子。 ‘::=’は、引数をクォートする関数（歴史的理
     由によりマクロと呼ばれる）を定義します。 そして、それが返す式（マク
     ロ展開と呼ばれる）はマクロが呼ばれた文脈の中で評価されます。 それ以
     外はマクロ関数は通常の関数と同じです。

     ‘*note macroexpand::’は（評価せずに）マクロ展開を返します。 ‘foo’が
     マクロ関数の時、 ‘macroexpand (foo (x))’に続けて ‘``%’を実行すると
     、 それは ‘foo (x)’と同値です。

     ‘::=’は、新しいマクロ関数の名前をグローバルリスト ‘*note macros::’に
     追加します。 ‘*note kill::’や ‘*note remove::’, ‘*note
     remfunction::’は、マクロ関数定義をアンバインドし、 ‘macros’から名前
     を削除します。

     ‘*note fundef::’や ‘*note dispfun::’はそれぞれマクロ関数定義を返し
     、 それをラベルに割り当てます。

     評価対象となる式を構成するために、 マクロ関数は一般的に‘*note
     buildq::’, ‘*note 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

 -- 演算子: :=

     関数定義の演算子。 ‘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’の定義を‘*note local::’が現れたブロックや他の
     合成式内に限定します。

     もしある形式引数<x_k>がクォートされたシンボルなら、‘:=’で定義された
     関数は対応する実際の引数を評価しません。 それ以外の場合、実際の引数
     はすべて評価されます。

     ‘*note define::’や‘*note ::=::’も参照してください。

     例:

     ‘:=’は（クォートクォートで陽に評価されない限り）関数本体を評価しま
     せん。

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


File: maxima.info,  Node: User defined operators,  Prev: Assignment operators,  Up: Operators

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

 -- 関数: 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

 -- 関数: 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)’に整理するよう指示します。

     *note Introduction to operators::も参照してください。

 -- 関数: nofix (<op>)
 -- 関数: nofix (<op>, <pos>)

     ‘nofix’演算子は引数のない関数を示すのに使われます。 コマンドにそん
     な演算子が存在すると、 対応する関数が評価されるだけです。 例えば、
     Maximaブレイクから抜けるために"exit;"とタイプする時、 "exit"は
     ‘nofix’演算子と似たように振る舞います。 関数 ‘nofix("x")’は ‘x’を
     ‘nofix’演算子に宣言する構文拡張関数です。

     *note Introduction to operators::も参照してください。

 -- 関数: postfix (<op>)
 -- 関数: postfix (<op>, <lbp>, <lpos>, <pos>)

     ‘prefix’変種のような‘postfix’演算子は引数一つの関数を示しますが、 こ
     の場合、例えば3!のように、入力文字列の中で引数が演算子に先行します
     。 ‘postfix("x")’関数は ‘x’を‘postfix’演算子に宣言する構文拡張関数
     です。

     *note Introduction to operators::も参照してください。

 -- 関数: prefix (<op>)
 -- 関数: prefix (<op>, <rbp>, <rpos>, <pos>)

     ‘prefix’演算子は引数一つの関数であり、 その引数は演算子のすぐ後ろに
     置かれます。 ‘prefix("x")’は ‘x’を‘prefix’演算子に宣言する構文拡張
     関数です。

     *note Introduction to operators::も参照してください。


File: maxima.info,  Node: Evaluation,  Next: Simplification,  Prev: Operators,  Up: Top

8 Evaluation
************

* Menu:

* Functions and Variables for Evaluation::


File: maxima.info,  Node: Functions and Variables for Evaluation,  Prev: Evaluation,  Up: Evaluation

8.1 Functions and Variables for Evaluation
==========================================

 -- 演算子: '

     シングルクォート演算子‘'’は評価を抑制します。

     シンボルにシングルクォートを用いると、シンボルが評価されません。

     関数コールにシングルクォートを用いると、 関数の引数は（抑制されない
     限り）評価されますが、関数コールは評価されません。結果は、関数コー
     ルの名詞形です。

     括弧でくくられた式にシングルクォートを用いると、 式の中のすべてのシ
     ンボルと関数コールは評価されません。 例えば、‘'(f(x))’は、式
     ‘f(x)’を評価しないことを意味します。 ‘'f(x)’（‘f(x)’ではなく‘f’へ適
     用されたシングルクォート）は‘[x]’に適用された‘f’の名詞形を返します
     。

     シングルクォートは式整理を抑制しません。

     グローバルフラグ ‘*note noundisp::’が ‘true’の時、名詞はシングルク
     ォート付きで表示されます。 このスイッチは関数定義を表示するときには
     、常に‘true’です。

     クォートクォート演算子 *note ‘''’: quote-quote.と ‘*note 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

 -- 演算子: ''
     クォートクォート演算子‘''’(シングルクォートマーク２つ）は、入力式の
     中の評価を部分修正します。

     一般式<expr>にクォートクォートを用いると、入力式の中の<expr>に
     <expr>の値を代入します。

     式の演算子にクォートクォートを用いると、（もし動詞でないなら）演算
     子は名詞から動詞に変わります。

     クォートクォート演算子は入力パーサが適用します; クォートクォート演
     算子はパースされた入力式の一部としては格納されません。 クォートクォ
     ート演算子は、パースされるといつもすぐに適用され、クォートできませ
     ん。 このように、関数定義やラムダ式、シングルクォート‘'’でクォート
     された式の中のように通常評価が抑制される時も、 クォートクォートがあ
     ると評価を実行します。

     ‘*note batch::’や‘*note load::’はクォートクォートを認識します。

     シングルクォート演算子 *note ‘'’: quote.と ‘*note 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

 -- 関数: alias (<new_name_1>, <old_name_1>, ..., <new_name_n>,
          <old_name_n>)
     (利用者もしくはシステム)関数や変数、配列等に対して別名を与えます。
     任意の偶数個の引数を取ります。

 -- 関数: ev (<expr>, <arg_1>, ..., <arg_n>)

     引数<arg_1>, ..., <arg_n>で指定された環境下で 式<expr>を評価します
     。 引数は、スイッチ（ブーリアンフラグ）だったり、割り当てだったり、
     等式だったり、関数だったりします。 <ev>は評価の結果（別の式）を返し
     ます。

     評価は以下のようにステップを追って実行されます。

       1. 最初に、以下の任意のもしくはすべての引数をスキャンして環境を準
          備します。

             • ‘*note simp::’を引数に指定すると<expr>を整理します。
               ‘false’なら整理を抑制するスイッチ‘simp’の設定に関わらずで
               す。
             • ‘*note noeval::’を引数に指定すると‘ev’の評価フェイズを抑
               制します。 （以下のステップ(4)を参照してください。） これ
               は、他のスイッチとの連携時や、<expr>を再評価せずに再整理
               をさせる時に役に立ちます。
             • ‘*note nouns::’を引数に指定すると<expr>の中の名詞形式 （
               典型的には、‘'integrate’や‘'diff’のような未評価関数）を評
               価します。
             • ‘*note expand::’を引数に指定すると展開します。
             • ‘expand (<m>, <n>)’を引数に指定すると、 ‘*note
               maxposex::’と‘*note maxnegex::’の値をそれぞれ<m>と<n>に設
               定して、展開します。
             • ‘*note detout::’を引数に指定すると、<expr>の中で計算され
               るどんな逆行列も、逆行列の外側に行列式を保つようにします
               。
             • ‘*note diff::’を引数に指定すると<expr>の中のすべての微分
               を実行します。
             • ‘derivlist (<x>, <y>, <z>, ...)’を引数に指定すると指定さ
               れた変数に関する微分のみを実行します。
             • ‘risch’を引数に指定すると <expr>の中の積分をRischアルゴリ
               ズムを使って評価します。 ‘*note risch::’を参照してくださ
               い。 特殊なシンボル‘*note nouns::’を使った時には標準の積
               分ルーチンが呼び出されます。
             • ‘*note float::’を引数に指定すると非整数有理数を浮動小数点
               に変換します。
             • ‘*note numer::’を引数に指定すると数値引数が指定された（指
               数関数を含む）いくつかの数学関数を浮動小数点に評価します
               。 また、<expr>の中の numerval宣言された変数は、宣言され
               た値に置き換えられます。 また、‘*note float::’スイッチを
               オンにします。
             • ‘*note pred::’を引数に指定すると述語（‘true’もしくは
               ‘false’に評価される式）を評価します。
             • ‘*note eval::’を引数に指定すると<expr>の特別な後評価をし
               ます。（ステップ(5)を参照。） ‘eval’は複数回起こるかもし
               れません。‘eval’のそれぞれのインスタンスのために、式は再
               評価されます。
             • 評価フラグ（‘*note evflag::’を参照）として宣言されたアト
               ム‘A’を引数に指定すると、 <expr>の評価の最中、‘A’が
               ‘true’にバインドされます。
             • ‘V: expression’（もしくは代わりに‘V=expression’）を引数に
               指定すると、 <expr>の評価の最中、‘V’が‘expression’の値に
               バインドされます。 もし‘V’がMaximaオプションなら、
               <expr>の評価の最中、‘V’の値に‘expression’が使われることに
               注意してください。 もし‘ev’の複数の引数がこのタイプの場合
               、並列してバインドされます。 もし‘V’が非アトムの式なら、
               バインドではなく、代入が実行されます。
             • 関数名 ‘F’が評価関数(‘*note evfun::’参照)として宣言されて
               いる場合、 ‘F’を引数に指定すると ‘F’が <expr>に適用されま
               す。
             • 他のどんな関数名（例えば、‘*note sum::’)でも引数に指定す
               ると、 <expr>の中にそれらの名前が現れた時それらが動詞であ
               るかのように評価します。
             • 加えて、exprの中で出現する関数（‘F(x)’としましょう）を、
               <expr>の今回の評価の目的のため、 ‘F(X) := expression’を
               ‘ev’の引数に与えて、局所的に定義することができます。
             • もし以上で言及しなかったアトム、添字付き変数、または、添
               字付き式が引数として与えられたら、 それを評価して、 もし
               その結果が等式もしくは割り当てであったら、示されたバイン
               ドもしくは代入を実行します。 もしその結果がリストなら、リ
               ストのメンバが、 ‘ev’に与えられた追加の引数であるかのよう
               に扱います。 これにより、 ‘*note solve::’が返すような、与
               えられた等式のリスト （例えば、 ‘[X=1,Y=A**2]’)や 等式の
               名前のリスト（例えば、 ‘[%t1, %t2]’。ここで ‘%t1’, ‘%t2’は
               等式）が使えます。

          ‘ev’の引数は、代入等式と評価関数以外はどんな順序で与えてもかま
          いません。 代入等式は左から右へ順に扱われ、 評価関数は、例えば
          、 ‘ev (<expr>, ratsimp, realpart)’は ‘realpart (ratsimp
          (<expr>))’と扱われるように、合成されます。

          ‘*note simp::’, ‘*note numer::’, ‘*note float::’スイッチは、ブ
          ロックの中でローカルにも、 またMaximaの中でグローバルにも設定
          でき、その場合，リセットされるまで効果を保ちます。

          ‘numer’と‘float’スイッチがともに‘true’でない場合、 もし
          <expr>が標準有理式(CRE)なら、‘ev’が返す式もまたCREです。

       2. step (1)の最中に、引数の中のもしくは引数の値の、等式の左辺に現
          れる添字なしの変数のリストを作ります。 <expr>の中の変数（添字
          なし変数や配列関数に関連づけられていない添字付き変数）は、 先
          のリストに現れるものを除いて、グローバルな値に置き換えられます
          。 普通、 <expr>は、ただのラベルだったり (以下の例の ‘%i2’のよ
          うに） ‘%’だったりするので、 その場合，このステップは単にラベ
          ルされた式を取り出し、 ‘ev’はその式に対して機能することになり
          ます。

       3. 引数で指定されたどんな代入文もすぐ実行されます。

       4. （引数で‘*note noeval::’が指定されていない限り）結果の式は再評
          価され、 引数に従って整理されます。 <expr>の中のどんな関数コー
          ルもその中の変数が評価された後実行されること、 ‘ev(F(x))’は
          ‘F(ev(x))’のように振る舞うことに注意してください。

       5. 引数の中の‘*note 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

 -- 特殊シンボル: eval

     ‘ev (<expr>)’のコールの引数として、 ‘eval’は <expr>の追加の評価をも
     たらします。 ‘*note 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

 -- プロパティ: 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

 -- プロパティ: 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))

 -- オプション変数: infeval

     「無限評価」モードにします。‘ev’は、値が変わらなくなるまで式を繰り
     返し評価します。 このモードで変数(‘X’とします）が評価されることを避
     けるには、単に‘X='X’を‘ev’の引数として含めます。 ‘ev (X, X=X+1,
     infeval)’のような式は、もちろん、無限ループを引き起こします。

 -- 特殊シンボル: noeval

     ‘noeval’は、‘*note ev::’の評価フェイズを抑制します。 これは、他のス
     イッチとの関連や、 式を再評価することなしに再整理するのに役に立ちま
     す。

 -- 特殊シンボル: nouns

     ‘nouns’は‘*note evflag::’の１つです。 ‘*note ev::’コマンドのオプシ
     ョンとして使われる時、 ‘nouns’は、式の中に現れる「名詞」形すべてを
     「動詞」に‘*note ev::’します。すなわち、それらを評価します。 ‘*note
     noun::’, ‘*note nounify::’, ‘verb’, ‘*note verbify::’も参照してくだ
     さい。

 -- 特殊シンボル: pred

     ‘ev (<expr>)’のコールでの引数として、 ‘pred’は、 述語論理(‘true’ま
     たは‘false’に評価される式)を評価するようにします。 ‘*note ev::’を参
     照してください。

     例:

          (%i1) 1<2;
          (%o1)                                1 < 2
          (%i2) 1<2,pred;
          (%o2)                                true


File: maxima.info,  Node: Simplification,  Next: Mathematical Functions,  Prev: Evaluation,  Up: Top

9 Simplification
****************

* Menu:

* Functions and Variables for Simplification::


File: maxima.info,  Node: Functions and Variables for Simplification,  Prev: Simplification,  Up: Simplification

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)’の形の式に適用されたときには こ
     の整理はされません。

 -- 宣言: antisymmetric
     もし‘declare(h,antisymmetric)’が実行されると、 ‘h’は反対称として整
     理されます。 例えば、‘h(x,z,y)’は‘-h(x,y,z)’と整理されます。 即ち、
     ‘symmetric’か‘commutative’で得られた結果に(-1)^nを掛けたものとなり
     ます。 ここで、nはその形に変換するのに必要な置換の回数です。

 -- 関数: combine (<expr>)
     同じ分母を持つ項を単一の項に結合することによって和<expr>を整理しま
     す。

 -- 宣言: commutative

     もし‘declare(h,commutative)’が実行されたなら、 ‘h’は可換関数として
     整理されます。 例えば、‘h(x,z,y)’は‘h(x,y,z)’に整理されます。 これ
     は‘symmetric’と同じです。

 -- 関数: 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にはできません。

 -- 関数: 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

 -- オプション変数: 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]

 -- オプション変数: domain
     デフォルト値: ‘real’

     ‘domain’が‘complex’に設定されている時、 ‘sqrt (x^2)’は、‘abs(x)’を
     返さず、‘sqrt (x^2)’ のままを保ちます。

 -- 宣言: 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

 -- 関数: expandwrt (<expr>, <x_1>, ..., <x_n>)

     式‘expr’を、変数<x_1>, ..., <x_n>に関して展開します。 変数を含む積
     すべては陽に現れます。 返される形式は、変数を含む式の和の積を含みま
     せん。 <x_1>, ..., <x_n>は、変数、演算子、式であり得ます。

     デフォルトでは、分母は展開されませんが、これは、スイッチ
     ‘expandwrt_denom’によって 制御することができます。

     この関数は‘simplification/stopex.mac’から自動ロードされます。

 -- オプション変数: expandwrt_denom
     デフォルト値: ‘false’

     ‘expandwrt_denom’は、‘expandwrt’によって有理式の扱いを制御します。
     もし‘true’なら、式の分子も分母も‘expandwrt’の引数に従って展開されま
     すが、 もし‘expandwrt_denom’が‘false’なら、分子だけがその方法で展開
     されます。

 -- 関数: expandwrt_factored (<expr>, <x_1>, ..., <x_n>)

     ‘expandwrt’に似ていますが、積の式を幾分違って扱います。
     ‘expandwrt_factored’は、‘expr’の、 変数<x_1>, ..., <x_n>を含む因子
     上でだけ展開します。

     この関数は、‘simplification/stopex.mac’から自動ロードされます。

 -- オプション変数: expon
     デフォルト値: 0

     ‘expon’は、(‘expand’のコールに依らず)自動的に展開される負のべき乗の
     最大指数です。 例えば、 もし‘expon’が4なら、 ‘(x+1)^(-5)’は自動的に
     は展開されません。

 -- 関数: exponentialize (<expr>)
 -- オプション変数: exponentialize

     関数‘exponentialize (expr)’は、 <expr>の中の円関数や双曲関数を指数
     関数に変換します。 グローバル変数‘exponentialize’を設定する必要はあ
     りません。

     変数‘exponentialize’が‘true’の時、 円関数や双曲関数すべては指数関数
     形に変換されます。 デフォルト値は‘false’です。

     ‘demoivre’は複素数の指数関数を円関数に変換します。
     ‘exponentialize’や‘demoivre’は同時にtrueにすることはできません。

 -- オプション変数: expop
     デフォルト値: 0

     ‘expop’は、自動的に展開される最高の正の指数です。 例えば、‘(x +
     1)^3’が入力された時、 ‘expop’が3以下の時だけ自動的に展開されます。
     もし、‘n’が‘expop’より大きい‘(x + 1)^n’が展開されることを望むなら、
     ‘expand ((x + 1)^n)’の実行は、 ‘maxposex’がn以上の時だけ機能します
     。

 -- 宣言: lassociative

     ‘declare (g, lassociative)’は、 Maximaの整理器に ‘g’が左結合である
     ことを告げます。 例えば、‘g (g (a, b), g (c, d))’は‘g (g (g (a, b),
     c), d)’に整理されます。

 -- 宣言: 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’も参
     照してください。

 -- オプション変数: maxnegex
     デフォルト値: 1000

     ‘maxnegex’は、 ‘expand’コマンドによって展開される最大の負の指数です
     。 （‘maxposex’)も参照してください。）

 -- オプション変数: maxposex
     デフォルト値: 1000

     ‘maxposex’は、 ‘expand’コマンドで展開される最大指数です。 （
     ‘maxnegex’)も参照してください。）

 -- 宣言: 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)’の形の式に適用された時
     にはなされません。

 -- 関数: 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

 -- 宣言: nary

     ‘declare(f, nary)’はMaximaに 関数 ‘f’をn項関数として認識するよう指
     示します。

     ‘nary’宣言は *note ‘nary’: operator_nary.関数をコールするのと同じで
     はありません。 ‘declare(f, nary)’は唯一の効果は 例えば、 ‘foo(x,
     foo(y, z))’を ‘foo(x, y, z)’に整理するように 入れ子の式をフラットに
     するようMaxima整理器に指示することです。 *note 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’に設定したくないフラグの１
     つです。

 -- システム変数: opproperties

     ‘opproperties’は、Maximaの整理器が認識する特殊演算子プロパティのリ
     ストです: ‘linear’, ‘additive’, ‘multiplicative’, ‘outative’,
     ‘evenfun’, ‘oddfun’, ‘commutative’, ‘symmetric’, ‘antisymmetric’,
     ‘nary’, ‘lassociative’, ‘rassociative’.

 -- 宣言: 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’です。

 -- 関数: 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

 -- オプション変数: 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’の時だけ意味を持つことに注意してくだ
     さい。

 -- 宣言: rassociative

     ‘declare (g, rassociative)’は、 Maximaの整理器に ‘g’が右結合である
     ことを告げます。 例えば、 ‘g(g(a, b), g(c, d))’は、‘g(a, g(b, g(c,
     d)))’に整理されます。

 -- 関数: scsimp (<expr>, <rule_1>, ..., <rule_n>)

     順次的な相対整理(Sequential Comparative Simplification) (Stouteによ
     る方法)。 ‘scsimp’は、 規則<rule_1>, ..., <rule_n>に従って、
     <expr>を整理しようとします。 もしより小さな式が得られたら、 プロセ
     スは繰り返されます。 そうでなければ、すべての整理が試された後、 元
     の答えを返します。

     ‘example (scsimp)’はいくつかの例を表示します。

 -- オプション変数: 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)

 -- 宣言: symmetric

     ‘declare (h, symmetric)’は、Maximaの整理器に ‘h’が対称関数であるこ
     とを告げます。 例えば、‘h (x, z, y)’は‘h (x, y, z)’に整理されます。

     ‘commutative’は‘symmetric’と同義です。

 -- 関数: 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)


File: maxima.info,  Node: Mathematical Functions,  Next: Maximas Database,  Prev: Simplification,  Up: Top

10 Mathematical Functions
*************************

* Menu:

* Functions for Numbers::
* Functions for Complex Numbers::
* Combinatorial Functions::
* Root Exponential and Logarithmic Functions::
* Trigonometric Functions::
* Random Numbers::


File: maxima.info,  Node: Functions for Numbers,  Next: Functions for Complex Numbers,  Prev: Mathematical Functions,  Up: Mathematical Functions

10.1 Functions for Numbers
==========================

 -- 関数: abs (<expr>)

     <expr>の絶対値を返します。もし<expr>が複素数なら、<expr>の絶対値
     (modulus)を返します。

     ‘abs’はリスト上、行列上、等式上に分配されます。 ‘*note
     distribute_over::’を参照してください。

 -- 関数: 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

 -- 関数: entier (<x>)
     <x>が数値の場合、<x>以下の最大の整数を返します。 （‘fixnum’における
     ）‘fix’はこれの別名で、 ‘fix(<x>)’は正確に同じです。

 -- 関数: 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

 -- 関数: fix (<x>)
     ‘entier (<x>)’の別名です。

 -- 関数: lmax (<L>)

     <L>がリストもしくは集合の時、‘apply ('max, args (<L>))’を返します。
     <L>がリストでも集合でもない時、エラーを示します。

 -- 関数: lmin (<L>)

     <L>がリストもしくは集合の時、‘apply ('min, args (<L>))’を返します。
     <L>がリストでも集合でもない時、エラーを示します。

 -- 関数: 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)’を使います。

 -- 関数: 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)’を使います。

     ‘*note max::’や *note lmin::.も参照してください。

 -- 関数: round (<x>)

     <x>が実数の時、<x>に最も近い整数を返します。 1/2を掛けてroundして
     2を掛けると、最も近い偶数に丸められます。 <x>の評価は、‘floor’や
     ‘ceiling’に似ています。

 -- 関数: 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’関数はリスト、行列もしくは等式上に分配されます。 ‘*note
     distribute_over::’を参照してください。


File: maxima.info,  Node: Functions for Complex Numbers,  Next: Combinatorial Functions,  Prev: Functions for Numbers,  Up: Mathematical Functions

10.2 Functions for Complex Numbers
==================================

 -- 関数: cabs (<expr>)
     <expr>の複素数の絶対値を返します。

 -- 関数: 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

 -- 関数: 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)

 -- 関数: imagpart (<expr>)
     式<expr>の虚部を返します。

     ‘imagpart’は、計算関数であり、整理関数ではありません。

     ‘abs’, ‘carg’, ‘polarform’, ‘rectform’, ‘realpart’も 参照してくださ
     い。

 -- 関数: polarform (<expr>)
     <expr>と同値な式‘r %e^(%i theta)’を返します。 ここで、‘r’と
     ‘theta’は純粋な実数です。

 -- 関数: realpart (<expr>)
     <expr>の実部を返します。 ‘realpart’と‘imagpart’は、 平方根、対数関
     数、指数関数はもちろん三角関数や双曲関数を含む式上で機能します。

 -- 関数: rectform (<expr>)
     <expr>と同値な式‘a + b %i’を返します。 ここで<a>と<b>は純粋な実数で
     す。


File: maxima.info,  Node: Combinatorial Functions,  Next: Root Exponential and Logarithmic Functions,  Prev: Functions for Complex Numbers,  Up: Mathematical Functions

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)’を返します。

 -- 関数: 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)

 -- 関数: factcomb (<expr>)
     例えば、‘(n + 1)*n!’を‘(n + 1)!’に変換することによって、 <expr>の中
     の階乗の係数を階乗それ自身と結合しようとします。

     もし‘sumsplitfact’が‘false’に設定されたなら、 ‘minfactorial’が
     ‘factcomb’の後適用されるようになります。

 -- 関数: 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)’を掛けたものに整理されます。

     変数 ‘*note factlim::’, ‘*note gammalim::’は整数や有理数の引数の階
     乗の数値評価を制御します。 関数 ‘*note minfactorial::’, ‘*note
     factcomb::’は階乗を含む式の整理を制御します。 ‘factlim’,
     ‘gammalim’, ‘minfactorial’, ‘factcomb’を参照してください。

     関数 ‘*note gamma::’, ‘*note bffac::’, ‘*note cbffac::’はガンマ関数
     の変形です。 多倍長浮動小数点精度の実数と複素数のガンマ関数を評価す
     るために、 ‘gamma’は内部で ‘bffac’や ‘cbffac’をコールします。

     ‘*note makegamma::’は階乗や関係した関数に‘gamma’を代入します。

     Maximaは階乗関数の導関数や、負の整数のような特殊な値の極限を知って
     います。

     オプション変数 ‘*note 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

 -- オプション変数: factlim
     デフォルト値: -1

     ‘factlim’は、自動的に展開される最高の階乗を指定します。 もし-1なら
     、すべての整数は展開されます。

 -- オプション変数: factorial_expand
     デフォルト値: false

     オプション変数‘factorial_expand’は ‘(n+1)!’のような式の整理を制御し
     ます。 ここで‘n’は整数です。 例は‘!’を参照してください。

 -- 関数: 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!!’です。

 -- 関数: minfactorial (<expr>)

     整数だけ違う２つの階乗の出現に関して <expr>を検査します。 そして、
     ‘minfactorial’は、 一方を多項式掛ける他方に変えます。

          (%i1) n!/(n+2)!;
                                         n!
          (%o1)                       --------
                                      (n + 2)!
          (%i2) minfactorial (%);
                                          1
          (%o2)                    ---------------
                                   (n + 1) (n + 2)

 -- オプション変数: sumsplitfact
     デフォルト値: ‘true’

     ‘sumsplitfact’が‘false’の時、 ‘minfactorial’は、‘factcomb’の後に適
     用されます。


File: maxima.info,  Node: Root Exponential and Logarithmic Functions,  Next: Trigonometric Functions,  Prev: Combinatorial Functions,  Up: Mathematical Functions

10.4 Root, Exponential and Logarithmic Functions
================================================

 -- オプション変数: %e_to_numlog
     デフォルト値: ‘false’

     ‘true’の時、 ‘r’をある有理数、‘x’をある式とすると、
     ‘%e^(r*log(x))’は‘x^r’に整理されます。 ‘radcan’コマンドもこの変換を
     行い、その上この同類のさらに複雑な変換をすることに注意すべきです。
     ‘logcontract’コマンドは‘log’を含む式を「短縮」します。

 -- オプション変数: %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)’の特別な整理は実行されま
     せん。

 -- オプション変数: %enumer
     デフォルト値: ‘false’

     ‘%enumer’が‘true’の時、 ‘numer’が‘true’の時はいつでも、 ‘%e’は数値
     2.718...に置き換えられます。

     ‘%enumer’が‘false’の時、 ‘%e^x’の指数が数に評価される時だけ、 この
     代入が実行されます。

     ‘*note ev::’, ‘*note numer::’も参照してください。

 -- 関数: exp (<x>)

     指数関数を表します。 入力にある‘exp (<x>)’のインスタンスは、
     ‘%e^<x>’に整理されます; ‘exp’は整理された式の中には現れません。

     もし‘demoivre’が‘true’で、かつ、 ‘b’が‘%i’を含まないなら、 ‘%e^(a +
     b %i)’は‘%e^(a (cos(b) + %i sin(b)))’に整理されます。 ‘*note
     demoivre::’を参照してください。

     ‘%emode’が‘true’の時、 ‘%e^(%pi %i x)’は整理されます。 ‘*note
     %emode::’を参照してください。

     ‘%enumer’が‘true’の時、 ‘numer’が‘true’の時にはいつでも ‘%e’は
     2.718...に置き換えれます。 ‘*note %enumer::’を参照してください。

 -- 関数: 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]

 -- 関数: 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’を含む式を「短縮」しま
          す。

 -- オプション変数: logabs
     デフォルト値: ‘false’

     例えば‘integrate(1/x,x)’のように、logが生成される不定積分を実行する
     時、 もし‘logabs’が‘true’なら もし‘logabs’が‘false’なら 答えは、
     ‘log(...)’の形で与えられます。 定積分については、 終端での不定積分
     の「評価」がしばしば必要になるので、‘logabs:true’設定が使われます。

 -- オプション変数: logarc
 -- 関数: logarc (<expr>)

     グローバル変数‘logarc’が‘true’の時、 逆円関数や逆双曲線関数は、同値
     の対数関数に置き換えられます。 ‘logarc’のデフォルト値は‘false’です
     。

     関数‘logarc(<expr>)’は、 グローバル変数‘logarc’を設定することなしに
     、式<expr>に対して上記置き換えを実行します。

 -- オプション変数: logconcoeffp
     デフォルト値: ‘false’

     ‘logcontract’を使った時、どの係数が短縮されるかを制御します。 引数
     １つの述語論理関数の名前に設定することができます。 例えば、もし
     SQRTを生成したいなら、 ‘logconcoeffp:'logconfun$
     logconfun(m):=featurep(m,integer) or ratnump(m)$’を実行できます。 す
     ると、 ‘logcontract(1/2*log(x));’は‘log(sqrt(x))’を与えるでしょう。

 -- 関数: 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))’を与えるでしょう。

 -- オプション変数: 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’に設定されているなら、
     これらのすべての整理は止められます。

 -- オプション変数: lognegint
     デフォルト値: ‘false’

     もし‘true’なら、正の整数‘n’に対して規則 ‘log(-n)’ ->
     ‘log(n)+%i*%pi’ が実装されます。

 -- オプション変数: lognumer
     デフォルト値: ‘false’

     もし‘true’なら、 引数は、‘log’の計算の前に絶対値に変換されます。 も
     し‘numer’も‘true’なら、 ‘log’の引数に負の整数を与えたとき、 引数は
     、‘log’の計算の前に絶対値に変換されます。

 -- オプション変数: logsimp
     デフォルト値: ‘true’

     もし‘false’なら、 ‘%e’は、‘log’を含む累乗へ整理がなされます。

 -- 関数: plog (<x>)

     ‘-%pi’ < ‘carg(<x>)’ <= ‘+%pi’を虚部係数とする複素数値の自然対数の
     主値を表します。

 -- 関数: sqrt (<x>)
     <x>の平方根。 内部的には‘<x>^(1/2)’で表現されます。
     ‘rootscontract’も参照してください。

     ‘radexpand’が‘true’なら、nのべき乗となる積の因子のn番目の根を 累乗
     根の外部に押し出すようにします。 例えば、 ‘radexpand’が‘true’の時だ
     け、‘sqrt(16*x^2)’は‘4*x’になります。


File: maxima.info,  Node: Trigonometric Functions,  Next: Random Numbers,  Prev: Root Exponential and Logarithmic Functions,  Up: Mathematical Functions

10.5 Trigonometric Functions
============================

* Menu:

* Introduction to Trigonometric::
* Functions and Variables for Trigonometric::


File: maxima.info,  Node: Introduction to Trigonometric,  Next: Functions and Variables for Trigonometric,  Prev: Trigonometric Functions,  Up: Trigonometric Functions

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>)’を実行してください。


File: maxima.info,  Node: Functions and Variables for Trigonometric,  Prev: Introduction to Trigonometric,  Up: Trigonometric Functions

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)   ]

 -- オプション変数: %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)

 -- 関数: acos (<x>)
     - 逆余弦

 -- 関数: acosh (<x>)
     - 逆双曲余弦

 -- 関数: acot (<x>)
     - 逆余接

 -- 関数: acoth (<x>)
     - 逆双曲余接

 -- 関数: acsc (<x>)
     - 逆余割

 -- 関数: acsch (<x>)
     - 逆双曲余割

 -- 関数: asec (<x>)
     - 逆正割

 -- 関数: asech (<x>)
     - 逆双曲正割

 -- 関数: asin (<x>)
     - 逆正弦

 -- 関数: asinh (<x>)
     - 逆双曲正弦

 -- 関数: atan (<x>)
     - 逆正接

 -- 関数: atan2 (<y>, <x>)
     - ‘-%pi’から‘%pi’までの間の‘atan(<y>/<x>)’の値をもたらします。

 -- 関数: atanh (<x>)
     - 逆双曲正接

 -- パッケージ: atrig1
     ‘atrig1’パッケージは、逆三角関数のためのいくつかの追加の整理規則を
     含みます。 Maximaが既に知っている規則と合わせて、 以下の角度が完全
     に実装されます: ‘0’, ‘%pi/6’, ‘%pi/4’, ‘%pi/3’, ‘%pi/2’。 他の3象限
     の対応する角度も利用可能です。 これらを使うには、
     ‘load("atrig1");’を実行してください。

 -- 関数: cos (<x>)
     - 余弦

 -- 関数: cosh (<x>)
     - 双曲余弦

 -- 関数: cot (<x>)
     - 余接

 -- 関数: coth (<x>)
     - 双曲余接

 -- 関数: csc (<x>)
     - 余割

 -- 関数: csch (<x>)
     - 双曲余割

 -- オプション変数: 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)

 -- パッケージ: ntrig
     ‘ntrig’パッケージは、 引数が形式‘<f>(<n> %pi/10)’ ―<f>は関数 ‘sin’,
     ‘cos’, ‘tan’, ‘csc’, ‘sec’, ‘cot’のいずれか― の三角関数を整理するの
     に使われる整理規則の集合を含みます。

 -- 関数: sec (<x>)
     - 正割

 -- 関数: sech (<x>)
     - 双曲正割

 -- 関数: sin (<x>)
     - 正弦

 -- 関数: sinh (<x>)
     - 双曲正弦

 -- 関数: tan (<x>)
     - 正接

 -- 関数: tanh (<x>)
     - 双曲正接

 -- 関数: 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)

 -- オプション変数: trigexpandplus
     デフォルト値: ‘true’

     ‘trigexpandplus’は、‘trigexpand’の「和」規則を制御します。
     ‘trigexpand’コマンドが使われるか、もしくは ‘trigexpand’スイッチが
     ‘true’に設定されている時 和(例えば‘sin(x+y))’)の展開は、
     ‘trigexpandplus’が‘true’の時だけ起こります。

 -- オプション変数: trigexpandtimes
     デフォルト値: ‘true’

     ‘trigexpandtimes’は、‘trigexpand’の「積」規則を制御します。
     ‘trigexpand’コマンドが使われるか、もしくは、 ‘trigexpand’スイッチが
     ‘true’に設定されている時、 積(例えば‘sin(2*x)’)の展開は、
     ‘trigexpandtimes’が‘true’の時だけ起こります。

 -- オプション変数: triginverses
     デフォルト値: ‘true’

     ‘triginverses’は、 三角関数や双曲線関数とそれらの逆関数の合成の整理
     を制御します。

     もし‘all’なら、 例えば、‘atan(tan(<x>))’ と‘tan(atan(<x>))’のどちら
     も<x>に整理されます。

     もし‘true’なら、 ‘<arcfun>(<fun>(<x>))’の整理は止められます。

     もし‘false’なら、 ‘<arcfun>(<fun>(<x>))’と ‘<fun>(<arcfun>(<x>))’の
     どちらの整理も止められます。

 -- 関数: 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

 -- オプション変数: trigsign
     デフォルト値: ‘true’

     ‘trigsign’が‘true’の時、 三角関数への負の引数の整理を認めます。 例
     えば、‘sin(-x)’は、 ‘trigsign’が‘true’の時だけ、 ‘-sin(x)’になりま
     す。

 -- 関数: 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’のいくつかの例を表示します。

 -- 関数: 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


File: maxima.info,  Node: Random Numbers,  Prev: Trigonometric Functions,  Up: Mathematical Functions

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)’は、乱数生成器の現在のステートのコピーを
     返します。

 -- 関数: set_random_state (<s>)
     <s>を乱数生成器状態にコピーします。

     ‘set_random_state’はいつも‘done’を返します。

 -- 関数: 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


File: maxima.info,  Node: Maximas Database,  Next: Plotting,  Prev: Mathematical Functions,  Up: Top

11 Maximas Database
*******************

* Menu:

* Introduction to Maximas Database::
* Functions and Variables for Properties::
* Functions and Variables for Facts::
* Functions and Variables for Predicates::


File: maxima.info,  Node: Introduction to Maximas Database,  Next: Functions and Variables for Properties,  Prev: Maximas Database,  Up: Maximas Database

11.1 Introduction to Maximas Database
=====================================


File: maxima.info,  Node: Functions and Variables for Properties,  Next: Functions and Variables for Facts,  Prev: Introduction to Maximas Database,  Up: Maximas Database

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

 -- 宣言: 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’を参照してください。

 -- 関数: 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]]

 -- プロパティ: 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

 -- 宣言: posfun
     ‘declare (f, posfun)’は、 ‘f’を正の関数と宣言します。 ‘is (f(x) >
     0)’は‘true’を出力します。

 -- 関数: printprops (<a>, <i>)
 -- 関数: printprops ([<a_1>, ..., <a_n>], <i>)
 -- 関数: printprops (all, <i>)

     アトム<a>に関連付けられた指標<i>の属性を表示します。 <a>は、アトム
     のリストもしくはアトム‘all’もありえます。 その場合，与えられたプロ
     パティを持つすべてのアトムに適用します。 例えば、 ‘printprops ([f,
     g], atvalue)’。 ‘printprops’は、表示できないプロパティ、 すなわち
     ‘*note atvalue::’, ‘*note atomgrad::’, ‘*note gradef::’, ‘*note
     matchdeclare::’のためのものです。


File: maxima.info,  Node: Functions and Variables for Facts,  Next: Functions and Variables for Predicates,  Prev: Functions and Variables for Properties,  Up: Maximas Database

11.3 Functions and Variables for Facts
======================================

 -- 関数: activate (<context_1>, ..., <context_n>)
     文脈<context_1>, ..., <context_n>をアクティベートします。 これらの
     文脈に関する事実は、演繹し情報を検索するために利用可能となります。
     これらの文脈に関する事実は、‘facts ()’によってリストされません。

     変数‘activecontexts’は、 ‘activate’関数を使ってアクティブになった文
     脈のリストです。

 -- システム変数: activecontexts
     デフォルト値: ‘[]’

     変数‘activecontexts’は、 アクティブである文脈と対照的に、
     ‘activate’関数を使ってアクティブになった文脈のリストです。 ゆえに、
     それらは現在の文脈の部分文脈です。

 -- システム変数: askexp
     ‘asksign’がコールされた時、 ‘askexp’は、‘asksign’がテストしている式
     です。

     以前は、control-AでMaximaブレイクに入ることによって、 ユーザーが
     ‘askexp’を検査することができました。

 -- 関数: 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>が偶数か奇数か、決定しようとします。

 -- 関数: asksign (<expr>)

     最初に、指定された式が正か負かゼロか決定しようとします。 できなけれ
     ば、演繹を完了するのに必要な質問をユーザーに尋ねます。 ユーザーの答
     えは、現在の計算の演繹のため、データベースに記録されます。
     ‘asksign’の戻り値は、‘pos’, ‘neg’もしくは‘zero’のいずれか１つです。

 -- 関数: 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

 -- オプション変数: 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’の時、 そんな式は、上でリストされた演算子すべ
     てに関してスカラーのように振る舞います。

 -- オプション変数: 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’は、いつもユーザーからの入力
     を要請します。

 -- オプション変数: 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

 -- オプション変数: context
     デフォルト値: ‘initial’

     ‘context’は、‘assume’と‘forget’によって保守される事実の集まりの名前
     です。

     ‘assume’は、‘context’と名付けられた集まりに事実を追加する一方、
     ‘forget’は、事実を取り除きます。

     ‘context’を名前<foo>にバインドすることは、 現在の文脈を<foo>に変え
     ます。 もし指定された文脈<foo>がまだ存在しないなら、 ‘newcontext’の
     コールによって自動的に生成されます。 指定された文脈は自動的にアクテ
     ィベートされます。

     文脈メカニズムの一般的な記述に関しては、‘contexts’を参照してくださ
     い。

 -- オプション変数: contexts
     デフォルト値: ‘[initial, global]’

     ‘contexts’は、 現在アクティブな文脈を含んでいる、現在存在する文脈の
     リストです。

     文脈メカニズムは、ユーザーが 文脈と呼ばれる事実の集まりにバインドし
     、名付けることを可能にします。 一旦これがなされると、ユーザーは、 文
     脈を単にアクティベートしたりデアクティベートすることで、 たくさんの
     数の事実をMaximaに仮定させたり忘れさせたりできます。

     任意のシンボルのアトムは、文脈となりえ、 その文脈の中に含まれた事実
     は、 ‘forget’をコールすることで１つ１つ破壊されるまで、 あるいは、
     それらが属する文脈を破壊するために‘kill’をコールすることで、全体と
     して破壊されるまで、記憶装置に保持されます。

     文脈は階層的に存在します。 その根はいつも文脈‘global’であり、 文脈
     ‘global’は、いくつかの関数が必要とするMaximaについての情報を含みま
     す。 アクティブな文脈の部分文脈である任意の文脈の中の事実すべてそう
     であるように、 与えられた文脈の中では、 その文脈の中の事実すべては
     、「アクティブ」（それらが演繹や探索に使われるという意味） です。

     新鮮なMaximaが起動された時、 ユーザーは、‘initial’と呼ばれる文脈の
     中にいます。 それは、部分文脈として‘global’を持ちます。

     ‘facts’, ‘newcontext’, ‘supcontext’, ‘killcontext’, ‘activate’,
     ‘deactivate’, ‘assume’, ‘forget’も参照してください。

 -- 関数: deactivate (<context_1>, ..., <context_n>)

     特定の文脈<context_1>, ..., <context_n>をデアクティベートします。

 -- 関数: facts (<item>)
 -- 関数: facts ()

     もし<item>が文脈の名前なら、 ‘facts (<item>)’は指定された文脈の
     ‘facts’のリストを返します。

     もし<item>が文脈の名前でなければ、 ‘facts (<item>)’は現在の文脈の中
     で、 <item>について知っている‘facts’のリストを返します。 異なる文脈
     中のアクティブな‘facts’はリストされません。

     ‘facts ()’（すなわち引数なし）は現在の文脈をリストします。

 -- 関数: forget (<pred_1>, ..., <pred_n>)
 -- 関数: forget (<L>)
     ‘assume’で規定された述語論理を取り除きます。 述語論理は以前に規定さ
     れたものと同値の（必ずしも同一である必要なない）式です。

     ‘forget (<L>)’（<L>は述語論理のリスト）は、 リスト上のそれぞれの項
     目を忘れます。

 -- 関数: 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

 -- 関数: killcontext (<context_1>, ..., <context_n>)

     文脈<context_1>, ..., <context_n>を消します。

     もし文脈の１つが現在の文脈なら、 新しい文脈は、 消されなかった現在
     の文脈の最初の利用可能な部分文脈になるでしょう。 もし最初の利用可能
     な消されなかった文脈が‘global’なら、 ‘initial’が代わりに使われます
     。 もし‘initial’文脈が消されたら、 新しい、空の‘initial’文脈が生成
     されます。

     ‘killcontext’は、現在アクティブな文脈を消すことを拒否します。 なぜ
     なら、それは現在の文脈の部分文脈、もしくは 関数‘activate’の使用によ
     ってアクティブになっているから。

     ‘killcontext’は、引数を評価します。 ‘killcontext’は、‘done’を返しま
     す。

 -- 関数: 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

 -- 関数: newcontext (<name>)

     <name>と呼ばれる新しい、空の文脈を生成します。 <name>は、唯一の部分
     文脈として‘global’を持ちます。 新しく生成された文脈は現在アクティブ
     な文脈になります。

     ‘newcontext’は、引数を評価します。 ‘newcontext’は、<name>を返します
     。

 -- 関数: sign (<expr>)
     現在のデータベースの事実に基づいて<expr>の符号を決定しようとします
     。 以下の答えの１つを返します; ‘pos’ (positive), ‘neg’ (negative),
     ‘zero’, ‘pz’ (正もしくはゼロ), ‘nz’ (負もしくはゼロ), ‘pn’ (正もし
     くは負), or ‘pnz’ (正、負もしくはゼロ、すなわちなにもわからない).

 -- 関数: supcontext (<name>, <context>)
 -- 関数: supcontext (<name>)

     <name>と呼ばれる新しい文脈を生成します。 <name>は、部分文脈として
     <context>を持ちます。 <context>は存在しなければいけません。

     もし<context>が指定されないなら、 現在の文脈が仮定されます。


File: maxima.info,  Node: Functions and Variables for Predicates,  Prev: Functions and Variables for Facts,  Up: Maximas Database

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]

 -- 関数: 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)’の実領域は空です。

 -- 特殊演算子: constant

     ‘declare (<a>, constant)’は、<a>を定数に宣言します。 ‘*note
     declare::’を参照してください。

 -- 関数: constantp (<expr>)

     もし<expr>が定数式なら、‘true’を返します。 そうでなければ、
     ‘false’を返します。

     もし引数が、（‘/R/’をつけて表示される有理数を含む）数や ‘*note
     %pi::’, ‘*note %e::’, ‘*note %i::’にようなシンボル定数、 定数にバイ
     ンドされた変数、‘*note 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)

 -- 関数: 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

 -- 関数: 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

 -- 関数: unknown (<expr>)]

     <expr>がMaximaの整理器が認識しない演算子や関数を含む時だけ、
     ‘true’を返します。

 -- 関数: 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’を返します。


File: maxima.info,  Node: Plotting,  Next: File Input and Output,  Prev: Maximas Database,  Up: Top

12 Plotting
***********

* Menu:

* Introduction to Plotting::
* Plotting Formats::
* Functions and Variables for Plotting::
* Plotting Options::
* Gnuplot Options::
* Gnuplot_pipes Format Functions::


File: maxima.info,  Node: Introduction to Plotting,  Next: Plotting Formats,  Prev: Plotting,  Up: Plotting

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’はオプション名です。


File: maxima.info,  Node: Plotting Formats,  Next: Functions and Variables for Plotting,  Prev: Introduction to Plotting,  Up: Plotting

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’に対する同義語として受け付けられます
     。


File: maxima.info,  Node: Functions and Variables for Plotting,  Next: Plotting Options,  Prev: Plotting Formats,  Up: Plotting

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"])$

 -- 関数: 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つの変換に関するドキュメ
     ンテーションを参照してください。

 -- システム関数: polar_to_xy

     plot3dの‘transform_xy’オプションに対する値として与えることができま
     す。 その効果はplot3dの2つの独立変数をz軸からの距離と方位角(極座標
     )として通訳し、 それらをxとy座標に変換することです。

 -- 関数: 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)"])$

     プロットオプションに関する節も参照してください。

 -- 関数: 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])$

     プロットオプションについての節も参照してください。

 -- システム変数: plot_options

     このリストの要素は、プロットのデフォルトオプションを指定します。 も
     し‘plot2d’もしくは‘plot3d’がコールされる時、オプションが指定された
     ら、 その値は、デフォルトオプションより優先されます。 そうでなけれ
     ば、‘plot_options’の中の値が使われます。 デフォルトオプションは、
     ‘set_plot_option’を使って割り当てられます。 それぞれのプロットコマ
     ンドに特化したローカルオプションがあり、それらは、この、グローバル
     オプションのリストには含まれません。

     ‘plot_options’のそれぞれの要素は、２つ以上の項目のリストです。 最初
     の項目はオプション名で、残りはオプションに割り当てられる値です。 い
     くつかの場合、割り当てられた値はリストであり、複数の項目からなるこ
     とがあります。

     ‘set_plot_option’と‘get_option’、プロットオプションの節も参照してく
     ださい。

 -- 関数: 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]]

 -- システム関数: spherical_to_xyz

     plot3dの‘transform_xy’オプションに対する値として与えることができま
     す。 その効果はplot3dでの2つの独立変数と関数を点の球座標 (1番目は
     z軸に対する角度、次にxy射影のx軸に対する角度、最後に原点からの距離)
     として解釈し、それらをx,y,z座標に変換することです。


File: maxima.info,  Node: Plotting Options,  Next: Gnuplot Options,  Prev: Functions and Variables for Plotting,  Up: Plotting

12.4 Plotting Options
=====================

すべてのオプションは、この節のキーワードの1つで始まり、 1つ以上の値が続
くリストで構成されます。 オプションのほとんどは (<plot2d>, <plot3d>,
<contour_plot>, <implicit_plot>) どのプロットコマンドでも。また関数
<set_plot_option>の中でも使うことができます; 例外は以下のリストで指定さ
れます。

 -- プロットオプション: adapt_depth [adapt_depth, <integer>]

     適応プロットルーチンで使われる分割の最大数です。

     デフォルト値: 5

 -- プロットオプション: axes [axes, <symbol>]

     ここで、<symbol>は‘true’, ‘false’, ‘x’, ‘y’のいずれかでありえます。
     もし‘false’なら、軸は表示されません; もし‘x’か‘y’に等しいなら、xか
     y軸のみが表示され、 ‘true’に等しいなら、両方の軸が表示されます。 こ
     のオプションはplot2dとimplicit_plotだけが使います。

     デフォルト値: ‘true’

 -- プロットオプション: azimuth [azimuth, <number>]

     plot3dプロットは plot2dと同様の水平軸と垂直軸に関してx軸とy軸と、 紙
     から垂直に出てくるz軸で始まるものと考えることができます。 z軸はその
     後x軸の回りに‘elevation’に等しい角度だけ回転され、 その後、xy平面は
     新しいz軸の回りに角度‘azimuth’だけ回転されます。 このオプションは
     azimuthに関する値を単位、度で設定します。

     デフォルト値: 30

     ‘elevation’も参照してください。

 -- プロットオプション: box [box, <symbol>]

     もし‘true’に設定されるなら、 境界枠がプロットに表示されます; もし
     ‘false’に設定されるなら、 枠は表示されません。

     デフォルト値: ‘true’

 -- プロットオプション: 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

 -- プロットオプション: colorbox [colorbox, <symbol>]

     ここで、<symbol>は‘true’か‘false’であり得ます。 もし‘true’なら、
     plot3dはzの違った値を表現するために、 違った色のパレットを使う時は
     いつでも、 zの値の大きさに従って使われた色を示す枠が右に示されます
     。 このオプションはxmaximaでは機能しません。

     デフォルト値: ‘false’

 -- プロットオプション: elevation [elevation, <number>]

     plot3dプロットは plot2dでの水平と垂直軸にxとy軸に 紙から直立に立っ
     たz軸から始まると考えられます。 その後、z軸はx軸の回りを
     ‘elevation’に等しい角度だけ回転し、 xy平面は新しいz軸の回りを
     ‘azimuth’角度だけ回転します。 このオプションはelevationの値を度単位
     で設定します。

     デフォルト値: 60

     ‘azimuth’も参照してください。

 -- プロットオプション: grid [grid, <integer>, <integer>]

     3次元プロットのためにx方向、y方向で使われるグリッド点の数を設定しま
     す。

     デフォルト値: 30, 30

 -- プロットオプション: legend [legend, <string_1>, ..., <string_n>]
 -- プロットオプション: legend [legend, <false>]

     複数のプロットが示される時、プロットのラベルを指定します。 もし与え
     られたラベルの数より多くの式があるなら、ラベルは繰り返されます。 も
     し値‘false’が与えられるなら、凡例は表示されません。 デフォルトでは
     、式や関数の名前が使われます。また、点の離散集合に関しては、 単語
     discrete1, discrete2, ...が使われます。 このオプションは
     <set_plot_optiion>で設定することができます。

 -- プロットオプション: logx [logx]

     水平軸を対数的にスケールするようにします。 <set_plot_option>では使
     うことはできません。

 -- プロットオプション: logy [logy]

     垂直軸を対数的にスケールするようにします。 <set_plot_option>では使
     うことはできません。

 -- Plot option: mesh_lines_color [mesh_lines_color, <color>]

     パレットが使われる時、plot3dがメッシュ線を描くのに使う色を設定しま
     す。 オプション ‘color’と同じ色を受け付けます。 (‘color’で許される
     色のリストを参照してください。) 値 ‘false’を与えて、メッシュ線を完
     全に消すこともできます。

     デフォルト値: black

 -- プロットオプション: nticks [nticks, <integer>]

     plot2dで関数をプロットする時、 関数をプロットするための適応プロット
     ルーチンによって使われる点の数の初期値を与えます。 plot2dやplot3dで
     パラメトリック関数をプロットする時、 プロットで表示される点の数を設
     定します。

     デフォルト値: 29

 -- プロットオプション: 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]

 -- プロットオプション: plot_format [plot_format, <format>]

     ここで<format>は以下のいずれかです; gnuplot, xmaxima, mgnuplot,
     gnuplot_pipes.

     プロットで使われるフォーマットを設定します。

     デフォルト値: Windowsシステムではgnuplot, 他のシステムでは
     gnuplot_pipes

 -- プロットオプション: 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’

 -- プロットオプション: 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

 -- プロットオプション: psfile [psfile, <string>]

     このオプションは、プロットをスクリーンに表示する代わりに、
     <string>に等しい名前のポストスクリプトファイルに保存します。 デフォ
     ルトでは、そのファイルは、変数<maxima_tempdir>で定義されたディレク
     トリに 生成されます; 変数の値を変えて、違うディレクトリにファイルを
     保存できます。

 -- プロットオプション: run_viewer [run_viewer, <symbol>]

     プロットフォーマット用の適切なビューアを走らせるかどうか制御します
     。

     デフォルト値: ‘true’

 -- プロットオプション: 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’も参照してください。

 -- プロットオプション: t [t, <min>, <max>]

     パラメトリックプロットのデフォルトの範囲。

     デフォルト値: -3, 3

 -- プロットオプション: transform_xy [transform_xy, <symbol>]

     ここで、<symbol>は‘false’か 関数‘transform_xy’を使うことで得られる
     結果をとり得ます。 もし‘false’と違うなら、 plot3dで3座標を変換する
     のに使われます。

     デフォルト値: ‘false’

     ‘make_transform’, ‘polar_to_xy’, ‘spherical_to_xyz’を参照してくださ
     い。

 -- プロットオプション: x [x, <min>, <max>]

     2dプロットコマンドの最初の(またはplot3dの最初の二つのどちらかの) オ
     プションとして使われる時、 1番目の独立変数がxであることを示し、その
     範囲を設定します。 最初のオプションの後(またはplot3dでは2番目のオプ
     ションの後)、 プロット内で示される有効な水平領域を定義するために、
     再び使うことができます。

 -- プロットオプション: xlabel [xlabel, <string>]

     1番目の軸をラベルする<string>を指定します; もしこのオプションが使わ
     れないなら、 plot2dかimplicit_plotで関数をプロットする時、そのラベ
     ルは独立変数の名前です。 plot3dで表面を、もしくはcontour_plotで等高
     線をプロットする時、 そのラベルは1番目の変数の名前です。 パラメトリ
     ックプロットの場合、1番目の式です。 <set_plot_option>では使うことは
     できません。

 -- プロットオプション: y [y, <min>, <max>]
     plot3dでの最初の2つのオプションの1つとして使われる時、 独立変数の
     1つがyであることを示し、その範囲を設定します。 そうでなければ、 プ
     ロットで示される2番目の変数の有効領域を定義します。

 -- プロットオプション: ylabel [ylabel, <string>]

     二番目の軸をラベルする<string>を指定します; もしこのオプションが使
     われないなら、 plot2dやimplicit_plotで関数をプロットする時、そのラ
     ベルは、"y"となり、 plot3dで表面をプロットするときや、
     contour_plotで等高線をプロットする時、 二番目の変数名となり、 パラ
     メトリックプロットの場合には、二番目の式になります。
     <set_plot_option>では使うことはできません。

 -- プロットオプション: z [z, <min>, <max>]
     プロットで示されるzの値の有効範囲を設定するためにplot3dで使われます
     。

 -- プロットオプション: zlabel [zlabel, <string>]

     plot3dを使う時、第三軸をラベルする<string>を指定します。 もしこのオ
     プションが使われないなら、 そのラベルは、 表面をプロットする時は
     "z"となり、 パラメトリックプロットの場合には三番目の式になります。
     <set_plot_option>では使うことはできません。 また、plot2d,
     implicit_plotでは無視されます。


File: maxima.info,  Node: Gnuplot Options,  Next: Gnuplot_pipes Format Functions,  Prev: Plotting Options,  Up: Plotting

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端末名です。

 -- プロットオプション: gnuplot_out_file

     ‘gnuplot_term’オプションと関連して使われる時、 Gnuplotがサポートす
     るグラフィックフォーマットの１つで、 ファイルにプロットを保存するの
     に使われます。 もしポストスクリプトファイルを生成したければ、 代わ
     りにオプション ‘psfile’を使うことができます。 これは、Openmathでも
     機能し、たった１つのオプションで同じことができます。

          [gnuplot_term, png], [gnuplot_out_file, "graph3.png"]

 -- プロットオプション: gnuplot_pm3d

     ‘false’の値では、PM3Dモードの使用を抑制するのに使われます。 PM3Dモ
     ードはデフォルトで使用可能です。

 -- プロットオプション: gnuplot_preamble

     プロットを描く前に、gnuplotコマンドを挿入します。 有効などんな
     gnuplotコマンドも使うことができます。 複数のコマンドは、セミコロン
     で分離されなければいけません。 示される例はログスケールプロットを生
     成します。 ‘gnuplot_preamble’のデフォルト値は、空の文字列‘""’です。

 -- プロットオプション: gnuplot_curve_titles

     これは、上記で記載した_legend_で置き換えられた古いオプションです。

 -- プロットオプション: gnuplot_curve_styles

     これは、上記で記載した_style_で置き換えられた古いオプションです。

 -- プロットオプション: gnuplot_default_term_command

     デフォルト端末の端末タイプを設定するgnuplotコマンド。 デフォルト値
     は、‘set term pop’です。

 -- プロットオプション: gnuplot_dumb_term_command

     ダム端末の端末タイプを設定するgnuplotコマンド。 デフォルト値は、
     ‘"set term dumb 79 22"’です。 これは、79文字 x 22文字のテキスト出力
     を生成します。

 -- プロットオプション: 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ドキュメンテーションを 参照して
     ください。


File: maxima.info,  Node: Gnuplot_pipes Format Functions,  Prev: Gnuplot Options,  Up: Plotting

12.6 Gnuplot_pipes Format Functions
===================================

 -- 関数: gnuplot_start ()

     ‘gnuplot_pipes’フォーマットでのプロットのため使われるgnuplotへのパ
     イプを開きます。 プロットの前に手動でパイプを開く必要はありません。

 -- 関数: gnuplot_close ()

     ‘gnuplot_pipes’フォーマットで使われたgnuplotへのパイプを閉じます。

 -- 関数: gnuplot_restart ()

     ‘gnuplot_pipes’フォーマットで使われたgnuplotへのパイプを閉じて、 新
     しいパイプを開きます。

 -- 関数: gnuplot_replot ()
 -- 関数: gnuplot_replot (<s>)

     gnuplotウィンドウを更新します。 もし‘gnuplot_replot’が、文字列<s>の
     中のgnuplotコマンドを引数としてコールされたなら、 ‘s’はウィンドウが
     再プロットされる前にgnuplotに送られます。

 -- 関数: gnuplot_reset ()

     ‘gnuplot_pipes’フォーマットと一緒に使われるgnuplotの状態をリセット
     します。 gnuplotウィンドウを更新するには、 ‘gnuplot_reset’の後に
     ‘gnuplot_replot’をコールください。


File: maxima.info,  Node: File Input and Output,  Next: Polynomials,  Prev: Plotting,  Up: Top

13 File Input and Output
************************

* Menu:

* Comments::
* Files::
* Functions and Variables for File Input and Output::


File: maxima.info,  Node: Comments,  Next: Files,  Prev: File Input and Output,  Up: File Input and Output

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


File: maxima.info,  Node: Files,  Next: Functions and Variables for File Input and Output,  Prev: Comments,  Up: File Input and Output

13.2 Files
==========

ファイルは、単に、データやテキスト含む、特別なストレージデバイスのある領
域です。 ディスク上のファイルは、比喩的に「ディレクトリ」の中にグループ
化されます。 ディレクトリは、単にファイルのリストです。 ファイルを扱うコ
マンドは以下の通りです:

   ‘save’, ‘load’, ‘loadfile’, ‘stringout’, ‘batch’, ‘demo’,
‘writefile’, ‘closefile’,と ‘appendfile’。

   ファイル名が‘*note plot2d::’や‘*note save::’、‘*note writefile::’のよ
うな関数に渡され、 ファイル名がパスを含まない時、Maximaは現在のワーキン
グディレクトリにファイルを保存します。 現在のワーキングディレクトリは
WindowsやLinuxのようなシステムと、インストールに依存します。


File: maxima.info,  Node: Functions and Variables for File Input and Output,  Prev: Files,  Up: File Input and Output

13.3 Functions and Variables for File Input and Output
======================================================

 -- 関数: appendfile (<filename>)
     コンソールの筆記録を<filename>に追加します。 ‘appendfile’は、 筆記
     録ファイルが、存在すれば、いつも追加されることを除いて、
     ‘writefile’と同じです。

     ‘*note closefile::’は、‘appendfile’や‘writefile’によって開かれた筆
     記録ファイルを閉じます。

 -- 関数: batch (<filename>)
 -- 関数: batch (<filename>, option)

     ‘batch(<filename>)’はMaximaの式を<filename>から読み込み、評価します
     。 ‘batch’は、リスト‘*note file_search_maxima::’の中で<filename>を
     検索します。 ‘*note file_search::’も参照してください。

     ‘batch(<filename>, demo)’は、 ‘demo(<filename>)’ようなものです。 こ
     の場合、‘batch’は、リスト‘*note file_search_demo::’の中で
     <filename>を検索します。 ‘*note 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の式より成り、それぞれの式は、‘;’もしくは
     ‘$’で終了します。 特殊変数‘*note %::’と関数‘*note %th::’は、ファイ
     ル内での前の結果を参照します。 ファイルは‘:lisp’構成子を含むかもし
     れません。 ファイルの中の空白、タブ、改行は無視されます。 適した入
     力ファイルは、テキストエディタもしくは、‘*note stringout::’関数で作
     ることができます。

     ‘batch’は、それぞれの入力式を<filename>から読み込み、 入力をコンソ
     ールに表示し、 対応する出力式を計算し、 出力式を表示します。 入力ラ
     ベルは入力式に割り当てられ、出力ラベルは出力式に割り当てられます。
     ‘batch’は、エラーがない限り、ファイルの中のすべての入力式を評価しま
     す。 もしユーザー入力が（例えば、‘*note asksign::’や‘*note
     askinteger::’によって）要求されたら、 ‘batch’は、ポーズして必要な入
     力を入手し、続けます。

     コンソールで‘control-C’をタイプすることで、‘batch’を停止させること
     が可能かもしれません。 ‘control-C’の効果は、基礎となるLispの実装に
     依存します。

     ‘batch’にはいくつか用法があります。 役立つコマンドラインの蓄積を供
     給したり、 エラーのないデモンストレーションを与えたり、 複雑な問題
     を解く時、人の考えを整理するのを助けたり。

     ‘batch’は引数を評価します。 第二引数なしで呼び出されたり、オプショ
     ン‘demo’で呼び出された時、 ‘batch’は‘filename’のパスを文字列として
     返します。 オプション‘test’で呼び出された時、 戻り値は、空のリスト
     ‘[]’か、<filename>と失敗したテストの数を含むリストです。

     ‘*note load::’, ‘*note batchload::’, ‘*note demo::’も参照してくださ
     い。

 -- 関数: batchload (<filename>)

     <filename>からMaximaの式を読み込み、評価します。 入力式や出力式を表
     示しません。 ラベルを出力式に割り当てません。 しかし、（‘print’や
     ‘describe’が生成するような)プリント文の出力は表示されます。

     特殊変数‘*note %::’や関数‘*note %th::’は、 ファイルの中の結果ではな
     く、対話インタープリタからの以前の結果を参照します。 ファイルは
     ‘:lisp’構成子を含むことはできません。

     ‘batchload’は、<filename>のパスを文字列として返します。
     ‘batchload’は引数を評価します。

     ‘*note batch::’や‘*note load::’も参照してください。

 -- 関数: closefile ()

     ‘*note writefile::’や‘*note appendfile::’で開いたトランスクリプトフ
     ァイルを閉じます。

 -- オプション変数: file_output_append
     デフォルト値: ‘false’

     ‘file_output_append’は、 ファイル出力関数が出力ファイルに追加するか
     、ファイルを切り詰めるか決めます。 ‘file_output_append’が‘true’の時
     、 ファイル出力関数は出力ファイルに追加します。 そうでなければ，出
     力ファイルは切り詰められます。

     ‘*note save::’, ‘*note stringout::’, ‘*note with_stdout::’は、
     ‘file_output_append’を考慮します。 出力ファイルを書き出す他の関数は
     ‘file_output_append’を考慮しません。 特に、プロット感巣や変換関数は
     常に出力ファイルを切り詰め、 ‘*note tex::’や‘*note appendfile::’は
     いつも追加します。

 -- 関数: filename_merge (<path>, <filename>)

     <path>と<filename>から修正されたパスを構成します。 もし、<path>の最
     後の構成要素が形式‘###.<something>’なら、 構成要素は、
     ‘<filename>.<something>’に置き換えられます。 そうでなければ、最後の
     構成要素は単に<filename>に置き換えられます。

     結果はLispのパス名オブジェクトです。

 -- 関数: file_search (<filename>)
 -- 関数: file_search (<filename>, <pathlist>)

     ‘file_search’は、ファイル<filename>を検索し、 もし見つかれば、（文
     字列として）ファイルへのパスを返します; そうでなければ、
     ‘file_search’は‘false’を返します。 ‘file_search (<filename>)’は、 デ
     フォルトのサーチディレクトリを検索します。 デフォルトのサーチディレ
     クトリは、‘*note file_search_maxima::’, ‘*note file_search_lisp::’,
     ‘*note file_search_demo::’変数によって指定されます。

     ‘file_search’は、 名前を「ワイルドカード」ファイルサーチパターンに
     マッチさせようとする前に、 最初に、渡された実際の名前が存在するかチ
     ェックします。 ファイルサーチパターンに関連した‘*note
     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>の中に１つのディレクトリだけしかない場合でさ
     え、まだ、 それは、要素１つのリストとして与えられなければいけません
     。

     ユーザーはデフォルト検索ディレクトリを修正できます。 ‘*note
     file_search_maxima::’を参照してください。

     ‘file_search’は、‘file_search_maxima’と‘*note file_search_lisp::’を
     を検索ディレクトリとして、 ‘*note load::’によって呼び出されます。

 -- オプション変数: file_search_maxima
 -- オプション変数: file_search_lisp
 -- オプション変数: file_search_demo
 -- オプション変数: file_search_usage
 -- オプション変数: file_search_tests

     これらの変数は、‘*note load::’, ‘*note 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が起動した時にファイル検索パスが自動的に割り当てられるような
     式を入れておくと便利かもしれません。 *note 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_type (<filename>)

     <filename>の中身について、ファイル名拡張子を下に、推測を返します。
     <filename>は、実際のファイルを参照する必要はありません; ファイルを
     開いたり、中身を探索したりはしません。

     戻り値はシンボルであり、‘object’, ‘lisp’, ‘maxima’のいずれかです。
     もし拡張子が‘file_type_maxima’の中の値の1つと一致したら、
     ‘file_type’は‘maxima’を返します。 もし拡張子が"‘file_type_lisp’の中
     の値の1つと一致したら、 ‘file_type’は‘lisp’を返します。 上のいずれ
     でもないなら、‘file_type’は‘object’を返します。

     ‘*note pathname_type::’も参照してください。

     デフォルト値に関しては、‘*note file_type_maxima::’と‘*note
     file_type_lisp::’を 参照してください。

     例:

          (%i2) map('file_type,
                    ["test.lisp", "test.mac", "test.dem", "test.txt"]);
          (%o2)            [lisp, maxima, maxima, object]

 -- オプション変数: file_type_lisp
     デフォルト値: ‘[l, lsp, lisp]’

     ‘file_type_lisp’は、 maximaがLispソースファイルの印として認識するフ
     ァイル拡張子のリストです。

     ‘*note file_type::’も参照してください。

 -- オプション変数: file_type_maxima
     デフォルト値: ‘[mac, mc, demo, dem, dm1, dm2, dm3, dmt]’

     ‘file_type_maxima’は、 maximaがMaximaソースファイルの印として認識す
     るファイル拡張子のリストです。

     ‘*note file_type::’も参照してください。

 -- 関数: load (<filename>)

     <filename>の中の式を評価します。 そして、変数、関数、他のオブジェク
     トをMaximaにもたらします。 、<filename>から再生されたバインドは存在
     するオブジェクトのバインドを上書きします(clobber)。 ファイルを見つ
     けるために、 ‘load’は、探索ディレクトリとして‘file_search_maxima’と
     ‘file_search_lisp’を引数として‘file_search’をコールします。 もし
     ‘load’が成功したら ファイルの名前を返します。 そうでなければ、
     ‘load’はエラーメッセージを出力します。

     ‘load’は、LispコードでもMaximaコードでも等しく機能します。 ‘*note
     save::’, ‘*note translate_file::’, ‘*note compile_file::’―これらは
     Lispコードを生成します―が生成したファイルはすべて‘load’によって処理
     できます。 ‘load’は、Lispファイルをロードするために‘loadfile’をコー
     ルし、 Maximaファイルをロードするために‘*note batchload::’をコール
     します。

     ‘load’は、Maximaファイルの中で‘:lisp’構成子を認識しません。
     <filename>を処理する時、 グローバル変数‘_’, ‘__’, ‘%’, ‘%th’は、
     ‘load’がコールされた時バインドされていた値を持ちます。

     ‘*note loadfile::’, ‘*note batch::’, ‘*note batchload::’, ‘*note
     demo::’も参照してください。 ‘loadfile’はLispファイルを処理します;
     ‘batch’, ‘batchload’, ‘demo’はMaximaファイルを処理します。

     ファイル探索メカニズムについてもっと詳しいことは‘*note
     file_search::’を参照してください。

     ‘load’は引数を評価します。

 -- システム変数: load_pathname
     デフォルト値: ‘false’

     関数‘*note load::’や、‘*note loadfile::’、‘*note 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

 -- 関数: loadfile (<filename>)

     <filename>の中のLisp式を評価します。 ‘loadfile’は、‘file_search’を
     呼び出しません。 だから、‘filename’はファイル拡張子とファイルを見つ
     けるのに必要なパスも含まなければいけません。

     ‘loadfile’は、‘*note save::’, ‘*note translate_file::’, ‘*note
     compile_file::’によって生成されたファイルを処理できます。 ユーザー
     は、‘loadfile’の代わりに‘*note load::’を使うほうが便利だと気づくで
     しょう。

 -- オプション変数: loadprint
     デフォルト値: ‘true’

     ‘loadprint’は、ファイルがロードされた時、メッセージを表示するかどう
     か告げます。

        • ‘loadprint’が‘true’の時, いつもメッセージを表示します。
        • ‘loadprint’が‘'loadfile’の時, ファイルが関数‘loadfile’によって
          ロードされた時だけメッセージを表示します。
        • ‘loadprint’が‘'autoload’の時、 ファイルが自動的にロードされた
          時だけメッセージを表示します。 ‘*note setup_autoload::’を参照
          してください。
        • ‘loadprint’が‘false’の時, メッセージは決して表示されません。

 -- オプション変数: packagefile
     デフォルト値: ‘false’

     他の人が使うパッケージ（ファイル）を生成するために‘*note save::’や
     ‘*note translate::’を使う パッケージデザイナは、 ファイルがロードさ
     れる時必要な場合を除いて、 Maximaの情報リスト（例えば、‘*note
     values::’, ‘*note functions::’）に情報が追加されることを抑制するた
     めに、‘packagefile: true’を設定したいかもしれません。 この方法によ
     れば、 ユーザーが自身のデータを追加した時ユーザーの方法では パッケ
     ージの中身は、得られないでしょう。 これは、起こりうる名前衝突の問題
     を解決はしないことに注意してください。 このフラグは、パッケージファ
     イルへの出力であるものに素直に影響することにも注意してください。 フ
     ラグを‘true’に設定することは、 Maxima初期化ファイルを生成するにも役
     に立ちます。

 -- 関数: 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

 -- 関数: printfile (<path>)

     <path>という名前のファイルをコンソールに表示します。 <path>は、文字
     列もしくはシンボルです; もしシンボルなら、文字列に変換されます。

     もし<path>が現在のワーキングディレクトリからアクセス可能なファイル
     名なら、 そのファイルがコンソールに表示されます。 そうでなければ、
     ‘printfile’は、 ‘*note filename_merge::’を介して‘*note
     file_search_usage::’の要素のそれぞれに <path>を追加することでファイ
     ルを見つけようとします。

     ‘printfile’は、もし<path>が存在しているファイルを示しているなら、
     <path>を返し、そうでなければ、 成功したファイル名マージの結果を返し
     ます。

 -- 関数: 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>)’によって回復できます。 ‘*note load::’を参
     照してください。

     グローバルフラグ ‘*note file_output_append::’は、 ‘save’が出力ファ
     イルに追加するか、切り詰めるか決めます。 ‘file_output_append’が
     ‘true’の時、 ‘save’は出力ファイルに追加します。 そうでなければ、
     ‘save’は出力ファイルを切り詰めます。 どちらの場合も、もしファイルが
     存在しなければ、‘save’はファイルを生成します。

     特殊形式‘save (<filename>, values, functions, labels, ...)’ は、
     ‘*note values::’, ‘*note functions::’, ‘*note labels::’, などと名付
     けられた項目を 保存します。 名前は、変数‘*note infolists::’によって
     指定された任意のものです。 ‘*note 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の現在の状態を保存します
     。 これは、自動的に定義された項目はもちろん、ユーザー定義の変数、関
     数、配列などすべてを 含みます。 保存される項目は、 もしそれらがユー
     ザーによって新しい値を割り当てられたなら、 ‘*note
     file_search_maxima::’や‘*note showtime::’のようなシステム変数を含み
     ます。 ‘*note myoptions::’を参照してください。

     ‘save’は<filename>を評価し、他の引数すべてをクォートします。

 -- 関数: stringout (<filename>, <expr_1>, <expr_2>, <expr_3>, ...)
 -- 関数: stringout (<filename>, [<m>, <n>])
 -- 関数: stringout (<filename>, input)
 -- 関数: stringout (<filename>, functions)
 -- 関数: stringout (<filename>, values)

     ‘stringout’は、 式が入力としてタイプされたのと同じ形式で、式をファ
     イルに書き込みます。 なので、ファイルは‘*note batch::’や‘*note
     demo::’コマンドの入力として使えますし、 どんな目的のためでも編集で
     きます。 ‘stringout’は、‘*note writefile::’が進行中の間に実行するこ
     とができます。

     グローバルフラグ‘*note file_output_append::’は、 ‘stringout’が出力
     ファイルに追加するか、切り詰めるか決めます。 ‘file_output_append’が
     ‘true’の時、 ‘stringout’は、出力ファイルに追加します。 そうでなけれ
     ば、‘stringout’は出力ファイルを切り詰めます。 どちらの場合も、もし
     ファイルが存在しなければ，‘stringout’はファイルを生成します。

     ‘stringout’の一般形式は、１つ以上の式の値を出力ファイルに書き込みま
     す。 もし式が変数なら、変数の値だけが書き込まれ、変数名は書き込まれ
     ないことに注意してください。 役に立つ特殊な場合として、式は、 入力
     ラベル(‘%i1’, ‘%i2’, ‘%i3’, ...)もしくは出力ラベル(‘%o1’, ‘%o2’,
     ‘%o3’, ...)でもよいです。 ）

     もし‘*note grind::’が‘true’なら、 ‘stringout’は、‘grind’フォーマッ
     トを使って出力をフォーマットします。 そうでなければ、‘string’フォー
     マットが使われます。 ‘grind’と‘string’を参照してください。

     特殊形式‘stringout (<filename>, [<m>, <n>])’は、 mからnまでの入力ラ
     ベルの値を書き込みます。

     特殊形式 ‘stringout (<filename>, input)’は、 入力ラベルすべてをファ
     イルに書き込みます。

     特殊形式‘stringout (<filename>, functions)’は、 （グローバルリスト
     ‘*note functions::’で名付けられた）ユーザー定義関数すべてをファイル
     に書き込みます。

     特殊形式‘stringout (<filename>, values)’は、 （グローバルリスト
     ‘*note values::’で名付けられた）ユーザーが割り当てた変数すべてをフ
     ァイルに書き込みます。 変数それぞれは、変数名とコロンとその値という
     割り当て文として出力されます。 ‘stringout’の一般形式は変数を割り当
     て文として出力しないことに注意してください。

 -- 関数: 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’は、最初の引数がラベルかどうか見るためにテストした後、最初の引
     数を評価します。 クォートクォート‘''’は、引数の評価を強制し、 その
     結果、テストをだめにして、ラベルを妨げます。

     ‘*note 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$$

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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>に書き込みます。 評価される式は
     出力に書き込まれません。 出力は、‘*note print::’, ‘*note
     display::’, ‘*note grind::’や他の関数によって生成されたものです。

     グローバルフラグ ‘*note file_output_append::’は、 ‘with_stdout’が出
     力ファイル<f>に追加するか切り詰めるか決めます。
     ‘file_output_append’が‘true’の時、 ‘with_stdout’は出力ファイルに追
     加します。 そうでなければ、‘with_stdout’は出力ファイルを切り詰めま
     す。 どちらの場合も、もしファイルが存在しないなら、‘with_stdout’は
     ファイルを生成します。

     ‘with_stdout’は最後の引数の値を返します。

     ‘*note 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

 -- 関数: writefile (<filename>)

     Maximaセッションのトランスクリプトを<filename>に書き込むことを開始
     します。 ユーザーとMaximaの間の対話すべてが、ちょうどコンソールに現
     れるように、このファイルに記録されます。

     トランスクリプトがコンソール出力フォーマットで出力されるので、 それ
     はMaximaに再ロードすることはできません。 最ロード可能な式を含むファ
     イルを作るには、 ‘*note save::’と‘*note stringout::’を参照してくだ
     さい。 ‘save’は、Lisp形式の式を保存する一方、‘stringout’は、
     Maxima形式 の式を保存します。

     <filename>が既に存在している時、‘writefile’の実行の効果は、 基礎と
     なるLisp実装に依存します; トランスクリプファイルは負かされるかもし
     れませんし、ファイルは追加されるかもしれません。 ‘*note
     appendfile::’は、いつもトランスクリプトファイルに追加します。

     以前の対話の表示を保存するために‘writefile’の後、 ‘*note
     playback::’を実行するのが便利かもしれません。 ‘playback’は入力と出
     力変数(‘%i1’, ‘%o1’, など)だけを表示し、 （戻り値と対照的に）関数の
     中のプリント文によって生成された任意の出力は‘playback’によって表示
     されません。

     ‘*note closefile::’は、‘writefile’や‘appendfile’が開いたトランスク
     リプトファイルを閉じます。


File: maxima.info,  Node: Polynomials,  Next: Special Functions,  Prev: File Input and Output,  Up: Top

14 Polynomials
**************

* Menu:

* Introduction to Polynomials::
* Functions and Variables for Polynomials::


File: maxima.info,  Node: Introduction to Polynomials,  Next: Functions and Variables for Polynomials,  Prev: Polynomials,  Up: Polynomials

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/が続きます。


File: maxima.info,  Node: Functions and Variables for Polynomials,  Prev: Introduction to Polynomials,  Up: Polynomials

14.2 Functions and Variables for Polynomials
============================================

 -- オプション変数: algebraic
     デフォルト値: ‘false’

     代数的整数の整理の効果が現れるようにするためには、 ‘algebraic’は
     ‘true’に設定されなければいけません。

 -- オプション変数: berlefact
     デフォルト値: ‘true’

     ‘berlefact’が‘false’の時、 Kroneckerの因数分解アルゴリズムが使われ
     ます。 そうでなければ、Berlekampのアルゴリズム―これがデフォルトです
     ーが使われます。

 -- 関数: bezout (<p1>, <p2>, <x>)

     ‘resultant’コマンドの代替。 行列を返します。 この行列の
     ‘determinant’は、望みの結果です。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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]

 -- 関数: denom (<expr>)

     有理式<expr>の分母を返します。

 -- 関数: 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’は２番目の例の主変数であることに注意してください。

 -- 関数: 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]

 -- 関数: ezgcd (<p_1>, <p_2>, <p_3>, ...)
     最初の要素が、多項式<p_1>, <p_2>, <p_3>, ...の最大公約数で、 残りの
     要素が、多項式を最大公約数で割ったものであるリストを返します。 これ
     はいつも‘ezgcd’アルゴリズムを使います。

     ‘*note gcd::’, ‘*note gcdex::’, ‘*note gcdivide::’, ‘*note
     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]

 -- オプション変数: facexpand
     デフォルト値: ‘true’

     ‘facexpand’は、‘factor’が返すこれ以上小さくできない因子が 展開され
     た形式（デフォルト）か再帰的（正規のCRE）形式かを制御します。

 -- 関数: 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)

 -- オプション変数: factorflag
     デフォルト値: ‘false’

     ‘factorflag’が‘false’の時、 有理式の整数因子の素因素分解を抑制しま
     す。

 -- 関数: 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)

 -- 関数: 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) )

 -- 関数: 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’のオーダーです。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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が要
     求されないなら、これは、時々計算のスピードを上げます。

     ‘*note ezgcd::’, ‘*note gcdex::’, ‘*note gcdivide::’, ‘*note
     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

     ‘*note ezgcd::’は 一番目の要素が多項式 <p_1>と <p_2>の最大公約数で
     、 残りの要素が最大公約数で多項式を割ったもので構成されるリストを返
     します。

          (%i6) ezgcd(p1, p2);
                              2                     3
          (%o6)           [6 x  + 13 x + 6, x + 1, x  + x]

 -- 関数: 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’は関数 ‘*note
     igcdex::’を呼び出します。

     ‘*note ezgcd::’, ‘*note gcd::’, ‘*note gcdivide::’, ‘*note
     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

 -- 関数: gcfactor (<n>)

     ガウス整数 すなわち、<a>と<b>が有理整数(元々の整数) である形式‘<a>
     + <b> %i’ の数、<n>をガウス整数上に因数分解します。 因子は、<a>と
     <b>を非負にすることによって正規化されます。

 -- 関数: 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)

 -- 関数: gfactorsum (<expr>)

     ‘factorsum’に似ていますが、 ‘factor’の代わりに‘gfactor’を適用します
     。

 -- 関数: 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

 -- オプション変数: intfaclim
     デフォルト値: true

     もし‘true’なら、 もし試し割りとPollardのロー法の後、因子が見つから
     なければ、 Maximaは、整数の素因素分解をあきらめ、素因数分解は完了し
     ません。

     ‘intfaclim’が‘false’の時、 (これは、ユーザーが明示的に‘factor’をコ
     ールした場合です） 完全な素因数分解が試みられます。 ‘divisors’,
     ‘divsum’ や‘totient’の中で因子が計算される時は、 ‘intfaclim’は
     ‘false’に設定されます

     ‘factor’への内部コールは、 ‘intfaclim’のユーザー指定の値を考慮しま
     す。 ‘intfaclim’を‘true’に設定することは、 大きな整数を素因数分解す
     るのに費やす時間を少なくするかもしれません。

 -- オプション変数: 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]

 -- 関数: lopow (<expr>, <x>)

     <expr>の中に陽に現れる<x>の最小の指数を返します。 例えば、

          (%i1) lopow ((x+y)^2 + (x+y)^a, x+y);
          (%o1)                       min(a, 2)

 -- 関数: 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

 -- オプション変数: 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’に割り当てられるの
     を許します。 それが役に立つ結果を持つかどうか明らかではありませんが
     。

 -- 関数: num (<expr>)

     もし<expr>が比なら、その分子を返します。 もし<expr>が比でないなら、
     <expr>が返されます。

     ‘num’は引数を評価します。

 -- 関数: 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

 -- 関数: polymod (<p>)
 -- 関数: polymod (<p>, <m>)

     多項式<p>を、変数‘modulus’の値である現在の法に関してモジュラー表現
     に変換します。

     ‘polymod (<p>, <m>)’は、 ‘modulus’の現在値の代わりに法<m>を使うよう
     に指定します。

     ‘modulus’を参照してください。

 -- 関数: powers (<expr>, <x>)

     <expr>に現れる<x>のべきを返します。

     ‘load ("powers")’ loads this function.

 -- 関数: 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’が返す２要素リストの最初の要素を返します。

 -- 関数: 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

 -- オプション変数: ratalgdenom
     デフォルト値: ‘true’

     ‘ratalgdenom’が‘true’の時、 根号に関する分母の有理化が有効になるこ
     とを許します。 ‘ratalgdenom’は、 標準有理式(CRE)が代数モードで使わ
     れる時だけ、効果を持ちます。

 -- 関数: 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

 -- 関数: ratdenom (<expr>)

     <expr>を標準有理式(CRE)に強制した後、<expr>の分母を返します。 戻り
     値はCREです。

     <expr>は、もしまだCREでないなら、‘rat’によってCREに強制的に変換され
     ます。 この変換は、すべての項を共通の分母上に置くことによって、
     <expr>の形式を変えます。

     ‘denom’は似ていますが、 CREではなく通常の式を返します。 また、
     ‘denom’は共通の分母上にすべての項を置こうとはしませんし、
     ‘ratdenom’によって比と見なされるいくつかの式は、‘denom’には比と見な
     されません。

 -- オプション変数: 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

 -- 関数: 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

 -- 関数: ratdisrep (<expr>)

     一般式として引数を返します。 もし<expr>が一般式なら、戻り値は引数か
     ら変わりません。

     典型的には、‘ratdisrep’は、 標準有理式(CRE)を一般式に変換するために
     コールされます。 もし「伝染」を止めたかったり、非有理文脈で有理関数
     を使いたいなら、 これは、時々便利です。

     ‘totaldisrep’も参照してください。

 -- 関数: 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

 -- オプション変数: 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’体系は互換性はなく、 同時には使えないかもしれ
     ません。

 -- 関数: ratnumer (<expr>)

     <expr>を標準有理式(CRE)に強制変換した後、その分子を返します。 戻り
     値はCREです。

     もしまだCREでないなら、<expr>は、‘rat’によってCREに強制変換されます
     。 この変換は、 共通の分母上にすべての項を置くことによって、
     <expr>の形式を変えるかもしれません。

     ‘num’は似ていますが、 CREではなく通常の式を返します。 また、‘num’は
     共通の分母上にすべての項を置こうとはしませんし、 ‘ratnumer’によって
     比と見なされるいくつかの式は、‘num’には比と見なされません。

 -- 関数: ratp (<expr>)

     もし<expr>が標準有理式(CRE)もしくは拡張CREなら、‘true’を返し、 そう
     でなければ、‘false’を返します。

     CREは、‘rat’と関連関数によって生成されます。 拡張CREは、‘taylor’と
     関連関数によって生成されます。

 -- オプション変数: ratprint
     デフォルト値: ‘true’

     ‘ratprint’が‘true’の時、 ユーザーに浮動小数点を有理数に変換したこと
     を通知するメッセージが表示されます。

 -- 関数: 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

 -- オプション変数: ratsimpexpons
     デフォルト値: ‘false’

     ‘ratsimpexpons’が‘true’の時、 式整理の間、‘ratsimp’が式の指数に適用
     されます。

 -- オプション変数: radsubstflag
     デフォルト値: ‘false’

     ‘radsubstflag’がもし ‘true’なら、 ‘ratsubst’が ‘x’に関して‘sqrt
     (x)’に ‘u’を代入するような代入をできるようにします。

 -- 関数: 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

 -- 関数: 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 ()’はリストをクリアします。

 -- オプション変数: 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)

 -- 関数: 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

 -- システム変数: ratweights
     デフォルト値: ‘[]’

     ‘ratweights’は、‘ratweight’で割り当てられた重みのリストです。 リス
     トは累積されます: ‘ratweight’のコールそれぞれは、リストに項目を追加
     します。

     ‘kill (ratweights)’と‘save (ratweights)’はともに期待通り動作します
     。

 -- オプション変数: ratwtlvl
     デフォルト値: ‘false’

     ‘ratwtlvl’は、 標準有理式(CRE)の切り詰めを制御するために、
     ‘ratweight’関数と組み合わせて使われます。 デフォルト値の‘false’では
     、切り詰めは起こりません。

 -- 関数: 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’が返す２要素リストの２番目の要素を返します。

 -- 関数: 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’と同じ引数を取り、 行列を返します。 戻り
     値の判別式は望みの終結式です。

 -- オプション変数: savefactors
     デフォルト値: ‘false’

     ‘savefactors’が‘true’の時、 同じ因子のいくつかを含む式の因数分解を
     後でする時にスピードアップするために、 因子の積である式の因子がある
     関数によって保存されるようにします。

 -- 関数: showratvars (<expr>)
     式‘expr’の中の標準有理式 (CRE)変数のリストを返します。

     ‘ratvars’も参照してください。

 -- 関数: 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)

 -- 関数: 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]

 -- 関数: totaldisrep (<expr>)

     <expr>のすべての部分式を標準有理式(CRE)から一般形に変換して、 結果
     を返します。 もし<expr>がそれ自身CRE形なら、‘totaldisrep’は、
     ‘ratdisrep’と同一です。

     ‘totaldisrep’は、 CRE形の部分式を持つ等式やリストや行列などの式を
     ratdisrepするために役に立つかもしれません。

 -- 関数: untellrat (<x_1>, ..., <x_n>)
     <x_1>, ..., <x_n>から ‘tellrat’プロパティを 削除します。


File: maxima.info,  Node: Special Functions,  Next: Elliptic Functions,  Prev: Polynomials,  Up: Top

15 Special Functions
********************

* Menu:

* Introduction to Special Functions::
* Bessel Functions::
* Airy Functions::
* Gamma and factorial Functions::
* Exponential Integrals::
* Error Function::
* Struve Functions::
* Hypergeometric Functions::
* Parabolic Cylinder Functions::
* Functions and Variables for Special Functions::


File: maxima.info,  Node: Introduction to Special Functions,  Next: Bessel Functions,  Prev: Special Functions,  Up: Special Functions

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関数


File: maxima.info,  Node: Bessel Functions,  Next: Airy Functions,  Prev: Introduction to Special Functions,  Up: Special Functions

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_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_i (<v>, <z>)

     次数v、独立変数zの第一種変形ベッセル関数

     ‘bessel_i’は以下のように定義されます。
                              inf
                              ====   - v - 2 k  v + 2 k
                              \     2          z
                               >    -------------------
                              /     k! gamma(v + k + 1)
                              ====
                              k = 0

     無限級数は計算には使われませんが。

 -- 関数: 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に近づく極限が取られます。

 -- 関数: 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

 -- 関数: 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’を参照してください。

 -- オプション変数: 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)

 -- 関数: 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)’を
     使って取り組むのが多分望ましいです。

 -- 関数: scaled_bessel_i0 (<z>)

     ‘scaled_bessel_i(0,z)’と同一です。

 -- 関数: scaled_bessel_i1 (<z>)

     ‘scaled_bessel_i(1,z)’と同一です。

 -- 関数: %s [<u>,<v>] (<z>)
     Lommelの小s[u,v](z)関数。 多分Gradshteyn & Ryzhik 8.570.1.


File: maxima.info,  Node: Airy Functions,  Next: Gamma and factorial Functions,  Prev: Bessel Functions,  Up: Special Functions

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_dai (<x>)
     エアリー関数Ai ‘airy_ai(x)’の導関数。

     ‘airy_ai’を参照してください。

 -- 関数: airy_bi (<x>)
     エアリー関数Bi(x)。 (A&S 10.4.3)

     導関数‘diff (airy_bi(x), x)’は‘airy_dbi(x)’です。

     ‘airy_ai’, ‘airy_dbi’を参照してください。

 -- 関数: airy_dbi (<x>)
     エアリーBi関数‘airy_bi(x)’の導関数。

     ‘airy_ai’と‘airy_bi’を参照してください。


File: maxima.info,  Node: Gamma and factorial Functions,  Next: Exponential Integrals,  Prev: Airy Functions,  Up: Special Functions

15.4 Gamma and factorial Functions
==================================

ガンマ関数と、関連したベータ、プサイ、不完全ガンマ関数は Abramowitz and
Stegun, Handbook of Mathematical Functions, Chapter 6の中で定義されてい
ます。

 -- 関数: bffac (<expr>, <n>)
     階乗（シフトガンマ）関数の多倍長浮動小数点バージョン。 ２番目の引数
     は、保持し返すディジットの数です。 少しの余分を要請するのはいい考え
     です。

 -- 関数: bfpsi (<n>, <z>, <fpprec>)
 -- 関数: bfpsi0 (<z>, <fpprec>)
     ‘bfpsi’は、実引数<z>と整数次数<n>の多ガンマ関数です。 ‘bfpsi0’はデ
     ィガンマ関数です。 ‘bfpsi0 (<z>, <fpprec>)’は‘bfpsi (0, <z>,
     <fpprec>)’と同値です。

     これらの関数は多倍長浮動小数点値を返します。 <fpprec>は戻り値の多倍
     長浮動小数点精度です。

 -- 関数: cbffac (<z>, <fpprec>)
     複素多倍長浮動小数点の階乗です。

     ‘load ("bffac")’はこの関数をロードします。

 -- 関数: 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’です。

 -- 関数: log_gamma (<z>)

     ガンマ関数の自然対数。

 -- 関数: gamma_incomplete (<a>,<z>)

     第二種不完全ガンマ関数 A&S 6.5.2:

                                        inf
                                       /
                                       [     a - 1   - t
              gamma_incomplete(a, z) = I    t      %e    dt
                                       ]
                                       /
                                        z

 -- 関数: gamma_incomplete_regularized (<a>, <z>)

     正則第二種不完全ガンマ関数 A&S 6.5.1:

          gamma_incomplete_regularized(a, z) =
                                                  gamma_incomplete(a, z)
                                                  ----------------------
                                                         gamma(a)

 -- 関数: gamma_incomplete_generalized (<a>,<z1>,<z1> )
     一般化不完全ガンマ関数

          gamma_incomplete_generalized(a, z1, z2) =
                                                         z2
                                                        /
                                                        [    a - 1   - t
                                                        I   t      %e    dt
                                                        ]
                                                        /
                                                         z1

 -- オプション変数: gammalim
     デフォルト値: 1000000

     ‘gammalim’は、整数と有理数引数に関してガンマ関数の整理を制御します
     。 もし引数の絶対値が‘gammalim’よりも大きくないなら、 整理が行われ
     ます。 ‘factlim’スイッチは、 整数引数の‘gamma’の結果の整理を制御し
     ます。 ‘factlim’スイッチは、 整数引数の‘gamma’の結果の整理も制御す
     ることに注意してください。

 -- 関数: makegamma (<expr>)
     <expr>の中の２項、階乗、ベータ関数のインスタンスをガンマ関数に変換
     します。

     ‘makefact’も参照してください。

 -- 関数: 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

 -- 関数: 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)

 -- 関数: 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

 -- 関数: 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)

 -- オプション変数: beta_expand
     デフォルト値: false

     ‘beta_expand’が‘true’の時、 a+nやa-nのような引数に対して
     ‘beta(a,b)’ と、関連した関数は展開されます。 ここでnは整数です。

 -- オプション変数: beta_args_sum_to_integer
     デフォルト値: false

     ‘beta_args_sum_to_integer’が‘true’の時、 引数<a>と<b>の和が整数の時
     、 Maximaは‘beta(a,b)’を整理します。

 -- 関数: 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’は数値を計算できます。

 -- オプション変数: maxpsiposint
     デフォルト値: 20

     ‘maxpsiposint’は、 ‘psi[n](x)’が厳密な値を計算しようとする 最も大き
     な正の値です。

 -- オプション変数: maxpsinegint
     デフォルト値: -10

     ‘maxpsinegint’ ‘psi[n](x)’が厳密な値を計算しようとする 最も大きな負
     の値です。 従って、もし <x>が‘maxnegint’よりも小さければ、 たとえ可
     能でも、 ‘psi[n](<x>)’は整理された答えを返しません。

 -- オプション変数: maxpsifracnum
     デフォルト値: 6

     <x>を１より小さい、形式‘p/q’の有理数とします。 もし‘p’が
     ‘maxpsifracnum’より大きいなら ‘psi[<n>](<x>)’は、 整理された値を返
     そうとしません。

 -- オプション変数: maxpsifracdenom
     デフォルト値: 6

     <x>を１より小さい、形式‘p/q’の有理数とします。 もし‘q’が
     ‘maxpsifracdenom’より大きいなら ‘psi[<n>](<x>)’は、 整理された値を
     返そうとしません。

 -- 関数: makefact (<expr>)
     <expr>の中の二項、ガンマ、ベータ関数のインスタンスを階乗に変換しま
     す。

     ‘makegamma’も参照してください。

 -- 関数: numfactor (<expr>)
     式<expr>を掛ける数値因子を返します。 式<expr>は単一項でなければいけ
     ません。

     ‘content’は、輪の中のすべての項の最大公約数を返します。

          (%i1) gamma (7/2);
                                    15 sqrt(%pi)
          (%o1)                     ------------
                                         8
          (%i2) numfactor (%);
                                         15
          (%o2)                          --
                                         8


File: maxima.info,  Node: Exponential Integrals,  Next: Error Function,  Prev: Gamma and factorial Functions,  Up: Special Functions

15.5 Exponential Integrals
==========================

指数積分と、関連した関数は、 Abramowitz and Stegun, Handbook of
Mathematical Functions, 5章の中で定義されています。

 -- 関数: expintegral_e1 (<z>)
     指数積分E1(z) (A&S 5.1.1)

 -- 関数: expintegral_ei (<z>)
     指数積分Ei(z) (A&S 5.1.2)

 -- 関数: expintegral_li (<z>)
     指数積分Li(z) (A&S 5.1.3)

 -- 関数: expintegral_e (<n>,<z>)
     指数積分 En(z) (A&S 5.1.4)

 -- 関数: expintegral_si (<z>)
     指数積分 Si(z) (A&S 5.2.1)

 -- 関数: expintegral_ci (<z>)
     指数積分 Ci(z) (A&S 5.2.2)

 -- 関数: expintegral_shi (<z>)
     指数積分 Shi(z) (A&S 5.2.3)

 -- 関数: expintegral_chi (<z>)
     指数積分 Chi(z) (A&S 5.2.4)

 -- オプション変数: expintrep
     デフォルト値: false

     指数積分の表現を、 gamma_incomplete, expintegral_e1,
     expintegral_ei, expintegral_li, expintegral_trig, expintegral_hyp に
     変えます。

 -- オプション変数: expintexpand
     デフォルト値: false

     Expand the Exponential Integral 半整数値の指数積分E[n](z)をErfcもし
     くはErfの項で展開し、 整数値のそれをEiの項で展開します。


File: maxima.info,  Node: Error Function,  Next: Struve Functions,  Prev: Exponential Integrals,  Up: Special Functions

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’.

 -- 関数: erfc (<z>)
     相補誤差関数erfc(z) (A&S 7.1.2)

     ‘erfc(z) = 1-erf(z)’

 -- 関数: erfi (<z>)
     虚数誤差関数

     ‘erfi(z) = -%i*erf(%i*z)’

 -- 関数: erf_generalized (<z1>,<z2>)
     一般化誤差関数Erf(z1,z2)

 -- 関数: 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’を参照し
     てください。

 -- 関数: 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’を参照し
     てください。

 -- オプション変数: erf_representation
     デフォルト値: false

     ‘true’の時、 erfc, erfi, erf_generalized, fresnel_s, fresnel_c は、
     erfに変換されます。

 -- オプション変数: hypergeometric_representation
     デフォルト値: false

     fresnel_sとfresnel_cに関して超幾何表現への変換を可能にします。


File: maxima.info,  Node: Struve Functions,  Next: Hypergeometric Functions,  Prev: Error Function,  Up: Special Functions

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)

 -- 関数: struve_l (<v>, <z>)
     次数v、独立変数zの変形シュトルーベ関数L (A&S 12.2.1)


File: maxima.info,  Node: Hypergeometric Functions,  Next: Parabolic Cylinder Functions,  Prev: Struve Functions,  Up: Special Functions

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)

 -- 関数: %w [<k>,<u>] (<z>)
     Whittaker W関数 (A&S 13.1.33)

 -- 関数: %f [<p>,<q>] (<[a],[b],z>)
     pFq(a1,a2,..ap;b1,b2,..bq;z)超幾何関数。 ここで、‘a’は長さ‘p’のリス
     トで、 ‘b’は長さ‘q’のリストです。

 -- 関数: 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


File: maxima.info,  Node: Parabolic Cylinder Functions,  Next: Functions and Variables for Special Functions,  Prev: Hypergeometric Functions,  Up: Special Functions

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)


File: maxima.info,  Node: Functions and Variables for Special Functions,  Prev: Parabolic Cylinder Functions,  Up: Special Functions

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

 -- 関数: 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))’の解。

 -- 関数: nzeta (<z>)
     プラズマ分散関数 ‘nzeta(z) = %i*sqrt(%pi)*exp(-z^2)*(1-erf(-%i*z))’

 -- 関数: nzetar (<z>)
     ‘realpart(nzeta(z))’を返します。

 -- 関数: nzetai (<z>)
     ‘imagpart(nzeta(z))’を返します。


File: maxima.info,  Node: Elliptic Functions,  Next: Limits,  Prev: Special Functions,  Up: Top

16 Elliptic Functions
*********************

* Menu:

* Introduction to Elliptic Functions and Integrals::
* Functions and Variables for Elliptic Functions::
* Functions and Variables for Elliptic Integrals::


File: maxima.info,  Node: Introduction to Elliptic Functions and Integrals,  Next: Functions and Variables for Elliptic Functions,  Up: Top

16.1 Introduction to Elliptic Functions and Integrals
=====================================================

Maximaは、Jacobiの楕円関数と不完全楕円積分のサポートを含みます。 これは
、数値評価はもちろんこれらの関数のシンボル操作を含みます。 これらの関数
の定義と、プロパティの多くは Abramowitz and Stegun, 16-17章にあります。
可能な限り、そこれで与えられた定義と関係を使います。

   特に、すべての楕円関数と積分は、 法kや率角\alphaの代わりにパラメータ
mを使います。

   これは、 楕円関数のために率角を使うAbramowitz and Stegunと違っている
ところです。 以下の関係は真です: m = k^2 and k = \sin(\alpha)

   楕円関数と積分は、主としてシンボル計算をサポートするように意図されて
います。 それ故に、関数と積分の導関数のほとんどが知られています。 しかし
ながら、もし浮動小数点値が与えられたなら、 浮動小数点の結果が返されます
。

   楕円関数と積分の他の性質のほとんどのサポートはまだ書かれていません。

   楕円関数のいくつかの例:
     (%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)の条件のもと置かれています。


File: maxima.info,  Node: Functions and Variables for Elliptic Functions,  Next: Functions and Variables for Elliptic Integrals,  Prev: Introduction to Elliptic Functions and Integrals,  Up: Top

16.2 Functions and Variables for Elliptic Functions
===================================================

 -- 関数: jacobi_sn (<u>, <m>)
     Jacobiの楕円関数sn(u,m)

 -- 関数: jacobi_cn (<u>, <m>)
     Jacobiの楕円関数cn(u,m).

 -- 関数: jacobi_dn (<u>, <m>)
     Jacobiの楕円関数dn(u,m).

 -- 関数: jacobi_ns (<u>, <m>)
     Jacobiの楕円関数ns(u,m) = 1/sn(u,m).

 -- 関数: jacobi_sc (<u>, <m>)
     Jacobiの楕円関数sc(u,m) = sn(u,m)/cn(u,m).

 -- 関数: jacobi_sd (<u>, <m>)
     Jacobiの楕円関数sd(u,m) = sn(u,m)/dn(u,m).

 -- 関数: jacobi_nc (<u>, <m>)
     Jacobiの楕円関数nc(u,m) = 1/cn(u,m).

 -- 関数: jacobi_cs (<u>, <m>)
     Jacobiの楕円関数cs(u,m) = cn(u,m)/sn(u,m).

 -- 関数: jacobi_cd (<u>, <m>)
     Jacobiの楕円関数cd(u,m) = cn(u,m)/dn(u,m).

 -- 関数: jacobi_nd (<u>, <m>)
     Jacobiの楕円関数nc(u,m) = 1/cn(u,m).

 -- 関数: jacobi_ds (<u>, <m>)
     Jacobiの楕円関数ds(u,m) = dn(u,m)/sn(u,m).

 -- 関数: jacobi_dc (<u>, <m>)
     Jacobiの楕円関数dc(u,m) = dn(u,m)/cn(u,m).

 -- 関数: inverse_jacobi_sn (<u>, <m>)
     Jacobiの楕円関数の逆関数sn(u,m).

 -- 関数: inverse_jacobi_cn (<u>, <m>)
     Jacobiの楕円関数の逆関数cn(u,m).

 -- 関数: inverse_jacobi_dn (<u>, <m>)
     Jacobiの楕円関数の逆関数dn(u,m).

 -- 関数: inverse_jacobi_ns (<u>, <m>)
     Jacobiの楕円関数の逆関数ns(u,m).

 -- 関数: inverse_jacobi_sc (<u>, <m>)
     Jacobiの楕円関数の逆関数sc(u,m).

 -- 関数: inverse_jacobi_sd (<u>, <m>)
     Jacobiの楕円関数の逆関数sd(u,m).

 -- 関数: inverse_jacobi_nc (<u>, <m>)
     Jacobiの楕円関数の逆関数nc(u,m).

 -- 関数: inverse_jacobi_cs (<u>, <m>)
     Jacobiの楕円関数の逆関数cs(u,m).

 -- 関数: inverse_jacobi_cd (<u>, <m>)
     Jacobiの楕円関数の逆関数cd(u,m).

 -- 関数: inverse_jacobi_nd (<u>, <m>)
     Jacobiの楕円関数の逆関数nc(u,m).

 -- 関数: inverse_jacobi_ds (<u>, <m>)
     Jacobiの楕円関数の逆関数ds(u,m).

 -- 関数: inverse_jacobi_dc (<u>, <m>)
     Jacobiの楕円関数の逆関数dc(u,m).


File: maxima.info,  Node: Functions and Variables for Elliptic Integrals,  Prev: Functions and Variables for Elliptic Functions,  Up: Top

16.3 Functions and Variables for Elliptic Integrals
===================================================

 -- 関数: elliptic_f (<phi>, <m>)
     以下のように定義された第一種不完全楕円積分

     integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi)

     *note elliptic_e::と*note elliptic_kc::も参照してください。

 -- 関数: elliptic_e (<phi>, <m>)
     以下のように定義された第二種不完全楕円積分

     elliptic_e(phi, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi)

     *note elliptic_e::と*note elliptic_ec::も参照してください。

 -- 関数: 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と関連付けられます。

     *note elliptic_e::も参照してください。

 -- 関数: elliptic_pi (<n>, <phi>, <m>)
     以下のように定義された第三種不完全楕円積分

     integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi)

     Maximaが知っているphiに関する唯一の導関数

 -- 関数: elliptic_kc (<m>)
     以下のように定義された第一種完全楕円積分

     integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2)

     mのある値に関して 積分の値はGamma関数で表されることが知られています
     。 それらを評価するには‘makegamma’を使ってください。

 -- 関数: elliptic_ec (<m>)
     以下のように定義された第二種完全楕円積分

     integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2)

     mのある値に関して 積分の値はGamma関数で表されることが知られています
     。 それらを評価するには‘makegamma’を使ってください。


File: maxima.info,  Node: Limits,  Next: Differentiation,  Prev: Elliptic Functions,  Up: Top

17 Limits
*********

* Menu:

* Functions and Variables for Limits::


File: maxima.info,  Node: Functions and Variables for Limits,  Prev: Limits,  Up: Limits

17.1 Functions and Variables for Limits
=======================================

 -- オプション変数: lhospitallim
     Default: 4

     ‘lhospitallim’は、 ‘limit’の中で使われるロピタルの規則の回数の最大
     数です。 これは ‘limit (cot(x)/csc(x), x, 0)’のような場合の 無限ル
     ープを防ぎます。

 -- 関数: 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を参照
     してください。

 -- オプション変数: limsubst
     デフォルト値: ‘false’ - ‘limit’が未知の形式の上の代入を試みることを
     防ぎます。

     これは、1を与える‘limit (f(n)/f(n+1), n, inf)’のようなバグを避ける
     ためです。 ‘limsubst’を‘true’に設定することはそんな代入を許します。
     ‘limit’が未知の形式上で代入をしようとするのを防ぎます。

 -- 関数: tlimit (<expr>, <x>, <val>, <dir>)
 -- 関数: tlimit (<expr>, <x>, <val>)
 -- 関数: tlimit (<expr>)

     ‘expr’の‘x’に関する‘val’ でのテイラー級数展開の方向‘dir’からの極限
     を取ります。

 -- オプション変数: tlimswitch
     デフォルト値: ‘true’

     ‘tlimswitch’が‘true’の時、 ‘limit’コマンドは もし入力式が直接計算で
     きないなら、 テイラー級数展開を使います。 これは、
     ‘limit(x/(x-1)-1/log(x),x,1,plus)’のような 極限の評価を許します。
     ‘tlimswitch’が‘false’で、 入力式の極限は直接には計算できない時は、
     ‘limit’は、未評価の極限式を返します。


File: maxima.info,  Node: Differentiation,  Next: Integration,  Prev: Limits,  Up: Top

18 Differentiation
******************

* Menu:

* Functions and Variables for Differentiation::


File: maxima.info,  Node: Functions and Variables for Differentiation,  Prev: Differentiation,  Up: Differentiation

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
                            /

 -- 関数: 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
                            /

 -- 関数: 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

 -- Property: atomgrad

     ‘atomgrad’は、式のアトムのグラディエントプロパティです。 このプロパ
     ティは‘gradef’で割り当てられます。

 -- 関数: 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’はatvalue<c>を返します。

     例:

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

 -- 関数: cartan

     微分形式の外積代数は エリーカルタンによって開発された微分幾何の基本
     ツールであり、 偏微分方程式論での有用な応用を持ちます。 ‘cartan’パ
     ッケージは、 演算子‘~’ (ウェッジ積)と‘|’ (形式のベクトルとの縮約)と
     一緒に、 関数‘ext_diff’と‘lie_diff’を実装します。 例と一緒にこれら
     のコマンドの簡潔な記述を見るには、‘demo (tensor)’を実行してください
     。

     ‘cartan’は、F.B. EstabrookとH.D. Wahlquistによって実装されました。

 -- 関数: 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)

 -- 関数: 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

 -- システム変数: dependencies
     デフォルト値: ‘[]’

     ‘dependencies’は、 ‘depends’や‘gradef’によって割り当てられた、関数
     依存を持つアトムのリストです。 ‘dependencies’リストは累積的です:
     each call to ‘depends’や‘gradef’のコールそれぞれは、上乗せの項目を
     追加します。

     ‘depends’と‘gradef’を参照してください。

 -- 関数: 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

 -- オプション変数: derivabbrev
     デフォルト値: ‘false’

     ‘derivabbrev’が‘true’の時、 シンボリックな導関数(すなわち、‘diff’名
     詞)が下付き添字として表示されます。 そうでなければ、導関数はライプ
     ニッツ表記‘dy/dx’で表示されます。

 -- 関数: 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

 -- 関数: derivlist (<var_1>, ..., <var_k>)

     ‘ev’コマンド内にて、指摘された変数に関する微分のみを起こします。

 -- オプション変数: derivsubst
     デフォルト値: ‘false’

     ‘derivsubst’が‘true’の時、 ‘subst (x, 'diff (y, t), 'diff (y, t,
     2))’ のような非構文法的代入は‘'diff (x, t)’をもらします。

 -- 関数: 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)のように扱われます。

 -- 特殊シンボル: diff

     ‘ev’コールの中で、‘evflag’として‘diff’が存在する時、 ‘expr’の中で表
     現されたすべての微分は実行されます。

 -- 関数: dscalar (<f>)

     スカラーのダランベルシアンをスカラー関数に<f>に適用します。

     ‘load ("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]

 -- 関数: 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>)’は、
     ‘d<f>/d<x_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’によって定義されたいかなる変数も含み
     ません。

     例えば、関数が陽に知られていないが、一階微分が知られていて、 高階の
     微分を得ることが望まれる時、勾配が必要です。

 -- システム変数: gradefs
     デフォルト値: ‘[]’

     ‘gradefs’は、偏微分が‘gradef’によって定義された 関数のリストです。
     ‘gradefs’は、 偏微分が‘gradef’によって定義されたいかなる変数も含み
     ません。

 -- 関数: 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)


File: maxima.info,  Node: Integration,  Next: Equations,  Prev: Differentiation,  Up: Top

19 Integration
**************

* Menu:

* Introduction to Integration::
* Functions and Variables for Integration::
* Introduction to QUADPACK::
* Functions and Variables for QUADPACK::


File: maxima.info,  Node: Introduction to Integration,  Next: Functions and Variables for Integration,  Prev: Integration,  Up: Integration

19.1 Introduction to Integration
================================

Maximaは、積分を扱うためのいくつかのルーチンを持っています。
‘integrate’関数はそれらのほとんどを利用します。 指定されていない関数（と
もちろんその導関数）を扱う‘antid’パッケージもあります。 数値目的のために
は、 ‘quad_qag’, ‘quad_qags’などと名付けられたQUADPACKから適応積分器一式
があります。 それらは見出し‘QUADPACK’の下で記述されています。 超幾何関数
を扱うことができます。詳細は‘specint’を参照してください。 一般的に言って
、Maximaは 「初等関数」（有理関数、三角関数、対数、指数関数、根号など）
と２、３の拡張（誤差関数、二重対数関数）を使った積分可能な積分だけを扱い
ます。 ‘g(x)’や‘h(x)’と言った未知の関数を使った積分を扱いません。


File: maxima.info,  Node: Functions and Variables for Integration,  Next: Introduction to QUADPACK,  Prev: Introduction to Integration,  Up: Integration

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

 -- 関数: 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’のデモンストレーシ
     ョンを実行します。

 -- 関数: defint (<expr>, <x>, <a>, <b>)

     定積分を計算しようとします。 ‘integrate’は、 積分の範囲が指定されて
     いる時、 すなわち、‘integrate’が ‘integrate (<expr>, <x>, <a>,
     <b>)’としてコールされた時、 ‘defint’をコールします。

     このように、ユーザーの観点からは、‘integrate’をコールすることは十分
     です。

     ‘defint’は、シンボリック式、計算された積分または積分の名詞形、 を返
     します。 定積分の数値近似に関しては、‘quad_qag’と関連関数を参照して
     ください。

 -- オプション変数: erfflag
     デフォルト値: ‘true’

     ‘erfflag’が‘false’の時、 ‘risch’が もしまず第一に被積分になにもない
     なら、 答えの中に‘erf’関数を導入することを妨げます。

 -- 関数: 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

 -- オプション変数: 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

 -- 関数: 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

 -- システム変数: 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

 -- システム変数: 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

 -- オプション変数: 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がもっと役立つ結果を得るのを助けます。

 -- 関数: 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’は、様々な発見的方法を利用し、いくつかの特殊な場合を認識
     することもあります。

 -- 関数: 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

 -- 関数: 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)

 -- 関数: tldefint (<expr>, <x>, <a>, <b>)

     ‘tlimswitch’が‘true’に設定されている‘ldefint’と同値です。


File: maxima.info,  Node: Introduction to QUADPACK,  Next: Functions and Variables for QUADPACK,  Prev: Functions and Variables for Integration,  Up: Integration

19.3 Introduction to QUADPACK
=============================

QUADPACKは、１次元定積分の数値計算のための関数のコレクションです。 R.
Piessens (1), E. de Doncker (2), C. Ueberhuber (3), D. Kahaner (4).  の
合同プロジェクトから始まりました。

   Maximaに含まれるQUADPACKライブラリは、 SLATEC共通数学ライブラリ バー
ジョン4.1(5) に現れる 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積分が使われます。

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


File: maxima.info,  Node: Functions and Variables for QUADPACK,  Prev: Introduction to QUADPACK,  Up: Integration

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

 -- 関数: 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’よりも精確で 効率的で
     あることに注意してください。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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


File: maxima.info,  Node: Equations,  Next: Differential Equations,  Prev: Integration,  Up: Top

20 Equations
************

* Menu:

* Functions and Variables for Equations::


File: maxima.info,  Node: Functions and Variables for Equations,  Prev: Equations,  Up: Equations

20.1 Functions and Variables for Equations
==========================================

 -- システム変数: %rnum_list
     デフォルト値: ‘[]’

     ‘%rnum_list’は、 ‘*note solve::’や‘*note 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

 -- オプション変数: algepsilon
     デフォルト値: 10^8

     ‘algsys’が ‘*note algepsilon::’を使います。

 -- オプション変数: algexact
     デフォルト値: ‘false’

     ‘algexact’は、以下のように‘*note algsys::’の振る舞いに影響を与えま
     す:

     もし‘algexact’が‘true’なら、 ‘algsys’はいつも‘*note solve::’をコー
     ルし、 ‘solve’の失敗時には‘*note realroots::’を使います。

     もし‘algexact’が‘false’なら、 問題が１変数でないときだけ、 もしくは
     、方程式が二次もしくは四次なら ‘solve’がコールされます。

     このように、‘algexact: true’は、 厳密解だけを保証せず、ただ、
     ‘algsys’は最初に厳密解を与えるように最大限努力して、 他のすべてが失
     敗した時近似をもたらすことだけを保証します。

 -- 関数: 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’, ..., が、解の任意パラメータを表すために、必要
     に応じて導入されます; これらの変数は、リスト ‘*note %rnum_list::’に
     も追加されます。

     方法は以下の通りです:

       1. 最初に、方程式は因数分解され、サブシステムに分割されます。

       2. それぞれのサブシステム<S_i>に関して、等式<E>と変数<x>が選択さ
          れます。 変数はゼロでない最低次を持つよう選ばれます。 そして、
          <x>に関する<E>と<E_j>の終結式が サブシステム<S_i>の中の残って
          いる等式群<E_j>のそれぞれに関して計算されます。

          これは、<x>が消去されるので、 １つ変数の少ない新しいサブシステ
          ム<S_i'>をもたらします ここでプロセスは(1)に戻ります。

       3. いつか、１つの等式から成るサブシステムが得られます。 もし等式
          が多変数なら、浮動小数点数の形式の近似は導入されず、 厳密解を
          見つけるために‘*note solve::’がコールされます。

          いくつかの場合、‘solve’は解を見つけることができないか、 もし見
          つけたら、絵が非常に大きな式になるかもしれません。

          もし等式が１変数で、線形か二次か四次なら、 もし近似が導入され
          ないなら、再び‘solve’がコールされます。 もし近似が導入されるか
          、等式が１変数でなく、線形でも二次でも、四次でもないなら、 も
          しスイッチ‘*note realonly::’が‘true’なら、 実数解を見つけるた
          め関数‘*note realroots::’がコールされます。 もし‘realonly’が
          ‘false’なら、 実数解と複素数解を探す‘*note allroots::’がコール
          されます。

          もし‘algsys’が 要求よりも有効数字が少ない解を生成するなら、 ユ
          ーザーは‘*note algepsilon::’の値をより高い値に変更できます。

          もし‘algexact’が‘true’に設定されているなら、 いつも‘solve’がコ
          ールされます。

       4. 最終的に、ステップ(3)で得られた解は以前のレベルに代入され、解
          処理は(1)に戻ります。

     ‘algsys’が（通常、初期の段階での厳密解発見の失敗による）浮動小数点
     近似を含む多変数方程式に出会う時、 厳密な方法をそんな方程式に適用し
     ようとせず、かわりにメッセージを表示します: "‘algsys’ cannot solve
     - system too complicated."

     ‘*note radcan::’との対話は、多きなもしくは複雑な式を生成することが
     できます。 この場合、‘*note pickapart::’または ‘*note 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

 -- 関数: allroots (<expr>)
 -- 関数: allroots (<eqn>)

     1変数多項式<expr>もしくは1変数多項式方程式<eqn>の実数と複素数の根の
     数値近似を 計算する。

     フラグ‘*note 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)

 -- 関数: bfallroots (<expr>)
 -- 関数: bfallroots (<eqn>)

     １変数の多項式<expr>または多項式等式<eqn>の実数根と複素数根の数値近
     似 を計算します。

     ‘bfallroots’は多倍長浮動小数点を使って根を計算する以外の すべての点
     で、‘bfallroots’は‘allroots’と同一です。 詳しい情報については‘*note
     allroots::’を参照してください。

 -- オプション変数: backsubst
     デフォルト値: ‘true’

     ‘backsubst’が‘false’の時、 方程式が三角行列化された後、‘*note
     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]

 -- オプション変数: breakup
     デフォルト値: ‘true’

     ‘breakup’が‘true’の時、 ‘*note solve::’は、三次と四次の方程式の解を
     共通部分式を使って表現します。 共通部分式は、中間式ラベル(‘%t1’,
     ‘%t2’, など)に割り当てられます。 そうでなければ、共通部分式は同定さ
     れません。

     ‘breakup: true’は、 ‘*note 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]

 -- 関数: dimension (<eqn>)
 -- 関数: dimension (<eqn_1>, ..., <eqn_n>)

     ‘dimen’は、次元解析パッケージです。 ‘load ("dimen")’はこのパッケー
     ジをロードします。 ‘demo ("dimen")’は短いデモンストレーションを表示
     します。

 -- オプション変数: dispflag
     デフォルト値: ‘true’

     もし‘block’内で‘false’に設定されたら ‘block’内でコールされた解法関
     数が生成する出力の表示を抑制します。 ‘block’をドル記号$で終端すると
     、 ‘dispflag’を‘false’に設定します。

 -- 関数: 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)

     警告: これはとても未熟な実装です - 多くの安全性チェックや 明らかな
     一般化が忘れられています。

 -- オプション変数: globalsolve
     デフォルト値: ‘false’

     ‘globalsolve’が‘true’の時、 ２つ以上の線形方程式を解く時、 解くべき
     変数が、‘linsolve’や‘*note solve::’が見つけた解の値に割り当てられま
     す。

     ‘globalsolve’が‘false’の時、 ２つ以上の線形方程式を解く時、 ‘*note
     linsolve::’や‘solve’が見つけた解は、 等式として表現され、 解くべき
     変数は割り当てられません。

     ２つ以上の線形方程式以外の何かを解く時には、 ‘solve’は
     ‘globalsolve’を無視します。 方程式を解く他の関数(例えば‘*note
     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

 -- 関数: 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’

 -- オプション変数: ieqnprint
     デフォルト値: ‘true’

     ‘ieqnprint’は、‘ieqn’コマンドが返す結果の振る舞いを決めます。
     ‘ieqnprint’が‘false’の時、 ‘*note ieqn::’関数が返すリストは、形式

     [<solution>, <technique used>, <nterms>, <flag>]

     を取ります。

     ここで、もし解が厳密なら<flag>はありません。

     そうでなければ、厳密でない解か閉じていない形の解かに対応して、それ
     ぞれ、単語‘approximate’または‘incomplete’です。 もし級数法が使われ
     たら、 <nterms>は、取った項の数を与えます。 （項の数は、もしエラー
     が更なる項の生成を防いだなら、‘ieqn’に与えられたnよりも小さいことも
     あり得ます。）

 -- 関数: lhs (<expr>)

     <expr>の演算子が関係演算子‘< <= = # equal notequal >= >’の１つ、 割
     り当て演算子‘:= ::= : ::’の１つ、 または‘*note infix::’で宣言された
     ユーザー定義の二項中置演算子の時、 式<expr>の左辺(すなわち、最初の
     項) を返します。

     <expr>がアトムか、演算子が上で記載したもの以外の何かの時、 ‘lhs’は
     <expr>を返します。

     ‘*note 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

 -- 関数: linsolve ([<expr_1>, ..., <expr_m>], [<x_1>, ..., <x_n>])

     変数のリストに関して同時線形方程式のリストを解きます。 それぞれの式
     は変数に関する多項式でなければならず、等式も取り得ます。

     ‘*note globalsolve::’が‘true’の時、 解くべき変数それぞれは、方程式
     の解の値にバインドされます。

     ‘*note backsubst::’が‘false’の時、 ‘linsolve’は、方程式が三角行列化
     された後、後退代入を実行しません。 これは、後退代入が極端に大きな式
     の生成の原因となる非常に大きな問題に関して 必要とされるかもしれませ
     ん。

     ‘*note linsolve_params::’が‘true’の時、 ‘linsolve’は ‘*note
     algsys::’の下のマニュアルの中で記述された任意のパラメータを表すのに
     使われる ‘%r’シンボルも生成します。 そうでなければ、 ‘linsolve’は、
     他を使って表現されたいくつかの変数を持つ 決定中の方程式系を解きます
     。

     ‘*note 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]

 -- オプション変数: linsolvewarn
     デフォルト値: ‘true’

     ‘linsolvewarn’が‘true’の時、 ‘linsolve’はメッセージ"Dependent
     equations eliminated"を表示します。

 -- オプション変数: linsolve_params
     デフォルト値: ‘true’

     ‘linsolve_params’が‘true’の時、 ‘*note linsolve::’は、 ‘*note
     algsys::’の下のマニュアルに記述された任意のパラメータを表すのに使わ
     れる‘%r’シンボルも生成します。 それでなければ、‘linsolve’は、 他を
     使って表現されたいくつかの変数を使った 決定中の方程式系を解きます。

 -- システム変数: multiplicities
     デフォルト値: ‘not_set_yet’

     ‘multiplicities’は、 ‘*note solve::’や‘*note realroots::’が返す個々
     の解の多様性のリストに設定されます。

 -- 関数: 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

 -- 関数: nthroot (<p>, <n>)
     pは整数係数多項式で、 nは正の整数ですが、 q^n=pのような整数上の多項
     式qを返すか、 pが完全なn番目のべきでないことを示すエラーメッセージ
     を表示します。 このルーチンは、‘*note factor::’より、また‘*note
     sqfr::’よりさえもっと速いです。

 -- オプション変数: polyfactor
     デフォルト値: ‘false’

     オプション変数‘polyfactor’が‘true’の時、 ‘*note allroots::’と‘*note
     bfallroots::’は もし多項式が実数なら実数上で、もし多項式が複素数な
     ら複素数上で多項式を因数分解します。

     例は‘allroots’を参照してください。

 -- オプション変数: programmode
     デフォルト値: ‘true’

     ‘programmode’が‘true’の時、 ‘*note solve::’, ‘*note realroots::’,
     ‘*note allroots::’, ‘*note linsolve::’は、 リストの中の要素として解
     を返します。 (‘*note backsubst::’が‘false’設定されている時― その場
     合、‘programmode: false’が仮定されます―を除いて)

     ‘programmode’が‘false’の時、 ‘solve’などは、中間式ラベル‘%t1’,
     ‘t2’など生成し、 解をそれらに割り当てます。

 -- オプション変数: realonly
     デフォルト値: ‘false’

     ‘realonly’が‘true’の時、 ‘*note algsys::’は、 ‘%i’を含まないそれら
     の解だけを返します。

 -- 関数: realroots (<expr>, <bound>)
 -- 関数: realroots (<eqn>, <bound>)
 -- 関数: realroots (<expr>)
 -- 関数: realroots (<eqn>)

     変数多項式<expr>もしくは1変数多項方程式<eqn>の実根の有理近似を、
     ‘bound’の許容誤差の範囲内で計算します。 <expr>もしくは<eqn>の係数は
     リテラル数でなければなりません。 ‘%pi’のようなシンボル定数は却下さ
     れます。

     ‘realroots’は、みつけた根の多様性を グローバル変数‘*note
     multiplicities::’に割り当てます。

     ‘realroots’は、それぞれの根を囲むためSturm列を構成し、 近似を精密化
     するため二分法を適用します。 根を探索する前に、すべての係数は同値の
     有理数に変換され、 正確な有理算術によって計算が実行されます。 たと
     え係数が浮動小数点でも、 （‘*note float::’もしくは‘*note numer::’フ
     ラグによって浮動小数点が強要されない限り）結果は有理数です。

     <bound>が1よりも小さい時、全ての整数根は正確に計算されます。
     <bound>がしてされない時、グローバル変数‘*note rootsepsilon::’と等し
     いと仮定されます。

     グローバル変数‘*note 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]

 -- 関数: rhs (<expr>)

     <expr>の演算子が関係演算子‘< <= = # equal notequal >= >’の１つ、 割
     り当て演算子‘:= ::= : ::’の１つ、または、 ‘*note infix::’で宣言され
     たユーザー定義の二項中置演算子の時 式<expr>の右辺(すなわち、二番目
     の項)を返します。

     <expr>がアトムか、演算子が上で記載したもの以外の何かの時、 ‘rhs’は
     <expr>を返します。

     ‘*note 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

 -- オプション変数: rootsconmode
     デフォルト値: ‘true’

     ‘rootsconmode’は、‘rootscontract’コマンドの振る舞いを決定します。 詳
     細は‘*note rootscontract::’を参照してください。

 -- 関数: rootscontract (<expr>)

     根の積を積の根に変換します。 例えば、 ‘rootscontract
     (sqrt(x)*y^(3/2))’は‘sqrt(x*y^3)’をもたらします。

     ‘*note radexpand::’が‘true’かつ‘*note domain::’が‘real’の時、
     ‘rootscontract’は、 converts ‘*note abs::’を‘*note sqrt::’に変換し
     ます。 例えば、‘rootscontract (abs(x)*sqrt(y))’は‘sqrt(x^2*y)’をも
     たらします。

     以下のように‘*note 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’は、 ‘*note logcontract::’と似た方法で、‘*note
     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

 -- オプション変数: rootsepsilon
     デフォルト値: 1.0e-7

     ‘rootsepsilon’は、 ‘*note realroots::’関数が見つけた根に関する信頼
     区間を確立する許容誤差です。

 -- 関数: 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>について解かれます。

     ‘*note breakup::’が‘false’なら、 ‘solve’は３次もしくは４次方程式の
     解を、 デフォルトであるいくつかの共通部分式から成る表現ではなく、 単
     一の式で表現されます。

     ‘multiplicities’は、‘solve’や‘*note realroots::’, ‘*note
     allroots::’が返した 多数の独立の解のリストに設定されます。 ‘slove’に
     影響するスイッチについては、‘apropos (solve)’を試してください。 も
     しスイッチの目的がはっきりしないなら、 個々のスイッチ名について
     ‘*note describe::’を使うことができます。

     ‘solve ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>])’ は、‘*note
     linsolve::’もしくは‘*note algsys::’をコールすることで， 同時（線形
     もしくは非線形）代数方程式系を解き、変数の解リストのリストを返しま
     す。 ‘linsolve’の場合、このリストは解の単一リストを含みます。 引数
     に２つのリストをとります。 最初のリストは解くべき等式を示し、２番目
     のリストは決定すべき未知数のリストです。 もし等式の変数の総数が等式
     の数に等しいなら、２番目の引数リストは省略できます。

     ‘*note programmode::’が‘false’の時、 ‘solve’は中間式(‘%t’)ラベルを
     持つ解を表示し、ラベルのリストを返します。

     ‘*note 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]]

     更に知るには、‘*note algsys::’と ‘*note %rnum_list::’.

 -- オプション変数: solvedecomposes
     デフォルト値: ‘true’

     ‘solvedecomposes’が‘true’の時、 もし多項式を解くように頼まれたなら
     、 ‘solve’は、‘*note polydecomp::’をコールします。

 -- オプション変数: solveexplicit
     デフォルト値: ‘false’

     ‘solveexplicit’が‘true’の時、 ‘*note solve::’が 陰解―すなわち、
     ‘F’がある関数である形式‘F(x) = 0’の解― を返すことを妨げます。

 -- オプション変数: solvefactors
     デフォルト値: ‘true’

     ‘solvefactors’が‘false’の時、 ‘*note solve::’は、式を因数分解しよう
     としません。 ‘false’設定は、 因数分解が不要ないくつかの場合に望まれ
     るかもしれません。

 -- オプション変数: solvenullwarn
     デフォルト値: ‘true’

     ‘solvenullwarn’が‘true’の時、 もし空の等式リストか空の変数リストを
     引数にコールされたら ‘*note solve::’は、警告メッセージを表示します
     。 例えば、‘solve ([], [])’は、２つの警告メッセージを表示し、 ‘[]’を
     返します。

 -- オプション変数: solveradcan
     デフォルト値: ‘false’

     ‘solveradcan’が‘true’の時、 ‘*note solve::’は‘radcan’をコールし、
     ‘solve’は遅くなりますが、 指数と対数を含むある問題が解けるようにな
     ります。

 -- オプション変数: solvetrigwarn
     デフォルト値: ‘true’

     ‘solvetrigwarn’が‘true’の時、 ‘*note solve::’は、 方程式を解くため
     に逆三角関数を使い、ゆえに解を失っていることを示す メッセージを表示
     するかもしれません。


File: maxima.info,  Node: Differential Equations,  Next: Numerical,  Prev: Equations,  Up: Top

21 Differential Equations
*************************

* Menu:

* Introduction to Differential Equations::
* Functions and Variables for Differential Equations::


File: maxima.info,  Node: Introduction to Differential Equations,  Next: Functions and Variables for Differential Equations,  Prev: Differential Equations,  Up: Differential Equations

21.1 Introduction to Differential Equations
===========================================

この節は、 一次と二次方程式のいくつかの特定のタイプの解析解を得るための
Maximaで利用可能な関数を 記述します。 微分方程式系の数値解を得るには、 付
加パッケージ‘dynamics’を参照してください。 位相空間でのグラフィカルな表
現に関して、 付加パッケージ‘plotdf’を参照してください。


File: maxima.info,  Node: Functions and Variables for Differential Equations,  Prev: Introduction to Differential Equations,  Up: Differential Equations

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’を参照してください。

 -- 関数: 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’を返します。

 -- 関数: ic1 (<solution>, <xval>, <yval>)
     一階微分方程式の初期値問題を解きます。 ここで、<solution>は、
     ‘ode2’が見つけるような、方程式の一般解であり、 <xval>は、独立変数の
     初期値を、形式‘<x> = <x0>’で与え、 <yval>は、従属変数の初期値を、形
     式‘<y> = <y0>’で与えます。

     用法の例については‘ode2’を参照してください。

 -- 関数: ic2 (<solution>, <xval>, <yval>, <dval>)
     二階微分方程式の初期値を解きます。 ここで、 <solution>は、‘ode2’が
     見つけるような、 方程式の一般解のであり、 <xval>は、独立変数の初期
     値を、形式‘<x> = <x0>’で与え、 <yval>は、従属変数の初期値を、形式
     ‘<y> = <y0>’で与え、 <dval>は、従属変数の独立変数に関する一階導関数
     の初期値を、 形式‘diff(<y>,<x>) = <dy0>’で、与えます。 (‘diff’はク
     ォートされる必要はありません。)

     用法の例については、‘ode2’を参照してください。

 -- 関数: 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


File: maxima.info,  Node: Numerical,  Next: Matrices and Linear Algebra,  Prev: Differential Equations,  Up: Top

22 Numerical
************

* Menu:

* Introduction to fast Fourier transform::
* Functions and Variables for fast Fourier transform::
* Introduction to Fourier series::
* Functions and Variables for Fourier series::


File: maxima.info,  Node: Introduction to fast Fourier transform,  Next: Functions and Variables for fast Fourier transform,  Prev: Numerical,  Up: Numerical

22.1 Introduction to fast Fourier transform
===========================================

‘fft’パッケージは、高速Fourier変換の（数式計算ではなく）数値計算に関する
関数を含みます。


File: maxima.info,  Node: Functions and Variables for fast Fourier transform,  Next: Introduction to Fourier series,  Prev: Introduction to fast Fourier transform,  Up: Numerical

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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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

 -- 関数: 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]

 -- オプション変数: fortindent
     デフォルト値: 0

     ‘fortindent’は、‘fortran’コマンドが表示する式の 式の左マージンイン
     デントを制御します。 0は、標準のプリントアウト(すなわち6スペース)を
     与え、 正の値は、式を更に右に印字するようにします。

 -- 関数: 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

 -- オプション変数: fortspaces
     デフォルト値: ‘false’

     ‘fortspaces’が‘true’の時、 ‘fortran’は、印字行それぞれを80カラムま
     でスペースで埋めます。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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


File: maxima.info,  Node: Introduction to Fourier series,  Next: Functions and Variables for Fourier series,  Prev: Functions and Variables for fast Fourier transform,  Up: Numerical

22.3 Introduction to Fourier series
===================================

‘fourie’パッケージは、Fourier級数のシンボル計算のための関数を含みます。

   ‘fourie’パッケージの中には Fourier積分係数を計算する関数や、式の操作
のためのいくつかの関数があります。


File: maxima.info,  Node: Functions and Variables for Fourier series,  Prev: Introduction to Fourier series,  Up: Numerical

22.4 Functions and Variables for Fourier series
===============================================

 -- 関数: equalp (<x>, <y>)

     もし‘equal (<x>, <y>)’なら、‘true’を返し、 そうでないなら、
     ‘false’を返します。 (この場合、‘equal (x, y)’がするようなエラーメッ
     セージを与えません。)

 -- 関数: remfun (<f>, <expr>)
 -- 関数: remfun (<f>, <expr>, <x>)

     ‘remfun (<f>, <expr>)’は、 <expr>の中の‘<f> (<arg>)’すべてを<arg>で
     置き換えます。

     ‘remfun (<f>, <expr>, <x>)’は、 <expr>の中の‘<f> (<arg>)’を <arg>が
     変数<x>を含むときだけ <arg>で置き換えます。

 -- 関数: funp (<f>, <expr>)
 -- 関数: funp (<f>, <expr>, <x>)

     ‘funp (<f>, <expr>)’は、 もし<expr>が関数<f>を含むなら ‘true’を返し
     ます。

     ‘funp (<f>, <expr>, <x>)’は、 もし<expr>が関数<f>を含み、変数 <x>が
     <f>のインスタンスの１つの引数のどこかにあるなら、 ‘true’を返します
     。

 -- 関数: 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>は、絶対値を含むことができます。

 -- 関数: fourier (<f>, <x>, <p>)

     区間‘[-p, p]’上で定義された‘<f>(<x>)’のFourier係数のリストを返しま
     す。

 -- 関数: foursimp (<l>)

     もし‘sinnpiflag’が‘true’なら、‘sin (n %pi)’を0に整理します。 もし
     ‘cosnpiflag’が‘true’なら、‘cos (n %pi)’を‘(-1)^n’に整理します。

 -- オプション変数: sinnpiflag
     デフォルト値: ‘true’

     ‘foursimp’を参照してください。

 -- オプション変数: cosnpiflag
     デフォルト値: ‘true’

     ‘foursimp’を参照してください。

 -- 関数: fourexpand (<l>, <x>, <p>, <limit>)

     Fourier係数<l>のリストから <limit>項までのFourier級数を構成し、返し
     ます。 (<limit>は‘inf’もあり得ます。) <x>と<p>は、‘fourier’における
     ものと同じ意味を持ちます。

 -- 関数: fourcos (<f>, <x>, <p>)

     ‘[0, <p>]’上で定義された ‘<f>(<x>)’のFourierコサイン係数を返します
     。

 -- 関数: foursin (<f>, <x>, <p>)

     ‘[0, <p>]’上で定義された ‘<f>(<x>)’のFourierサイン係数を返します。

 -- 関数: totalfourier (<f>, <x>, <p>)

     ‘fourexpand (foursimp (fourier (<f>, <x>, <p>)), <x>, <p>, 'inf)’を
     返します。

 -- 関数: fourint (<f>, <x>)

     ‘[minf, inf]’上で定義された ‘<f>(<x>)’のFourier積分係数のリストを構
     成し、返します。

 -- 関数: fourintcos (<f>, <x>)
     ‘[0, inf]’上の‘<f>(<x>)’のFourierコサイン積分係数を返します。

 -- 関数: fourintsin (<f>, <x>)
     ‘[0, inf]’上の‘<f>(<x>)’のFourierサイン積分係数を返します。


File: maxima.info,  Node: Matrices and Linear Algebra,  Next: Affine,  Prev: Numerical,  Up: Top

23 Matrices and Linear Algebra
******************************

* Menu:

* Introduction to Matrices and Linear Algebra::
* Functions and Variables for Matrices and Linear Algebra::


File: maxima.info,  Node: Introduction to Matrices and Linear Algebra,  Next: Functions and Variables for Matrices and Linear Algebra,  Prev: Matrices and Linear Algebra,  Up: Matrices and Linear Algebra

23.1 Introduction to Matrices and Linear Algebra
================================================

* Menu:

* Dot::
* Vectors::
* eigen::


File: maxima.info,  Node: Dot,  Next: Vectors,  Prev: Introduction to Matrices and Linear Algebra,  Up: Introduction to Matrices and Linear Algebra

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’です。

   ‘.’を含む式の整理を支配する いくつかのフラグがあります。 すなわち、
‘*note dot0nscsimp::’, ‘*note dot0simp::’, ‘*note dot1simp::’, ‘*note
dotassoc::’, ‘*note dotconstrules::’, ‘*note dotdistrib::’, ‘*note
dotexptsimp::’, ‘*note dotident::’, ‘*note dotscrules::’。


File: maxima.info,  Node: Vectors,  Next: eigen,  Prev: Dot,  Up: Introduction to Matrices and Linear Algebra

23.1.2 Vectors
--------------

‘vect’は、ベクトル解析のための関数のパッケージです。 ‘load ("vect")’は、
このパッケージをロードし、 ‘demo ("vect")’は、デモンストレーションを表示
します。

   ベクトル解析パッケージは、 グラディエント、ダイバージェンス、カール、
ラプラシアン演算子と一緒に、 ドット積やクロス積を含むシンボリックな式を
結合したり整理したりすることができます。 これらの演算子の和や積上の分配
は、 任意の特定の直交座標系の成分への展開を含む、様々な他の展開と同様に
、 いくつかのフラグで決定されます。 場のスカラーポテンシャルやベクトルポ
テンシャルを演繹するための関数もあります。

   The ‘vect’パッケージは以下の関数を含みます: ‘*note vectorsimp::’,
‘*note scalefactors::’, ‘*note express::’, ‘*note potential::’, ‘*note
vectorpotential::’.

   デフォルトでは、‘vect’パッケージはドット演算子‘.’を可換演算子とは宣言
しません。 可換ドット演算子‘.’を得るには、コマンド‘declare(".",
commutative)’を実行しなければいけません。


File: maxima.info,  Node: eigen,  Prev: Vectors,  Up: Introduction to Matrices and Linear Algebra

23.1.3 eigen
------------

パッケージ‘eigen’は、 固有値や固有ベクトルのシンボリックな計算に充てられ
た いくつかの関数を含みます。 もし‘eigenvalues’または‘eigenvectors’の１
つが呼び出されたなら、 Maximaは、パッケージを自動的にロードします。 パッ
ケージは‘load ("eigen")’として陽にロードすることもできます。

   ‘demo ("eigen")’は、このパッケージの能力のデモンストレーションを表示
します。 ‘batch ("eigen")’は、 連続する計算の間のユーザープロンプトなし
に、 同じデモンストレーションを実行します。

   ‘eigen’パッケージの関数は、 ‘*note innerproduct::’, ‘*note
unitvector::’, ‘*note columnvector::’, ‘*note gramschmidt::’, ‘*note
eigenvalues::’, ‘*note eigenvectors::’, ‘*note uniteigenvectors::’,
‘*note similaritytransform::’です。


File: maxima.info,  Node: Functions and Variables for Matrices and Linear Algebra,  Prev: Introduction to Matrices and Linear Algebra,  Up: Matrices and Linear Algebra

23.2 Functions and Variables for Matrices and Linear Algebra
============================================================

 -- 関数: addcol (<M>, <list_1>, ..., <list_n>)

     １つまたは複数のリスト(または行列)が与える列を 行列<M>に追加します
     。

 -- 関数: addrow (<M>, <list_1>, ..., <list_n>)

     １つまたは複数のリスト(または行列)が与える行を 行列<M>に追加します
     。

 -- 関数: adjoint (<M>)

     行列<M>の余因子行列を返します。 余因子行列は、<M>の余因子の行列の転
     置です。

 -- 関数: 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   ]

 -- 関数: 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   ]

 -- 関数: 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)

 -- 関数: 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   ]

 -- 関数: col (<M>, <i>)

     行列<M>の<i>番目の列を返します。 戻り値は行列です。

 -- 関数: 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 ]

 -- 関数: 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’を使ってコピーを生成し、割り当てを使うことは
     、 別個の変更されたコピーを生成します。

 -- 関数: determinant (<M>)

     <M>の行列式をガウスの消去法と似た方法で計算します。

     結果の形式は、スイッチ‘*note ratmx::’の設定に依ります。

     スイッチ‘ratmx’と‘*note sparse::’がともに‘true’の時コールされる 粗
     な行列式を計算するための特殊なルーチンがあります。

 -- オプション変数: detout
     デフォルト値: ‘false’

     ‘detout’が‘true’の時、 逆行列が計算された行列の行列式は、逆行列から
     因子として外に出されます。

     このスイッチが効果を持つには、 ‘*note doallmxops::’と‘*note
     doscmxops::’は、‘false’でなければいけません。 (それらの記述を参照し
     てください。) ‘ev’は他の２つを正しく設定するので、 代わりに、このス
     イッチを‘*note 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

 -- 関数: diagmatrix (<n>, <x>)

     対角要素すべてが<x>に等しい、 サイズが<n>掛ける<n>の対角線行列を返
     します。 ‘diagmatrix (<n>, 1)’は、 (‘ident (<n>)’と同じように)単位
     行列を返します。

     <n>は、整数に評価されなければいけなく、そうでなければ、
     ‘diagmatrix’はエラーメッセージを出力します。

     <x>は、別の行列を含む、任意の種類の式を取り得ます もし<x>が行列なら
     、それはコピーされません; 対角要素すべては、同じインスタンス<x>を参
     照します。

 -- オプション変数: doallmxops
     デフォルト値: ‘true’

     ‘doallmxops’が‘true’の時、 行列に関係する演算すべてが実行されます。
     ‘false’の時、 then the setting of the 個々の‘dot’スイッチの設定が、
     どの演算を実行するか決めます。

 -- オプション変数: 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)    ]

 -- オプション変数: domxmxops
     デフォルト値: ‘true’

     ‘domxmxops’が‘true’の時、 行列-行列演算、行列-リスト演算すべてが実
     行されます (しかし、スカラー-行列演算は実行されません); もしこのス
     イッチが‘false’なら、 演算は実行されません。

 -- オプション変数: domxnctimes
     デフォルト値: ‘false’

     ‘domxnctimes’が‘true’の時、 行列の非可換積が実行されます。

 -- オプション変数: dontfactor
     デフォルト値: ‘[]’

     ある変数に関する因数分解が起こらないよう、 ‘dontfactor’をその変数の
     リストに設定することができます。 (リストは初期には空です。) 標準有
     理式(CRE)形で仮定される変数順序に従って、 ‘dontfactor’リスト上のそ
     れらよりも重要でない変数に関しても 因数分解は、 行われなくなります
     。

 -- オプション変数: doscmxops
     デフォルト値: ‘false’

     ‘doscmxops’が‘true’の時、 スカラー-行列演算が実行されます。

 -- オプション変数: doscmxplus
     デフォルト値: ‘false’

     ‘doscmxplus’が‘true’の時、 スカラー-行列演算は、行列の結果をもたら
     します。 このスイッチは、‘*note doallmxops::’の下に包括されません。

 -- オプション変数: dot0nscsimp
     デフォルト値: ‘true’

     ‘dot0nscsimp’が‘true’の時、 ゼロと非スカラー項の非可換積は、可換積
     に整理されます。

 -- オプション変数: dot0simp
     デフォルト値: ‘true’

     ‘dot0simp’が‘true’の時、 ゼロとスカラー項の非可換積は、 可換積に整
     理されます。

 -- オプション変数: dot1simp
     デフォルト値: ‘true’

     ‘dot1simp’が‘true’の時、 １ともう１つの項の非可換積は、可換積に整理
     されます。

 -- オプション変数: dotassoc
     デフォルト値: ‘true’

     ‘dotassoc’が‘true’の時、 式‘(A.B).C’は‘A.(B.C)’に整理されます。

 -- オプション変数: dotconstrules
     デフォルト値: ‘true’

     ‘dotconstrules’が‘true’の時、 定数ともう１つの項の非可換積は、可換
     積に整理されます。 このフラグをオンにすることは、事実上、 ‘*note
     dot1simp::’はもちろん、‘*note dot0simp::’, ‘*note dot0nscsimp::’も
     オンにします。

 -- オプション変数: dotdistrib
     デフォルト値: ‘false’

     ‘dotdistrib’が‘true’の時、 式‘A.(B + C)’は‘A.B + A.C’に整理されます
     。

 -- オプション変数: dotexptsimp
     デフォルト値: ‘true’

     ‘dotexptsimp’が‘true’の時、 式‘A.A’は‘A^^2’に整理されます。

 -- オプション変数: dotident
     デフォルト値: 1

     ‘dotident’は‘X^^0’が返す値です。

 -- オプション変数: dotscrules
     デフォルト値: ‘false’

     ‘dotscrules’が‘true’の時、 式‘A.SC’または‘SC.A’は、‘SC*A’に整理され
     、 ‘A.(SC*B)’は‘SC*(A.B)’に整理されます。

 -- 関数: echelon (<M>)

     ガウスの消去法で生成される、行列<M>の階段形を返します。 階段形は、
     <M>から初等行演算によって計算され、 それぞれの行の最初の非ゼロ要素
     が１で、 その要素の下の列要素がすべてゼロであるような行列です。

     ‘*note triangularize::’もガウスの消去法を実行しますが、 それぞれの
     行の先頭の非ゼロ要素を規格化しません。

     ‘*note lu_factor::’と‘*note 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 ]

 -- 関数: eigenvalues (<M>)
 -- 関数: eivals (<M>)

     行列<M>の固有値を含む２つのリストのリストを返します。 戻り値の最初
     の部分リストは、行列の固有値のリストで、 二番目の部分リストは、対応
     する順序で固有値の重複度のリストです。

     ‘eivals’は、‘eigenvalues’と同義です。

     ‘eigenvalues’は、 行列の特性多項式の根を見つけるために、 関数‘*note
     solve::’をコールします。 時々、 ‘solve’は、多項式の根を見つけられな
     いかもしれません; その場合、このパッケージの (‘*note
     innerproduct::’, ‘*note unitvector::’, ‘*note columnvector::’,
     ‘*note gramschmidt::’を除いた)いくつかの他の関数はうまく動かないで
     しょう。

     いくつかの場合、‘solve’が見つける固有値は、 複雑な式かもしれません
     。 (これは、 ‘solve’が 実数とわかっている固有値について 見てもすぐ
     にはわからない実数式を返す時、起こることがあります。) 他のいくつか
     の関数を使って固有値を整理することが可能なことがあります。

     パッケージ‘eigen.mac’は、 ‘eigenvalues’や‘*note eigenvectors::’が参
     照された時、 自動的にロードされます。 もし‘eigen.mac’がまだロードさ
     れていないなら、 ‘load ("eigen")’はそれをロードします。 ロードした
     後は、パッケージの中の関数と変数すべてが利用可能です。

 -- 関数: eigenvectors (<M>)
 -- 関数: eivects (<M>)

     行列<M>の固有ベクトルを計算します。 戻り値は、２つの要素のリストで
     す。 最初のものは、<M>の固有値のリストと固有値の重複度のリストです
     。 二番目のものは、固有ベクトルのリストのリストです。 固有値それぞ
     れに対して固有ベクトルのリストが１つあります。 リストそれぞれの中に
     は、固有ベクトルが１つの時も複数のときもあります。

     ‘eivects’は、‘eigenvectors’と同義です。

     パッケージ‘eigen.mac’は、 ‘*note eigenvalues::’や‘eigenvectors’が参
     照された時、 自動的にロードされます。 もし‘eigen.mac’がまだロードさ
     れていないなら、 ‘load ("eigen")’はそれをロードします。 ロードした
     後は、パッケージの中の関数と変数すべてが利用可能です。

     この関数に影響するフラグは以下の通りです:

     ‘nondiagonalizable’は、 ‘eigenvectors’が戻った後、行列が対角化不可
     能か可能かに依って ‘true’か‘false’に設定されます。

     ‘hermitianmatrix’が‘true’の時、 エルミート行列の縮退した固有ベクト
     ルが、グラム-シュミットアルゴリズムを使って直交化されるようにします
     。

     ‘knowneigvals’が‘true’の時、 causes the ‘eigen’パッケージが、 行列
     の固有値がユーザーに知られていて、グローバル名‘listeigvals’の下記憶
     されていることを仮定するようにします。 ‘listeigvals’は、 出力
     ‘eigenvalues’に似たリストに設定されなければいけません。

     ここで、関数‘*note algsys::’が固有ベクトルについて解くために使われ
     ます。 もし固有値がごちゃごちゃしているなら、 ‘algsys’は、時々、解
     を見つけられないかもしれません。 いくつかの場合、 最初に
     ‘eigenvalues’コマンドを使って固有値を見つけ、 それらをもっと簡潔な
     何かに換算するために他の関数を使うことによって、 固有値を整理するこ
     とが可能かもしれません。 整理に続いて、 ‘true’に設定された
     ‘knowneigvals’フラグとともに 再び‘eigenvectors’をコールすることがで
     きます。

     ‘*note 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

 -- 関数: ematrix (<m>, <n>, <x>, <i>, <j>)

     値が<x>の‘[<i>, <j>]’要素を除いて、すべての要素がゼロの <m>行<n>列
     行列を返します。

 -- 関数: 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)  ]

 -- 関数: 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>は、 (‘*note make_array::’では
     なく‘array’が生成する)宣言配列か、 未宣言配列か、配列関数か、２つの
     引数を持つラムダ式のいずれかです。 (配列関数は、他の関数のように、
     ‘*note :=::’や‘*note 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 ]

 -- 関数: 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]

 -- 関数: ident (<n>)

     <n>行<n>列の単位行列を返します。

 -- 関数: innerproduct (<x>, <y>)
 -- 関数: inprod (<x>, <y>)

     <x>と<y>の(スカラー積やドット積とも呼ばれる)内積を返します。 <x>と
     <y>は、等しい長さのリストか、ともに等しい長さの1列行列か1行行列です
     。 戻り値は、‘conjugate (x) . y’です。 ここで、‘.’は非可換乗算演算
     子です。

     ‘load ("eigen")’はこの関数をロードします。

     ‘inprod’は、‘innerproduct’と同義です。

 -- 関数: invert (<M>)

     行列<M>の逆行列を返します。 逆行列は随伴法で計算されます。

     これは、ユーザーが 要素が多倍長浮動小数点の行列や 要素が浮動小数点
     係数多項式の行列の逆行列を、 CRE形に変換することなしに計算すること
     を可能にします。

     余因子は、‘*note determinant::’関数で計算されるので、 もし‘*note
     ratmx::’が‘false’なら、 要素の表現を変えることなしに、逆行列が計算
     されます。

     現在の実装は、高次の行列には非効率的です。

     ‘*note detout::’が‘true’の時、 行列式は、逆行列から係数として外に出
     されます。

     逆行列の要素は自動的には展開されません。 もし<M>が多項式の要素を持
     つなら、 ‘expand (invert (m)), detout’が、見た目がよりよい出力を生
     成することができます。 もし全体を行列式で割られたものが望ましいなら
     、 ‘xthru (%)’で達成することができます。 また、代わりに最初から以下
     のようにしても達成できます。

          expand (adjoint (m)) / expand (determinant (m))
          invert (m) := adjoint (m) / determinant (m)

     行列の逆を計算する別の方法について‘^^’ (非可換べき乗)を参照してくだ
     さい。

 -- 関数: list_matrix_entries (<M>)

     行列<M>の要素を含むリストを返します。

     例:

          (%i1) list_matrix_entries(matrix([a,b],[c,d]));
          (%o1)                     [a, b, c, d]

 -- オプション変数: lmxchar
     デフォルト値: ‘[’

     ‘lmxchar’は、行列の左区切り記号として表示される文字です。 ‘*note
     rmxchar::’も参照してください。

     例:

          (%i1) lmxchar: "|"$
          (%i2) matrix ([a, b, c], [d, e, f], [g, h, i]);
                                     | a  b  c ]
                                     |         ]
          (%o2)                      | d  e  f ]
                                     |         ]
                                     | g  h  i ]

 -- 関数: matrix (<row_1>, ..., <row_n>)

     行<row_1>, ..., <row_n>を持つ長方形行列を返します。 行それぞれは、
     式のリストです。 すべての行は同じ長さでなければいけません。

     オペランドが、２つの行列、スカラーと行列、行列とスカラーのいずれか
     の時、 演算‘+’ (足し算), ‘-’ (引き算), ‘*’ (掛け算), ‘/’ (割り算)は
     要素毎に実行されます。 もしオペランドが、スカラーと行列、行列とスカ
     ラーのいずれかなら、 演算‘^’ (べき乗, ‘**’と同値)は、要素毎に実行さ
     れますが、 もしオペランドが２つの行列なら要素毎には実行されません。
     ‘.’ (非可換乗算)を含むすべての演算は、通常、完全に実行されます。

     行列の掛け算は、非可換乗算演算子‘.’で表されます。 対応する非可換べ
     き乗演算子は‘^^’です。 行列 ‘<A>’に関して、 ‘<A>.<A> = <A>^^2’であ
     り、 もし存在するなら、‘<A>^^-1’は<A>の逆行列です。

     ドット演算や行列-リスト演算を含む式の整理を制御するためのスイッチが
     あります。 それらは、 ‘*note doallmxops::’, ‘*note domxexpt::’
     ‘*note domxmxops::’, ‘*note doscmxops::’, ‘*note doscmxplus::’です
     。

     行列に関係する付加的なオプションがあります。 それらは以下の通りです
     : ‘*note lmxchar::’, ‘*note rmxchar::’, ‘*note ratmx::’, ‘*note
     listarith::’, ‘*note detout::’, ‘scalarmatrix’, ‘*note sparse::’

     行列を引数として取ったり、行列を戻り値としてもたらしたりするたくさ
     んの関数があります。 ‘*note eigenvalues::’, ‘*note eigenvectors::’,
     ‘*note determinant::’, ‘*note charpoly::’, ‘*note genmatrix::’,
     ‘*note addcol::’, ‘*note addrow::’, ‘*note copymatrix::’, ‘*note
     transpose::’, ‘*note echelon::’, ‘*note 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 ]

 -- 関数: matrixmap (<f>, <M>)

     ‘<f>(<M>[i,j])’に等しい要素‘i,j’を持つ行列を返します。

     ‘*note map::’, ‘*note fullmap::’, ‘*note fullmapl::’, ‘*note
     apply::’も参照してください。

 -- 関数: matrixp (<expr>)

     もし<expr>が行列なら‘true’を返し，そうでなければ、‘false’を返します
     。

 -- オプション変数: matrix_element_add
     デフォルト値: ‘+’

     ‘matrix_element_add’は、 行列乗算の中で足し算の代わりに呼び出される
     演算です。 ‘matrix_element_add’は、 任意のn項演算子(すなわち、任意
     の数の引数を扱う関数)に割り当てられます。 割り当てられた値は、クォ
     ートマークでくくられた演算子の名前か、 関数名かラムダ式を取り得ます
     。

     ‘*note matrix_element_mult::’と‘*note 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  ]

 -- オプション変数: matrix_element_mult
     デフォルト値: ‘*’

     ‘matrix_element_mult’は、 行列乗算の中で掛け算の代わりに呼び出され
     る演算です。 ‘matrix_element_mult’は、 任意の二項演算子に割り当てら
     れます。 割り当てられた値は、クォートマークでくくられた演算子の名前
     か、関数名か、 ラムダ式を取り得ます。

     ドット演算子‘.’は、いくつかの文脈で役に立つ選択です。

     ‘*note matrix_element_add::’と‘*note 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) ) ]

 -- オプション変数: matrix_element_transpose
     デフォルト値: ‘false’

     ‘matrix_element_transpose’は、 転置される時、行列のそれぞれの要素に
     適用される演算です。 ‘*note matrix_element_mult::’は、任意の単項演
     算子に割り当てられます。 割り当てられた値はクォートマークでくくられ
     た演算子の名前か、 関数名か、ラムダ式を取り得ます。

     ‘matrix_element_transpose’が‘*note transpose::’に等しい時、
     ‘transpose’関数が要素すべてに適用されます。
     ‘matrix_element_transpose’が‘nonscalars’に等しい時、 ‘transpose’関
     数は非スカラー要素すべてに適用されます。 もしある要素がアトムなら、
     ‘nonscalars’オプションは アトムが宣言された非スカラーの時だけ
     ‘transpose’を適用します。 一方、‘transpose’オプションはいつも
     ‘transpose’を適用します。

     デフォルト値, ‘false’,はいかなる演算も適用しないことを意味します。

     ‘*note matrix_element_add::’と‘*note 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   ]

 -- 関数: mattrace (<M>)

     正方行列<M>の跡(すなわち、主対角上の要素の和)を返します。

     ‘mattrace’は、‘*note ncharpoly::’―Maximaの‘*note charpoly::’の代わ
     り― によってコールされます。

     ‘load ("nchrpl")’はこの関数をロードします。

 -- 関数: minor (<M>, <i>, <j>)

     行列<M>の<i>, <j>小行列を返します。 すなわち、行<i>と列<j>を除いた
     <M>です。

 -- 関数: ncharpoly (<M>, <x>)
     行列<M>の <x>に関する特性多項式を返します。 これはMaximaの‘*note
     charpoly::’の代わりです。

     ‘ncharpoly’は、与えられた行列のべきの跡を計算することで機能します。
     それは、特性多項式の根のべきの和に等しいことが知られています。 それ
     らの量から根の対称関数を計算することができます。 それらは、特性多項
     式の係数以上のなにものでもありません。 ‘charpoly’は、 ‘<x> * ident
     [n] - a’の行列式を形成することで機能します。 このように、
     ‘ncharpoly’ は完全に多項式算術を避けるので、 例えば、整数で埋められ
     た大きな密な行列の場合、‘ncharpoly’が勝ります。

     ‘load ("nchrpl")’はこのファイルをロードします。

 -- 関数: newdet (<M>)

     行列<M>の行列式を ジョンソン-ジェントルマンのtree minorアルゴリズム
     を使って計算します。 ‘newdet’はCRE形式で結果を返します。

 -- 宣言: nonscalar

     アトムをドット演算子に関してリストか行列のように振る舞うようにしま
     す。

 -- 関数: nonscalarp (<expr>)

     もし<expr>が非スカラー、すなわち、 非スカラーとして宣言されたアトム
     かリスト、行列を含むなら、 ‘true’を返します。

 -- 関数: permanent (<M>, <n>)

     行列<M>のパーマネントを計算します。 パーマネントは行列式のようです
     が、符号が変わりません。 ‘permanent’はCRE形式で結果を返します。

     ‘newdet’も参照してください。

 -- 関数: rank (<M>)

     行列<M>のランクを計算します。 すなわち、<M>の、最も大きな非特異な小
     行列式の次数です。

     もし<rank>がゼロと同値の行列要素が確かにそうであることを決定するこ
     とができないなら、 、間違った答えを返します。

 -- オプション変数: ratmx
     デフォルト値: ‘false’

     ‘ratmx’が‘false’の時、 行列要素の表現で、行列式と行列の足し算、引き
     算、掛け算が実行され、 逆行列の結果は一般表現のまま残されます。

     ‘ratmx’が‘true’の時、 上で述べた４つの演算は、CRE形式で実行され、 逆
     行列の結果もCRE形式になります。 これは、(‘ratfac’の設定に依って) い
     つも望まれているわけではないですが、 要素が展開されるようになるかも
     しれないことに注意してください。

 -- 関数: row (<M>, <i>)

     行列<M>の<i>番目の行を返します。 戻り値は行列です。

 -- オプション変数: rmxchar
     デフォルト値: ‘]’

     ‘rmxchar’は、行列の右辺に描かれる文字です。

     ‘lmxchar’も参照してください。

 -- オプション変数: scalarmatrixp
     デフォルト値: ‘true’

     ‘scalarmatrixp’が‘true’の時、 1 x 1行列が行列のドット積を計算した結
     果として生成される時はいつでも、 スカラー、すなわち、行列の唯一の要
     素、に整理されます。

     ‘scalarmatrixp’が‘all’の時、 すべての1 x 1行列はスカラーに整理され
     ます。

     ‘scalarmatrixp’が‘false’の時、 1 x 1行列はスカラーに整理されません
     。

 -- 関数: 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です。 式を現
     在の座標形の物理成分に展開するために、 形式?を利用する関数がありま
     す。

 -- 関数: setelmx (<x>, <i>, <j>, <M>)

     <x>を行列<M>の(<i>, <j>)番目の要素に割り当て、 変わった行列を返しま
     す。

     ‘<M> [<i>, <j>]: <x>’は同じ効果を持ちますが、 <M>の代わりに<x>を返
     します。

 -- 関数: 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’と同義です。

 -- オプション変数: sparse
     デフォルト値: ‘false’

     ‘sparse’が‘true’の時、 かつ、もし‘ratmx’が‘true’なら、
     ‘determinant’は、粗な行列式を計算するために特別なルーチンを使います
     。

 -- 関数: 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>から構成された新しい行列を返します。

 -- 関数: transpose (<M>)
     <M>の転置を返します。

     もし<M>が行列なら、 戻り値は、‘N[i,j] = M[j,i]’であるような別の行列
     <N>です。

     もし<M>がリストなら、 返し値は、‘N[i,1] = M[i]’であるような、
     ‘length (m)’行1列の行列<N>です。

     そうでなければ<M>はシンボルで、 戻り値は、名詞式‘'transpose (<M>)’で
     す。

 -- 関数: 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 ]

 -- 関数: uniteigenvectors (<M>)
 -- 関数: ueivects (<M>)

     行列<M>の単位固有ベクトルを計算します。 戻り値は、リストのリストで
     す。 最初の部分リストは‘eigenvalues’コマンドの出力であり、 他の部分
     リストは、固有値それぞれに対応する行列の単位固有ベクトルです。

     ‘eigenvectors’コマンドでの記述で言及されたフラグは、 これに関しても
     同じ効果を持ちます。

     ‘knowneigvects’が‘true’の時、 ‘eigen’パッケージは、 行列の固有ベク
     トルがユーザーに知られていて、 グローバル名‘listeigvects’の下に記憶
     されていることを仮定します。 ‘listeigvects’は、 ‘eigenvectors’コマ
     ンドの出力に似たリストに設定されなければいけません。

     もし‘knowneigvects’が‘true’に設定されていて、 固有ベクトルのリスト
     が与えれているなら、 フラグ‘nondiagonalizable’の設定は正しくないか
     もしれません。 もしこの場合に該当するなら、正しい値に設定してくださ
     い。 作者は、ユーザーがしていることを知っていること、 固有値が適切
     な次元のベクトル空間を作り出さない行列を対角化しようとはしないこと
     を 仮定しています。

     ‘load ("eigen")’はこの関数をロードします。

     ‘ueivects’は‘uniteigenvectors’と同義です。

 -- 関数: unitvector (<x>)
 -- 関数: uvect (<x>)

     <x>/norm(<x>)を返します; これは、<x>と同じ向きの単位ベクトルです。

     ‘load ("eigen")’はこの関数をロードします。

     ‘uvect’は、‘unitvector’と同義です。

 -- 関数: vectorpotential (<givencurl>)

     現在の座標系で与えられた回転ベクトルのベクトルポテンシャルを返しま
     す。 ‘potentialzeroloc’が ‘potential’に対して似たような役割を持ちま
     すが、 等式の左辺側の次数は座標変数の巡回置換でなければいけません。

 -- 関数: vectorpotential (<givencurl>)
     現在の座標系で、与えられた回転ベクトルのベクトルポテンシャルを返し
     ます。 ‘potentialzeroloc’は、‘potential’と同様の役割を持ちますが、
     等式の左辺の順序が座標の巡回置換でなければいけません。

 -- 関数: 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’として宣言されています。

 -- オプション変数: vect_cross
     デフォルト値: ‘false’

     ‘vect_cross’が‘true’の時、 ~がSHARE;VECTの中で定義されているところ
     (とにかく、VECT_CROSSが‘true’に設定されているところ) で
     DIFF(X~Y,T)が機能するようにします。

 -- 関数: zeromatrix (<m>, <n>)

     要素すべてがゼロの<m>行<n>列行列を返します。


File: maxima.info,  Node: Affine,  Next: itensor,  Prev: Matrices and Linear Algebra,  Up: Top

24 Affine
*********

* Menu:

* Introduction to Affine::
* Functions and Variables for Affine::


File: maxima.info,  Node: Introduction to Affine,  Next: Functions and Variables for Affine,  Prev: Affine,  Up: Affine

24.1 Introduction to Affine
===========================

‘affine’は多項式の群を扱うパッケージです。


File: maxima.info,  Node: Functions and Variables for Affine,  Prev: Introduction to Affine,  Up: Affine

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")’はこの関数をロードします。

 -- 関数: 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")’はこの関数をロードします。

 -- 関数: 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")’はこの関数をロードします。

 -- 関数: declare_weights (<x_1>, <w_1>, ..., <x_n>, <w_n>)
     重み <w_1>, ..., <w_n> それぞれを<x_1>, ..., <x_n>に割り当てます。
     これらは、‘nc_degree’を計算する時に使われる重みです。

     ‘load("affine")’はこの関数をロードします。

 -- 関数: nc_degree (<p>)
     非可換多項式<p>の次数を返します。 ‘declare_weights’を参照してくださ
     い。

     ‘load("affine")’はこの関数をロードします。

 -- 関数: dotsimp (<f>)
     <f>が方程式によって生成されたイデアルに含まれる時だけ、 すなわち、
     <f>が方程式の要素の多項式結合の時だけ、 0を返します。

     ‘load("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.

 -- 関数: check_overlaps (<n>, <add_to_simps>)
     次数<n>までの重複をチェックします。 すなわち、‘dotsimp’が正しく機能
     するように、 それぞれの次数で十分な整理規則を持つことを確認します。
     もしあらかじめ単項式の空間次元が何か知っているなら、 このプロセスは
     、スピードアップできます。 もし有限グローバル次元なら、 ‘hilbert’が
     使われるべきです。 もし単項式次元を知らないなら、 ‘rank_function’を
     指定しないでください。 オプションの三番目の引数‘reset’は、 ‘false’は
     、物事の再設定についてわざわざ問い合わせないように言います。

     ‘load("affine")’はこの関数をロードします。

 -- 関数: mono ([<x_1>, ..., <x_n>], <n>)
     次数<n>の変数<x_1>, ..., <x_n>に関する現在のドット整理に関係した 独
     立な単項式のリストを返します。

     ‘load("affine")’ loads this function.

 -- 関数: monomial_dimensions (<n>)
     カレント代数に関する次数<n>までのヒルベルト級数を計算します。

     ‘load("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")’はこの関数をロードします。

 -- 関数: list_nc_monomials ([<p_1>, ..., <p_n>])
 -- 関数: list_nc_monomials (<p>)

     多項式<p>または多項式のリスト<p_1>, ..., <p_n> の中に現れる非可換単
     項式のリストを返します。

     ‘load("affine")’はこの関数をロードします。

 -- オプション変数: all_dotsimp_denoms
     デフォルト値: ‘false’

     ‘all_dotsimp_denoms’がリストの時、 ‘dotsimp’が出会う分母がリストに
     追加されます。 ‘all_dotsimp_denoms’は、 ‘dotsimp’をコールする前に 空
     のリスト‘[]’に初期化されるかもしれません。

     デフォルトでは、‘dotsimp’は分母を集めません。


File: maxima.info,  Node: itensor,  Next: ctensor,  Prev: Affine,  Up: Top

25 itensor
**********

* Menu:

* Introduction to itensor::
* Functions and Variables for itensor::


File: maxima.info,  Node: Introduction to itensor,  Next: Functions and Variables for itensor,  Prev: itensor,  Up: itensor

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方程式を計算する方法を示し、 理論
のスカラー場に関連したハミルトニアンも演繹します。

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


File: maxima.info,  Node: Functions and Variables for itensor,  Prev: Introduction to itensor,  Up: itensor

25.2 Functions and Variables for itensor
========================================

25.2.1 Managing indexed objects
-------------------------------

 -- 関数: dispcon (<tensor_1>, <tensor_2>, ...)
 -- 関数: dispcon (all)

     ‘defcon’に与えられたような引数の縮約プロパティを表示します。
     ‘dispcon (all)’は、定義された縮約プロパティすべてを表示します。

 -- 関数: entertensor (<name>)

     プロンプトによって、 任意の数のテンソル添字や微分添字を持つ<name>と
     呼ばれる添字付きオブジェクトを生成することを許す関数です。 単一添字
     または(nullもありえる)添字のリストが容認可能な入力です。
     (‘covdiff’の下の例を参照してください。)

 -- 関数: changename (<old>, <new>, <expr>)

     <expr>の中の<old>と呼ばれるすべての添字付きオブジェクトの名前を
     <new>に変えます。 <old>はシンボルまたは形式‘[<name>, <m>, <n>]’のリ
     ストであり得ます。 後者の場合、<m>個の共変添字と<n>個の反変添字を持
     つ <name>と呼ばれるそれらの添字付きオブジェクトだけが<new>にリネー
     ムされます。

 -- 関数: 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

 -- 関数: ishow (<expr>)

     下付き添字としての共変添字と上付き添字としての反変添字を持つように
     添字付きオブジェクトを持つ形で<expr>を表示します。 微分添字は、共変
     添字からコンマで区切られた下付き添字として表示されます。 (このドキ
     ュメント至る所の例を参照してください。)

 -- 関数: 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’は、これらの式を合理的な方法で扱おうとします; しかしながら
     、そんな非合法な式上で動くようにコールされた時、その振る舞いは未定
     義と考えなければいけません。

 -- 関数: 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

 -- 関数: show (<expr>)
     下付き添字として共変インデックス、上付き添字として反変インデックス
     を持つよう、 インデックスされたオブジェクトと一緒に‘expr’を表示しま
     す。 微分インデックスは下付き添字として表示され、 コンマによって共
     変インデックスと区別されます。

 -- オプション変数: flipflag

     デフォルト: ‘false’.  もし‘false’なら反変添字の順に従って、 そうで
     なければ、共変添字の順に従って、 添字がリネームされます。

     もし‘flipflag’が‘false’なら、 ‘rename’は 左から右に現れるよう反変添
     字のリストを形成します (もし‘true’なら共変添字について同様に)。 リ
     ストの最初のダミー添字は‘%1’に、次は‘%2’にというように、リネームさ
     れます。 そして、‘rename’の後、並び替えが起こります。 (‘rename’の下
     の例を参照してください。)

 -- 関数: 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’で縮約プロパティを与えられたそれら添字付きオブジェクトのリ
     ストです。

 -- 関数: remcon (<tensor_1>, ..., <tensor_n>)
 -- 関数: remcon (all)
     <tensor_1>, ..., <tensor_n>からすべての縮約プロパティを取り除きます
     。 ‘remcon(all)’は、すべての添字付きオブジェクトから すべての縮約プ
     ロパティを取り除きます。

 -- 関数: contract (<expr>)

     和と積の任意の組み合わせであり得る <expr>に関して テンソル縮約を実
     行します。 この関数は ‘defcon’関数に与えられた情報を使います。 最高
     の結果として、 ‘expr’は完全に展開されなければいけません。 もし項の
     分母の中に変数がないなら、 ‘ratexpand’は 和の積やべきを展開する 最
     速の方法です。 もしGCD消去が不要なら、 ‘gcd’スイッチは‘false’でなけ
     ればいけません。

 -- 関数: indexed_tensor (<tensor>)

     値に関する美しい姿が既に ‘ichr1’, ‘ichr2’, ‘icurvature’とともにある
     ように存在する <tensor>に成分を割り当てる前に実行されなければいけま
     せん。 ‘icurvature’の下の例を参照してください。

 -- 関数: 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

 -- 関数: remcomps (<tensor>)

     ‘components’関数で割り当てられたすべての値を <tensor>からアンバイン
     ドします。

 -- 関数: 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よりも高い階数のテンソルの成分も表示すること
     ができます。

 -- 関数: idummy ()

     Increments ‘icounter’を1つ増やし、 形式‘%n’の添字を値として返します
     。ここでnは正の整数です。 これは式を形成する際必要なダミー添字が既
     に使用中の添字とぶつからないことを保証します。 (‘indices’の下の例を
     参照してください。)

 -- オプション変数: idummyx
     デフォルト値: ‘%’

     ダミー添字の接頭辞です。 (‘indices’の下の例を参照してください。)

 -- オプション変数: icounter
     デフォルト値: ‘1’

     テンソルパッケージで次のダミー添字を生成する際使われる数値接尾を決
     定します。 接頭辞はオプション‘idummy’ (デフォルト: ‘%’)で決定されま
     す。

 -- 関数: kdelta (<L1>, <L2>)
     共変添字のリスト<L1>と反変添字のリスト<L2>を使って ‘itensor’パッケ
     ージで定義された 一般化されたKroneckerのデルタ関数です。
     ‘kdelta([i],[j])’は通常のKroneckerデルタを返します。 コマンド
     ‘ev(<expr>,kdelta)’は ‘kdelta([],[])’を多様体の次元に含む 式の評価
     をもたらします。

     この表記法の乱用となることですが、 ‘itensor’は ‘kdelta’が2つの共変
     添字だけ、または、2つの反変添字だけを持つことも許し、 事実上、共(反
     )変「単位行列」を供給します。 これは厳密にはプログラミング目的とし
     てみなされ、 ‘kdelta([i,j],[])’が有効なテンソルオブジェクトだという
     ことを意味するつもりではありません。

 -- 関数: 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

 -- 関数: levi_civita (<L>)
     もしリスト<L>が整数の偶置換から成るなら1を返し、 <L>が奇置換なら成
     るなら-1を返し、 <L>のいくつかの添字が繰り返しなら0を返す 置換(別名
     Levi-Civita)テンソルです。

 -- 関数: 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

 -- 関数: 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

 -- 関数: lc_u

     未評価のLevi-Civitaシンボル(‘levi_civita’)を含む式のために使われる
     整理ルール。 ‘lc_l’と組み合わせて、 たくさんの式を、‘levi_civita’の
     評価より、より効率的に整理するのに使うことができます。 詳しくは、
     ‘lc_l’を参照してください。

 -- 関数: canten (<expr>)
     名前を変えて(‘rename’を参照してください)、ダミー添字を置換すること
     で、 <expr>を整理します。 ‘rename’は 微分がないテンソル積の和に制限
     されます。 本当に限定されていて、 もし‘canform’が要求された整理を実
     行する能力がない時だけ使われるはずです。

     ‘canten’関数は、 引数が添字が完全に対称な式の時だけ数学的に正確な結
     果を返します。 この理由から、‘canten’は、 もし‘allsym’が‘true’に設
     定されてないなら エラーを返します。

 -- 関数: concan (<expr>)
     ‘canten’に似ていますが、添字縮約も実行します。

25.2.2 Tensor symmetries
------------------------

 -- オプション変数: allsym

     デフォルト: ‘false’。 もし‘true’なら、すべての添字付きオブジェクト
     は共変、反変添字のすべてに関して対称と仮定されます。 もし‘false’な
     ら、これらの添字に関して、いかなる種類の対称性も仮定されません。
     ‘iframe_flag’が‘true’に設定されない限り、 微分添字はいつも対称と取
     られます。

 -- 関数: 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]], []]]

 -- 関数: remsym (<tensor>, <m>, <n>)
     <m>個の共変添字と<n>個の反変添字を持つ<tensor>から すべての対称プロ
     パティを取り除きます。

 -- 関数: canform (<expr>)
 -- 関数: canform (<expr>, <rename>)
     ダミー添字をリネームして、 それらに課せられた対称条件によって指令さ
     れたようにすべての添字を並べ替えることで、 <expr>を整理します。 も
     し‘allsym’が‘true’なら、 すべての添字は対称と仮定され、 そうでなけ
     れば、‘decsym’宣言が提供する対称情報が使われます。 ダミー添字は
     ‘rename’関数に関するものと同じ方法でリネームされます。 ‘canform’が
     大きな式に適用される時、 計算にかなりの時間が費やされるかもしれませ
     ん。 この時間は最初に式に対して‘rename’をコールすることで短くできま
     す。 ‘decsym’の下の例も参照してください。 注意: ‘canform’は いつも
     数学的に正しい結果を返しますが、 式を最も簡単な形式に完全に整理でき
     ないかもしれません。

     オプションの二番目のパラメータ<rename>は、 もし‘false’に設定された
     なら、リネームを抑制します。

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テンソルと場の方程式を演繹することを可能にし
     ます。

 -- 関数: 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])’を返します。

 -- 関数: 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

 -- 関数: rediff (<ten>)

     テンソル式 <ten>の中の‘idiff’コマンドすべてを評価します。

 -- 関数: undiff (<expr>)

     <expr>と同値な、 添字付きオブジェクトの微分すべてが‘idiff’関数の名
     詞形で置き換えられた 式を返します。 引数はもし微分が実行されていた
     らその添字付きオブジェクトをもたらします。 微分された添字付きオブジ
     ェクトを <expr>を生じるある関数定義で置き換えて、 ‘ev(<expr>,
     idiff)’で微分を実行したい時、 これは役に立ちます。

 -- 関数: 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

 -- 関数: flush (<expr>, <tensor_1>, <tensor_2>, ...)
     <expr>において、 微分添字を持たない <tensor_i>をすべて0にします。

 -- 関数: flushd (<expr>, <tensor_1>, <tensor_2>, ...)
     <expr>において、 微分添字を持つ <tensor_i>をすべて0にします。

 -- 関数: 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

 -- 関数: coord (<tensor_1>, <tensor_2>, ...)

     <tensor_i>に、 その名前が<tensor_i>の1つである反変ベクトルの微分が
     Kroneckerデルタをもたらす 座標微分プロパティを与えます。 例えば、 も
     し ‘coord(x)’が実行されたら、 ‘idiff(x([],[i]),j)’は
     ‘kdelta([i],[j])’を与えます。 ‘coord’はこのプロパティを持つ添字付き
     オブジェクトすべてのリストです。

 -- 関数: remcoord (<tensor_1>, <tensor_2>, ...)
 -- 関数: remcoord (all)

     ‘tensor_i’から 関数 ‘coord’がもたらした座標微分プロパティを削除しま
     す。 ‘remcoord(all)’は添字付きオブジェクトすべてからこのプロパティ
     を削除します。

 -- 関数: makebox (<expr>)
     ‘show’と同じように <expr>を表示します; しかし、 <expr>に現れるテン
     ソル d'Alembert演算子はすべて記号 ‘[]’を使って示されます。 例えば、
     ‘[]p([m],[n])’は ‘g([],[i,j])*p([m],[n],i,j)’を表します。

 -- 関数: 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

 -- 関数: 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’も参照してください。

 -- 関数: flush1deriv (<expr>, <tensor>)

     <expr>において、 微分添字を1つだけ持つ <tensor>をすべて0にします。

25.2.4 Tensors in curved spaces
-------------------------------

 -- 関数: imetric (<g>)
 -- システム変数: imetric

     変数 ‘imetric:<g>’を割り当てることで計量を指定します。 加えて、 コ
     マンド ‘defcon(<g>),defcon(<g>, <g>, kdelta)’を実行することで 計量
     <g>の縮約プロパティが設定されます。 (デフォルトではバインドされてい
     ない)変数 ‘imetric’は ‘imetric(<g>)’コマンドが割り当てる計量にバイ
     ンドされます。

 -- 関数: idim (<n>)
     計量の次元を設定します。 与えられた次元でLevi-Civita記号の反対称プ
     ロパティも初期化します。

 -- 関数: ichr1 ([<i>, <j>, <k>])
     以下の定義を介して第一種Christoffel記号をもたらします。
                 (g      + g      - g     )/2 .
                   ik,j     jk,i     ij,k
     特定の計量で Christoffel記号を評価するには、 ‘chr2’の下の例のように
     変数 ‘imetric’が名前を割り当てられなければいけません。

 -- 関数: ichr2 ([<i>, <j>], [<k>])
     以下の定義を介して第二種Christoffel記号をもたらします。
                                 ks
             ichr2([i,j],[k]) = g    (g      + g      - g     )/2
                                       is,j     js,i     ij,s

 -- 関数: 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

 -- 関数: 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)

 -- 関数: lorentz_gauge (<expr>)
     反変添字と同一の微分添字を持つ <expr>の中で 添字付きオブジェクトす
     べてに0を代入することで、 Lorentz条件を課します。

 -- 関数: 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

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’), この関数は何もし
     ません。

 -- 変数: 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

 -- 変数: 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’は存在しません。

 -- 変数: 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’は存在しません。

 -- 変数: ifc1

     (Ricci回転係数としても知られている)第一種標構係数。 このテンソルは
     標構計量の第一種接続係数への寄与を表します。 以下のように定義されま
     す:


                    - ifb      + ifb      + ifb
                         c a b      b c a      a b c
          ifc1    = --------------------------------
              abc                   2


 -- 変数: ifc2

     第二種標構係数。 このテンソルは標構計量の第一種接続係数への寄与を表
     します。 必要に応じて、標構ブラケット (‘ifb’)の、 適切な上付き、下
     付き添字での置換として定義されます:


              c       cd
          ifc2   = ifg   ifc1
              ab             abd

 -- 変数: ifr

     標枠。 標構計量(‘ifg’)を形成するために 逆標構場 (‘ifri’)を 縮約しま
     す。

 -- 変数: ifri

     逆標構場。 (双対基底ベクトル)標構基底を指定します。 標構計量と一緒
     に、 標構に基づいた計算すべての基底を形成します。

 -- 変数: ifg

     標構計量。 ‘kdelta’のデフォルトですが、 ‘components’を使って変える
     ことができます。

 -- 変数: ifgi

     逆標構計量。 標構計量 (‘ifg’)を ‘kdelta’に縮約します。

 -- オプション変数: iframe_bracket_form
     デフォルト値: ‘true’

     標構ブラケット (‘ifb’)が如何に計算されるか指定します。

25.2.6 Torsion and nonmetricity
-------------------------------

Maximaは今では、ねじれと非計量性を考慮することができます。 フラグ
‘itorsion_flag’が ‘true’に設定されている時、 ねじれの寄与が 接続係数に加
えられます。 同様に、 フラグ ‘inonmet_flag’が trueの時、 非計量性成分が
含まれます。

 -- 変数: inm

     非計量性ベクトル。 共形非計量性は計量テンソルの共変微分を通して定義
     されます。 ‘inonmet_flag’が ‘true’に設定されている時 通常零の計量テ
     ンソルの共変微分は以下のように評価されます:


          g     =- g  inm
           ij;k     ij   k

 -- 変数: inmc1

     非計量ベクトル成分の共変置換。 以下のように定義されます:


                     g   inm  - inm  g   - g   inm
                      ab    c      a  bc    ac    b
          inmc1    = ------------------------------
               abc                 2

     (もし標構計量を使うなら、‘ifg’を ‘g’に代入します。)

 -- 変数: 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’に代入します。)

 -- 変数: ikt1

     (コントーションとしても知られる)ねじれテンソルの共変置換。 以下のよ
     うに定義されます:


                            d           d       d
                    -g   itr  - g    itr   - itr   g
                      ad    cb    bd    ca      ab  cd
          ikt1    = ----------------------------------
              abc                   2

     (もし標構計量を使うなら、‘ifg’を ‘g’に代入します。)

 -- 変数: ikt2

     (コントーションとしても知られる)ねじれテンソルの共変置換。 以下のよ
     うに定義されます:


              c     cd
          ikt2   = g   ikt1
              ab           abd

     (もし標構計量を使うなら、‘ifg’を ‘g’に代入します。)

 -- 変数: 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

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

 -- 演算子: |

     縦線 ‘|’は "ベクトルの縮約"二項演算子を示します。 完全反対称共変テ
     ンソルが反変ベクトルと縮約される時、 結果は、どの添字が縮約に使われ
     るかに関わらず同じです。 このように、 添字に無関係な方法で縮約演算
     子を定義することが可能です。

     ‘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

     ‘|’演算子で使われるテンソルは は共変添字に対して完全反対称と宣言さ
     れなければいけないことが 本質的であることに注意してください。 そう
     でないなら、結果は正しくありません。

 -- 関数: 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

 -- 関数: 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

 -- オプション変数: igeowedge_flag
     デフォルト値: ‘false’

     ウェッジ積と外微分の振る舞いを制御します。 ‘false’ (デフォルト)に設
     定された時、 微分形式の概念は 完全反対称共変テンソル場のそれに対応
     します。 ‘true’に設定された時、 微分形式は容積要素の概念に一致しま
     す。

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’関数は幾分実験的です。

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

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


File: maxima.info,  Node: ctensor,  Next: atensor,  Prev: itensor,  Up: Top

26 ctensor
**********

* Menu:

* Introduction to ctensor::
* Functions and Variables for ctensor::


File: maxima.info,  Node: Introduction to ctensor,  Next: Functions and Variables for ctensor,  Prev: ctensor,  Up: ctensor

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


File: maxima.info,  Node: Functions and Variables for ctensor,  Prev: Introduction to ctensor,  Up: ctensor

26.2 Functions and Variables for ctensor
========================================

26.2.1 Initialization and setup
-------------------------------

 -- 関数: csetup ()
     パッケージを初期化し、ユーザーに計量を対話的に入力可能にする
     ‘ctensor’(成分テンソル)パッケージの関数 より詳細は‘ctensor’を参照し
     てください。

 -- 関数: cmetric (<dis>)
 -- 関数: cmetric ()
     計量の逆元を計算し、将来の計算のためパッケージを設定する
     ‘ctensor’(成分テンソル)パッケージの関数

     もし‘cframe_flag’が‘false’なら、 関数は逆計量‘ug’を(ユーザー定義の
     )行列‘lg’から計算します。 計量の行列式も計算され、変数‘gdet’に保存
     されます。 更に、パッケージは計量が対角的か調べ、結果に従って
     ‘diagmetric’の値を設定します。 もしオプション引数<dis>が渡されて、
     それが‘false’でないなら、 ユーザーは計量の逆元を見るように促されま
     す。

     もし‘cframe_flag’が‘true’なら、 関数は‘fri’ (逆標構行列)と‘lfg’(標
     構計量)の値が定義されていると考えます。 これらから、標構行列‘fr’と
     逆標構計量‘ufg’が計算されます。

 -- 関数: 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’の値を表示します。

 -- 関数: init_ctensor ()
     ‘ctensor’パッケージを初期化します。

     ‘init_ctensor’関数は‘ctensor’パッケージを再初期化します。 それは
     ‘ctensor’が使う配列、行列すべてを削除し、 フラグすべてをリセットし
     、 ‘dim’を4にリセットし、 標構計量を Lorentz標構にリセットします。

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]’は 最
     後の添字が反変であるような方法で定義されます。

 -- 関数: ricci (<dis>)
     ‘ctensor’ (成分テンソル)パッケージの関数。 ‘ricci’は Ricciテンソル
     の共変(対称)成分 ‘ric[i,j]’を計算します。 もし引数 <dis>が ‘true’な
     ら、 非零成分が表示されます。

 -- 関数: uricci (<dis>)
     この関数は最初にRicciテンソルの共変成分 ‘ric[i,j]’を計算します。 そ
     して、混合 Ricciテンソルが反変計量テンソルを使って計算されます。 も
     し引数 <dis>の値が ‘true’なら これらの(添字 ‘i’は共変で、添字 ‘j’は
     反変の)混合成分 ‘uric[i,j]’ は直接表示されます。 そうでないなら、
     ‘ricci(false)’は 結果を表示することなく、単に配列 ‘uric[i,j]’の要素
     を計算します。

 -- 関数: scurvature ()
     与えられた計量を持つ Riemannian多様体の (Ricciテンソルを縮約するこ
     とで得られる)スカラ曲率を返します。

 -- 関数: einstein (<dis>)
     ‘ctensor’ (成分テンソル)パッケージの関数。 ‘einstein’は、 (関数
     ‘christof’と ‘ricci’を使って) Christoffel記号と Ricciテンソルを得ら
     れた後、 混合 Einsteinテンソルを計算します。 もし引数 <dis>が
     ‘true’なら、 混合 Einsteinテンソル ‘ein[i,j]’の非零値が表示されます
     。 ここで ‘j’は反変添字です。 変数 ‘rateinstein’は これらの成分上の
     有理整理をもたらします。 もし ‘ratfac’が ‘true’なら、 成分は因数分
     解もされます。

 -- 関数: leinstein (<dis>)
     共変 Einsteinテンソル。 ‘leinstein’は 配列 ‘lein’に共変 Einsteinテ
     ンソルの値を格納します。 共変 Einsteinテンソルは、 計量テンソルを掛
     けることで 混合 Einsteinテンソル ‘ein’から計算されます。 もし引数
     <dis>が ‘true’なら、 共変 Einsteinテンソルの非零値が表示されます。

 -- 関数: 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テンソルは 標構場係数から最初に計算されます。

 -- 関数: lriemann (<dis>)
     共変 Riemannテンソル (‘lriem[]’).

     配列 ‘lriem’として 共変 Riemannテンソルを計算します。 もし引数
     <dis>が ‘true’なら、 固有の非零値が表示されます。

     もし変数 ‘cframe_flag’が ‘true’なら、 共変 Riemannテンソルは 標構場
     係数から直接計算されます。 そうでないなら、 (3,1) Riemannテンソルが
     最初に計算されます。

     添字順序の情報は ‘riemann’を参照してください。

 -- 関数: uriemann (<dis>)
     配列要素 ‘uriem[i,j,k,l]’として Riemann曲率テンソルの反変成分を計算
     します。 もし <dis>が ‘true’なら、これらが表示されます。

 -- 関数: rinvariant ()
     テンソル
          lriem[i,j,k,l]*uriem[i,j,k,l].
     を縮約することで得られるKretschmann不変量 (‘kinvariant’)を形成しま
     す。

     このオブジェクトは非常に大きくなるかもしれないので、 自動的には整理
     されません。

 -- 関数: weyl (<dis>)
     Weylの共形テンソルを計算します。 もし引数 <dis>が ‘true’なら、 非零
     成分 ‘weyl[i,j,k,l]’がユーザーに表示されます。 そうでないなら、これ
     らの成分は 単に計算され、格納されます。 もしスイッチ ‘ratweyl’が
     ‘true’に設定されているなら、 成分は有理整理されます; もし ‘ratfac’が
     ‘true’なら、 結果は因数分解もされます。

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



     この能力は 例えば、 重力源から遠く、弱い場極限で取り組む時に 役に立
     つかもしれません。

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

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

 -- 関数: 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つを識別する方法がないまま、テンソルの混ざ
     った状態で終わるかもしれないので、 矛盾する結果をもたらすかもしれま
     せん。

 -- 関数: 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日時点、実装はテ
     ストされていなく、 エラーを含みそうです。

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)係数を計算し
     ます。

 -- 関数: nonmetricity (<nm>)

     非計量性ベクトル <nm>から(2,1)非計量性係数を計算します。

26.2.7 Miscellaneous features
-----------------------------

 -- 関数: ctransform (<M>)
     任意の平方対称行列 <M>上で座標変換を実行する ‘ctensor’ (成分テンソ
     ル)パッケージの関数。 ユーザーは変換を定義する函数を入力しなければ
     いけません。 (以前‘transform’と呼ばれていました。)

 -- 関数: 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]]

 -- 関数: cograd ()
     スカラ関数の 共変勾配を計算します。 ‘contragrad’が以下で例示する例
     のように ユーザーは対応するベクトル名を選べます。

 -- 関数: 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

 -- 関数: 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

 -- 関数: checkdiv ()

     ベクトル場(発散)の対応するn個の成分を印字することで (最初の添字が共
     変でなければいけない)混合二階テンソルの共変発散を計算します。 ここ
     でn = ‘dim’です。 もし関数の引数が ‘g’なら、 Einsteinテンソルの発散
     が形成され、零にならなければいけません。 加えて、発散(ベクトル)は 配
     列名 ‘div’を与えられます。

 -- 関数: cgeodesic (<dis>)
     ‘ctensor’ (成分テンソル)パッケージの関数。 ‘cgeodesic’は 与えられた
     計量での運動の測地方程式を計算します。 それらは配列 ‘geod[i]’に格納
     されます。 もし引数 <dis>が ‘true’なら、 これらの方程式が表示されま
     す。

 -- 関数: bdvac (<f>)

     Brans- Dicke重力理論の 真空場の方程式の 共変成分を生成します。 スカ
     ラ場は引数 <f>で指定されます。 <f>は、 例えば、‘'p(x)’のように、 関
     数依存性を持つ(クォートされた)関数名でなければいけません。

     二階共変場テンソルの成分は配列 ‘bd’で表されます。

 -- 関数: invariant1 ()

     R^2の不変密度に関する 混合Euler- Lagrangeテンソル(場の方程式)を生成
     します。 場の方程式は ‘inv1’と名付けられた配列の成分です。

 -- 関数: invariant2 ()

     *** NOT YET IMPLEMENTED ***

     ‘ric[i,j]*uriem[i,j]’の不変密度に関する 混合Euler- Lagrangeテンソル
     (場の方程式)を生成します。 場の方程式は ‘inv2’と名付けられた配列の
     成分です。

 -- 関数: bimetric ()

     *** NOT YET IMPLEMENTED ***

     Rosenの二計量(bimetric)理論の場の方程式を生成します。 場の方程式は
     ‘rosen’と名付けられた配列の成分です。

26.2.8 Utility functions
------------------------

 -- 関数: diagmatrixp (<M>)

     もし <M>が対角行列か対角 (2D) 配列なら ‘true’を返します。

 -- 関数: symmetricp (<M>)

     もし <M>が対称行列か対称 (2D) 配列なら ‘true’を返します。

 -- 関数: ntermst (<f>)
     ユーザーに 二重に下付き添字テンソル(配列) <f>の「サイズ」のquick
     pictureを与えます。 二番目の要素が 一番目の要素が指定する成分の
     NTERMSに対応する2つの要素のリストを印字します。 この方法で、 非零式
     をすばやく見つけて整理を試みることが可能です。

 -- 関数: 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

 -- 関数: deleten (<L>, <n>)
     <n>番目の要素を削除した<L>から成る新しいリストを返します。

26.2.9 Variables used by ‘ctensor’
----------------------------------

 -- オプション変数: dim
     デフォルト値: 4

     ‘ctensor’ (成分テンソル)パッケージのオプション。 ‘dim’は デフォルト
     4の多様体の次元です。 コマンド ‘dim: n’は 次元を任意の別の値 ‘n’に
     再設定します。

 -- オプション変数: diagmetric
     デフォルト値: ‘false’

     ‘ctensor’ (成分テンソル)パッケージのオプション。 もし ‘diagmetric’が
     ‘true’なら、 特殊なルーチンが 計量の対角性を考慮して (計量テンソル
     を明示的に含む)幾何的オブジェクトすべてを 計算します。 もちろん、実
     行時間短縮になります。 注意: もし対角計量が指定されたら、 ‘csetup’は
     自動的にこのオプションを設定します。

 -- オプション変数: ctrgsimp

     テンソルを計算する時、三角関数整理を使うようにします。 現在、
     ‘ctrgsimp’は 動標構を含む計算だけに影響します。

 -- オプション変数: cframe_flag

     計算を ホロノミック(holonomic)計量と対比して動標構に関係して実行す
     るようにします。 標構は逆標構配列 ‘fri’と標構計量 ‘lfg’で定義されま
     す。 Cartesian標構を使う計算に関して、 ‘lfg’は適切な次元の単位行列
     でなければいけません; Lorentz標構での計算に関して、 ‘lfg’は適切な符
     号を持たなければいけません。

 -- オプション変数: ctorsion_flag

     コントーションテンソルが 接続係数の計算に含まれるようにします。 コ
     ントーションテンソル自体は ユーザーが提供するテンソル ‘tr’から
     ‘contortion’によって計算されます。

 -- オプション変数: cnonmet_flag

     非計量性係数が 接続係数の計算に含まれるようにします。 コントーショ
     ンテンソルは ユーザーが提供する非計量性ベクトル ‘nm’から 関数
     ‘nonmetricity’によって計算されます。

 -- オプション変数: ctayswitch

     もし ‘true’に設定されているなら、 いくつかの ‘ctensor’計算が
     Taylor級数展開を使って実行されるようにします。 現在、 ‘christof’,
     ‘ricci’, ‘uricci’, ‘einstein’, ‘weyl’がこの設定を考慮します。

 -- オプション変数: ctayvar

     ‘ctayswitch’が ‘true’に設定されているなら Taylor級数展開で使われる
     変数。

 -- オプション変数: ctaypov

     ‘ctayswitch’が ‘true’に設定されている時 Taylor級数展開で使われる最
     大べき数

 -- オプション変数: ctaypt

     ‘ctayswitch’が ‘true’に設定されている時 Taylor級数展開が実行される
     点。

 -- システム変数: gdet

     計量テンソル ‘lg’の行列式。 ‘cframe_flag’が ‘false’に設定されている
     時、 ‘cmetric’によって計算されます。

 -- オプション変数: ratchristof

     ‘christof’が有理整理を適用するようにします。

 -- オプション変数: rateinstein
     デフォルト値: ‘true’

     もし ‘true’なら、 Einsteinテンソルの非零成分上で 有理整理が実行され
     ます; もし ‘ratfac’が ‘true’なら、 成分は因数分解もされます。

 -- オプション変数: ratriemann
     デフォルト値: ‘true’

     Riemannテンソルの整理を制御するスイッチの1つです; もし ‘true’なら、
     有理整理がされます; もし ‘ratfac’が ‘true’なら、 成分それぞれは因数
     分解もされます。

 -- オプション変数: ratweyl
     デフォルト値: ‘true’

     もし ‘true’なら、 このスイッチは, ‘weyl’関数が Weylテンソルの値に有
     理整理を適用するようにします。 もし‘ratfac’が ‘true’なら、 成分は因
     数分解もされます。

 -- 変数: lfg
     共変標構計量。 デフォルトでは、 符号 (+,+,+,-)を持つ4次元Lorentz標
     構に初期化されます。 ‘cframe_flag’が ‘true’の時使われます。

 -- 変数: ufg
     逆標構計量。 ‘cframe_flag’が ‘true’に設定されているなら、
     ‘cmetric’がコールされた時 ‘lfg’から計算されます。

 -- 変数: riem
     (3,1) Riemannテンソル。 関数 ‘riemann’が呼び出された時計算されます
     。 添字順序についての情報については、 ‘riemann’の記述を参照してくだ
     さい。

     もし ‘cframe_flag’が ‘true’なら、 ‘riem’は 共変Riemannテンソル
     ‘lriem’から計算されます。

 -- 変数: lriem

     共変Riemannテンソル。 ‘lriemann’が計算します。

 -- 変数: uriem

     反変Riemannテンソル。

 -- 変数: ric

     混合Ricciテンソル。 ‘ricci’が計算します。

 -- 変数: uric

     反変Ricciテンソル。 ‘ricci’が計算します。

 -- 変数: lg

     計量テンソル。 このテンソルは 他の計算が実行される前に (‘dim’掛け
     ‘dim’行列として)指定されなければいけません。

 -- 変数: ug

     計量テンソルの逆元。 ‘cmetric’が計算します。

 -- 変数: weyl

     Weylテンソル。 ‘weyl’が計算します。

 -- 変数: fb

     ‘frame_bracket’によって計算される、 標構ブラケット係数。

 -- 変数: kinvariant

     Kretchmann不変量。 ‘rinvariant’が計算します。

 -- 変数: np

     Newman-Penroseヌルテトラド。 ‘nptetrad’が計算します。

 -- 変数: 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 ]

 -- 変数: tr

     ユーザーが提供するねじれを表す階数3のテンソル ‘contortion’が使いま
     す。

 -- 変数: kt

     コントーションテンソル。 ‘contortion’が ‘tr’から計算します。

 -- 変数: nm

     ユーザーが提供する非計量性ベクトル。 ‘nonmetricity’が使います。

 -- 変数: nmc

     ‘nonmetricity’が ‘nm’から計算する 非計量性係数。

 -- システム変数: tensorkill

     テンソルパッケージが初期化されたかを示す変数。 ‘csetup’が設定し使い
     ます。 ‘init_ctensor’が再設定します。

 -- オプション変数: ct_coords
     デフォルト値: ‘[]’

     ‘ctensor’ (成分テンソル)パッケージのオプション。 ‘ct_coords’は座標
     のリストを含みます。 関数 ‘csetup’がコールされる時通常定義される一
     方、 割り当て ‘ct_coords: [j1, j2, ..., jn]’で座標を再定義できます
     。 ここで、jは新しい座標名です。 ‘csetup’も参照してください。

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


File: maxima.info,  Node: atensor,  Next: Sums Products and Series,  Prev: ctensor,  Up: Top

27 atensor
**********

* Menu:

* Introduction to atensor::
* Functions and Variables for atensor::


File: maxima.info,  Node: Introduction to atensor,  Next: Functions and Variables for atensor,  Prev: atensor,  Up: atensor

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’はいつも 望みの整理
を得ることができるわけではありません。


File: maxima.info,  Node: Functions and Variables for atensor,  Prev: Introduction to atensor,  Up: atensor

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)’と同値です。

 -- 関数: atensimp (<expr>)

     ‘init_atensor’のコールで構成された規則に従って、 代数テンソル式
     <expr>を整理します。 整理は、 適用可能な場所への 交換関係の再帰的な
     適用と‘sf’, ‘af’, ‘av’のコールの決定を含みます。 複雑な式に関してさ
     え、 関数がいつでも終了することを確実にするために 保護手段が使われ
     ます。

 -- 変数: adim
     デフォルト値: 0

     代数の次元。 ‘atensor’は 添字付きオブジェクトが有効な基底ベクトルか
     決定するのに ‘adim’の値を使います。 ‘abasep’を参照してください。

 -- 変数: aform
     デフォルト値: ‘ident(3)’

     双一次形式‘sf’, ‘af’, ‘av’のデフォルト値。 デフォルトは、単位行列
     ‘ident(3)’です。

 -- 変数: asymbol
     デフォルト値: ‘v’

     基底ベクトルのシンボル。

 -- 関数: sf (<u>, <v>)

     交換関係で使われる対称スカラ関数。 デフォルトの実装は 両方の引数が
     ‘abasep’を使った基底ベクトルかチェックし、 もしそうなら、行列
     ‘aform’から対応する値を代入します。

 -- 関数: af (<u>, <v>)

     交換関係で使われる反対称スカラ関数。 デフォルトの実装は 両方の引数
     が‘abasep’を使った基底ベクトルかチェックし、 もしそうなら、行列
     ‘aform’から対応する値を代入します。

 -- 関数: 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

 -- 関数: abasep (<v>)

     引数が ‘atensor’基底ベクトルかチェックします。 すなわち、
     ‘asymbol’の値と同じシンボルと 1と ‘adim’の間の数値の添字を持つ添字
     付きシンボルかどうか、チェックします。


File: maxima.info,  Node: Sums Products and Series,  Next: Number Theory,  Prev: atensor,  Up: Top

28 Sums, Products, and Series
*****************************

* Menu:

* Sums and Products::
* Introduction to Series::
* Functions and Variables for Series::
* Poisson series::


File: maxima.info,  Node: Sums and Products,  Next: Introduction to Series,  Prev: Sums Products and Series,  Up: Sums Products and Series

28.1 Sums and Products
======================

 -- 関数: bashindices (<expr>)
     それぞれの和や積に独自のインデックスを与えることで、 式<expr>を変換
     します。 これは、 和や積と一緒に機能する時 ‘changevar’によりよい精
     度を与えます。 独自のインデックスの形式は‘j<number>’です。 量
     <number>は、‘gensumnum’に参照することで決定されます。 これを、ユー
     ザーは変更することができます。 例えば、‘gensumnum:0$’はそれを再設定
     します。

 -- 関数: 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)

 -- 関数: intosum (<expr>)

     和の外側の掛け算因子を内側に移動します。 もし外側の式でインデックス
     が使われているなら、 関数は、‘sumcontract’に関してするのと同じよう
     に、合理的なインデックスを見つけようとします。 これは、本質的に、和
     の‘outative’プロパティの逆の考えですが、 このプロパティを取り除かず
     、ただ無視するだけであることに注意してください。

     いくつかの場合、 ‘intosum’の前に、‘scanmap (multthru, <expr>)’が必
     要になるかもしれません。

 -- 関数: 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

 -- オプション変数: simpsum
     デフォルト値: ‘false’

     ‘simpsum’が‘true’の時、 ‘sum’の結果は、整理されます。 この整理は、
     時々、閉形式を生成することができるかもしれません。 もし‘simpsum’が
     ‘false’もしくは、もしクォートされた形‘'sum’が使われたなら、 値は、
     数学で使われるΣ表示の表現である和の名詞形です。

 -- 関数: 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

 -- 関数: sumcontract (<expr>)
     定数だけ異なる上限と下限を持つ足し算の和すべてを結合します。 結果は
     、 そんな和のそれぞれの集合が、この和を形成するよう抽出されなければ
     ならないすべての適切な余分の項に加えられた１つの和を含む式です。
     ‘sumcontract’は、互換性のある和すべてを結合し、 可能なら和の１つか
     らインデックスの１つを使い、もし供給されたどれもが使えないなら、合
     理的なインデックスを形成するよう試みます。

     ‘sumcontract’の前に、‘intosum (<expr>)’を実行する必要があるかもしれ
     ません。

 -- オプション変数: 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


File: maxima.info,  Node: Introduction to Series,  Next: Functions and Variables for Series,  Prev: Sums and Products,  Up: Sums Products and Series

28.2 Introduction to Series
===========================

Maximaは、微分可能な関数の級数を見つけるために、 関数‘taylor’と
‘powerseries’を含みます。 ある級数の閉形式を見つける性能がある‘nusum’の
ようなツールも持ちます。 足し算や掛け算のような演算は、級数上で普通に機
能します。 この節は、展開を制御するグローバル変数を提供します。


File: maxima.info,  Node: Functions and Variables for Series,  Next: Poisson series,  Prev: Introduction to Series,  Up: Sums Products and Series

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

 -- 関数: 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

 -- オプション変数: maxtayorder
     デフォルト値: ‘true’

     ‘maxtayorder’が‘true’の時、 (切り詰められた)Taylor級数の代数操作の
     間、 ‘taylor’は、厳密とわかっているできるだけ多くの項を保とうとしま
     す。

 -- 関数: 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

 -- オプション変数: 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

 -- 関数: 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

 -- 関数: 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)]

 -- 関数: 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

 -- オプション変数: psexpand
     デフォルト値: ‘false’

     ‘psexpand’が‘true’の時、 拡張有理関数展開が完全に展開されて表示され
     ます。 スイッチ‘ratexpand’は同じ効果を持ちます。

     ‘psexpand’が‘false’の時、 多変数式がちょうど有理関数パッケージにあ
     るかのように表示されます。

     ‘psexpand’が‘multi’の時、 変数に関する同じ総次数の項は一緒にまとめ
     られます。

 -- 関数: 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

 -- 関数: 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

 -- オプション変数: taylordepth
     デフォルト値: 3

     もしまだ非ゼロ項がないなら、 展開の次数が‘<n> 2^taylordepth’以下で
     ある限り、 ‘taylor’は、 ‘<g>(<x>)’の展開の次数を倍にします。

 -- 関数: 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]]

 -- 関数: taylorp (<expr>)

     もし<expr>がTaylor級数なら、‘true’を、 そうでないなら、‘false’を返
     します。

 -- オプション変数: taylor_logexpand
     デフォルト値: ‘true’

     ‘taylor_logexpand’は、 ‘taylor’級数の中の対数の展開を制御します。

     ‘taylor_logexpand’が‘true’の時、 対数すべては完全に展開されるので、
     対数的恒等式を含むゼロ認識問題は 展開プロセスを邪魔しません。 しか
     しながら、分岐情報を無視するので、この方法はいつも数学的にただしい
     わけではありません。

     ‘taylor_logexpand’が‘false’に設定されている時、 生じる対数の唯一の
     展開は、 形式的なべき級数を得るのに必要なものです。

 -- オプション変数: taylor_order_coefficients
     デフォルト値: ‘true’

     ‘taylor_order_coefficients’は、 Taylor級数の中の係数の順序付けを制
     御します。

     ‘taylor_order_coefficients’が‘true’の時、 Taylor級数の係数は標準に
     順序付けられます。

 -- 関数: taylor_simplifier (<expr>)

     べき級数<expr>の係数を整理します。 ‘taylor’はこの関数をコールします
     。

 -- オプション変数: taylor_truncate_polynomials
     デフォルト値: ‘true’

     ‘taylor_truncate_polynomials’が‘true’の時、 多項式は入力切り詰めレ
     ベルを基礎に切り詰められます。

     そうでないなら、 ‘taylor’への多項式入力は、 不定の精度を持つと考え
     られます。

 -- 関数: taytorat (<expr>)
     ‘taylor’形式から標準有理式(CRE)形式に <expr>を変換します。 効果は
     ‘rat (ratdisrep (<expr>))’と同じですが、より速いです。

 -- 関数: 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

 -- 関数: 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)

 -- オプション変数: verbose
     デフォルト値: ‘false’

     ‘verbose’が‘true’の時、 ‘powerseries’は進捗メッセージを印字します。


File: maxima.info,  Node: Poisson series,  Prev: Functions and Variables for Series,  Up: Sums Products and Series

28.4 Poisson series
===================

 -- 関数: intopois (<a>)
     <a>をPoisson符号に変換します。

 -- 関数: outofpois (<a>)

     <a>をPoisson符号から一般表現に変換します。 もし<a>がPoisson形式でな
     いなら、 ‘outofpois’は変換を実行し、 すなわち、その戻り値は、
     ‘outofpois (intopois (<a>))’です。 例えば、この関数は、 特定のタイ
     プのサインやコサイン項のべきの和に関する 標準整理器です。

 -- 関数: poisdiff (<a>, <b>)

     <a>を<b>に関して微分します。 <b>は三角関数の引数の中だけ、または係
     数の中だけにいなければいけません。

 -- 関数: poisexpt (<a>, <b>)

     関数的に‘intopois (<a>^<b>)’と同一です。 <b>は正の整数でなければい
     けません。

 -- 関数: poisint (<a>, <b>)

     (‘poisdiffと’)似て制限された意味で積分します。 もし<b>が三角関数の
     引数の中にあるなら、 <b>の中の非周期的項は落とされます。

 -- オプション変数: poislim
     デフォルト値: 5

     ‘poislim’は、三角関数の引数の中の係数の領域を決定します。 初期値5は
     区間[-2^(5-1)+1,2^(5-1)]、すなわち[-15,16]に対応しますが、
     [-2^(n-1)+1, 2^(n-1)]に設定することができます。

 -- 関数: poismap (<series>, <sinfn>, <cosfn>)

     関数<sinfn>を与えられたPoisson級数のサイン項に、 <cosfn>をコサイン
     項に マップします。 <sinfn>と <cosfn>は、２引数関数です。 引数それ
     ぞれは、級数の中の項の係数と三角関数部です。

 -- 関数: poisplus (<a>, <b>)

     関数的に‘intopois (a + b)’と同一です。

 -- 関数: poissimp (<a>)

     <a>を、一般表現の<a>に関するPoisson級数に変換します。

 -- 特殊シンボル: poisson

     シンボル‘/P/’は、Poisson級数式の行ラベルに続きます。

 -- 関数: 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)’をもたらします。

 -- 関数: poistimes (<a>, <b>)

     ‘intopois (<a>*<b>)’と同じ機能です。

 -- 関数: poistrim ()

     (もしユーザーがそれを定義したら) Poisson乗算の間、適用する予約関数
     です。 項の中の<u>, <v>, ..., <z>の係数を引数とする６引数の述語論理
     関数です。 (この項の係数に関して)‘poistrim’が‘true’の項は、 乗算の
     間に消去されます。

 -- 関数: printpois (<a>)

     可読フォーマットでPoisson級数を印字します。 ‘outofpois’と共通で、 も
     し必要なら、<a>を最初にPoisson符号に変換します。


File: maxima.info,  Node: Number Theory,  Next: Symmetries,  Prev: Sums Products and Series,  Up: Top

29 Number Theory
****************

* Menu:

* Functions and Variables for Number Theory::


File: maxima.info,  Node: Functions and Variables for Number Theory,  Prev: Number Theory,  Up: Number Theory

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

 -- 関数: bernpoly (<x>, <n>)

     変数<x>に関する<n>番目のBernoulli多項式を返します。

 -- 関数: bfzeta (<s>, <n>)

     引数<s>に関するRiemannのゼータ関数を返します。 戻り値は多倍長浮動小
     数点(bfloat)です; <n>は戻り値の小数点以下の桁数です。

 -- 関数: bfhzeta (<s>, <h>, <n>)

     引数<s>と<h>に関するHurwitzのゼータ関数を返します。 戻り値は多倍長
     浮動小数点(bfloat)です; <n>は戻り値の小数点以下の桁数です。

     Hurwitzゼータ関数は以下のように定義されます。

                                  inf
                                  ====
                                  \        1
                   zeta (s,h)  =   >    --------
                                  /            s
                                  ====  (k + h)
                                  k = 0

     ‘load ("bffac")’はこの関数をロードします。

 -- 関数: 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’も参照してください
     。

 -- 関数: 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]

 -- 関数: 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

 -- 関数: 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

 -- オプション変数: 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]

 -- 関数: 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

 -- 関数: 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]

 -- 関数: 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]

 -- 関数: 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

 -- 関数: 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

 -- 関数: igcdex (<n>, <k>)

     リスト ‘[<a>, <b>, <u>]’を返します。 ここで、 <u>は<n>と <k>の最大
     公約数で、 <u>は ‘<a> <n> + <b> <k>’に等しいです。 引数 <n>と <k>は
     整数でなければいけません。

     ‘igcdex’はユークリッドのアルゴリズムを実装します。 *note 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]

 -- 関数: 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]

 -- 関数: 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

 -- 関数: isqrt (<x>)

     整数 <x>の絶対値の「整数平方根」を返します。

 -- 関数: 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]

 -- 関数: lcm (<expr_1>, ..., <expr_n>)

     引数の最小公倍数を返します。 引数は、整数はもちろん一般式を取り得ま
     す。

     ‘load ("functs")’はこの関数をロードします。

 -- 関数: 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

 -- 関数: next_prime (<n>)

     <n>よりも大きな最も小さな素数を返します。

          (%i1) next_prime(27);
          (%o1)                       29

 -- 関数: 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

 -- 関数: primep (<n>)

     素数テスト。 もし‘primep (<n>)’が‘false’を返すなら、 <n>は合成数で
     あり、 もし‘true’を返すなら、<n>は非常に高い確立で素数です。

     3317044064679887385961981より小さな<n>に対して、 Miller-Rabinのテス
     トの決定的バージョンが使われます。 もし‘primep (<n>)’が‘true’を返す
     なら、 <n>は素数です。

     3317044064679887385961981よりの大きな<n>に対して、 ‘primep’は、
     ‘primep_number_of_tests’個のMiller-Rabinの疑似素数テストと 1つの
     Lucasの疑似素数テストを使います。 <n>がMiller-Rabinのテスト１つを通
     過する確率は 1/4より小さいです。 ‘primep_number_of_tests’に関してデ
     フォルト値25を使うと、 通過した<n>が合成である確率は 10^-15よりもは
     るかに小さいです。

 -- オプション変数: primep_number_of_tests
     デフォルト値: 25

     ‘primep’の中で使われるMiller-Rabinのテストの回数。

 -- 関数: prev_prime (<n>)

     <n>よりも小さな最大の素数を返します。

          (%i1) prev_prime(27);
          (%o1)                       23

 -- 関数: 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

 -- 関数: totient (<n>)

     <n>以下の、 <n>と互いに素な整数の数を返します。

 -- オプション変数: zerobern
     デフォルト値: ‘true’

     ‘zerobern’が‘false’の時、 ‘bern’はBernoulli数を除外し、‘euler’はゼ
     ロに等しいEuler数を除外します。 ‘bern’と‘euler’を参照してください。

 -- 関数: 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

 -- オプション変数: 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)


File: maxima.info,  Node: Symmetries,  Next: Groups,  Prev: Number Theory,  Up: Top

30 Symmetries
*************

* Menu:

* Introduction to Symmetries::
* Functions and Variables for Symmetries::


File: maxima.info,  Node: Introduction to Symmetries,  Next: Functions and Variables for Symmetries,  Prev: Symmetries,  Up: Symmetries

30.1 Introduction to Symmetries
===============================

‘sym’は、多項式の対称群を扱うパッケージです。

   これは、 Annick Valibouze
(<https://web.archive.org/web/20061125035035/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.
     <https://web.archive.org/web/20061125035035/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.


File: maxima.info,  Node: Functions and Variables for Symmetries,  Prev: Introduction to Symmetries,  Up: Symmetries

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)]

 -- 関数: ele2pui (<m>, <L>)
     基本対称関数から完全関数に行きます。 ‘comp2ele’や‘comp2comp’に似て
     います。

     基数を変える他の関数: ‘comp2ele’.

 -- 関数: ele2comp (<m>, <L>)
     基本対称関数から完全関数に行きます。 ‘comp2ele’や‘comp2pui’に似てい
     ます。

     基数を変える他の関数: ‘comp2ele’.

 -- 関数: 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’.

 -- 関数: 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’.

 -- 関数: 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’.

 -- 関数: 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

 -- 関数: 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’.

 -- 関数: 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’.

 -- 関数: pui2ele (<n>, <lpui>)
     べき関数から基本対称関数への変転に影響します。 もしフラグ
     ‘pui2ele’が‘girard’なら、 1から<n>までの基本対称関数のリストを返し
     、 もしフラグが‘close’なら、 <n>番目の基本対称関数を返します。

     基数を変えるための他の関数: ‘comp2ele’.

 -- 関数: 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

 -- 関数: schur2comp (<P>, <l_var>)
     <P>はリスト<l_var>の変数の多項式です。 これらの変数のそれぞれは完全
     対称関数を表します。 <l_var>の中で、 <i>番目の完全対称関数は 文字
     ‘h’と整数<i>の連結‘h<i>’によって表されます。 この関数は <P>を
     Schur関数を使って表現します。

          (%i1) schur2comp (h1*h2 - h3, [h1, h2, h3]);
          (%o1)                         s
                                         1, 2
          (%i2) schur2comp (a*h3, [h3]);
          (%o2)                         s  a
                                         3

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

 -- 関数: 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

 -- 関数: explose (<pc>, <lvar>)
     短縮形<pc>に関連付けられた対称多項式を返します。 リスト<lvar>は変数
     を含みます。

          (%i1) explose (a*x + 1, [x, y, z]);
          (%o1)                  a z + a y + a x + 1

 -- 関数: part2cont (<ppart>, <lvar>)
     対称式を分割形から短縮形に変換します。 短縮形は<lvar>の中の変数で表
     されます。

          (%i1) part2cont ([[2*a^3*b, 4, 1]], [x, y]);
                                        3    4
          (%o1)                      2 a  b x  y

 -- 関数: partpol (<psym>, <lvar>)
     <psym>は リスト<lvar>の変数に関する対称多項式です。 この関数は分割
     表現を返します。

          (%i1) partpol (-a*(x + y) + 3*x*y, [x, y]);
          (%o1)               [[3, 1, 1], [- a, 1, 0]]

 -- 関数: tcontract (<pol>, <lvar>)
     多項式<pol>が リスト<lvar>の変数に関して対称かテストします。 もしそ
     うなら、関数‘contract’のように短縮表現を返します。

 -- 関数: tpartpol (<pol>, <lvar>)
     多項式<pol>が リスト<lvar>の中の変数に関して 対称かテストします。 も
     しそうなら 関数‘partpol’のように 分割表現を返します。

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’の中にあれば)。

 -- 関数: 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’。

 -- 関数: 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’。

 -- 関数: 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’も参照してくだ
     さい。

 -- 関数: 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 ]

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

 -- 関数: lgtreillis (<n>, <m>)
     重み<n>と長さ<m>の分割のリストを返します。

          (%i1) lgtreillis (4, 2);
          (%o1)                   [[3, 1], [2, 2]]
     以下も参照してください: ‘ltreillis’, ‘treillis’, ‘treinat’。

 -- 関数: ltreillis (<n>, <m>)
     重み<n>と<m>以下の長さの分割のリストを返します。

          (%i1) ltreillis (4, 2);
          (%o1)               [[4, 0], [3, 1], [2, 2]]
     以下も参照してください: ‘lgtreillis’, ‘treillis’, ‘treinat’。

 -- 関数: treillis (<n>)
     重み<n>の分割すべてを返します。

          (%i1) treillis (4);
          (%o1)    [[4], [3, 1], [2, 2], [2, 1, 1], [1, 1, 1, 1]]

     以下も参照してください: ‘lgtreillis’, ‘ltreillis’, ‘treinat’。

 -- 関数: 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’。

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’.

 -- 関数: 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>)’

 -- 関数: prodrac (<L>, <k>)
     <L>は 集合<A>上の基本対称関数を含む リストです。 ‘prodrac’は、 根が
     <A>の要素の <k>掛ける<k>の積の 多項式を返します。

     ‘somrac’も参照してください。

 -- 関数: 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’。

 -- 関数: somrac (<L>, <k>)
     リスト<L>は 多項式<P>の基本対称関数を含みます。 関数は 根が<P>の根
     の<k>掛ける<k>の別個の和である 多項式を計算します。

     ‘prodrac’も参照してください。

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’。

 -- 関数: 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’。

 -- 関数: 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’.

 -- 関数: 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’。

 -- 関数: 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’。

 -- 関数: 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’。

 -- 関数: 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’。

 -- 関数: resolvante_unitaire (<P>, <Q>, <x>)
     多項式‘<Q>(<x>)’によって 多項式‘<P>(<x>)’の解核を計算します。

     以下も参照してください:
     ‘resolvante_produit_sym’, ‘resolvante’,
     ‘resolvante_alternee1’, ‘resolvante_klein’, ‘resolvante_klein3’,
     ‘resolvante_vierer’, ‘resolvante_diedrale’。

 -- 関数: 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’。

30.2.7 Miscellaneous
--------------------

 -- 関数: multinomial (<r>, <part>)
     ここで<r>は分割<part>の重みです。 この関数は、同類の多項係数を返し
     ます: もし<part>の部分が <i_1>, <i_2>, ..., <i_k>なら、 結果は
     ‘<r>!/(<i_1>! <i_2>! ... <i_k>!)’ です。

 -- 関数: permut (<L>)
     リスト<L>の置換のリストを返します。


File: maxima.info,  Node: Groups,  Next: Runtime Environment,  Prev: Symmetries,  Up: Top

31 Groups
*********

* Menu:

* Functions and Variables for Groups::


File: maxima.info,  Node: Functions and Variables for Groups,  Prev: Groups,  Up: Groups

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


File: maxima.info,  Node: Runtime Environment,  Next: Miscellaneous Options,  Prev: Groups,  Up: Top

32 Runtime Environment
**********************

* Menu:

* Introduction for Runtime Environment::
* Interrupts::
* Functions and Variables for Runtime Environment::


File: maxima.info,  Node: Introduction for Runtime Environment,  Next: Interrupts,  Prev: Runtime Environment,  Up: Runtime Environment

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文を含むことがで
きます。


File: maxima.info,  Node: Interrupts,  Next: Functions and Variables for Runtime Environment,  Prev: Introduction for Runtime Environment,  Up: Runtime Environment

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が 止め
られた点から再開するようにします。


File: maxima.info,  Node: Functions and Variables for Runtime Environment,  Prev: Interrupts,  Up: Runtime Environment

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

 -- システム変数: maxima_tempdir

     ‘maxima_tempdir’は、Maximaが一時的なファイルを生成するディレクトリ
     を 指名します。 特に、プロットのための一時ファイルが
     ‘maxima_tempdir’に生成されます。

     ‘maxima_tempdir’の初期値は、 もしMaximaが置くことができるなら、ユー
     ザーのホームディレクトリです; そうでなければ、Maximaは適切なディレ
     クトリについて推量します。

     ‘maxima_tempdir’は、ディレクトリを指名する文字列に割り当てられます
     。

 -- システム変数: 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’を変えません; それらの変数
     は、別々に変更しなければいけません。

 -- 関数: room ()
 -- 関数: room (true)
 -- 関数: room (false)

     Maximaの記憶装置とスタックマネージメントの状態の描写を印字します。
     ‘room’は、同じ名前のLisp関数をコールします。

        • ‘room ()’は、適度の描写を印字します。
        • ‘room (true)’は、言葉数の多い描写を印字します。
        • ‘room (false)’は、簡潔な描写を印字します。

 -- 関数: sstatus (<keyword>, <item>)

     <keyword>がシンボル‘feature’の時、<item>がシステムフィーチャのリス
     ト上に追加されます。 ‘sstatus (keyword, item)’が実行された後、
     ‘status (feature, item)’は‘true’を返します。 もし<keyword>がシンボ
     ル‘nofeature’なら、 <item>はシステムフィーチャのリストから削除され
     ます。 これはパッケージ作者が、搭載したフィーチャの追跡をするのに役
     に立つかもしれません。

     ‘status’も参照してください。

 -- 関数: 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’を参照してください。

 -- 関数: 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’を設定してください。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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


File: maxima.info,  Node: Miscellaneous Options,  Next: Rules and Patterns,  Prev: Runtime Environment,  Up: Top

33 Miscellaneous Options
************************

* Menu:

* Introduction to Miscellaneous Options::
* Share::
* Functions and Variables for Miscellaneous Options::


File: maxima.info,  Node: Introduction to Miscellaneous Options,  Next: Share,  Prev: Miscellaneous Options,  Up: Miscellaneous Options

33.1 Introduction to Miscellaneous Options
==========================================

この節では、Maximaの操作上、グローバルな効果を持つ様々なオプションが論じ
られます。 すべてのユーザー定義関数のリストのような様々なリストも論じら
れます。


File: maxima.info,  Node: Share,  Next: Functions and Variables for Miscellaneous Options,  Prev: Introduction to Miscellaneous Options,  Up: Miscellaneous Options

33.2 Share
==========

Maximaの「共有」ディレクトリは、Maximaユーザーのためのものですが、
Maximaのコア実装の部分ではない、プログラムと他のファイルを含みます。 こ
れらのプログラムは、通常、 ‘load’や ‘setup_autoload’によってロードされま
す。

   ‘:lisp *maxima-sharedir*’は、 ユーザーのファイルシステム内の共有ディ
レクトリの位置を表示します。

   ‘printfile ("share.usg")’は、 共有パッケージの期限切れリストを印字し
ます。 ユーザーは、 ファイルシステムブラウザを使って共有ディレクトリをブ
ラウズすることがもっと情報が得られることを知るでしょう。


File: maxima.info,  Node: Functions and Variables for Miscellaneous Options,  Prev: Share,  Up: Miscellaneous Options

33.3 Functions and Variables for Miscellaneous Options
======================================================

 -- 宣言: alphabetic

     ‘alphabetic’は、 ‘declare’が認識する宣言タイプです。 式
     ‘declare(<s>, alphabetic)’は、Maximaに <s>―は文字列でなければいけま
     せん―の中の文字のすべてをalphabeticとして認識するように 命じます。

     *note 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~]

 -- オプション変数: genindex
     デフォルト値: ‘i’

     ‘genindex’は、 必要な時、和の次の変数を生成するために使われる アル
     ファベットの接頭辞です。

 -- オプション変数: gensumnum
     デフォルト値: 0

     ‘gensumnum’は、 和の次の変数を生成するために使われる 数値接尾辞です
     。 もし‘false’に設定されているなら、 インデックスは数値接尾辞なしで
     ‘genindex’だけから成ります。

 -- 関数: 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>に関連づけられたプロパティすべての名前のリストを返します。

 -- 特殊シンボル: props

     ‘props’は、 ‘declare’関数で指定されたプロパティはもちろん、
     ‘atvalue’, ‘matchdeclare’, などが指定したような、 ‘infolists’で陽に
     言及されたもの以外の任意のプロパティ、を持つアトムです。

 -- 関数: propvars (<prop>)

     ‘props’リスト上の、 <prop>が示すプロパティを持つアトムのリストを返
     します。 従って， ‘propvars (atvalue)’は、atvalueを持つアトムのリス
     トを返します。

 -- 関数: 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

 -- 関数: 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

 -- 関数: rem (<atom>, <indicator>)

     <atom>から、<indicator>が示すプロパティを取り除きます。 ‘rem’は
     ‘put’の効果をひっくり返します。

     ‘rem’が呼び出された時、もし<atom>が<indicator>プロパティを持ってい
     たなら、‘rem’は‘done’を返します。もしそんなプロパティを持っていなか
     ったら‘false’を返します。

 -- 関数: 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’は引数をクォートします。

 -- 関数: remvalue (<name_1>, ..., <name_n>)
 -- 関数: remvalue (all)

     (添字付きもありえる)ユーザー変数<name_1>, ..., <name_n>の値をシステ
     ムから 取り除きます。

     ‘remvalue (all)’は、 removes the values of all variables in
     ‘values’―(Maximaが自動的に割り当てたものと対照的に) ユーザーが名前
     を与えた変数すべてのリスト― の中の変数すべての値を取り除きます。

     ‘values’も参照してください。

 -- 関数: rncombine (<expr>)

     同一の分母や、たがいに数値因子だけことなる分母を持つ <expr>のすべて
     の項を結合することで、 <expr>を変換します。 これは、‘combine’の振る
     舞いとわずかに違います。 ‘combine’は、同一分母を持つ項を集めます。

     ‘pfeformat: true’を設定し、‘combine’を使うことは、 ‘rncombine’を使
     って得られるものと似た結果をもたらしますが、 ‘rncombine’は、 クロス
     積の数値的分母因子のおまけのステップを実行します。 これは、きれいな
     形式と、いくつかの相殺を認識する可能性を生みます。

     ‘load("rncomb")’はこの関数をロードします。

 -- 関数: scalarp (<expr>)

     もし<expr>が、数か、定数、 ‘declare’で‘scalar’と宣言された変数、 数
     と定数とそんな変数から完全に構成され、行列やリストを含まない変数な
     ら、 ‘true’を返します。

 -- 関数: 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


File: maxima.info,  Node: Rules and Patterns,  Next: Sets,  Prev: Miscellaneous Options,  Up: Top

34 Rules and Patterns
*********************

* Menu:

* Introduction to Rules and Patterns::
* Functions and Variables for Rules and Patterns::


File: maxima.info,  Node: Introduction to Rules and Patterns,  Next: Functions and Variables for Rules and Patterns,  Prev: Rules and Patterns,  Up: Rules and Patterns

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’パッ
ケージの可換/非可換代数用メカニズムがあります。


File: maxima.info,  Node: Functions and Variables for Rules and Patterns,  Prev: Introduction to Rules and Patterns,  Up: Rules and Patterns

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’も参照してください。

 -- 関数: apply2 (<expr>, <rule_1>, ..., <rule_n>)

     もし<rule_1>が与えられた部分式上で失敗したら、 <rule_2>が繰り返し適
     用されます、などなど。 すべてのルールが与えられた部分式上で失敗した
     時だけ、 ルールの全組が次の部分式に繰り返し適用されます。 もしルー
     ルの１つが成功したら、 同じ部分式が最初のルールから再処理されます。

     ‘maxapplydepth’は、 ‘apply1’と‘apply2’が処理する最も深い部分式の深
     さです。

     ‘apply1’と‘let’も参照してください。

 -- 関数: applyb1 (<expr>, <rule_1>, ..., <rule_n>)

     失敗するまで、繰り返し <expr>の最も深い部分式に <rule_1>を適用し、
     その後、 <rule_1>がトップレベルの式で失敗するまで、 同じルールを１
     つ高いレベル(すなわち、より大きな部分式)に適用します。 その後、
     <rule_2>が<rule_1>の結果に 同様に適用されます。 <rule_n>がトップレ
     ベルの式に適用された後、結果が返されます。

     ‘applyb1’は ‘apply1’に似ていますが、 トップダウンからの代わりにボト
     ムアップから働きます。

     ‘maxapplyheight’は ‘applyb1’が、あきらめる前に届く 最大の高さです

     ‘apply1’, ‘apply2’, ‘let’も参照してください。

 -- オプション変数: 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’の値は変わりません。

 -- オプション変数: default_let_rule_package
     デフォルト値: ‘default_let_rule_package’

     ‘default_let_rule_package’は、 ‘let’でユーザーによって、 また、
     ‘current_let_rule_package’の値を変更することによって、 陽に設定され
     ない時使われる ルールルールの名前です。

 -- 関数: 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)]

 -- 関数: defrule (<rulename>, <pattern>, <replacement>)

     与えられたパターンに関する置き換えルールを定義し、名付けます。 もし
     <rulename>と名付けられたルールが (‘apply1’, ‘applyb1’, ‘apply2’によ
     って) 式に適用されるなら、 パターンにマッチするすべての部分式は
     replacementで置き換えられます。 パターンマッチが値を割り当てる
     replacementの中の変数すべては その後整理される置き換えの中のそれら
     の値を割り当てられます。

     ルールそれ自身は、 パターンマッチと置き換えの１演算で式を変換する 関
     数として扱うことができます。 マッチが失敗したら、ルール関数は
     ‘false’を返します。

 -- 関数: 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) -> []]

 -- 関数: 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

 -- オプション変数: 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)!

 -- 関数: 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’が
     定義するルールを表示します。

 -- 関数: 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>’と同値です。

 -- オプション変数: let_rule_packages
     デフォルト値: ‘[default_let_rule_package]’

     ‘let_rule_packages’は、 デフォルトパッケージ
     ‘default_let_rule_package’に加える ユーザー定義のletルールパッケー
     ジすべてのリストです。

 -- 関数: 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)]

 -- オプション変数: maxapplydepth
     デフォルト値: 10000

     ‘maxapplydepth’は ‘apply1’と ‘apply2’が探索する 最大深さです。

 -- オプション変数: maxapplyheight
     デフォルト値: 10000

     ‘maxapplyheight’は ‘applyb1’があきらめる前に到達する 最大高さです。

 -- 関数: 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’で定義され
     たルールを削除します。

 -- 関数: 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)]

 -- 関数: 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)

 -- 関数: 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

 -- 関数: clear_rules ()

     ‘kill (rules)’を実行し、 足し算‘+’, 掛け算‘*’, べき‘^’に関して 次の
     ルール番号を1に再設定します。


File: maxima.info,  Node: Sets,  Next: Function Definition,  Prev: Rules and Patterns,  Up: Top

35 Sets
*******

* Menu:

* Introduction to Sets::
* Functions and Variables for Sets::


File: maxima.info,  Node: Introduction to Sets,  Next: Functions and Variables for Sets,  Prev: Sets,  Up: Sets

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}

   節*note Functions and Variables for Sets::は、 Maximaの集合関数の完全
なリストを持ちます。

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の集合関数とそれらのドキュメンテ
ーションを書きました。


File: maxima.info,  Node: Functions and Variables for Sets,  Prev: Introduction to Sets,  Up: Sets

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}

 -- 関数: 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)]

 -- 関数: 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

 -- 関数: 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]}

 -- 関数: 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}

 -- 関数: 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

 -- 関数: 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)}

 -- 関数: 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

 -- 関数: emptyp (<a>)

     <a>が空の集合か空のリストの時だけ、‘true’を返します。

     例:

          (%i1) map (emptyp, [{}, []]);
          (%o1)                     [true, true]
          (%i2) map (emptyp, [a + b, {{}}, %pi]);
          (%o2)                 [false, false, false]

 -- 関数: 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}}

 -- 関数: 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

 -- 関数: 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)}

 -- 関数: 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);

 -- 関数: 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])]))

 -- 関数: 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])}

 -- 関数: 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]}

 -- 関数: intersect (<a_1>, ..., <a_n>)

     ‘intersect’は、以下に見る‘intersection’と同じです。

 -- 関数: 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)                          {}

 -- 関数: 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})

 -- 関数: 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

 -- 関数: 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)}

 -- 関数: 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}

 -- 関数: 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

 -- 関数: 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)

 -- 関数: 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)

 -- 関数: 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}]

 -- 関数: 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]}

 -- 関数: 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)                         {{}}

 -- 関数: 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]

 -- 関数: 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

 -- 関数: 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)                          {}

 -- 関数: 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

 -- 関数: 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}

 -- 関数: 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

 -- 関数: 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}}

 -- 関数: 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

 -- 関数: 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!

 -- 関数: 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

 -- 関数: 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}

 -- 関数: 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

 -- 関数: 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}

 -- 関数: 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)

 -- 関数: 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}

 -- 関数: 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]


File: maxima.info,  Node: Function Definition,  Next: Program Flow,  Prev: Sets,  Up: Top

36 Function Definition
**********************

* Menu:

* Introduction to Function Definition::
* Function::
* Macros::
* Functions and Variables for Function Definition::


File: maxima.info,  Node: Introduction to Function Definition,  Next: Function,  Prev: Function Definition,  Up: Function Definition

36.1 Introduction to Function Definition
========================================


File: maxima.info,  Node: Function,  Next: Macros,  Prev: Introduction to Function Definition,  Up: Function Definition

36.2 Function
=============

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>)’を除いて、
記憶された値すべてを一度に削除する方法はありません。


File: maxima.info,  Node: Macros,  Next: Functions and Variables for Function Definition,  Prev: Function,  Up: Function Definition

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)

 -- 関数: 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

 -- 関数: 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

 -- Global variable: macros
     デフォルト値: ‘[]’

     ‘macros’は、ユーザー定義のマクロ関数のリストです。 マクロ関数定義演
     算子‘::=’は、このリストに新しいマクロ関数を入れ、 ‘kill’, ‘remove’,
     ‘remfunction’はリストからマクロ関数を削除します。

     ‘infolists’も参照してください。

 -- 関数: 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<>


File: maxima.info,  Node: Functions and Variables for Function Definition,  Prev: Macros,  Up: Function Definition

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)

 -- 関数: 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’を使うことはできません。

     ブロックは、典型的な場合、関数定義の右辺に現れますが、他の場所でも
     使うことができます。

 -- 関数: break (<expr_1>, ..., <expr_n>)

     <expr_1>, ..., <expr_n>を評価し、印字し、それから ユーザーが環境を
     検査し変更できるところでMaximaブレイクを引き起こします。 ‘exit;’を
     タイプすると、計算が再開されます。

 -- 関数: 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’の最初の負の要素を「キャッチ」して、それを「スロー」
     します。

 -- 関数: 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’も参照してください。

 -- 関数: compile (<f_1>, ..., <f_n>)
 -- 関数: compile (functions)
 -- 関数: compile (all)

     Maxima関数<f_1>, ..., <f_n>をLispに翻訳し、 Lisp翻訳を評価し、 翻訳
     された関数それぞれについてLisp関数‘COMPILE’をコールします。
     ‘compile’は、コンパイルされた関数名のリストを返します。

     ‘compile (all)’や‘compile (functions)’は、 ユーザー定義関数すべてを
     コンパイルします。

     ‘compile’は引数をクォートします; クォートクォート演算子‘''’はクォー
     トに優先します。

 -- 関数: 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)

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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)

 -- 関数: fullmapl (<f>, <list_1>, ...)

     ‘fullmap’に似ていますが、‘fullmapl’はリストや行列にのみマップします
     。

     例:

          (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
          (%o1)                [[a + 3, 4], [4, 3.5]]

 -- システム変数: 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]

 -- 関数: fundef (<f>)

     関数<f>の定義を返します。

     引数は、(‘::=’で定義された）マクロの名前か、 (‘:=’もしくは
     ‘define’で定義された）通常の関数か、 (‘:=’や‘define’で定義され、引
     数がカギ括弧でくくられた）配列関数か、 (‘:=’や‘define’で定義され、
     いくつかの引数がカギ括弧でくくられ、残りがかっこでくくられた）添字
     関数か、 特別な添字の値によって選択された添字関数族の１つか、一定の
     添字で定義された添字関数です。

     ‘fundef’は引数をクォートします; クォートクォート演算子‘''’はクォー
     トに優先します。

     ‘fundef (<f>)’は<f>の定義を返します。 対照的に、‘dispfun (<f>)’は中
     間式ラベルを生成し、ラベルに定義を割り当てます。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- オプション変数: 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

 -- オプション変数: mode_checkp
     デフォルト値: ‘true’

     ‘mode_checkp’が‘true’の時、 ‘mode_declare’はバインドされた変数のモ
     ードをチェックします。

 -- オプション変数: mode_check_errorp
     デフォルト値: ‘false’

     ‘mode_check_errorp’が‘true’の時、 ‘mode_declare’はエラーをコールし
     ます。

 -- オプション変数: mode_check_warnp
     デフォルト値: ‘true’

     ‘mode_check_warnp’が‘true’の時、 モードエラーが記述されます。

 -- 関数: 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’と同義です。

 -- 関数: 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’を使うことです。

 -- 関数: remfunction (<f_1>, ..., <f_n>)
 -- 関数: remfunction (all)

     シンボル<f_1>, ..., <f_n>の関数定義をアンバインドします。 引数は、
     （‘:=’もしくは‘define’で生成された）通常の関数名もしくは（‘::=’で生
     成された）マクロ関数をとります。

     ‘remfunction (all)’は関数定義すべてをアンバインドします。

     ‘remfunction’は引数をクォートします。

     ‘remfunction’は、関数定義はアンバインドされたシンボルのリストを返し
     ます。 シンボルに関数定義がなければ、シンボルの代わりに‘false’を返
     します。

     ‘remfunction’は配列関数すなわち添字付き関数には適用されません。 こ
     れらのタイプの関数には‘remarray’を適用します。

 -- オプション変数: savedef
     デフォルト値: ‘true’

     ‘savedef’が‘true’の時、 関数が解釈される時に ユーザー関数のMaximaバ
     ージョンが保持されます。 これは、定義が‘dispfun’によって表示される
     ことを許し、 関数が編集されることを許します。

     ‘savedef’が‘false’の時、 解釈された関数の名前は、‘functions’リスト
     から取り除かれます。

 -- オプション変数: transcompile
     デフォルト値: ‘true’

     ‘transcompile’が‘true’の時、 ‘translate’と‘translate_file’は 翻訳コ
     ードをコンパイルにより適したものにする宣言を生成します。

     ‘compfile’は実行中‘transcompile: true’を設定します。

 -- 関数: 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’が返す結果は、翻訳された関数名のリストです。

 -- 関数: 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’
     も参照してください。

 -- オプション変数: transrun
     デフォルト値: ‘true’

     ‘transrun’が‘false’の時、 すべての関数について、翻訳バージョンでは
     なく、 インタープリトされるバージョン(まだあると仮定して)が実行され
     るようにします。

 -- オプション変数: 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’は効果を
     持ちません。

 -- オプション変数: tr_bound_function_applyp
     デフォルト値: ‘true’

     ‘tr_bound_function_applyp’が‘true’の時、 もし(関数引数のような)バイ
     ンドされた変数が関数として使われていることが見つかったら Maximaは警
     告を与えます。 ‘tr_bound_function_applyp’は、 そんな場合に生成され
     たコードに影響しません。

     例えば、 ‘g (f, x) := f (x+1)’のような式は警告メッセージをトリガー
     します。

 -- オプション変数: tr_file_tty_messagesp
     デフォルト値: ‘false’

     ‘tr_file_tty_messagesp’が‘true’の時、 ファイルの翻訳中に
     ‘translate_file’が生成するメッセージがコンソールに表示され、
     ‘false’の時、ファイルの翻訳に関するメッセージは UNLISPファイルに挿
     入されるだけです。

 -- オプション変数: 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’です。

 -- オプション変数: tr_function_call_default
     デフォルト値: ‘general’

     ‘false’は、あきらめて‘meval’をコールすることを意味し、 ‘expr’は、引
     数が固定されたLisp関数を仮定することを意味します。 ‘general’、デフ
     ォルトは ‘mexprs’や‘mlexprs’にはよいが‘macros’にはよくないコードを
     与えます。 ‘general’は、コンパイルされたコードの中で変数バインドが
     正確であることを保証します。 ‘general’モードでは、 F(X)を翻訳する時
     、もしFがバインドされた変数なら、 ‘apply (f, [x])’を意味すると仮定
     され、適切な警告と合わせてそのように翻訳されます。 これをオフにする
     必要はありません。 デフォルト設定で警告メッセージがないことは、
     Maximaインタープリタと、翻訳、コンパイルされたコードの完全互換性を
     意味します。

 -- オプション変数: tr_numer
     デフォルト値: ‘false’

     ‘tr_numer’が‘true’の時、 ‘numer’プロパティは それらを持つアトム、例
     えば、‘%pi’に使われます。

 -- オプション変数: tr_optimize_max_loop
     デフォルト値: 100

     ‘tr_optimize_max_loop’は、 翻訳器のマクロ展開と最適化パスが形式を検
     討する際繰り返す最大回数です。 これはマクロ展開エラーや終了しない最
     適化プロパティをキャッチします。

 -- オプション変数: tr_semicompile
     デフォルト値: ‘false’

     ‘tr_semicompile’が‘true’の時、 ‘translate_file’と‘compfile’は、 マ
     クロ展開されたが、Lispコンパイラによって機械語にコンパイルされない
     形式を出力します。

 -- システム変数: 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]

     翻訳された出力の形式に影響するスイッチのリスト。 翻訳器をデバッグし
     ようとする時 この情報はシステムの人たちに役に立ちます。 翻訳された
     生成物を与えられた状態で生成されるべきだったものと比較することによ
     って、 バグを追跡することが可能です。

 -- 関数: tr_warnings_get ()

     現在の翻訳の間に翻訳器が与える警告のリストを印字します。

 -- オプション変数: tr_warn_bad_function_calls
     デフォルト値: ‘true’

     - 翻訳時にされた不適切な宣言のせいで正確でないかもしれない関数コー
     ルが行われている時、 警告を与えます。

 -- オプション変数: tr_warn_fexpr
     デフォルト値: ‘compfile’

     - もしFEXPRに遭遇したら、警告を与えます。 FEXPRは、通常、翻訳コード
     の中で出力されるべきではありません。 合法で特殊なプログラム形式はす
     べて翻訳されます。

 -- オプション変数: tr_warn_meval
     デフォルト値: ‘compfile’

     - もし関数‘meval’がコールされたら、警告を与えます。 もし‘meval’がコ
     ールされたら、それは翻訳の中の問題を示します。

 -- オプション変数: tr_warn_mode
     デフォルト値: ‘all’

     - 変数がそのモードに不適切な値を割り当てられた時、警告を与えます。

 -- オプション変数: tr_warn_undeclared
     デフォルト値: ‘compile’

     - 未宣言変数についての警告をいつTTYに送るかを決めます。

 -- オプション変数: tr_warn_undefined_variable
     デフォルト値: ‘all’

     - 未定義のグローバル変数が見られた時、警告を与えます。

 -- 関数: 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’は引数を評価します。

 -- 関数: declare_translated (<f_1>, <f_2>, ...)

     MaximaコードのファイルをLispに翻訳する時、 ファイルの中で見る関数が
     翻訳された関数としてコールされるか、コンパイルされた関数としてコー
     ルされるか、また、どの関数がMaxima関数か未定義なのか、翻訳器が知る
     ことは重要です。 この宣言をファイルの先頭に置くことは、 たとえまだ
     Lisp関数値を持たないシンボルがコール時にそれを持つだろうが、 それを
     知らせます。 ‘fn’がLisp関数になるつもりであることを翻訳器が知らない
     時、 ‘(MFUNCTION-CALL fn arg1 arg2 ...)’が生成されます。


File: maxima.info,  Node: Program Flow,  Next: Debugging,  Prev: Function Definition,  Up: Top

37 Program Flow
***************

* Menu:

* Lisp and Maxima::
* Garbage Collection::
* Introduction to Program Flow::
* Functions and Variables for Program Flow::


File: maxima.info,  Node: Lisp and Maxima,  Next: Garbage Collection,  Prev: Program Flow,  Up: Program Flow

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


File: maxima.info,  Node: Garbage Collection,  Next: Introduction to Program Flow,  Prev: Lisp and Maxima,  Up: Program Flow

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の制御の仕方に関する
ドキュメントを調べてください。


File: maxima.info,  Node: Introduction to Program Flow,  Next: Functions and Variables for Program Flow,  Prev: Garbage Collection,  Up: Program Flow

37.3 Introduction to Program Flow
=================================

Maximaは、 ‘go’のようなもっとプリミティブな構成子はもちろん、 繰り返しの
ために‘do’ループを提供します。


File: maxima.info,  Node: Functions and Variables for Program Flow,  Prev: Introduction to Program Flow,  Up: Program Flow

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

 -- 特殊演算子: 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

 -- 関数: errcatch (<expr_1>, ..., <expr_n>)

     <expr_1>, ..., <expr_n>を１つずつ評価し、 もしエラーが起こらないな
     ら、‘[<expr_n>]’ (リスト)を返します。 もしいずれかの引数の評価中に
     エラーが起こったら、 ‘errcatch’ はエラーが伝搬することを抑制し、 引
     数をこれ以上評価せずに空のリスト‘[]’を返します。

     ‘errcatch’は もしエラーがチャッチされないなら‘batch’を終了させるエ
     ラーが起こるかもしれないと疑うような ‘batch’ファイルで役立ちます。

 -- 関数: error (<expr_1>, ..., <expr_n>)
 -- システム変数: error

     <expr_1>, ..., <expr_n>を評価して印字します。 そして、エラーがあれ
     ば、トップレベルMaximaか直近の‘errcatch’に戻るようにします。

     変数‘error’はエラーを記述するリストに設定されます。 ‘error’の最初の
     要素はフォーマット文字列です。 引数<expr_1>, ..., <expr_n>の中の文
     字列すべてを結合したものです。 残りの要素は文字列でない引数の値です
     。

     ‘errormsg()’は‘error’をフォーマットし印字します。 これは直近のエラ
     ーメッセージを効果的に再印字します。

 -- オプション変数: 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);

 -- オプション変数: error_syms
     デフォルト値: ‘[errexp1, errexp2, errexp3]’

     エラーメッセージの中で、 ‘error_size’より大きな式はシンボルで置き換
     えられ、 シンボルは式に設定されます。 シンボルはリスト
     ‘error_syms’から取られます。 最初の大きすぎる式は、
     ‘error_syms[1]’で置き換えられ、 ２番目は、‘error_syms[2]’で置き換え
     られ、などなど。

     もし大きすぎる式が‘error_syms’の要素よりもあれば、 シンボルは自動的
     に構成されます。 <n>番目のシンボルは‘concat ('errexp, <n>)’と同値で
     す。

     ‘error’と‘error_size’も参照してください。

 -- 関数: errormsg ()

     直近のエラーメッセージを再印字します。 変数‘error’はメッセージを保
     持し、 ‘errormsg’はそれをフォーマットし印字します。

 -- オプション変数: 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

 -- 特殊演算子: for

     繰り返しで使われます。 Maximaの繰り返し機能の記述に関しては、‘do’を
     参照してください。

 -- 関数: go (<tag>)

     制御を ‘go’の引数でタグ付けされたブロックの文に移すために ‘block’内
     部で使われます。 文をタグ付けするには、 その文の前に、 アトムの引数
     を ‘block’の中の別の文として 先行させてください。 例えば:

          block ([x], x:1, loop, x+1, ..., go(loop), ...)

     ‘go’の引数は、同じ‘block’の中に現れるタグの名前でなければいけません
     。 ‘go’を含む‘block’以外の‘block’の中のタグに移るために、 ‘go’を使
     うことはできません。

 -- 特殊演算子: 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         論理 前置

 -- 関数: 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]


 -- 関数: mapatom (<expr>)

     <expr>がマップルーチンでアトムとして扱われる時だけ‘true’を返します
     。 "Mapatoms"はアトム、(有理数を含む)数、添字付き変数です。

 -- オプション変数: 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’なら、 上の２つの例に関して、エラーメッセージ
     が表示されます。

 -- オプション変数: mapprint
     デフォルト値: ‘true’

     ‘mapprint’が‘true’の時、 ‘map’, ‘mapl’, ‘fullmap’からの様々な情報メ
     ッセージが 一定の状況で生成されます。 これらは ‘map’が‘apply’を使っ
     たり、‘map’が 最短のリストで切り詰めているような状況を含みます。

     もし‘mapprint’が‘false’なら、これらのメッセージは抑制されます

 -- 関数: maplist (<f>, <expr_1>, ..., <expr_n>)
     式<expr_1>, ..., <expr_n>のパーツに<f>を適用した結果のリストを返し
     ます。 <f>は、関数名かラムダ式です。

     ‘maplist’は‘map (<f>, <expr_1>, ..., <expr_n>)’とは違います。 mapは
     主演算子が<expr_i>と同じ式を返します。 (整理と‘map’が‘apply’を行う
     場合は例外です。)

 -- オプション変数: prederror
     デフォルト値: ‘false’

     ‘prederror’が‘true’の時、 ‘if’文の述語論理か‘is’関数が ‘true’か
     ‘false’に評価されるのに失敗した時はいつでも エラーメッセージが表示
     されます。

     もし‘false’なら、この場合，代わりに‘unknown’が返されます。
     ‘prederror: false’モードは翻訳コードではサポートされません; しかし
     ながら、‘maybe’は翻訳コードでサポートされます。

     ‘is’と‘maybe’も参照してください。

 -- 関数: return (<value>)
     引数を連れて、陽にブロックから抜けるために使われます。 もっと情報を
     知るには、‘block’も参照してください。

 -- 関数: 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))

     この場合、両方の方法で同じ答えを得ます。

 -- 関数: throw (<expr>)

     <expr>を評価し、 直近の‘catch’に値を投げ戻します。 ‘throw’は、
     ‘catch’と一緒に、非ローカルリターンメカニズムとして使われます。

 -- 特殊演算子: while
 -- 特殊演算子: unless
     ‘do’を参照してください。

 -- 関数: 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


File: maxima.info,  Node: Debugging,  Next: asympa,  Prev: Program Flow,  Up: Top

38 Debugging
************

* Menu:

* Source Level Debugging::
* Keyword Commands::
* Functions and Variables for Debugging::


File: maxima.info,  Node: Source Level Debugging,  Next: Keyword Commands,  Up: Debugging

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に評価ような、 そのファイルウィンドウで利用可能な追加のコマンドが
あります。


File: maxima.info,  Node: Keyword Commands,  Next: Functions and Variables for Debugging,  Prev: Source Level Debugging,  Up: Debugging

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プロンプトに戻り
     ます。


File: maxima.info,  Node: Functions and Variables for Debugging,  Prev: Keyword Commands,  Up: Debugging

38.3 Functions and Variables for Debugging
==========================================

 -- オプション変数: debugmode
     デフォルト値: ‘false’

     もし‘debugmode’が ‘true’なら、 Maximaのエラーが起こった時Maximaはデ
     バッガーを開始します。 ユーザーはコールバックを検査したり、ブレイク
     ポイントを設定したり、Maximaコードをステップ実行したりなど コマンド
     を入力することができます。 デバッガーコマンドのリストに関しては、
     ‘debugging’を参照してください。

     ‘debugmode’をイネーブルにしても、Lispのエラーは捕らえられません。

 -- オプション変数: refcheck
     デフォルト値: ‘false’

     ‘refcheck’が‘true’の時、 Maximaは 計算の中で、バイドされた変数が最
     初に使われる度にメッセージを印字します。

 -- オプション変数: setcheck
     デフォルト値: ‘false’

     もし‘setcheck’が(添字付きでもよい)変数のリストに設定されているなら
     、 Maximaは 変数またはそれらの添字付き出現が通常の割り当て演算子
     ‘:’、‘::’割り当て演算子、 または関数引数バインドでバインドされた時
     (しかし関数割り当て‘:=’やマクロ割り当て‘::=’演算子でバインドされた
     時以外) はいつでも、 メッセージを印字します。 メッセージは変数名と
     バインドされた値から構成されます。

     ‘setcheck’は、 ‘all’または‘true’に設定することができ、 それによって
     、すべての変数を含みます。

     ‘setcheck’の新しい要素のそれぞれは、 チェックする変数の新しいリスト
     を確立し、 以前‘setcheck’に割り当てられたいかなる変数も忘れられます
     。

     もし自身以外の何かに評価されるなら、 ‘setcheck’に割り当てられた名前
     はクォートしなければいけません。 例えば、もし‘x’, ‘y’, ‘z’が既にバ
     インドされているなら、 チェックする変数のリストに置くには、

          setcheck: ['x, 'y, 'z]$

     をタイプしてください。

     ‘setcheck’リスト上の変数が、例えば、‘X: 'X’のように、 それ自身に割
     り当てられた時は、なにも印字されません。

 -- オプション変数: setcheckbreak
     デフォルト値: ‘false’

     ‘setcheckbreak’が‘true’の時、 ‘setcheck’リスト上の変数が新しい値を
     割り当てられた時はいつでも Maximaはブレイクプロンプトを出します。 ブ
     レイクは、割り当てが実行される前に起こります。 この時点で、
     ‘setval’が変数が割り当てられようとしている値を保持します。 ゆえに、
     ‘setval’に割り当てることで、違う値を割り当てることができます。

     ‘setcheck’と‘setval’も参照してください。

 -- システム変数: setval

     ‘setcheckbreak’が起こった時、変数が設定されようとしている値を保持し
     ます。 ゆえに、 ‘setval’に割り当てることで、違う値を割り当てること
     ができます。

     ‘setcheck’と‘setcheckbreak’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: untimer (<f_1>, ..., <f_n>)
 -- 関数: untimer ()

     ‘untimer’はタイマーリストから 与えられた関数<f_1>, ..., <f_n>それぞ
     れを削除します。

     引数なしの時、 ‘untimer’は、現在、タイマーリスト上の関数すべてを削
     除します。

     ‘untimer (f)’が実行された後、 ‘timer_info()’ (引数なし)は、 現在タ
     イマーリスト上にない関数についての情報を返しませんけれども、
     ‘timer_info (f)’は、まだ以前に集計されたタイミング統計を返します。
     ‘timer (f)’は、 タイミング統計すべてをゼロに再設定し、 ‘f’をタイマ
     ーリストに再び入れます。

 -- オプション変数: timer_devalue
     デフォルト値: ‘false’

     ‘timer_devalue’が‘true’の時、 Maximaは、計られる関数から 他の計測さ
     れる関数で費やされた時間を引きます。 そうでなければ、関数それぞれに
     ついて報告された時間は、 他の関数で計測される時間を含みます。 計測
     されない関数で費やされた時間は、総時間から引かれないことに注意して
     ください。

     ‘timer’と‘timer_info’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’は、同じ関数で同時には有効にできません。

 -- 関数: 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);

 -- 関数: untrace (<f_1>, ..., <f_n>)
 -- 関数: untrace ()

     ‘untrace’は、 与えられた関数<f_1>, ..., <f_n>について、 ‘trace’関数
     でイネーブルされたトレースをディセーブルします。 引数なしでは、
     ‘untrace’は関数すべてのトレースをディセーブルします。

     ‘untrace’はトレースをディセーブルした関数のリストを返します。


File: maxima.info,  Node: asympa,  Next: augmented_lagrangian,  Prev: Debugging,  Up: Top

39 asympa
*********

* Menu:

* Introduction to asympa::
* Functions and variables for asympa::


File: maxima.info,  Node: Introduction to asympa,  Next: Functions and variables for asympa,  Prev: asympa,  Up: asympa

39.1 Introduction to asympa
===========================

 -- 関数: asympa
     ‘asympa’は漸近解析パッケージです。 パッケージは、 複雑性解析と数値
     解析で広く使われている"ビッグO"と"リトルo"関数を含む、 漸近解析のた
     めの式整理関数を含みます。

     ‘load ("asympa")’はこのパッケージをロードします。


File: maxima.info,  Node: Functions and variables for asympa,  Prev: Introduction to asympa,  Up: asympa

39.2 Functions and variables for asympa
=======================================


File: maxima.info,  Node: augmented_lagrangian,  Next: Bernstein,  Prev: asympa,  Up: Top

40 augmented_lagrangian
***********************

* Menu:

* Functions and Variables for augmented_lagrangian::


File: maxima.info,  Node: Functions and Variables for augmented_lagrangian,  Prev: augmented_lagrangian,  Up: augmented_lagrangian

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


File: maxima.info,  Node: Bernstein,  Next: bode,  Prev: augmented_lagrangian,  Up: Top

41 Bernstein
************

* Menu:

* Functions and Variables for Bernstein::


File: maxima.info,  Node: Functions and Variables for Bernstein,  Prev: Bernstein,  Up: Bernstein

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")’。


File: maxima.info,  Node: bode,  Next: cobyla,  Prev: Bernstein,  Up: Top

42 bode
*******

* Menu:

* Functions and Variables for bode::


File: maxima.info,  Node: Functions and Variables for bode,  Prev: bode,  Up: bode

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’も参照してください。

 -- 関数: 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’も参照してください。


File: maxima.info,  Node: cobyla,  Next: contrib_ode,  Prev: bode,  Up: Top

43 cobyla
*********

* Menu:

* Introduction to cobyla::
* Functions and Variables for cobyla::
* Examples for cobyla::


File: maxima.info,  Node: Introduction to cobyla,  Next: Functions and Variables for cobyla,  Prev: cobyla,  Up: cobyla

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
<https://web.archive.org/web/20160607190705/http://www.damtp.cam.ac.uk:80/user/na/reports.html>


File: maxima.info,  Node: Functions and Variables for cobyla,  Next: Examples for cobyla,  Prev: Introduction to cobyla,  Up: cobyla

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")’はこの関数をロードします。


File: maxima.info,  Node: Examples for cobyla,  Prev: Functions and Variables for cobyla,  Up: cobyla

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ディレクトリにあります。


File: maxima.info,  Node: contrib_ode,  Next: descriptive,  Prev: cobyla,  Up: Top

44 contrib_ode
**************

* Menu:

* Introduction to contrib_ode::
* Functions and Variables for contrib_ode::
* Possible improvements to contrib_ode::
* Test cases for contrib_ode::
* References for contrib_ode::


File: maxima.info,  Node: Introduction to contrib_ode,  Next: Functions and Variables for contrib_ode,  Prev: contrib_ode,  Up: contrib_ode

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)’が実行されたら、 長いデ
バッグトレースとメッセージが表示されます。


File: maxima.info,  Node: Functions and Variables for contrib_ode,  Next: Possible improvements to contrib_ode,  Prev: Introduction to contrib_ode,  Up: contrib_ode

44.2 Functions and Variables for contrib_ode
============================================

 -- 関数: contrib_ode (<eqn>, <y>, <x>)

     独立変数<x>と従属変数<y>に関するODE <eqn>の解のリストを返します。

 -- 関数: 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

 -- 関数: 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

 -- システム変数: method

     変数‘method’は成功した解法に設定されます。

 -- 変数: %c

     ‘%c’は一階ODEの積分定数です。

 -- 変数: %k1

     ‘%k1’は二階ODEの最初の積分定数です。

 -- 変数: %k2

     ‘%k2’は二階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’も参照してください。

 -- 関数: gauss_b (<a>, <b>, <c>, <x>)
     See ‘gauss_a’.

 -- 関数: dgauss_a (<a>, <b>, <c>, <x>)
     ‘gauss_a(<a>, <b>, <c>, <x>)’の<x>に関する導関数。

 -- 関数: dgauss_b (<a>, <b>, <c>, <x>)
     ‘gauss_b(<a>, <b>, <c>, <x>)’の<x>に関する導関数。

 -- 関数: 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’も参照してください。

 -- 関数: kummer_u (<a>, <b>, <x>)

     Abramowitz and Stegun, Handbook of Mathematical Functions, Section
     13.1.3の中で定義される KummerのU関数

     ‘kummer_m’を参照してください。

 -- 関数: dkummer_m (<a>, <b>, <x>)
     ‘kummer_m(<a>, <b>, <x>)’の<x>に関する導関数。

 -- 関数: dkummer_u (<a>, <b>, <x>)
     ‘kummer_u(<a>, <b>, <x>)’の<x>に関する導関数。


File: maxima.info,  Node: Possible improvements to contrib_ode,  Next: Test cases for contrib_ode,  Prev: Functions and Variables for contrib_ode,  Up: contrib_ode

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の相当な問
     題があります: いくつかの部分が未実装です; いくつかのテストケースが
     無限ループのようです; 他のテストケースではクラッシュします; さらに
     他では非常に複雑な「解」を返します。 本当にリリースの準備ができてい
     たか疑っています。

   • もっとテストケースを追加すること。


File: maxima.info,  Node: Test cases for contrib_ode,  Next: References for contrib_ode,  Prev: Possible improvements to contrib_ode,  Up: contrib_ode

44.4 Test cases for contrib_ode
===============================

Murphy, Kamke, Zwillingerと他で ルーチンはおおよそ千のテストケース上でテ
ストされています。 これらはテストサブディレクトリに含まれています。

   • The Clairaultルーチン‘ode1_clairault’は、 特異解を含み、 Murphyと
     Kamkeの中のClairault方程式の 知られている解すべてを見つけます。

   • 他のルーチンは、多重解が存在する時に しばしば単一界を返します。

   • ‘ode1_lie’の「解」のいくつかは過度に複雑でチェックが不可能です。

   • いくつかのクラッシュがあります。


File: maxima.info,  Node: References for contrib_ode,  Prev: Test cases for contrib_ode,  Up: contrib_ode

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


File: maxima.info,  Node: descriptive,  Next: diag,  Prev: contrib_ode,  Up: Top

45 descriptive
**************

* Menu:

* Introduction to descriptive::
* Functions and Variables for data manipulation::
* Functions and Variables for descriptive statistics::
* Functions and Variables for statistical graphs::


File: maxima.info,  Node: Introduction to descriptive,  Next: Functions and Variables for data manipulation,  Prev: descriptive,  Up: descriptive

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 ]


File: maxima.info,  Node: Functions and Variables for data manipulation,  Next: Functions and Variables for descriptive statistics,  Prev: Introduction to descriptive,  Up: descriptive

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

 -- 関数: 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’は最後の入力を理解するのを助けるはずで
     す。

 -- 関数: 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


File: maxima.info,  Node: Functions and Variables for descriptive statistics,  Next: Functions and Variables for statistical graphs,  Prev: Functions and Variables for data manipulation,  Up: descriptive

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]

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’.

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’.

 -- 関数: 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’も参照してください。

 -- 関数: 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]

 -- 関数: 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]

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。


File: maxima.info,  Node: Functions and Variables for statistical graphs,  Prev: Functions and Variables for descriptive statistics,  Up: descriptive

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’も参照してください。

 -- 関数: 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)$

 -- 関数: 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))$

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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 ) $

 -- 関数: 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


File: maxima.info,  Node: diag,  Next: distrib,  Prev: descriptive,  Up: Top

46 diag
*******

* Menu:

* Functions and Variables for diag::


File: maxima.info,  Node: Functions and Variables for diag,  Prev: diag,  Up: diag

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")’を書いてください。

 -- 関数: 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")’を書いてください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: 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")’を書いてください。


File: maxima.info,  Node: distrib,  Next: draw,  Prev: diag,  Up: Top

47 distrib
**********

* Menu:

* Introduction to distrib::
* Functions and Variables for continuous distributions::
* Functions and Variables for discrete distributions::


File: maxima.info,  Node: Introduction to distrib,  Next: Functions and Variables for continuous distributions,  Prev: distrib,  Up: distrib

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'>に連絡くだ
さい。


File: maxima.info,  Node: Functions and Variables for continuous distributions,  Next: Functions and Variables for discrete distributions,  Prev: Introduction to distrib,  Up: distrib

47.2 Functions and Variables for continuous distributions
=========================================================

 -- 関数: pdf_normal (<x>,<m>,<s>)
     s>0で Normal(m,s)(正規)確率変数の密度函数の <x>での値を返します。 こ
     の関数を利用するには、初めに ‘load("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’も参照してください。

 -- 関数: 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

 -- 関数: mean_normal (<m>,<s>)
     s>0で Normal(m,s)(正規)確率変数の平均、すなわち <m>を返します。 こ
     の関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_normal (<m>,<s>)
     s>0で Normal(m,s)(正規)確率変数の分散、すなわち <s^2>を返します。 こ
     の関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_normal (<m>,<s>)
     s>0で Normal(m,s)(正規)確率変数の分散、すなわち <s>を返します。 こ
     の関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_normal (<m>,<s>)
     s>0で Normal(m,s)(正規)確率変数の歪度を返します。それは常に0に等し
     いです。 この関数を利用するには、初めに ‘load("distrib")’を書いてく
     ださい。

 -- 関数: kurtosis_normal (<m>,<s>)
     s>0で Normal(m,s)(正規)確率変数の尖度を返します。それは常に0に等し
     いです。 この関数を利用するには、初めに ‘load("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")’を書いてください。

 -- 関数: pdf_student_t (<x>,<n>)
     n>0自由度のStudent確率変数 t(n)の密度函数の <x>での値を返します。 こ
     の関数を利用するには、初めに ‘load("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

 -- 関数: quantile_student_t (<q>,<n>)
     n>0自由度のStudent確率変数 t(n)の <q>-分位数を返します。 言い換える
     と、これは ‘cdf_student_t’の逆函数です。 引数 <q>は [0,1]の要素でな
     ければいけません。 この関数を利用するには、初めに
     ‘load("distrib")’を書いてください。

 -- 関数: mean_student_t (<n>)
     n>0自由度のStudent確率変数 t(n)の平均を返します。 それはいつも0に等
     しいです。 この関数を利用するには、初めに ‘load("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

 -- 関数: std_student_t (<n>)
     n>2自由度のStudent確率変数 t(n)の標準偏差を返します。 この関数を利
     用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_student_t (<n>)
     n>3自由度のStudent確率変数 t(n)の歪度係数を返します。 それはいつも
     0に等しいです。 この関数を利用するには、初めに ‘load("distrib")’を
     書いてください。

 -- 関数: kurtosis_student_t (<n>)
     n>4自由度のStudent確率変数 t(n)の尖度係数を返します。 この関数を利
     用するには、初めに ‘load("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")’を書いてください。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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")’を書いてください。

 -- 関数: 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

 -- 関数: var_noncentral_student_t (<n>,<ncp>)
     n>2自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数
     nc_t(n,ncp)の分散を返します。 この関数を利用するには、初めに
     ‘load("distrib")’を書いてください。

 -- 関数: std_noncentral_student_t (<n>,<ncp>)
     n>2自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数
     nc_t(n,ncp)の標準偏差を返します。 この関数を利用するには、初めに
     ‘load("distrib")’を書いてください。

 -- 関数: skewness_noncentral_student_t (<n>,<ncp>)
     n>3自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数
     nc_t(n,ncp)の歪度係数を返します。 この関数を利用するには、初めに
     ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_noncentral_student_t (<n>,<ncp>)
     n>3自由度で非中心度パラメータ ncpを持つ 非中心Student確率変数
     nc_t(n,ncp)の尖度係数を返します。 この関数を利用するには、初めに
     ‘load("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")’を書いてください。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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)

 -- 関数: 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)

 -- 関数: 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

 -- 関数: random_chi2 (<n>)
 -- 関数: random_chi2 (<n>,<m>)
     n>0で、カイ二乗確率変量 Chi^2(n)を返します。 二番目の引数 <m>ととも
     に‘random_chi2’をコールすると、 サイズ <m>のランダムな標本がシミュ
     レートされます。

     シミュレーションはAhrens-Chengアルゴリズムに基づきます。 詳細は
     ‘random_gamma’を参照してください。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: pdf_noncentral_chi2 (<x>,<n>,<ncp>)
     n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数
     nc_Chi^2(n,ncp)の 密度函数の <x>での値を返します。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: cdf_noncentral_chi2 (<x>,<n>,<ncp>)
     n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数
     nc_Chi^2(n,ncp)の 分布函数の <x>での値を返します。 この関数を利用す
     るには、初めに ‘load("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’に等
     しいなら、 数値的に計算され、 そうでなければ、名目上の式を返します
     。

 -- 関数: mean_noncentral_chi2 (<n>,<ncp>)
     n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数
     nc_Chi^2(n,ncp)の 平均を返します。

 -- 関数: var_noncentral_chi2 (<n>,<ncp>)
     n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数
     nc_Chi^2(n,ncp)の 分散を返します。

 -- 関数: std_noncentral_chi2 (<n>,<ncp>)
     n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数
     nc_Chi^2(n,ncp)の 標準偏差を返します。

 -- 関数: skewness_noncentral_chi2 (<n>,<ncp>)
     n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数
     nc_Chi^2(n,ncp)の 歪度係数を返します。

 -- 関数: kurtosis_noncentral_chi2 (<n>,<ncp>)
     n>0と非中心度パラメータ ncp>=0を持つ 非中心カイ二乗確率変数
     nc_Chi^2(n,ncp)の 尖度係数を返します。

 -- 関数: 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")’を書いてください。

 -- 関数: pdf_f (<x>,<m>,<n>)
     m,n>0で、F確率変数 F(m,n)の密度関数の <x>の値を返します。

     この関数を利用するには、初めに ‘load("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

 -- 関数: 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

 -- 関数: mean_f (<m>,<n>)
     m,n>2で、F確率変数 F(m,n)の 平均を返します。 この関数を利用するには
     、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_f (<m>,<n>)
     m,n>4で、F確率変数 F(m,n)の 分散を返します。 この関数を利用するには
     、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_f (<m>,<n>)
     m,n>4で、F確率変数 F(m,n)の 標準偏差を返します。 この関数を利用する
     には、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_f (<m>,<n>)
     m,n>6で、F確率変数 F(m,n)の 歪度係数を返します。 この関数を利用する
     には、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_f (<m>,<n>)
     m,n>8で、F確率変数 F(m,n)の 尖度係数を返します。 この関数を利用する
     には、初めに ‘load("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")’を書いてください。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: random_exp (<m>)
 -- 関数: random_exp (<m>,<k>)
     m>0で、 Exponential(m)(指数)確率変量を返します。 二番目の引数 <k>と
     ともに‘random_exp’をコールすると、 サイズ <k>のランダムな標本がシミ
     ュレートされます。

     シミュレーションアルゴリズムは一般逆函数法です。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: pdf_lognormal (<x>,<m>,<s>)
     s>0で、Lognormal(m,s)(対数正規)確率変数の 密度函数の <x>での値を返
     します。

     この関数を利用するには、初めに ‘load("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’も参照してください。

 -- 関数: 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

 -- 関数: mean_lognormal (<m>,<s>)
     s>0で、Lognormal(m,s)(対数正規)確率変数の 平均を返します。 この関数
     を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_lognormal (<m>,<s>)
     s>0で、Lognormal(m,s)(対数正規)確率変数の 分散を返します。 この関数
     を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_lognormal (<m>,<s>)
     s>0で、Lognormal(m,s)(対数正規)確率変数の 標準偏差を返します。 この
     関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_lognormal (<m>,<s>)
     s>0で、Lognormal(m,s)(対数正規)確率変数の 歪度係数を返します。 この
     関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_lognormal (<m>,<s>)
     s>0で、Lognormal(m,s)(対数正規)確率変数の 尖度係数を返します。 この
     関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: random_lognormal (<m>,<s>)
 -- 関数: random_lognormal (<m>,<s>,<n>)
     s>0で、Lognormal(m,s)(対数正規)確率変量を返します。 三番目の引数
     <n>とともに‘random_lognormal’をコールすると、 サイズ <n>のランダム
     な標本がシミュレートされます。

     対数世紀変量は確率正規変量の平均によってシミュレートされます。 詳細
     は ‘random_normal’を見てください。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: pdf_gamma (<x>,<a>,<b>)
     a,b>0で、 Gamma(a,b)確率変数の 密度函数の <x>での値を返します。 こ
     の関数を利用するには、初めに ‘load("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

 -- 関数: quantile_gamma (<q>,<a>,<b>)
     a,b>0で、 Gamma(a,b)確率変数の <p>-分位数を返します; 言い換えれば、
     これは ‘cdf_gamma’の逆函数です。 引数 <q>は [0,1]の要素でなければい
     けません。 この関数を利用するには、初めに ‘load("distrib")’を書いて
     ください。

 -- 関数: mean_gamma (<a>,<b>)
     a,b>0で、 Gamma(a,b)確率変数の 平均を返します。 この関数を利用する
     には、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_gamma (<a>,<b>)
     a,b>0で、 Gamma(a,b)確率変数の 分散を返します。 この関数を利用する
     には、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_gamma (<a>,<b>)
     a,b>0で、 Gamma(a,b)確率変数の 標準偏差を返します。 この関数を利用
     するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_gamma (<a>,<b>)
     a,b>0で、 Gamma(a,b)確率変数の 歪度係数を返します。 この関数を利用
     するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_gamma (<a>,<b>)
     a,b>0で、 Gamma(a,b)確率変数の 尖度係数を返します。 この関数を利用
     するには、初めに ‘load("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")’を書いてください。

 -- 関数: pdf_beta (<x>,<a>,<b>)
     a,b>0で、 Beta(a,b)確率変数の 密度函数の <x>での値を返します。 この
     関数を利用するには、初めに ‘load("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

 -- 関数: quantile_beta (<q>,<a>,<b>)
     a,b>0で、 Beta(a,b)確率変数の <q>-分位数を返します; 言い換えると、
     これは‘cdf_beta’の逆函数です。 引数 <q> [0,1]の要素でなければいけま
     せん。 この関数を利用するには、初めに ‘load("distrib")’を書いてくだ
     さい。

 -- 関数: mean_beta (<a>,<b>)
     a,b>0で、 Beta(a,b)確率変数の 平均を返します。 この関数を利用するに
     は、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_beta (<a>,<b>)
     a,b>0で、 Beta(a,b)確率変数の 分散を返します。 この関数を利用するに
     は、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_beta (<a>,<b>)
     a,b>0で、 Beta(a,b)確率変数の 標準偏差を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_beta (<a>,<b>)
     a,b>0で、 Beta(a,b)確率変数の 歪度係数を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_beta (<a>,<b>)
     a,b>0で、 Beta(a,b)確率変数の 尖度係数を返します。 この関数を利用す
     るには、初めに ‘load("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")’を書いてください。

 -- 関数: pdf_continuous_uniform (<x>,<a>,<b>)
     a<bで、 Continuous Uniform(a,b)確率変数の密度函数の <x>での値を返し
     ます。 この関数を利用するには、初めに ‘load("distrib")’を書いてくだ
     さい。

 -- 関数: cdf_continuous_uniform (<x>,<a>,<b>)
     a<bで、 Continuous Uniform(a,b)確率変数の分布函数の <x>での値を返し
     ます。 この関数を利用するには、初めに ‘load("distrib")’を書いてくだ
     さい。

 -- 関数: quantile_continuous_uniform (<q>,<a>,<b>)
     a<bで、 Continuous Uniform(a,b)確率変数の分布函数の <q>-分位数を返
     します。 言い換えると、これは ‘cdf_continuous_uniform’の逆函数です
     。 引数 <q>は [0,1]の要素でなければいけません。 この関数を利用する
     には、初めに ‘load("distrib")’を書いてください。

 -- 関数: mean_continuous_uniform (<a>,<b>)
     a<bで、 Continuous Uniform(a,b)確率変数の分布函数の 平均を返します
     。 この関数を利用するには、初めに ‘load("distrib")’を書いてください
     。

 -- 関数: var_continuous_uniform (<a>,<b>)
     a<bで、 Continuous Uniform(a,b)確率変数の分布函数の 分散を返します
     。 この関数を利用するには、初めに ‘load("distrib")’を書いてください
     。

 -- 関数: std_continuous_uniform (<a>,<b>)
     a<bで、 Continuous Uniform(a,b)確率変数の分布函数の 標準偏差を返し
     ます。 この関数を利用するには、初めに ‘load("distrib")’を書いてくだ
     さい。

 -- 関数: skewness_continuous_uniform (<a>,<b>)
     a<bで、 Continuous Uniform(a,b)確率変数の分布函数の 歪度係数を返し
     ます。 この関数を利用するには、初めに ‘load("distrib")’を書いてくだ
     さい。

 -- 関数: kurtosis_continuous_uniform (<a>,<b>)
     a<bで、 Continuous Uniform(a,b)確率変数の分布函数の 尖度係数を返し
     ます。 この関数を利用するには、初めに ‘load("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")’を書いてください。

 -- 関数: pdf_logistic (<x>,<a>,<b>)
     b>0で、 Logistic(a,b)確率変数の 密度函数の <x>での値を返します。 こ
     の関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: cdf_logistic (<x>,<a>,<b>)
     b>0で、 Logistic(a,b)確率変数の 分布函数の <x>での値を返します。 こ
     の関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: quantile_logistic (<q>,<a>,<b>)
     b>0で、 Logistic(a,b)確率変数の <q>-分位数を返します。 言い換えると
     、これは ‘cdf_logistic’の逆函数です。 引数 <q>は [0,1]の要素でなけ
     ればいけません。 この関数を利用するには、初めに ‘load("distrib")’を
     書いてください。

 -- 関数: mean_logistic (<a>,<b>)
     b>0で、 Logistic(a,b)確率変数の平均を返します。 この関数を利用する
     には、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_logistic (<a>,<b>)
     b>0で、 Logistic(a,b)確率変数の分散を返します。 この関数を利用する
     には、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_logistic (<a>,<b>)
     b>0で、 Logistic(a,b)確率変数の標準偏差を返します。 この関数を利用
     するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_logistic (<a>,<b>)
     b>0で、 Logistic(a,b)確率変数の歪度係数を返します。 この関数を利用
     するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_logistic (<a>,<b>)
     b>0で、 Logistic(a,b)確率変数の尖度係数を返します。 この関数を利用
     するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: random_logistic (<a>,<b>)
 -- 関数: random_logistic (<a>,<b>,<n>)
     b>0で、 Logistic(a,b)確率変量を返します。 三番目の引数 <n>とともに
     ‘random_logistic’をコールすると、 サイズ <n>のランダムな標本がシミ
     ュレートされます。

     実装アルゴリズムは一般逆函数法に基づいています。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: pdf_pareto (<x>,<a>,<b>)
     a,b>0で、 Pareto(a,b)確率変数の 密度函数の <x>の値を返します。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: cdf_pareto (<x>,<a>,<b>)
     a,b>0で、 Pareto(a,b)確率変数の 分布函数の <x>の値を返します。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: quantile_pareto (<q>,<a>,<b>)
     a,b>0で、 Pareto(a,b)確率変数の <q>-分位数を返します; 言い換えると
     、これは ‘cdf_pareto’の逆函数です。 引数 <q>は [0,1]の要素でなけれ
     ばいけません。 この関数を利用するには、初めに ‘load("distrib")’を書
     いてください。

 -- 関数: mean_pareto (<a>,<b>)
     a,b>0で、 Pareto(a,b)確率変数の 平均を返します。 この関数を利用する
     には、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_pareto (<a>,<b>)
     a>2,b>0で、 Pareto(a,b)確率変数の 分散を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_pareto (<a>,<b>)
     a>2,b>0で、 Pareto(a,b)確率変数の 標準偏差を返します。 この関数を利
     用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_pareto (<a>,<b>)
     a>2,b>0で、 Pareto(a,b)確率変数の 歪度係数を返します。 この関数を利
     用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_pareto (<a>,<b>)
     a>2,b>0で、 Pareto(a,b)確率変数の 尖度係数を返します。 この関数を利
     用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: random_pareto (<a>,<b>)
 -- 関数: random_pareto (<a>,<b>,<n>)
     a>2,b>0で、 Pareto(a,b)確率変量を返します。 三番目の引数 <n>ととも
     に‘random_pareto’をコールすると、 サイズ <n>のランダムな標本がシミ
     ュレートされます。

     実装アルゴリズムは一般逆函数法に基づいています。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: pdf_weibull (<x>,<a>,<b>)
     a,b>0で、 Weibull(a,b)確率変数の 密度函数の <x>の値を返します。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: cdf_weibull (<x>,<a>,<b>)
     a,b>0で、 Weibull(a,b)確率変数の 分布函数の <x>の値を返します。 こ
     の関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: quantile_weibull (<q>,<a>,<b>)
     a,b>0で、 Weibull(a,b)確率変数の <q>-分位数を返します; 言い換えれば
     、これは ‘cdf_weibull’の逆函数です。 引数 <q>は [0,1]の要素でなけれ
     ばいけません。 この関数を利用するには、初めに ‘load("distrib")’を書
     いてください。

 -- 関数: mean_weibull (<a>,<b>)
     a,b>0で、 Weibull(a,b)確率変数の 平均を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_weibull (<a>,<b>)
     a,b>0で、 Weibull(a,b)確率変数の 分散を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_weibull (<a>,<b>)
     a,b>0で、 Weibull(a,b)確率変数の 標準偏差を返します。 この関数を利
     用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_weibull (<a>,<b>)
     a,b>0で、 Weibull(a,b)確率変数の 歪度係数を返します。 この関数を利
     用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_weibull (<a>,<b>)
     a,b>0で、 Weibull(a,b)確率変数の 尖度係数を返します。 この関数を利
     用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: random_weibull (<a>,<b>)
 -- 関数: random_weibull (<a>,<b>,<n>)
     a,b>0で、 Weibull(a,b)確率変量を返します。

     実装アルゴリズムは一般逆函数法に基づいています。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: random_rayleigh (<b>)
 -- 関数: random_rayleigh (<b>,<n>)
     b>0で、 Rayleigh(b)確率変量を返します。 二番目の引数 <n>とともに
     ‘random_pareto’をコールすると、 サイズ <n>のランダムな標本がシミュ
     レートされます。

     実装アルゴリズムは一般逆函数法に基づいています。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: pdf_laplace (<x>,<a>,<b>)
     b>0で、 Laplace(a,b)確率変数の密度函数の <x>での値を返します。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: cdf_laplace (<x>,<a>,<b>)
     b>0で、 Laplace(a,b)確率変数の分布函数の <x>での値を返します。 この
     関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: quantile_laplace (<q>,<a>,<b>)
     b>0で、 Laplace(a,b)確率変数の<q>-分位数を返します; 言い換えれば、
     これは ‘cdf_laplace’の逆函数です。 引数 <q>は [0,1]の要素でなければ
     いけません。 この関数を利用するには、初めに ‘load("distrib")’を書い
     てください。

 -- 関数: mean_laplace (<a>,<b>)
     b>0で、 Laplace(a,b)確率変数の平均を返します。 この関数を利用するに
     は、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_laplace (<a>,<b>)
     b>0で、 Laplace(a,b)確率変数の分散を返します。 この関数を利用するに
     は、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_laplace (<a>,<b>)
     b>0で、 Laplace(a,b)確率変数の標準偏差を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_laplace (<a>,<b>)
     b>0で、 Laplace(a,b)確率変数の歪度係数を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_laplace (<a>,<b>)
     b>0で、 Laplace(a,b)確率変数の尖度係数を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: random_laplace (<a>,<b>)
 -- 関数: random_laplace (<a>,<b>,<n>)
     b>0で、 Laplace(a,b)確率変量を返します。 三番目の引数 <n>とともに
     ‘random_laplace’をコールすると、 サイズ <n>のランダムな標本がシミュ
     レートされます。

     実装アルゴリズムは一般逆函数法に基づいています。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: pdf_cauchy (<x>,<a>,<b>)
     b>0で、 Cauchy(a,b)確率変数の密度函数の<x>での値を返します。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: cdf_cauchy (<x>,<a>,<b>)
     b>0で、 Cauchy(a,b)確率変数の分布函数の<x>での値を返します。 この関
     数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: quantile_cauchy (<q>,<a>,<b>)
     b>0で、 Cauchy(a,b)確率変数の<q>-分位数を返します; 言い換えると、こ
     れは ‘cdf_cauchy’の逆函数です。 引数 <q>は [0,1]の要素でなければい
     けません。 この関数を利用するには、初めに ‘load("distrib")’を書いて
     ください。

 -- 関数: random_cauchy (<a>,<b>)
 -- 関数: random_cauchy (<a>,<b>,<n>)
     b>0で、 Cauchy(a,b)確率変量を返します。 三番目の引数 <n>とともに
     ‘random_cauchy’をコールすると、 サイズ <n>のランダムな標本がシミュ
     レートされます。

     実装アルゴリズムは一般逆函数法に基づいています。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: pdf_gumbel (<x>,<a>,<b>)
     b>0で、 Gumbel(a,b)確率変数の密度函数の<x>での値を返します。 この関
     数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: cdf_gumbel (<x>,<a>,<b>)
     b>0で、 Gumbel(a,b)確率変数の分布函数の<x>での値を返します。 この関
     数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: quantile_gumbel (<q>,<a>,<b>)
     b>0で、 Gumbel(a,b)確率変数の<q>-分位数を返します; 言い換えれば、こ
     れは ‘cdf_gumbel’の逆函数です。 引数 <q>は [0,1]の要素でなければい
     けません。 この関数を利用するには、初めに ‘load("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’も参照してください。

 -- 関数: var_gumbel (<a>,<b>)
     b>0で、 Gumbel(a,b)確率変数の分散を返します。 この関数を利用するに
     は、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_gumbel (<a>,<b>)
     b>0で、 Gumbel(a,b)確率変数の標準偏差を返します。 この関数を利用す
     るには、初めに ‘load("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のゼータ函数を表します。

 -- 関数: kurtosis_gumbel (<a>,<b>)
     b>0で、 Gumbel(a,b)確率変数の尖度係数を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: random_gumbel (<a>,<b>)
 -- 関数: random_gumbel (<a>,<b>,<n>)
     b>0で、 Gumbel(a,b)確率変量を返します。 三番目の引数 <n>とともに
     ‘random_gumbel’をコールすると、 サイズ <n>のランダムな標本がシミュ
     レートされます。

     実装アルゴリズムは一般逆函数法に基づいています。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。


File: maxima.info,  Node: Functions and Variables for discrete distributions,  Prev: Functions and Variables for continuous distributions,  Up: distrib

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

 -- 関数: 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

 -- 関数: quantile_general_finite_discrete (<q>,<v>)
     ベクトル確率 vを持つ 一般有限離散確率変数の <q>-分位数を返します。

     さらなる詳細は ‘pdf_general_finite_discrete’を参照してください。

 -- 関数: mean_general_finite_discrete (<v>)
     ベクトル確率 vを持つ 一般有限離散確率変数の 平均を返します。

     さらなる詳細は ‘pdf_general_finite_discrete’を参照してください。

 -- 関数: var_general_finite_discrete (<v>)
     ベクトル確率 vを持つ 一般有限離散確率変数の 分散を返します。

     さらなる詳細は ‘pdf_general_finite_discrete’を参照してください。

 -- 関数: std_general_finite_discrete (<v>)
     ベクトル確率 vを持つ 一般有限離散確率変数の 標準偏差を返します。

     さらなる詳細は ‘pdf_general_finite_discrete’を参照してください。

 -- 関数: skewness_general_finite_discrete (<v>)
     ベクトル確率 vを持つ 一般有限離散確率変数の 歪度係数を返します。

     さらなる詳細は ‘pdf_general_finite_discrete’を参照してください。

 -- 関数: kurtosis_general_finite_discrete (<v>)
     ベクトル確率 vを持つ 一般有限離散確率変数の 尖度係数を返します。

     さらなる詳細は ‘pdf_general_finite_discrete’を参照してください。

 -- 関数: 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]

 -- 関数: pdf_binomial (<x>,<n>,<p>)
     0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の確率函数の<x>での
     値を返します。 この関数を利用するには、初めに ‘load("distrib")’を書
     いてください。 4 (%o6) - 7

 -- 関数: 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

 -- 関数: quantile_binomial (<q>,<n>,<p>)
     0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の<q>-分位数を返しま
     す; 言い換えれば、これは ‘cdf_binomial’の逆函数です。 引数 <q>は
     [0,1]の要素でなければいけません。 この関数を利用するには、初めに
     ‘load("distrib")’を書いてください。

 -- 関数: mean_binomial (<n>,<p>)
     0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の平均を返します。 こ
     の関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_binomial (<n>,<p>)
     0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の分散を返します。 こ
     の関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_binomial (<n>,<p>)
     0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の標準偏差を返します
     。 この関数を利用するには、初めに ‘load("distrib")’を書いてください
     。

 -- 関数: skewness_binomial (<n>,<p>)
     0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の歪度係数を返します
     。 この関数を利用するには、初めに ‘load("distrib")’を書いてください
     。

 -- 関数: kurtosis_binomial (<n>,<p>)
     0<p<1かつ nは正の整数で、 Binomial(n,p)確率変数の尖度係数を返します
     。 この関数を利用するには、初めに ‘load("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")’を書いてください。

 -- 関数: pdf_poisson (<x>,<m>)
     m>0で、 Poisson(m)確率変数の確率函数の <x>での値を返します。

     この関数を利用するには、初めに ‘load("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

 -- 関数: quantile_poisson (<q>,<m>)
     m>0で、 Poisson(m)確率変数の <q>-分位数を返します; 言い換えると、こ
     れは ‘cdf_poisson’の逆函数です。 引数 <q>は [0,1]の要素でなればいけ
     ません。 この関数を利用するには、初めに ‘load("distrib")’を書いてく
     ださい。

 -- 関数: mean_poisson (<m>)
     m>0で、 Poisson(m)確率変数の平均を返します。 この関数を利用するには
     、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_poisson (<m>)
     m>0で、 Poisson(m)確率変数の分散を返します。 この関数を利用するには
     、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_poisson (<m>)
     m>0で、 Poisson(m)確率変数の標準偏差を返します。 この関数を利用する
     には、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_poisson (<m>)
     m>0で、 Poisson(m)確率変数の歪度係数を返します。 この関数を利用する
     には、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_poisson (<m>)
     m>0で、 Poisson(m)確率変数の尖度係数を返します。 この関数を利用する
     には、初めに ‘load("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")’を書いてください。

 -- 関数: 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

 -- 関数: cdf_bernoulli (<x>,<p>)
     0<p<1で、 Bernoulli(p)確率変数の分布函数の <x>での値を返します。 こ
     の関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: quantile_bernoulli (<q>,<p>)
     0<p<1で、 Bernoulli(p)確率変数の<q>-分位数を返します; 言い換えると
     、これは ‘cdf_bernoulli’の逆函数です。 引数 <q>は [0,1]の要素でなけ
     ればいけません。 この関数を利用するには、初めに ‘load("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

 -- 関数: 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

 -- 関数: 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)

 -- 関数: 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)

 -- 関数: 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

 -- 関数: random_bernoulli (<p>)
 -- 関数: random_bernoulli (<p>,<n>)
     0<p<1で、 Bernoulli(p)確率変量を返します。 二番目の引数 <n>とともに
     ‘random_bernoulli’をコールすると、 サイズ <n>のランダムな標本がシミ
     ュレートされます。

     これは ‘random’組み込みMaxima関数の直接の応用です。

     ‘random’も参照してください。 この関数を利用するには、初めに
     ‘load("distrib")’を書いてください。

 -- 関数: pdf_geometric (<x>,<p>)
     0<p<1で、 Geometric(p)(幾何)確率変数の確率函数の <x>での値を返しま
     す。 この関数を利用するには、初めに ‘load("distrib")’を書いてくださ
     い。

 -- 関数: cdf_geometric (<x>,<p>)
     0<p<1で、 Geometric(p)(幾何)確率変数の分布函数の <x>での値を返しま
     す。 この関数を利用するには、初めに ‘load("distrib")’を書いてくださ
     い。

 -- 関数: quantile_geometric (<q>,<p>)
     0<p<1で、 Geometric(p)(幾何)確率変数の <q>-分位数を返します; 言い換
     えると、これは ‘cdf_geometric’の逆函数です。 引数 <q>は [0,1]の要素
     でなければいけません。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: mean_geometric (<p>)
     0<p<1で、 Geometric(p)(幾何)確率変数の 平均を返します。 この関数を
     利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_geometric (<p>)
     0<p<1で、 Geometric(p)(幾何)確率変数の 分散を返します。 この関数を
     利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_geometric (<p>)
     0<p<1で、 Geometric(p)(幾何)確率変数の 標準偏差を返します。 この関
     数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_geometric (<p>)
     0<p<1で、 Geometric(p)(幾何)確率変数の 歪度係数を返します。 この関
     数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_geometric (<p>)
     0<p<1で、 Geometric(p)(幾何)確率変数の 尖度係数を返します。 この関
     数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: random_geometric (<p>)
 -- 関数: random_geometric (<p>,<n>)
     0<p<1で、 Geometric(p)(幾何)確率変量を返します。 二番目の引数 <n>と
     ともに‘random_geometric’をコールすると、 サイズ <n>のランダムな標本
     がシミュレートされます。

     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: pdf_discrete_uniform (<x>,<n>)
     nが厳密に正の整数で、 Discrete Uniform(n)確率変数の確率函数の <x>で
     の値を返します。 この関数を利用するには、初めに ‘load("distrib")’を
     書いてください。

 -- 関数: cdf_discrete_uniform (<x>,<n>)
     nが厳密に正の整数で、 Discrete Uniform(n)確率変数の分風函数の <x>で
     の値を返します。 この関数を利用するには、初めに ‘load("distrib")’を
     書いてください。

 -- 関数: quantile_discrete_uniform (<q>,<n>)
     nが厳密に正の整数で、 Discrete Uniform(n)確率変数の <q>-分位数を返
     します; 言い換えると、これは ‘cdf_discrete_uniform’の逆函数です。 引
     数 <q>は [0,1]の要素でなければいけません。 この関数を利用するには、
     初めに ‘load("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")’.

 -- 関数: var_discrete_uniform (<n>)
     nが厳密に正の整数で、 Discrete Uniform(n)確率変数の 分散を返します
     。 この関数を利用するには、初めに ‘load("distrib")’を書いてください
     。

 -- 関数: std_discrete_uniform (<n>)
     nが厳密に正の整数で、 Discrete Uniform(n)確率変数の 標準偏差を返し
     ます。 この関数を利用するには、初めに ‘load("distrib")’を書いてくだ
     さい。

 -- 関数: skewness_discrete_uniform (<n>)
     nが厳密に正の整数で、 Discrete Uniform(n)確率変数の 歪度係数を返し
     ます。 この関数を利用するには、初めに ‘load("distrib")’を書いてくだ
     さい。

 -- 関数: kurtosis_discrete_uniform (<n>)
     nが厳密に正の整数で、 Discrete Uniform(n)確率変数の 尖度係数を返し
     ます。 この関数を利用するには、初めに ‘load("distrib")’を書いてくだ
     さい。

 -- 関数: random_discrete_uniform (<n>)
 -- 関数: random_discrete_uniform (<n>,<m>)
     nが厳密に正の整数で、 Discrete Uniform(n)確率変量を返します。 二番
     目の引数 <m>とともに‘random_discrete_unform’をコールすると、 サイズ
     <m>のランダムな標本がシミュレートされます。

     これは ‘random’組み込みMaxima関数の直接の応用です。

     ‘random’も参照してください。 この関数を利用するには、初めに
     ‘load("distrib")’を書いてください。

 -- 関数: pdf_hypergeometric (<x>,<n1>,<n2>,<n>)
     <n1>, <n2>, <n>が非負整数でかつ n<=n1+n2で、
     Hypergeometric(n1,n2,n)確率変数の 確率函数の <x>での値を返します。
     この関数を利用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: cdf_hypergeometric (<x>,<n1>,<n2>,<n>)
     <n1>, <n2>, <n>が非負整数でかつ n<=n1+n2で、
     Hypergeometric(n1,n2,n)確率変数の 分布函数の <x>での値を返します。
     この関数を利用するには、初めに ‘load("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")’を書いてください。

 -- 関数: mean_hypergeometric (<n1>,<n2>,<n>)
     <n1>, <n2>, <n>が非負整数でかつ n<=n1+n2で、
     Hypergeometric(n1,n2,n)確率変数の 平均を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: var_hypergeometric (<n1>,<n2>,<n>)
     <n1>, <n2>, <n>が非負整数でかつ n<=n1+n2で、
     Hypergeometric(n1,n2,n)確率変数の 分散を返します。 この関数を利用す
     るには、初めに ‘load("distrib")’を書いてください。

 -- 関数: std_hypergeometric (<n1>,<n2>,<n>)
     <n1>, <n2>, <n>が非負整数でかつ n<=n1+n2で、
     Hypergeometric(n1,n2,n)確率変数の 標準偏差を返します。 この関数を利
     用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: skewness_hypergeometric (<n1>,<n2>,<n>)
     <n1>, <n2>, <n>が非負整数でかつ n<=n1+n2で、
     Hypergeometric(n1,n2,n)確率変数の 標準偏差を返します。 この関数を利
     用するには、初めに ‘load("distrib")’を書いてください。

 -- 関数: kurtosis_hypergeometric (<n1>,<n2>,<n>)
     <n1>, <n2>, <n>が非負整数でかつ n<=n1+n2で、
     Hypergeometric(n1,n2,n)確率変数の 歪度係数を返します。 この関数を利
     用するには、初めに ‘load("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")’を書いてください。

 -- 関数: pdf_negative_binomial (<x>,<n>,<p>)
     0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の確率函数
     の <x>での値を返します。 この関数を利用するには、初めに
     ‘load("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

 -- 関数: quantile_negative_binomial (<q>,<n>,<p>)
     0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の <q>-分位
     数を返します; 言い換えると、これは ‘cdf_negative_binomial’の逆函数
     です。 引数 <q>は [0,1]の要素でなければいけません。 この関数を利用
     するには、初めに ‘load("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")’.

 -- 関数: var_negative_binomial (<n>,<p>)
     0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の 分散を返
     します。 この関数を利用するには、初めに ‘load("distrib")’を書いてく
     ださい。

 -- 関数: std_negative_binomial (<n>,<p>)
     0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の 標準偏差
     を返します。 この関数を利用するには、初めに ‘load("distrib")’を書い
     てください。

 -- 関数: skewness_negative_binomial (<n>,<p>)
     0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の 歪度係数
     を返します。 この関数を利用するには、初めに ‘load("distrib")’を書い
     てください。

 -- 関数: kurtosis_negative_binomial (<n>,<p>)
     0<p<1かつ nが正の整数で、 Negative Binomial(n,p)確率変数の 尖度係数
     を返します。 この関数を利用するには、初めに ‘load("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")’を書いてください。


File: maxima.info,  Node: draw,  Next: drawdf,  Prev: distrib,  Up: Top

48 draw
*******

* Menu:

* Introduction to draw::
* Functions and Variables for draw::
* Functions and Variables for pictures::
* Functions and Variables for worldmap::


File: maxima.info,  Node: Introduction to draw,  Next: Functions and Variables for draw,  Prev: draw,  Up: draw

48.1 Introduction to draw
=========================

‘draw’はMaxima-Gnuplotインターフェイスです。

   Maximaレベルで使われる３つの主な関数があります: ‘draw2d’, ‘draw3d’,
‘draw’。

   このパッケージのさらに磨きかけられた例のために以下のリンクに従ってく
ださい:

   <http://riotorto.users.sourceforge.net/gnuplot>

   このプログラムを走らせるにはGnuplot 4.2以上が必要です。


File: maxima.info,  Node: Functions and Variables for draw,  Next: Functions and Variables for pictures,  Prev: Introduction to draw,  Up: draw

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")’を書いてくださ
     い。

 -- シーン構成子: 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")’を書いてくださ
     い。

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’も参照してください。

 -- 関数: draw2d (<option>, <graphic_object>, ...)
     この関数は ‘draw(gr2d(<options>, ..., <graphic_object>, ...))’.  の
     ショートカットです。

     2dで唯一のシーンをプロットするのに使うことができます。

     この関数を利用するには、最初に‘load("draw")’を書いてください。

     ‘draw’と‘gr2d’も参照してください。

 -- 関数: draw3d (<option>, <graphic_object>, ...)
     この関数は ‘draw(gr3d(<options>, ..., <graphic_object>, ...))’ のシ
     ョートカットです。

     3dでユニークなシーンをプロットするのに使うことができます。

     この関数を利用するには、最初に‘load("draw")’を書いてください。

     ‘draw’と‘gr3d’も参照してください。

 -- 関数: 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]) $

 -- 関数: 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)$

 -- 関数: 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")’を書いてください。

48.2.3 Graphic options
----------------------

 -- グラフィックオプション: adapt_depth
     デフォルト値: 10

     ‘adapt_depth’は適応プロットルーチンが使う分割の最大数です。

     このオプションは2d‘explicit’関数に対してだけ有効です。

 -- グラフィックオプション: 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’も 参照してください。

 -- グラフィックオプション: 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’も参照してください
     。

 -- グラフィックオプション: 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’も参照してくださ
     い。

 -- グラフィックオプション: 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’も 参照してくださ
     い。

 -- グラフィックオプション: 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’も参照してくださ
     い。

 -- グラフィックオプション: background_color
     デフォルト値: ‘white’

     端末‘gif’, ‘png’, ‘jpg’, ‘gif’のための背景色を設定します。 デフォル
     ト背景色は白です。

     ‘color’も参照してください。

 -- グラフィックオプション: 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]]) )$

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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)$

 -- グラフィックオプション: 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) $

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: data_file_name
     デフォルト値: ‘"data.gnuplot"’

     これは、 リクエストされたプロットを構築するためにGnuplotが必要とす
     る数値データを含む ファイルの名前です。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題なりません。 関数‘draw’の引数としても使うことができます。

     ‘gnuplot_file_name’の中で例を参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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)) $

 -- グラフィックオプション: 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))$

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: fill_color
     デフォルト値: ‘"red"’

     ‘fill_color’はポリゴンと2d ‘explicit’関数を塗りつぶすための色を指定
     します。

     如何に色が指定されるかを知るには‘color’を参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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ドキュメンテーションは端末とフォントに関する情報の重要なソー
     スです。

 -- グラフィックオプション: font_size
     デフォルト値: 10

     このオプションは、 フォントサイズを端末によって使われるように設定す
     るために使うことができます。 １つの書体とサイズだけがプロットの間中
     で使うことができます。 オプション‘font’が空の文字列に等しくない時だ
     け、 ‘font_size’はアクティブです。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

     ‘font’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: grid
     デフォルト値: ‘false’

     もし‘grid’が‘true’なら、 <xy>平面上に格子が描かれます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

     例:

          (%i1) load("draw")$
          (%i2) draw2d(grid = true,
                       explicit(exp(u),u,-2,2))$

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’.

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: ip_grid
     デフォルト値: ‘[50, 50]’

     ‘ip_grid’はインプリシットなプロットでの最初のサンプリングのためにグ
     リッドを設定します。

     このオプションは‘implicit’オブジェクトに対してだけ関係があります。

 -- グラフィックオプション: ip_grid_in
     デフォルト値: ‘[5, 5]’

     ‘ip_gridi_in’はインプリシットなプロットでの二番目のサンプリングのた
     めにグリッドを設定します。

     このオプションは‘implicit’オブジェクトに対してだけ関係があります。

 -- グラフィックオプション: 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) )$

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’.

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: logx
     デフォルト値: ‘false’

     もし‘logx’が‘true’なら、 <x>軸は対数スケールで描かれます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

     例:

          (%i1) load("draw")$
          (%i2) draw2d(explicit(log(x),x,0.01,5),
                       logx = true)$

     ‘logy’, ‘logz’も参照してください。

 -- グラフィックオプション: logy
     デフォルト値: ‘false’

     もし‘logy’が‘true’なら、 <y>軸は対数スケールで描かれます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

     例:

          (%i1) load("draw")$
          (%i2) draw2d(logy = true,
                       explicit(exp(x),x,0,5))$

     ‘logx’, ‘logz’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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) )$

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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)))$

 -- グラフィックオプション: 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]]) )$

 -- グラフィックオプション: 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]]) )$

 -- グラフィックオプション: 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))

 -- グラフィックオプション: 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)) )$

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: title
     デフォルト値: ‘""’ (empty string)

     オプション‘title’、文字列は、シーンのメインタイトルです。 デフォル
     トではタイトルは書かれません。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

     例:

          (%i1) load("draw")$
          (%i2) draw2d(explicit(exp(u),u,-2,2),
                       title = "Exponential function")$

 -- グラフィックオプション: 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) )$

 -- グラフィックオプション: 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]]) )$

 -- グラフィックオプション: 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) )$

 -- グラフィックオプション: 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]))$

 -- グラフィックオプション: 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")$

 -- グラフィックオプション: 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) )$

 -- グラフィックオプション: x_voxel
     デフォルト値: 10

     ‘x_voxel’は 3d ‘暗黙の’オブジェクトで実装されたマーチングキューブア
     ルゴリズム x方向のボクセルの数です。 グラフィックオブジェクト
     ‘region’でも使われます。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: xlabel
     デフォルト値: ‘""’ (empty string)

     オプション‘xlabel’、文字列は <x>軸のラベルです。 デフォルトでは、ラ
     ベルは書かれません。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

     例:

          (%i1) load("draw")$
          (%i2) draw2d(xlabel = "Time",
                       explicit(exp(u),u,-2,2),
                       ylabel = "Population")$

     ‘ylabel’と‘zlabel’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: xrange_secondary
     デフォルト値: ‘auto’

     もし‘xrange_secondary’が‘auto’なら、 二番目の<x>軸の範囲は自動的に
     計算されます。

     もしユーザーが 二番目の<x>軸の特定した区間が欲しいなら、
     ‘xrange_secondary=[-2, 3]’のように、Maximaリストとして与えられなけ
     ればいけません。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

     ‘xrange’, ‘yrange’, ‘zrange’, ‘yrange_secondary’も参照してください
     。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: xtics_axis
     デフォルト値: ‘false’

     もし‘xtics_axis’が‘true’なら、 チックマークとそれらのラベルが <x>軸
     に沿ってだけプロットされます。 もし‘false’なら、チックは境界上にプ
     ロットされます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

 -- グラフィックオプション: xtics_rotate
     デフォルト値: ‘false’

     もし‘xtics_rotate’が‘true’なら、 <x>軸上のチックマークが90度回転さ
     れます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

 -- グラフィックオプション: xtics_rotate_secondary
     デフォルト値: ‘false’

     もし‘xtics_rotate_secondary’が‘true’なら、 補助的な<x>軸上のチック
     マークが90度回転されます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

 -- グラフィックオプション: xtics_secondary
     デフォルト値: ‘auto’

     このグラフィックオプションは、 二番目の<x>軸上にチックマークを描く
     方法を制御します。

     完全な記述に関しては、‘xtics’を参照してください。

 -- グラフィックオプション: xtics_secondary_axis
     デフォルト値: ‘false’

     もし‘xtics_secondary_axis’が‘true’なら、 チックマークとそれらのラベ
     ルは補助的な<x>軸に沿ってだけプロットされ、 もし‘false’なら、境界上
     にプロットされます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: xy_file
     デフォルト値: ‘""’ (empty string)

     ‘xy_file’は、 マウスでクリックし、'x'キーを叩いた後、座標が保存され
     る ファイルの名前です。 デフォルトでは、座標は保存されません。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題なりません。

 -- グラフィックオプション: 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))$

 -- グラフィックオプション: y_voxel
     デフォルト値: 10

     ‘y_voxel’は 3d‘暗黙の’オブジェクトで実装されたマーチングキューブア
     ルゴリズム で使われるy方向のボクセルの数です。 グラフィックオブジェ
     クト‘region’でも使われます。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: ylabel
     デフォルト値: ‘""’ (empty string)

     オプション‘ylabel’、文字列は <y>軸のラベルです。 デフォルトでは、ラ
     ベルは書かれません。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

     例:

          (%i1) load("draw")$
          (%i2) draw2d(xlabel = "Time",
                       ylabel = "Population",
                       explicit(exp(u),u,-2,2) )$

     ‘xlabel’と‘zlabel’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: ytics
     デフォルト値: ‘auto’

     このグラフィックオプションは、 <y>軸上にチックマークを描く方法を制
     御します。

     完全な記述に関しては、‘xtics’を参照してください。

 -- グラフィックオプション: ytics_axis
     デフォルト値: ‘false’

     もし‘ytics_axis’が‘true’なら、 チックマークとそれらのラベルは<y>軸
     に沿ってだけプロットされ、 もし‘false’なら、境界上にプロットされま
     す。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

 -- グラフィックオプション: ytics_rotate
     デフォルト値: ‘false’

     もし‘ytics_rotate’が‘true’なら、 <y>軸上のチックマークが90度回転さ
     れます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

 -- グラフィックオプション: ytics_rotate_secondary
     デフォルト値: ‘false’

     もし‘ytics_rotate_secondary’が‘true’なら、 補助的な<y>軸上のチック
     マークが90度回転されます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

 -- グラフィックオプション: ytics_secondary
     デフォルト値: ‘auto’

     このグラフィックオプションは、 二番目の<y>軸上にチックマークを描く
     方法を制御します。

     完全な記述に関しては、‘xtics’を参照してください。

 -- グラフィックオプション: ytics_secondary_axis
     デフォルト値: ‘false’

     もし‘ytics_secondary_axis’が‘true’なら、 チックマークとそれらのラベ
     ルは補助的な<y>軸に沿ってだけプロットされ、 もし‘false’なら、境界上
     にプロットされます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: z_voxel
     デフォルト値: 10

     ‘z_voxel’は 3d‘implicit’オブジェクトで実装されたマーチングキューブ
     アルゴリズム で使われるz方向のボクセルの数です。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: 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’も参照してください。

 -- グラフィックオプション: ztics
     デフォルト値: ‘auto’

     このグラフィックオプションは、 <z>軸上にチックマークを描く方法を制
     御します。

     完全な記述に関しては、‘xtics’を参照してください。

 -- グラフィックオプション: ztics_axis
     デフォルト値: ‘false’

     もし‘ztics_secondary_axis’が‘true’なら、 チックマークとそれらのラベ
     ルは補助的な<z>軸に沿ってだけプロットされ、 もし‘false’なら、境界上
     にプロットされます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

 -- グラフィックオプション: ztics_rotate
     デフォルト値: ‘false’

     もし‘ztics_rotate’が‘true’なら、 <z>軸上のチックマークが90度回転さ
     れます。

     これはグローバルグラフィックスオプションなので、 シーン記述の位置は
     問題になりません。

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))$

 -- グラフィックオブジェクト: 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);

 -- グラフィックオブジェクト: 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] )$

 -- グラフィックオブジェクト: 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]]));

 -- グラフィックオブジェクト: 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’も参照してください。

 -- グラフィックオブジェクト: 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>
     には更に丹念な例があります。

 -- グラフィックオブジェクト: 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);

 -- グラフィックオブジェクト: 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]) )$

 -- グラフィックオブジェクト: 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);

 -- グラフィックオブジェクト: 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" )$

 -- グラフィックオブジェクト: 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) )$

 -- グラフィックオブジェクト: 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))$

 -- グラフィックオブジェクト: 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) )$

 -- グラフィックオブジェクト: 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]]) )$

 -- グラフィックオブジェクト: 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’.

 -- グラフィックオブジェクト: 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] )$

 -- グラフィックオブジェクト: 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))$

 -- グラフィックオブジェクト: 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’.

 -- グラフィックオブジェクト: 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) )$

 -- グラフィックオブジェクト: 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)) )$


File: maxima.info,  Node: Functions and Variables for pictures,  Next: Functions and Variables for worldmap,  Prev: Functions and Variables for draw,  Up: draw

48.3 Functions and Variables for pictures
=========================================

 -- 関数: get_pixel (<pic>,<x>,<y>)
     ピクチャからピクセルを返します。 座標<x>と<y>は 0からそれぞれ
     ‘width-1’と‘height-1’までの範囲を取ります。

 -- 関数: 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)})

 -- 関数: 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)})

 -- 関数: negative_picture (<pic>)
     (<level>または<rgb>)ピクチャの反転を返します。

 -- 関数: picture_equalp (<x>,<y>)
     等しいピクチャの場合‘true’を、そうでなければ‘false’ を返します。

 -- 関数: picturep (<x>)
     もし引数が適正なイメージなら ‘true’を、そうでなければ‘false’を返し
     ます。

 -- 関数: read_xpm (<xpm_file>)
     xpm形式のファイルを読み、ピクチャオブジェクトを返します。

 -- 関数: rgb2level (<pic>)
     <rgb>ピクチャを 赤、緑、青チャンネルを平均することで<level>の１つに
     変換します。

 -- 関数: 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)})


File: maxima.info,  Node: Functions and Variables for worldmap,  Prev: Functions and Variables for pictures,  Up: draw

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’も参照してください。

 -- 関数: 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)$

 -- 関数: 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, %)$

 -- 関数: make_poly_country (<country_name>)
     色付けられた国を描画するのに必要なポリゴンを作ります。 もし島が存在
     するなら、1つの国はただ1つ以上のポリゴンで定義され得ます。

     例:

          (%i1) load("worldmap")$
          (%i2) make_poly_country(India)$
          (%i3) apply(draw2d, %)$

 -- 関数: 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)$

 -- 関数: 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(%))$

 -- 関数: 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(%))$

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> も参
     照してください。


File: maxima.info,  Node: drawdf,  Next: dynamics,  Prev: draw,  Up: Top

49 drawdf
*********

* Menu:

* Introduction to drawdf::
* Functions and Variables for drawdf::


File: maxima.info,  Node: Introduction to drawdf,  Next: Functions and Variables for drawdf,  Prev: drawdf,  Up: drawdf

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つの自励方程式系に変換します。


File: maxima.info,  Node: Functions and Variables for drawdf,  Prev: Introduction to drawdf,  Up: drawdf

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))$


File: maxima.info,  Node: dynamics,  Next: ezunits,  Prev: drawdf,  Up: Top

50 dynamics
***********

* Menu:

* Introduction to dynamics::
* Functions and Variables for dynamics::


File: maxima.info,  Node: Introduction to dynamics,  Next: Functions and Variables for dynamics,  Prev: dynamics,  Up: dynamics

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>で変えることができます。


File: maxima.info,  Node: Functions and Variables for dynamics,  Prev: Introduction to dynamics,  Up: dynamics

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>回繰り返されます。

 -- 関数: 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>は
     正の整数でなければいけません。

 -- 関数: 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つでなければいけません。 変
     数はリストの中に明示的に指名されなければいけません。

 -- 関数: 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とできます。

 -- 関数: julia (<x>, <y>, ...<options>...)

     複素数(<x> + i <y>)に関するJulia集合の表現のグラフィックスファイル
     を生成します。 パラメータ<x>と<y>は実数でなければいけません。 ファ
     イルは、XPMグラフィックスフォーマットでカレントディレクトリかユーザ
     ーディレクトリに生成されます。 プログラムは走らせるのに数秒かかるか
     もしれません。終了後、生成したファイル名と共にメッセージが印字され
     ます。

     Julia集合に属さない点には、異なる色が割り当てられます。 繰り返し回
     数に従って、その点から始まり、半径2の収束円から動く数列を取ります。
     繰り返しの最大回数はオプション<levels>で設定されます; その回数の繰
     り返しの後、もし数列がまだ収束円内なら、 点はオプション<color>で定
     義された色で塗られます。

     Julia集合に属さない点に使われる色すべては、同じ<saturation>と
     <value>を持ちますが、 <hue>と(<hue> + <huerange>)の間に一様に分布す
     る、違った色相角を持ちます。

     <options>はオプションの列です。 受け付けられるオプションのリストは
     以下の節で与えられます。

 -- 関数: mandelbrot (<options>)

     Mandelbrot集合の表現のグラフィックスファイルを生成します。 ファイル
     は、XPMグラフィックスフォーマットでカレントディレクトリかユーザーデ
     ィレクトリに生成されます。 プログラムは走らせるのに数秒かかるかもし
     れません。終了後、生成したファイル名と共にメッセージが印字されます
     。

     Mandelbrot集合に属さない点には、異なる色が割り当てられます。 繰り返
     し回数に従って、その点から始まり、半径2の収束円から動く数列を取りま
     す。 繰り返しの最大回数はオプション<levels>で設定されます; その回数
     の繰り返しの後、もし数列がまだ収束円内なら、 点はオプション
     <color>で定義された色で塗られます。

     Mandelbrot集合に属さない点に使われる色すべては、同じ<saturation>と
     <value>を持ちますが、 <hue>と(<hue> + <huerange>)の間に一様に分布す
     る、違った色相角を持ちます。

     <options>はオプションの列です。 受け付けられるオプションのリストは
     以下の節で与えられます。

 -- 関数: 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>個の値を示します。

 -- 関数: 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個の要素を持つもう一つのリストです: 独立
     変数の値にその点に対応する従属変数の値が続きます。

 -- 関数: 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>回
     繰り返されます。

   オプション

   それぞれのオプションは複数の項目のリストです。 最初の項目はオプション
名で、残りはオプションの引数からなります。

   関数‘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])$


File: maxima.info,  Node: ezunits,  Next: f90,  Prev: dynamics,  Up: Top

51 ezunits
**********

* Menu:

* Introduction to ezunits::
* Introduction to physical_constants::
* Functions and Variables for ezunits::


File: maxima.info,  Node: Introduction to ezunits,  Next: Introduction to physical_constants,  Prev: ezunits,  Up: ezunits

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単位で、 他の基本的な次元や単位を
宣言できます。


File: maxima.info,  Node: Introduction to physical_constants,  Next: Functions and Variables for ezunits,  Prev: Introduction to ezunits,  Up: ezunits

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


File: maxima.info,  Node: Functions and Variables for ezunits,  Prev: Introduction to physical_constants,  Up: ezunits

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

 -- 演算子: ``

     単位変換演算子。 式 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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]

 -- 関数: 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

 -- 関数: 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]

 -- 関数: 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

 -- 関数: 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

 -- 関数: natural_unit (<expr>, [<v_1>, ..., <v_n>])

     ‘dimension(<expr>) = dimension(<v_1>^<e_1> ... <v_n>^<e_n>)’である
     ような 指数<e_1>, ..., <e_n>を見つけます。

     ‘load("ezunits")’はこの関数をロードします。

     例:


File: maxima.info,  Node: f90,  Next: finance,  Prev: ezunits,  Up: Top

52 f90
******

* Menu:

* Functions and Variables for f90::


File: maxima.info,  Node: Functions and Variables for f90,  Prev: f90,  Up: f90

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


File: maxima.info,  Node: finance,  Next: fractals,  Prev: f90,  Up: Top

53 finance
**********

* Menu:

* Introduction to finance::
* Functions and Variables for finance::


File: maxima.info,  Node: Introduction to finance,  Next: Functions and Variables for finance,  Prev: finance,  Up: finance

53.1 Introduction to finance
============================

これは金融パッケージ(第0.1版)です。

   すべての関数において、 <rate>は複利率であり、 <num>は期間で正でなくて
はいけません。 また、<flow>はキャッシュフローを示すので、 産出はフローが
負になり、投入は正になります。

   このパッケージで定義された関数を使う前に、 ‘load("finance")$’と書いて
パッケージをロードしなければいけないことに 注意してください。

   著者: Nicolas Guarin Zapata.


File: maxima.info,  Node: Functions and Variables for finance,  Prev: Introduction to finance,  Up: finance

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

 -- 関数: fv (<rate>,<PV>,<num>)

     ある利率を与えられたとして、現在価値の将来価値を計算します。
     <rate>は利率で、<PV>は現在価値、 <num>は期間です。

     例:

          (%i1) load("finance")$
          (%i2) fv(0.12,1000,3);
          (%o2)                     1404.928

 -- 関数: pv (<rate>,<FV>,<num>)

     ある利率を与えられたとして、将来価値の現在価値を計算します。
     <rate>は利率で、<PV>は現在価値、 <num>は期間です。

     例:

          (%i1) load("finance")$
          (%i2) pv(0.12,1000,3);
          (%o2)                711.7802478134108

 -- 関数: graph_flow (<val>)

     時間順でマネーフローを、 正の値は青で上に、負の値は赤で下に プロッ
     トします。 フローの向きは値の符号で与えられます。 <val>はフローの値
     のリストです。

     例:

          (%i1) load("finance")$
          (%i2) graph_flow([-5000,-3000,800,1300,1500,2000])$

 -- 関数: annuity_pv (<rate>,<PV>,<num>)

     (総額のような)現在価値がわかっている年金を計算できます。 年金は一定
     で定期払いです。 <rate>は利率で、<PV>は現在価値、 <num>は期間です。

     例:

          (%i1) load("finance")$
          (%i2) annuity_pv(0.12,5000,10);
          (%o2)                884.9208207992202

 -- 関数: annuity_fv (<rate>,<FV>,<num>)

     要望価値(将来価値)がわかっている年金を計算できます。 年金は一定で定
     期払いです。 <rate>は利率で、<PV>は将来価値、 <num>は期間です。

     例:

          (%i1) load("finance")$
          (%i2) annuity_fv(0.12,65000,10);
          (%o2)                3703.970670389863

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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


File: maxima.info,  Node: fractals,  Next: ggf,  Prev: finance,  Up: Top

54 fractals
***********

* Menu:

* Introduction to fractals::
* Definitions for IFS fractals::
* Definitions for complex fractals::
* Definitions for Koch snowflakes::
* Definitions for Peano maps::


File: maxima.info,  Node: Introduction to fractals,  Next: Definitions for IFS fractals,  Prev: fractals,  Up: fractals

54.1 Introduction to fractals
=============================

このパッケージはよく知られているフラクタルをいくつか定義します:

   - ランダムIFS(反復函数系)を使って: Sierpinski三角形、木、シダ

   - 複素フラクタル: MandelbrotとJulia集合

   - Koch雪片集合

   - Peano写像: SierpinskiとHilbert写像

   著者: José Ramírez Labrador.

   質問、提案、バグに関しては、 pepe DOT ramirez AAATTT uca DOT es まで
、私に気兼ねせずコンタクトしてください。


File: maxima.info,  Node: Definitions for IFS fractals,  Next: Definitions for complex fractals,  Prev: Introduction to fractals,  Up: fractals

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

 -- 関数: treefale (<n>)

     すべて同じ縮小比を持つ3つの縮小写像。 引数<n>は十分大きく、10000以
     上でなければいけません、

     例:

          (%i1) load("fractals")$
          (%i2) n: 10000$
          (%i3) plot2d([discrete,treefale(n)], [style,dots])$

 -- 関数: fernfale (<n>)

     変換を選択する確率が縮小比に関係する、4つの縮小写像。 引数<n>は十分
     大きく、10000以上でなければいけません、

     例:

          (%i1) load("fractals")$
          (%i2) n: 10000$
          (%i3) plot2d([discrete,fernfale(n)], [style,dots])$


File: maxima.info,  Node: Definitions for complex fractals,  Next: Definitions for Koch snowflakes,  Prev: Definitions for IFS fractals,  Up: Top

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

 -- 関数: 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’.

 -- オプション変数: 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’を提案し
     ます。

 -- 関数: 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’.


File: maxima.info,  Node: Definitions for Koch snowflakes,  Next: Definitions for Peano maps,  Prev: Definitions for complex fractals,  Up: Top

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


File: maxima.info,  Node: Definitions for Peano maps,  Prev: Definitions for Koch snowflakes,  Up: fractals

54.5 Definitions for Peano maps
===============================

ある面積を覆う連続曲線。 警告: <n>と共に点の数は指数関数的に増加します。

 -- 関数: hilbertmap (<nn>)

     Hilbert写像。 <nn>は小さく(例えば5で)なければいけません。 もし7以上
     ならMaximaはクラッシュするかもしれません。

     例:

          (%i1) load("fractals")$
          (%i2) plot2d([discrete,hilbertmap(6)])$

 -- 関数: sierpinskimap (<nn>)

     Sierpinski写像。 <nn>は小さく(例えば5で)なければいけません。 もし
     7以上ならMaximaはクラッシュするかもしれません。

     例:

          (%i1) load("fractals")$
          (%i2) plot2d([discrete,sierpinskimap(6)])$


File: maxima.info,  Node: ggf,  Next: graphs,  Prev: fractals,  Up: Top

55 ggf
******

* Menu:

* Functions and Variables for ggf::


File: maxima.info,  Node: Functions and Variables for ggf,  Prev: ggf,  Up: ggf

55.1 Functions and Variables for ggf
====================================

 -- オプション変数: GGFINFINITY
     デフォルト値: 3

     これは関数‘ggf’のオプション変数です。

     母関数の連分数を計算する時、 (厳密に)<GGFINFINITY>より大きな次数を
     持つ 部分商は捨てられます。 現在のコンバージェントは母関数の正確な
     値として考えられます; 部分商すべての次数はたいてい0か1です; もしよ
     り大きな値を使うなら、 十分精度の高い計算を行うために十分な項を与え
     るべきです。

     ‘ggf’も参照してください。

 -- オプション変数: GGFCFMAX
     デフォルト値: 3

     これは 関数‘ggf’のオプション変数です。

     母関数の連分数を計算する時、 もし <GGFCFMAX>個の部分商を計算した後
     、よい結果が見つからないなら (<GGFINFINITY>フラグを参照してください
     )、 母関数は２つの多項式の分数でないように考えられ、 関数は抜けます
     。 もっと複雑な母関数のためにより大きな値を自由に入れてください。

     ‘ggf’も参照してください。

 -- 関数: ggf (<l>)
     (もし母関数が２つの多項式の分数なら) 与えられた最初の数項に対する、
     数列の母関数を計算します。 <l>は数のリストです。

     解は２つの多項式の分数として返されます。 解が見つからなかったら、
     ‘done’を返します。

     この関数は グローバル変数<GGFINFINITY>と<GGFCFMAX>で制御されます。
     <GGFINFINITY>と<GGFCFMAX>も参照してください。

     この関数を使うには、最初に‘load("ggf")’を書いてください。


File: maxima.info,  Node: graphs,  Next: grobner,  Prev: ggf,  Up: Top

56 graphs
*********

* Menu:

* Introduction to graphs::
* Functions and Variables for graphs::


File: maxima.info,  Node: Introduction to graphs,  Next: Functions and Variables for graphs,  Prev: graphs,  Up: graphs

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")’でロードしてくだ
さい。


File: maxima.info,  Node: Functions and Variables for graphs,  Prev: Introduction to graphs,  Up: graphs

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

 -- 関数: copy_graph (<g>)
     グラフ<g>のコピーを返します。

 -- 関数: 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

 -- 関数: clebsch_graph ()
     Clebschグラフを返します。

 -- 関数: complement_graph (<g>)
     グラフ <g>の補グラフを返します。

 -- 関数: complete_bipartite_graph (<n>, <m>)
     <n+m>この頂点上の完全2部グラフを返します。

 -- 関数: complete_graph (<n>)
     <n>この頂点上の完全グラフを返します。

 -- 関数: cycle_digraph (<n>)
     <n>個の頂点上の有向グラフを返します。

 -- 関数: cycle_graph (<n>)
     <n>この頂点上の閉路を返します。

 -- 関数: cuboctahedron_graph (<n>)
     立方八面体グラフを返します。

 -- 関数: cube_graph (<n>)
     <n>次元立方体を返します。

 -- 関数: dodecahedron_graph ()
     十二面体グラフを返します。

 -- 関数: empty_graph (<n>)
     <n>個の頂点上の空グラフを返します。

 -- 関数: flower_snark (<n>)
     <4n>個の頂点上の花グラフを返します。

     例:
          (%i1) load ("graphs")$
          (%i2) f5 : flower_snark(5)$
          (%i3) chromatic_index(f5);
          (%o3)                           4

 -- 関数: from_adjacency_matrix (<A>)
     隣接行列 <A>で表現されるグラフを返します。

 -- 関数: frucht_graph ()
     Fruchtグラフを返します。

 -- 関数: graph_product (<g1>, <g1>)
     グラフ <g1>と <g2>の直積を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) grid : graph_product(path_graph(3), path_graph(4))$
          (%i3) draw_graph(grid)$

 -- 関数: graph_union (<g1>, <g1>)
     グラフ<g1>と <g2>の和を返します。

 -- 関数: grid_graph (<n>, <m>)
     <n x m>グリッドを返します。

 -- 関数: great_rhombicosidodecahedron_graph ()
     大菱形二十・十二面体グラフを返します。

 -- 関数: great_rhombicuboctahedron_graph ()
     大斜方立方八面体グラフを返します。

 -- 関数: grotzch_graph ()
     Grotzchグラフを返します。

 -- 関数: heawood_graph ()
     Heawoodグラフを返します。

 -- 関数: icosahedron_graph ()
     二十面体グラフを返します。

 -- 関数: icosidodecahedron_graph ()
     二十・十二面体グラフを返します。

 -- 関数: 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

 -- 関数: line_graph (<g>)
     グラフ <g>の折れ線グラフを返します。

 -- 関数: 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]

 -- 関数: mycielski_graph (<g>)
     グラフ <g>のMycielskiグラフを返します。

 -- 関数: new_graph ()
     頂点も辺も持たないグラフを返します。

 -- 関数: path_digraph (<n>)
     <n>個の頂点上の有向道を返します。

 -- 関数: path_graph (<n>)
     <n>個の頂点上の道を返します。

 -- 関数: petersen_graph ()
 -- 関数: petersen_graph (<n>, <d>)
     Petersenグラフ <P_{n,d}>を返します。 <n>と <d>のデフォルト値は
     ‘n=5’と ‘d=2’です。

 -- 関数: random_bipartite_graph (<a>, <b>, <p>)
     ‘a+b’個の頂点上のランダムな2部グラフを返します。 辺それぞれは確率
     <p>で存在します。

 -- 関数: random_digraph (<n>, <p>)
     ‘n’個の頂点上のランダムな有向グラフを返します。 弧それぞれは確率
     <p>で存在します。

 -- 関数: random_regular_graph (<n>)
 -- 関数: random_regular_graph (<n>, <d>)
     <n>個の頂点上の ランダムな<d>正則グラフを返します。 <d>のデフォルト
     値は ‘d=3’です。

 -- 関数: random_graph (<n>, <p>)
     <n>個の頂点上のランダムグラフを返します。 辺それぞれは確率 <p>で存
     在します。

 -- 関数: random_graph1 (<n>, <m>)
     <n>個の頂点とランダムな <m>個の辺上のランダムグラフを返します。

 -- 関数: 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

 -- 関数: random_tournament (<n>)
     <n>個の頂点上のランダムなトーナメントを返します。

 -- 関数: random_tree (<n>)
     <n>個の頂点上のランダムな木を返します。

 -- 関数: 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 ()
     Tutteグラフを返します。

 -- 関数: underlying_graph (<g>)
     有向グラフ <g>の台グラフを返します。

 -- 関数: wheel_graph (<n>)
     <n+1>個の頂点上の車輪グラフを返します。

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 ]

 -- 関数: average_degree (<gr>)
     グラフ <gr>に関する平均次数を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) average_degree(grotzch_graph());
                                         40
          (%o2)                          --
                                         11

 -- 関数: 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]]

 -- 関数: 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)$

 -- 関数: chromatic_index (<gr>)
     グラフ <gr>の彩色指数を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) chromatic_index(p);
          (%o3)                           4

 -- 関数: chromatic_number (<gr>)
     グラフ <gr>の彩色数を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) chromatic_number(cycle_graph(5));
          (%o2)                           3
          (%i3) chromatic_number(cycle_graph(6));
          (%o3)                           2

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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]]

 -- 関数: diameter (<gr>)
     グラフ <gr>の直径を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) diameter(dodecahedron_graph());
          (%o2)                           5

 -- 関数: 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

 -- 関数: 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]

 -- 関数: edge_connectivity (<gr>)
     グラフ <gr>の辺連結性を返します。

     ‘min_edge_cut’も参照してください。

 -- 関数: edges (<gr>)
     (有向)グラフ <gr>の辺(弧)のリストを返します。

     例:
          (%i1) load ("graphs")$
          (%i2) edges(complete_graph(4));
          (%o2)   [[2, 3], [1, 3], [1, 2], [0, 3], [0, 2], [0, 1]]

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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)

 -- 関数: graph_center (<gr>)
     グラフ <gr>の中心を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) g : grid_graph(5,5)$
          (%i3) graph_center(g);
          (%o3)                         [12]

 -- 関数: graph_eigenvalues (<gr>)
     グラフ <gr>の固有値を返します。 関数は maxima ‘eigenvalue’関数と同
     じフォーマットで固有値を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) graph_eigenvalues(p);
          (%o3)               [[3, - 2, 1], [1, 4, 5]]

 -- 関数: graph_periphery (<gr>)
     グラフ <gr>の外周を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) g : grid_graph(5,5)$
          (%i3) graph_periphery(g);
          (%o3)                    [24, 20, 4, 0]

 -- 関数: graph_size (<gr>)
     グラフ <gr>の辺の数を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) graph_size(p);
          (%o3)                          15

 -- 関数: graph_order (<gr>)
     グラフ <gr>の頂点の数を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) graph_order(p);
          (%o3)                          10

 -- 関数: girth (<gr>)
     <gr>の最短閉路の長さを返します。

     例:
          (%i1) load ("graphs")$
          (%i2) g : heawood_graph()$
          (%i3) girth(g);
          (%o3)                           6

 -- 関数: 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))$

 -- 関数: 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))$

 -- 関数: 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]

 -- 関数: 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)                          []

 -- 関数: 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

 -- 関数: 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

 -- 関数: is_connected (<gr>)
     もしグラフ <gr>が連結なら ‘true’を、 そうでないなら ‘false’を返しま
     す。

     例:
          (%i1) load ("graphs")$
          (%i2) is_connected(graph_union(cycle_graph(4), path_graph(3)));
          (%o2)                         false

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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  ]

 -- 関数: 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]

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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)$

 -- 関数: 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)$

 -- 関数: 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

 -- 関数: min_edge_cut (<gr>)
     グラフ <gr>の最小切断辺を返します。

     ‘edge_connectivity’も参照してください。

 -- 関数: min_vertex_cover (<gr>)
     グラフ <gr>の最小頂点被覆を返します。

 -- 関数: min_vertex_cut (<gr>)
     Returns the minimum vertex cut in the graph グラフ <gr>の最小頂点切
     断を返します。

     ‘vertex_connectivity’も参照してください。

 -- 関数: 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))$

 -- 関数: neighbors (<v>, <gr>)
     グラフ <gr>の頂点 <v>の隣接点のリストを返します。

     例:
          (%i1) load ("graphs")$
          (%i2) p : petersen_graph()$
          (%i3) neighbors(3, p);
          (%o3)                       [4, 8, 2]

 -- 関数: 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

 -- 関数: 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)                          []

 -- 関数: 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]]

 -- 関数: 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]

 -- 関数: radius (<gr>)
     グラフ <gr>の半径を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) radius(dodecahedron_graph());
          (%o2)                           5

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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))$

 -- 関数: 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]]

 -- 関数: 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

 -- 関数: 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]

 -- 関数: vertex_connectivity (<g>)
     グラフ <g>の頂点連結性を返します。

     ‘min_vertex_cut’も参照してください。

 -- 関数: vertex_degree (<v>, <gr>)
     グラフ <gr>の頂点 <v>の次数を返します。

 -- 関数: 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]

 -- 関数: vertex_eccentricity (<v>, <gr>)

     グラフ <gr>の頂点 <v>の離心率を返します。

     例:
          (%i1) load ("graphs")$
          (%i2) g:cycle_graph(7)$
          (%i3) vertex_eccentricity(0, g);
          (%o3)                           3

 -- 関数: 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]

 -- 関数: 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]

 -- 関数: vertices (<gr>)
     グラフ <gr>の頂点のリストを返します。

     例:
          (%i1) load ("graphs")$
          (%i2) vertices(complete_graph(4));
          (%o2)                     [3, 2, 1, 0]

 -- 関数: 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]]]

 -- 関数: wiener_index (<gr>)
     グラフ <gr>のWiener指数を返します。

     例:
          (%i2) wiener_index(dodecahedron_graph());
          (%o2)                          500

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]

 -- 関数: 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

 -- 関数: 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

 -- 関数: add_vertices (<v_list>, <gr>)
     リスト <v_list>の中の頂点すべてをグラフ <gr>に加えます。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: remove_vertex (<v>, <gr>)
     グラフ <gr>から頂点 <v>を削除します。

56.2.4 Reading and writing to files
-----------------------------------

 -- 関数: dimacs_export (<gr>, <fl>)
 -- 関数: dimacs_export (<gr>, <fl>, <comment1>, ..., <commentn>)

     グラフをファイル <fl>にDIMACSフォーマットでエクスポートします。 オ
     プションのコメントはファイルの頭に加えられます。

 -- 関数: dimacs_import (<fl>)

     DIMACSフォーマットのファイル <fl>からグラフを返します。

 -- 関数: graph6_decode (<str>)

     文字列 <str>にgraph6フォーマットで符号化されたグラフを返します。

 -- 関数: graph6_encode (<gr>)

     グラフ <gr>をgraph6フォーマットに符号化した文字列を返します。

 -- 関数: graph6_export (<gr_list>, <fl>)

     リスト <gr_list>内のグラフをファイル <fl>に graph6フォーマットでエ
     クスポートします。

 -- 関数: graph6_import (<fl>)

     graph6フォーマットのファイル <fl>からグラフのリストを返します。

 -- 関数: sparse6_decode (<str>)

     文字列 <str>にsparse6フォーマットで符号化されたグラフを返します。

 -- 関数: sparse6_encode (<gr>)

     グラフ <gr>をsparse6フォーマットに符号化した文字列を返します。

 -- 関数: sparse6_export (<gr_list>, <fl>)

     リスト <gr_list>内のグラフを ファイル <fl>にsparse6フォーマットでエ
     クスポートします。

 -- 関数: sparse6_import (<fl>)

     sparse6フォーマットのファイル <fl>からグラフのリストを返します。

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

 -- オプション変数: draw_graph_program
     デフォルト値: <spring_embedding>

     頂点を配置するのに使われるプログラムのデフォルト値は ‘draw_graph’プ
     ログラムです。

 -- draw_graphオプション: show_id
     デフォルト値: <false>

     もし <true>なら頂点のidが表示されます。

 -- draw_graphオプション: show_label
     デフォルト値: <false>

     もし <true>なら頂点のラベルが表示されます。

 -- draw_graphオプション: label_alignment
     デフォルト値: <center>

     頂点のラベル/idをいかに整列させるか決めます。 ‘left’, ‘center’,
     ‘right’であり得ます。

 -- draw_graphオプション: show_weight
     デフォルト値: <false>

     もし <true>なら辺の重みを表示します。

 -- draw_graphオプション: vertex_type
     デフォルト値: <circle>

     頂点をいかに表示するか定義します。 可能な値に関しては、 ‘draw’パッ
     ケージの <point_type>オプションを参照してください。

 -- draw_graphオプション: vertex_size
     頂点のサイズ。

 -- draw_graphオプション: vertex_color
     頂点を表示するのに使う色。

 -- draw_graphオプション: show_vertices
     デフォルト値: []

     選択された頂点を異なる色を使って表示。

 -- draw_graphオプション: show_vertex_type

     <show_vertices>で指定された頂点をいかに表示するか定義します。 可能
     な値については、 ‘draw’パッケージの <point_type>オプションを参照し
     てください。

 -- draw_graphオプション: show_vertex_size
     <show_vertices>内の頂点のサイズ

 -- draw_graphオプション: show_vertex_color
     <show_vertices>リスト内の頂点を表示するのに使う色。

 -- draw_graphオプション: vertex_partition
     デフォルト値: []

     グラフの頂点の分割 ‘[[v1,v2,...],...,[vk,...,vn]]’ 分割内のそれぞれ
     のリストの頂点は異なる色で描画されます。

 -- draw_graphオプション: vertex_coloring
     頂点の色付けを指定します。 色付け <col>は <vertex_coloring>が返すよ
     うなフォーマットで指定されなければいけません。

 -- draw_graphオプション: edge_color
     辺を表示するのに使われる色。

 -- draw_graphオプション: edge_width
     辺の幅。

 -- draw_graphオプション: edge_type
     辺をいかに表示するか定義します。 ‘draw’パッケージの<line_type>オプ
     ションを参照してください。

 -- draw_graphオプション: show_edges
     異なる色を使ってリスト <e_list>内で指定された辺を表示する。

 -- draw_graphオプション: show_edge_color
     <show_edges>リスト内の辺を表示するのに使う色。

 -- draw_graphオプション: show_edge_width
     <show_edges>内の辺の幅。

 -- draw_graphオプション: show_edge_type
     <show_edges>内の辺を以下に表示するかを定義します。 ‘draw’パッケージ
     の<line_type>オプションを参照してください。

 -- draw_graphオプション: edge_partition
     グラフの辺の分割 ‘[[e1,e2,...],...,[ek,...,em]]’ 分割内のそれぞれの
     リストの辺は異なる色を使って描画されます。

 -- draw_graphオプション: edge_coloring
     辺の色付け。 色付けは 関数 <edge_coloring>が返すようなフォーマット
     で指定しなければいけません。

 -- draw_graphオプション: redraw
     デフォルト値: <false>

     もし ‘true’なら、 たとえ位置がグラフの以前の描画から保存されていて
     も頂点位置が再計算されます。

 -- draw_graphオプション: head_angle
     デフォルト値: 15

     (有向グラフの)弧に表示される矢印の角度。

 -- draw_graphオプション: head_length
     デフォルト値: 0.1

     (有向グラフの)弧に表示される矢印の長さ。

 -- draw_graphオプション: spring_embedding_depth
     デフォルト値: 50

     バネ埋め込みグラフ描画アルゴリズムでの繰り返し回数

 -- draw_graphオプション: terminal
     描画で使う端末。 (‘draw’パッケージの <terminal>オプションを参照して
     ください。)

 -- draw_graphオプション: file_name
     端末がスクリーンでないなら、描画のファイル名。

 -- draw_graphオプション: program
     グラフの頂点を配置するのに使われるプログラムを定義します。
     graphvizプログラム (dot, neato, twopi, circ, fdp)の1つ, <circular>,
     <spring_embedding>, <planar_embedding>を取り得ます。 2連結平面グラ
     フでは <planar_embedding>だけが利用可能です。
     ‘program=spring_embedding’の時、 固定位置の頂点の集合が
     <fixed_vertices>オプションで指定可能です。

 -- draw_graphオプション: fixed_vertices
     正多角形沿いに固定された位置を持つ頂点のリストを指定します。
     ‘program=spring_embedding’の時、使うことができます。

 -- 関数: vertices_to_path (<v_list>)
     頂点のリスト <v_list>を <v_list>で定義された経路の辺のリストに変換
     します。

 -- 関数: vertices_to_cycle (<v_list>)
     頂点のリスト <v_list>を <v_list>で定義された閉路の辺のリストに変換
     します。


File: maxima.info,  Node: grobner,  Next: impdiff,  Prev: graphs,  Up: Top

57 grobner
**********

* Menu:

* Introduction to grobner ::
* Functions and Variables for grobner ::


File: maxima.info,  Node: Introduction to grobner,  Next: Functions and Variables for grobner,  Prev: Top,  Up: Top

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

57.1.2 Implementations of admissible monomial orders in grobner
---------------------------------------------------------------

   • ‘lex’

     純粋に辞書式の、 単項式比較のデフォルト順序
   • ‘grlex’

     全次数順序。同点は辞書式で決めます。

   • ‘grevlex’

     全次数。同点は逆辞書式で決めます。

   • ‘invlex’

     逆時書式順序。


File: maxima.info,  Node: Functions and Variables for grobner,  Prev: Introduction to grobner,  Up: Top

57.2 Functions and Variables for grobner
========================================

57.2.1 Global switches for grobner
----------------------------------

 -- オブション変数: poly_monomial_order
     デフォルト値: ‘lex’

     このグローバルスイッチは どの単項式順序が多項式とGroebner基底計算で
     使われるか制御します。 もし設定されないなら、 ‘lex’が使われます。

 -- オブション変数: poly_coefficient_ring
     デフォルト値: ‘expression_ring’

     このスイッチは grober計算で使われる多項式の係数環を示します。 もし
     設定されないなら、 _maximaの_ 一般式環が使われます。 もし望むなら、
     この変数を ‘ring_of_integers’に設定できます。

 -- オブション変数: poly_primary_elimination_order
     デフォルト値: ‘false’

     消去ベース関数で消去される変数のデフォルト順序名。 設定されていない
     なら、 ‘lex’が使われます。

 -- オブション変数: poly_secondary_elimination_order
     デフォルト値: ‘false’

     消去ベース関数で保持される変数のデフォルト順序名。 設定されていない
     なら、 ‘lex’が使われます。

 -- オブション変数: poly_elimination_order
     デフォルト値: ‘false’

     消去計算で使われるデフォルト消去順序名。 設定されているなら、 変数
     ‘poly_primary_elimination_order’と
     ‘poly_secondary_elimination_order’の設定を上書きします。 ユーザーは
     これが消去変数の数に有効な真の消去順序であることを保証しなければい
     けません。

 -- オブション変数: poly_return_term_list
     デフォルト値: ‘false’

     もし ‘true’に設定されているなら、 このパッケージの関数すべては
     _maxima_一般式ではなく、 それぞれの多項式を 現在の単項式順序で並べ
     た項のリストとして返します。

 -- オブション変数: poly_grobner_debug
     デフォルト値: ‘false’

     もし ‘true’に設定されているなら、 デバッグ用、トレース用出力を生成
     します。

 -- オブション変数: poly_grobner_algorithm
     デフォルト値: ‘buchberger’

     可能な値:
        • ‘buchberger’
        • ‘parallel_buchberger’
        • ‘gebauer_moeller’

     Groebner基底を見つけるのに使われるアルゴリズム名。

 -- オブション変数: poly_top_reduction_only
     デフォルト値: ‘false’

     もし ‘false’でないなら、 可能な時はいつでも、頭項簡約を使います。 頭
     項簡約は、割り算アルゴリズムが最初の簡約後に停止することを意味しま
     す。

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

 -- 関数: 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

 -- 関数: 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

 -- 関数: poly_s_polynomial (<poly1>, <poly2>, <varlist>)
     2つの多項式 <poly1>と <poly2>の _シジジー多項式_ (_S多項式_)を返し
     ます。

 -- 関数: poly_primitive_part (<poly1>, <varlist>)
     多項式 <poly1>を係数のGCDで割ったものを返します。

          (%i1) poly_primitive_part(35*y+21*x,[x,y]);
          (%o1)                              5 y + 3 x

 -- 関数: poly_normalize (<poly>, <varlist>)
     多項式 <poly1>を主係数で割ったものを返します。 割り算が可能であるこ
     とを仮定しています。 これは、体の場合には大丈夫ですが、環の場合には
     いつも可能なわけではありません。

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

 -- 関数: poly_expt (<poly>, <number>, <varlist>)
     <poly>の、正の整数 <number>のべき乗を返します。 もし <number>が正の
     整数でないなら、 エラーが生じます。

          (%i1) poly_expt(x-y,3,[x,y])-(x-y)^3,expand;
          (%o1)                                  0

 -- 関数: poly_content (<poly>. <varlist>)
     ‘poly_content’は係数のGCDを抽出します。

          (%i1) poly_content(35*y+21*x,[x,y]);
          (%o1)                                  7

 -- 関数: 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.

 -- 関数: poly_exact_divide (<poly1>, <poly2>, <varlist>)
     多項式 <poly1>を多項式 <poly2>で割ります。 余りのない厳密な割り算が
     可能と仮定します。 商を返します。

 -- 関数: poly_normal_form (<poly>, <polylist>, <varlist>)
     ‘poly_normal_form’は 多項式の集合 <polylist>に関して 多項式 <poly>の
     正規形を見つけます。

 -- 関数: poly_buchberger_criterion (<polylist>, <varlist>)
     Buchberger判定(criterion)を使って もし <polylist>が現在の項順序に関
     して Groebner基底なら ‘true’を返します: Buchberger判定(criterion)は
     、 <polylist>の2つの多項式 h1と h2すべてに関して、 S多項式
     S(h1,h2)が <polylist>を法として0に簡約されるというものです。

 -- 関数: poly_buchberger (<polylist_fl> <varlist>)
     ‘poly_buchberger’は 多項式のリスト上でBuchbergerアルゴリズムを実行
     し、 結果の Groebner基底を返します。

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>を簡約します。 それぞれ
     の多項式は他の多項式で完全に簡約されます。

 -- 関数: poly_minimization (<polylist>, <varlist>)
     <polylist>と同じ単項式イデアルの最小全域である、 多項式リスト
     <polylist>の部分リストを返します。 すなわち、部分リストの中の多項式
     の主単項式はすべて、他の多項式の主単項式を割りません。

 -- 関数: poly_normalize_list (<polylist>, <varlist>)
     ‘poly_normalize_list’は ‘poly_normalize’をリストの中の多項式それぞ
     れに適用します。 これは リスト <polylist>の中のすべての多項式を主係
     数で割ることを意味します。

 -- 関数: poly_grobner (<polylist>, <varlist>)
     多項式リスト <polylist>で張られたイデアルのGroebner基底を返します。
     グローバルフラグで影響を受けます。

 -- 関数: poly_reduced_grobner (<polylist>, <varlist>)
     多項式リスト <polylist>で張られたイデアルの簡約Groebner基底を返しま
     す。

 -- 関数: poly_depends_p (<poly>, <var>, <varlist>)
     ‘poly_depends’は多項式が変数 <var>に依存するかテストします。

 -- 関数: poly_elimination_ideal (<polylist>, <number>, <varlist>)

     ‘poly_elimination_ideal’は、 (必ずしもGroebner基底である必要はない
     )生成多項式のリストとして指定されたイデアルの number番目の消去イデ
     アルの Groebner基底を返します。

 -- 関数: poly_colon_ideal (<polylist1>, <polylist2>, <varlist>)

     コロンイデアル

     I(polylist1):I(polylist2)

     の簡約Groebner基底を返します。

     ここで、 polylist1と polylist2は2つの多項式リストです。

 -- 関数: poly_ideal_intersection (<polylist1>, <polylist2>, <varlist>)

     ‘poly_ideal_intersection’は2つのイデアルの交わりです。

 -- 関数: poly_lcm (<poly1>, <poly2>, <varlist>)
     <poly1>と <poly2>の最小公倍数(式)を返します。

 -- 関数: poly_gcd (<poly1>, <poly2>, <varlist>)

     <poly1>と <poly2>の最大公約数(式)を返します。

     ‘*note ezgcd::’, ‘*note gcd::’, ‘*note gcdex::’, ‘*note 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

 -- 関数: 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

 -- 関数: poly_grobner_subsetp (<polylist1>, <polylist2>, <varlist>)

     ‘poly_grobner_subsetp’は <polylist1>が生成するイデアルが
     <polylist2>が生成するイデアルに含まれるかテストします。 このテスト
     が常に成功するには、<polylist2>が Groebner基底でなければいけません
     。

 -- 関数: poly_grobner_member (<poly>, <polylist>, <varlist>)

     もし多項式 <poly>が Groebner基底であると仮定された多項式リスト
     <polylist>が生成するイデアルに属するなら、 ‘true’を返します。 そう
     でないなら、 ‘false’を返します。

     ‘poly_grobner_member’は 多項式が Groebner基底であると仮定された多項
     式のリストが生成するイデアルに属するかテストします。 ‘normal_form’が
     0と同値です。

 -- 関数: poly_ideal_saturation1 (<polylist>, <poly>, <varlist>)
     イデアル

     I(polylist):poly^inf のsaturationの簡約 Groebner基底を返します。

     幾何学的に、代数的閉体上で、 これは <poly>の多様体上で恒等的に0とな
     らない <polylist>が生成するイデアルの中の 多項式の集合です。

 -- 関数: poly_ideal_saturation (<polylist1>, <polylist2>, <varlist>)
     イデアル

     I(polylist1):I(polylist2)^inf のsaturationの簡約 Groebner基底を返し
     ます。

     幾何学的に、代数的閉体上で、 これは <polylist2>の多様体上で恒等的に
     0とならない <polylist1>が生成するイデアルの中の 多項式の集合です。

 -- 関数: poly_ideal_polysaturation1 (<polylist1>, <polylist2>,
          <varlist>)
     <polylist2>は2個の多項式のリスト ‘[poly1,...,polyn]’です。 多項式リ
     スト <polylist1>が生成するイデアルの 多項式リスト <polylist2>の多項
     式に関する連続saturationの列によって得られるイデアル

     I(polylist):poly1^inf:...:polyn^inf

     の簡約 Groebner基底を返します。

 -- 関数: poly_ideal_polysaturation (<polylist>, <polylistlist>,
          <varlist>)
     <polylistlist>は多項式リストn個のリスト
     ‘[polylist1,...,polylistn]’です。 イデアル

     I(polylist):I(polylist_1)^inf:...:I(polylist_n)^inf のsaturationの
     簡約 Groebner基底を返します。

 -- 関数: poly_saturation_extension (<poly>, <polylist>, <varlist1>,
          <varlist2>)

     ‘poly_saturation_extension’は有名な Rabinowitzのトリックを実装しま
     す。

 -- 関数: poly_polysaturation_extension (<poly>, <polylist>, <varlist1>,
          <varlist2>)


File: maxima.info,  Node: impdiff,  Next: implicit_plot,  Prev: grobner,  Up: Top

58 impdiff
**********

* Menu:

* Functions and Variables for impdiff::


File: maxima.info,  Node: Functions and Variables for impdiff,  Prev: impdiff,  Up: impdiff

58.1 Functions and Variables for impdiff
========================================

 -- 関数: implicit_derivative (<f>,<indvarlist>,<orderlist>,<depvar>)
     このサブルーチンは多変数関数の陰導関数を計算します。 <f>は配列関数
     で、 インデックスは<indvarlist>順の微分の階数です; <indvarlist>は独
     立変数リストです; <orderlist>は望みの次数です; <depvar>は従属変数で
     す。

     この関数を使うには、最初に‘load("impdiff")’を書いてください。


File: maxima.info,  Node: implicit_plot,  Next: interpol,  Prev: impdiff,  Up: Top

59 implicit_plot
****************

* Menu:

* Functions and Variables for implicit_plot::


File: maxima.info,  Node: Functions and Variables for implicit_plot,  Prev: implicit_plot,  Up: implicit_plot

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"]);


File: maxima.info,  Node: interpol,  Next: lapack,  Prev: implicit_plot,  Up: Top

60 interpol
***********

* Menu:

* Introduction to interpol::
* Functions and Variables for interpol::


File: maxima.info,  Node: Introduction to interpol,  Next: Functions and Variables for interpol,  Prev: interpol,  Up: interpol

60.1 Introduction to interpol
=============================

パッケージ‘interpol’は 多項式内挿のためのLagrange、線形、三次スプライン
法を定義します。

   コメント、バグ、提案は<'mario AT edu DOT xunta DOT es'>にコンタクトを
取ってください。


File: maxima.info,  Node: Functions and Variables for interpol,  Prev: Introduction to interpol,  Up: interpol

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

 -- 関数: charfun2 (<x>, <a>, <b>)
     もし数 <x>が区間 [a, b)に属するなら、‘true’を返し、 そうでないなら
     、 ‘false’を返します。

 -- 関数: 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

 -- 関数: 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))$

 -- 関数: 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])$


File: maxima.info,  Node: lapack,  Next: lbfgs,  Prev: interpol,  Up: Top

61 lapack
*********

* Menu:

* Introduction to lapack::
* Functions and Variables for lapack::


File: maxima.info,  Node: Introduction to lapack,  Next: Functions and Variables for lapack,  Prev: lapack,  Up: lapack

61.1 Introduction to lapack
===========================

‘lapack’は SLATECプロジェクトから得られるようなFortranライブラリLAPACKの
(プログラム ‘f2c’を介した) Common Lisp翻訳です。

   (訳者注意書き: lapackを使用するには、load("lapack");
load("eigensys");を実行してください。load("lapack")には、初回だけコンパ
イルで時間がかかるかもしれません。)


File: maxima.info,  Node: Functions and Variables for lapack,  Prev: Introduction to lapack,  Up: lapack

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      ]

 -- 関数: dgeqrf (<A>)

     行列 <A>のQR分解します。 All elements of <A>のすべての要素は整数か
     浮動小数点数でなければいけません。 <A>は行と列の数は同じかもしれま
     せんし違うかもしれません。

     2つの項目のリストを返します。 一番目の項目は行列 <Q>で、それは<A>と
     同じ行数を持つ平方正規直交行列です。 二番目の項目は行列 <R>で、それ
     は<A>tお同じサイズで、 対角以下のすべての要素がが零に等しいものです
     。 積 ‘<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

 -- 関数: 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

 -- 関数: 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      ]

 -- 関数: 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ノルム、すなわち、 行列要素の平方の和の平方根 を
          計算します。

 -- 関数: 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 ]


File: maxima.info,  Node: lbfgs,  Next: lindstedt,  Prev: lapack,  Up: Top

62 lbfgs
********

* Menu:

* Introduction to lbfgs::
* Functions and Variables for lbfgs::


File: maxima.info,  Node: Introduction to lbfgs,  Next: Functions and Variables for lbfgs,  Prev: Top,  Up: Top

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>


File: maxima.info,  Node: Functions and Variables for lbfgs,  Prev: Introduction to lbfgs,  Up: Top

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]

 -- 変数: lbfgs_nfeval_max
     デフォルト値: 100

     ‘lbfgs_nfeval_max’は、‘lbfgs’がする性能指標(FOM)の評価の最大回数で
     す。 ‘lbfgs_nfeval_max’に届いた時、 ‘lbfgs’は最後に成功した直線探索
     の結果を返します。

 -- 変数: lbfgs_ncorrections
     デフォルト値: 25

     ‘lbfgs_ncorrections’は‘lbfgs’が保つ近似逆Hessian行列に適用された修
     正回数です。


File: maxima.info,  Node: lindstedt,  Next: linearalgebra,  Prev: lbfgs,  Up: Top

63 lindstedt
************

* Menu:

* Functions and Variables for lindstedt::


File: maxima.info,  Node: Functions and Variables for lindstedt,  Prev: lindstedt,  Up: lindstedt

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")’を書いてください。


File: maxima.info,  Node: linearalgebra,  Next: lsquares,  Prev: lindstedt,  Up: Top

64 linearalgebra
****************

* Menu:

* Introduction to linearalgebra::
* Functions and Variables for linearalgebra::


File: maxima.info,  Node: Introduction to linearalgebra,  Next: Functions and Variables for linearalgebra,  Prev: linearalgebra,  Up: linearalgebra

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 ]


File: maxima.info,  Node: Functions and Variables for linearalgebra,  Prev: Introduction to linearalgebra,  Up: linearalgebra

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])

 -- 関数: blockmatrixp (<M>)

     <M>のエントリがすべて行列なら、その時に限って、 trueを返します。

 -- 関数: columnop (<M>, <i>, <j>, <theta>)

     もし<M>が行列なら、 列演算‘C_i <- C_i - <theta> * C_j’を施すことで
     生じる行列を返します。 もし<M>が行<i>か行<j>を持たないなら エラーを
     シグナルします。

 -- 関数: columnswap (<M>, <i>, <j>)

     もし <M>が行列なら、列 <i>と <j>を交換します。 もし <M>に列 <i>か
     <j>がないなら、 エラーをシグナルします。

 -- 関数: columnspace (<M>)

     もし <M>が行列なら、 ‘span (v_1, ..., v_n)’を返します。 ここで、集
     合 ‘{v_1, ..., v_n}’は <M>の列空間の基底です。 空集合の包は ‘{0}’で
     す。 従って、列空間が1員だけ持つ時、 ‘span ()’を返します。

 -- 関数: 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>の値を変えません。

 -- 関数: cholesky (<M>)
 -- 関数: cholesky (<M>, <field>)

     自己共役(すなわちHermite)行列のCholesky分解を返します。

     二番目の引数はデフォルトでは'generalring'です。 <field>の取り得る値
     の説明については ‘lu_factor’を参照してください。

 -- 関数: ctranspose (<M>)

     行列 <M>の複素共役転置を返します。 関数 ‘ctranspose’は それぞれの行
     列要素を転置するのに ‘matrix_element_transpose’を使います。

 -- 関数: 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 ]

 -- 関数: dotproduct (<u>, <v>)

     ベクトル <u>と <v>の内積を返します。 これは‘conjugate (transpose
     (<u>)) . <v>’と同じです。 引数 <u>と <v>は列ベクトルでなければいけ
     ません。

 -- 関数: 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 ]

 -- 関数: get_lu_factors (<x>)

     ‘<x> = lu_factor (<A>)’の時、 ‘get_lu_factors’は 形式 ‘[P, L, U]’の
     リストを返します。 ここで、 <P>は置換行列、 <L>は対角成分を含む下三
     角行列、 <U>は上三角行列であり、 ‘<A> = <P> <L> <U>’が成り立ちます
     。

 -- 関数: hankel (<col>)
 -- 関数: hankel (<col>, <row>)

     Hankel行列 <H>を返します。 <H>の最初の列は <col>です; 最初の成分を
     除いて、 <H>の最後の行は <row>です。 <row>のデフォルトは <col>と同
     じ長さを持つ零ベクトルです。

 -- 関数: 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   ]

 -- 関数: hilbert_matrix (<n>)

     <n>掛け<n>のHilbert行列を返します。 <n>が正の整数でない時、エラーを
     シグナルします。

 -- 関数: identfor (<M>)
 -- 関数: identfor (<M>, <fld>)

     行列 <M>と同じ形を持つ単位行列を返します。 単位行列の対角成分は体
     <fld>の乗算単位元です; <fld>のデフォルトは <generalring>です。

     一番目の引数 <M>は平方行列か非行列でなければいけません。 <M>が行列
     の時、 <M>のそれぞれの成分は平方行列であり得ます。 - 従って、 <M>は
     区分されたMaxima行列であり得ます。 行列は、任意の(有限の)深さに区分
     できます。

     ‘zerofor’も参照してください。

 -- 関数: invert_by_lu (<M>, <(rng generalring)>)

     LU分解を使って、 行列 <M>の逆行列を返します。 LU分解は環 <rng>を使
     って実行されます。

 -- 関数: 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 ]

 -- 関数: kronecker_product (<A>, <B>)

     行列 <A>と <B>のKronecker積を返します。

 -- 関数: listp (<e>, <p>)
 -- 関数: listp (<e>)

     オプションの引数 <p>が与えられたとして、 もし <e>がMaximaリストで、
     <p>がすべてのリストの要素で ‘true’に評価されるなら、 ‘true’を返しま
     す。 ‘listp’がオプションの引数を与えられない時、 もし <e>がMaximaリ
     ストなら、 ‘true’を返します。 他のすべての場合、 ‘false’を返します
     。

 -- 関数: 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>を最小にする成分を探して部分行列をスキャンします。 最小化の成分
     のインデックスを返します。

 -- 関数: lu_backsub (<M>, <b>)

     ‘<M> = lu_factor (<A>, <field>)’の時、 ‘lu_backsub (<M>, <b>)’は 線
     形系 ‘<A> <x> = <b>’を解きます。

 -- 関数: 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 ]

 -- 関数: mat_cond (<M>, 1)
 -- 関数: mat_cond (<M>, inf)

     行列 <m>の<p>-ノルムの行列条件数を返します。 <p>に許される値は1と
     <inf>です。 この関数は、行列 <m>の逆元を計算するのにLU分解を使いま
     す。 このため、‘mat_cond’の実行時間は行列サイズの三乗に比例します;
     ‘lu_factor’は、 行列サイズの二乗に比例する時間内に 無限大ノルム条件
     数の下限と上限を決定します。

 -- 関数: mat_norm (<M>, 1)
 -- 関数: mat_norm (<M>, inf)
 -- 関数: mat_norm (<M>, frobenius)

     行列 <M>の行列 <p>-ノルムを返します。 .  The allowed values for
     <p>に許される値は1か ‘inf’か ‘frobenius’ (Frobenius行列ノルム)です
     。 行列 <M>は区分されない行列でなければいけません。

 -- 関数: matrixp (<e>, <p>)
 -- 関数: matrixp (<e>)

     オプション引数 <p>が与えられたとして、 もし <e>が行列で、 <p>が行列
     成分すべてに対して ‘true’に評価されるなら、 ‘true’を返します。
     ‘matrixp’がオプション引数を与えられない時は、 もし ‘e’が行列なら、
     ‘true’を返します。 他のすべての場合には、 ‘false’を返します。

     ‘blockmatrixp’も参照してください。

 -- 関数: matrix_size (<M>)

     行列 <M>の行数と列数をそれぞれ与える2要素リストを返します。

 -- 関数: mat_fullunblocker (<M>)

     もし <M>が区分行列なら、 行列をすべてのレベルで区分解除します。 も
     し <M>が行列なら、 <M>を返します; それ以外ではエラーをシグナルしま
     す。

 -- 関数: mat_trace (<M>)

     行列 <M>の跡を返します。 もし <M>が行列でないなら、名詞形を返します
     。 <M>が区分行列の時、 ‘mat_trace(M)’は
     ‘mat_trace(mat_unblocker(m))’するのと同じ値を返します。

 -- 関数: 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 ]

 -- 関数: nullspace (<M>)

     もし <M>が行列なら、 ‘span (v_1, ..., v_n)’を返します。 ここで、,
     where the set 集合 ‘{v_1, ..., v_n}’は <M>の零空間の基底です。 空集
     合のスパンは ‘{0}’です。 なので、零空間が要素を1つだけ持つときは、
     ‘span ()’を返します。

 -- 関数: nullity (<M>)

     もし <M>が行列なら、 <M>の零空間の次元を返します。

 -- 関数: 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>それぞれは列ベクトルでなければいけません。

 -- 関数: 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

 -- 関数: polytocompanion (<p>, <x>)

     もし <p>が <x>の多項式なら、 <p>のコンパニオン行列を返します。 次数
     <n>のモニック多項式(最高次数の係数が1の多項式)に対しては、 ‘<p> =
     (-1)^<n> charpoly (polytocompanion (<p>, <x>))’.  があります。

     <p>が <x>の多項式でないなら、エラーをシグナルします。

 -- 関数: 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>の多項式かチェックしません。

 -- 関数: rowop (<M>, <i>, <j>, <theta>)

     もし <M>が行列なら、 行演算 ‘R_i <- R_i - theta * R_j’をすることで
     生じる 行列を返します。 もし <M>に行<i>か <j>がないなら、 エラーを
     シグナルします。

 -- 関数: 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

 -- 関数: rowswap (<M>, <i>, <j>)

     もし <M>が行列なら、行 <i>と <j>を入れ替えます。 もし <M>に行<i>か
     <j>がないなら、エラーをシグナルします。

 -- 関数: 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    ]

 -- 関数: vandermonde_matrix ([<x_1>, ..., <x_n>])

     <i>番目の行が‘[1, <x_i>, <x_i>^2, ... <x_i>^(<n>-1)]’の <n>掛け
     <n>行列を返します。

 -- 関数: zerofor (<M>)
 -- 関数: zerofor (<M>, <fld>)

     行列 <M>と同じ形の零行列を返します。 零行列の成分すべては体 <fld>の
     加算の単位元です; <fld>のデフォルトは <generalring>です。

     一番目の引数 <M>は 平方行列か行列以外でなければいけません。 <M>が行
     列の時、 <M>の成分それぞれは平方行列であり得ます。 - 従って <M>は区
     分Maxima行列であり得ます。 行列は任意の(有限の)深さに区分できます。

     ‘identfor’も参照してください。

 -- 関数: zeromatrixp (<M>)

     <M>が区分行列でない時、 もし行列 <M>のそれぞれの要素 <e>に対して
     ‘is (equal (<e>, 0))’が真なら、 ‘true’を返します。 <M>が区分行列の
     時、 もし<e>の要素それぞれに対して ‘zeromatrixp’が ‘true’に評価され
     るなら、 ‘true’を返します。


File: maxima.info,  Node: lsquares,  Next: minpack,  Prev: linearalgebra,  Up: Top

65 lsquares
***********

* Menu:

* Introduction to lsquares::
* Functions and Variables for lsquares::


File: maxima.info,  Node: Introduction to lsquares,  Next: Functions and Variables for lsquares,  Prev: lsquares,  Up: lsquares

65.1 Introduction to lsquares
=============================

‘lsquares’は 数値データからモデルのパラメータを見積もる 最小二乗法を実装
するための関数のコレクションです。


File: maxima.info,  Node: Functions and Variables for lsquares,  Prev: Introduction to lsquares,  Up: lsquares

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

 -- 関数: 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

 -- 関数: 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]]

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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")’を書いてください。


File: maxima.info,  Node: minpack,  Next: makeOrders,  Prev: lsquares,  Up: Top

66 minpack
**********

* Menu:

* Introduction to minpack::
* Functions and Variables for minpack::


File: maxima.info,  Node: Introduction to minpack,  Next: Functions and Variables for minpack

66.1 Introduction to minpack
============================

‘Minpack’は Netlibから得られるFortranライブラリ MINPACKの (‘f2cl’を介し
た)Common Lisp翻訳です。


File: maxima.info,  Node: Functions and Variables for minpack,  Prev: Introduction to minpack

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’
          繰り返しがよい進捗を産んでいません。


File: maxima.info,  Node: makeOrders,  Next: mnewton,  Prev: minpack,  Up: Top

67 makeOrders
*************

* Menu:

* Functions and Variables for makeOrders::


File: maxima.info,  Node: Functions and Variables for makeOrders,  Prev: makeOrders,  Up: makeOrders

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")’を書いてください。


File: maxima.info,  Node: mnewton,  Next: numericalio,  Prev: makeOrders,  Up: Top

68 mnewton
**********

* Menu:

* Introduction to mnewton::
* Functions and Variables for mnewton::


File: maxima.info,  Node: Introduction to mnewton,  Next: Functions and Variables for mnewton,  Prev: mnewton,  Up: mnewton

68.1 Introduction to mnewton
============================

‘mnewton’は １変数または多変数の非線形方程式を解くための Newton法の実装
です。


File: maxima.info,  Node: Functions and Variables for mnewton,  Prev: Introduction to mnewton,  Up: mnewton

68.2 Functions and Variables for mnewton
========================================

 -- オプション変数: newtonepsilon
     デフォルト値: ‘10.0^(-fpprec/2)’

     ‘mnewton’関数が解に向かって収束した時を決定する精度。 もし
     ‘newtonepsilon’が多倍長浮動小数点なら、‘mnewton’計算は多倍長浮動小
     数点でされます。 ‘mnewton’も参照してください。

 -- オプション変数: newtonmaxiter
     デフォルト値: ‘50’

     もし収束しないか収束が遅すぎるなら ‘mnewton’関数を止める繰り返しの
     最大数。

     ‘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’も参照してください。


File: maxima.info,  Node: numericalio,  Next: opsubst,  Prev: mnewton,  Up: Top

69 numericalio
**************

* Menu:

* Introduction to numericalio::
* Functions and Variables for plain-text input and output::
* Functions and Variables for binary input and output::


File: maxima.info,  Node: Introduction to numericalio,  Next: Functions and Variables for plain-text input and output,  Prev: numericalio,  Up: numericalio

69.1 Introduction to numericalio
================================

‘numericalio’は ファイルやストリームを読み書きする関数のコレクションです
。 プレインテキスト入出力のための関数は、 数(整数、浮動小数点、多倍長浮
動小数点)やシンボル、文字列を読み書きできます。 バイナリ入出力のための関
数は、 浮動小数点数だけを読み書きできます。

   もし既に入力データを記憶すべきリスト、行列、配列オブジェクトがあるな
ら、 ‘numericalio’入力関数群はデータをそのオブジェクトに書き込むことがで
きます。 そうでなければ、 ‘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’は バイトストリームを読んだり書いたりするためのストリー
ムを開く 関数を含みます。


File: maxima.info,  Node: Functions and Variables for plain-text input and output,  Next: Functions and Variables for binary input and output,  Prev: Introduction to numericalio,  Up: numericalio

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>が指定されないなら、ファイルは空
     白で区切られていると仮定されます。

 -- 関数: read_array (<S>, <A>)
 -- 関数: read_array (<S>, <A>, <separator_flag>)

     <A>が一杯になるか、ソースが尽きるまで、 ソース<S>を配列<A>に読み込
     みます。 入力データは列優先順に配列に読み込まれます; 入力は<A>の次
     元に一致する必要はありません。

     ソース<S>はファイル名かストリームかもしれません。

     <separator_flag>の認識される値は ‘comma’, ‘pipe’, ‘semicolon’,
     ‘space’です。 もし<separator_flag>が指定されないなら、ファイルは空
     白で区切られていると仮定されます。

 -- 関数: 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>が指定されないなら、ファイルは空
     白で区切られていると仮定されます。

 -- 関数: read_nested_list (<S>)
 -- 関数: read_nested_list (<S>, <separator_flag>)

     ソース<S>を読み込み、 入れ子のリストとして内容全体を返します。 ソー
     ス<S>はファイル名かストリームかもしれません。

     ‘read_nested_list’は 入力のそれぞれの行について部分リストを持つリス
     トを返します。 行数は要素数と同じである必要はありません。 空の行は
     無視されません: 空の行は空の部分リストをもたらします。

     <separator_flag>の認識される値は ‘comma’, ‘pipe’, ‘semicolon’,
     ‘space’です。 もし<separator_flag>が指定されないなら、ファイルは空
     白で区切られていると仮定されます。

 -- 関数: 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>が指定されないなら、ファイルは空
     白で区切られていると仮定されます。

 -- 関数: 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>が指定されないなら、ファイルは空
     白で区切られていると仮定されます。


File: maxima.info,  Node: Functions and Variables for binary input and output,  Prev: Functions and Variables for plain-text input and output,  Up: numericalio

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’は外部のバイトオーダーは最上位
     バイト優先を仮定します。

 -- 関数: openr_binary (<file_name>)
     <file_name>という名前のファイルを読むための 8ビット符号なしバイトの
     入力ストリームを返します。

 -- 関数: openw_binary (<file_name>)
     <file_name>という名前のファイルに書き込むための 8ビット符号なしバイ
     トの出力ストリームを返します。

 -- 関数: opena_binary (<file_name>)
     <file_name>という名前のファイルに追加するための 8ビット符号なしバイ
     トの出力ストリームを返します。

 -- 関数: read_binary_matrix (<S>, <M>)
     <M>が一杯になるかソースが尽きるまで、 ソース<S>から行列<M>にバイナ
     リの8バイト浮動小数点数を読み込みます。 <M>の要素は行優先順で読み込
     まれます。

     ソース<S>はファイル名かストリームかもしれません。

     ソースの要素のバイトオーダーは ‘assume_external_byte_order’で指定さ
     れます。

 -- 関数: read_binary_array (<S>, <A>)
     <A>が一杯になるかソースが尽きるまで、 ソース<S>から配列<A>にバイナ
     リの8バイト浮動小数点数を読み込みます。 <M>の要素は行優先順で読み込
     まれます。

     ソース<S>はファイル名かストリームかもしれません。

     ソースの要素のバイトオーダーは ‘assume_external_byte_order’で指定さ
     れます。

 -- 関数: 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’で指定さ
     れます。

 -- 関数: 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’で指定されます。


File: maxima.info,  Node: opsubst,  Next: orthopoly,  Prev: numericalio,  Up: Top

70 opsubst
**********

* Menu:

* Functions and Variables for opsubst::


File: maxima.info,  Node: Functions and Variables for opsubst,  Prev: opsubst,  Up: opsubst

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")’を書いてください。


File: maxima.info,  Node: orthopoly,  Next: plotdf,  Prev: opsubst,  Up: Top

71 orthopoly
************

* Menu:

* Introduction to orthogonal polynomials::
* Functions and Variables for orthogonal polynomials::


File: maxima.info,  Node: Introduction to orthogonal polynomials,  Next: Functions and Variables for orthogonal polynomials,  Prev: orthopoly,  Up: orthopoly

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)の下で公開されています。

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

   更に知るにはセクション*note 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>)’を使って関数名をクォートするだけとは違います。

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コードを使って評価されます。


File: maxima.info,  Node: Functions and Variables for orthogonal polynomials,  Prev: Introduction to orthogonal polynomials,  Up: orthopoly

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.

 -- 関数: assoc_legendre_q (<n>, <m>, <x>)
     次数 <n>と位数 <m>の第二種Legendre陪函数。

     参考文献: Abramowitz and Stegun, equation 8.5.3 and 8.1.8.

 -- 関数: chebyshev_t (<n>, <x>)
     第一種Chebyshev函数。

     参考文献: Abramowitz and Stegun, equation 22.5.47, page 779.

 -- 関数: chebyshev_u (<n>, <x>)
     第二種Chebyshev函数。

     参考文献: Abramowitz and Stegun, equation 22.5.48, page 779.

 -- 関数: gen_laguerre (<n>, <a>, <x>)
     次数 <n>の一般化Laguerre多項式。

     参考文献: Abramowitz and Stegun, equation 22.5.54, page 780.

 -- 関数: hermite (<n>, <x>)
     Hermite多項式。

     参考文献: Abramowitz and Stegun, equation 22.5.55, page 780.

 -- 関数: intervalp (<e>)
     もし入力が区間なら ‘true’を、 そうでないなら ‘false’を返します。

 -- 関数: 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.

 -- 関数: laguerre (<n>, <x>)
     Laguerre多項式。

     参考文献: Abramowitz and Stegun, equations 22.5.16 and 22.5.54,
     page 780.

 -- 関数: legendre_p (<n>, <x>)
     第一種Legendre多項式。

     参考文献: Abramowitz and Stegun, equations 22.5.50 and 22.5.51,
     page 779.

 -- 関数: legendre_q (<n>, <x>)
     第二種Legendre多項式。

     参考文献: Abramowitz and Stegun, equations 8.5.3 and 8.1.8.

 -- 関数: 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);

 -- 変数: orthopoly_returns_intervals
     デフォルト値: ‘true’

     ‘orthopoly_returns_intervals’が ‘true’の時、 浮動小数点の結果が形式
     ‘interval (<c>, <r>)’ で返されます。 ここで、 <c>は区間の中心で、
     <r>は半径です。 中心は複素数であり得ます; その場合、区間は複素平面
     上の円です。

 -- 関数: 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は
     エラーをシグナルします。

 -- 関数: 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

 -- 変数: 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.

 -- 関数: spherical_bessel_j (<n>, <x>)
     第一種球Bessel函数。

     参考文献: Abramowitz and Stegun, equations 10.1.8, page 437 and
     10.1.15, page 439.

 -- 関数: spherical_bessel_y (<n>, <x>)
     第二種球Bessel函数。

     参考文献: Abramowitz and Stegun, equations 10.1.9, page 437 and
     10.1.15, page 439.

 -- 関数: spherical_hankel1 (<n>, <x>)
     第一種球Hankel函数。

     参考文献: Abramowitz and Stegun, equation 10.1.36, page 439.

 -- 関数: spherical_hankel2 (<n>, <x>)
     第二種球Hankel函数。

     参考文献: Abramowitz and Stegun, equation 10.1.17, page 439.

 -- 関数: spherical_harmonic (<n>, <m>, <x>, <y>)
     球調和函数。

     参考文献: Merzbacher 9.64.

 -- 関数: unit_step (<x>)
     左連続の単位階段函数;なので ‘unit_step (<x>)’は‘<x> <= 0’で0であり
     、 ‘<x> > 0’で1です。

     もし0で値1/2を取る単位階段函数が欲しいなら、 ‘(1 + signum
     (<x>))/2’を使ってください。

 -- 関数: ultraspherical (<n>, <a>, <x>)
     (Gegenbauer多項式としても知られている)超球多項式。

     参考文献: Abramowitz and Stegun, equation 22.5.46, page 779.


File: maxima.info,  Node: plotdf,  Next: romberg,  Prev: orthopoly,  Up: Top

72 plotdf
*********

* Menu:

* Introduction to plotdf::
* Functions and Variables for plotdf::


File: maxima.info,  Node: Introduction to plotdf,  Next: Functions and Variables for plotdf,  Prev: plotdf,  Up: plotdf

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つの自励方程式系に変換します。


File: maxima.info,  Node: Functions and Variables for plotdf,  Prev: Introduction to plotdf,  Up: plotdf

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


File: maxima.info,  Node: romberg,  Next: simplex,  Prev: plotdf,  Up: Top

73 romberg
**********

* Menu:

* Functions and Variables for romberg::


File: maxima.info,  Node: Functions and Variables for romberg,  Prev: Top,  Up: Top

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

 -- オプション変数: rombergabs
     デフォルト値: 0.0

     ‘romberg’の精度は、 グローバル変数‘rombergabs’と‘rombergtol’で決定
     されます。 ‘romberg’は 連続する近似の間の絶対差が‘rombergabs’よりも
     小さい時か、 連続する近似に関する相対差が‘rombergtol’よりも小さい時
     、 成功のうちに終了します。 従って、 ‘rombergabs’が0.0 (デフォルト
     )の時、 相対誤差テストだけが‘romberg’に効果を持ちます。

     ‘rombergit’と‘rombergmin’も参照してください。

 -- オプション変数: rombergit
     デフォルト値: 11

     ‘romberg’は あきらめる前に、せいぜい‘rombergit’回、ステップサイズを
     半分にします; それゆえ、関数評価の最大回数は‘2^rombergit’です。
     ‘romberg’はいつも、少なくとも‘rombergmin’回の繰り返しを行います; こ
     れは、被積分関数が振動的な時、見せかけの終了を防ぐつもりの発見的方
     法です。

     ‘rombergabs’と‘rombergtol’も参照してください。

 -- オプション変数: rombergmin
     デフォルト値: 0

     ‘romberg’はいつも、少なくとも‘rombergmin’回の繰り返しを行います; こ
     れは、被積分関数が振動的な時、見せかけの終了を防ぐつもりの発見的方
     法です。

     ‘rombergit’, ‘rombergabs’, ‘rombergtol’も参照してください。

 -- オプション変数: rombergtol
     デフォルト値: 1e-4

     ‘romberg’の精度は グローバル変数‘rombergabs’と‘rombergtol’によって
     決定されます。 ‘romberg’は 連続する近似の間の絶対差が‘rombergabs’よ
     りも小さい時か、 連続する近似に関する相対差が‘rombergtol’よりも小さ
     い時、 成功のうちに終了します。 従って、 ‘rombergabs’が0.0 (デフォ
     ルト)の時、 相対誤差テストだけが‘romberg’に効果を持ちます。

     ‘rombergit’と‘rombergmin’も参照してください。


File: maxima.info,  Node: simplex,  Next: simplification,  Prev: romberg,  Up: Top

74 simplex
**********

* Menu:

* Introduction to simplex::
* Functions and Variables for simplex::


File: maxima.info,  Node: Introduction to simplex,  Next: Functions and Variables for simplex,  Prev: simplex,  Up: simplex

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


File: maxima.info,  Node: Functions and Variables for simplex,  Prev: Introduction to simplex,  Up: simplex

74.2 Functions and Variables for simplex
========================================

 -- オプション変数: epsilon_lp
     デフォルト値: ‘10^-8’

     ‘linear_program’の数値計算で使われるイプシロン。

     以下も参照してください: ‘linear_program’

 -- 関数: 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’

 -- 関数: maximize_lp (<obj>, <cond>, [<pos>])

     いくつかの線形制約<cond>に従う線形目標関数<obj>を最大化します。 引
     数と戻り値の詳細な記述に関しては、 ‘minimize_lp’を参照してください
     。

     以下も参照してください: ‘minimize_lp’.

 -- 関数: 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’。

 -- オプション変数: nonegative_lp
     デフォルト値: ‘false’

     もし‘nonegative_lp’がtrueなら、 ‘minimize_lp’と‘maximize_lp’の決定
     変数すべては正と仮定されます。

     以下も参照してください: ‘minimize_lp’。


File: maxima.info,  Node: simplification,  Next: solve_rec,  Prev: simplex,  Up: Top

75 simplification
*****************

* Menu:

* Introduction to simplification::
* Package absimp::
* Package facexp::
* Package functs::
* Package ineq::
* Package rducon::
* Package scifac::
* Package sqdnst::


File: maxima.info,  Node: Introduction to simplification,  Next: Package absimp,  Prev: simplification,  Up: simplification

75.1 Introduction to simplification
===================================

ディレクトリ‘maxima/share/simplification’は 整理ルールと整理関数を実装す
るいくつかのスクリプトと整理に関係しないいくつかの関数を含みます。


File: maxima.info,  Node: Package absimp,  Next: Package facexp,  Prev: Introduction to simplification,  Up: simplification

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)


File: maxima.info,  Node: Package facexp,  Next: Package functs,  Prev: Package absimp,  Up: simplification

75.3 Package facexp
===================

‘facexp’パッケージは、 制御された展開によって式を構造化する能力をユーザ
ーに与えるいくつかの関連関数を含みます。 式が物理的意味を持つ変数を含む
とき、この能力は特に役に立ちます。 そんな式の最も簡潔な形式は、それらの
変数に関して式を完全に展開し、 その後係数を因数分解することで得られるこ
とがしばしばあるからです。 この手続きは標準のMaxima関数を使って実行する
ことは難しくありませんが、 追加の微調整も望まれていて、これらの仕上げは
適用するのが更に難しくなることがあります。

   関数‘facsum’とその関連形式は、 この方法で式の構造を制御するための便利
な手段を提供します。 別の関数‘collectterms’は、 この形式に既に整理された
複数の式を 式全体を再整理することなく、足し合わせるのに使うことができま
す。 式が非常に大きいとき、この関数は役に立つかもしれません。

   ‘load ("facexp")’はこのパッケージをロードします。 ‘demo (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’の結果に影響するかもしれません。

 -- グローバル変数: nextlayerfactor
     デフォルト値: ‘false’

     ‘nextlayerfactor’が‘true’の時、 ‘facsum’の再帰コールが 引数の係数の
     因数分解された形式の因子に適用されます。

     ‘false’の時、 ‘facsum’は、 ‘facsum’への再帰コールが起こる時はいつで
     も、全体としてそれぞれの係数に適用されます。

     ‘facsum’の引数リストに アトム‘nextlayerfactor’を入れると、
     ‘nextlayerfactor: true’の効果がありますが、 式の次のレベルだけに関
     してです。

     ‘nextlayerfactor’はいつも ‘true’か‘false’にバインドされているので、
     ‘facsum’の引数リストの中に現れる時はいつでも、 シングルクォートで表
     さなければいけません。

 -- グローバル変数: facsum_combine
     デフォルト値: ‘true’

     引数が多項式の商の時、 ‘facsum_combine’は ‘facsum’が返す最終結果の
     形式を制御します。 もし‘facsum_combine’が‘false’なら、 形式は既に記
     述したような完全に展開された和として返されますが、 もし‘true’なら、
     返される式は、既に記述した形式の多項式の比です。

     有理式の分子と分母両方を‘facsum’したいが、 分母が分子の項ずつに掛け
     られたくない時、 このスイッチの‘true’設定は役に立ちます。

 -- 関数: factorfacsum (<expr>, <arg_1>, ... <arg_n>)
     <expr>の因子に関して引数として <arg_1>, ...  <arg_n>を付けて
     ‘facsum’をコールすることで得られる <expr>の形式を返します。 もし
     <expr>の因子のいずれかがべきに累乗されるなら、 因子と指数と両方がこ
     の方法で処理されます。

 -- 関数: collectterms (<expr>, <arg_1>, ..., <arg_n>)

     もしいくつかの式が‘facsum’もしくは‘factorfacsum’, ‘factenexpand’,
     ‘facexpten’, ‘factorfacexpten’で整理されていて、それらが一緒に加算
     されているなら、 関数‘collectterms’を使ってそれらを結合することが望
     まれる場合があります。 ‘collectterms’は、‘nextlayerfactor’を除いて
     これらの他の関連した関数に渡すことができる引数すべてを 引数として取
     ることができます。 ‘collectterms’の利点は、‘facsum’と似た形式を返す
     ことです。 しかし、既に‘facsum’で処理された加算形式なのでこの処理を
     繰り返す必要はありません。 この能力は加算する式が非常に大きい時特に
     役立ちます。


File: maxima.info,  Node: Package functs,  Next: Package ineq,  Prev: Package facexp,  Up: simplification

75.4 Package functs
===================

 -- 関数: rempart (<expr>, <n>)
     式<expr>からパーツ<n>を取り除きます。

     もし<n>が形式‘[<l>, <m>]’のリストなら、 パーツ<l>から<m>までが取り
     除かれます。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: 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)])

 -- 関数: tracematrix (<M>)
     行列<M>の跡(対角要素の和)を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: rational (z)
     分母を有理化するように、 <z>の分子と分母に分母の複素共役を掛けます
     。 もし与えられたものがそうであれば、正準有理式(CRE)形式を返し、 そ
     うでないなら、一般形式を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: nonzeroandfreeof (<x>, <expr>)
     もし <expr>がゼロでなく、 ‘freeof (<x>, <expr>)’が‘true’を返すなら
     、 ‘true’を返します。 そうでなければ、‘false’を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: linear (<expr>, <x>)
     <expr>が変数<x>に関して線形の式の時、 ‘linear’は‘<a>*<x> + <b>’を返
     します。 ここで、<a>はゼロでなく、<a>と<b>は<x>に依存しません。 そ
     うでなければ、‘linear’は<expr>を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: gcdivide (<p>, <q>)

     ‘takegcd’が‘true’の時、 ‘gcdivide’は多項式<p>と<q>を最大公約多項式
     で割り、 結果の比を返します。

     ‘takegcd’が‘false’の時、 ‘gcdivide’は比‘<p>/<q>’を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

     ‘*note ezgcd::’, ‘*note gcd::’, ‘*note gcdex::’, ‘*note
     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

 -- 関数: arithmetic (<a>, <d>, <n>)
     算術級数‘<a>, <a> + <d>, <a> + 2*<d>, ..., <a> + (<n> - 1)*<d>’の第
     <n>項を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: geometric (<a>, <r>, <n>)
     幾何級数‘<a>, <a>*<r>, <a>*<r>^2, ..., <a>*<r>^(<n> - 1)’の第<n>項
     を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: harmonic (<a>, <b>, <c>, <n>)
     調和級数‘<a>/<b>, <a>/(<b> + <c>), <a>/(<b> + 2*<c>), ..., <a>/(<b>
     + (<n> - 1)*<c>)’の第<n>項を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: arithsum (<a>, <d>, <n>)
     算術級数の1から<n>までの和を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: geosum (<a>, <r>, <n>)
     幾何級数の1から<n>までの和を返します。 もし<n>が無限大(‘inf’)なら、
     <r>の絶対値が1未満でのみ、和は有限です。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: gaussprob (<x>)
     Gaussian確率函数‘%e^(-<x>^2/2) / sqrt(2*%pi)’を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: gd (<x>)
     Gudermannian函数‘2*atan(%e^x)-%pi/2’を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: agd (<x>)
     逆Gudermannian函数‘log (tan (%pi/4 + x/2)))’を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: vers (<x>)
     正矢(せいし)‘1 - cos (x)’を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: covers (<x>)
     余矢(よし)‘1 - sin (<x>)’を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: exsec (<x>)
     外正割(exsecant)‘sec (<x>) - 1’を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: hav (<x>)
     半正矢‘(1 - cos(x))/2’を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: combination (<n>, <r>)
     一度に<r>個を取る<n>個のオブジェクトの組み合わせの数を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。

 -- 関数: permutation (<n>, <r>)
     <n>個のオブジェクトの集合から選択された<r>個のオブジェクトの置換の
     数を返します。

     この関数を使うには、最初に‘load("functs")’を書いてください。


File: maxima.info,  Node: Package ineq,  Next: Package rducon,  Prev: Package functs,  Up: simplification

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")’とか、 規則名を引用符で囲まなければいけません。


File: maxima.info,  Node: Package rducon,  Next: Package scifac,  Prev: Package ineq,  Up: simplification

75.6 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)’はこの関
     数のデモを見せます。


File: maxima.info,  Node: Package scifac,  Next: Package sqdnst,  Prev: Package rducon,  Up: simplification

75.7 Package scifac
===================

 -- 関数: gcfac (<expr>)
     ‘gcfac’は 科学者が式をより簡単にしようとする時に適用するのと同じ発
     見的方法の適用を試みる 因数分解関数です。 ‘gcfac’は単項式タイプの因
     数分解に限られます。 和に関しては、‘gcfac’は以下を行います:

       1. 整数上で素因数分解します。
       2. 項の複雑さに関わらず、生じる項の最大の冪を係数として因数分解し
          ます。
       3. 項の隣同士の対を因数分解する時に、(1)と(2)を使います。
       4. 式がもはや変化しなくなるまで、 これらのテクニックを繰り返し、
          再帰的に適用します。

     対のすべての可能な再配列の中から最も簡潔な対因数分解された結果を産
     むものを見つけることの 組み合わせ的に困難な性質のため、 項目(3)は必
     ずしも、対での因数分解の最善の仕事をしません。

     ‘load ("scifac")’はこの関数をロードします。 ‘demo (scifac)’はこの関
     数のデモを見せます。


File: maxima.info,  Node: Package sqdnst,  Prev: Package scifac,  Up: simplification

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")’はこの関数をロードします。


File: maxima.info,  Node: solve_rec,  Next: stats,  Prev: simplification,  Up: Top

76 solve_rec
************

* Menu:

* Introduction to solve_rec::
* Functions and Variables for solve_rec::


File: maxima.info,  Node: Introduction to solve_rec,  Next: Functions and Variables for solve_rec,  Prev: solve_rec,  Up: solve_rec

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)


File: maxima.info,  Node: Functions and Variables for solve_rec,  Prev: Introduction to solve_rec,  Up: solve_rec

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

 -- オプション変数: simplify_products
     デフォルト値: ‘true’

     もし‘simplify_products’が‘true’なら、 ‘solve_rec’は答えの積をを整理
     しようとします。

     以下も参照してください: ‘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

 -- 関数: 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’.

 -- 関数: 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’.

 -- オプション変数: product_use_gamma
     デフォルト値: ‘true’

     積を整理する時、 もし‘product_use_gamma’が‘true’なら、 ‘solve_rec’は
     式の中にガンマ函数を導入します。

     以下も参照してください: ‘simplify_products’, ‘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


File: maxima.info,  Node: stats,  Next: stirling,  Prev: solve_rec,  Up: Top

77 stats
********

* Menu:

* Introduction to stats::
* Functions and Variables for inference_result::
* Functions and Variables for stats::
* Functions and Variables for special distributions::


File: maxima.info,  Node: Introduction to stats,  Next: Functions and Variables for inference_result,  Prev: Top,  Up: Top

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'>にコンタ
クトしてください。


File: maxima.info,  Node: Functions and Variables for inference_result,  Next: Functions and Variables for stats,  Prev: Introduction to stats,  Up: Top

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’も参照してください。

 -- 関数: inferencep (<obj>)

     <obj>が ‘inference_result’オブジェクトか否かに依存して、 ‘true’か
     ‘false’を返します。

 -- 関数: 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]

 -- 関数: 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’も参照してください。


File: maxima.info,  Node: Functions and Variables for stats,  Next: Functions and Variables for special distributions,  Prev: Functions and Variables for inference_result,  Up: Top

77.3 Functions and Variables for stats
======================================

 -- オプション変数: stats_numer
     デフォルト値: ‘true’

     もし ‘stats_numer’が ‘true’なら、 推定統計的関数は浮動小数点数で結
     果を返します。 もし ‘false’なら、 結果は記号と有理フォーマットで与
     えられます。

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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

 -- 関数: 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]


File: maxima.info,  Node: Functions and Variables for special distributions,  Prev: Functions and Variables for stats,  Up: Top

77.4 Functions and Variables for special distributions
======================================================

 -- 関数: pdf_signed_rank (<x>, <n>)
     符号順位統計の正確確率分布の確率密度関数。 引数 <x>は実数であり、
     <n>は正の整数です。

     ‘test_signed_rank’も参照してください。

 -- 関数: cdf_signed_rank (<x>, <n>)
     符号順位統計の正確確率分布の累積密度関数。 引数 <x>は実数であり、
     <n>は正の整数です。

     ‘test_signed_rank’も参照してください。

 -- 関数: pdf_rank_sum (<x>, <n>, <m>)
     順位和統計の正確確率分布の確率密度関数。 引数 <x>は実数であり、
     <n>と <m>はともに正の整数です。

     ‘test_rank_sum’も参照してください。

 -- 関数: cdf_rank_sum (<x>, <n>, <m>)
     順位和統計の正確確率分布の累積密度関数。 引数 <x>は実数であり、
     <n>と <m>はともに正の整数です。

     ‘test_rank_sum’も参照してください。


File: maxima.info,  Node: stirling,  Next: stringproc,  Prev: stats,  Up: Top

78 stirling
***********

* Menu:

* Functions and Variables for stirling::


File: maxima.info,  Node: Functions and Variables for stirling,  Prev: stirling,  Up: stirling

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")’を書いてください。


File: maxima.info,  Node: stringproc,  Next: to_poly_solve,  Prev: stirling,  Up: Top

79 stringproc
*************

* Menu:

* Introduction to string processing::
* Functions and Variables for input and output::
* Functions and Variables for characters::
* Functions and Variables for strings::


File: maxima.info,  Node: Introduction to string processing,  Next: Functions and Variables for input and output,  Prev: stringproc,  Up: stringproc

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’を返します。


File: maxima.info,  Node: Functions and Variables for input and output,  Next: Functions and Variables for characters,  Prev: Introduction to string processing,  Up: stringproc

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’を返します。

 -- 関数: flength (<stream>)
     <stream>の中の要素の数を返します。

 -- 関数: fposition (<stream>)
 -- 関数: fposition (<stream>, <pos>)
     もし<pos>が使われてないなら、 <stream>の中の現在位置を返します。 も
     し<pos>が使われているなら、 ‘fposition’は<stream>の中の位置を設定し
     ます。 <pos>は正の数でなければいけません。 <stream>の最初の要素は位
     置1にあります。

 -- 関数: freshline ()
 -- 関数: freshline (<stream>)
     もし位置が行の最初でないなら (<stream>に)改行を書きます。
     ‘newline’も参照してください。

 -- 関数: newline ()
 -- 関数: newline (<stream>)
     (<stream>に)改行を書きます。 ‘newline()’の使用の例に関しては、
     ‘sprint’を参照してください。 ‘newline()’が期待通りに動かない いくつ
     かの場合があることに注意してください。

 -- 関数: opena (<file>)
     <file>への出力ストリームを返します。 もし存在しているファイルを開い
     たら、 ‘opena’はファイルの終わりに要素を追加します。

 -- 関数: openr (<file>)
     <file>への入力ストリームを返します。 もし<file>が存在しないなら、生
     成されます。

 -- 関数: openw (<file>)
     <file>への出力ストリームを返します。 もし<file>が存在しないなら、生
     成されます。 もし存在しているファイルを開いたら、‘openw’は <file>を
     破壊的に変更します。

 -- 関数: 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’は出力を含む文字列を返します。

 -- 関数: readline (<stream>)
     <stream>の現在位置から行の終わりまでの文字を含む文字列か、 もしファ
     イルの終わりが来たら<false>を返します。

 -- 関数: 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


File: maxima.info,  Node: Functions and Variables for characters,  Next: Functions and Variables for strings,  Prev: Functions and Variables for input and output,  Up: stringproc

79.3 Functions and Variables for characters
===========================================

 -- 関数: alphacharp (<char>)
     もし<char>がアルファベット文字なら‘true’を返します。

 -- 関数: alphanumericp (<char>)
     もし<char>がアルファベット文字か数字なら‘true’を返します。

 -- 関数: 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

 -- 関数: cequal (<char_1>, <char_2>)
     もし<char_1>と<char_2>が同じなら‘true’を返します。

 -- 関数: cequalignore (<char_1>, <char_2>)
     ‘cequal’と同様ですが、文字の大小を無視します。

 -- 関数: cgreaterp (<char_1>, <char_2>)
     もし<char_1>のASCIIコードが<char_2>のそれより大きいなら‘true’を返し
     ます。

 -- 関数: cgreaterpignore (<char_1>, <char_2>)
     ‘cgreaterp’と同様ですが、文字の大小を無視します。

 -- 関数: charp (<obj>)
     もし<obj>がMaxima-文字なら‘true’を返します。 例えばイントロダクショ
     ンを参照してください。

 -- 関数: cint (<char>)
     <char>のASCIIコードを返します。

 -- 関数: clessp (<char_1>, <char_2>)
     もし<char_1>のASCIIコードが<char_2>のそれより小さいなら‘true’を返し
     ます。

 -- 関数: clesspignore (<char_1>, <char_2>)
     ‘clessp’と同様ですが、文字の大小を無視します。

 -- 関数: 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 { | } ~

 -- 関数: cunlisp (<lisp_char>)
     Lisp文字をMaxima文字に変換します。 (必要としないでしょう。)

 -- 関数: digitcharp (<char>)
     もし<char>が0から9までの数字なら、 ‘true’を返します。

 -- 関数: lcharp (<obj>)
     もし <obj>がLisp文字なら、‘true’を返します。 (必要としないでしょう
     。)

 -- 関数: lowercasep (<char>)
     もし<char>が小文字なら、‘true’を返します。

 -- 変数: newline
     改行文字。

 -- 変数: space
     スペース文字。

 -- 変数: tab
     タブ文字。

 -- 関数: uppercasep (<char>)
     もし<char>が大文字なら、‘true’を返します。


File: maxima.info,  Node: Functions and Variables for strings,  Prev: Functions and Variables for characters,  Up: stringproc

79.4 Functions and Variables for strings
========================================

 -- 関数: stringp (<obj>)
     もし<obj>が文字列なら、‘true’を返します。 例はイントロダクションを
     参照してください。

 -- 関数: charat (<string>, <n>)
     <string>の<n>番目の文字を返します。 <string>の一番目の文字は<n> =
     1で返されます。

          (%i1) charat("Lisp",1);
          (%o1)                           L

 -- 関数: charlist (<string>)
     <string>の文字すべてのリストを返します。

          (%i1) charlist("Lisp");
          (%o1)                     [L, i, s, p]
          (%i2) %[1];
          (%o2)                           L

 -- 関数: 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’も参照してください。

 -- 関数: 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’も参照してください。

 -- 関数: scopy (<string>)
     <string>のコピーを新しい文字列として返します。

 -- 関数: sdowncase (<string>)
 -- 関数: sdowncase (<string>, <start>)
 -- 関数: sdowncase (<string>, <start>, <end>)
     ‘supcase’と同様ですが、大文字が小文字に変換されます。

 -- 関数: sequal (<string_1>, <string_2>)
     もし<string_1>と<string_2>が同じ長さで、同じ文字を含むなら、
     ‘true’を返します。

 -- 関数: sequalignore (<string_1>, <string_2>)
     ‘sequal’と同様ですが、文字の大小を無視します。

 -- 関数: sexplode (<string>)
     ‘sexplode’は関数‘charlist’の別名です。

 -- 関数: 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.

 -- 関数: 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.

 -- 関数: sinvertcase (<string>)
 -- 関数: sinvertcase (<string>, <start>)
 -- 関数: sinvertcase (<string>, <start>, <end>)
     位置<start>から<end>までのそれぞれの文字を逆順にすることを除いて
     <string>を返します。 もし<end>が与えられないなら、 <start>から
     <string>の終わりまでのすべての文字列が置き換えられます。

          (%i1) sinvertcase("sInvertCase");
          (%o1)                      SiNVERTcASE

 -- 関数: slength (<string>)
     <string>の中の文字の数を返します。

 -- 関数: smake (<num>, <char>)
     <num>個の文字<char>を持つ新しい文字列を返します。

          (%i1) smake(3,"w");
          (%o1)                          www

 -- 関数: 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

 -- 関数: 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]

 -- 関数: sposition (<char>, <string>)
     <string>の中で、<char>とマッチする最初の文字の位置を返します。
     <string>の一番目の文字は位置1にあります。 文字の大小を無視した文字
     のマッチに関しては， ‘ssearch’を参照してください。

 -- 関数: 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.

 -- 関数: sremovefirst (<seq>, <string>)
 -- 関数: sremovefirst (<seq>, <string>, <test>)
 -- 関数: sremovefirst (<seq>, <string>, <test>, <start>)
 -- 関数: sremovefirst (<seq>, <string>, <test>, <start>, <end>)
     ‘seq’とマッチする最初の文字列だけが削除されることを除いて、
     ‘sremove’同様です。

 -- 関数: sreverse (<string>)
     <string>の文字すべてが逆順の文字列を返します。

 -- 関数: 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

 -- 関数: 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.'

 -- 関数: 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.

 -- 関数: ssubstfirst (<new>, <old>, <string>)
 -- 関数: ssubstfirst (<new>, <old>, <string>, <test>)
 -- 関数: ssubstfirst (<new>, <old>, <string>, <test>, <start>)
 -- 関数: ssubstfirst (<new>, <old>, <string>, <test>, <start>, <end>)
     <old>とマッチする最初の部分文字列だけを置き換えることを除いて、
     ‘subst’と同様です。

 -- 関数: strim (<seq>,<string>)
     <string>の両端から<seq>に現れるすべての文字を除いた文字列を返します
     。

          (%i1) "/* comment */"$
          (%i2) strim(" /*",%);
          (%o2)                        comment
          (%i3) slength(%);
          (%o3)                           7

 -- 関数: striml (<seq>, <string>)
     <string>の左端だけトリムすることを除いて ‘strim’と同様です。

 -- 関数: strimr (<seq>, <string>)
     <string>の右端だけトリムすることを除いて ‘strim’と同様です。

 -- 関数: 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

 -- 関数: supcase (<string>)
 -- 関数: supcase (<string>, <start>)
 -- 関数: supcase (<string>, <start>, <end>)
     <string>の位置<start>から<end>までの小文字を対応する大文字に置き換
     えた 文字列を返します。 もし<end>が与えられないなら、 <start>から
     <string>の終わりまでのすべての小文字が置き換えられます。

          (%i1) supcase("english",1,2);
          (%o1)                        English

 -- 関数: 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]


File: maxima.info,  Node: to_poly_solve,  Next: unit,  Prev: stringproc,  Up: Top

80 to_poly_solve
****************

* Menu:

* Functions and Variables for to_poly_solve::


File: maxima.info,  Node: Functions and Variables for to_poly_solve,  Prev: to_poly_solve,  Up: to_poly_solve

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関数にマージされるかもしれません。


File: maxima.info,  Node: unit,  Next: zeilberger,  Prev: to_poly_solve,  Up: Top

81 unit
*******

* Menu:

* Introduction to Units::
* Functions and Variables for Units::


File: maxima.info,  Node: Introduction to Units,  Next: Functions and Variables for Units,  Prev: unit,  Up: unit

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 : 次元機能、温度の扱い、略語表示、仲間。単位を含む量の足し算の例
を示す。


File: maxima.info,  Node: Functions and Variables for Units,  Prev: Introduction to Units,  Up: unit

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")’を書いてください。

 -- 関数: 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")’を書いてください。

 -- 関数: 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")’を書いてください。

 -- オプション変数: 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
     不運にも、 このオプションの広い多様性は 最初は少し混乱するものです
     が、 一旦、ユーザーがそれらを使うのに成長すれば、 それらがワーキン
     グ環境上でまさに完全な制御を持つことをユーザーは見いだすに違いあり
     ません。

 -- 関数: 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>です。

 -- 変数: %unitexpand
     デフォルト値: ‘2’

     これは _unit_の初期ロードの最中に ‘metricexpandall’に供給される 値
     です。


File: maxima.info,  Node: zeilberger,  Next: Function and Variable Index,  Prev: unit,  Up: Top

82 zeilberger
*************

* Menu:

* Introduction to zeilberger::
* Functions and Variables for zeilberger::


File: maxima.info,  Node: Introduction to zeilberger,  Next: Functions and Variables for zeilberger,  Prev: zeilberger,  Up: zeilberger

82.1 Introduction to zeilberger
===============================

‘zeilberger’は 超幾何定総和に関するZeilbergerのアルゴリズムと 超幾何不定
総和に関するGosperのアルゴリズムの実装します。

   ‘zeilberger’は Axel Rieseによって開発された「フィルタリング」最適化法
を利用します。

   ‘zeilberger’はFabrizio Carusoによって開発されました。

   ‘load ("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’.


File: maxima.info,  Node: Functions and Variables for zeilberger,  Prev: Introduction to zeilberger,  Up: zeilberger

82.2 Functions and Variables for zeilberger
===========================================

 -- 関数: AntiDifference (F_k, <k>)

     もし存在すれば、F_kの超幾何反差を返します。
     そうでなければ、 ‘AntiDifference’は ‘no_hyp_antidifference’を返しま
     す。

 -- 関数: Gosper (F_k, <k>)
     もし存在すれば、 F_kに対する有理証(rational certificate)、 すなわち
     、 以下のような有理函数を返します。 F_k = R(k+1) F_(k+1) - R(k)
     F_k, そうでなければ、 ‘Gosper’は ‘no_hyp_sol’を返します。

 -- 関数: 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

 -- 関数: 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’は ‘[]’を返します。

 -- 関数: 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’を呼
     び出します。

82.3 General global variables
=============================

 -- グローバル変数: MAX_ORD
     デフォルト値: 5

     ‘MAX_ORD’は ‘Zeilberger’が試みる漸化式の最大次数です。

 -- グローバル変数: simplified_output
     デフォルト値: ‘false’

     ‘simplified_output’が ‘true’の時、 ‘zeilberger’パッケージの関数は 解
     の更なる整理を試みます。

 -- グローバル変数: linear_solver
     デフォルト値: ‘linsolve’

     ‘linear_solver’は Zeilbergerのアルゴリズムで方程式系を解くのに使う
     ソルバを指定します。

 -- グローバル変数: warnings
     デフォルト値: ‘true’

     ‘warnings’が ‘true’の時、 ‘zeilberger’パッケージの関数は 実行中に警
     告メッッセージを印字します。

 -- グローバル変数: Gosper_in_Zeilberger
     デフォルト値: ‘true’

     ‘Gosper_in_Zeilberger’が ‘true’の時、 ‘Zeilberger’関数は
     ‘parGosper’をコールする前に ‘Gosper’をコールします。 そうでないなら
     、 ‘Zeilberger’はすぐに ‘parGosper’に向かいます。

 -- グローバル変数: trivial_solutions
     デフォルト値: ‘true’

     ‘trivial_solutions’が ‘true’の時、 ‘Zeilberger’は 零に等しい証を持
     つ解か、 すべての係数が零に等しい解 を返します。

82.4 Variables related to the modular test
==========================================

 -- グローバル変数: mod_test
     デフォルト値: ‘false’

     ‘mod_test’が ‘true’の時、 ‘parGosper’は 解を持たない系を除くために
     モジュラーテストを実行します。

 -- グローバル変数: modular_linear_solver
     デフォルト値: ‘linsolve’

     ‘modular_linear_solver’は ‘parGosper’でのモジュラーテストが使う線形
     ソルバを指定します。

 -- グローバル変数: ev_point
     デフォルト値: ‘big_primes[10]’

     ‘parGosper’でモジュラーテストを実行する時 ‘ev_point’で変数 <n>が評
     価されます。

 -- グローバル変数: mod_big_prime
     デフォルト値: ‘big_primes[1]’

     ‘mod_big_prime’は ‘parGosper’でモジュラーテストが使う法です。

 -- グローバル変数: mod_threshold
     デフォルト値: 4

     ‘mod_threshold’は ‘parGosper’でのモジュラーテストが試みられる際の最
     大次数です。


File: maxima.info,  Node: Function and Variable Index,  Next: Translator's Comments,  Prev: zeilberger,  Up: Top

83 Indices
**********

[index]
* Menu:

* _:                                     Functions and Variables for Command Line.
                                                             (line   44)
* __:                                    Functions and Variables for Command Line.
                                                             (line    6)
* -:                                     Arithmetic operators.
                                                             (line    7)
* ::                                     Assignment operators.
                                                             (line    6)
* :::                                    Assignment operators.
                                                             (line   85)
* ::=:                                   Assignment operators.
                                                             (line  111)
* :=:                                    Assignment operators.
                                                             (line  183)
* !:                                     Combinatorial Functions.
                                                             (line   50)
* !!:                                    Combinatorial Functions.
                                                             (line    6)
* ?:                                     Functions and Variables for Command Line.
                                                             (line  171)
* ??:                                    Functions and Variables for Command Line.
                                                             (line  183)
* .:                                     Arithmetic operators.
                                                             (line  197)
* ':                                     Functions and Variables for Evaluation.
                                                             (line    6)
* '':                                    Functions and Variables for Evaluation.
                                                             (line   97)
* [:                                     Functions and Variables for Lists.
                                                             (line    6)
* ]:                                     Functions and Variables for Lists.
                                                             (line    7)
* @:                                     Functions and Variables for Structures.
                                                             (line   71)
* *:                                     Arithmetic operators.
                                                             (line    8)
* **:                                    Arithmetic operators.
                                                             (line  158)
* /:                                     Arithmetic operators.
                                                             (line    9)
* #:                                     Operators for Equations.
                                                             (line    6)
* %:                                     Functions and Variables for Command Line.
                                                             (line   87)
* %%:                                    Functions and Variables for Command Line.
                                                             (line  100)
* %and:                                  Functions and Variables for to_poly_solve.
                                                             (line   14)
* %c:                                    Functions and Variables for contrib_ode.
                                                             (line   71)
* %e:                                    Functions and Variables for Constants.
                                                             (line    6)
* %e_to_numlog:                          Root Exponential and Logarithmic Functions.
                                                             (line    6)
* %edispflag:                            Functions and Variables for Display.
                                                             (line    6)
* %emode:                                Root Exponential and Logarithmic Functions.
                                                             (line   14)
* %enumer:                               Root Exponential and Logarithmic Functions.
                                                             (line   30)
* %f:                                    Hypergeometric Functions.
                                                             (line   19)
* %gamma:                                Functions and Variables for Constants.
                                                             (line   19)
* %i:                                    Functions and Variables for Constants.
                                                             (line   10)
* %iargs:                                Functions and Variables for Trigonometric.
                                                             (line   50)
* %if:                                   Functions and Variables for to_poly_solve.
                                                             (line   81)
* %k1:                                   Functions and Variables for contrib_ode.
                                                             (line   75)
* %k2:                                   Functions and Variables for contrib_ode.
                                                             (line   79)
* %m:                                    Hypergeometric Functions.
                                                             (line   12)
* %or:                                   Functions and Variables for to_poly_solve.
                                                             (line  119)
* %phi:                                  Functions and Variables for Constants.
                                                             (line   46)
* %pi:                                   Functions and Variables for Constants.
                                                             (line   99)
* %piargs:                               Functions and Variables for Trigonometric.
                                                             (line    6)
* %rnum_list:                            Functions and Variables for Equations.
                                                             (line    6)
* %s:                                    Bessel Functions.   (line  164)
* %th:                                   Functions and Variables for Command Line.
                                                             (line  144)
* %unitexpand:                           Functions and Variables for Units.
                                                             (line  400)
* %w:                                    Hypergeometric Functions.
                                                             (line   16)
* `:                                     Functions and Variables for ezunits.
                                                             (line    6)
* ``:                                    Functions and Variables for ezunits.
                                                             (line   88)
* ^:                                     Arithmetic operators.
                                                             (line   10)
* ^^:                                    Arithmetic operators.
                                                             (line  180)
* +:                                     Arithmetic operators.
                                                             (line    6)
* <:                                     Relational operators.
                                                             (line    6)
* <=:                                    Relational operators.
                                                             (line    7)
* =:                                     Operators for Equations.
                                                             (line   28)
* >:                                     Relational operators.
                                                             (line    9)
* >=:                                    Relational operators.
                                                             (line    8)
* |:                                     Functions and Variables for itensor.
                                                             (line 1324)
* ~:                                     Functions and Variables for itensor.
                                                             (line 1291)
* abasep:                                Functions and Variables for atensor.
                                                             (line  114)
* abs:                                   Functions for Numbers.
                                                             (line    6)
* absboxchar:                            Functions and Variables for Display.
                                                             (line   25)
* absint:                                Functions and Variables for Fourier series.
                                                             (line   31)
* absint <1>:                            Functions and Variables for Fourier series.
                                                             (line   32)
* absint <2>:                            Functions and Variables for Fourier series.
                                                             (line   33)
* absolute_real_time:                    Functions and Variables for Runtime Environment.
                                                             (line  166)
* acos:                                  Functions and Variables for Trigonometric.
                                                             (line   76)
* acosh:                                 Functions and Variables for Trigonometric.
                                                             (line   79)
* acot:                                  Functions and Variables for Trigonometric.
                                                             (line   82)
* acoth:                                 Functions and Variables for Trigonometric.
                                                             (line   85)
* acsc:                                  Functions and Variables for Trigonometric.
                                                             (line   88)
* acsch:                                 Functions and Variables for Trigonometric.
                                                             (line   91)
* activate:                              Functions and Variables for Facts.
                                                             (line    6)
* activecontexts:                        Functions and Variables for Facts.
                                                             (line   14)
* adapt_depth:                           Plotting Options.   (line   12)
* adapt_depth <1>:                       Functions and Variables for draw.
                                                             (line  192)
* add_edge:                              Functions and Variables for graphs.
                                                             (line 1107)
* add_edges:                             Functions and Variables for graphs.
                                                             (line 1120)
* add_vertex:                            Functions and Variables for graphs.
                                                             (line 1134)
* add_vertices:                          Functions and Variables for graphs.
                                                             (line 1148)
* addcol:                                Functions and Variables for Matrices and Linear Algebra.
                                                             (line    6)
* additive:                              Functions and Variables for Simplification.
                                                             (line    6)
* addmatrices:                           Functions and Variables for linearalgebra.
                                                             (line    6)
* addrow:                                Functions and Variables for Matrices and Linear Algebra.
                                                             (line   11)
* adim:                                  Functions and Variables for atensor.
                                                             (line   61)
* adjacency_matrix:                      Functions and Variables for graphs.
                                                             (line  305)
* adjoin:                                Functions and Variables for Sets.
                                                             (line    6)
* adjoint:                               Functions and Variables for Matrices and Linear Algebra.
                                                             (line   16)
* af:                                    Functions and Variables for atensor.
                                                             (line   84)
* aform:                                 Functions and Variables for atensor.
                                                             (line   67)
* agd:                                   Package functs.     (line  129)
* airy_ai:                               Airy Functions.     (line   15)
* airy_bi:                               Airy Functions.     (line   27)
* airy_dai:                              Airy Functions.     (line   22)
* airy_dbi:                              Airy Functions.     (line   34)
* algebraic:                             Functions and Variables for Polynomials.
                                                             (line    6)
* algepsilon:                            Functions and Variables for Equations.
                                                             (line   29)
* algexact:                              Functions and Variables for Equations.
                                                             (line   34)
* algsys:                                Functions and Variables for Equations.
                                                             (line   50)
* algsys <1>:                            Functions and Variables for Equations.
                                                             (line   51)
* alias:                                 Functions and Variables for Expressions.
                                                             (line    6)
* alias <1>:                             Functions and Variables for Evaluation.
                                                             (line  231)
* aliases:                               Functions and Variables for Expressions.
                                                             (line   12)
* all_dotsimp_denoms:                    Functions and Variables for Affine.
                                                             (line  118)
* allbut:                                Functions and Variables for Expressions.
                                                             (line   20)
* allroots:                              Functions and Variables for Equations.
                                                             (line  145)
* allroots <1>:                          Functions and Variables for Equations.
                                                             (line  146)
* allsym:                                Functions and Variables for itensor.
                                                             (line  494)
* alphabetic:                            Functions and Variables for Miscellaneous Options.
                                                             (line    6)
* alphacharp:                            Functions and Variables for characters.
                                                             (line    6)
* alphanumericp:                         Functions and Variables for characters.
                                                             (line    9)
* amortization:                          Functions and Variables for finance.
                                                             (line   95)
* and:                                   Logical operators.  (line    6)
* annuity_fv:                            Functions and Variables for finance.
                                                             (line   60)
* annuity_pv:                            Functions and Variables for finance.
                                                             (line   49)
* antid:                                 Functions and Variables for Differentiation.
                                                             (line    6)
* antidiff:                              Functions and Variables for Differentiation.
                                                             (line   58)
* AntiDifference:                        Functions and Variables for zeilberger.
                                                             (line    6)
* antisymmetric:                         Functions and Variables for Simplification.
                                                             (line   20)
* append:                                Functions and Variables for Lists.
                                                             (line   40)
* appendfile:                            Functions and Variables for File Input and Output.
                                                             (line    6)
* apply:                                 Functions and Variables for Function Definition.
                                                             (line    6)
* apply1:                                Functions and Variables for Rules and Patterns.
                                                             (line    6)
* apply2:                                Functions and Variables for Rules and Patterns.
                                                             (line   21)
* applyb1:                               Functions and Variables for Rules and Patterns.
                                                             (line   33)
* apropos:                               Functions and Variables for Help.
                                                             (line    6)
* args:                                  Functions and Variables for Expressions.
                                                             (line   50)
* arit_amortization:                     Functions and Variables for finance.
                                                             (line  119)
* arithmetic:                            Package functs.     (line   90)
* arithsum:                              Package functs.     (line  108)
* array:                                 Functions and Variables for Arrays.
                                                             (line    6)
* array <1>:                             Functions and Variables for Arrays.
                                                             (line    7)
* array <2>:                             Functions and Variables for Arrays.
                                                             (line    8)
* arrayapply:                            Functions and Variables for Arrays.
                                                             (line   33)
* arrayinfo:                             Functions and Variables for Arrays.
                                                             (line   40)
* arraymake:                             Functions and Variables for Arrays.
                                                             (line  132)
* arrays:                                Functions and Variables for Arrays.
                                                             (line  174)
* ascii:                                 Functions and Variables for characters.
                                                             (line   12)
* asec:                                  Functions and Variables for Trigonometric.
                                                             (line   94)
* asech:                                 Functions and Variables for Trigonometric.
                                                             (line   97)
* asin:                                  Functions and Variables for Trigonometric.
                                                             (line  100)
* asinh:                                 Functions and Variables for Trigonometric.
                                                             (line  103)
* askexp:                                Functions and Variables for Facts.
                                                             (line   21)
* askinteger:                            Functions and Variables for Facts.
                                                             (line   28)
* askinteger <1>:                        Functions and Variables for Facts.
                                                             (line   29)
* askinteger <2>:                        Functions and Variables for Facts.
                                                             (line   30)
* askinteger <3>:                        Functions and Variables for Facts.
                                                             (line   31)
* asksign:                               Functions and Variables for Facts.
                                                             (line   42)
* assoc:                                 Functions and Variables for Lists.
                                                             (line   47)
* assoc <1>:                             Functions and Variables for Lists.
                                                             (line   48)
* assoc_legendre_p:                      Functions and Variables for orthogonal polynomials.
                                                             (line    6)
* assoc_legendre_q:                      Functions and Variables for orthogonal polynomials.
                                                             (line   12)
* assume:                                Functions and Variables for Facts.
                                                             (line   49)
* assume_external_byte_order:            Functions and Variables for binary input and output.
                                                             (line    6)
* assume_pos:                            Functions and Variables for Facts.
                                                             (line  125)
* assume_pos_pred:                       Functions and Variables for Facts.
                                                             (line  147)
* assumescalar:                          Functions and Variables for Facts.
                                                             (line  102)
* asymbol:                               Functions and Variables for atensor.
                                                             (line   73)
* asympa:                                Introduction to asympa.
                                                             (line    6)
* at:                                    Functions and Variables for Differentiation.
                                                             (line  106)
* at <1>:                                Functions and Variables for Differentiation.
                                                             (line  107)
* atan:                                  Functions and Variables for Trigonometric.
                                                             (line  106)
* atan2:                                 Functions and Variables for Trigonometric.
                                                             (line  109)
* atanh:                                 Functions and Variables for Trigonometric.
                                                             (line  112)
* atensimp:                              Functions and Variables for atensor.
                                                             (line   53)
* atom:                                  Functions and Variables for Expressions.
                                                             (line   63)
* atomgrad:                              Functions and Variables for Differentiation.
                                                             (line  149)
* atrig1:                                Functions and Variables for Trigonometric.
                                                             (line  115)
* atvalue:                               Functions and Variables for Differentiation.
                                                             (line  154)
* atvalue <1>:                           Functions and Variables for Differentiation.
                                                             (line  155)
* augcoefmatrix:                         Functions and Variables for Matrices and Linear Algebra.
                                                             (line   21)
* augmented_lagrangian_method:           Functions and Variables for augmented_lagrangian.
                                                             (line    6)
* augmented_lagrangian_method <1>:       Functions and Variables for augmented_lagrangian.
                                                             (line    7)
* augmented_lagrangian_method <2>:       Functions and Variables for augmented_lagrangian.
                                                             (line    9)
* augmented_lagrangian_method <3>:       Functions and Variables for augmented_lagrangian.
                                                             (line   10)
* av:                                    Functions and Variables for atensor.
                                                             (line   90)
* average_degree:                        Functions and Variables for graphs.
                                                             (line  320)
* axes:                                  Plotting Options.   (line   18)
* axis_3d:                               Functions and Variables for draw.
                                                             (line  199)
* axis_bottom:                           Functions and Variables for draw.
                                                             (line  217)
* axis_left:                             Functions and Variables for draw.
                                                             (line  234)
* axis_right:                            Functions and Variables for draw.
                                                             (line  251)
* axis_top:                              Functions and Variables for draw.
                                                             (line  268)
* azimuth:                               Plotting Options.   (line   27)
* background_color:                      Functions and Variables for draw.
                                                             (line  285)
* backsubst:                             Functions and Variables for Equations.
                                                             (line  213)
* backtrace:                             Functions and Variables for Program Flow.
                                                             (line    6)
* backtrace <1>:                         Functions and Variables for Program Flow.
                                                             (line    7)
* bars:                                  Functions and Variables for draw.
                                                             (line 2309)
* barsplot:                              Functions and Variables for statistical graphs.
                                                             (line    6)
* barsplot_description:                  Functions and Variables for statistical graphs.
                                                             (line    7)
* Base of natural logarithm:             Functions and Variables for Constants.
                                                             (line    7)
* bashindices:                           Sums and Products.  (line    6)
* batch:                                 Functions and Variables for File Input and Output.
                                                             (line   14)
* batch <1>:                             Functions and Variables for File Input and Output.
                                                             (line   15)
* batchload:                             Functions and Variables for File Input and Output.
                                                             (line   65)
* bc2:                                   Functions and Variables for Differential Equations.
                                                             (line    6)
* bdvac:                                 Functions and Variables for ctensor.
                                                             (line  728)
* belln:                                 Functions and Variables for Sets.
                                                             (line   24)
* benefit_cost:                          Functions and Variables for finance.
                                                             (line  226)
* berlefact:                             Functions and Variables for Polynomials.
                                                             (line   12)
* bern:                                  Functions and Variables for Number Theory.
                                                             (line    6)
* bernpoly:                              Functions and Variables for Number Theory.
                                                             (line   24)
* bernstein_approx:                      Functions and Variables for Bernstein.
                                                             (line   73)
* bernstein_expand:                      Functions and Variables for Bernstein.
                                                             (line  102)
* bernstein_explicit:                    Functions and Variables for Bernstein.
                                                             (line   48)
* bernstein_poly:                        Functions and Variables for Bernstein.
                                                             (line    6)
* bessel_i:                              Bessel Functions.   (line   33)
* bessel_j:                              Bessel Functions.   (line    6)
* bessel_k:                              Bessel Functions.   (line   48)
* bessel_y:                              Bessel Functions.   (line   22)
* besselexpand:                          Bessel Functions.   (line  126)
* beta:                                  Gamma and factorial Functions.
                                                             (line  166)
* beta_args_sum_to_integer:              Gamma and factorial Functions.
                                                             (line  642)
* beta_expand:                           Gamma and factorial Functions.
                                                             (line  636)
* beta_incomplete:                       Gamma and factorial Functions.
                                                             (line  272)
* beta_incomplete_generalized:           Gamma and factorial Functions.
                                                             (line  515)
* beta_incomplete_regularized:           Gamma and factorial Functions.
                                                             (line  419)
* bezout:                                Functions and Variables for Polynomials.
                                                             (line   19)
* bf_find_root:                          Functions and Variables for fast Fourier transform.
                                                             (line  289)
* bf_find_root <1>:                      Functions and Variables for fast Fourier transform.
                                                             (line  290)
* bf_fmin_cobyla:                        Functions and Variables for cobyla.
                                                             (line   49)
* bf_fmin_cobyla <1>:                    Functions and Variables for cobyla.
                                                             (line   50)
* bfallroots:                            Functions and Variables for Equations.
                                                             (line  203)
* bfallroots <1>:                        Functions and Variables for Equations.
                                                             (line  204)
* bffac:                                 Gamma and factorial Functions.
                                                             (line   10)
* bfhzeta:                               Functions and Variables for Number Theory.
                                                             (line   33)
* bfloat:                                Functions and Variables for Numbers.
                                                             (line    6)
* bfloatp:                               Functions and Variables for Numbers.
                                                             (line   15)
* bfpsi:                                 Gamma and factorial Functions.
                                                             (line   15)
* bfpsi0:                                Gamma and factorial Functions.
                                                             (line   16)
* bftorat:                               Functions and Variables for Numbers.
                                                             (line   20)
* bftrunc:                               Functions and Variables for Numbers.
                                                             (line   28)
* bfzeta:                                Functions and Variables for Number Theory.
                                                             (line   28)
* biconnected_components:                Functions and Variables for graphs.
                                                             (line  330)
* bimetric:                              Functions and Variables for ctensor.
                                                             (line  749)
* binomial:                              Combinatorial Functions.
                                                             (line   20)
* bipartition:                           Functions and Variables for graphs.
                                                             (line  344)
* block:                                 Functions and Variables for Function Definition.
                                                             (line   64)
* block <1>:                             Functions and Variables for Function Definition.
                                                             (line   65)
* blockmatrixp:                          Functions and Variables for linearalgebra.
                                                             (line   21)
* bode_gain:                             Functions and Variables for bode.
                                                             (line    6)
* bode_phase:                            Functions and Variables for bode.
                                                             (line   51)
* border:                                Functions and Variables for draw.
                                                             (line  293)
* bothcoef:                              Functions and Variables for Polynomials.
                                                             (line   24)
* boundaries_array:                      Functions and Variables for worldmap.
                                                             (line   11)
* box:                                   Functions and Variables for Expressions.
                                                             (line   70)
* box <1>:                               Functions and Variables for Expressions.
                                                             (line   71)
* box <2>:                               Plotting Options.   (line   39)
* boxchar:                               Functions and Variables for Expressions.
                                                             (line  118)
* boxplot:                               Functions and Variables for statistical graphs.
                                                             (line  135)
* boxplot <1>:                           Functions and Variables for statistical graphs.
                                                             (line  136)
* boxplot_description:                   Functions and Variables for statistical graphs.
                                                             (line  137)
* break:                                 Functions and Variables for Function Definition.
                                                             (line  106)
* breakup:                               Functions and Variables for Equations.
                                                             (line  230)
* bug_report:                            Functions and Variables for Bug Detection and Reporting.
                                                             (line   61)
* build_info:                            Functions and Variables for Bug Detection and Reporting.
                                                             (line   72)
* buildq:                                Macros.             (line    6)
* burn:                                  Functions and Variables for Number Theory.
                                                             (line   50)
* cabs:                                  Functions for Complex Numbers.
                                                             (line    6)
* canform:                               Functions and Variables for itensor.
                                                             (line  554)
* canform <1>:                           Functions and Variables for itensor.
                                                             (line  555)
* canten:                                Functions and Variables for itensor.
                                                             (line  478)
* cardinality:                           Functions and Variables for Sets.
                                                             (line   51)
* carg:                                  Functions for Complex Numbers.
                                                             (line    9)
* cartan:                                Functions and Variables for Differentiation.
                                                             (line  209)
* cartesian_product:                     Functions and Variables for Sets.
                                                             (line   69)
* catch:                                 Functions and Variables for Function Definition.
                                                             (line  112)
* cauchy_matrix:                         Functions and Variables for Matrices and Linear Algebra.
                                                             (line   34)
* cauchy_matrix <1>:                     Functions and Variables for Matrices and Linear Algebra.
                                                             (line   36)
* cauchysum:                             Functions and Variables for Series.
                                                             (line    6)
* cbffac:                                Gamma and factorial Functions.
                                                             (line   24)
* cbrange:                               Functions and Variables for draw.
                                                             (line  312)
* cbtics:                                Functions and Variables for draw.
                                                             (line  340)
* cdf_bernoulli:                         Functions and Variables for discrete distributions.
                                                             (line  210)
* cdf_beta:                              Functions and Variables for continuous distributions.
                                                             (line  766)
* cdf_binomial:                          Functions and Variables for discrete distributions.
                                                             (line   91)
* cdf_cauchy:                            Functions and Variables for continuous distributions.
                                                             (line 1213)
* cdf_chi2:                              Functions and Variables for continuous distributions.
                                                             (line  257)
* cdf_continuous_uniform:                Functions and Variables for continuous distributions.
                                                             (line  820)
* cdf_discrete_uniform:                  Functions and Variables for discrete distributions.
                                                             (line  350)
* cdf_exp:                               Functions and Variables for continuous distributions.
                                                             (line  512)
* cdf_f:                                 Functions and Variables for continuous distributions.
                                                             (line  431)
* cdf_gamma:                             Functions and Variables for continuous distributions.
                                                             (line  707)
* cdf_general_finite_discrete:           Functions and Variables for discrete distributions.
                                                             (line   22)
* cdf_geometric:                         Functions and Variables for discrete distributions.
                                                             (line  305)
* cdf_gumbel:                            Functions and Variables for continuous distributions.
                                                             (line 1237)
* cdf_hypergeometric:                    Functions and Variables for discrete distributions.
                                                             (line  403)
* cdf_laplace:                           Functions and Variables for continuous distributions.
                                                             (line 1168)
* cdf_logistic:                          Functions and Variables for continuous distributions.
                                                             (line  871)
* cdf_lognormal:                         Functions and Variables for continuous distributions.
                                                             (line  644)
* cdf_negative_binomial:                 Functions and Variables for discrete distributions.
                                                             (line  458)
* cdf_noncentral_chi2:                   Functions and Variables for continuous distributions.
                                                             (line  382)
* cdf_noncentral_student_t:              Functions and Variables for continuous distributions.
                                                             (line  162)
* cdf_normal:                            Functions and Variables for continuous distributions.
                                                             (line   10)
* cdf_pareto:                            Functions and Variables for continuous distributions.
                                                             (line  916)
* cdf_poisson:                           Functions and Variables for discrete distributions.
                                                             (line  149)
* cdf_rank_sum:                          Functions and Variables for special distributions.
                                                             (line   24)
* cdf_rayleigh:                          Functions and Variables for continuous distributions.
                                                             (line 1017)
* cdf_signed_rank:                       Functions and Variables for special distributions.
                                                             (line   12)
* cdf_student_t:                         Functions and Variables for continuous distributions.
                                                             (line   76)
* cdf_weibull:                           Functions and Variables for continuous distributions.
                                                             (line  962)
* cdisplay:                              Functions and Variables for ctensor.
                                                             (line  773)
* ceiling:                               Functions for Numbers.
                                                             (line   14)
* central_moment:                        Functions and Variables for descriptive statistics.
                                                             (line  133)
* central_moment <1>:                    Functions and Variables for descriptive statistics.
                                                             (line  134)
* cequal:                                Functions and Variables for characters.
                                                             (line   21)
* cequalignore:                          Functions and Variables for characters.
                                                             (line   24)
* cf:                                    Functions and Variables for Number Theory.
                                                             (line   71)
* cfdisrep:                              Functions and Variables for Number Theory.
                                                             (line  131)
* cfexpand:                              Functions and Variables for Number Theory.
                                                             (line  147)
* cflength:                              Functions and Variables for Number Theory.
                                                             (line  163)
* cframe_flag:                           Functions and Variables for ctensor.
                                                             (line 1014)
* cgeodesic:                             Functions and Variables for ctensor.
                                                             (line  722)
* cgreaterp:                             Functions and Variables for characters.
                                                             (line   27)
* cgreaterpignore:                       Functions and Variables for characters.
                                                             (line   31)
* changename:                            Functions and Variables for itensor.
                                                             (line   22)
* changevar:                             Functions and Variables for Integration.
                                                             (line    6)
* chaosgame:                             Functions and Variables for dynamics.
                                                             (line    6)
* charat:                                Functions and Variables for strings.
                                                             (line   10)
* charfun:                               Functions and Variables for Predicates.
                                                             (line    6)
* charfun2:                              Functions and Variables for interpol.
                                                             (line  101)
* charlist:                              Functions and Variables for strings.
                                                             (line   17)
* charp:                                 Functions and Variables for characters.
                                                             (line   34)
* charpoly:                              Functions and Variables for Matrices and Linear Algebra.
                                                             (line   65)
* chebyshev_t:                           Functions and Variables for orthogonal polynomials.
                                                             (line   17)
* chebyshev_u:                           Functions and Variables for orthogonal polynomials.
                                                             (line   22)
* check_overlaps:                        Functions and Variables for Affine.
                                                             (line   79)
* checkdiv:                              Functions and Variables for ctensor.
                                                             (line  714)
* cholesky:                              Functions and Variables for linearalgebra.
                                                             (line   68)
* cholesky <1>:                          Functions and Variables for linearalgebra.
                                                             (line   69)
* christof:                              Functions and Variables for ctensor.
                                                             (line  172)
* chromatic_index:                       Functions and Variables for graphs.
                                                             (line  356)
* chromatic_number:                      Functions and Variables for graphs.
                                                             (line  365)
* cint:                                  Functions and Variables for characters.
                                                             (line   38)
* circulant_graph:                       Functions and Variables for graphs.
                                                             (line   67)
* clear_edge_weight:                     Functions and Variables for graphs.
                                                             (line  375)
* clear_rules:                           Functions and Variables for Rules and Patterns.
                                                             (line  803)
* clear_vertex_label:                    Functions and Variables for graphs.
                                                             (line  388)
* clebsch_graph:                         Functions and Variables for graphs.
                                                             (line   87)
* clessp:                                Functions and Variables for characters.
                                                             (line   41)
* clesspignore:                          Functions and Variables for characters.
                                                             (line   45)
* close:                                 Functions and Variables for input and output.
                                                             (line   25)
* closefile:                             Functions and Variables for File Input and Output.
                                                             (line   80)
* cmetric:                               Functions and Variables for ctensor.
                                                             (line   14)
* cmetric <1>:                           Functions and Variables for ctensor.
                                                             (line   15)
* cnonmet_flag:                          Functions and Variables for ctensor.
                                                             (line 1028)
* coeff:                                 Functions and Variables for Polynomials.
                                                             (line   39)
* coeff <1>:                             Functions and Variables for Polynomials.
                                                             (line   40)
* coefmatrix:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line  101)
* cograd:                                Functions and Variables for ctensor.
                                                             (line  663)
* col:                                   Functions and Variables for Matrices and Linear Algebra.
                                                             (line  111)
* collapse:                              Functions and Variables for Expressions.
                                                             (line  127)
* collectterms:                          Package facexp.     (line   87)
* color:                                 Plotting Options.   (line   46)
* color <1>:                             Functions and Variables for draw.
                                                             (line  363)
* colorbox:                              Plotting Options.   (line   61)
* colorbox <1>:                          Functions and Variables for draw.
                                                             (line  411)
* columnop:                              Functions and Variables for linearalgebra.
                                                             (line   25)
* columns:                               Functions and Variables for draw.
                                                             (line  432)
* columnspace:                           Functions and Variables for linearalgebra.
                                                             (line   36)
* columnswap:                            Functions and Variables for linearalgebra.
                                                             (line   31)
* columnvector:                          Functions and Variables for Matrices and Linear Algebra.
                                                             (line  115)
* combination:                           Package functs.     (line  154)
* combine:                               Functions and Variables for Simplification.
                                                             (line   26)
* commutative:                           Functions and Variables for Simplification.
                                                             (line   30)
* comp2pui:                              Functions and Variables for Symmetries.
                                                             (line    9)
* compare:                               Functions and Variables for Predicates.
                                                             (line   22)
* compfile:                              Functions and Variables for Function Definition.
                                                             (line  135)
* compfile <1>:                          Functions and Variables for Function Definition.
                                                             (line  136)
* compfile <2>:                          Functions and Variables for Function Definition.
                                                             (line  137)
* compile:                               Functions and Variables for Function Definition.
                                                             (line  152)
* compile <1>:                           Functions and Variables for Function Definition.
                                                             (line  153)
* compile <2>:                           Functions and Variables for Function Definition.
                                                             (line  154)
* compile_file:                          Functions and Variables for Function Definition.
                                                             (line 1234)
* compile_file <1>:                      Functions and Variables for Function Definition.
                                                             (line 1235)
* compile_file <2>:                      Functions and Variables for Function Definition.
                                                             (line 1236)
* complement_graph:                      Functions and Variables for graphs.
                                                             (line   90)
* complete_bipartite_graph:              Functions and Variables for graphs.
                                                             (line   93)
* complete_graph:                        Functions and Variables for graphs.
                                                             (line   96)
* Complex infinity:                      Functions and Variables for Constants.
                                                             (line   39)
* complex_number_p:                      Functions and Variables for to_poly_solve.
                                                             (line  185)
* components:                            Functions and Variables for itensor.
                                                             (line  183)
* compose_functions:                     Functions and Variables for to_poly_solve.
                                                             (line  206)
* concan:                                Functions and Variables for itensor.
                                                             (line  488)
* concat:                                Functions and Variables for Strings.
                                                             (line    6)
* conditional evaluation:                Functions and Variables for to_poly_solve.
                                                             (line   82)
* conjugate:                             Functions for Complex Numbers.
                                                             (line   37)
* conmetderiv:                           Functions and Variables for itensor.
                                                             (line  728)
* connect_vertices:                      Functions and Variables for graphs.
                                                             (line 1151)
* connected_components:                  Functions and Variables for graphs.
                                                             (line  401)
* cons:                                  Functions and Variables for Lists.
                                                             (line   58)
* constant:                              Functions and Variables for Predicates.
                                                             (line   52)
* constantp:                             Functions and Variables for Predicates.
                                                             (line   57)
* constituent:                           Functions and Variables for characters.
                                                             (line   48)
* constvalue:                            Functions and Variables for ezunits.
                                                             (line  246)
* cont2part:                             Functions and Variables for Symmetries.
                                                             (line  196)
* content:                               Functions and Variables for Polynomials.
                                                             (line  121)
* context:                               Functions and Variables for Facts.
                                                             (line  214)
* contexts:                              Functions and Variables for Facts.
                                                             (line  231)
* continuous_freq:                       Functions and Variables for data manipulation.
                                                             (line    6)
* continuous_freq <1>:                   Functions and Variables for data manipulation.
                                                             (line    7)
* contortion:                            Functions and Variables for ctensor.
                                                             (line  602)
* contour:                               Functions and Variables for draw.
                                                             (line  450)
* contour_levels:                        Functions and Variables for draw.
                                                             (line  478)
* contour_plot:                          Functions and Variables for Plotting.
                                                             (line    6)
* contract:                              Functions and Variables for itensor.
                                                             (line  168)
* contract <1>:                          Functions and Variables for Symmetries.
                                                             (line  207)
* contract_edge:                         Functions and Variables for graphs.
                                                             (line 1169)
* Contraction with a vector:             Functions and Variables for itensor.
                                                             (line 1325)
* contragrad:                            Functions and Variables for ctensor.
                                                             (line  667)
* contrib_ode:                           Functions and Variables for contrib_ode.
                                                             (line    6)
* convert:                               Functions and Variables for Units.
                                                             (line  137)
* coord:                                 Functions and Variables for itensor.
                                                             (line  708)
* copy:                                  Functions and Variables for linearalgebra.
                                                             (line   42)
* copy_graph:                            Functions and Variables for graphs.
                                                             (line   64)
* copylist:                              Functions and Variables for Lists.
                                                             (line   64)
* copymatrix:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line  141)
* cor:                                   Functions and Variables for descriptive statistics.
                                                             (line  564)
* cor <1>:                               Functions and Variables for descriptive statistics.
                                                             (line  565)
* cos:                                   Functions and Variables for Trigonometric.
                                                             (line  122)
* cosh:                                  Functions and Variables for Trigonometric.
                                                             (line  125)
* cosnpiflag:                            Functions and Variables for Fourier series.
                                                             (line   62)
* cot:                                   Functions and Variables for Trigonometric.
                                                             (line  128)
* coth:                                  Functions and Variables for Trigonometric.
                                                             (line  131)
* cov:                                   Functions and Variables for descriptive statistics.
                                                             (line  468)
* cov1:                                  Functions and Variables for descriptive statistics.
                                                             (line  497)
* covdiff:                               Functions and Variables for itensor.
                                                             (line  863)
* covect:                                Functions and Variables for Matrices and Linear Algebra.
                                                             (line  116)
* covers:                                Package functs.     (line  139)
* create_graph:                          Functions and Variables for graphs.
                                                             (line    9)
* create_graph <1>:                      Functions and Variables for graphs.
                                                             (line   10)
* create_graph <2>:                      Functions and Variables for graphs.
                                                             (line   11)
* create_list:                           Functions and Variables for Lists.
                                                             (line   68)
* csc:                                   Functions and Variables for Trigonometric.
                                                             (line  134)
* csch:                                  Functions and Variables for Trigonometric.
                                                             (line  137)
* csetup:                                Functions and Variables for ctensor.
                                                             (line    9)
* cspline:                               Functions and Variables for interpol.
                                                             (line  169)
* cspline <1>:                           Functions and Variables for interpol.
                                                             (line  170)
* ct_coords:                             Functions and Variables for ctensor.
                                                             (line 1177)
* ct_coordsys:                           Functions and Variables for ctensor.
                                                             (line   30)
* ct_coordsys <1>:                       Functions and Variables for ctensor.
                                                             (line   31)
* ctaylor:                               Functions and Variables for ctensor.
                                                             (line  288)
* ctaypov:                               Functions and Variables for ctensor.
                                                             (line 1045)
* ctaypt:                                Functions and Variables for ctensor.
                                                             (line 1050)
* ctayswitch:                            Functions and Variables for ctensor.
                                                             (line 1034)
* ctayvar:                               Functions and Variables for ctensor.
                                                             (line 1040)
* ctorsion_flag:                         Functions and Variables for ctensor.
                                                             (line 1022)
* ctransform:                            Functions and Variables for ctensor.
                                                             (line  614)
* ctranspose:                            Functions and Variables for linearalgebra.
                                                             (line   76)
* ctrgsimp:                              Functions and Variables for ctensor.
                                                             (line 1009)
* cube_graph:                            Functions and Variables for graphs.
                                                             (line  108)
* cuboctahedron_graph:                   Functions and Variables for graphs.
                                                             (line  105)
* cunlisp:                               Functions and Variables for characters.
                                                             (line   60)
* Current input expression:              Functions and Variables for Command Line.
                                                             (line    7)
* current_let_rule_package:              Functions and Variables for Rules and Patterns.
                                                             (line   48)
* cv:                                    Functions and Variables for descriptive statistics.
                                                             (line  157)
* cv <1>:                                Functions and Variables for descriptive statistics.
                                                             (line  158)
* cycle_digraph:                         Functions and Variables for graphs.
                                                             (line   99)
* cycle_graph:                           Functions and Variables for graphs.
                                                             (line  102)
* cylindrical:                           Functions and Variables for draw.
                                                             (line 2337)
* data_file_name:                        Functions and Variables for draw.
                                                             (line  529)
* days360:                               Functions and Variables for finance.
                                                             (line    6)
* dblint:                                Functions and Variables for Integration.
                                                             (line   58)
* deactivate:                            Functions and Variables for Facts.
                                                             (line  259)
* debugmode:                             Functions and Variables for Debugging.
                                                             (line    6)
* declare:                               Functions and Variables for Properties.
                                                             (line    6)
* declare_constvalue:                    Functions and Variables for ezunits.
                                                             (line  247)
* declare_dimensions:                    Functions and Variables for ezunits.
                                                             (line  474)
* declare_fundamental_dimensions:        Functions and Variables for ezunits.
                                                             (line  504)
* declare_fundamental_units:             Functions and Variables for ezunits.
                                                             (line  535)
* declare_qty:                           Functions and Variables for ezunits.
                                                             (line  351)
* declare_translated:                    Functions and Variables for Function Definition.
                                                             (line 1261)
* declare_unit_conversion:               Functions and Variables for ezunits.
                                                             (line  434)
* declare_units:                         Functions and Variables for ezunits.
                                                             (line  291)
* declare_weights:                       Functions and Variables for Affine.
                                                             (line   50)
* decsym:                                Functions and Variables for itensor.
                                                             (line  502)
* default_let_rule_package:              Functions and Variables for Rules and Patterns.
                                                             (line   60)
* defcon:                                Functions and Variables for itensor.
                                                             (line  147)
* defcon <1>:                            Functions and Variables for itensor.
                                                             (line  148)
* define:                                Functions and Variables for Function Definition.
                                                             (line  166)
* define <1>:                            Functions and Variables for Function Definition.
                                                             (line  167)
* define <2>:                            Functions and Variables for Function Definition.
                                                             (line  168)
* define <3>:                            Functions and Variables for Function Definition.
                                                             (line  169)
* define <4>:                            Functions and Variables for Function Definition.
                                                             (line  170)
* define_variable:                       Functions and Variables for Function Definition.
                                                             (line  251)
* defint:                                Functions and Variables for Integration.
                                                             (line   99)
* defmatch:                              Functions and Variables for Rules and Patterns.
                                                             (line   67)
* defmatch <1>:                          Functions and Variables for Rules and Patterns.
                                                             (line   68)
* defrule:                               Functions and Variables for Rules and Patterns.
                                                             (line  162)
* defstruct:                             Functions and Variables for Structures.
                                                             (line   11)
* defstruct <1>:                         Functions and Variables for Structures.
                                                             (line   12)
* deftaylor:                             Functions and Variables for Series.
                                                             (line   37)
* degree_sequence:                       Functions and Variables for graphs.
                                                             (line  436)
* del:                                   Functions and Variables for Differentiation.
                                                             (line  220)
* delay:                                 Functions and Variables for draw.
                                                             (line  540)
* delete:                                Functions and Variables for Lists.
                                                             (line   95)
* delete <1>:                            Functions and Variables for Lists.
                                                             (line   96)
* deleten:                               Functions and Variables for ctensor.
                                                             (line  987)
* delta:                                 Functions and Variables for Differentiation.
                                                             (line  239)
* demo:                                  Functions and Variables for Help.
                                                             (line   31)
* demoivre:                              Functions and Variables for Simplification.
                                                             (line   36)
* demoivre <1>:                          Functions and Variables for Simplification.
                                                             (line   37)
* denom:                                 Functions and Variables for Polynomials.
                                                             (line  132)
* dependencies:                          Functions and Variables for Differentiation.
                                                             (line  254)
* depends:                               Functions and Variables for Differentiation.
                                                             (line  264)
* derivabbrev:                           Functions and Variables for Differentiation.
                                                             (line  318)
* derivdegree:                           Functions and Variables for Differentiation.
                                                             (line  325)
* derivlist:                             Functions and Variables for Differentiation.
                                                             (line  341)
* derivsubst:                            Functions and Variables for Differentiation.
                                                             (line  345)
* describe:                              Functions and Variables for Help.
                                                             (line   68)
* describe <1>:                          Functions and Variables for Help.
                                                             (line   69)
* describe <2>:                          Functions and Variables for Help.
                                                             (line   70)
* desolve:                               Functions and Variables for Differential Equations.
                                                             (line   15)
* desolve <1>:                           Functions and Variables for Differential Equations.
                                                             (line   16)
* determinant:                           Functions and Variables for Matrices and Linear Algebra.
                                                             (line  151)
* detout:                                Functions and Variables for Matrices and Linear Algebra.
                                                             (line  160)
* dfloat:                                Functions and Variables for to_poly_solve.
                                                             (line  256)
* dgauss_a:                              Functions and Variables for contrib_ode.
                                                             (line   98)
* dgauss_b:                              Functions and Variables for contrib_ode.
                                                             (line  101)
* dgeev:                                 Functions and Variables for lapack.
                                                             (line    6)
* dgeev <1>:                             Functions and Variables for lapack.
                                                             (line    7)
* dgemm:                                 Functions and Variables for lapack.
                                                             (line  279)
* dgemm <1>:                             Functions and Variables for lapack.
                                                             (line  280)
* dgeqrf:                                Functions and Variables for lapack.
                                                             (line   68)
* dgesv:                                 Functions and Variables for lapack.
                                                             (line   97)
* dgesvd:                                Functions and Variables for lapack.
                                                             (line  166)
* dgesvd <1>:                            Functions and Variables for lapack.
                                                             (line  167)
* diag:                                  Functions and Variables for diag.
                                                             (line    6)
* diag_matrix:                           Functions and Variables for linearalgebra.
                                                             (line   81)
* diagmatrix:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line  187)
* diagmatrixp:                           Functions and Variables for ctensor.
                                                             (line  759)
* diagmetric:                            Functions and Variables for ctensor.
                                                             (line 1000)
* diameter:                              Functions and Variables for graphs.
                                                             (line  410)
* diff:                                  Functions and Variables for Differentiation.
                                                             (line  419)
* diff <1>:                              Functions and Variables for Differentiation.
                                                             (line  351)
* diff <2>:                              Functions and Variables for Differentiation.
                                                             (line  352)
* diff <3>:                              Functions and Variables for Differentiation.
                                                             (line  353)
* diff <4>:                              Functions and Variables for Differentiation.
                                                             (line  354)
* diff <5>:                              Functions and Variables for itensor.
                                                             (line  573)
* digitcharp:                            Functions and Variables for characters.
                                                             (line   63)
* dim:                                   Functions and Variables for ctensor.
                                                             (line  993)
* dimacs_export:                         Functions and Variables for graphs.
                                                             (line 1219)
* dimacs_export <1>:                     Functions and Variables for graphs.
                                                             (line 1220)
* dimacs_import:                         Functions and Variables for graphs.
                                                             (line 1225)
* dimension:                             Functions and Variables for Equations.
                                                             (line  301)
* dimension <1>:                         Functions and Variables for Equations.
                                                             (line  302)
* dimensionless:                         Functions and Variables for ezunits.
                                                             (line  652)
* dimensions:                            Functions and Variables for draw.
                                                             (line  567)
* dimensions <1>:                        Functions and Variables for ezunits.
                                                             (line  574)
* dimensions_as_list:                    Functions and Variables for ezunits.
                                                             (line  575)
* direct:                                Functions and Variables for Symmetries.
                                                             (line  255)
* discrete_freq:                         Functions and Variables for data manipulation.
                                                             (line   45)
* disjoin:                               Functions and Variables for Sets.
                                                             (line   88)
* disjointp:                             Functions and Variables for Sets.
                                                             (line  107)
* disolate:                              Functions and Variables for Expressions.
                                                             (line  138)
* disp:                                  Functions and Variables for Display.
                                                             (line   37)
* dispcon:                               Functions and Variables for itensor.
                                                             (line    9)
* dispcon <1>:                           Functions and Variables for itensor.
                                                             (line   10)
* dispflag:                              Functions and Variables for Equations.
                                                             (line  308)
* dispform:                              Functions and Variables for Expressions.
                                                             (line  147)
* dispform <1>:                          Functions and Variables for Expressions.
                                                             (line  148)
* dispfun:                               Functions and Variables for Function Definition.
                                                             (line  343)
* dispfun <1>:                           Functions and Variables for Function Definition.
                                                             (line  344)
* dispJordan:                            Functions and Variables for diag.
                                                             (line   94)
* display:                               Functions and Variables for Display.
                                                             (line   59)
* display_format_internal:               Functions and Variables for Display.
                                                             (line  101)
* display2d:                             Functions and Variables for Display.
                                                             (line   84)
* disprule:                              Functions and Variables for Rules and Patterns.
                                                             (line  175)
* disprule <1>:                          Functions and Variables for Rules and Patterns.
                                                             (line  176)
* dispterms:                             Functions and Variables for Display.
                                                             (line  123)
* distrib:                               Functions and Variables for Simplification.
                                                             (line   52)
* distribute_over:                       Functions and Variables for Simplification.
                                                             (line   73)
* divide:                                Functions and Variables for Polynomials.
                                                             (line  136)
* divisors:                              Functions and Variables for Sets.
                                                             (line  121)
* divsum:                                Functions and Variables for Number Theory.
                                                             (line  179)
* divsum <1>:                            Functions and Variables for Number Theory.
                                                             (line  180)
* dkummer_m:                             Functions and Variables for contrib_ode.
                                                             (line  122)
* dkummer_u:                             Functions and Variables for contrib_ode.
                                                             (line  125)
* dlange:                                Functions and Variables for lapack.
                                                             (line  260)
* do:                                    Functions and Variables for Program Flow.
                                                             (line   53)
* doallmxops:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line  200)
* dodecahedron_graph:                    Functions and Variables for graphs.
                                                             (line  111)
* domain:                                Functions and Variables for Simplification.
                                                             (line  120)
* domxexpt:                              Functions and Variables for Matrices and Linear Algebra.
                                                             (line  207)
* domxmxops:                             Functions and Variables for Matrices and Linear Algebra.
                                                             (line  239)
* domxnctimes:                           Functions and Variables for Matrices and Linear Algebra.
                                                             (line  246)
* dontfactor:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line  251)
* doscmxops:                             Functions and Variables for Matrices and Linear Algebra.
                                                             (line  260)
* doscmxplus:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line  265)
* dot0nscsimp:                           Functions and Variables for Matrices and Linear Algebra.
                                                             (line  271)
* dot0simp:                              Functions and Variables for Matrices and Linear Algebra.
                                                             (line  277)
* dot1simp:                              Functions and Variables for Matrices and Linear Algebra.
                                                             (line  283)
* dotassoc:                              Functions and Variables for Matrices and Linear Algebra.
                                                             (line  289)
* dotconstrules:                         Functions and Variables for Matrices and Linear Algebra.
                                                             (line  294)
* dotdistrib:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line  302)
* dotexptsimp:                           Functions and Variables for Matrices and Linear Algebra.
                                                             (line  308)
* dotident:                              Functions and Variables for Matrices and Linear Algebra.
                                                             (line  313)
* dotproduct:                            Functions and Variables for linearalgebra.
                                                             (line  101)
* dotscrules:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line  318)
* dotsimp:                               Functions and Variables for Affine.
                                                             (line   62)
* dpart:                                 Functions and Variables for Expressions.
                                                             (line  200)
* draw:                                  Functions and Variables for draw.
                                                             (line   53)
* draw_file:                             Functions and Variables for draw.
                                                             (line  120)
* draw_graph:                            Functions and Variables for graphs.
                                                             (line 1266)
* draw_graph <1>:                        Functions and Variables for graphs.
                                                             (line 1267)
* draw_graph_program:                    Functions and Variables for graphs.
                                                             (line 1369)
* draw2d:                                Functions and Variables for draw.
                                                             (line  100)
* draw3d:                                Functions and Variables for draw.
                                                             (line  110)
* drawdf:                                Functions and Variables for drawdf.
                                                             (line    9)
* drawdf <1>:                            Functions and Variables for drawdf.
                                                             (line   10)
* drawdf <2>:                            Functions and Variables for drawdf.
                                                             (line   11)
* drawdf <3>:                            Functions and Variables for drawdf.
                                                             (line   13)
* drawdf <4>:                            Functions and Variables for drawdf.
                                                             (line   14)
* drawdf <5>:                            Functions and Variables for drawdf.
                                                             (line   15)
* dscalar:                               Functions and Variables for Differentiation.
                                                             (line  424)
* dscalar <1>:                           Functions and Variables for ctensor.
                                                             (line  694)
* e:                                     Functions and Variables for Constants.
                                                             (line    7)
* echelon:                               Functions and Variables for Matrices and Linear Algebra.
                                                             (line  324)
* edge_color:                            Functions and Variables for graphs.
                                                             (line 1435)
* edge_coloring:                         Functions and Variables for graphs.
                                                             (line 1462)
* edge_coloring <1>:                     Functions and Variables for graphs.
                                                             (line  418)
* edge_connectivity:                     Functions and Variables for graphs.
                                                             (line  444)
* edge_partition:                        Functions and Variables for graphs.
                                                             (line 1458)
* edge_type:                             Functions and Variables for graphs.
                                                             (line 1441)
* edge_width:                            Functions and Variables for graphs.
                                                             (line 1438)
* edges:                                 Functions and Variables for graphs.
                                                             (line  449)
* eigens_by_jacobi:                      Functions and Variables for linearalgebra.
                                                             (line  107)
* eigens_by_jacobi <1>:                  Functions and Variables for linearalgebra.
                                                             (line  108)
* eigenvalues:                           Functions and Variables for Matrices and Linear Algebra.
                                                             (line  353)
* eigenvectors:                          Functions and Variables for Matrices and Linear Algebra.
                                                             (line  379)
* eighth:                                Functions and Variables for Lists.
                                                             (line  160)
* einstein:                              Functions and Variables for ctensor.
                                                             (line  200)
* eivals:                                Functions and Variables for Matrices and Linear Algebra.
                                                             (line  354)
* eivects:                               Functions and Variables for Matrices and Linear Algebra.
                                                             (line  380)
* elapsed_real_time:                     Functions and Variables for Runtime Environment.
                                                             (line  180)
* elapsed_run_time:                      Functions and Variables for Runtime Environment.
                                                             (line  195)
* ele2comp:                              Functions and Variables for Symmetries.
                                                             (line   26)
* ele2polynome:                          Functions and Variables for Symmetries.
                                                             (line  467)
* ele2pui:                               Functions and Variables for Symmetries.
                                                             (line   20)
* elem:                                  Functions and Variables for Symmetries.
                                                             (line   32)
* elementp:                              Functions and Variables for Sets.
                                                             (line  161)
* elevation:                             Plotting Options.   (line   70)
* elevation_grid:                        Functions and Variables for draw.
                                                             (line 2356)
* elim:                                  Functions and Variables for to_poly_solve.
                                                             (line  284)
* elim_allbut:                           Functions and Variables for to_poly_solve.
                                                             (line  343)
* eliminate:                             Functions and Variables for Polynomials.
                                                             (line  151)
* eliminate_using:                       Functions and Variables for to_poly_solve.
                                                             (line  362)
* ellipse:                               Functions and Variables for draw.
                                                             (line 2384)
* elliptic_e:                            Functions and Variables for Elliptic Integrals.
                                                             (line   13)
* elliptic_ec:                           Functions and Variables for Elliptic Integrals.
                                                             (line   50)
* elliptic_eu:                           Functions and Variables for Elliptic Integrals.
                                                             (line   20)
* elliptic_f:                            Functions and Variables for Elliptic Integrals.
                                                             (line    6)
* elliptic_kc:                           Functions and Variables for Elliptic Integrals.
                                                             (line   42)
* elliptic_pi:                           Functions and Variables for Elliptic Integrals.
                                                             (line   35)
* ematrix:                               Functions and Variables for Matrices and Linear Algebra.
                                                             (line  489)
* empty_graph:                           Functions and Variables for graphs.
                                                             (line  114)
* emptyp:                                Functions and Variables for Sets.
                                                             (line  173)
* endcons:                               Functions and Variables for Lists.
                                                             (line  165)
* enhanced3d:                            Functions and Variables for draw.
                                                             (line  608)
* entermatrix:                           Functions and Variables for Matrices and Linear Algebra.
                                                             (line  494)
* entertensor:                           Functions and Variables for itensor.
                                                             (line   15)
* entier:                                Functions for Numbers.
                                                             (line   54)
* epsilon_lp:                            Functions and Variables for simplex.
                                                             (line    6)
* equal:                                 Functions and Variables for Predicates.
                                                             (line   87)
* equalp:                                Functions and Variables for Fourier series.
                                                             (line    6)
* equiv_classes:                         Functions and Variables for Sets.
                                                             (line  184)
* erf:                                   Error Function.     (line    9)
* erf_generalized:                       Error Function.     (line   24)
* erf_representation:                    Error Function.     (line   51)
* erfc:                                  Error Function.     (line   14)
* erfflag:                               Functions and Variables for Integration.
                                                             (line  112)
* erfi:                                  Error Function.     (line   19)
* errcatch:                              Functions and Variables for Program Flow.
                                                             (line  225)
* error:                                 Functions and Variables for Program Flow.
                                                             (line  235)
* error <1>:                             Functions and Variables for Program Flow.
                                                             (line  236)
* error_size:                            Functions and Variables for Program Flow.
                                                             (line  249)
* error_syms:                            Functions and Variables for Program Flow.
                                                             (line  292)
* error_type:                            Functions and Variables for draw.
                                                             (line  641)
* errormsg:                              Functions and Variables for Program Flow.
                                                             (line  312)
* errormsg <1>:                          Functions and Variables for Program Flow.
                                                             (line  307)
* errors:                                Functions and Variables for draw.
                                                             (line 2415)
* euler:                                 Functions and Variables for Number Theory.
                                                             (line  195)
* Euler-Mascheroni constant:             Functions and Variables for Constants.
                                                             (line   20)
* Euler's number:                        Functions and Variables for Constants.
                                                             (line    7)
* ev:                                    Functions and Variables for Evaluation.
                                                             (line  236)
* ev_point:                              Functions and Variables for zeilberger.
                                                             (line  149)
* eval:                                  Functions and Variables for Evaluation.
                                                             (line  395)
* eval_string:                           Functions and Variables for strings.
                                                             (line   25)
* evenfun:                               Functions and Variables for Simplification.
                                                             (line  126)
* evenp:                                 Functions and Variables for Numbers.
                                                             (line   36)
* every:                                 Functions and Variables for Sets.
                                                             (line  213)
* every <1>:                             Functions and Variables for Sets.
                                                             (line  214)
* evflag:                                Functions and Variables for Evaluation.
                                                             (line  413)
* evfun:                                 Functions and Variables for Evaluation.
                                                             (line  474)
* evolution:                             Functions and Variables for dynamics.
                                                             (line   15)
* evolution2d:                           Functions and Variables for dynamics.
                                                             (line   26)
* evundiff:                              Functions and Variables for itensor.
                                                             (line  634)
* example:                               Functions and Variables for Help.
                                                             (line  132)
* example <1>:                           Functions and Variables for Help.
                                                             (line  133)
* exp:                                   Root Exponential and Logarithmic Functions.
                                                             (line   41)
* expand:                                Functions and Variables for Simplification.
                                                             (line  147)
* expand <1>:                            Functions and Variables for Simplification.
                                                             (line  148)
* expandwrt:                             Functions and Variables for Simplification.
                                                             (line  227)
* expandwrt_denom:                       Functions and Variables for Simplification.
                                                             (line  238)
* expandwrt_factored:                    Functions and Variables for Simplification.
                                                             (line  246)
* expintegral_chi:                       Exponential Integrals.
                                                             (line   30)
* expintegral_ci:                        Exponential Integrals.
                                                             (line   24)
* expintegral_e:                         Exponential Integrals.
                                                             (line   18)
* expintegral_e1:                        Exponential Integrals.
                                                             (line    9)
* expintegral_ei:                        Exponential Integrals.
                                                             (line   12)
* expintegral_li:                        Exponential Integrals.
                                                             (line   15)
* expintegral_shi:                       Exponential Integrals.
                                                             (line   27)
* expintegral_si:                        Exponential Integrals.
                                                             (line   21)
* expintexpand:                          Exponential Integrals.
                                                             (line   40)
* expintrep:                             Exponential Integrals.
                                                             (line   33)
* explicit:                              Functions and Variables for draw.
                                                             (line 2456)
* explicit <1>:                          Functions and Variables for draw.
                                                             (line 2457)
* explose:                               Functions and Variables for Symmetries.
                                                             (line  222)
* expon:                                 Functions and Variables for Simplification.
                                                             (line  254)
* exponentialize:                        Functions and Variables for Simplification.
                                                             (line  261)
* exponentialize <1>:                    Functions and Variables for Simplification.
                                                             (line  262)
* expop:                                 Functions and Variables for Simplification.
                                                             (line  274)
* express:                               Functions and Variables for Differentiation.
                                                             (line  430)
* expt:                                  Functions and Variables for Display.
                                                             (line  135)
* exptdispflag:                          Functions and Variables for Display.
                                                             (line  144)
* exptisolate:                           Functions and Variables for Expressions.
                                                             (line  214)
* exptsubst:                             Functions and Variables for Expressions.
                                                             (line  220)
* exsec:                                 Package functs.     (line  144)
* extdiff:                               Functions and Variables for itensor.
                                                             (line 1352)
* extract_linear_equations:              Functions and Variables for Affine.
                                                             (line  101)
* extremal_subset:                       Functions and Variables for Sets.
                                                             (line  278)
* extremal_subset <1>:                   Functions and Variables for Sets.
                                                             (line  279)
* ezgcd:                                 Functions and Variables for Polynomials.
                                                             (line  178)
* f90:                                   Functions and Variables for f90.
                                                             (line    6)
* facexpand:                             Functions and Variables for Polynomials.
                                                             (line  208)
* facsum:                                Package facexp.     (line   22)
* facsum_combine:                        Package facexp.     (line   70)
* factcomb:                              Combinatorial Functions.
                                                             (line   42)
* factlim:                               Combinatorial Functions.
                                                             (line  134)
* factor:                                Functions and Variables for Polynomials.
                                                             (line  214)
* factor <1>:                            Functions and Variables for Polynomials.
                                                             (line  215)
* factorfacsum:                          Package facexp.     (line   81)
* factorflag:                            Functions and Variables for Polynomials.
                                                             (line  341)
* factorial:                             Combinatorial Functions.
                                                             (line   49)
* factorial_expand:                      Combinatorial Functions.
                                                             (line  140)
* factorout:                             Functions and Variables for Polynomials.
                                                             (line  347)
* factorsum:                             Functions and Variables for Polynomials.
                                                             (line  366)
* facts:                                 Functions and Variables for Facts.
                                                             (line  263)
* facts <1>:                             Functions and Variables for Facts.
                                                             (line  264)
* false:                                 Functions and Variables for Constants.
                                                             (line   14)
* fast_central_elements:                 Functions and Variables for Affine.
                                                             (line   68)
* fast_linsolve:                         Functions and Variables for Affine.
                                                             (line    6)
* fasttimes:                             Functions and Variables for Polynomials.
                                                             (line  385)
* fb:                                    Functions and Variables for ctensor.
                                                             (line 1129)
* feature:                               Functions and Variables for Runtime Environment.
                                                             (line    6)
* featurep:                              Functions and Variables for Runtime Environment.
                                                             (line   16)
* features:                              Functions and Variables for Properties.
                                                             (line  306)
* fernfale:                              Definitions for IFS fractals.
                                                             (line   39)
* Fetch documentation:                   Functions and Variables for Command Line.
                                                             (line  172)
* Fetch documentation (inexact search):  Functions and Variables for Command Line.
                                                             (line  184)
* fft:                                   Functions and Variables for fast Fourier transform.
                                                             (line   94)
* fib:                                   Functions and Variables for Number Theory.
                                                             (line  204)
* fibtophi:                              Functions and Variables for Number Theory.
                                                             (line  214)
* fifth:                                 Functions and Variables for Lists.
                                                             (line  171)
* file_name:                             Functions and Variables for draw.
                                                             (line  651)
* file_name <1>:                         Functions and Variables for graphs.
                                                             (line 1491)
* file_output_append:                    Functions and Variables for File Input and Output.
                                                             (line   85)
* file_search:                           Functions and Variables for File Input and Output.
                                                             (line  108)
* file_search <1>:                       Functions and Variables for File Input and Output.
                                                             (line  109)
* file_search_demo:                      Functions and Variables for File Input and Output.
                                                             (line  152)
* file_search_lisp:                      Functions and Variables for File Input and Output.
                                                             (line  151)
* file_search_maxima:                    Functions and Variables for File Input and Output.
                                                             (line  150)
* file_search_tests:                     Functions and Variables for File Input and Output.
                                                             (line  154)
* file_search_usage:                     Functions and Variables for File Input and Output.
                                                             (line  153)
* file_type:                             Functions and Variables for File Input and Output.
                                                             (line  188)
* file_type_lisp:                        Functions and Variables for File Input and Output.
                                                             (line  211)
* file_type_maxima:                      Functions and Variables for File Input and Output.
                                                             (line  219)
* filename_merge:                        Functions and Variables for File Input and Output.
                                                             (line   99)
* fill_color:                            Functions and Variables for draw.
                                                             (line  669)
* fill_density:                          Functions and Variables for draw.
                                                             (line  677)
* fillarray:                             Functions and Variables for Arrays.
                                                             (line  202)
* filled_func:                           Functions and Variables for draw.
                                                             (line  685)
* find_root:                             Functions and Variables for fast Fourier transform.
                                                             (line  287)
* find_root <1>:                         Functions and Variables for fast Fourier transform.
                                                             (line  288)
* find_root_abs:                         Functions and Variables for fast Fourier transform.
                                                             (line  292)
* find_root_error:                       Functions and Variables for fast Fourier transform.
                                                             (line  291)
* find_root_rel:                         Functions and Variables for fast Fourier transform.
                                                             (line  293)
* findde:                                Functions and Variables for ctensor.
                                                             (line  619)
* first:                                 Functions and Variables for Lists.
                                                             (line  176)
* fix:                                   Functions for Numbers.
                                                             (line   98)
* fixed_vertices:                        Functions and Variables for graphs.
                                                             (line 1502)
* flatten:                               Functions and Variables for Sets.
                                                             (line  296)
* flength:                               Functions and Variables for input and output.
                                                             (line   28)
* flipflag:                              Functions and Variables for itensor.
                                                             (line  136)
* float:                                 Functions and Variables for Numbers.
                                                             (line   41)
* float2bf:                              Functions and Variables for Numbers.
                                                             (line   47)
* floatnump:                             Functions and Variables for Numbers.
                                                             (line   54)
* floor:                                 Functions for Numbers.
                                                             (line   58)
* flower_snark:                          Functions and Variables for graphs.
                                                             (line  117)
* flush:                                 Functions and Variables for itensor.
                                                             (line  687)
* flush1deriv:                           Functions and Variables for itensor.
                                                             (line  820)
* flushd:                                Functions and Variables for itensor.
                                                             (line  690)
* flushnd:                               Functions and Variables for itensor.
                                                             (line  693)
* fmin_cobyla:                           Functions and Variables for cobyla.
                                                             (line    6)
* fmin_cobyla <1>:                       Functions and Variables for cobyla.
                                                             (line    7)
* font:                                  Functions and Variables for draw.
                                                             (line  719)
* font_size:                             Functions and Variables for draw.
                                                             (line  804)
* for:                                   Functions and Variables for Program Flow.
                                                             (line  347)
* forget:                                Functions and Variables for Facts.
                                                             (line  275)
* forget <1>:                            Functions and Variables for Facts.
                                                             (line  276)
* fortindent:                            Functions and Variables for fast Fourier transform.
                                                             (line  196)
* fortran:                               Functions and Variables for fast Fourier transform.
                                                             (line  203)
* fortspaces:                            Functions and Variables for fast Fourier transform.
                                                             (line  254)
* fourcos:                               Functions and Variables for Fourier series.
                                                             (line   73)
* fourexpand:                            Functions and Variables for Fourier series.
                                                             (line   67)
* fourier:                               Functions and Variables for Fourier series.
                                                             (line   47)
* fourier_elim:                          Functions and Variables for to_poly_solve.
                                                             (line  393)
* fourint:                               Functions and Variables for Fourier series.
                                                             (line   87)
* fourintcos:                            Functions and Variables for Fourier series.
                                                             (line   92)
* fourintsin:                            Functions and Variables for Fourier series.
                                                             (line   95)
* foursimp:                              Functions and Variables for Fourier series.
                                                             (line   52)
* foursin:                               Functions and Variables for Fourier series.
                                                             (line   78)
* fourth:                                Functions and Variables for Lists.
                                                             (line  189)
* fposition:                             Functions and Variables for input and output.
                                                             (line   31)
* fposition <1>:                         Functions and Variables for input and output.
                                                             (line   32)
* fpprec:                                Functions and Variables for Numbers.
                                                             (line   58)
* fpprintprec:                           Functions and Variables for Numbers.
                                                             (line   66)
* frame_bracket:                         Functions and Variables for ctensor.
                                                             (line  419)
* freeof:                                Functions and Variables for Expressions.
                                                             (line  226)
* freshline:                             Functions and Variables for input and output.
                                                             (line   38)
* freshline <1>:                         Functions and Variables for input and output.
                                                             (line   39)
* fresnel_c:                             Error Function.     (line   27)
* fresnel_s:                             Error Function.     (line   39)
* from_adjacency_matrix:                 Functions and Variables for graphs.
                                                             (line  126)
* frucht_graph:                          Functions and Variables for graphs.
                                                             (line  129)
* full_listify:                          Functions and Variables for Sets.
                                                             (line  355)
* fullmap:                               Functions and Variables for Function Definition.
                                                             (line  424)
* fullmapl:                              Functions and Variables for Function Definition.
                                                             (line  442)
* fullratsimp:                           Functions and Variables for Polynomials.
                                                             (line  393)
* fullratsubst:                          Functions and Variables for Polynomials.
                                                             (line  430)
* fullsetify:                            Functions and Variables for Sets.
                                                             (line  369)
* funcsolve:                             Functions and Variables for Equations.
                                                             (line  315)
* functions:                             Functions and Variables for Function Definition.
                                                             (line  452)
* fundamental_dimensions:                Functions and Variables for ezunits.
                                                             (line  506)
* fundamental_units:                     Functions and Variables for ezunits.
                                                             (line  617)
* fundamental_units <1>:                 Functions and Variables for ezunits.
                                                             (line  618)
* fundef:                                Functions and Variables for Function Definition.
                                                             (line  496)
* funmake:                               Functions and Variables for Function Definition.
                                                             (line  513)
* funp:                                  Functions and Variables for Fourier series.
                                                             (line   21)
* funp <1>:                              Functions and Variables for Fourier series.
                                                             (line   22)
* fv:                                    Functions and Variables for finance.
                                                             (line   16)
* gamma:                                 Gamma and factorial Functions.
                                                             (line   29)
* gamma_incomplete:                      Gamma and factorial Functions.
                                                             (line  118)
* gamma_incomplete_generalized:          Gamma and factorial Functions.
                                                             (line  139)
* gamma_incomplete_regularized:          Gamma and factorial Functions.
                                                             (line  130)
* gammalim:                              Gamma and factorial Functions.
                                                             (line  151)
* gauss_a:                               Functions and Variables for contrib_ode.
                                                             (line   83)
* gauss_b:                               Functions and Variables for contrib_ode.
                                                             (line   95)
* gaussprob:                             Package functs.     (line  119)
* gcd:                                   Functions and Variables for Polynomials.
                                                             (line  475)
* gcdex:                                 Functions and Variables for Polynomials.
                                                             (line  520)
* gcdex <1>:                             Functions and Variables for Polynomials.
                                                             (line  521)
* gcdivide:                              Package functs.     (line   49)
* gcfac:                                 Package scifac.     (line    6)
* gcfactor:                              Functions and Variables for Polynomials.
                                                             (line  560)
* gd:                                    Package functs.     (line  124)
* gdet:                                  Functions and Variables for ctensor.
                                                             (line 1055)
* gen_laguerre:                          Functions and Variables for orthogonal polynomials.
                                                             (line   27)
* genfact:                               Combinatorial Functions.
                                                             (line  146)
* genindex:                              Functions and Variables for Miscellaneous Options.
                                                             (line   25)
* genmatrix:                             Functions and Variables for Matrices and Linear Algebra.
                                                             (line  533)
* genmatrix <1>:                         Functions and Variables for Matrices and Linear Algebra.
                                                             (line  534)
* genmatrix <2>:                         Functions and Variables for Matrices and Linear Algebra.
                                                             (line  535)
* gensumnum:                             Functions and Variables for Miscellaneous Options.
                                                             (line   31)
* gensym:                                Functions and Variables for Miscellaneous Options.
                                                             (line   38)
* gensym <1>:                            Functions and Variables for Miscellaneous Options.
                                                             (line   39)
* geo_amortization:                      Functions and Variables for finance.
                                                             (line  146)
* geo_annuity_fv:                        Functions and Variables for finance.
                                                             (line   83)
* geo_annuity_pv:                        Functions and Variables for finance.
                                                             (line   71)
* geomap:                                Functions and Variables for worldmap.
                                                             (line  141)
* geomap <1>:                            Functions and Variables for worldmap.
                                                             (line  142)
* geometric:                             Package functs.     (line   96)
* geometric_mean:                        Functions and Variables for descriptive statistics.
                                                             (line  351)
* geometric_mean <1>:                    Functions and Variables for descriptive statistics.
                                                             (line  352)
* geosum:                                Package functs.     (line  113)
* get:                                   Functions and Variables for Properties.
                                                             (line  337)
* get_edge_weight:                       Functions and Variables for graphs.
                                                             (line  457)
* get_edge_weight <1>:                   Functions and Variables for graphs.
                                                             (line  458)
* get_lu_factors:                        Functions and Variables for linearalgebra.
                                                             (line  165)
* get_pixel:                             Functions and Variables for pictures.
                                                             (line    6)
* get_plot_option:                       Functions and Variables for Plotting.
                                                             (line   34)
* get_tex_environment:                   Functions and Variables for File Input and Output.
                                                             (line  690)
* get_tex_environment_default:           Functions and Variables for File Input and Output.
                                                             (line  727)
* get_vertex_label:                      Functions and Variables for graphs.
                                                             (line  475)
* gfactor:                               Functions and Variables for Polynomials.
                                                             (line  566)
* gfactorsum:                            Functions and Variables for Polynomials.
                                                             (line  577)
* ggf:                                   Functions and Variables for ggf.
                                                             (line   31)
* GGFCFMAX:                              Functions and Variables for ggf.
                                                             (line   19)
* GGFINFINITY:                           Functions and Variables for ggf.
                                                             (line    6)
* girth:                                 Functions and Variables for graphs.
                                                             (line  540)
* global_variances:                      Functions and Variables for descriptive statistics.
                                                             (line  526)
* global_variances <1>:                  Functions and Variables for descriptive statistics.
                                                             (line  527)
* globalsolve:                           Functions and Variables for Equations.
                                                             (line  337)
* gnuplot_close:                         Gnuplot_pipes Format Functions.
                                                             (line   11)
* gnuplot_curve_styles:                  Gnuplot Options.    (line   74)
* gnuplot_curve_titles:                  Gnuplot Options.    (line   70)
* gnuplot_default_term_command:          Gnuplot Options.    (line   78)
* gnuplot_dumb_term_command:             Gnuplot Options.    (line   83)
* gnuplot_file_name:                     Functions and Variables for draw.
                                                             (line  817)
* gnuplot_out_file:                      Gnuplot Options.    (line   48)
* gnuplot_pm3d:                          Gnuplot Options.    (line   58)
* gnuplot_preamble:                      Gnuplot Options.    (line   63)
* gnuplot_ps_term_command:               Gnuplot Options.    (line   89)
* gnuplot_replot:                        Gnuplot_pipes Format Functions.
                                                             (line   20)
* gnuplot_replot <1>:                    Gnuplot_pipes Format Functions.
                                                             (line   21)
* gnuplot_reset:                         Gnuplot_pipes Format Functions.
                                                             (line   27)
* gnuplot_restart:                       Gnuplot_pipes Format Functions.
                                                             (line   15)
* gnuplot_start:                         Gnuplot_pipes Format Functions.
                                                             (line    6)
* gnuplot_term:                          Gnuplot Options.    (line   12)
* go:                                    Functions and Variables for Program Flow.
                                                             (line  352)
* Golden mean:                           Functions and Variables for Constants.
                                                             (line   47)
* Gosper:                                Functions and Variables for zeilberger.
                                                             (line   12)
* Gosper_in_Zeilberger:                  Functions and Variables for zeilberger.
                                                             (line  121)
* GosperSum:                             Functions and Variables for zeilberger.
                                                             (line   17)
* gr2d:                                  Functions and Variables for draw.
                                                             (line    9)
* gr3d:                                  Functions and Variables for draw.
                                                             (line   29)
* gradef:                                Functions and Variables for Differentiation.
                                                             (line  490)
* gradef <1>:                            Functions and Variables for Differentiation.
                                                             (line  491)
* gradefs:                               Functions and Variables for Differentiation.
                                                             (line  529)
* gramschmidt:                           Functions and Variables for Matrices and Linear Algebra.
                                                             (line  593)
* gramschmidt <1>:                       Functions and Variables for Matrices and Linear Algebra.
                                                             (line  594)
* graph_center:                          Functions and Variables for graphs.
                                                             (line  494)
* graph_charpoly:                        Functions and Variables for graphs.
                                                             (line  484)
* graph_eigenvalues:                     Functions and Variables for graphs.
                                                             (line  503)
* graph_flow:                            Functions and Variables for finance.
                                                             (line   38)
* graph_order:                           Functions and Variables for graphs.
                                                             (line  531)
* graph_periphery:                       Functions and Variables for graphs.
                                                             (line  513)
* graph_product:                         Functions and Variables for graphs.
                                                             (line  132)
* graph_size:                            Functions and Variables for graphs.
                                                             (line  522)
* graph_union:                           Functions and Variables for graphs.
                                                             (line  140)
* graph6_decode:                         Functions and Variables for graphs.
                                                             (line 1229)
* graph6_encode:                         Functions and Variables for graphs.
                                                             (line 1233)
* graph6_export:                         Functions and Variables for graphs.
                                                             (line 1237)
* graph6_import:                         Functions and Variables for graphs.
                                                             (line 1242)
* great_rhombicosidodecahedron_graph:    Functions and Variables for graphs.
                                                             (line  146)
* great_rhombicuboctahedron_graph:       Functions and Variables for graphs.
                                                             (line  149)
* grid:                                  Plotting Options.   (line   82)
* grid <1>:                              Functions and Variables for draw.
                                                             (line  838)
* grid_graph:                            Functions and Variables for graphs.
                                                             (line  143)
* grind:                                 Functions and Variables for Display.
                                                             (line  165)
* grind <1>:                             Functions and Variables for Display.
                                                             (line  166)
* grobner_basis:                         Functions and Variables for Affine.
                                                             (line   19)
* grotzch_graph:                         Functions and Variables for graphs.
                                                             (line  152)
* halfangles:                            Functions and Variables for Trigonometric.
                                                             (line  140)
* hamilton_cycle:                        Functions and Variables for graphs.
                                                             (line  549)
* hamilton_path:                         Functions and Variables for graphs.
                                                             (line  560)
* hankel:                                Functions and Variables for linearalgebra.
                                                             (line  172)
* hankel <1>:                            Functions and Variables for linearalgebra.
                                                             (line  173)
* hankel_1:                              Bessel Functions.   (line   59)
* hankel_2:                              Bessel Functions.   (line  108)
* harmonic:                              Package functs.     (line  102)
* harmonic_mean:                         Functions and Variables for descriptive statistics.
                                                             (line  325)
* harmonic_mean <1>:                     Functions and Variables for descriptive statistics.
                                                             (line  326)
* hav:                                   Package functs.     (line  149)
* head_angle:                            Functions and Variables for draw.
                                                             (line  852)
* head_angle <1>:                        Functions and Variables for graphs.
                                                             (line 1472)
* head_both:                             Functions and Variables for draw.
                                                             (line  886)
* head_length:                           Functions and Variables for draw.
                                                             (line  906)
* head_length <1>:                       Functions and Variables for graphs.
                                                             (line 1477)
* head_type:                             Functions and Variables for draw.
                                                             (line  928)
* heawood_graph:                         Functions and Variables for graphs.
                                                             (line  155)
* Help:                                  Functions and Variables for Help.
                                                             (line   71)
* hermite:                               Functions and Variables for orthogonal polynomials.
                                                             (line   32)
* hessian:                               Functions and Variables for linearalgebra.
                                                             (line  179)
* hgfred:                                Functions and Variables for Special Functions.
                                                             (line   95)
* hilbert_matrix:                        Functions and Variables for linearalgebra.
                                                             (line  205)
* hilbertmap:                            Definitions for Peano maps.
                                                             (line    8)
* hipow:                                 Functions and Variables for Polynomials.
                                                             (line  582)
* histogram:                             Functions and Variables for statistical graphs.
                                                             (line  189)
* histogram <1>:                         Functions and Variables for statistical graphs.
                                                             (line  190)
* histogram <2>:                         Functions and Variables for statistical graphs.
                                                             (line  191)
* histogram <3>:                         Functions and Variables for statistical graphs.
                                                             (line  192)
* histogram <4>:                         Functions and Variables for statistical graphs.
                                                             (line  193)
* histogram <5>:                         Functions and Variables for statistical graphs.
                                                             (line  194)
* histogram_description:                 Functions and Variables for statistical graphs.
                                                             (line  195)
* hodge:                                 Functions and Variables for itensor.
                                                             (line 1381)
* horner:                                Functions and Variables for fast Fourier transform.
                                                             (line  260)
* horner <1>:                            Functions and Variables for fast Fourier transform.
                                                             (line  261)
* hypergeometric:                        Hypergeometric Functions.
                                                             (line   23)
* hypergeometric_representation:         Error Function.     (line   57)
* i:                                     Functions and Variables for Constants.
                                                             (line   11)
* ibase:                                 Functions and Variables for Display.
                                                             (line  264)
* ic_convert:                            Functions and Variables for itensor.
                                                             (line 1472)
* ic1:                                   Functions and Variables for Differential Equations.
                                                             (line   64)
* ic2:                                   Functions and Variables for Differential Equations.
                                                             (line   72)
* icc1:                                  Functions and Variables for itensor.
                                                             (line 1048)
* icc2:                                  Functions and Variables for itensor.
                                                             (line 1063)
* ichr1:                                 Functions and Variables for itensor.
                                                             (line  840)
* ichr2:                                 Functions and Variables for itensor.
                                                             (line  847)
* icosahedron_graph:                     Functions and Variables for graphs.
                                                             (line  158)
* icosidodecahedron_graph:               Functions and Variables for graphs.
                                                             (line  161)
* icounter:                              Functions and Variables for itensor.
                                                             (line  334)
* icurvature:                            Functions and Variables for itensor.
                                                             (line  853)
* ident:                                 Functions and Variables for Matrices and Linear Algebra.
                                                             (line  646)
* identfor:                              Functions and Variables for linearalgebra.
                                                             (line  210)
* identfor <1>:                          Functions and Variables for linearalgebra.
                                                             (line  211)
* identity:                              Functions and Variables for Sets.
                                                             (line  386)
* idiff:                                 Functions and Variables for itensor.
                                                             (line  592)
* idim:                                  Functions and Variables for itensor.
                                                             (line  836)
* idummy:                                Functions and Variables for itensor.
                                                             (line  322)
* idummyx:                               Functions and Variables for itensor.
                                                             (line  329)
* ieqn:                                  Functions and Variables for Equations.
                                                             (line  392)
* ieqnprint:                             Functions and Variables for Equations.
                                                             (line  421)
* if:                                    Functions and Variables for Program Flow.
                                                             (line  364)
* ifactors:                              Functions and Variables for Number Theory.
                                                             (line  240)
* ifb:                                   Functions and Variables for itensor.
                                                             (line 1020)
* ifc1:                                  Functions and Variables for itensor.
                                                             (line 1079)
* ifc2:                                  Functions and Variables for itensor.
                                                             (line 1092)
* ifg:                                   Functions and Variables for itensor.
                                                             (line 1113)
* ifgi:                                  Functions and Variables for itensor.
                                                             (line 1118)
* ifr:                                   Functions and Variables for itensor.
                                                             (line 1103)
* iframe_bracket_form:                   Functions and Variables for itensor.
                                                             (line 1122)
* iframes:                               Functions and Variables for itensor.
                                                             (line 1014)
* ifri:                                  Functions and Variables for itensor.
                                                             (line 1108)
* ifs:                                   Functions and Variables for dynamics.
                                                             (line   36)
* igcdex:                                Functions and Variables for Number Theory.
                                                             (line  254)
* igeodesic_coords:                      Functions and Variables for itensor.
                                                             (line  911)
* igeowedge_flag:                        Functions and Variables for itensor.
                                                             (line 1419)
* ikt1:                                  Functions and Variables for itensor.
                                                             (line 1171)
* ikt2:                                  Functions and Variables for itensor.
                                                             (line 1185)
* ilt:                                   Functions and Variables for Integration.
                                                             (line  118)
* image:                                 Functions and Variables for draw.
                                                             (line 2505)
* Imaginary unit:                        Functions and Variables for Constants.
                                                             (line   11)
* imagpart:                              Functions for Complex Numbers.
                                                             (line   56)
* imetric:                               Functions and Variables for itensor.
                                                             (line  827)
* imetric <1>:                           Functions and Variables for itensor.
                                                             (line  828)
* implicit:                              Functions and Variables for draw.
                                                             (line 2592)
* implicit <1>:                          Functions and Variables for draw.
                                                             (line 2594)
* implicit_derivative:                   Functions and Variables for impdiff.
                                                             (line    6)
* implicit_plot:                         Functions and Variables for implicit_plot.
                                                             (line    6)
* implicit_plot <1>:                     Functions and Variables for implicit_plot.
                                                             (line    7)
* in_neighbors:                          Functions and Variables for graphs.
                                                             (line  583)
* inchar:                                Functions and Variables for Command Line.
                                                             (line  190)
* ind:                                   Functions and Variables for Constants.
                                                             (line   23)
* Indeterminate:                         Functions and Variables for Constants.
                                                             (line   24)
* indexed_tensor:                        Functions and Variables for itensor.
                                                             (line  177)
* indices:                               Functions and Variables for itensor.
                                                             (line   52)
* induced_subgraph:                      Functions and Variables for graphs.
                                                             (line  164)
* inf:                                   Functions and Variables for Constants.
                                                             (line   34)
* inference_result:                      Functions and Variables for inference_result.
                                                             (line    6)
* inferencep:                            Functions and Variables for inference_result.
                                                             (line   47)
* infeval:                               Functions and Variables for Evaluation.
                                                             (line  542)
* infinity:                              Functions and Variables for Constants.
                                                             (line   38)
* infix:                                 User defined operators.
                                                             (line    6)
* infix <1>:                             User defined operators.
                                                             (line    7)
* infix <2>:                             User defined operators.
                                                             (line    8)
* inflag:                                Functions and Variables for Expressions.
                                                             (line  311)
* infolists:                             Functions and Variables for Command Line.
                                                             (line  214)
* init_atensor:                          Functions and Variables for atensor.
                                                             (line    6)
* init_atensor <1>:                      Functions and Variables for atensor.
                                                             (line    7)
* init_ctensor:                          Functions and Variables for ctensor.
                                                             (line  131)
* inm:                                   Functions and Variables for itensor.
                                                             (line 1135)
* inmc1:                                 Functions and Variables for itensor.
                                                             (line 1145)
* inmc2:                                 Functions and Variables for itensor.
                                                             (line 1157)
* innerproduct:                          Functions and Variables for Matrices and Linear Algebra.
                                                             (line  650)
* inpart:                                Functions and Variables for Expressions.
                                                             (line  332)
* inprod:                                Functions and Variables for Matrices and Linear Algebra.
                                                             (line  651)
* inrt:                                  Functions and Variables for Number Theory.
                                                             (line  276)
* intanalysis:                           Functions and Variables for Integration.
                                                             (line  161)
* integer_partitions:                    Functions and Variables for Sets.
                                                             (line  398)
* integer_partitions <1>:                Functions and Variables for Sets.
                                                             (line  399)
* integerp:                              Functions and Variables for Numbers.
                                                             (line   84)
* integrate:                             Functions and Variables for Integration.
                                                             (line  198)
* integrate <1>:                         Functions and Variables for Integration.
                                                             (line  199)
* integrate_use_rootsof:                 Functions and Variables for Integration.
                                                             (line  414)
* integration_constant:                  Functions and Variables for Integration.
                                                             (line  355)
* integration_constant_counter:          Functions and Variables for Integration.
                                                             (line  379)
* intersect:                             Functions and Variables for Sets.
                                                             (line  439)
* intersection:                          Functions and Variables for Sets.
                                                             (line  443)
* intervalp:                             Functions and Variables for orthogonal polynomials.
                                                             (line   37)
* intfaclim:                             Functions and Variables for Polynomials.
                                                             (line  605)
* intopois:                              Poisson series.     (line    6)
* intosum:                               Sums and Products.  (line   33)
* inv_mod:                               Functions and Variables for Number Theory.
                                                             (line  284)
* invariant1:                            Functions and Variables for ctensor.
                                                             (line  736)
* invariant2:                            Functions and Variables for ctensor.
                                                             (line  741)
* inverse_fft:                           Functions and Variables for fast Fourier transform.
                                                             (line   40)
* inverse_jacobi_cd:                     Functions and Variables for Elliptic Functions.
                                                             (line   66)
* inverse_jacobi_cn:                     Functions and Variables for Elliptic Functions.
                                                             (line   45)
* inverse_jacobi_cs:                     Functions and Variables for Elliptic Functions.
                                                             (line   63)
* inverse_jacobi_dc:                     Functions and Variables for Elliptic Functions.
                                                             (line   75)
* inverse_jacobi_dn:                     Functions and Variables for Elliptic Functions.
                                                             (line   48)
* inverse_jacobi_ds:                     Functions and Variables for Elliptic Functions.
                                                             (line   72)
* inverse_jacobi_nc:                     Functions and Variables for Elliptic Functions.
                                                             (line   60)
* inverse_jacobi_nd:                     Functions and Variables for Elliptic Functions.
                                                             (line   69)
* inverse_jacobi_ns:                     Functions and Variables for Elliptic Functions.
                                                             (line   51)
* inverse_jacobi_sc:                     Functions and Variables for Elliptic Functions.
                                                             (line   54)
* inverse_jacobi_sd:                     Functions and Variables for Elliptic Functions.
                                                             (line   57)
* inverse_jacobi_sn:                     Functions and Variables for Elliptic Functions.
                                                             (line   42)
* invert:                                Functions and Variables for Matrices and Linear Algebra.
                                                             (line  662)
* invert_by_lu:                          Functions and Variables for linearalgebra.
                                                             (line  223)
* ip_grid:                               Functions and Variables for draw.
                                                             (line  952)
* ip_grid_in:                            Functions and Variables for draw.
                                                             (line  960)
* irr:                                   Functions and Variables for finance.
                                                             (line  213)
* is:                                    Functions and Variables for Facts.
                                                             (line  283)
* is_biconnected:                        Functions and Variables for graphs.
                                                             (line  594)
* is_bipartite:                          Functions and Variables for graphs.
                                                             (line  605)
* is_connected:                          Functions and Variables for graphs.
                                                             (line  616)
* is_digraph:                            Functions and Variables for graphs.
                                                             (line  625)
* is_edge_in_graph:                      Functions and Variables for graphs.
                                                             (line  636)
* is_graph:                              Functions and Variables for graphs.
                                                             (line  652)
* is_graph_or_digraph:                   Functions and Variables for graphs.
                                                             (line  662)
* is_isomorphic:                         Functions and Variables for graphs.
                                                             (line  673)
* is_planar:                             Functions and Variables for graphs.
                                                             (line  686)
* is_sconnected:                         Functions and Variables for graphs.
                                                             (line  703)
* is_tree:                               Functions and Variables for graphs.
                                                             (line  726)
* is_vertex_in_graph:                    Functions and Variables for graphs.
                                                             (line  714)
* ishow:                                 Functions and Variables for itensor.
                                                             (line   45)
* isolate:                               Functions and Variables for Expressions.
                                                             (line  358)
* isolate_wrt_times:                     Functions and Variables for Expressions.
                                                             (line  374)
* isomorphism:                           Functions and Variables for graphs.
                                                             (line  571)
* isqrt:                                 Functions and Variables for Number Theory.
                                                             (line  296)
* isreal_p:                              Functions and Variables for to_poly_solve.
                                                             (line  460)
* items_inference:                       Functions and Variables for inference_result.
                                                             (line   52)
* itr:                                   Functions and Variables for itensor.
                                                             (line 1197)
* jacobi:                                Functions and Variables for Number Theory.
                                                             (line  300)
* jacobi_cd:                             Functions and Variables for Elliptic Functions.
                                                             (line   30)
* jacobi_cn:                             Functions and Variables for Elliptic Functions.
                                                             (line    9)
* jacobi_cs:                             Functions and Variables for Elliptic Functions.
                                                             (line   27)
* jacobi_dc:                             Functions and Variables for Elliptic Functions.
                                                             (line   39)
* jacobi_dn:                             Functions and Variables for Elliptic Functions.
                                                             (line   12)
* jacobi_ds:                             Functions and Variables for Elliptic Functions.
                                                             (line   36)
* jacobi_nc:                             Functions and Variables for Elliptic Functions.
                                                             (line   24)
* jacobi_nd:                             Functions and Variables for Elliptic Functions.
                                                             (line   33)
* jacobi_ns:                             Functions and Variables for Elliptic Functions.
                                                             (line   15)
* jacobi_p:                              Functions and Variables for orthogonal polynomials.
                                                             (line   40)
* jacobi_sc:                             Functions and Variables for Elliptic Functions.
                                                             (line   18)
* jacobi_sd:                             Functions and Variables for Elliptic Functions.
                                                             (line   21)
* jacobi_sn:                             Functions and Variables for Elliptic Functions.
                                                             (line    6)
* jacobian:                              Functions and Variables for linearalgebra.
                                                             (line  228)
* JF:                                    Functions and Variables for diag.
                                                             (line   32)
* join:                                  Functions and Variables for Lists.
                                                             (line  194)
* jordan:                                Functions and Variables for diag.
                                                             (line   55)
* julia:                                 Functions and Variables for dynamics.
                                                             (line   49)
* julia_parameter:                       Definitions for complex fractals.
                                                             (line   38)
* julia_set:                             Definitions for complex fractals.
                                                             (line   21)
* julia_sin:                             Definitions for complex fractals.
                                                             (line   46)
* kdels:                                 Functions and Variables for itensor.
                                                             (line  354)
* kdelta:                                Functions and Variables for itensor.
                                                             (line  341)
* keepfloat:                             Functions and Variables for Polynomials.
                                                             (line  621)
* key:                                   Functions and Variables for draw.
                                                             (line  968)
* kill:                                  Functions and Variables for Command Line.
                                                             (line  261)
* kill <1>:                              Functions and Variables for Command Line.
                                                             (line  262)
* kill <2>:                              Functions and Variables for Command Line.
                                                             (line  263)
* kill <3>:                              Functions and Variables for Command Line.
                                                             (line  264)
* kill <4>:                              Functions and Variables for Command Line.
                                                             (line  265)
* kill <5>:                              Functions and Variables for Command Line.
                                                             (line  266)
* kill <6>:                              Functions and Variables for Command Line.
                                                             (line  267)
* kill <7>:                              Functions and Variables for Command Line.
                                                             (line  268)
* killcontext:                           Functions and Variables for Facts.
                                                             (line  335)
* kinvariant:                            Functions and Variables for ctensor.
                                                             (line 1133)
* kostka:                                Functions and Variables for Symmetries.
                                                             (line  421)
* kron_delta:                            Functions and Variables for Sets.
                                                             (line  468)
* kronecker_product:                     Functions and Variables for linearalgebra.
                                                             (line  250)
* kt:                                    Functions and Variables for ctensor.
                                                             (line 1160)
* kummer_m:                              Functions and Variables for contrib_ode.
                                                             (line  104)
* kummer_u:                              Functions and Variables for contrib_ode.
                                                             (line  115)
* kurtosis:                              Functions and Variables for descriptive statistics.
                                                             (line  375)
* kurtosis <1>:                          Functions and Variables for descriptive statistics.
                                                             (line  376)
* kurtosis_bernoulli:                    Functions and Variables for discrete distributions.
                                                             (line  274)
* kurtosis_beta:                         Functions and Variables for continuous distributions.
                                                             (line  799)
* kurtosis_binomial:                     Functions and Variables for discrete distributions.
                                                             (line  127)
* kurtosis_chi2:                         Functions and Variables for continuous distributions.
                                                             (line  348)
* kurtosis_continuous_uniform:           Functions and Variables for continuous distributions.
                                                             (line  851)
* kurtosis_discrete_uniform:             Functions and Variables for discrete distributions.
                                                             (line  382)
* kurtosis_exp:                          Functions and Variables for continuous distributions.
                                                             (line  613)
* kurtosis_f:                            Functions and Variables for continuous distributions.
                                                             (line  475)
* kurtosis_gamma:                        Functions and Variables for continuous distributions.
                                                             (line  740)
* kurtosis_general_finite_discrete:      Functions and Variables for discrete distributions.
                                                             (line   67)
* kurtosis_geometric:                    Functions and Variables for discrete distributions.
                                                             (line  333)
* kurtosis_gumbel:                       Functions and Variables for continuous distributions.
                                                             (line 1277)
* kurtosis_hypergeometric:               Functions and Variables for discrete distributions.
                                                             (line  435)
* kurtosis_laplace:                      Functions and Variables for continuous distributions.
                                                             (line 1194)
* kurtosis_logistic:                     Functions and Variables for continuous distributions.
                                                             (line  897)
* kurtosis_lognormal:                    Functions and Variables for continuous distributions.
                                                             (line  688)
* kurtosis_negative_binomial:            Functions and Variables for discrete distributions.
                                                             (line  497)
* kurtosis_noncentral_chi2:              Functions and Variables for continuous distributions.
                                                             (line  413)
* kurtosis_noncentral_student_t:         Functions and Variables for continuous distributions.
                                                             (line  212)
* kurtosis_normal:                       Functions and Variables for continuous distributions.
                                                             (line   55)
* kurtosis_pareto:                       Functions and Variables for continuous distributions.
                                                             (line  943)
* kurtosis_poisson:                      Functions and Variables for discrete distributions.
                                                             (line  180)
* kurtosis_rayleigh:                     Functions and Variables for continuous distributions.
                                                             (line 1131)
* kurtosis_student_t:                    Functions and Variables for continuous distributions.
                                                             (line  118)
* kurtosis_weibull:                      Functions and Variables for continuous distributions.
                                                             (line  988)
* label:                                 Functions and Variables for draw.
                                                             (line 2641)
* label <1>:                             Functions and Variables for draw.
                                                             (line 2642)
* label_alignment:                       Functions and Variables for draw.
                                                             (line  990)
* label_alignment <1>:                   Functions and Variables for graphs.
                                                             (line 1385)
* label_orientation:                     Functions and Variables for draw.
                                                             (line 1015)
* labels:                                Functions and Variables for Command Line.
                                                             (line  324)
* labels <1>:                            Functions and Variables for Command Line.
                                                             (line  325)
* lagrange:                              Functions and Variables for interpol.
                                                             (line    6)
* lagrange <1>:                          Functions and Variables for interpol.
                                                             (line    7)
* laguerre:                              Functions and Variables for orthogonal polynomials.
                                                             (line   49)
* lambda:                                Functions and Variables for Function Definition.
                                                             (line  597)
* lambda <1>:                            Functions and Variables for Function Definition.
                                                             (line  598)
* lambda <2>:                            Functions and Variables for Function Definition.
                                                             (line  599)
* lambert_w:                             Functions and Variables for Special Functions.
                                                             (line  143)
* laplace:                               Functions and Variables for Differentiation.
                                                             (line  536)
* laplacian_matrix:                      Functions and Variables for graphs.
                                                             (line  736)
* lassociative:                          Functions and Variables for Simplification.
                                                             (line  283)
* last:                                  Functions and Variables for Lists.
                                                             (line  213)
* lbfgs:                                 Functions and Variables for lbfgs.
                                                             (line    6)
* lbfgs <1>:                             Functions and Variables for lbfgs.
                                                             (line    7)
* lbfgs_ncorrections:                    Functions and Variables for lbfgs.
                                                             (line  266)
* lbfgs_nfeval_max:                      Functions and Variables for lbfgs.
                                                             (line  259)
* lc_l:                                  Functions and Variables for itensor.
                                                             (line  447)
* lc_u:                                  Functions and Variables for itensor.
                                                             (line  471)
* lc2kdt:                                Functions and Variables for itensor.
                                                             (line  379)
* lcharp:                                Functions and Variables for characters.
                                                             (line   66)
* lcm:                                   Functions and Variables for Number Theory.
                                                             (line  308)
* ldefint:                               Functions and Variables for Integration.
                                                             (line  460)
* ldisp:                                 Functions and Variables for Display.
                                                             (line  318)
* ldisplay:                              Functions and Variables for Display.
                                                             (line  350)
* legend:                                Plotting Options.   (line   89)
* legend <1>:                            Plotting Options.   (line   90)
* legendre_p:                            Functions and Variables for orthogonal polynomials.
                                                             (line   55)
* legendre_q:                            Functions and Variables for orthogonal polynomials.
                                                             (line   61)
* leinstein:                             Functions and Variables for ctensor.
                                                             (line  209)
* length:                                Functions and Variables for Lists.
                                                             (line  216)
* let:                                   Functions and Variables for Rules and Patterns.
                                                             (line  210)
* let <1>:                               Functions and Variables for Rules and Patterns.
                                                             (line  211)
* let_rule_packages:                     Functions and Variables for Rules and Patterns.
                                                             (line  337)
* letrat:                                Functions and Variables for Rules and Patterns.
                                                             (line  284)
* letrules:                              Functions and Variables for Rules and Patterns.
                                                             (line  306)
* letrules <1>:                          Functions and Variables for Rules and Patterns.
                                                             (line  307)
* letsimp:                               Functions and Variables for Rules and Patterns.
                                                             (line  320)
* letsimp <1>:                           Functions and Variables for Rules and Patterns.
                                                             (line  321)
* letsimp <2>:                           Functions and Variables for Rules and Patterns.
                                                             (line  322)
* levi_civita:                           Functions and Variables for itensor.
                                                             (line  374)
* lfg:                                   Functions and Variables for ctensor.
                                                             (line 1084)
* lfreeof:                               Functions and Variables for Expressions.
                                                             (line  441)
* lg:                                    Functions and Variables for ctensor.
                                                             (line 1116)
* lgtreillis:                            Functions and Variables for Symmetries.
                                                             (line  428)
* lhospitallim:                          Functions and Variables for Limits.
                                                             (line    6)
* lhs:                                   Functions and Variables for Equations.
                                                             (line  439)
* li:                                    Root Exponential and Logarithmic Functions.
                                                             (line   56)
* liediff:                               Functions and Variables for itensor.
                                                             (line  604)
* limit:                                 Functions and Variables for Limits.
                                                             (line   13)
* limit <1>:                             Functions and Variables for Limits.
                                                             (line   14)
* limit <2>:                             Functions and Variables for Limits.
                                                             (line   15)
* limsubst:                              Functions and Variables for Limits.
                                                             (line   54)
* Lindstedt:                             Functions and Variables for lindstedt.
                                                             (line    6)
* line_graph:                            Functions and Variables for graphs.
                                                             (line  181)
* line_type:                             Functions and Variables for draw.
                                                             (line 1040)
* line_width:                            Functions and Variables for draw.
                                                             (line 1063)
* linear:                                Functions and Variables for Simplification.
                                                             (line  289)
* linear <1>:                            Package functs.     (line   42)
* linear_program:                        Functions and Variables for simplex.
                                                             (line   13)
* linear_solver:                         Functions and Variables for zeilberger.
                                                             (line  109)
* linearinterpol:                        Functions and Variables for interpol.
                                                             (line  105)
* linearinterpol <1>:                    Functions and Variables for interpol.
                                                             (line  106)
* linechar:                              Functions and Variables for Command Line.
                                                             (line  359)
* linel:                                 Functions and Variables for Display.
                                                             (line  383)
* linenum:                               Functions and Variables for Command Line.
                                                             (line  375)
* linsolve:                              Functions and Variables for Equations.
                                                             (line  480)
* linsolve_params:                       Functions and Variables for Equations.
                                                             (line  554)
* linsolvewarn:                          Functions and Variables for Equations.
                                                             (line  548)
* lispdisp:                              Functions and Variables for Display.
                                                             (line  392)
* List delimiters:                       Functions and Variables for Lists.
                                                             (line    8)
* list_correlations:                     Functions and Variables for descriptive statistics.
                                                             (line  606)
* list_correlations <1>:                 Functions and Variables for descriptive statistics.
                                                             (line  607)
* list_matrix_entries:                   Functions and Variables for Matrices and Linear Algebra.
                                                             (line  691)
* list_nc_monomials:                     Functions and Variables for Affine.
                                                             (line  110)
* list_nc_monomials <1>:                 Functions and Variables for Affine.
                                                             (line  111)
* listarith:                             Functions and Variables for Lists.
                                                             (line  227)
* listarray:                             Functions and Variables for Arrays.
                                                             (line  250)
* listconstvars:                         Functions and Variables for Expressions.
                                                             (line  399)
* listdummyvars:                         Functions and Variables for Expressions.
                                                             (line  407)
* listify:                               Functions and Variables for Sets.
                                                             (line  491)
* listoftens:                            Functions and Variables for itensor.
                                                             (line   30)
* listofvars:                            Functions and Variables for Expressions.
                                                             (line  425)
* listp:                                 Functions and Variables for Lists.
                                                             (line  233)
* listp <1>:                             Functions and Variables for linearalgebra.
                                                             (line  254)
* listp <2>:                             Functions and Variables for linearalgebra.
                                                             (line  255)
* lmax:                                  Functions for Numbers.
                                                             (line  101)
* lmin:                                  Functions for Numbers.
                                                             (line  106)
* lmxchar:                               Functions and Variables for Matrices and Linear Algebra.
                                                             (line  700)
* load:                                  Functions and Variables for File Input and Output.
                                                             (line  227)
* load_pathname:                         Functions and Variables for File Input and Output.
                                                             (line  257)
* loadfile:                              Functions and Variables for File Input and Output.
                                                             (line  283)
* loadprint:                             Functions and Variables for File Input and Output.
                                                             (line  294)
* local:                                 Functions and Variables for Function Definition.
                                                             (line  715)
* locate_matrix_entry:                   Functions and Variables for linearalgebra.
                                                             (line  263)
* log:                                   Root Exponential and Logarithmic Functions.
                                                             (line  113)
* log_gamma:                             Gamma and factorial Functions.
                                                             (line  114)
* logabs:                                Root Exponential and Logarithmic Functions.
                                                             (line  149)
* logarc:                                Root Exponential and Logarithmic Functions.
                                                             (line  157)
* logarc <1>:                            Root Exponential and Logarithmic Functions.
                                                             (line  158)
* logcb:                                 Functions and Variables for draw.
                                                             (line 1086)
* logconcoeffp:                          Root Exponential and Logarithmic Functions.
                                                             (line  167)
* logcontract:                           Root Exponential and Logarithmic Functions.
                                                             (line  176)
* logexpand:                             Root Exponential and Logarithmic Functions.
                                                             (line  195)
* Logical conjunction:                   Functions and Variables for to_poly_solve.
                                                             (line   15)
* Logical disjunction:                   Functions and Variables for to_poly_solve.
                                                             (line  120)
* lognegint:                             Root Exponential and Logarithmic Functions.
                                                             (line  205)
* lognumer:                              Root Exponential and Logarithmic Functions.
                                                             (line  211)
* logsimp:                               Root Exponential and Logarithmic Functions.
                                                             (line  218)
* logx:                                  Plotting Options.   (line   99)
* logx <1>:                              Functions and Variables for draw.
                                                             (line 1111)
* logy:                                  Plotting Options.   (line  104)
* logy <1>:                              Functions and Variables for draw.
                                                             (line 1127)
* logz:                                  Functions and Variables for draw.
                                                             (line 1143)
* lopow:                                 Functions and Variables for Polynomials.
                                                             (line  650)
* lorentz_gauge:                         Functions and Variables for itensor.
                                                             (line  907)
* lowercasep:                            Functions and Variables for characters.
                                                             (line   70)
* lpart:                                 Functions and Variables for Expressions.
                                                             (line  447)
* lratsubst:                             Functions and Variables for Polynomials.
                                                             (line  657)
* lreduce:                               Functions and Variables for Sets.
                                                             (line  505)
* lreduce <1>:                           Functions and Variables for Sets.
                                                             (line  506)
* lriem:                                 Functions and Variables for ctensor.
                                                             (line 1100)
* lriemann:                              Functions and Variables for ctensor.
                                                             (line  235)
* lsquares_estimates:                    Functions and Variables for lsquares.
                                                             (line    6)
* lsquares_estimates <1>:                Functions and Variables for lsquares.
                                                             (line    7)
* lsquares_estimates_approximate:        Functions and Variables for lsquares.
                                                             (line  145)
* lsquares_estimates_exact:              Functions and Variables for lsquares.
                                                             (line   96)
* lsquares_mse:                          Functions and Variables for lsquares.
                                                             (line  206)
* lsquares_residual_mse:                 Functions and Variables for lsquares.
                                                             (line  324)
* lsquares_residuals:                    Functions and Variables for lsquares.
                                                             (line  275)
* lsum:                                  Sums and Products.  (line   14)
* ltreillis:                             Functions and Variables for Symmetries.
                                                             (line  435)
* lu_backsub:                            Functions and Variables for linearalgebra.
                                                             (line  288)
* lu_factor:                             Functions and Variables for linearalgebra.
                                                             (line  293)
* m1pbranch:                             Functions and Variables for Numbers.
                                                             (line  112)
* macroexpand:                           Macros.             (line   93)
* macroexpand1:                          Macros.             (line  125)
* macroexpansion:                        Functions and Variables for Function Definition.
                                                             (line  745)
* macros:                                Macros.             (line  155)
* mainvar:                               Functions and Variables for Expressions.
                                                             (line  453)
* make_array:                            Functions and Variables for Arrays.
                                                             (line  338)
* make_graph:                            Functions and Variables for graphs.
                                                             (line  184)
* make_graph <1>:                        Functions and Variables for graphs.
                                                             (line  185)
* make_level_picture:                    Functions and Variables for pictures.
                                                             (line   10)
* make_level_picture <1>:                Functions and Variables for pictures.
                                                             (line   11)
* make_poly_continent:                   Functions and Variables for worldmap.
                                                             (line   35)
* make_poly_continent <1>:               Functions and Variables for worldmap.
                                                             (line   36)
* make_poly_country:                     Functions and Variables for worldmap.
                                                             (line   50)
* make_polygon:                          Functions and Variables for worldmap.
                                                             (line   60)
* make_random_state:                     Random Numbers.     (line    6)
* make_random_state <1>:                 Random Numbers.     (line    7)
* make_random_state <2>:                 Random Numbers.     (line    8)
* make_random_state <3>:                 Random Numbers.     (line    9)
* make_rgb_picture:                      Functions and Variables for pictures.
                                                             (line   39)
* make_transform:                        Functions and Variables for Plotting.
                                                             (line   43)
* makebox:                               Functions and Variables for itensor.
                                                             (line  723)
* makefact:                              Gamma and factorial Functions.
                                                             (line  691)
* makegamma:                             Gamma and factorial Functions.
                                                             (line  160)
* makelist:                              Functions and Variables for Lists.
                                                             (line  237)
* makelist <1>:                          Functions and Variables for Lists.
                                                             (line  238)
* makeOrders:                            Functions and Variables for makeOrders.
                                                             (line    6)
* makeset:                               Functions and Variables for Sets.
                                                             (line  546)
* mandelbrot:                            Functions and Variables for dynamics.
                                                             (line   71)
* mandelbrot_set:                        Definitions for complex fractals.
                                                             (line    6)
* manual_demo:                           Functions and Variables for Help.
                                                             (line  168)
* map:                                   Functions and Variables for Program Flow.
                                                             (line  413)
* mapatom:                               Functions and Variables for Program Flow.
                                                             (line  448)
* maperror:                              Functions and Variables for Program Flow.
                                                             (line  453)
* maplist:                               Functions and Variables for Program Flow.
                                                             (line  478)
* mapprint:                              Functions and Variables for Program Flow.
                                                             (line  469)
* mat_cond:                              Functions and Variables for linearalgebra.
                                                             (line  389)
* mat_cond <1>:                          Functions and Variables for linearalgebra.
                                                             (line  390)
* mat_fullunblocker:                     Functions and Variables for linearalgebra.
                                                             (line  420)
* mat_function:                          Functions and Variables for diag.
                                                             (line  180)
* mat_norm:                              Functions and Variables for linearalgebra.
                                                             (line  398)
* mat_norm <1>:                          Functions and Variables for linearalgebra.
                                                             (line  399)
* mat_norm <2>:                          Functions and Variables for linearalgebra.
                                                             (line  400)
* mat_trace:                             Functions and Variables for linearalgebra.
                                                             (line  426)
* mat_unblocker:                         Functions and Variables for linearalgebra.
                                                             (line  432)
* matchdeclare:                          Functions and Variables for Rules and Patterns.
                                                             (line  344)
* matchfix:                              User defined operators.
                                                             (line   93)
* matchfix <1>:                          User defined operators.
                                                             (line   94)
* matrix:                                Functions and Variables for Matrices and Linear Algebra.
                                                             (line  716)
* matrix_element_add:                    Functions and Variables for Matrices and Linear Algebra.
                                                             (line  849)
* matrix_element_mult:                   Functions and Variables for Matrices and Linear Algebra.
                                                             (line  880)
* matrix_element_transpose:              Functions and Variables for Matrices and Linear Algebra.
                                                             (line  921)
* matrix_size:                           Functions and Variables for linearalgebra.
                                                             (line  416)
* matrixmap:                             Functions and Variables for Matrices and Linear Algebra.
                                                             (line  837)
* matrixp:                               Functions and Variables for Matrices and Linear Algebra.
                                                             (line  844)
* matrixp <1>:                           Functions and Variables for linearalgebra.
                                                             (line  406)
* matrixp <2>:                           Functions and Variables for linearalgebra.
                                                             (line  407)
* mattrace:                              Functions and Variables for Matrices and Linear Algebra.
                                                             (line  970)
* max:                                   Functions for Numbers.
                                                             (line  111)
* max_clique:                            Functions and Variables for graphs.
                                                             (line  752)
* max_degree:                            Functions and Variables for graphs.
                                                             (line  761)
* max_flow:                              Functions and Variables for graphs.
                                                             (line  772)
* max_independent_set:                   Functions and Variables for graphs.
                                                             (line  802)
* max_matching:                          Functions and Variables for graphs.
                                                             (line  812)
* MAX_ORD:                               Functions and Variables for zeilberger.
                                                             (line   98)
* maxapplydepth:                         Functions and Variables for Rules and Patterns.
                                                             (line  490)
* maxapplyheight:                        Functions and Variables for Rules and Patterns.
                                                             (line  495)
* maxima_tempdir:                        Functions and Variables for Runtime Environment.
                                                             (line   33)
* maxima_userdir:                        Functions and Variables for Runtime Environment.
                                                             (line   46)
* maximize_lp:                           Functions and Variables for simplex.
                                                             (line   40)
* maxnegex:                              Functions and Variables for Simplification.
                                                             (line  301)
* maxposex:                              Functions and Variables for Simplification.
                                                             (line  307)
* maxpsifracdenom:                       Gamma and factorial Functions.
                                                             (line  684)
* maxpsifracnum:                         Gamma and factorial Functions.
                                                             (line  677)
* maxpsinegint:                          Gamma and factorial Functions.
                                                             (line  670)
* maxpsiposint:                          Gamma and factorial Functions.
                                                             (line  664)
* maxtayorder:                           Functions and Variables for Series.
                                                             (line   69)
* maybe:                                 Functions and Variables for Facts.
                                                             (line  352)
* mean:                                  Functions and Variables for descriptive statistics.
                                                             (line    6)
* mean <1>:                              Functions and Variables for descriptive statistics.
                                                             (line    7)
* mean_bernoulli:                        Functions and Variables for discrete distributions.
                                                             (line  220)
* mean_beta:                             Functions and Variables for continuous distributions.
                                                             (line  783)
* mean_binomial:                         Functions and Variables for discrete distributions.
                                                             (line  109)
* mean_chi2:                             Functions and Variables for continuous distributions.
                                                             (line  286)
* mean_continuous_uniform:               Functions and Variables for continuous distributions.
                                                             (line  831)
* mean_deviation:                        Functions and Variables for descriptive statistics.
                                                             (line  273)
* mean_deviation <1>:                    Functions and Variables for descriptive statistics.
                                                             (line  274)
* mean_discrete_uniform:                 Functions and Variables for discrete distributions.
                                                             (line  361)
* mean_exp:                              Functions and Variables for continuous distributions.
                                                             (line  546)
* mean_f:                                Functions and Variables for continuous distributions.
                                                             (line  459)
* mean_gamma:                            Functions and Variables for continuous distributions.
                                                             (line  724)
* mean_general_finite_discrete:          Functions and Variables for discrete distributions.
                                                             (line   47)
* mean_geometric:                        Functions and Variables for discrete distributions.
                                                             (line  317)
* mean_gumbel:                           Functions and Variables for continuous distributions.
                                                             (line 1247)
* mean_hypergeometric:                   Functions and Variables for discrete distributions.
                                                             (line  415)
* mean_laplace:                          Functions and Variables for continuous distributions.
                                                             (line 1178)
* mean_logistic:                         Functions and Variables for continuous distributions.
                                                             (line  881)
* mean_lognormal:                        Functions and Variables for continuous distributions.
                                                             (line  672)
* mean_negative_binomial:                Functions and Variables for discrete distributions.
                                                             (line  476)
* mean_noncentral_chi2:                  Functions and Variables for continuous distributions.
                                                             (line  397)
* mean_noncentral_student_t:             Functions and Variables for continuous distributions.
                                                             (line  182)
* mean_normal:                           Functions and Variables for continuous distributions.
                                                             (line   38)
* mean_pareto:                           Functions and Variables for continuous distributions.
                                                             (line  927)
* mean_poisson:                          Functions and Variables for discrete distributions.
                                                             (line  164)
* mean_rayleigh:                         Functions and Variables for continuous distributions.
                                                             (line 1053)
* mean_student_t:                        Functions and Variables for continuous distributions.
                                                             (line   95)
* mean_weibull:                          Functions and Variables for continuous distributions.
                                                             (line  972)
* median:                                Functions and Variables for descriptive statistics.
                                                             (line  234)
* median <1>:                            Functions and Variables for descriptive statistics.
                                                             (line  235)
* median_deviation:                      Functions and Variables for descriptive statistics.
                                                             (line  299)
* median_deviation <1>:                  Functions and Variables for descriptive statistics.
                                                             (line  300)
* member:                                Functions and Variables for Lists.
                                                             (line  257)
* mesh:                                  Functions and Variables for draw.
                                                             (line 2681)
* mesh_lines_color:                      Plotting Options.   (line  109)
* method:                                Functions and Variables for contrib_ode.
                                                             (line   67)
* metricexpandall:                       Functions and Variables for Units.
                                                             (line  383)
* min:                                   Functions for Numbers.
                                                             (line  120)
* min_degree:                            Functions and Variables for graphs.
                                                             (line  823)
* min_edge_cut:                          Functions and Variables for graphs.
                                                             (line  834)
* min_vertex_cover:                      Functions and Variables for graphs.
                                                             (line  839)
* min_vertex_cut:                        Functions and Variables for graphs.
                                                             (line  842)
* minf:                                  Functions and Variables for Constants.
                                                             (line   42)
* minfactorial:                          Combinatorial Functions.
                                                             (line  151)
* minimalPoly:                           Functions and Variables for diag.
                                                             (line  123)
* minimize_lp:                           Functions and Variables for simplex.
                                                             (line   48)
* minimum_spanning_tree:                 Functions and Variables for graphs.
                                                             (line  848)
* minor:                                 Functions and Variables for Matrices and Linear Algebra.
                                                             (line  979)
* minpack_lsquares:                      Functions and Variables for minpack.
                                                             (line    6)
* minpack_solve:                         Functions and Variables for minpack.
                                                             (line   62)
* Minus infinity:                        Functions and Variables for Constants.
                                                             (line   43)
* mnewton:                               Functions and Variables for mnewton.
                                                             (line   21)
* mod:                                   Functions and Variables for Number Theory.
                                                             (line  315)
* mod_big_prime:                         Functions and Variables for zeilberger.
                                                             (line  155)
* mod_test:                              Functions and Variables for zeilberger.
                                                             (line  137)
* mod_threshold:                         Functions and Variables for zeilberger.
                                                             (line  160)
* mode_check_errorp:                     Functions and Variables for Function Definition.
                                                             (line  881)
* mode_check_warnp:                      Functions and Variables for Function Definition.
                                                             (line  887)
* mode_checkp:                           Functions and Variables for Function Definition.
                                                             (line  875)
* mode_declare:                          Functions and Variables for Function Definition.
                                                             (line  892)
* mode_identity:                         Functions and Variables for Function Definition.
                                                             (line  934)
* ModeMatrix:                            Functions and Variables for diag.
                                                             (line  144)
* modular_linear_solver:                 Functions and Variables for zeilberger.
                                                             (line  143)
* modulus:                               Functions and Variables for Polynomials.
                                                             (line  682)
* moebius:                               Functions and Variables for Sets.
                                                             (line  580)
* mon2schur:                             Functions and Variables for Symmetries.
                                                             (line   57)
* mono:                                  Functions and Variables for Affine.
                                                             (line   90)
* monomial_dimensions:                   Functions and Variables for Affine.
                                                             (line   96)
* multi_elem:                            Functions and Variables for Symmetries.
                                                             (line   82)
* multi_orbit:                           Functions and Variables for Symmetries.
                                                             (line  332)
* multi_pui:                             Functions and Variables for Symmetries.
                                                             (line   97)
* multibernstein_poly:                   Functions and Variables for Bernstein.
                                                             (line   63)
* multinomial:                           Functions and Variables for Symmetries.
                                                             (line  800)
* multinomial_coeff:                     Functions and Variables for Sets.
                                                             (line  613)
* multinomial_coeff <1>:                 Functions and Variables for Sets.
                                                             (line  614)
* multiplicative:                        Functions and Variables for Simplification.
                                                             (line  313)
* multiplicities:                        Functions and Variables for Equations.
                                                             (line  562)
* multiplot_mode:                        Functions and Variables for draw.
                                                             (line  135)
* multsym:                               Functions and Variables for Symmetries.
                                                             (line  344)
* multthru:                              Functions and Variables for Simplification.
                                                             (line  329)
* multthru <1>:                          Functions and Variables for Simplification.
                                                             (line  330)
* mycielski_graph:                       Functions and Variables for graphs.
                                                             (line  213)
* myoptions:                             Functions and Variables for Command Line.
                                                             (line  379)
* N'th previous output:                  Functions and Variables for Command Line.
                                                             (line  145)
* nary:                                  Functions and Variables for Simplification.
                                                             (line  372)
* nary <1>:                              User defined operators.
                                                             (line  190)
* nary <2>:                              User defined operators.
                                                             (line  191)
* natural_unit:                          Functions and Variables for ezunits.
                                                             (line  682)
* nc_degree:                             Functions and Variables for Affine.
                                                             (line   56)
* ncexpt:                                Functions and Variables for Display.
                                                             (line  136)
* ncharpoly:                             Functions and Variables for Matrices and Linear Algebra.
                                                             (line  984)
* Negative infinity:                     Functions and Variables for Constants.
                                                             (line   43)
* negative_picture:                      Functions and Variables for pictures.
                                                             (line   65)
* negdistrib:                            Functions and Variables for Simplification.
                                                             (line  392)
* negsumdispflag:                        Functions and Variables for Display.
                                                             (line  408)
* neighbors:                             Functions and Variables for graphs.
                                                             (line  857)
* new:                                   Functions and Variables for Structures.
                                                             (line   49)
* new <1>:                               Functions and Variables for Structures.
                                                             (line   50)
* new_graph:                             Functions and Variables for graphs.
                                                             (line  216)
* new_variable:                          Functions and Variables for to_poly_solve.
                                                             (line  496)
* newcontext:                            Functions and Variables for Facts.
                                                             (line  375)
* newdet:                                Functions and Variables for Matrices and Linear Algebra.
                                                             (line  998)
* newline:                               Functions and Variables for characters.
                                                             (line   73)
* newline <1>:                           Functions and Variables for input and output.
                                                             (line   43)
* newline <2>:                           Functions and Variables for input and output.
                                                             (line   44)
* newton:                                Functions and Variables for fast Fourier transform.
                                                             (line  366)
* newtonepsilon:                         Functions and Variables for mnewton.
                                                             (line    6)
* newtonmaxiter:                         Functions and Variables for mnewton.
                                                             (line   13)
* next_prime:                            Functions and Variables for Number Theory.
                                                             (line  342)
* nextlayerfactor:                       Package facexp.     (line   53)
* nicedummies:                           Functions and Variables for to_poly_solve.
                                                             (line  539)
* niceindices:                           Functions and Variables for Series.
                                                             (line   76)
* niceindicespref:                       Functions and Variables for Series.
                                                             (line  109)
* ninth:                                 Functions and Variables for Lists.
                                                             (line  293)
* nm:                                    Functions and Variables for ctensor.
                                                             (line 1164)
* nmc:                                   Functions and Variables for ctensor.
                                                             (line 1168)
* noeval:                                Functions and Variables for Evaluation.
                                                             (line  549)
* nofix:                                 User defined operators.
                                                             (line  202)
* nofix <1>:                             User defined operators.
                                                             (line  203)
* nolabels:                              Functions and Variables for Command Line.
                                                             (line  385)
* nonarray:                              Functions and Variables for Properties.
                                                             (line  362)
* noncentral_moment:                     Functions and Variables for descriptive statistics.
                                                             (line  109)
* noncentral_moment <1>:                 Functions and Variables for descriptive statistics.
                                                             (line  110)
* nonegative_lp:                         Functions and Variables for simplex.
                                                             (line   88)
* nonmetricity:                          Functions and Variables for ctensor.
                                                             (line  607)
* nonnegintegerp:                        Functions and Variables for Numbers.
                                                             (line  128)
* nonscalar:                             Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1003)
* nonscalarp:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1008)
* nonzeroandfreeof:                      Package functs.     (line   36)
* not:                                   Logical operators.  (line   27)
* notequal:                              Functions and Variables for Predicates.
                                                             (line  185)
* noun:                                  Functions and Variables for Expressions.
                                                             (line  465)
* noundisp:                              Functions and Variables for Expressions.
                                                             (line  471)
* nounify:                               Functions and Variables for Expressions.
                                                             (line  477)
* nouns:                                 Functions and Variables for Evaluation.
                                                             (line  555)
* np:                                    Functions and Variables for ctensor.
                                                             (line 1137)
* npi:                                   Functions and Variables for ctensor.
                                                             (line 1141)
* nptetrad:                              Functions and Variables for ctensor.
                                                             (line  435)
* npv:                                   Functions and Variables for finance.
                                                             (line  201)
* nroots:                                Functions and Variables for Equations.
                                                             (line  568)
* nterms:                                Functions and Variables for Expressions.
                                                             (line  487)
* ntermst:                               Functions and Variables for ctensor.
                                                             (line  767)
* nthroot:                               Functions and Variables for Equations.
                                                             (line  580)
* nticks:                                Plotting Options.   (line  118)
* nticks <1>:                            Functions and Variables for draw.
                                                             (line 1159)
* ntrig:                                 Functions and Variables for Trigonometric.
                                                             (line  193)
* nullity:                               Functions and Variables for linearalgebra.
                                                             (line  473)
* nullspace:                             Functions and Variables for linearalgebra.
                                                             (line  466)
* num:                                   Functions and Variables for Polynomials.
                                                             (line  703)
* num_distinct_partitions:               Functions and Variables for Sets.
                                                             (line  647)
* num_distinct_partitions <1>:           Functions and Variables for Sets.
                                                             (line  648)
* num_partitions:                        Functions and Variables for Sets.
                                                             (line  668)
* num_partitions <1>:                    Functions and Variables for Sets.
                                                             (line  669)
* numbered_boundaries:                   Functions and Variables for worldmap.
                                                             (line   22)
* numberp:                               Functions and Variables for Numbers.
                                                             (line  132)
* numer:                                 Functions and Variables for Numbers.
                                                             (line  160)
* numer_pbranch:                         Functions and Variables for Numbers.
                                                             (line  178)
* numerval:                              Functions and Variables for Numbers.
                                                             (line  204)
* numfactor:                             Gamma and factorial Functions.
                                                             (line  697)
* nusum:                                 Functions and Variables for Series.
                                                             (line  138)
* nzeta:                                 Functions and Variables for Special Functions.
                                                             (line  146)
* nzetai:                                Functions and Variables for Special Functions.
                                                             (line  152)
* nzetar:                                Functions and Variables for Special Functions.
                                                             (line  149)
* obase:                                 Functions and Variables for Display.
                                                             (line  416)
* odd_girth:                             Functions and Variables for graphs.
                                                             (line  866)
* oddfun:                                Functions and Variables for Simplification.
                                                             (line  127)
* oddp:                                  Functions and Variables for Numbers.
                                                             (line  213)
* ode_check:                             Functions and Variables for contrib_ode.
                                                             (line   38)
* ode2:                                  Functions and Variables for Differential Equations.
                                                             (line   82)
* odelin:                                Functions and Variables for contrib_ode.
                                                             (line   10)
* op:                                    Functions and Variables for Expressions.
                                                             (line  494)
* opena:                                 Functions and Variables for input and output.
                                                             (line   49)
* opena_binary:                          Functions and Variables for binary input and output.
                                                             (line   24)
* openr:                                 Functions and Variables for input and output.
                                                             (line   53)
* openr_binary:                          Functions and Variables for binary input and output.
                                                             (line   16)
* openw:                                 Functions and Variables for input and output.
                                                             (line   57)
* openw_binary:                          Functions and Variables for binary input and output.
                                                             (line   20)
* operatorp:                             Functions and Variables for Expressions.
                                                             (line  541)
* operatorp <1>:                         Functions and Variables for Expressions.
                                                             (line  542)
* opproperties:                          Functions and Variables for Simplification.
                                                             (line  402)
* opsubst:                               Functions and Variables for Expressions.
                                                             (line  550)
* opsubst <1>:                           Functions and Variables for opsubst.
                                                             (line    6)
* opsubst <2>:                           Functions and Variables for opsubst.
                                                             (line    7)
* opsubst <3>:                           Functions and Variables for opsubst.
                                                             (line    8)
* optimize:                              Functions and Variables for Expressions.
                                                             (line  557)
* optimprefix:                           Functions and Variables for Expressions.
                                                             (line  564)
* optionset:                             Functions and Variables for Command Line.
                                                             (line  404)
* or:                                    Logical operators.  (line   40)
* orbit:                                 Functions and Variables for Symmetries.
                                                             (line  362)
* orbits:                                Functions and Variables for dynamics.
                                                             (line   92)
* ordergreat:                            Functions and Variables for Expressions.
                                                             (line  570)
* ordergreatp:                           Functions and Variables for Expressions.
                                                             (line  588)
* orderless:                             Functions and Variables for Expressions.
                                                             (line  571)
* orderlessp:                            Functions and Variables for Expressions.
                                                             (line  589)
* orthogonal_complement:                 Functions and Variables for linearalgebra.
                                                             (line  477)
* orthopoly_recur:                       Functions and Variables for orthogonal polynomials.
                                                             (line   66)
* orthopoly_returns_intervals:           Functions and Variables for orthogonal polynomials.
                                                             (line   93)
* orthopoly_weight:                      Functions and Variables for orthogonal polynomials.
                                                             (line  101)
* out_neighbors:                         Functions and Variables for graphs.
                                                             (line  877)
* outative:                              Functions and Variables for Simplification.
                                                             (line  409)
* outchar:                               Functions and Variables for Command Line.
                                                             (line  421)
* outermap:                              Functions and Variables for Program Flow.
                                                             (line  550)
* outofpois:                             Poisson series.     (line    9)
* packagefile:                           Functions and Variables for File Input and Output.
                                                             (line  308)
* pade:                                  Functions and Variables for Series.
                                                             (line  186)
* palette:                               Plotting Options.   (line  127)
* palette <1>:                           Plotting Options.   (line  129)
* palette <2>:                           Functions and Variables for draw.
                                                             (line 1179)
* parabolic_cylinder_d:                  Parabolic Cylinder Functions.
                                                             (line   12)
* parametric:                            Functions and Variables for draw.
                                                             (line 2705)
* parametric <1>:                        Functions and Variables for draw.
                                                             (line 2707)
* parametric_surface:                    Functions and Variables for draw.
                                                             (line 2747)
* parg:                                  Functions and Variables for to_poly_solve.
                                                             (line  558)
* parGosper:                             Functions and Variables for zeilberger.
                                                             (line   61)
* parse_string:                          Functions and Variables for strings.
                                                             (line   43)
* part:                                  Functions and Variables for Expressions.
                                                             (line  670)
* part2cont:                             Functions and Variables for Symmetries.
                                                             (line  229)
* partfrac:                              Functions and Variables for Number Theory.
                                                             (line  349)
* partition:                             Functions and Variables for Expressions.
                                                             (line  705)
* partition_set:                         Functions and Variables for Sets.
                                                             (line  691)
* partpol:                               Functions and Variables for Symmetries.
                                                             (line  237)
* partswitch:                            Functions and Variables for Expressions.
                                                             (line  720)
* path_digraph:                          Functions and Variables for graphs.
                                                             (line  219)
* path_graph:                            Functions and Variables for graphs.
                                                             (line  222)
* pathname_directory:                    Functions and Variables for File Input and Output.
                                                             (line  323)
* pathname_name:                         Functions and Variables for File Input and Output.
                                                             (line  324)
* pathname_type:                         Functions and Variables for File Input and Output.
                                                             (line  325)
* pdf_bernoulli:                         Functions and Variables for discrete distributions.
                                                             (line  197)
* pdf_beta:                              Functions and Variables for continuous distributions.
                                                             (line  762)
* pdf_binomial:                          Functions and Variables for discrete distributions.
                                                             (line   86)
* pdf_cauchy:                            Functions and Variables for continuous distributions.
                                                             (line 1208)
* pdf_chi2:                              Functions and Variables for continuous distributions.
                                                             (line  237)
* pdf_continuous_uniform:                Functions and Variables for continuous distributions.
                                                             (line  815)
* pdf_discrete_uniform:                  Functions and Variables for discrete distributions.
                                                             (line  345)
* pdf_exp:                               Functions and Variables for continuous distributions.
                                                             (line  495)
* pdf_f:                                 Functions and Variables for continuous distributions.
                                                             (line  426)
* pdf_gamma:                             Functions and Variables for continuous distributions.
                                                             (line  703)
* pdf_general_finite_discrete:           Functions and Variables for discrete distributions.
                                                             (line    6)
* pdf_geometric:                         Functions and Variables for discrete distributions.
                                                             (line  300)
* pdf_gumbel:                            Functions and Variables for continuous distributions.
                                                             (line 1233)
* pdf_hypergeometric:                    Functions and Variables for discrete distributions.
                                                             (line  398)
* pdf_laplace:                           Functions and Variables for continuous distributions.
                                                             (line 1163)
* pdf_logistic:                          Functions and Variables for continuous distributions.
                                                             (line  867)
* pdf_lognormal:                         Functions and Variables for continuous distributions.
                                                             (line  638)
* pdf_negative_binomial:                 Functions and Variables for discrete distributions.
                                                             (line  453)
* pdf_noncentral_chi2:                   Functions and Variables for continuous distributions.
                                                             (line  376)
* pdf_noncentral_student_t:              Functions and Variables for continuous distributions.
                                                             (line  141)
* pdf_normal:                            Functions and Variables for continuous distributions.
                                                             (line    6)
* pdf_pareto:                            Functions and Variables for continuous distributions.
                                                             (line  911)
* pdf_poisson:                           Functions and Variables for discrete distributions.
                                                             (line  144)
* pdf_rank_sum:                          Functions and Variables for special distributions.
                                                             (line   18)
* pdf_rayleigh:                          Functions and Variables for continuous distributions.
                                                             (line 1000)
* pdf_signed_rank:                       Functions and Variables for special distributions.
                                                             (line    6)
* pdf_student_t:                         Functions and Variables for continuous distributions.
                                                             (line   72)
* pdf_weibull:                           Functions and Variables for continuous distributions.
                                                             (line  957)
* pearson_skewness:                      Functions and Variables for descriptive statistics.
                                                             (line  423)
* pearson_skewness <1>:                  Functions and Variables for descriptive statistics.
                                                             (line  424)
* permanent:                             Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1013)
* permut:                                Functions and Variables for Symmetries.
                                                             (line  805)
* permutation:                           Package functs.     (line  159)
* permutations:                          Functions and Variables for Sets.
                                                             (line  711)
* petersen_graph:                        Functions and Variables for graphs.
                                                             (line  225)
* petersen_graph <1>:                    Functions and Variables for graphs.
                                                             (line  226)
* petrov:                                Functions and Variables for ctensor.
                                                             (line  476)
* pfeformat:                             Functions and Variables for Display.
                                                             (line  448)
* phi:                                   Functions and Variables for Constants.
                                                             (line   47)
* pi:                                    Functions and Variables for Constants.
                                                             (line  100)
* pickapart:                             Functions and Variables for Expressions.
                                                             (line  727)
* picture_equalp:                        Functions and Variables for pictures.
                                                             (line   68)
* picturep:                              Functions and Variables for pictures.
                                                             (line   71)
* piece:                                 Functions and Variables for Expressions.
                                                             (line  811)
* piechart:                              Functions and Variables for statistical graphs.
                                                             (line  269)
* piechart <1>:                          Functions and Variables for statistical graphs.
                                                             (line  270)
* piechart <2>:                          Functions and Variables for statistical graphs.
                                                             (line  271)
* piechart <3>:                          Functions and Variables for statistical graphs.
                                                             (line  272)
* piechart <4>:                          Functions and Variables for statistical graphs.
                                                             (line  273)
* piechart <5>:                          Functions and Variables for statistical graphs.
                                                             (line  274)
* piechart_description:                  Functions and Variables for statistical graphs.
                                                             (line  275)
* planar_embedding:                      Functions and Variables for graphs.
                                                             (line  888)
* playback:                              Functions and Variables for Command Line.
                                                             (line  444)
* playback <1>:                          Functions and Variables for Command Line.
                                                             (line  445)
* playback <2>:                          Functions and Variables for Command Line.
                                                             (line  446)
* playback <3>:                          Functions and Variables for Command Line.
                                                             (line  447)
* playback <4>:                          Functions and Variables for Command Line.
                                                             (line  448)
* playback <5>:                          Functions and Variables for Command Line.
                                                             (line  449)
* playback <6>:                          Functions and Variables for Command Line.
                                                             (line  450)
* playback <7>:                          Functions and Variables for Command Line.
                                                             (line  451)
* plog:                                  Root Exponential and Logarithmic Functions.
                                                             (line  223)
* plot_format:                           Plotting Options.   (line  151)
* plot_options:                          Functions and Variables for Plotting.
                                                             (line  304)
* plot_real_part:                        Plotting Options.   (line  161)
* plot2d:                                Functions and Variables for Plotting.
                                                             (line   60)
* plot2d <1>:                            Functions and Variables for Plotting.
                                                             (line   61)
* plot2d <2>:                            Functions and Variables for Plotting.
                                                             (line   62)
* plot3d:                                Functions and Variables for Plotting.
                                                             (line  205)
* plot3d <1>:                            Functions and Variables for Plotting.
                                                             (line  206)
* plotdf:                                Functions and Variables for plotdf.
                                                             (line    6)
* plotdf <1>:                            Functions and Variables for plotdf.
                                                             (line    7)
* plotdf <2>:                            Functions and Variables for plotdf.
                                                             (line    8)
* plotdf <3>:                            Functions and Variables for plotdf.
                                                             (line    9)
* plsquares:                             Functions and Variables for lsquares.
                                                             (line  375)
* plsquares <1>:                         Functions and Variables for lsquares.
                                                             (line  376)
* plsquares <2>:                         Functions and Variables for lsquares.
                                                             (line  377)
* pochhammer:                            Functions and Variables for orthogonal polynomials.
                                                             (line  117)
* pochhammer_max_index:                  Functions and Variables for orthogonal polynomials.
                                                             (line  147)
* point_size:                            Functions and Variables for draw.
                                                             (line 1254)
* point_type:                            Plotting Options.   (line  173)
* point_type <1>:                        Functions and Variables for draw.
                                                             (line 1275)
* points:                                Functions and Variables for draw.
                                                             (line 2777)
* points <1>:                            Functions and Variables for draw.
                                                             (line 2778)
* points <2>:                            Functions and Variables for draw.
                                                             (line 2779)
* points <3>:                            Functions and Variables for draw.
                                                             (line 2780)
* points <4>:                            Functions and Variables for draw.
                                                             (line 2782)
* points <5>:                            Functions and Variables for draw.
                                                             (line 2784)
* points <6>:                            Functions and Variables for draw.
                                                             (line 2785)
* points <7>:                            Functions and Variables for draw.
                                                             (line 2786)
* points <8>:                            Functions and Variables for draw.
                                                             (line 2787)
* points <9>:                            Functions and Variables for draw.
                                                             (line 2789)
* points <10>:                           Functions and Variables for draw.
                                                             (line 2790)
* points_joined:                         Functions and Variables for draw.
                                                             (line 1316)
* poisdiff:                              Poisson series.     (line   16)
* poisexpt:                              Poisson series.     (line   21)
* poisint:                               Poisson series.     (line   26)
* poislim:                               Poisson series.     (line   31)
* poismap:                               Poisson series.     (line   38)
* poisplus:                              Poisson series.     (line   44)
* poissimp:                              Poisson series.     (line   48)
* poisson:                               Poisson series.     (line   52)
* poissubst:                             Poisson series.     (line   56)
* poistimes:                             Poisson series.     (line   75)
* poistrim:                              Poisson series.     (line   79)
* polar:                                 Functions and Variables for draw.
                                                             (line 2937)
* polar_to_xy:                           Functions and Variables for Plotting.
                                                             (line   54)
* polarform:                             Functions for Complex Numbers.
                                                             (line   64)
* polartorect:                           Functions and Variables for fast Fourier transform.
                                                             (line    6)
* poly_add:                              Functions and Variables for grobner.
                                                             (line   80)
* poly_buchberger:                       Functions and Variables for grobner.
                                                             (line  181)
* poly_buchberger_criterion:             Functions and Variables for grobner.
                                                             (line  175)
* poly_coefficient_ring:                 Functions and Variables for grobner.
                                                             (line   15)
* poly_colon_ideal:                      Functions and Variables for grobner.
                                                             (line  228)
* poly_content:                          Functions and Variables for grobner.
                                                             (line  151)
* poly_depends_p:                        Functions and Variables for grobner.
                                                             (line  219)
* poly_elimination_ideal:                Functions and Variables for grobner.
                                                             (line  222)
* poly_elimination_order:                Functions and Variables for grobner.
                                                             (line   34)
* poly_exact_divide:                     Functions and Variables for grobner.
                                                             (line  167)
* poly_expand:                           Functions and Variables for grobner.
                                                             (line  118)
* poly_expt:                             Functions and Variables for grobner.
                                                             (line  144)
* poly_gcd:                              Functions and Variables for grobner.
                                                             (line  245)
* poly_grobner:                          Functions and Variables for grobner.
                                                             (line  211)
* poly_grobner_algorithm:                Functions and Variables for grobner.
                                                             (line   56)
* poly_grobner_debug:                    Functions and Variables for grobner.
                                                             (line   50)
* poly_grobner_equal:                    Functions and Variables for grobner.
                                                             (line  264)
* poly_grobner_member:                   Functions and Variables for grobner.
                                                             (line  283)
* poly_grobner_subsetp:                  Functions and Variables for grobner.
                                                             (line  276)
* poly_ideal_intersection:               Functions and Variables for grobner.
                                                             (line  238)
* poly_ideal_polysaturation:             Functions and Variables for grobner.
                                                             (line  320)
* poly_ideal_polysaturation1:            Functions and Variables for grobner.
                                                             (line  310)
* poly_ideal_saturation:                 Functions and Variables for grobner.
                                                             (line  301)
* poly_ideal_saturation1:                Functions and Variables for grobner.
                                                             (line  293)
* poly_lcm:                              Functions and Variables for grobner.
                                                             (line  242)
* poly_minimization:                     Functions and Variables for grobner.
                                                             (line  201)
* poly_monomial_order:                   Functions and Variables for grobner.
                                                             (line    9)
* poly_multiply:                         Functions and Variables for grobner.
                                                             (line   94)
* poly_normal_form:                      Functions and Variables for grobner.
                                                             (line  171)
* poly_normalize:                        Functions and Variables for grobner.
                                                             (line  110)
* poly_normalize_list:                   Functions and Variables for grobner.
                                                             (line  206)
* poly_polysaturation_extension:         Functions and Variables for grobner.
                                                             (line  334)
* poly_primary_elimination_order:        Functions and Variables for grobner.
                                                             (line   22)
* poly_primitive_part:                   Functions and Variables for grobner.
                                                             (line  104)
* poly_pseudo_divide:                    Functions and Variables for grobner.
                                                             (line  157)
* poly_reduced_grobner:                  Functions and Variables for grobner.
                                                             (line  215)
* poly_reduction:                        Functions and Variables for grobner.
                                                             (line  197)
* poly_return_term_list:                 Functions and Variables for grobner.
                                                             (line   43)
* poly_s_polynomial:                     Functions and Variables for grobner.
                                                             (line  100)
* poly_saturation_extension:             Functions and Variables for grobner.
                                                             (line  328)
* poly_secondary_elimination_order:      Functions and Variables for grobner.
                                                             (line   28)
* poly_subtract:                         Functions and Variables for grobner.
                                                             (line   87)
* poly_top_reduction_only:               Functions and Variables for grobner.
                                                             (line   66)
* polydecomp:                            Functions and Variables for Polynomials.
                                                             (line  710)
* polyfactor:                            Functions and Variables for Equations.
                                                             (line  586)
* polygon:                               Functions and Variables for draw.
                                                             (line 2961)
* polygon <1>:                           Functions and Variables for draw.
                                                             (line 2963)
* polymod:                               Functions and Variables for Polynomials.
                                                             (line  761)
* polymod <1>:                           Functions and Variables for Polynomials.
                                                             (line  762)
* polynome2ele:                          Functions and Variables for Symmetries.
                                                             (line  484)
* polynomialp:                           Functions and Variables for linearalgebra.
                                                             (line  484)
* polynomialp <1>:                       Functions and Variables for linearalgebra.
                                                             (line  485)
* polynomialp <2>:                       Functions and Variables for linearalgebra.
                                                             (line  486)
* polytocompanion:                       Functions and Variables for linearalgebra.
                                                             (line  523)
* pop:                                   Functions and Variables for Lists.
                                                             (line  298)
* posfun:                                Functions and Variables for Properties.
                                                             (line  382)
* postfix:                               User defined operators.
                                                             (line  213)
* postfix <1>:                           User defined operators.
                                                             (line  214)
* potential:                             Functions and Variables for Integration.
                                                             (line  474)
* power_mod:                             Functions and Variables for Number Theory.
                                                             (line  372)
* powerdisp:                             Functions and Variables for Display.
                                                             (line  469)
* powers:                                Functions and Variables for Polynomials.
                                                             (line  772)
* powerseries:                           Functions and Variables for Series.
                                                             (line  244)
* powerset:                              Functions and Variables for Sets.
                                                             (line  730)
* powerset <1>:                          Functions and Variables for Sets.
                                                             (line  731)
* pred:                                  Functions and Variables for Evaluation.
                                                             (line  563)
* prederror:                             Functions and Variables for Program Flow.
                                                             (line  486)
* prefix:                                User defined operators.
                                                             (line  223)
* prefix <1>:                            User defined operators.
                                                             (line  224)
* prev_prime:                            Functions and Variables for Number Theory.
                                                             (line  408)
* Previous input:                        Functions and Variables for Command Line.
                                                             (line   45)
* Previous output:                       Functions and Variables for Command Line.
                                                             (line   88)
* Previous result in compound expression: Functions and Variables for Command Line.
                                                             (line  101)
* primep:                                Functions and Variables for Number Theory.
                                                             (line  387)
* primep_number_of_tests:                Functions and Variables for Number Theory.
                                                             (line  403)
* print:                                 Functions and Variables for Display.
                                                             (line  478)
* print_graph:                           Functions and Variables for graphs.
                                                             (line  904)
* printf:                                Functions and Variables for input and output.
                                                             (line   62)
* printf <1>:                            Functions and Variables for input and output.
                                                             (line   63)
* printfile:                             Functions and Variables for File Input and Output.
                                                             (line  338)
* printpois:                             Poisson series.     (line   86)
* printprops:                            Functions and Variables for Properties.
                                                             (line  386)
* printprops <1>:                        Functions and Variables for Properties.
                                                             (line  387)
* printprops <2>:                        Functions and Variables for Properties.
                                                             (line  388)
* prodrac:                               Functions and Variables for Symmetries.
                                                             (line  496)
* product:                               Sums and Products.  (line   44)
* product_use_gamma:                     Functions and Variables for solve_rec.
                                                             (line  167)
* program:                               Functions and Variables for graphs.
                                                             (line 1494)
* programmode:                           Functions and Variables for Equations.
                                                             (line  595)
* prompt:                                Functions and Variables for Command Line.
                                                             (line  490)
* properties:                            Functions and Variables for Miscellaneous Options.
                                                             (line   64)
* proportional_axes:                     Functions and Variables for draw.
                                                             (line 1347)
* props:                                 Functions and Variables for Miscellaneous Options.
                                                             (line   68)
* propvars:                              Functions and Variables for Miscellaneous Options.
                                                             (line   74)
* psexpand:                              Functions and Variables for Series.
                                                             (line  288)
* psfile:                                Plotting Options.   (line  186)
* psi:                                   Gamma and factorial Functions.
                                                             (line  648)
* psi <1>:                               Functions and Variables for ctensor.
                                                             (line  456)
* psubst:                                Functions and Variables for Expressions.
                                                             (line  816)
* psubst <1>:                            Functions and Variables for Expressions.
                                                             (line  817)
* ptriangularize:                        Functions and Variables for linearalgebra.
                                                             (line  531)
* pui:                                   Functions and Variables for Symmetries.
                                                             (line  108)
* pui_direct:                            Functions and Variables for Symmetries.
                                                             (line  374)
* pui2comp:                              Functions and Variables for Symmetries.
                                                             (line  133)
* pui2ele:                               Functions and Variables for Symmetries.
                                                             (line  158)
* pui2polynome:                          Functions and Variables for Symmetries.
                                                             (line  502)
* puireduc:                              Functions and Variables for Symmetries.
                                                             (line  165)
* push:                                  Functions and Variables for Lists.
                                                             (line  311)
* put:                                   Functions and Variables for Miscellaneous Options.
                                                             (line   80)
* pv:                                    Functions and Variables for finance.
                                                             (line   27)
* qput:                                  Functions and Variables for Miscellaneous Options.
                                                             (line  105)
* qrange:                                Functions and Variables for descriptive statistics.
                                                             (line  255)
* qrange <1>:                            Functions and Variables for descriptive statistics.
                                                             (line  256)
* qty:                                   Functions and Variables for ezunits.
                                                             (line  350)
* quad_qag:                              Functions and Variables for QUADPACK.
                                                             (line    6)
* quad_qag <1>:                          Functions and Variables for QUADPACK.
                                                             (line    8)
* quad_qagi:                             Functions and Variables for QUADPACK.
                                                             (line  132)
* quad_qagi <1>:                         Functions and Variables for QUADPACK.
                                                             (line  134)
* quad_qags:                             Functions and Variables for QUADPACK.
                                                             (line   71)
* quad_qags <1>:                         Functions and Variables for QUADPACK.
                                                             (line   73)
* quad_qawc:                             Functions and Variables for QUADPACK.
                                                             (line  201)
* quad_qawc <1>:                         Functions and Variables for QUADPACK.
                                                             (line  203)
* quad_qawf:                             Functions and Variables for QUADPACK.
                                                             (line  283)
* quad_qawf <1>:                         Functions and Variables for QUADPACK.
                                                             (line  285)
* quad_qawo:                             Functions and Variables for QUADPACK.
                                                             (line  358)
* quad_qawo <1>:                         Functions and Variables for QUADPACK.
                                                             (line  360)
* quad_qaws:                             Functions and Variables for QUADPACK.
                                                             (line  437)
* quad_qaws <1>:                         Functions and Variables for QUADPACK.
                                                             (line  439)
* quadrilateral:                         Functions and Variables for draw.
                                                             (line 2987)
* quantile:                              Functions and Variables for descriptive statistics.
                                                             (line  215)
* quantile <1>:                          Functions and Variables for descriptive statistics.
                                                             (line  216)
* quantile_bernoulli:                    Functions and Variables for discrete distributions.
                                                             (line  214)
* quantile_beta:                         Functions and Variables for continuous distributions.
                                                             (line  777)
* quantile_binomial:                     Functions and Variables for discrete distributions.
                                                             (line  103)
* quantile_cauchy:                       Functions and Variables for continuous distributions.
                                                             (line 1217)
* quantile_chi2:                         Functions and Variables for continuous distributions.
                                                             (line  268)
* quantile_continuous_uniform:           Functions and Variables for continuous distributions.
                                                             (line  825)
* quantile_discrete_uniform:             Functions and Variables for discrete distributions.
                                                             (line  355)
* quantile_exp:                          Functions and Variables for continuous distributions.
                                                             (line  529)
* quantile_f:                            Functions and Variables for continuous distributions.
                                                             (line  442)
* quantile_gamma:                        Functions and Variables for continuous distributions.
                                                             (line  718)
* quantile_general_finite_discrete:      Functions and Variables for discrete distributions.
                                                             (line   42)
* quantile_geometric:                    Functions and Variables for discrete distributions.
                                                             (line  310)
* quantile_gumbel:                       Functions and Variables for continuous distributions.
                                                             (line 1241)
* quantile_hypergeometric:               Functions and Variables for discrete distributions.
                                                             (line  408)
* quantile_laplace:                      Functions and Variables for continuous distributions.
                                                             (line 1172)
* quantile_logistic:                     Functions and Variables for continuous distributions.
                                                             (line  875)
* quantile_lognormal:                    Functions and Variables for continuous distributions.
                                                             (line  659)
* quantile_negative_binomial:            Functions and Variables for discrete distributions.
                                                             (line  470)
* quantile_noncentral_chi2:              Functions and Variables for continuous distributions.
                                                             (line  387)
* quantile_noncentral_student_t:         Functions and Variables for continuous distributions.
                                                             (line  175)
* quantile_normal:                       Functions and Variables for continuous distributions.
                                                             (line   24)
* quantile_pareto:                       Functions and Variables for continuous distributions.
                                                             (line  921)
* quantile_poisson:                      Functions and Variables for discrete distributions.
                                                             (line  158)
* quantile_rayleigh:                     Functions and Variables for continuous distributions.
                                                             (line 1034)
* quantile_student_t:                    Functions and Variables for continuous distributions.
                                                             (line   89)
* quantile_weibull:                      Functions and Variables for continuous distributions.
                                                             (line  966)
* quartile_skewness:                     Functions and Variables for descriptive statistics.
                                                             (line  445)
* quartile_skewness <1>:                 Functions and Variables for descriptive statistics.
                                                             (line  446)
* quit:                                  Functions and Variables for Command Line.
                                                             (line  497)
* qunit:                                 Functions and Variables for Number Theory.
                                                             (line  415)
* quotient:                              Functions and Variables for Polynomials.
                                                             (line  778)
* quotient <1>:                          Functions and Variables for Polynomials.
                                                             (line  779)
* radcan:                                Functions and Variables for Simplification.
                                                             (line  425)
* radexpand:                             Functions and Variables for Simplification.
                                                             (line  450)
* radius:                                Functions and Variables for graphs.
                                                             (line  930)
* radsubstflag:                          Functions and Variables for Polynomials.
                                                             (line 1119)
* random:                                Random Numbers.     (line   32)
* random_bernoulli:                      Functions and Variables for discrete distributions.
                                                             (line  289)
* random_bernoulli <1>:                  Functions and Variables for discrete distributions.
                                                             (line  290)
* random_beta:                           Functions and Variables for continuous distributions.
                                                             (line  803)
* random_beta <1>:                       Functions and Variables for continuous distributions.
                                                             (line  804)
* random_binomial:                       Functions and Variables for discrete distributions.
                                                             (line  132)
* random_binomial <1>:                   Functions and Variables for discrete distributions.
                                                             (line  133)
* random_bipartite_graph:                Functions and Variables for graphs.
                                                             (line  230)
* random_cauchy:                         Functions and Variables for continuous distributions.
                                                             (line 1223)
* random_cauchy <1>:                     Functions and Variables for continuous distributions.
                                                             (line 1224)
* random_chi2:                           Functions and Variables for continuous distributions.
                                                             (line  365)
* random_chi2 <1>:                       Functions and Variables for continuous distributions.
                                                             (line  366)
* random_continuous_uniform:             Functions and Variables for continuous distributions.
                                                             (line  856)
* random_continuous_uniform <1>:         Functions and Variables for continuous distributions.
                                                             (line  857)
* random_digraph:                        Functions and Variables for graphs.
                                                             (line  234)
* random_discrete_uniform:               Functions and Variables for discrete distributions.
                                                             (line  387)
* random_discrete_uniform <1>:           Functions and Variables for discrete distributions.
                                                             (line  388)
* random_exp:                            Functions and Variables for continuous distributions.
                                                             (line  628)
* random_exp <1>:                        Functions and Variables for continuous distributions.
                                                             (line  629)
* random_f:                              Functions and Variables for continuous distributions.
                                                             (line  479)
* random_f <1>:                          Functions and Variables for continuous distributions.
                                                             (line  480)
* random_gamma:                          Functions and Variables for continuous distributions.
                                                             (line  744)
* random_gamma <1>:                      Functions and Variables for continuous distributions.
                                                             (line  745)
* random_general_finite_discrete:        Functions and Variables for discrete distributions.
                                                             (line   72)
* random_general_finite_discrete <1>:    Functions and Variables for discrete distributions.
                                                             (line   73)
* random_geometric:                      Functions and Variables for discrete distributions.
                                                             (line  337)
* random_geometric <1>:                  Functions and Variables for discrete distributions.
                                                             (line  338)
* random_graph:                          Functions and Variables for graphs.
                                                             (line  243)
* random_graph1:                         Functions and Variables for graphs.
                                                             (line  247)
* random_gumbel:                         Functions and Variables for continuous distributions.
                                                             (line 1281)
* random_gumbel <1>:                     Functions and Variables for continuous distributions.
                                                             (line 1282)
* random_hypergeometric:                 Functions and Variables for discrete distributions.
                                                             (line  440)
* random_hypergeometric <1>:             Functions and Variables for discrete distributions.
                                                             (line  441)
* random_laplace:                        Functions and Variables for continuous distributions.
                                                             (line 1198)
* random_laplace <1>:                    Functions and Variables for continuous distributions.
                                                             (line 1199)
* random_logistic:                       Functions and Variables for continuous distributions.
                                                             (line  901)
* random_logistic <1>:                   Functions and Variables for continuous distributions.
                                                             (line  902)
* random_lognormal:                      Functions and Variables for continuous distributions.
                                                             (line  692)
* random_lognormal <1>:                  Functions and Variables for continuous distributions.
                                                             (line  693)
* random_negative_binomial:              Functions and Variables for discrete distributions.
                                                             (line  502)
* random_negative_binomial <1>:          Functions and Variables for discrete distributions.
                                                             (line  503)
* random_network:                        Functions and Variables for graphs.
                                                             (line  250)
* random_noncentral_chi2:                Functions and Variables for continuous distributions.
                                                             (line  417)
* random_noncentral_chi2 <1>:            Functions and Variables for continuous distributions.
                                                             (line  418)
* random_noncentral_student_t:           Functions and Variables for continuous distributions.
                                                             (line  217)
* random_noncentral_student_t <1>:       Functions and Variables for continuous distributions.
                                                             (line  218)
* random_normal:                         Functions and Variables for continuous distributions.
                                                             (line   60)
* random_normal <1>:                     Functions and Variables for continuous distributions.
                                                             (line   61)
* random_pareto:                         Functions and Variables for continuous distributions.
                                                             (line  947)
* random_pareto <1>:                     Functions and Variables for continuous distributions.
                                                             (line  948)
* random_permutation:                    Functions and Variables for Sets.
                                                             (line  759)
* random_poisson:                        Functions and Variables for discrete distributions.
                                                             (line  184)
* random_poisson <1>:                    Functions and Variables for discrete distributions.
                                                             (line  185)
* random_rayleigh:                       Functions and Variables for continuous distributions.
                                                             (line 1153)
* random_rayleigh <1>:                   Functions and Variables for continuous distributions.
                                                             (line 1154)
* random_regular_graph:                  Functions and Variables for graphs.
                                                             (line  238)
* random_regular_graph <1>:              Functions and Variables for graphs.
                                                             (line  239)
* random_student_t:                      Functions and Variables for continuous distributions.
                                                             (line  122)
* random_student_t <1>:                  Functions and Variables for continuous distributions.
                                                             (line  123)
* random_tournament:                     Functions and Variables for graphs.
                                                             (line  263)
* random_tree:                           Functions and Variables for graphs.
                                                             (line  266)
* random_weibull:                        Functions and Variables for continuous distributions.
                                                             (line  992)
* random_weibull <1>:                    Functions and Variables for continuous distributions.
                                                             (line  993)
* range:                                 Functions and Variables for descriptive statistics.
                                                             (line  201)
* range <1>:                             Functions and Variables for descriptive statistics.
                                                             (line  202)
* rank:                                  Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1020)
* rank <1>:                              Functions and Variables for linearalgebra.
                                                             (line  551)
* rassociative:                          Functions and Variables for Simplification.
                                                             (line  470)
* rat:                                   Functions and Variables for Polynomials.
                                                             (line  786)
* rat <1>:                               Functions and Variables for Polynomials.
                                                             (line  787)
* ratalgdenom:                           Functions and Variables for Polynomials.
                                                             (line  831)
* ratchristof:                           Functions and Variables for ctensor.
                                                             (line 1060)
* ratcoef:                               Functions and Variables for Polynomials.
                                                             (line  838)
* ratcoef <1>:                           Functions and Variables for Polynomials.
                                                             (line  839)
* ratdenom:                              Functions and Variables for Polynomials.
                                                             (line  865)
* ratdenomdivide:                        Functions and Variables for Polynomials.
                                                             (line  879)
* ratdiff:                               Functions and Variables for Polynomials.
                                                             (line  922)
* ratdisrep:                             Functions and Variables for Polynomials.
                                                             (line  964)
* rateinstein:                           Functions and Variables for ctensor.
                                                             (line 1064)
* ratepsilon:                            Functions and Variables for Numbers.
                                                             (line  217)
* ratexpand:                             Functions and Variables for Polynomials.
                                                             (line  975)
* ratexpand <1>:                         Functions and Variables for Polynomials.
                                                             (line  976)
* ratfac:                                Functions and Variables for Polynomials.
                                                             (line 1019)
* ratinterpol:                           Functions and Variables for interpol.
                                                             (line  265)
* ratinterpol <1>:                       Functions and Variables for interpol.
                                                             (line  266)
* rational:                              Package functs.     (line   29)
* rationalize:                           Functions and Variables for Numbers.
                                                             (line  223)
* ratmx:                                 Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1028)
* ratnumer:                              Functions and Variables for Polynomials.
                                                             (line 1040)
* ratnump:                               Functions and Variables for Numbers.
                                                             (line  297)
* ratp:                                  Functions and Variables for Polynomials.
                                                             (line 1053)
* ratprint:                              Functions and Variables for Polynomials.
                                                             (line 1061)
* ratriemann:                            Functions and Variables for ctensor.
                                                             (line 1070)
* ratsimp:                               Functions and Variables for Polynomials.
                                                             (line 1067)
* ratsimp <1>:                           Functions and Variables for Polynomials.
                                                             (line 1068)
* ratsimpexpons:                         Functions and Variables for Polynomials.
                                                             (line 1113)
* ratsubst:                              Functions and Variables for Polynomials.
                                                             (line 1125)
* ratvars:                               Functions and Variables for Polynomials.
                                                             (line 1161)
* ratvars <1>:                           Functions and Variables for Polynomials.
                                                             (line 1162)
* ratvars <2>:                           Functions and Variables for Polynomials.
                                                             (line 1163)
* ratvarswitch:                          Functions and Variables for Polynomials.
                                                             (line 1181)
* ratweight:                             Functions and Variables for Polynomials.
                                                             (line 1231)
* ratweight <1>:                         Functions and Variables for Polynomials.
                                                             (line 1232)
* ratweights:                            Functions and Variables for Polynomials.
                                                             (line 1258)
* ratweyl:                               Functions and Variables for ctensor.
                                                             (line 1077)
* ratwtlvl:                              Functions and Variables for Polynomials.
                                                             (line 1268)
* read:                                  Functions and Variables for Command Line.
                                                             (line  508)
* read_array:                            Functions and Variables for plain-text input and output.
                                                             (line   26)
* read_array <1>:                        Functions and Variables for plain-text input and output.
                                                             (line   27)
* read_binary_array:                     Functions and Variables for binary input and output.
                                                             (line   38)
* read_binary_list:                      Functions and Variables for binary input and output.
                                                             (line   48)
* read_binary_list <1>:                  Functions and Variables for binary input and output.
                                                             (line   49)
* read_binary_matrix:                    Functions and Variables for binary input and output.
                                                             (line   28)
* read_hashed_array:                     Functions and Variables for plain-text input and output.
                                                             (line   39)
* read_hashed_array <1>:                 Functions and Variables for plain-text input and output.
                                                             (line   40)
* read_list:                             Functions and Variables for plain-text input and output.
                                                             (line   68)
* read_list <1>:                         Functions and Variables for plain-text input and output.
                                                             (line   69)
* read_list <2>:                         Functions and Variables for plain-text input and output.
                                                             (line   70)
* read_list <3>:                         Functions and Variables for plain-text input and output.
                                                             (line   71)
* read_matrix:                           Functions and Variables for plain-text input and output.
                                                             (line    6)
* read_matrix <1>:                       Functions and Variables for plain-text input and output.
                                                             (line    7)
* read_matrix <2>:                       Functions and Variables for plain-text input and output.
                                                             (line    8)
* read_matrix <3>:                       Functions and Variables for plain-text input and output.
                                                             (line    9)
* read_nested_list:                      Functions and Variables for plain-text input and output.
                                                             (line   54)
* read_nested_list <1>:                  Functions and Variables for plain-text input and output.
                                                             (line   55)
* read_xpm:                              Functions and Variables for pictures.
                                                             (line   75)
* readline:                              Functions and Variables for input and output.
                                                             (line  117)
* readonly:                              Functions and Variables for Command Line.
                                                             (line  524)
* Real infinity:                         Functions and Variables for Constants.
                                                             (line   35)
* real_imagpart_to_conjugate:            Functions and Variables for to_poly_solve.
                                                             (line  596)
* realonly:                              Functions and Variables for Equations.
                                                             (line  606)
* realpart:                              Functions for Complex Numbers.
                                                             (line   68)
* realroots:                             Functions and Variables for Equations.
                                                             (line  612)
* realroots <1>:                         Functions and Variables for Equations.
                                                             (line  613)
* realroots <2>:                         Functions and Variables for Equations.
                                                             (line  614)
* realroots <3>:                         Functions and Variables for Equations.
                                                             (line  615)
* rearray:                               Functions and Variables for Arrays.
                                                             (line  382)
* rectangle:                             Functions and Variables for draw.
                                                             (line 3019)
* rectform:                              Functions for Complex Numbers.
                                                             (line   72)
* rectform_log_if_constant:              Functions and Variables for to_poly_solve.
                                                             (line  613)
* recttopolar:                           Functions and Variables for fast Fourier transform.
                                                             (line   22)
* rediff:                                Functions and Variables for itensor.
                                                             (line  622)
* redraw:                                Functions and Variables for graphs.
                                                             (line 1466)
* reduce_consts:                         Package rducon.     (line    6)
* reduce_order:                          Functions and Variables for solve_rec.
                                                             (line    6)
* refcheck:                              Functions and Variables for Debugging.
                                                             (line   17)
* region:                                Functions and Variables for draw.
                                                             (line 3047)
* region_boundaries:                     Functions and Variables for worldmap.
                                                             (line  113)
* region_boundaries_plus:                Functions and Variables for worldmap.
                                                             (line  125)
* rem:                                   Functions and Variables for Miscellaneous Options.
                                                             (line  128)
* remainder:                             Functions and Variables for Polynomials.
                                                             (line 1275)
* remainder <1>:                         Functions and Variables for Polynomials.
                                                             (line 1276)
* remarray:                              Functions and Variables for Arrays.
                                                             (line  389)
* remarray <1>:                          Functions and Variables for Arrays.
                                                             (line  390)
* rembox:                                Functions and Variables for Expressions.
                                                             (line  837)
* rembox <1>:                            Functions and Variables for Expressions.
                                                             (line  838)
* rembox <2>:                            Functions and Variables for Expressions.
                                                             (line  839)
* remcomps:                              Functions and Variables for itensor.
                                                             (line  273)
* remcon:                                Functions and Variables for itensor.
                                                             (line  162)
* remcon <1>:                            Functions and Variables for itensor.
                                                             (line  163)
* remcoord:                              Functions and Variables for itensor.
                                                             (line  716)
* remcoord <1>:                          Functions and Variables for itensor.
                                                             (line  717)
* remfun:                                Functions and Variables for Fourier series.
                                                             (line   12)
* remfun <1>:                            Functions and Variables for Fourier series.
                                                             (line   13)
* remfunction:                           Functions and Variables for Function Definition.
                                                             (line  957)
* remfunction <1>:                       Functions and Variables for Function Definition.
                                                             (line  958)
* remlet:                                Functions and Variables for Rules and Patterns.
                                                             (line  500)
* remlet <1>:                            Functions and Variables for Rules and Patterns.
                                                             (line  501)
* remlet <2>:                            Functions and Variables for Rules and Patterns.
                                                             (line  502)
* remlet <3>:                            Functions and Variables for Rules and Patterns.
                                                             (line  503)
* remove:                                Functions and Variables for Miscellaneous Options.
                                                             (line  137)
* remove <1>:                            Functions and Variables for Miscellaneous Options.
                                                             (line  138)
* remove <2>:                            Functions and Variables for Miscellaneous Options.
                                                             (line  139)
* remove <3>:                            Functions and Variables for Miscellaneous Options.
                                                             (line  140)
* remove <4>:                            Functions and Variables for Miscellaneous Options.
                                                             (line  141)
* remove_constvalue:                     Functions and Variables for ezunits.
                                                             (line  248)
* remove_dimensions:                     Functions and Variables for ezunits.
                                                             (line  475)
* remove_edge:                           Functions and Variables for graphs.
                                                             (line 1199)
* remove_fundamental_dimensions:         Functions and Variables for ezunits.
                                                             (line  505)
* remove_fundamental_units:              Functions and Variables for ezunits.
                                                             (line  536)
* remove_vertex:                         Functions and Variables for graphs.
                                                             (line 1213)
* rempart:                               Package functs.     (line    6)
* remrule:                               Functions and Variables for Rules and Patterns.
                                                             (line  522)
* remrule <1>:                           Functions and Variables for Rules and Patterns.
                                                             (line  523)
* remsym:                                Functions and Variables for itensor.
                                                             (line  550)
* remvalue:                              Functions and Variables for Miscellaneous Options.
                                                             (line  173)
* remvalue <1>:                          Functions and Variables for Miscellaneous Options.
                                                             (line  174)
* rename:                                Functions and Variables for itensor.
                                                             (line   73)
* rename <1>:                            Functions and Variables for itensor.
                                                             (line   74)
* reset:                                 Functions and Variables for Command Line.
                                                             (line  545)
* residue:                               Functions and Variables for Integration.
                                                             (line  484)
* resolvante:                            Functions and Variables for Symmetries.
                                                             (line  528)
* resolvante_alternee1:                  Functions and Variables for Symmetries.
                                                             (line  699)
* resolvante_bipartite:                  Functions and Variables for Symmetries.
                                                             (line  706)
* resolvante_diedrale:                   Functions and Variables for Symmetries.
                                                             (line  719)
* resolvante_klein:                      Functions and Variables for Symmetries.
                                                             (line  737)
* resolvante_klein3:                     Functions and Variables for Symmetries.
                                                             (line  746)
* resolvante_produit_sym:                Functions and Variables for Symmetries.
                                                             (line  755)
* resolvante_unitaire:                   Functions and Variables for Symmetries.
                                                             (line  780)
* resolvante_vierer:                     Functions and Variables for Symmetries.
                                                             (line  788)
* rest:                                  Functions and Variables for Lists.
                                                             (line  351)
* rest <1>:                              Functions and Variables for Lists.
                                                             (line  352)
* resultant:                             Functions and Variables for Polynomials.
                                                             (line 1283)
* resultant <1>:                         Functions and Variables for Polynomials.
                                                             (line 1284)
* return:                                Functions and Variables for Program Flow.
                                                             (line  499)
* reveal:                                Functions and Variables for Expressions.
                                                             (line  906)
* reverse:                               Functions and Variables for Lists.
                                                             (line  359)
* revert:                                Functions and Variables for Series.
                                                             (line  300)
* revert2:                               Functions and Variables for Series.
                                                             (line  301)
* rgb2level:                             Functions and Variables for pictures.
                                                             (line   78)
* rhs:                                   Functions and Variables for Equations.
                                                             (line  656)
* ric:                                   Functions and Variables for ctensor.
                                                             (line 1108)
* ricci:                                 Functions and Variables for ctensor.
                                                             (line  183)
* riem:                                  Functions and Variables for ctensor.
                                                             (line 1092)
* riemann:                               Functions and Variables for ctensor.
                                                             (line  215)
* rinvariant:                            Functions and Variables for ctensor.
                                                             (line  251)
* risch:                                 Functions and Variables for Integration.
                                                             (line  500)
* rk:                                    Functions and Variables for dynamics.
                                                             (line  105)
* rk <1>:                                Functions and Variables for dynamics.
                                                             (line  106)
* rmxchar:                               Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1043)
* rncombine:                             Functions and Variables for Miscellaneous Options.
                                                             (line  185)
* romberg:                               Functions and Variables for romberg.
                                                             (line    6)
* romberg <1>:                           Functions and Variables for romberg.
                                                             (line    7)
* rombergabs:                            Functions and Variables for romberg.
                                                             (line  100)
* rombergit:                             Functions and Variables for romberg.
                                                             (line  111)
* rombergmin:                            Functions and Variables for romberg.
                                                             (line  122)
* rombergtol:                            Functions and Variables for romberg.
                                                             (line  131)
* room:                                  Functions and Variables for Runtime Environment.
                                                             (line   62)
* room <1>:                              Functions and Variables for Runtime Environment.
                                                             (line   63)
* room <2>:                              Functions and Variables for Runtime Environment.
                                                             (line   64)
* rootsconmode:                          Functions and Variables for Equations.
                                                             (line  697)
* rootscontract:                         Functions and Variables for Equations.
                                                             (line  703)
* rootsepsilon:                          Functions and Variables for Equations.
                                                             (line  763)
* round:                                 Functions for Numbers.
                                                             (line  131)
* row:                                   Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1039)
* rowop:                                 Functions and Variables for linearalgebra.
                                                             (line  545)
* rowswap:                               Functions and Variables for linearalgebra.
                                                             (line  562)
* rreduce:                               Functions and Variables for Sets.
                                                             (line  778)
* rreduce <1>:                           Functions and Variables for Sets.
                                                             (line  779)
* run_testsuite:                         Functions and Variables for Bug Detection and Reporting.
                                                             (line    6)
* run_viewer:                            Plotting Options.   (line  194)
* save:                                  Functions and Variables for File Input and Output.
                                                             (line  393)
* save <1>:                              Functions and Variables for File Input and Output.
                                                             (line  394)
* save <2>:                              Functions and Variables for File Input and Output.
                                                             (line  395)
* save <3>:                              Functions and Variables for File Input and Output.
                                                             (line  396)
* save <4>:                              Functions and Variables for File Input and Output.
                                                             (line  397)
* save <5>:                              Functions and Variables for File Input and Output.
                                                             (line  398)
* savedef:                               Functions and Variables for Function Definition.
                                                             (line  975)
* savefactors:                           Functions and Variables for Polynomials.
                                                             (line 1302)
* saving:                                Functions and Variables for finance.
                                                             (line  174)
* scalarmatrixp:                         Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1050)
* scalarp:                               Functions and Variables for Miscellaneous Options.
                                                             (line  198)
* scaled_bessel_i:                       Bessel Functions.   (line  147)
* scaled_bessel_i0:                      Bessel Functions.   (line  156)
* scaled_bessel_i1:                      Bessel Functions.   (line  160)
* scalefactors:                          Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1063)
* scanmap:                               Functions and Variables for Program Flow.
                                                             (line  503)
* scanmap <1>:                           Functions and Variables for Program Flow.
                                                             (line  504)
* scatterplot:                           Functions and Variables for statistical graphs.
                                                             (line  315)
* scatterplot <1>:                       Functions and Variables for statistical graphs.
                                                             (line  316)
* scatterplot <2>:                       Functions and Variables for statistical graphs.
                                                             (line  317)
* scatterplot <3>:                       Functions and Variables for statistical graphs.
                                                             (line  318)
* scatterplot_description:               Functions and Variables for statistical graphs.
                                                             (line  319)
* schur2comp:                            Functions and Variables for Symmetries.
                                                             (line  180)
* sconcat:                               Functions and Variables for Strings.
                                                             (line   45)
* scopy:                                 Functions and Variables for strings.
                                                             (line   62)
* scsimp:                                Functions and Variables for Simplification.
                                                             (line  476)
* scurvature:                            Functions and Variables for ctensor.
                                                             (line  196)
* sdowncase:                             Functions and Variables for strings.
                                                             (line   65)
* sdowncase <1>:                         Functions and Variables for strings.
                                                             (line   66)
* sdowncase <2>:                         Functions and Variables for strings.
                                                             (line   67)
* sec:                                   Functions and Variables for Trigonometric.
                                                             (line  198)
* sech:                                  Functions and Variables for Trigonometric.
                                                             (line  201)
* second:                                Functions and Variables for Lists.
                                                             (line  365)
* sequal:                                Functions and Variables for strings.
                                                             (line   70)
* sequalignore:                          Functions and Variables for strings.
                                                             (line   74)
* set_draw_defaults:                     Functions and Variables for draw.
                                                             (line  165)
* set_edge_weight:                       Functions and Variables for graphs.
                                                             (line  938)
* set_partitions:                        Functions and Variables for Sets.
                                                             (line  894)
* set_partitions <1>:                    Functions and Variables for Sets.
                                                             (line  895)
* set_plot_option:                       Functions and Variables for Plotting.
                                                             (line  322)
* set_random_state:                      Random Numbers.     (line   27)
* set_tex_environment:                   Functions and Variables for File Input and Output.
                                                             (line  691)
* set_tex_environment_default:           Functions and Variables for File Input and Output.
                                                             (line  728)
* set_up_dot_simplifications:            Functions and Variables for Affine.
                                                             (line   34)
* set_up_dot_simplifications <1>:        Functions and Variables for Affine.
                                                             (line   35)
* set_vertex_label:                      Functions and Variables for graphs.
                                                             (line  951)
* setcheck:                              Functions and Variables for Debugging.
                                                             (line   23)
* setcheckbreak:                         Functions and Variables for Debugging.
                                                             (line   51)
* setdifference:                         Functions and Variables for Sets.
                                                             (line  819)
* setelmx:                               Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1080)
* setequalp:                             Functions and Variables for Sets.
                                                             (line  843)
* setify:                                Functions and Variables for Sets.
                                                             (line  859)
* setp:                                  Functions and Variables for Sets.
                                                             (line  875)
* setunits:                              Functions and Variables for Units.
                                                             (line    6)
* setup_autoload:                        Functions and Variables for Miscellaneous Options.
                                                             (line  204)
* setval:                                Functions and Variables for Debugging.
                                                             (line   62)
* seventh:                               Functions and Variables for Lists.
                                                             (line  370)
* sexplode:                              Functions and Variables for strings.
                                                             (line   77)
* sf:                                    Functions and Variables for atensor.
                                                             (line   78)
* shortest_path:                         Functions and Variables for graphs.
                                                             (line  964)
* shortest_weighted_path:                Functions and Variables for graphs.
                                                             (line  974)
* show:                                  Functions and Variables for itensor.
                                                             (line  130)
* show_edge_color:                       Functions and Variables for graphs.
                                                             (line 1448)
* show_edge_type:                        Functions and Variables for graphs.
                                                             (line 1454)
* show_edge_width:                       Functions and Variables for graphs.
                                                             (line 1451)
* show_edges:                            Functions and Variables for graphs.
                                                             (line 1445)
* show_id:                               Functions and Variables for graphs.
                                                             (line 1375)
* show_label:                            Functions and Variables for graphs.
                                                             (line 1380)
* show_vertex_color:                     Functions and Variables for graphs.
                                                             (line 1422)
* show_vertex_size:                      Functions and Variables for graphs.
                                                             (line 1419)
* show_vertex_type:                      Functions and Variables for graphs.
                                                             (line 1413)
* show_vertices:                         Functions and Variables for graphs.
                                                             (line 1408)
* show_weight:                           Functions and Variables for graphs.
                                                             (line 1391)
* showcomps:                             Functions and Variables for itensor.
                                                             (line  278)
* showratvars:                           Functions and Variables for Polynomials.
                                                             (line 1309)
* showtime:                              Functions and Variables for Command Line.
                                                             (line  556)
* sierpinskiale:                         Definitions for IFS fractals.
                                                             (line   16)
* sierpinskimap:                         Definitions for Peano maps.
                                                             (line   18)
* sign:                                  Functions and Variables for Facts.
                                                             (line  384)
* signum:                                Functions for Numbers.
                                                             (line  137)
* similaritytransform:                   Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1088)
* simp:                                  Functions and Variables for Simplification.
                                                             (line  486)
* simp_inequality:                       Functions and Variables for to_poly_solve.
                                                             (line  636)
* simple_linear_regression:              Functions and Variables for stats.
                                                             (line  742)
* simple_linear_regression <1>:          Functions and Variables for stats.
                                                             (line  743)
* simplified_output:                     Functions and Variables for zeilberger.
                                                             (line  103)
* simplify_products:                     Functions and Variables for solve_rec.
                                                             (line   52)
* simplify_sum:                          Functions and Variables for solve_rec.
                                                             (line   60)
* simplode:                              Functions and Variables for strings.
                                                             (line   80)
* simplode <1>:                          Functions and Variables for strings.
                                                             (line   81)
* simpmetderiv:                          Functions and Variables for itensor.
                                                             (line  746)
* simpmetderiv <1>:                      Functions and Variables for itensor.
                                                             (line  747)
* simpsum:                               Sums and Products.  (line  100)
* simtran:                               Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1089)
* sin:                                   Functions and Variables for Trigonometric.
                                                             (line  204)
* sinh:                                  Functions and Variables for Trigonometric.
                                                             (line  207)
* sinnpiflag:                            Functions and Variables for Fourier series.
                                                             (line   57)
* sinsert:                               Functions and Variables for strings.
                                                             (line   93)
* sinvertcase:                           Functions and Variables for strings.
                                                             (line  104)
* sinvertcase <1>:                       Functions and Variables for strings.
                                                             (line  105)
* sinvertcase <2>:                       Functions and Variables for strings.
                                                             (line  106)
* sixth:                                 Functions and Variables for Lists.
                                                             (line  375)
* skewness:                              Functions and Variables for descriptive statistics.
                                                             (line  399)
* skewness <1>:                          Functions and Variables for descriptive statistics.
                                                             (line  400)
* skewness_bernoulli:                    Functions and Variables for discrete distributions.
                                                             (line  259)
* skewness_beta:                         Functions and Variables for continuous distributions.
                                                             (line  795)
* skewness_binomial:                     Functions and Variables for discrete distributions.
                                                             (line  122)
* skewness_chi2:                         Functions and Variables for continuous distributions.
                                                             (line  331)
* skewness_continuous_uniform:           Functions and Variables for continuous distributions.
                                                             (line  846)
* skewness_discrete_uniform:             Functions and Variables for discrete distributions.
                                                             (line  377)
* skewness_exp:                          Functions and Variables for continuous distributions.
                                                             (line  598)
* skewness_f:                            Functions and Variables for continuous distributions.
                                                             (line  471)
* skewness_gamma:                        Functions and Variables for continuous distributions.
                                                             (line  736)
* skewness_general_finite_discrete:      Functions and Variables for discrete distributions.
                                                             (line   62)
* skewness_geometric:                    Functions and Variables for discrete distributions.
                                                             (line  329)
* skewness_gumbel:                       Functions and Variables for continuous distributions.
                                                             (line 1264)
* skewness_hypergeometric:               Functions and Variables for discrete distributions.
                                                             (line  430)
* skewness_laplace:                      Functions and Variables for continuous distributions.
                                                             (line 1190)
* skewness_logistic:                     Functions and Variables for continuous distributions.
                                                             (line  893)
* skewness_lognormal:                    Functions and Variables for continuous distributions.
                                                             (line  684)
* skewness_negative_binomial:            Functions and Variables for discrete distributions.
                                                             (line  492)
* skewness_noncentral_chi2:              Functions and Variables for continuous distributions.
                                                             (line  409)
* skewness_noncentral_student_t:         Functions and Variables for continuous distributions.
                                                             (line  207)
* skewness_normal:                       Functions and Variables for continuous distributions.
                                                             (line   50)
* skewness_pareto:                       Functions and Variables for continuous distributions.
                                                             (line  939)
* skewness_poisson:                      Functions and Variables for discrete distributions.
                                                             (line  176)
* skewness_rayleigh:                     Functions and Variables for continuous distributions.
                                                             (line 1109)
* skewness_student_t:                    Functions and Variables for continuous distributions.
                                                             (line  113)
* skewness_weibull:                      Functions and Variables for continuous distributions.
                                                             (line  984)
* slength:                               Functions and Variables for strings.
                                                             (line  114)
* smake:                                 Functions and Variables for strings.
                                                             (line  117)
* small_rhombicosidodecahedron_graph:    Functions and Variables for graphs.
                                                             (line  269)
* small_rhombicuboctahedron_graph:       Functions and Variables for graphs.
                                                             (line  272)
* smax:                                  Functions and Variables for descriptive statistics.
                                                             (line  186)
* smax <1>:                              Functions and Variables for descriptive statistics.
                                                             (line  187)
* smin:                                  Functions and Variables for descriptive statistics.
                                                             (line  171)
* smin <1>:                              Functions and Variables for descriptive statistics.
                                                             (line  172)
* smismatch:                             Functions and Variables for strings.
                                                             (line  123)
* smismatch <1>:                         Functions and Variables for strings.
                                                             (line  124)
* snowmap:                               Definitions for Koch snowflakes.
                                                             (line    6)
* snub_cube_graph:                       Functions and Variables for graphs.
                                                             (line  275)
* snub_dodecahedron_graph:               Functions and Variables for graphs.
                                                             (line  278)
* solve:                                 Functions and Variables for Equations.
                                                             (line  769)
* solve <1>:                             Functions and Variables for Equations.
                                                             (line  770)
* solve <2>:                             Functions and Variables for Equations.
                                                             (line  771)
* solve_rec:                             Functions and Variables for solve_rec.
                                                             (line   83)
* solve_rec_rat:                         Functions and Variables for solve_rec.
                                                             (line  144)
* solvedecomposes:                       Functions and Variables for Equations.
                                                             (line  918)
* solveexplicit:                         Functions and Variables for Equations.
                                                             (line  924)
* solvefactors:                          Functions and Variables for Equations.
                                                             (line  930)
* solvenullwarn:                         Functions and Variables for Equations.
                                                             (line  937)
* solveradcan:                           Functions and Variables for Equations.
                                                             (line  945)
* solvetrigwarn:                         Functions and Variables for Equations.
                                                             (line  952)
* some:                                  Functions and Variables for Sets.
                                                             (line  943)
* some <1>:                              Functions and Variables for Sets.
                                                             (line  944)
* somrac:                                Functions and Variables for Symmetries.
                                                             (line  519)
* sort:                                  Functions and Variables for Lists.
                                                             (line  380)
* sort <1>:                              Functions and Variables for Lists.
                                                             (line  381)
* space:                                 Functions and Variables for characters.
                                                             (line   76)
* sparse:                                Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1113)
* sparse6_decode:                        Functions and Variables for graphs.
                                                             (line 1246)
* sparse6_encode:                        Functions and Variables for graphs.
                                                             (line 1250)
* sparse6_export:                        Functions and Variables for graphs.
                                                             (line 1254)
* sparse6_import:                        Functions and Variables for graphs.
                                                             (line 1259)
* specint:                               Functions and Variables for Special Functions.
                                                             (line    6)
* spherical:                             Functions and Variables for draw.
                                                             (line 3067)
* spherical_bessel_j:                    Functions and Variables for orthogonal polynomials.
                                                             (line  163)
* spherical_bessel_y:                    Functions and Variables for orthogonal polynomials.
                                                             (line  169)
* spherical_hankel1:                     Functions and Variables for orthogonal polynomials.
                                                             (line  175)
* spherical_hankel2:                     Functions and Variables for orthogonal polynomials.
                                                             (line  180)
* spherical_harmonic:                    Functions and Variables for orthogonal polynomials.
                                                             (line  185)
* spherical_to_xyz:                      Functions and Variables for Plotting.
                                                             (line  352)
* splice:                                Macros.             (line  164)
* split:                                 Functions and Variables for strings.
                                                             (line  133)
* split <1>:                             Functions and Variables for strings.
                                                             (line  134)
* split <2>:                             Functions and Variables for strings.
                                                             (line  135)
* sposition:                             Functions and Variables for strings.
                                                             (line  149)
* spring_embedding_depth:                Functions and Variables for graphs.
                                                             (line 1482)
* sprint:                                Functions and Variables for input and output.
                                                             (line  121)
* sqfr:                                  Functions and Variables for Polynomials.
                                                             (line 1314)
* sqrt:                                  Root Exponential and Logarithmic Functions.
                                                             (line  228)
* sqrtdenest:                            Package sqdnst.     (line    6)
* sqrtdispflag:                          Functions and Variables for Display.
                                                             (line  514)
* sremove:                               Functions and Variables for strings.
                                                             (line  154)
* sremove <1>:                           Functions and Variables for strings.
                                                             (line  155)
* sremove <2>:                           Functions and Variables for strings.
                                                             (line  156)
* sremove <3>:                           Functions and Variables for strings.
                                                             (line  157)
* sremovefirst:                          Functions and Variables for strings.
                                                             (line  170)
* sremovefirst <1>:                      Functions and Variables for strings.
                                                             (line  171)
* sremovefirst <2>:                      Functions and Variables for strings.
                                                             (line  172)
* sremovefirst <3>:                      Functions and Variables for strings.
                                                             (line  173)
* sreverse:                              Functions and Variables for strings.
                                                             (line  177)
* ssearch:                               Functions and Variables for strings.
                                                             (line  180)
* ssearch <1>:                           Functions and Variables for strings.
                                                             (line  181)
* ssearch <2>:                           Functions and Variables for strings.
                                                             (line  182)
* ssearch <3>:                           Functions and Variables for strings.
                                                             (line  183)
* ssort:                                 Functions and Variables for strings.
                                                             (line  194)
* ssort <1>:                             Functions and Variables for strings.
                                                             (line  195)
* sstatus:                               Functions and Variables for Runtime Environment.
                                                             (line   73)
* ssubst:                                Functions and Variables for strings.
                                                             (line  209)
* ssubst <1>:                            Functions and Variables for strings.
                                                             (line  210)
* ssubst <2>:                            Functions and Variables for strings.
                                                             (line  211)
* ssubst <3>:                            Functions and Variables for strings.
                                                             (line  212)
* ssubstfirst:                           Functions and Variables for strings.
                                                             (line  226)
* ssubstfirst <1>:                       Functions and Variables for strings.
                                                             (line  227)
* ssubstfirst <2>:                       Functions and Variables for strings.
                                                             (line  228)
* ssubstfirst <3>:                       Functions and Variables for strings.
                                                             (line  229)
* staircase:                             Functions and Variables for dynamics.
                                                             (line  139)
* standardize_inverse_trig:              Functions and Variables for to_poly_solve.
                                                             (line  659)
* stardisp:                              Functions and Variables for Display.
                                                             (line  520)
* starplot:                              Functions and Variables for statistical graphs.
                                                             (line  374)
* starplot_description:                  Functions and Variables for statistical graphs.
                                                             (line  375)
* stats_numer:                           Functions and Variables for stats.
                                                             (line    6)
* status:                                Functions and Variables for Runtime Environment.
                                                             (line   84)
* status <1>:                            Functions and Variables for Runtime Environment.
                                                             (line   85)
* std:                                   Functions and Variables for descriptive statistics.
                                                             (line   75)
* std <1>:                               Functions and Variables for descriptive statistics.
                                                             (line   76)
* std_bernoulli:                         Functions and Variables for discrete distributions.
                                                             (line  246)
* std_beta:                              Functions and Variables for continuous distributions.
                                                             (line  791)
* std_binomial:                          Functions and Variables for discrete distributions.
                                                             (line  117)
* std_chi2:                              Functions and Variables for continuous distributions.
                                                             (line  316)
* std_continuous_uniform:                Functions and Variables for continuous distributions.
                                                             (line  841)
* std_discrete_uniform:                  Functions and Variables for discrete distributions.
                                                             (line  372)
* std_exp:                               Functions and Variables for continuous distributions.
                                                             (line  581)
* std_f:                                 Functions and Variables for continuous distributions.
                                                             (line  467)
* std_gamma:                             Functions and Variables for continuous distributions.
                                                             (line  732)
* std_general_finite_discrete:           Functions and Variables for discrete distributions.
                                                             (line   57)
* std_geometric:                         Functions and Variables for discrete distributions.
                                                             (line  325)
* std_gumbel:                            Functions and Variables for continuous distributions.
                                                             (line 1260)
* std_hypergeometric:                    Functions and Variables for discrete distributions.
                                                             (line  425)
* std_laplace:                           Functions and Variables for continuous distributions.
                                                             (line 1186)
* std_logistic:                          Functions and Variables for continuous distributions.
                                                             (line  889)
* std_lognormal:                         Functions and Variables for continuous distributions.
                                                             (line  680)
* std_negative_binomial:                 Functions and Variables for discrete distributions.
                                                             (line  487)
* std_noncentral_chi2:                   Functions and Variables for continuous distributions.
                                                             (line  405)
* std_noncentral_student_t:              Functions and Variables for continuous distributions.
                                                             (line  202)
* std_normal:                            Functions and Variables for continuous distributions.
                                                             (line   46)
* std_pareto:                            Functions and Variables for continuous distributions.
                                                             (line  935)
* std_poisson:                           Functions and Variables for discrete distributions.
                                                             (line  172)
* std_rayleigh:                          Functions and Variables for continuous distributions.
                                                             (line 1090)
* std_student_t:                         Functions and Variables for continuous distributions.
                                                             (line  109)
* std_weibull:                           Functions and Variables for continuous distributions.
                                                             (line  980)
* std1:                                  Functions and Variables for descriptive statistics.
                                                             (line   92)
* std1 <1>:                              Functions and Variables for descriptive statistics.
                                                             (line   93)
* stemplot:                              Functions and Variables for statistical graphs.
                                                             (line  433)
* stemplot <1>:                          Functions and Variables for statistical graphs.
                                                             (line  434)
* stirling:                              Functions and Variables for stirling.
                                                             (line    6)
* stirling <1>:                          Functions and Variables for stirling.
                                                             (line    7)
* stirling1:                             Functions and Variables for Sets.
                                                             (line 1009)
* stirling2:                             Functions and Variables for Sets.
                                                             (line 1061)
* strim:                                 Functions and Variables for strings.
                                                             (line  233)
* striml:                                Functions and Variables for strings.
                                                             (line  243)
* strimr:                                Functions and Variables for strings.
                                                             (line  246)
* string:                                Functions and Variables for Strings.
                                                             (line   53)
* stringdisp:                            Functions and Variables for Strings.
                                                             (line   60)
* stringout:                             Functions and Variables for File Input and Output.
                                                             (line  449)
* stringout <1>:                         Functions and Variables for File Input and Output.
                                                             (line  450)
* stringout <2>:                         Functions and Variables for File Input and Output.
                                                             (line  451)
* stringout <3>:                         Functions and Variables for File Input and Output.
                                                             (line  452)
* stringout <4>:                         Functions and Variables for File Input and Output.
                                                             (line  453)
* stringp:                               Functions and Variables for strings.
                                                             (line    6)
* strong_components:                     Functions and Variables for graphs.
                                                             (line  989)
* structures:                            Functions and Variables for Structures.
                                                             (line    6)
* struve_h:                              Struve Functions.   (line   12)
* struve_l:                              Struve Functions.   (line   15)
* style:                                 Plotting Options.   (line  201)
* style <1>:                             Plotting Options.   (line  202)
* sublis:                                Functions and Variables for Expressions.
                                                             (line  963)
* sublis_apply_lambda:                   Functions and Variables for Expressions.
                                                             (line  977)
* sublist:                               Functions and Variables for Lists.
                                                             (line  441)
* sublist_indices:                       Functions and Variables for Lists.
                                                             (line  452)
* submatrix:                             Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1120)
* submatrix <1>:                         Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1121)
* submatrix <2>:                         Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1122)
* subnumsimp:                            Functions and Variables for Expressions.
                                                             (line  984)
* subsample:                             Functions and Variables for data manipulation.
                                                             (line   59)
* subsample <1>:                         Functions and Variables for data manipulation.
                                                             (line   60)
* Subscript operator:                    Functions and Variables for Lists.
                                                             (line    8)
* subset:                                Functions and Variables for Sets.
                                                             (line 1121)
* subsetp:                               Functions and Variables for Sets.
                                                             (line 1139)
* subst:                                 Functions and Variables for Expressions.
                                                             (line 1001)
* subst_parallel:                        Functions and Variables for to_poly_solve.
                                                             (line  671)
* substinpart:                           Functions and Variables for Expressions.
                                                             (line 1048)
* substpart:                             Functions and Variables for Expressions.
                                                             (line 1103)
* substring:                             Functions and Variables for strings.
                                                             (line  249)
* substring <1>:                         Functions and Variables for strings.
                                                             (line  250)
* subvar:                                Functions and Variables for Arrays.
                                                             (line  406)
* subvarp:                               Functions and Variables for Arrays.
                                                             (line  431)
* sum:                                   Sums and Products.  (line  108)
* sumcontract:                           Sums and Products.  (line  203)
* sumexpand:                             Sums and Products.  (line  214)
* summand_to_rec:                        Functions and Variables for solve_rec.
                                                             (line  175)
* summand_to_rec <1>:                    Functions and Variables for solve_rec.
                                                             (line  176)
* sumsplitfact:                          Combinatorial Functions.
                                                             (line  165)
* supcase:                               Functions and Variables for strings.
                                                             (line  261)
* supcase <1>:                           Functions and Variables for strings.
                                                             (line  262)
* supcase <2>:                           Functions and Variables for strings.
                                                             (line  263)
* supcontext:                            Functions and Variables for Facts.
                                                             (line  390)
* supcontext <1>:                        Functions and Variables for Facts.
                                                             (line  391)
* surface_hide:                          Functions and Variables for draw.
                                                             (line 1386)
* symbolp:                               Functions and Variables for Expressions.
                                                             (line 1132)
* symmdifference:                        Functions and Variables for Sets.
                                                             (line 1153)
* symmetric:                             Functions and Variables for Simplification.
                                                             (line  519)
* symmetricp:                            Functions and Variables for ctensor.
                                                             (line  763)
* system:                                Functions and Variables for Runtime Environment.
                                                             (line  107)
* t:                                     Plotting Options.   (line  235)
* tab:                                   Functions and Variables for characters.
                                                             (line   79)
* take_channel:                          Functions and Variables for pictures.
                                                             (line   82)
* take_inference:                        Functions and Variables for inference_result.
                                                             (line   71)
* take_inference <1>:                    Functions and Variables for inference_result.
                                                             (line   72)
* take_inference <2>:                    Functions and Variables for inference_result.
                                                             (line   73)
* tan:                                   Functions and Variables for Trigonometric.
                                                             (line  210)
* tanh:                                  Functions and Variables for Trigonometric.
                                                             (line  213)
* taylor:                                Functions and Variables for Series.
                                                             (line  340)
* taylor <1>:                            Functions and Variables for Series.
                                                             (line  341)
* taylor <2>:                            Functions and Variables for Series.
                                                             (line  342)
* taylor <3>:                            Functions and Variables for Series.
                                                             (line  343)
* taylor <4>:                            Functions and Variables for Series.
                                                             (line  345)
* taylor_logexpand:                      Functions and Variables for Series.
                                                             (line  527)
* taylor_order_coefficients:             Functions and Variables for Series.
                                                             (line  540)
* taylor_simplifier:                     Functions and Variables for Series.
                                                             (line  549)
* taylor_truncate_polynomials:           Functions and Variables for Series.
                                                             (line  554)
* taylordepth:                           Functions and Variables for Series.
                                                             (line  491)
* taylorinfo:                            Functions and Variables for Series.
                                                             (line  497)
* taylorp:                               Functions and Variables for Series.
                                                             (line  522)
* taytorat:                              Functions and Variables for Series.
                                                             (line  563)
* tcl_output:                            Functions and Variables for File Input and Output.
                                                             (line  353)
* tcl_output <1>:                        Functions and Variables for File Input and Output.
                                                             (line  354)
* tcl_output <2>:                        Functions and Variables for File Input and Output.
                                                             (line  355)
* tcontract:                             Functions and Variables for Symmetries.
                                                             (line  244)
* tellrat:                               Functions and Variables for Polynomials.
                                                             (line 1329)
* tellrat <1>:                           Functions and Variables for Polynomials.
                                                             (line 1330)
* tellsimp:                              Functions and Variables for Rules and Patterns.
                                                             (line  569)
* tellsimpafter:                         Functions and Variables for Rules and Patterns.
                                                             (line  626)
* tensorkill:                            Functions and Variables for ctensor.
                                                             (line 1172)
* tentex:                                Functions and Variables for itensor.
                                                             (line 1436)
* tenth:                                 Functions and Variables for Lists.
                                                             (line  490)
* terminal:                              Functions and Variables for draw.
                                                             (line 1403)
* terminal <1>:                          Functions and Variables for graphs.
                                                             (line 1487)
* test_mean:                             Functions and Variables for stats.
                                                             (line   13)
* test_mean <1>:                         Functions and Variables for stats.
                                                             (line   14)
* test_means_difference:                 Functions and Variables for stats.
                                                             (line  112)
* test_means_difference <1>:             Functions and Variables for stats.
                                                             (line  113)
* test_normality:                        Functions and Variables for stats.
                                                             (line  711)
* test_proportion:                       Functions and Variables for stats.
                                                             (line  345)
* test_proportion <1>:                   Functions and Variables for stats.
                                                             (line  346)
* test_proportions_difference:           Functions and Variables for stats.
                                                             (line  437)
* test_proportions_difference <1>:       Functions and Variables for stats.
                                                             (line  438)
* test_rank_sum:                         Functions and Variables for stats.
                                                             (line  645)
* test_rank_sum <1>:                     Functions and Variables for stats.
                                                             (line  646)
* test_sign:                             Functions and Variables for stats.
                                                             (line  520)
* test_sign <1>:                         Functions and Variables for stats.
                                                             (line  521)
* test_signed_rank:                      Functions and Variables for stats.
                                                             (line  570)
* test_signed_rank <1>:                  Functions and Variables for stats.
                                                             (line  571)
* test_variance:                         Functions and Variables for stats.
                                                             (line  216)
* test_variance <1>:                     Functions and Variables for stats.
                                                             (line  217)
* test_variance_ratio:                   Functions and Variables for stats.
                                                             (line  279)
* test_variance_ratio <1>:               Functions and Variables for stats.
                                                             (line  280)
* testsuite_files:                       Functions and Variables for Bug Detection and Reporting.
                                                             (line   45)
* tex:                                   Functions and Variables for File Input and Output.
                                                             (line  493)
* tex <1>:                               Functions and Variables for File Input and Output.
                                                             (line  494)
* tex <2>:                               Functions and Variables for File Input and Output.
                                                             (line  495)
* tex <3>:                               Functions and Variables for File Input and Output.
                                                             (line  496)
* tex <4>:                               Functions and Variables for File Input and Output.
                                                             (line  497)
* tex <5>:                               Functions and Variables for File Input and Output.
                                                             (line  498)
* tex1:                                  Functions and Variables for File Input and Output.
                                                             (line  549)
* texput:                                Functions and Variables for File Input and Output.
                                                             (line  559)
* texput <1>:                            Functions and Variables for File Input and Output.
                                                             (line  560)
* texput <2>:                            Functions and Variables for File Input and Output.
                                                             (line  561)
* texput <3>:                            Functions and Variables for File Input and Output.
                                                             (line  562)
* texput <4>:                            Functions and Variables for File Input and Output.
                                                             (line  563)
* third:                                 Functions and Variables for Lists.
                                                             (line  495)
* throw:                                 Functions and Variables for Program Flow.
                                                             (line  541)
* time:                                  Functions and Variables for Runtime Environment.
                                                             (line  128)
* timedate:                              Functions and Variables for Runtime Environment.
                                                             (line  138)
* timedate <1>:                          Functions and Variables for Runtime Environment.
                                                             (line  139)
* timer:                                 Functions and Variables for Debugging.
                                                             (line   70)
* timer <1>:                             Functions and Variables for Debugging.
                                                             (line   71)
* timer <2>:                             Functions and Variables for Debugging.
                                                             (line   72)
* timer_devalue:                         Functions and Variables for Debugging.
                                                             (line  112)
* timer_info:                            Functions and Variables for Debugging.
                                                             (line  123)
* timer_info <1>:                        Functions and Variables for Debugging.
                                                             (line  124)
* title:                                 Functions and Variables for draw.
                                                             (line 1471)
* tldefint:                              Functions and Variables for Integration.
                                                             (line  521)
* tlimit:                                Functions and Variables for Limits.
                                                             (line   62)
* tlimit <1>:                            Functions and Variables for Limits.
                                                             (line   63)
* tlimit <2>:                            Functions and Variables for Limits.
                                                             (line   64)
* tlimswitch:                            Functions and Variables for Limits.
                                                             (line   69)
* to_lisp:                               Functions and Variables for Command Line.
                                                             (line  567)
* to_poly:                               Functions and Variables for to_poly_solve.
                                                             (line  723)
* to_poly_solve:                         Functions and Variables for to_poly_solve.
                                                             (line  777)
* todd_coxeter:                          Functions and Variables for Groups.
                                                             (line    6)
* todd_coxeter <1>:                      Functions and Variables for Groups.
                                                             (line    7)
* toeplitz:                              Functions and Variables for linearalgebra.
                                                             (line  567)
* toeplitz <1>:                          Functions and Variables for linearalgebra.
                                                             (line  568)
* tokens:                                Functions and Variables for strings.
                                                             (line  271)
* tokens <1>:                            Functions and Variables for strings.
                                                             (line  272)
* topological_sort:                      Functions and Variables for graphs.
                                                             (line 1000)
* totaldisrep:                           Functions and Variables for Polynomials.
                                                             (line 1380)
* totalfourier:                          Functions and Variables for Fourier series.
                                                             (line   82)
* totient:                               Functions and Variables for Number Theory.
                                                             (line  426)
* tpartpol:                              Functions and Variables for Symmetries.
                                                             (line  248)
* tr:                                    Functions and Variables for ctensor.
                                                             (line 1155)
* tr_array_as_ref:                       Functions and Variables for Function Definition.
                                                             (line 1106)
* tr_bound_function_applyp:              Functions and Variables for Function Definition.
                                                             (line 1118)
* tr_file_tty_messagesp:                 Functions and Variables for Function Definition.
                                                             (line 1129)
* tr_float_can_branch_complex:           Functions and Variables for Function Definition.
                                                             (line 1137)
* tr_function_call_default:              Functions and Variables for Function Definition.
                                                             (line 1151)
* tr_numer:                              Functions and Variables for Function Definition.
                                                             (line 1165)
* tr_optimize_max_loop:                  Functions and Variables for Function Definition.
                                                             (line 1171)
* tr_semicompile:                        Functions and Variables for Function Definition.
                                                             (line 1178)
* tr_state_vars:                         Functions and Variables for Function Definition.
                                                             (line 1185)
* tr_warn_bad_function_calls:            Functions and Variables for Function Definition.
                                                             (line 1200)
* tr_warn_fexpr:                         Functions and Variables for Function Definition.
                                                             (line 1206)
* tr_warn_meval:                         Functions and Variables for Function Definition.
                                                             (line 1213)
* tr_warn_mode:                          Functions and Variables for Function Definition.
                                                             (line 1219)
* tr_warn_undeclared:                    Functions and Variables for Function Definition.
                                                             (line 1224)
* tr_warn_undefined_variable:            Functions and Variables for Function Definition.
                                                             (line 1229)
* tr_warnings_get:                       Functions and Variables for Function Definition.
                                                             (line 1196)
* trace:                                 Functions and Variables for Debugging.
                                                             (line  141)
* trace <1>:                             Functions and Variables for Debugging.
                                                             (line  142)
* trace <2>:                             Functions and Variables for Debugging.
                                                             (line  143)
* trace_options:                         Functions and Variables for Debugging.
                                                             (line  169)
* trace_options <1>:                     Functions and Variables for Debugging.
                                                             (line  170)
* tracematrix:                           Package functs.     (line   24)
* transcompile:                          Functions and Variables for Function Definition.
                                                             (line  985)
* transform:                             Functions and Variables for draw.
                                                             (line 1486)
* transform_xy:                          Plotting Options.   (line  241)
* translate:                             Functions and Variables for Function Definition.
                                                             (line  993)
* translate <1>:                         Functions and Variables for Function Definition.
                                                             (line  994)
* translate <2>:                         Functions and Variables for Function Definition.
                                                             (line  995)
* translate_file:                        Functions and Variables for Function Definition.
                                                             (line 1044)
* translate_file <1>:                    Functions and Variables for Function Definition.
                                                             (line 1045)
* transparent:                           Functions and Variables for draw.
                                                             (line 1524)
* transpose:                             Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1127)
* transrun:                              Functions and Variables for Function Definition.
                                                             (line 1099)
* tree_reduce:                           Functions and Variables for Sets.
                                                             (line 1183)
* tree_reduce <1>:                       Functions and Variables for Sets.
                                                             (line 1184)
* treefale:                              Definitions for IFS fractals.
                                                             (line   28)
* treillis:                              Functions and Variables for Symmetries.
                                                             (line  442)
* treinat:                               Functions and Variables for Symmetries.
                                                             (line  450)
* triangle:                              Functions and Variables for draw.
                                                             (line 3086)
* triangularize:                         Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1139)
* trigexpand:                            Functions and Variables for Trigonometric.
                                                             (line  216)
* trigexpandplus:                        Functions and Variables for Trigonometric.
                                                             (line  245)
* trigexpandtimes:                       Functions and Variables for Trigonometric.
                                                             (line  253)
* triginverses:                          Functions and Variables for Trigonometric.
                                                             (line  261)
* trigrat:                               Functions and Variables for Trigonometric.
                                                             (line  306)
* trigreduce:                            Functions and Variables for Trigonometric.
                                                             (line  275)
* trigreduce <1>:                        Functions and Variables for Trigonometric.
                                                             (line  276)
* trigsign:                              Functions and Variables for Trigonometric.
                                                             (line  289)
* trigsimp:                              Functions and Variables for Trigonometric.
                                                             (line  296)
* trivial_solutions:                     Functions and Variables for zeilberger.
                                                             (line  128)
* true:                                  Functions and Variables for Constants.
                                                             (line  104)
* trunc:                                 Functions and Variables for Series.
                                                             (line  567)
* truncated_cube_graph:                  Functions and Variables for graphs.
                                                             (line  281)
* truncated_dodecahedron_graph:          Functions and Variables for graphs.
                                                             (line  284)
* truncated_icosahedron_graph:           Functions and Variables for graphs.
                                                             (line  287)
* truncated_tetrahedron_graph:           Functions and Variables for graphs.
                                                             (line  290)
* ttyoff:                                Functions and Variables for Display.
                                                             (line  526)
* tube:                                  Functions and Variables for draw.
                                                             (line 3116)
* tube_extremes:                         Functions and Variables for draw.
                                                             (line 1541)
* tutte_graph:                           Functions and Variables for graphs.
                                                             (line  293)
* ueivects:                              Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1161)
* ufg:                                   Functions and Variables for ctensor.
                                                             (line 1088)
* uforget:                               Functions and Variables for Units.
                                                             (line  111)
* ug:                                    Functions and Variables for ctensor.
                                                             (line 1121)
* ultraspherical:                        Functions and Variables for orthogonal polynomials.
                                                             (line  197)
* und:                                   Functions and Variables for Constants.
                                                             (line  109)
* Undefined:                             Functions and Variables for Constants.
                                                             (line  110)
* underlying_graph:                      Functions and Variables for graphs.
                                                             (line  296)
* undiff:                                Functions and Variables for itensor.
                                                             (line  626)
* union:                                 Functions and Variables for Sets.
                                                             (line 1216)
* unique:                                Functions and Variables for Lists.
                                                             (line  476)
* unit_step:                             Functions and Variables for orthogonal polynomials.
                                                             (line  190)
* unit_vectors:                          Functions and Variables for draw.
                                                             (line 1556)
* uniteigenvectors:                      Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1160)
* unitp:                                 Functions and Variables for ezunits.
                                                             (line  398)
* units:                                 Functions and Variables for ezunits.
                                                             (line  290)
* unitvector:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1186)
* unknown:                               Functions and Variables for Predicates.
                                                             (line  212)
* unless:                                Functions and Variables for Program Flow.
                                                             (line  547)
* unorder:                               Functions and Variables for Expressions.
                                                             (line 1140)
* unsum:                                 Functions and Variables for Series.
                                                             (line  584)
* untellrat:                             Functions and Variables for Polynomials.
                                                             (line 1389)
* untimer:                               Functions and Variables for Debugging.
                                                             (line   97)
* untimer <1>:                           Functions and Variables for Debugging.
                                                             (line   98)
* untrace:                               Functions and Variables for Debugging.
                                                             (line  222)
* untrace <1>:                           Functions and Variables for Debugging.
                                                             (line  223)
* uppercasep:                            Functions and Variables for characters.
                                                             (line   82)
* uric:                                  Functions and Variables for ctensor.
                                                             (line 1112)
* uricci:                                Functions and Variables for ctensor.
                                                             (line  188)
* uriem:                                 Functions and Variables for ctensor.
                                                             (line 1104)
* uriemann:                              Functions and Variables for ctensor.
                                                             (line  247)
* use_fast_arrays:                       Functions and Variables for Arrays.
                                                             (line  436)
* user_preamble:                         Functions and Variables for draw.
                                                             (line 1577)
* usersetunits:                          Functions and Variables for Units.
                                                             (line  205)
* uvect:                                 Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1187)
* values:                                Functions and Variables for Command Line.
                                                             (line  596)
* vandermonde_matrix:                    Functions and Variables for linearalgebra.
                                                             (line  588)
* var:                                   Functions and Variables for descriptive statistics.
                                                             (line   31)
* var <1>:                               Functions and Variables for descriptive statistics.
                                                             (line   32)
* var_bernoulli:                         Functions and Variables for discrete distributions.
                                                             (line  233)
* var_beta:                              Functions and Variables for continuous distributions.
                                                             (line  787)
* var_binomial:                          Functions and Variables for discrete distributions.
                                                             (line  113)
* var_chi2:                              Functions and Variables for continuous distributions.
                                                             (line  301)
* var_continuous_uniform:                Functions and Variables for continuous distributions.
                                                             (line  836)
* var_discrete_uniform:                  Functions and Variables for discrete distributions.
                                                             (line  367)
* var_exp:                               Functions and Variables for continuous distributions.
                                                             (line  563)
* var_f:                                 Functions and Variables for continuous distributions.
                                                             (line  463)
* var_gamma:                             Functions and Variables for continuous distributions.
                                                             (line  728)
* var_general_finite_discrete:           Functions and Variables for discrete distributions.
                                                             (line   52)
* var_geometric:                         Functions and Variables for discrete distributions.
                                                             (line  321)
* var_gumbel:                            Functions and Variables for continuous distributions.
                                                             (line 1256)
* var_hypergeometric:                    Functions and Variables for discrete distributions.
                                                             (line  420)
* var_laplace:                           Functions and Variables for continuous distributions.
                                                             (line 1182)
* var_logistic:                          Functions and Variables for continuous distributions.
                                                             (line  885)
* var_lognormal:                         Functions and Variables for continuous distributions.
                                                             (line  676)
* var_negative_binomial:                 Functions and Variables for discrete distributions.
                                                             (line  482)
* var_noncentral_chi2:                   Functions and Variables for continuous distributions.
                                                             (line  401)
* var_noncentral_student_t:              Functions and Variables for continuous distributions.
                                                             (line  197)
* var_normal:                            Functions and Variables for continuous distributions.
                                                             (line   42)
* var_pareto:                            Functions and Variables for continuous distributions.
                                                             (line  931)
* var_poisson:                           Functions and Variables for discrete distributions.
                                                             (line  168)
* var_rayleigh:                          Functions and Variables for continuous distributions.
                                                             (line 1070)
* var_student_t:                         Functions and Variables for continuous distributions.
                                                             (line  100)
* var_weibull:                           Functions and Variables for continuous distributions.
                                                             (line  976)
* var1:                                  Functions and Variables for descriptive statistics.
                                                             (line   51)
* var1 <1>:                              Functions and Variables for descriptive statistics.
                                                             (line   52)
* vect_cross:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1236)
* vector:                                Functions and Variables for draw.
                                                             (line 3139)
* vector <1>:                            Functions and Variables for draw.
                                                             (line 3140)
* vectorpotential:                       Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1195)
* vectorpotential <1>:                   Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1201)
* vectorsimp:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1206)
* verbify:                               Functions and Variables for Expressions.
                                                             (line 1176)
* verbose:                               Functions and Variables for Series.
                                                             (line  614)
* vers:                                  Package functs.     (line  134)
* vertex_color:                          Functions and Variables for graphs.
                                                             (line 1405)
* vertex_coloring:                       Functions and Variables for graphs.
                                                             (line 1431)
* vertex_coloring <1>:                   Functions and Variables for graphs.
                                                             (line 1085)
* vertex_connectivity:                   Functions and Variables for graphs.
                                                             (line 1018)
* vertex_degree:                         Functions and Variables for graphs.
                                                             (line 1023)
* vertex_distance:                       Functions and Variables for graphs.
                                                             (line 1026)
* vertex_eccentricity:                   Functions and Variables for graphs.
                                                             (line 1037)
* vertex_in_degree:                      Functions and Variables for graphs.
                                                             (line 1047)
* vertex_out_degree:                     Functions and Variables for graphs.
                                                             (line 1066)
* vertex_partition:                      Functions and Variables for graphs.
                                                             (line 1425)
* vertex_size:                           Functions and Variables for graphs.
                                                             (line 1402)
* vertex_type:                           Functions and Variables for graphs.
                                                             (line 1396)
* vertices:                              Functions and Variables for graphs.
                                                             (line 1077)
* vertices_to_cycle:                     Functions and Variables for graphs.
                                                             (line 1510)
* vertices_to_path:                      Functions and Variables for graphs.
                                                             (line 1506)
* view:                                  Functions and Variables for draw.
                                                             (line 1599)
* warnings:                              Functions and Variables for zeilberger.
                                                             (line  115)
* Wedge product:                         Functions and Variables for itensor.
                                                             (line 1292)
* weyl:                                  Functions and Variables for ctensor.
                                                             (line 1125)
* weyl <1>:                              Functions and Variables for ctensor.
                                                             (line  260)
* wheel_graph:                           Functions and Variables for graphs.
                                                             (line  299)
* while:                                 Functions and Variables for Program Flow.
                                                             (line  546)
* wiener_index:                          Functions and Variables for graphs.
                                                             (line 1097)
* with_stdout:                           Functions and Variables for File Input and Output.
                                                             (line  761)
* with_stdout <1>:                       Functions and Variables for File Input and Output.
                                                             (line  762)
* write_binary_data:                     Functions and Variables for binary input and output.
                                                             (line   60)
* write_data:                            Functions and Variables for plain-text input and output.
                                                             (line   85)
* write_data <1>:                        Functions and Variables for plain-text input and output.
                                                             (line   86)
* writefile:                             Functions and Variables for File Input and Output.
                                                             (line  790)
* wronskian:                             Package functs.     (line   14)
* x:                                     Plotting Options.   (line  252)
* x_voxel:                               Functions and Variables for draw.
                                                             (line 1615)
* xaxis:                                 Functions and Variables for draw.
                                                             (line 1622)
* xaxis_color:                           Functions and Variables for draw.
                                                             (line 1639)
* xaxis_secondary:                       Functions and Variables for draw.
                                                             (line 1657)
* xaxis_type:                            Functions and Variables for draw.
                                                             (line 1682)
* xaxis_width:                           Functions and Variables for draw.
                                                             (line 1700)
* xlabel:                                Plotting Options.   (line  260)
* xlabel <1>:                            Functions and Variables for draw.
                                                             (line 1717)
* xrange:                                Functions and Variables for draw.
                                                             (line 1735)
* xrange_secondary:                      Functions and Variables for draw.
                                                             (line 1754)
* xreduce:                               Functions and Variables for Sets.
                                                             (line 1242)
* xreduce <1>:                           Functions and Variables for Sets.
                                                             (line 1243)
* xthru:                                 Functions and Variables for Simplification.
                                                             (line  526)
* xtics:                                 Functions and Variables for draw.
                                                             (line 1770)
* xtics_axis:                            Functions and Variables for draw.
                                                             (line 1830)
* xtics_rotate:                          Functions and Variables for draw.
                                                             (line 1840)
* xtics_rotate_secondary:                Functions and Variables for draw.
                                                             (line 1849)
* xtics_secondary:                       Functions and Variables for draw.
                                                             (line 1858)
* xtics_secondary_axis:                  Functions and Variables for draw.
                                                             (line 1866)
* xu_grid:                               Functions and Variables for draw.
                                                             (line 1876)
* xy_file:                               Functions and Variables for draw.
                                                             (line 1894)
* xyplane:                               Functions and Variables for draw.
                                                             (line 1903)
* y:                                     Plotting Options.   (line  269)
* y_voxel:                               Functions and Variables for draw.
                                                             (line 1919)
* yaxis:                                 Functions and Variables for draw.
                                                             (line 1926)
* yaxis_color:                           Functions and Variables for draw.
                                                             (line 1943)
* yaxis_secondary:                       Functions and Variables for draw.
                                                             (line 1961)
* yaxis_type:                            Functions and Variables for draw.
                                                             (line 1984)
* yaxis_width:                           Functions and Variables for draw.
                                                             (line 2002)
* ylabel:                                Plotting Options.   (line  274)
* ylabel <1>:                            Functions and Variables for draw.
                                                             (line 2019)
* yrange:                                Functions and Variables for draw.
                                                             (line 2037)
* yrange_secondary:                      Functions and Variables for draw.
                                                             (line 2057)
* ytics:                                 Functions and Variables for draw.
                                                             (line 2084)
* ytics_axis:                            Functions and Variables for draw.
                                                             (line 2092)
* ytics_rotate:                          Functions and Variables for draw.
                                                             (line 2102)
* ytics_rotate_secondary:                Functions and Variables for draw.
                                                             (line 2111)
* ytics_secondary:                       Functions and Variables for draw.
                                                             (line 2120)
* ytics_secondary_axis:                  Functions and Variables for draw.
                                                             (line 2128)
* yv_grid:                               Functions and Variables for draw.
                                                             (line 2138)
* z:                                     Plotting Options.   (line  283)
* z_voxel:                               Functions and Variables for draw.
                                                             (line 2156)
* zaxis:                                 Functions and Variables for draw.
                                                             (line 2162)
* zaxis_color:                           Functions and Variables for draw.
                                                             (line 2181)
* zaxis_type:                            Functions and Variables for draw.
                                                             (line 2201)
* zaxis_width:                           Functions and Variables for draw.
                                                             (line 2220)
* Zeilberger:                            Functions and Variables for zeilberger.
                                                             (line   74)
* zeroa:                                 Functions and Variables for Constants.
                                                             (line  120)
* zerob:                                 Functions and Variables for Constants.
                                                             (line  136)
* zerobern:                              Functions and Variables for Number Theory.
                                                             (line  430)
* zeroequiv:                             Functions and Variables for Predicates.
                                                             (line  217)
* zerofor:                               Functions and Variables for linearalgebra.
                                                             (line  593)
* zerofor <1>:                           Functions and Variables for linearalgebra.
                                                             (line  594)
* zeromatrix:                            Functions and Variables for Matrices and Linear Algebra.
                                                             (line 1243)
* zeromatrixp:                           Functions and Variables for linearalgebra.
                                                             (line  605)
* zeta:                                  Functions and Variables for Number Theory.
                                                             (line  436)
* zeta%pi:                               Functions and Variables for Number Theory.
                                                             (line  465)
* zlabel:                                Plotting Options.   (line  287)
* zlabel <1>:                            Functions and Variables for draw.
                                                             (line 2239)
* zlange:                                Functions and Variables for lapack.
                                                             (line  261)
* zrange:                                Functions and Variables for draw.
                                                             (line 2258)
* ztics:                                 Functions and Variables for draw.
                                                             (line 2279)
* ztics_axis:                            Functions and Variables for draw.
                                                             (line 2287)
* ztics_rotate:                          Functions and Variables for draw.
                                                             (line 2297)
* かけ算:                                Arithmetic operators.
                                                             (line    9)
* クォートクォート演算子:                Functions and Variables for Evaluation.
                                                             (line   98)
* クォート演算子:                        Functions and Variables for Evaluation.
                                                             (line    7)
* べき乗:                                Arithmetic operators.
                                                             (line   11)
* マクロ関数定義の演算子:                Assignment operators.
                                                             (line  112)
* 不等号（構文的不等号）:                Operators for Equations.
                                                             (line    7)
* 二重階乗:                              Combinatorial Functions.
                                                             (line    7)
* 以上:                                  Relational operators.
                                                             (line    9)
* 以下:                                  Relational operators.
                                                             (line    8)
* 割り当て演算子:                        Assignment operators.
                                                             (line    7)
* 割り当て演算子 (左辺を評価する):       Assignment operators.
                                                             (line   86)
* 割り算:                                Arithmetic operators.
                                                             (line   10)
* 大なり:                                Relational operators.
                                                             (line   10)
* 小なり:                                Relational operators.
                                                             (line    7)
* 引き算:                                Arithmetic operators.
                                                             (line    8)
* 等号 (構文法的に等しい):               Operators for Equations.
                                                             (line   29)
* 等式演算子:                            Operators for Equations.
                                                             (line   29)
* 論理否定:                              Logical operators.  (line   28)
* 論理和:                                Logical operators.  (line   41)
* 論理積:                                Logical operators.  (line    7)
* 足し算:                                Arithmetic operators.
                                                             (line    7)
* 関数定義演算子:                        Assignment operators.
                                                             (line  184)
* 階乗:                                  Combinatorial Functions.
                                                             (line   51)
* 非可換かけ算:                          Arithmetic operators.
                                                             (line  198)
* 非可換べき乗:                          Arithmetic operators.
                                                             (line  181)


File: maxima.info,  Node: Translator's Comments,  Prev: Function and Variable Index,  Up: Top

Appendix A Translator's Comments
********************************

* Menu:

* Translation Policies::
* About Terms in Japanese::


File: maxima.info,  Node: Translation Policies,  Next: About Terms in Japanese,  Up: Translator's Comments

A.1 Translation Policies
========================

とにかく、質より量ということで訳を進めました。品質を高めるべく、少しずつ
見直しを進めています。 訳者自身が意味を理解していない文もありましたので
、誤訳、迷訳についてはご指摘いただければ幸いです。

   できるだけ多くの人に参考になるようにと、章のレベルに応じて、訳語を変
えたところがあります。 例えば、足し算と加算を使い分けたりしました。その
結果、文体に一貫性が欠ける部分があるかと思いますが、意図を汲み取っていた
だければ幸いです。

   章や節などのノード名は、訳すとtexi2htmlに不具合があるので、英文そのま
まとしました。


File: maxima.info,  Node: About Terms in Japanese,  Prev: Translation Policies,  Up: Translator's Comments

A.2 About Terms in Japanese
===========================

simplification
     simplificationとevaluationがMaximaの基礎となっていますが、
     simplificationは、対応する日本語がないと思いました。Maximaに関する
     他の記事では、簡易化、簡素化、簡単化などと訳されているようです。一
     番近いニュアンスは、「式の整理をすること」と思いましたので、「整理
     」もしくは「式整理」と訳しました。 reduceの訳語には簡約を使いました
     。
function
     functionは、数学的な定義に基づく場合とプログラミング的な定義に基づ
     く場合があるので、前者を函数、後者を関数と漢字を充てました。


Tag Table:
Node: Top264
Node: Introduction to Maxima14685
Node: Bug Detection and Reporting21876
Node: Functions and Variables for Bug Detection and Reporting22118
Ref: run_testsuite22358
Ref: testsuite_files24737
Ref: bug_report25532
Ref: build_info26043
Node: Help26267
Node: Documentation26448
Node: Functions and Variables for Help27715
Ref: apropos27885
Ref: demo29222
Ref: describe30640
Ref: example33879
Ref: manual_demo35581
Node: Command Line35849
Node: Introduction to Command Line36107
Node: Functions and Variables for Command Line36321
Ref: __36582
Ref: _38595
Ref: %40286
Ref: %%41050
Ref: %th42788
Ref: ?44124
Ref: ??44876
Ref: inchar45279
Ref: infolists46374
Ref: kill49005
Ref: labels52649
Ref: linechar54822
Ref: linenum55823
Ref: myoptions55911
Ref: nolabels56150
Ref: optionset57145
Ref: outchar57826
Ref: playback58925
Ref: prompt61338
Ref: quit61615
Ref: read62180
Ref: readonly62777
Ref: reset63485
Ref: showtime64124
Ref: to_lisp64571
Ref: values65722
Node: Functions and Variables for Display67060
Ref: %edispflag67274
Ref: absboxchar67954
Ref: disp68284
Ref: display69015
Ref: display2d69944
Ref: display_format_internal70468
Ref: dispterms71162
Ref: expt72131
Ref: ncexpt72131
Ref: exptdispflag72477
Ref: grind73164
Ref: ibase77975
Ref: ldisp79999
Ref: ldisplay81173
Ref: linel82561
Ref: lispdisp83092
Ref: negsumdispflag83629
Ref: obase84090
Ref: pfeformat85378
Ref: powerdisp86190
Ref: print86614
Ref: sqrtdispflag88085
Ref: stardisp88275
Ref: ttyoff88481
Node: Data Types and Structures88934
Node: Numbers89181
Node: Introduction to Numbers89403
Node: Functions and Variables for Numbers90155
Ref: bfloat90351
Ref: bfloatp90851
Ref: bftorat91008
Ref: bftrunc91472
Ref: evenp91894
Ref: float92038
Ref: float2bf92311
Ref: floatnump92670
Ref: fpprec92824
Ref: fpprintprec93151
Ref: integerp94089
Ref: m1pbranch95089
Ref: numberp95826
Ref: numer97168
Ref: numer_pbranch97952
Ref: numerval98917
Ref: oddp99446
Ref: ratepsilon99590
Ref: rationalize99777
Ref: ratnump103001
Node: Strings103192
Node: Introduction to Strings103398
Node: Functions and Variables for Strings105828
Ref: concat106024
Ref: sconcat107495
Ref: string107800
Ref: stringdisp108046
Node: Constants108896
Node: Functions and Variables for Constants109078
Ref: %e109264
Ref: %i109450
Ref: false109523
Ref: %gamma109696
Ref: ind109767
Ref: inf109998
Ref: infinity110076
Ref: minf110161
Ref: %phi110274
Ref: %pi112846
Ref: true113013
Ref: und113178
Ref: zeroa113405
Ref: zerob113908
Node: Lists114188
Node: Introduction to Lists114383
Node: Functions and Variables for Lists115479
Ref: [115665
Ref: ]115665
Ref: append116820
Ref: assoc117216
Ref: cons117922
Ref: copylist118202
Ref: create_list118286
Ref: delete119677
Ref: eighth122367
Ref: endcons122523
Ref: fifth122778
Ref: first122940
Ref: fourth123887
Ref: join124050
Ref: last124859
Ref: length124959
Ref: listarith125682
Ref: makelist126262
Ref: member127089
Ref: ninth128647
Ref: pop128802
Ref: push129359
Ref: rest130915
Ref: reverse131293
Ref: second131551
Ref: seventh131716
Ref: sixth131880
Ref: sort132042
Ref: sublist135444
Ref: sublist_indices135759
Ref: unique136901
Ref: tenth137353
Ref: third137509
Node: Arrays137666
Node: Functions and Variables for Arrays137839
Ref: array138010
Ref: arrayapply139737
Ref: arrayinfo140057
Ref: arraymake144170
Ref: arrays145979
Ref: fillarray147225
Ref: listarray149508
Ref: make_array153450
Ref: rearray155694
Ref: remarray156093
Ref: subvar156821
Ref: subvarp157568
Ref: use_fast_arrays157715
Node: Structures159756
Node: Introduction to Structures159958
Node: Functions and Variables for Structures161906
Node: Expressions166676
Node: Introduction to Expressions166945
Node: Nouns and Verbs168574
Node: Identifiers171405
Node: Inequality173879
Node: Functions and Variables for Expressions174222
Ref: alias174417
Ref: aliases174664
Ref: allbut175058
Ref: args176201
Ref: atom176869
Ref: box177244
Ref: boxchar179427
Ref: collapse179793
Ref: disolate180529
Ref: dispform181086
Ref: dpart183019
Ref: exptisolate183631
Ref: exptsubst183872
Ref: freeof184089
Ref: inflag188106
Ref: inpart189243
Ref: isolate190550
Ref: isolate_wrt_times191596
Ref: listconstvars192411
Ref: listdummyvars192848
Ref: listofvars193620
Ref: lfreeof194377
Ref: lpart194692
Ref: mainvar194992
Ref: noun195892
Ref: noundisp196151
Ref: nounify196418
Ref: nterms196940
Ref: op197328
Ref: operatorp199263
Ref: option_opsubst199640
Ref: optimize199925
Ref: optimprefix200343
Ref: ordergreat200562
Ref: orderless200562
Ref: ordergreatp201647
Ref: orderlessp201647
Ref: part205973
Ref: partition207739
Ref: partswitch208330
Ref: pickapart208618
Ref: piece211666
Ref: psubst211889
Ref: rembox212742
Ref: reveal216018
Ref: sublis218706
Ref: sublis_apply_lambda219193
Ref: subnumsimp219573
Ref: subst220217
Ref: substinpart222864
Ref: substpart225517
Ref: symbolp226861
Ref: unorder227159
Ref: verbify228785
Node: Operators229180
Node: Introduction to operators229485
Node: Arithmetic operators234120
Ref: +234300
Ref: -234300
Ref: *234300
Ref: /234300
Ref: ^234300
Ref: **241926
Ref: ^^242751
Ref: .243490
Node: Relational operators244004
Ref: <244176
Ref: <=244176
Ref: >=244176
Ref: >244176
Node: Logical operators247126
Ref: and247295
Ref: not248585
Ref: or249304
Node: Operators for Equations250584
Ref: #250765
Ref: =251509
Node: Assignment operators256183
Ref: :256363
Ref: ::259226
Ref: ::=259984
Ref: :=263371
Node: User defined operators266503
Ref: infix266655
Ref: matchfix271109
Ref: operator_nary276214
Ref: nofix276920
Ref: postfix277518
Ref: prefix277995
Node: Evaluation278372
Node: Functions and Variables for Evaluation278543
Ref: quote278734
Ref: quote-quote282550
Ref: ev288681
Ref: eval299028
Ref: evflag299637
Ref: evfun302249
Ref: infeval305173
Ref: noeval305618
Ref: nouns305873
Ref: pred306321
Node: Simplification306753
Node: Functions and Variables for Simplification306949
Ref: additive307160
Ref: antisymmetric307895
Ref: commutative308460
Ref: demoivre308729
Ref: function_distrib309521
Ref: distribute_over310438
Ref: domain312395
Ref: evenfun312631
Ref: oddfun312631
Ref: expand313322
Ref: expandwrt317404
Ref: expandwert_denom317999
Ref: expandwrt_factored318409
Ref: expon318776
Ref: exponentialize319080
Ref: expop319732
Ref: lassociative320212
Ref: linear320464
Ref: maxnegex321163
Ref: maxposex321397
Ref: multiplicative321613
Ref: multthru322411
Ref: declaration_nary324847
Ref: negdistrib325685
Ref: opproperties326297
Ref: outative326670
Ref: radcan327662
Ref: radexpand328926
Ref: rassociative330040
Ref: scsimp330290
Ref: simp330820
Ref: symmetric332335
Ref: xthru332616
Node: Mathematical Functions333771
Node: Functions for Numbers334126
Ref: abs334330
Ref: ceiling334627
Ref: entier336644
Ref: floor336857
Ref: fix338846
Ref: lmax338911
Ref: lmin339110
Ref: max339309
Ref: min339856
Ref: round340474
Ref: signum340736
Node: Functions for Complex Numbers341613
Ref: cabs341834
Ref: conjugate343027
Ref: imagpart343561
Ref: polarform343835
Ref: realpart344000
Ref: rectform344232
Node: Combinatorial Functions344374
Ref: !!344604
Ref: binomial345385
Ref: factcomb346363
Ref: !346731
Ref: factorial346731
Ref: factlim350862
Ref: factorial_expand351081
Ref: genfact351353
Ref: minfactorial351649
Ref: sumsplitfact352214
Node: Root Exponential and Logarithmic Functions352414
Ref: %e_to_numlog352678
Ref: %emode353140
Ref: %enumer353883
Ref: exp354325
Ref: li355122
Ref: log357754
Ref: logabs359752
Ref: logarc360234
Ref: logconcoeffp360691
Ref: logcontract361216
Ref: logexpand362330
Ref: lognegint362977
Ref: lognumer363188
Ref: logsimp363547
Ref: plog363721
Ref: sqrt363878
Node: Trigonometric Functions364305
Node: Introduction to Trigonometric364610
Node: Functions and Variables for Trigonometric365887
Ref: %piargs366125
Ref: %iargs368163
Ref: halfangles370600
Ref: trigexpand373406
Ref: trigexpandplus374999
Ref: trigexpandtimes375422
Ref: triginverses375853
Ref: trigreduce376430
Ref: trigsign377105
Ref: trigsimp377398
Ref: trigrat377854
Node: Random Numbers380780
Ref: make_random_state380926
Ref: set_random_state381880
Ref: random382042
Node: Maximas Database383727
Node: Introduction to Maximas Database384043
Node: Functions and Variables for Properties384277
Ref: declare384540
Ref: features396741
Ref: get398204
Ref: nonarray399244
Ref: posfun399845
Ref: printprops400005
Node: Functions and Variables for Facts400658
Ref: activate400917
Ref: activecontexts401399
Ref: askexp401723
Ref: askinteger402030
Ref: asksign402798
Ref: assume403243
Ref: assumescalar405918
Ref: assume_pos407174
Ref: assume_pos_pred408572
Ref: context411013
Ref: option_contexts411822
Ref: deactivate413708
Ref: facts413854
Ref: forget414411
Ref: is414806
Ref: killcontext416948
Ref: maybe417881
Ref: newcontext418801
Ref: sign419183
Ref: supcontext419611
Node: Functions and Variables for Predicates419962
Ref: charfun420184
Ref: compare420838
Ref: constant422043
Ref: constantp422206
Ref: equal423479
Ref: notequal428159
Ref: unknown429090
Ref: zeroequiv429246
Node: Plotting430537
Node: Introduction to Plotting430842
Node: Plotting Formats432916
Node: Functions and Variables for Plotting436561
Ref: contour_plot436777
Ref: get_plot_option438214
Ref: make_transform438668
Ref: polar_to_xy439477
Ref: plot2d439796
Ref: plot3d447204
Ref: plot_options452453
Ref: set_plot_option453633
Ref: spherical_to_xyz455107
Node: Plotting Options455531
Ref: axes456279
Ref: azimut456767
Ref: option_box457385
Ref: color457655
Ref: colorbox458624
Ref: elevation459100
Ref: grid459653
Ref: legend459872
Ref: logx460570
Ref: logy460749
Ref: mesh_lines_color460928
Ref: nticks461376
Ref: palette461797
Ref: plot_format463363
Ref: plot_real_part463713
Ref: point_type464545
Ref: psfile465315
Ref: run_viewer465800
Ref: style466020
Ref: t468489
Ref: transform_xy468645
Ref: x469091
Ref: xlabel469600
Ref: y470180
Ref: ylabel470518
Ref: z471100
Ref: zlabel471266
Node: Gnuplot Options471755
Ref: gnuplot_out_file474365
Ref: gnuplot_pm3d474974
Ref: gnuplot_preamble475177
Ref: gnuplot_curve_titles475634
Ref: gnuplot_curve_styles475791
Ref: gnuplot_default_term_command475947
Ref: gnuplot_dumb_term_command476151
Ref: gnuplot_ps_term_command476432
Node: Gnuplot_pipes Format Functions476969
Ref: gnuplot_start477141
Ref: gnuplot_close477376
Ref: gnuplot_restart477505
Ref: gnuplot_replot477676
Ref: gnuplot_reset478007
Node: File Input and Output478283
Node: Comments478519
Node: Files480010
Node: Functions and Variables for File Input and Output481063
Ref: appendfile481295
Ref: batch481697
Ref: batchload485238
Ref: closefile486045
Ref: file_output_append486200
Ref: filename_merge487053
Ref: file_search487504
Ref: file_search_maxima490196
Ref: file_search_lisp490196
Ref: file_search_demo490196
Ref: file_search_usage490196
Ref: file_search_tests490196
Ref: file_type492226
Ref: file_type_lisp493372
Ref: file_type_maxima493664
Ref: load493988
Ref: load_pathname495930
Ref: loadfile496928
Ref: loadprint497538
Ref: packagefile498340
Ref: pathname_directory499458
Ref: pathname_name499458
Ref: pathname_type499458
Ref: printfile500019
Ref: tcl_output500891
Ref: save502192
Ref: stringout506001
Ref: tex508899
Ref: tex1511478
Ref: texput511774
Ref: get_tex_environment517098
Ref: get_tex_enviroment_default518505
Ref: with_stdout519869
Ref: writefile521311
Node: Polynomials523004
Node: Introduction to Polynomials523228
Node: Functions and Variables for Polynomials526386
Ref: algebraic526600
Ref: ezgcd534169
Ref: factor535775
Ref: gcd548493
Ref: gcdex550973
Ref: lowpow556684
Ref: polydecomp559733
Ref: polymod561845
Ref: powers562210
Ref: quotient562348
Ref: ratfac574014
Ref: ratsimp576588
Ref: radsubstflag579076
Ref: ratsubst579339
Ref: sqfr587719
Node: Special Functions591567
Node: Introduction to Special Functions592014
Node: Bessel Functions593623
Ref: bessel_j593803
Ref: bessel_y594345
Ref: bessel_i594785
Ref: bessel_k595327
Ref: hankel_1595781
Ref: hankel_2597865
Ref: besselexpand598674
Node: Airy Functions600552
Node: Gamma and factorial Functions601864
Ref: bffac602263
Ref: bfpsi602523
Ref: cbffac602960
Ref: gamma603116
Ref: gammalim608030
Ref: makegamma608561
Node: Exponential Integrals633227
Node: Error Function634604
Node: Struve Functions636555
Node: Hypergeometric Functions637226
Node: Parabolic Cylinder Functions639808
Node: Functions and Variables for Special Functions640444
Node: Elliptic Functions647511
Node: Introduction to Elliptic Functions and Integrals647820
Node: Functions and Variables for Elliptic Functions651644
Node: Functions and Variables for Elliptic Integrals653986
Ref: elliptic_f654232
Ref: elliptic_e654466
Ref: elliptic_eu654719
Ref: elliptic_kc655374
Ref: elliptic_ec655710
Node: Limits656044
Node: Functions and Variables for Limits656211
Ref: lhospitallim656384
Ref: limit656667
Ref: limsubst659023
Ref: tlimit659476
Ref: tlimswitch659728
Node: Differentiation660244
Node: Functions and Variables for Differentiation660431
Ref: antid660649
Ref: antidiff663180
Ref: at665543
Ref: atomgrad667540
Ref: atvalue667727
Ref: cartan670387
Ref: del671032
Ref: delta671722
Ref: dependencies672086
Ref: depends672545
Ref: derivabrev675368
Ref: derivdegree675711
Ref: derivlist676280
Ref: derivsubst676432
Ref: diff676681
Ref: symbol_diff680257
Ref: dscalar680458
Ref: express680647
Ref: gradef683508
Ref: gradefs685635
Ref: laplace685929
Node: Integration690713
Node: Introduction to Integration690993
Node: Functions and Variables for Integration692137
Ref: changevar692384
Ref: defint697831
Ref: erfflag698501
Ref: ilt698765
Ref: intanalysis700967
Ref: integrate702540
Ref: integration_constant711749
Ref: integration_constant_counter712638
Ref: integrate_use_rootsof713985
Ref: ldefint716404
Ref: potential717286
Ref: residue717886
Ref: risch718550
Ref: tldefint719736
Node: Introduction to QUADPACK719873
Ref: Introduction to QUADPACK-Footnote-1723751
Ref: Introduction to QUADPACK-Footnote-2723817
Ref: Introduction to QUADPACK-Footnote-3723883
Ref: Introduction to QUADPACK-Footnote-4723927
Ref: Introduction to QUADPACK-Footnote-5723989
Ref: Introduction to QUADPACK-Footnote-6724028
Ref: Introduction to QUADPACK-Footnote-7724069
Node: Functions and Variables for QUADPACK724254
Ref: quad_qag724456
Ref: quad_qags727412
Ref: quad_qagi729762
Ref: quad_qawc732422
Ref: quad_qawf735895
Ref: quad_qawo738980
Ref: quad_qaws742251
Node: Equations745390
Node: Functions and Variables for Equations745569
Ref: %rnum_list745757
Ref: algepsilon746855
Ref: algexact746989
Ref: algsys747830
Ref: allroots753141
Ref: bfallroots755641
Ref: backsubst756094
Ref: breakup756860
Ref: dimension760253
Ref: dispflag760552
Ref: funcsolve760897
Ref: globalsolve761929
Ref: ieqn764080
Ref: ieqnprint765773
Ref: lhs766634
Ref: linsolve768312
Ref: linsolvewarn771459
Ref: linsolve_params771674
Ref: multiplicities772157
Ref: nroots772394
Ref: nthroot772870
Ref: polyfactor773253
Ref: programmode773646
Ref: realonly774253
Ref: realroots774466
Ref: rhs776768
Ref: rootsconmode778445
Ref: rootscontract778693
Ref: rootsepsilon781562
Ref: solve781780
Ref: solveexplicit789531
Ref: solvefactors789806
Ref: solvenullwarn790123
Ref: solveradcan790531
Ref: solvetrigwarn790830
Node: Differential Equations791149
Node: Introduction to Differential Equations791408
Node: Functions and Variables for Differential Equations792087
Node: Numerical800189
Node: Introduction to fast Fourier transform800522
Node: Functions and Variables for fast Fourier transform800905
Ref: polartorect801200
Ref: recttopolar801911
Ref: inverse_fft802717
Ref: fft805185
Ref: fortindent809310
Ref: fortran809665
Ref: fortspaces812328
Ref: horner812546
Ref: find_root813759
Ref: bf_find_root813759
Ref: find_root_error813759
Ref: find_root_abs813759
Ref: find_root_rel813759
Ref: newton818240
Node: Introduction to Fourier series819666
Node: Functions and Variables for Fourier series820185
Ref: equalp820409
Ref: remfun820671
Ref: funp821017
Ref: absint821402
Ref: fourier822102
Ref: foursimp822252
Ref: sinnpiflag822477
Ref: cosnpiflag822603
Ref: fourexpand822729
Ref: fourcos823017
Ref: foursin823163
Ref: totalfourier823300
Ref: fourint823442
Ref: fourintcos823604
Ref: forintsin823731
Node: Matrices and Linear Algebra823855
Node: Introduction to Matrices and Linear Algebra824136
Node: Dot824482
Node: Vectors826170
Node: eigen827604
Node: Functions and Variables for Matrices and Linear Algebra828690
Ref: addcol828984
Ref: addrow829147
Ref: adjoint829310
Ref: augcoefmatrix829459
Ref: cauchy_matrix830097
Ref: charpoly831509
Ref: coefmatrix833130
Ref: col833562
Ref: columnvector833670
Ref: covect833670
Ref: copymatrix834641
Ref: determinant835291
Ref: detout835674
Ref: diagmatrix836842
Ref: doallmxops837489
Ref: domxexpt837817
Ref: domxmxops839226
Ref: domxnctimes839578
Ref: dontfactor839747
Ref: doscmxops840241
Ref: doscmxplus840410
Ref: dot0nscsimp840690
Ref: dot0simp840900
Ref: dot1simp841102
Ref: dotassoc841303
Ref: dotconstrules841476
Ref: dotdistrib841873
Ref: dotexptsimp842061
Ref: dotident842233
Ref: dotscrules842352
Ref: echelon842602
Ref: eigenvalues844092
Ref: eivals844092
Ref: eigenvectors845756
Ref: eivects845756
Ref: ematrix851027
Ref: entermatrix851203
Ref: genmatrix852715
Ref: gramschmidt855659
Ref: ident858532
Ref: innerproduct858609
Ref: inprod858609
Ref: invert859126
Ref: list_matrix_entries860588
Ref: lmxchar860807
Ref: matrix861370
Ref: matrixmap867771
Ref: matrixp868018
Ref: matrix_element_add868163
Ref: matrix_element_mult869575
Ref: matrix_element_transpose871682
Ref: mattrace874189
Ref: minor874516
Ref: ncharpoly874666
Ref: newdet875592
Ref: nonscalar875806
Ref: nonscalarp875947
Ref: permanent876158
Ref: rank876442
Ref: ratmx876779
Ref: row877429
Ref: rmxchar877537
Ref: scalarmatrixp877727
Ref: scalefactors878274
Ref: setelmx879382
Ref: similaritytransform879649
Ref: simtran879649
Ref: sparse881102
Ref: submatrix881377
Ref: transpose881697
Ref: triangularize882138
Ref: uniteigenvectors883220
Ref: ueivects883220
Ref: unitvector884798
Ref: uvect884798
Ref: vectorpotential885073
Ref: vectorsimp885760
Ref: vect_cross887380
Ref: zeromatrix887691
Node: Affine887796
Node: Introduction to Affine887991
Node: Functions and Variables for Affine888236
Node: itensor894467
Node: Introduction to itensor894646
Node: Functions and Variables for itensor908631
Ref: dispcon908890
Ref: show915512
Node: ctensor985226
Node: Introduction to ctensor985406
Node: Functions and Variables for ctensor990138
Node: atensor1052147
Node: Introduction to atensor1052344
Node: Functions and Variables for atensor1056610
Node: Sums Products and Series1062461
Node: Sums and Products1062741
Ref: bashindices1062930
Ref: lsum1063484
Ref: intosum1064198
Ref: product1064863
Ref: simpsum1067556
Ref: sum1068023
Ref: sumcontract1072850
Ref: sumexpand1073592
Node: Introduction to Series1074589
Node: Functions and Variables for Series1075198
Ref: cauchysum1075428
Ref: deftaylor1076733
Ref: maxtayorder1078157
Ref: niceindices1078451
Ref: niceindicespref1080048
Ref: nusum1081188
Ref: pade1083451
Ref: powerseries1086491
Ref: psexpand1088519
Ref: revert1089052
Ref: taylor1090997
Ref: taylordepth1099101
Ref: taylorinfo1099362
Ref: taylorp1100278
Ref: taylor_logexpand1100427
Ref: taylor_order_coefficients1101138
Ref: taylor_simplifier1101469
Ref: taylor_truncate_polynomials1101622
Ref: taytorat1101987
Ref: trunc1102193
Ref: unsum1102781
Ref: verbose1104029
Node: Poisson series1104207
Ref: intopois1104366
Ref: outopois1104440
Ref: poisdiff1104846
Ref: poisexpt1105037
Ref: poisint1105189
Ref: poislim1105411
Ref: poismap1105725
Ref: poisplus1106038
Ref: poissimp1106130
Ref: poisson1106238
Ref: poissubst1106354
Ref: poistimes1107458
Ref: poistrim1107547
Ref: printpois1107906
Node: Number Theory1108111
Node: Functions and Variables for Number Theory1108307
Ref: bern1108515
Ref: bernpoly1109301
Ref: bfzeta1109410
Ref: bfhzeta1109622
Ref: burn1110292
Ref: cf1111358
Ref: cfdisrep1114303
Ref: cfexpand1114956
Ref: cflength1115571
Ref: divsum1116203
Ref: euler1116741
Ref: fib1117064
Ref: fibtophi1117545
Ref: ifactors1118762
Ref: igcdex1119373
Ref: inrt1120176
Ref: inv_mod1120454
Ref: isqrt1120899
Ref: jacobi1120995
Ref: lcm1121251
Ref: mod1121480
Ref: next_prime1122884
Ref: partfrac1123055
Ref: power_mod1124239
Ref: primep1124845
Ref: primep_number_of_tests1125794
Ref: prev_time1125949
Ref: qunit1126114
Ref: totient1126559
Ref: zeta1126940
Ref: zeta%pi1128470
Node: Symmetries1129145
Node: Introduction to Symmetries1129345
Node: Functions and Variables for Symmetries1130941
Node: Groups1168555
Node: Functions and Variables for Groups1168718
Node: Runtime Environment1170774
Node: Introduction for Runtime Environment1171043
Node: Interrupts1172524
Node: Functions and Variables for Runtime Environment1173894
Ref: feature1174123
Ref: featurep1174662
Ref: maxima_tempdir1175346
Ref: maxima_userdir1175975
Ref: room1176937
Ref: sstatus1177404
Ref: status1178020
Ref: system1179416
Ref: time1180432
Ref: timedate1181011
Ref: absolute_real_time1182280
Ref: elapsed_real_time1182737
Ref: elapsed_run_time1183257
Node: Miscellaneous Options1183814
Node: Introduction to Miscellaneous Options1184097
Node: Share1184550
Node: Functions and Variables for Miscellaneous Options1185483
Ref: alphabetic1185715
Ref: genindex1186442
Ref: gensumnum1186658
Ref: gensym1186981
Ref: properties1188064
Ref: props1188200
Ref: propvars1188515
Ref: put1188772
Ref: qput1189738
Ref: rem1190561
Ref: remove1191000
Ref: remvalue1193073
Ref: rncombine1193606
Ref: scalarp1194404
Ref: setup_autoload1194683
Node: Rules and Patterns1196168
Node: Introduction to Rules and Patterns1196414
Node: Functions and Variables for Rules and Patterns1197699
Ref: apply11197948
Ref: apply21198723
Ref: applyb11199373
Ref: current_let_rule_package1200204
Ref: default_let_rule_package1200950
Ref: defmatch1201313
Ref: defrule1206241
Ref: disprule1207079
Ref: let1208598
Ref: letrat1213600
Ref: letrules1214422
Ref: letsimp1215141
Ref: let_rule_packages1215884
Ref: matchdeclare1216188
Ref: maxapplydepth1225068
Ref: maxapplyheight1225236
Ref: remlet1225412
Ref: remrule1226593
Ref: tellsimp1228795
Ref: tellsimpafter1231311
Ref: clear_rules1241437
Node: Sets1241623
Node: Introduction to Sets1241811
Node: Functions and Variables for Sets1253574
Ref: adjoin1253753
Ref: belln1254349
Ref: cardinality1255394
Ref: cartesian_product1255943
Ref: disjoin1256758
Ref: disjointp1257545
Ref: divisors1257967
Ref: elementp1259595
Ref: emptyp1260017
Ref: equiv_classes1260334
Ref: every1261633
Ref: extremal_subset1265108
Ref: flatten1265843
Ref: full_listify1268507
Ref: fullsetify1269112
Ref: identity1269776
Ref: integer_partitions1270095
Ref: intersect1272066
Ref: intersection1272188
Ref: listify1274149
Ref: lreduce1274616
Ref: makeset1276070
Ref: moebius1277894
Ref: multinomial_coeff1279156
Ref: num_distinct_partitions1280481
Ref: num_partitions1281337
Ref: partition_set1282289
Ref: permutations1283123
Ref: powerset1283794
Ref: rreduce1285845
Ref: setdifference1287402
Ref: setequalp1288289
Ref: setify1288966
Ref: setp1289593
Ref: set_partitions1290200
Ref: some1292002
Ref: stirling11295557
Ref: stirling21297670
Ref: subset1300116
Ref: subsetp1300788
Ref: symmdifference1301241
Ref: tree_reduce1302350
Ref: union1303823
Ref: xreduce1304835
Node: Function Definition1306793
Node: Introduction to Function Definition1307059
Node: Function1307278
Node: Macros1313475
Ref: buildq1313635
Ref: macroexpand1318351
Ref: macroexpand11319713
Ref: macros1320988
Ref: splice1321394
Node: Functions and Variables for Function Definition1323280
Ref: apply1323505
Ref: block1325967
Ref: break1329221
Ref: catch1329519
Ref: compfile1330807
Ref: compile1331674
Ref: define1332312
Ref: define_variable1336725
Ref: dispfun1341121
Ref: fullmap1345040
Ref: fullmapl1345796
Ref: functions1346086
Ref: fundef1348107
Ref: funmake1349060
Ref: lambda1352318
Ref: local1358933
Ref: macroexpansion1360328
Ref: mode_checkp1366634
Ref: mode_check_errorp1366850
Ref: mode_check_warnp1367046
Ref: mode_declare1367221
Ref: mode_identity1369401
Ref: remfunction1371081
Ref: transcompile1372462
Ref: translate1372806
Ref: translate_file1375633
Ref: transrun1378693
Ref: tr_array_as_ref1379006
Ref: tr_bound_function_applyp1379614
Ref: tr_file_tty_message1380158
Ref: tr_float_can_branch_complex1380556
Ref: tr_function_call_default1381329
Ref: tr_numer1382375
Ref: tr_optimize_max_loop1382601
Ref: tr_semicompile1382939
Ref: tr_state_vars1383252
Ref: tr_warnings_get1383898
Ref: tr_warn_fexpr1384278
Ref: tr_warn_meval1384600
Ref: tr_warn_mode1384864
Ref: tr_warn_undeclared1385045
Ref: tr_warn_undefined_variable1385218
Ref: compile_file1385395
Ref: declare_translated1386966
Node: Program Flow1387717
Node: Lisp and Maxima1387979
Node: Garbage Collection1392592
Node: Introduction to Program Flow1393731
Node: Functions and Variables for Program Flow1394109
Ref: backtrace1394328
Ref: do1396113
Ref: errcatch1405398
Ref: error1406035
Ref: error_size1406776
Ref: error_syms1408469
Ref: errormsg1409248
Ref: option_errormsg1409460
Ref: for1410823
Ref: go1410988
Ref: if1411630
Ref: map1414480
Ref: mapatom1416589
Ref: maperror1416811
Ref: mapprint1417540
Ref: maplist1418028
Ref: prederror1418454
Ref: throw1421066
Ref: while1421292
Ref: unless1421292
Ref: outermap1421392
Node: Debugging1428464
Node: Source Level Debugging1428676
Node: Keyword Commands1433598
Node: Functions and Variables for Debugging1436786
Ref: debugmode1436981
Ref: refcheck1437620
Ref: setcheck1437862
Ref: setcheckbreak1439444
Ref: setval1440094
Ref: timer1440431
Ref: untimer1441910
Ref: timer_devalue1442670
Ref: timer_info1443253
Ref: trace1444212
Ref: trace_options1445715
Ref: untrace1448493
Node: asympa1448938
Node: Introduction to asympa1449128
Node: Functions and variables for asympa1449656
Node: augmented_lagrangian1449845
Node: Functions and Variables for augmented_lagrangian1450050
Node: Bernstein1454241
Node: Functions and Variables for Bernstein1454411
Node: bode1459491
Node: Functions and Variables for bode1459632
Node: cobyla1463003
Node: Introduction to cobyla1463203
Node: Functions and Variables for cobyla1465816
Node: Examples for cobyla1468822
Node: contrib_ode1469587
Node: Introduction to contrib_ode1469893
Node: Functions and Variables for contrib_ode1475584
Node: Possible improvements to contrib_ode1480532
Node: Test cases for contrib_ode1481966
Node: References for contrib_ode1482832
Node: descriptive1484371
Node: Introduction to descriptive1484684
Node: Functions and Variables for data manipulation1490367
Node: Functions and Variables for descriptive statistics1499699
Node: Functions and Variables for statistical graphs1527737
Node: diag1548931
Node: Functions and Variables for diag1549075
Node: distrib1566675
Node: Introduction to distrib1566921
Node: Functions and Variables for continuous distributions1573296
Node: Functions and Variables for discrete distributions1635687
Node: draw1661575
Node: Introduction to draw1661821
Node: Functions and Variables for draw1662417
Node: Functions and Variables for pictures1793468
Node: Functions and Variables for worldmap1798215
Node: drawdf1811314
Node: Introduction to drawdf1811487
Node: Functions and Variables for drawdf1813609
Node: dynamics1823438
Node: Introduction to dynamics1823622
Node: Functions and Variables for dynamics1825628
Node: ezunits1841941
Node: Introduction to ezunits1842157
Node: Introduction to physical_constants1846229
Node: Functions and Variables for ezunits1851185
Node: f901880201
Node: Functions and Variables for f901880337
Node: finance1882358
Node: Introduction to finance1882535
Node: Functions and Variables for finance1883256
Node: fractals1893935
Node: Introduction to fractals1894212
Node: Definitions for IFS fractals1894889
Node: Definitions for complex fractals1896687
Node: Definitions for Koch snowflakes1899213
Node: Definitions for Peano maps1900207
Node: ggf1901083
Node: Functions and Variables for ggf1901219
Node: graphs1903158
Node: Introduction to graphs1903329
Node: Functions and Variables for graphs1904692
Node: grobner1955977
Node: Introduction to grobner1956158
Node: Functions and Variables for grobner1958388
Ref: poly_gcd1969724
Node: impdiff1973984
Node: Functions and Variables for impdiff1974142
Node: implicit_plot1974790
Node: Functions and Variables for implicit_plot1974967
Node: interpol1976169
Node: Introduction to interpol1976359
Node: Functions and Variables for interpol1976796
Node: lapack1990216
Node: Introduction to lapack1990390
Node: Functions and Variables for lapack1990953
Node: lbfgs2011132
Node: Introduction to lbfgs2011303
Node: Functions and Variables for lbfgs2012385
Node: lindstedt2028079
Node: Functions and Variables for lindstedt2028243
Node: linearalgebra2029805
Node: Introduction to linearalgebra2030018
Node: Functions and Variables for linearalgebra2034557
Ref: addmatrices2034781
Ref: blockmatrixp2035297
Ref: columnop2035428
Ref: columnswap2035700
Ref: columnspace2035898
Ref: copy2036216
Ref: cholesky2037080
Ref: ctranspose2037398
Ref: diag_matrix2037615
Ref: dotproduct2038553
Ref: eigens_by_jacobi2038792
Ref: get_lu_factors2041970
Ref: hankel2042305
Ref: hessian2042604
Ref: hilbert_matrix2043710
Ref: identfor2043873
Ref: invert_by_lu2044499
Ref: jacobian2044683
Ref: kronecker_product2045611
Ref: listp2045710
Ref: locate_matrix_entry2046185
Ref: lu_factor2047458
Ref: mat_cond2053189
Ref: mat_norm2053704
Ref: linearalgebra_matrixp2054065
Ref: matrix_size2054583
Ref: mat_fullunblocker2054707
Ref: mat_trace2054959
Ref: mat_unblocker2055228
Ref: nullspace2056832
Ref: nullity2057189
Ref: orthogonal_complement2057294
Ref: polynomialp2057629
Ref: polytocompanion2059460
Ref: ptringularize2059859
Ref: rowp2060333
Ref: rowswap2060937
Ref: toeplitz2061133
Ref: vandermonde_matrix2061970
Ref: zerofor2062139
Ref: zeromatrixp2062739
Node: lsquares2063113
Node: Introduction to lsquares2063304
Node: Functions and Variables for lsquares2063656
Node: minpack2086338
Node: Introduction to minpack2086522
Node: Functions and Variables for minpack2086806
Node: makeOrders2091608
Node: Functions and Variables for makeOrders2091772
Node: mnewton2092833
Node: Introduction to mnewton2093020
Node: Functions and Variables for mnewton2093320
Ref: newtonepsilon2093514
Ref: newtonmaxiter2093872
Ref: function_mnewton2094121
Node: numericalio2095738
Node: Introduction to numericalio2096010
Node: Functions and Variables for plain-text input and output2101279
Node: Functions and Variables for binary input and output2107450
Node: opsubst2111941
Node: Functions and Variables for opsubst2112099
Node: orthopoly2114679
Node: Introduction to orthogonal polynomials2114894
Ref: Floating point Evaluation2126598
Node: Functions and Variables for orthogonal polynomials2134289
Node: plotdf2142017
Node: Introduction to plotdf2142194
Node: Functions and Variables for plotdf2144417
Node: romberg2154344
Node: Functions and Variables for romberg2154495
Node: simplex2162269
Node: Introduction to simplex2162456
Node: Functions and Variables for simplex2162971
Node: simplification2167399
Node: Introduction to simplification2167700
Node: Package absimp2168099
Node: Package facexp2169309
Ref: collectterms2174866
Node: Package functs2175764
Ref: gcdivide2177980
Node: Package ineq2182628
Node: Package rducon2187859
Node: Package scifac2189641
Node: Package sqdnst2190953
Node: solve_rec2192212
Node: Introduction to solve_rec2192407
Node: Functions and Variables for solve_rec2193145
Node: stats2201884
Node: Introduction to stats2202160
Node: Functions and Variables for inference_result2203597
Node: Functions and Variables for stats2208879
Node: Functions and Variables for special distributions2244703
Node: stirling2245901
Node: Functions and Variables for stirling2246058
Node: stringproc2248822
Node: Introduction to string processing2249120
Node: Functions and Variables for input and output2253198
Ref: sprint2259023
Node: Functions and Variables for characters2259784
Node: Functions and Variables for strings2263105
Node: to_poly_solve2277068
Node: Functions and Variables for to_poly_solve2277244
Node: unit2326968
Node: Introduction to Units2327144
Node: Functions and Variables for Units2331465
Node: zeilberger2352644
Node: Introduction to zeilberger2352856
Node: Functions and Variables for zeilberger2355081
Node: Function and Variable Index2361715
Node: Translator's Comments2788656
Node: Translation Policies2788883
Node: About Terms in Japanese2789814

End Tag Table


Local Variables:
coding: utf-8
End:
