DIRECTORY
Rope,
IO,
MathExpr,
MathConstructors,
AlgebraClasses,
Structures,
Ints,
Vectors;

VectorsImpl: CEDAR PROGRAM
IMPORTS Rope, IO, MathConstructors, Structures, AlgebraClasses, Ints 
EXPORTS Vectors =

BEGIN OPEN AC: AlgebraClasses, Vectors;
SyntaxError: PUBLIC ERROR [reason: ATOM] = CODE;
BadCoordinateStructure: PUBLIC ERROR [coordinateStructure: AC.Object] = CODE;
TypeError: PUBLIC ERROR [message: ATOM _ $Unspecified] = CODE;

Method: TYPE = AC.Method;
Object: TYPE = AC.Object;
MakeVectorStructure: PUBLIC AC.VectorStructureConstructor ~ {
vectorStructureData: VectorStructureData _ NEW[VectorStructureDataRec _ [
row: row,
coordinateStructure: coordinateStructure,
dimension: dimension
] ];
method: Method _ AC.LookupMethodInStructure[$category, coordinateStructure];
category: REF AC.Category _ NARROW[method.value];
SELECT category^ FROM
set => vectorStructure _ AC.MakeStructure[
name: NIL,
class: vectorsClass,
instanceData: vectorStructureData
];
group => vectorStructure _ AC.MakeStructure[
name: NIL,
class: vectorsOverGroupClass,
instanceData: vectorStructureData
];
ring, algebra => vectorStructure _ AC.MakeStructure[
name: NIL,
class: vectorsOverRingClass,
instanceData: vectorStructureData
];
field, divisionAlgebra => vectorStructure _ AC.MakeStructure[
name: NIL,
class: vectorsOverFieldClass,
instanceData: vectorStructureData
];
ENDCASE => ERROR BadCoordinateStructure[coordinateStructure];
vectorStructure.name _ ShortPrintName[vectorStructure];
IF AC.LookupStructure[vectorStructure.name] = NIL THEN AC.InstallStructure[vectorStructure];
};
PrintName: PUBLIC AC.ToRopeOp = {
data: VectorStructureData _ NARROW[in.data];
shortPrintNameMethod: Method _ AC.LookupMethodInStructure[$shortPrintName, data.coordinateStructure];
RETURN[Rope.Concat[
"Vectors over ",
NARROW[AC.ApplyNoLkpNoRecastRef[shortPrintNameMethod,LIST[data.coordinateStructure] ] ]
] ];
};

ShortPrintName: PUBLIC AC.ToRopeOp = {
data: VectorStructureData _ NARROW[in.data];
shortPrintNameMethod: Method _ AC.LookupMethodInStructure[$shortPrintName, data.coordinateStructure];
RETURN[Rope.Cat[
"Vec(",
NARROW[AC.ApplyNoLkpNoRecastRef[shortPrintNameMethod,LIST[data.coordinateStructure] ] ],
")"
] ];
};

CoordinateStructure: PUBLIC AC.UnaryOp = {
data: VectorStructureData _ NARROW[arg.data];
RETURN[data.coordinateStructure];
};

Dimension: PUBLIC AC.StructureRankOp = {
data: VectorStructureData _ NARROW[structure.data];
RETURN[data.dimension];
};

IsVectorStructure: PUBLIC AC.UnaryPredicate = {
RETURN[ISTYPE[arg.data, VectorStructureData] ];
};

Recast: PUBLIC AC.BinaryOp = {
thisVectorStructure: Object _ secondArg;
thisVectorStructureData: VectorStructureData _ NARROW[thisVectorStructure.data];
thisStructureCoordinateStructure: Object _ thisVectorStructureData.coordinateStructure;
thisStructureDimension: NAT _ thisVectorStructureData.dimension;
canRecastMethod: Method _ AC.LookupMethodInStructure[$canRecast, thisStructureCoordinateStructure];
recastMethod: Method _ AC.LookupMethodInStructure[$recast, thisStructureCoordinateStructure];
flag: BOOL;

IF AC.StructureEqual[firstArg.class, secondArg] THEN RETURN[firstArg]; -- nothing to do

flag _ AC.ApplyPredNoLkpNoRecast[canRecastMethod,LIST[firstArg.class, thisStructureCoordinateStructure] ];
IF flag THEN  {
recastElement: Object _ AC.ApplyNoLkpNoRecastObject[recastMethod, LIST[firstArg, thisStructureCoordinateStructure] ];
RETURN[ ImbedScalar[recastElement, thisVectorStructure] ];
};

IF AC.LookupMethodInStructure[$vectorStructure, firstArg.class]#NIL THEN {
inputVectorStructure: Object _ firstArg.class;
inputVectorStructureData: VectorStructureData _ NARROW[inputVectorStructure.data];
inputStructureCoordinateStructure: Object _ inputVectorStructureData.coordinateStructure;
inputStructureDimension: NAT _ inputVectorStructureData.dimension;
argData: VectorData _ NARROW[firstArg.data];
resultData: VectorData;
IF thisStructureDimension#inputStructureDimension THEN RETURN[NIL];
flag _ AC.ApplyPredNoLkpNoRecast[canRecastMethod,LIST[inputStructureCoordinateStructure, thisStructureCoordinateStructure] ];
IF NOT flag THEN RETURN[NIL]; -- give up
resultData _ NEW[VectorDataRec[argData.dimensionPlus1 - 1] ];
FOR i:NAT IN [1..argData.dimensionPlus1) DO
resultData[i] _ AC.ApplyNoLkpNoRecastObject[recastMethod, LIST[argData[i], thisStructureCoordinateStructure] ];
ENDLOOP;
RETURN[ NEW[AC.ObjectRec _ [
flavor: StructureElement,
class: thisVectorStructure,
data: resultData
] ] ];
};

