Summary

###########################################################################

	File:     seqops.icn

	Subject:  Procedures to manipulate T-sequences

	Author:   Ralph E. Griswold

	Date:     June 11, 2001

###########################################################################

  This file is in the public domain.

###########################################################################

  These procedures perform operations related to T-Sequences and to
  analyze T-Sequences.

###########################################################################

  Requires:  Courage.

###########################################################################

   copyl(xargs[])	 copy list of lists
   eval_tree(n)	 evaluate expression tree
   expression_tree(n)	 create expression tree
   fragment(s, i, p, arg)

   get_analysis(s)	 analyze sequence
   get_scollate(s)	 analyze for collation
   get_splace(s)	 analyze for motif along a path
   get_srepeat(s)	 analyze for repeat
   get_srun(s)		 analyze for run
   get_sruns(s)	 analyze for simple runs
   is_scompact(x)	 test sequence for compactness
   pimage(x)
   remod(s, p)
   sanalout()		 output analysis
   sanalysis(x)	 over-all analysis
   sbinop(op, xargs[])	 binary operation on terms
   sbound(xargs[])	 compute sequence upper bound  FIX!
   scollate(xargs[])	 sequence collation
   scompress(xargs[])	 compact sequence
   sconcat(xargs[])	 concatenate sequences
   scpal(xargs[])	 closed sequence palindrome
   sdecimate(xargs[])	 decimate sequence
   sdecollate(order, x) decollate sequence
   sdelta(x)		 get delta sequence
   sdirection(x)	 "direction" of delta(x)
   sequiv(x1, x2)	 test sequence equivalence
   sextend(xargs[])	 extend sequence
   sflatten(x)		 flatten nested sequence
   sground(s, i)	 ground sequence to i
   shaft_period(x1, x2) shaft period
   simage(x, limit)	 string image of sequence
   sinit()		 initialize sequence operations
   slayer(xargs[])	 layer sequences
   slength(x)		 compute sequence length
   slocate(xargs[])	 sequences of first positions of terms
   smap(xargs[])	 map terms in sequence
   smin(xargs[])	 compute sequence lower bound	FIX
   smissing(x)		 missing terms in sequence  BOGUS??
   smod(xargs[])	 modular reduction
   smutate(xargs[])	 mutation
   snormal(x)		 normalize sequence
   sopal(xargs[])	 create open sequence palindrome
   sorder(x)		 positions of first occurrence
   sparity(xargs[])	 adjust parity
   speriod(s)		 sequence period
   splace(xargs[])	 place motif along a path
   splaceg(xargs[])	 generalized motifs along a path
   spositions(x1, x2)	 shaft positions
   spromote(x)		 promote term to sequence
   srandom(x)		 random selection
   sreflecth(xargs[])	 reflect sequence horizontally
   sreflectr(xargs[])
   sreflectv(xargs[])	 reflect sequence vertically
   sremdupl(xargs[])	 remove duplicate adjacent terms
   srepeat(xargs[])	 repeat sequence
   srepl(xargs[])	 replicate sequence terms
   srotatev(xargs[])	 rotate sequence vertically
   srun(xargs[])	 create connected run
   sruns(xargs[])	 create simple runs
   sscale(xargs[])	 scale terms in sequence
   sscollate(xargs[])	 collate entire sequences
   sselect(xargs[])	 select terms from sequence
   sshift(x, i)	 shift terms sequence
   sunmod(x)		 modular expansion
   sunop(op, xargs[])	 unary operation on terms
   walk_tree(n, tree_list, tree_ptrs, depth)
			 walk expression tree

###########################################################################

  Links:  factors, numbers

###########################################################################

This file is part of the (main) package.

copyl(xargs)

: copy list of lists

eval_tree(n)

expression_tree(n)

fragment(s, i, p, arg)

get_analysis(seq)

get_scollate(seq)

: find collation in sequence

get_splace(seq)

: find motif along a path in sequence

get_srepeat(seq)

: find repeat in sequence

get_srun(seq)

get_sruns(seq)

is_scompact(x)

: test sequence for compactness

pimage(s)

 DOES THIS BELONG HERE?

remod(seq, p)

: handle modulus

sanalout()

sanalysis(x)

sbinop(op, xargs)

: binary operation on terms

sbound(xargs)

: compute sequence upper bound  FIX!

scollate(xargs)

: sequence term collation

scompress(xargs)

: compact sequence

sconcat(xargs)

: concatenate sequences

sconstant(seq)

: test for constant sequence

scpal(xargs)

: closed sequence palindrome

sdecimate(xargs)

: decimate sequence

sdecollate(order, x)

: sequence decollation

sdelta(seq)

: sequence delta

sdirection(x)

: sequence delta "direction"

sdistrib(x)

sequiv(x1, x2)

 test for sequence equivalence

sextend(xargs)

: extend sequence

sflatten(s)

 flatten packet sequence  BELONGS HERE?

sground(seq, i)

: ground sequence to i

shaft_period(x1, x2)

: shaft period

simage(x, limit)

: string image of sequence

simageb(seq)

: bracketed sequence image

sinit()

: initialize sequence operations

slayer(xargs)

: layer sequences

slength(x)

: compute sequence length

slocate(xargs)

: sequences of first positions of terms

smap(xargs)

: map terms in sequence

smin(xargs)

: compute sequence lower bound	FIX

smissing(x)

: missing terms in sequence  BOGUS??

smod(xargs)

: modular reduction

smutate(xargs)

: mutation

snormal(x)

: normalize sequence

sopal(xargs)

: create open sequence palindrome

sorder(x)

: positions of first occurrence

sparity(xargs)

: adjust parity

speriod(seq)

: period of sequence

splace(xargs)

: place motif along a path

splaceg(xargs)

: generalized motifs along a path

spositions(x1, x2)

: positions of values in sequence

spromote(x)

: promote term to sequence

srandom(x)

: random selection

sreflecth(xargs)

: reflect sequence horizontally

sreflectr(xargs)

sreflectv(xargs)

: reflect sequence vertically

sremdupl(xargs)

: remove duplicate adjacent terms

srepeat(xargs)

: repeat sequence

srepl(xargs)

 replicate sequence terms

srotatev(xargs)

: rotate sequence vertically

srun(xargs)

: create connected runs

sruns(xargs)

 disconnected runs

sscale(xargs)

: scale terms in sequence

sscollate(xargs)

: entire sequence collation

sselect(xargs)

: select terms from sequence

sshift(x, i)

: shift terms sequence

sunmod(x)

: modular expansion

sunop(op, xargs)

: unary operation on terms

walk_tree(n, tree_list, tree_ptrs, depth)

node(name, seqlist)