モジュール fsmanip

素性構造を操作するための述語です．

目次

述語

Top of this page Contents Index of this package LiLFeS Documents LiLFeS Home Page Tsujii laboratory

述語

copy/2

書式copy(+$S1, -$S2)
引数
+$S1bot 素性構造1
-$S2bot 素性構造2
素性構造S1をヒープ上でコピーしてS2に入れます。 S1 = S2 と、単一化によって代入する場合と違って、構造共有が起こりません。 
> ?- X = person, X = Y.
 X: [$1] person
 Y: [$1] ...
 > ?- X = person, copy(X, Y).
 X: person
 Y: person

normalize/2

書式normalize(+$S1, -$S2)
引数
+$S1bot Feature structure1
-$S2bot Feature structure2
注意第２引数は bot でなければなりません．
素性構造 $S1 を正規化して $S2 にコピーします． コピーした素性構造にたいして，'b_copy/2' や 'recopy' を使うことが出来ます．

canonical_copy/2

書式canonical_copy(+$S1, -$S2)
引数
+$S1bot Feature structure1
-$S2bot Feature structure2
素性構造 $S1 を $S2 にコピーします．素性の値がすべて デフォルト値の素性構造は正規化されて atom に変換します．

unifiable/2

書式unifiable(+$A, +$B)
引数
+$Abot
+$Bbot
$A と $B が単一化可能なときにこの述語は成功します． この述語を実行した後，$A と $B は書きかえられません．

isshared/2

書式isshared(+S1, +S2)
引数
+S1bot 素性構造１
+S2bot 素性構造２
２つの素性構造の間に構造共有がある時に成功します。 
> ?- X = NAME\"John", Y = FATHER\X, isshared(X,Y).
 　
 |~person       ~|
 X: [$1] | NAME:"John"   |
 | AGE:integer   |
 |_FATHER:person_|
 |~person         ~|
 Y: | NAME:string     |
 | AGE:integer     |
 |_FATHER:[$1] ..._|

isnotshared/2

書式isnotshared(+S1, +S2)
引数
+S1bot 素性構造１
+S2bot 素性構造２
２つの素性構造の間に構造共有がない時に成功します。 
> ?- X = NAME\"John", Y = FATHER\X, isnotshared(X,Y).
 no

recopy/2

書式recopy(+S1, -S2)
引数
+S1bot 素性構造１
-S2bot 素性構造２
素性構造S1をS2へコピーします。 ただし素性構造1がヒープ上で一塊になっていなくてはいけません．コピーの後などに更にコピーする場合に使えます．

b_equiv/2

書式b_equiv(+S1, +S2)
引数
+S1bot 素性構造１
+S2bot 素性構造２
２つの素性構造が同等であれば成功します。

identical/2

書式identical(+FS1,+FS2)
２つの素性構造FS1とFS2が構造共有している場合に成功します。
> ?- X = person & AGE\10, X = Y, identical(X,Y). 
 　
 |~person       ~|
 X: [$1] | NAME:string   |
 | AGE:10        |
 |_FATHER:person_|
 　
 > ?- identical(person & AGE\10, person & AGE\10).
 no

not_identical/2

書式not_identical(+$FS1, +$FS2)
引数
+$FS1bot
+$FS2bot
素性構造 $FS1 と $FS2 が identical でないときに成功します．

is_integer/1

書式is_integer(+T)
引数
+Tbot型
入力が整数であれば成功します。 
> ?- is_integer(5).
 yes

is_string/1

書式is_string(+T)
引数
+Tbot型
入力が文字列であれば成功します。 
> ?- is_string("abc").
 yes

is_float/1

書式is_float(+T)
引数
+Tbot型
入力が実数であれば成功します。 
> ?- is_float(-5.3).
 yes

have_child/1

書式have_child(+S)
Sが子を持てば（＝nodeであれば）成功します。

have_no_child/1

書式have_no_child(+S)
Sが子を持っていなければ（＝leafであれば）成功します。

compound/1

書式compound(+S)
Sが子を持てば（＝nodeであれば）成功します。

