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

# 11. Maximas Database

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

## 11.1 Introduction to Maximas Database

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

## 11.2 Functions and Variables for Properties

プロパティ: alphabetic

  `alphabetic`は`declare`が認識するプロパティタイプです。 式 `declare(s, alphabetic)`は sの中の文字すべてをアルファベット文字として認識するように Maximaに命じます。 sは文字列でなければいけません。

  Identifiersも参照してください。

  例:

      (%i1) xx\~yy\`\@ : 1729;
      (%o1)                         1729
      (%i2) declare ("~`@", alphabetic);
      (%o2)                         done
      (%i3) xx~yy`@ + @yy`xx + `xx@@yy~;
      (%o3)               `xx@@yy~ + @yy`xx + 1729
      (%i4) listofvars (%);
      (%o4)                  [@yy`xx, `xx@@yy~]

  Categories: Declarations and inferences

プロパティ: bindtest

  コマンド `declare(x, bindtest)`は xがバインドされずに評価された時、 Maximaにエラーを起こすように命じます。

      (%i1) aa + bb;
      (%o1)                        bb + aa
      (%i2) declare (aa, bindtest);
      (%o2)                         done
      (%i3) aa + bb;
      aa unbound variable
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i4) aa : 1234;
      (%o4)                         1234
      (%i5) aa + bb;
      (%o5)                       bb + 1234

プロパティ: constant

  `declare(a, constant)`は aが定数であるように宣言します。 シンボルが定数であるという宣言は定数でない値をシンボルに割り当てることを 妨げません。

  `constantp`と `declare`を参照してください。

  例:

      (%i1) declare(c, constant);
      (%o1)                         done
      (%i2) constantp(c);
      (%o2)                         true
      (%i3) c : x;
      (%o3)                           x
      (%i4) constantp(c);
      (%o4)                         false

  Categories: Declarations and inferences · Constants

関数: constantp (expr)

  もし exprが定数式なら `true`を返します。 そうでないなら `false`を返します。

  もし引数が、（`/R/`をつけて表示される有理数を含む）数や `%pi`, `%e`, `%i`にようなシンボル定数、定数にバインドされた変数、 `declare`で宣言された定数、引数が定数の関数のいずれかなら、 式を定数式とみなします。

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

  例:

      (%i1) constantp (7 * sin(2));
      (%o1)                                true
      (%i2) constantp (rat (17/29));
      (%o2)                                true
      (%i3) constantp (%pi * sin(%e));
      (%o3)                                true
      (%i4) constantp (exp (x));
      (%o4)                                false
      (%i5) declare (x, constant);
      (%o5)                                done
      (%i6) constantp (exp (x));
      (%o6)                                true
      (%i7) constantp (foo (x) + bar (%e) + baz (2));
      (%o7)                                false
      (%i8)

  Categories: Predicate functions · Constants

関数: declare (a_1, p_1, a_2, p_2, …)

  アトムやアトムのリスト a_iにプロパティやプロパティのリスト p_iを割り当てます。 a_iや p_iがリストの時、プロパティすべてをアトムのそれぞれが得ます。

  `declare`は引数をクォートします。 `declare`はいつも `done`を返します。

  それぞれの宣言フラグに関する記述で注意しているように、 いくつかのフラグに関して、 もし objectが featureを持つよう宣言されているなら、 `featurep(object, feature)`は `true`を返します。

  フィーチャーシステムについてさらに知るには `features`.を参照してください。 アトムからプロパティを削除するには `remove`.を使ってください。

  `declare`は以下のプロパティを認識します:

  `additive`

    代入 `a_i(x + y + z + ...)` `-->` `a_i(x) + a_i(y) + a_i(z) + ...` によって、 a_i式を整理するように Maximaに命じます。 代入は１番目の引数のみで実行されます。

  `alphabetic`

    a_iの中の文字すべてをアルファベット文字として認識するように Maximaに命じます。(a_iは文字列でなければいけません。)

  `antisymmetric, commutative, symmetric`

    a_iを対称もしくは反対称関数として認識するように Maximaに命じます。 `commutative`は `symmetric`と同じです。

  `bindtest`

    a_iがバインドされずに評価された時、 Maximaにエラーを起こすように命じます。

  `constant`

    a_iをシンボル定数とみなすように Maximaに命じます。

  `even, odd`

    a_iを偶数か奇数の整数変数として認識するように Maximaに命じます。

  `oddfun, evenfun`

    a_iを偶関数もしくは奇関数として認識するように Maximaに命じます。

  `evflag`

    `ev`のフラグ引数として a_iが現れた時、 `ev`の実行中 a_iを `true`にバインドするように `ev`に命じます。 `evflag`を参照してください。

  `evfun`

    `ev`のフラグ引数として a_iが現れた時、 a_iと名付けられた関数を適用するように `ev`に命じます。 `evfun`を参照してください。

  `feature`

    a_iをフィーチャー名として認識するように Maximaに命じます。 すると他のアトムを a_iプロパティを持つように定義できるようになります。

  `increasing, decreasing`

    a_iを単調増加関数か単調減少関数として認識するように Maximaに命じます。

  `integer, noninteger`

    a_iを整数変数か非整数変数として認識するように Maximaに命じます。

  `integervalued`

    a_iを整数値を返す関数として認識するように Maximaに命じます。

  `lassociative, rassociative`

    a_iを右結合か左結合関数として認識するように Maximaに命じます。

  `linear`

    a_iを `outative`かつ `additive`に宣言することと同値です。

  `mainvar`

    a_iを「主変数」とみなすように Maximaに命じます。 `ordergreatp`で決定されるように、 Maximaの式の標準順序では主変数は他のすべての定数や変数に続きます。

  `multiplicative`

    代入 `a_i(x * y * z * ...)` `-->` `a_i(x) * a_i(y) * a_i(z) * ...` によって、 a_i式を整理するように Maximaに命じます。 代入は１番目の引数のみで実行されます。

  `nary`

    a_iを n項関数として認識するように Maximaに命じます。

    `nary`宣言は `nary`関数をコールするのとは同じではありません。 `declare(foo, nary)`だけの効果は、 Maxima整理器をネストされた式を平坦にするように指示することです。 例えば `foo(x, foo(y, z))`を `foo(x, y, z)`に整理します。

  `nonarray`

    a_iを配列でないものとみなすように Maximaに命じます。 この宣言は添字付き変数名の多重評価を抑制します。

  `nonscalar`

    a_iを非スカラー変数とみなすように Maximaに命じます。 普通の使い方は変数をシンボルベクトルや行列として宣言することです。

  `noun`

    a_iを名詞としてパースするように Maximaに命じます。 この効果は a_iのインスタンスを `'a_i`や `nounify(a_i)`で置き換えることです。 どちらに置き換えるかは文脈に依存します。

  `outative`

    a_i式を最初の引数から定数因子を引き出すことで整理するように Maximaに命じます。

    a_iが１つ引数を持つ時、 もしリテラル定数や宣言定数なら因子は定数とみなされます。

    a_iが２つ以上の引数を持つ時、 もし２番目の引数がシンボルで、因子が２番目の引数の制約を受けないなら、 因子は定数とみなされます。

  `posfun`

    a_iを正関数として認識するように Maximaに命じます。

  `rational, irrational`

    a_iを有理変数か非有理実変数として認識するように Maximaに命じます。

  `real, imaginary, complex`

    a_iを実変数か純虚数変数、複素変数として認識するように Maximaに命じます。

  `scalar`

    a_iをスカラー変数とみなすように Maximaに命じます。

  プロパティの使い方の例はドキュメントの中のプロパティの個別の記述それぞれで入手可能です。

  Categories: Declarations and inferences

