EZ::Punkt2D WegstueckSchlange::endpunkt()
{
if (anzahl()>0)
return letztesWegstueck()->endpunkt();
else
return Punkt2D(NaN(),NaN());
}
void CascadingDescriptor::initializeCascadingDescriptor() {
typeSet.insert("CascadingDescriptor");
id = "";
explicitDuration = NaN();
playerName = "";
repetitions = 0;
freeze = false;
region = NULL;
formatterRegion = NULL;
focusIndex = "";
moveUp = "";
moveDown = "";
moveLeft = "";
moveRight = "";
focusSrc = "";
selectionSrc = "";
focusBorderColor = NULL;
selBorderColor = NULL;
focusBorderWidth = 0;
focusBorderTransparency = NaN();
inputTransitions = new vector<Transition*>;
outputTransitions = new vector<Transition*>;
parameters = new map<string, string>;
descriptors = new vector<GenericDescriptor*>;
unsolvedDescriptors = new vector<GenericDescriptor*>;
}
QString ReadableNumber::makeReadable(const char *s) const
{
QString qs;
bool ok;
auto parts = QString(s).split('.');
auto integer_part = parts[0].toLong(&ok);
if (!ok) return NaN();
qs += makeReadable(integer_part);
if (1 == parts.size()) return qs;
QString fractional_part = parts[1];
if (0 == fractional_part.size()) return qs;
qs += " POINT";
foreach(auto c, fractional_part)
{
auto digit = (long)c.digitValue();
if (-1 == digit) return NaN();
qs += " " + makeReadable((long)digit);
}
EZ::Punkt2D WegstueckSchlange::endpunkt( int nummer )
{
sWegstueck::Zeiger weg = wegstueck(nummer);
if (weg!= NULL)
return weg->endpunkt();
else
return Punkt2D(NaN(),NaN());
}
EZ::Punkt2D WegstueckSchlange::endpunkt( double definitionswert )
{
sWegstueck::Zeiger weg = wegstueck(definitionswert);
if (weg!= NULL)
return weg->endpunkt();
else
return Punkt2D(NaN(),NaN());
}
FlexibleTimeMeasurement::FlexibleTimeMeasurement(
double expectedValue, double minValue, double maxValue) :
TimeMeasurement(expectedValue) {
computedValue = NaN();
minFeasibleValue = NaN();
maxFeasibleValue = NaN();
setBoundaryValues(minValue, maxValue);
}
/* ParseDataArray: Stores in the data array.
* Returns the number of entries used. */
int ParseDataArray()
{
size_t originalDC;
int number;
bool notNumber;
originalDC = DC;
notNumber = false;
/* construct a word for each element in the array and store it */
while ((part = strtok(NULL, DELIMITERS_AND_COMMA)) != NULL)
{
NaN(part, notNumber);
number = atoi(part);
if (notNumber == true || (number == ZERO && *part != ZERO_CHAR))
{
DC = originalDC;
SYNTAX_ASSERT(false, DATA_DEF_CONTAINS_NAN);
return ERROR;
}
data[DC].Bits = number;
DC++;
}
SYNTAX_ASSERT(ZERO < DC - originalDC, DATA_DEF_NO_NUMBERS);
return DC - originalDC;
}
double
acos(double arg)
{
if(arg > 1 || arg < -1)
return NaN();
return PIO2 - asin(arg);
}
double WegstueckSchlange::endausrichtung()
{
if (anzahl()>0)
return letztesWegstueck()->endausrichtung();
else
return NaN();
}
double WegstueckSchlange::laenge( int nummer )
{
if (nummer<anzahl())
return (wegstueck(nummer)->weglaenge());
else
return NaN();
}
double WegstueckSchlange::winkel( int nummer )
{
Kreiswegstueck::Zeiger kreisweg = Kreiswegstueck::Zeiger::konvertiere(wegstueck(nummer));
if (kreisweg!=NULL)
return kreisweg->winkel();
else
return NaN();
}
double WegstueckSchlange::winkel( double definitionswert )
{
Kreiswegstueck::Zeiger kreisweg = Kreiswegstueck::Zeiger::konvertiere(wegstueck(definitionswert));
if (kreisweg!=NULL)
return kreisweg->winkel();
else
return NaN();
}
double WegstueckSchlange::endausrichtung( double defintionswert )
{
sWegstueck::Zeiger weg = wegstueck(defintionswert);
if (weg!= NULL)
return weg->endausrichtung();
else
return NaN();
}
double WegstueckSchlange::endausrichtung( int nummer )
{
sWegstueck::Zeiger weg = wegstueck(nummer);
if (weg!= NULL)
return weg->endausrichtung();
else
return NaN();
}
double WegstueckSchlange::laenge( double definitionswert )
{
sWegstueck::Zeiger weg = wegstueck(definitionswert);
if (weg!= NULL)
return weg->weglaenge();
else
return NaN();
}
double WegstueckSchlange::startDefinitionswert( int nummer )
{
double definitionswert = 0.0;
for (deque<sWegstueck::Zeiger>::iterator iter = m_schlange.begin();iter < m_schlange.end();iter++)
{
if (nummer-- == 0)
return definitionswert;
definitionswert=definitionswert+=(*iter)->weglaenge();
}
return NaN();
}
double WegstueckSchlange::startDefinitionswert( double def )
{
double definitionswert = 0.0;
for (deque<sWegstueck::Zeiger>::iterator iter = m_schlange.begin();iter < m_schlange.end();iter++)
{
double alterDefwert = definitionswert;
definitionswert += (*iter)->weglaenge();
if (def<definitionswert)
return alterDefwert;
}
return NaN();
}
int
main ()
{
/* Finite values. */
ASSERT (!isnanf (3.141f));
ASSERT (!isnanf (3.141e30f));
ASSERT (!isnanf (3.141e-30f));
ASSERT (!isnanf (-2.718f));
ASSERT (!isnanf (-2.718e30f));
ASSERT (!isnanf (-2.718e-30f));
ASSERT (!isnanf (0.0f));
ASSERT (!isnanf (-0.0f));
/* Infinite values. */
ASSERT (!isnanf (1.0f / 0.0f));
ASSERT (!isnanf (-1.0f / 0.0f));
/* Quiet NaN. */
ASSERT (isnanf (NaN ()));
#if defined FLT_EXPBIT0_WORD && defined FLT_EXPBIT0_BIT
/* Signalling NaN. */
{
#define NWORDS \
((sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
typedef union { float value; unsigned int word[NWORDS]; } memory_float;
memory_float m;
m.value = NaN ();
# if FLT_EXPBIT0_BIT > 0
m.word[FLT_EXPBIT0_WORD] ^= (unsigned int) 1 << (FLT_EXPBIT0_BIT - 1);
# else
m.word[FLT_EXPBIT0_WORD + (FLT_EXPBIT0_WORD < NWORDS / 2 ? 1 : - 1)]
^= (unsigned int) 1 << (sizeof (unsigned int) * CHAR_BIT - 1);
# endif
if (FLT_EXPBIT0_WORD < NWORDS / 2)
m.word[FLT_EXPBIT0_WORD + 1] |= (unsigned int) 1 << FLT_EXPBIT0_BIT;
else
m.word[0] |= (unsigned int) 1;
ASSERT (isnanf (m.value));
}
#endif
return 0;
}
/***********************************************************************
* Free dynamic memory used by one motif.
***********************************************************************/
void free_motif
(MOTIF_T *a_motif)
{
/* Don't bother with empty motifs. */
if (a_motif == NULL)
return;
// Reset all memeber values
a_motif->id[0] = 0;
a_motif->id2[0] = 0;
a_motif->length = 0;
a_motif->alph_size = 0;
a_motif->ambigs = 0;
a_motif->evalue = NaN();
a_motif->num_sites = NaN();
a_motif->complexity = NaN();
free_matrix(a_motif->freqs);
a_motif->freqs = NULL;
free_matrix(a_motif->scores);
a_motif->freqs = NULL;
if (a_motif->url) free(a_motif->url);
a_motif->url = NULL;
}
std::string FloatConstantGenerator::GenFloatConstantImpl(
const FieldDef &field) const {
const auto &constant = field.value.constant;
T v;
auto done = StringToNumber(constant.c_str(), &v);
FLATBUFFERS_ASSERT(done);
if (done) {
#if (!defined(_MSC_VER) || (_MSC_VER >= 1800))
if (std::isnan(v)) return NaN(v);
if (std::isinf(v)) return Inf(v);
#endif
return Value(v, constant);
}
return "#"; // compile time error
}
Descriptor::Descriptor(string id) :
GenericDescriptor(id) {
explicitDuration = NaN();
presentationTool = "";
repetitions = 0;
freeze = false;
region = NULL;
parameters = new map<string, Parameter*>;
keyNavigation = NULL;
focusDecoration = NULL;
inputTransitions = new vector<Transition*>;
outputTransitions = new vector<Transition*>;
typeSet.insert("Descriptor");
}
/*
sqrtC returns the square root of its floating
point argument. Newton's method.
calls frexp
*/
double
sqrtC(double arg)
{
double x, temp;
int exp, i;
if(arg <= 0) {
if(arg < 0)
return NaN();
return 0;
}
if(isInf(arg, 1))
return arg;
x = frexp(arg, &exp);
while(x < 0.5) {
x *= 2;
exp--;
}
/*
* NOTE
* this wont work on 1's comp
*/
if(exp & 1) {
x *= 2;
exp--;
}
temp = 0.5 * (1.0+x);
while(exp > 60) {
temp *= (1L<<30);
exp -= 60;
}
while(exp < -60) {
temp /= (1L<<30);
exp += 60;
}
if(exp >= 0)
temp *= 1L << (exp/2);
else
temp /= 1L << (-exp/2);
for(i=0; i<=4; i++)
temp = 0.5*(temp + arg/temp);
return temp;
}
void SolveGEIP(const Matrix& A, Vector &x, const Vector& b)
{
// Verify that the system is well-formed
const int size = A.Rows();
if ((A.Cols() != size) || (b.Size() != size)) {
throw NonconformableShapesError();
}
// Prepare the augmented matrix
Matrix aug(size, size+1, NaN());
for (int i = 0; i < size; ++i) {
aug.Col(i) = A.Col(i);
}
aug.Col(size) = b;
// Go to town...
eliminate(aug, size, fabs(1e-14));
back_substitute(aug, size);
x = aug.Col(size);
}
double
asin(double arg)
{
double temp;
int sign;
sign = 0;
if(arg < 0) {
arg = -arg;
sign++;
}
if(arg > 1)
return NaN();
temp = sqrt(1 - arg*arg);
if(arg > 0.7)
temp = PIO2 - atan(temp/arg);
else
temp = atan(arg/temp);
if(sign)
temp = -temp;
return temp;
}
bool Steuerfunktionen::aktualisiereRaender()
{
// die definierten Definitionsmaxima und -minima in Vektoren speichern,
// um dann daraus den größten bzw. kleinsten Wert zu ermitteln.
std::vector <double> minima;
std::vector <double> maxima;
if (m_geschwindigkeitFunktion!=NULL)
{
minima.push_back(m_geschwindigkeitFunktion->definitionsminimum());
maxima.push_back(m_geschwindigkeitFunktion->definitionsmaximum());
}
if (m_lenkwinkelAenderungFunktion!=NULL)
{
minima.push_back(m_lenkwinkelAenderungFunktion->definitionsminimum());
maxima.push_back(m_lenkwinkelAenderungFunktion->definitionsmaximum());
}
// Alle NaN Werte entfernen
minima.erase(remove_if(minima.begin(),minima.end(),&istNaN),minima.end());
maxima.erase(remove_if(maxima.begin(),maxima.end(),&istNaN),maxima.end());
if (minima.empty()||maxima.empty())
{
// Ränder können nicht bestimmt werden
m_definitionsmaximum = m_definitionsmaximum = NaN();
return false;
}
else
{
m_definitionsminimum = *std::max_element(minima.begin(),minima.end()); // Maximum der Minima
m_definitionsmaximum = *std::min_element(maxima.begin(),maxima.end()); // Minimum der Maxima
m_definitionsmaximum = std::max(m_definitionsmaximum,m_definitionsminimum); //Maximum >= Minimum
return true;
}
};
double Steuerfunktionen::lenkwinkelAenderung( double d ) const
{
if (m_lenkwinkelAenderungFunktion == NULL)
return NaN();
return (*m_lenkwinkelAenderungFunktion)(d);
}
double Steuerfunktionen::geschwindigkeit( double d ) const
{
if (m_geschwindigkeitFunktion == NULL)
return NaN();
return (*m_geschwindigkeitFunktion)(d);
}
Interval::Interval():
_lower( NaN() ),
_upper( NaN() )
{
}
BOOLEAN_T get_next_data_block_from_prior_reader_from_psp(
DATA_BLOCK_READER_T *reader,
DATA_BLOCK_T *data_block
) {
BOOLEAN_T result = FALSE;
const int buffer_size = 100;
char buffer[buffer_size];
int num_read = 0;
PSP_DATA_BLOCK_READER_T *psp_reader
= (PSP_DATA_BLOCK_READER_T *) get_data_block_reader_data(reader);
double *output_prior = get_prior_from_data_block(data_block);
*output_prior = NaN();
int c = 0;
// Skip over leading white space
while((c = fgetc(psp_reader->psp_file)) != EOF) {
if (isspace(c)) {
if (c == '\n') {
psp_reader->at_start_of_line = TRUE;
}
else {
psp_reader->at_start_of_line = FALSE;
}
continue;
}
else {
break;
}
}
if (c == '>' && psp_reader->at_start_of_line == TRUE) {
// We found the start of a new sequence while trying
// to find a prior.
c = ungetc(c, psp_reader->psp_file);
if (ferror(psp_reader->psp_file)) {
die(
"Error reading file:%s.\nError message: %s\n",
psp_reader->filename,
strerror(ferror(psp_reader->psp_file))
);
}
}
else {
// We are at start of a prior.
// Read prior string until next space or EOF.
int buffer_index = 0;
while(c != EOF && !isspace(c)) {
buffer[buffer_index] = c;
++buffer_index;
if (buffer_index >= (buffer_size - 1)) {
// No prior string should be this long
buffer[buffer_size - 1] = 0;
die("File %s contains invalid prior value: %s\n", psp_reader->filename, buffer);
}
c = fgetc(psp_reader->psp_file);
}
if (c == '\n') {
psp_reader->at_start_of_line = TRUE;
}
else {
psp_reader->at_start_of_line = FALSE;
}
buffer[buffer_index] = '\0';
// If the buffer is not empty, it should contain a string
// representing the prior. Convert it to a double.
if (buffer_index != 0) {
char *end_ptr = NULL;
double prior = strtod(buffer, &end_ptr);
if (end_ptr == buffer
|| *end_ptr != '\0'
|| prior < 0.0L
|| prior > 1.0L
) {
die("File %s contains invalid prior value: %s\n", psp_reader->filename, buffer);
}
*output_prior = prior;
num_read = 1;
++psp_reader->current_position;
result = TRUE;
}
}
if (c == EOF && ferror(psp_reader->psp_file)) {
die(
"Error while reading file:%s.\nError message: %s\n",
psp_reader->filename,
strerror(ferror(psp_reader->psp_file))
);
}
set_start_pos_for_data_block(data_block, psp_reader->current_position);
set_num_read_into_data_block(data_block, num_read);
return result;
}
double
charstod(int(*f)(void*), void *vp)
{
char str[400], *s, *e, *start;
int c;
s = str;
e = str + sizeof str - 1;
c = (*f)(vp);
while(c == ' ' || c == '\t')
c = (*f)(vp);
if(c == '-' || c == '+'){
ADVANCE;
}
start = s;
while(c >= '0' && c <= '9'){
ADVANCE;
}
if(c == '.'){
ADVANCE;
while(c >= '0' && c <= '9'){
ADVANCE;
}
}
if(s > start && (c == 'e' || c == 'E')){
ADVANCE;
if(c == '-' || c == '+'){
ADVANCE;
}
while(c >= '0' && c <= '9'){
ADVANCE;
}
}else if(s == start && (c == 'i' || c == 'I')){
ADVANCE;
if(c != 'n' && c != 'N')
return NaN();
ADVANCE;
if(c != 'f' && c != 'F')
return NaN();
ADVANCE;
if(c != 'i' && c != 'I')
return NaN();
ADVANCE;
if(c != 'n' && c != 'N')
return NaN();
ADVANCE;
if(c != 'i' && c != 'I')
return NaN();
ADVANCE;
if(c != 't' && c != 'T')
return NaN();
ADVANCE;
if(c != 'y' && c != 'Y')
return NaN();
ADVANCE; /* so caller can back up uniformly */
USED(c);
}else if(s == str && (c == 'n' || c == 'N')){
ADVANCE;
if(c != 'a' && c != 'A')
return NaN();
ADVANCE;
if(c != 'n' && c != 'N')
return NaN();
ADVANCE; /* so caller can back up uniformly */
USED(c);
}
*s = 0;
return strtod(str, &s);
}
