コード例 #1
0
ファイル: master.cpp プロジェクト: ogdf/ogdf
void Master::treeInterfaceNodeBounds(int id, double lb, double ub)
{
	if (VbcLog_ == NoVbc) return;

	//char string[256];
	ostringstream info;

	if (isInfinity(fabs(lb))) {
		if (isInfinity(fabs(ub)))
			info << "I " << id << " \\iLower Bound: ---\\nUpper Bound:  ---\\i";
		else
			info << "I " << id << " \\iLower Bound: ---\\nUpper Bound:  "
				<< std::ios::fixed << std::setprecision(2) << std::setw(6) << ub << "\\i";
	}
	else {
		if (isInfinity(fabs(ub)))
			info << "I " << id << " \\iLower Bound: "
				<< std::ios::fixed << std::setprecision(2) << std::setw(6) << lb
				<< "\\nUpper Bound:  ---\\i";
		else
			info << "I " << id << " \\iLower Bound: "
				<< std::ios::fixed << std::setprecision(2) << std::setw(6) << lb
				<< "\\nUpper Bound:  "
				<< std::ios::fixed << std::setprecision(2) << std::setw(6) << ub
				<< "\\i";
	}

	writeTreeInterface(info.str());
}
コード例 #2
0
ファイル: Coordinator.cpp プロジェクト: Chabrier/vle
void
Coordinator::processInit(Simulator* simulator)
{
    Time tn = simulator->init(m_currentTime);

    if (not isInfinity(tn)) {
        m_eventTable.addInternal(simulator, tn);
    }
}
コード例 #3
0
ファイル: Simulator.cpp プロジェクト: alsabadel/vle
InternalEvent * Simulator::buildInternalEvent(const Time& currentTime)
{
    Time time(timeAdvance());

    if (not isInfinity(time)) {
        return new InternalEvent(currentTime + time, this);
    } else {
        return 0;
    }
}
コード例 #4
0
ファイル: Simulator.cpp プロジェクト: alsabadel/vle
InternalEvent* Simulator::init(const Time& currentTime)
{
    Time time(m_dynamics->init(currentTime));

    if (not isInfinity(time)) {
        return new InternalEvent(currentTime + time, this);
    } else {
        return 0;
    }
}
コード例 #5
0
ファイル: ImfConvert.cpp プロジェクト: A7med-Shoukry/g3d
unsigned int
floatToUint (float f)
{
    if (isNegative (f) || isNan (f))
	return 0;

    if (isInfinity (f) || f > UINT_MAX)
	return UINT_MAX;

    return (unsigned int) f;
}
コード例 #6
0
ファイル: cost.cpp プロジェクト: axem/spritepack
	string Cost::toString(CostType costType) const
	{
		if (!isInfinity() && costType == CompressionCost)
		{
			return SpritePack::toString((double)value / 1000.0, 1) + "ms";
		}
		else
		{
			return Number::toString();
		}
	}
コード例 #7
0
	void NominalEventMonitor::stopMonitor() {
		stopped = true;
		if (running) {
			running = false;
			if (isInfinity(expectedSleepTime) || paused) {
				unlockConditionSatisfied();
			} else {
				wakeUp();
			}
		}
	}
