関する関数:       Rows, Cols, degree, length, size,

*** 行列生成関数:             I, Z, ONE, linspace, logspace, rand, randn
                              diag, diag2vec, vec2diag,
                              reshape, fliplr, flipud,

*** 実部，虚部，分子，分母:   Re, Im, Nu, De

*** 三角関数                  acos, acosh, asin, asinh, atan, atanh, atan2,
                              cos, cosh, sin, sinh, tan, tanh,

*** 指数，対数，平方根関数    exp, log, log10, sqrt,

*** ビット操作関数            bit_and, bit_or, bit_comp, bit_xor,
                              bit_lshift, bit_rshift

*** 行列の大きさを            max, maximum, min, minimum, mean, sum, prod
    調べる関数:               std, cumsum, cumprod, cumsum_vec, cumprod_vec
                              det, trace, rank, flobnorm, infnorm, norm,

*** 行列の大きさを            max, max_col, max_row, maximum,
    調べる関数                min, min_col, min_row, minimum,
                              mean, mean_col, mean_row,
                              sum, sum_col, sum_row,
                              prod, prod_col, prod_row,
                              std, std_col, std_row,
                              cumsum, cumsum_col, cumsum_row
                              cumprod, cumprod_col, cumprod_row
                              det, trace, rank, flobnorm, infnorm, norm,

*** 複素値に関する関数:       abs, arg, conj, isreal, iscomplex

*** 多項式，有理多項式        derivative, higher, lower, integral,
    関数                      poles, roots, zeros, 

*** 固有値関数:               eig, eigen, eigval, eigvec,

*** 特異値関数:               svd, sing, singleftvec, singrightvec, 
                              singval, maxsing, minsing, 

*** 行列分解関数:             hess, lu, qr, qr_nop, qz, schur, svd

*** 文字列関数:               printf, sprintf
                              scanf, sscanf, strchr

*** ファイル関数:             fopen, feof, fprintf, fscanf, fread, fwrite

*** シミュレーション関数:     rkf45, rngkut4, 
                              Ode, OdeAuto, Ode45, Ode45Auto,
                              OdeHybrid, OdeHybridAuto,
                              Ode45Hybrid, Ode45HybridAuto,
                              OdeStop, OdeXY

*** その他の関数:             ceil, floor, fix, round, round2z
                              kernel, pseudoinv, vectorprod, rem, fact, sgn
                              all, all_col, all_col, any, any_col, any_row,
                              eval, find, sort, makelist, appendlist,
                              system, error, warning, isnan, isinf, isfinite


/* Cols */
          Integer Cols(Matrix M1): 行列の列数
          Integer Cols(Array A1):  配列の列数
/* Cols */

/* De */
          Polynomial De(Rational R1): 有理多項式の分母
          Array      De(Array A1):    有理多項式配列の分母配列
/* De */

/* I */
          Matrix I(Integer i1):             (正方)単位行列
          Matrix I(Integer i1, Integer i2): (非正方)単位行列
          Matrix I(Matrix M1):              行列M1と同じサイズの単位行列
          Array  I(Array A1):               配列M1と同じサイズの単位配列
/* I */

/* Im */
          Real       Im(Complex c1):      複素数の虚部
          Array      Im(CoArray A1):      複素配列の虚部配列
          Matrix     Im(CoMatrix M1):     複素行列の虚部行列
          Polynomial Im(CoPolynomial P1): 複素多項式の虚部多項式
          Rational   Im(CoRational R1):   複素有理多項式の虚部有理多項式
/* Im */

/* Nu */
          Polynomial Nu(Rational R1): 有理多項式の分子
          Array      Nu(Array A1):    有理多項式配列の分子配列
/* Nu */

/* Ode */
          {T, X, U} = Ode(t0, t1, x0, diff_eqs, ..., link_eqs, h, dtsav)
          Array  T, X, U;
          Real   t0, t1, h(= 4.0E-2), dtsav(= 1.0E-3);
          Matrix x0;
          Matrix diff_eqs(), link_eqs();

          4次のルンゲ－クッタの公式にしたがって，指定された
          きざみ幅hで，常微分方程式の[t0,t1]時刻の解を求める。
          {T, X, U} = Ode();
          T: 時間の系列
          X: 状態ベクトルの時系列
          U: 入出力ベクトルの時系列
/* Ode */

/* OdeAuto */
          {T, X, U} = OdeAuto(t0, t1, x0, diff_eqs, ..., 
                                        link_eqs, eps, dtsav, dtmin, dtmax)
          Array  T, X, U;
          Real   t0, t1, eps(= 1.0E-6), dtsav(= 1.0E-3);
          Real   dtmin(= EPS), dtmax(= abs(t1-t0)/5), dtmax = max(dtmax,dtsav);
          Matrix x0;
          Matrix diff_eqs(), link_eqs();

          きざみを自動調節しながら4次のルンゲ－クッタの公式にしたがって
          指定された誤差内で常微分方程式の[t0,t1]時刻の解を求める。
          ただし，きざみの最小値と最大値はdtminとdtmaxであり，
          dtmax < dtsav のとき，dtmax = dtsavに設定される。
          {T, X, U} = OdeAuto();
          T: 時間の系列
          X: 状態ベクトルの時系列
          U: 入出力ベクトルの時系列
/* OdeAuto */

/* Ode45 */
          {T, X, U} = Ode45(t0, t1, x0, diff_eqs, ..., link_eqs, h, dtsav);
          Array  T, X, U;
          Real   t0, t1, h(= 4.0E-2), dtsav(= 1.0E-3);
          Matrix x0;
          Matrix diff_eqs(), link_eqs();

          RKF45の公式にしたがって，指定されたきざみ幅 h で，
          常微分方程式の[t0,t1]時刻の解を求める。
          {T, X, U} = Ode45();
          T: 時間の系列
          X: 状態ベクトルの時系列
          U: 入出力ベクトルの時系列
/* Ode45 */

/* Ode45Auto */
          {T, X, U} = Ode45Auto(t0, t1, x0, diff_eqs, ..., 
                                   link_eqs, eps, dtsav, dtmin, dtmax);
          Array  T, X, U;
          Real   t0, t1, eps(= 1.0E-6), dtsav(= 1.0E-3);
          Real   dtmin(= EPS), dtmax(= abs(t1-t0)/5), dtmax = max(dtmax,dtsav);
          Matrix x0;
          Matrix diff_eqs(), link_eqs();

          きざみを自動調節しながらRKF45の公式にしたがって
          指定された誤差内で常微分方程式の[t0,t1]時刻の解を求める。
          ただし，きざみの最小値と最大値はdtminとdtmaxであり，
          dtmax < dtsav のとき，dtmax = dtsavに設定される。
          {T, X, U} = Ode45Auto();
          T: 時間の系列
          X: 状態ベクトルの時系列
          U: 入出力ベクトルの時系列
