datatypedef.h

Go to the documentation of this file.

/*
 * datatypedef.h
 *
 * Defines neccessary structs
 */


#ifndef _DATATYPEDEF_H_
#define _DATATYPEDEF_H_

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>

using std::string;

struct index_order{
    std::vector<int> order;
    int partition_number;
};


struct adj_map{
    int variable;
    long double factor;
};



struct cmp_map{

    int metric;

    std::vector<int> file1_partitions;
    int var1;

    int file2_partition;
    int var2;
};



struct rgb_color{
    int r;
    int g;
    int b;
};



struct pnt{
    long double *vals;
    int size;

    pnt(){
        size = 0;
        vals = NULL;
    }

    ~pnt(){
        if(size > 0)
            delete[] vals;
    }

    pnt(const pnt &p){
        size = p.size;  
        
        if(size > 0){
            vals = new long double[size];

            for(int i=0; i<size; i++){
                vals[i] = p.vals[i];
            }
        }
    }

    pnt & operator = (const pnt &p){
        
        if(this != &p){
            if(size > 0)
                delete[] vals;

            size = p.size;
            vals = new long double[size];

            for(int i=0; i<size; i++){
                vals[i] = p.vals[i];
            }
        }
        
        return *this;
    }
};



struct VariableDimensionArray {
    
    VariableDimensionArray(){
        this->index = NULL;
        index_size = 0;
    }

    ~VariableDimensionArray(){
        delete[] index;
    }

    VariableDimensionArray(const VariableDimensionArray &vda){
        this->sizes = vda.sizes;
        this->index_size = vda.index_size;

        if(index_size > 0){
            this->index = new int[index_size];

            for(int i=0; i<index_size; i++)
                index[i] = vda.index[i];
        }
    }

    VariableDimensionArray & operator = (const VariableDimensionArray &vda){
        if(this != &vda){
            if(index_size > 0)
                delete[] index;
        
            this->sizes = vda.sizes;
            this->index_size = vda.index_size;

            if(index_size > 0){
                this->index = new int[index_size];

                for(int i=0; i<index_size; i++)
                    index[i] = vda.index[i];
            }
        }

        return *this;
    }

    void initArray(std::vector<int> dim_sizes){

        if(this->index != NULL)
            return;

        int i_size = 1;
        for(int i=0; i<dim_sizes.size(); i++){
            i_size *= dim_sizes[i];
        }

        index = new int[i_size];
        index_size = i_size;

        for(int i=0; i<i_size; i++)
            index[i] = -1;

        for(int i=0; i<dim_sizes.size(); i++){
            this->sizes.push_back(dim_sizes[i]);
        }
    }

    int translate_coord_to_index(std::vector<int> vals){    
    
        int flat_i = 0;

        for(int i=0; i<vals.size(); i++){

            if(vals[i] >= sizes[i] || vals[i] < 0)
                return -1;

            int multiplier = 1;
            for(int m=(i+1); m<vals.size(); m++){
                multiplier *= sizes[m];
            }

            flat_i += vals[i] * multiplier;
        }

        return flat_i;
    }

    std::vector<int> translate_index_to_coords(int index){
        if(index > index_size){
            std::vector<int> blank_ret;
            return blank_ret;
        }

        std::vector<int> ret;

        for(int i=0; i<sizes.size(); i++){

            int dimsize = 1;
            for(int m=(i+1); m<sizes.size(); m++){
                dimsize *= sizes[m];
            }       
            
            ret.push_back(index / dimsize);
            index = index % dimsize;
        }

        return ret;
    }

    int getValue(std::vector<int> rLoc){

        if(rLoc.size() != sizes.size())
            return -1;

        int flat_i = translate_coord_to_index(rLoc);
        return index[flat_i];
    }

    void setValue(std::vector<int> rLoc, int rVal){
        
        if(rLoc.size() != sizes.size())
            return;

        int flat_i = translate_coord_to_index(rLoc);
        index[flat_i] = rVal;
    }

    int *index;
    int index_size;
    
    //Dimenional layout
    std::vector<int> sizes;
};



#endif