コード例 #8
0
ファイル: RootCoordinator.cpp プロジェクト: Chabrier/vle
bool
RootCoordinator::run()
{
    m_currentTime = m_coordinator->getCurrentTime();

    if (isInfinity(m_currentTime))
        return false;

    if ((m_end - m_currentTime) < 0)
        return false;

    m_coordinator->run();

    return true;
}
コード例 #9
0
ファイル: NominalEventMonitor.cpp プロジェクト: Gingar/port
	void NominalEventMonitor::prepareNptTransitionsEvents() {
		AttributionEvent* event;
		set<double>* transValues;
		set<double>::iterator i;

		executionObject->prepareTransitionEvents(
				ContentAnchor::CAT_NPT,
				timeBaseProvider->getCurrentTimeValue(timeBaseId));

		transValues = executionObject->getTransitionsValues(
				ContentAnchor::CAT_NPT);

		if (transValues == NULL || transValues->empty()) {
			cout << "NominalEventMonitor::prepareNptTransitionsEvents ";
			cout << "nothing to do (2)." << endl;
			return;
		}

		executionObject->updateTransitionTable(
				timeBaseProvider->getCurrentTimeValue(timeBaseId),
				NULL,
				ContentAnchor::CAT_NPT);

		i = transValues->begin();
		while (i != transValues->end()) {
			if (!isInfinity(*i)) {
				/*cout << "NominalEventMonitor::prepareNptTransitionsEvents ";
				cout << "add listener contentId '" << timeBaseId;
				cout << "' for value '" << *i;
				cout << "' (current time = '";
				cout << timeBaseProvider->getCurrentTimeValue(timeBaseId);
				cout << "')" << endl;*/

				timeBaseProvider->addTimeListener(timeBaseId, *i, this);
			}
			++i;
		}

		delete transValues;

		event = (AttributionEvent*)(executionObject->getEventFromAnchorId(
				"contentId"));

		if (event != NULL) {
			adapter->setPropertyValue(event, itos(timeBaseId), NULL);
			event->stop();
		}
	}
コード例 #10
0
ファイル: NominalEventMonitor.cpp プロジェクト: Gingar/port
	void NominalEventMonitor::stopMonitor() {
		stopped = true;

		if (timeBaseProvider != NULL) {
			timeBaseProvider->removeTimeListener(timeBaseId, this);
			timeBaseProvider->removeIdListener(this);
		}

		if (running) {
			running = false;
			if (isInfinity(expectedSleepTime) || paused) {
				unlockConditionSatisfied();
			} else {
				wakeUp();
			}
		}
	}
コード例 #11
0
	string FlexibleTimeMeasurement::toString() {
		return (
			  "expected value: "
			  + itos(expectedValue)
			  + "; actual value: "
			  + (isNaN(actualValue) ? "UNDEFINED" :
			  "" + itos(actualValue))) + (
			  "; minimum value: "
			  + itos(minimumValue)
			  + "; maximum value : "
			  + (isInfinity(maximumValue) ?
			  "INFINITY" : ""
			  + itos(maximumValue))
			  + "; computed value: "
			  + (isNaN(computedValue) ? "UNDEFINED"
			  : "" + itos(computedValue)));
	}
コード例 #12
0
ファイル: DecimalDecNumber.cpp プロジェクト: jiaxuan/mlnotes
std::string DecimalDecNumber::toStringAllowScientific(uint32 decimalPlaces) const
{
   if (!isZero() && !isInfinity() && !decNumberIsNaN(&m_value))
   {
      static const int BUFFER_SIZE = 256;
      char buffer[BUFFER_SIZE];
      {
         DecimalDecNumber rounded(*this);
         rounded.round(decimalPlaces, RoundingMode::ROUND_TO_ZERO);
         decNumberToString(&rounded.m_value, buffer);
      }

      char * e = buffer + strlen(buffer);
      char * f = std::find(buffer, e, '+');
      if (f != e)
         return buffer;
   }
   return toString(decimalPlaces);
}
コード例 #13
0
	string LinearCostFunctionDuration::toString() {
		return (
			(
			"expected value: "
			+ itos(expectedValue)
			+ "; actual value: "
			+ (!isNaN(actualValue) ? "UNDEFINED" :
			"" + itos(actualValue))) +
			("; minimum value: "
			+ itos(minimumValue)
			+ "; maximum value : "
			+ (isInfinity(maximumValue) ?
			"INFINITY" : "" + itos(maximumValue))
			+ "; computed value: "
			+ (!isNaN(computedValue) ? "UNDEFINED"
			: "" + itos(computedValue)))
			+ "; shrinking cost rate: "
			+ itos(getShrinkingCostRate())
			+ "; stretching cost rate: "
			+ itos(getStretchingCostRate()));
	}