/* Ode45Auto */

/* OdeHybrid */
          {T, X, U} = OdeHybrid(t0, t1, dt, x0, diff_eqs, ..., 
                                                link_eqs, h, dtsav);
          Array  T, X, U;
          Real   t0, t1, dt, h(= 4.0E-2), dtsav(= max(h, 1.0E-3));
          Matrix x0;
          Matrix diff_eqs(), link_eqs();

          4次のルンゲ－クッタの公式にしたがって，指定されたきざみ幅hで，
          常微分方程式の[t0,t1]時刻の解を求める。ただし，サンプリング
          間で外部入力は一定値をとる。
          また，きざみ幅hが省略されて，dt < 4.0E-2のとき，h = dtである．
          {T, X, U} = OdeHybrid();
          T: 時間の系列
          X: 状態ベクトルの時系列
          U: 入出力ベクトルの時系列
/* OdeHybrid */

/* OdeHybridAuto */
         {T, X, U} = OdeHybridAuto(t0, t1, dt, x0, diff_eqs, ...,
                                          link_eqs, eps, dtsav, dtmin, dtmax);
          Array  T, X, U;
          Real   t0, t1, dt, eps(= 1.0E-6), dtsav(= 1.0E-3);
          Real   dtmin(= EPS), dtmax(= abs(t1-t0)/5), dtmax = max(dtmax,dtsav);
          Matrix x0;
          Matrix diff_eqs(), link_eqs();

          きざみを自動調節しながら4次のルンゲ－クッタの公式にしたがって
          指定された誤差内で常微分方程式の[t0,t1]時刻の解を求める。
          サンプリング間で外部入力は一定値をとる。
          ただし，きざみの最小値と最大値はdtminとdtmaxであり，
          dtmax < dtsav のとき，dtmax = dtsavに設定される。
          {T, X, U} = OdeHybridAuto();
          T: 時間の系列
          X: 状態ベクトルの時系列
          U: 入出力ベクトルの時系列
/* OdeHybridAuto */

/* Ode45Hybrid */
          {T, X, U} = Ode45Hybrid(t0, t1, dt, x0, diff_eqs, ..., 
                                                  link_eqs, h, dtsav);
          Array  T, X, U;
          Real   t0, t1, dt, h(= 4.0E-2), dtsav(= max(h, 1.0E-3));
          Matrix x0;
          Matrix diff_eqs(), link_eqs();

          RKF45の公式にしたがって，指定されたきざみ幅hで，
          常微分方程式の[t0,t1]時刻の解を求める。ただし，
          サンプリング間で外部入力は一定値をとる。
          また，きざみ幅hが省略されて，dt < 4.0E-2のとき，
          h = dtである．
          {T, X, U} = Ode45Hybrid();
          T: 時間の系列
          X: 状態ベクトルの時系列
          U: 入出力ベクトルの時系列
/* Ode45Hybrid */

/* Ode45HybridAuto */
          {T, X, U} = Ode45HybridAuto(t0, t1, dt, x0, diff_eqs, ...,
                                         link_eqs, eps, dtsav, dtmin, dtmax);
          Array  T, X, U;
          Real   t0, t1, dt, eps(= 1.0E-6), dtsav(= 1.0E-3);
          Real   dtmin(= EPS), dtmax(= abs(t1-t0)/5), dtmax = max(dtmax,dtsav);
          Matrix x0;
          Matrix diff_eqs(), link_eqs();

          きざみを自動調節しながらRKF45の公式にしたがって
          指定された誤差内で常微分方程式の[t0,t1]時刻の解を求める。
          サンプリング間で外部入力は一定値をとる。
          ただし，きざみの最小値と最大値はdtminとdtmaxであり，
          dtmax < dtsav のとき，dtmax = dtsavに設定される。
          {T, X, U} = Ode45HybridAuto();
          T: 時間の系列
          X: 状態ベクトルの時系列
          U: 入出力ベクトルの時系列
/* Ode45HybridAuto */

/* OdeStop *
          OdeStop();

          Ode(), OdeAuto(), OdeHybrid() の実行を強制的に停止する。
          各関数は，その時刻までの結果を返す。
/* OdeStop *

/* OdeXY */
          {X_t, Y_t} = OdeXY(t);
          Array X_t, Y_t;
          Real t;

          時刻 t の状態 X_t と入出力 Y_t を返す。これらのベクトルは
          実際に計算されたデータの中で時刻 t を含む最小の区間のデータ
          を用い線形補間して得られるものである。
/* OdeXY */

/* ONE */
          Matrix ONE(Integer i1):             1で満たされた(正方)行列
          Matrix ONE(Integer i1, Integer i2): 1で満たされた(非正方)行列
          Matrix ONE(Matrix M1):              M1と同じサイズの行列
          Array  ONE(Array A1):               A1と同じサイズの配列
/* ONE */

/* Re */
          Real       Re(Complex c1):      複素数の実部
          Array      Re(CoArray A1):      複素配列の実部配列
          Matrix     Re(CoMatrix M1):     複素行列の実部行列
          Polynomial Re(CoPolynomial P1): 複素多項式の実部
          Rational   Re(CoRational R1):   複素有理多項式の実部
/* Re */

/* Rows */
          Integert Rows(Matrix M1): 行列の行数
          Integert Rows(Array A1):  配列の行数
/* Rows */

/* Z */
          Matrix Z(Integer i1):             (正方)零行列
          Matrix Z(Integer i1, Integer i2): (非正方)零行列
          Matrix Z(Matrix M1):              M1と同じサイズの零行列
          Array  Z(Array A1):               A1と同じサイズの零配列
/* Z */

/* abs */
          Integer abs(Integer i1):  整数の絶対値
          Real    abs(Real r1):     実数の絶対値
          Real    abs(Complex c1):  複素数の絶対値
          Array   abs(Array A1):    各成分の絶対値
          Matrix  abs(Matrix M1):   各成分の絶対値
          Matrix  abs(String str):  ASCIIコードからなる行列
/* abs */

/* acos */
          Real    acos(Real r1):    実数の逆余弦関数
          Complex acos(Complex c1): 複素数の逆余弦関数
          Array   acos(Array A1):   各成分の逆余弦関数
/* acos */

/* acosh */
          Real    acosh(Real r1):    実数の逆双曲線余弦関数
          Complex acosh(Complex c1): 複素数の逆双曲線余弦関数
          Array   acosh(Array A1):   各成分の逆双曲線余弦関数
/* acosh */

