/** * Helper method to locate the leftmost cube * in a series of neighboured cubes. */ unsigned Phonemic::leftmostNeighbor(unsigned id) { // Find leftmost cube Neighborhood hood = Neighborhood(id); CubeID leftmostID = id; while(hood.hasCubeAt(LEFT)) { leftmostID = hood.cubeAt(LEFT); hood = Neighborhood(leftmostID); } return leftmostID; }
/** * Helper method to determine if any cubes are neighboured */ bool Phonemic::noNeighbors() { for(CubeID cube: CubeSet::connected()) { Neighborhood hood = Neighborhood(cube); if(hood.hasCubeAt(LEFT) || hood.hasCubeAt(RIGHT)) return false; } return true; }
/** * Helper method to decide if a series of cubes * spells the current word. */ void Phonemic::checkForWord(unsigned id) { // Find leftmost cube CubeID nextID = leftmostNeighbor(id); Neighborhood hood = Neighborhood(nextID); // Find the sequence of symbols spelled by // the sequence of cubes int wordAttempt[MAX_WORD_SIZE]; wordAttempt[0] = cubes[nextID].symbol; int i = 1; while(hood.hasCubeAt(RIGHT)) { nextID = hood.cubeAt(RIGHT); hood = Neighborhood(nextID); wordAttempt[i] = cubes[nextID].symbol; i++; } wordAttempt[i] = -1; // Check for a match bool match = true; for(int i = 0; i < /*MAX_WORD_SIZE*/ length; i++) { if(/*order[i]*/ wordFamilies[level].phonemes[word][i] != wordAttempt[i]) { match = false; break; } //if(wordFamilies[level].phonemes[word][i] == -1) break; } // Recognize match if(match) { //sounding.play(SfxChime); //sounding.play(SfxCat); sounding.play(/*SfxChime*/ *wordFamilies[level].words[word].sound); allSmiles(); System::paint(); state = WORD_FOUND; } }
void TrainOutput(NET* Net, REAL* Output) { INT i,j; REAL Out, Weight, Lambda; for (i=0; i<Net->OutputLayer->Units; i++) { for (j=0; j<Net->KohonenLayer->Units; j++) { Out = Output[i]; Weight = Net->OutputLayer->Weight[i][j]; Lambda = Neighborhood(Net, j); Net->OutputLayer->Weight[i][j] += Net->Alpha_ * Lambda * (Out - Weight); } } }
void TrainKohonen(NET* Net, REAL* Input) { INT i,j; REAL Out, Weight, Lambda, StepSize; for (i=0; i<Net->KohonenLayer->Units; i++) { for (j=0; j<Net->InputLayer->Units; j++) { Out = Input[j]; Weight = Net->KohonenLayer->Weight[i][j]; Lambda = Neighborhood(Net, i); Net->KohonenLayer->Weight[i][j] += Net->Alpha * Lambda * (Out - Weight); } StepSize = Net->KohonenLayer->StepSize[i]; Net->KohonenLayer->StepSize[i] += Net->Alpha__ * Lambda * -StepSize; } }
/** * Notes: * - Comment out the parts you aren't currently using. */ int main() { // test_buffer(); // ------------------------------------------------------------------------ //test_shape(); // ------------------------------------------------------------------------ // animate neighborhood unsigned int size_x = TERM_SIZE_X/Shape::size_x; unsigned int size_y = TERM_SIZE_Y/Shape::size_y; Neighborhood(size_x, size_y).animate(1000); // ------------------------------------------------------------------------ return 0; // success }
/** * Helper method to sounds out the sequence of cubes. */ void Phonemic::soundOut(unsigned id) { // Wait for audio channel to be clear if(sounding.isPlaying()) return; // Highlight the current cube cubes[id].vid.bg0.image(vec(0,0), *cubes[id].images[1]); System::paint(); System::finish(); // Play the current cube's sound sounding.play(*cubes[id].sound); while(sounding.isPlaying()) { System::yield(); } // Return the cube to its normal appearance cubes[id].vid.bg0.image(vec(0,0), *cubes[id].images[0]); // Play any cube connected to the right Neighborhood hood = Neighborhood(id); if(hood.hasCubeAt(RIGHT)) soundOut(hood.cubeAt(RIGHT)); }
Instance(const std::vector<Resource>& resources, const std::vector<Machine>& machines, const std::vector<Service>& services, const std::vector<Process>& processes, const std::vector<BalanceCost>& balanceCosts, std::vector<int> const & initAssignment, int processMoveCostWeight, int serviceMoveCostWeight, int machineMoveCostWeight, int numNeighborhoods, int numLocations) : _resources(resources), _machines(machines), _services(services), _processes(processes), _balanceCosts(balanceCosts), _initAssignment(initAssignment), _processMoveCostWeight(processMoveCostWeight), _serviceMoveCostWeight(serviceMoveCostWeight), _machineMoveCostWeight(machineMoveCostWeight), _numNeighborhoods(numNeighborhoods), _numLocations(numLocations), _numResources(_resources.size()), _resourcesLoadCostWeight(_resources.size(), 0) { for (int i = 0; i < numResources(); i++) { _isTransient.push_back(_resources[i].transient()); _resourcesLoadCostWeight[i] = _resources[i].loadCostWeight(); } for (int i = 0; i < _processes.size(); i++) { _services[_processes[i].service()].addProcess(i); } for (int i = 0; i < _numLocations; i++) { _locations.push_back(Location(i)); } for (int i = 0; i < _numNeighborhoods; i++) { _neighborhoods.push_back(Neighborhood(i)); } for (int i = 0; i < _machines.size(); i++) { _locations[machines[i].location()].addMachine(i); _neighborhoods[machines[i].neighborhood()].addMachine(i); } for (int i = 0; i < _services.size(); i++) { for (int j = 0; j < _services[i].dependencies().size(); j++) { _dependencies.push_back( std::make_pair(i, _services[i].dependencies()[j])); } } }