math-exercises 2.2.63 → 2.2.65

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (26) hide show
  1. package/lib/exercises/math/derivation/tangent/derivativeTangentEquationReading.d.ts.map +1 -1
  2. package/lib/exercises/math/derivation/tangent/derivativeTangentEquationReading.js +6 -1
  3. package/lib/exercises/math/functions/basics/graphicInequationAffine.js +1 -1
  4. package/lib/exercises/math/functions/square/squareImageInterval.js +1 -1
  5. package/lib/exercises/math/functions/trinoms/coefficientsIdentification.js +1 -1
  6. package/lib/exercises/math/functions/trinoms/findSecondRoot.js +1 -1
  7. package/lib/exercises/math/geometry/perimeters/circleRadiusFromPerimeter.js +1 -1
  8. package/lib/exercises/math/probaStat/conditionalProbability.d.ts.map +1 -1
  9. package/lib/exercises/math/probaStat/conditionalProbability.js +2 -1
  10. package/lib/exercises/math/probaStat/stats1var/averageList.d.ts.map +1 -1
  11. package/lib/exercises/math/probaStat/stats1var/averageList.js +2 -1
  12. package/lib/index.d.ts +539 -538
  13. package/lib/index.d.ts.map +1 -1
  14. package/lib/playground.d.ts.map +1 -1
  15. package/lib/playground.js +10 -4
  16. package/lib/tree/nodes/node.d.ts +2 -0
  17. package/lib/tree/nodes/node.d.ts.map +1 -1
  18. package/lib/tree/nodes/operators/fractionNode.d.ts.map +1 -1
  19. package/lib/tree/nodes/operators/fractionNode.js +5 -0
  20. package/lib/tree/nodes/sets/intervalNode.d.ts +1 -0
  21. package/lib/tree/nodes/sets/intervalNode.d.ts.map +1 -1
  22. package/lib/tree/nodes/sets/intervalNode.js +20 -6
  23. package/lib/tree/parsers/latexParser.js +1 -0
  24. package/lib/tree/parsers/rationalParser.d.ts.map +1 -1
  25. package/lib/tree/parsers/rationalParser.js +4 -0
  26. package/package.json +1 -1
package/lib/index.d.ts CHANGED
@@ -1,139 +1,140 @@
1
+ import { Exercise, Question } from "./exercises/exercise";
1
2
  import "./prototypesEnhancement";