/* all */
          Integer all(Array A1):  全ての成分が非ゼロなら１
          Integer all(Matrix M1): 全ての成分が非ゼロなら１
/* all */

/* all_col */
          Array all_col(Array A1):  列毎に全ての成分が非ゼロなら１
          Array all_col(Matrix M1): 列毎に全ての成分が非ゼロなら１
/* all_col */

/* all_row */
          Array all_row(Array A1):  行毎に全ての成分が非ゼロなら１
          Array all_row(Matrix M1): 行毎に全ての成分が非ゼロなら１
/* all_row */

/* any */
          Integer any(Array A1):  非ゼロの成分が存在すれば１
          Integer any(Matrix M1): 非ゼロの成分が存在すれば１
/* any */

/* any_col */
          Array any_col(Array A1):  列毎に非ゼロの成分が存在すれば１
          Array any_col(Matrix M1): 列毎に非ゼロの成分が存在すれば１
/* any_col */

/* any_row */
          Array any_row(Array A1):  行毎に非ゼロの成分が存在すれば１
          Array any_row(Matrix M1): 行毎に非ゼロの成分が存在すれば１
/* any_row */

/* appendlist */
          List appendlist(List L1, Arg1): データをリストに追加
/* appendlist */

/* arg */
          Real  arg(Complex c1): 複素数の偏角
          Array arg(Array A1):   各成分の偏角
/* arg */

/* asin */
          Real    asin(Real r1):    実数の逆正弦関数
          Complex asin(Complex c1): 複素数の逆正弦関数
          Array   asin(Array A1):   各成分の逆正弦関数
/* asin */

/* asinh */
          Real    asinh(Real r1):    実数の逆双曲線正弦関数
          Complex asinh(Complex c1): 複素数の逆双曲線正弦関数
          Array   asinh(Array A1):   各成分の逆双曲線正弦関数
/* asinh */

/* atan */
          Real    atan(Real r1):    実数の逆正接関数
          Complex atan(Complex c1): 複素数の逆正接関数
          Array   atan(Array A1):   各成分の逆正接関数
/* atan */

/* atanh */
          Real    atanh(Real r1):    実数の逆双曲線正接関数
          Complex atanh(Complex c1): 複素数の逆双曲線正接関数
          Array   atanh(Array A1):   各成分の逆双曲線正接関数
/* atanh */

/* atan2 */
          Real atan2(Real r1, Real r2):    実数の逆正接関数(2)
          Array atan2(Array A1, Array A2): 各成分の逆正接関数(2)
/* atan2 */

/* bit_and */
          Integer bit_and(Integer i1, Integer i2): ビット毎の AND
/* bit_and */

/* bit_comp */
          Integer bit_xor(Integer i1): ビット毎の補数
/* bit_comp */

/* bit_or */
          Integer bit_or(Integer i1, Integer i2): ビット毎の OR
/* bit_or */

/* bit_lshift */
          Integer bit_lshift(Integer i1, Integer i2): i2ビット左シフト
/* bit_lshift */

/* bit_rshift */
          Integer bit_rshift(Integer i1, Integer i2): i2ビット右シフト
/* bit_rshift */

/* bit_xor */
          Integer bit_xor(Integer i1, Integer i2): ビット毎の排他的 OR
/* bit_xor */

/* ceil */
          Real  ceil(Real r1):      実数の最高値への丸め
          Complex ceil(Complex c1): 実部と虚部の最高値への丸め
          Polynomail ceil(Polynomial P1): 係数の最高値への丸め
          Rational ceil(Rational P1): 係数の最高値への丸め
          Array ceil(Array A1):     各成分の最高値への丸め
          Matrix ceil(Matrix M1):   各成分の最高値への丸め
          Index ceil(Index I1):     各成分の最高値への丸め
/* ceil */

/* clock */
          Matrix clock(): 現在の日付と時間
/* clock */

/* conj */
          Complex      conj(Complex c1):      共役複素数
          CoPolynomial conj(CoPolynomial P1): 共役複数多項式
          CoRational   conj(CoRational R1):   共役複素有理多項式
          CoArray      conj(CoArray A1):      各成分の共役複素数
          CoMatrix     conj(CoMatrix M1):     共役複素行列
/* conj */

/* cos */
          Real    cos(Real r1):    実数の余弦関数
          Complex cos(Complex c1): 複素数の余弦関数
          Array   cos(Array A1):   各成分の余弦関数
/* cos */

/* cosh */
          Real    cosh(Real r1):    実数の双曲線余弦関数
          Complex cosh(Complex c1): 複素数の双曲線余弦関数
          Array   cosh(Array A1):   各成分の双曲線余弦関数
/* cosh */

/* cumsum */
          Matrix cumsum(Matrix M1): 全ての成分の累積和
          Array cumsum(Array A1):   全ての成分の累積和
          Index cumsum(Index X1):   全ての成分の累積和
/* cumsum */

/* cumsum_col */
          Matrix cumsum_col(Matrix M1): 列毎の累積和からなるベクトル
          Array cumsum_col(Array A1):   列毎の累積和からなるベクトル
          Index cumsum_col(Index X1):   列毎の累積和からなるベクトル
/* cumsum_col */

/* cumsum_row */
          Matrix cumsum_row(Matrix M1): 行毎の累積和からなるベクトル
          Array cumsum_row(Array A1):   行毎の累積和からなるベクトル
          Index cumsum_row(Index X1):   行毎の累積和からなるベクトル
/* cumsum_row */

/* cumprod */
          Matrix cumprod(Matrix M1): 全ての成分の累積積
          Array cumprod(Array A1):   全ての成分の累積積
          Index cumprod(Index X1):   全ての成分の累積積
/* cumprod */

/* cumprod_col */
          Matrix cumprod_col(Matrix M1): 列毎の累積積からなるベクトル
          Array cumprod_col(Array A1):   列毎の累積積からなるベクトル
          Index cumprod_col(Index X1):   列毎の累積積からなるベクトル
/* cumprod_col */

/* cumprod_row */
          Matrix cumprod_row(Matrix M1): 行毎の累積積からなるベクトル
          Array cumprod_row(Array A1):   行毎の累積積からなるベクトル
          Index cumprod_row(Index X1):   行毎の累積積からなるベクトル
/* cumprod_row */

/* degree */
          Integer degree(Polynomial P1): 多項式の次数
/* degree */

/* derivative */
          Polynomial derivative(Polynomial P1): 多項式の導関数
          Rational   derivative(Rational R1):   有理多項式の導関数
          Array      derivative(Array A1):      各成分のの導関数
          Matrix     derivative(Matrix M1):     各成分の導関数
/* derivative */

