モジュール lillib:lists

This module provides various predicates for manipulating lists, such as append and reverse.

バージョン

April 07, 1999

登場したバージョン

July 09, 1998

著者

MITSUISHI Yutaka (mitsuisi@is.s.u-tokyo.ac.jp)

append/3: concatenation of two lists
revappend/3: Concatenation of reversed and original ordered lists
append_list/2: Concatenation of lists
delete/3: remove specified elements from a list
reverse/2: Reverse of a list
last/2: Get the last element of a list
member/2: Get an element of a list
member_e/2: 'equivalent' version of 'member/2'
member_i/2: 'identical' version of 'member/2'
member_s/2: 'subsume' version of 'member/2'
member_sd/2: 'subsumed' version of 'member/2'
memberchk/2: check an item is an element of a list
memberchk_e/2: 'equivalent' version of 'memberchk/2'
memberchk_i/2: 'identical' version of 'memberchk/2'
memberchk_s/2: 'subsume' version of 'memberchk/2'
memberchk_sd/2: 'subsumed' version of 'memberchk/2'
member_2/4: Get the corresponding elements from two lists
fast_member/2: fast version of 'member/2'
fast_member_2/4: fast version of 'member_2/4'
assoc/3: association list
assoc_e/3: 'equivalent' version of 'assoc/3'
assoc_i/3: 'identical' version of 'assoc/3'
remove_duplicates/2: remove duplicated elements from a list
listcommon/3: common part of two lists
flatten_list/2: flatten a list
make_n_list/3: make an n-length list
make_num_list/3: make a list of integers
length/2: length of a list
nth_elem/3: get an n-th element of a list
set_difference/3: get the difference of two sets
set_difference_e/3: 'equivalent' version of 'set_difference/3'
set_difference_i/3: 'identical' version of 'set_difference/3'
input_list/2: Lisp 形式のリストを LiLFeS 形式のリストへ変換する
output_list/2: LiLFeS 形式のリストを Lisp 形式のリストに変換する
dlength/3: length of a difference list
dmember/3: member of a difference list
dmember_2/5: member_2 of a difference list

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

述語

append/3

書式 append(?$L1, ?$L2, ?$L3)

引数

`?$L1`	list	List 1
`?$L2`	list	List 2
`?$L3`	list	Concatenation of List 1 and List 2

This is true when $L3 is the combined list of the elements in $L1 and $L2 in the original orders.

 > ?- append([1, 2, 3], [4, 5], X).
  X: < 1, 2, 3, 4, 5 >

revappend/3

書式 revappend(?$L1, ?$L2, ?$L3)

引数

`?$L1`	list	Reversed list
`?$L2`	list	List
`?$L3`	list	Concatenation

This is true when $L3 is the combined list of the elements in $L1 and $L2, in the reversed order as to $L1 and in the original order as to $L2.

 > ?- revappend([1, 2, 3], [4, 5], X).
  X: < 3, 2, 1, 4, 5 >

append_list/2

書式 append_list(+$LL, -$L)

引数

`+$LL`	list of list	Input lists
`-$L`	list	Concatenation of the lists

This lets $L3 be the combined list of the elements in the elements in $LL.

 > ?- append_list([[1, 2], [3], [4, 5]],X).
  X: < 1, 2, 3, 4, 5 >

delete/3

書式 delete(+$List1, +$Elem, -$List2)

引数

`+$List1`	list	input list
`+$Elem`	bot	an element to be removed
`-$List2`	list	output

This removes elements $Elem from $List and returns to $List2.

 > ?- delete([1, 2, 2, 4, 5], 2, X).
  X: < 1, 4, 5 >

reverse/2

書式 reverse(?$L1, ?$L2)

引数

`?$L1`	list	Original ordered list
`?$L2`	list	Reversed ordered list

This is true when $L1 and $L2 have the same elements but in reversed orders each other.

 > ?- reverse([1, 2, 3, 4], X).
  X: < 4, 3, 2, 1 >

last/2

書式 last(?$L, ?$X)

引数

`?$L`	list	Input list
`?$X`	bot	The last element of the list

This lets $X be the last element in $L.

 > ?- last([1, 2, 3, 4], X).
  X: 4

member/2

書式 member(?$X, +$L)

引数

`?$X`	bot	a list element
`+$L`	list	a list

This is true when $X is unified with an element in $L.

 > ?- member(X, [1, 2, 3]).
  X: 1
  Enter ';' for more choices, otherwise press ENTER --> ;
  X: 2
  Enter ';' for more choices, otherwise press ENTER --> ;
  X: 3
  Enter ';' for more choices, otherwise press ENTER --> ;
  no