プロパティ: decreasing
プロパティ: increasing

  コマンド `declare(f, decreasing)`や `declare(f, increasing)`は fを減少関数や増加関数として認識するように Maximaに命じます。

  他のプロパティに関しては `declare`も参照してください。

  例:

      (%i1) assume(a > b);
      (%o1)                        [a > b]
      (%i2) is(f(a) > f(b));
      (%o2)                        unknown
      (%i3) declare(f, increasing);
      (%o3)                         done
      (%i4) is(f(a) > f(b));
      (%o4)                         true

  Categories: Declarations and inferences

プロパティ: even
プロパティ: odd

  `declare(a, even)`や `declare(a, odd)`は シンボル aを偶数や奇数の整数変数としてみなすように Maximaに命じます。 関数 `evenp`や, `oddp`, `integerp`は プロパティ `even`と `odd`はを認識しません。

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

  例:

      (%i1) declare(n, even);
      (%o1)                         done
      (%i2) askinteger(n, even);
      (%o2)                          yes
      (%i3) askinteger(n);
      (%o3)                          yes
      (%i4) evenp(n);
      (%o4)                         false

  Categories: Declarations and inferences

宣言: feature

  Maximaは、システムフィーチャと数学式に適用されるフィーチャの、 ２つの異なるタイプのフィーチャを理解します。 システムフィーチャについての情報に関しては `status`も参照してください。 数学的フィーチャについての情報に関しては `features`と `featurep`も参照してください。

  `feature`それ自身は関数名でも変数名でもありません。

関数: featurep (a, f)

  現在のデータベースの中の事実に基づいてオブジェクト aがフィーチャ fを持つかどうかを決定しようとします。 もしそうなら `true`を返し、そうでないなら `false`を返します。

  `featurep`は fも fの否定も確立できない時は、 `false`を返すことに注意してください。

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

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

      (%i1) declare (j, even)$
      (%i2) featurep (j, integer);
      (%o2)                           true

  Categories: Predicate functions · Declarations and inferences

宣言: features

  Maximaは関数や変数のある数学的プロパティを認識します。 それらは「フィーチャー」と呼ばれます。

  `declare (x, foo)`は プロパティ fooを関数もしくは変数 xに与えます。

  `declare (foo, feature)`は 新しいフィーチャー fooを宣言します。 例えば、 `declare ([red, green, blue], feature)`は、 ３つの新しいフィーチャー `red`, `green`, `blue`を宣言します。

  もし xが fooプロパティを持つなら、 述語論理 `featurep (x, foo)`は `true`を返し、 そうでなければ、`false`を返します。

  インフォリスト `features`は既知のフィーチャーのリストです。 それらは、

         integer        noninteger      even
         odd            rational        irrational
         real           imaginary       complex
         analytic       increasing      decreasing
         oddfun         evenfun         posfun
         constant       commutative     lassociative
         rassociative   symmetric       antisymmetric
         integervalued

  に任意のユーザー定義フィーチャーを加えたものです。

  `features`は数学的フィーチャーのリストです。 非数学的でシステム依存のフィーチャーのリストもあります。 `status`を参照してください。

  例:

      (%i1) declare (FOO, feature);
      (%o1)                         done
      (%i2) declare (x, FOO);
      (%o2)                         done
      (%i3) featurep (x, FOO);
      (%o3)                         true

  Categories: Declarations and inferences