/* det */
          Real       det(Matrix M1):   実行列の行列式
          Complex    det(CoMatrix M1): 複素行列の行列式
          Polynomial det(PoMatrix M1): 多項式行列の行列式
          Rational   det(RaMatrix M1): 有理多項式行列の行列式
/* det */

/* diag */
          Matrix diag(Real r1, Real r2, ..., Real rn):               対角行列
          CoMatrix diag(Complex c1, ..., Complex cn):            複素対角行列
          PoMatrix diag(Polynomial P1, ..., Polynomial Pn):    対角多項式行列
          RaMatrix diag(Rational R1, ..., Rational Rn):    対角有理多項式行列
          Matrix diag(Matrix M1, Matrix M2, ..., Matrix Mn): ブロック対角行列
/* diag */

/* diag2vec */
          Matrix diag2vec(Matrix M1): 対角成分からなるベクトル
/* diag2vec */

/* eig */
          List eig(Matrix M1):            固有値と固有ベクトル
                                          {val, vec} = eig(A);
                                          Matrix val: 固有値
                                          Matrix vec: 固有ベクトル
                                          A * vec = vec * val

          List eig(Matrix M1, Matrix M2): 一般化固有値，一般化固有ベクトル
                                          {val, vec} = eig(A, B);
                                          Matrix val: 一般化固有値
                                          Matrix vec: 一般化固有ベクトル
                                          A * vec = B * vec * val


          List eig(Matrix M1, "S"):       対称行列の固有値と固有ベクトル

                                          第2引数は定数文字列
                                          's' または 'S'

                                          {val, vec} = eig(A, "S");
                                          Matrix val: 固有値
                                          Matrix vec: 固有ベクトル
                                          A * vec = vec * val

          List eig(Matrix M1, "H"):       エルミート行列の固有値と
                                          固有ベクトル
                                          {val, vec} = eig(A, "H");
                                          Matrix val: 固有値
                                          Matrix vec: 固有ベクトル
                                          A * vec = vec * val

                                          第2引数は定数文字列
                                          'h' または 'H'

/* eig */

/* eigval */
     Matrix eigval(Matrix M1):            固有値
     Matrix eigval(Matrix M1, Matrix M2): 一般化固有値

     Matrix eigval(Matrix M1, "S"):       対称行列の固有値

                                          第2引数は定数文字列
                                          's' または 'S'

     Matrix eigval(Matrix M1, "H"):       エルミート行列の固有値

                                          第2引数は定数文字列
                                          'h' または 'H'
/* eigval */

/* eigvec */
      Matrix eigvec(Matrix M1):            固有ベクトル
      Matrix eigvec(Matrix M1, Matrix M2): 一般化固有ベクトル

      Matrix eigvec(Matrix M1, "S"):       対称行列の固有ベクトル

                                           第2引数は定数文字列
                                           's' または 'S'

      Matrix eigvec(Matrix M1, "H"):       エルミート行列の固有ベクトル

                                           第2引数は定数文字列
                                           'h' または 'H'
/* eigvec */

/* error */
          void error(String s1): エラー関数
/* error */

/* eval */
         多項式，有理多項式，多項式行列，有理多項式行列の評価

          Real       eval((Polynomial| Rational| Matrix| Array),
                          (Real| Complex| Polynomial| Rational| Matrix)):
          Complex    eval((Polynomial| Rational| Matrix| Array),
                          (Real| Complex| Polynomial| Rational| Matrix)):
          Polynomial eval((Polynomial| Rational| Matrix| Array),
                          (Real| Complex| Polynomial| Rational| Matrix)):
          Rational   eval((Polynomial| Rational| Matrix| Array),
                          (Real| Complex| Polynomial| Rational| Matrix)):
          Array      eval((Polynomial| Rational| Matrix| Array),
                          (Real| Complex| Polynomial| Rational| Matrix)):
          Matrix     eval((Polynomial| Rational| Matrix| Array),
                          (Real| Complex| Polynomial| Rational| Matrix)):
/* eval */

/* exp */
          Real    exp(Real r1):    実数の指数関数
          Complex exp(Complex c1): 複素数の指数関数
          Array   exp(Array A1):   各成分の指数関数
          Matrix  exp(Matrix M1):  行列のの指数関数
/* exp */

/* fact */
          Integer fact(Integer i1): 整数の階乗
          Real fact(Real r1):       実数の階乗
          Array fact(Array A1):     各成分の階乗
/* fact */

/* fclose */
          Integer fclose(Integer fp): ファイルをクローズ
/* fclose */

/* feof */
         Integer feof(Integer fd): ファイルの終端を調べる
                                   1: 終端に達している
                                   0: 終端に達していない
/* feof */

/* fft */
          Array fft(Array A1, ..., Integer N):
          Matrix fft(Matrix M1, ..., Integer N):

          高速フーリエ変換
          (N は 2^n でなければならない)
/* fft */

/* fft_col */
          Array fft_col(Array A1, ..., Integer N):
          Matrix fft_col(Matrix M1, ..., Integer N):

          高速フーリエ変換(列毎)
          (N は 2^n でなければならない)
/* fft_col */

/* fft_row */
          Array fft_row(Array A1, ..., Integer N):
          Matrix fft_row(Matrix M1, ..., Integer N):

          高速フーリエ変換(行毎)
          (N は 2^n でなければならない)
/* fft_row */

/* fgets */
          String fgets(Integer fd): ファイルから文字列を読み込む
                                    デフォルトの文字列長は 1023
          String fgets(Integer fd, Integer len): ファイルから文字列を読み込む
                                                 len := 文字列長
/* fgets */

/* fix */
          Real fix(Real r1):        0 への丸め
          Complex fix(Complex c1):  実部と虚部の 0 への丸め
          Polynomial fix(Polynomial P1):  係数の 0 への丸め
          Rational fix(Rational R1):  係数の 0 への丸め
          Array fix(Array A1):      各成分の0への丸め
          Matrix fix(Matrix M1):    各成分の0への丸め
          Index fix(Index I1):      各成分の0への丸め
/* fix */


/* find */
          Index find(Array A1):  非ゼロ成分の指数
          Index find(Matrix M1): 非ゼロ成分の指数
/* find */

/* fliplr */
          Matrix fliplr(Matrix M1): 列を逆順に並べる
          Array  fliplr(Array A1):  列を逆順に並べる
/* fliplr */

/* flipud */
          Matrix flipud(Matrix M1): 行を逆順に並べる
          Array  flipud(Array A1):  行を逆順に並べる
/* flipud */

/* floor */
          Real  floor(Real r1):      最低値への丸め
          Complex floor(Complex c1): 実部と虚部の最低値への丸め
          Polynomial floor(Polynomial P1): 係数の最低値への丸め
          Rational floor(Rational R1): 係数の最低値への丸め
          Array floor(Array A1):     各成分の最低値への丸め
          Matrix floor(Matrix M1):   各成分の最低値への丸め
          Index floor(Index I1):     各成分の最低値への丸め
