/home/enzo/treballs/fib/pfc/nanocomp/src/truthTable.cpp

Go to the documentation of this file.

/*
 *                                                                         *
 *   This program 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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
                                                                          */

// $Revision: 1.7 $

#include "truthTable.hpp"
#include <math.h>
#include <iostream>


TruthTable::TruthTable(wxString name, int inputs, int outputs)
{
    table.resize((int)(pow(2, inputs)));
    //We have 2^inputs outputs, so we must
    //initialize 2^input false values
    for (unsigned int i = 0; i < table.size(); i++)
    {
        table[i].resize(outputs);
        for (unsigned int j = 0; j < table[i].size(); j++)
        {
            table[i][j] = false;
        }
    }
    
    this->inputs = inputs;
    this->outputs = outputs;
    this->name = name;
}



TruthTable::TruthTable()
{
    inputs = 0;
    outputs = 0;
}


TruthTable::~TruthTable()
{
}



vector<bool> TruthTable::getOutput(vector<bool> input)
{
    return table[getIndex(input)];
}



int TruthTable::getIndex(vector<bool> input)
{
    int result = 0;
    int base = 1;
    for (unsigned int i = 0; i < input.size(); i++)
    {
        if (input[input.size() - 1 - i])
        {
            result += base;
        } 
        base *= 2;
    }
    return result;
}



void TruthTable::setOutput(vector<bool> input, vector<bool> output)
{
    table[getIndex(input)] = output;
}



int TruthTable::getInputs()
{
    return inputs;
}



int TruthTable::getOutputs()
{
    return outputs;
}



wxString TruthTable::getOutput(wxString input)
{
    vector<bool> vInput = stringToVector(input);
    return vectorToString(getOutput(vInput));
}



bool TruthTable::getOutput(vector<bool> input, int output)
{
    return getOutput(input)[output];
}



bool TruthTable::getOutput(wxString input, int output)
{
    vector<bool> vInput = stringToVector(input);
    return getOutput(vInput)[output];
}
    
    

void TruthTable::setOutput(wxString input, wxString output)
{
    vector<bool> vInput = stringToVector(input);
    vector<bool> vOutput = stringToVector(output);
    setOutput(vInput, vOutput);
}



int TruthTable::getIndex(wxString input)
{
    vector<bool> vInput = stringToVector(input);
    return getIndex(vInput);
}



vector <bool> TruthTable::stringToVector(wxString input)
{
    vector<bool> result(input.length());
    for (unsigned int i = 0; i < input.length(); i++)
    {
        if (input[i] == '0')
        {
            result[i] = false;
        }
        else
        {
            result[i] = true;
        }
    }
    
    return result;
}



wxString TruthTable::vectorToString(vector<bool> input)
{
    wxString result= _("");
    for (unsigned int i = 0; i < input.size(); i++)
    {
        if (input[i])
        {
            result += '1';
        }
        else
        {
            result += '0';
        }
    }
    
    return result;
}



vector< vector<bool> > TruthTable::getTable()
{
    return table;
}



void TruthTable::copyTable(TruthTable newTable)
{
    table = newTable.getTable();
    name = newTable.getName();
    inputs = newTable.getInputs();
    outputs = newTable.getOutputs();
}



wxString TruthTable::getName()
{
    return name;
}



void TruthTable::setName(wxString newName)
{
    name = newName;
}



void TruthTable::setTable(vector< vector<bool> > table)
{
    this->table = table;
}

---