From a6352a4428911afca91d6e672dc540146c99d415 Mon Sep 17 00:00:00 2001 From: dos-reis Date: Mon, 23 Feb 2009 02:37:02 +0000 Subject: * interp/compiler.boot (compAtom): Don't interpret 'nil' as empty vector. (compSymbol): Don't interpret 'true' and 'false' as Boolean constants if domain Boolean is not in scope. * algebra/any.spad.pamphlet (Property): Tidy. * algebra/asp.spad.pamphlet (Asp34): Likewise. * algebra/functions.spad.pamphlet (BasicFunctions): Likewise. * algebra/lodop.spad.pamphlet (OppositeMonogenicLinearOperator): Likewise. * algebra/groebsol.spad.pamphlet: Import Boolean. --- src/ChangeLog | 13 ++++++++++++ src/algebra/any.spad.pamphlet | 22 ++++++++------------ src/algebra/asp.spad.pamphlet | 40 ++++++++++++++++++------------------ src/algebra/d01routine.spad.pamphlet | 2 +- src/algebra/functions.spad.pamphlet | 10 ++++----- src/algebra/groebsol.spad.pamphlet | 1 + src/algebra/lodop.spad.pamphlet | 12 +++++------ src/interp/compiler.boot | 13 ++++-------- 8 files changed, 58 insertions(+), 55 deletions(-) (limited to 'src') diff --git a/src/ChangeLog b/src/ChangeLog index 5e6aa71c..2d4994b9 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,16 @@ +2009-02-22 Gabriel Dos Reis + + * interp/compiler.boot (compAtom): Don't interpret 'nil' as empty + vector. + (compSymbol): Don't interpret 'true' and 'false' as Boolean + constants if domain Boolean is not in scope. + * algebra/any.spad.pamphlet (Property): Tidy. + * algebra/asp.spad.pamphlet (Asp34): Likewise. + * algebra/functions.spad.pamphlet (BasicFunctions): Likewise. + * algebra/lodop.spad.pamphlet (OppositeMonogenicLinearOperator): + Likewise. + * algebra/groebsol.spad.pamphlet: Import Boolean. + 2009-02-22 Gabriel Dos Reis * interp/util.lisp (MAKESPAD): Remove. diff --git a/src/algebra/any.spad.pamphlet b/src/algebra/any.spad.pamphlet index d4c44f11..a887307c 100644 --- a/src/algebra/any.spad.pamphlet +++ b/src/algebra/any.spad.pamphlet @@ -268,7 +268,7 @@ import SExpression ++ Date Last Modified: January 18, 2008. ++ An `Property' is a pair of name and value. Property(): Public == Private where - Public ==> CoercibleTo(OutputForm) with + Public == CoercibleTo(OutputForm) with name: % -> Symbol ++ name(p) returns the name of property p value: % -> SExpression @@ -277,12 +277,9 @@ Property(): Public == Private where ++ property(n,val) constructs a property with name `n' and ++ value `val'. - Private ==> add - rep(x: %): SExpression == - x pretend SExpression - - per(x: SExpression): % == - x pretend % + Private == add + import Boolean + Rep == SExpression name x == -- Note: It is always well defined to take the `car' here @@ -298,11 +295,10 @@ Property(): Public == Private where coerce x == v := value x - val: OutputForm - if null? v then val := false::OutputForm - else if EQ(v, true)$Lisp : Boolean - then val := true::OutputForm - else val := v::OutputForm + val := + null? v => false::OutputForm + EQ(v,'T)$Lisp => true::OutputForm + v::OutputForm bracket(infix(outputForm '_=_>, outputForm name x, val)$OutputForm)$OutputForm @@ -523,7 +519,7 @@ Environment(): Public == Private where <>= --Copyright (c) 1991-2002, The Numerical Algorithms Group Ltd. --All rights reserved. ---Copyright (C) 2007-2008, Gabriel Dos Reis. +--Copyright (C) 2007-2009, Gabriel Dos Reis. --All rights reserved. -- --Redistribution and use in source and binary forms, with or without diff --git a/src/algebra/asp.spad.pamphlet b/src/algebra/asp.spad.pamphlet index e5f2b900..e2706808 100644 --- a/src/algebra/asp.spad.pamphlet +++ b/src/algebra/asp.spad.pamphlet @@ -1635,19 +1635,19 @@ Asp34(name): Exports == Implementation where real : UFST := ["real"::FST]$UFST integer : UFST := ["integer"::FST]$UFST syms : SYMTAB := empty()$SYMTAB - declare!(IFLAG,fortranInteger(),syms)$SYMTAB - declare!(N,fortranInteger(),syms)$SYMTAB - xType : FT := construct(real,[N],false)$FT - declare!(X,xType,syms)$SYMTAB - declare!(Y,xType,syms)$SYMTAB - declare!(LRWORK,fortranInteger(),syms)$SYMTAB - declare!(LIWORK,fortranInteger(),syms)$SYMTAB - rType : FT := construct(real,[LRWORK],false)$FT - declare!(RWORK,rType,syms)$SYMTAB - iType : FT := construct(integer,[LIWORK],false)$FT - declare!(IWORK,iType,syms)$SYMTAB + declare!('IFLAG,fortranInteger(),syms)$SYMTAB + declare!('N,fortranInteger(),syms)$SYMTAB + xType : FT := construct(real,['N],false)$FT + declare!('X,xType,syms)$SYMTAB + declare!('Y,xType,syms)$SYMTAB + declare!('LRWORK,fortranInteger(),syms)$SYMTAB + declare!('LIWORK,fortranInteger(),syms)$SYMTAB + rType : FT := construct(real,['LRWORK],false)$FT + declare!('RWORK,rType,syms)$SYMTAB + iType : FT := construct(integer,['LIWORK],false)$FT + declare!('IWORK,iType,syms)$SYMTAB Rep := FortranProgram(name,["void"]$UFST, - [IFLAG,N,X,Y,RWORK,LRWORK,IWORK,LIWORK],syms) + ['IFLAG,'N,'X,'Y,'RWORK,'LRWORK,'IWORK,'LIWORK],syms) -- To help the poor old compiler localAssign(s:Symbol,u:EXI):FC == assign(s,u)$FC @@ -1655,15 +1655,15 @@ Asp34(name): Exports == Implementation where coerce(u:Matrix MachineFloat):$ == dimension := nrows(u) ::Polynomial Integer locals : SYMTAB := empty()$SYMTAB - declare!(I,fortranInteger(),syms)$SYMTAB - declare!(J,fortranInteger(),syms)$SYMTAB - declare!(W1,[real,[dimension],false]$FT,locals)$SYMTAB - declare!(W2,[real,[dimension],false]$FT,locals)$SYMTAB - declare!(MS,[real,[dimension,dimension],false]$FT,locals)$SYMTAB - assign1 : FC := localAssign(IFLAG@Symbol,(-1)@EXI) + declare!('I,fortranInteger(),syms)$SYMTAB + declare!('J,fortranInteger(),syms)$SYMTAB + declare!('W1,[real,[dimension],false]$FT,locals)$SYMTAB + declare!('W2,[real,[dimension],false]$FT,locals)$SYMTAB + declare!('MS,[real,[dimension,dimension],false]$FT,locals)$SYMTAB + assign1 : FC := localAssign('IFLAG,(-1)@EXI) call : FC := call("F04ASF(MS,N,X,N,Y,W1,W2,IFLAG)")$FC - assign2 : FC := localAssign(IFLAG::Symbol,-(IFLAG@Symbol::EXI)) - assign3 : FC := assign(MS,u)$FC + assign2 : FC := localAssign('IFLAG,-('IFLAG::EXI)) + assign3 : FC := assign('MS,u)$FC code' : List FC := [assign1,assign3,call,assign2,returns()]$List(FC) ([locals,code']$RSFC)::$ diff --git a/src/algebra/d01routine.spad.pamphlet b/src/algebra/d01routine.spad.pamphlet index c3b04127..9733ea0a 100644 --- a/src/algebra/d01routine.spad.pamphlet +++ b/src/algebra/d01routine.spad.pamphlet @@ -607,7 +607,7 @@ d01gbfAnnaType(): NumericalIntegrationCategory == Result add nia:NIA := [vars.i,args.fn,segs.i,args.abserr,rel] not rangeIsFinite(nia) case finite => return [0.0,"d01gbf is not a suitable routine for infinite integrals",ext] - [getMeasure(R,d01gbf@S)$RT, "Recommended is d01gbf", ext] + [getMeasure(R,'d01gbf)$RT, "Recommended is d01gbf", ext] numericalIntegration(args:MDNIA,hints:Result) == import Integer diff --git a/src/algebra/functions.spad.pamphlet b/src/algebra/functions.spad.pamphlet index 5dff2a13..f48391f2 100644 --- a/src/algebra/functions.spad.pamphlet +++ b/src/algebra/functions.spad.pamphlet @@ -63,11 +63,11 @@ BasicFunctions(): E == I where cotEntry:RS := [n1dpi, n3dpi, ndpi] logEntry:RS := [construct([1$DF])$SDF,esdf, construct([0$DF])$SDF] entryList:List(Record(key:Symbol,entry:RS)) := - [[sin@Symbol, sinEntry], [cos@Symbol, cosEntry], - [tan@Symbol, tanEntry], [sec@Symbol, secEntry], - [csc@Symbol, cscEntry], [cot@Symbol, cotEntry], - [asin@Symbol, asinEntry], [acos@Symbol, acosEntry], - [atan@Symbol, atanEntry], [log@Symbol, logEntry]] + [['sin, sinEntry], ['cos, cosEntry], + ['tan, tanEntry], ['sec, secEntry], + ['csc, cscEntry], ['cot, cotEntry], + ['asin, asinEntry], ['acos, acosEntry], + ['atan, atanEntry], ['log, logEntry]] construct(entryList)$Rep bfKeys():List Symbol == keys(bf())$Rep diff --git a/src/algebra/groebsol.spad.pamphlet b/src/algebra/groebsol.spad.pamphlet index b689d991..33ebeff5 100644 --- a/src/algebra/groebsol.spad.pamphlet +++ b/src/algebra/groebsol.spad.pamphlet @@ -57,6 +57,7 @@ GroebnerSolve(lv,F,R) : C == T ++ in general position, for system lp in variables lv. T == add + import Boolean import PolToPol(lv,F) import GroebnerPackage(F,DP,OV,DPoly) import GroebnerInternalPackage(F,DP,OV,DPoly) diff --git a/src/algebra/lodop.spad.pamphlet b/src/algebra/lodop.spad.pamphlet index a2a8d35a..6f23a155 100644 --- a/src/algebra/lodop.spad.pamphlet +++ b/src/algebra/lodop.spad.pamphlet @@ -91,13 +91,11 @@ OppositeMonogenicLinearOperator(P, R): OPRcat == OPRdef where po: $ -> P ++ po(q) creates a value in P equal to q in $. OPRdef == P add - Rep := P - x, y: $ - a: P - op a == a: $ - po x == x: P - x*y == (y:P) *$P (x:P) - coerce(x): OutputForm == prefix(op::OutputForm, [coerce(x:P)$P]) + Rep == P + op a == per a + po x == rep x + (x: %) * (y: %) == per(rep(y) * rep(x)) + coerce(x): OutputForm == prefix(op::OutputForm, [coerce rep x]) @ \section{package NCODIV NonCommutativeOperatorDivision} diff --git a/src/interp/compiler.boot b/src/interp/compiler.boot index 06f7c318..ae68d089 100644 --- a/src/interp/compiler.boot +++ b/src/interp/compiler.boot @@ -375,7 +375,6 @@ compAtomWithModemap(x,m,e,v) == --accept only monadic operators T:= or/[t for (t:= [.,target,.]) in Tl | modeEqual(m,target)] => T 1=#(Tl:= [y for t in Tl | (y:= convert(t,m))]) => first Tl - 0<#Tl and m=$NoValueMode => first Tl nil transImplementation(op,map,fn) == @@ -387,12 +386,11 @@ compAtom(x,m,e) == T:= compAtomWithModemap(x,m,e,get(x,"modemap",e)) => T x="nil" => T:= - modeIsAggregateOf('List,m,e) is [.,R]=> compList(x,['List,R],e) - modeIsAggregateOf('Vector,m,e) is [.,R]=> compVector(x,['Vector,R],e) - T => convert(T,m) + modeIsAggregateOf('List,m,e) is [.,R] => compList(x,['List,R],e) + return nil + convert(T,m) t:= - isSymbol x => - compSymbol(x,m,e) or return nil + isSymbol x => compSymbol(x,m,e) or return nil m = $OutputForm and primitiveType x => [x,m,e] STRINGP x => [x,x,e] [x,primitiveType x or return nil,e] @@ -411,11 +409,8 @@ primitiveType x == compSymbol(s,m,e) == s="$NoValue" => ["$NoValue",$NoValueMode,e] isFluid s => [s,getmode(s,e) or return nil,e] - s="true" => ['(QUOTE T),$Boolean,e] - s="false" => [false,$Boolean,e] s=m or isLiteral(s,e) => [["QUOTE",s],s,e] v := get(s,"value",e) => ---+ MEMQ(s,$functorLocalParameters) => NRTgetLocalIndex s [s,v.mode,e] --s will be replaced by an ELT form in beforeCompile -- cgit v1.2.3