/* floor */

/* fopen */
          Integer fopen(String name, String rw): ファイルをオープンし，
             rw = "r" 読み込み               ファイルハンドラを返す
             rw = "w" 書き込み
/* fopen */

/* fprintf */
          void fprintf(String s1, String s2, Arg1, Arg2, ..., Argn):
          フォーマット変換しファイルに出力する
/* fprintf */

/* fread */
          Matrix fread(Integer fd, Integer num, String type)
          Matrix fread(Integer fd, Integer num, String type, Integer flip)

          ファイルからバイナリデータを行列として読み込む
/* fread */

/* frobnorm */
          Real frobnorm(Matrix M1): フロベニウスノルム
                                    (ユークリッドノルム)
/* frobnorm */

/* frobnorm_col */
          フロベニウスノルム(列毎)

          Matrix frobnorm_col(Matrix M1):
/* frobnorm_col */

/* frobnorm_row */
          フロベニウスノルム(行毎)

          Matrix frobnorm_row(Matrix M1):
/* frobnorm_row */

/* fscanf */
          List fscanf(Integer fd, String format):
          フォーマット変換しファイルから読み込む
/* fscanf */

/* fwrite */
          void fwrite(Integer fd, Matrix M, String type)

          行列の成分を指定して型のバイナリとしてファイルに保存
/* fwrite */

/* getch */
          Integer getch(): 標準入力から１文字読み込む
/* getch */

/* getenv */
         String getenv(String name)

         環境変数を調べる
         例: disp = getenv("DISPLAY");
/* getenv */

/* gets */
          String gets():            標準入力から文字列を読み込む
                                    デフォルトの文字列長は 1023
          String gets(Integer len): 標準入力から文字列を読み込む
                                    len := 文字列長
/* gets */

/* gettimer */
         Real gettimer(): settimer()が呼ばれてからの時間
/* gettimer */

/* gotoxy */
         void gotoxy(Integer x, Integer y) カーソルを (x,y) へ移動
/* gotoxy */

/* hess */
          List hess(Matrix M1)
          {Q, H} = hess(A)
          Q# * A * Q = H
          Matrix Q: 直交(ユニタリ)行列
          Matrix H: ヘッセンベルグ行列

          ヘッセンベルグ分解
/* hess */

/* higher */
          高次へ係数をシフトする

          Polynomial higher(Polynomial P1)
          Rational   higher(Rational R1)
          Array      higher(Array A1)
          Matrix     higher(Matrix M1)
/* higher */

/* ifft */
          Array ifft(Array A1, ..., Integer N);
          Matrix ifft(Matrix A1, ..., Integer N);

          逆高速フーリエ変換
          (N は 2^n でなければならない)
/* ifft */

/* ifft_col */
          Array ifft_col(Array A1, ..., Integer N);
          Matrix ifft_col(Matrix A1, ..., Integer N);

          逆高速フーリエ変換(列毎)
          (N は 2^n でなければならない)
/* ifft_col */

/* ifft_row */
          Array ifft_row(Array A1, ..., Integer N);
          Matrix ifft_row(Matrix A1, ..., Integer N);

          逆高速フーリエ変換(行毎)
          (N は 2^n でなければならない)
/* ifft_row */

/* integral */
          Polynomial integral(Polynomial P1):
          Rational   integral(Rational R1):
          Array      integral(Array A1):
          Matrix     integral(Matrix M1):

          不定積分
/* integral */

/* infnorm */
          Real infnorm(Matrix M1): 無限大ノルム
/* infnorm */

/* inv */
          Matrix inv(Matrix A, Real tol): 逆行列
/* inv */

/* isfinite */
          Integer isfinite(Real r1)
          Integer isfinite(Complex c1)
          Array isfinite(Matrix A)

          NaN でなくかつ無限大でないか？ (1:真, 0:偽)
/* isfinite */

/* isinf */
          Integer isinf(Real r1)
          Integer isinf(Complex c1)
          Array isinf(Matrix A)

          無限大の判定 (1:真, 0:偽)
/* isinf */

/* isnan */
          Integer isnan(Real r1)
          Integer isnan(Complex c1)
          Array isnan(Matrix A)

          NaNの判定 (1:真, 0:偽)
/* isnan */

/* isreal */
          Integer isreal(Polynomial P1): 実多項式なら１
          Integer isreal(Rational R1): 実有理多項式なら１
          Integer isreal(Matrix M1): 実行列なら１
          Integer isreal(Array A1): 実配列なら１
/* isreal */

/* iscomplex */
          Integer iscomplex(Polynomial P1): 複素多項式なら１
          Integer iscomplex(Rational R1): 複素有理多項式なら１
          Integer iscomplex(Matrix M1): 複素行列なら１
          Integer iscomplex(Array A1): 複素配列なら１
/* iscomplex */

/* kernel */
          Matrix kernel(Matrix M1):           カーネル(ヌル空間)
          Matrix kernel(Matrix M1, Real tol): カーネル(ヌル空間)
          デフォルト: tol = frobnorm(M1)*EPS                    
/* kernel */

/* length */
          Integer length(Matrix M1):  ベクトルの長さ
          Integer length(List L1):    リストの成分の数
          Integer length(String str): 文字列の長さ
/* length */

/* linspace */
          Array linspace(Real r1, Real r2):             線形空間ベクトル
          Array linspace(Real r1, Real r2, Integer i1): 線形空間ベクトル
          Default: (i1 = 100)
/* linspace */

/* log */
          Real    log(Real r1):    実数の自然対数
          Complex log(Complex c1): 複素数の自然対数
          Array   log(Array A1):   各成分の自然対数
/* log */

/* log10 */
          Real    log10(Real r1):    実数の常用対数
          Complex log10(Complex c1): 複素数の常用対数
          Array   log10(Array A1):   各成分の常用対数
/* log10 */

/* logspace */
          Array logspace(Real r1, Real r2):             対数空間ベクトル
          Array logspace(Real r1, Real r2, Integer i1): 対数空間ベクトル
          デフォルト: (i3 = 50);
/* logspace */

/* lower */
          Polynomial lower(Polynomial P1): 
          Rational   lower(Rational R1):
          Array      lower(Array A1):
          Matrix     lower(Matrix M1):

          係数を低次へシフトする
/* lower */

/* lu */
          List lu(Matrix M1):    LU分解
                                 {L, U} = lu(A):
                                 L * U = A:
                                 Matrix L: 下三角行列
                                 Matrix U: 上三角行列
/* lu */

