[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 9. Simplification

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 9.1 Functions and Variables for Simplification

プロパティ: additive

  もし `declare(f, additive)`が実行されると:

  (1) もし `f`が1変数関数なら、 `f`が和に適用された時はいつでも `f`は和の上に分配整理されます。 例えば、 `f(y+x)`は、 `f(y)+f(x)`に整理されます。

  (2) もし `f`が2変数以上の関数なら、 `sum`や `integrate`の場合と同様に 加法性が第一番目の引数に対して定義されます。 例えば、 `f(h(x)+g(x),x)`は `f(h(x),x)+f(g(x),x)`に整理されます。 `f`が `sum(x[i],i,lower-limit,upper-limit)`の形の式に適用されたときには この整理はされません。

  例:

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

  Categories: Operators · Declarations and inferences

プロパティ: antisymmetric

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

  例:

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

  Categories: Operators · Declarations and inferences

関数: combine (expr)

  同じ分母を持つ項を単一の項に結合することによって和 exprを整理します。

  例:

      (%i1) 1*f/2*b + 2*c/3*a + 3*f/4*b +c/5*b*a;
                                   5 b f   a b c   2 a c
      (%o1)                        ----- + ----- + -----
                                     4       5       3
      (%i2) combine (%);
                               75 b f + 4 (3 a b c + 10 a c)
      (%o2)                    -----------------------------
                                            60

  Categories: Expressions

プロパティ: commutative

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

  例:

      (%i1) S (b, a);
      (%o1)                               S(b, a)
      (%i2) S (a, b) + S (b, a);
      (%o2)                          S(b, a) + S(a, b)
      (%i3) declare (S, commutative);
      (%o3)                                done
      (%i4) S (b, a);
      (%o4)                               S(a, b)
      (%i5) S (a, b) + S (b, a);
      (%o5)                              2 S(a, b)
      (%i6) S (a, c, e, d, b);
      (%o6)                          S(a, b, c, d, e)

  Categories: Operators · Declarations and inferences

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

  関数 `demoivre (expr)`は グローバル変数 `demoivre`を設定することなく式を変換します。

  変数 `demoivre`が`true`の時、 複素数の指数関数は円関数の項で表した同値な式に変換されます: もし`b`が`%i`を含まないなら、 `exp (a + b*%i)`は `%e^a * (cos(b) + %i*sin(b))`に整理されます。 `a`と `b`は展開されません。

  `demoivre`のデフォルト値は `false`です。

  `exponentialize`は円関数や双曲関数を指数関数形に変換します。 `demoivre`と `exponentialize`は同時に両方trueにはできません。

  Categories: Complex variables · Trigonometric functions · Hyperbolic functions

関数: distrib (expr)

  和を積上に分配します。 式のトップレベルのみで働きます。 すなわち、再帰的でなく `expand`より速い点で `expand`とは違います。 トップレベルの和すべてを展開する点で `multthru`とは違います。

  例:

      (%i1) distrib ((a+b) * (c+d));
      (%o1)                 b d + a d + b c + a c
      (%i2) multthru ((a+b) * (c+d));
      (%o2)                 (b + a) d + (b + a) c
      (%i3) distrib (1/((a+b) * (c+d)));
                                      1
      (%o3)                    ---------------
                               (b + a) (d + c)
      (%i4) expand (1/((a+b) * (c+d)), 1, 0);
                                      1
      (%o4)                 ---------------------
                            b d + a d + b c + a c

  Categories: Expressions

オプション変数: distribute_over

  デフォルト値: `true`

  `distribute_over`は リストや行列や等式のようなバッグ(重複を許す集合)上の関数のマッピングを制御します。 今回、すべてのMaxima関数がこのプロパティを持つ訳ではありません。 このプロパティはコマンド `properties`で調べることが可能です。

  `distribute_over`を値 `false`に設定した時、 関数のマッピングはオフにスイッチされます。

  例:

  `sin`関数はリスト上にマップします:

      (%i1) sin([x,1,1.0]);
      (%o1)                 [sin(x), sin(1), .8414709848078965]

  `mod`は リスト上にマップされる２変数関数です。 入れ子のリスト上のマッピングも可能です:

      (%i2) mod([x,11,2*a],10);
      (%o2)                    [mod(x, 10), 1, 2 mod(a, 5)]
      (%i3) mod([[x,y,z],11,2*a],10);
      (%o3)       [[mod(x, 10), mod(y, 10), mod(z, 10)], 1, 2 mod(a, 5)]

  `floor`関数の行列や等式上のマッピング:

      (%i4) floor(matrix([a,b],[c,d]));
                                  [ floor(a)  floor(b) ]
      (%o4)                       [                    ]
                                  [ floor(c)  floor(d) ]
      (%i5) floor(a=b);
      (%o5)                         floor(a) = floor(b)

  １変数以上の関数は任意の引数上、または、すべての引数上にマップします:

      (%i6) expintegral_e([1,2],[x,y]);
      (%o6) [[expintegral_e(1, x), expintegral_e(1, y)],
             [expintegral_e(2, x), expintegral_e(2, y)]]

  関数がプロパティdistribute_overを持つかチェックします:

      (%i7) properties(abs);
      (%o7) [integral, distributes over bags, noun, rule, gradef]

  `distribute_over`を `false`値に設定すると、 関数の展開はオフになります。

      (%i1) distribute_over;
      (%o1)                                true
      (%i2) sin([x,1,1.0]);
      (%o2)                [sin(x), sin(1), 0.8414709848078965]
      (%i3) distribute_over : not distribute_over;
      (%o3)                                false
      (%i4) sin([x,1,1.0]);
      (%o4)                          sin([x, 1, 1.0])
      (%i5)

  Categories: Simplification flags and variables

オプション変数: domain

  デフォルト値: `real`

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

  Categories: Simplification flags and variables

プロパティ: evenfun
プロパティ: oddfun

  `declare(f, evenfun)`や `declare(f, oddfun)`は 関数 `f`を偶関数か奇関数として認識するように命じます。

  例:

      (%i1) o (- x) + o (x);
      (%o1)                     o(x) + o(- x)
      (%i2) declare (o, oddfun);
      (%o2)                         done
      (%i3) o (- x) + o (x);
      (%o3)                           0
      (%i4) e (- x) - e (x);
      (%o4)                     e(- x) - e(x)
      (%i5) declare (e, evenfun);
      (%o5)                         done
      (%i6) e (- x) - e (x);
      (%o6)                           0

関数: expand
`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)`の実行が行われます。

  `expand(expr, 0, 0)`は `expr`を再整理します。 `expr`は再評価はされません。 `ev(expr, noeval)`との違いは、 特殊な表現(例えばCRE形式)が削除されることです。 `ev`も参照してください。

  `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

  Categories: Expressions

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

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

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

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

  Categories: Expressions

オプション変数: expandwrt_denom

  デフォルト値: `false`

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

  Categories: Expressions

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

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

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

  Categories: Expressions

オプション変数: expon

  デフォルト値: 0

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

  Categories: Expressions

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

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

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

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

  Categories: Complex variables · Trigonometric functions · Hyperbolic functions

オプション変数: expop

  デフォルト値: 0

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

  Categories: Expressions

プロパティ: lassociative

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

  Categories: Declarations and inferences · Operators · Simplification

プロパティ: linear

  Maximaの演算子のプロパティの１つ。 そう宣言された1変数関数 `f`に関して、 `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)`を出力します。

  例:

      (%i1) declare (f, linear);
      (%o1)                                done
      (%i2) f(x+y);
      (%o2)                             f(y) + f(x)
      (%i3) declare (a, constant);
      (%o3)                                done
      (%i4) f(a*x);
      (%o4)                               a f(x)

  `linear`は `additive`かつ `outative`と同値です。 `opproperties`も参照してください。

  例:

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

  Categories: Declarations and inferences · Operators · Simplification

オプション変数: maxnegex

  デフォルト値: 1000

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

  Categories: Expressions

オプション変数: maxposex

  デフォルト値: 1000

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

  Categories: Expressions

プロパティ: multiplicative

  `declare (f, multiplicative)`は Maxima整理器に `f`が乗法的であることを知らせます。

  1. もし `f`が１変数関数なら、 整理器が積に適用された `f`に出会うといつでも、 `f`はその積上に分配されます。 例えば、 `f(x*y)`は `f(x)*f(y)`に整理されます。 この整理は形式 `f('product(...))`の式には適用されません。
  2. もし `f`が多変数関数なら、 乗法性は `f`の最初の引数の乗法性として定義されます。 例えば、 `f (g(x) * h(x), x)`は `f (g(x) ,x) * f (h(x), x)`に整理されます。

  `declare(nounify(product), multiplicative)`はMaximaに記号積を整理するように命じます。

  例:

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

  `declare(nounify(product), multiplicative)` tells Maxima to simplify symbolic products.

      (%i1) product (a[i] * b[i], i, 1, n);
                                          n
                                        /===\
                                         ! !
      (%o1)                              ! !  a  b
                                         ! !   i  i
                                        i = 1
      (%i2) declare (nounify (product), multiplicative);
      (%o2)                                done
      (%i3) product (a[i] * b[i], i, 1, n);
                                       n         n
                                     /===\     /===\
                                      ! !       ! !
      (%o3)                         ( ! !  a )  ! !  b
                                      ! !   i   ! !   i
                                     i = 1     i = 1

  Categories: Declarations and inferences · Expressions · Simplification

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

  Categories: Expressions

プロパティ: nary

  `declare(f, nary)`はMaximaに 関数 `f`をn項関数として認識するよう命じます。

  `nary`宣言は `nary`関数をコールするのと同じではありません。 `declare(f, nary)`は唯一の効果は 例えば、 `foo(x, foo(y, z))`を `foo(x, y, z)`に整理するように 入れ子の式をフラットにするようMaxima整理器に指示することです。 `declare`も参照してください。

  例:

      (%i1) H (H (a, b), H (c, H (d, e)));
      (%o1)               H(H(a, b), H(c, H(d, e)))
      (%i2) declare (H, nary);
      (%o2)                         done
      (%i3) H (H (a, b), H (c, H (d, e)));
      (%o3)                   H(a, b, c, d, e)

オプション変数: negdistrib

  デフォルト値: `true`

  `negdistrib`が`true`の時 -1が式上に分配されます。 例えば、 `-(x + y)`は `- y - x`になります。 `false`に設定すると `- (x + y)`はそのまま表示されることになるでしょう。 これは時々役に立ちますが、よく注意してください; `simp`フラグ同様に、 当然のことながら、Maximaの中でローカルな使用以外には、 これは `false`に設定したくないフラグの１つです。

  例:

      (%i1) negdistrib;
      (%o1)                                true
      (%i2) -(x+y);
      (%o2)                               - y - x
      (%i3) negdistrib : not negdistrib ;
      (%o3)                                false
      (%i4) -(x+y);
      (%o4)                              - (y + x)

  Categories: Simplification flags and variables

システム変数: opproperties

  `opproperties`は、Maximaの整理器が認識する特殊演算子プロパティのリストです:

  例:

      (%i1) opproperties;
      (%o1) [linear, additive, multiplicative, outative, evenfun, oddfun,.
             commutative, symmetric, antisymmetric, nary, lassociative, rassociative]

  Categories: Global variables · Operators

プロパティ: outative

  `declare (f, outative)`は Maximaの整理器に `f`の引数の中の定数因子が外に出すことができることを告げます。

  1. もし`f`が1変数関数なら、 整理器が積に適用された `f`に出会うといつでも、 その積は定数因子と定数でない因子に分割され、定数因子が外に出されます。 例えば、 `a`を定数とすると、 `f(a*x)`は `a*f(x)`に整理されます。 アトムでない定数因子は外に出ません。
  2. もし`f`が多変数関数なら、 outativityは `sum`や `integrate`の場合のように定義されます。 すなわち、 `a`が`x`に依らないとすると、 `f (a*g(x), x)`は `a * f(g(x), x)`に整理されます。

  `sum`, `integrate`, `limit`はすべて `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)

  Categories: Declarations and inferences · Operators

関数: radcan (expr)

  対数関数、指数関数、累乗根を含む exprを 与えられ場変数の順序で式の大きなクラス上の標準形式に整理します; 関数的に同値な形式は特殊な形式にマップされます。 式の幾分大きなクラスに対して `radcan`は正規形を生成します。 このクラスの同値な2式は必ずしも見た目が同じわけではありませんが、 それらの差は `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

  Categories: Simplification functions

オプション変数: radexpand

  デフォルト値: `true`

  `radexpand`は根号のいくつかの整理を制御します。

  `radexpand`が `all`の時 n乗の積の因子のn番目の根を根号の外に出すようにします。 例えば、もし`radexpand`が `all`なら、 `sqrt (16*x^2)`は `4*x`に整理されます。

  特に `sqrt (x^2)`を考えます。

  - もし `radexpand`が `all`か `assume (x > 0)`が実行されたなら、 `sqrt(x^2)`は `x`に整理されます。
  - もし `radexpand`が `true`かつ `domain`が `real`(これはデフォルトです)なら、 `sqrt(x^2)`は `abs(x)`に整理されます。
  - もし `radexpand`が `false`か、 `radexpand`が `true`かつ `domain`が `complex`なら、 `sqrt(x^2)`は整理されません。

  `domain`は `radexpand`が `true`の時だけ 意味を持つことに注意してください。

  Categories: Simplification flags and variables

プロパティ: rassociative

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

  Categories: Declarations and inferences · Operators

関数: scsimp (expr, rule_1, ..., rule_n)

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

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

  Categories: Simplification functions

オプション変数: simp

  デフォルト値: `true`

  `simp`は整理を有効にします。 これは標準です。 `simp`は `evflag`でもあります。 それは関数 `ev`に認識されます。 `ev`を参照してください。

  `simp`が値 `false`で `evflag`として使われる時、 式の評価フェイズの間だけ整理は抑制されます。 フラグは評価フェイズに続く整理を抑制できません。

  例:

  グローバルに整理をスイッチオフします。 式 `sin(1.0)`は数値に整理されません。 `simp`-フラグは整理をオンにスイッチします。

      (%i1) simp:false;
      (%o1)                                false
      (%i2) sin(1.0);
      (%o2)                              sin(1.0)
      (%i3) sin(1.0),simp;
      (%o3)                          .8414709848078965

  整理を再びスイッチオンします。 `simp`-フラグは完全には整理を抑制できません。 割り当ては式の評価フェイズの間に起こるので、 出力は整理された式を示しますが、変数 `x`は値として未整理の式を持ちます。

      (%i4) simp:true;
      (%o4)                                true
      (%i5) x:sin(1.0),simp:false;
      (%o5)                          .8414709848078965
      (%i6) :lisp $X
      ((%SIN) 1.0)

  Categories: Evaluation flags

プロパティ: symmetric

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

  `commutative`は `symmetric`と同義です。

  Categories: Declarations and inferences · Operators

関数: xthru (expr)

  （和の） exprのすべての項を 共通分母上で `ratsimp`がするように積や指数和を展開することなしに結合させます。 因子が陽であるときだけ、 `xthru`は有理式の分子と分母の共通因子を消去します。

  分子と分母の最大公約数の陽因子を消去するために、式を `ratsimp`する前に `xthru`を使うのがよい場合があります。

      (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
                                      20
                       1       (x + 2)   - 2 y       x
      (%o1)        --------- + --------------- - ---------
                          19             20             20
                   (y + x)        (y + x)        (y + x)
      (%i2) xthru (%);
                                       20
                                (x + 2)   - y
      (%o2)                     -------------
                                         20
                                  (y + x)

  Categories: Expressions

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by 市川雄二 on June, 21 2016 using texi2html 1.76.