par.h

Go to the documentation of this file.

//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
#ifndef         PAR_H
#define         PAR_H

#include        <iomanip>
#include        <stdlib.h>
#include        <cmath>
#include        <stack>

using namespace std;

template <class T> static T par_add(T x, T y)   { return x + y; }
template <class T> static T par_sub(T x, T y)   { return x - y; }
template <class T> static T par_mul(T x, T y)   { return x * y; }
template <class T> static T par_div(T x, T y)   { return x / y; }
template <class T> static T par_mod(T x, T y)   { return x % y; }
template <class T> static T par_or(T x, T y)    { return x | y; }
template <class T> static T par_and(T x, T y)   { return x & y; }
template <class T> static T par_max(T x, T y)   { return x>=y ? x : y; }
template <class T> static T par_min(T x, T y)   { return x<=y ? x : y; }
template <class T> static T par_neg(T x)                { return -x; }
template <class T> static T par_nop(T x)                { return x; }
template <class T> static T par_not(T x)                { return !x; }


//      -------------- special functions -----------------
template <class T> static T par_pow(T x, T y)   { return pow(x,y); }

template <class T>  static bool par_eq(T x, T y){ return x==y; }
template <class T>  static bool par_ne(T x, T y){ return x!=y; }
template <class T>  static bool par_lt(T x, T y){ return x<y; }
template <class T>  static bool par_gt(T x, T y){ return x>y; }
template <class T>  static bool par_le(T x, T y){ return x<=y; }
template <class T>  static bool par_ge(T x, T y){ return x>=y; }

bool            *flag=NULL;
int                     flag_N=0;

bool            *flagtemp=NULL;         // current useful array of bools (active flags)
bool            restrict=false;         // if on, then in some sort of if block
bool            ifelseflag=true;        // if on, then in an IFP block (off in an ELSEP block)

stack<bool *>   rs;                                     // stack of flags
stack<bool>             ifelses;                        // saves ifp/elsep status in a nested IFP

#define ifp(x) \
        (x); \
        flagtemp = new bool[flag_N]; \
        memcpy(flagtemp, flag, flag_N); \
        rs.push(flagtemp);  \
        ifelses.push(true); \
        restrict = true; \
        ifelseflag = true;
                                // restrict will not work for nested, use stack of bool...

#define elsep() \
        flagtemp = rs.top(); \
        ifelseflag = false; \
        ifelses.pop(); \
        ifelses.push(false);
        
#define endifp \
        flagtemp = rs.top(); \
        delete [] flagtemp; \
        rs.pop(); \
        ifelses.pop(); \
        if (!ifelses.empty()) ifelseflag = ifelses.top(); \
                else ifelseflag = true; \
        if (!rs.empty()) flagtemp = rs.top(); \
                else { flagtemp=NULL; restrict = false; }
                        

//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
template <class T>
class par
{
 private:                                       
  T             *data;                                  
  int   N;                                              

 public:
  
        par(const int n=1)                      
    { 
      N = n;    
      data = new T[n];
    }

        ~par()                                          
    { delete [] data; }
        
        par(const par<T> &x)            
    {                                                   
    for (int i=0; i<x.N; i++)
                data[i] = x.data[i];
        N = x.N;
    }

  // cast conversions
  /*par(const T &d)
    {
      for (int i=0; i<N; i++)
        data[i] = d;    
    }
  */
  //-----------------------------------------------------------------------
  //-----------------------------------------------------------------------
    friend  void par_bool_par(par<T> &x, bool f(T,T), par<T> &y)
    {
    delete [] flag;
    flag = new bool[x.N];
        flag_N = x.N; 
        for (int i=0; i<x.N; i++)
                {
                flag[i] = f(x.data[i],y.data[i]);
                }
    }

    friend void par_bool_sing(par<T> &x, bool f(T,T), const T &t)
    {
    par<T> y(x.N);
        y=t;
    par_bool_par(x,f,y);
    }

    friend void par_self(par<T> &x, T f(T))
    {
    for (int i=0; i<x.N; i++)
                x.data[i] = f(x.data[i]);
    }

