9338381529

Committed 02 Jun 2024 12:48PM UTC coverage: 81.532% (-0.6%) from 82.112%

Build # 9338381529

Build Type

Pull #1708

github

Committed by

web-flow

Commit Message

Merge 24dd539cf into 24c0aa3d3

Pull Request Pull Request #1708: Make Python operations stricter about types

Run Details

3450 of 4599 branches covered (75.02%)

Branch coverage included in aggregate %.

14 of 96 new or added lines in 1 file covered. (14.58%)

35 existing lines in 1 file now uncovered.

10933 of 13042 relevant lines covered (83.83%)

140656.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

44.2

/src/stdlib/pylib.ts

import { Value } from '../types'

export function is_float(v: Value) {
  return typeof v === 'number'
}

export function is_int(v: Value) {
  return typeof v === 'bigint'
}

function __is_numeric(v: Value) {
  return is_int(v) || is_float(v)
}

function __is_string(v: Value) {
  // Retrieved from https://stackoverflow.com/questions/4059147/check-if-a-variable-is-a-string-in-javascript
  return typeof v === 'string' || v instanceof String
}

export function __py_adder(x: Value, y: Value) {
  if (typeof x === typeof y) {
    return x + y
  }
  if (typeof x === 'bigint') {
    return Number(x) + y
  }
  if (typeof y === 'bigint') {
    return x + Number(y)
  }
  if (__is_numeric(x) && __is_numeric(y)) {
    return x + y
  }
  throw new Error(`Invalid types for addition operation: ${typeof x}, ${typeof y}`)
}

export function __py_minuser(x: Value, y: Value) {
  if (!__is_numeric(x)) {
    throw new Error('Expected number on left hand side of operation, got ' + typeof x + '.')
  }
  if (!__is_numeric(y)) {
    throw new Error('Expected number on right hand side of operation, got ' + typeof y + '.')
  }
  if (typeof x === 'bigint' && typeof y === 'bigint') {
    return x - y
  }
  if (typeof x === 'number' && typeof y === 'number') {
    return x - y
  }
  if (typeof x === 'bigint' && typeof y === 'number') {
    return Number(x) - y
  }
  if (typeof x === 'number' && typeof y === 'bigint') {
    return x - Number(y)
  }
  throw new Error(`Invalid types for subtraction operation: ${typeof x}, ${typeof y}`)
}

export function __py_multiplier(x: Value, y: Value) {
  if (
    !(
      (__is_numeric(x) && __is_numeric(y)) ||
      (__is_string(x) && __is_numeric(y)) ||
      (__is_string(y) && __is_numeric(x))
    )
  ) {
    throw new Error(`Invalid types for multiply operation: ${typeof x}, ${typeof y}`)
  }

  if (typeof x === 'bigint' && typeof y === 'bigint') {
    return x * y
  }
  if (typeof x === 'number' && typeof y === 'number') {
    return x * y
  }
  if (typeof x === 'bigint' && typeof y === 'number') {
    return Number(x) * y
  }
  if (typeof x === 'number' && typeof y === 'bigint') {
    return x * Number(y)
  }
  if (typeof x == 'number' && __is_string(y)) {
    return y.repeat(x)
  }
  if (typeof y == 'number' && __is_string(x)) {
    return x.repeat(y)
  }
  throw new Error(`Invalid types for multiply operation: ${typeof x}, ${typeof y}`)
}

export function __py_divider(x: Value, y: Value) {
  if (!__is_numeric(x)) {
    throw new Error('Expected number on left hand side of operation, got ' + typeof x + '.')
  }
  if (!__is_numeric(y)) {
    throw new Error('Expected number on right hand side of operation, got ' + typeof y + '.')
  }
  if (typeof x === 'bigint' && typeof y === 'bigint') {
    return Number(x) / Number(y)
  }
  if (typeof x === 'number' && typeof y === 'number') {
    return x / y
  }
  if (typeof x === 'bigint' && typeof y === 'number') {
    return Number(x) / y
  }
  if (typeof x === 'number' && typeof y === 'bigint') {
    return x / Number(y)
  }
  throw new Error(`Invalid types for divide operation: ${typeof x}, ${typeof y}`)
}