コード例 #14
0
int ss_func( const gsl_vector* x, void* params, gsl_vector* f )
{
	struct reac_info* ri = (struct reac_info *)params;
	// Stoich* s = reinterpret_cast< Stoich* >( ri->stoich.eref().data() );
	int num_consv = ri->num_mols - ri->rank;

	for ( unsigned int i = 0; i < ri->num_mols; ++i ) {
		double temp = op( gsl_vector_get( x, i ) );
		if ( isNaN( temp ) || isInfinity( temp ) ) {
			return GSL_ERANGE;
		} else {
			ri->nVec[i] = temp;
		}
	}
	vector< double > vels;
	ri->pool->updateReacVelocities( &ri->nVec[0], vels );
	assert( vels.size() == static_cast< unsigned int >( ri->num_reacs ) );

	// y = Nr . v
	// Note that Nr is row-echelon: diagonal and above.
	for ( int i = 0; i < ri->rank; ++i ) {
		double temp = 0;
		for ( int j = i; j < ri->num_reacs; ++j )
			temp += gsl_matrix_get( ri->Nr, i, j ) * vels[j];
		gsl_vector_set( f, i, temp );
	}

	// dT = gamma.S - T
	for ( int i = 0; i < num_consv; ++i ) {
		double dT = - ri->T[i];
		for ( unsigned int j = 0; j < ri->num_mols; ++j )
			dT += gsl_matrix_get( ri->gamma, i, j) *
				op( gsl_vector_get( x, j ) );

		gsl_vector_set( f, i + ri->rank, dT );
	}

	return GSL_SUCCESS;
}
コード例 #15
0
ファイル: Coordinator.cpp プロジェクト: Chabrier/vle
void
Coordinator::run()
{
    Bag& bag = m_eventTable.getCurrentBag();
    if (not bag.dynamics.empty() or not bag.executives.empty())
        m_currentTime = m_eventTable.getCurrentTime();
    else
        vDbg(m_context, "Coordinator::run bag is empty...\n");

    vDbg(m_context, _("-------- BAG [%f] --------\n"), m_currentTime);

    //
    // Call output functions for all executives and dynamics models then
    // dispatches external events for all executives and dynamics.
    //

    const std::size_t nb_dynamics = bag.dynamics.size();
    const std::size_t nb_executive = bag.executives.size();

    if (nb_dynamics > 0) {
        for (std::size_t i = 0; i != nb_dynamics; ++i)
            bag.dynamics[i]->output(m_currentTime);

        dispatchExternalEvent(bag.dynamics, nb_dynamics);
    }

    if (nb_executive > 0) {
        for (std::size_t i = 0; i != nb_executive; ++i)
            bag.executives[i]->output(m_currentTime);

        dispatchExternalEvent(bag.executives, nb_executive);
    }

    //
    // First we sort executives models according to the depth of the executive
    // model into the structure of the models.
    //
    if (not bag.executives.empty()) {
        std::sort(bag.executives.begin(),
                  bag.executives.end(),
                  [](const Simulator* lhs, const Simulator* rhs) {
                      return ::depth(lhs->dynamics()) <
                             ::depth(rhs->dynamics());
                  });
    }

    //
    // Compute internal, confluent or external transition for dynamics models.
    // If parallelization is available, use it otherwise, compute transition
    // linearly.
    //
    if (m_simulators_thread_pool.parallelize()) {
        m_simulators_thread_pool.for_each(bag.dynamics, m_currentTime);
    } else {
        for (auto& elem : bag.dynamics) {
            if (elem->haveInternalEvent()) {
                if (not elem->haveExternalEvents())
                    elem->internalTransition(m_currentTime);
                else
                    elem->confluentTransitions(m_currentTime);
            } else {
                elem->externalTransition(m_currentTime);
            }
        }
    }

    for (auto& elem : bag.dynamics) {
        auto tn = elem->getTn();
        if (not isInfinity(tn))
            m_eventTable.addInternal(elem, tn);
    }

    for (auto& elem : bag.executives) {
        if (elem->haveInternalEvent()) {
            if (not elem->haveExternalEvents())
                elem->internalTransition(m_currentTime);
            else
                elem->confluentTransitions(m_currentTime);
        } else {
            elem->externalTransition(m_currentTime);
        }
    }

    for (auto& elem : bag.executives) {
        auto tn = elem->getTn();
        if (not isInfinity(tn))
            m_eventTable.addInternal(elem, tn);
    }

    //
    // Finally, we go through simulators and executive to get all observation
    // and dispatch to output plug-in.
    //
    for (auto& elem : bag.dynamics) {
        auto& observations = elem->getObservations();
        for (auto& obs : observations)
            obs.view->run(elem->dynamics().get(),
                          m_currentTime,
                          obs.portname,
                          std::move(obs.value));

        observations.clear();
    }

    for (auto& elem : bag.executives) {
        auto& observations = elem->getObservations();
        for (auto& obs : observations)
            obs.view->run(elem->dynamics().get(),
                          m_currentTime,
                          obs.portname,
                          std::move(obs.value));

        observations.clear();
    }

    //
    // Process observation event if the next bag is scheduled for a different
    // date than \e m_currentTime.
    //
    auto next = m_eventTable.getNextTime();
    if (next > m_currentTime) {

        //
        // Scheduler is empty. We eat all timed view until the duration time
        //
        auto eatuntil = std::min(next, m_durationTime);

        while (m_timed_observation_scheduler.haveObservationAtTime(eatuntil)) {
            auto obs =
              m_timed_observation_scheduler.getObservationAtTime(eatuntil);

            if (not obs.empty()) {
                m_currentTime = obs.back().mTime;

                for (auto& elem : obs) {
                    elem.run();
                    elem.update();

                    if (not isInfinity(elem.mTime))
                        m_timed_observation_scheduler.add(
                          elem.mView, elem.mTime, elem.mTimestep);
                }
            }
        }

        if (isInfinity(next) or next > m_durationTime) {
            //
            // For all Timed view, process a final observation and clear the
            // scheduler.
            //
            m_currentTime = m_durationTime;
            m_timed_observation_scheduler.finalize(m_currentTime);
        }
    }

    //
    // Finally, we destroy model and simulator if one executive delete a model
    //
    if (not m_delete_model.empty())
        dynamic_deletion();

    m_eventTable.makeNextBag();
    m_currentTime = m_eventTable.getCurrentTime();
}
コード例 #16
0
ファイル: NominalEventMonitor.cpp プロジェクト: Gingar/port
	void NominalEventMonitor::resumeMonitor() {
		if (!isInfinity(expectedSleepTime) && paused) {
			paused = false;
			unlockConditionSatisfied();
		}
	}