    friend void par_to_par(par<T> &y, T f(T), par<T> &x)
    {
    for (int i=0; i<y.N; i++)
                y.data[i] = f(x.data[i]);
    }

    void par2_to_par(T f(T,T) , par<T> &x, par<T> &y)
    {
    for (int i=0; i<N; i++)
                data[i] = f(x.data[i],y.data[i]);                       // Farg occurs here when data different size
    }

    friend void sing_to_par(par<T> &y, T f(T), const T &t)
    {
    for (int i=0; i<y.N; i++)
                y.data[i] = f(t);
    }

    friend void par_and_sing_to_par(par<T> &z, T f(T,T), par<T> &x, const T &t)
    {
    par<T> y(x.N);      y=t;
    z.par2_to_par(f,x,y);               
    }

    friend void par_and_sing_to_par_rev(par<T> &z, T f(T,T), par<T> &x, const T &t)
    {
    par<T> y(x.N);      y=t;
    z.par2_to_par(f,y,x);       
    }


    //-----------------------------------------------------------------------
    //-----------------------------------------------------------------------
    par<T> &operator - () 
    { static par<T> z(N); z.reassign(N); par_to_par(z ,par_neg ,*this ); return z;}

        par<T> &operator ! () 
    { static par<T> z(N); z.reassign(N); par_to_par(z ,par_not ,*this ); return z;}

    par<T> &operator + ()
    { return *this; }


    par<T> &operator + (par<T> &y)
        {static par<T> z(N); z.reassign(N); z.par2_to_par( par_add, *this, y); return z;}

    par<T> &operator - (par<T> &y)
    {static par<T> z(N); z.reassign(N); z.par2_to_par( par_sub, *this, y); return z;}

    par<T> &operator * (par<T> &y)
    {static par<T> z(N); z.reassign(N); z.par2_to_par( par_mul, *this, y); return z;}

    par<T> &operator / (par<T> &y)
    {static par<T> z(N); z.reassign(N); z.par2_to_par( par_div, *this, y); return z;}

    par<T> &operator % (par<T> &y)
    {static par<T> z(N); z.reassign(N); z.par2_to_par( par_mod, *this, y); return z;}

    par<T> &operator | (par<T> &y)
    {static par<T> z(N); z.reassign(N); z.par2_to_par( par_or, *this, y); return z;}

    par<T> &operator & (par<T> &y)
    {static par<T> z(N); z.reassign(N); z.par2_to_par( par_and, *this, y); return z;}

    par<T> &operator += (par<T> &y)
        {this->par2_to_par( par_add, *this, y); return *this;}

    par<T> &operator -= (par<T> &y)
    {this->par2_to_par( par_sub, *this, y); return *this;}

    par<T> &operator *= (par<T> &y)
    {this->par2_to_par( par_mul, *this, y); return *this;}

    par<T> &operator /= (par<T> &y)
    {this->par2_to_par( par_div, *this, y); return *this;}

    par<T> &operator %= (par<T> &y)
    {this->par2_to_par( par_mod, *this, y); return *this;}

    par<T> &operator |= (par<T> &y)
    {this->par2_to_par( par_or, *this, y); return *this;}

    par<T> &operator &= (par<T> &y)
    {this->par2_to_par( par_and, *this, y); return *this;}

    friend T reduce(T init, T f(T,T), const par<T> &x)
    { for (int i=0; i<x.N; i++)  init = f(init , x.data[i]);  return init; }
        
        friend T operator += (T &x, par<T> &y)
        {return x=reduce( 0, par_add, y);}

    friend T operator -= (T &x, par<T> &y)
    {return x=reduce( 0, par_sub, y);}

    friend T operator *= (T &x, par<T> &y)
    {return x=reduce( 1, par_mul, y);}

    friend T operator /= (T &x, par<T> &y)
    {return x=reduce( 1, par_div, y);}

    friend T operator %= (T &x, par<T> &y)
    {return x=reduce( 1, par_mod, y);}