export function __py_modder(x: Value, y: Value) {
  if (!__is_numeric(x)) {
    throw new Error('Expected number on left hand side of operation, got ' + typeof x + '.')
  }
  if (!__is_numeric(y)) {
    throw new Error('Expected number on right hand side of operation, got ' + typeof y + '.')
  }
  if (typeof x === 'bigint' && typeof y === 'bigint') {
    return x % y
  }
  if (typeof x === 'number' && typeof y === 'number') {
    return x % y
  }
  if (typeof x === 'bigint' && typeof y === 'number') {
    return Number(x) % y
  }
  if (typeof x === 'number' && typeof y === 'bigint') {
    return x % Number(y)
  }
  throw new Error(`Invalid types for modulo operation: ${typeof x}, ${typeof y}`)
}

export function __py_powerer(x: Value, y: Value) {
  if (!__is_numeric(x)) {
    throw new Error('Expected number on left hand side of operation, got ' + typeof x + '.')
  }
  if (!__is_numeric(y)) {
    throw new Error('Expected number on right hand side of operation, got ' + typeof y + '.')
  }
  if (typeof x === 'bigint' && typeof y === 'bigint') {
    let res = BigInt(1)
    for (let i = 0; i < y; i++) {
      res = res * x
    }
    return res
  }
  if (typeof x === 'number' && typeof y === 'number') {
    return Math.pow(x, y)
  }
  if (typeof x === 'bigint' && typeof y === 'number') {
    return Math.pow(Number(x), y)
  }
  if (typeof x === 'number' && typeof y === 'bigint') {
    return Math.pow(x, Number(y))
  }
  throw new Error(`Invalid types for power operation: ${typeof x}, ${typeof y}`)
}

export function __py_floorer(x: Value, y: Value) {
  return BigInt(Math.floor(__py_divider(x, y)))
}

export function __py_unary_plus(x: Value) {
  if (__is_numeric(x)) {
    return +Number(x)
  }
  throw new Error(`Invalid type for unary plus operation: ${typeof x}`)
}

export function math_abs(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.abs(Number(x))
}

export function math_acos(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.acos(Number(x))
}

export function math_acosh(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.acosh(Number(x))
}

export function math_asin(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.asin(Number(x))
}

export function math_asinh(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.asinh(Number(x))
}

export function math_atan(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.atan(Number(x))
}

export function math_atan2(y: Value, x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.atan2(Number(y), Number(x))
}

export function math_atanh(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.atanh(Number(x))
}

export function math_cbrt(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.cbrt(Number(x))
}

export function math_ceil(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.ceil(Number(x))
}

export function math_clz32(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.clz32(Number(x))
}

export function math_cos(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.cos(Number(x))
}

export function math_cosh(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.cosh(Number(x))
}

export function math_exp(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.exp(Number(x))
}

export function math_expm1(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.expm1(Number(x))
}

export function math_floor(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.floor(Number(x))
}

export function math_fround(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.fround(Number(x))
}

export function math_hypot(...elements: Value[]) {
  const coercedElements: number[] = elements.map(el => {
    if (!__is_numeric(el)) {
      throw new Error(`Invalid type for operation: ${typeof el}`)
    }
    return Number(el)
  })
  return Math.hypot(...coercedElements)
}

export function math_imul(x: Value, y: Value) {
  if (!__is_numeric(x) || !__is_numeric(y)) {
    throw new Error(`Invalid types for power operation: ${typeof x}, ${typeof y}`)
  }
  return Math.imul(Number(x), Number(y))
}

export function math_log(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.log(Number(x))
}

export function math_log1p(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.log1p(Number(x))
}

export function math_log2(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.log2(Number(x))
}

export function math_log10(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.log10(Number(x))
}

export function math_max(...elements: Value[]) {
  // TODO: Python max also supports strings!
  const coercedElements: number[] = elements.map(el => {
    if (!__is_numeric(el)) {
      throw new Error(`Invalid type for operation: ${typeof el}`)
    }
    return Number(el)
  })
  return Math.max(...coercedElements)
}

export function math_min(...elements: Value[]) {
  // TODO: Python min also supports strings!
  const coercedElements: number[] = elements.map(el => {
    if (!__is_numeric(el)) {
      throw new Error(`Invalid type for operation: ${typeof el}`)
    }
    return Number(el)
  })
  return Math.min(...coercedElements)
}

export function math_pow(x: Value, y: Value) {
  if (!__is_numeric(x) || !__is_numeric(y)) {
    throw new Error(`Invalid types for power operation: ${typeof x}, ${typeof y}`)
  }
  return Math.pow(Number(x), Number(y))
}

export function math_random() {
  return Math.random()
}

export function math_round(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.round(Number(x))
}