simple/1

書式simple(+S)
Sが子を持っていなければ（＝leafであれば）成功します。

follow/3

書式follow(+S1, +L, ?S2)
引数
+S1bot 素性構造
+Lfeature or list 素性のパスを表すリスト (パスの長さが1の場合、直接素性を記述してもかまいません)
?S2bot 結果の素性構造
注意+L は、最も上の階層の素性を指定する他に、下の階層の素性（素性の型の持つ素性など）のパスをリストとして指定することができます。いずれの場合も、素性名には \が必要です。
素性構造S1のパスLをたどった結果を取得してS2として返します。
> ?- follow(a & F1\n ,F1\ ,X).
 X: n
 > ?- follow([a, b, c], [tl\, hd\], X).
 X: b 
 　
 上の例は、?- a & F1\n = F1\X. や ?- [a,b,c] = tl\hd\X. と等価ですが、実際は L の部分を type_featurelist で取得した素性にしたりして使えます。

follow_if_exists/3

書式follow_if_exists(+S1, +L, ?S2)
引数
+S1bot 素性構造
+Lfeature or list 素性のパスを表すリスト (パスの長さが1の場合、直接素性を記述してもかまいません)
?S2bot 結果の素性構造
注意+L は、最も上の階層の素性を指定する他に、下の階層の素性（素性の型の持つ素性など）のパスをリストとして指定することができます。いずれの場合も、素性名には \が必要です。
素性構造S1のパスLをたどった結果を取得してS2として返します。ただしF1にパスLがない場合は失敗します。 
> ?- follow_if_exists([a|_], [tl\, hd\], X).
 no

restriction/2

書式restriction($S, +F)
引数
$Sbot ：素性構造
素性構造の指定された素性を消去（最汎の型に変更）します。 
> ?- X = NAME\"John" & AGE\10 & FATHER\(NAME\"Tom" & AGE\40), restriction(X,FATHER\). 
 |~person       ~|
 X: | NAME:"John"   |
 | AGE:10        |
 |_FATHER:person_|

overwrite/3

書式overwrite($S, +F, $T)
引数
$Sbot ：素性構造
$Tbot 素性構造
素性構造の指定された素性を上書きします。 
> ?- X = NAME\"John" & AGE\10 & FATHER\(NAME\"Tom" & AGE\40), restriction(X,FATHER\). 
 |~person               ~|
 | NAME:"John"           |
 X: | AGE:10                |
 |        |~person    ~| |
 | FATHER:| NAME:"Bob" | |
 |_       |_AGE:40    _|_|

subnodelist/2

書式subnodelist(+S, -L)
引数
+Sbot 素性構造
-Llist 結果のリスト
素性構造の子ノードの一覧をリストとして得ます。直接の子ノードだけでなく、さらに下のノードも一列にリストにします。 
> ?- subnodelist(person & Name\"Mary",X)
 |~person            ~|                                          
 | NAME:[$1] "Jack"   |                                          
 X: < | AGE:[$2] integer   |, [$1] ..., [$2] ..., [$3] ..., [$4] ... >
 | FATHER:[$3] person |                                          
 |_MOTHER:[$4] person_|

subnodelist_count/2

書式subnodelist_count(+S, -L)
引数
+Sbot 素性構造
-Llist 結果のリスト
subnodelist の出力の要素に、辿った回数を付加したリストを返します。

sharednodelist/2

書式sharednodelist(+S, -L)
引数
+Sbot 素性構造
-Llist 結果のリスト
素性構造のうち、構造共有しているノードをリストとして得ます。 
> ?- A = ( p(X,Y) :- q(X,Z), r(Z,Y) ), sharednodelist(A, B).
 |~:-/2                                          ~|
 |       |~p/2          ~|                        |
 | chead:| arg1:[$1] bot |                        |
 A: |       |_arg2:[$2] bot_|                        |
 |         |~q/2          ~|  |~r/2          ~|   |
 | cbody:< | arg1:[$1] ... |, | arg1:[$3] ... | > |
 |_        |_arg2:[$3] bot_|  |_arg2:[$2] ..._|  _|
 B: < [$1] ..., [$2] ..., [$3] ... >
 　
 上の例のように、変数リストの取得に使うことができます。但し、Singletonの変数は、構造共有が置きないため、リストに加えられることがないことに注意して下さい。

