migrationfc.cpp

人工智能中模糊逻辑算法 FuzzyLib 2.0 is a comprehensive C++ Fuzzy Logic library for constructing fuzzy logic sy

{
// temporary
    for (int i=0; i<MAX_DEMANDING_NODES; i++)
    {
        remote_demands[i] = random(100);
    }
}


// for each demanding node, run C1 to get its attraction force and
// fill remote_attractions[MAX_DEMANDING_NODES] with the results
int TMigrationFC::RunC1(int index, double input1, double input2,
int AggregationMethod, int CorrelationMethod, int AlphaCutType, int CompositionMethod, int DefuzzificationMethod)
{
    // apply new inputs
	C1->rules[0]->predicate->premises[0]->set_scalar(input1);
	C1->rules[0]->predicate->premises[1]->set_scalar(input2);
	C1->rules[1]->predicate->premises[0]->set_scalar(input1);
	C1->rules[1]->predicate->premises[1]->set_scalar(input2);
	C1->rules[2]->predicate->premises[0]->set_scalar(input1);
	C1->rules[2]->predicate->premises[1]->set_scalar(input2);
	C1->rules[3]->predicate->premises[0]->set_scalar(input1);
	C1->rules[3]->predicate->premises[1]->set_scalar(input2);
	C1->rules[4]->predicate->premises[0]->set_scalar(input1);
	C1->rules[4]->predicate->premises[1]->set_scalar(input2);
	C1->rules[5]->predicate->premises[0]->set_scalar(input1);
	C1->rules[5]->predicate->premises[1]->set_scalar(input2);
	C1->rules[6]->predicate->premises[0]->set_scalar(input1);
	C1->rules[6]->predicate->premises[1]->set_scalar(input2);
	C1->rules[7]->predicate->premises[0]->set_scalar(input1);
	C1->rules[7]->predicate->premises[1]->set_scalar(input2);
	C1->rules[8]->predicate->premises[0]->set_scalar(input1);
	C1->rules[8]->predicate->premises[1]->set_scalar(input2);

    // run the controller for the new inputs
	remote_attractionsets[index]        = C1->GenerateOutputSet(AggregationMethod, CorrelationMethod, AlphaCutType, CompositionMethod);
	return remote_attractions[index]    = C1->GenerateOutput   (AggregationMethod, CorrelationMethod, AlphaCutType, CompositionMethod, DefuzzificationMethod);
}









// fill (partially) candidate_nodes_ids[MAX_CANDIDATE_NODES] with ids of
// first nodes with attraction force > MEDIUM, the rest fill with INVALID_ID
void TMigrationFC::ChooseCandidates()
{
    for (int i=0; i<MAX_CANDIDATE_NODES; i++)
    {
        remote_demands[i] = i;
    }
}









// fill local_load
void TMigrationFC::GetLocalLoad()  //using Fragment->Node->NodeMonitor->Others[i]
{
// temporary
    local_load = random(100);
}


// for each chosen candidate node
// fill remote_loads[index]
void TMigrationFC::GetRemoteLoad(int index)  //using Fragment->Node->NodeMonitor->Others[i]
{
// temporary
    for (int i=0; i<MAX_CANDIDATE_NODES; i++)
    {
        remote_loads[i] = random(100);
    }
}


// for each chosen candidate node
// run C2 to get the local_repulsion force relative to its load
// fill local_repulsions[MAX_CANDIDATE_NODES] with the results
int TMigrationFC::RunC2(int index, double input1, double input2,
int AggregationMethod, int CorrelationMethod, int AlphaCutType, int CompositionMethod, int DefuzzificationMethod)
{
    // apply new inputs
	C2->rules[0]->predicate->premises[0]->set_scalar(input1);
	C2->rules[0]->predicate->premises[1]->set_scalar(input2);
	C2->rules[1]->predicate->premises[0]->set_scalar(input1);
	C2->rules[1]->predicate->premises[1]->set_scalar(input2);
	C2->rules[2]->predicate->premises[0]->set_scalar(input1);
	C2->rules[2]->predicate->premises[1]->set_scalar(input2);
	C2->rules[3]->predicate->premises[0]->set_scalar(input1);
	C2->rules[3]->predicate->premises[1]->set_scalar(input2);
	C2->rules[4]->predicate->premises[0]->set_scalar(input1);
	C2->rules[4]->predicate->premises[1]->set_scalar(input2);
	C2->rules[5]->predicate->premises[0]->set_scalar(input1);
	C2->rules[5]->predicate->premises[1]->set_scalar(input2);
	C2->rules[6]->predicate->premises[0]->set_scalar(input1);
	C2->rules[6]->predicate->premises[1]->set_scalar(input2);
	C2->rules[7]->predicate->premises[0]->set_scalar(input1);
	C2->rules[7]->predicate->premises[1]->set_scalar(input2);
	C2->rules[8]->predicate->premises[0]->set_scalar(input1);
	C2->rules[8]->predicate->premises[1]->set_scalar(input2);

    // run the controller for the new inputs
	local_repulsionsets[index]      = C2->GenerateOutputSet(AggregationMethod, CorrelationMethod, AlphaCutType, CompositionMethod);
	return local_repulsions[index]  = C2->GenerateOutput   (AggregationMethod, CorrelationMethod, AlphaCutType, CompositionMethod, DefuzzificationMethod);
}



