26 if (step < 0) {

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

28 array.push(j);

30 } else {

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

32 array.push(j);

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

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

269 var negative = x < 0;

12 function makeArrayLength(x) {

13 if (x < 1 || x > 4294967295 || x != x || isNaN(x) || !isFinite(x)) return 100;

14 else return Math.floor(x) & 0xffff;

73 }

74 } while (((~((new Error('abc')) instanceof((typeof RegExp == 'function') ? RegExp : Object)))) && __loopvar0 < 3)

75 if ((((protoObj1.prop1--) != (((VarArr0.unshift(((parseInt("-60") instanceof((typeof EvalError == 'function') ? EvalError : Object)) instanceof((typeof Error == 'function') ? Error : Object)), (++protoObj1.length), ((-1773563946 * 84 + 4294967296) == arrObj0.prop1), (arrObj0.prop0 %= aliasOfi16[(protoObj0.prop0) & 255]), ({}

80 #else

81 if (!isfinite(x))

82 return (x);

137 z = 1.0;

138 while (x >= 3.0)

139 {

143 /*

144 while (x < 0.0)

145 {

151 */

152 while (x < 2.0)

153 {

53 #ifdef INFINITIES

54 if (!isfinite(x))

55 return (x);

99 {

100 while (tx > 2.5)

101 {

124 }

125 while (tx < 1.5)

126 {

27 using std::isfinite;

28 if (!isfinite(x))

29 {

45 Real u = x;

46 while (abs(x_ - computed) > (i++)*scale)

47 {

28 using std::isfinite;

29 if (!isfinite(x))

30 {

49 int i = 0;

50 while (abs(f - x_) >= (1 + i++)*std::numeric_limits<Real>::epsilon()*abs(x_))

51 {

26 using std::isfinite;

27 if (!isfinite(x))

28 {

48 Real scale = std::numeric_limits<Real>::epsilon()*abs(x_)/2;

49 while (abs(x_ - computed) > (i++)*scale)

50 {

122 #ifdef INFINITIES

123 if(!isfinite(x))

124 return(x);

185 #ifdef INFINITIES

186 if(!isfinite(x))

187 return(x);

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

223 while( e >= 16 )

224 {

338 }

339 while( k == 0 );

340 i = i + k;

389 #endif

390 while( (e = (*q & 0x7ff0) >> 4) == 0 )

391 {

7 var e = -6;

8 function makeArrayLength(x) { if (x < 1 || x > 4294967295 || x != x || isNaN(x) || !isFinite(x)) return 100; else return Math.floor(x) & 0xffff; };;

9 var func3 = function (argStr4, argArr5, argArr6) {

19 obj1.length = makeArrayLength(undefined);

20 } while (((argArr5[(loopInvariant)] * ary[((((argArr6[(((arrObj0.prop0 >= 0 ? arrObj0.prop0 : 0)) & 0XF)] + i8[(18) & 255]) >= 0 ? (argArr6[(((arrObj0.prop0 >= 0 ? arrObj0.prop0 : 0)) & 0XF)] + i8[(18) & 255]) : 0)) & 0XF)] + ((obj1.prop1 !== e) || (arrObj0.prop0 != obj1.length)))))

21 return (5 in arrObj0);

6 function test0() {

7 function makeArrayLength(x) { if(x < 1 || x > 4294967295 || x != x || isNaN(x) || !isFinite(x)) return 100; else return Math.floor(x) & 0xffff; };;

8 var obj0 = {};

26 }

27 } while((1) && __loopvar1 < 3)

28 e *= arrObj0.prop0;

249 function hasErrorProto(obj) {

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

251 if (obj === ERROR_PROTOTYPE) {

311 function isInt(x) {

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

313 return false;

35 #elif defined(HAVE_ISFINITE)

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

37 #elif defined(HAVE__FINITE)

33 #ifndef isinf

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

35 #endif

100 distMatrixTemp = distMatrix;

101 while(distMatrixTemp < distMatrixEnd)

102 {

122 distMatrixTemp = distMatrix;

123 while(distMatrixTemp < distMatrixEnd)

124 if(isinf(*distMatrixTemp++))

151 distMatrixTemp += nOfRows;

152 while(distMatrixTemp < distMatrixEnd)

153 {

161 distMatrixTemp = distMatrix + row;

162 while(distMatrixTemp < distMatrixEnd)

163 {

124 exp = 1;

125 while ((bits & 0x800000) == 0) {

126 bits <<= 1;

139 public static native boolean isInfinite(float x) /*-{

140 return !isFinite(x);

141 }-*/;

150 #else

151 if( !isfinite(x) )

152 return(x);

207 z = 1.0;

208 while( x >= 3.0 )

209 {

213 /*

214 while( x < 0.0 )

215 {

221 */

222 while( x < 2.0 )

223 {

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

54 if mode == GRISU_PRECISION

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

56 len -= 1

75 write(io, "0.")

76 while pt < 0

77 write(io, '0')

83 write(io, pdigits, len)

84 while pt > len

85 write(io, '0')

130 write(io, '.')

131 while pt < 0

132 write(io, '0')

33 return pos + 3

34 elseif !isfinite(x)

35 buf[pos] = UInt8('I')

62 i = len - 1

63 while i >= 0

64 j = p10bits - e2

98 i = MIN_BLOCK_2[idx + 1]

99 while i < 200

100 j = 120 + (-e2 - 16 * idx)

184 roundPos = pos

185 while true

186 roundPos -= 1

208 if trimtrailingzeros

209 while buf[pos - 1] == UInt8('0')

210 pos -= 1

29 return pos + 3

30 elseif !isfinite(x)

31 buf[pos] = UInt8('I')

53 i = len - 1

54 while i >= 0

55 j = p10bits - e2

95 end

96 while i < blocks

97 j = 120 + (-e2 - 16 * idx)

113 k = 0

114 while k < 9 - maximum

115 # global digits, lastDigit, k

136 dotPos = 1

137 while true

138 roundPos -= 1

95 # a) slow loop

96 while true

97 c_div10 = div(c, 10)

113 if a_allzero

114 while true

115 a_div10 = div(a, 10)

148 end

149 while true

150 c_div10 = div(c, 10)

166 # reduce to max significant digits

167 while true

168 b_div10 = div(b, 10)

180 # remove trailing zeros

181 while true

182 b_div10 = div(b, 10)

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

61 if mode == PRECISION

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

63 len -= 1

81 write(io, "0.")

82 while pt < 0

83 write(io, '0')

89 write(io, pdigits, len)

90 while pt > len

91 write(io, '0')

135 write(io, '.')

136 while pt < 0

137 write(io, '0')

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

50 if !isfinite(x)

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

85 b = c = 0

86 while true

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

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

20 if (!isfinite(x)) {

21 #else

26

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

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

31

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

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