RETURN[NIL];
};

CanRecast: PUBLIC AC.BinaryPredicate = {
thisVectorStructure: Object _ secondArg;
thisVectorStructureData: VectorStructureData _ NARROW[thisVectorStructure.data];
thisStructureCoordinateStructure: Object _ thisVectorStructureData.coordinateStructure;
thisStructureDimension: NAT _ thisVectorStructureData.dimension;
canRecastMethod: Method _ AC.LookupMethodInStructure[$canRecast, thisStructureCoordinateStructure];
flag: BOOL;
firstArgStructure: Object _ IF firstArg.flavor = StructureElement THEN firstArg.class ELSE IF firstArg.flavor = Structure THEN firstArg ELSE ERROR;
IF AC.StructureEqual[firstArgStructure, thisVectorStructure] THEN RETURN[TRUE];

flag _ AC.ApplyPredNoLkpNoRecast[canRecastMethod,LIST[firstArgStructure, thisStructureCoordinateStructure] ];
IF flag THEN RETURN[TRUE];

IF AC.LookupMethodInStructure[$vectorStructure, firstArgStructure]#NIL THEN {
inputVectorStructure: Object _ firstArgStructure;
inputVectorStructureData: VectorStructureData _ NARROW[inputVectorStructure.data];
inputStructureCoordinateStructure: Object _ inputVectorStructureData.coordinateStructure;
inputStructureDimension: NAT _ inputVectorStructureData.dimension;
IF thisStructureDimension#inputStructureDimension THEN RETURN[FALSE];
flag _ AC.ApplyPredNoLkpNoRecast[canRecastMethod,LIST[inputStructureCoordinateStructure, thisStructureCoordinateStructure] ];
RETURN[flag];
};
RETURN[FALSE];
};

ToExpr: PUBLIC AC.ToExprOp = {
vectorData: VectorData _ NARROW[in.data];
vectorStructureData: VectorStructureData _ NARROW[in.class.data];
size: CARDINAL _ vectorData.dimensionPlus1 - 1;
outColumn: LIST OF MathExpr.EXPR _ NIL;
method: Method _ AC.LookupMethodInStructure[$toExpr, vectorStructureData.coordinateStructure];
FOR j:NAT DECREASING IN [1..size] DO
outColumn _ CONS[NARROW[AC.ApplyNoLkpNoRecastRef[method, LIST[vectorData[j]] ]] , outColumn];
ENDLOOP;
out _  MathConstructors.MakeVector[size, outColumn, vectorStructureData.row]; -- row (not column) vector
}; 
LegalFirstChar: PUBLIC AC.LegalFirstCharOp = {
SELECT char FROM
'[ => RETURN[TRUE];
ENDCASE;
RETURN[FALSE];
};

Read: PUBLIC AC.ReadOp ~ {
structureData: VectorStructureData _ NARROW[structure.data];
coordinateStructure: AC.Object _ structureData.coordinateStructure;
readMethod: AC.Method _ AC.LookupMethodInStructure[$read, coordinateStructure];
puncChar: CHAR;
nextElement: AC.Object;
length: NAT _ 0;
list, listTail: LIST OF AC.Object _ NIL;
outData: VectorData;
[]_ in.SkipWhitespace[];
puncChar _ in.GetChar[];
[]_ in.SkipWhitespace[];
IF puncChar # '[ THEN ERROR SyntaxError[$LeftParenExpected];
[]_ in.SkipWhitespace[];
puncChar _ in.PeekChar[];
IF puncChar = '] THEN puncChar _ in.GetChar[];
WHILE puncChar # '] DO
nextElement _ AC.ApplyReadMethod[readMethod, in, coordinateStructure];
length _ length + 1;
[]_ in.SkipWhitespace[];
IF list=NIL THEN list _ listTail _LIST[nextElement] ELSE
{ listTail.rest _ LIST[nextElement];  listTail _ listTail.rest };
puncChar _ in.GetChar[];
[]_ in.SkipWhitespace[];
IF puncChar # '] THEN
IF puncChar # ', THEN ERROR SyntaxError[$CommaExpected];
ENDLOOP;
outData _ NEW[VectorDataRec[length] ];
FOR i:NAT IN [1..length] DO
outData[i] _ list.first;
list _ list.rest;
ENDLOOP;
out _ NEW[AC.ObjectRec _ [flavor: StructureElement, class: structure, data: outData] ];
};