2
- declare const mathExercises: (import("./exercises/exercise").Exercise<{
3
+ declare const mathExercises: (Exercise<{
3
4
  numbers: number[];
4
- }, {}> | import("./exercises/exercise").Exercise<{
5
+ }, {}> | Exercise<{
5
6
  numbers: number[];
6
- }, {}> | import("./exercises/exercise").Exercise<{
7
+ }, {}> | Exercise<{
7
8
  dividend: number;
8
9
  divisor: number;
9
10
  quotient: number;
10
11
  remainder: number;
11
- }, {}> | import("./exercises/exercise").Exercise<{
12
+ }, {}> | Exercise<{
12
13
  type: number;
13
- }, {}> | import("./exercises/exercise").Exercise<{
14
+ }, {}> | Exercise<{
14
15
  chosenNumbers: number[];
15
- }, {}> | import("./exercises/exercise").Exercise<{
16
+ }, {}> | Exercise<{
16
17
  a: number;
17
18
  b: number;
18
- }, {}> | import("./exercises/exercise").Exercise<{
19
+ }, {}> | Exercise<{
19
20
  a: number;
20
- }, {}> | import("./exercises/exercise").Exercise<{
21
+ }, {}> | Exercise<{
21
22
  a: number;
22
23
  b: number;
23
- }, {}> | import("./exercises/exercise").Exercise<{
24
+ }, {}> | Exercise<{
24
25
  nb: number;
25
26
  divisor: number;
26
- }, {}> | import("./exercises/exercise").Exercise<{
27
+ }, {}> | Exercise<{
27
28
  integerFirst: boolean;
28
29
  integer: number;
29
30
  rational: number[];
30
- }, {}> | import("./exercises/exercise").Exercise<{
31
+ }, {}> | Exercise<{
31
32
  integer: number;
32
33
  rational: number[];
33
34
  integerFirst: boolean;
34
35
  }, {
35
36
  allowNonIrreductible?: boolean | undefined;
36
- }> | import("./exercises/exercise").Exercise<{
37
+ }> | Exercise<{
37
38
  integer: number;
38
39
  rational: [number, number];
39
40
  }, {
40
41
  allowNonIrreductible?: boolean | undefined;
41
- }> | import("./exercises/exercise").Exercise<{
42
+ }> | Exercise<{
42
43
  rand: number;
43
44
  numerator: number;
44
45
  denominator: number;
45
- }, {}> | import("./exercises/exercise").Exercise<{
46
+ }, {}> | Exercise<{
46
47
  rationalNum: [number, number];
47
48
  rationalDenum: [number, number];
48
- }, {}> | import("./exercises/exercise").Exercise<{
49
+ }, {}> | Exercise<{
49
50
  rationalNum: [number, number];
50
51
  rationalDenum: [number, number];
51
52
  }, {
52
53
  allowNonIrreductible?: boolean | undefined;
53
- }> | import("./exercises/exercise").Exercise<{
54
+ }> | Exercise<{
54
55
  rational: number[];
55
56
  rational2: number[];
56
57
  }, {
57
58
  allowNonIrreductible?: boolean | undefined;
58
- }> | import("./exercises/exercise").Exercise<{
59
+ }> | Exercise<{
59
60
  num: number;
60
61
  denum: number;
61
- }, {}> | import("./exercises/exercise").Exercise<{
62
+ }, {}> | Exercise<{
62
63
  num: number;
63
64
  denum: number;
64
65
  leadingPart: number;
65
- }, {}> | import("./exercises/exercise").Exercise<{
66
+ }, {}> | Exercise<{
66
67
  denom: number;
67
68
  num1: number;
68
69
  num2: number;
69
- }, {}> | import("./exercises/exercise").Exercise<{
70
+ }, {}> | Exercise<{
70
71
  num1: number;
71
72
  num2: number;
72
73
  denom1: number;
73
74
  denom2: number;
74
- }, {}> | import("./exercises/exercise").Exercise<{
75
+ }, {}> | Exercise<{
75
76
  num1: number;
76
77
  num2: number;
77
78
  denom1: number;
78
79
  denom2: number;
79
- }, {}> | import("./exercises/exercise").Exercise<{
80
+ }, {}> | Exercise<{
80
81
  numbers: number[];
81
- }, {}> | import("./exercises/exercise").Exercise<{
82
+ }, {}> | Exercise<{
82
83
  rand: number;
83
84
  a: number;
84
85
  b: number;
85
86
  c: number;
86
- }, {}> | import("./exercises/exercise").Exercise<{
87
+ }, {}> | Exercise<{
87
88
  numbers: number[];
88
- }, {}> | import("./exercises/exercise").Exercise<{
89
+ }, {}> | Exercise<{
89
90
  rand: number;
90
91
  a: number;
91
92
  b: number;
92
- }, {}> | import("./exercises/exercise").Exercise<{
93
+ }, {}> | Exercise<{
93
94
  numbers: number[];
94
- }, {}> | import("./exercises/exercise").Exercise<{
95
+ }, {}> | Exercise<{
95
96
  numbers: number[];
96
- }, {}> | import("./exercises/exercise").Exercise<{
97
+ }, {}> | Exercise<{
97
98
  type: number;
98
99
  a: number;
99
100
  b: number;
100
101
  c: number;
101
102
  d: number | undefined;
102
- }, {}> | import("./exercises/exercise").Exercise<{
103
+ }, {}> | Exercise<{
103
104
  type: number;
104
105
  flip: number;
105
106
  a: number;
106
107
  b: number;
107
108
  c: number;
108
109
  d: number;
109
- }, {}> | import("./exercises/exercise").Exercise<{
110
+ }, {}> | Exercise<{
110
111
  nodeIds: any;
111
112
  type: number;
112
113
  subType: number;
113
- }, {}> | import("./exercises/exercise").Exercise<{
114
+ }, {}> | Exercise<{
114
115
  nodeIds: any;
115
116
  type: number;
116
- }, {}> | import("./exercises/exercise").Exercise<{
117
+ }, {}> | Exercise<{
117
118
  nodeIds: any;
118
119
  type: number;
119
- }, {}> | import("./exercises/exercise").Exercise<{
120
+ }, {}> | Exercise<{
120
121
  randQuation: number;
121
122
  x1: string | number;
122
123
  x2: string | number;
123
124
  x3: string | number;
124
125
  x4: string | number;
125
- }, {}> | import("./exercises/exercise").Exercise<{
126
+ }, {}> | Exercise<{
126
127
  xValues: number[];
127
128
  yValues: number[];
128
- }, {}> | import("./exercises/exercise").Exercise<{
129
+ }, {}> | Exercise<{
129
130
  scale: number;
130
131
  isSmallScale: boolean;
131
132
  fakeDistance: number;
132
- }, {}> | import("./exercises/exercise").Exercise<{
133
+ }, {}> | Exercise<{
133
134
  scale: number;
134
135
  isSmallScale: boolean;
135
136
  fakeDistance: number;
136
- }, {}> | import("./exercises/exercise").Exercise<{
137
+ }, {}> | Exercise<{
137
138
  coeffIds: any;
138
139
  xValues: any[];
139
140
  yValues: any[];
@@ -143,7 +144,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
143
144
  }, {
144
145
  coeffNumberTypes: string[];
145
146
  valuesNumberTypes: string[];
146
- }> | import("./exercises/exercise").Exercise<{
147
+ }> | Exercise<{
147
148
  coeffIds: any;
148
149
  xValues: any[];
149
150
  yValues: any[];
@@ -152,126 +153,126 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
152
153
  }, {
153
154
  coeffNumberTypes: string[];
154
155
  valuesNumberTypes: string[];
155
- }> | import("./exercises/exercise").Exercise<{
156
+ }> | Exercise<{
156
157
  xValues: number[];
157
158
  yValues: number[];
158
- }, {}> | import("./exercises/exercise").Exercise<{
159
+ }, {}> | Exercise<{
159
160
  precisionAsked: number;
160
161
  decimal: number;
161
162
  precision: number;
162
- }, {}> | import("./exercises/exercise").Exercise<{
163
+ }, {}> | Exercise<{
163
164
  nb: number;
164
165
  rankAsked: number;
165
- }, {}> | import("./exercises/exercise").Exercise<{
166
+ }, {}> | Exercise<{
166
167
  nb: string;
167
168
  rankAsked: number;
168
- }, {}> | import("./exercises/exercise").Exercise<{
169
+ }, {}> | Exercise<{
169
170
  nb: number;
170
171
  rankAsked: number;
171
- }, {}> | import("./exercises/exercise").Exercise<{
172
+ }, {}> | Exercise<{
172
173
  nb: number;
173
174
  rankAsked: number;
174
- }, {}> | import("./exercises/exercise").Exercise<{
175
+ }, {}> | Exercise<{
175
176
  a: number;
176
177
  b: number;
177
- }, {}> | import("./exercises/exercise").Exercise<{
178
+ }, {}> | Exercise<{
178
179
  type: number;
179
180
  a: number;
180
181
  b: number;
181
- }, {}> | import("./exercises/exercise").Exercise<{
182
+ }, {}> | Exercise<{
182
183
  type: number;
183
184
  nbIds: any;
184
185
  nbValue: number;
185
186
  pow: number;
186
- }, {}> | import("./exercises/exercise").Exercise<{
187
+ }, {}> | Exercise<{
187
188
  type: number;
188
189
  a: number;
189
190
  b: number;
190
- }, {}> | import("./exercises/exercise").Exercise<{
191
+ }, {}> | Exercise<{
191
192
  dec: number;
192
193
  pow: number;
193
194
  isDivide: boolean;
194
- }, {}> | import("./exercises/exercise").Exercise<{
195
+ }, {}> | Exercise<{
195
196
  dec: number;
196
197
  pow: number;
197
- }, {}> | import("./exercises/exercise").Exercise<{
198
+ }, {}> | Exercise<{
198
199
  a: number;
199
200
  b: number;
200
- }, {}> | import("./exercises/exercise").Exercise<{
201
+ }, {}> | Exercise<{
201
202
  a: number;
202
203
  b: number;
203
- }, {}> | import("./exercises/exercise").Exercise<{
204
+ }, {}> | Exercise<{
204
205
  affine1Coeffs: number[];
205
206
  affine2Coeffs: number[];
206
- }, {}> | import("./exercises/exercise").Exercise<{
207
+ }, {}> | Exercise<{
207
208
  type: number;
208
209
  a?: number | undefined;
209
210
  b?: number | undefined;
210
211
  affine1Coeffs?: number[] | undefined;
211
212
  affine2Coeffs?: number[] | undefined;
212
- }, {}> | import("./exercises/exercise").Exercise<{
213
+ }, {}> | Exercise<{
213
214
  affine1Coeffs: number[];
214
215
  affine2Coeffs: number[];
215
- }, {}> | import("./exercises/exercise").Exercise<{
216
+ }, {}> | Exercise<{
216
217
  a: number;
217
218
  b: number;
218
219
  coeff: number;
219
- }, {}> | import("./exercises/exercise").Exercise<{
220
+ }, {}> | Exercise<{
220
221
  coeff: number;
221
222
  affine1: number[];
222
223
  affine2: number[];
223
- }, {}> | import("./exercises/exercise").Exercise<{
224
+ }, {}> | Exercise<{
224
225
  coeffs: number[];
225
- }, {}> | import("./exercises/exercise").Exercise<{
226
+ }, {}> | Exercise<{
226
227
  a: number;
227
228
  b: number;
228
229
  c: number;
229
- }, {}> | import("./exercises/exercise").Exercise<{
230
+ }, {}> | Exercise<{
230
231
  randNbr: number;
231
- }, {}> | import("./exercises/exercise").Exercise<{
232
+ }, {}> | Exercise<{
232
233
  a: number;
233
234
  b: number;
234
- }, {}> | import("./exercises/exercise").Exercise<{
235
+ }, {}> | Exercise<{
235
236
  a: number;
236
237
  b: number;
237
- }, {}> | import("./exercises/exercise").Exercise<{
238
+ }, {}> | Exercise<{
238
239
  a: number;
239
240
  b: number;
240
241
  c: number;
241
- }, {}> | import("./exercises/exercise").Exercise<{
242
+ }, {}> | Exercise<{
242
243
  a: number;
243
244
  b: number;
244
245
  c: number;
245
246
  d: number;
246
- }, {}> | import("./exercises/exercise").Exercise<{
247
+ }, {}> | Exercise<{
247
248
  a: number;
248
249
  b: number;
249
250
  c: number;
250
251
  d: number;
251
- }, {}> | import("./exercises/exercise").Exercise<{
252
+ }, {}> | Exercise<{
252
253
  a: number;
253
254
  b: number;
254
255
  c: number;
255
256
  d: number;
256
- }, {}> | import("./exercises/exercise").Exercise<{
257
+ }, {}> | Exercise<{
257
258
  a: number;
258
259
  b: number;
259
- }, {}> | import("./exercises/exercise").Exercise<{
260
+ }, {}> | Exercise<{
260
261
  a: number;
261
262
  b: number;
262
263
  x: number;
263
- }, {}> | import("./exercises/exercise").Exercise<{
264
+ }, {}> | Exercise<{
264
265
  a: number;
265
266
  x: number;
266
267
  b: number;
267
268
  c: number;
268
- }, {}> | import("./exercises/exercise").Exercise<{
269
+ }, {}> | Exercise<{
269
270
  a: number;
270
271
  x: number;
271
272
  b: number;
272
273
  c: number;
273
274
  d: number;
274
- }, {}> | import("./exercises/exercise").Exercise<{
275
+ }, {}> | Exercise<{
275
276
  type: number;
276
277
  vars: {
277
278
  flip: boolean;
@@ -279,10 +280,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
279
280
  randAdd?: number | undefined;
280
281
  op2?: string | undefined;
281
282
  };
282
- }, {}> | import("./exercises/exercise").Exercise<{
283
+ }, {}> | Exercise<{
283
284
  solutionNodeIds: any;
284
285
  equationNodeIds: any;
285
- }, {}> | import("./exercises/exercise").Exercise<{
286
+ }, {}> | Exercise<{
286
287
  type: number;
287
288
  a: number;
288
289
  b: number;
@@ -292,63 +293,63 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
292
293
  f: number;
293
294
  }, {
294
295
  integerSolutions: boolean;
295
- }> | import("./exercises/exercise").Exercise<{
296
+ }> | Exercise<{
296
297
  a: number;
297
298
  b: number;
298
- }, {}> | import("./exercises/exercise").Exercise<{
299
+ }, {}> | Exercise<{
299
300
  a: number;
300
301
  b: number;
301
- }, {}> | import("./exercises/exercise").Exercise<{
302
+ }, {}> | Exercise<{
302
303
  affine1Coeffs: number[];
303
304
  affine2Coeffs: number[];
304
- }, {}> | import("./exercises/exercise").Exercise<{
305
+ }, {}> | Exercise<{
305
306
  affinesCoeffs: number[][];
306
307
  operation: string;
307
- }, {}> | import("./exercises/exercise").Exercise<{
308
+ }, {}> | Exercise<{
308
309
  a: number;
309
310
  b: number;
310
- }, {}> | import("./exercises/exercise").Exercise<{
311
+ }, {}> | Exercise<{
311
312
  a: number;
312
313
  bOperand: number;
313
- }, {}> | import("./exercises/exercise").Exercise<{
314
+ }, {}> | Exercise<{
314
315
  a: number;
315
316
  b: number;
316
317
  c: number;
317
318
  d: number;
318
319
  isSubstract: boolean;
319
- }, {}> | import("./exercises/exercise").Exercise<{
320
+ }, {}> | Exercise<{
320
321
  b: number;
321
322
  c: number;
322
323
  ineqType: import("./math/inequations/inequation").InegalitySymbols;
323
- }, {}> | import("./exercises/exercise").Exercise<{
324
+ }, {}> | Exercise<{
324
325
  a: number;
325
326
  b: number;
326
327
  ineqType: import("./math/inequations/inequation").InegalitySymbols;
327
- }, {}> | import("./exercises/exercise").Exercise<{
328
+ }, {}> | Exercise<{
328
329
  ineqType: import("./math/inequations/inequation").InegalitySymbols;
329
330
  a: number;
330
331
  b: number;
331
332
  c: number;
332
- }, {}> | import("./exercises/exercise").Exercise<{
333
+ }, {}> | Exercise<{
333
334
  coeff: number;
334
335
  ineqType: import("./math/inequations/inequation").InegalitySymbols;
335
336
  a: number;
336
337
  b: number;
337
338
  c: number;
338
339
  d: number;
339
- }, {}> | import("./exercises/exercise").Exercise<{
340
+ }, {}> | Exercise<{
340
341
  k: number;
341
342
  inequationSymbol: import("./math/inequations/inequation").InegalitySymbols;
342
- }, {}> | import("./exercises/exercise").Exercise<{
343
+ }, {}> | Exercise<{
343
344
  rand: boolean;
344
345
  poly1: number[];
345
346
  poly2: number[];
346
347
  xValue: number;
347
- }, {}> | import("./exercises/exercise").Exercise<{
348
+ }, {}> | Exercise<{
348
349
  rand: number;
349
350
  polynome1Coeffs: number[];
350
351
  polynome2Coeffs: number[];
351
- }, {}> | import("./exercises/exercise").Exercise<{
352
+ }, {}> | Exercise<{
352
353
  firstTermIsAffine: boolean;
353
354
  a: number;
354
355
  b: number;
@@ -357,263 +358,263 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
357
358
  e: number;
358
359
  f: number;
359
360
  g: number;
360
- }, {}> | import("./exercises/exercise").Exercise<{
361
+ }, {}> | Exercise<{
361
362
  coeffs: number[][];
362
363
  isXAsked: boolean;
363
- }, {}> | import("./exercises/exercise").Exercise<{
364
+ }, {}> | Exercise<{
364
365
  coeffs: number[][];
365
366
  isXAsked: boolean;
366
- }, {}> | import("./exercises/exercise").Exercise<{
367
+ }, {}> | Exercise<{
367
368
  sysCoeffs: number[][];
368
369
  x: number;
369
370
  y: number;
370
- }, {}> | import("./exercises/exercise").Exercise<{
371
+ }, {}> | Exercise<{
371
372
  word: string;
372
- }, {}> | import("./exercises/exercise").Exercise<{
373
+ }, {}> | Exercise<{
373
374
  type: number;
374
375
  reds: number;
375
376
  greens: number;
376
377
  blacks: number;
377
- }, {}> | import("./exercises/exercise").Exercise<{
378
+ }, {}> | Exercise<{
378
379
  type: number;
379
380
  face1?: number | undefined;
380
381
  face2?: number | undefined;
381
382
  face3?: number | undefined;
382
- }, {}> | import("./exercises/exercise").Exercise<{
383
+ }, {}> | Exercise<{
383
384
  z1Re: number;
384
385
  z1Im: number;
385
386
  z2Re: number;
386
387
  z2Im: number;
387
- }, {}> | import("./exercises/exercise").Exercise<{
388
+ }, {}> | Exercise<{
388
389
  re: number;
389
390
  im: number;
390
- }, {}> | import("./exercises/exercise").Exercise<{
391
+ }, {}> | Exercise<{
391
392
  z1: number[];
392
393
  z2: number[];
393
- }, {}> | import("./exercises/exercise").Exercise<{
394
+ }, {}> | Exercise<{
394
395
  z1: number[];
395
396
  z2: number[];
396
- }, {}> | import("./exercises/exercise").Exercise<{
397
+ }, {}> | Exercise<{
397
398
  z1: number[];
398
399
  z2: number[];
399
- }, {}> | import("./exercises/exercise").Exercise<{
400
+ }, {}> | Exercise<{
400
401
  re: number;
401
402
  im: number;
402
- }, {}> | import("./exercises/exercise").Exercise<{
403
+ }, {}> | Exercise<{
403
404
  a: number;
404
405
  b: number;
405
406
  z1: number[];
406
407
  z2: number[];
407
- }, {}> | import("./exercises/exercise").Exercise<{
408
+ }, {}> | Exercise<{
408
409
  re: number;
409
410
  im: number;
410
- }, {}> | import("./exercises/exercise").Exercise<{
411
+ }, {}> | Exercise<{
411
412
  z1: number[];
412
413
  z2: number[];
413
- }, {}> | import("./exercises/exercise").Exercise<{
414
+ }, {}> | Exercise<{
414
415
  re: number;
415
416
  im: number;
416
417
  isRe: boolean;
417
- }, {}> | import("./exercises/exercise").Exercise<{
418
+ }, {}> | Exercise<{
418
419
  arg: number;
419
420
  zTex: string;
420
- }, {}> | import("./exercises/exercise").Exercise<{
421
+ }, {}> | Exercise<{
421
422
  randomUnitIndex: number;
422
423
  randomUnitInstructionIndex: number;
423
424
  randomAera: number;
424
- }, {}> | import("./exercises/exercise").Exercise<{
425
+ }, {}> | Exercise<{
425
426
  randomUnitIndex: number;
426
427
  randomUnitInstructionIndex: number;
427
428
  randomCapacity: number;
428
- }, {}> | import("./exercises/exercise").Exercise<{
429
+ }, {}> | Exercise<{
429
430
  randomUnitIndex: number;
430
431
  randomUnitInstructionIndex: number;
431
432
  randomLength: number;
432
433
  }, {
433
434
  units: string[];
434
- }> | import("./exercises/exercise").Exercise<{
435
+ }> | Exercise<{
435
436
  randomUnitIndex: number;
436
437
  randomUnitInstructionIndex: number;
437
438
  randomMass: number;
438
- }, {}> | import("./exercises/exercise").Exercise<{
439
+ }, {}> | Exercise<{
439
440
  randomUnitIndex: number;
440
441
  randomUnitInstructionIndex: number;
441
442
  randomValue: number;
442
443
  isVolumeToCapacity: boolean;
443
- }, {}> | import("./exercises/exercise").Exercise<{
444
+ }, {}> | Exercise<{
444
445
  randomUnitIndex: number;
445
446
  randomUnitInstructionIndex: number;
446
447
  randomVolume: number;
447
- }, {}> | import("./exercises/exercise").Exercise<{
448
+ }, {}> | Exercise<{
448
449
  dec: number;
449
450
  isDecimalToHours: boolean;
450
- }, {}> | import("./exercises/exercise").Exercise<{
451
+ }, {}> | Exercise<{
451
452
  tex: string;
452
- }, {}> | import("./exercises/exercise").Exercise<{
453
+ }, {}> | Exercise<{
453
454
  a: number;
454
455
  b: number;
455
- }, {}> | import("./exercises/exercise").Exercise<{
456
+ }, {}> | Exercise<{
456
457
  a: number;
457
458
  b: number;
458
- }, {}> | import("./exercises/exercise").Exercise<{
459
+ }, {}> | Exercise<{
459
460
  a: number;
460
461
  b: number;
461
- }, {}> | import("./exercises/exercise").Exercise<{
462
+ }, {}> | Exercise<{
462
463
  affine1Coeffs: number[];
463
464
  affine2Coeffs: number[];
464
- }, {}> | import("./exercises/exercise").Exercise<{
465
+ }, {}> | Exercise<{
465
466
  a: number;
466
467
  b: number;
467
- }, {}> | import("./exercises/exercise").Exercise<{
468
+ }, {}> | Exercise<{
468
469
  a: number;
469
- }, {}> | import("./exercises/exercise").Exercise<{
470
+ }, {}> | Exercise<{
470
471
  a: number;
471
472
  b: number;
472
- }, {}> | import("./exercises/exercise").Exercise<{
473
+ }, {}> | Exercise<{
473
474
  a: number;
474
475
  b: number;
475
- }, {}> | import("./exercises/exercise").Exercise<{
476
+ }, {}> | Exercise<{
476
477
  a: number;
477
478
  b: number;
478
- }, {}> | import("./exercises/exercise").Exercise<{
479
+ }, {}> | Exercise<{
479
480
  a: number;
480
481
  power: number;
481
- }, {}> | import("./exercises/exercise").Exercise<{
482
+ }, {}> | Exercise<{
482
483
  poly1Coeffs: number[];
483
484
  poly2Coeffs: number[];
484
- }, {}> | import("./exercises/exercise").Exercise<{
485
+ }, {}> | Exercise<{
485
486
  poly1Coeffs: number[];
486
487
  poly2Coeffs: number[];
487
- }, {}> | import("./exercises/exercise").Exercise<{
488
+ }, {}> | Exercise<{
488
489
  a: number;
489
- }, {}> | import("./exercises/exercise").Exercise<{
490
+ }, {}> | Exercise<{
490
491
  coefficients: number[];
491
- }, {}> | import("./exercises/exercise").Exercise<{
492
+ }, {}> | Exercise<{
492
493
  coefficients: number[];
493
- }, {}> | import("./exercises/exercise").Exercise<{
494
+ }, {}> | Exercise<{
494
495
  a: number;
495
496
  coin: number;
496
497
  racine1: number;
497
498
  racine2: number;
498
- }, {}> | import("./exercises/exercise").Exercise<{
499
+ }, {}> | Exercise<{
499
500
  type: number;
500
501
  a?: number | undefined;
501
502
  b?: number | undefined;
502
503
  coefficients?: number[] | undefined;
503
504
  tex?: string | undefined;
504
- }, {}> | import("./exercises/exercise").Exercise<{
505
+ }, {}> | Exercise<{
505
506
  affineA: number;
506
507
  affineB: number;
507
- }, {}> | import("./exercises/exercise").Exercise<{
508
+ }, {}> | Exercise<{
508
509
  affineA: number;
509
510
  affineB: number;
510
- }, {}> | import("./exercises/exercise").Exercise<{
511
+ }, {}> | Exercise<{
511
512
  affineA: number;
512
513
  affineB: number;
513
- }, {}> | import("./exercises/exercise").Exercise<{
514
+ }, {}> | Exercise<{
514
515
  affineA: number;
515
516
  affineB: number;
516
517
  power: number;
517
- }, {}> | import("./exercises/exercise").Exercise<{
518
+ }, {}> | Exercise<{
518
519
  affinecoeffs: number[];
519
- }, {}> | import("./exercises/exercise").Exercise<{
520
+ }, {}> | Exercise<{
520
521
  affinecoeffs: number[];
521
- }, {}> | import("./exercises/exercise").Exercise<{
522
+ }, {}> | Exercise<{
522
523
  coeffs: number[];
523
- }, {}> | import("./exercises/exercise").Exercise<{
524
+ }, {}> | Exercise<{
524
525
  askConvex: boolean;
525
526
  quadcoeffs: number[];
526
- }, {}> | import("./exercises/exercise").Exercise<{
527
+ }, {}> | Exercise<{
527
528
  quadcoeffs: number[];
528
- }, {}> | import("./exercises/exercise").Exercise<{
529
+ }, {}> | Exercise<{
529
530
  a: number;
530
531
  b: number;
531
532
  c: number;
532
- }, {}> | import("./exercises/exercise").Exercise<{
533
+ }, {}> | Exercise<{
533
534
  a: number;
534
535
  b: number;
535
536
  c: number;
536
537
  d: number;
537
- }, {}> | import("./exercises/exercise").Exercise<{
538
+ }, {}> | Exercise<{
538
539
  coeffs: number[];
539
- }, {}> | import("./exercises/exercise").Exercise<{
540
+ }, {}> | Exercise<{
540
541
  coeffs: number[];
541
542
  x: number;
542
- }, {}> | import("./exercises/exercise").Exercise<{
543
+ }, {}> | Exercise<{
543
544
  abscisse: number;
544
545
  trinome: number[];
545
- }, {}> | import("./exercises/exercise").Exercise<{
546
+ }, {}> | Exercise<{
546
547
  A: number[];
547
548
  B: number[];
548
- }, {}> | import("./exercises/exercise").Exercise<{
549
+ }, {}> | Exercise<{
549
550
  xA: number;
550
551
  yA: number;
551
552
  yPrimeA: any;
552
553
  trinomCoeffs: number[];
553
- }, {}> | import("./exercises/exercise").Exercise<{
554
+ }, {}> | Exercise<{
554
555
  a: number;
555
- }, {}> | import("./exercises/exercise").Exercise<{
556
+ }, {}> | Exercise<{
556
557
  a: number;
557
558
  initialY: number;
558
- }, {}> | import("./exercises/exercise").Exercise<{
559
+ }, {}> | Exercise<{
559
560
  type: string;
560
561
  d: number;
561
562
  e: number;
562
563
  f: number | undefined;
563
- }, {}> | import("./exercises/exercise").Exercise<{
564
+ }, {}> | Exercise<{
564
565
  a: number;
565
566
  b: number;
566
- }, {}> | import("./exercises/exercise").Exercise<{
567
+ }, {}> | Exercise<{
567
568
  a: number;
568
569
  b: number;
569
- }, {}> | import("./exercises/exercise").Exercise<{
570
+ }, {}> | Exercise<{
570
571
  a: number;
571
572
  b: number;
572
573
  isStrict: boolean;
573
- }, {}> | import("./exercises/exercise").Exercise<{
574
+ }, {}> | Exercise<{
574
575
  xA: number;
575
576
  yA: number;
576
577
  xB: number;
577
578
  yB: number;
578
- }, {}> | import("./exercises/exercise").Exercise<{
579
+ }, {}> | Exercise<{
579
580
  xA: number;
580
581
  xB: number;
581
582
  yA: number;
582
583
  yB: number;
583
- }, {}> | import("./exercises/exercise").Exercise<{
584
+ }, {}> | Exercise<{
584
585
  xA: number;
585
586
  xB: number;
586
587
  yA: number;
587
588
  yB: number;
588
- }, {}> | import("./exercises/exercise").Exercise<{
589
+ }, {}> | Exercise<{
589
590
  a: number;
590
591
  b: number;
591
592
  askingPositive: boolean;
592
- }, {}> | import("./exercises/exercise").Exercise<{
593
+ }, {}> | Exercise<{
593
594
  b: number;
594
595
  secondPoint: number[];
595
- }, {}> | import("./exercises/exercise").Exercise<{
596
+ }, {}> | Exercise<{
596
597
  b: number;
597
598
  secondPoint: number[];
598
- }, {}> | import("./exercises/exercise").Exercise<{
599
+ }, {}> | Exercise<{
599
600
  a: number;
600
601
  b: number;
601
- }, {}> | import("./exercises/exercise").Exercise<{
602
+ }, {}> | Exercise<{
602
603
  a: number;
603
604
  b: number;
604
605
  isAskingA: boolean;
605
- }, {}> | import("./exercises/exercise").Exercise<{
606
+ }, {}> | Exercise<{
606
607
  G1x: number;
607
608
  G2x: number;
608
609
  G2y: number;
609
610
  G1y: number;
610
611
  xValues: number[];
611
612
  yValues: number[];
612
- }, {}> | import("./exercises/exercise").Exercise<{
613
+ }, {}> | Exercise<{
613
614
  rSquared: number;
614
615
  xValues: number[];
615
616
  yValues: number[];
616
- }, {}> | import("./exercises/exercise").Exercise<{
617
+ }, {}> | Exercise<{
617
618
  G1x: number;
618
619
  G2x: number;
619
620
  G2y: number;
@@ -621,44 +622,44 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
621
622
  rSquared: number;
622
623
  xValues: number[];
623
624
  yValues: number[];
624
- }, {}> | import("./exercises/exercise").Exercise<{
625
+ }, {}> | Exercise<{
625
626
  trinomial: number[];
626
627
  leftbound: number;
627
628
  rightbound: number;
628
- }, {}> | import("./exercises/exercise").Exercise<{
629
+ }, {}> | Exercise<{
629
630
  xA: number;
630
631
  xB: number;
631
632
  yA: number;
632
633
  yB: number;
633
- }, {}> | import("./exercises/exercise").Exercise<{
634
+ }, {}> | Exercise<{
634
635
  affineA: number;
635
636
  affineB: number;
636
637
  x: number;
637
638
  y: number;
638
639
  isOnLine: boolean;
639
- }, {}> | import("./exercises/exercise").Exercise<{
640
+ }, {}> | Exercise<{
640
641
  rand: boolean;
641
642
  poly1: number[];
642
643
  poly2: number[];
643
644
  xValue: number;
644
- }, {}> | import("./exercises/exercise").Exercise<{
645
+ }, {}> | Exercise<{
645
646
  isSpline: boolean;
646
647
  splinePoints: number[][];
647
648
  x: number;
648
649
  y: number;
649
- }, {}> | import("./exercises/exercise").Exercise<{
650
+ }, {}> | Exercise<{
650
651
  poly1: number[];
651
652
  xValue: number;
652
- }, {}> | import("./exercises/exercise").Exercise<{
653
+ }, {}> | Exercise<{
653
654
  xValue: number;
654
655
  yValue: number;
655
656
  affineCoeffs?: number[] | undefined;
656
657
  trinomCoeffs?: number[] | undefined;
657
658
  isAffine: boolean;
658
- }, {}> | import("./exercises/exercise").Exercise<{
659
+ }, {}> | Exercise<{
659
660
  yValue: number;
660
661
  splinePoints: [number, number][];
661
- }, {}> | import("./exercises/exercise").Exercise<{
662
+ }, {}> | Exercise<{
662
663
  yValue: number;
663
664
  splinePoints: [number, number][];
664
665
  isStrict: boolean;
@@ -668,11 +669,11 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
668
669
  b: number;
669
670
  closure: import("./tree/nodes/sets/closure").ClosureType;
670
671
  }[];
671
- }, {}> | import("./exercises/exercise").Exercise<{
672
+ }, {}> | Exercise<{
672
673
  yValue: number;
673
674
  fSplinePoints: number[][];
674
675
  gSplinePoints: number[][];
675
- }, {}> | import("./exercises/exercise").Exercise<{
676
+ }, {}> | Exercise<{
676
677
  yValue: number;
677
678
  fSplinePoints: number[][];
678
679
  gSplinePoints: number[][];
@@ -682,310 +683,310 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
682
683
  b: number;
683
684
  closure: import("./tree/nodes/sets/closure").ClosureType;
684
685
  }[];
685
- }, {}> | import("./exercises/exercise").Exercise<{
686
+ }, {}> | Exercise<{
686
687
  xValues: number[];
687
688
  imageValues: number[];
688
689
  isAskingImage: boolean;
689
690
  value: number;
690
- }, {}> | import("./exercises/exercise").Exercise<{
691
+ }, {}> | Exercise<{
691
692
  isImage: boolean;
692
693
  x: number;
693
694
  y: number;
694
- }, {}> | import("./exercises/exercise").Exercise<{
695
+ }, {}> | Exercise<{
695
696
  yValue: number;
696
697
  xValue: number;
697
698
  inegalitySymbol: import("./math/inequations/inequation").InegalitySymbols;
698
699
  a: number;
699
700
  b: number;
700
- }, {}> | import("./exercises/exercise").Exercise<{
701
+ }, {}> | Exercise<{
701
702
  k: number;
702
- }, {}> | import("./exercises/exercise").Exercise<{
703
+ }, {}> | Exercise<{
703
704
  a: number;
704
705
  b: number;
705
706
  c: number;
706
707
  d: number;
707
- }, {}> | import("./exercises/exercise").Exercise<{
708
+ }, {}> | Exercise<{
708
709
  param: string;
709
710
  coeffs: number[];
710
- }, {}> | import("./exercises/exercise").Exercise<{
711
+ }, {}> | Exercise<{
711
712
  param: string;
712
713
  a: number;
713
714
  alpha: number;
714
715
  beta: number;
715
- }, {}> | import("./exercises/exercise").Exercise<{
716
+ }, {}> | Exercise<{
716
717
  a: number;
717
718
  b: number;
718
719
  c: number;
719
- }, {}> | import("./exercises/exercise").Exercise<{
720
+ }, {}> | Exercise<{
720
721
  a: number;
721
722
  b: number;
722
723
  c: number;
723
- }, {}> | import("./exercises/exercise").Exercise<{
724
+ }, {}> | Exercise<{
724
725
  a: number;
725
726
  b: number;
726
727
  c: number;
727
- }, {}> | import("./exercises/exercise").Exercise<{
728
+ }, {}> | Exercise<{
728
729
  a: number;
729
730
  b: number;
730
731
  c: number;
731
- }, {}> | import("./exercises/exercise").Exercise<{
732
+ }, {}> | Exercise<{
732
733
  a: number;
733
734
  b: number;
734
735
  c: number;
735
- }, {}> | import("./exercises/exercise").Exercise<{
736
+ }, {}> | Exercise<{
736
737
  a: number;
737
738
  b: number;
738
739
  c: number;
739
- }, {}> | import("./exercises/exercise").Exercise<{
740
+ }, {}> | Exercise<{
740
741
  a: number;
741
742
  b: number;
742
743
  c: number;
743
- }, {}> | import("./exercises/exercise").Exercise<{
744
+ }, {}> | Exercise<{
744
745
  a: number;
745
746
  b: number;
746
747
  c: number;
747
- }, {}> | import("./exercises/exercise").Exercise<{
748
+ }, {}> | Exercise<{
748
749
  a: number;
749
750
  b: number;
750
751
  c: number;
751
752
  ineqType: import("./math/inequations/inequation").InegalitySymbols;
752
- }, {}> | import("./exercises/exercise").Exercise<{
753
+ }, {}> | Exercise<{
753
754
  a: number;
754
755
  b: number;
755
756
  c: number;
756
- }, {}> | import("./exercises/exercise").Exercise<{
757
+ }, {}> | Exercise<{
757
758
  roots: number[];
758
759
  a: number;
759
- }, {}> | import("./exercises/exercise").Exercise<{
760
+ }, {}> | Exercise<{
760
761
  a: number;
761
762
  b: number;
762
763
  c: number;
763
- }, {}> | import("./exercises/exercise").Exercise<{
764
+ }, {}> | Exercise<{
764
765
  a: number;
765
766
  b: number;
766
767
  c: number;
767
- }, {}> | import("./exercises/exercise").Exercise<{
768
+ }, {}> | Exercise<{
768
769
  a: number;
769
770
  b: number;
770
771
  c: number;
771
- }, {}> | import("./exercises/exercise").Exercise<{
772
+ }, {}> | Exercise<{
772
773
  quadrinomial: number[];
773
774
  leftbound: number;
774
775
  rightbound: number;
775
- }, {}> | import("./exercises/exercise").Exercise<{
776
+ }, {}> | Exercise<{
776
777
  a: number;
777
778
  b: number;
778
779
  type: number;
779
- }, {}> | import("./exercises/exercise").Exercise<{
780
+ }, {}> | Exercise<{
780
781
  coeffs: number[];
781
- }, {}> | import("./exercises/exercise").Exercise<{
782
+ }, {}> | Exercise<{
782
783
  trinomCoeffs: number[];
783
784
  isAskingPositive: boolean;
784
- }, {}> | import("./exercises/exercise").Exercise<{
785
+ }, {}> | Exercise<{
785
786
  aIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
786
787
  bIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
787
788
  cIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
788
789
  isAsking: string;
789
- }, {}> | import("./exercises/exercise").Exercise<{
790
+ }, {}> | Exercise<{
790
791
  trinomIdentifiers: import("./math/polynomials/generalTrinom").GeneralTrinomIdentifiers;
791
- }, {}> | import("./exercises/exercise").Exercise<{
792
+ }, {}> | Exercise<{
792
793
  trinomIdentifiers: import("./math/polynomials/generalTrinom").GeneralTrinomIdentifiers;
793
- }, {}> | import("./exercises/exercise").Exercise<{
794
+ }, {}> | Exercise<{
794
795
  trinomIdentifiers: import("./math/polynomials/generalTrinom").GeneralTrinomIdentifiers;
795
796
  firstRootIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
796
- }, {}> | import("./exercises/exercise").Exercise<{
797
+ }, {}> | Exercise<{
797
798
  a: number;
798
799
  k: number;
799
- }, {}> | import("./exercises/exercise").Exercise<{
800
+ }, {}> | Exercise<{
800
801
  random: number;
801
802
  a?: number | undefined;
802
803
  uCoeffs: number[];
803
804
  vCoeffs: number[];
804
- }, {}> | import("./exercises/exercise").Exercise<{
805
+ }, {}> | Exercise<{
805
806
  a: number;
806
807
  k: number;
807
- }, {}> | import("./exercises/exercise").Exercise<{
808
+ }, {}> | Exercise<{
808
809
  pm: number;
809
810
  a: number;
810
811
  b: number;
811
- }, {}> | import("./exercises/exercise").Exercise<{
812
+ }, {}> | Exercise<{
812
813
  tenthPower: number;
813
814
  nbTex: string;
814
- }, {}> | import("./exercises/exercise").Exercise<{
815
+ }, {}> | Exercise<{
815
816
  a: number;
816
817
  powered: number;
817
818
  c: number;
818
819
  k: number;
819
820
  isLog10: boolean;
820
- }, {}> | import("./exercises/exercise").Exercise<{
821
+ }, {}> | Exercise<{
821
822
  nb: number;
822
823
  powers: number[];
823
824
  signs: number[];
824
825
  isLog10: boolean;
825
- }, {}> | import("./exercises/exercise").Exercise<{
826
+ }, {}> | Exercise<{
826
827
  type: string;
827
828
  fctTex: string;
828
- }, {}> | import("./exercises/exercise").Exercise<{
829
+ }, {}> | Exercise<{
829
830
  type: string;
830
831
  fctCmd: string;
831
- }, {}> | import("./exercises/exercise").Exercise<{
832
+ }, {}> | Exercise<{
832
833
  a: number;
833
834
  b: number;
834
835
  closure: import("./tree/nodes/sets/closure").ClosureType;
835
836
  type: number;
836
- }, {}> | import("./exercises/exercise").Exercise<{
837
+ }, {}> | Exercise<{
837
838
  lowerBound: number;
838
839
  upperBound: number;
839
840
  trinomial: number[];
840
- }, {}> | import("./exercises/exercise").Exercise<{
841
+ }, {}> | Exercise<{
841
842
  lowerBound: number;
842
843
  upperBound: number;
843
844
  quadrinomial: number[];
844
- }, {}> | import("./exercises/exercise").Exercise<{
845
+ }, {}> | Exercise<{
845
846
  lowerBoundIndex: number;
846
847
  upperBoundIndex: number;
847
848
  k: number;
848
- }, {}> | import("./exercises/exercise").Exercise<{
849
+ }, {}> | Exercise<{
849
850
  lowerBoundIndex: number;
850
851
  upperBoundIndex: number;
851
852
  k: number;
852
- }, {}> | import("./exercises/exercise").Exercise<{
853
+ }, {}> | Exercise<{
853
854
  questionType: string;
854
855
  trinomial: number[];
855
856
  upperBound: number;
856
857
  lowerBound: number;
857
- }, {}> | import("./exercises/exercise").Exercise<{
858
+ }, {}> | Exercise<{
858
859
  questionType: string;
859
860
  trinomial: number[];
860
861
  upperBound: number;
861
862
  lowerBound: number;
862
- }, {}> | import("./exercises/exercise").Exercise<{
863
+ }, {}> | Exercise<{
863
864
  a: number;
864
865
  b: number;
865
866
  aX: number;
866
867
  bX: number;
867
- }, {}> | import("./exercises/exercise").Exercise<{
868
+ }, {}> | Exercise<{
868
869
  a: number;
869
870
  b: number;
870
871
  aU: number;
871
872
  bU: number;
872
- }, {}> | import("./exercises/exercise").Exercise<{
873
+ }, {}> | Exercise<{
873
874
  a: number;
874
875
  b: number;
875
876
  aU: number;
876
877
  bU: number;
877
- }, {}> | import("./exercises/exercise").Exercise<{
878
+ }, {}> | Exercise<{
878
879
  coin: boolean;
879
880
  radius: number;
880
881
  diametre: number;
881
- }, {}> | import("./exercises/exercise").Exercise<{
882
+ }, {}> | Exercise<{
882
883
  length: number;
883
884
  width: number;
884
- }, {}> | import("./exercises/exercise").Exercise<{
885
+ }, {}> | Exercise<{
885
886
  sidesLengths: number[];
886
- }, {}> | import("./exercises/exercise").Exercise<{
887
+ }, {}> | Exercise<{
887
888
  side: number;
888
- }, {}> | import("./exercises/exercise").Exercise<{}, {}> | import("./exercises/exercise").Exercise<{
889
+ }, {}> | Exercise<{}, {}> | Exercise<{
889
890
  randomSide: number;
890
- }, {}> | import("./exercises/exercise").Exercise<{
891
+ }, {}> | Exercise<{
891
892
  area: number;
892
893
  isPerfectSquare: boolean;
893
- }, {}> | import("./exercises/exercise").Exercise<{
894
+ }, {}> | Exercise<{
894
895
  area: number;
895
896
  width: number;
896
- }, {}> | import("./exercises/exercise").Exercise<{
897
+ }, {}> | Exercise<{
897
898
  area: number;
898
- }, {}> | import("./exercises/exercise").Exercise<{
899
+ }, {}> | Exercise<{
899
900
  coords1: number[];
900
901
  coords2: number[];
901
- }, {}> | import("./exercises/exercise").Exercise<{
902
+ }, {}> | Exercise<{
902
903
  coordsA: number[];
903
904
  coordsB: number[];
904
- }, {}> | import("./exercises/exercise").Exercise<{
905
+ }, {}> | Exercise<{
905
906
  aX: number;
906
907
  aY: number;
907
908
  bX: number;
908
909
  bY: number;
909
- }, {}> | import("./exercises/exercise").Exercise<{
910
+ }, {}> | Exercise<{
910
911
  x: number;
911
912
  y: number;
912
- }, {}> | import("./exercises/exercise").Exercise<{
913
+ }, {}> | Exercise<{
913
914
  xValue: number;
914
915
  yValue: number;
915
- }, {}> | import("./exercises/exercise").Exercise<{
916
+ }, {}> | Exercise<{
916
917
  xValue: number;
917
918
  yValue: number;
918
- }, {}> | import("./exercises/exercise").Exercise<{
919
+ }, {}> | Exercise<{
919
920
  correctA: number;
920
921
  correctB: number;
921
- }, {}> | import("./exercises/exercise").Exercise<{
922
+ }, {}> | Exercise<{
922
923
  x: number;
923
924
  y: number;
924
- }, {}> | import("./exercises/exercise").Exercise<{
925
+ }, {}> | Exercise<{
925
926
  x: number;
926
927
  y: number;
927
- }, {}> | import("./exercises/exercise").Exercise<{
928
+ }, {}> | Exercise<{
928
929
  abscissType: import("./math/numbers/nombre").NumberType;
929
930
  axisUnit: number;
930
931
  oneUnitTex: string;
931
932
  absciss: number;
932
933
  abscissTex: string;
933
934
  coeff: number;
934
- }, {}> | import("./exercises/exercise").Exercise<{
935
+ }, {}> | Exercise<{
935
936
  abscissType: import("./math/numbers/nombre").NumberType;
936
937
  axisUnit: number;
937
938
  oneUnitTex: string;
938
939
  absciss: number;
939
940
  abscissTex: string;
940
941
  coeff: number;
941
- }, {}> | import("./exercises/exercise").Exercise<{
942
+ }, {}> | Exercise<{
942
943
  abscissType: import("./math/numbers/nombre").NumberType;
943
944
  axisUnit: number;
944
945
  oneUnitTex: string;
945
946
  absciss: number;
946
947
  abscissTex: string;
947
948
  coeff: number;
948
- }, {}> | import("./exercises/exercise").Exercise<{
949
+ }, {}> | Exercise<{
949
950
  abscissType: import("./math/numbers/nombre").NumberType;
950
951
  axisUnit: number;
951
952
  oneUnitTex: string;
952
953
  absciss: number;
953
954
  abscissTex: string;
954
955
  coeff: number;
955
- }, {}> | import("./exercises/exercise").Exercise<{
956
+ }, {}> | Exercise<{
956
957
  coin: boolean;
957
958
  radius: number;
958
959
  diametre: number;
959
- }, {}> | import("./exercises/exercise").Exercise<{
960
+ }, {}> | Exercise<{
960
961
  length: number;
961
962
  width: number;
962
- }, {}> | import("./exercises/exercise").Exercise<{
963
+ }, {}> | Exercise<{
963
964
  side: number;
964
- }, {}> | import("./exercises/exercise").Exercise<{
965
+ }, {}> | Exercise<{
965
966
  sides: number[];
966
- }, {}> | import("./exercises/exercise").Exercise<{
967
+ }, {}> | Exercise<{
967
968
  perimeter: number;
968
- }, {}> | import("./exercises/exercise").Exercise<{
969
+ }, {}> | Exercise<{
969
970
  perimeter: number;
970
971
  width: number;
971
- }, {}> | import("./exercises/exercise").Exercise<{
972
+ }, {}> | Exercise<{
972
973
  perimeter: number;
973
- }, {}> | import("./exercises/exercise").Exercise<{
974
+ }, {}> | Exercise<{
974
975
  sideA: string;
975
976
  sideB: string;
976
977
  sideC: string;
977
978
  triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
978
- }, {}> | import("./exercises/exercise").Exercise<{
979
+ }, {}> | Exercise<{
979
980
  square: number;
980
981
  sideLengths: number[];
981
982
  triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
982
- }, {}> | import("./exercises/exercise").Exercise<{
983
+ }, {}> | Exercise<{
983
984
  isRight: boolean;
984
985
  a: number;
985
986
  b: number;
986
987
  c: number;
987
988
  vertices: string[];
988
- }, {}> | import("./exercises/exercise").Exercise<{
989
+ }, {}> | Exercise<{
989
990
  vertices: string[];
990
991
  xA: number;
991
992
  yA: number;
@@ -994,40 +995,40 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
994
995
  xC: number;
995
996
  yC: number;
996
997
  factor: number;
997
- }, {}> | import("./exercises/exercise").Exercise<{
998
+ }, {}> | Exercise<{
998
999
  triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
999
1000
  insidePointsIdentifiers: import("./math/geometry/point").PointIdentifiers[];
1000
1001
  segmentAsked: import("./math/geometry/segment").SegmentIdentifiers;
1001
1002
  isPapillon: boolean;
1002
1003
  }, {
1003
1004
  configurationType: string;
1004
- }> | import("./exercises/exercise").Exercise<{
1005
+ }> | Exercise<{
1005
1006
  randLetters: string[];
1006
1007
  vectors: string[];
1007
- }, {}> | import("./exercises/exercise").Exercise<{
1008
+ }, {}> | Exercise<{
1008
1009
  xA: number;
1009
1010
  xB: number;
1010
1011
  yA: number;
1011
1012
  yB: number;
1012
- }, {}> | import("./exercises/exercise").Exercise<{
1013
+ }, {}> | Exercise<{
1013
1014
  uCoords: string[];
1014
1015
  vCoords: string[];
1015
- }, {}> | import("./exercises/exercise").Exercise<{
1016
+ }, {}> | Exercise<{
1016
1017
  A: number[];
1017
1018
  B: number[];
1018
- }, {}> | import("./exercises/exercise").Exercise<{
1019
+ }, {}> | Exercise<{
1019
1020
  xu: number;
1020
1021
  yu: number;
1021
1022
  xv: number;
1022
1023
  yv: number;
1023
- }, {}> | import("./exercises/exercise").Exercise<{
1024
+ }, {}> | Exercise<{
1024
1025
  xA: number;
1025
1026
  xB: number;
1026
1027
  xC: number;
1027
1028
  yA: number;
1028
1029
  yB: number;
1029
1030
  yC: number;
1030
- }, {}> | import("./exercises/exercise").Exercise<{
1031
+ }, {}> | Exercise<{
1031
1032
  xA: number;
1032
1033
  xB: number;
1033
1034
  xC: number;
@@ -1036,7 +1037,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
1036
1037
  yB: number;
1037
1038
  yC: number;
1038
1039
  yD: number;
1039
- }, {}> | import("./exercises/exercise").Exercise<{
1040
+ }, {}> | Exercise<{
1040
1041
  xA: number;
1041
1042
  xB: number;
1042
1043
  xC: number;
@@ -1045,7 +1046,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
1045
1046
  yB: number;
1046
1047
  yC: number;
1047
1048
  yD: number;
1048
- }, {}> | import("./exercises/exercise").Exercise<{
1049
+ }, {}> | Exercise<{
1049
1050
  xA: number;
1050
1051
  xB: number;
1051
1052
  xC: number;
@@ -1054,11 +1055,11 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
1054
1055
  yB: number;
1055
1056
  yC: number;
1056
1057
  yD: number;
1057
- }, {}> | import("./exercises/exercise").Exercise<{
1058
+ }, {}> | Exercise<{
1058
1059
  caracAsked: string;
1059
1060
  uPoints: number[][];
1060
1061
  vPoints: number[][];
1061
- }, {}> | import("./exercises/exercise").Exercise<{
1062
+ }, {}> | Exercise<{
1062
1063
  a: number;
1063
1064
  b: number;
1064
1065
  u: {
@@ -1069,259 +1070,259 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
1069
1070
  x: number;
1070
1071
  y: number;
1071
1072
  };
1072
- }, {}> | import("./exercises/exercise").Exercise<{
1073
+ }, {}> | Exercise<{
1073
1074
  x: number;
1074
1075
  y: number;
1075
- }, {}> | import("./exercises/exercise").Exercise<{
1076
+ }, {}> | Exercise<{
1076
1077
  uX: number;
1077
1078
  uY: number;
1078
1079
  aX: number;
1079
1080
  aY: number;
1080
- }, {}> | import("./exercises/exercise").Exercise<{
1081
+ }, {}> | Exercise<{
1081
1082
  x: number;
1082
1083
  y: number;
1083
- }, {}> | import("./exercises/exercise").Exercise<{
1084
+ }, {}> | Exercise<{
1084
1085
  uCoords: string[];
1085
1086
  vCoords: string[];
1086
- }, {}> | import("./exercises/exercise").Exercise<{
1087
+ }, {}> | Exercise<{
1087
1088
  AB: number;
1088
1089
  AC: number;
1089
1090
  trigoPoint: string;
1090
- }, {}> | import("./exercises/exercise").Exercise<{
1091
+ }, {}> | Exercise<{
1091
1092
  trinom: number[];
1092
- }, {}> | import("./exercises/exercise").Exercise<{
1093
+ }, {}> | Exercise<{
1093
1094
  askConvex: boolean;
1094
1095
  quadcoeffs: number[];
1095
1096
  inflexionPoint: number;
1096
- }, {}> | import("./exercises/exercise").Exercise<{
1097
+ }, {}> | Exercise<{
1097
1098
  cubeSide: number;
1098
- }, {}> | import("./exercises/exercise").Exercise<{
1099
+ }, {}> | Exercise<{
1099
1100
  h: number;
1100
1101
  baseOfPyramid: {
1101
1102
  type: string;
1102
1103
  sideSizes: number[];
1103
1104
  };
1104
- }, {}> | import("./exercises/exercise").Exercise<{
1105
+ }, {}> | Exercise<{
1105
1106
  h: number;
1106
1107
  baseOfPyramidSides: {
1107
1108
  ABSide: number;
1108
1109
  ACSide: number;
1109
1110
  BCSide: number;
1110
1111
  };
1111
- }, {}> | import("./exercises/exercise").Exercise<{
1112
+ }, {}> | Exercise<{
1112
1113
  h: number;
1113
1114
  baseOfPyramidSides: {
1114
1115
  ABSide: number;
1115
1116
  ACSide: number;
1116
1117
  BCSide: number;
1117
1118
  };
1118
- }, {}> | import("./exercises/exercise").Exercise<{
1119
+ }, {}> | Exercise<{
1119
1120
  radius: number;
1120
1121
  height: number;
1121
- }, {}> | import("./exercises/exercise").Exercise<{
1122
+ }, {}> | Exercise<{
1122
1123
  radius: number;
1123
- }, {}> | import("./exercises/exercise").Exercise<{
1124
+ }, {}> | Exercise<{
1124
1125
  length: number;
1125
1126
  width: number;
1126
1127
  height: number;
1127
1128
  angle: number;
1128
- }, {}> | import("./exercises/exercise").Exercise<{
1129
+ }, {}> | Exercise<{
1129
1130
  A: number[];
1130
1131
  B: number[];
1131
- }, {}> | import("./exercises/exercise").Exercise<{
1132
+ }, {}> | Exercise<{
1132
1133
  lengths: number[];
1133
- }, {}> | import("./exercises/exercise").Exercise<{
1134
+ }, {}> | Exercise<{
1134
1135
  points: import("./math/geometry/point").PointIdentifiers[];
1135
1136
  startPoint: string;
1136
1137
  translationPoints: string[];
1137
1138
  }, {
1138
1139
  useVector: boolean;
1139
- }> | import("./exercises/exercise").Exercise<{
1140
+ }> | Exercise<{
1140
1141
  type: number;
1141
1142
  commands: string[];
1142
- }, {}> | import("./exercises/exercise").Exercise<{
1143
+ }, {}> | Exercise<{
1143
1144
  type: number;
1144
1145
  commands: string[];
1145
- }, {}> | import("./exercises/exercise").Exercise<{
1146
+ }, {}> | Exercise<{
1146
1147
  startPoint: number[];
1147
1148
  vector: number[];
1148
1149
  askedPointCoords: number[];
1149
1150
  askedPointName: string;
1150
1151
  isOnLine: boolean;
1151
1152
  coeff?: number | undefined;
1152
- }, {}> | import("./exercises/exercise").Exercise<{
1153
+ }, {}> | Exercise<{
1153
1154
  startPoint: number[];
1154
1155
  vector: number[];
1155
- }, {}> | import("./exercises/exercise").Exercise<{
1156
+ }, {}> | Exercise<{
1156
1157
  startPoint: number[];
1157
1158
  vector: number[];
1158
- }, {}> | import("./exercises/exercise").Exercise<{
1159
+ }, {}> | Exercise<{
1159
1160
  coeffs: number[];
1160
1161
  to: string;
1161
- }, {}> | import("./exercises/exercise").Exercise<{
1162
+ }, {}> | Exercise<{
1162
1163
  coeffs: number[];
1163
1164
  to: string;
1164
- }, {}> | import("./exercises/exercise").Exercise<{
1165
+ }, {}> | Exercise<{
1165
1166
  numCoeffs: number[];
1166
1167
  denumCoeffs: number[];
1167
1168
  isRight: boolean;
1168
- }, {}> | import("./exercises/exercise").Exercise<{
1169
+ }, {}> | Exercise<{
1169
1170
  limitTo: "+\\infty" | "-\\infty";
1170
1171
  numCoeffs: number[];
1171
1172
  denumCoeffs: number[];
1172
- }, {}> | import("./exercises/exercise").Exercise<{
1173
+ }, {}> | Exercise<{
1173
1174
  reason: string;
1174
1175
  firstTerm: string;
1175
- }, {}> | import("./exercises/exercise").Exercise<{
1176
+ }, {}> | Exercise<{
1176
1177
  coeffs: number[];
1177
- }, {}> | import("./exercises/exercise").Exercise<{
1178
+ }, {}> | Exercise<{
1178
1179
  coeffs: number[];
1179
- }, {}> | import("./exercises/exercise").Exercise<{
1180
+ }, {}> | Exercise<{
1180
1181
  polyNumCoeffs: number[];
1181
1182
  polyDenumCoeffs: number[];
1182
- }, {}> | import("./exercises/exercise").Exercise<{
1183
+ }, {}> | Exercise<{
1183
1184
  numCoeffs: number[];
1184
1185
  denumCoeffs: number[];
1185
- }, {}> | import("./exercises/exercise").Exercise<{
1186
+ }, {}> | Exercise<{
1186
1187
  type: number;
1187
1188
  to: string;
1188
1189
  from: string | undefined;
1189
1190
  a: number | undefined;
1190
- }, {}> | import("./exercises/exercise").Exercise<{
1191
+ }, {}> | Exercise<{
1191
1192
  a: string;
1192
1193
  b: string;
1193
1194
  c: string;
1194
1195
  d: string;
1195
- }, {}> | import("./exercises/exercise").Exercise<{
1196
+ }, {}> | Exercise<{
1196
1197
  AiCoeff: number;
1197
1198
  AjCoeff: number;
1198
1199
  BiCoeff: number;
1199
1200
  BjCoeff: number;
1200
- }, {}> | import("./exercises/exercise").Exercise<{
1201
+ }, {}> | Exercise<{
1201
1202
  randNbr: number;
1202
1203
  randPercent: number;
1203
1204
  isUp: boolean;
1204
- }, {}> | import("./exercises/exercise").Exercise<{
1205
+ }, {}> | Exercise<{
1205
1206
  rate: number;
1206
1207
  nbMois: number;
1207
- }, {}> | import("./exercises/exercise").Exercise<{
1208
+ }, {}> | Exercise<{
1208
1209
  evolution: number;
1209
- }, {}> | import("./exercises/exercise").Exercise<{
1210
+ }, {}> | Exercise<{
1210
1211
  evolutions: string[];
1211
- }, {}> | import("./exercises/exercise").Exercise<{
1212
+ }, {}> | Exercise<{
1212
1213
  randPercent: number;
1213
1214
  isUp: boolean;
1214
- }, {}> | import("./exercises/exercise").Exercise<{
1215
+ }, {}> | Exercise<{
1215
1216
  isPercentToDecimal: boolean;
1216
1217
  nb: number;
1217
- }, {}> | import("./exercises/exercise").Exercise<{
1218
+ }, {}> | Exercise<{
1218
1219
  percent: number;
1219
1220
  nb: number;
1220
- }, {}> | import("./exercises/exercise").Exercise<{
1221
+ }, {}> | Exercise<{
1221
1222
  total: number;
1222
1223
  lefties: number;
1223
- }, {}> | import("./exercises/exercise").Exercise<{
1224
+ }, {}> | Exercise<{
1224
1225
  evolution: number;
1225
- }, {}> | import("./exercises/exercise").Exercise<{
1226
+ }, {}> | Exercise<{
1226
1227
  TVA: number;
1227
1228
  ht: number;
1228
- }, {}> | import("./exercises/exercise").Exercise<{
1229
+ }, {}> | Exercise<{
1229
1230
  TTC: number;
1230
1231
  TVA: number;
1231
- }, {}> | import("./exercises/exercise").Exercise<{
1232
+ }, {}> | Exercise<{
1232
1233
  ttc: number;
1233
1234
  ht: number;
1234
1235
  tva: number;
1235
- }, {}> | import("./exercises/exercise").Exercise<{
1236
+ }, {}> | Exercise<{
1236
1237
  vd: number;
1237
1238
  vf: number;
1238
- }, {}> | import("./exercises/exercise").Exercise<{
1239
+ }, {}> | Exercise<{
1239
1240
  vf: number;
1240
1241
  percentRate: number;
1241
- }, {}> | import("./exercises/exercise").Exercise<{
1242
+ }, {}> | Exercise<{
1242
1243
  contextType: number;
1243
1244
  total: number;
1244
1245
  populationPercent: number;
1245
- }, {}> | import("./exercises/exercise").Exercise<{
1246
+ }, {}> | Exercise<{
1246
1247
  subPopulationEffectif: number;
1247
1248
  subPopulationPercent: number;
1248
1249
  contextType: number;
1249
- }, {}> | import("./exercises/exercise").Exercise<{
1250
+ }, {}> | Exercise<{
1250
1251
  int: number;
1251
1252
  power: number;
1252
- }, {}> | import("./exercises/exercise").Exercise<{
1253
+ }, {}> | Exercise<{
1253
1254
  int: number;
1254
1255
  power: number;
1255
- }, {}> | import("./exercises/exercise").Exercise<{
1256
+ }, {}> | Exercise<{
1256
1257
  decimal: number;
1257
- }, {}> | import("./exercises/exercise").Exercise<{
1258
+ }, {}> | Exercise<{
1258
1259
  int: number;
1259
1260
  power: number;
1260
- }, {}> | import("./exercises/exercise").Exercise<{
1261
+ }, {}> | Exercise<{
1261
1262
  a: number;
1262
1263
  b: number;
1263
1264
  c: number;
1264
- }, {}> | import("./exercises/exercise").Exercise<{
1265
+ }, {}> | Exercise<{
1265
1266
  randPower: number;
1266
- }, {}> | import("./exercises/exercise").Exercise<{
1267
+ }, {}> | Exercise<{
1267
1268
  a: number;
1268
1269
  b: number;
1269
1270
  c: number;
1270
- }, {}> | import("./exercises/exercise").Exercise<{
1271
+ }, {}> | Exercise<{
1271
1272
  a: number;
1272
1273
  b: number;
1273
1274
  c: number;
1274
- }, {}> | import("./exercises/exercise").Exercise<{
1275
+ }, {}> | Exercise<{
1275
1276
  a: number;
1276
1277
  b: number;
1277
1278
  c: number;
1278
1279
  }, {
1279
1280
  useOnlyPowersOfTen: boolean;
1280
- }> | import("./exercises/exercise").Exercise<{
1281
+ }> | Exercise<{
1281
1282
  tenPower: number;
1282
1283
  decimal: number;
1283
- }, {}> | import("./exercises/exercise").Exercise<{
1284
+ }, {}> | Exercise<{
1284
1285
  c: number;
1285
- }, {}> | import("./exercises/exercise").Exercise<{
1286
+ }, {}> | Exercise<{
1286
1287
  coeffs: number[];
1287
- }, {}> | import("./exercises/exercise").Exercise<{
1288
+ }, {}> | Exercise<{
1288
1289
  a: number;
1289
- }, {}> | import("./exercises/exercise").Exercise<{
1290
+ }, {}> | Exercise<{
1290
1291
  coeffs: number[];
1291
- }, {}> | import("./exercises/exercise").Exercise<{
1292
+ }, {}> | Exercise<{
1292
1293
  coeffs: number[];
1293
- }, {}> | import("./exercises/exercise").Exercise<{
1294
+ }, {}> | Exercise<{
1294
1295
  a: number;
1295
1296
  isCos: boolean;
1296
- }, {}> | import("./exercises/exercise").Exercise<{
1297
+ }, {}> | Exercise<{
1297
1298
  coeffs: number[];
1298
1299
  isCos: boolean;
1299
- }, {}> | import("./exercises/exercise").Exercise<{
1300
+ }, {}> | Exercise<{
1300
1301
  type: number;
1301
1302
  a?: number | undefined;
1302
1303
  coeffs?: number[] | undefined;
1303
1304
  isCos?: boolean | undefined;
1304
1305
  c?: number | undefined;
1305
- }, {}> | import("./exercises/exercise").Exercise<{
1306
+ }, {}> | Exercise<{
1306
1307
  repartitions: number[];
1307
1308
  colorAskedIndex: number;
1308
- }, {}> | import("./exercises/exercise").Exercise<{
1309
+ }, {}> | Exercise<{
1309
1310
  questionType: string;
1310
1311
  value?: string | undefined;
1311
1312
  color?: import("./exercises/utils/cardsData").CardsColor | undefined;
1312
- }, {}> | import("./exercises/exercise").Exercise<{
1313
+ }, {}> | Exercise<{
1313
1314
  flip: number;
1314
1315
  pA?: number | undefined;
1315
1316
  pB?: number | undefined;
1316
1317
  pAB?: number | undefined;
1317
1318
  pA_B?: number | undefined;
1318
1319
  pB_A?: number | undefined;
1319
- }, {}> | import("./exercises/exercise").Exercise<{
1320
+ }, {}> | Exercise<{
1320
1321
  isParityQuestion: boolean;
1321
1322
  isEvenQuestion: boolean;
1322
1323
  nbFaces: number;
1323
1324
  faceAsked: number;
1324
- }, {}> | import("./exercises/exercise").Exercise<{
1325
+ }, {}> | Exercise<{
1325
1326
  type: number;
1326
1327
  A: number;
1327
1328
  B: number;
@@ -1331,46 +1332,46 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
1331
1332
  BD: number;
1332
1333
  }, {
1333
1334
  allowApproximate: string;
1334
- }> | import("./exercises/exercise").Exercise<{
1335
+ }> | Exercise<{
1335
1336
  randomValues: number[];
1336
1337
  randomEffectives: number[];
1337
- }, {}> | import("./exercises/exercise").Exercise<{
1338
+ }, {}> | Exercise<{
1338
1339
  x1: number;
1339
1340
  x2: number;
1340
1341
  x3: number;
1341
1342
  x4: number;
1342
1343
  rand: number;
1343
- }, {}> | import("./exercises/exercise").Exercise<{
1344
+ }, {}> | Exercise<{
1344
1345
  randomValues: number[];
1345
1346
  randomEffectives: number[];
1346
- }, {}> | import("./exercises/exercise").Exercise<{
1347
+ }, {}> | Exercise<{
1347
1348
  sortedValues: number[];
1348
- }, {}> | import("./exercises/exercise").Exercise<{
1349
+ }, {}> | Exercise<{
1349
1350
  randomValues: number[];
1350
1351
  randomEffectives: number[];
1351
1352
  randomQuartile: number;
1352
- }, {}> | import("./exercises/exercise").Exercise<{
1353
+ }, {}> | Exercise<{
1353
1354
  randomValues: number[];
1354
1355
  randomQuartile: number;
1355
- }, {}> | import("./exercises/exercise").Exercise<{
1356
+ }, {}> | Exercise<{
1356
1357
  sortedValues: number[];
1357
- }, {}> | import("./exercises/exercise").Exercise<{
1358
+ }, {}> | Exercise<{
1358
1359
  sortedValues: number[];
1359
- }, {}> | import("./exercises/exercise").Exercise<{
1360
+ }, {}> | Exercise<{
1360
1361
  xValues: number[];
1361
1362
  yValues: number[];
1362
- }, {}> | import("./exercises/exercise").Exercise<{
1363
+ }, {}> | Exercise<{
1363
1364
  isJustified: boolean;
1364
1365
  cloudPointsIdentifiers: import("./math/geometry/CloudPoints").CloudPointsIdentifiers;
1365
- }, {}> | import("./exercises/exercise").Exercise<{
1366
+ }, {}> | Exercise<{
1366
1367
  pA: number;
1367
1368
  pB: number;
1368
1369
  pUnion: number;
1369
- }, {}> | import("./exercises/exercise").Exercise<{
1370
+ }, {}> | Exercise<{
1370
1371
  questionType: string;
1371
1372
  value?: string | undefined;
1372
1373
  color?: string | undefined;
1373
- }, {}> | import("./exercises/exercise").Exercise<{
1374
+ }, {}> | Exercise<{
1374
1375
  aCapB: number;
1375
1376
  aCapBBarre: number;
1376
1377
  aBarreCapB: number;
@@ -1380,7 +1381,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
1380
1381
  probaFrac: number[];
1381
1382
  }, {
1382
1383
  allowNonIrreductible?: boolean | undefined;
1383
- }> | import("./exercises/exercise").Exercise<{
1384
+ }> | Exercise<{
1384
1385
  aCapB: number;
1385
1386
  aCapBBarre: number;
1386
1387
  aBarreCapB: number;
@@ -1390,22 +1391,22 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
1390
1391
  probaFrac: number[];
1391
1392
  }, {
1392
1393
  allowNonIrreductible?: boolean | undefined;
1393
- }> | import("./exercises/exercise").Exercise<{
1394
+ }> | Exercise<{
1394
1395
  exerciseVars: {
1395
1396
  n: number;
1396
1397
  k: number;
1397
1398
  a: number;
1398
1399
  b: number;
1399
1400
  };
1400
- }, {}> | import("./exercises/exercise").Exercise<{
1401
+ }, {}> | Exercise<{
1401
1402
  nX: number;
1402
1403
  a: number;
1403
1404
  b: number;
1404
- }, {}> | import("./exercises/exercise").Exercise<{
1405
+ }, {}> | Exercise<{
1405
1406
  nX: number;
1406
1407
  a: number;
1407
1408
  b: number;
1408
- }, {}> | import("./exercises/exercise").Exercise<{
1409
+ }, {}> | Exercise<{
1409
1410
  n: number;
1410
1411
  p: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
1411
1412
  interval: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
@@ -1413,170 +1414,170 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
1413
1414
  isSentence: boolean;
1414
1415
  }, {
1415
1416
  instructionType: string;
1416
- }> | import("./exercises/exercise").Exercise<{
1417
+ }> | Exercise<{
1417
1418
  firstValue: number;
1418
1419
  askedRank: number;
1419
1420
  reason: number;
1420
- }, {}> | import("./exercises/exercise").Exercise<{
1421
+ }, {}> | Exercise<{
1421
1422
  firstValue: number;
1422
1423
  reason: number;
1423
- }, {}> | import("./exercises/exercise").Exercise<{
1424
+ }, {}> | Exercise<{
1424
1425
  rank1: number;
1425
1426
  reason: number;
1426
1427
  value1: number;
1427
- }, {}> | import("./exercises/exercise").Exercise<{
1428
+ }, {}> | Exercise<{
1428
1429
  reason: number;
1429
1430
  startRank: number;
1430
1431
  startValue: number;
1431
- }, {}> | import("./exercises/exercise").Exercise<{
1432
+ }, {}> | Exercise<{
1432
1433
  firstRank: number;
1433
1434
  firstValue: number;
1434
1435
  reason: number;
1435
- }, {}> | import("./exercises/exercise").Exercise<{
1436
+ }, {}> | Exercise<{
1436
1437
  firstValue: number;
1437
1438
  reason: number;
1438
1439
  randValue: number;
1439
- }, {}> | import("./exercises/exercise").Exercise<{
1440
+ }, {}> | Exercise<{
1440
1441
  final: number;
1441
- }, {}> | import("./exercises/exercise").Exercise<{
1442
+ }, {}> | Exercise<{
1442
1443
  sequences: number[][];
1443
1444
  answerIndex: number;
1444
- }, {}> | import("./exercises/exercise").Exercise<{
1445
+ }, {}> | Exercise<{
1445
1446
  reason: number;
1446
1447
  sequence: number[];
1447
- }, {}> | import("./exercises/exercise").Exercise<{
1448
+ }, {}> | Exercise<{
1448
1449
  reason: number;
1449
1450
  sequence: number[];
1450
- }, {}> | import("./exercises/exercise").Exercise<{
1451
+ }, {}> | Exercise<{
1451
1452
  isAri: boolean;
1452
1453
  sequence: number[];
1453
- }, {}> | import("./exercises/exercise").Exercise<{
1454
+ }, {}> | Exercise<{
1454
1455
  firstRank: number;
1455
1456
  firstValue: number;
1456
1457
  reason: number;
1457
1458
  nbTerms: number;
1458
- }, {}> | import("./exercises/exercise").Exercise<{
1459
+ }, {}> | Exercise<{
1459
1460
  firstValue: number;
1460
1461
  reason: number;
1461
1462
  firstRank: number;
1462
- }, {}> | import("./exercises/exercise").Exercise<{
1463
+ }, {}> | Exercise<{
1463
1464
  rank1: number;
1464
1465
  rank2: number;
1465
1466
  reason: number;
1466
1467
  value1: number;
1467
- }, {}> | import("./exercises/exercise").Exercise<{
1468
+ }, {}> | Exercise<{
1468
1469
  rank1: number;
1469
1470
  value1: number;
1470
1471
  rank2: number;
1471
1472
  value2: number;
1472
1473
  rankAsked: number;
1473
- }, {}> | import("./exercises/exercise").Exercise<{
1474
+ }, {}> | Exercise<{
1474
1475
  firstRank: number;
1475
1476
  firstTerm: number;
1476
1477
  reason: number;
1477
1478
  askedRank: number;
1478
- }, {}> | import("./exercises/exercise").Exercise<{
1479
+ }, {}> | Exercise<{
1479
1480
  firstValue: number;
1480
1481
  reason: number;
1481
1482
  askedRank: number;
1482
- }, {}> | import("./exercises/exercise").Exercise<{
1483
+ }, {}> | Exercise<{
1483
1484
  reason: number;
1484
1485
  firstValue: number;
1485
- }, {}> | import("./exercises/exercise").Exercise<{
1486
+ }, {}> | Exercise<{
1486
1487
  value1: number;
1487
1488
  reason: number;
1488
1489
  rank1: number;
1489
- }, {}> | import("./exercises/exercise").Exercise<{
1490
+ }, {}> | Exercise<{
1490
1491
  raison: number;
1491
1492
  final: number;
1492
- }, {}> | import("./exercises/exercise").Exercise<{
1493
+ }, {}> | Exercise<{
1493
1494
  reason: number;
1494
1495
  startRank: number;
1495
1496
  startValue: number;
1496
- }, {}> | import("./exercises/exercise").Exercise<{
1497
+ }, {}> | Exercise<{
1497
1498
  firstValue: number;
1498
1499
  reason: number;
1499
1500
  firstRank: number;
1500
- }, {}> | import("./exercises/exercise").Exercise<{
1501
+ }, {}> | Exercise<{
1501
1502
  reason: number;
1502
1503
  firstValue: number;
1503
1504
  firstRank: number;
1504
- }, {}> | import("./exercises/exercise").Exercise<{
1505
+ }, {}> | Exercise<{
1505
1506
  firstRank: number;
1506
1507
  firstTerm: number;
1507
1508
  reason: number;
1508
1509
  askedRank: number;
1509
- }, {}> | import("./exercises/exercise").Exercise<{
1510
+ }, {}> | Exercise<{
1510
1511
  sequence: number[];
1511
1512
  reason: number;
1512
- }, {}> | import("./exercises/exercise").Exercise<{
1513
+ }, {}> | Exercise<{
1513
1514
  firstRank: number;
1514
1515
  firstValue: number;
1515
1516
  reason: number;
1516
1517
  nbTerms: number;
1517
- }, {}> | import("./exercises/exercise").Exercise<{
1518
+ }, {}> | Exercise<{
1518
1519
  rank: number;
1519
1520
  coeffs: number[];
1520
- }, {}> | import("./exercises/exercise").Exercise<{
1521
+ }, {}> | Exercise<{
1521
1522
  coeffs: number[];
1522
- }, {}> | import("./exercises/exercise").Exercise<{
1523
+ }, {}> | Exercise<{
1523
1524
  rank: number;
1524
1525
  u0: number;
1525
1526
  coeffs: number[];
1526
- }, {}> | import("./exercises/exercise").Exercise<{
1527
+ }, {}> | Exercise<{
1527
1528
  termeid: number;
1528
1529
  affine: number[];
1529
1530
  termeAdd: number;
1530
1531
  termeMult: number;
1531
- }, {}> | import("./exercises/exercise").Exercise<{
1532
+ }, {}> | Exercise<{
1532
1533
  nValue: number;
1533
1534
  points: number[][];
1534
1535
  isArithmetic: boolean;
1535
- }, {}> | import("./exercises/exercise").Exercise<{
1536
+ }, {}> | Exercise<{
1536
1537
  intervalMin: string | number;
1537
1538
  intervalMax: string | number;
1538
1539
  intervalClosure: import("./tree/nodes/sets/closure").ClosureType;
1539
- }, {}> | import("./exercises/exercise").Exercise<{
1540
+ }, {}> | Exercise<{
1540
1541
  int1Min: number;
1541
1542
  int1Max: number;
1542
1543
  int1Closure: import("./tree/nodes/sets/closure").ClosureType;
1543
1544
  int2Min: number;
1544
1545
  int2Max: number;
1545
1546
  int2Closure: import("./tree/nodes/sets/closure").ClosureType;
1546
- }, {}> | import("./exercises/exercise").Exercise<{
1547
+ }, {}> | Exercise<{
1547
1548
  int1Min: number;
1548
1549
  int1Max: number;
1549
1550
  int1Closure: import("./tree/nodes/sets/closure").ClosureType;
1550
1551
  int2Min: number;
1551
1552
  int2Max: number;
1552
1553
  int2Closure: import("./tree/nodes/sets/closure").ClosureType;
1553
- }, {}> | import("./exercises/exercise").Exercise<{
1554
+ }, {}> | Exercise<{
1554
1555
  intervalMin: string | number;
1555
1556
  intervalMax: string | number;
1556
1557
  intervalClosure: import("./tree/nodes/sets/closure").ClosureType;
1557
- }, {}> | import("./exercises/exercise").Exercise<{
1558
+ }, {}> | Exercise<{
1558
1559
  type: number;
1559
1560
  nb: string;
1560
- }, {}> | import("./exercises/exercise").Exercise<{
1561
+ }, {}> | Exercise<{
1561
1562
  x: number;
1562
1563
  y: number;
1563
1564
  z: number;
1564
- }, {}> | import("./exercises/exercise").Exercise<{}, {}> | import("./exercises/exercise").Exercise<{}, {}> | import("./exercises/exercise").Exercise<{
1565
+ }, {}> | Exercise<{}, {}> | Exercise<{}, {}> | Exercise<{
1565
1566
  sqrtOperand: number;
1566
- }, {}> | import("./exercises/exercise").Exercise<{
1567
+ }, {}> | Exercise<{
1567
1568
  k: number;
1568
- }, {}> | import("./exercises/exercise").Exercise<{
1569
+ }, {}> | Exercise<{
1569
1570
  type: number;
1570
1571
  a: number;
1571
1572
  x: number;
1572
1573
  b: number | undefined;
1573
1574
  y: number;
1574
- }, {}> | import("./exercises/exercise").Exercise<{
1575
+ }, {}> | Exercise<{
1575
1576
  a: number;
1576
1577
  b: number;
1577
1578
  c: number;
1578
1579
  d: number;
1579
- }, {}> | import("./exercises/exercise").Exercise<{
1580
+ }, {}> | Exercise<{
1580
1581
  a: number;
1581
1582
  b: number;
1582
1583
  c: number;
@@ -1584,187 +1585,187 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
1584
1585
  x: number;
1585
1586
  y: number;
1586
1587
  z: number | undefined;
1587
- }, {}> | import("./exercises/exercise").Exercise<{
1588
+ }, {}> | Exercise<{
1588
1589
  a: number;
1589
1590
  b: number;
1590
1591
  c: number;
1591
1592
  d: number;
1592
- }, {}> | import("./exercises/exercise").Exercise<{
1593
+ }, {}> | Exercise<{
1593
1594
  a: number;
1594
1595
  b: number;
1595
1596
  c: number;
1596
1597
  d: number;
1597
- }, {}> | import("./exercises/exercise").Exercise<{
1598
+ }, {}> | Exercise<{
1598
1599
  a: number;
1599
1600
  k: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
1600
1601
  isSquareInside: boolean;
1601
- }, {}> | import("./exercises/exercise").Exercise<{
1602
+ }, {}> | Exercise<{
1602
1603
  valueIndex: number;
1603
1604
  isCos: boolean;
1604
- }, {}> | import("./exercises/exercise").Exercise<{
1605
+ }, {}> | Exercise<{
1605
1606
  mainValue: number;
1606
1607
  isCos: boolean;
1607
- }, {}> | import("./exercises/exercise").Exercise<{
1608
+ }, {}> | Exercise<{
1608
1609
  sideA: string;
1609
1610
  sideB: string;
1610
1611
  sideC: string;
1611
1612
  randAngle: number;
1612
1613
  randTrigo: number;
1613
- }, {}> | import("./exercises/exercise").Exercise<{
1614
+ }, {}> | Exercise<{
1614
1615
  sideLengths: number[];
1615
1616
  randAngle: number;
1616
1617
  randSides: number[];
1617
- }, {}> | import("./exercises/exercise").Exercise<{
1618
+ }, {}> | Exercise<{
1618
1619
  sideLengths: number[];
1619
1620
  randAngle: number;
1620
1621
  randSide: number;
1621
1622
  randSideQuestion: number;
1622
- }, {}> | import("./exercises/exercise").Exercise<{
1623
+ }, {}> | Exercise<{
1623
1624
  angleValue: number;
1624
1625
  angleIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
1625
1626
  point: string;
1626
- }, {}> | import("./exercises/exercise").Exercise<{
1627
+ }, {}> | Exercise<{
1627
1628
  trigFunction: string;
1628
1629
  trigValue: number;
1629
1630
  angleInDegrees: number;
1630
- }, {}> | import("./exercises/exercise").Exercise<{
1631
+ }, {}> | Exercise<{
1631
1632
  degree: number;
1632
1633
  trigoFunct: string;
1633
- }, {}> | import("./exercises/exercise").Exercise<{
1634
+ }, {}> | Exercise<{
1634
1635
  degree: number;
1635
- }, {}> | import("./exercises/exercise").Exercise<{
1636
+ }, {}> | Exercise<{
1636
1637
  degree: number;
1637
- }, {}> | import("./exercises/exercise").Exercise<{
1638
+ }, {}> | Exercise<{
1638
1639
  degree: number;
1639
- }, {}> | import("./exercises/exercise").Exercise<{
1640
+ }, {}> | Exercise<{
1640
1641
  degree: number;
1641
1642
  multipleOf2PiToAdd: number;
1642
1643
  nodeIds: any;
1643
- }, {}> | import("./exercises/exercise").Exercise<{
1644
+ }, {}> | Exercise<{
1644
1645
  degree: number;
1645
1646
  radianNodeIds: any;
1646
1647
  isDegreeToRadian: boolean;
1647
- }, {}> | import("./exercises/exercise").Exercise<{
1648
+ }, {}> | Exercise<{
1648
1649
  radius: number;
1649
1650
  thetaInDegree: number | undefined;
1650
1651
  thetaInRadNodeIds: any;
1651
1652
  isThetaInDegree: boolean;
1652
- }, {}> | import("./exercises/exercise").Exercise<{
1653
+ }, {}> | Exercise<{
1653
1654
  degree: number;
1654
1655
  leftBoundPiMultiple: number;
1655
- }, {}> | import("./exercises/exercise").Exercise<{
1656
+ }, {}> | Exercise<{
1656
1657
  exercise: {
1657
1658
  a: number;
1658
1659
  nbIteration: number;
1659
1660
  op: string;
1660
1661
  b?: number | undefined;
1661
1662
  };
1662
- }, {}> | import("./exercises/exercise").Exercise<{
1663
+ }, {}> | Exercise<{
1663
1664
  exercise: {
1664
1665
  a: number;
1665
1666
  b: number;
1666
1667
  op: string;
1667
1668
  };
1668
- }, {}> | import("./exercises/exercise").Exercise<{
1669
+ }, {}> | Exercise<{
1669
1670
  a: number;
1670
1671
  b: number;
1671
1672
  id1: number;
1672
1673
  id2: number;
1673
- }, {}> | import("./exercises/exercise").Exercise<{
1674
+ }, {}> | Exercise<{
1674
1675
  initialValue: number;
1675
1676
  step: number;
1676
1677
  iterations: number;
1677
1678
  opIndex: number;
1678
- }, {}> | import("./exercises/exercise").Exercise<{
1679
+ }, {}> | Exercise<{
1679
1680
  initialValue: number;
1680
1681
  step: number;
1681
1682
  iterations: number;
1682
1683
  opIndex: number;
1683
1684
  a: number;
1684
1685
  x: number;
1685
- }, {}> | import("./exercises/exercise").Exercise<{
1686
+ }, {}> | Exercise<{
1686
1687
  x: number;
1687
1688
  trinom: number[];
1688
1689
  image: number;
1689
- }, {}> | import("./exercises/exercise").Exercise<{
1690
+ }, {}> | Exercise<{
1690
1691
  a: number;
1691
1692
  b: number;
1692
1693
  opresult: number;
1693
1694
  condition: string;
1694
- }, {}> | import("./exercises/exercise").Exercise<{
1695
+ }, {}> | Exercise<{
1695
1696
  exercise: {
1696
1697
  op: string;
1697
1698
  n: number;
1698
1699
  p: number;
1699
1700
  };
1700
1701
  }, {}>)[];
