acosolution.h

Go to the documentation of this file.

#pragma once

#include <vector>
#include <random>
#include "vec3.h"

class ACOSolution {
    std::vector<vec3<int>> dVector; 
    std::vector<char> dDirections; 
    bool dError; 
public:

    ACOSolution();

    ACOSolution(std::vector<char> &directions);

    static const char UP    = 0; 
    static const char DOWN  = 1; 
    static const char LEFT  = 2; 
    static const char RIGHT = 3; 
    static const char FRONT = 4; 
    static const char DIR_TO_CHAR(char d);
 
    std::vector<vec3<int>> &vector() { return dVector; }
    const std::vector<vec3<int>> &vector() const { return dVector; } 
    std::vector<char> &directions(){ return dDirections; }
    const std::vector<char> &directions() const { return dDirections; }
    vec3<int> bead(unsigned int i){ return dVector[i]; }

    char direction(unsigned int i){ return dDirections[i]; }

    static vec3<int> DIRECTION_VECTOR(vec3<int> prevDirection, char dir);

    vec3<int> previous_direction() const;

    int count_contacts(const HPChain &chain) const;

    void perturb_one(std::mt19937 &dRandGen);

    bool has_error() { return dError; }

    void set_error() { dError = true; }

    void clear_error() { dError = false; };
};

std::ostream& operator<<(std::ostream& stream, const ACOSolution &sol);

/********/

inline ACOSolution::ACOSolution()
: dVector({{0,0,0}, {1,0,0}}), dError(false)
{}


inline ACOSolution::ACOSolution(std::vector<char> &directions)
: dVector({{0,0,0}, {1,0,0}}), dDirections(directions), dError(false)
{
    // We build the protein coordinates, based on the given directions vector
    for(char dir: directions){
        vec3<int> prev = this->previous_direction();
        vec3<int> delta = DIRECTION_VECTOR(prev, dir);
        dVector.push_back(dVector.back() + delta);
    }
}

inline
const char ACOSolution::DIR_TO_CHAR(char d){
    static const char map[] = { 'U', 'D', 'R', 'L', 'F' };
    return map[(int) d];
}

inline
vec3<int> ACOSolution::DIRECTION_VECTOR(vec3<int> prevDirection, char dir){
    if(dir == FRONT){
        return prevDirection;
    }

    // Will be either 1 or -1
    int sign = prevDirection.x + prevDirection.y + prevDirection.z;

    struct { char x, z; }
        isZero = {
            .x = (prevDirection.x == 0),
            .z = (prevDirection.z == 0),
        };
    
    vec3<int> retval({0,0,0});
    if(dir == RIGHT){
        retval.x = sign * isZero.x;
        retval.y = sign * !isZero.x;
    } else if(dir == LEFT){
        retval.x = -sign * isZero.x;
        retval.y = -sign * !isZero.x;
    } else if(dir == UP){
        retval.z = 1 * isZero.z;
        retval.y = 1 * !isZero.z;
    } else /* if(dir == DOWN) */ {
        retval.z = -1 * isZero.z;
        retval.y = -1 * !isZero.z;
    }

    return retval;
}

inline
vec3<int> ACOSolution::previous_direction() const {
    return dVector.back() - dVector[dVector.size() - 2];
}

inline
int ACOSolution::count_contacts(const HPChain &chain) const {
    int contacts = 0;

    for(unsigned i = 0; i < dVector.size(); i++){
        if(chain[i] == 'P') continue;

        for(unsigned j = i+1; j < dVector.size(); j++){
            if(chain[j] == 'P') continue;
            int norm1 = (dVector[i] - dVector[j]).norm1();
            if(norm1 == 1) contacts++;
        }
    }

    return contacts;
}

inline
void ACOSolution::perturb_one(std::mt19937 &gen){
    std::uniform_real_distribution<> randDist(0.0, 1.0);

    // Decide where to perturb
    int randPos = randDist(gen) * dDirections.size();

    // Perturb that position
    dDirections[randPos] = randDist(gen) * 5;

    // Rebuild the vector
    dVector = {{0,0,0}, {1,0,0}};
    for(char dir: dDirections){
        vec3<int> prev = previous_direction();
        vec3<int> delta = ACOSolution::DIRECTION_VECTOR(prev, dir);
        dVector.push_back(dVector.back() + delta);
    }
}

inline
std::ostream& operator<<(std::ostream& stream, const ACOSolution &sol){
    for(const vec3<int> &point: sol.vector())
        stream << point << " ";
    stream << "\n";
    for(char c: sol.directions())
        stream << ACOSolution::DIR_TO_CHAR(c);

    return stream;
}