
    <<LichenArrayStuff.mesa>>
        <<Last tweaked by Mike Spreitzer on April 28, 1987 2:05:10 pm PDT>>

    DIRECTORY LichenDataStructure, LichenSetTheory, RefTab;

    LichenArrayStuff: CEDAR DEFINITIONS
        IMPORTS RefTab
        =

    {OPEN LichenSetTheory, LichenDataStructure;

    GIPair: TYPE = ARRAY End OF NATURAL;

    PackArrayIndex: PROC [ArrayIndex] RETURNS [PackedArrayIndex];
    UnpackArrayIndex: PROC [PackedArrayIndex] RETURNS [ArrayIndex];

    Central: PROC [a: Array, ai: ArrayIndex] RETURNS [BOOL];

    HasMiddle: PROC [gp: GroupingParms] RETURNS [has: BOOL]
        = INLINE {has _ gp.middle.maxPlusOne > gp.middle.min};
    ComputeGroupingsIndex: PROC [a: Array, ai: ArrayIndex] RETURNS [gi2, gii2: Nat2, gi, cgii: NATURAL];
    GPMiddle: PROC [gp: GroupingParmses] RETURNS [r2: Range2]
        = INLINE {r2 _ [gp[Foo].middle, gp[Bar].middle]};
    Gi2ToAir: PROC [a: Array, gi2: Nat2] RETURNS [air: Range2, ngii2: Nat2, ngii: NATURAL];
    GiToGi2: PROC [a: Array, gi: NATURAL] RETURNS [gi2: Nat2]
        = INLINE {
            gi2[Foo] _ gi / a.groupingParmses[Bar].sum;
            gi2[Bar] _ gi - gi2[Foo] * a.groupingParmses[Bar].sum};
    ComputeJointGroupingsIndex: PROC [a: Array, j: Joint, jii: Nat2] RETURNS [jgi2: Nat2, jgi, ctii: NATURAL, jiir: Range2];
        <<<low side's groupings index, high side's gi> >>
    ArrayJointIndex: PROC [a: Array, phase: Nat2] RETURNS [i: INT]
        = INLINE {i _ a.jointsPeriod[Bar]*phase[Foo] + phase[Bar]};

    Jgi2ToLair: PROC [a: Array, phase: Nat2, j: Joint, jgi2: Nat2] RETURNS [lair, jiir: Range2, jCount: NATURAL];
    Jgi2ToGi: PROC [a: Array, d: Dim, phase: Nat2, j: Joint, jgi2: Nat2, side: End] RETURNS [gi2: Nat2, gi: NATURAL];
    Jgi2ToGip: PROC [a: Array, d: Dim, phase: Nat2, j: Joint, jgi2: Nat2] RETURNS [gip: GIPair];
    AgiToAi: PROC [a: Array, gi2, gii2: Nat2] RETURNS [ai: ArrayIndex];
    EnumJgiOfGi: PROC [a: Array, gi2: Nat2, Consume: PROC [d: Dim, j: Joint, side: End, jgi2, phase: Nat2]];

    EnumerateGroupsContainingPort: PROC [a: Array, ep: Port, Consume: PROC [gi2: Nat2, gi: NATURAL, g: Group]];
    EnumerateArrayWiresContainingGroup: PROC [a: Array, gi2: Nat2, gi: NATURAL, g: Group, Consume: PROC [ArrayWire], addIfMissing: 
    BOOL];
    EnumerateGroupsOfArrayWire: PROC [a: Array, aw: ArrayWire, Consume: PROC [gi2: Nat2, gi: NATURAL, g: Group, membership: 
    BoolSeq--group instance index 
    PortToGroup: PROC [a: Array, gi: NATURAL, ep: Port] RETURNS [g: Group] = INLINE {
        gs: Groupings = NARROW[a.groupingses[gi]];
        g _ NARROW[gs.toGroup.Fetch[ep].val];
        };

    BestGroup: PROC [g: Group] RETURNS [bg: Group]
        = INLINE {IF g = NIL THEN bg _ g ELSE FOR bg _ g, bg.better WHILE bg.better # NIL DO NULL ENDLOOP};


    GetArrayJoint: PROC [a: Array, d: Dim, phase: Nat2] RETURNS [j: Joint]
        = INLINE {j _ NARROW[a.joints[d][ArrayJointIndex[a, phase]]]};


    FetchTie: PROC [j: Joint, side: End, jgi: NATURAL, g: Group] RETURNS [tie: Tie]
        = INLINE {rt: RefTable = NARROW[j.toTie[side][jgi]]; tie _ NARROW[rt.Fetch[g].val]};

    BestTie: PROC [x: Tie] RETURNS [bx: Tie]
        = INLINE {FOR bx _ x, bx.better WHILE bx.better # NIL DO NULL ENDLOOP};

    GroupsHypotheticallyConnected: PROC [a: Array, j: Joint, jgi: NATURAL, gs: ARRAY End OF Group] RETURNS [BOOL];

    GroupsActuallyConnected: PROC [a: Array, j: Joint, jgi: NATURAL, lai: Nat2, gs: ARRAY End OF Group] RETURNS [BOOL];

    FetchRPD: PROC [a: Array, d: Dim, rp: SidedPort] RETURNS [rpd: SidedPortData]
        = INLINE {rpd _ NARROW[a.toRole[d][rp.side].Fetch[rp.port].val]};

    GetRoot: PROC [a: Array, d: Dim, rp: SidedPortData, clai: NATURAL] RETURNS [root: NATURAL];
    GetNext: PROC [rp: SidedPortData, clai: NATURAL] RETURNS [next: NATURAL];
    RPDNeedsLinks: PROC [a: Array, d: Dim, rpd: SidedPortData] RETURNS [needs: BOOL];

    EnumerateJoints: PROC [a: Array, Consume: PROC [d: Dim, phase: Nat2, j: Joint]];
    EnumerateTies: PROC [a: Array, Consume: PROC [d: Dim, phase: Nat2, jgi: NATURAL, jgi2: Nat2, j: Joint, tie: Tie]];
    EnumerateTiesOfGroup: PROC [a: Array, gi2: Nat2, g: Group, Consume: PROC [d: Dim, phase: Nat2, jgi: NATURAL, jgi2: Nat2, j: Joint, 
    tie: Tie, side: End]];
    ArrayEltPortsConnectedByJoint: PROC [a: Array, d: Dim, lowIndex: ArrayIndex, rp1, rp2: SidedPort] RETURNS [hypothetically, really: 
    BOOL];
    ArrayEltPortsConnected: PROC [a: Array, ai1, ai2: ArrayIndex, ep1, ep2: Port] RETURNS [hypothetically: BOOL];

    IsIncompleteArray: PROC [ct: CellType] RETURNS [BOOL];

    GroupInWireAt: PROC [a: Array, gi2: Nat2, g: Group, aw: ArrayWire, ai: ArrayIndex] RETURNS [BOOL];

    GetArrayPortForPort: PROC [act: CellType, a: Array, index: ArrayIndex, ep: Port, mayAdd: BOOL] RETURNS [arrayPort: Port];
    GetArrayPortForGroup: PROC [act: CellType, a: Array, index: ArrayIndex, g: Group, mayAdd: BOOL] RETURNS [arrayPort: Port];

    MakeGroupsForPort: PROC [a: Array, ep: Port];
    GetGroup: PROC [a: Array, gi: NATURAL, ep: Port, mayAdd: BOOL] RETURNS [g: Group];
    MakeGroup: PROC [a: Array, gi2: Nat2, gs: Groupings] RETURNS [g: Group];
    AddPortToGroup: PROC [a: Array, gi: NATURAL, ep: Port, g: Group, links: BOOL];
    RemovePortFromGroup: PROC [a: Array, gi: NATURAL, ep: Port, g: Group];
        <<Can not be called on incomplete arrays.>>
    UnrolePort: PROC [a: Array, ep: Port];
        <<Can not be called on incomplete arrays.>>
    AddTie: PROC [j: Joint, jgi: NATURAL, tie: Tie];
    MakeArrayConnection: PROC [ct: CellType, d: Dim, lowRange: Range2, rp1, rp2: SidedPort, may: BOOL] RETURNS [connected: BOOL];
        <<If NOT may, don't doubt hypotheses.>>
    FlushArrayWires: PROC [a: Array, doomedArrayPorts: Set--of port of a--];
    TrimEmptyGroups: PROC [a: Array];
    ArrayWireForGroup: PROC [a: Array, index: ArrayIndex, gi: NATURAL, g: Group, mayAdd: BOOL] RETURNS [aw: ArrayWire];
    SetArrayPortForGroup: PROC [a: Array, index: ArrayIndex, gi: NATURAL, g: Group, ap: Port];
    SetArrayPortForPort: PROC [a: Array, index: ArrayIndex, ep, ap: Port];
    EnsurePortForGroups: PROC [act: CellType, gis, giis: ARRAY End OF Nat2, gss: GroupListPair] RETURNS [ap: Port];
    CrossATie: PROC [ct: CellType, d: Dim, fromP: Port, fromS: End] RETURNS [toP: Port];
    ComputeTieCompleteAt: PROC [a: Array, d: Dim, tie: Tie, clai: NATURAL] RETURNS [complete: BOOL];
    RetractFalseHypotheses: PROC [act: CellType];
    TrimArray: PROC [a: Array];
        <<Remove SidedPortData.links where possible.>>
        <<Remove Ties with one empty side.>>

    DeleteGroup: PROC [a: Array, g: Group];
    DeleteTie: PROC [j: Joint, jgi: NATURAL, tie: Tie];

    FmtIndex: PROC [a: Array, index: ArrayIndex] RETURNS [asRope: ROPE];
    Subscript: PROC [ROPE, INT] RETURNS [ROPE];
    Subscript2: PROC [ROPE, ArrayIndex] RETURNS [ROPE];

    }.