contains/2

書式contains(+S1, +S2)
引数
+S1bot 素性構造１
+S2bot 素性構造２
素性構造S1の中でS2を構造共有していれば成功します。 
> ?- N = "John", X = NAME\N & FATHER\NAME\N , contains(X,N).
 （成功して、XとNの値が返る） 
 > ?- X = NAME\"John" & FATHER\NAME\"John" , contains(X,N).
 no 
 　
 例のように、値が同じでも構造共有していなければ失敗します。
 S1の中に変数S2があるかどうかを調べるのに使うことができます。

is_cyclic/1

書式is_cyclic(+S)
引数
+Sbot 素性構造
素性構造Sがサイクルをもっていれば成功します。

equivalent/2

書式equivalent(+S1, +S2)
引数
+S1bot 素性構造１
+S2bot 素性構造２
２つの素性構造が完全に等しい場合に成功します。 
> ?- equivalent(person & AGE\10, person & NAME\"Mary").
 no

not_equivalent/2

書式not_equivalent(+$FS1, +$FS2)
引数
+$FS1bot
+$FS2bot
This is true when $FS1 and $FS2 are not equivalent.

subsume/2

書式subsume(+S1, +S2)
引数
+S1bot 素性構造１
+S2bot 素性構造２
注意type_subsumeとの違いは、素性の中まで調べることです。
素性構造S1が素性構造S2を包摂するなら成功。 
> ?- subsume(person & AGE\10, person)
 no
 > ?- subsume(person, person & AGE\10)
 yes

type_equal/2

書式type_equal(+FS1, +FS2)
２つの素性構造のうち、型の部分が等しいなら成功します。 
> ?- type_equal(foo & F1\a, foo & F1\b).
 yes

type_subsume/2

書式type_subsume(+TYPE1, +TYPE2)
引数
+TYPE1bot 型（素性構造）１
+TYPE2bot 型（素性構造）２
TYPE1がTYPE2を包摂する（TYPE1はTYPE2を汎化したもの）なら成功。 
> ?- type_subsume(list, nil).
 yes
 > ?- type_subsume(nil, list).
 no

type_toptype/2

書式type_toptype(+FS, -TYPE)
引数
+FSbot 素性構造
-TYPEbot 素性構造の型
素性構造のうち、型だけを取り出します。 
> ?- type_toptype(競走馬 & 系統\'Hail to Reason',X).
 X: 競走馬
 > ?- type_toptype(p(a,b,c),X).
 X: p/3

type_copy/2

書式type_copy(+$FS, -$TYPE)
引数
+$FSbot
-$TYPEbot
This lets the value of $TYPE be the type of $FS. $FS の型を $TYPE にコピーします．

type_extendable/1

書式type_extendable(+TYPE)
他のモジュールでその型のsubtypeが定義できれば成功します．

type_unify/3

書式type_unify(+TYPE1, +TYPE2, -RESULT)
引数
+TYPE1bot 型（素性構造）１
+TYPE2bot 型（素性構造）２
-RESULTbot 型のみの単一化の結果
TYPE1とTYPE2を単一化したものを RESULTに返します。 
> ?- type_unify(長方形, 菱形, X).
 X: 正方形

type_common/3

書式type_common(+FS1, +FS2, +FS3)
引数
+FS1bot 素性構造１
+FS2bot 素性構造３
FS1とFS2とFS3が同じ型であれば成功します．

type_nfeature/2

書式type_nfeature(+TYPE, -NUM)
引数
+TYPEbot 型（素性構造）
-NUMinteger 素性の数
TYPE がいくつ素性を持つかを返します。 
> ?- type_nfeature(cons, N).
 N : 2

type_featurelist/2