FromRope: PUBLIC AC.FromRopeOp ~ {
out _ Read[IO.RIS[in], structure];
};

ToRope: PUBLIC AC.ToRopeOp ~ { 
vectorStructureData: VectorStructureData _ NARROW[in.class.data];
coordinateStructure: AC.Object _ vectorStructureData.coordinateStructure;
toRopeMethod: AC.Method _ AC.LookupMethodInStructure[$toRope, coordinateStructure];
inData: VectorData _ NARROW[in.data];
out _ "[ "; 
FOR i:NAT IN [1..inData.dimensionPlus1) DO
out _ Rope.Concat[ out, NARROW[AC.ApplyNoLkpNoRecastRef[toRopeMethod, LIST[inData[i] ] ] ] ];
IF i < inData.dimensionPlus1-1 THEN out _ Rope.Concat[out,", "];
ENDLOOP;
out _ Rope.Concat[ out, " ]" ];
};

Write: PUBLIC AC.WriteOp ~ {
stream.PutRope[ ToRope[in] ]
};  
ImbedScalar: PUBLIC AC.UnaryImbedOp ~ {
dimension: NAT _ Dimension[structure];
resultData: VectorData _ NEW[VectorDataRec[dimension] ];
FOR i:NAT IN [1..dimension] DO
resultData[i] _ in;
ENDLOOP;
RETURN[ NEW[AC.ObjectRec _ [
flavor: StructureElement,
class: structure,
data: resultData
] ] ];
};

MakeVector: PUBLIC AC.ListImbedOp ~ {
structureData: VectorStructureData _ NARROW[structure.data];
coordinateStructure: AC.Object _ structureData.coordinateStructure;
dimension: NAT _ structureData.dimension;
recastMethod: Method _ AC.LookupMethodInStructure[$recast, coordinateStructure];
length: NAT _ 0;
ptr: LIST OF AC.Object _ data;
outData: VectorData;
WHILE ptr#NIL DO length _ length + 1; ptr _ ptr.rest ENDLOOP;
IF length#dimension THEN ERROR TypeError[$BadDimension]; 
outData _ NEW[VectorDataRec[dimension] ];
FOR i:NAT IN [1..dimension] DO
outData[i] _ AC.ApplyNoLkpNoRecastObject[recastMethod, LIST[data.first, coordinateStructure] ];
IF outData[i] = NIL THEN TypeError[];
data _ data.rest;
ENDLOOP;
out _ NEW[AC.ObjectRec _ [flavor: StructureElement, class: structure, data: outData] ];
};
Coordinate: PUBLIC AC.BinaryOp ~ {
firstData: VectorData _ NARROW[firstArg.data];
index: INT _ Ints.ToINT[secondArg];
IF index<1 OR firstData.dimensionPlus1-1<index THEN RETURN[NIL];
RETURN[firstData[index] ];
};

Zero: PUBLIC AC.NullaryOp ~ {
coordinateStructure: Object _ CoordinateStructure[structure];
zero: Object _ AC.ApplyLkpNoRecastObject[$zero, coordinateStructure, LIST[coordinateStructure] ];
RETURN[ImbedScalar[zero, structure] ];
};

One: PUBLIC AC.NullaryOp ~ {
coordinateStructure: Object _ CoordinateStructure[structure];
one: Object _ AC.ApplyLkpNoRecastObject[$one, coordinateStructure, LIST[coordinateStructure] ];
RETURN[ImbedScalar[one, structure] ];
};

Add: PUBLIC AC.BinaryOp ~ {
coordinateStructure: Object _ CoordinateStructure[firstArg.class];
sumMethod: Method _ AC.LookupMethodInStructure[$sum, coordinateStructure];
IF sumMethod=NIL THEN ERROR TypeError[$MethodNotFound];
RETURN[ MapBinaryElementOp[firstArg, secondArg, sumMethod] ];
};

Negate: PUBLIC AC.UnaryOp ~ {
coordinateStructure: Object _ CoordinateStructure[arg.class];
negationMethod: Method _ AC.LookupMethodInStructure[$negation, coordinateStructure];
IF negationMethod=NIL THEN ERROR TypeError[$MethodNotFound];
RETURN[ MapUnaryElementOp[arg, negationMethod] ];
};

Subtract: PUBLIC AC.BinaryOp ~ {
coordinateStructure: Object _ CoordinateStructure[firstArg.class];
differenceMethod: Method _ AC.LookupMethodInStructure[$difference, coordinateStructure];
IF differenceMethod=NIL THEN ERROR TypeError[$MethodNotFound];
RETURN[ MapBinaryElementOp[firstArg, secondArg, differenceMethod] ];
};

