Actual source code: taois.c

      1: #include "tao_general.h"
     2:  #include taois.h

      6: /*@C
      7:    TaoIndexSetDestroy - Destroys the TaoIndexSet object.

      9:    Input Parameter:
     10: .  SS - the vector

     12:    Level: beginner
     13: @*/
     14: int TaoIndexSetDestroy( TaoIndexSet * SS){
     15:   TaoFunctionBegin;
     16:   if (SS) delete SS;
     17:   TaoFunctionReturn(0);
     18: }

     22: /*@C
     23:    Duplicate - Creates a new TaoIndexSet object with the same structure as this one.

     25:    Output Parameter:
     26: .  SS -  new TaoIndexSet object

     28:    Level: intermediate
     29: @*/
     30: int TaoIndexSet::Duplicate(TaoIndexSet** SS){
     31:   TaoFunctionBegin;
     32:   SETERRQ(56,"Operation not defined");
     33:   /* TaoFunctionReturn(1); */
     34: }

     39: /*@C
     40:    IsSame - Determines whether this index set is the same as another.

     42:    Input Parameter:
     43: .  ss -  an index set

     45:    Output Parameter:
     46: .  flg -  set to TAO_TRUE if the two index sets are the same and TAO_FALSE otherwise

     48:    Level: intermediate
     49: @*/
     50: int TaoIndexSet::IsSame(TaoIndexSet* ss, TaoTruth* flg){
     51:   TaoFunctionBegin;
     52:   SETERRQ(56,"Operation not defined");
     53:   /* TaoFunctionReturn(1); */
     54: }

     58: /*@C
     59:    ComplementOf - Let this index set be the complement of the input index set.

     61:    Input Parameter:
     62: .  ss -  an index set

     64:    Level: intermediate
     65: @*/
     66: int TaoIndexSet::ComplementOf(TaoIndexSet* ss){
     67:   TaoFunctionBegin;
     68:   SETERRQ(56,"Operation not defined");
     69:   /* TaoFunctionReturn(1); */
     70: }

     74: /*@C
     75:    IntersectionOf - Let this index set be the intersection of the given two index sets.

     77:    Input Parameter:
     78: +  ss1 -  an index set
     79: -  ss2 -  an index set

     81:    Level: intermediate
     82: @*/
     83: int TaoIndexSet::IntersectionOf(TaoIndexSet* ss1, TaoIndexSet* ss2){
     84:   TaoFunctionBegin;
     85:   SETERRQ(56,"Operation not defined");
     86:   /* TaoFunctionReturn(1); */
     87: }

     91: /*@C
     92:    UnionOf - Let this index set be the union of the given two index sets.

     94:    Input Parameter:
     95: +  ss1 -  an index set
     96: -  ss2 -  an index set

     98:    Level: intermediate
     99: @*/
    100: int TaoIndexSet::UnionOf(TaoIndexSet* ss1, TaoIndexSet* ss2){
    101:   TaoFunctionBegin;
    102:   SETERRQ(56,"Operation not defined");
    103:   /* TaoFunctionReturn(1); */
    104: }

    108: /*@C
    109:    WhichEqual - Describes which elements of the vectors equal one another.

    111:    Input Parameter:
    112: .  vv1, vv2 -  the vectors

    114:    Level: intermediate
    115: @*/
    116: int TaoIndexSet::WhichEqual(TaoVec* vv1,TaoVec* vv2){
    117:   TaoFunctionBegin;
    118:   SETERRQ(56,"Operation not defined");
    119:   /* TaoFunctionReturn(1); */
    120: }

    122: int TaoIndexSet::WhichLessThan(TaoVec* tv1,TaoVec* tv2){
    123:   TaoFunctionBegin;
    124:   SETERRQ(56,"Operation not defined");
    125:   /* TaoFunctionReturn(1); */
    126: }

    128: int TaoIndexSet::WhichGreaterThan(TaoVec* tv1,TaoVec* tv2){
    129:   TaoFunctionBegin;
    130:   SETERRQ(56,"Operation not defined");
    131:   /* TaoFunctionReturn(1); */
    132: }

    136: /*@C
    137:    WhichBetween - Describes which elements of vector tv are greater than
    138:    the corresponding element of vector low and less than corresponding element
    139:    of vector high.

    141:    Input Parameters:
    142: +  xxll -  the vector representing lower bounds on the vector tv
    143: .  vv - the TAO vector
    144: -  xxuu - the vector of upper bounds

    146:    Level: intermediate
    147: @*/
    148: int TaoIndexSet::WhichBetween(TaoVec* xxll,TaoVec* vv ,TaoVec* xxuu){
    149:   TaoFunctionBegin;
    150:   SETERRQ(56,"Operation not defined");
    151:   /* TaoFunctionReturn(1); */
    152: }

    156: /*@C
    157:    WhichBetweenOrEqual - Describes which elements of vector are in the closed
    158:    interface defined by the lower and upper bounds.

    160:    Input Parameters:
    161: +  xxll -  the vector representing lower bounds on the vector tv
    162: .  vv - the TAO vector
    163: -  xxuu - the vector of upper bounds

    165:    Level: intermediate
    166: @*/
    167: int TaoIndexSet::WhichBetweenOrEqual(TaoVec *xxll, TaoVec *vv, TaoVec *xxuu)
    168: {
    169:   TaoFunctionBegin;
    170:   SETERRQ(56,"Operation not defined");
    171:   /* TaoFunctionReturn(1); */
    172: }

    176: /*@C
    177:    GetSize - Describes which elements of vector tv are greater than
    178:    the corresponding element of vector low and less than corresponding element
    179:    of vector high.

    181:    Output Parameter:
    182: .  nn - the number of size of the index set.

    184:    Level: intermediate
    185: @*/
    186: int TaoIndexSet::GetSize(int *nn){;
    187:   TaoFunctionBegin;
    188:   SETERRQ(56,"Operation not defined");
    189:   /* TaoFunctionReturn(1); */
    190: }

    195: /*@C
    196:   View - Views the contents of the index set.
    197:
    198:   Input Parameters: none
    199:
    200:   Level: intermediate
    201: @*/
    202: int TaoIndexSet::View(){
    203:   TaoFunctionBegin;
    204:   SETERRQ(56,"Operation not defined");
    205:   /* TaoFunctionReturn(1); */
    206: }