コード例 #17
0
ファイル: IntervalAnchor.cpp プロジェクト: lince/ginga-srpp
	bool IntervalAnchor::isObjectDuration(double value) {
		return isInfinity(value);
	}
コード例 #18
0
ファイル: NominalEventMonitor.cpp プロジェクト: Gingar/port
	void NominalEventMonitor::run() {
		lock();
		EventTransition* nextTransition;
		double time;
		double mediaTime = 0;
		double nextEntryTime;
		nextTransition = NULL;

		/*cout << "====== Anchor Monitor Activated for '";
		cout << executionObject->getId().c_str() << "' (";
		cout << this << " ======" << endl;*/

		while (running) {
			if (deleting) {
				break;
			}

			if (paused) {
				waitForUnlockCondition();

			} else {
				if (executionObject != NULL) {
					nextTransition = executionObject->getNextTransition();

				} else {
					nextTransition = NULL;
					running = false;
				}

				if (nextTransition == NULL) {
					running = false;

				} else {
					nextEntryTime = nextTransition->getTime();
					if (isInfinity(nextEntryTime)) {
						expectedSleepTime = infinity();

					} else {
						mediaTime = (adapter->getPlayer()->getMediaTime()
								* 1000);

      					expectedSleepTime = nextEntryTime - mediaTime;
					}

					/*cout << "ANCHORMONITOR NEXTTRANSITIONTIME = '";
					cout << nextEntryTime << "' MEDIATIME = '" << mediaTime;
					cout << "' EXPECTEDSLEEPTIME = '" << expectedSleepTime;
					cout << "' (" << this << ")" << endl;*/

					if (running && !deleting) {
						if (isInfinity(expectedSleepTime)) {
							waitForUnlockCondition();

						} else {
							Thread::usleep((int)(expectedSleepTime));
						}

						if (running && !deleting) {
							if (executionObject == NULL || adapter == NULL) {
								unlock();
								return;
							}

							mediaTime = (adapter->getPlayer()->getMediaTime()
									* 1000);

							time = nextEntryTime - mediaTime;
							if (time < 0) {
								time = 0;
							}

							if (!paused && time <= DEFAULT_ERROR) {
								// efetua a transicao no estado do evento
								executionObject->updateTransitionTable(
									   mediaTime + DEFAULT_ERROR,
									   adapter->getPlayer(),
									   ContentAnchor::CAT_TIME);
							}
						}
					}
				}
			}
		}

		if (!stopped && adapter != NULL && !deleting) {
			adapter->getPlayer()->forceNaturalEnd();
		}
		unlock();
	}