ScalarMultiply: PUBLIC AC.BinaryOp ~ {
secondData: VectorData _ NARROW[secondArg.data];
vectorStructureData: VectorStructureData _ NARROW[secondArg.class.data];
coordinateStructure: Object _ vectorStructureData.coordinateStructure;
dimension: NAT _ vectorStructureData.dimension;
productMethod: Method _ AC.LookupMethodInStructure[$product, coordinateStructure];
resultData: VectorData;
resultData _ NEW[VectorDataRec[dimension] ];
FOR i:NAT IN [1..dimension] DO
resultData[i] _ AC.ApplyNoLkpNoRecastObject[productMethod, LIST[firstArg, secondData[i] ] ]; 
ENDLOOP;
result _ NEW[AC.ObjectRec _ [flavor: StructureElement, class: secondArg.class, data: resultData] ];
};
Equal: PUBLIC AC.BinaryPredicate ~ {
firstArgData: VectorData _ NARROW[firstArg.data];
secondArgData: VectorData _ NARROW[secondArg.data];
vectorStructureData: VectorStructureData _ NARROW[firstArg.class.data];
coordinateEqualsMethod: Method _ AC.LookupMethodInStructure[$eqFormula, vectorStructureData.coordinateStructure];
IF firstArgData.dimensionPlus1 # secondArgData.dimensionPlus1 THEN RETURN[FALSE];
FOR j: NAT IN [1..firstArgData.dimensionPlus1) DO
IF NOT AC.ApplyPredNoLkpNoRecast[coordinateEqualsMethod, LIST[firstArgData[j], secondArgData[j] ] ] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};
MapUnaryElementOp: PUBLIC AC.BinaryMixedOp ~ {
vectorData: VectorData _ NARROW[firstArg.data];
method: Method _ NARROW[secondArg];
newCoordinateStructure, newVecStructure: AC.Object _ NIL;
dimension: NAT _ Dimension[firstArg.class];
newData: VectorData _ NEW[VectorDataRec[dimension] ];
FOR i:INT IN [1..dimension] DO
newData[i] _ AC.ApplyNoLkpNoRecastObject[method, LIST[vectorData[i] ] ];
IF newData[i]# NIL THEN newCoordinateStructure _ newData[i].class;
ENDLOOP;
IF newCoordinateStructure = NIL THEN RETURN[firstArg]; -- map has trivial result
newVecStructure _ MakeVectorStructure[newCoordinateStructure, dimension];
RETURN[ NEW[AC.ObjectRec _ [
flavor: StructureElement,
class: newVecStructure,
data: newData
] ] ];
};

MapBinaryElementOp: PUBLIC AC.TernaryMixedOp ~ {
firstData: VectorData _ NARROW[firstArg.data];
secondData: VectorData _ NARROW[secondArg.data];
method: Method _ NARROW[thirdArg];
newCoordinateStructure, newVecStructure: AC.Object _ NIL;
dimension: NAT _ Dimension[firstArg.class];
coordinateStructure: Object _ CoordinateStructure[firstArg.class];
newData: VectorData _ NEW[VectorDataRec[dimension] ];
FOR i:INT IN [1..dimension] DO
newData[i] _ AC.ApplyNoLkpRecastObject[method, coordinateStructure, LIST[firstData[i], secondData[i] ] ]; -- do recast
IF newData[i]# NIL THEN newCoordinateStructure _ newData[i].class;
ENDLOOP;
IF newCoordinateStructure = NIL THEN RETURN[firstArg]; -- map has trivial result
newVecStructure _ MakeVectorStructure[newCoordinateStructure, dimension];
RETURN[ NEW[AC.ObjectRec _ [
flavor: StructureElement,
class: newVecStructure,
data: newData
] ] ];
};
ObjectAndIntDesired: PUBLIC AC.UnaryToListOp ~ {
RETURN[ LIST[arg, Ints.Ints] ]; -- arg assumed to be a Vector Structure
};

VectorAndCoordinateDesired: PUBLIC AC.UnaryToListOp ~ {
thisVectorStructureData: VectorStructureData _ NARROW[arg.data];
coordinateStructure: Object _ thisVectorStructureData.coordinateStructure;
RETURN[ LIST[arg, coordinateStructure] ]; -- arg assumed to be a Vector Structure
};
CoordinateAndVectorDesired: PUBLIC AC.UnaryToListOp ~ {
thisVectorStructureData: VectorStructureData _ NARROW[arg.data];
coordinateStructure: Object _ thisVectorStructureData.coordinateStructure;
RETURN[ LIST[coordinateStructure, arg] ]; -- arg assumed to be a Vector Structure
};
vectorsClass: AC.Object _ AC.MakeClass["VectorsClass", NIL, NIL];

vectorsOverGroupClass: AC.Object _ AC.MakeClass["VectorsOverGroupClass", vectorsClass, NIL];

vectorsOverRingClass: AC.Object _ AC.MakeClass["VectorsOverRingClass", vectorsOverGroupClass, NIL];

vectorsOverFieldClass: AC.Object _ AC.MakeClass["VectorsOverFieldClass", vectorsOverRingClass, NIL];

