/usr/share/axiom-20170501/src/algebra/WP.spad is in axiom-source 20170501-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | )abbrev domain WP WeightedPolynomials
++ Author: James Davenport
++ Date Created: 17 April 1992
++ Date Last Updated: 12 July 1992
++ Description:
++ This domain represents truncated weighted polynomials over a general
++ (not necessarily commutative) polynomial type. The variables must be
++ specified, as must the weights.
++ The representation is sparse
++ in the sense that only non-zero terms are represented.
WeightedPolynomials(R,VarSet,E,P,vl,wl,wtlevel) : SIG == CODE where
R : Ring
VarSet : OrderedSet
E : OrderedAbelianMonoidSup
P : PolynomialCategory(R,E,VarSet)
vl : List VarSet
wl : List NonNegativeInteger
wtlevel : NonNegativeInteger
SIG ==> Ring with
if R has CommutativeRing then Algebra(R)
coerce: $ -> P
++ coerce(wp) convert back into a "P", ignoring weights
if R has Field then
"/": ($,$) -> Union($,"failed")
++ x/y division (only works if minimum weight
++ of divisor is zero, and if R is a Field)
coerce: P -> $
++ coerce(p) coerces p into Weighted form,
++ applying weights and ignoring terms
changeWeightLevel: NonNegativeInteger -> Void
++ changeWeightLevel(n) changes the weight level to
++ the new value given:
++ NB: previously calculated terms are not affected
CODE ==> add
Rep := PolynomialRing(P,NonNegativeInteger)
p:P
w,x1,x2:$
n:NonNegativeInteger
z:Integer
changeWeightLevel(n) ==
wtlevel:=n
lookupList:List Record(var:VarSet, weight:NonNegativeInteger)
if #vl ^= #wl then error "incompatible length lists in WeightedPolynomial"
lookupList:=[[v,n] for v in vl for n in wl]
-- local operation
innercoerce:(p,z) -> $
lookup:Varset -> NonNegativeInteger
lookup v ==
l:=lookupList
while l ^= [] repeat
v = l.first.var => return l.first.weight
l:=l.rest
0
innercoerce(p,z) ==
z<0 => 0
zero? p => 0
mv:= mainVariable p
mv case "failed" => monomial(p,0)
n:=lookup(mv)
up:=univariate(p,mv)
ans:$
ans:=0
while not zero? up repeat
d:=degree up
f:=n*d
lcup:=leadingCoefficient up
up:=up-leadingMonomial up
mon:=monomial(1,mv,d)
f<=z =>
tmp:= innercoerce(lcup,z-f)
while not zero? tmp repeat
ans:=ans+ monomial(mon*leadingCoefficient(tmp),degree(tmp)+f)
tmp:=reductum tmp
ans
coerce(p):$ == innercoerce(p,wtlevel)
coerce(w):P == "+"/[c for c in coefficients w]
coerce(p:$):OutputForm ==
zero? p => (0$Integer)::OutputForm
degree p = 0 => leadingCoefficient(p):: OutputForm
reduce("+",(reverse [paren(c::OutputForm) for c in coefficients p])
::List OutputForm)
0 == 0$Rep
1 == 1$Rep
x1 = x2 ==
-- Note that we must strip out any terms greater than wtlevel
while degree x1 > wtlevel repeat
x1 := reductum x1
while degree x2 > wtlevel repeat
x2 := reductum x2
x1 =$Rep x2
x1 + x2 == x1 +$Rep x2
-x1 == -(x1::Rep)
x1 * x2 ==
-- Note that this is probably an extremely inefficient definition
w:=x1 *$Rep x2
while degree(w) > wtlevel repeat
w:=reductum w
w
|