CORE_MorseArray.hpp

Go to the documentation of this file.

#ifndef CORE_MorseArray_HPP
#define CORE_MorseArray_HPP

template<class T>
tString CORE_MorseArray<T>::toString() const {
    tString ret="";
    ret+="Max values number per element:"+CORE_Integer::toString(mLD)+"\n";
    ret+="Increment for indices:"+CORE_Integer::toString(mIncI)+"\n";
    ret+="Number of elements:"+CORE_Integer::toString(mSize)+"\n";
    ret+="Values:"+mValues.toString()+"\n";
    ret+="Indices:"+mIndices->toString()+"\n";
    return ret;
}

template<class T>
tBoolean CORE_MorseArray<T>::saveToFile(const tString& fileName) const {
    
    
    ofstream f(fileName.c_str(),ios::out);
    
    if (f) {
        f << "# save a morse array \n";
        f << "# M is the number of element \n";
        f << "# P: is the max number of values at each element \n";
        f<< mSize<<"\t"<<mLD<<"\n";
        f << "# U is 1: if the tensor is uniform over the domain, 0: otherwise \n";
        f <<((tUSInt)!mIncI)<<"\n";
        f << "# M[i][0] M[i][1] .... M[i][d] with d< P and i in [0,getSize()[ and line may be empty for no data on element i \n";
        
        
        //index of first element value in increasing order
        const tUIndex *k0=&(*mIndices.get())[0];
        
        //number of values of the element i
        tUIndex d,n;
        //values of the morse array
        const T* Mi=&mValues[0];
        
        if (mIncI==1) {
            for (tUIndex i=0;i<mSize;i++) {
                //size of the element
                n=(*(k0+1))-(*k0);
                if (n>0) {
                    for (d=0;d<n;d++) {
                        f<< (*Mi)<<"\t";
                        Mi++;
                   }
                }
                //next element 
                k0++;
                f<<"\n";
            }
        } else {
            //uniform
            n=(*(k0+1))-(*k0);
            if (n>0) {
                for (d=0;d<n;d++) {
                    f<< (*Mi)<<"\t";
                    Mi++;
                }
            }
            f<<"\n";
        }
        
        //free the file pointer
        f.close();
    } else {
        return false;
    }
    return true;   
}

template<class T>
tBoolean CORE_MorseArray<T>::loadFromFile(const tString& fileName) {
    
    
    ifstream f(fileName.c_str(),ios::in);
    
    if (f) {
        
        // number of line
        tUInteger numLine=0;
        //tUInteger maxLines=CORE_Object::getMaxUInt();
        
        //for reading a line
        tUSInt len=1024;
        char line[len];
        
        //for analysing a line
        SP::CORE_String tokenizer=CORE_String::New();
        
       //number of tokens per line
        tUInteger i,nTokens;
        
        //index of comment char
        tUIndex iComment;

        //to stop the reading if all data are read
        tUIndex nDataRead=0;
        tUSInt nLinesBeforeData=0;
        tUSInt nMaxLinesBeforeData=10;
      
        tBoolean isUniformRead=false;

        //reset the attributes
        mSize=0;
        mLD=0;
        mIncI=1;
        mPacksNumber=0;
        mIsConstant=false;
        mValues.setSize(0);
        mIsIndicesReferenced=false;
        mIndices=CORE_UIndexArray::New();

        tReal *Mi=null;
        tUIndex *indices=null;
        tUIndex n=0;
        
        while ( (!f.eof()) && ((mSize==0) || (nDataRead<mSize)) ) {
            
            //read the line
            f.getline(line,len);
            numLine++;
            
            //analyse the line
            tokenizer->setString(line);
            
            //ignore comment part
            iComment=tokenizer->getString().find("#");
            if (iComment!=tString::npos) {
                
                //comment line
                if (iComment==0) continue;
                
                //ignore all chars after #
                tokenizer->setString(tokenizer->getString().substr(0,iComment));
            }
            
            //erase blanks before and after line
           tokenizer->trim();
           
           //anaylyse all the tokens of the line
           tokenizer->tokenize();

           //get the number of token
           nTokens=tokenizer->getTokensNumber();

           //read the data
           if (mSize==0) {
               if (nTokens>=2) {
                   mSize=CORE_Integer::parseInt(tokenizer->nextToken());
                   mLD=CORE_Integer::parseInt(tokenizer->nextToken());
                   if ((mSize==0) || (mLD==0)) {
                       //no data
                       return false;
                   }
                   mValues.setSize(mSize*mLD);
                   mIndices->setSize(mSize+1);
                   Mi=&mValues[0];
                   indices=&(*mIndices.get())[0];
                   *indices=0;
                   indices++;
               } else {
                   nLinesBeforeData++;
                   if (nLinesBeforeData>nMaxLinesBeforeData) {
                       //no data
                       cout << "warning : no data in file "<<fileName<<"\n";
                       return false;
                   }
               }
               continue;
           }

           //read uniform data if not read
           if (!isUniformRead) {
               if (nTokens>=1) {
                   mIncI=!((tBoolean)CORE_Integer::parseInt(tokenizer->nextToken()));
                   isUniformRead=true;
                   if (mIncI==0) mIsConstant=true;
               } else {
                   nLinesBeforeData++;
                   if (nLinesBeforeData>nMaxLinesBeforeData) {
                       //no data
                       cout << "warning : no data in file "<<fileName<<"\n";
                       return false;
                   }
               }
               continue;
           }

           //read the values
           if (nTokens==0) {
               //empty lines no data
               *indices=n;
               indices+=mIncI;
              
           } else {
               //read the data
               n+=nTokens;
               *indices=n;
               indices+=mIncI;
               for (i=0;i<nTokens;i++) {
                   (*Mi)=CORE_Real::parseReal(tokenizer->nextToken());
                   Mi++;
               }
              
              
           }

           //uniform case
           if (mIncI==0) {
               nDataRead=mSize;
               mIndices->setSize(2);
           } else {
               nDataRead++;
           }
           
        } //reading next line

        //free the file pointer
        f.close();
        
        
    } else {
        throw CORE_Exception("common/core",
                             "CORE_MorseArray::loadFromFile("+fileName+")",
                             "impossible to open file");
        return false;
    }
    //fit the size of values
    fitToSize();
    
    return true;
}