setCategoryMethod: Method _ AC.MakeMethod[Value, FALSE, NEW[AC.Category _ set], NIL, NIL];
groupCategoryMethod: Method _ AC.MakeMethod[Value, FALSE, NEW[AC.Category _ group], NIL, NIL];
ringCategoryMethod: Method _ AC.MakeMethod[Value, FALSE, NEW[AC.Category _ ring], NIL, NIL];
fieldCategoryMethod: Method _ AC.MakeMethod[Value, FALSE, NEW[AC.Category _ field], NIL, NIL];
vectorSpaceCategoryMethod: Method _ AC.MakeMethod[Value, FALSE, NEW[AC.Category _ vectorSpace], NIL, NIL];
vectorStructureMethod: Method _ AC.MakeMethod[Value, FALSE, NIL, NIL, "vectorStructure"];
matrixStructureMethod: Method _ AC.MakeMethod[Value, FALSE, NIL, NIL, "matrixStructure"];
shortPrintNameMethod: Method _ AC.MakeMethod[ToRopeOp, FALSE, NEW[AC.ToRopeOp _ ShortPrintName], NIL, "shortPrintName"];
recastMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Recast], NIL, "recast"];
canRecastMethod: Method _ AC.MakeMethod[BinaryPredicate, TRUE, NEW[AC.BinaryPredicate _ CanRecast], NIL, "canRecast"];
toExprMethod: Method _ AC.MakeMethod[ToExprOp, FALSE, NEW[AC.ToExprOp _ ToExpr], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "toExpr"];
legalFirstCharMethod: Method _ AC.MakeMethod[LegalFirstCharOp, FALSE, NEW[AC.LegalFirstCharOp _ LegalFirstChar], NIL, "legalFirstChar"];
readMethod: Method _ AC.MakeMethod[ReadOp, FALSE, NEW[AC.ReadOp _ Read], NIL, "read"];
fromRopeMethod: Method _ AC.MakeMethod[FromRopeOp, TRUE, NEW[AC.FromRopeOp _ FromRope], NIL, "fromRope"];
toRopeMethod: Method _ AC.MakeMethod[ToRopeOp, FALSE, NEW[AC.ToRopeOp _ ToRope], NIL, "toRope"];
parenMethod: Method _ AC.MakeMethod[UnaryOp, FALSE, NEW[AC.UnaryOp _ AC.Copy], NIL, "paren"];
imbedScalarMethod: Method _ AC.MakeMethod[UnaryImbedOp, FALSE, NEW[AC.UnaryImbedOp _ ImbedScalar], NIL, "imbedScalar"];
vectorMethod: Method _ AC.MakeMethod[ListImbedOp, FALSE, NEW[AC.ListImbedOp _ MakeVector], NIL, "vector"];
coordinateMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Coordinate], NEW[AC.UnaryToListOp _ ObjectAndIntDesired], "coordinate"];
zeroMethod: Method _ AC.MakeMethod[NullaryOp, FALSE, NEW[AC.NullaryOp _ Zero], NIL, "zero"];
oneMethod: Method _ AC.MakeMethod[NullaryOp, FALSE, NEW[AC.NullaryOp _ One], NIL, "one"];
sumMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Add], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "sum"];
negationMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Negate], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "negation"];
differenceMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Subtract], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "difference"];
scalarProductMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ ScalarMultiply], NEW[AC.UnaryToListOp _ CoordinateAndVectorDesired], "scalarProduct"];
equalMethod: Method _ AC.MakeMethod[BinaryPredicate, TRUE, NEW[AC.BinaryPredicate _ Equal], NEW[AC.UnaryToListOp _ AC.DefaultDesiredArgStructures], "equals"];
mapUnaryElementOpMethod: Method _ AC.MakeMethod[BinaryMixedOp, TRUE, NEW[AC.BinaryMixedOp _ MapUnaryElementOp], NIL, "mapUnary"]; -- should nave non-NIL DesiredArgStructures
mapBinaryElementOpMethod: Method _ AC.MakeMethod[TernaryMixedOp, TRUE, NEW[AC.TernaryMixedOp _ MapBinaryElementOp], NIL, "mapBinary"]; -- should nave non-NIL DesiredArgStructures

makeVectorStructureMethod: Method _ AC.MakeMethod[VectorStructureConstructor, FALSE, NEW[AC.VectorStructureConstructor _ MakeVectorStructure], NIL, "makeVectorStructure"];


