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