関数: get (a, i)

  iが示すアトム aのユーザープロパティを検索し、 もし aがプロパティ iを持たないなら `false`を返します。

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

  `put`や `qput`も参照してください。

      (%i1) put (%e, 'transcendental, 'type);
      (%o1)                    transcendental
      (%i2) put (%pi, 'transcendental, 'type)$
      (%i3) put (%i, 'algebraic, 'type)$
      (%i4) typeof (expr) := block ([q],
              if numberp (expr)
              then return ('algebraic),
              if not atom (expr)
              then return (maplist ('typeof, expr)),
              q: get (expr, 'type),
              if q=false
              then errcatch (error(expr,"is not numeric.")) else q)$
      (%i5) typeof (2*%e + x*%pi);
      x is not numeric.
      (%o5)  [[transcendental, []], [algebraic, transcendental]]
      (%i6) typeof (2*%e + %pi);
      (%o6)     [transcendental, [algebraic, transcendental]]

  Categories: Declarations and inferences

プロパティ: integer
プロパティ: noninteger

  `declare(a, integer)`や `declare(a, noninteger)`は aを整数変数か非整数変数として認識するように Maximaに命じます。

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

  例:

      (%i1) declare(n, integer, x, noninteger);
      (%o1)                         done
      (%i2) askinteger(n);
      (%o2)                          yes
      (%i3) askinteger(x);
      (%o3)                          no

  Categories: Declarations and inferences

プロパティ: integervalued

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

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

  例:

      (%i1) exp(%i)^f(x);
                                    %i f(x)
      (%o1)                      (%e  )
      (%i2) declare(f, integervalued);
      (%o2)                         done
      (%i3) exp(%i)^f(x);
                                    %i f(x)
      (%o3)                       %e

  Categories: Declarations and inferences

プロパティ: nonarray

  コマンド`declare(a, nonarray)`はMaximaに aが配列でないものと考えるように命じます。 もし aが添字付き変数ならこの宣言は多重評価を抑制します。

  例:

      (%i1) a:'b$ b:'c$ c:'d$

      (%i4) a[x];
      (%o4)                          d
                                      x
      (%i5) declare(a, nonarray);
      (%o5)                         done
      (%i6) a[x];
      (%o6)                          a
                                      x

  Categories: Expressions

宣言: nonscalar

  アトムをドット演算子に関してリストか行列のように振る舞うようにします。

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

  Categories: Declarations and inferences · Vectors · Matrices

関数: nonscalarp (expr)

  もし exprが非スカラー、すなわち、 非スカラーとして宣言されたアトムかリスト、行列を含むなら、 `true`を返します。

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

  Categories: Predicate functions · Vectors · Matrices

プロパティ: posfun

  `declare (f, posfun)`は `f`を正の関数と宣言します。 `is (f(x) > 0)`は `true`を出力します。

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

  Categories: Declarations and inferences · Operators

関数: printprops
`printprops` (a, i)
`printprops` ([a_1, …, a_n], i)
`printprops` (all, i)

  アトム aに関連付けられた指標 iの属性を表示します。 aはアトムのリストだったり、アトム `all`だったりします。 `a`の場合、与えられたプロパティを持つすべてのアトムに適用します。 例えば、 `printprops ([f, g], atvalue)`。 `printprops`は表示できないプロパティ、 すなわち `atvalue`, `atomgrad`, `gradef`, `matchdeclare`のためのものです。

  Categories: Declarations and inferences · Display functions

関数: properties (a)

  アトム aに関連づけられたプロパティすべての名前のリストを返します。

  Categories: Declarations and inferences

特殊シンボル: props

  `props`は、`declare`関数で指定されたプロパティはもちろん、 `atvalue`, `matchdeclare`, などが指定したような、 `infolists`で明示的に言及されたもの以外の任意のプロパティを持つアトムです。

  Categories: Declarations and inferences · Global variables

関数: propvars (prop)

  `props`リスト上の propが示すプロパティを持つアトムのリストを返します。 従って、 `propvars (atvalue)`は atvalueを持つアトムのリストを返します。

  Categories: Declarations and inferences

関数: put (atom, value, indicator)

  valueを atomの (indicatorが指定する)プロパティに割り当てます。 indicatorは任意のプロパティの名前を取り得ますが、 システム定義のプロパティは取りません。

  `rem`は `put`の効果をひっくり返します。

  `put`は引数を評価します。 `put`は valueを返します。

  例:

      (%i1) put (foo, (a+b)^5, expr);
                                         5
      (%o1)                       (b + a)
      (%i2) put (foo, "Hello", str);
      (%o2)                         Hello
      (%i3) properties (foo);
      (%o3)            [[user properties, str, expr]]
      (%i4) get (foo, expr);
                                         5
      (%o4)                       (b + a)
      (%i5) get (foo, str);
      (%o5)                         Hello

  Categories: Declarations and inferences

関数: qput (atom, value, indicator)

  valueを atomの (indicatorが指定する)プロパティに割り当てます。 引数がクォートされることを除いて、これは `put`と同じです。

  例:

      (%i1) foo: aa$
      (%i2) bar: bb$
      (%i3) baz: cc$
      (%i4) put (foo, bar, baz);
      (%o4)                          bb
      (%i5) properties (aa);
      (%o5)                [[user properties, cc]]
      (%i6) get (aa, cc);
      (%o6)                          bb
      (%i7) qput (foo, bar, baz);
      (%o7)                          bar
      (%i8) properties (foo);
      (%o8)            [value, [user properties, baz]]
      (%i9) get ('foo, 'baz);
      (%o9)                          bar

  Categories: Declarations and inferences

プロパティ: rational
プロパティ: irrational

  `declare(a, rational)`や `declare(a, irrational)`は aを有理実変数か非有理実変数として認識するように Maximaに命じます。

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

  Categories: Declarations and inferences

プロパティ: real
プロパティ: imaginary
プロパティ: complex

  `declare(a, real)`や, `declare(a, imaginary)`, `declare(a, complex)`は aを実変数、純虚数変数、複素変数として認識するように Maximaに命じます。

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

  Categories: Declarations and inferences

関数: rem (atom, indicator)

  atomから indicatorが示すプロパティを取り除きます。 `rem`は `put`の効果をひっくり返します。

  `rem`が呼び出された時、もし atomが indicatorプロパティを持っていたなら、 `rem`は `done`を返します。 もしそんなプロパティを持っていなかったら `false`を返します。

  Categories: Declarations and inferences

関数: remove
`remove` (a_1, p_1, …, a_n, p_n)
`remove` ([a_1, …, a_m], [p_1, …, p_n], …)
`remove` ("a", operator)
`remove` (a, transfun)
`remove` (all, p)

  アトムに関連づけられたプロパティを取り除きます。

  `remove (a_1, p_1, ..., a_n, p_n)`はアトム `a_k`からプロパティ `p_k`を取り除きます。

  `remove ([a_1, ..., a_m], [p_1, ..., p_n], ...)`はアトム a_1, …, a_mからプロパティ `p_1, ..., p_n`を取り除きます。 リストのペアは複数を取り得ます。

  `remove (all, p)`はプロパティ pを、それを持つアトムすべてから取り除きます。

  取り除かれるプロパティは、 `function`, `macro`, `mode_declare`のようなシステム定義のプロパティかもしれません。 `remove`は `put`で定義されたプロパティを取り除きません。

  翻訳された Lispバージョンの関数を取り除くために プロパティは `transfun`を取ることができます。 これを実行した後は、翻訳バージョンでなく Maximaバージョンの関数が実行されます。

  `remove ("a", operator)`または、同値の `remove ("a", op)`は、aから `prefix`, `infix`, `nary`, `postfix`, `matchfix`, `nofix`が宣言した演算子プロパティを取り除きます。 演算子名はクォートされた文字列として書かれなければいけないことに注意してください。

  アトムが指定されたプロパティを持つ持たないに関わらず、 `remove`はいつも `done`を返します。 この振る舞いは、もっと具体的な削除関数`remvalue`, `remarray`, `remfunction`, `remrule`と違っています。

  `remove`は引数をクォートします。

  Categories: Declarations and inferences

プロパティ: scalar

  `declare(a, scalar)`は aをスカラ変数とみなすように Maximaに命じます。

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

  Categories: Declarations and inferences

関数: scalarp (expr)

  もし exprが数か、定数、 `declare`で `scalar`と宣言された変数、 または、数と定数とそんな変数から完全に構成され、行列やリストを含まない変数なら、 `true`を返します。

  Categories: Predicate functions · Vectors · Matrices

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

## 11.3 Functions and Variables for Facts

関数: activate (context_1, …, context_n)

  文脈 context_1, …, context_nをアクティベートします。 これらの文脈に関する事実は、演繹し情報を検索するために利用可能となります。 これらの文脈に関する事実は`facts ()`によってリストされません。

  変数 `activecontexts`は、 `activate`関数を使ってアクティブになった文脈のリストです。

  Categories: Declarations and inferences

システム変数: activecontexts

  デフォルト値: `[]`

  変数`activecontexts`は、 現在の文脈の部分文脈なのでアクティブである文脈と対照的に、 `activate`関数を使ってアクティブになった文脈のリストです。

  Categories: Declarations and inferences

関数: askinteger
`askinteger` (expr, integer)
`askinteger` (expr)
`askinteger` (expr, even)
`askinteger` (expr, odd)

  `askinteger (expr, integer)`は `assume`データベースから exprが整数かどうかを決定しようとします。 もしそうでなく決定できなければ、 `askinteger`はユーザーに入力を促し、 可能ならばデータベースに情報をインストールしようとします。 `askinteger (expr)`は `askinteger (expr, integer)`と同値です。

  同様に、 `askinteger (expr, even)`や `askinteger (expr, odd)`は それぞれ、exprが偶数か奇数か決定しようとします。

  Categories: Declarations and inferences

関数: asksign (expr)

  最初に、指定された式が正か負かゼロか決定しようとします。 できなければ、演繹を完了するのに必要な質問をユーザーに尋ねます。 ユーザーの答えは、現在の計算の演繹のため、データベースに記録されます。 `asksign`の戻り値は `pos`か `neg`, `zero`のいずれか１つです。

  Categories: Declarations and inferences

関数: assume (pred_1, …, pred_n)

  述語論理 pred_1, …, pred_nを現在の文脈に追加します。 もし述語論理が現在の文脈と矛盾していたり冗長だったりしたなら、文脈に追加されません。 文脈は `assume`がコールされる毎に述語論理を累積していきます。

  `assume`は、文脈に追加された述語論理か、 当該のアトム `redundant`もしくは `inconsistent`を を要素に持つリストを返します。

  述語論理 pred_1, …, pred_nは 関係演算子 `< <= equal notequal >= >`を持つ式のみ許されます。 述語論理はリテラル等号 `=`やリテラル不等号 `#`の式は使えません。 `integerp`のような述語関数も使えません。

  形式 `pred_1 and ...and pred_n`の合成された述語論理は認識されます。 しかし `pred_1 or ... or pred_n`は認識されません。 もし `pred_k`が関係述語論理なら `not pred_k`は認識されます。 形式 `not (pred_1 and pred_2)`の式や `not (pred_1 or pred_2)`は認識されません。

  Maximaの推論メカニズムはそれほど強くありません; `is`によって決定されない多くの明らかな結果があります。 これは既知の弱みです。

  `assume`は複素数を伴う述語論理を扱いません。 もし述語論理が複素数を含むなら `assume`は `inconsistent`か `redundant`を返します。

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

  `is`や `facts`, `forget`, `context`, `declare`も参照してください。

  例:

      (%i1) assume (xx > 0, yy < -1, zz >= 0);
      (%o1)              [xx > 0, yy < - 1, zz >= 0]
      (%i2) assume (aa < bb and bb < cc);
      (%o2)                  [bb > aa, cc > bb]
      (%i3) facts ();
      (%o3)     [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
      (%i4) is (xx > yy);
      (%o4)                         true
      (%i5) is (yy < -yy);
      (%o5)                         true
      (%i6) is (sinh (bb - aa) > 0);
      (%o6)                         true
      (%i7) forget (bb > aa);
      (%o7)                       [bb > aa]
      (%i8) prederror : false;
      (%o8)                         false
      (%i9) is (sinh (bb - aa) > 0);
      (%o9)                        unknown
      (%i10) is (bb^2 < cc^2);
      (%o10)                       unknown

  Categories: Declarations and inferences

オプション変数: assumescalar

  デフォルト値: `true`

  `assumescalar`は、 `nonscalarp (expr)`が `false`であるような式 `expr`が ある変換に対してスカラーのように振る舞うと仮定されるかどうかを決めるのを助けます。

  `expr`がリストや行列以外の任意の式を表してるとし `[1, 2, 3]`が任意のリストや行列を表しているとすると、 もし `assumescalar`が `true`か `scalarp (expr)`が `true`か `constantp (expr)`が `true`なら、 `expr . [1, 2, 3]`は `[expr, 2 expr, 3 expr]`をもたらします。

  もし `assumescalar`が `true`なら、 そんな式は可換演算子に対してだけスカラーのように振る舞いますが、 非可換乗算 `.`に対してはそうは振る舞いません。

  `assumescalar`が `false`の時 そんな式は非スカラーのように振る舞います。

  `assumescalar`が `all`の時、 そんな式は上でリストされた演算子すべてに対してスカラーのように振る舞います。

  Categories: Declarations and inferences

オプション変数: assume_pos

  デフォルト値: `false`

  `assume_pos`が `true`で パラメータ xの符号が現在の文脈や他の考慮から決定できない時、 `sign`や `asksign (x)`は `true`を返します。 これによって、 `integrate`や他の計算から起こるような 自動生成される `asksign`問い合わせを事前に防ぐことができます。

  デフォルトでは、パラメータは `symbolp (x)`か `subvarp (x)`のような xです。 パラメータとして考えられる式のクラスは、 変数 `assume_pos_pred`を介してある程度変えることができます。

  `sign`と `asksign`は、 式の中のオペランドの符号から式の符号を演繹しようとします。 例えば、もし`a`や `b`がともに正なら `a + b`も正です。

  しかしながら、`asksign`問い合わせすべてを迂回する方法はありません。 特に `asksign`引数が差 `x - y`か 対数 `log(x)`の時、 たとえ `assume_pos`が `true`で `assume_pos_pred`が 引数すべてに `true`を返す関数であっても、 `asksign`はいつもユーザーからの入力を要請します。

  Categories: Declarations and inferences

オプション変数: assume_pos_pred

  デフォルト値: `false`

  `assume_pos_pred`が関数名や引数 xのラムダ式に割り当てられている時、 xが `assume_pos`のためのパラメータと考えられるかどうかを決定するために その関数がコールされます。 `assume_pos`が `false`の時、 `assume_pos_pred`は無視されます。

  `sign`と `asksign`が、 アトムか添字付き変数、関数コール式のいずれかの引数 xで `assume_pos_pred`関数をコールします。 もし `assume_pos_pred`関数が `true`を返すなら、 xは `assume_pos`のためのパラメータと考えられます。

  デフォルトでは、パラメータは `symbolp (x)`か `subvarp (x)`のような xです。

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

  例:

      (%i1) assume_pos: true$
      (%i2) assume_pos_pred: symbolp$
      (%i3) sign (a);
      (%o3)                          pos
      (%i4) sign (a[1]);
      (%o4)                          pnz
      (%i5) assume_pos_pred: lambda ([x], display (x), true)$
      (%i6) asksign (a);
                                    x = a

      (%o6)                          pos
      (%i7) asksign (a[1]);
                                   x = a
                                        1

      (%o7)                          pos
      (%i8) asksign (foo (a));
                                 x = foo(a)

      (%o8)                          pos
      (%i9) asksign (foo (a) + bar (b));
                                 x = foo(a)

                                 x = bar(b)

      (%o9)                          pos
      (%i10) asksign (log (a));
                                    x = a

      Is  a - 1  positive, negative, or zero?

      p;
      (%o10)                         pos
      (%i11) asksign (a - b);
                                    x = a

                                    x = b

                                    x = a

                                    x = b

      Is  b - a  positive, negative, or zero?

      p;
      (%o11)                         neg

  Categories: Declarations and inferences

オプション変数: context

  デフォルト値: `initial`

  `context`は `assume`と `forget`によって保守される事実の集まりの名前です。

  `assume`は `context`と名付けられた集まりに事実を追加する一方、 `forget`は事実を取り除きます。

  `context`を名前 fooにバインドすると 現在の文脈は fooに変わります。 もし指定された文脈 fooがまだ存在しないなら、 自動的に `newcontext`がコールされて生成されます。 指定された文脈は自動的にアクティベートされます。

  文脈メカニズムの一般的な記述に関しては `contexts`を参照してください。

  Categories: Declarations and inferences

オプション変数: contexts

  デフォルト値: `[initial, global]`

  `contexts`は現在存在する文脈のリストです。現在アクティブな文脈を含んでいます。

  文脈メカニズムによって ユーザーが文脈と呼ばれる事実の集まりにバインドし、名付けることが可能になります。 一旦名付けると、 ユーザーは文脈を単にアクティベートしたりデアクティベートすることで たくさんの数の事実をMaximaに仮定させたり忘れさせたりできます。

  任意のシンボルのアトムが文脈となることができ、 その文脈の中に含まれた事実は、 `forget`をコールすることで１つ１つ破壊されるまで、 あるいは、それらが属する文脈を破壊するために`kill`をコールすることで 全体として破壊されるまで、記憶装置に保持されます。

  文脈は階層的に存在します。 その根はいつも文脈 `global`であり、 文脈 `global`はいくつかの関数が必要とするMaximaについての情報を含みます。 アクティブな文脈の部分文脈である任意の文脈の中の事実すべてそうであるように、 与えられた文脈の中では その文脈の中の事実すべては「アクティブ」（それらが演繹や探索に使われるという意味）です。

  Maximaが新たに起動された時、 ユーザーは `initial`と呼ばれる文脈の中にいます。 それは部分文脈として `global`を持ちます。

  `facts`, `newcontext`, `supcontext`, `killcontext`, `activate`, `deactivate`, `assume`, `forget`も参照してください。

  Categories: Declarations and inferences

関数: deactivate (context_1, …, context_n)

  特定の文脈 context_1, …, context_nをデアクティベートします。

  Categories: Declarations and inferences

関数: facts
`facts` (item)
`facts` ()

  もし itemが文脈の名前なら `facts (item)`は指定された文脈の `facts`のリストを返します。

  もし itemが文脈の名前でないなら、 `facts (item)`は現在の文脈の中で itemについて知っている `facts`のリストを返します。 異なる文脈中のアクティブな `facts`はリストされません。

  `facts ()`（すなわち引数なし）は現在の文脈をリストします。

  Categories: Declarations and inferences

関数: forget
`forget` (pred_1, …, pred_n)
`forget` (L)

  `assume`で規定された述語論理を取り除きます。 述語論理は以前に規定されたものと同値の（必ずしも同一である必要はない）式です。

  `forget (L)` (Lは述語論理のリスト)はリスト上のそれぞれの項目を忘れます。

  Categories: Declarations and inferences

関数: is (expr)

  `assume`データベースの中の事実から述語論理 exprが確かか否かを決定しようとします。

  もし述語論理が確かに `true`か `false`なら、 `is`はそれぞれ `true`か `false`を返します。 そうでないなら戻り値はグローバルフラグ `prederror`に依存します。 `prederror`が `true`の時 `is`はエラーメッセージを出力します。 そうでないなら `is`は `unknown`を出力します。

  `ev(expr, pred)` (対話プロンプトでは `expr, pred`と書けます)は `is(expr)`と同値です。

  `assume`, `facts`, `maybe`も参照してください。

  例:

  `is`は述語論理の評価を引き起こします。

      (%i1) %pi > %e;
      (%o1)                       %pi > %e
      (%i2) is (%pi > %e);
      (%o2)                         true

  `is`は `assume`データベースから述語論理を演繹しようとします。

      (%i1) assume (a > b);
      (%o1)                        [a > b]
      (%i2) assume (b > c);
      (%o2)                        [b > c]
      (%i3) is (a < b);
      (%o3)                         false
      (%i4) is (a > c);
      (%o4)                         true
      (%i5) is (equal (a, c));
      (%o5)                         false

  もし `is`が `assume`データベースから述語論理を証明もしくは否定できなかったら グローバルフラグ `prederror`が `is`の振る舞いを決めます。

      (%i1) assume (a > b);
      (%o1)                        [a > b]
      (%i2) prederror: true$
      (%i3) is (a > 0);
      Maxima was unable to evaluate the predicate:
      a > 0
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i4) prederror: false$
      (%i5) is (a > 0);
      (%o5)                        unknown

  Categories: Predicate functions · Declarations and inferences

関数: killcontext (context_1, …, context_n)

  文脈 context_1, …, context_nを消します。

  もし文脈の１つが現在の文脈なら 新しい文脈は消されなかった現在の文脈の最初の利用可能な部分文脈になるでしょう。 もし最初の利用可能な消されなかった文脈が `global`なら、 `initial`が代わりに使われます。 もし `initial`文脈が消されたら 新しい空の`initial`文脈が生成されます。

  現在の文脈の部分文脈であるためか 関数 `activate`の使用による理由で現在アクティブになっている文脈を消すことを `killcontext`は拒否します。

  `killcontext`は引数を評価します。 `killcontext`は `done`を返します。

  Categories: Declarations and inferences

関数: maybe (expr)

  述語論理exprが `assume`データベースの事実から正しいかどうかを 決定しようとします。

  もし述語論理が確かに `true`か `false`なら、 `maybe`はそれぞれ `true`か `false`を返します。 そうでないなら `maybe`は `unknown`を返します。

  `maybe`は `prederror: false`での `is`と関数的に同値です。 しかし `prederror`に値を実際に割り当てることなく結果が計算されます。

  `assume`, `facts`, `is`も参照してください。

  例:

      (%i1) maybe (x > 0);
      (%o1)                        unknown
      (%i2) assume (x > 1);
      (%o2)                        [x > 1]
      (%i3) maybe (x > 0);
      (%o3)                         true

  Categories: Predicate functions · Declarations and inferences

関数: newcontext
`newcontext` (name)
`newcontext` ()

  nameと呼ばれる新しい空の文脈を生成します。 nameは唯一の部分文脈として `global`を持ちます。 新しく生成された文脈は現在アクティブな文脈になります。

  もし nameが指定されないなら、(`gensym`を使って)新しい名前を生成して返します。

  `newcontext`は引数を評価します。 `newcontext`は (もし指定されたら) nameを、そうでなければ新しい文脈名を返します。

  Categories: Declarations and inferences

関数: sign (expr)

  現在のデータベースの事実に基づいて exprの符号を決定しようとします。 以下の答えの１つを返します; `pos` (positive)か, `neg` (negative), `zero`, `pz` (正もしくはゼロ), `nz` (負もしくはゼロ), `pn` (正もしくは負), `pnz` (正、負もしくはゼロ、すなわちなにもわからない).

  Categories: Declarations and inferences

関数: supcontext
`supcontext` (name, context)
`supcontext` (name)
`supcontext` ()

  nameと呼ばれる新しい文脈を生成します。 nameは部分文脈として contextを持ちます。 contextは存在しなければいけません。

  もし contextが指定されないなら現在の文脈が仮定されます。

  もし nameが指定されないなら、(`gensym`を使って)新しい名前を生成して返します。

  `supcontext`は引数を評価します。 `supcontext`は (もし指定されたら) nameを、そうでなければ新しい文脈名を返します。

  Categories: Declarations and inferences

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

## 11.4 Functions and Variables for Predicates

関数: charfun (p)

  述語論理 pが `false`に評価される時 0を返します; 述語論理 pが `true`に評価される時 1を返します。 述語論理が `true`も `false`でもない何かに評価される時(unknown) 名詞形を返します。

  例:

      (%i1) charfun (x < 1);
      (%o1)                    charfun(x < 1)
      (%i2) subst (x = -1, %);
      (%o2)                           1
      (%i3) e : charfun ('"and" (-1 < x, x < 1))$
      (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
      (%o4)                       [0, 1, 0]

  Categories: Mathematical functions

関数: compare (x, y)

  `is (x op y)`が `true`に評価されるような比較演算子 op (`<`, `<=`, `>`, `>=`, `=`, `#`)を返します; xか yが `%i`に依存し、かつ `x # `y``の時、 `notcomparable`を返します; 該当する演算子がなかったり Maximaが演算子を決定できなかった時には `unknown`を返します。

  例:

      (%i1) compare (1, 2);
      (%o1)                           <
      (%i2) compare (1, x);
      (%o2)                        unknown
      (%i3) compare (%i, %i);
      (%o3)                           =
      (%i4) compare (%i, %i + 1);
      (%o4)                     notcomparable
      (%i5) compare (1/x, 0);
      (%o5)                           #
      (%i6) compare (x, abs(x));
      (%o6)                          <=

  関数 `compare`は引数の実領域が空でないか決定しようとはしません; 従って、

      (%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
      (%o1)                           <

  `acos (x^2 + 1)`の実領域は空です。

  Categories: Declarations and inferences

関数: equal (a, b)

  同値、すなわち同じ値であることを表します。

  `equal`はそれ自身で評価も整理もされません。 関数 `is`は `equal`をブーリアン値に評価しようとします。 もし aと bが `ratisimp(a - b)`を評価することで決定されるように変数の可能な値すべてで等しいときだけ `is(equal(a, b)`は `true`を返します; もし `ratsimp`が0を返したら２つの式は同値と考えられます。 ２つの式は構文法的に等しくなくても（すなわち同一でなくても）同値でありえます。

  `is`が`equal`を`true`か `false`への換算に失敗した時、 結果はグローバルフラグ `prederror`に依存します。 `prederror`が `true`の時 `is`はエラーメッセージを出力します。 そうでないなら `is`は `unknown`を返します。

  `is`に加えていくつかの他の演算子、すなわち `if`, `and`, `or`, `not`は `equal`と `notequal`を `true`か `false`に評価します。

  `equal`の否定は `notequal`です。

  例:

  `equal`はそれ自身で評価も整理もされません。

      (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
                              2
      (%o1)            equal(x  - 1, (x - 1) (x + 1))
      (%i2) equal (x, x + 1);
      (%o2)                    equal(x, x + 1)
      (%i3) equal (x, y);
      (%o3)                      equal(x, y)

  関数`is`は `equal`をブーリアン値に評価しようとします。 `is(equal(a, b)`は `ratisimp(a - b)`が0を返すとき `true`を返します。 ２つの式は構文法的に等しくなくても（すなわち同一でなくても）同値でありえます。

      (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
      (%o1)                           0
      (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
      (%o2)                         true
      (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
      (%o3)                         false
      (%i4) ratsimp (x - (x + 1));
      (%o4)                          - 1
      (%i5) is (equal (x, x + 1));
      (%o5)                         false
      (%i6) is (x = x + 1);
      (%o6)                         false
      (%i7) ratsimp (x - y);
      (%o7)                         x - y
      (%i8) is (equal (x, y));
      (%o8)                        unknown
      (%i9) is (x = y);
      (%o9)                         false

  `is`が `equal`を `true`か `false`への換算に失敗したとき、 結果はグローバルフラグ `prederror`に依存します。

      (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
                          2             2
      (%o1)             [x  + 2 x + 1, x  - 2 x - 1]
      (%i2) ratsimp (aa - bb);
      (%o2)                        4 x + 2
      (%i3) prederror : true;
      (%o3)                         true
      (%i4) is (equal (aa, bb));
      Maxima was unable to evaluate the predicate:
             2             2
      equal(x  + 2 x + 1, x  - 2 x - 1)
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i5) prederror : false;
      (%o5)                         false
      (%i6) is (equal (aa, bb));
      (%o6)                        unknown

  いくつかの演算子が `equal`や `notequal`を `true`か `false`に評価します。

      (%i1) if equal (y, y - 1) then FOO else BAR;
      (%o1)                          BAR
      (%i2) eq_1 : equal (x, x + 1);
      (%o2)                    equal(x, x + 1)
      (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
                               2                   2
      (%o3)             equal(y  + 2 y + 1, (y + 1) )
      (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
      (%o4)                  [false, true, true]

  `not expr`は exprの評価を伴うので、 `not equal(a, b)`は `is(notequal(a, b))`と同値です。

      (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
      (%o1)            [notequal(2 z, 2 z - 1), true]
      (%i2) is (notequal (2*z, 2*z - 1));
      (%o2)                         true

  Categories: Operators

関数: notequal (a, b)

  `equal(a, b)`の否定を表します。

  例:

      (%i1) equal (a, b);
      (%o1)                      equal(a, b)
      (%i2) maybe (equal (a, b));
      (%o2)                        unknown
      (%i3) notequal (a, b);
      (%o3)                    notequal(a, b)
      (%i4) not equal (a, b);
      (%o4)                    notequal(a, b)
      (%i5) maybe (notequal (a, b));
      (%o5)                        unknown
      (%i6) assume (a > b);
      (%o6)                        [a > b]
      (%i7) equal (a, b);
      (%o7)                      equal(a, b)
      (%i8) maybe (equal (a, b));
      (%o8)                         false
      (%i9) notequal (a, b);
      (%o9)                    notequal(a, b)
      (%i10) maybe (notequal (a, b));
      (%o10)                        true

  Categories: Operators

関数: unknown (expr)]

  exprがMaximaの整理器が認識しない演算子や関数を含む時だけ `true`を返します。

  Categories: Predicate functions · Simplification functions

関数: zeroequiv (expr, v)

  変数 vの式 exprがゼロと同値かどうかテストし、 `true`か, `false`, `dontknow`を返します。

  `zeroequiv`は以下の制限を持ちます:

  1. Maximaが微分や評価する方法を知らない関数を使わない。
  2. もし式が実線上で極を持つなら結果としてエラーになります。 （しかしこれは起こりにくいことです。）
  3. もし式が１階微分方程式の解ではない関数（例えばベッセル関数）を含むなら 正しくない結果になるかもしれません。
  4. アルゴリズムは注意深く選ばれた部分式に関してランダムに選ばれた点での評価を使います。 アルゴリズムはエラーの可能性を細小にしようとしますが、これはいつも危険な仕事です。

  例えば、`zeroequiv (sin(2 * x) - 2 * sin(x) * cos(x), x)`は `true`を返し、 `zeroequiv (%e^x + x, x)`は `false`を返します。 一方、 `zeroequiv (log(a * b) - log(a) - log(b), a)`は 余分なパラメータ`b`があるので `dontknow`を返します。

  Categories: Predicate functions

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

This document was generated by 市川雄二 on October, 4 2018 using texi2html 1.76.