doc/info/ja/stringproc.texi

   1 @menu
   2 * Introduction to string processing::
   3 * Functions and Variables for input and output::
   4 * Functions and Variables for characters::
   5 * Functions and Variables for strings::
   6 @end menu
   7
   8 @node Introduction to string processing, Functions and Variables for input and output, stringproc, stringproc
   9 @section Introduction to string processing
  10
  11 @code{stringproc.lisp}は、
  12  enlarges
  13 Maximaの文字列を扱う機能を拡大し、
  14 ファイル入出力に関するいくつかの役立つ関数を追加します。
  15
  16 質問とバグに関して、van.nek at arcor.deにメールしてください。
  17
  18 Maximaでは、
  19 文字列は、"text"とタイプすることで簡単に構成することができます。
  20 @code{stringp}は文字列かテストします。
  21
  22 @c ===beg===
  23 @c m: "text";
  24 @c stringp(m);
  25 @c ===end===
  26 @example
  27 (%i1) m: "text";
  28 (%o1)                         text
  29 (%i2) stringp(m);
  30 (%o2)                         true
  31 @end example
  32
  33 文字は長さ1の文字列として表されます。
  34 これらはLisp文字ではありません。
  35 テストは
  36 @code{charp}で行うことができます。
  37 (関連として、@code{lcharp}と
  38 @code{cunlisp}を使ったLisp文字からMaxima文字への変換)
  39
  40
  41 @c ===beg===
  42 @c c: "e";
  43 @c [charp(c),lcharp(c)];
  44 @c supcase(c);
  45 @c charp(%);
  46 @c ===end===
  47 @example
  48 (%i1) c: "e";
  49 (%o1)                           e
  50 (%i2) [charp(c),lcharp(c)];
  51 (%o2)                     [true, false]
  52 (%i3) supcase(c);
  53 (%o3)                           E
  54 (%i4) charp(%);
  55 (%o4)                         true
  56 @end example
  57
  58 @code{stringproc.lisp}の中の、文字を返す関数すべては、Maxima文字を返します。
  59 導入された文字が長さ1の文字列だという事実のおかげで、たくさんの文字列関数を文字にも使うことができます。
  60 既に見たように、
  61 @code{supcase}は１例です。
  62
  63 Maxima文字列の最初の文字は位置1にあることを知ることは重要です。
  64 これは、Maximaリストの中の最初の要素も位置1にあるという事実によって設計されています。
  65 例えば、@code{charat}や@code{charlist}の定義を見てください。
  66
  67 応用として、
  68 文字列関数はしばしばファイルを扱う時に使われます。
  69 @code{stringproc.lisp}の中に役立つストリーム関数、印字関数を見つけるでしょう。
  70 以下の例はここで導入された関数のいくつかがいかに働くか示します。
  71
  72 例:
  73
  74 @code{openw}は、ファイルへの出力ストリームを返し、
  75 @code{printf}は、このファイルへのフォーマットされた書き込みを可能にします。
  76 詳細は@code{printf}を参照してください。
  77
  78 @example
  79 (%i1) s: openw("E:/file.txt");
  80 (%o1)                    #<output stream E:/file.txt>
  81 (%i2) for n:0 thru 10 do printf( s, "~d ", fib(n) );
  82 (%o2)                                done
  83 (%i3) printf( s, "~%~d ~f ~a ~a ~f ~e ~a~%",
  84               42,1.234,sqrt(2),%pi,1.0e-2,1.0e-2,1.0b-2 );
  85 (%o3)                                false
  86 (%i4) close(s);
  87 (%o4)                                true
  88 @end example
  89
  90 ストリームを閉じた後、今度は入力方向で再び開くことができます。
  91 @code{readline}は行全体を１つの文字列として返します。
  92 現在、@code{stringproc}パッケージは
  93 文字列を操作するたくさんの関数を提供しています。
  94 @code{split}や@code{tokens}でトークン化できます。
  95
  96 @example
  97 (%i5) s: openr("E:/file.txt");
  98 (%o5)                     #<input stream E:/file.txt>
  99 (%i6) readline(s);
 100 (%o6)                     0 1 1 2 3 5 8 13 21 34 55
 101 (%i7) line: readline(s);
 102 (%o7)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
 103 (%i8) list: tokens(line);
 104 (%o8)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
 105 (%i9) map( parse_string, list );
 106 (%o9)            [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
 107 (%i10) float(%);
 108 (%o10) [42.0, 1.234, 1.414213562373095, 3.141592653589793, 0.01,
 109                                                      0.01, 0.01]
 110 (%i11) readline(s);
 111 (%o11)                               false
 112 (%i12) close(s)$
 113 @end example
 114
 115 ファイルの終わりに来ると、
 116 @code{readline}は@code{false}を返します。
 117
 118 @opencatbox
 119 @category{Strings}
 120 @category{Share packages}
 121 @category{Package stringproc}
 122 @closecatbox
 123
 124
 125 @node Functions and Variables for input and output, Functions and Variables for characters, Introduction to string processing, stringproc
 126 @section Functions and Variables for input and output
 127
 128 例:
 129
 130 @c ===beg===
 131 @c s: openw("E:/file.txt");
 132 @c control:
 133 @c  "~2tAn atom: ~20t~a~%~2tand a list: ~20t~@{~r ~@}~%~2tand an integer: ~20t~d~%"$
 134 @c printf( s,control, 'true,[1,2,3],42 )$
 135 @c close(s);
 136 @c s: openr("E:/file.txt");
 137 @c while stringp( tmp:readline(s) ) do print(tmp)$
 138 @c close(s)$
 139 @c ===end===
 140 @example
 141 (%i1) s: openw("E:/file.txt");
 142 (%o1)                     #<output stream E:/file.txt>
 143 (%i2) control:
 144 "~2tAn atom: ~20t~a~%~2tand a list: ~20t~@{~r ~@}~%~2t\
 145 and an integer: ~20t~d~%"$
 146 (%i3) printf( s,control, 'true,[1,2,3],42 )$
 147 (%o3)                                false
 148 (%i4) close(s);
 149 (%o4)                                true
 150 (%i5) s: openr("E:/file.txt");
 151 (%o5)                     #<input stream E:/file.txt>
 152 (%i6) while stringp( tmp:readline(s) ) do print(tmp)$
 153   An atom:          true
 154   and a list:       one two three
 155   and an integer:   42
 156 (%i7) close(s)$
 157 @end example
 158
 159 @deffn {関数} close (@var{stream})
 160 @var{stream}を閉じて、
 161 もし@var{stream}が開いていたら
 162 @code{true}を返します。
 163
 164 @opencatbox
 165 @category{File input}
 166 @category{File output}
 167 @category{Package stringproc}
 168 @closecatbox
 169
 170 @end deffn
 171
 172 @deffn {関数} flength (@var{stream})
 173 @var{stream}の中の要素の数を返します。
 174
 175 @opencatbox
 176 @category{File input}
 177 @category{File output}
 178 @category{Package stringproc}
 179 @closecatbox
 180
 181 @end deffn
 182
 183 @deffn {関数} fposition (@var{stream})
 184 @deffnx {関数} fposition (@var{stream}, @var{pos})
 185 もし@var{pos}が使われてないなら、
 186 @var{stream}の中の現在位置を返します。
 187 もし@var{pos}が使われているなら、
 188 @code{fposition}は@var{stream}の中の位置を設定します。
 189 @var{pos}は正の数でなければいけません。
 190 @var{stream}の最初の要素は位置1にあります。
 191
 192 @opencatbox
 193 @category{File input}
 194 @category{File output}
 195 @category{Package stringproc}
 196 @closecatbox
 197
 198 @end deffn
 199
 200 @deffn {関数} freshline ()
 201 @deffnx {関数} freshline (@var{stream})
 202 もし位置が行の最初でないなら
 203 (@var{stream}に)改行を書きます。
 204 @code{newline}も参照してください。
 205
 206 @opencatbox
 207 @category{File output}
 208 @category{Package stringproc}
 209 @closecatbox
 210
 211 @end deffn
 212
 213 @deffn {関数} newline ()
 214 @deffnx {関数} newline (@var{stream})
 215 (@var{stream}に)改行を書きます。
 216 @code{newline()}の使用の例に関しては、
 217 @code{sprint}を参照してください。
 218 @code{newline()}が期待通りに動かない
 219 いくつかの場合があることに注意してください。
 220
 221 @opencatbox
 222 @category{File output}
 223 @category{Package stringproc}
 224 @closecatbox
 225
 226 @end deffn
 227
 228 @deffn {関数} opena (@var{file})
 229 @var{file}への出力ストリームを返します。
 230 もし存在しているファイルを開いたら、
 231 @code{opena}はファイルの終わりに要素を追加します。
 232
 233 @opencatbox
 234 @category{File output}
 235 @category{Package stringproc}
 236 @closecatbox
 237
 238 @end deffn
 239
 240 @deffn {関数} openr (@var{file})
 241 @var{file}への入力ストリームを返します。
 242 もし@var{file}が存在しないなら、生成されます。
 243
 244 @opencatbox
 245 @category{File input}
 246 @category{Package stringproc}
 247 @closecatbox
 248
 249 @end deffn
 250
 251 @deffn {関数} openw (@var{file})
 252 @var{file}への出力ストリームを返します。
 253 もし@var{file}が存在しないなら、生成されます。
 254 もし存在しているファイルを開いたら、@code{openw}は
 255 @var{file}を破壊的に変更します。
 256
 257 @opencatbox
 258 @category{File output}
 259 @category{Package stringproc}
 260 @closecatbox
 261
 262 @end deffn
 263
 264 @deffn {関数} printf (@var{dest}, @var{string})
 265 @deffnx {関数} printf (@var{dest}, @var{string}, @var{expr_1}, ..., @var{expr_n})
 266 Common Lisp関数FORMATをMaximaで利用可能にします。
 267 (gcl.infoから:
 268 「フォーマットは
 269 制御文字列の文字を出力し、波形記号がディレクティブを挿入することを守ることで、
 270 フォーマットされた出力を生成します。
 271 波形記号の後の文字は多分、前置パラメータと修飾語が先行し、
 272 望まれるフォーマットの種類を指定します。
 273 ほとんどのディレクティブは、出力を生成するために1つまたは複数の引数を使います。」)
 274
 275 以下の記述と例は@code{printf}を使うアイデアを与えるかもしれません。
 276 さらなる情報に関して、Lisp参考文献を参照してください。
 277
 278 @example
 279    ~%       改行
 280    ~&       行のフレッシュ
 281    ~t       タブ
 282    ~$       通貨記号
 283    ~d       10進整数
 284    ~b       2進整数
 285    ~o       8進整数
 286    ~x       16進整数
 287    ~br      b進整数
 288    ~r       整数を一字一字
 289    ~p       複数形
 290    ~f       浮動小数点
 291    ~e       科学的記数法
 292    ~g       大きさに応じて~fまたは~e
 293    ~h       多倍長浮動小数点
 294    ~a       Maxima関数文字列を使う
 295    ~s       ~aと同様, しかし"ダブルコーテーション"で囲まれた出力
 296    ~~       ~
 297    ~<       行揃え, ~> 終端
 298    ~(       大文字小文字変換, ~) 終端
 299    ~[       選択, ~] 終端
 300    ~@{       繰り返し, ~@} 終端
 301 @end example
 302
 303 選択ディレクティブ@code{~[}は添字がゼロから始まることに注意してください。
 304 ディレクティブ~*がサポートされていないことにも注意してください。
 305
 306 @c ===beg===
 307 @c printf( false, "~a ~a ~4f ~a ~@@r",
 308 @c         "String",sym,bound,sqrt(12),144), bound = 1.234;
 309 @c printf( false,"~@{~a ~@}",["one",2,"THREE"] );
 310 @c printf( true,"~@{~@{~9,1f ~@}~%~@}",mat ),
 311 @c         mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
 312 @c control: "~:(~r~) bird~p ~[is~;are~] singing."$
 313 @c printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
 314 @c ===end===
 315 @example
 316 (%i1) printf( false, "~a ~a ~4f ~a ~@@r",
 317               "String",sym,bound,sqrt(12),144), bound = 1.234;
 318 (%o1)                 String sym 1.23 2*sqrt(3) CXLIV
 319 (%i2) printf( false,"~@{~a ~@}",["one",2,"THREE"] );
 320 (%o2)                          one 2 THREE
 321 (%i3) printf(true,"~@{~@{~9,1f ~@}~%~@}",mat ),
 322           mat = args(matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]))$
 323       1.1       2.0       3.3
 324       4.0       5.0       6.0
 325       7.0       8.9       9.0
 326 (%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
 327 (%i5) printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
 328 (%o5)                    Two birds are singing.
 329 @end example
 330
 331 もし@var{dest}がストリームか@code{true}なら、
 332 @code{printf}は@code{false}を返します。
 333 そうでないなら、@code{printf}は出力を含む文字列を返します。
 334
 335 @opencatbox
 336 @category{File output}
 337 @category{Package stringproc}
 338 @closecatbox
 339
 340 @end deffn
 341
 342 @deffn {関数} readline (@var{stream})
 343 @var{stream}の現在位置から行の終わりまでの文字を含む文字列か、
 344 もしファイルの終わりが来たら@var{false}を返します。
 345
 346 @opencatbox
 347 @category{File input}
 348 @category{Package stringproc}
 349 @closecatbox
 350
 351 @end deffn
 352
 353 @c -----------------------------------------------------------------------------
 354 @anchor{sprint}
 355 @deffn {関数} sprint (@var{expr_1}, @dots{}, @var{expr_n})
 356
 357 引数を順に評価し、一番左から始まる「一行」に表示します。
 358 数は数の右隣に'-'と共に印字され、行の長さを無視します。
 359 もし中間行ブレークを置きたいなら、
 360 @code{newline()}―@code{stringproc.lisp} から自動ロードされます―
 361 が役に立つかもしれません。
 362
 363 例:
 364
 365 @c ===beg===
 366 @c for n:0 thru 19 do sprint( fib(n) )$
 367 @c for n:0 thru 22 do (
 368 @c    sprint(fib(n)), if mod(n,10)=9 then newline() )$
 369 @c ===end===
 370 @example
 371 (%i1) for n:0 thru 19 do sprint( fib(n) )$
 372 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
 373 (%i2) for n:0 thru 22 do (
 374          sprint(fib(n)), if mod(n,10)=9 then newline() )$
 375 0 1 1 2 3 5 8 13 21 34
 376 55 89 144 233 377 610 987 1597 2584 4181
 377 6765 10946 17711
 378 @end example
 379
 380 @opencatbox
 381 @category{Package stringproc}
 382 @closecatbox
 383 @end deffn
 384
 385 @node Functions and Variables for characters, Functions and Variables for strings, Functions and Variables for input and output, stringproc
 386 @section Functions and Variables for characters
 387
 388 @deffn {関数} alphacharp (@var{char})
 389 もし@var{char}がアルファベット文字なら@code{true}を返します。
 390
 391 @opencatbox
 392 @category{Predicate functions}
 393 @category{Package stringproc}
 394 @closecatbox
 395
 396 @end deffn
 397
 398 @deffn {関数} alphanumericp (@var{char})
 399 もし@var{char}がアルファベット文字か数字なら@code{true}を返します。
 400
 401 @opencatbox
 402 @category{Predicate functions}
 403 @category{Package stringproc}
 404 @closecatbox
 405
 406 @end deffn
 407
 408 @deffn {関数} ascii (@var{int})
 409 ASCIIコード@var{int}( -1 < int < 256 )に対応する文字を返します。
 410
 411 @c ===beg===
 412 @c for n from 0 thru 255 do (
 413 @c    tmp: ascii(n), if alphacharp(tmp) then sprint(tmp),
 414 @c       if n=96 then newline() )$
 415 @c ===end===
 416 @example
 417 (%i1) for n from 0 thru 255 do (
 418    tmp: ascii(n), if alphacharp(tmp) then sprint(tmp),
 419       if n=96 then newline() )$
 420 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
 421 a b c d e f g h i j k l m n o p q r s t u v w x y z
 422 @end example
 423
 424 @opencatbox
 425 @category{Package stringproc}
 426 @closecatbox
 427
 428 @end deffn
 429
 430 @deffn {関数} cequal (@var{char_1}, @var{char_2})
 431 もし@var{char_1}と@var{char_2}が同じなら@code{true}を返します。
 432
 433 @opencatbox
 434 @category{Predicate functions}
 435 @category{Package stringproc}
 436 @closecatbox
 437
 438 @end deffn
 439
 440 @deffn {関数} cequalignore (@var{char_1}, @var{char_2})
 441 @code{cequal}と同様ですが、文字の大小を無視します。
 442
 443 @opencatbox
 444 @category{Predicate functions}
 445 @category{Package stringproc}
 446 @closecatbox
 447
 448 @end deffn
 449
 450 @deffn {関数} cgreaterp (@var{char_1}, @var{char_2})
 451 もし@var{char_1}のASCIIコードが@var{char_2}のそれより大きいなら@code{true}を返します。
 452
 453 @opencatbox
 454 @category{Predicate functions}
 455 @category{Package stringproc}
 456 @closecatbox
 457
 458 @end deffn
 459
 460 @deffn {関数} cgreaterpignore (@var{char_1}, @var{char_2})
 461 @code{cgreaterp}と同様ですが、文字の大小を無視します。
 462
 463 @opencatbox
 464 @category{Predicate functions}
 465 @category{Package stringproc}
 466 @closecatbox
 467
 468 @end deffn
 469
 470 @deffn {関数} charp (@var{obj})
 471 もし@var{obj}がMaxima-文字なら@code{true}を返します。
 472 例えばイントロダクションを参照してください。
 473
 474 @opencatbox
 475 @category{Predicate functions}
 476 @category{Package stringproc}
 477 @closecatbox
 478
 479 @end deffn
 480
 481 @deffn {関数} cint (@var{char})
 482 @var{char}のASCIIコードを返します。
 483
 484 @opencatbox
 485 @category{Package stringproc}
 486 @closecatbox
 487
 488 @end deffn
 489
 490 @deffn {関数} clessp (@var{char_1}, @var{char_2})
 491 もし@var{char_1}のASCIIコードが@var{char_2}のそれより小さいなら@code{true}を返します。
 492
 493 @opencatbox
 494 @category{Predicate functions}
 495 @category{Package stringproc}
 496 @closecatbox
 497
 498 @end deffn
 499
 500 @deffn {関数} clesspignore (@var{char_1}, @var{char_2})
 501 @code{clessp}と同様ですが、文字の大小を無視します。
 502
 503 @opencatbox
 504 @category{Predicate functions}
 505 @category{Package stringproc}
 506 @closecatbox
 507
 508 @end deffn
 509
 510 @deffn {関数} constituent (@var{char})
 511 もし@var{char}がグラフィック文字であり、スペース文字でないなら、
 512 @code{true}を返します。
 513 グラフィック文字は見ることができる文字とスペース文字です。
 514 (@code{constituent}は、Paul Graham, ANSI Common Lisp, 1996, page 67で定義されています。)
 515
 516 @c ===beg===
 517 @c for n from 0 thru 255 do (
 518 @c    tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
 519 @c ===end===
 520 @example
 521 (%i1) for n from 0 thru 255 do (
 522 tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
 523 ! " #  %  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @@ A B
 524 C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c
 525 d e f g h i j k l m n o p q r s t u v w x y z @{ | @} ~
 526 @end example
 527
 528 @opencatbox
 529 @category{Predicate functions}
 530 @category{Package stringproc}
 531 @closecatbox
 532
 533 @end deffn
 534
 535 @deffn {関数} cunlisp (@var{lisp_char})
 536 Lisp文字をMaxima文字に変換します。
 537 (必要としないでしょう。)
 538
 539 @opencatbox
 540 @category{Package stringproc}
 541 @closecatbox
 542
 543 @end deffn
 544
 545 @deffn {関数} digitcharp (@var{char})
 546 もし@var{char}が0から9までの数字なら、
 547 @code{true}を返します。
 548
 549 @opencatbox
 550 @category{Predicate functions}
 551 @category{Package stringproc}
 552 @closecatbox
 553
 554 @end deffn
 555
 556 @deffn {関数} lcharp (@var{obj})
 557 もし @var{obj}がLisp文字なら、@code{true}を返します。
 558 (必要としないでしょう。)
 559
 560 @opencatbox
 561 @category{Predicate functions}
 562 @category{Package stringproc}
 563 @closecatbox
 564
 565 @end deffn
 566
 567 @deffn {関数} lowercasep (@var{char})
 568 もし@var{char}が小文字なら、@code{true}を返します。
 569
 570 @opencatbox
 571 @category{Predicate functions}
 572 @category{Package stringproc}
 573 @closecatbox
 574
 575 @end deffn
 576
 577 @defvr {変数} newline
 578 改行文字。
 579
 580 @opencatbox
 581 @category{Global variables}
 582 @category{Package stringproc}
 583 @closecatbox
 584
 585 @end defvr
 586
 587 @defvr {変数} space
 588 スペース文字。
 589
 590 @opencatbox
 591 @category{Global variables}
 592 @category{Package stringproc}
 593 @closecatbox
 594
 595 @end defvr
 596
 597 @defvr {変数} tab
 598 タブ文字。
 599
 600 @opencatbox
 601 @category{Global variables}
 602 @category{Package stringproc}
 603 @closecatbox
 604
 605 @end defvr
 606
 607 @deffn {関数} uppercasep (@var{char})
 608 もし@var{char}が大文字なら、@code{true}を返します。
 609
 610 @opencatbox
 611 @category{Predicate functions}
 612 @category{Package stringproc}
 613 @closecatbox
 614
 615 @end deffn
 616
 617 @node Functions and Variables for strings,  , Functions and Variables for characters, stringproc
 618 @section Functions and Variables for strings
 619
 620 @deffn {関数} stringp (@var{obj})
 621 もし@var{obj}が文字列なら、@code{true}を返します。
 622 例はイントロダクションを参照してください。
 623
 624 @opencatbox
 625 @category{Predicate functions}
 626 @category{Package stringproc}
 627 @closecatbox
 628
 629 @end deffn
 630
 631 @deffn {関数} charat (@var{string}, @var{n})
 632 @var{string}の@var{n}番目の文字を返します。
 633 @var{string}の一番目の文字は@var{n} = 1で返されます。
 634
 635 @c ===beg===
 636 @c charat("Lisp",1);
 637 @c ===end===
 638 @example
 639 (%i1) charat("Lisp",1);
 640 (%o1)                           L
 641 @end example
 642
 643 @opencatbox
 644 @category{Package stringproc}
 645 @closecatbox
 646
 647 @end deffn
 648
 649 @deffn {関数} charlist (@var{string})
 650 @var{string}の文字すべてのリストを返します。
 651
 652 @c ===beg===
 653 @c charlist("Lisp");
 654 @c %[1];
 655 @c ===end===
 656 @example
 657 (%i1) charlist("Lisp");
 658 (%o1)                     [L, i, s, p]
 659 (%i2) %[1];
 660 (%o2)                           L
 661 @end example
 662
 663 @opencatbox
 664 @category{Package stringproc}
 665 @closecatbox
 666
 667 @end deffn
 668
 669 @deffn {関数} eval_string (@var{str})
 670 文字列@var{str}をMaxima式としてパースし、評価します。
 671 文字列@var{str}は終端子(ドル記号@code{$}またはセミコロン@code{;})
 672 を持つかもしれませんし持たないかもしれません。
 673
 674 もし複数あるなら、最初の式だけがパースされ、評価されます。
 675
 676 もし@var{str}が文字列でないならエラーが出力されます。
 677
 678 例:
 679
 680 @c ===beg===
 681 @c eval_string ("foo: 42; bar: foo^2 + baz");
 682 @c eval_string ("(foo: 42, bar: foo^2 + baz)");
 683 @c ===end===
 684 @example
 685 (%i1) eval_string ("foo: 42; bar: foo^2 + baz");
 686 (%o1)                       42
 687 (%i2) eval_string ("(foo: 42, bar: foo^2 + baz)");
 688 (%o2)                   baz + 1764
 689 @end example
 690
 691 @code{parse_string}も参照してください。
 692
 693 @opencatbox
 694 @category{Package stringproc}
 695 @closecatbox
 696
 697 @end deffn
 698
 699 @deffn {関数} parse_string (@var{str})
 700 文字列@var{str}をMaxima式としてパースします(評価しません)。
 701 文字列@var{str}は終端子(ドル記号@code{$}またはセミコロン@code{;})
 702 を持つかもしれませんし持たないかもしれません。
 703
 704 もし複数あるなら、最初の式だけがパースされ、評価されます。
 705
 706 もし@var{str}が文字列でないならエラーが出力されます。
 707
 708 例:
 709
 710 @c ===beg===
 711 @c parse_string ("foo: 42; bar: foo^2 + baz");
 712 @c parse_string ("(foo: 42, bar: foo^2 + baz)");
 713 @c ===end===
 714 @example
 715 (%i1) parse_string ("foo: 42; bar: foo^2 + baz");
 716 (%o1)                    foo : 42
 717 (%i2) parse_string ("(foo: 42, bar: foo^2 + baz)");
 718                                    2
 719 (%o2)          (foo : 42, bar : foo  + baz)
 720 @end example
 721
 722 @code{eval_string}も参照してください。
 723
 724 @opencatbox
 725 @category{Package stringproc}
 726 @closecatbox
 727
 728 @end deffn
 729
 730 @deffn {関数} scopy (@var{string})
 731 @var{string}のコピーを新しい文字列として返します。
 732
 733 @opencatbox
 734 @category{Package stringproc}
 735 @closecatbox
 736
 737 @end deffn
 738
 739 @deffn {関数} sdowncase (@var{string})
 740 @deffnx {関数} sdowncase (@var{string}, @var{start})
 741 @deffnx {関数} sdowncase (@var{string}, @var{start}, @var{end})
 742 @code{supcase}と同様ですが、大文字が小文字に変換されます。
 743
 744 @opencatbox
 745 @category{Package stringproc}
 746 @closecatbox
 747
 748 @end deffn
 749
 750 @deffn {関数} sequal (@var{string_1}, @var{string_2})
 751 もし@var{string_1}と@var{string_2}が同じ長さで、同じ文字を含むなら、
 752 @code{true}を返します。
 753
 754 @opencatbox
 755 @category{Predicate functions}
 756 @category{Package stringproc}
 757 @closecatbox
 758
 759 @end deffn
 760
 761 @deffn {関数} sequalignore (@var{string_1}, @var{string_2})
 762 @code{sequal}と同様ですが、文字の大小を無視します。
 763
 764 @opencatbox
 765 @category{Predicate functions}
 766 @category{Package stringproc}
 767 @closecatbox
 768
 769 @end deffn
 770
 771 @deffn {関数} sexplode (@var{string})
 772 @code{sexplode}は関数@code{charlist}の別名です。
 773
 774 @opencatbox
 775 @category{Package stringproc}
 776 @closecatbox
 777
 778 @end deffn
 779
 780 @deffn {関数} simplode (@var{list})
 781 @deffnx {関数} simplode (@var{list}, @var{delim})
 782 @code{simplode}は式のリストを取り、それらを結合して文字列にします。
 783 もしデリミタ@var{delim}が指定されないなら、
 784 @code{simplode}はデリミタを使いません。
 785 @var{delim}は任意の文字列を取り得ます。
 786
 787 @c ===beg===
 788 @c simplode(["xx[",3,"]:",expand((x+y)^3)]);
 789 @c simplode( sexplode("stars")," * " );
 790 @c simplode( ["One","more","coffee."]," " );
 791 @c ===end===
 792 @example
 793 (%i1) simplode(["xx[",3,"]:",expand((x+y)^3)]);
 794 (%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
 795 (%i2) simplode( sexplode("stars")," * " );
 796 (%o2)                   s * t * a * r * s
 797 (%i3) simplode( ["One","more","coffee."]," " );
 798 (%o3)                   One more coffee.
 799 @end example
 800
 801 @opencatbox
 802 @category{Package stringproc}
 803 @closecatbox
 804
 805 @end deffn
 806
 807 @deffn {関数} sinsert (@var{seq}, @var{string}, @var{pos})
 808 @code{substring (@var{string}, 1, @var{pos} - 1)}と
 809 文字列@var{seq}、@code{substring (@var{string}, @var{pos})}
 810 の結合となる文字列を返します。
 811 @var{string}の一番目の文字は位置1にあることに注意してください。
 812
 813 @c ===beg===
 814 @c s: "A submarine."$
 815 @c concat( substring(s,1,3),"yellow ",substring(s,3) );
 816 @c sinsert("hollow ",s,3);
 817 @c ===end===
 818 @example
 819 (%i1) s: "A submarine."$
 820 (%i2) concat( substring(s,1,3),"yellow ",substring(s,3) );
 821 (%o2)                  A yellow submarine.
 822 (%i3) sinsert("hollow ",s,3);
 823 (%o3)                  A hollow submarine.
 824 @end example
 825
 826 @opencatbox
 827 @category{Package stringproc}
 828 @closecatbox
 829
 830 @end deffn
 831
 832 @deffn {関数} sinvertcase (@var{string})
 833 @deffnx {関数} sinvertcase (@var{string}, @var{start})
 834 @deffnx {関数} sinvertcase (@var{string}, @var{start}, @var{end})
 835 位置@var{start}から@var{end}までのそれぞれの文字を逆順にすることを除いて
 836 @var{string}を返します。
 837 もし@var{end}が与えられないなら、
 838 @var{start}から
 839 @var{string}の終わりまでのすべての文字列が置き換えられます。
 840
 841 @c ===beg===
 842 @c sinvertcase("sInvertCase");
 843 @c ===end===
 844 @example
 845 (%i1) sinvertcase("sInvertCase");
 846 (%o1)                      SiNVERTcASE
 847 @end example
 848
 849 @opencatbox
 850 @category{Package stringproc}
 851 @closecatbox
 852
 853 @end deffn
 854
 855 @deffn {関数} slength (@var{string})
 856 @var{string}の中の文字の数を返します。
 857
 858 @opencatbox
 859 @category{Package stringproc}
 860 @closecatbox
 861
 862 @end deffn
 863
 864 @deffn {関数} smake (@var{num}, @var{char})
 865 @var{num}個の文字@var{char}を持つ新しい文字列を返します。
 866
 867 @c ===beg===
 868 @c smake(3,"w");
 869 @c ===end===
 870 @example
 871 (%i1) smake(3,"w");
 872 (%o1)                          www
 873 @end example
 874
 875 @opencatbox
 876 @category{Package stringproc}
 877 @closecatbox
 878
 879 @end deffn
 880
 881 @deffn {関数} smismatch (@var{string_1}, @var{string_2})
 882 @deffnx {関数} smismatch (@var{string_1}, @var{string_2}, @var{test})
 883 @var{string_1}と@var{string_2}が異なる@var{string_1}の最初の文字の位置、または
 884 @code{false}を返します。
 885 マッチングのデフォルトのテスト関数は@code{sequal}です。
 886 もし@code{smismatch}が文字の大小を無視なければいけないなら、
 887 テストとして@code{sequalignore}を使ってください。
 888
 889 @c ===beg===
 890 @c smismatch("seven","seventh");
 891 @c ===end===
 892 @example
 893 (%i1) smismatch("seven","seventh");
 894 (%o1)                           6
 895 @end example
 896
 897 @opencatbox
 898 @category{Package stringproc}
 899 @closecatbox
 900
 901 @end deffn
 902
 903 @deffn {関数} split (@var{string})
 904 @deffnx {関数} split (@var{string}, @var{delim})
 905 @deffnx {関数} split (@var{string}, @var{delim}, @var{multiple})
 906 @var{string}のすべてのトークンのリストを返します。
 907 それぞれのトークンはパースされていない文字列です。
 908 @code{split}は@var{delim}をデリミタとして使います。
 909 もし@var{delim}が与えられないなら、
 910 スペース文字がデフォルトのデリミタです。
 911 @var{multiple}はデフォルトで@code{true}のブーリアン変数です。
 912 重複デリミタが1つとして読まれます。
 913 これは、
 914 もしタブが複数スペース文字として保存されているなら、
 915 役立ちます。
 916 もし@var{multiple}が@code{false}に設定されるなら、
 917 それぞれのデリミタが有効です。
 918
 919 @c ===beg===
 920 @c split("1.2   2.3   3.4   4.5");
 921 @c split("first;;third;fourth",";",false);
 922 @c ===end===
 923 @example
 924 (%i1) split("1.2   2.3   3.4   4.5");
 925 (%o1)                 [1.2, 2.3, 3.4, 4.5]
 926 (%i2) split("first;;third;fourth",";",false);
 927 (%o2)               [first, , third, fourth]
 928 @end example
 929
 930 @opencatbox
 931 @category{Package stringproc}
 932 @closecatbox
 933
 934 @end deffn
 935
 936 @deffn {関数} sposition (@var{char}, @var{string})
 937 @var{string}の中で、@var{char}とマッチする最初の文字の位置を返します。
 938 @var{string}の一番目の文字は位置1にあります。
 939 文字の大小を無視した文字のマッチに関しては，
 940 @code{ssearch}を参照してください。
 941
 942 @opencatbox
 943 @category{Package stringproc}
 944 @closecatbox
 945
 946 @end deffn
 947
 948 @deffn {関数} sremove (@var{seq}, @var{string})
 949 @deffnx {関数} sremove (@var{seq}, @var{string}, @var{test})
 950 @deffnx {関数} sremove (@var{seq}, @var{string}, @var{test}, @var{start})
 951 @deffnx {関数} sremove (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
 952 @var{string}同様文字列を返しますが、
 953 @var{seq}とマッチする部分文字列すべてなしに返します。
 954 マッチのデフォルトのテスト関数は@code{sequal}です。
 955 もし@code{sremove}が@var{seq}を検索する間文字の大小を無視しなければいけないなら、
 956 テストとして@code{sequalignore}を使ってください。
 957 探索を限定するには@var{start}と@var{end}を使ってください。
 958 @var{string}の一番目の文字は位置1にあることに注意してください。
 959
 960 @c ===beg===
 961 @c sremove("n't","I don't like coffee.");
 962 @c sremove ("DO ",%,'sequalignore);
 963 @c ===end===
 964 @example
 965 (%i1) sremove("n't","I don't like coffee.");
 966 (%o1)                   I do like coffee.
 967 (%i2) sremove ("DO ",%,'sequalignore);
 968 (%o2)                    I like coffee.
 969 @end example
 970
 971 @opencatbox
 972 @category{Package stringproc}
 973 @closecatbox
 974
 975 @end deffn
 976
 977 @deffn {関数} sremovefirst (@var{seq}, @var{string})
 978 @deffnx {関数} sremovefirst (@var{seq}, @var{string}, @var{test})
 979 @deffnx {関数} sremovefirst (@var{seq}, @var{string}, @var{test}, @var{start})
 980 @deffnx {関数} sremovefirst (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
 981 @code{seq}とマッチする最初の文字列だけが削除されることを除いて、
 982 @code{sremove}同様です。
 983
 984 @opencatbox
 985 @category{Package stringproc}
 986 @closecatbox
 987
 988 @end deffn
 989
 990 @deffn {関数} sreverse (@var{string})
 991 @var{string}の文字すべてが逆順の文字列を返します。
 992
 993
 994 @opencatbox
 995 @category{Package stringproc}
 996 @closecatbox
 997
 998 @end deffn
 999
1000 @deffn {関数} ssearch (@var{seq}, @var{string})
1001 @deffnx {関数} ssearch (@var{seq}, @var{string}, @var{test})
1002 @deffnx {関数} ssearch (@var{seq}, @var{string}, @var{test}, @var{start})
1003 @deffnx {関数} ssearch (@var{seq}, @var{string}, @var{test}, @var{start}, @var{end})
1004 文字列@var{seq}とマッチする@var{string}の最初の部分文字列の位置を返します。
1005 マッチのためのデフォルトのテスト関数は@code{sequal}です。
1006 もし@code{ssearch}が文字の大小を無視しなければいけないなら、
1007 テストとして@code{sequalignore}を使ってください。
1008 検索を限定するには、@var{start}と@var{end}を使ってください。
1009 @var{string}の一番目の文字は位置1にあることに注意してください。
1010
1011 @example
1012 (%i1) ssearch("~s","~@{~S ~@}~%",'sequalignore);
1013 (%o1)                                  4
1014 @end example
1015
1016 @opencatbox
1017 @category{Package stringproc}
1018 @closecatbox
1019
1020 @end deffn
1021
1022 @deffn {関数} ssort (@var{string})
1023 @deffnx {関数} ssort (@var{string}, @var{test})
1024 @code{test (@var{c}, @var{d})}が@code{false}、かつ、@code{test (@var{d}, @var{c})}が@code{true}であるような2つの連続する文字@var{c}と@var{d}がないような順で
1025 @var{string}の文字すべてを含む文字列を返します。
1026
1027 ソートのためのデフォルトのテスト関数は@var{clessp}です。
1028 テスト関数一式は@code{@{clessp, clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore@}}です。
1029
1030 @c ===beg===
1031 @c ssort("I don't like Mondays.");
1032 @c ssort("I don't like Mondays.",'cgreaterpignore);
1033 @c ===end===
1034 @example
1035 (%i1) ssort("I don't like Mondays.");
1036 (%o1)                    '.IMaddeiklnnoosty
1037 (%i2) ssort("I don't like Mondays.",'cgreaterpignore);
1038 (%o2)                 ytsoonnMlkIiedda.'
1039 @end example
1040
1041 @opencatbox
1042 @category{Package stringproc}
1043 @closecatbox
1044
1045 @end deffn
1046
1047 @deffn {関数} ssubst (@var{new}, @var{old}, @var{string})
1048 @deffnx {関数} ssubst (@var{new}, @var{old}, @var{string}, @var{test})
1049 @deffnx {関数} ssubst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start})
1050 @deffnx {関数} ssubst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start}, @var{end})
1051 @var{string}の中の@var{old}にマッチするすべての部分文字列を
1052 @var{new}で置き換えた文字列を返します。
1053 @var{old}と@var{new}は同じ長さである必要はありません。
1054 マッチのためのデフォルトのテスト関数は@code{sequal}です。
1055 もし@code{ssubst}がoldを検索する間大文字小文字を無視すべきなら、
1056 テストとして@code{sequalignore}を使ってください。
1057 検索を制限するには、@var{start}と@var{end}を使ってください。
1058 @var{string}の一番目の文字は位置1にあることに注意してください。
1059
1060 @c ===beg===
1061 @c ssubst("like","hate","I hate Thai food. I hate green tea.");
1062 @c ssubst("Indian","thai",%,'sequalignore,8,12);
1063 @c ===end===
1064 @example
1065 (%i1) ssubst("like","hate","I hate Thai food. I hate green tea.");
1066 (%o1)          I like Thai food. I like green tea.
1067 (%i2) ssubst("Indian","thai",%,'sequalignore,8,12);
1068 (%o2)         I like Indian food. I like green tea.
1069 @end example
1070
1071 @opencatbox
1072 @category{Package stringproc}
1073 @closecatbox
1074
1075 @end deffn
1076
1077 @deffn {関数} ssubstfirst (@var{new}, @var{old}, @var{string})
1078 @deffnx {関数} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test})
1079 @deffnx {関数} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start})
1080 @deffnx {関数} ssubstfirst (@var{new}, @var{old}, @var{string}, @var{test}, @var{start}, @var{end})
1081 @var{old}とマッチする最初の部分文字列だけを置き換えることを除いて、
1082 @code{subst}と同様です。
1083
1084 @opencatbox
1085 @category{Package stringproc}
1086 @closecatbox
1087
1088 @end deffn
1089
1090 @deffn {関数} strim (@var{seq},@var{string})
1091 @var{string}の両端から@var{seq}に現れるすべての文字を除いた文字列を返します。
1092
1093 @c ===beg===
1094 @c "/* comment */"$
1095 @c strim(" /*",%);
1096 @c slength(%);
1097 @c ===end===
1098 @example
1099 (%i1) "/* comment */"$
1100 (%i2) strim(" /*",%);
1101 (%o2)                        comment
1102 (%i3) slength(%);
1103 (%o3)                           7
1104 @end example
1105
1106 @opencatbox
1107 @category{Package stringproc}
1108 @closecatbox
1109
1110 @end deffn
1111
1112 @deffn {関数} striml (@var{seq}, @var{string})
1113 @var{string}の左端だけトリムすることを除いて
1114 @code{strim}と同様です。
1115
1116 @opencatbox
1117 @category{Package stringproc}
1118 @closecatbox
1119
1120 @end deffn
1121
1122 @deffn {関数} strimr (@var{seq}, @var{string})
1123 @var{string}の右端だけトリムすることを除いて
1124 @code{strim}と同様です。
1125
1126 @opencatbox
1127 @category{Package stringproc}
1128 @closecatbox
1129
1130 @end deffn
1131
1132 @deffn {関数} substring (@var{string}, @var{start})
1133 @deffnx {関数} substring (@var{string}, @var{start}, @var{end})
1134 位置@var{start}で始まり位置@var{end}で終わる
1135 @var{string}の部分文字列を返します。
1136 位置@var{end}の文字は含まれません。
1137 もし@var{end}が与えられないなら、部分文字列は文字列の残りを含みます。
1138 @var{string}の一番目の文字は位置1にあることに注意してください。
1139
1140 @c ===beg===
1141 @c substring("substring",4);
1142 @c substring(%,4,6);
1143 @c ===end===
1144 @example
1145 (%i1) substring("substring",4);
1146 (%o1)                        string
1147 (%i2) substring(%,4,6);
1148 (%o2)                          in
1149 @end example
1150
1151 @opencatbox
1152 @category{Package stringproc}
1153 @closecatbox
1154
1155 @end deffn
1156
1157 @deffn {関数} supcase (@var{string})
1158 @deffnx {関数} supcase (@var{string}, @var{start})
1159 @deffnx {関数} supcase (@var{string}, @var{start}, @var{end})
1160 @var{string}の位置@var{start}から@var{end}までの小文字を対応する大文字に置き換えた
1161 文字列を返します。
1162 もし@var{end}が与えられないなら、
1163 @var{start}から@var{string}の終わりまでのすべての小文字が置き換えられます。
1164
1165 @c ===beg===
1166 @c supcase("english",1,2);
1167 @c ===end===
1168 @example
1169 (%i1) supcase("english",1,2);
1170 (%o1)                        English
1171 @end example
1172
1173 @opencatbox
1174 @category{Package stringproc}
1175 @closecatbox
1176
1177 @end deffn
1178
1179 @deffn {関数} tokens (@var{string})
1180 @deffnx {関数} tokens (@var{string}, @var{test})
1181 @var{string}から抽出されたトークンのリストを返します。
1182 トークンは、文字があるテスト関数を満たす部分文字列です。
1183 もしテストが与えられないなら、
1184 @var{constituent}がデフォルトテストとして使われます。
1185 @code{@{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp@}}はテスト関数一式です。
1186 (The Lisp-version of
1187 @code{tokens}のLispバージョンはPaul Grahamによって書かれました。 ANSI Common Lisp, 1996, page 67.)
1188
1189 @c ===beg===
1190 @c tokens("24 October 2005");
1191 @c tokens("05-10-24",'digitcharp);
1192 @c map(parse_string,%);
1193 @c ===end===
1194 @example
1195 (%i1) tokens("24 October 2005");
1196 (%o1)                  [24, October, 2005]
1197 (%i2) tokens("05-10-24",'digitcharp);
1198 (%o2)                     [05, 10, 24]
1199 (%i3) map(parse_string,%);
1200 (%o3)                      [5, 10, 24]
1201 @end example
1202
1203 @opencatbox
1204 @category{Package stringproc}
1205 @closecatbox
1206
1207 @end deffn