コード例 #19
0
ファイル: NominalEventMonitor.cpp プロジェクト: Gingar/port
	void NominalEventMonitor::pauseMonitor() {
		if (!isInfinity(expectedSleepTime)) {
			wakeUp();
			paused = true;
		}
	}
コード例 #20
0
ファイル: DecimalDecNumber.cpp プロジェクト: jiaxuan/mlnotes
// Lalit: toString should "truncate" values rather than round
std::string DecimalDecNumber::toString(uint32 decimalPlaces) const
{
   // Remove these statics if we ever get a short string optimisation in place (gcc 4.1)
   static const std::string zero = "0.0";
   static const std::string posinf = "+INF";
   static const std::string neginf = "-INF";
   static const std::string nan = "NaN";

   if (isZero())
      return zero;
   else if (isInfinity())
   {
      return isNegative() ? neginf : posinf;
   }
   else if (decNumberIsNaN(&m_value))
   {
      // TODO: is it possible to have positive/negative nans?
      return nan;
   }
  
   static const int BUFFER_SIZE = 256;
   char buffer[BUFFER_SIZE];
   {
      DecimalDecNumber rounded(*this);
      rounded.round(decimalPlaces, RoundingMode::ROUND_TO_ZERO);
      decNumberToString(&rounded.m_value, buffer);
   }

   // printf("after round: %s\n", buffer);

   char * b = buffer;
   char * e = buffer + strlen(buffer);
   unpackScientificFormat(b, e, BUFFER_SIZE, decimalPlaces);

   if ((e-b) == 3 && strcmp(buffer, "NaN") == 0)
   {
      return buffer;
   }
   else if (std::find(b, e, '.') == e)
   {
      strcpy(e, ".0");
      return buffer;
   }

   {
      // This code makes the unit tests pass (which were based on the old Decimal implementation)
      // Ensure that there are no trailing zeros, except when the value is an integer, in which case there should be one trailing zero.
      char * lastNonZeroDigitAfterDecimal = e - 1;
      while (*lastNonZeroDigitAfterDecimal == '0')
      {
         --lastNonZeroDigitAfterDecimal;
      }

      if (*lastNonZeroDigitAfterDecimal == '.')
      {
         *(++lastNonZeroDigitAfterDecimal) = '0';
      }
      *(lastNonZeroDigitAfterDecimal + 1) = 0;
   }

   // printf("last return\n");
   return buffer;
}