/* lu_p */
          List lu_p(Matrix M1):  並べ替え付 LU分解
                                 {L, U, P} = lu_p(A):
                                 L * U = P * A:
                                 Matrix L: 下三角行列
                                 Matrix U: 上三角行列
                                 Matrix P: 置換行列
/* lu_p */

/* makelist */
          List makelist(Integer i1):  i1個の成分をもつリストを作る
/* makelist */

/* max */
          Integer max(Integer i1, Integer i2)  大きい方の整数
          Real max(Real r1, Real r2)           大きい方の実数	
          Complex max(Complex c1, Complex c2)  絶対値が大きい方の複素数
          Matrix max(Matrix M1):               ベクトル成分の最大値
          Matrix max(Matrix M1):               行毎の最大値からなる
                                               ベクトル
          Matrix max(Matrix M1, Matrix M2)     成分毎の比較
          Array max(Array M1, Array M2)        成分毎の比較
/* max */

/* max_col */
          Matrix max_col(Matrix M1)            ベクトルの最大値
          Matrix max_col(Matrix M1)            列毎の最大値
/* max_col */

/* max_row */
          Matrix max_row(Matrix M1)            ベクトルの最大値
          Matrix max_row(Matrix M1)            行毎の最大値
/* max_row */

/* maximum */
          List maximum(Matrix M1): 最大成分
          List maximum(Array A1):  最大成分

          {dd, i, j} = maximum(M1): 実行列の最大成分とその指数
          {dd, i, j} = maximum(A1): 実配列の最大成分とその指数
          dd = M1(i,j);  dd = A1(i,j);

          {cc, i, j} = maximum(M1): 複素行列の最大成分とその指数
          {cc, i, j} = maximum(A1): 複素配列の最大成分とその指数
          cc = M1(i,j);  cc = A1(i,j);
/* maximum */

/* maxsing */
          Real maxsing(Matrix M1): 最大特異値
/* maxsing */

/* menu */
         mode = menu({"TITLE","item1","item2","item3","item4"});
         mode = menu({"TITLE","item1","item2","item3","item4"}, default_item);
         Integer default_item;

         メニューを作成
/* menu */

/* mean */
          Real       mean(Matrix M1):   全ての成分の平均値
          Complex    mean(CoMatrix M1): 全ての成分の平均値
          Polynomial mean(PoMatrix M1): 全ての成分の平均値
          Rational   mean(RaMatrix M1): 全ての成分の平均値
          Real       mean(Array A1):    全ての成分の平均値
          Complex    mean(CoArray A1):  全ての成分の平均値
          Polynomial mean(PoArray A1):  全ての成分の平均値
          Rational   mean(RaArray A1):  全ての成分の平均値
          Integer    mean(Index X1):    全ての成分の平均値
/* mean */

/* mean_col */
          Matrix   mean_col(Matrix M1):  ベクトルの平均値
          Matrix   mean_col(Matrix M1):  列毎の平均値からなるベクトル
/* mean_col */

/* mean_row */
          Matrix   mean_row(Matrix M1):  ベクトルの平均値
          Matrix   mean_row(Matrix M1):  行毎の平均値からなるベクトル
/* mean_row */

/* min */
          Integer min(Integer i1, Integer i2)  小さい方の整数
          Real min(Real r1, Real r2)           小さい方の実数
          Complex min(Complex c1, Complex c2)  絶対値が小さい方の複素数
          Matrix min(Matrix M1):               ベクトル成分の最小値
          Matrix min(Matrix M1):               行毎の最小値からなる
                                               ベクトル
          Matrix min(Matrix M1, Matrix M2)     成分毎の比較
          Array min(Array M1, Array M2)        成分毎の比較
/* min */

/* min_col */
          Matrix min_col(Matrix M1)            ベクトルの最小値
          Matrix min_col(Matrix M1)            列毎の最小値
/* min_col */

/* min_row */
          Matrix min_row(Matrix M1)            ベクトルの最小値
          Matrix min_row(Matrix M1)            行毎の最小値
/* min_row */

/* minimum */
          List minimum(Matrix M1): 最小成分
          List minimum(Array A1):  最小成分

          {dd, i, j} = minimum(M1): 実行列の最小値とその指
          {dd, i, j} = minimum(A1): 実配列の最小値とその指数
          dd = M1(i,j);  dd = A1(i,j);

          {cc, i, j} = minimum(M1): 複素行列の最小値とその指数
          {cc, i, j} = minimum(A1): 複素配列の最小値とその指数
          cc = M1(i,j);  cc = A1(i,j);
/* minimum */

/* minsing */
          Real minsing(Matrix M2): 最小特異値
/* minsing */


/* norm */
          Real norm(Matrix M1, Integer i1): p-ノルム
          デフォルト: (i1 = 2)
/* norm */

/* poles */
          CoMatrix poles(Rational R1): 有理多項式の極からなるベクトル
/* poles */

/* printf */
          void printf(String s1, Arg1, Arg2, ..., Argn): 
          フォーマット変換し，標準出力に出力
/* printf */

/* prod */
          Real       prod(Matrix M1):   全ての成分の積
          Complex    prod(CoMatrix M1): 全ての成分の積
          Polynomial prod(PoMatrix M1): 全ての成分の積
          Rational   prod(RaMatrix M1): 全ての成分の積
          Real       prod(Array A1):    全ての成分の積
          Complex    prod(CoArray A1):  全ての成分の積
          Polynomial prod(PoArray A1):  全ての成分の積
          Rational   prod(RaArray A1):  全ての成分の積
          Integer    prod(Index X1):    全ての成分の積
/* prod */

/* prod_col */
          Matrix   prod_col(Matrix M1):  ベクトルの全ての成分の積
          Matrix   prod_col(Matrix M1):  列毎の成分の積からなるベクトル
/* prod_col */

/* prod_row */
          Matrix   prod_row(Matrix M1):  ベクトルの全ての成分の積
          Matrix   prod_row(Matrix M1):  行毎の成分の積からなるベクトル
/* prod_row */

/* pseudoinv */
          Matrix pseudoinv(Matrix M1):           擬似逆行列
          Matrix pseudoinv(Matrix M1, Real tol): 擬似逆行列(精度指定)
          デフォルト: tol = frobnorm(M1)*EPS                    
/* pseudoinv */

/* putenv */
         void putenv(string)
         例: disp = putenv("DISPLAY=dazai:0.0");

         環境変数の変更
/* putenv */

/* qr */
         List qr(Matrix M1):    QR 分解
                                {Q, R} = qr(A):
                                Q * R = A:
                                Matrix Q: 直交(ユニタリ)行列
                                Matrix R: 上三角行列
/* qr */