    friend T operator |= (T &x, par<T> &y)
    {return x=reduce( false, par_or, y);}

    friend T operator &= (T &x, par<T> &y)
    {return x=reduce( true, par_and, y);}

        T max_value(par<T> &y)
        {return reduce( y.data[0], par_max, y);}

        T min_value(par<T> &y)
        {return reduce( y.data[0], par_min, y);}




        friend par<bool> &flag_setup_x_op_y(par<T> &x)
        {static par<bool> r(x.N);  r.reassign(x.N); r=flag;  return r;}

    friend par<bool> &operator == (par<T> &x, par<T> &y)
    { par_bool_par(x, par_eq, y); return flag_setup_x_op_y(x);}

    friend par<bool> &operator != (par<T> &x, par<T> &y)
    { par_bool_par(x, par_ne, y); return flag_setup_x_op_y(x);}

    friend par<bool> &operator < (par<T> &x, par<T> &y)
    { par_bool_par(x, par_lt, y); return flag_setup_x_op_y(x);}

    friend par<bool> &operator > (par<T> &x, par<T> &y)
    { par_bool_par(x, par_gt, y); return flag_setup_x_op_y(x);}

    friend par<bool> &operator <= (par<T> &x, par<T> &y)
    { par_bool_par(x, par_le, y); return flag_setup_x_op_y(x);}

    friend par<bool> &operator >= (par<T> &x, par<T> &y)
    { par_bool_par(x, par_ge, y); return flag_setup_x_op_y(x);}

        friend par<bool> &operator && (par<T> &x, par<T> &y)
    { par_bool_par(x, par_and, y); return flag_setup_x_op_y(x);}

        friend par<bool> &operator || (par<T> &x, par<T> &y)
    { par_bool_par(x, par_or, y); return flag_setup_x_op_y(x);}

    friend par<bool> &operator == (par<T> &x, const T &t)
    { par_bool_sing(x, par_eq, t); return flag_setup_x_op_y(x);}

    friend par<bool> &operator != (par<T> &x, const T &t)
    { par_bool_sing(x, par_ne, t); return flag_setup_x_op_y(x);}

    friend par<bool> &operator < (par<T> &x, const T &t)
    { par_bool_sing(x, par_lt, t); return flag_setup_x_op_y(x);}

    friend par<bool> &operator > (par<T> &x, const T &t)
    { par_bool_sing(x, par_gt, t); return flag_setup_x_op_y(x);}

    friend par<bool> &operator <= (par<T> &x, const T &t)
        { par_bool_sing(x, par_le, t); return flag_setup_x_op_y(x);}

    friend par<bool> &operator >= (par<T> &x, const T &t)
    { par_bool_sing(x, par_ge, t); return flag_setup_x_op_y(x);}

    friend par<bool> &operator == (const T &t, par<T> &x)
    { par_bool_sing(t, par_eq, x); return flag_setup_x_op_y(x);}

    friend par<bool> &operator != (const T &t, par<T> &x)
    { par_bool_sing(t, par_ne, x); return flag_setup_x_op_y(x);}

    friend par<bool> &operator < (const T &t, par<T> &x)
    { par_bool_sing(t, par_lt, x); return flag_setup_x_op_y(x);}

    friend par<bool> &operator > (const T &t, par<T> &x)
    { par_bool_sing(t, par_gt, x); return flag_setup_x_op_y(x);}

    friend par<bool> &operator >= (const T &t, par<T> &x)
    { par_bool_sing(t, par_ge, x); return flag_setup_x_op_y(x);}

    friend par<bool> &operator <= (const T &t, par<T> &x)
    { par_bool_sing(t, par_le, x); return flag_setup_x_op_y(x);}

    friend par<bool> &operator && (const T &t, par<T> &x)
    { par_bool_sing(t, par_and, x); return flag_setup_x_op_y(x);}

    friend par<bool> &operator && (par<T> &x, const T &t)
    { par_bool_sing(t, par_and, x); return flag_setup_x_op_y(x);}

        friend par<bool> &operator || (const T &t, par<T> &x)
    { par_bool_sing(t, par_and, x); return flag_setup_x_op_y(x);}

