25 stop -= (stop - start) * 1e-10; // floating point precision!

26 if (step < 0) {

27 while ((j = start + step * i++) > stop) {

28 array.push(j);

29 }

30 } else {

31 while ((j = start + step * i++) < stop) {

32 array.push(j);

33 }

266 */

267 pv.logAdjusted = function(x, b) {

268 if (!isFinite(x)) return x;

269 var negative = x < 0;

270 if (x < b) x += (b - x) / b;

52

53 #ifdef INFINITIES

54 if (!isfinite(x))

55 return (x);

56 #endif

98 if (x >= 1.5)

99 {

100 while (tx > 2.5)

101 {

102 nx -= 1.0;

123 goto contz;

124 }

125 while (tx < 1.5)

126 {

127 if (tx == 0.0)

79 return (NANF);

80 #else

81 if (!isfinite(x))

82 return (x);

83 #endif

136 direction = 0;

137 z = 1.0;

138 while (x >= 3.0)

139 {

140 x -= 1.0;

142 }

143 /*

144 while (x < 0.0)

145 {

146 if (x > -1.E-4)

248

249 function hasErrorProto(obj) {

250 while (obj && (obj !== OBJECT_PROTOTYPE)) {

251 if (obj === ERROR_PROTOTYPE) {

252 return true;

310

311 function isInt(x) {

312 if (!isNumber(x) || (x !== Math.floor(x)) || !isFinite(x)) {

313 return false;

314 }

121 #endif

122 #ifdef INFINITIES

123 if(!isfinite(x))

124 return(x);

125 #endif

184 #endif

185 #ifdef INFINITIES

186 if(!isfinite(x))

187 return(x);

188 #endif

221 e = (NBITS -1) - e;

222 /* clean out 16 bits at a time */

223 while( e >= 16 )

224 {

225 #ifdef IBMPC

28 # wrapper for the core grisu function, primarily for debugging

29 function grisu(x::Float64, mode::Integer, ndigits::Integer)

30 if !isfinite(x); error("non-finite value: $x"); end

31 if ndigits < 0; error("negative digits requested"); end

32 @grisu_ccall x mode ndigits

68 pt = int(POINT[1])

69 if mode == PRECISION

70 while len > 1 && DIGITS[len] == '0'

71 len -= 1

72 end

89 # => 0.00########

90 write(io, "0.")

91 while pt < 0

92 write(io, '0')

93 pt += 1

34 #define PIKE_ISINF(X) isinf(X)

35 #elif defined(HAVE_ISFINITE)

36 #define PIKE_ISINF(X) (!isfinite(X))

37 #elif defined(HAVE__FINITE)

38 #define PIKE_ISINF(X) (!_finite(X))

32

33 #ifndef isinf

34 #define isinf(x) (!isfinite(x))

35 #endif

36

99

100 distMatrixTemp = distMatrix;

101 while(distMatrixTemp < distMatrixEnd)

102 {

103 value = *distMatrixTemp++;

121 infValue = 10;

122 distMatrixTemp = distMatrix;

123 while(distMatrixTemp < distMatrixEnd)

124 if(isinf(*distMatrixTemp++))

125 *(distMatrixTemp-1) = infValue;

25 global grisu, grisu_fix, grisu_sig

26 function grisu(x::Float64, mode::Integer, ndigits::Integer)

27 if !isfinite(x); error("non-finite value: $x"); end

28 if ndigits < 0; error("negative digits requested"); end

29 @grisu_ccall x mode ndigits

53 pt = _jl_point[1]

54 if mode == GRISU_PRECISION

55 while len > 1 && _jl_digits[len] == '0'

56 len -= 1

57 end

74 # => 0.00########

75 write(io, "0.")

76 while pt < 0

77 write(io, '0')

78 pt += 1

28 # wrapper for the core grisu function, primarily for debugging

29 function grisu(x::Float64, mode::Integer, ndigits::Integer)

30 if !isfinite(x); error("non-finite value: $x"); end

31 if ndigits < 0; error("negative digits requested"); end

32 @grisu_ccall x mode ndigits

60 pt = POINT[1]

61 if mode == PRECISION

62 while len > 1 && DIGITS[len] == '0'

63 len -= 1

64 end

80 # => 0.00########

81 write(io, "0.")

82 while pt < 0

83 write(io, '0')

84 pt += 1

48 function convert{T<:Integer}(::Type{Rational{T}}, x::FloatingPoint)

49 x == 0 && return zero(T)//one(T)

50 if !isfinite(x)

51 x < 0 && return -one(T)//zero(T)

52 x > 0 && return +one(T)//zero(T)

84 a = d = 1

85 b = c = 0

86 while true

87 f = itrunc(y); y -= f

88 p, q = f*a+c, f*b+d

18 {

19 #if defined (__PX4_NUTTX) || defined (__PX4_QURT)

20 if (!isfinite(x)) {

21 #else

22 if (!std::isfinite(x)) {

25 }

26

27 while (x >= (Type)M_PI) {

28 x -= (Type)(2.0 * M_PI);

29

30 }

31

32 while (x < (Type)(-M_PI)) {

33 x += (Type)(2.0 * M_PI);

34