/* qr_p */
          List qr_p(Matrix M1):  置換付き QR 分解
                                 {Q, R, P} = qr_p(A):
                                 Q * R = A * P:
                                 Matrix Q: 直交(ユニタリ)行列
                                 Matrix R: 上三角行列
                                 Matrix P: 置換行列
/* qr_p */

/* qz */             
          List qz(Matrix M1):    QZ 分解
                                 {AA, BB, Q, Z, VEC} = qz(A,B):
                                 Q# * A * Z = AA:
                                 Q# * B * Z = BB:
                                 val = diag2vec(AA) ./ diag2vec(BB):
                                 A * VEC = B * VEC * vec2diag(val):
                                Matrix  AA: 上三角行列
                                Matrix  BB: 上三角行列
                                Matrix   Q: 直交(ユニタリ)行列
                                Matrix   Z: 直交(ユニタリ)行列
                                Matrix VEC: 一般化固有ベクトル
                                Matrix val: 一般化固有値
/* qz */

/* rand */
          Real rand():                         一様分布乱数
          Matrix rand(Integer i1):             一様分布乱数行列
          Matrix rand(Integer i1, Integer i2): 一様分布乱数行列
          Integer rand("seed"):                一様分布乱数の種
          Integer rand("seed", Integer i1):    一様分布乱数の種を設定
          デフォルト: (i2 = i1)
          Matrix rand(Matrix M1);              一様分布乱数行列
          Array rand(Array M1);                一様分布乱数配列
/* rand */

/* randn */
          Real randn():                         正規分布乱数
          Matrix randn(Integer i1):             正規分布乱数行列
          Matrix randn(Integer i1, Integer i2): 正規分布乱数行列
          Integer randn("seed"):                正規分布乱数の種
          Integer randn("seed", Integer i1):    正規分布乱数の種を設定
          デフォルト: (i2 = i1)
          Matrix randn(Matrix M1);              正規分布乱数行列
          Array randn(Array M1);                正規分布乱数行列
/* randn */

/* rank */
          Integer rank(Matrix M1):           ランク(階数)
          Integer rank(Matrix M1, Real tol): ランク(階数)(精度指定)
          デフォルト: tol = frobnorm(M1)*EPS                    
/* rank */

/* rem */
          Integer rem(Integer i1, Integer i2): 商の余り
          Real    rem(Integer i1, Real r2):    商の余り
          Matrix  rem(Integer i1, Matrix a):   商の余り
          Array   rem(Integer i1, Array a):    商の余り
          Index   rem(Integer i1, Index a):    商の余り
          Real    rem(Real r1, Integer i2):    商の余り
          Real    rem(Real r1, Real r2):       商の余り
          Matrix  rem(Real r1, Matrix a):      商の余り
          Array   rem(Real r1, Array a):       商の余り
          Index   rem(Real r1, Index a):       商の余り
          Matrix  rem(Matrix a, Integer i1):   商の余り
          Matrix  rem(Matrix a, Real r1):      商の余り
          Matrix  rem(Matrix a, Matrix b):     商の余り
          Array  rem(Array a, Integer i1):     商の余り
          Array  rem(Array a, Real r1):        商の余り
          Array  rem(Array a, Array b):        商の余り
          Index  rem(Index a, Integer i1):     商の余り
          Index  rem(Index a, Real r1):        商の余り
          Index  rem(Index a, Index b):        商の余り
/* rem */

/* reshape */
          Matrix reshape(Matrix M1, Integer i1, Integer i2):  行列の変形
/* reshape */

/* rkf45 */
          Matrix rkf45(Real t, Matrix x, Matrix diff_eqs(), Real dt)
          Matrix rkf45(Real t, Matrix x, Matrix diff_eqs(), Matrix u)
          Matrix rkf45(Real t, Matrix x, Matrix diff_eqs(), Matrix u, Real dt)
          Matrix rkf45(Real t, Matrix x, Matrix diff_eqs(),
                                         Matrix link_eqs())
          Matrix rkf45(Real t, Matrix x, Matrix diff_eqs(),
                                         Matrix link_eqs(), Real dt)
          
          RKF45の公式にしたがって常微分方程式の解を求める。
/* rkf45 */

/* rngkut4 */
          Matrix rngkut4(Real t, Matrix x, Matrix diff_eqs(), Real dt)
          Matrix rngkut4(Real t, Matrix x, Matrix diff_eqs(),
                                           Matrix u)
          Matrix rngkut4(Real t, Matrix x, Matrix diff_eqs(),
                                           Matrix u, Real dt)
          Matrix rngkut4(Real t, Matrix x, Matrix diff_eqs(),
                                           Matrix link_eqs())
          Matrix rngkut4(Real t, Matrix x, Matrix diff_eqs(),
                                           Matrix link_eqs(), Real dt)

          4次のルンゲ－クッタの公式にしたがって常微分方程式の解を求める。
/* rngkut4 */

/* roots */
          CoMatrix roots(Polynomial P1): 多項式の根からなるベクトル
/* roots */

/* round */
          Real round(Real r1):       最も近い整数への丸め
          Complex round(Complex c1): 最も近い整数への丸め
          Polynomial round(Polynomial P1): 最も近い整数への丸め
          Rational round(Rational R1): 最も近い整数への丸め
          Array round(Array A1):     各成分の最も近い整数への丸め
          Matrix round(Matrix M1):   各成分の最も近い整数への丸め
          Index round(Index I1):     各成分の最も近い整数への丸め
/* round */

/* round2z */
          ゼロへの丸め (デフォルトの tol = EPS)
          Rounding function to 0 with tolerance
          Integer round2z(Integer i1)
          Integer round2z(Integer i1, Real tol)
          Real round2z(Real r1)
          Real round2z(Real r1, Real tol)
          Complex round2z(Complex c1)
          Complex round2z(Complex c1, Real tol)
          Polynomial round2z(Polynomial P1)
          Polynomial round2z(Polynomial P1, Real tol)
          Rational round2z(Rational R1)
          Rational round2z(Rational R1, Real tol)
          Matrix round2z(Matrix M1)
          Matrix round2z(Matrix M1, Real tol)
/* round2z */

/* scanf */
          List scanf(String format): 
          フォーマット変換し，標準入力から読み込む
/* scanf */

/* schur */
          List schur(Matrix M1):  Schur 分解
                                 {U, T} = schur(A):
                                  U# * A * U = T:
                                  Matrix U: 直交(ユニタリ)行列
                                  Matrix T: 擬似上三角行列
                                            上三角行列
/* schur */

/* settimer */
          void settimer(): タイマ－をスタートさせる
/* settimer */

/* sgn */
          Real sgn(Real r1):   実数の符号関数
          Array sgn(Array A1): 各成分の符号