AC.AddMethodToClass[$category, setCategoryMethod, vectorsClass];
AC.AddMethodToClass[$vectorStructure, vectorStructureMethod, vectorsClass];
AC.AddMethodToClass[$matrixStructure, matrixStructureMethod, vectorsClass];
AC.AddMethodToClass[$shortPrintName, shortPrintNameMethod, vectorsClass];
AC.AddMethodToClass[$recast, recastMethod, vectorsClass];
AC.AddMethodToClass[$canRecast, canRecastMethod, vectorsClass];
AC.AddMethodToClass[$toExpr, toExprMethod, vectorsClass];
AC.AddMethodToClass[$legalFirstChar, legalFirstCharMethod, vectorsClass];
AC.AddMethodToClass[$read, readMethod, vectorsClass];
AC.AddMethodToClass[$fromRope, fromRopeMethod, vectorsClass];
AC.AddMethodToClass[$toRope, toRopeMethod, vectorsClass];
AC.AddMethodToClass[$paren, parenMethod, vectorsClass];
AC.AddMethodToClass[$vector, vectorMethod, vectorsClass];
AC.AddMethodToClass[$coordinate, coordinateMethod, vectorsClass];
AC.AddMethodToClass[$eqFormula, equalMethod, vectorsClass];
AC.AddMethodToClass[$mapUnary, mapUnaryElementOpMethod, vectorsClass];
AC.AddMethodToClass[$mapBinary, mapBinaryElementOpMethod, vectorsClass];

AC.AddMethodToClass[$category, groupCategoryMethod, vectorsOverGroupClass];
AC.AddMethodToClass[$zero, zeroMethod, vectorsOverGroupClass];
AC.AddMethodToClass[$sum, sumMethod, vectorsOverGroupClass];
AC.AddMethodToClass[$negation, negationMethod, vectorsOverGroupClass];
AC.AddMethodToClass[$difference, differenceMethod, vectorsOverGroupClass];

AC.AddMethodToClass[$category, ringCategoryMethod, vectorsOverRingClass];

AC.AddMethodToClass[$category, fieldCategoryMethod, vectorsOverFieldClass];
AC.AddMethodToClass[$category, vectorSpaceCategoryMethod, vectorsOverFieldClass];


AC.AddMethodToClass[$makeVectorStructure, makeVectorStructureMethod, Structures.StructuresClass];



END.


HVectorsImpl.mesa
Last Edited by: Arnon, July 19, 1985 2:54:46 pm PDT

Errors and Types
Vector Structure Ops
Conversion and IO
Args are a StructureElement and a Structure
See if can recast firstArg into thisStructureCoordinateStructure
If firstArg is a Vector, check if can recast its coordinateStructure into thisStructureCoordinateStructure, and if has right dimension; if so, recast all its elements.
Can't do it
Args are either [Structure, Structure] or [StructureElement, Structure]
Constructor
Assumes scalar is an element of coordinateStructure
Attempts to recast supplied elements into coordinateStructure.
If data = NIL then returns empty vector.
Selection
Arithmetic
firstArg is scalar, secondArg is vector 

ComponentWiseMultiply: PUBLIC AC.BinaryOp;

ComponentWisePower: PUBLIC AC.BinaryOp;

ComponentWiseInvert: PUBLIC AC.UnaryOp;