template<class T>
void CORE_MorseArray<T>::removeValue(const T& value) {
    tUIndex *I=&(*mIndices.get())[0];
    T * Vs=&mValues[0];

    const T* W=&mValues[0];
    //index for W in [0,old size of values [
    tUIndex j=0;
    //index for Vs in [0,new size of values [
    tUIndex index=0;

    //element index in [0,mSize[
    tUIndex i;

    I++;
    for (i=0;i<mSize;i++) {
        while (j<(*I)) {
            //copy all the elemenys which are different
            if ((*W)!=value) {
                //register the element
                (*Vs)=(*W);
                Vs++;
                index++;
            }
            
            //next value of element
            W++;
            j++;
        }

        //next index of element
        (*I)=index;
        I++;
       
    }
    
    
}

template<class T>
tBoolean CORE_MorseArray<T>::uniformize(tBoolean& isConstant) {

    tBoolean isUni=true;
    isConstant=true;
    
    //no element or 1 element
    if (mSize<=1) {
        return isUni;
    }

    //if the mose array is already uniform
    if (isUniform()) {
        return isUni;
    }
    
    //zero value
    tReal eps=1.e-12;
    
   
   
    
    //curent index element
    tUIndex i=0;
    const tUIndex *I=&(*mIndices.get())[i];
    const T *Vi,*V=&mValues[*I];
    
    //get the first refreence element
    const T *Ri,*R=&mValues[0];
    //the uniform size
    tUIndex k,sR=((*(I+1))-(*I));
    tUIndex s=sR;
    //next element
    i++;
  
    while (i<mSize) {

        //read the index & values of the element i
        I+=mIncI;
        V+=s*mIncI;

        //size of the next element
        s=((*(I+1))-(*I));

        //verify the size & values of the values of the elemnt is the same as the first element
        if (s!=sR) {
            isUni=false;
            if (s!=0) {
                isConstant=false;
            }
        }
        Ri=R;
        Vi=V;
        for (k=0;k<sR;k++) {
            if (fabs((*Vi)-(*Ri))>eps) {
                //different not null value: not constant  & not uniform
                isConstant=false;
                return false;
            }
            Vi++;
            Ri++;
        }
        
        //next element
        i++;
       
    }

    if (isUni) {
        //the morse array is uniform
        mLD=sR;
        mIncI=0;
        //resize the array
        mIndices->setSize(2);
        mValues.setSize(mLD);
        //erase the unused memory
        mValues.fitToSize();
        mIndices->fitToSize();
    }
    return isUni;
}