    friend par<bool> &operator || (par<T> &x, const T &t)
    { par_bool_sing(t, par_and, x); return flag_setup_x_op_y(x);}


    friend par<T> &operator + (par<T> &x, const T &t)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par( z, par_add, x, t); return z;}

    friend par<T> &operator + (const T &t, par<T> &x)
        {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par_rev( z, par_add, x, t); return z;}

    friend par<T> &operator - (par<T> &x, const T &t)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par( z, par_sub, x, t); return z;}

    friend par<T> &operator - (const T &t, par<T> &x)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par_rev( z, par_sub, x, t); return z;}

    friend par<T> &operator * (par<T> &x, const T &t)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par( z, par_mul, x, t); return z;}

    friend par<T> &operator * (const T &t, par<T> &x)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par_rev( z, par_mul, x, t); return z;}

    friend par<T> &operator / (par<T> &x, const T &t)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par( z, par_div, x, t); return z;}

    friend par<T> &operator / (const T &t, par<T> &x)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par_rev( z, par_div, x, t); return z;}

    friend par<T> &operator % (par<T> &x, const T &t)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par( z, par_mod, x, t); return z;}

    friend par<T> &operator % (const T &t, par<T> &x)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par_rev( z, par_mod, x, t); return z;}

    friend par<T> &operator | (par<T> &x, const T &t)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par( z, par_or, x, t); return z;}

    friend par<T> &operator | (const T &t, par<T> &x)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par_rev( z, par_or, x, t); return z;}

    friend par<T> &operator & (par<T> &x, const T &t)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par( z, par_and, x, t); return z;}

    friend par<T> &operator & (const T &t, par<T> &x)
    {static par<T> z(x.N); z.reassign(x.N); par_and_sing_to_par_rev( z, par_and, x, t); return z;}

        par<T> &operator ++ ()
        {
        par_and_sing_to_par(*this, par_add, *this, 1);
        return *this;
        }

        par<T> &operator ++ (int a)
        {
        static par<T> z(N); z.reassign(N);
        par_and_sing_to_par(*z, par_add, *this, 1);
        return z;
        }

        par<T> &operator -- ()
        {
        par_and_sing_to_par(*this, par_sub, *this, 1);
        return *this;
        }

        par<T> &operator -- (int a)
        {
        static par<T> z(N); z.reassign(N);
        par_and_sing_to_par(z, par_sub, *this, 1);
        return z;
        }

    // ---------------------------------------------------------------------
    // ---------------------------------------------------------------------
    friend std::ostream &operator << ( std::ostream &out, par<T> &x)
    {
    for (int i=0; i<x.N; i++)
                out << std::setw(12) << x.data[i];
    return out;
        }


    friend std::istream &operator >> ( std::istream &in, par<T> &x)
    {
    for (int i=0; i<x.N; i++)
                in >> x.data[i];
    return in;
    }
    // -------------------------------------------------
    // -------------------------------------------------
    T &operator [] ( int i )                            // single, left
    { return data[i]; } 

    const T &operator [] ( int i ) const        // single, right
    { return data[i]; } 

        par<T> &operator [] ( par<T> &x )                                       
    { 
        static par<T> z(x.N); z.reassign(x.N);
        for (int i=0; i<x.N; i++)
                z.data[i] = data[ x.data[i]%x.N ];                              // permutation
        return z;
    } 


    // ----------------------------------------------------------------------
    // ----------------------------------------------------------------------
    par<T> &operator = (const par<T> &x)
    {
        if (flagtemp !=NULL && restrict)
                for (int i=0; i<N; i++)
                        {if (flagtemp[i]) data[i] = x.data[i];}
                else
                        for (int i=0; i<N; i++)
                                data[i] = x.data[i];
                return *this;
    }


    par<T> &operator = (const T &t)
    {
        if (flagtemp !=NULL && restrict)
                for (int i=0; i<N; i++)
                        {if (flagtemp[i]) data[i] = t;}
        else    
                for (int i=0; i<N; i++)
                        data[i]=t;
        return *this;
        }

    par<T> &operator = (const T *t)
        {
        if (flagtemp !=NULL && restrict)
                for (int i=0; i<N; i++)
                        { if (flag[i]) data[i] = t[i]; }
        else    
                for (int i=0; i<N; i++)
                        data[i]=t[i];
        return *this;
        }



    // ----------------------------------------------------------------------
    // ----------------------------------------------------------------------

    friend void addr(par<T> &x)
    { for (int i=0; i<x.N; i++) x.data[i] = i; }

    void all_on()
    {
    delete [] flag;
    flag = new bool[N];
        flag_N = N;
        for (int i=0; i<flag_N; i++) flag[i]=true;
    }

        friend T first(const par<T> &x)
        {
        if (flag != NULL)
                for (int i=0; i<x.N; i++)
                        if (flag[i]) return x.data[i];
        return x.data[0];
        }

        friend int first_index(const par<T> &x)
        {
        if (flag != NULL)
                for (int i=0; i<x.N; i++)
                        if (flag[i]) return i;
        return -1;
        }

        friend T nth(const par<T> &x, int n)
        {
        int c=0;
        if (flag != NULL)
                for (int i=0; i<x.N; i++)
                        if (flag[i]) 
                                {
                                c++;
                                if (c==n) return x.data[i];
                                }
        return x.data[0];
        }

        friend T nth_index(const par<T> &x, int n)
        {
        int c=0;
        if (flag != NULL)
                for (int i=0; i<x.N; i++)
                        if (flag[i]) 
                                {
                                c++;
                                if (c==n) return i;
                                }
        return -1;
        }

        friend bool any(par<T> &x)
        {
        for (int i=0; i<x.N; i++)
                if (x.data[i]) return true;
        return false;
        }

        friend bool all(par<T> &x)
        {
        for (int i=0; i<x.N; i++)
                if (!x.data[i]) return false;
        return true;
        }

        friend int active(par<T> &x)
        {
        int c=0;
        for (int i=0; i<x.N; i++)
                if (flag[i]) c++;
        return c;
        }

        friend par<T> &scan(T init, T f(T,T), const par<T> &x)
        { 
        static par<T> z(N); z.reassign(N);
        z.data[0] = x.data[0];
        for (int i=1; i<x.N; i++)
                z.data[i] = f(z.data[i-1], x.data[i]);
        return z;
        }

    
    // -------------------------------------------------
    // -------------------------------------------------
        void reassign(int n)
        { delete [] data;  N = n;  data = new T[n]; }


    void dumpflags()
        {
    for (int i=0; i<flag_N; i++)
                std::cout<<flag[i];
    std::cout << std::endl;             
    }
        
        friend par<T> &pow(par<T> &x, T t)
    {
        par<T> y(x.N);
    static par<T> z(x.N);
        z.reassign(x.N); 
    y = t;
        z.par2_to_par( std::pow, x, y); return z;
    }

    friend par<T> &pow(T t, par<T> &x)
    {
        par<T> y(x.N);
    static par<T> z(x.N);  
        z.reassign(x.N); 
    y = t;
        z.par2_to_par( std::pow, y, x); return z;
    }


    // -------------------------------------------------
    // -------------------------------------------------
        friend par<T> &rotate(par<T> &x, int amt)
        {
        static par<T> z(x.N); z.reassign(x.N);
        for (int i=0; i<x.N; i++)
                z.data[(i+amt+x.N)%x.N] = x.data[i];            
        return z;
        }

        friend par<T> &permute(par<T> &x, par<int> &y)
        {
        static par<T> z(x.N); z.reassign(x.N);
        for (int i=0; i<x.N; i++)
                z.data[y.data[i]%x.N] = x.data[i];
        return z;
        }

        friend par<T> &pack(par<T> &x)
        {
        static par<T> z(x.N); z.reassign(x.N);
        int c=0;
        for (int i=0; i<x.N; i++)
                if (flag[i]) z.data[c++] = x.data[i];
        return z;
        }

};                      


#endif                  

---