ComponentWiseDivide: PUBLIC AC.BinaryOp;
Comparison
Operations
firstArg is a Vector, secondArg is a unary Method (e.g. UnaryOp, UnaryPredicate) on its coordinateStructure, result is Vector of results of applications of the unary operation to the elements of firstArg.
firstArg and secondArg are Vectors over the same coordinateStructure, and of the same length. thirdArg is a binary Method (e.g. BinaryOp, BinaryPredicate) on coordinateStructure. The result is a Vector of the results of the application of the binary operation to corresponding pairs of elements of firstArg and secondArg.
Standard Desired Arg Structures
VectorIntAndCoordinateDesired: PUBLIC AC.UnaryToListOp ~ {
thisVectorStructureData: VectorStructureData _ NARROW[arg.data];
coordinateStructure: Object _ thisVectorStructureData.coordinateStructure;
RETURN[ LIST[arg, Ints.Ints, coordinateStructure] ]; -- arg assumed to be a Vector Structure
};
Start Code
subclass[vectorsClass]
subclass[vectorsOverGroupClass]
subclass[vectorsOverRingClass]
Κά˜Jš
œ™J™3J™š
Οk	˜	Jš
œ˜Icode˜K˜	K˜Kš
œ˜Kš
œ˜K˜Jš
œ˜—J˜
head2šœ
œ
˜Jšœœ5˜EJšœ
˜J˜—Jšœ
œ
œ˜'
head™Jš	œ
œ
œ
œœ
˜0Jš	œœ
œœœ
˜MJš	œœ
œœœ
˜>J˜Jšœœœ˜Jšœœœ˜—š
œ™šΟnœœ
œ˜=šœ+œ˜IK˜	Kš
œ)˜)K˜Kš
œ˜—Kšœœ9˜LKšœ
œ
œœ˜1šœ˜šœœ˜*Kšœœ
˜
Kš
œ˜Kš
œ!˜!Kš
œ˜—šœœ˜,Kšœœ
˜
Kš
œ˜Kš
œ!˜!Kš
œ˜—šœ#œ˜4Kšœœ
˜
Kš
œ˜Kš
œ!˜!Kš
œ˜—šœ,œ˜=Kšœœ
˜
Kš
œ˜Kš
œ!˜!Kš
œ˜—Kšœœ-˜=—Kš
œ7˜7Kš
œ
œ)œ
œ
œ#˜\K˜—šž	œ	œ
˜!Jšœœ
˜,KšœœD˜ešœ
˜Jš
œ˜Jšœ
œ,œ˜WJš
œ˜—J˜J˜—šžœ	œ
˜&Jšœœ
˜,KšœœD˜ešœ
˜J˜Jšœ
œ,œ˜XJš
œ˜Jš
œ˜—J˜J˜—šžœ	œ˜*Jšœœ˜-Jšœ˜!J˜J˜—šž	œ	œ˜(Jšœœ˜3Jšœ˜J˜J˜—šžœœ
œ˜/Jšœ
œ"˜/J˜J˜——š
œ™šžœ	œ
˜Jš
œ+™+J˜(Jšœ/œ˜PJš
œW˜WJš
œ@˜@KšœœG˜cKšœœD˜]Jšœœ
˜J˜Jš	œ
œ+œ
œΟc˜WJ˜Jš
œ@™@Jšœœ(œ5˜jšœœ˜Jšœœ(œ/˜uJšœ4˜:Jš
œ˜J˜—Jš
Ϥ
™§
šœ
œ;œ
œ˜JJš
œ.˜.Jšœ0œ˜RJš
œY˜YJš
œB˜BJšœœ˜,Jš
œ˜Jšœ0œ
œ
œ˜CJšœœ(œH˜}Jšœ
œœ
œ
œŸ
˜(Jšœ
œ-˜=šœœ
œ˜+Jšœœ(œ1˜oJšœ
˜—šœœ
œ˜K˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜—K˜K™Kšœ
œ˜K˜J˜—šž	œ	œ˜(Jš
œG™GJ˜(Jšœ/œ˜PJš
œW˜WJš
œ@˜@KšœœG˜cJšœœ
˜Jšœœ$œœ
œœ
œ
œ
˜“
Jš
œ
œ8œ
œ
œ˜OJ˜Jšœœ(œ8˜mJšœœ
œ
œ˜J˜šœ
œ>œ
œ˜MJš
œ1˜1Jšœ0œ˜RJš
œY˜YJš
œB˜BJšœ0œ
œ
œ˜EJšœœ(œH˜}Jšœ˜
K˜—Kšœ
œ˜K˜J˜—šžœ	œ
˜Jšœœ
˜)Jšœ+œ˜AJšœœ!˜/Jš	œœ
œ
œœ
˜'KšœœK˜^š	œœ

œ
œ˜$Jš	œœ
œ
œœ ˜]Kšœ
˜—JšœNŸ˜hJš
œ˜—šžœ	œ˜.šœ˜Kšœœ
œ˜Kšœ
˜—Kšœ
œ˜J˜J˜—šžœœ
œ˜Jšœ%œ˜<Jšœœ,˜CJšœœ
œ5˜OJšœ
œ
˜Kšœ
œ˜Kšœœ˜Jš	œœ
œ
œ
œ
˜(Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœœ
œ!˜<Jš
œ˜Jš
œ˜Jšœœ˜.šœ˜Jšœœ6˜FKš
œ˜Jš
œ˜š	œœ
œœ˜8Jšœœ+˜A—Jš
œ˜Jš
œ˜šœ˜Jšœœ
œ˜8—Kšœ
˜—Jšœ
œ˜&šœœ
œ
˜Jš
œ˜Jš
œ˜Jšœ
˜—Jšœœ
œK˜WJ˜J˜—šžœœ
œ˜"Jšœœ
œ˜"J˜J˜—šžœœ
œ˜Jšœ+œ˜AJšœœ2˜IJšœœ
œ7˜SJšœœ
˜%Jš
œ˜šœœ
œ˜*Jšœ	œ%œ˜]Kšœœ˜@Jšœ
˜—Jš
œ˜K˜J˜—šžœœ˜Jš
œ˜Jš
œ˜——™šžœœ
œ˜'Jš
œ3™3Jšœœ˜&Jšœœ˜8šœœ
œ˜Jš
œ˜Jšœ
˜—šœœ
œ˜K˜Kš
œ˜Kš
œ˜Kš
œ˜—Jš
œ˜J˜—šž
œœ
œ˜%Jš
œ>™>Jš
œ(™(Jšœ%œ˜<Jšœœ,˜CJšœœ˜)Kšœœ7˜PKšœœ˜Kšœœ
œ
œ˜Jš
œ˜Jšœœ
œ%œ
˜=Jšœœ
œ˜9Jšœ
œ˜)šœœ
œ˜Jšœ
œ(œ$˜_Jšœœ
œ
˜%Jš
œ˜Jšœ
˜—Jšœœ
œK˜WJ˜——š
ž	™	šž
œœ
œ
˜"Jšœœ˜.Jšœœ˜#Jš
œ	œ"œ
œ
œ˜@Jšœ˜K˜K˜——š
œ
™
šžœœ
œ˜Jš
œ=˜=Jšœœ4œ˜aJšœ ˜&J˜J˜—šžœ	œ˜Jš
œ=˜=Jšœœ3œ˜_Jšœ˜%J˜J˜—šžœœ
œ
˜Jš
œB˜BJšœœ4˜JJšœœ
œ
œ˜7Jšœ7˜=J˜J˜—šžœ	œ˜Jš
œ=˜=Jšœœ9˜TJšœœ
œ
œ˜<Jšœ+˜1J˜J˜—šžœ	œ
˜ Jš
œB˜BJšœœ;˜XJšœœ
œ
œ˜>Jšœ>˜DJ˜J˜—šžœ	œ
˜&J™(Jšœœ˜0Jšœ+œ˜HJš
œF˜FJšœœ!˜/Kšœœ8˜RJš
œ˜Jšœ
œ˜,šœœ
œ˜Jšœœ)œŸ
˜]Jšœ
˜—Jšœ	œ
œT˜cK˜J™—šžœ	œ
™*J™—šžœ	œ
™'J™—šžœ	œ	™'J™—Jšžœ	œ
™(—š
ž
™
šžœœ
œ˜$Jšœœ˜1Jšœœ˜3Jšœ+œ˜GKšœ!œN˜qJšœ<œ
œ
œ˜Qšœœ
œ"˜1Jšœ
œ
œ0œ'œ
œ
œ˜wJšœ
˜—Jšœ
œ˜
J˜——š
ž
™
šžœœ
œ˜.Kšœ8žœžœ}™Μ
Jšœœ˜/Kšœœ˜#Jšœ)œ
œ
˜9Jšœœ˜+Jšœœ˜5šœœ
œ˜Jšœ
œ"œ˜HJšœ
œ
œ+˜BJšœ
˜—Jš	œœ
œ
œŸ˜PJš
œI˜Išœœ
œ˜K˜Kš
œ˜Kš
œ
˜
Kš
œ˜—K˜K˜—šžœœ
œ˜0Kšœ€
žœžœ¨
™ΑJšœœ˜.Jšœœ˜0Kšœœ˜"Jšœ)œ
œ
˜9Jšœœ˜+Jš
œB˜BJšœœ˜5šœœ
œ˜Jšœ
œ3œ"Ÿ˜vJšœ
œ
œ+˜BJšœ
˜—Jš	œœ
œ
œŸ˜PJš
œI˜Išœœ
œ˜K˜Kš
œ˜Kš
œ
˜
Kš
œ˜—K˜——™šžœœ
œ˜0JšœœŸ'˜GJ˜J˜—šžœœ
œ˜7Jšœ/œ˜@Jš
œJ˜JJšœœŸ'˜QJ˜—šžœœ
œ˜7Jšœ/œ˜@Jš
œJ˜JJšœœŸ'˜QJ˜—šžœœ
œ™:Jšœ/œ™@Jš
œJ™JJšœœ)Ÿ'™\J™——™
š	œœ
œœœ˜AK˜—šœœ
œ2œ˜\Kš
œ™K˜—šœœ
œ:œ˜cKš
œ™K˜—šœœ
œ:œ˜dKš
œ™—J˜Jš
œœœœ
œœœ˜ZJš
œœœœ
œœœ˜^Jš
œœœœ
œœœ˜\Jš
œœœœ
œœœ˜^Jš
œ$œœœ
œœœ˜jJš	œ œœœœ˜YJš	œ œœœœ˜YJšœœœœ
œœ˜xJšœœœœ
œœ˜_Jšœœœœ
œœ˜vJšœœœœ
œœ
œœ
žœ
˜“
Jšœœœœ
œ%œ˜ˆ
Jšœœœœ
œœ
˜VJšœœœœ
œœ˜iJšœœœœ
œœ˜`Jš
œœœœ
œœœ˜]Jšœœœœ
œœ˜wJšœœœœ
œœ˜jJš
œœœœ
œœ
œ5˜“
Jšœœœœ
œœ
˜\Jšœœœœ
œœ	˜YJšœœœœ
œœ
œœ&˜‰
Jšœœœœ
œœ
œœ+˜”
Jšœœœœ
œœ
œœ-˜œ
Jš
œœœœ
œœ
œ?˜€
Jšœœœœ
œœ
œœ)˜ž
Jšœ"œœœ
œ%œŸ+˜­
Jšœ#œœœ
œ'œŸ+˜²
J˜Jšœ$œ(œœ
œ4œ˜«
J˜J˜Jšœ>˜@JšœI˜KJšœI˜KJšœG˜IJšœ7˜9Jšœ=˜?Jšœ7˜9JšœG˜IJšœ3˜5Jšœ;˜=Jšœ7˜9Jšœ5˜7Jšœ7˜9Jšœ?˜AJšœ9˜;JšœD˜FJšœF˜HJ˜JšœI˜KJšœ<˜>Jšœ:˜<JšœD˜FJšœH˜JJ˜JšœG˜IJ˜JšœI˜KJšœO˜QJ˜J˜Jšœ_˜aJ˜—˜J˜—Jšœ
˜J˜J˜—…—O lΔ