File: ttcn3float.hh

package info (click to toggle)
eclipse-titan 6.5.0-1
  • links: PTS
  • area: main
  • in suites: buster
  • size: 101,128 kB
  • sloc: cpp: 259,139; ansic: 47,560; yacc: 22,554; makefile: 14,074; sh: 12,630; lex: 9,101; xml: 5,362; java: 4,849; perl: 3,784; awk: 48; php: 32; python: 13
file content (149 lines) | stat: -rw-r--r-- 3,839 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
/******************************************************************************
 * Copyright (c) 2000-2018 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
 *
 * Contributors:
 *   Balasko, Jeno
 *   Baranyi, Botond
 *   Raduly, Csaba
 *
 ******************************************************************************/
#ifndef TTCN3FLOAT_HH_
#define TTCN3FLOAT_HH_

#include <math.h>

/* TTCN-3 float values that have absolute value smaller than this
   are displayed in exponential notation. */
#define MIN_DECIMAL_FLOAT		1.0E-4
/* TTCN-3 float values that have absolute value larger or equal than this
   are displayed in exponential notation. */
#define MAX_DECIMAL_FLOAT		1.0E+10

#ifndef signbit
// Probably Solaris.
// Thankfully, IEEE Std 1003.1, 2004 Edition says that signbit is a macro,
// hence it's safe to use ifdef.

#ifdef __sparc
// Big endian

inline int signbitfunc(double d)
{
  return *((unsigned char*)&d) & 0x80;
}

#else
// Probably Intel, assume little endian
inline int signbitfunc(double d)
{
  return ((unsigned char*)&d)[sizeof(double)-1] & 0x80;
}

#endif

#define signbit(d) signbitfunc(d)

#endif // def signbit

/** A class which behaves almost, but not quite, entirely unlike
 *  a floating-point value.
 *
 *  It is used as a member of a union (in Value.hh);
 *  it MUST NOT have a constructor.
 */
struct ttcn3float {
  /// Implicit conversion
  operator double() const { return value; }

  /// Assignment from a proper double
  const ttcn3float& operator=(double d) {
    value = d;
    return *this;
  }

  /// Address-of, for scanf
  double* operator&() { return &value; }
  
  double operator+(const ttcn3float& x) const {
    return value + x.value;
  }

  const ttcn3float& operator+=(double d) {
    value += d;
    return *this;
  }

  const ttcn3float& operator-=(double d) {
    value -= d;
    return *this;
  }

  const ttcn3float& operator*=(double d) {
    value *= d;
    return *this;
  }

  const ttcn3float& operator/=(double d) {
    value /= d;
    return *this;
  }

  bool operator<(double d) const {
    if (isnan(value)) {
      return false; // TTCN-3 special: NaN is bigger than anything except NaN
    }
    else if (isnan(d)) {
      return true; // TTCN-3 special: NaN is bigger than anything except NaN
    }
    else if (value==0.0 && d==0.0) { // does not distinguish -0.0
      return signbit(value) && !signbit(d); // value negative, d positive
    }
    else { // finally, the sensible behavior
      return value < d;
    }
  }

  bool operator>(double d) const {
    if (isnan(value)) {
      return !isnan(d); // TTCN-3 special: NaN is bigger than anything except NaN
    }
    else if (isnan(d)) {
      return false; // TTCN-3 special: NaN is bigger than anything except NaN
    }
    else if (value==0.0 && d==0.0) { // does not distinguish -0.0
      return !signbit(value) && signbit(d); // value positive, d negative
    }
    else { // finally, the sensible behavior
      return value > d;
    }
  }

  bool operator==(double d) const {
    if (isnan(value)) {
      return !!isnan(d); // TTCN-3 special: NaN is bigger than anything except NaN
    }
    else if (isnan(d)) {
      return false;
    }
    else if (value==0.0 && d==0.0) { // does not distinguish -0.0
      return signbit(value) == signbit(d);
    }
    else { // finally, the sensible behavior
      return value == d;
    }
  }
public:
  double value;
};

/** Replacement for a user-defined constructor that ttcn3float can't have */
inline ttcn3float make_ttcn3float(double f) {
  ttcn3float retval = { f };
  return retval;
}

#endif /* TTCN3FLOAT_HH_ */