netiodata.cpp

此代码经过大量使用

/***************************************************************************
                          netiodata.cpp  -  description
                             -------------------
    copyright            : (C) 2000 by Matt Grover
    email                : [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

using namespace std;
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include "netiodata.h"

NetIOData::NetIOData(int size):
    netSize(size)
{
    unsigned int i;
    currNeuronIdx = 0;
    currSynIdx = 0;
    tempSynapse.reserve(1024);

    indexId = new unsigned int[netSize];
    synapse = new vector<SynapseData>[netSize];

    for (i=0; i<netSize; i++) {
        indexId[i] = 0;
    }
}

NetIOData::~NetIOData()
{
    unsigned int i;

    for (i=0; i<netSize; i++) {
        synapse[i].clear();
    }

    delete [] synapse;
    delete [] indexId;
}

int NetIOData::AddSynapse(unsigned int neuronId, unsigned int synapseId, float weight)
{
    unsigned int i;
    SynapseData addSyn;

    if (currNeuronIdx == 0 && indexId[0] == 0) {
        indexId[0] = neuronId;
    }

    if (neuronId != indexId[currNeuronIdx]) {
        synapse[currNeuronIdx].reserve(tempSynapse.size());

        for (i=0; i<tempSynapse.size(); i++) {
            synapse[currNeuronIdx].insert(synapse[currNeuronIdx].end(), tempSynapse[i]);
        }
        tempSynapse.clear();
        tempSynapse.reserve(1024);

        indexId[++currNeuronIdx] = neuronId;
    }

    addSyn.neuronId = synapseId;
    addSyn.weightVal = weight;

    tempSynapse.insert(tempSynapse.end(), addSyn);
    return 1;
}

unsigned int NetIOData::FirstNeuron()
{
    unsigned int i;

    if ( tempSynapse.size() ) {
        synapse[currNeuronIdx].reserve(tempSynapse.size());

        for (i=0; i<tempSynapse.size(); i++) {
            synapse[currNeuronIdx].insert(synapse[currNeuronIdx].end(), tempSynapse[i]);
        }
        tempSynapse.clear();
        tempSynapse.reserve(1024);
    }

    currNeuronIdx = 0;
    currSynIdx = 0;
    return indexId[0];
}

unsigned int NetIOData::NextNeuron()
{
    currNeuronIdx++;
    currSynIdx = 0;
    if (currNeuronIdx >= netSize) {
        return 0;
    }
    else {
        return indexId[currNeuronIdx];
    }
}

int NetIOData::FirstSynapse(unsigned int& synId, float& val)
{
    currSynIdx = 0;

    if (synapse[currNeuronIdx].size() > 0) {
        synId = synapse[currNeuronIdx][0].neuronId;
        val = synapse[currNeuronIdx][0].weightVal;
        return 1;
    }
    else {
        return 0;
    }
}

int NetIOData::NextSynapse(unsigned int& synId, float& val)
{
    currSynIdx++;

    if (synapse[currNeuronIdx].size() > currSynIdx) {
        synId = synapse[currNeuronIdx][currSynIdx].neuronId;
        val = synapse[currNeuronIdx][currSynIdx].weightVal;
        return 1;
    }
    else {
        return 0;
    }
}