[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

# 14. 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/が付きます。

·

Categories: Polynomials ·Rational expressions

[ < ] | [ > ] |  | [ << ] | [上] | [ >> ] |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

## 14.2 Functions and Variables for Polynomials

オプション変数: algebraic

  デフォルト値: `false`

  代数的整数が整理されるようにするためには、 `algebraic`を`true`に設定しなければいけません。

  ·

  Categories: Simplification flags and variables

オプション変数: berlefact

  デフォルト値: `true`

  `berlefact`が`false`の時、 Kroneckerの因数分解アルゴリズムを使います。 そうでないなら Berlekampのアルゴリズム―これがデフォルトですーを使います。

  ·

  Categories: Polynomials

関数: bezout (p1, p2, x)

  `resultant`コマンドの代替です。 行列を返します。 この行列の`determinant`が望みの終結式です。

  ·

  Categories: Polynomials

関数: bothcoef (expr, x)

  最初のメンバーが （exprが CRE形なら `ratcoef`が見つけるような） exprの中の xの係数であり、 ２番目のメンバーが 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

  ·

  Categories: Polynomials

関数: coeff (expr, x, n)
関数: coeff (expr, x)

  exprの `x^n`の係数を返します。 ここで exprは xの多項式か単項式です。

  `coeff(expr, x^n)`は `coeff(expr, x, n)`と同値です。 `coeff(expr, x, 0)`は xを含まない exprの剰余項を返します。 もし省略されたら nは1が仮定されます。

  xは単純変数か添字付き変数か、演算子1つとその引数のすべてから構成される exprの部分式です。

  `expand`か `factor`を適用することで、 exprと同値な式の係数を計算することが可能かもしれません。 `coeff`自身は `expand`や `factor`や他のいかなる関数も適用しません。

  例:

  `coeff`は exprの `x^n`の係数を返します。

      (%i1) coeff (b^3*a^3 + b^2*a^2 + b*a + 1, a^3);
                                      3
      (%o1)                          b

  `coeff(expr, x^n)`は `coeff(expr, x, n)`と同値です。

      (%i1) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z, 3);
      (%o1)                         - c
                                       3
      (%i2) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z^3);
      (%o2)                         - c
                                       3

  `coeff(expr, x, 0)`は exprの xを含まない剰余項です。

      (%i1) coeff (a*u + b^2*u^2 + c^3*u^3, b, 0);
                                  3  3
      (%o1)                      c  u  + a u

  xは単純変数か添字付き変数か、演算子1つとその引数のすべてから構成される exprの部分式です。

      (%i1) coeff (h^4 - 2*%pi*h^2 + 1, h, 2);
      (%o1)                        - 2 %pi
      (%i2) coeff (v[1]^4 - 2*%pi*v[1]^2 + 1, v[1], 2);
      (%o2)                        - 2 %pi
      (%i3) coeff (sin(1+x)*sin(x) + sin(1+x)^3*sin(x)^3, sin(1+x)^3);
                                      3
      (%o3)                        sin (x)
      (%i4) coeff ((d - a)^2*(b + c)^3 + (a + b)^4*(c - d), a + b, 4);
      (%o4)                         c - d

  `coeff`自身は `expand`や `factor`や他のいかなる関数も適用しません。

      (%i1) coeff (c*(a + b)^3, a);
      (%o1)                           0
      (%i2) expand (c*(a + b)^3);
                       3          2        2        3
      (%o2)           b  c + 3 a b  c + 3 a  b c + a  c
      (%i3) coeff (%, a);
                                      2
      (%o3)                        3 b  c
      (%i4) coeff (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c, (a + b)^3);
      (%o4)                           0
      (%i5) factor (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c);
                                        3
      (%o5)                      (b + a)  c
      (%i6) coeff (%, (a + b)^3);
      (%o6)                           c

  `coeff`はリスト、行列、等式上を散逸します。

      (%i1) coeff ([4*a, -3*a, 2*a], a);
      (%o1)                      [4, - 3, 2]
      (%i2) coeff (matrix ([a*x, b*x], [-c*x, -d*x]), x);
                                [  a    b  ]
      (%o2)                     [          ]
                                [ - c  - d ]
      (%i3) coeff (a*u - b*v = 7*u + 3*v, u);
      (%o3)                         a = 7

  ·

  Categories: Polynomials

関数: content (p_1, x_1, …, x_n)

  一番目のメンバーが多項式変数 p_1の x_nに関する項の係数の最大公約数（これが容量です）であり、 二番目のメンバーが多項式 p_1を容量で割ったものであるリストを返します。

  例:

      (%i1) content (2*x*y + 4*x^2*y^2, y);
                                         2
      (%o1)                   [2 x, 2 x y  + y]

  ·

  Categories: Polynomials

関数: denom (expr)

  有理式 exprの分母を返します。

  ·

  Categories: Expressions

関数: divide (p_1, p_2, x_1, …, x_n)

  主多項式変数 x_nに関して、 多項式 p_1を多項式 p_2で割った商と余りを計算します。 他の変数は `ratvars`関数での宣言に従います。 (The other variables are as in the `ratvars` function.) 結果は一番目の要素が商で２番目の要素が余りのリストです。

  例:

      (%i1) divide (x + y, x - y, x);
      (%o1)                       [1, 2 y]
      (%i2) divide (x + y, x - y);
      (%o2)                      [- 1, 2 x]

  二番目の例では `y`が主変数であることに注意してください。

  ·

  Categories: Polynomials

関数: eliminate ([eqn_1, …, eqn_n], [x_1, …, x_k])

  連続する終結式を取ることによって、 等式（もしくは0に等しいと仮定された式）から変数を消去します。 k個の変数 x_1, ..., x_kを消去した `n - k`個の式のリストを返します。 最初 x_1を消去し、`n - 1`個の式を得て、 次に変数 x_2を消去し、の繰り返し。 もし `k = n`なら、 変数 x_1, ..., x_kに依らないリストの中の単一式が返されます。 この場合、最後の変数について最後の結果を解くため `solve`がコールされます。

  例:

      (%i1) expr1: 2*x^2 + y*x + z;
                                            2
      (%o1)                    z + x y + 2 x
      (%i2) expr2: 3*x + 5*y - z - 1;
      (%o2)                  - z + 5 y + 3 x - 1
      (%i3) expr3: z^2 + x - y^2 + 5;
                                2    2
      (%o3)                    z  - y  + x + 5
      (%i4) eliminate ([expr3, expr2, expr1], [y, z]);
                   8         7         6          5          4
      (%o4) [7425 x  - 1170 x  + 1299 x  + 12076 x  + 22887 x

                                          3         2
                                  - 5154 x  - 1291 x  + 7688 x + 15376]

  ·

  Categories: Polynomials ·Algebraic equations

