
<<VectorsImpl.mesa>>
<<Last Edited by: Arnon, July 19, 1985 2:54:46 pm PDT>>
<<>>
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;
<<Errors and Types>>
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;
<<Vector Structure Ops>>
    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] ];
};

<<Conversion and IO>>
Recast: PUBLIC AC.BinaryOp = {
<<Args are a StructureElement and a Structure>>
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

<<See if can recast firstArg into thisStructureCoordinateStructure>>
flag _ AC.ApplyPredNoLkpNoRecast[canRecastMethod,LIST[firstArg.class, thisStructureCoordinateStructure] ];
IF flag THEN  {
recastElement: Object _ AC.ApplyNoLkpNoRecastObject[recastMethod, LIST[firstArg, thisStructureCoordinateStructure] ];
RETURN[ ImbedScalar[recastElement, thisVectorStructure] ];
};

<<If firstArg is a Vector, check if can recast its coordinateStructure into thisStructureCoordinateStructure, and if has right 
dimension; if so, recast all its elements.>>
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
        ] ] ];
    };

    <<Can't do it>>
    RETURN[NIL];
    };

CanRecast: PUBLIC AC.BinaryPredicate = {
<<Args are either [Structure, Structure] or [StructureElement, Structure]>>
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] ]
};  
<<Constructor>>
ImbedScalar: PUBLIC AC.UnaryImbedOp ~ {
<<Assumes scalar is an element of coordinateStructure>>
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 ~ {
<<Attempts to recast supplied elements into coordinateStructure.>>
<<If data = NIL then returns empty vector.>>
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] ];
};
<<Selection>>
    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] ];
        };

<<Arithmetic>>
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 ~ {
<<firstArg is scalar, secondArg is vector >>
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] ];
    };
<<>>
<<ComponentWiseMultiply: PUBLIC AC.BinaryOp;>>
<<>>
<<ComponentWisePower: PUBLIC AC.BinaryOp;>>
<<>>
<<ComponentWiseInvert: PUBLIC AC.UnaryOp;>>
<<>>
<<ComponentWiseDivide: PUBLIC AC.BinaryOp;>>
<<Comparison>>
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];
};
<<Operations>>
    MapUnaryElementOp: PUBLIC AC.BinaryMixedOp ~ {
        <<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.>>
    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 ~ {
        <<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.>>
    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
            ] ] ];
        };
<<Standard Desired Arg Structures>>
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
};
<<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>>
    vectorsClass: AC.Object _ AC.MakeClass["VectorsClass", NIL, NIL];

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

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

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

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.