// for each chosen candidate node, run C3 to get the migration force
// fill migrations[MAX_CANDIDATE_NODES] with the results
int TMigrationFC::RunC3(int index, double input1, double input2,
int AggregationMethod, int CorrelationMethod, int AlphaCutType, int CompositionMethod, int DefuzzificationMethod)
{
    // apply new inputs
	C3->rules[0]->predicate->premises[0]->set_scalar(input1);
	C3->rules[0]->predicate->premises[1]->set_scalar(input2);
	C3->rules[1]->predicate->premises[0]->set_scalar(input1);
	C3->rules[1]->predicate->premises[1]->set_scalar(input2);
	C3->rules[2]->predicate->premises[0]->set_scalar(input1);
	C3->rules[2]->predicate->premises[1]->set_scalar(input2);
	C3->rules[3]->predicate->premises[0]->set_scalar(input1);
	C3->rules[3]->predicate->premises[1]->set_scalar(input2);
	C3->rules[4]->predicate->premises[0]->set_scalar(input1);
	C3->rules[4]->predicate->premises[1]->set_scalar(input2);
	C3->rules[5]->predicate->premises[0]->set_scalar(input1);
	C3->rules[5]->predicate->premises[1]->set_scalar(input2);
	C3->rules[6]->predicate->premises[0]->set_scalar(input1);
	C3->rules[6]->predicate->premises[1]->set_scalar(input2);
	C3->rules[7]->predicate->premises[0]->set_scalar(input1);
	C3->rules[7]->predicate->premises[1]->set_scalar(input2);
	C3->rules[8]->predicate->premises[0]->set_scalar(input1);
	C3->rules[8]->predicate->premises[1]->set_scalar(input2);

    // run the controller for the new inputs
	migrationsets[index]        = C3->GenerateOutputSet(AggregationMethod, CorrelationMethod, AlphaCutType, CompositionMethod);
	return migrations[index]    = C3->GenerateOutput   (AggregationMethod, CorrelationMethod, AlphaCutType, CompositionMethod, DefuzzificationMethod);
}




// fill migration_node_id with the id of the node with the highest
// migrations[MAX_CANDIDATE_NODES] to migrate to.
// or fill migration_node_id with INVALID_ID for no migration
void TMigrationFC::SelectCandidate()
{
//
///    int    migration_node_id;
}






// returns the migration_node_id, if any
int TMigrationFC::Run()
{
    int index = 0;
    // fill demanding_nodes_ids[MAX_DEMANDING_NODES]
    IdentifyDemandingNodes();  // using Fragment->DemandHistoryTable[i]


    // fill local_demand
    GetLocalDemand();  // using Fragment->DemandHistoryTable[i]

    // for each demanding node in demanding_nodes_ids[MAX_DEMANDING_NODES]
    // fill remote_loads[index]
    GetRemoteDemand(index);  // using Fragment->DemandHistoryTable[i]

    // for each demanding node, run C1 to get its attraction force and
	// fill remote_attractions[MAX_DEMANDING_NODES] with the results
	RunC1(index, random(100), random(100), 0, 0, 0, 0, 0);


	// fill (partially) candidate_nodes_ids[MAX_CANDIDATE_NODES] with ids of
    // first nodes with attraction force > MEDIUM, the rest fill with INVALID_ID
	ChooseCandidates();



    // fill local_load
    GetLocalLoad();          //using Fragment->Node->NodeMonitor->Others[i]

    // for each chosen candidate node
    // fill remote_loads[index]
    GetRemoteLoad(index);//using Fragment->Node->NodeMonitor->Others[i]


    // for each chosen candidate node
    // run C2 to get the local_repulsion force relative to its load
	// fill local_repulsions[MAX_CANDIDATE_NODES] with the results
	RunC2(index, random(100), random(100), 0, 0, 0, 0, 0);

    // for each chosen candidate node, run C3 to get the migration force
	// fill migrations[MAX_CANDIDATE_NODES] with the results
	RunC3(index, random(100), random(100), 0, 0, 0, 0, 0);


	// fill migration_node_id with the id of the node with the highest
    // migrations[MAX_CANDIDATE_NODES] to migrate to.
    // or fill migration_node_id with INVALID_ID for no migration
	SelectCandidate();


	return migration_node_id;
}
////////////////////////////////////////////////////////////////////////////////