Ca.h

Go to the documentation of this file.

/*
 * Copyright (C) 2009 Kamil Dudka <xdudka00@stud.fit.vutbr.cz>
 *
 * This file is part of nucad (Non-Uniform CA Designer).
 *
 * nucad is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * nucad is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with nucad.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef CA_H
#define CA_H

#ifndef BUILDING_DOX
#   include <bitset>
#   include <string>
#endif

#include <boost/dynamic_bitset.hpp>

typedef signed long TCoord;

typedef unsigned long TBus;

#define RULE_WIDTH (1 << 5)

typedef std::bitset<RULE_WIDTH> TRule5N;

enum EDirection {
    D_NULL = 0,
    D_TOP,
    D_RIGHT,
    D_BOTTOM,
    D_LEFT,
    D_ONE_AFTER_LAST
};

struct Pos {
    TCoord row;
    TCoord col;

    Pos(): row(0), col(0) { }
    Pos(TCoord row_, TCoord col_):
        row(row_),
        col(col_)
    {
    }
};

void writeRule(std::ostream &str, const TRule5N &rule);

inline Pos neighbor(Pos pos, EDirection dir) {
    switch (dir) {
        case D_TOP:     return Pos(pos.row - 1, pos.col);
        case D_RIGHT:   return Pos(pos.row, pos.col + 1);
        case D_BOTTOM:  return Pos(pos.row + 1, pos.col);
        case D_LEFT:    return Pos(pos.row, pos.col - 1);
        default:        return pos;
    }
}

class CaState {
    public:
        CaState(size_t size);

        size_t size() const;

        bool getCellAtPos(Pos pos) const;

        void setCellAtPos(Pos pos, bool val);

        bool operator== (const CaState &other) const;
        bool operator!= (const CaState &other) const {
            return !operator== (other);
        }

    private:
        size_t size_;
        boost::dynamic_bitset <> bitset_;
};

std::ostream& operator<< (std::ostream &str, const CaState &state);

bool applyRule(const CaState &ca, Pos pos, const TRule5N &rule);

class IGate {
    public:
        virtual ~IGate() { }

        virtual IGate* clone() const = 0;

        virtual size_t nInputs() const = 0;

        virtual size_t nOutputs() const = 0;

        virtual TBus operator[] (TBus in) const = 0;
};

class IGateBinding {
    public:
        virtual ~IGateBinding() { }

        virtual IGateBinding* clone() const = 0;

        virtual void setInput(CaState &state, TBus in) const = 0;

        virtual void setOutput(CaState &state, TBus out) const = 0;

        virtual TBus getOutput(const CaState &state) const = 0;
};

class ICaRules {
    public:
        virtual ~ICaRules() { }
        virtual ICaRules* clone() const = 0;

        virtual void getRuleAtPos(Pos pos, TRule5N &rule) const = 0;
};

bool applyRules(CaState &state, const ICaRules *rules);

struct CaEvalParams {
    size_t caSize;                  // CA's size in one direction
    size_t nSteps;                  // CA's simulation limit for count of steps
};

class CaEvaluator {
    public:
        CaEvaluator(
                const IGate &gate,
                const IGateBinding &binding,
                const CaEvalParams &params);
        ~CaEvaluator();

        size_t caSize() const;

        float eval(const ICaRules *ca);

        bool cntSteps(const ICaRules *ca, unsigned &min, unsigned &max);

        void simulate(const ICaRules *ca, std::ostream &str, TBus in);

        void simulate(const ICaRules *ca, std::ostream &str);

    private:
        struct Private;
        Private *d;
};

#endif // CA_H

---