diff --git a/changelog b/changelog index 101d2dc..c36de76 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,6 @@ +20080218 tpd src/algebra/tree.spad add function examples +20080218 tpd src/algebra/bags.spad add function examples +20080218 tpd src/algebra/array2.spad add function examples 20080218 tpd src/algebra/array1.spad add function examples 20080218 tpd src/algebra/fr.spad add function examples 20080217 wxh src/interp/i-intern.boot upload proper file. diff --git a/src/algebra/array2.spad.pamphlet b/src/algebra/array2.spad.pamphlet index 38f6ba0..e6a8b7a 100644 --- a/src/algebra/array2.spad.pamphlet +++ b/src/algebra/array2.spad.pamphlet @@ -10,6 +10,15 @@ \tableofcontents \eject \section{category ARR2CAT TwoDimensionalArrayCategory} +TwoDimensionalArrayCategory is a general array category which +allows different representations and indexing schemes. +Rows and columns may be extracted with rows returned as objects +of type Row and columns returned as objects of type Col. +The index of the 'first' row may be obtained by calling the +function 'minRowIndex'. The index of the 'first' column may +be obtained by calling the function 'minColIndex'. The index of +the first element of a 'Row' is the same as the index of the +first column in an array and vice versa. <>= )abbrev category ARR2CAT TwoDimensionalArrayCategory ++ Two dimensional array categories and domains @@ -20,105 +29,190 @@ ++ Examples: ++ References: TwoDimensionalArrayCategory(R,Row,Col): Category == Definition where - ++ TwoDimensionalArrayCategory is a general array category which - ++ allows different representations and indexing schemes. - ++ Rows and columns may be extracted with rows returned as objects - ++ of type Row and columns returned as objects of type Col. - ++ The index of the 'first' row may be obtained by calling the - ++ function 'minRowIndex'. The index of the 'first' column may - ++ be obtained by calling the function 'minColIndex'. The index of - ++ the first element of a 'Row' is the same as the index of the - ++ first column in an array and vice versa. - R : Type - Row : FiniteLinearAggregate R - Col : FiniteLinearAggregate R + R : Type + Row : FiniteLinearAggregate R + Col : FiniteLinearAggregate R - Definition == HomogeneousAggregate(R) with + Definition == HomogeneousAggregate(R) with - shallowlyMutable - ++ one may destructively alter arrays + shallowlyMutable + ++ one may destructively alter arrays - finiteAggregate - ++ two-dimensional arrays are finite + finiteAggregate + ++ two-dimensional arrays are finite --% Array creation - new: (NonNegativeInteger,NonNegativeInteger,R) -> % - ++ new(m,n,r) is an m-by-n array all of whose entries are r - fill_!: (%,R) -> % - ++ fill!(m,r) fills m with r's + new: (NonNegativeInteger,NonNegativeInteger,R) -> % + ++ new(m,n,r) is an m-by-n array all of whose entries are r + ++ + ++E arr : ARRAY2 INT := new(5,4,0) + + fill_!: (%,R) -> % + ++ fill!(m,r) fills m with r's + ++ + ++E arr : ARRAY2 INT := new(5,4,0) + ++E fill!(arr,10) --% Size inquiries - minRowIndex : % -> Integer - ++ minRowIndex(m) returns the index of the 'first' row of the array m - maxRowIndex : % -> Integer - ++ maxRowIndex(m) returns the index of the 'last' row of the array m - minColIndex : % -> Integer - ++ minColIndex(m) returns the index of the 'first' column of the array m - maxColIndex : % -> Integer - ++ maxColIndex(m) returns the index of the 'last' column of the array m - nrows : % -> NonNegativeInteger - ++ nrows(m) returns the number of rows in the array m - ncols : % -> NonNegativeInteger - ++ ncols(m) returns the number of columns in the array m + minRowIndex : % -> Integer + ++ minRowIndex(m) returns the index of the 'first' row of the array m + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E minRowIndex(arr) + + maxRowIndex : % -> Integer + ++ maxRowIndex(m) returns the index of the 'last' row of the array m + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E maxRowIndex(arr) + + minColIndex : % -> Integer + ++ minColIndex(m) returns the index of the 'first' column of the array m + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E minColIndex(arr) + + maxColIndex : % -> Integer + ++ maxColIndex(m) returns the index of the 'last' column of the array m + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E maxColIndex(arr) + + nrows : % -> NonNegativeInteger + ++ nrows(m) returns the number of rows in the array m + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E nrows(arr) + + ncols : % -> NonNegativeInteger + ++ ncols(m) returns the number of columns in the array m + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E ncols(arr) --% Part extractions - elt: (%,Integer,Integer) -> R - ++ elt(m,i,j) returns the element in the ith row and jth - ++ column of the array m - ++ error check to determine if indices are in proper ranges - qelt: (%,Integer,Integer) -> R - ++ qelt(m,i,j) returns the element in the ith row and jth - ++ column of the array m - ++ NO error check to determine if indices are in proper ranges - elt: (%,Integer,Integer,R) -> R - ++ elt(m,i,j,r) returns the element in the ith row and jth - ++ column of the array m, if m has an ith row and a jth column, - ++ and returns r otherwise - row: (%,Integer) -> Row - ++ row(m,i) returns the ith row of m - ++ error check to determine if index is in proper ranges - column: (%,Integer) -> Col - ++ column(m,j) returns the jth column of m - ++ error check to determine if index is in proper ranges - parts: % -> List R - ++ parts(m) returns a list of the elements of m in row major order + elt: (%,Integer,Integer) -> R + ++ elt(m,i,j) returns the element in the ith row and jth + ++ column of the array m + ++ error check to determine if indices are in proper ranges + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E elt(arr,1,1) + + qelt: (%,Integer,Integer) -> R + ++ qelt(m,i,j) returns the element in the ith row and jth + ++ column of the array m + ++ NO error check to determine if indices are in proper ranges + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E qelt(arr,1,1) + + elt: (%,Integer,Integer,R) -> R + ++ elt(m,i,j,r) returns the element in the ith row and jth + ++ column of the array m, if m has an ith row and a jth column, + ++ and returns r otherwise + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E elt(arr,1,1,6) + ++E elt(arr,1,10,6) + + row: (%,Integer) -> Row + ++ row(m,i) returns the ith row of m + ++ error check to determine if index is in proper ranges + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E row(arr,1) + + column: (%,Integer) -> Col + ++ column(m,j) returns the jth column of m + ++ error check to determine if index is in proper ranges + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E column(arr,1) + + parts: % -> List R + ++ parts(m) returns a list of the elements of m in row major order + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E parts(arr) --% Part assignments - setelt: (%,Integer,Integer,R) -> R - -- will become setelt_! - ++ setelt(m,i,j,r) sets the element in the ith row and jth - ++ column of m to r - ++ error check to determine if indices are in proper ranges - qsetelt_!: (%,Integer,Integer,R) -> R - ++ qsetelt!(m,i,j,r) sets the element in the ith row and jth - ++ column of m to r - ++ NO error check to determine if indices are in proper ranges - setRow_!: (%,Integer,Row) -> % - ++ setRow!(m,i,v) sets to ith row of m to v - setColumn_!: (%,Integer,Col) -> % - ++ setColumn!(m,j,v) sets to jth column of m to v + setelt: (%,Integer,Integer,R) -> R + -- will become setelt_! + ++ setelt(m,i,j,r) sets the element in the ith row and jth + ++ column of m to r + ++ error check to determine if indices are in proper ranges + ++ + ++E arr : ARRAY2 INT := new(5,4,0) + ++E setelt(arr,1,1,17) + + qsetelt_!: (%,Integer,Integer,R) -> R + ++ qsetelt!(m,i,j,r) sets the element in the ith row and jth + ++ column of m to r + ++ NO error check to determine if indices are in proper ranges + ++ + ++E arr : ARRAY2 INT := new(5,4,0) + ++E qsetelt!(arr,1,1,17) + + setRow_!: (%,Integer,Row) -> % + ++ setRow!(m,i,v) sets to ith row of m to v + ++ + ++E T1:=TwoDimensionalArray Integer + ++E arr:T1:= new(5,4,0) + ++E T2:=OneDimensionalArray Integer + ++E arow:=construct([1,2,3,4]::List(INT))$T2 + ++E setRow!(arr,1,arow)$T1 + + setColumn_!: (%,Integer,Col) -> % + ++ setColumn!(m,j,v) sets to jth column of m to v + ++ + ++E T1:=TwoDimensionalArray Integer + ++E arr:T1:= new(5,4,0) + ++E T2:=OneDimensionalArray Integer + ++E acol:=construct([1,2,3,4,5]::List(INT))$T2 + ++E setColumn!(arr,1,acol)$T1 --% Map and Zip - map: (R -> R,%) -> % - ++ map(f,a) returns \spad{b}, where \spad{b(i,j) = f(a(i,j))} for all \spad{i, j} - map_!: (R -> R,%) -> % - ++ map!(f,a) assign \spad{a(i,j)} to \spad{f(a(i,j))} for all \spad{i, j} - map:((R,R) -> R,%,%) -> % - ++ map(f,a,b) returns \spad{c}, where \spad{c(i,j) = f(a(i,j),b(i,j))} - ++ for all \spad{i, j} - map:((R,R) -> R,%,%,R) -> % - ++ map(f,a,b,r) returns \spad{c}, where \spad{c(i,j) = f(a(i,j),b(i,j))} when both - ++ \spad{a(i,j)} and \spad{b(i,j)} exist; - ++ else \spad{c(i,j) = f(r, b(i,j))} when \spad{a(i,j)} does not exist; - ++ else \spad{c(i,j) = f(a(i,j),r)} when \spad{b(i,j)} does not exist; - ++ otherwise \spad{c(i,j) = f(r,r)}. - - add + map: (R -> R,%) -> % + ++ map(f,a) returns \spad{b}, where \spad{b(i,j) = f(a(i,j))} + ++ for all \spad{i, j} + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E map(-,arr) + ++E map((x +-> x + x),arr) + + map_!: (R -> R,%) -> % + ++ map!(f,a) assign \spad{a(i,j)} to \spad{f(a(i,j))} for all \spad{i, j} + ++ + ++E arr : ARRAY2 INT := new(5,4,10) + ++E map!(-,arr) + + map:((R,R) -> R,%,%) -> % + ++ map(f,a,b) returns \spad{c}, where \spad{c(i,j) = f(a(i,j),b(i,j))} + ++ for all \spad{i, j} + ++ + ++E adder(a:Integer,b:Integer):Integer == a+b + ++E arr : ARRAY2 INT := new(5,4,10) + ++E map(adder,arr,arr) + + map:((R,R) -> R,%,%,R) -> % + ++ map(f,a,b,r) returns \spad{c}, where \spad{c(i,j) = f(a(i,j),b(i,j))} + ++ when both \spad{a(i,j)} and \spad{b(i,j)} exist; + ++ else \spad{c(i,j) = f(r, b(i,j))} when \spad{a(i,j)} does not exist; + ++ else \spad{c(i,j) = f(a(i,j),r)} when \spad{b(i,j)} does not exist; + ++ otherwise \spad{c(i,j) = f(r,r)}. + ++ + ++E adder(a:Integer,b:Integer):Integer == a+b + ++E arr1 : ARRAY2 INT := new(5,4,10) + ++E arr2 : ARRAY2 INT := new(3,3,10) + ++E map(adder,arr1,arr2,17) + + add --% Predicates @@ -276,12 +370,12 @@ TwoDimensionalArrayCategory(R,Row,Col): Category == Definition where @ \section{domain IIARRAY2 InnerIndexedTwoDimensionalArray} +This is an internal type which provides an implementation of +2-dimensional arrays as PrimitiveArray's of PrimitiveArray's. <>= )abbrev domain IIARRAY2 InnerIndexedTwoDimensionalArray InnerIndexedTwoDimensionalArray(R,mnRow,mnCol,Row,Col):_ Exports == Implementation where - ++ This is an internal type which provides an implementation of - ++ 2-dimensional arrays as PrimitiveArray's of PrimitiveArray's. R : Type mnRow, mnCol : Integer Row : FiniteLinearAggregate R @@ -363,18 +457,18 @@ InnerIndexedTwoDimensionalArray(R,mnRow,mnCol,Row,Col):_ @ \section{domain IARRAY2 IndexedTwoDimensionalArray} +An IndexedTwoDimensionalArray is a 2-dimensional array where +the minimal row and column indices are parameters of the type. +Rows and columns are returned as IndexedOneDimensionalArray's with +minimal indices matching those of the IndexedTwoDimensionalArray. +The index of the 'first' row may be obtained by calling the +function 'minRowIndex'. The index of the 'first' column may +be obtained by calling the function 'minColIndex'. The index of +the first element of a 'Row' is the same as the index of the +first column in an array and vice versa. <>= )abbrev domain IARRAY2 IndexedTwoDimensionalArray IndexedTwoDimensionalArray(R,mnRow,mnCol):Exports == Implementation where - ++ An IndexedTwoDimensionalArray is a 2-dimensional array where - ++ the minimal row and column indices are parameters of the type. - ++ Rows and columns are returned as IndexedOneDimensionalArray's with - ++ minimal indices matching those of the IndexedTwoDimensionalArray. - ++ The index of the 'first' row may be obtained by calling the - ++ function 'minRowIndex'. The index of the 'first' column may - ++ be obtained by calling the function 'minColIndex'. The index of - ++ the first element of a 'Row' is the same as the index of the - ++ first column in an array and vice versa. R : Type mnRow, mnCol : Integer Row ==> IndexedOneDimensionalArray(R,mnCol) @@ -883,7 +977,6 @@ TwoDimensionalArray(R):Exports == Implementation where --SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. @ <<*>>= -<> <> <> diff --git a/src/algebra/bags.spad.pamphlet b/src/algebra/bags.spad.pamphlet index 32f07cf..65efc9e 100644 --- a/src/algebra/bags.spad.pamphlet +++ b/src/algebra/bags.spad.pamphlet @@ -31,6 +31,9 @@ Stack(S:SetCategory): StackAggregate S with stack: List S -> % ++ stack([x,y,...,z]) creates a stack with first (top) ++ element x, second element y,...,and last element z. + ++ + ++E a:Stack INT:= stack [1,2,3,4,5] + == add Rep := Reference List S s = t == deref s = deref t @@ -77,6 +80,9 @@ ArrayStack(S:SetCategory): StackAggregate(S) with arrayStack: List S -> % ++ arrayStack([x,y,...,z]) creates an array stack with first (top) ++ element x, second element y,...,and last element z. + ++ + ++E c:ArrayStack INT:= arrayStack [1,2,3,4,5] + == add Rep := IndexedFlexibleArray(S,0) @@ -127,6 +133,9 @@ Queue(S:SetCategory): QueueAggregate S with queue: List S -> % ++ queue([x,y,...,z]) creates a queue with first (top) ++ element x, second element y,...,and last (bottom) element z. + ++ + ++E e:Queue INT:= queue [1,2,3,4,5] + == Stack S add Rep := Reference List S lastTail==> LAST$Lisp @@ -171,6 +180,9 @@ Dequeue(S:SetCategory): DequeueAggregate S with dequeue: List S -> % ++ dequeue([x,y,...,z]) creates a dequeue with first (top or front) ++ element x, second element y,...,and last (bottom or back) element z. + ++ + ++E g:Dequeue INT:= dequeue [1,2,3,4,5] + == Queue S add Rep := Reference List S bottom_! d == @@ -363,6 +375,9 @@ Heap(S:OrderedSet): Exports == Implementation where heap : List S -> % ++ heap(ls) creates a heap of elements consisting of the ++ elements of ls. + ++ + ++E i:Heap INT := heap [1,6,3,7,5,2,4] + Implementation == IndexedFlexibleArray(S,0) add Rep := IndexedFlexibleArray( S,0) empty() == empty()$Rep @@ -450,7 +465,6 @@ Heap(S:OrderedSet): Exports == Implementation where --SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. @ <<*>>= -<> <> <> diff --git a/src/algebra/tree.spad.pamphlet b/src/algebra/tree.spad.pamphlet index 573f7f8..0a208e0 100644 --- a/src/algebra/tree.spad.pamphlet +++ b/src/algebra/tree.spad.pamphlet @@ -30,23 +30,53 @@ Tree(S: SetCategory): T==C where finiteAggregate shallowlyMutable tree: (S,List %) -> % - ++ tree(nd,ls) creates a tree with value nd, and children - ++ ls. + ++ tree(nd,ls) creates a tree with value nd, and children ls. + ++ + ++E t1:=tree [1,2,3,4] + ++E tree(5,[t1]) + tree: List S -> % ++ tree(ls) creates a tree from a list of elements of s. + ++ + ++E tree [1,2,3,4] + tree: S -> % ++ tree(nd) creates a tree with value nd, and no children + ++ + ++E tree 6 + cyclic?: % -> Boolean ++ cyclic?(t) tests if t is a cyclic tree. + ++ + ++E t1:=tree [1,2,3,4] + ++E cyclic? t1 + cyclicCopy: % -> % - ++ cyclicCopy(l) makes a copy of a (possibly) cyclic tree l. + ++ cyclicCopy(l) makes a copy of a (possibly) cyclic tree l. + ++ + ++E t1:=tree [1,2,3,4] + ++E cyclicCopy t1 + cyclicEntries: % -> List % ++ cyclicEntries(t) returns a list of top-level cycles in tree t. + ++ + ++E t1:=tree [1,2,3,4] + ++E cyclicEntries t1 + cyclicEqual?: (%, %) -> Boolean ++ cyclicEqual?(t1, t2) tests of two cyclic trees have ++ the same structure. + ++ + ++E t1:=tree [1,2,3,4] + ++E t2:=tree [1,2,3,4] + ++E cyclicEqual?(t1,t2) + cyclicParents: % -> List % ++ cyclicParents(t) returns a list of cycles that are parents of t. + ++ + ++E t1:=tree [1,2,3,4] + ++E cyclicParents t1 + C== add cycleTreeMax ==> 5 @@ -333,12 +363,13 @@ Tree(S: SetCategory): T==C where ++ of a value and a \spadfun{left} and \spadfun{right}, both binary trees. BinaryTreeCategory(S: SetCategory): Category == BinaryRecursiveAggregate(S) with shallowlyMutable - ++ Binary trees have updateable components + ++ Binary trees have updateable components finiteAggregate - ++ Binary trees have a finite number of components + ++ Binary trees have a finite number of components node: (%,S,%) -> % - ++ node(left,v,right) creates a binary tree with value \spad{v}, a binary - ++ tree \spad{left}, and a binary tree \spad{right}. + ++ node(left,v,right) creates a binary tree with value \spad{v}, a binary + ++ tree \spad{left}, and a binary tree \spad{right}. + ++ add cycleTreeMax ==> 5 @@ -372,12 +403,20 @@ BinaryTreeCategory(S: SetCategory): Category == BinaryRecursiveAggregate(S) with ++ and \spadfun{left} which are both binary trees. BinaryTree(S: SetCategory): Exports == Implementation where Exports == BinaryTreeCategory(S) with - binaryTree: S -> % - ++ binaryTree(v) is an non-empty binary tree - ++ with value v, and left and right empty. - binaryTree: (%,S,%) -> % - ++ binaryTree(l,v,r) creates a binary tree with - ++ value v with left subtree l and right subtree r. + binaryTree: S -> % + ++ binaryTree(v) is an non-empty binary tree + ++ with value v, and left and right empty. + ++ + ++E t1:=binaryTree([1,2,3]) + + binaryTree: (%,S,%) -> % + ++ binaryTree(l,v,r) creates a binary tree with + ++ value v with left subtree l and right subtree r. + ++ + ++E t1:=binaryTree([1,2,3]) + ++E t2:=binaryTree([4,5,6]) + ++E binaryTree(t1,[7,8,9],t2) + Implementation == add Rep := List Tree S t1 = t2 == (t1::Rep) =$Rep (t2::Rep) @@ -628,14 +667,29 @@ BinarySearchTree(S: OrderedSet): Exports == Implementation where shallowlyMutable finiteAggregate binarySearchTree: List S -> % - ++ binarySearchTree(l) \undocumented + ++ binarySearchTree(l) \undocumented + ++ + ++E binarySearchTree [1,2,3,4] + insert_!: (S,%) -> % - ++ insert!(x,b) inserts element x as leaves into binary search tree b. + ++ insert!(x,b) inserts element x as leaves into binary search tree b. + ++ + ++E t1:=binarySearchTree [1,2,3,4] + ++E insert!(5,t1) + insertRoot_!: (S,%) -> % - ++ insertRoot!(x,b) inserts element x as a root of binary search tree b. + ++ insertRoot!(x,b) inserts element x as a root of binary search tree b. + ++ + ++E t1:=binarySearchTree [1,2,3,4] + ++E insertRoot!(5,t1) + split: (S,%) -> Record(less: %, greater: %) - ++ split(x,b) splits binary tree b into two trees, one with elements greater - ++ than x, the other with elements less than x. + ++ split(x,b) splits binary tree b into two trees, one with elements + ++ greater than x, the other with elements less than x. + ++ + ++E t1:=binarySearchTree [1,2,3,4] + ++E split(3,t1) + Implementation == BinaryTree(S) add Rep := BinaryTree(S) binarySearchTree(u:List S) == @@ -663,21 +717,28 @@ BinarySearchTree(S: OrderedSet): Exports == Implementation where @ \section{domain BTOURN BinaryTournament} +A BinaryTournament(S) is the domain of binary trees where elements are +ordered down the tree. A binary search tree is either empty or is a +node containing a value of type S, and a right and a left which are +both BinaryTree(S) <>= )abbrev domain BTOURN BinaryTournament -++ Description: \spadtype{BinaryTournament(S)} is the domain of -++ binary trees where elements are ordered down the tree. -++ A binary search tree is either empty or is a node containing a -++ \spadfun{value} of type \spad{S}, and a \spadfun{right} -++ and a \spadfun{left} which are both \spadtype{BinaryTree(S)} BinaryTournament(S: OrderedSet): Exports == Implementation where Exports == BinaryTreeCategory(S) with shallowlyMutable binaryTournament: List S -> % ++ binaryTournament(ls) creates a binary tournament with the ++ elements of ls as values at the nodes. + ++ + ++E binaryTournament [1,2,3,4] + insert_!: (S,%) -> % ++ insert!(x,b) inserts element x as leaves into binary tournament b. + ++ + ++E t1:=binaryTournament [1,2,3,4] + ++E insert!(5,t1) + ++E t1 + Implementation == BinaryTree(S) add Rep := BinaryTree(S) binaryTournament(u:List S) == @@ -908,23 +969,46 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where balancedBinaryTree: (NonNegativeInteger, S) -> % ++ balancedBinaryTree(n, s) creates a balanced binary tree with ++ n nodes each with value s. + ++ + ++E balancedBinaryTree(4, 0) + setleaves_!: (%, List S) -> % ++ setleaves!(t, ls) sets the leaves of t in left-to-right order ++ to the elements of ls. + ++ + ++E t1:=balancedBinaryTree(4, 0) + ++E setleaves!(t1,[1,2,3,4]) + mapUp_!: (%, (S,S) -> S) -> S ++ mapUp!(t,f) traverses balanced binary tree t in an "endorder" ++ (left then right then node) fashion returning t with the value ++ at each successive interior node of t replaced by ++ f(l,r) where l and r are the values at the immediate ++ left and right nodes. + ++ + ++E T1:=BalancedBinaryTree Integer + ++E t2:=balancedBinaryTree(4, 0)$T1 + ++E setleaves!(t2,[1,2,3,4]::List(Integer)) + ++E adder(a:Integer,b:Integer):Integer == a+b + ++E mapUp!(t2,adder) + ++E t2 + mapUp_!: (%, %, (S,S,S,S) -> S) -> % - ++ mapUp!(t,t1,f) traverses t in an "endorder" (left then right then node) - ++ fashion returning t with the value at each successive interior - ++ node of t replaced by + ++ mapUp!(t,t1,f) traverses balanced binary tree t in an "endorder" + ++ (left then right then node) fashion returning t with the value + ++ at each successive interior node of t replaced by ++ f(l,r,l1,r1) where l and r are the values at the immediate ++ left and right nodes. Values l1 and r1 are values at the ++ corresponding nodes of a balanced binary tree t1, of identical ++ shape at t. + ++ + ++E T1:=BalancedBinaryTree Integer + ++E t2:=balancedBinaryTree(4, 0)$T1 + ++E setleaves!(t2,[1,2,3,4]::List(Integer)) + ++E adder4(i:INT,j:INT,k:INT,l:INT):INT == i+j+k+l + ++E mapUp!(t2,t2,adder4) + ++E t2 + mapDown_!: (%,S,(S,S) -> S) -> % ++ mapDown!(t,p,f) returns t after traversing t in "preorder" ++ (node then left then right) fashion replacing the successive @@ -932,6 +1016,14 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where ++ replaced by q := f(p,x). The mapDown!(l,q,f) and ++ mapDown!(r,q,f) are evaluated for the left and right subtrees ++ l and r of t. + ++ + ++E T1:=BalancedBinaryTree Integer + ++E t2:=balancedBinaryTree(4, 0)$T1 + ++E setleaves!(t2,[1,2,3,4]::List(Integer)) + ++E adder(i:Integer,j:Integer):Integer == i+j + ++E mapDown!(t2,4::INT,adder) + ++E t2 + mapDown_!: (%,S, (S,S,S) -> List S) -> % ++ mapDown!(t,p,f) returns t after traversing t in "preorder" ++ (node then left then right) fashion replacing the successive @@ -941,6 +1033,14 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where ++ and right subtrees of t, is evaluated producing two values ++ pl and pr. Then \spad{mapDown!(l,pl,f)} and \spad{mapDown!(l,pr,f)} ++ are evaluated. + ++ + ++E T1:=BalancedBinaryTree Integer + ++E t2:=balancedBinaryTree(4, 0)$T1 + ++E setleaves!(t2,[1,2,3,4]::List(Integer)) + ++E adder3(i:Integer,j:Integer,k:Integer):List Integer == [i+j,j+k] + ++E mapDown!(t2,4::INT,adder3) + ++E t2 + Implementation == BinaryTree(S) add Rep := BinaryTree(S) leaf? x == @@ -1003,20 +1103,30 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where @ \section{domain PENDTREE PendantTree} +A PendantTree(S)is either a leaf? and is an S or has +a left and a right both PendantTree(S)'s <>= )abbrev domain PENDTREE PendantTree -++ A PendantTree(S)is either a leaf? and is an S or has -++ a left and a right both PendantTree(S)'s PendantTree(S: SetCategory): T == C where T == BinaryRecursiveAggregate(S) with - ptree : S->% - ++ ptree(s) is a leaf? pendant tree - ptree:(%, %)->% - ++ ptree(x,y) \undocumented - coerce:%->Tree S - ++ coerce(x) \undocumented + ptree : S->% + ++ ptree(s) is a leaf? pendant tree + ++ + ++E t1:=ptree([1,2,3]) + + ptree:(%, %)->% + ++ ptree(x,y) \undocumented + ++ + ++E t1:=ptree([1,2,3]) + ++E ptree(t1,ptree([1,2,3])) + + coerce:%->Tree S + ++ coerce(x) \undocumented + ++ + ++E t1:=ptree([1,2,3]) + ++E t2:=ptree(t1,ptree([1,2,3])) + ++E t2::Tree List PositiveInteger - C == add Rep := Tree S import Tree S @@ -1073,7 +1183,6 @@ PendantTree(S: SetCategory): T == C where --SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. @ <<*>>= -<> <> <>