export function math_sign(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.sign(Number(x))
}

export function math_sin(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.sin(Number(x))
}

export function math_sinh(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.sinh(Number(x))
}

export function math_sqrt(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.sqrt(Number(x))
}

export function math_tan(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.tan(Number(x))
}

export function math_tanh(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.tanh(Number(x))
}

export function math_trunc(x: Value) {
  if (!__is_numeric(x)) {
    throw new Error(`Invalid type for operation: ${typeof x}`)
  }
  return Math.trunc(Number(x))
}

1	import { Value } from '../types'
2
3	export function is_float(v: Value) {	74✔
4	return typeof v === 'number'	46✔
5	}
6
7	export function is_int(v: Value) {	74✔
8	return typeof v === 'bigint'	82✔
9	}
10
11	function __is_numeric(v: Value) {
12	return is_int(v) \|\| is_float(v)	82✔
13	}
14
15	function __is_string(v: Value) {
16	// Retrieved from https://stackoverflow.com/questions/4059147/check-if-a-variable-is-a-string-in-javascript
17	return typeof v === 'string' \|\| v instanceof String	4✔
18	}
19
20	export function __py_adder(x: Value, y: Value) {	74✔
21	if (typeof x === typeof y) {	8✔
22	return x + y	4✔
23	}
24	if (typeof x === 'bigint') {	4!
25	return Number(x) + y	×
26	}
27	if (typeof y === 'bigint') {	4✔
28	return x + Number(y)	4✔
29	}
NEW 30	if (__is_numeric(x) && __is_numeric(y)) {	×
NEW 31	return x + y	×
32	}
NEW 33	throw new Error(`Invalid types for addition operation: ${typeof x}, ${typeof y}`)	×
34	}
35
36	export function __py_minuser(x: Value, y: Value) {	74✔
37	if (!__is_numeric(x)) {	6!
38	throw new Error('Expected number on left hand side of operation, got ' + typeof x + '.')	×
39	}
40	if (!__is_numeric(y)) {	6!
41	throw new Error('Expected number on right hand side of operation, got ' + typeof y + '.')	×
42	}
43	if (typeof x === 'bigint' && typeof y === 'bigint') {	6✔
44	return x - y	2✔
45	}
46	if (typeof x === 'number' && typeof y === 'number') {	4✔
47	return x - y	2✔
48	}
49	if (typeof x === 'bigint' && typeof y === 'number') {	2!
50	return Number(x) - y	×
51	}
52	if (typeof x === 'number' && typeof y === 'bigint') {	2✔
53	return x - Number(y)	2✔
54	}
NEW 55	throw new Error(`Invalid types for subtraction operation: ${typeof x}, ${typeof y}`)	×
56	}
57
58	export function __py_multiplier(x: Value, y: Value) {	74✔
59	if (	8✔
60	!(
61	(__is_numeric(x) && __is_numeric(y)) \|\|	18!
62	(__is_string(x) && __is_numeric(y)) \|\|
63	(__is_string(y) && __is_numeric(x))
64	)
65	) {
66	throw new Error(`Invalid types for multiply operation: ${typeof x}, ${typeof y}`)	2✔
67	}
68
69	if (typeof x === 'bigint' && typeof y === 'bigint') {	6✔
70	return x * y	2✔
71	}
72	if (typeof x === 'number' && typeof y === 'number') {	4✔
73	return x * y	2✔
74	}
75	if (typeof x === 'bigint' && typeof y === 'number') {	2!
76	return Number(x) * y	×
77	}
78	if (typeof x === 'number' && typeof y === 'bigint') {	2✔
79	return x * Number(y)	2✔
80	}
NEW 81	if (typeof x == 'number' && __is_string(y)) {	×
NEW 82	return y.repeat(x)	×
83	}
NEW 84	if (typeof y == 'number' && __is_string(x)) {	×
NEW 85	return x.repeat(y)	×
86	}
NEW 87	throw new Error(`Invalid types for multiply operation: ${typeof x}, ${typeof y}`)	×
88	}
89
90	export function __py_divider(x: Value, y: Value) {	74✔
91	if (!__is_numeric(x)) {	16✔
92	throw new Error('Expected number on left hand side of operation, got ' + typeof x + '.')	4✔
93	}
94	if (!__is_numeric(y)) {	12!
95	throw new Error('Expected number on right hand side of operation, got ' + typeof y + '.')	×
96	}
97	if (typeof x === 'bigint' && typeof y === 'bigint') {	12✔
98	return Number(x) / Number(y)	4✔
99	}
100	if (typeof x === 'number' && typeof y === 'number') {	8✔
101	return x / y	4✔
102	}
103	if (typeof x === 'bigint' && typeof y === 'number') {	4✔
104	return Number(x) / y	4✔
105	}
106	if (typeof x === 'number' && typeof y === 'bigint') {	×
107	return x / Number(y)	×
108	}
NEW 109	throw new Error(`Invalid types for divide operation: ${typeof x}, ${typeof y}`)	×
110	}
111
112	export function __py_modder(x: Value, y: Value) {	74✔
113	if (!__is_numeric(x)) {	8✔
114	throw new Error('Expected number on left hand side of operation, got ' + typeof x + '.')	2✔
115	}
116	if (!__is_numeric(y)) {	6!
117	throw new Error('Expected number on right hand side of operation, got ' + typeof y + '.')	×
118	}
119	if (typeof x === 'bigint' && typeof y === 'bigint') {	6✔
120	return x % y	2✔
121	}
122	if (typeof x === 'number' && typeof y === 'number') {	4✔
123	return x % y	2✔
124	}
125	if (typeof x === 'bigint' && typeof y === 'number') {	2✔
126	return Number(x) % y	2✔
127	}
128	if (typeof x === 'number' && typeof y === 'bigint') {	×
129	return x % Number(y)	×
130	}
NEW 131	throw new Error(`Invalid types for modulo operation: ${typeof x}, ${typeof y}`)	×
132	}
133
134	export function __py_powerer(x: Value, y: Value) {	74✔
135	if (!__is_numeric(x)) {	8✔
136	throw new Error('Expected number on left hand side of operation, got ' + typeof x + '.')	2✔
137	}
138	if (!__is_numeric(y)) {	6!
139	throw new Error('Expected number on right hand side of operation, got ' + typeof y + '.')	×
140	}
141	if (typeof x === 'bigint' && typeof y === 'bigint') {	6✔
142	let res = BigInt(1)	2✔
143	for (let i = 0; i < y; i++) {	2✔
144	res = res * x	2✔
145	}
146	return res	2✔
147	}
148	if (typeof x === 'number' && typeof y === 'number') {	4✔
149	return Math.pow(x, y)	2✔
150	}
151	if (typeof x === 'bigint' && typeof y === 'number') {	2✔
152	return Math.pow(Number(x), y)	2✔
153	}
UNCOV 154	if (typeof x === 'number' && typeof y === 'bigint') {	×
155	return Math.pow(x, Number(y))	×
156	}
NEW 157	throw new Error(`Invalid types for power operation: ${typeof x}, ${typeof y}`)	×
158	}
159
160	export function __py_floorer(x: Value, y: Value) {	74✔
161	return BigInt(Math.floor(__py_divider(x, y)))	8✔
162	}
163
164	export function __py_unary_plus(x: Value) {	74✔
NEW 165	if (__is_numeric(x)) {	×
166	return +Number(x)	×
167	}
NEW 168	throw new Error(`Invalid type for unary plus operation: ${typeof x}`)	×
169	}
170
171	export function math_abs(x: Value) {	74✔
NEW 172	if (!__is_numeric(x)) {	×
NEW 173	throw new Error(`Invalid type for operation: ${typeof x}`)	×
174	}
UNCOV 175	return Math.abs(Number(x))	×
176	}
177
178	export function math_acos(x: Value) {	74✔
NEW 179	if (!__is_numeric(x)) {	×
NEW 180	throw new Error(`Invalid type for operation: ${typeof x}`)	×
181	}
UNCOV 182	return Math.acos(Number(x))	×
183	}
184
185	export function math_acosh(x: Value) {	74✔
NEW 186	if (!__is_numeric(x)) {	×
NEW 187	throw new Error(`Invalid type for operation: ${typeof x}`)	×
188	}
UNCOV 189	return Math.acosh(Number(x))	×
190	}
191
192	export function math_asin(x: Value) {	74✔
NEW 193	if (!__is_numeric(x)) {	×
NEW 194	throw new Error(`Invalid type for operation: ${typeof x}`)	×
195	}
UNCOV 196	return Math.asin(Number(x))	×
197	}
198
199	export function math_asinh(x: Value) {	74✔
NEW 200	if (!__is_numeric(x)) {	×
NEW 201	throw new Error(`Invalid type for operation: ${typeof x}`)	×
202	}
UNCOV 203	return Math.asinh(Number(x))	×
204	}
205
206	export function math_atan(x: Value) {	74✔
NEW 207	if (!__is_numeric(x)) {	×
NEW 208	throw new Error(`Invalid type for operation: ${typeof x}`)	×
209	}
UNCOV 210	return Math.atan(Number(x))	×
211	}
212
213	export function math_atan2(y: Value, x: Value) {	74✔
NEW 214	if (!__is_numeric(x)) {	×
NEW 215	throw new Error(`Invalid type for operation: ${typeof x}`)	×
216	}
UNCOV 217	return Math.atan2(Number(y), Number(x))	×
218	}
219
220	export function math_atanh(x: Value) {	74✔
NEW 221	if (!__is_numeric(x)) {	×
NEW 222	throw new Error(`Invalid type for operation: ${typeof x}`)	×
223	}
UNCOV 224	return Math.atanh(Number(x))	×
225	}
226
227	export function math_cbrt(x: Value) {	74✔
NEW 228	if (!__is_numeric(x)) {	×
NEW 229	throw new Error(`Invalid type for operation: ${typeof x}`)	×
230	}
UNCOV 231	return Math.cbrt(Number(x))	×
232	}
233
234	export function math_ceil(x: Value) {	74✔
NEW 235	if (!__is_numeric(x)) {	×
NEW 236	throw new Error(`Invalid type for operation: ${typeof x}`)	×
237	}
UNCOV 238	return Math.ceil(Number(x))	×
239	}
240
241	export function math_clz32(x: Value) {	74✔
NEW 242	if (!__is_numeric(x)) {	×
NEW 243	throw new Error(`Invalid type for operation: ${typeof x}`)	×
244	}
UNCOV 245	return Math.clz32(Number(x))	×
246	}
247
248	export function math_cos(x: Value) {	74✔
NEW 249	if (!__is_numeric(x)) {	×
NEW 250	throw new Error(`Invalid type for operation: ${typeof x}`)	×
251	}
UNCOV 252	return Math.cos(Number(x))	×
253	}
254
255	export function math_cosh(x: Value) {	74✔
NEW 256	if (!__is_numeric(x)) {	×
NEW 257	throw new Error(`Invalid type for operation: ${typeof x}`)	×
258	}
UNCOV 259	return Math.cosh(Number(x))	×
260	}
261
262	export function math_exp(x: Value) {	74✔
NEW 263	if (!__is_numeric(x)) {	×
NEW 264	throw new Error(`Invalid type for operation: ${typeof x}`)	×
265	}
UNCOV 266	return Math.exp(Number(x))	×
267	}
268
269	export function math_expm1(x: Value) {	74✔
NEW 270	if (!__is_numeric(x)) {	×
NEW 271	throw new Error(`Invalid type for operation: ${typeof x}`)	×
272	}
UNCOV 273	return Math.expm1(Number(x))	×
274	}
275
276	export function math_floor(x: Value) {	74✔
NEW 277	if (!__is_numeric(x)) {	×
NEW 278	throw new Error(`Invalid type for operation: ${typeof x}`)	×
279	}
UNCOV 280	return Math.floor(Number(x))	×
281	}
282
283	export function math_fround(x: Value) {	74✔
NEW 284	if (!__is_numeric(x)) {	×
NEW 285	throw new Error(`Invalid type for operation: ${typeof x}`)	×
286	}
UNCOV 287	return Math.fround(Number(x))	×
288	}
289
290	export function math_hypot(...elements: Value[]) {	74✔
291	const coercedElements: number[] = elements.map(el => {	×
NEW 292	if (!__is_numeric(el)) {	×
NEW 293	throw new Error(`Invalid type for operation: ${typeof el}`)	×
294	}
UNCOV 295	return Number(el)	×
296	})
297	return Math.hypot(...coercedElements)	×
298	}
299
300	export function math_imul(x: Value, y: Value) {	74✔
NEW 301	if (!__is_numeric(x) \|\| !__is_numeric(y)) {	×
NEW 302	throw new Error(`Invalid types for power operation: ${typeof x}, ${typeof y}`)	×
303	}
UNCOV 304	return Math.imul(Number(x), Number(y))	×
305	}
306
307	export function math_log(x: Value) {	74✔
NEW 308	if (!__is_numeric(x)) {	×
NEW 309	throw new Error(`Invalid type for operation: ${typeof x}`)	×
310	}
UNCOV 311	return Math.log(Number(x))	×
312	}
313
314	export function math_log1p(x: Value) {	74✔
NEW 315	if (!__is_numeric(x)) {	×
NEW 316	throw new Error(`Invalid type for operation: ${typeof x}`)	×
317	}
UNCOV 318	return Math.log1p(Number(x))	×
319	}
320
321	export function math_log2(x: Value) {	74✔
NEW 322	if (!__is_numeric(x)) {	×
NEW 323	throw new Error(`Invalid type for operation: ${typeof x}`)	×
324	}
UNCOV 325	return Math.log2(Number(x))	×
326	}
327
328	export function math_log10(x: Value) {	74✔
NEW 329	if (!__is_numeric(x)) {	×
NEW 330	throw new Error(`Invalid type for operation: ${typeof x}`)	×
331	}
UNCOV 332	return Math.log10(Number(x))	×
333	}
334
335	export function math_max(...elements: Value[]) {	74✔
336	// TODO: Python max also supports strings!
337	const coercedElements: number[] = elements.map(el => {	×
NEW 338	if (!__is_numeric(el)) {	×
NEW 339	throw new Error(`Invalid type for operation: ${typeof el}`)	×
340	}
UNCOV 341	return Number(el)	×
342	})
343	return Math.max(...coercedElements)	×
344	}
345
346	export function math_min(...elements: Value[]) {	74✔
347	// TODO: Python min also supports strings!
348	const coercedElements: number[] = elements.map(el => {	×
NEW 349	if (!__is_numeric(el)) {	×
NEW 350	throw new Error(`Invalid type for operation: ${typeof el}`)	×
351	}
UNCOV 352	return Number(el)	×
353	})
354	return Math.min(...coercedElements)	×
355	}
356
357	export function math_pow(x: Value, y: Value) {	74✔
NEW 358	if (!__is_numeric(x) \|\| !__is_numeric(y)) {	×
NEW 359	throw new Error(`Invalid types for power operation: ${typeof x}, ${typeof y}`)	×
360	}
UNCOV 361	return Math.pow(Number(x), Number(y))	×
362	}
363
364	export function math_random() {	74✔
365	return Math.random()	×
366	}
367
368	export function math_round(x: Value) {	74✔
NEW 369	if (!__is_numeric(x)) {	×
NEW 370	throw new Error(`Invalid type for operation: ${typeof x}`)	×
371	}
UNCOV 372	return Math.round(Number(x))	×
373	}
374
375	export function math_sign(x: Value) {	74✔
NEW 376	if (!__is_numeric(x)) {	×
NEW 377	throw new Error(`Invalid type for operation: ${typeof x}`)	×
378	}
UNCOV 379	return Math.sign(Number(x))	×
380	}
381
382	export function math_sin(x: Value) {	74✔
NEW 383	if (!__is_numeric(x)) {	×
NEW 384	throw new Error(`Invalid type for operation: ${typeof x}`)	×
385	}
UNCOV 386	return Math.sin(Number(x))	×
387	}
388
389	export function math_sinh(x: Value) {	74✔
NEW 390	if (!__is_numeric(x)) {	×
NEW 391	throw new Error(`Invalid type for operation: ${typeof x}`)	×
392	}
UNCOV 393	return Math.sinh(Number(x))	×
394	}
395
396	export function math_sqrt(x: Value) {	74✔
NEW 397	if (!__is_numeric(x)) {	×
NEW 398	throw new Error(`Invalid type for operation: ${typeof x}`)	×
399	}
UNCOV 400	return Math.sqrt(Number(x))	×
401	}
402
403	export function math_tan(x: Value) {	74✔
NEW 404	if (!__is_numeric(x)) {	×
NEW 405	throw new Error(`Invalid type for operation: ${typeof x}`)	×
406	}
UNCOV 407	return Math.tan(Number(x))	×
408	}
409
410	export function math_tanh(x: Value) {	74✔
NEW 411	if (!__is_numeric(x)) {	×
NEW 412	throw new Error(`Invalid type for operation: ${typeof x}`)	×
413	}
UNCOV 414	return Math.tanh(Number(x))	×
415	}
416
417	export function math_trunc(x: Value) {	74✔
NEW 418	if (!__is_numeric(x)) {	×
NEW 419	throw new Error(`Invalid type for operation: ${typeof x}`)	×
420	}
UNCOV 421	return Math.trunc(Number(x))	×
422	}

source-academy / js-slang / 9338381529

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous