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

# 28. Sums, Products, and Series

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

## 28.1 Functions and Variables for Sums and Products

関数: bashindices (expr)

  それぞれの和や積に独自のインデックスを与えることで式 exprを変換します。 これは、和や積と一緒に機能する時 `changevar`によりよい精度を与えます。 独自のインデックスの形式は `jnumber`です。 量 numberは `gensumnum`に参照することで決定されます。 ユーザーはこれを変更することができます。 例えば、 `gensumnum:0$`はそれを再設定します。

  Categories: Sums and products

関数: lsum (expr, x, L)

  Lの中のそれぞれの要素 xに関する exprの和を表します。 もし引数 Lがリストに評価されないなら、名詞形 `'lsum`を返します。

  例:

      (%i1) lsum (x^i, i, [1, 2, 7]);
                                  7    2
      (%o1)                      x  + x  + x
      (%i2) lsum (i^2, i, rootsof (x^3 - 1, x));
                           ====
                           \      2
      (%o2)                 >    i
                           /
                           ====
                                         3
                           i in rootsof(x  - 1, x)

  Categories: Sums and products

関数: intosum (expr)

  和の外側の掛け算因子を内側に移動します。 もし外側の式でインデックスが使われているなら、 関数は `sumcontract`に関してするのと同じように、 合理的なインデックスを見つけようとします。 これは、本質的に和の `outative`プロパティの逆の考えですが、 このプロパティを取り除かず、ただ無視するだけであることに注意してください。

  いくつかの場合、 `intosum`の前に `scanmap (multthru, expr)`が必要になるかもしれません。

  Categories: Expressions

オプション変数: simpproduct

  デフォルト値: `false`

  `simpproduct`が `true`の時 `product`の結果は整理されます。 この整理は時々閉形式を生成することができるかもしれません。 もし `simpproduct`が `false`か 引用形式 `'product`が使われたなら、 値は数学で使われるpi記法の表現である積の名詞形です。

  Categories: Sums and products · Simplification flags and variables

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

  Categories: Sums and products

オプション変数: simpsum

  デフォルト値: `false`

  `simpsum`が `true`の時、 `sum`の結果は整理されます。 この整理は、時々、閉形式を生成することができるかもしれません。 もし `simpsum`が `false`であるか、クォートされた形 `'sum`が使われたなら、値は数学で使われるΣ表示の表現である和の名詞形です。

  Categories: Sums and products · Simplification flags and variables

関数: sum (expr, i, i_0, i_1)

  インデックス iが i_0から i_1まで変わるように exprの値の和を返します。 名詞形 `'sum`は大文字Σとして表示されます。

  `sum`は被和 exprと下限上限 i_0, i_1を評価し、 `sum`はインデックス iをクォートします（評価しません）。

  もし上限と下限が整数差だけ違うなら、被和 exprはインデックス iのそれぞれの値に関して評価され、結果は明示的な和です。

  そうでないならインデックスの範囲は不定です。 積を整理するためにいくつかの規則が適用されます。 グローバル変数 `simpsum`が `true`の時、 更なる規則が適用されます。いくつかの場合、式整理は和でない結果を出力します; そうでないなら、結果は名詞形 `'sum`です。

  `evflag`(評価フラグ) `cauchysum`が `true`の時、 和の積はコーシー積として表現されます。 コーシー積では内側の和のインデックスは独立に変化するのではなく、 外側の和のインデックスの関数になります。

  グローバル変数 `genindex`は、 和の次のインデックスを生成するのに使われるアルファベット前置です。

  `gensumnum`は、自動生成されるインデックスが必要な時 和の次のインデックスを生成するのに使われる数値接尾です。 `gensumnum`が `false`の時, 自動生成されるインデックスは接尾なしの `genindex`のみです。

  `sumcontract`, `intosum`, `bashindices`, `niceindices`, `nouns`, `evflag`, `zeilberger`も参照してください。

  例:

      (%i1) sum (i^2, i, 1, 7);
      (%o1)                          140
      (%i2) sum (a[i], i, 1, 7);
      (%o2)           a  + a  + a  + a  + a  + a  + a
                       7    6    5    4    3    2    1
      (%i3) sum (a(i), i, 1, 7);
      (%o3)    a(7) + a(6) + a(5) + a(4) + a(3) + a(2) + a(1)
      (%i4) sum (a(i), i, 1, n);
                                  n
                                 ====
                                 \
      (%o4)                       >    a(i)
                                 /
                                 ====
                                 i = 1
      (%i5) sum (2^i + i^2, i, 0, n);
                                n
                               ====
                               \       i    2
      (%o5)                     >    (2  + i )
                               /
                               ====
                               i = 0
      (%i6) sum (2^i + i^2, i, 0, n), simpsum;
                                    3      2
                         n + 1   2 n  + 3 n  + n
      (%o6)             2      + --------------- - 1
                                        6
      (%i7) sum (1/3^i, i, 1, inf);
                                  inf
                                  ====
                                  \     1
      (%o7)                        >    --
                                  /      i
                                  ====  3
                                  i = 1
      (%i8) sum (1/3^i, i, 1, inf), simpsum;
                                      1
      (%o8)                           -
                                      2
      (%i9) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf);
                                    inf
                                    ====
                                    \     1
      (%o9)                      30  >    --
                                    /      2
                                    ====  i
                                    i = 1
      (%i10) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf), simpsum;
                                        2
      (%o10)                       5 %pi
      (%i11) sum (integrate (x^k, x, 0, 1), k, 1, n);
                                  n
                                 ====
                                 \       1
      (%o11)                      >    -----
                                 /     k + 1
                                 ====
                                 k = 1
      (%i12) sum (if k <= 5 then a^k else b^k, k, 1, 10);
                10    9    8    7    6    5    4    3    2
      (%o12)   b   + b  + b  + b  + b  + a  + a  + a  + a  + a

  Categories: Sums and products

関数: sumcontract (expr)

  定数だけ異なる上限と下限を持つ足し算の和すべてを結合します。 結果は、そんな和のそれぞれの集合の和に この和を形成するために抽出されなければならなかった適切な余項 (appropriate extra term)すべてを加えた式です。 `sumcontract`は互換性のある和すべてを結合し、 可能なら和の1つからインデックスの1つを使い、 もし供給されたどれもが使えないなら合理的なインデックスを形成するよう試みます。

  `sumcontract`の前に `intosum (expr)`を実行する必要があるかもしれません。

  Categories: Sums and products

オプション変数: sumexpand

  デフォルト値: `false`

  `sumexpand`が `true`の時、和の積と指数和は、入れ子の和に整理されます。

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

  例:

      (%i1) sumexpand: true$
      (%i2) sum (f (i), i, 0, m) * sum (g (j), j, 0, n);
                           m      n
                          ====   ====
                          \      \
      (%o2)                >      >     f(i1) g(i2)
                          /      /
                          ====   ====
                          i1 = 0 i2 = 0
      (%i3) sum (f (i), i, 0, m)^2;
                           m      m
                          ====   ====
                          \      \
      (%o3)                >      >     f(i3) f(i4)
                          /      /
                          ====   ====
                          i3 = 0 i4 = 0

  Categories: Sums and products · Simplification flags and variables

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

## 28.2 Introduction to Series

Maximaには微分可能な関数の級数を見つけるための関数 `taylor`と `powerseries`が入っています。 ある級数の閉形式を見つけることができる `nusum`のようなツールもあります。 足し算や掛け算のような演算は級数上で普通に機能します。 この節では展開を制御するグローバル変数を提供します。

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

## 28.3 Functions and Variables for Series

オプション変数: cauchysum

  デフォルト値: `false`

  上限として `inf`を持つ和同士を掛ける時、 もし `sumexpand`が `true`で、かつ `cauchysum`が `true`なら、 通常の積ではなく Cauchy積が使われます。 Cauchy積では内側の和のインデックスは独立に変化するのではなく、外側のインデックスの関数です。

  例:

      (%i1) sumexpand: false$
      (%i2) cauchysum: false$
      (%i3) s: sum (f(i), i, 0, inf) * sum (g(j), j, 0, inf);
                            inf         inf
                            ====        ====
                            \           \
      (%o3)                ( >    f(i))  >    g(j)
                            /           /
                            ====        ====
                            i = 0       j = 0
      (%i4) sumexpand: true$
      (%i5) cauchysum: true$
      (%i6) expand(s,0,0);
                       inf     i1
                       ====   ====
                       \      \
      (%o6)             >      >     g(i1 - i2) f(i2)
                       /      /
                       ====   ====
                       i1 = 0 i2 = 0

  Categories: Sums and products

関数: deftaylor (f_1(x_1), expr_1, …, f_n(x_n), expr_n)

  `deftaylor`は、ある変数 x_iの関数 f_iそれぞれに関して、 expr_iをゼロの回りの Taylor級数と定義します。 expr_iは典型的には x_iの多項式か和です; `deftaylor`はもっと一般的な式も問題なく受け付けます。

  `powerseries (f_i(x_i), x_i, 0)`は `deftaylor`で定義された級数を返します。

  `deftaylor`は関数 f_1, ..., f_nのリストを返します。 `deftaylor`は引数を評価します。

  例:

      (%i1) deftaylor (f(x), x^2 + sum(x^i/(2^i*i!^2), i, 4, inf));
      (%o1)                          [f]
      (%i2) powerseries (f(x), x, 0);
                            inf
                            ====      i1
                            \        x         2
      (%o2)                  >     -------- + x
                            /       i1    2
                            ====   2   i1!
                            i1 = 4
      (%i3) taylor (exp (sqrt (f(x))), x, 0, 4);
                            2         3          4
                           x    3073 x    12817 x
      (%o3)/T/     1 + x + -- + ------- + -------- + . . .
                           2     18432     307200

  Categories: Power series

オプション変数: maxtayorder

  デフォルト値: `true`

  `maxtayorder`が `true`の時、(切り詰められた) Taylor級数の代数操作の間、 `taylor`は厳密とわかっているできるだけ多くの項を保とうとします。

  Categories: Power series

関数: niceindices (expr)

  exprの中の和や積のインデックスを改名します。 `niceindices`は、その名前が被加数や非積数の中に現れないなら、 インデックスそれぞれを `niceindicespref[1]`の値に改名しようとします。 現れた場合、 `niceindices`は 未使用の変数が見つかるまで `niceindicespref`の次の要素を順に試します。 もしリスト全部が使い果たされたら、 例えば `i0`, `i1`, `i2`, ....というように `niceindicespref[1]`の値に整数を追加することで、 追加のインデックスを構成します。

  `niceindices`は式を返します。 `niceindices`は引数を評価します。

  例:

      (%i1) niceindicespref;
      (%o1)                  [i, j, k, l, m, n]
      (%i2) product (sum (f (foo + i*j*bar), foo, 1, inf), bar, 1, inf);
                       inf    inf
                      /===\   ====
                       ! !    \
      (%o2)            ! !     >      f(bar i j + foo)
                       ! !    /
                      bar = 1 ====
                              foo = 1
      (%i3) niceindices (%);
                           inf  inf
                          /===\ ====
                           ! !  \
      (%o3)                ! !   >    f(i j l + k)
                           ! !  /
                          l = 1 ====
                                k = 1

  Categories: Sums and products

オプション変数: niceindicespref

  デフォルト値: `[i, j, k, l, m, n]`

  `niceindicespref`は、 `niceindices`が和や積のインデックスに使う名前の リストです。

  `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

  Categories: Sums and products

関数: nusum (expr, x, i_0, i_1)

  R.W. Gosperによる決定手続きを使って、 xに関する exprの不定超幾何総和を実行します。 exprと結果は整数べき、階乗、二項式、有理関数の積として表現可能でなければいけません。

  用語「定」と「不定和」は「定」と「不定積分」へ類似して使われています。 不定に和を取ることは、ただ例えば0からinfまで和を取るのではなく、 可変な長さの区間上の和に関してシンボリックな結果を与えることを意味します。 例えば、二項級数の一般的な部分和に関する公式はないので、 `nusum`はそれができません。

  `nusum`と `unsum`は有限積の和と差について少し知っています。 `unsum`も参照してください。

  例:

      (%i1) nusum (n*n!, n, 0, n);

      Dependent equations eliminated:  (1)
      (%o1)                     (n + 1)! - 1
      (%i2) nusum (n^4*4^n/binomial(2*n,n), n, 0, n);
                           4        3       2              n
            2 (n + 1) (63 n  + 112 n  + 18 n  - 22 n + 3) 4      2
      (%o2) ------------------------------------------------ - ------
                          693 binomial(2 n, n)                 3 11 7
      (%i3) unsum (%, n);
                                    4  n
                                   n  4
      (%o3)                   ----------------
                              binomial(2 n, n)
      (%i4) unsum (prod (i^2, i, 1, n), n);
                          n - 1
                          /===\
                           ! !   2
      (%o4)              ( ! !  i ) (n - 1) (n + 1)
                           ! !
                          i = 1
      (%i5) nusum (%, n, 1, n);

      Dependent equations eliminated:  (2 3)
                                  n
                                /===\
                                 ! !   2
      (%o5)                      ! !  i  - 1
                                 ! !
                                i = 1

  Categories: Sums and products

関数: pade (taylor_series, numer_deg_bound, denom_deg_bound)

  以下の有理関数すべてのリストを返します。 与えられたTaylor級数展開で、分子と分母の次数の和がべき級数の切り詰めレベル以下のもの すなわち「最良」近似を有理関数は持ち、加えて指定された次数範囲を満たすものです。

  taylor_seriesは１変数Taylor級数です。 numer_deg_boundと denom_deg_boundは分子と分母上の次数範囲を指定する正の整数です。

  taylor_seriesは Laurent級数も可能です。 次数範囲は、`inf`も可能で、 総次数が冪級数の長さ以下の有理関数すべてを返すことになります。 総次数は `numer_deg_bound + denom_deg_bound`として定義されます。 べき級数の長さは `"truncation level" + 1 - min(0, "order of series")`として定義されます。

      (%i1) taylor (1 + x + x^2 + x^3, x, 0, 3);
                                    2    3
      (%o1)/T/             1 + x + x  + x  + . . .
      (%i2) pade (%, 1, 1);
                                       1
      (%o2)                       [- -----]
                                     x - 1
      (%i3) t: taylor(-(83787*x^10 - 45552*x^9 - 187296*x^8
                         + 387072*x^7 + 86016*x^6 - 1507328*x^5
                         + 1966080*x^4 + 4194304*x^3 - 25165824*x^2
                         + 67108864*x - 134217728)
             /134217728, x, 0, 10);
                          2    3       4       5       6        7
                   x   3 x    x    15 x    23 x    21 x    189 x
      (%o3)/T/ 1 - - + ---- - -- - ----- + ----- - ----- - ------
                   2    16    32   1024    2048    32768   65536

                                        8         9          10
                                  5853 x    2847 x    83787 x
                                + ------- + ------- - --------- + . . .
                                  4194304   8388608   134217728
      (%i4) pade (t, 4, 4);
      (%o4)                          []

  このべき級数展開を持つ次数4の分子/分母の有理関数はありません。 一般的に、 解くのに十分な数の未知の係数を持つために、 その和が少なくともべき級数の次数になるまで 分子の次数と分母の次数を増やさなければいけません。

      (%i5) pade (t, 5, 5);
                           5                4                 3
      (%o5) [- (520256329 x  - 96719020632 x  - 489651410240 x

                        2
       - 1619100813312 x  - 2176885157888 x - 2386516803584)

                     5                 4                  3
      /(47041365435 x  + 381702613848 x  + 1360678489152 x

                        2
       + 2856700692480 x  + 3370143559680 x + 2386516803584)]

  Categories: Power series

関数: powerseries (expr, x, a)

  変数 xに関する点 a (無限大のためには `inf`かもしれません)の回りの exprのべき級数展開の一般形式を返します:

                 inf
                 ====
                 \               n
                  >    b  (x - a)
                 /      n
                 ====
                 n = 0

  もし `powerseries`が exprを展開することができないなら、 `taylor`が級数の最初のいくつかの項を与えることができます。

  `verbose`が `true`の時、 `powerseries`は進捗メッセージを印字します。

      (%i1) verbose: true$
      (%i2) powerseries (log(sin(x)/x), x, 0);
      can't expand
                                       log(sin(x))
      so we'll try again after applying the rule:
                                              d
                                            / -- (sin(x))
                                            [ dx
                              log(sin(x)) = i ----------- dx
                                            ]   sin(x)
                                            /
      in the first simplification we have returned:
                                   /
                                   [
                                   i cot(x) dx - log(x)
                                   ]
                                   /
                          inf
                          ====        i1  2 i1             2 i1
                          \      (- 1)   2     bern(2 i1) x
                           >     ------------------------------
                          /                i1 (2 i1)!
                          ====
                          i1 = 1
      (%o2)                -------------------------------------
                                            2

  Categories: Power series

オプション変数: psexpand

  デフォルト値: `false`

  `psexpand`が `true`の時、 拡張有理関数展開が完全に展開されて表示されます。 スイッチ `ratexpand`は同じ効果を持ちます。

  `psexpand`が `false`の時、 多変数式がちょうど有理関数パッケージと同じように表示されます。

  `psexpand`が `multi`の時、 変数に関する同じ総次数の項は一緒にまとめられます。

  Categories: Display flags and variables

関数: revert (expr, x)
関数: revert2 (expr, x, n)

  これらの関数は、変数 xに関するゼロの回りの Taylor級数 exprの反転を返します。 `revert`は exprの最高次数と等しい次数の多項式を返します。 `revert2`は次数 nの多項式を返します。 nは exprの次数よりも大きい値も小さい値も同じ値も取り得ます。

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

  例:

      (%i1) load ("revert")$
      (%i2) t: taylor (exp(x) - 1, x, 0, 6);
                         2    3    4    5     6
                        x    x    x    x     x
      (%o2)/T/      x + -- + -- + -- + --- + --- + . . .
                        2    6    24   120   720
      (%i3) revert (t, x);
                     6       5       4       3       2
                 10 x  - 12 x  + 15 x  - 20 x  + 30 x  - 60 x
      (%o3)/R/ - --------------------------------------------
                                      60
      (%i4) ratexpand (%);
                           6    5    4    3    2
                          x    x    x    x    x
      (%o4)             - -- + -- - -- + -- - -- + x
                          6    5    4    3    2
      (%i5) taylor (log(x+1), x, 0, 6);
                          2    3    4    5    6
                         x    x    x    x    x
      (%o5)/T/       x - -- + -- - -- + -- - -- + . . .
                         2    3    4    5    6
      (%i6) ratsimp (revert (t, x) - taylor (log(x+1), x, 0, 6));
      (%o6)                           0
      (%i7) revert2 (t, x, 4);
                                4    3    2
                               x    x    x
      (%o7)                  - -- + -- - -- + x
                               4    3    2

  Categories: Power series

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

  Categories: Power series

オプション変数: taylordepth

  デフォルト値: 3

  もしまだ非ゼロ項がないなら、展開の次数が `n 2^taylordepth`以下である限り、 `taylor`は `g(x)`の展開の次数を倍にします。

  Categories: Power series

関数: taylorinfo (expr)

  Taylor級数 exprについての情報を返します。 戻り値はリストのリストです。 リストそれぞれは、変数名、展開点、展開次数から構成されます。

  もし exprが Taylor級数でないなら、 `taylorinfo`は `false`を返します。

  例:

      (%i1) taylor ((1 - y^2)/(1 - x), x, 0, 3, [y, a, inf]);
                        2                       2
      (%o1)/T/ - (y - a)  - 2 a (y - a) + (1 - a )

               2                        2
       + (1 - a  - 2 a (y - a) - (y - a) ) x

               2                        2   2
       + (1 - a  - 2 a (y - a) - (y - a) ) x

               2                        2   3
       + (1 - a  - 2 a (y - a) - (y - a) ) x  + . . .
      (%i2) taylorinfo(%);
      (%o2)               [[y, a, inf], [x, 0, 3]]

  Categories: Power series

関数: taylorp (expr)

  もし exprが Taylor級数なら `true`を、 そうでないなら `false`を返します。

  Categories: Predicate functions · Power series

オプション変数: taylor_logexpand

  デフォルト値: `true`

  `taylor_logexpand`は `taylor`級数の中の対数の展開を制御します。

  `taylor_logexpand`が `true`の時、 対数すべては完全に展開されるので、 対数的恒等式を含むゼロ認識問題は展開プロセスを邪魔しません。 しかしながら、分岐情報を無視するのでこの方法はいつも数学的に正しいわけではありません。

  `taylor_logexpand`が `false`に設定されている時、 なされる対数の唯一の展開は形式的なべき級数を得るのに必要なものです。

  Categories: Power series · Exponential and logarithm functions

オプション変数: taylor_order_coefficients

  デフォルト値: `true`

  `taylor_order_coefficients`は Taylor級数の中の係数の順序付けを制御します。

  `taylor_order_coefficients`が `true`の時、 Taylor級数の係数は標準に順序付けられます。

  Categories: Power series

関数: taylor_simplifier (expr)

  べき級数 exprの係数を整理します。 `taylor`がこの関数をコールします。

  Categories: Power series

オプション変数: taylor_truncate_polynomials

  デフォルト値: `true`

  `taylor_truncate_polynomials`が `true`の時、 多項式は入力切り詰めレベルを基礎に切り詰められます。

  そうでないなら、 `taylor`への多項式入力は不定の精度を持つと考えられます。

  Categories: Power series

関数: taytorat (expr)

  `taylor`形式から標準有理式 (CRE)形式に exprを変換します。 効果は `rat (ratdisrep (expr))`と同じですがより速いです。

  Categories: Power series · Rational expressions

関数: trunc (expr)

  一般式 exprの内部表現に注釈をする(annotate)ので、まるでその和が切り詰められた 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

  Categories: Power series

関数: unsum (f, n)

  最初の後方差 `f(n) - f(n - 1)`を返します。 従って `unsum`はある意味 `sum`の逆です。

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

  例:

      (%i1) g(p) := p*4^n/binomial(2*n,n);
                                           n
                                        p 4
      (%o1)               g(p) := ----------------
                                  binomial(2 n, n)
      (%i2) g(n^4);
                                    4  n
                                   n  4
      (%o2)                   ----------------
                              binomial(2 n, n)
      (%i3) nusum (%, n, 0, n);
                           4        3       2              n
            2 (n + 1) (63 n  + 112 n  + 18 n  - 22 n + 3) 4      2
      (%o3) ------------------------------------------------ - ------
                          693 binomial(2 n, n)                 3 11 7
      (%i4) unsum (%, n);
                                    4  n
                                   n  4
      (%o4)                   ----------------
                              binomial(2 n, n)

  Categories: Sums and products

オプション変数: verbose

  デフォルト値: `false`

  `verbose`が `true`の時、 `powerseries`は進捗メッセージを印字します。

  Categories: Power series

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

## 28.4 Introduction to Fourier series

`fourie`パッケージは Fourier級数のシンボル計算のための関数を含みます。 `fourie`パッケージの中には Fourier積分係数を計算する関数や式の操作のためのいくつかの関数があります。

Categories: Fourier transform · Share packages · Package fourie

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

## 28.5 Functions and Variables for Fourier series

関数: equalp (x, y)

  もし `equal (x, y)`なら `true`を返し、 そうでないなら `false`を返します。 (この場合 `equal (x, y)`がするようなエラーメッセージを与えません。)

  Categories: Package fourie

関数: remfun
`remfun` (f, expr)
`remfun` (f, expr, x)

  `remfun (f, expr)`は exprの中の `f (arg)`すべてを argで置き換えます。

  `remfun (f, expr, x)`は exprの中の `f (arg)`を argが変数 xを含むときだけ argで置き換えます。

  Categories: Package fourie

関数: funp
`funp` (f, expr)
`funp` (f, expr, x)

  もし exprが関数 fを含むなら `funp (f, expr)`は `true`を返します。

  もし exprが関数 fを含み、変数 xが fのインスタンスの１つの引数のどこかにあるなら、 `funp (f, expr, x)`は `true`を返します。

  Categories: Package fourie

関数: absint
`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)`は xに関する fの aからbまでの定積分を返します。 fは絶対値を含むことができます。

  Categories: Package fourie · Integral calculus

関数: fourier (f, x, p)

  区間 `[-p, p]`上で定義された `f(x)`の Fourier係数のリストを返します。

  Categories: Package fourie

関数: foursimp (l)

  もし `sinnpiflag`が `true`なら `sin (n %pi)`を0に整理します。 もし `cosnpiflag`が `true`なら `cos (n %pi)`を `(-1)^n`に整理します。

  Categories: Package fourie · Trigonometric functions · Simplification functions

オプション変数: sinnpiflag

  デフォルト値: `true`

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

  Categories: Package fourie

オプション変数: cosnpiflag

  デフォルト値: `true`

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

  Categories: Package fourie

関数: fourexpand (l, x, p, limit)

  Fourier係数 lのリストから limit項までのFourier級数を構成して返します。 (limitは`inf`も取り得ます。) xと pは `fourier`におけるものと同じ意味を持ちます。

  Categories: Package fourie

関数: fourcos (f, x, p)

  `[0, p]`上で定義された `f(x)`の Fourierコサイン係数を返します。

  Categories: Package fourie

関数: foursin (f, x, p)

  `[0, p]`上で定義された `f(x)`の Fourierサイン係数を返します。

  Categories: Package fourie

関数: totalfourier (f, x, p)

  `fourexpand (foursimp (fourier (f, x, p)), x, p, 'inf)`を返します。

  Categories: Package fourie

関数: fourint (f, x)

  `[minf, inf]`上で定義された `f(x)`の Fourier積分係数のリストを構成して返します。

  Categories: Package fourie

関数: fourintcos (f, x)

  `[0, inf]`上の `f(x)`の Fourierコサイン積分係数を返します。

  Categories: Package fourie

関数: fourintsin (f, x)

  `[0, inf]`上の `f(x)`の Fourierサイン積分係数を返します。

  Categories: Package fourie

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

## 28.6 Functions and Variables for Poisson series

関数: intopois (a)

  aを Poisson符号に変換します。

  Categories: Poisson series

関数: outofpois (a)

  aを Poisson符号から一般表現に変換します。 もし aが Poisson形式でないなら、 `outofpois`は変換を実行します。 すなわち、その戻り値は `outofpois (intopois (a))`です。 例えば、この関数は特定のタイプのサインやコサイン項のべきの和に関する標準 (canonical)整理器です。

  Categories: Poisson series

関数: poisdiff (a, b)

  aを bに関して微分します。 bは三角関数の引数の中だけか係数の中だけにいなければいけません。

  Categories: Poisson series

関数: poisexpt (a, b)

  関数的に `intopois (a^b)`と同一です。 bは正の整数でなければいけません。

  Categories: Poisson series

関数: poisint (a, b)

  (`poisdiff`と)同様に制限された意味で積分します。 もし bが三角関数の引数の中にあるなら bの中の非周期的項を落とします。

  Categories: Poisson series

オプション変数: poislim

  デフォルト値: 5

  `poislim`は三角関数の引数の中の係数の領域を決定します。 初期値 5は区間 [-2^(5-1)+1,2^(5-1)] すなわち[-15,16]に対応しますが、 [-2^(n-1)+1, 2^(n-1)]に設定することができます。

  Categories: Poisson series

関数: poismap (series, sinfn, cosfn)

  関数 sinfnを与えられた Poisson級数のサイン項に、 cosfnをコサイン項にマップします。 sinfnと cosfnは ２引数関数です。 引数それぞれは級数の中の項の係数と三角関数部です。

  Categories: Poisson series

関数: poisplus (a, b)

  関数的に `intopois (a + b)`と同一です。

  Categories: Poisson series

関数: poissimp (a)

  aを一般表現の aに関する Poisson級数に変換します。

  Categories: Poisson series

特殊シンボル: poisson

  シンボル `/P/`は Poisson級数式の行ラベルに続きます。

  Categories: Poisson series

関数: poissubst (a, b, c)

  aを cの中の bに代入します。 cは Poisson級数です。

  (1) bが変数 u, v, w, x, y, zのいずれかの場合、 aはそれらの変数に関して線形の式(例えば `6*u + 4*v`)でなければいけません。

  (2) bはそれらの変数以外の場合、 aもまたそれらの変数を含んではいけなく、さらにサインもコサインも含んではいけません。

  `poissubst (a, b, c, d, n)`は上のタイプ (1)のようにaと bに関して演算しますが、 dが Poisson級数の場合、 cの中で bに `a + d`を代入した結果を供給するために、 `cos(d)`と `sin(d)`を次数 nに展開する特殊なタイプの代入です。 アイデアは dが小さなパラメータの項に関する展開だということです。 例えば、 `poissubst (u, v, cos(v), %e, 3)`は `cos(u)*(1 - %e^2/2) - sin(u)*(%e - %e^3/6)`をもたらします。

  Categories: Poisson series

関数: poistimes (a, b)

  `intopois (a*b)`と同じ機能です。

  Categories: Poisson series

関数: poistrim ()

  (もしユーザーがそれを定義したら) Poisson乗算の間、適用する予約関数です。 項の中の u, v, ..., zの係数を引数とする６引数の述語論理関数です。 (この項の係数に関して) `poistrim`が `true`となる項は乗算の間に消去されます。

  Categories: Poisson series

関数: printpois (a)

  可読フォーマットで Poisson級数を印字します。 `outofpois`と共通で、もし必要なら aを最初に Poisson符号に変換します。

  Categories: Poisson series · Display functions

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

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