書式type_featurelist(+TYPE, -LIST)
引数
+TYPEbot 型（素性構造）
-LISTlist 素性のリスト
TYPE の持つ素性をリストとして返します。 
> a <- [bot] + [F\].
 > b <- [a] + [G\].
 > c <- [a] + [H\].
 > d <- [b,c]+ [J\].
 > ?- type_featurelist(d, L).
 L: < F\, G\, H\, J\ >

type_havefeature/2

書式type_havefeature(+TYPE, +FEATURE)
引数
+TYPEbot 型（素性構造）
+FEATUREfeature 素性
注意FEATURE には必ず \ を付けて下さい。
TYPE が 素性として FEATURE を持つなら成功します。 
> ?- type_havefeature(フラッシュ, スート\).
 yes

type_subtypes/2

書式type_subtypes(+TYPE, -LIST)
引数
+TYPEbot 型（素性構造）
-LISTlist subtypeのリスト
TYPE のsubtypeの一覧をリストとして得ます。子だけでなく、全ての子孫が含まれます。 
> ?- type_subtypes(三角形, L).
 L : < 三角形, 二等辺三角形, 直角三角形, 直角二等辺三角形, 正三角形 > 
 > ?- type_subtypes(bot, L).
 L : （起動直後に実行すると、全ての組み込み型を表示）

type_nsubtypes/2

書式type_nsubtypes(+TYPE, -NUM)
引数
+TYPEbot 型（素性構造）
-NUMinteger subtypeの数
TYPE にいくつsubtypeがあるかを返します．

type_supertypes/2

書式type_supertypes(+TYPE, -LIST)
引数
+TYPEbot 型（素性構造）
-LISTlist supertypeのリスト
TYPE のsupertypeの一覧をリストとして得ます。親だけでなく、全ての祖先が含まれます。 
> ?- type_supertypes(正方形, L).
 L : < 正方形, 長方形, 凧形, 平行四辺形, 四角形, bot >

type_nsupertypes/2

書式type_nsupertypes(+TYPE, -NUM)
引数
+TYPEbot 型（素性構造）
-NUMinteger supertypeの数
TYPE にいくつsupertypeがあるかを返します．

type_unifiables/2

書式type_unifiables(+TYPE, -LIST)
引数
+TYPEbot 型（素性構造）
-LISTlist unufy可能な型のリスト
TYPE にunify可能な型のリストを取得します．

type_nunifiables/2

書式type_nunifiables(+TYPE, -NUM)
引数
+TYPEbot 型（素性構造）
-NUMinteger unify可能な型の数
TYPE にいくつunify可能な型があるかを返します．

type_directsubtypes/2

書式type_directsubtypes(+TYPE, -LIST)
引数
+TYPEbot 型（素性構造）
-LISTlist 直接のsubtypeのリスト
TYPE のsubtypeの一覧をリストとして得ます。親だけでなく、全ての祖先が含まれます。 
> ?- type_directsubtypes(pred/3, L).
 L: < pred/4, findall/3, commonpart/3, add_to_array/3, read_array/3, +/3, -/3,  //3, ///3, mod/3, follow/3, intersectionlist/3, type_unify/3 >

type_directsupertypes/2

書式type_directsupertypes(+TYPE, -LIST)
引数
+TYPEbot 型（素性構造）
-LISTlist 直接のsupertypeのリスト
TYPE のsupertypeの一覧をリストとして得ます。親だけでなく、全ての祖先が含まれます。 
> ?- type_directsupertypes(直角二等辺三角形, L).
 L : < 二等辺三角形, 直角三角形 >

fs_compare/3

書式fs_compare(+FS1,+FS2,-$Result)
引数
+FS1bot 素性構造1
+FS2bot 素性構造2
-$Result素性構造1と2の順序 (-1, 0, 1)
素性構造間の全順序を定義します．
Top of this page Contents Index of this package LiLFeS Documents LiLFeS Home Page Tsujii laboratory
This document is automatically created by lildoc on Fri Sep 24 14:13:59 2004