/* sgn */

/* sin */
          Real    sin(Real r1):    実数の正弦関数
          Complex sin(Complex c1): 複素数の正弦関数
          Array   sin(Array A1):   各成分の正弦関数
/* sin */

/* sing */
          void sing(Matrix M1): 特異値分解
/* sing */

/* singleftvec */
          Matrix singleftvec(Matrix M1): 左特異値ベクトル
/* singleftvec */

/* singrightvec */
          Matrix singrightvec(Matrix M1): 右特異値ベクトル
/* singrightvec */

/* singval */
          Matrix singval(Matrix M1): 特異値
/* singval */

/* sinh */
          Real    sinh(Real r1):    実数の双曲線正弦関数
          Complex sinh(Complex c1): 複素数の双曲線正弦関数
          Array   sinh(Array A1):   各成分の双曲線正弦関数
/* sinh */

/* size */
          List size(Matrix M1): 行列のサイズ
          List size(Array A1):  配列のサイズ
                                {m, n} = size(M1);
                                 Integer m: 行の数
                                 Integer n: 列の数
/* size */

/* sort */
          List sort(Matrix M1): 昇べきの順にソートする
                                {M2, idx} = sort(M1)
                                 Matrix M2: ソート結果
                                 Index idx: ソートに使われた指数

                                {A2, idx} = sort(A1)
                                 Array A2: ソート結果
                                 Index idx: ソートに使われた指数
/* sort */

/* sort_col */
          List sort_col(Matrix M1):
                                 昇べきの順にソートする(列毎)
                                {M2, idx} = sort_col(M1)
                                 Matrix M2: ソート結果
                                 Index idx: ソートに使われた指数

                                {A2, idx} = sort_col(A1)
                                 Array A2: ソート結果
                                 Index idx: ソートに使われた指数
/* sort_col */

/* sort_row */
          List sort_row(Matrix M1):
                                 昇べきの順にソートする(行毎)
                                {M2, idx} = sort_row(M1)
                                 Matrix M2: ソート結果
                                 Index idx: ソートに使われた指数

                                {A2, idx} = sort_row(A1)
                                 Array A2: ソート結果
                                 Index idx: ソートに使われた指数
/* sort_row */

/* sprintf */
          String sprintf(String s1, Arg1, Arg2, ..., Argn):

          フォーマット変換し文字列として出力する
/* sprintf */

/* sqrt */
          Real    sqrt(Real r1):    正の実数の平方根
          Complex sqrt(Complex c1): 複素数の実数の平方根
          Array   sqrt(Array A1):   各成分の平方根
          Matrix  sqrt(Matrix M1):  行列の平方根
/* sqrt */

/* std */
          Real       std(Matrix M1):   全ての成分の標準偏差
          Complex    std(CoMatrix M1): 全ての成分の標準偏差
          Polynomial std(PoMatrix M1): 全ての成分の標準偏差
          Rational   std(RaMatrix M1): 全ての成分の標準偏差
          Real       std(Array A1):    全ての成分の標準偏差
          Complex    std(CoArray A1):  全ての成分の標準偏差
          Polynomial std(PoArray A1):  全ての成分の標準偏差
          Rational   std(RaArray A1):  全ての成分の標準偏差
          Integer    std(Index X1):    全ての成分の標準偏差
/* std */

/* std_col */
          Matrix   std_col(Matrix M1):  ベクトルの全ての成分の標準偏差
          Matrix   std_col(Matrix M1):  列毎の標準偏差からなるベクトル
/* std_col */

/* std_row */
          Matrix   std_row(Matrix M1):  ベクトルの全ての成分の標準偏差
          Matrix   std_row(Matrix M1):  行毎の標準偏差からなるベクトル
/* std_row */

/* strchr */
          Integer strchr(String str, String c): 

          文字列 'str' の中の最初の 'c' 文字の位置
/* strchr */

/* svd */
          List svd(Matrix M1):   特異値分解
                                 {U, D, V} = svd(A):
                                 U * D * V# = A:
                                 Matrix U: 左特異値ベクトル
                                 Matrix V: 右特異値ベクトル 
                                 Matrix D: 特異値
/* svd */

/* sum */
          Real       sum(Matrix M1):    全ての成分の和
          Complex    sum(CoMatrix M1):  全ての成分の和
          Polynomial sum(PoMatrix M1):  全ての成分の和
          Rational   sum(RaMatrix M1):  全ての成分の和
          Real       sum(Array A1):     全ての成分の和
          Complex    sum(CoArray A1):   全ての成分の和
          Polynomial sum(PoArray A1):   全ての成分の和
          Rational   sum(RaArray A1):   全ての成分の和
          Integer    sum(Integer X1):   全ての成分の和
/* sum */

/* sum_col */
          Matrix   sum_col(Matrix M1):   ベクトルの全ての成分の和
          Matrix   sum_col(Matrix M1):   列毎の成分の和からなるベクトル
/* sum_col */

/* sum_row */
          Matrix   sum_row(Matrix M1):   ベクトルの全ての成分の和
          Matrix   sum_row(Matrix M1):   行毎の成分の和からなるベクトル
/* sum_row */

/* system */
          void system(String s1): システムコール(コマンドシェル)
/* system */

/* tan */
          Real    tan(Real r1):    実数の正接関数
          Complex tan(Complex c1): 複素数の正接関数
          Array   tan(Array A1):   各成分の正接関数
/* tan */

/* tanh */
          Real    tanh(Real r1):    実数の双曲線正接関数
          Complex tanh(Complex c1): 複素数の双曲線正接関数
          Array   tanh(Array A1):   各成分の双曲線正接関数
/* tanh */

/* trace */
          Real       trace(Matrix M1):   対角成分の和
          Complex    trace(CoMatrix M1): 対角成分の和
          Polynomial trace(PoMatrix M1): 対角成分の和
          Rational   trace(RaMatrix M1): 対角成分の和
          Real       trace(Array A1):    対角成分の和
          Complex    trace(CoArray A1):  対角成分の和
          Polynomial trace(PoArray A1):  対角成分の和
          Rational   trace(RaArray A1):  対角成分の和
/* trace */

/* trans */
          Matrix trans(Matrix A): 転置行列
/* trans */

/* vec2diag */
          Matrix vec2diag(Matrix M1): ベクトルの成分を対角にもつ行列
/* vec2diag */

/* vectorprod */
          Matrix vectorprod(Matrix M1, Matrix M2):  ベクトル積(外積)
/* vectorprod */

/* warning */
          void warning(String s1): 警告関数
/* warning */

/* zeros */
          Matrix zeros(Rational R1): 有理多項式のゼロからなるベクトル
/* zeros */
