/** * Generates a chain connecting the original and simulated initial * observations of the given data object for the given period. * The chain is simple in the sense that no two ministeps cancel each other out. */ void Chain::createInitialStateDifferences() { deallocateVector(this->linitialStateDifferences); //Rprintf("******** %d create initial\n",this->linitialStateDifferences.size() ); Data * pData = this->lpData; State * initialState = this->lpInitialState; int period = this->lperiod; // Create the required ministeps for (unsigned variableIndex = 0; variableIndex < pData->rDependentVariableData().size(); variableIndex++) { LongitudinalData * pVariableData = pData->rDependentVariableData()[variableIndex]; NetworkLongitudinalData * pNetworkData = dynamic_cast<NetworkLongitudinalData *>(pVariableData); BehaviorLongitudinalData * pBehaviorData = dynamic_cast<BehaviorLongitudinalData *>(pVariableData); if (pNetworkData) { const Network * pNetwork1 = pNetworkData->pNetwork(period); const Network * pNetwork2 = initialState->pNetwork(pNetworkData->name()); for (int i = 0; i < pNetwork1->n(); i++) { IncidentTieIterator iter1 = pNetwork1->outTies(i); IncidentTieIterator iter2 = pNetwork2->outTies(i); while (iter1.valid() || iter2.valid()) { if (iter1.valid() && (!iter2.valid() || iter1.actor() < iter2.actor())) { if (!pNetworkData->structural(i, iter1.actor(), period) // || !pNetworkData->structural(i, iter1.actor(), // period + 1) ) { NetworkChange * pMiniStep = new NetworkChange(pNetworkData, i, iter1.actor(), false); // PrintValue(getMiniStepDF(*pMiniStep)); this->linitialStateDifferences. push_back(pMiniStep); iter1.next(); // PrintValue(getMiniStepDF( // *this->linitialStateDifferences.back())); } else { // create step in structural subchain? } } else if (iter2.valid() && (!iter1.valid() || iter2.actor() < iter1.actor())) { if (!pNetworkData->structural(i, iter2.actor(), period) // || !pNetworkData->structural(i, iter2.actor(), // period + 1) ) { this->linitialStateDifferences.push_back( new NetworkChange(pNetworkData, i, iter2.actor(), false)); iter2.next(); //PrintValue(getMiniStepDF( // *this->linitialStateDifferences.back())); } else { // create step in structural subchain? } } else { iter1.next(); iter2.next(); } } } } else if (pBehaviorData) { for (int i = 0; i < pBehaviorData->n(); i++) { int delta = initialState-> behaviorValues(pBehaviorData->name())[i] - pBehaviorData->value(period, i); int singleChange = 1; if (delta < 0) { delta = -delta; singleChange = -1; } for (int j = 0; j < delta; j++) { if (!pBehaviorData->structural(period, j) //|| !pBehaviorData->structural(period, j + 1) ) { this->linitialStateDifferences.push_back( new BehaviorChange(pBehaviorData, i, singleChange)); // Rprintf(" %d %d in beh\n", i, singleChange); } else { // create step in structural subchain? } } } } } // Rprintf("xx ********%d %d end create initial diff\n", this->linitialStateDifferences.size(), period); }
/** * Generates a random chain connecting the start and end observations of the * given data object for the given period. The chain is simple in the sense * that no two ministeps cancel each other out. */ void Chain::connect(int period, MLSimulation * pMLSimulation) { this->clear(); this->lperiod = period; vector<MiniStep *> miniSteps; // Create the required ministeps for (unsigned variableIndex = 0; variableIndex < this->lpData->rDependentVariableData().size(); variableIndex++) { LongitudinalData * pVariableData = this->lpData->rDependentVariableData()[variableIndex]; NetworkLongitudinalData * pNetworkData = dynamic_cast<NetworkLongitudinalData *>(pVariableData); BehaviorLongitudinalData * pBehaviorData = dynamic_cast<BehaviorLongitudinalData *>(pVariableData); if (pNetworkData) { const Network * pNetwork1 = pNetworkData->pNetwork(period); const Network * pNetwork2 = pNetworkData->pNetwork(period + 1); for (int i = 0; i < pNetwork1->n(); i++) { IncidentTieIterator iter1 = pNetwork1->outTies(i); IncidentTieIterator iter2 = pNetwork2->outTies(i); while (iter1.valid() || iter2.valid()) { if (iter1.valid() && (!iter2.valid() || iter1.actor() < iter2.actor())) { if (!pNetworkData->structural(i, iter1.actor(), period) // || !pNetworkData->structural(i, iter1.actor(), // period + 1) ) { miniSteps.push_back( new NetworkChange(pNetworkData, i, iter1.actor(), false)); iter1.next(); } else { // create step in structural subchain? } } else if (iter2.valid() && (!iter1.valid() || iter2.actor() < iter1.actor())) { if (!pNetworkData->structural(i, iter2.actor(), period) // || !pNetworkData->structural(i, iter2.actor(), // period + 1) ) { miniSteps.push_back( new NetworkChange(pNetworkData, i, iter2.actor(), false)); iter2.next(); } else { // create step in structural subchain? } } else { iter1.next(); iter2.next(); } } } } else if (pBehaviorData) { for (int i = 0; i < pBehaviorData->n(); i++) { int delta = pBehaviorData->value(period + 1, i) - pBehaviorData->value(period, i); int singleChange = 1; if (delta < 0) { delta = -delta; singleChange = -1; } for (int j = 0; j < delta; j++) { if (!pBehaviorData->structural(period, j) //|| !pBehaviorData->structural(period, j + 1) ) { miniSteps.push_back( new BehaviorChange(pBehaviorData, i, singleChange)); } else { // create step in structural subchain? } } } } } // If we have no constraints we can go ahead and add to the chain in a // random order. If we do have contraints we need to make sure our chain // is valid. For now we have two distinct loops: if (this->lpData->rNetworkConstraints().size() == 0) { // Randomize the ministeps for (unsigned i = 1; i < miniSteps.size(); i++) { int j = nextInt(i + 1); MiniStep * pTempMiniStep = miniSteps[i]; miniSteps[i] = miniSteps[j]; miniSteps[j] = pTempMiniStep; } // And finally add the ministeps to this chain for (unsigned i = 0; i < miniSteps.size(); i++) { this->insertBefore(miniSteps[i], this->lpLast); } } else { unsigned count = 0; vector<MiniStep *> remainingMiniSteps; while(miniSteps.size() > 0 && count < this->lpData->rDependentVariableData().size()) { count++; remainingMiniSteps.clear(); for (unsigned i = 0; i < miniSteps.size(); i++) { // first try random insert //const NetworkChange * pNetworkChange = // dynamic_cast<const NetworkChange *>(miniSteps[i]); MiniStep * pMiniStep = this->randomMiniStep(this->lpFirst->pNext(), this->lpLast); bool valid = false; if (miniSteps[i]->behaviorMiniStep()) { valid = true; } else { // get current state at this place pMLSimulation->initialize(this->lperiod); pMLSimulation->executeMiniSteps(this->lpFirst->pNext(), pMiniStep); // see if valid here DependentVariable * pVariable = pMLSimulation->rVariables()[miniSteps[i]->variableId()]; // PrintValue(getMiniStepDF(*miniSteps[i])); if (!pVariable->validMiniStep(miniSteps[i])) { // Rprintf("first inval\n"); // no go, so try to find somewhere else to put it MiniStep * pLastMiniStep = this->pLastMiniStepForLink(miniSteps[i]); if (pLastMiniStep != this->lpFirst) { // Rprintf("lastl\n"); // PrintValue(getMiniStepDF(*pLastMiniStep)); pMiniStep = this->randomMiniStep(pLastMiniStep->pNext(), this->lpLast); // PrintValue(getMiniStepDF(*pMiniStep)); pMLSimulation->initialize(this->lperiod); pMLSimulation->executeMiniSteps(this->lpFirst-> pNext(), pMiniStep); // see if valid here if (!pVariable->validMiniStep(miniSteps[i])) { // Rprintf("second inval\n"); // no go, so try to find somewhere else to put // it MiniStep * pFirstMiniStep = this->pFirstMiniStepForLink(miniSteps[i]); // if (pFirstMiniStep != this->lpFirst) //{ // PrintValue(getMiniStepDF(*pFirstMiniStep)); pMiniStep = this->randomMiniStep(this-> lpFirst->pNext(), pFirstMiniStep); // PrintValue(getMiniStepDF(*pMiniStep)); pMLSimulation->initialize(this->lperiod); pMLSimulation-> executeMiniSteps(pFirstMiniStep, pMiniStep); // see if valid here if (pVariable->validMiniStep(miniSteps[i])) { Rprintf("thirsd true val\n"); valid = true; } // } } else { valid = true; } } } else { valid = true; } } if (valid) { this->insertBefore(miniSteps[i], pMiniStep); } else { remainingMiniSteps.push_back(miniSteps[i]); } } miniSteps = remainingMiniSteps; } // PrintValue(getChainDF(*this, false)); // Rprintf("****** count %d\n", count); if (miniSteps.size() > 0) { for (unsigned i = 0; i < miniSteps.size(); i++) { PrintValue(getMiniStepDF(*miniSteps[i])); } error("Cannot create minimal chain due to constraints"); } } }