Net.h

Go to the documentation of this file.

#ifndef _INC_NET_H
#define _INC_NET_H

#include <fstream>
#include <map>
#include <list>
#include <string>
#include <complex>
#include <iostream>

#include "matrix.h"
#include "su2_cmp.h"
#include "su2.h"

#include "Exception.h"


class Net
{
public:
    struct icoord
    {
        short x : 16;
        short t : 16;
        short z : 16;
        short y : 16;
    };


    struct icoord_cmp
    {
        bool operator()(const icoord& A, const icoord& B) const
        {
            int* pA = (int *) &A;
            int* pB = (int *) &B;

            if (*pA < *pB)
                return true;
            else if (*pA++ > *pB++)
                return false;
            else if (*pA < *pB)
                return true;
            else 
                return false;
            // If your machine has 64-bit integers comment out the above and
            // replace with this:
            // if(*pA < *pB)
            //      return true;
            // else
            //      return false;
        }
    };


//public:
    struct knot
    {
        int l;              
        std::string word;   
        //double coord[4];  //! 4D coordinate of the corresponding matrix
        Matrix<cdouble> M;
    };  

// private:
    std::list<knot*> knots;
    typedef std::complex<double> cdouble;

    double tilewidth;

    int G;

    Matrix<cdouble>* gate_set;  
    int N;                      
    char* gate_labels;          
    int* gate_orders;           
    int* gate_inverses;         

    int search_count;           

    char label_indices[512];            

    void generate_net(int max_length);

    void add(Matrix<cdouble>& U, char* word, int l);

//public:


    icoord coordinate(const Matrix<cdouble>& U, int rounding=-1);

    typedef std::map<icoord, std::list<knot*> , icoord_cmp> nettype;
    nettype su2net; 

    Net(double tw);

    Net(const char* file);

    ~Net(void);


    void generate(char* labels, cdouble** basis, int n, int max_length);

    void generate(char labels[], cdouble basis[][4], int n, int max_length)
    {
        cdouble** b = new cdouble*[n];
        for (int i=0;i<n;i++)
        {
            b[i] = new cdouble[4];
            memcpy(b[i],basis[i],4*sizeof(cdouble));
        }

        generate((char*)labels, b, n, max_length);

        for (int i=0;i<n;i++)
            delete[] b[i];
        delete[] b;
    }

    int load(const char* file);

    void save(const char* file);

    knot* nearest(const Matrix<cdouble>& U);

    std::string nearest_string(const Matrix<cdouble>& U)
    {
        return nearest(U)->word;
    }

    Matrix<cdouble> evaluate(const std::string& s);

    std::string invert(const std::string& s);

    int searched(void) { return search_count; }

    int size(void) { return knots.size(); }

    knot solovay_kitaev(const Matrix<cdouble>& U, int depth);


    friend std::ostream& operator<<(std::ostream& out, const Net& N);
};
#endif

---