diff options
Diffstat (limited to 'src/algebra/aggcat2.spad.pamphlet')
| -rw-r--r-- | src/algebra/aggcat2.spad.pamphlet | 223 |
1 files changed, 223 insertions, 0 deletions
diff --git a/src/algebra/aggcat2.spad.pamphlet b/src/algebra/aggcat2.spad.pamphlet new file mode 100644 index 00000000..6a4c57be --- /dev/null +++ b/src/algebra/aggcat2.spad.pamphlet @@ -0,0 +1,223 @@ +\documentclass{article} +\usepackage{axiom} +\begin{document} +\title{\$SPAD/src/algebra aggcat2.spad} +\author{Robert S. Sutor} +\maketitle +\begin{abstract} +\end{abstract} +\eject +\tableofcontents +\eject +\section{package FLAGG2 FiniteLinearAggregateFunctions2} +<<package FLAGG2 FiniteLinearAggregateFunctions2>>= +)abbrev package FLAGG2 FiniteLinearAggregateFunctions2 +--% FiniteLinearAggregateFunctions2 + +++ Author: ??? +++ Date Created: ??? +++ Date Last Updated: ??? +++ Description: +++ FiniteLinearAggregateFunctions2 provides functions involving two +++ FiniteLinearAggregates where the underlying domains might be +++ different. An example of this might be creating a list of rational +++ numbers by mapping a function across a list of integers where the +++ function divides each integer by 1000. + +FiniteLinearAggregateFunctions2(S, A, R, B): + Exports == Implementation where + S, R: Type + A : FiniteLinearAggregate S + B : FiniteLinearAggregate R + + Exports ==> with + map : (S -> R, A) -> B ++ map(f,a) applies function f to each member of aggregate + ++ \spad{a} resulting in a new aggregate over a + ++ possibly different underlying domain. + + reduce : ((S, R) -> R, A, R) -> R ++ reduce(f,a,r) applies function f to each + ++ successive element of the + ++ aggregate \spad{a} and an accumulant initialized to r. + ++ For example, + ++ \spad{reduce(_+$Integer,[1,2,3],0)} + ++ does \spad{3+(2+(1+0))}. Note: third argument r + ++ may be regarded as the + ++ identity element for the function f. + + scan : ((S, R) -> R, A, R) -> B ++ scan(f,a,r) successively applies + ++ \spad{reduce(f,x,r)} to more and more leading sub-aggregates + ++ x of aggregrate \spad{a}. + ++ More precisely, if \spad{a} is \spad{[a1,a2,...]}, then + ++ \spad{scan(f,a,r)} returns + ++ \spad{[reduce(f,[a1],r),reduce(f,[a1,a2],r),...]}. + + Implementation ==> add + if A has ListAggregate(S) then -- A is a list-oid + reduce(fn, l, ident) == + empty? l => ident + reduce(fn, rest l, fn(first l, ident)) + + if B has ListAggregate(R) or not(B has shallowlyMutable) then + -- A is a list-oid, and B is either list-oids or not mutable + map(f, l) == construct [f s for s in entries l] + + scan(fn, l, ident) == + empty? l => empty() + val := fn(first l, ident) + concat(val, scan(fn, rest l, val)) + + else -- A is a list-oid, B a mutable array-oid + map(f, l) == + i := minIndex(w := new(#l,NIL$Lisp)$B) + for a in entries l repeat (qsetelt_!(w, i, f a); i := inc i) + w + + scan(fn, l, ident) == + i := minIndex(w := new(#l,NIL$Lisp)$B) + vl := ident + for a in entries l repeat + vl := qsetelt_!(w, i, fn(a, vl)) + i := inc i + w + + else -- A is an array-oid + reduce(fn, v, ident) == + val := ident + for i in minIndex v .. maxIndex v repeat + val := fn(qelt(v, i), val) + val + + if B has ListAggregate(R) then -- A is an array-oid, B a list-oid + map(f, v) == + construct [f qelt(v, i) for i in minIndex v .. maxIndex v] + + scan(fn, v, ident) == + w := empty()$B + for i in minIndex v .. maxIndex v repeat + ident := fn(qelt(v, i), ident) + w := concat(ident, w) + reverse_! w + + else -- A and B are array-oid's + if B has shallowlyMutable then -- B is also mutable + map(f, v) == + w := new(#v,NIL$Lisp)$B + for i in minIndex w .. maxIndex w repeat + qsetelt_!(w, i, f qelt(v, i)) + w + + scan(fn, v, ident) == + w := new(#v,NIL$Lisp)$B + vl := ident + for i in minIndex v .. maxIndex v repeat + vl := qsetelt_!(w, i, fn(qelt(v, i), vl)) + w + + else -- B non mutable array-oid + map(f, v) == + construct [f qelt(v, i) for i in minIndex v .. maxIndex v] + + scan(fn, v, ident) == + w := empty()$B + for i in minIndex v .. maxIndex v repeat + ident := fn(qelt(v, i), ident) + w := concat(w, ident) + w + +@ +\section{package FSAGG2 FiniteSetAggregateFunctions2} +<<package FSAGG2 FiniteSetAggregateFunctions2>>= +)abbrev package FSAGG2 FiniteSetAggregateFunctions2 + +--% FiniteSetAggregateFunctions2 + +++ Author: Robert S. Sutor +++ Date Created: 15 May 1990 +++ Date Last Updated: 14 Oct 1993 +++ Description: +++ FiniteSetAggregateFunctions2 provides functions involving two +++ finite set aggregates where the underlying domains might be +++ different. An example of this is to create a set of rational +++ numbers by mapping a function across a set of integers, where the +++ function divides each integer by 1000. + +FiniteSetAggregateFunctions2(S, A, R, B): Exports == Implementation where + S, R: SetCategory + A : FiniteSetAggregate S + B : FiniteSetAggregate R + + Exports ==> with + map : (S -> R, A) -> B ++ map(f,a) applies function f to each member of + ++ aggregate \spad{a}, creating a new aggregate with + ++ a possibly different underlying domain. + + reduce : ((S, R) -> R, A, R) -> R ++ reduce(f,a,r) applies function f to each + ++ successive element of the aggregate \spad{a} and an + ++ accumulant initialised to r. + ++ For example, + ++ \spad{reduce(_+$Integer,[1,2,3],0)} + ++ does a \spad{3+(2+(1+0))}. + ++ Note: third argument r may be regarded + ++ as an identity element for the function. + + scan : ((S, R) -> R, A, R) -> B ++ scan(f,a,r) successively applies \spad{reduce(f,x,r)} + ++ to more and more leading sub-aggregates x of + ++ aggregate \spad{a}. + ++ More precisely, if \spad{a} is \spad{[a1,a2,...]}, then + ++ \spad{scan(f,a,r)} returns + ++ \spad {[reduce(f,[a1],r),reduce(f,[a1,a2],r),...]}. + + Implementation ==> add + map(fn, a) == + set(map(fn, parts a)$ListFunctions2(S, R))$B + reduce(fn, a, ident) == + reduce(fn, parts a, ident)$ListFunctions2(S, R) + scan(fn, a, ident) == + set(scan(fn, parts a, ident)$ListFunctions2(S, R))$B + +@ +\section{License} +<<license>>= +--Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. +--All rights reserved. +-- +--Redistribution and use in source and binary forms, with or without +--modification, are permitted provided that the following conditions are +--met: +-- +-- - Redistributions of source code must retain the above copyright +-- notice, this list of conditions and the following disclaimer. +-- +-- - Redistributions in binary form must reproduce the above copyright +-- notice, this list of conditions and the following disclaimer in +-- the documentation and/or other materials provided with the +-- distribution. +-- +-- - Neither the name of The Numerical ALgorithms Group Ltd. nor the +-- names of its contributors may be used to endorse or promote products +-- derived from this software without specific prior written permission. +-- +--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +--IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +--TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +--PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +--OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +--EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +--PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +--PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +--LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +--NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +@ +<<*>>= +<<license>> + +<<package FLAGG2 FiniteLinearAggregateFunctions2>> +<<package FSAGG2 FiniteSetAggregateFunctions2>> + +@ +\eject +\begin{thebibliography}{99} +\bibitem{1} nothing +\end{thebibliography} +\end{document} |