member_e/2

書式 member_e(?$X, +$L)

引数

`?$X`	bot	a list element
`+$L`	list	a list

関連項目 member/2

This is true when $X is equivalent to an element in $L.

member_i/2

書式 member_i(?$X, +$L)

引数

`?$X`	bot	a list element
`+$L`	list	a list

関連項目 member/2

This is true when $X is identical to an element in $L.

member_s/2

書式 member_s(?$X, +$L)

引数

`?$X`	bot	a list element
`+$L`	list	a list

関連項目 member/2

This is true when $X subsumes an element in $L.

member_sd/2

書式 member_sd(?$X, +$L)

引数

`?$X`	bot	a list element
`+$L`	list	a list

関連項目 member/2

This is true when $X is subsumed by an element in $L.

memberchk/2

書式 memberchk(+$X, +$L)

引数

`+$X`	bot	a list element
`+$L`	list	a list

関連項目 member/2

This is true when $X is unified with an element in $L. This does not succeeds more than once.

 > ?- memberchk(X, [1, 2, 3, 4]).
  X: 1

memberchk_e/2

書式 memberchk_e(+$X, +$L)

引数

`+$X`	bot	a list element
`+$L`	list	a list

関連項目 memberchk/2

This is true when $X is equivalent to an element in $L. This does not succeeds more than once.

memberchk_i/2

書式 memberchk_i(+$X, +$L)

引数

`+$X`	bot	a list element
`+$L`	list	a list

関連項目 memberchk/2

This is true when $X is identical to an element in $L. This does not succeed more than once.

memberchk_s/2

書式 memberchk_s(+$X, +$L)

引数

`+$X`	bot	a list element
`+$L`	list	a list

関連項目 memberchk/2

This is true when $X subsume an element in $L. This does not succeed more than once.

memberchk_sd/2

書式 memberchk_sd(+$X, +$L)

引数

`+$X`	bot	a list element
`+$L`	list	a list

関連項目 memberchk/2

This is true when $X is subsumed by an element in $L. This does not succeed more than once.

member_2/4

書式 member_2(?$X1, +$L1, ?$X2, +$L2)

引数

`?$X1`	bot	a list element
`+$L1`	list	a list
`?$X2`	bot	a list element
`+$L2`	list	a list

関連項目 member/2

This is true when $X1 and $X2 are unified with an element in $L1 and $L2 respectively. Where $X1 and $X2 are from the heads of $L1 and $L2 must be the same.

 > ?- member_2(X, [1, 2], Y, [4, 5]).
  X: 1
  Y: 4
  Enter ';' for more choices, otherwise press ENTER --> ;
  X: 2
  Y: 5
  Enter ';' for more choices, otherwise press ENTER --> ;
  no

fast_member/2

書式 fast_member(+$L, ?$X)

引数

`+$L`	list	a list
`?$X`	bot	a list element

関連項目 member/2

This is true when $X is unified with an element in $L. This is the same as 'member', but the order of the arguments is changed and this is faster.

 > ?- fast_member([1, 2, 3], X).
  X: 1
  Enter ';' for more choices, otherwise press ENTER --> ;
  X: 2
  Enter ';' for more choices, otherwise press ENTER --> ;
  X: 3
  Enter ';' for more choices, otherwise press ENTER --> ;
  no

fast_member_2/4

書式 fast_member_2(+$L1, ?$X1, +$L2, ?$X2)

引数

`+$L1`	list	list
`?$X1`	bot	list element
`+$L2`	list	list
`?$X2`	bot	list element

assoc/3

書式 assoc(+$X, +$L, -$Y)

引数

`+$X`	bot	key
`+$L`	list of ',/2'	association list
`-$Y`	bot	data

This lets $Y be the second element of the pair whose first element is unified with $X. The 2-element pair (',/2') is the first proper one in $L. This does not succeed more than once.

 > ?- assoc(1, [(1, "a"), (2, "b")], X).
  X: "a"

assoc_e/3

書式 assoc_e(+$X, +$L, -$Y)

引数

`+$X`	bot	key
`+$L`	list of ',/2'	association list
`-$Y`	bot	data

assoc_i/3

書式 assoc_i(+$X, +$L, -$Y)

引数

`+$X`	bot	key
`+$L`	list of ',/2'	association list
`-$Y`	bot	data

remove_duplicates/2

書式 remove_duplicates(+$L1, -$L2)

引数

`+$L1`	list	an original list
`-$L2`	list	output list

