• The added line is THIS COLOR.
• The deleted line is THIS COLOR.
```//[[Documentation]]

*Library Reference

Note: the LMNtal API is under development and its specification
is subject to change.

In the following, arguments with the '+' sign are those consumed upon
reaction with the library atoms, while arguments with the '-' sign are
those generated by the library API.  The slash (/) notation is used to
indicate the arity of atoms.

**Libraty integer
**Library integer

:integer.rnd(+N,-H)|H is bound to a random number between 0 and N-1.
:integer.srnd(+N)|sets N as the seed for random numbers.
:integer.srnd(+N)|Initialize the random number generator using N as the new seed of random numbers.
:integer.of_str(+S,-N)|N is bound to an integer whose string representation is S.
:integer.set(+\$a,+\$b,+\$g)|Creates a (multi)set \$g[\$a], \$g[\$a+1], ..., \$g[\$b].
\$g[X] must be a ground term with one free link X.  For example,
a=integer.set(1,100) will be reduced to a=1, ..., a=100.
:integer.set(+A,+B,+G)|Assume \$a[A] and \$b[B] are of type int and \$g[G] is of type ground.  Then creates a multiset \$g[\$a], \$g[\$a+1], ..., \$g[\$b].
For example, n=integer.set(1,100) will be reduced to n=1, ..., n=100.

**Libraty float

:float.of_str(+S,-N)|N is bound to a floating-point number whose string representation is S.

**Library nlmem

The library nlmem (nonlinear membrane) is used when coping or removing
a cell with free links (i.e., links connected to atoms outside the membrane).  When copying such cells, the free links should be split by inserting ternary
atoms; when removing such cells, the free links should be terminated
by a unary atom.  The library nlmem contains an implementation of
the following rule '''schemes''' that use aggregates:

R=nlmem.copy(X,a), {\$p[X|*Z]} :-
R=copied(X1,X2),
{\$p[X1|*Z1]}, {\$p[X2|*Z2]},
a(*Z1,*Z2,*Z).
nlmem.kill(X,b), {\$p[X|*Z]} :- b(*Z).

They are rule schemes in the sense that '''a''' and '''b''' are metasymbols to be replaced by any symbolic names.

:nlmem.copy(+{'''P'''},+'''a''',-'''R''')|
An abbreviated form of
&color(#8B4513){(nlmem.copy('''R0''','''a''','''R'''), {+'''R0''','''P'''})};.
Creates two copies of the
cell {+'''R0''','''P'''} with all its free links renamed, and
connects '''R''' and the two fresh copies of '''R0''' using
a ternary atom with the name '''a'''.
Furthermore, for each free link '''L''' of the original cell
{+'''R0''', '''P'''} (except '''R0''' that will disappear together with the '+'), nlmem.copy
connects the two fresh copies of '''L''' and
the original '''L''' via the ternary atom '''a'''.
:nlmem.copy(+{'''P'''},-'''R''')|Same as &color(#8B4513){{nlmem.copy({'''P'''},copied,'''R''')};.
:nlmem.kill(+{'''P'''},+'''b''')|
An abbreviated form of
&color(#8B4513){(nlmem.kill('''R0''','''b'''), {+'''R0''','''P'''})};.
Connects each free link '''L''' of the cell
{+'''R0''', '''P'''} (except '''R0''' that will disappear together with the '+') to the unary atom '''b'''.
:nlmem.kill(+{'''P'''})|Same as &color(#8B4513){nlmem.kill({'''P'''},killed)};.

**Library seq

Library seq is to apply sets of rules R&size(10){1};,..., R&size(10){n};
sequentially to a graph G, that is, rules R&size(10){n+1}; are applied
only after rules in R&size(10){n}; becomes non-applicable.

Each set of rules R&size(10){k}; is specified as a cell containing rules,
while the initial graph G is specified as a cell containing G.
For instance,

r=seq.run({a}, [{a:-b}, {b:-c. a:-never.}, {c:-d. b:-never.}])

is reduced to

r={d}

:r=seq.run(+M,+Rs)|M is a cell (called a data cell) and Rs is a list of cells (called rull cells) each containing rules.
Applies rules in Rs to the data cell M sequentially from left to right.
When reaction terminates for the rules in some rule cell, these rules are removed and the rules in the next rule cell are inserted into the data cell.
Stops execution when stop_seq/0 appears in the cell.

**Library io

Input/output in SLIM is done through ports.  An operation on
a port will return a new port to be used for future operations on the port.
A simple program that copies stdin to stdout can be written as:

main.
main :-
loop(S, eof, I, io.stdout).

loop(S, EOF, I, O) :- S == EOF |
io.free_port(I), io.free_port(O).
loop(S0, EOF, I0, O0) :- S0 \== EOF |
io.print_line(O0, S0, O),
loop(S, EOF, I, O).

:io.stdin(-Ret&#x52;ort)| Returns a standard input port.
:io.stdout(-Ret&#x52;ort)| Returns a standard output port.
port Port and returns a new port Ret&#x52;ort.
atom whose name is C) from the input
port Port and returns a new port Ret&#x52;ort.
:io.read_token(+Port,-Ret&#x52;ort,-Str)| Read a token Str separated by a space or newline from the input port Port and returns a new port Ret&#x52;ort.
:io.close_port(+Port,-Ret&#x52;ort)| Close Port and returns it as Ret&#x52;ort.
Further operations on the port will cause an error.
:io.free_port(+Port)|  Frees Port.
:io.print_char(+Port,+C,-Ret&#x52;ort)|  Print the name of an atom C to Port and return a new port Ret&#x52;ort.  The atom name need not necessarily be a single
character.
:io.print(+Port,+Str,-Ret&#x52;ort)| Print a string Str to Port and
return a new port Ret&#x52;ort.
:io.print_newline(+Port,-Ret&#x52;ort)|  Print a newline to Port and
return a new port Ret&#x52;ort.
:io.print_line(+Port,+Str,-Ret&#x52;ort)| Print a string Str and a newline
to Port and return a new port Ret&#x52;ort.
:io.print_mem(+Port,+M,-Ret&#x52;ort)|  Print the content of the membrane M
to Port and return a new port Ret&#x52;ort.
to Port and return a new port Ret&#x52;ort.  The membrane must not have free links other than that linked to this API.
:io.open_output_string(-SRet&#x52;ort)|  Creates a new string output port SRet&#x52;ort.
:io.open_input_string(+Str,-SRet&#x52;ort)|  Creates a new string input port
SRet&#x52;ort consisting of the characters in the string Str.
:io.output_string(+Port,-Ret&#x52;ort,-Str)|  Dumps the current content of the string port Port to Str and returns the port as Ret&#x52;ort (without flushing it).

//**Library io (LMNtal Java)

//:io.popup(+Str)| Displays the string Str in a pop-up window.
//:io.input| Reads an atom name typed into a pop-up window.  The result is a new nullary atom with the given name.
//:io.input(+Atom)| Displays the name of the unary Atom on a pop-up window and reads an atom name typed into the window.
//The result is a two-atom molecule with done/1 and a unary atom with the given name.
//:io.input(+Atom,-X)| Dislays the name of the unary Atom on a pop-up window and reads an atom name typed into the window.
//The result is a two-atom radical with done/2 and a unary atom with the given name, of the form newAtom(Y), done(Y,X).
//:io.inputInteger(+Atom,-X)| Same as above, except that the result is Int(X), where Int is an integer (which is a unary atom in LMNtal) that has been typed in.
//:io.use| Enables the use of standard input (System.in) and standard output (System.out).  The result consists of two molecules representing standard input and standard output.
//:io.readline(-Atom,-Res)| reads one line from standard input, connnecting to Atom a unary atom whose name is the input string (or an empty string if the string can't be read), and connects done/1 or nil/1 to Res, depending on whether the string could be read.  To be used with io.use.
//:io.print(+Atom,-Res)| prints the name of the unary Atom (a string or a non-string atom) into standard output, and connects done/1 to Res.  To be used witn io.use.

```