1701
- declare const pcExercises: (import("./exercises/exercise").Exercise<{
1702
+ declare const pcExercises: (Exercise<{
1702
1703
  numbers: number[];
1703
- }, {}> | import("./exercises/exercise").Exercise<{
1704
+ }, {}> | Exercise<{
1704
1705
  randQuation: number;
1705
1706
  x1: string | number;
1706
1707
  x2: string | number;
1707
1708
  x3: string | number;
1708
1709
  x4: string | number;
1709
- }, {}> | import("./exercises/exercise").Exercise<{
1710
+ }, {}> | Exercise<{
1710
1711
  a: number;
1711
1712
  b: number;
1712
- }, {}> | import("./exercises/exercise").Exercise<{
1713
+ }, {}> | Exercise<{
1713
1714
  a: number;
1714
1715
  b: number;
1715
- }, {}> | import("./exercises/exercise").Exercise<{
1716
+ }, {}> | Exercise<{
1716
1717
  a: number;
1717
1718
  b: number;
1718
1719
  c: number;
1719
- }, {}> | import("./exercises/exercise").Exercise<{
1720
+ }, {}> | Exercise<{
1720
1721
  a: number;
1721
1722
  b: number;
1722
1723
  c: number;
1723
1724
  d: number;
1724
- }, {}> | import("./exercises/exercise").Exercise<{
1725
+ }, {}> | Exercise<{
1725
1726
  a: number;
1726
1727
  b: number;
1727
- }, {}> | import("./exercises/exercise").Exercise<{
1728
+ }, {}> | Exercise<{
1728
1729
  coefficients: number[];
1729
- }, {}> | import("./exercises/exercise").Exercise<{
1730
+ }, {}> | Exercise<{
1730
1731
  coefficients: number[];
1731
- }, {}> | import("./exercises/exercise").Exercise<{
1732
+ }, {}> | Exercise<{
1732
1733
  type: number;
1733
1734
  a?: number | undefined;
1734
1735
  b?: number | undefined;
1735
1736
  coefficients?: number[] | undefined;
1736
1737
  tex?: string | undefined;
1737
- }, {}> | import("./exercises/exercise").Exercise<{
1738
+ }, {}> | Exercise<{
1738
1739
  A: number[];
1739
1740
  B: number[];
1740
- }, {}> | import("./exercises/exercise").Exercise<{
1741
+ }, {}> | Exercise<{
1741
1742
  a: number;
1742
- }, {}> | import("./exercises/exercise").Exercise<{
1743
+ }, {}> | Exercise<{
1743
1744
  a: number;
1744
1745
  initialY: number;
1745
- }, {}> | import("./exercises/exercise").Exercise<{
1746
+ }, {}> | Exercise<{
1746
1747
  type: string;
1747
1748
  d: number;
1748
1749
  e: number;
1749
1750
  f: number | undefined;
1750
- }, {}> | import("./exercises/exercise").Exercise<{
1751
+ }, {}> | Exercise<{
1751
1752
  b: number;
1752
1753
  secondPoint: number[];
1753
- }, {}> | import("./exercises/exercise").Exercise<{
1754
+ }, {}> | Exercise<{
1754
1755
  tenthPower: number;
1755
1756
  nbTex: string;
1756
- }, {}> | import("./exercises/exercise").Exercise<{
1757
+ }, {}> | Exercise<{
1757
1758
  a: number;
1758
1759
  powered: number;
1759
1760
  c: number;
1760
1761
  k: number;
1761
1762
  isLog10: boolean;
1762
- }, {}> | import("./exercises/exercise").Exercise<{
1763
+ }, {}> | Exercise<{
1763
1764
  nb: number;
1764
1765
  powers: number[];
1765
1766
  signs: number[];
1766
1767
  isLog10: boolean;
1767
- }, {}> | import("./exercises/exercise").Exercise<{
1768
+ }, {}> | Exercise<{
1768
1769
  vertices: string[];
1769
1770
  xA: number;
1770
1771
  yA: number;
@@ -1773,110 +1774,110 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
1773
1774
  xC: number;
1774
1775
  yC: number;
1775
1776
  factor: number;
1776
- }, {}> | import("./exercises/exercise").Exercise<{
1777
+ }, {}> | Exercise<{
1777
1778
  triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
1778
1779
  insidePointsIdentifiers: import("./math/geometry/point").PointIdentifiers[];
1779
1780
  segmentAsked: import("./math/geometry/segment").SegmentIdentifiers;
1780
1781
  isPapillon: boolean;
1781
1782
  }, {
1782
1783
  configurationType: string;
1783
- }> | import("./exercises/exercise").Exercise<{
1784
+ }> | Exercise<{
1784
1785
  xA: number;
1785
1786
  xB: number;
1786
1787
  yA: number;
1787
1788
  yB: number;
1788
- }, {}> | import("./exercises/exercise").Exercise<{
1789
+ }, {}> | Exercise<{
1789
1790
  uCoords: string[];
1790
1791
  vCoords: string[];
1791
- }, {}> | import("./exercises/exercise").Exercise<{
1792
+ }, {}> | Exercise<{
1792
1793
  AB: number;
1793
1794
  AC: number;
1794
1795
  trigoPoint: string;
1795
- }, {}> | import("./exercises/exercise").Exercise<{
1796
+ }, {}> | Exercise<{
1796
1797
  total: number;
1797
1798
  lefties: number;
1798
- }, {}> | import("./exercises/exercise").Exercise<{
1799
+ }, {}> | Exercise<{
1799
1800
  decimal: number;
1800
- }, {}> | import("./exercises/exercise").Exercise<{
1801
+ }, {}> | Exercise<{
1801
1802
  a: number;
1802
1803
  b: number;
1803
1804
  c: number;
1804
- }, {}> | import("./exercises/exercise").Exercise<{
1805
+ }, {}> | Exercise<{
1805
1806
  sideLengths: number[];
1806
1807
  randAngle: number;
1807
1808
  randSides: number[];
1808
- }, {}> | import("./exercises/exercise").Exercise<{
1809
+ }, {}> | Exercise<{
1809
1810
  sideLengths: number[];
1810
1811
  randAngle: number;
1811
1812
  randSide: number;
1812
1813
  randSideQuestion: number;
1813
- }, {}> | import("./exercises/exercise").Exercise<{
1814
+ }, {}> | Exercise<{
1814
1815
  reactionArray: import("./pc/constants/molecularChemistry/reaction").ReactionSpecies[];
1815
- }, {}> | import("./exercises/exercise").Exercise<{
1816
+ }, {}> | Exercise<{
1816
1817
  reactionArray: import("./pc/constants/molecularChemistry/reaction").ReactionSpecies[];
1817
1818
  randomSpacieIndex: number;
1818
- }, {}> | import("./exercises/exercise").Exercise<{
1819
+ }, {}> | Exercise<{
1819
1820
  concentrationMere: number;
1820
1821
  volumeFille: number;
1821
1822
  concentrationFille: number;
1822
- }, {}> | import("./exercises/exercise").Exercise<{
1823
+ }, {}> | Exercise<{
1823
1824
  randomMoleculeIndex: number;
1824
- }, {}> | import("./exercises/exercise").Exercise<{
1825
+ }, {}> | Exercise<{
1825
1826
  mass: number;
1826
1827
  velocity: number;
1827
- }, {}> | import("./exercises/exercise").Exercise<{
1828
+ }, {}> | Exercise<{
1828
1829
  mG: number;
1829
1830
  randomMoleculeIndex: number;
1830
- }, {}> | import("./exercises/exercise").Exercise<{
1831
+ }, {}> | Exercise<{
1831
1832
  randomMoleculeIndex: number;
1832
- }, {}> | import("./exercises/exercise").Exercise<{
1833
+ }, {}> | Exercise<{
1833
1834
  randomMoleculeIndex: number;
1834
- }, {}> | import("./exercises/exercise").Exercise<{
1835
+ }, {}> | Exercise<{
1835
1836
  randomNumber: number;
1836
1837
  randomTenPower: number;
1837
- }, {}> | import("./exercises/exercise").Exercise<{
1838
+ }, {}> | Exercise<{
1838
1839
  frequencyEmitted: number;
1839
1840
  ambulanceSpeed: number;
1840
- }, {}> | import("./exercises/exercise").Exercise<{
1841
+ }, {}> | Exercise<{
1841
1842
  mass: number;
1842
1843
  height: number;
1843
- }, {}> | import("./exercises/exercise").Exercise<{
1844
+ }, {}> | Exercise<{
1844
1845
  randomMaterial1: number;
1845
1846
  randomMaterial2: number;
1846
1847
  ramdonAngleIncidenceDeg: number;
1847
- }, {}> | import("./exercises/exercise").Exercise<{
1848
+ }, {}> | Exercise<{
1848
1849
  frequency1: number;
1849
1850
  frequency2: number;
1850
1851
  soundAsked: number;
1851
- }, {}> | import("./exercises/exercise").Exercise<{
1852
+ }, {}> | Exercise<{
1852
1853
  frequency: number;
1853
- }, {}> | import("./exercises/exercise").Exercise<{
1854
+ }, {}> | Exercise<{
1854
1855
  period: number;
1855
- }, {}> | import("./exercises/exercise").Exercise<{
1856
+ }, {}> | Exercise<{
1856
1857
  period: number;
1857
1858
  splinePoints: number[][];
1858
- }, {}> | import("./exercises/exercise").Exercise<{
1859
+ }, {}> | Exercise<{
1859
1860
  period: number;
1860
1861
  frequency: number;
1861
1862
  splinePoints: number[][];
1862
- }, {}> | import("./exercises/exercise").Exercise<{
1863
+ }, {}> | Exercise<{
1863
1864
  xA: number;
1864
1865
  yA: number;
1865
1866
  xB: number;
1866
1867
  yB: number;
1867
- }, {}> | import("./exercises/exercise").Exercise<{
1868
+ }, {}> | Exercise<{
1868
1869
  weight: number;
1869
1870
  originIsMoon: boolean;
1870
- }, {}> | import("./exercises/exercise").Exercise<{
1871
+ }, {}> | Exercise<{
1871
1872
  mass: number;
1872
- }, {}> | import("./exercises/exercise").Exercise<{
1873
+ }, {}> | Exercise<{
1873
1874
  planet: string;
1874
1875
  mass: number;
1875
- }, {}> | import("./exercises/exercise").Exercise<{
1876
+ }, {}> | Exercise<{
1876
1877
  length: number;
1877
1878
  forceValue: number;
1878
1879
  angleDegree: number;
1879
- }, {}> | import("./exercises/exercise").Exercise<{
1880
+ }, {}> | Exercise<{
1880
1881
  varAsked: string;
1881
1882
  F: {
1882
1883
  significantPart: number;
@@ -1890,22 +1891,22 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
1890
1891
  significantPart: number;
1891
1892
  exponent: number;
1892
1893
  };
1893
- }, {}> | import("./exercises/exercise").Exercise<{
1894
+ }, {}> | Exercise<{
1894
1895
  mass: number;
1895
1896
  isAsking: string;
1896
- }, {}> | import("./exercises/exercise").Exercise<{
1897
+ }, {}> | Exercise<{
1897
1898
  mass: number;
1898
1899
  force: number;
1899
1900
  target: "le poids" | "la masse";
1900
- }, {}> | import("./exercises/exercise").Exercise<{
1901
+ }, {}> | Exercise<{
1901
1902
  planet: string;
1902
1903
  mass: import("./pc/measure/measure").Measure<string>;
1903
1904
  distance: import("./pc/measure/measure").Measure<string>;
1904
- }, {}> | import("./exercises/exercise").Exercise<{
1905
+ }, {}> | Exercise<{
1905
1906
  planet: string;
1906
1907
  mass: number;
1907
1908
  h: number;
1908
- }, {}> | import("./exercises/exercise").Exercise<{
1909
+ }, {}> | Exercise<{
1909
1910
  qA: {
1910
1911
  significant: number;
1911
1912
  exponent: number;
@@ -1915,167 +1916,167 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
1915
1916
  exponent: number;
1916
1917
  };
1917
1918
  distance: number;
1918
- }, {}> | import("./exercises/exercise").Exercise<{
1919
+ }, {}> | Exercise<{
1919
1920
  lightYear: number;
1920
- }, {}> | import("./exercises/exercise").Exercise<{
1921
+ }, {}> | Exercise<{
1921
1922
  v: number;
1922
1923
  l: number;
1923
1924
  T: number;
1924
- }, {}> | import("./exercises/exercise").Exercise<{
1925
+ }, {}> | Exercise<{
1925
1926
  lightYear: number;
1926
1927
  distanceMeters: import("./pc/measure/measure").Measure<string>;
1927
1928
  isLightYearToMeters: boolean;
1928
- }, {}> | import("./exercises/exercise").Exercise<{
1929
+ }, {}> | Exercise<{
1929
1930
  atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
1930
1931
  elementToFind: "proton" | "neutron" | "electron";
1931
- }, {}> | import("./exercises/exercise").Exercise<{
1932
+ }, {}> | Exercise<{
1932
1933
  atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
1933
- }, {}> | import("./exercises/exercise").Exercise<{
1934
+ }, {}> | Exercise<{
1934
1935
  atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
1935
- }, {}> | import("./exercises/exercise").Exercise<{
1936
+ }, {}> | Exercise<{
1936
1937
  atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
1937
- }, {}> | import("./exercises/exercise").Exercise<{
1938
+ }, {}> | Exercise<{
1938
1939
  totalWeight: number;
1939
1940
  percent: number;
1940
1941
  elWeight: number;
1941
1942
  type: number;
1942
- }, {}> | import("./exercises/exercise").Exercise<{}, {}> | import("./exercises/exercise").Exercise<{
1943
+ }, {}> | Exercise<{}, {}> | Exercise<{
1943
1944
  atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
1944
- }, {}> | import("./exercises/exercise").Exercise<{
1945
+ }, {}> | Exercise<{
1945
1946
  atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
1946
- }, {}> | import("./exercises/exercise").Exercise<{
1947
+ }, {}> | Exercise<{
1947
1948
  atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols").AtomSymbols;
1948
1949
  sampleMass: number;
1949
- }, {}> | import("./exercises/exercise").Exercise<{
1950
+ }, {}> | Exercise<{
1950
1951
  totalMass: number;
1951
1952
  totalVolume: number;
1952
1953
  elementMass: number;
1953
1954
  elementVolume: number;
1954
1955
  targetProportion: "massique" | "volumique";
1955
- }, {}> | import("./exercises/exercise").Exercise<{
1956
+ }, {}> | Exercise<{
1956
1957
  maxQuantity: number;
1957
1958
  productQuantity: number;
1958
- }, {}> | import("./exercises/exercise").Exercise<{
1959
+ }, {}> | Exercise<{
1959
1960
  combustibleName: string;
1960
1961
  combustibleQuantity: number;
1961
- }, {}> | import("./exercises/exercise").Exercise<{
1962
+ }, {}> | Exercise<{
1962
1963
  firstReagentVariables: number[];
1963
1964
  secondReagentVariables: number[];
1964
- }, {}> | import("./exercises/exercise").Exercise<{
1965
+ }, {}> | Exercise<{
1965
1966
  firstReagentVariables: number[];
1966
1967
  secondReagentVariables: number[];
1967
- }, {}> | import("./exercises/exercise").Exercise<{
1968
+ }, {}> | Exercise<{
1968
1969
  instruction: string;
1969
1970
  answer: string;
1970
1971
  nA: number;
1971
1972
  nB: number;
1972
- }, {}> | import("./exercises/exercise").Exercise<{
1973
+ }, {}> | Exercise<{
1973
1974
  a: number;
1974
1975
  b: number;
1975
1976
  vA: number;
1976
1977
  vB: number;
1977
1978
  cB: number;
1978
- }, {}> | import("./exercises/exercise").Exercise<{}, {}> | import("./exercises/exercise").Exercise<{
1979
+ }, {}> | Exercise<{}, {}> | Exercise<{
1979
1980
  mol: number;
1980
1981
  molarMass: number;
1981
- }, {}> | import("./exercises/exercise").Exercise<{
1982
+ }, {}> | Exercise<{
1982
1983
  mass: number;
1983
1984
  molarMass: number;
1984
- }, {}> | import("./exercises/exercise").Exercise<{
1985
+ }, {}> | Exercise<{
1985
1986
  quantity: number;
1986
- }, {}> | import("./exercises/exercise").Exercise<{
1987
+ }, {}> | Exercise<{
1987
1988
  moleculeName: string;
1988
1989
  sampleMass: number;
1989
1990
  molarMass: number;
1990
- }, {}> | import("./exercises/exercise").Exercise<{
1991
+ }, {}> | Exercise<{
1991
1992
  amplitude: number;
1992
1993
  period: number;
1993
- }, {}> | import("./exercises/exercise").Exercise<{
1994
+ }, {}> | Exercise<{
1994
1995
  p1: number;
1995
1996
  v1: number;
1996
1997
  p2: number | undefined;
1997
1998
  v2: number | undefined;
1998
1999
  isAskingPressure: boolean;
1999
- }, {}> | import("./exercises/exercise").Exercise<{
2000
+ }, {}> | Exercise<{
2000
2001
  intensity: number;
2001
2002
  seconds: number;
2002
- }, {}> | import("./exercises/exercise").Exercise<{
2003
+ }, {}> | Exercise<{
2003
2004
  power: number;
2004
2005
  seconds: number;
2005
- }, {}> | import("./exercises/exercise").Exercise<{
2006
+ }, {}> | Exercise<{
2006
2007
  E: number;
2007
2008
  I: number;
2008
2009
  r: number;
2009
2010
  R: number;
2010
2011
  isAsking: string;
2011
- }, {}> | import("./exercises/exercise").Exercise<{
2012
+ }, {}> | Exercise<{
2012
2013
  ggbCommands: string[];
2013
2014
  type: string;
2014
- }, {}> | import("./exercises/exercise").Exercise<{
2015
+ }, {}> | Exercise<{
2015
2016
  isAsking: string;
2016
2017
  uAB: number;
2017
2018
  uED: number;
2018
2019
  uDC: number;
2019
- }, {}> | import("./exercises/exercise").Exercise<{
2020
+ }, {}> | Exercise<{
2020
2021
  l1: number;
2021
2022
  l2: number;
2022
2023
  isAsking: string;
2023
2024
  circuit: string;
2024
- }, {}> | import("./exercises/exercise").Exercise<{
2025
+ }, {}> | Exercise<{
2025
2026
  l1: number;
2026
2027
  l2: number;
2027
- }, {}> | import("./exercises/exercise").Exercise<{
2028
+ }, {}> | Exercise<{
2028
2029
  voltage: number;
2029
2030
  current: number;
2030
2031
  resistance: number;
2031
2032
  target: string;
2032
2033
  targetValue: number;
2033
- }, {}> | import("./exercises/exercise").Exercise<{
2034
+ }, {}> | Exercise<{
2034
2035
  power: number;
2035
2036
  seconds: number;
2036
2037
  energy: number;
2037
- }, {}> | import("./exercises/exercise").Exercise<{
2038
+ }, {}> | Exercise<{
2038
2039
  substance: string;
2039
2040
  mass: number;
2040
2041
  latentHeat: number;
2041
2042
  energy: number;
2042
- }, {}> | import("./exercises/exercise").Exercise<{
2043
+ }, {}> | Exercise<{
2043
2044
  isAsking: string;
2044
2045
  mass: number;
2045
2046
  velocity: number;
2046
2047
  kineticEnergy: number;
2047
- }, {}> | import("./exercises/exercise").Exercise<{
2048
+ }, {}> | Exercise<{
2048
2049
  entry: number;
2049
2050
  out: number;
2050
- }, {}> | import("./exercises/exercise").Exercise<{
2051
+ }, {}> | Exercise<{
2051
2052
  eComb: number;
2052
2053
  quantity: number;
2053
- }, {}> | import("./exercises/exercise").Exercise<{
2054
+ }, {}> | Exercise<{
2054
2055
  pc: number;
2055
2056
  mass: number;
2056
- }, {}> | import("./exercises/exercise").Exercise<{
2057
+ }, {}> | Exercise<{
2057
2058
  type: number;
2058
2059
  pc?: number | undefined;
2059
2060
  mass?: number | undefined;
2060
2061
  eComb?: number | undefined;
2061
2062
  quantity?: number | undefined;
2062
- }, {}> | import("./exercises/exercise").Exercise<{
2063
+ }, {}> | Exercise<{
2063
2064
  mass: number;
2064
2065
  specificHeat: number;
2065
2066
  initialTemp: number;
2066
2067
  finalTemp: number;
2067
2068
  variable: "c" | "m" | "E_th" | "deltaT";
2068
- }, {}> | import("./exercises/exercise").Exercise<{
2069
+ }, {}> | Exercise<{
2069
2070
  inputPower: number;
2070
2071
  outputPower: number;
2071
2072
  efficiency: number;
2072
2073
  variable: "P_in" | "P_out" | "η";
2073
- }, {}> | import("./exercises/exercise").Exercise<{
2074
+ }, {}> | Exercise<{
2074
2075
  norm: number;
2075
- }, {}> | import("./exercises/exercise").Exercise<{
2076
+ }, {}> | Exercise<{
2076
2077
  ggbCommands: string[];
2077
2078
  movementType: string;
2078
- }, {}> | import("./exercises/exercise").Exercise<{
2079
+ }, {}> | Exercise<{
2079
2080
  distance: {
2080
2081
  value: number;
2081
2082
  unitIndex: number;
@@ -2084,56 +2085,56 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
2084
2085
  value: number;
2085
2086
  unitIndex: number;
2086
2087
  };
2087
- }, {}> | import("./exercises/exercise").Exercise<{
2088
+ }, {}> | Exercise<{
2088
2089
  typeOfAcceleration: string;
2089
2090
  ggbCommands: string[];
2090
- }, {}> | import("./exercises/exercise").Exercise<{
2091
+ }, {}> | Exercise<{
2091
2092
  object1: string;
2092
2093
  object2: string;
2093
2094
  reference: "à l'autre" | "au sol";
2094
- }, {}> | import("./exercises/exercise").Exercise<{
2095
+ }, {}> | Exercise<{
2095
2096
  speed: number;
2096
2097
  distance: number;
2097
2098
  deltaTime: number;
2098
2099
  target: "distance" | "vitesse moyenne" | "temps";
2099
- }, {}> | import("./exercises/exercise").Exercise<{
2100
+ }, {}> | Exercise<{
2100
2101
  epsilon: number;
2101
2102
  l: number;
2102
2103
  molecule: string;
2103
- }, {}> | import("./exercises/exercise").Exercise<{
2104
+ }, {}> | Exercise<{
2104
2105
  moleculeName: string;
2105
2106
  concentration: number;
2106
2107
  molarAbsorptivity: number;
2107
2108
  pathLength: number;
2108
2109
  absorbance: number;
2109
2110
  randomIndex: number;
2110
- }, {}> | import("./exercises/exercise").Exercise<{
2111
+ }, {}> | Exercise<{
2111
2112
  concentration: number;
2112
2113
  quantity: number;
2113
2114
  volume: number;
2114
2115
  variable: "C" | "V" | "n";
2115
- }, {}> | import("./exercises/exercise").Exercise<{
2116
+ }, {}> | Exercise<{
2116
2117
  concentration: number;
2117
2118
  mass: number;
2118
2119
  molarMass: number;
2119
2120
  variable: "C" | "M" | "t";
2120
- }, {}> | import("./exercises/exercise").Exercise<{
2121
+ }, {}> | Exercise<{
2121
2122
  wavelengths: import("./pc/measure/measure").Measure<string>[];
2122
2123
  targetColor: "rouge" | "verte" | "bleue";
2123
2124
  energy: import("./pc/measure/measure").Measure<string>;
2124
- }, {}> | import("./exercises/exercise").Exercise<{
2125
+ }, {}> | Exercise<{
2125
2126
  atomicMass: number;
2126
2127
  atomicNumber: number;
2127
2128
  isAsking: string;
2128
2129
  symbol: string;
2129
- }, {}> | import("./exercises/exercise").Exercise<{
2130
+ }, {}> | Exercise<{
2130
2131
  commands: string[];
2131
- }, {}> | import("./exercises/exercise").Exercise<{
2132
+ }, {}> | Exercise<{
2132
2133
  order: number;
2133
2134
  multiplier: number;
2134
- }, {}> | import("./exercises/exercise").Exercise<{
2135
+ }, {}> | Exercise<{
2135
2136
  E: number;
2136
2137
  S: number;
2137
2138
  }, {}>)[];
2138
- export { mathExercises, pcExercises };
2139
+ export { mathExercises, pcExercises, Exercise, Question };
2139
2140
  //# sourceMappingURL=index.d.ts.map