This lets $L2 be the result of removing all equivalent duplicate elements in $L1.

 > ?- remove_duplicates([1, 2, 3, 2, 4], X).
  X: < 1, 3, 2, 4 >

listcommon/3

書式 listcommon(+$L1, +$L2, -$L3)

引数

`+$L1`	list	list 1
`+$L2`	list	list 2
`-$L3`	list	common part of the lists

著者 NISHIDA Kenji (nishiken@is.s.u-tokyo.ac.jp)

This lets $L3 be a list of all the elements that have equivalent elements both in $L1 and in $L2.

 > ?- listcommon([1, 2, 3, 4], [5, 4, 3], X).
  X: < 3, 4 >

flatten_list/2

書式 flatten_list(+$L1, -$L2)

引数

`+$L1`	list	input list
`-$L2`	list	output list

This lets $L2 be a flattened list of $L1.

 > ?- flatten_list([1, [2, [3, 4], 5]], X).
  X: < 1, 2, 3, 4, 5 >

make_n_list/3

書式 make_n_list(+$N, +$X, -$L)

引数

`+$N`	integer (>= 0)	length of a list
`+$X`	bot	a list element
`-$L`	list	output

This lets $L be a list whose length is $N and all the elements are equivalent to $X.

 > ?- make_n_list(5, "hoge", X).
  X: < "hoge", "hoge", "hoge", "hoge", "hoge" >

make_num_list/3

書式 make_num_list(+$FROM, +$BEFORE, -$RESULT)

引数

`+$FROM`	integer	a start of a list
`+$BEFORE`	integer	an end of the list
`-$RESULT`	list of integers	output

This lets $RESULT be a list whose elements are the integers from $FROM before $BEFORE.

 > ?- make_num_list(2, 5, X).
  X: < 2, 3, 4 >

length/2

書式 length(+$L, -$N)

引数

`+$L`	list	input list
`-$N`	integer	length of the list

This lets $N be the length of $L.

 > ?- length([3, 3, 3, 3], X).
  X: 4

nth_elem/3

書式 nth_elem(+$LIST, +$N, -$ELEM)

引数

`+$LIST`	list	a list
`+$N`	integer	index
`-$ELEM`	bot	an element of the list

This returns $Nth element of the list $LIST as $ELEM.

 > ?- nth([2, 4, 6, 8], 2, X).
  X: 6

set_difference/3

書式 set_difference(+$Set1, +$Set2, -$Diff)

引数

`+$Set1`	list	Set 1
`+$Set2`	list	Set 2

This returns the elements of $Set1 not included in $Set2.

 > ?- set_difference([1, 2, 3, 4], [6, 4, 2], X).
  X: < 1, 3 >

set_difference_e/3

書式 set_difference_e(+$Set1, +$Set2, -$Diff)

引数

`+$Set1`	list	Set 1
`+$Set2`	list	Set 2

set_difference_i/3

書式 set_difference_i(+$Set1, +$Set2, -$Diff)

引数

`+$Set1`	list	Set 1
`+$Set2`	list	Set 2

input_list/2

書式 input_list(+$STRING, -$LIST)

引数

`+$STRING`	string	Lisp 形式のリスト
`-$LIST`	list	LiLFeS 形式のリスト

output_list/2

書式 output_list(+$LIST, -$STRING)

引数

`+$LIST`	list	LiLFeS 形式のリスト
`-$STRING`	string	Lisp 形式のリスト

dlength/3

書式 dlength(+Head, +Tail, -N)

引数

`+Head`	list
`+Tail`	list
`-N`	integer

Returns the length of the difference list between Head and Tail.

dmember/3

書式 dmember(+LHead, +LTail, ?E)

引数

`+LHead`		head of the difference list
`+LTail`		tail (end) of the difference list
`?E`		the element to search for

as with member, but searches in a difference list given by 'LHead' and 'LTail'

dmember_2/5

書式 dmember_2(+L1Head, +L1Tail, ?E1, +L2, ?E2)

引数

`+L1Head`		head of the first list (difference list)
`+L1Tail`		tail (end) of the first list
`?E1`		the element to search for in the first list
`+L2`		second list
`?E2`		the element to search for in the second list

as 'fast_member_2', but the first list is considered a difference list It is not necessary to give the 2nd list as difference list as well, as both lists are processed in tandem.

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

コメントはこちら:

MITSUISHI Yutaka (mitsuisi@is.s.u-tokyo.ac.jp)

This document is automatically created by lildoc on Fri Sep 24 14:14:00 2004