関数: ezgcd (p_1, p_2, p_3, …)

  一番目の要素が多項式 p_1, p_2, p_3, …の最大公約数で、 残りの要素は多項式を最大公約数で割ったものであるリストを返します。 これはいつも `ezgcd`アルゴリズムを使います。

  `gcd` , `gcdex` , `gcdivide` , `poly_gcd` も参照してください。

  例:

  三つの多項式は最大公約数 `2*x-3`を持ちます。 GCDは最初、関数 `gcd`で計算され、その後、関数 `ezgcd`で計算されます。

      (%i1) p1 : 6*x^3-17*x^2+14*x-3;
                              3       2
      (%o1)                6 x  - 17 x  + 14 x - 3
      (%i2) p2 : 4*x^4-14*x^3+12*x^2+2*x-3;
                          4       3       2
      (%o2)            4 x  - 14 x  + 12 x  + 2 x - 3
      (%i3) p3 : -8*x^3+14*x^2-x-3;
                                3       2
      (%o3)                - 8 x  + 14 x  - x - 3

      (%i4) gcd(p1, gcd(p2, p3));
      (%o4)                        2 x - 3

      (%i5) ezgcd(p1, p2, p3);
                         2               3      2           2
      (%o5) [2 x - 3, 3 x  - 4 x + 1, 2 x  - 4 x  + 1, - 4 x  + x + 1]

  ·

  Categories: Polynomials

オプション変数: facexpand

  デフォルト値: `true`

  `facexpand`は `factor`が返すこれ以上小さくできない因子が 展開された形式（デフォルト）か再帰的（正規のCRE）形式かを制御します。

  ·

  Categories: Polynomials