template<class T>
void CORE_MorseArray<T>::MergeMorseArray(const tUInteger& nSubsets,
                                        CORE_UIndexArray& indices,
                                        const tUIndex& ld,
                                        CORE_Array<T>& array) {
    if (nSubsets==1) {
        array.setSize(indices[indices.getSize()-1]);
        array.fitToSize();
        return;
    }
    
    //merge the subset arrays
    tUInteger subsetId=0;
    
    //the size of indices is N+nSubsets : N is the number of elements.
    tUIndex N=indices.getSize()-nSubsets;

    tUIndex i,start,end;
   
    
    //copy the endices of the first pack from [start,end[
    // Ig is the indices of the global indices
    tUIndex *Ig=&indices[0];
    tUIndex index=0;
    
    // Ip is the indices of the pack indices
    const tUIndex *Ip=null;
    // Ag is the global vector values
    T *Ag=&array[0];
    // Ap is the pack vector values
    const T *Ap=null;
    //Number of elemnts to copy
    tIndex nA,k;
    
    
    for (subsetId=0;subsetId<nSubsets;subsetId++) {

        //start index of the packed array subsetId 
        start=subsetId*N/nSubsets;
        
        //end index of the packed array subsetId
        end=(subsetId+1)*N/nSubsets;

        if (start<end) { //not empty pack
            
            //index of the first element of array subsetId in [0,N/nSubsets]
            Ip=&indices[start+subsetId];
            
            //set the pointer of array to start element of the packed array subsetId
            Ap=&array[start*ld];
            
            for (i=start;i<end;i++) {
                
                //copy the index of the begining
                (*Ig)=index;
                
                //index of next global element
                Ig++;
                
                //merge indices Ic into Ii
                //number of element of the row i
                nA=(*(Ip+1)-(*Ip));
                
                //index of next element of subset
                Ip++;
                
                //merge array Ac into Ai
                for (k=0;k<nA;k++) {
                    (*Ag)=(*Ap);
                    Ag++;
                    Ap++;
                }
                
                
                //update the new index of the element
                index+=nA;
                
                
                
            } //end loop on i
        }//end not empty pack

        
        
        
    } //end loop on subset
  
    

        
    
    //fit the arrays to util size
    indices.setSize(N+1);
    indices[N]=index;
    indices.fitToSize();
    
    array.setSize(index);
    array.fitToSize();
}


template<class T>
void CORE_MorseArray<T>::MergeMorseArrays(const tUInteger& nSubsets,
                                         CORE_UIndexArray& indices,
                                         const tUIndex& ld,
                                         const vector<CORE_Array<T>* >& arrays) {
    typename vector<CORE_Array<T>* >::const_iterator iArray;
    
    
    if (nSubsets==1) {
        //index is the index of the last exluded element
        // which is the size of the usefull array 
        tUIndex index=indices[indices.getSize()-1];
        iArray=arrays.begin();
        while(iArray!=arrays.end()) {
            CORE_Array<T> &array=*(*iArray);
            array.setSize(index);
            array.fitToSize();
            iArray++;
        }
        return;
    }
    //merge the subset arrays
    tUInteger subsetId=0;
    
    //the size of indices is N+nSubsets
    tUIndex N=indices.getSize()-nSubsets;

    tUIndex i,start,end;
   
    
    //copy the endices of the first pack from [start,end[
    // Ig is the indices of the global indices
    tUIndex *Ig=&indices[0];
    tUIndex index=0;
    
    // Ip is the indices of the pack indices
    const tUIndex *Ip=null;
    

    //Number of elemnts to copy
    tIndex nA,k;

    
    tUIndex s,nArrays=arrays.size();
    T* Ags[nArrays];
    const T* Aps[nArrays];
    
    
    
    iArray=arrays.begin();
    if (iArray==arrays.end()) {//no arrays
        return;
    }
    
    //build the curent general array pointers Ais
    s=0;
    while(iArray!=arrays.end()) {
        CORE_Array<T> *array=(*iArray);
        if (array==null) {
            //a null pointer erreor
            return;
        }
        if (array->getSize()<=index) {
            //all array are full filled
            return;
        }
        Ags[s]=&(*array)[0];
        
        //next array
        iArray++;
        s++;
    }
   
    //merge the arrays
    for (subsetId=0;subsetId<nSubsets;subsetId++) {
        
        //start index of the packed array subsetId 
        start=subsetId*N/nSubsets;

        //end exlcued index of the packed array subsetId 
        end=(subsetId+1)*N/nSubsets;


        if (start<end) { //not empty pack
            
            //index of the first element of array subsetId in [0,N/nSubsets]
            Ip=&indices[start+subsetId];
            
            //set the pointer of arrays of subset to start element
            iArray=arrays.begin();
            s=0;
            while(iArray!=arrays.end()) {
                Aps[s]=&(*(*iArray))[start*ld];
                s++;
                iArray++;
            }
            
            for (i=start;i<end;i++) {

                //copy the index of the begining
                (*Ig)=index;
                Ig++;
                
                //merge indices Ip into Ig
                nA=(*(Ip+1)-(*Ip));
                Ip++;

                
                
                //merge array Ac into Ai
                for (s=0;s<nArrays;s++) {
                    T* &Ag=Ags[s];
                    const T* &Ap=Aps[s];
                    
                    for (k=0;k<nA;k++) {
                        (*Ag)=(*Ap);
                        Ag++;
                        Ap++;
                    }
                }
            
                index+=nA;
            } //end loop on i
            
        }//end not empty pack

        
    } //end subset loop
    
    //fit the arrays to util size
    indices.setSize(N+1);
    indices[N]=index;
    indices.fitToSize();
    
    iArray=arrays.begin();
    while(iArray!=arrays.end()) {
        CORE_Array<T> &array=*(*iArray);
        array.setSize(index);
        array.fitToSize();
        iArray++;
    }
    
    
    
}
#endif