関数: factor (expr)
関数: factor (expr, p)

  任意の数の変数と関数を含んだ式 exprを整数上既約な因子に因数分解します。 `factor (expr, p)`は exprを 最小多項式が pである要素を加えた有理数体上で因数分解します。

  `factor`は整数を素因数分解するのに `ifactor`関数を使います。

  `factorflag`が `false`なら有理式の整数因子の素因数分解を抑制します。

  `dontfactor`に変数のリストを割り当てるとその変数に関して因数分解しなくなります。 （初期状態では空です。） 因数分解は `dontfactor`リスト上のそれらより （CRE形式で仮定された変数順序を使って）重要でない変数に関しても実行されなくなります。

  `savefactors`が `true`なら、 同じ因子をいくつか含む式の今後の因数分解をスピードアップするために 式の因子(因子の積)がある関数によって保存されます。

  `berlefact`が `false`なら Kroneckerの因数分解アルゴリズムが使われ、 そうでないならデフォルトである Berlekampのアルゴリズムが使われます。

  `intfaclim`が `true`なら、 もし自明な割り算やPollardのロー法のあと因子が見つからないなら 整数の素因数分解をあきらめます。 `false`に設定されているなら （これはユーザーが陽に `factor`をコールする場合です） 整数の完全な素因数分解が企てられます。 `intfaclim`のユーザー設定は内部で `factor`がコールされた時に使われます。 `intfaclim`は Maximaが大きな整数を素因数分解するのに ありえないぐらい長い時間を使うことを妨げるようにリセットされます。

  例:

      (%i1) factor (2^63 - 1);
                          2
      (%o1)              7  73 127 337 92737 649657
      (%i2) factor (-8*y - 4*x + z^2*(2*y + x));
      (%o2)               (2 y + x) (z - 2) (z + 2)
      (%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
                      2  2        2    2    2
      (%o3)          x  y  + 2 x y  + y  - x  - 2 x - 1
      (%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
                             2
                           (x  + 2 x + 1) (y - 1)
      (%o4)                ----------------------
                                 36 (y + 1)
      (%i5) factor (1 + %e^(3*x));
                            x         2 x     x
      (%o5)              (%e  + 1) (%e    - %e  + 1)
      (%i6) factor (1 + x^4, a^2 - 2);
                          2              2
      (%o6)             (x  - a x + 1) (x  + a x + 1)
      (%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
                             2
      (%o7)              - (y  + x) (z - x) (z + x)
      (%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2;
                                   x + 2
      (%o8)               ------------------------
                                                 2
                          (x + 3) (x + b) (x + c)
      (%i9) ratsimp (%);
                      4                  3
      (%o9) (x + 2)/(x  + (2 c + b + 3) x

           2                       2             2                   2
       + (c  + (2 b + 6) c + 3 b) x  + ((b + 3) c  + 6 b c) x + 3 b c )
      (%i10) partfrac (%, x);
                 2                   4                3
      (%o10) - (c  - 4 c - b + 6)/((c  + (- 2 b - 6) c

           2              2         2                2
       + (b  + 12 b + 9) c  + (- 6 b  - 18 b) c + 9 b ) (x + c))

                       c - 2
       - ---------------------------------
           2                             2
         (c  + (- b - 3) c + 3 b) (x + c)

                               b - 2
       + -------------------------------------------------
                   2             2       3      2
         ((b - 3) c  + (6 b - 2 b ) c + b  - 3 b ) (x + b)

                               1
       - ----------------------------------------------
                   2
         ((b - 3) c  + (18 - 6 b) c + 9 b - 27) (x + 3)
      (%i11) map ('factor, %);
                    2
                   c  - 4 c - b + 6                 c - 2
      (%o11) - ------------------------- - ------------------------
                      2        2                                  2
               (c - 3)  (c - b)  (x + c)   (c - 3) (c - b) (x + c)

                             b - 2                        1
                  + ------------------------ - ------------------------
                                   2                          2
                    (b - 3) (c - b)  (x + b)   (b - 3) (c - 3)  (x + 3)
      (%i12) ratsimp ((x^5 - 1)/(x - 1));
                             4    3    2
      (%o12)                x  + x  + x  + x + 1
      (%i13) subst (a, x, %);
                             4    3    2
      (%o13)                a  + a  + a  + a + 1
      (%i14) factor (%th(2), %);
                             2        3        3    2
      (%o14)   (x - a) (x - a ) (x - a ) (x + a  + a  + a + 1)
      (%i15) factor (1 + x^12);
                             4        8    4
      (%o15)               (x  + 1) (x  - x  + 1)
      (%i16) factor (1 + x^99);
                       2            6    3
      (%o16) (x + 1) (x  - x + 1) (x  - x  + 1)

         10    9    8    7    6    5    4    3    2
       (x   - x  + x  - x  + x  - x  + x  - x  + x  - x + 1)

         20    19    17    16    14    13    11    10    9    7    6
       (x   + x   - x   - x   + x   + x   - x   - x   - x  + x  + x

          4    3            60    57    51    48    42    39    33
       - x  - x  + x + 1) (x   + x   - x   - x   + x   + x   - x

          30    27    21    18    12    9    3
       - x   - x   + x   + x   - x   - x  + x  + 1)

  ·

  Categories: Polynomials

オプション変数: factorflag

  デフォルト値: `false`

  `factorflag`が `false`の時 有理式の整数因子の素因素分解を抑制します。

  ·

  Categories: Polynomials

関数: factorout (expr, x_1, x_2, …)

  和 exprを形式 `f (x_1, x_2, …)*g`の項の和に再整理します。 ここで `g`はどのx_iも含まない式の積で `f`は因数分解されたものです。

  オプション変数 `keepfloat`は `factorout`に無視されることに注意してください。

  例:

      (%i1) expand (a*(x+1)*(x-1)*(u+1)^2);
                   2  2          2      2      2
      (%o1)     a u  x  + 2 a u x  + a x  - a u  - 2 a u - a
      (%i2) factorout(%,x);
               2
      (%o2) a u  (x - 1) (x + 1) + 2 a u (x - 1) (x + 1)
                                                    + a (x - 1) (x + 1)

  ·

  Categories: Expressions

関数: factorsum (expr)

  exprの和の形の因子の中の項を 項の和が因数分解可能であるような項のグループにまとめようとします。 `factorsum`は `expand ((x + y)^2 + (z + w)^2)`の結果を回復できますが、 `expand ((x + 1)^2 + (x + y)^2)`は回復できません。 項が共通の変数を持つからです。

  例:

      (%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
                 2      2                            2      2
      (%o1) a x z  + a z  + 2 a w x z + 2 a w z + a w  x + v  x

                                           2        2    2            2
                              + 2 u v x + u  x + a w  + v  + 2 u v + u
      (%i2) factorsum (%);
                                         2          2
      (%o2)            (x + 1) (a (z + w)  + (v + u) )

  ·

  Categories: Expressions

関数: fasttimes (p_1, p_2)

  多項式の掛け算のための特殊なアルゴリズムを使って、 多項式 p_1と p_2の積を返します。 `p_1`と `p_2`は多変数で密でほぼ同じサイズであるべきです。 `n_1`が `p_1`の次数で `n_2`が `p_2`の次数だとすると、 古典的な掛け算は `n_1 n_2`のオーダーですが、 `fasttimes`は `max (n_1, n_2)^1.585`のオーダーです。

  ·

  Categories: Polynomials

関数: fullratsimp (expr)

  `fullratsimp`は ratsimpと式の非有理的整理を式変形されなくなるまで繰り返し適応し、結果を返します。

  非有理式が含まれる時は、 よくあるような `ratsimp`１回コールとその後の非有理的（「一般的」）整理だけでは 整理された結果を返すのに十分でないかもしれません。 時々複数回のコールが必要とされます。 `fullratsimp`はこのプロセスを楽にしてくれます。

  `fullratsimp (expr, x_1, ..., x_n)`は `ratsimp`や `rat`と同様複数の引数を取ります。

  例:

      (%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
                             a/2     2   a/2     2
                           (x    - 1)  (x    + 1)
      (%o1)                -----------------------
                                    a
                                   x  - 1
      (%i2) ratsimp (expr);
                                2 a      a
                               x    - 2 x  + 1
      (%o2)                    ---------------
                                    a
                                   x  - 1
      (%i3) fullratsimp (expr);
                                    a
      (%o3)                        x  - 1
      (%i4) rat (expr);
                             a/2 4       a/2 2
                           (x   )  - 2 (x   )  + 1
      (%o4)/R/             -----------------------
                                    a
                                   x  - 1

  ·

  Categories: Simplification functions ·Rational expressions

関数: fullratsubst (a, b, c)

  結果が変わらなくなるまで自身を再帰的にコールすることを除いて `ratsubst`と同じです。 置き換える式と置き換えられる式が１つ以上の変数を共通に持つ時、 この関数は役に立ちます。

  `fullratsubst`は `lratsubst`のフォーマットでも引数を受け付けます。 すなわち、一番目の引数は１つの代入等式もしくはそんな等式のリストで、 二番目の引数は処理される式というものです。

  `load ("lrats")`は `fullratsubst`と `lratsubst`をロードします。

  例:

      (%i1) load ("lrats")$

  - `subst`は多重代入を実行できます。 `lratsubst`は `subst`に似ています。

      (%i2) subst ([a = b, c = d], a + c);
      (%o2)                         d + b
      (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
      (%o3)                (d + a c) e + a d + b c

  - もし代入一つだけを望むなら、 一番目の引数に等式を一つ与えます。

      (%i4) lratsubst (a^2 = b, a^3);
      (%o4)                          a b

  - `fullratsubst`は結果が変わらなくなるまで再帰することを除いて `ratsubst`と同値です。

      (%i5) ratsubst (b*a, a^2, a^3);
                                     2
      (%o5)                         a  b
      (%i6) fullratsubst (b*a, a^2, a^3);
                                       2
      (%o6)                         a b

  - `fullratsubst`も、 一番目の引数として等式のリストもしくは式一つを受け入れます。

      (%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
      (%o7)                           b
      (%i8) fullratsubst (a^2 = b*a, a^3);
                                       2
      (%o8)                         a b

  - `fullratsubst`は不確定な再帰を起こすことがあります。

      (%i9) errcatch (fullratsubst (b*a^2, a^2, a^3));

      *** - Lisp stack overflow. RESET

  ·

  Categories: Rational expressions

関数: gcd (p_1, p_2, x_1, …)

  p_1と p_2の最大公約数を返します。 フラグ `gcd`はどのアルゴリズムを利用するか決めます。 `gcd`を `ez`か, `subres`, `red`, `spmod`いずれかに設定すると、それぞれ `ezgcd`, 部分終結式`prs`, 被約, モジュラーアルゴリズムを選択することになります。 もし `gcd`が `false`なら、 `gcd (p_1, p_2, x)`はすべての xに対していつも 1を返します。 （例えば `ratsimp`, `factor`など）多くの関数は背後で gcdを計算します。 斉次多項式に対しては `gcd`に`subres`を使うことを推奨します。 例えば `gcd (x^2 - 2*sqrt(2)*x + 2, x - sqrt(2))` のように代数的数が含まれる時、 `algebraic`は `true`でなくてはいけません。 また `gcd`は `ez`であってはいけません。

  もし `gcd`フラグ―デフォルトは `spmod`―が `false`なら、 式が標準有理式(CRE)形に変換される時も最大公約数を計算しません。 もし gcdが不要ならこれは時々計算のスピードを上げます。

  `ezgcd` , `gcdex` , `gcdivide` , `poly_gcd` も参照してください。

  例:

      (%i1) p1:6*x^3+19*x^2+19*x+6;
                              3       2
      (%o1)                6 x  + 19 x  + 19 x + 6
      (%i2) p2:6*x^5+13*x^4+12*x^3+13*x^2+6*x;
                        5       4       3       2
      (%o2)          6 x  + 13 x  + 12 x  + 13 x  + 6 x
      (%i3) gcd(p1, p2);
                                  2
      (%o3)                    6 x  + 13 x + 6
      (%i4) p1/gcd(p1, p2), ratsimp;
      (%o4)                         x + 1
      (%i5) p2/gcd(p1, p2), ratsimp;
                                    3
      (%o5)                        x  + x

  `ezgcd` は 一番目の要素が多項式 p_1と p_2の最大公約数で、 残りの要素が最大公約数で多項式を割ったもので構成されるリストを返します。

      (%i6) ezgcd(p1, p2);
                          2                     3
      (%o6)           [6 x  + 13 x + 6, x + 1, x  + x]

  ·

  Categories: Polynomials ·Rational expressions

関数: gcdex (f, g)
関数: gcdex (f, g, x)

  リスト `[a, b, u]`を返します。 ここで uは fと gの最大公約数(gcd)であり、 かつ `a f + b g`はuに等しいです。 引数 fと gは１変数多項式であるか、 そうでないなら指定された主変数 xの多項式でなければいけません。 これが機能するには単項イデアル整域にある必要があるからです。 gcdは他の変数の有理関数係数を持つ１変数多項式としての fと gに対するgcdを意味します。

  `gcdex`はユークリッドのアルゴリズムを実行します。 すべてが `[f, g, -1]`に直角の `L[i]: [a[i], b[i], r[i]]`の列を持ち、 `q = quotient(r[i]/r[i+1])`なら `L[i+2]: L[i] - q L[i+1]`となるように次を組み立て、 余り `r[i+2]`がゼロの時 `L[i+1]`で終了します。

  引数 fと gは整数であり得ます。 この場合、`gcdex`は関数 `igcdex` を呼び出します。

  `ezgcd` , `gcd` , `gcdivide` , `poly_gcd` も参照してください。

  例:

      (%i1) gcdex (x^2 + 1, x^3 + 4);
                             2
                            x  + 4 x - 1  x + 4
      (%o1)/R/           [- ------------, -----, 1]
                                 17        17
      (%i2) % . [x^2 + 1, x^3 + 4, -1];
      (%o2)/R/                        0

  以下の gcdは `k(y)[x]`に対して働くので`1`です。 `k[y, x]`で期待する`y+1`ではないことに注意してください。

      (%i1) gcdex (x*(y + 1), y^2 - 1, x);
                                     1
      (%o1)/R/                 [0, ------, 1]
                                    2
                                   y  - 1

  ·

  Categories: Polynomials ·Rational expressions

関数: gcfactor (n)

  ガウス整数(すなわち aと bが有理整数(通常の整数)であるとして形式 `a + b `%i``の数) nを ガウス整数上で因数分解します。 因子は aと bを非負にすることによって正規化されます。

  ·

  Categories: Integers

関数: gfactor (expr)

  多項式 exprをガウス整数（虚数単位`%i`を付け加えた整数）上で因数分解します。 aが `%i`となる `factor (expr, a^2+1)`ようなものです。

  例:

      (%i1) gfactor (x^4 - 1);
      (%o1)           (x - 1) (x + 1) (x - %i) (x + %i)

  ·

  Categories: Polynomials

関数: gfactorsum (expr)

  `factorsum`に似ていますが `factor`の代わりに `gfactor`を適用します。

  ·

  Categories: Expressions

関数: hipow (expr, x)

  exprの中の xの明示的に示された指数の最も大きなものを返します。 xは変数もしくは一般式です。 もし xが exprの中に現れないなら、 `hipow`は `0`を返します。

  `hipow`は `expr`に等価な式を考慮しません。 特に `hipow`は `expr`を展開しないので、 `hipow (expr, x)`と `hipow (expand (expr, x))`は違った結果をもたらすかもしれません。

  例:

      (%i1) hipow (y^3 * x^2 + x * y^4, x);
      (%o1)                           2
      (%i2) hipow ((x + y)^5, x);
      (%o2)                           1
      (%i3) hipow (expand ((x + y)^5), x);
      (%o3)                           5
      (%i4) hipow ((x + y)^5, x + y);
      (%o4)                           5
      (%i5) hipow (expand ((x + y)^5), x + y);
      (%o5)                           0

  ·

  Categories: Expressions

オプション変数: intfaclim

  デフォルト値: true

  もし `true`なら、 試し割りとPollardのロー法のあと因子が見つからないなら Maximaは整数の素因素分解をあきらめ、素因数分解は完了しません。

  `intfaclim`が`false`の時、 (これは、ユーザーが明示的に`factor`をコールした場合です） 完全な素因数分解を試みます。 `divisors`や, `divsum`, `totient`の中で因子が計算される時は、 `intfaclim`は `false`に設定されます

  `factor`への内部コールは `intfaclim`のユーザー指定の値を考慮します。 `intfaclim`を `true`に設定することは 大きな整数を素因数分解するのに費やす時間を少なくするかもしれません。

  ·

  Categories: Integers

オプション変数: keepfloat

  デフォルト値: `false`

  `keepfloat`が`true`なら、 浮動小数点数を含む式を標準有理式(CRE)形に変換する時 浮動小数点を有理数化しないようにします。

  関数 `solve`とそれを呼び出す関数(例えば `eigenvalues`)は、 現在、このフラグを無視しとにかく浮動小数点数を変換することに注意してください。

  例:

      (%i1) rat(x/2.0);

      `rat' replaced 0.5 by 1/2 = 0.5
                                             x
      (%o1)/R/                               -
                                             2
      (%i2) rat(x/2.0), keepfloat;

      (%o2)/R/                     E        0.5 x

  `solve`は `keepfloat`を無視します:

      (%i3) solve(1.0-x,x), keepfloat;

      `rat' replaced 1.0 by 1/1 = 1.0
      (%o3)                               [x = 1]

  ·

  Categories: Numerical evaluation

関数: lopow (expr, x)

  exprの中に明示的に現れる xの最小の指数を返します。 例えば、

      (%i1) lopow ((x+y)^2 + (x+y)^a, x+y);
      (%o1)                       min(a, 2)

  ·

  Categories: Expressions

関数: lratsubst (L, expr)

  `subst`の代わりに `ratsubst`を使うことを除いて、 `subst (L, expr)`に似ています。

  `lratsubst`の一番目の引数は `subst`が受け付けるそれと同一のフォーマットの等式もしくは等式のリストです。 代入は等式のリストによって与えられた順、すなわち左から右に実行されます。

  `load ("lrats")`は `fullratsubst`と `lratsubst`をロードします。

  例:

      (%i1) load ("lrats")$

  - `subst`は多重代入を実行できます。 `lratsubst`は `subst`に似ています。

      (%i2) subst ([a = b, c = d], a + c);
      (%o2)                         d + b
      (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
      (%o3)                (d + a c) e + a d + b c

  - もし代入１つだけを望むなら等式一つを一番目の引数として与えることができます。

      (%i4) lratsubst (a^2 = b, a^3);
      (%o4)                          a b

  ·

  Categories: Polynomials ·Rational expressions

オプション変数: modulus

  デフォルト値: `false`

  `modulus`が正の数 pの時、 （`rat`や関連の関数が返すような）有理数上の演算に関して、 いわゆる均衡法系("balanced" modulus system)と呼ばれるものを使って、 pを法とする合同変換が実行されます。 均衡法系では、 `n modulo p`はnを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`に割り当てることができます。

  ·

  Categories: Integers

関数: num (expr)

  もし exprが比ならその分子を返します。 もし exprが比でないなら exprが返されます。

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

  ·

  Categories: Expressions

関数: polydecomp (p, x)

  変数 xの多項式 pを xの多項式の関数合成に分解します。 `polydecomp`は

      lambda ([x], p_1) (lambda ([x], p_2) (... (lambda ([x], p_n) (x))
        ...))

  が pに等しいようなリスト `[p_1, ..., p_n]`を返します。 nより小さい iについて p_iの次数は1より大きいです。

  このような分解は一意的ではありません。

  例:

      (%i1) polydecomp (x^210, x);
                                7   5   3   2
      (%o1)                   [x , x , x , x ]
      (%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a));
                      6      4      3    2
      (%o2)          x  - 2 x  - 2 x  + x  + 2 x - a + 1
      (%i3) polydecomp (p, x);
                              2       3
      (%o3)                 [x  - a, x  - x - 1]

  以下の関数は `x`の関数として `L = [e_1, ..., e_n]`を合成します; それはpolydecompの逆です。

      compose (L, x) :=
        block ([r : x], for e in L do r : subst (e, x, r), r) $

  `compose`を使って上の例を再表現します:

      (%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
                              2       3
      (%o3)                 [x  - a, x  - x - 1]

  `compose (polydecomp (p, x), x)`はいつも（展開されていない） pを返しますが、 `polydecomp (compose ([p_1, ..., p_n], x), x)`は 必ずしも `[p_1, ..., p_n]`を返さないことに注意してください。

      (%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x);
                                2       2
      (%o4)                   [x  + 2, x  + 1]
      (%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x);
                            2       2
                           x  + 3  x  + 5
      (%o5)               [------, ------, 2 x + 1]
                             4       2

  ·

  Categories: Polynomials

関数: polymod (p)
関数: polymod (p, m)

  多項式 pを現在の法(変数 `modulus`の値)に関するモジュラー表現に変換します。

  `polymod (p, m)`は `modulus`の現在値の代わりに法 mを使うように指定します。

  `modulus`を参照してください。

  ·

  Categories: Polynomials

関数: powers (expr, x)

  exprに現れるxのべきを返します。

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

  ·

  Categories: Expressions ·Polynomials

関数: quotient (p_1, p_2)
関数: quotient (p_1, p_2, x_1, …, x_n)

  多項式 p_1を多項式 p_2で割った結果を返します。 引数 x_1, …, x_nは `ratvars`と同様に解釈されます。

  `quotient`は `divide`が返す２要素リストの最初の要素を返します。

  ·

  Categories: Polynomials

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

  exprを標準有理式(CRE)形式に変換します。 具体的には、展開し、共通の分母上ですべての項を結合し、通分し、 `ratepsilon`の許容誤差内で浮動小数点を有理数に変換します。 もし変数が指定されたなら、 `ratvars`のように x_1, …, x_nに従って並び替えられます。

  `rat`は一般に加算`+`, 減算`-`, 乗算`*`, 除算`/`と整数べきの指数を除いた関数を整理しません。 一方で `ratsimp`はこれらの場合を扱います。 CRE形式の中のアトム(数と変数）は一般形式でのそれと同じではないことに注意してください。 例えば `rat(x) - x`は `rat(0)`を出力します。 これは0とは違う内部表現を持ちます。

  `ratfac`が `true`の時、 `rat`は CREの一部因数分解された形式を出力します。 有理演算の最中、因数分解パッケージをコールすることなく 式を可能な限り因数分解された形で保持します。 これにより常に、いくつかの計算でメモリと時間を節約することになります。 分子と分母は互いに素になりますが（例えば `((x^2 - 1)^4/(x + 10^2)`は `(x - 1)^4 (x + 1)^2`を出力します）、 それぞれの部分の中の因子は互いに素とは限りません。

  `ratprint`が `false`なら ユーザーに浮動小数点を有理数に変換したことを通知するメッセージの出力を抑制します。

  `keepfloat`が `true`なら 浮動小数点が有理数に変換されることを抑制します。

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

  例:

      (%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x) /
            (4*y^2 + x^2);
                                                 4
                                        (x - 2 y)
                    (y + a) (2 y + x) (------------ + 1)
                                         2      2 2
                                       (x  - 4 y )
      (%o1)         ------------------------------------
                                    2    2
                                 4 y  + x
      (%i2) rat (%, y, a, x);
                                  2 a + 2 y
      (%o2)/R/                    ---------
                                   x + 2 y

  ·

  Categories: Rational expressions

オプション変数: ratalgdenom

  デフォルト値: `true`

  `ratalgdenom`が `true`の時 根号に関する分母の有理化を有効にします。 `ratalgdenom`は標準有理式(CRE)が代数モードで使われる時だけ効果を持ちます。

  ·

  Categories: Simplification flags and variables

関数: ratcoef (expr, x, n)
関数: ratcoef (expr, x)

  式 exprの中の式 `x^n`の係数を返します。 nを省略した場合 nは1が仮定されます。

  戻り値は（非有理な意味で可能な場合を除いて）xの中の変数の制約を受けません。 このタイプの係数が存在しなければ0を返します。

  `ratcoef`は最初の引数を展開し有理的に整理するので 純粋に構文法的な `coeff`のそれとは違った答えを生成することがあります。 例えば `ratcoef ((x + 1)/y + x, x)`は `(y + 1)/y`を返しますが、 `coeff`は1を返します。

  exprを和と見ると、`ratcoef (expr, x, 0)`は xを含まない項の和を返します。 だからもし xの負のべき乗が存在するなら ratcoefを使うべきではありません。

  exprは検査される前に有理的に整理されるので、 係数が想像された形とは全く違って現れることがあります。

  例:

      (%i1) s: a*x + b*x + 5$
      (%i2) ratcoef (s, a + b);
      (%o2)                           x

  ·

  Categories: Polynomials ·Rational expressions

関数: ratdenom (expr)

  exprを標準有理式(CRE)に強制した後、exprの分母を返します。 戻り値はCREです。

  もしexprがCREでないなら `rat`によってCREに強制的に変換されます。 すべての項を共通の分母上に置くことによって、この変換は exprの形式を変えることがあります。

  `denom`は似ていますが、CREではなく通常の式を返します。 また、`denom`は共通の分母上にすべての項を置こうとはしませんし、 `ratdenom`が比と見なすいくつかの式は `denom`は比と見なしません。

  ·

  Categories: Rational expressions

オプション変数: ratdenomdivide

  デフォルト値: `true`

  `ratdenomdivide`が `true`の時、 `ratexpand`は、分子が和である比を共通の分母を持つ比の和に展開します。 そうでないなら `ratexpand`は比の和を１つの比に縮約します。 その比の分子はそれぞれの比の分子の和です。

  例:

      (%i1) expr: (x^2 + x + 1)/(y^2 + 7);
                                  2
                                 x  + x + 1
      (%o1)                      ----------
                                    2
                                   y  + 7
      (%i2) ratdenomdivide: true$
      (%i3) ratexpand (expr);
                             2
                            x        x        1
      (%o3)               ------ + ------ + ------
                           2        2        2
                          y  + 7   y  + 7   y  + 7
      (%i4) ratdenomdivide: false$
      (%i5) ratexpand (expr);
                                  2
                                 x  + x + 1
      (%o5)                      ----------
                                    2
                                   y  + 7
      (%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3);
                                           2
                                 b        a
      (%o6)                    ------ + ------
                                2        2
                               b  + 3   b  + 3
      (%i7) ratexpand (expr2);
                                        2
                                   b + a
      (%o7)                        ------
                                    2
                                   b  + 3

  ·

  Categories: Simplification flags and variables ·Rational expressions

関数: ratdiff (expr, x)

  有理式 exprを xに関して微分します。 exprは xの多項式もしくは多項式の商でなければなりません。 引数 xは exprの変数もしくは部分式を取り得ます。

  結果は、たぶん違った形式になりますが `diff`と同値です。 有理式の場合 `ratdiff`は `diff`より速いでしょう。

  もしexprが標準有理式(CRE)なら `ratdiff`は標準有理式を返します。 そうでないなら一般式を返します。

  `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

  ·

  Categories: Rational expressions

関数: ratdisrep (expr)

  引数を一般式として返します。 もし exprが一般式なら戻り値は引数と変わりません。

  典型的には `ratdisrep`は標準有理式(CRE)を一般式に変換するためにコールされます。 もし「伝染」を止めたかったり非有理文脈で有理関数を使いたいなら、 これは時々便利です。

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

  ·

  Categories: Rational expressions

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

  exprを展開します。 指数和や和の積を展開し、共通分母上の分数を結合し、通分し、 （もし和なら）分子を分母で割ったそれぞれの項に分割します。

  たとえ exprが標準有理式(CRE)でも `ratexpand`の戻り値は一般式です。

  スイッチ `ratexpand`が `true`なら、 CRE式は一般式や表示形式に変換された時完全に展開されます。 一方もし `false`なら再帰形式に変換します。 `ratsimp`も参照してください。

  `ratdenomdivide`が `true`の時、 `ratexpand`は分子が和である比を共通の分母を持つ比の和に展開します。 そうでないなら、 `ratexpand`は比の和をその分子がそれぞれの比の分子の和である単一の比にまとめます。

  `keepfloat`が `true`の場合、 浮動小数点を含んだ式をCRE形式に変換する時、浮動小数点が有理化されるのを抑制します。

  例:

      (%i1) ratexpand ((2*x - 3*y)^3);
                           3         2       2        3
      (%o1)          - 27 y  + 54 x y  - 36 x  y + 8 x
      (%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1);
                               x - 1       1
      (%o2)                   -------- + -----
                                     2   x - 1
                              (x + 1)
      (%i3) expand (expr);
                          x              1           1
      (%o3)          ------------ - ------------ + -----
                      2              2             x - 1
                     x  + 2 x + 1   x  + 2 x + 1
      (%i4) ratexpand (expr);
                              2
                           2 x                 2
      (%o4)           --------------- + ---------------
                       3    2            3    2
                      x  + x  - x - 1   x  + x  - x - 1

  ·

  Categories: Rational expressions

オプション変数: ratfac

  デフォルト値: `false`

  `ratfac`が `true`の時、 標準有理式(CRE)を部分的に因数分解された形式で操作します。

  有理演算の間、 式を、`factor`をコールせずに 可能な限り最大限因数分解した形で維持します。 これはいつも保存領域を節約し、いくつかの計算では時間も節約することがあります。 分子と分母は互いに素になります。 例えば `rat ((x^2 - 1)^4/(x + 1)^2)`は `(x - 1)^4 (x + 1)^2)`をもたらしますが、 それぞれの部分の中の因子は互いに素ではないかもしれません。

  `ctensr`（成分テンソル操作）パッケージでは、 `ratfac`が `true`の時、 Ricci, Einstein, Riemann, Weylテンソルとスカラー曲率を 自動的に因数分解します。 `ratfac`はテンソルの成分が２、３の項から成ると知られている場合だけ 設定すべきです。

  `ratfac`と `ratweight`体系は互換性はなく、 同時には使えないかもしれません。

  ·

  Categories: Rational expressions

関数: ratnumer (expr)

  exprを標準有理式(CRE)に強制変換した後、その分子を返します。 戻り値はCREです。

  もしexprがCREでないなら `rat`によってCREに強制変換されます。 この変換は、 共通の分母上にすべての項を置くことによって、 exprの形式を変えるかもしれません。

  `num`は似ていますが、 CREではなく通常の式を返します。 また `num`は共通の分母上にすべての項を置こうとはしませんし、 `ratnumer`が比と見なすいくつかの式は `num`は比と見しません。

  ·

  Categories: Rational expressions

関数: ratp (expr)

  もし exprが標準有理式(CRE)か拡張CREなら `true`を返し、 そうでないなら `false`を返します。

  CREは `rat`と関連関数によって生成されます。 拡張CREは `taylor`と関連関数によって生成されます。

  ·

  Categories: Predicate functions ·Rational expressions

オプション変数: ratprint

  デフォルト値: `true`

  `ratprint`が `true`の時、 ユーザーに浮動小数点を有理数に変換したことを通知するメッセージを表示します。

  ·

  Categories: Rational expressions ·Numerical evaluation ·Console interaction

関数: ratsimp (expr)
関数: ratsimp (expr, x_1, ..., x_n)

  式 expとその部分式の全てを有理的に整理します（非有理的関数の引数も含みます）。 結果は二つの多項式の商として、再帰的形式 —主変数の係数が他の変数の多項式である形式—で返されます。 変数は(例えば `sin(z^2+1)`のような)非有理関数を含むかもしれませんが、 どんな非有理関数の引数もまた有理的に整理されます。

  `ratsimp (expr, x_1, ..., x_n)`は `ratvars`で指定した場合と同様に変数の順序指定に従って有理的に整理します。

  `ratsimpexpons`が `true`の時、 `ratsimp`は式の指数にも適用されます。

  `ratexpand`も参照してください。 `ratsimp`は `ratexpand`に影響するフラグのいくつかに影響されることに注意してください。

  例:

      (%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2);
                                               2      2
                         x         (log(x) + 1)  - log (x)
      (%o1)        sin(------) = %e
                        2
                       x  + x
      (%i2) ratsimp (%);
                                   1          2
      (%o2)                  sin(-----) = %e x
                                 x + 1
      (%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1));
                             3/2
                      (x - 1)    - sqrt(x - 1) (x + 1)
      (%o3)           --------------------------------
                           sqrt((x - 1) (x + 1))
      (%i4) ratsimp (%);
                                 2 sqrt(x - 1)
      (%o4)                    - -------------
                                       2
                                 sqrt(x  - 1)
      (%i5) x^(a + 1/a), ratsimpexpons: true;
                                     2
                                    a  + 1
                                    ------
                                      a
      (%o5)                        x

  ·

  Categories: Simplification functions ·Rational expressions

オプション変数: ratsimpexpons

  デフォルト値: `false`

  `ratsimpexpons`が `true`の時、 式整理の間 `ratsimp`を式の指数に適用します。

  ·

  Categories: Simplification flags and variables ·Rational expressions

オプション変数: radsubstflag

  デフォルト値: `false`

  もし `radsubstflag`が `true`なら、 `ratsubst`が `x`の中の `sqrt (x)`に `u`を代入するような代入をできるようにします。

  ·

  Categories: Simplification flags and variables

関数: ratsubst (a, b, c)

  cの中の bに aを代入し、結果の式を返します。 bは和でも積tでもべきなどでも問題ありません。

  `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

  ·

  Categories: Rational expressions

関数: ratvars (x_1, …, x_n)
関数: ratvars ()
システム変数: ratvars

  有理式に関して主変数 x_1, ..., x_nを宣言します。 もし x_nが有理式の中に存在するなら それを主変数と見なします。 もし x_nが有理式の中に存在せず x_[n-1]が存在するなら、それを主変数と見なします。 などと先行する変数を通してx_1まで続きます。 x_1は 後に続く変数が存在しなかった時だけ主変数と見なされる変数です。

  もし有理式の中の変数が `ratvars`リストの中に存在しなかったら、 その変数には x_1よりも低い優先順位が与えられます。

  `ratvars`の引数は変数や `sin(x)`のような非有理関数もあり得ます。

  変数 `ratvars`は直近にコールされたときの関数 `ratvars`の引数のリストです。 関数 `ratvars`のコールそれぞれはリストを再設定します。 `ratvars ()`はリストをクリアします。

  ·

  Categories: Rational expressions

オプション変数: ratvarswitch

  デフォルト値: `true`

  Maximaは Lisp変数 `VARLIST`の中に有理式の主変数の内部リストを保持します。 もし `ratvarswitch`が `true`なら、 すべての評価は新しいリスト `VARLIST`で開始します。 これがデフォルトの振る舞いです。 そうでないなら、以前の評価からの主変数が内部リスト `VARLIST`から取り除かれません。

  主変数は関数 `ratvars`で宣言されるのですが、 オプション変数 `ratvarswitch`は主変数に影響しません。

  例:

  もし `ratvarswitch`が `true`なら すべての評価は新しいリスト `VARLIST`で始まります。

      (%i1) ratvarswitch:true$

      (%i2) rat(2*x+y^2);
                                   2
      (%o2)/R/                    y  + 2 x
      (%i3) :lisp varlist
      ($X $Y)

      (%i3) rat(2*a+b^2);
                                   2
      (%o3)/R/                    b  + 2 a

      (%i4) :lisp varlist
      ($A $B)

  もし `ratvarswitch`が `false`なら 直前の評価からの主変数はまだ存在しています。

      (%i4) ratvarswitch:false$

      (%i5) rat(2*x+y^2);
                                   2
      (%o5)/R/                    y  + 2 x
      (%i6) :lisp varlist
      ($X $Y)

      (%i6) rat(2*a+b^2);
                                   2
      (%o6)/R/                    b  + 2 a

      (%i7) :lisp varlist
      ($A $B $X $Y)

  ·

  Categories: Rational expressions ·Global flags

関数: ratweight (x_1, w_1, …, x_n, w_n)
関数: ratweight ()

  変数 x_iに重み w_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

  ·

  Categories: Rational expressions

システム変数: ratweights

  デフォルト値: `[]`

  `ratweights`は `ratweight`が割り当てた重みのリストです。 リストは累積されます: `ratweight`をコールすると毎回リストに項目を追加します。

  `kill (ratweights)`と `save (ratweights)`はともに期待通り動作します。

  ·

  Categories: Rational expressions

オプション変数: ratwtlvl

  デフォルト値: `false`

  `ratwtlvl`は、 標準有理式(CRE)の切り詰めを制御するために `ratweight`関数と組み合わせて使われます。 デフォルト値の `false`では切り詰めは起こりません。

  ·

  Categories: Rational expressions

関数: remainder (p_1, p_2)
関数: remainder (p_1, p_2, x_1, …, x_n)

  多項式 p_1を多項式 p_2で割った余りを返します。 引数 x_1, ..., x_nは`ratvars`と同様に解釈されます。

  `remainder`は `divide`が返す２要素リストの２番目の要素を返します。

  ·

  Categories: Polynomials

関数: resultant (p_1, p_2, x)
変数: resultant

  変数 xを消去して２つの多項式 p_1と p_2の終結式を計算します。 終結式は p_1と p_2の中の xの係数の判別式です。 それは p_1と p_2が定数でない因子を共通に持つ時だけゼロに等しいです。

  もし p_1か p_2が因数分解できるなら、 `resultant`をコールする前に `factor`をコールするのが望ましいかもしれません。

  変数 `resultant`はどのアルゴリズムが計算に使われるか制御します。 部分終結式prsには `subres` モジュラー終結式アルゴリズムには `mod` 通分prsには `red`。 大抵の問題では `subres`が最適です。 いくつかの大きな次数の１変数もしくは２変数問題では `mod`がよりよいかもしれません。

  関数 `bezout`は `resultant`と同じ引数を取り、行列を返します。 戻り値の判別式は望みの終結式です。

  ·

  Categories: Polynomials

オプション変数: savefactors

  デフォルト値: `false`

  `savefactors`が `true`の時、 同じ因子のいくつかを含む式の因数分解を後でする時にスピードアップするために、 いくつかの関数が因子の積の形の式の因子を保存されるようにします。

  ·

  Categories: Polynomials

関数: showratvars (expr)

  式 `expr`の中の標準有理式 (CRE)変数のリストを返します。

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

  ·

  Categories: Rational expressions ·Display functions

関数: sqfr (expr)

  多項式因子が「平方にならない」ことを除いて `factor`に似ています。 すなわち、それらは次数１だけの因子を持ちます。 このアルゴリズムは `factor`の最初の段階でも使われるのですが、 多項式は n階微分と共通に nよりも大きな次数のすべての因子を持つという事実を使います。 このように、それぞれの変数に関する微分の多項式との最大公約数を取ることによって、 1よりも大きな次数の因子を見つけることができます。

  例:

      (%i1) sqfr (4*x^4 + 4*x^3 - 3*x^2 - 4*x - 1);
                                      2   2
      (%o1)                  (2 x + 1)  (x  - 1)

  ·

  Categories: Polynomials

関数: tellrat (p_1, ..., p_n)
関数: tellrat ()

  多項式 p_1, ..., p_nの解である要素を Maximaに知られている代数的整数の環に加えます。 それぞれの引数 p_iは整数係数の多項式です。

  `tellrat (x)`は、実際には有理関数の中で xに0を代入することを意味します。

  `tellrat ()`は現在の代入のリストを返します。

  代数的整数の整理が効果を持つようにするためには、 `algebraic`を `true`に設定しなければいけません。

  Maximaは、起動の際には虚数単位と整数の根すべてについて知っています。

  核(kernels)を取り `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]

  ·

  Categories: Polynomials ·Rational expressions

関数: totaldisrep (expr)

  exprのすべての部分式を標準有理式(CRE)から一般形に変換して結果を返します。 もし exprがそれ自身CRE形なら、 `totaldisrep`は `ratdisrep`と同一です。

  `totaldisrep`は CRE形の部分式を持つ等式やリストや行列などの式を ratdisrepするために役に立つかもしれません。

  ·

  Categories: Rational expressions

関数: untellrat (x_1, …, x_n)

  x_1, …, x_nから `tellrat`プロパティを削除します。

  ·

  Categories: Polynomials ·Rational expressions

[ << ] | [ >> ] |  |  |  |  |  | [冒頭] | [目次] | [見出し] | [ ? ]

この文書は市川 雄二によって2012年1月月5日にtexi2html 1.82を用いて生成されました。