math-exercises 3.0.130 → 3.0.132
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/exercise.d.ts +37 -30
- package/lib/exercises/exercise.d.ts.map +1 -1
- package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.d.ts +3 -3
- package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.d.ts.map +1 -1
- package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.js +48 -44
- package/lib/exercises/math/calcul/ordering/compareA10N.d.ts +1 -1
- package/lib/exercises/math/calcul/ordering/compareA10N.js +3 -3
- package/lib/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.d.ts.map +1 -1
- package/lib/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.js +0 -1
- package/lib/exercises/math/calcul/ordering/compareFracAndDec.d.ts +1 -1
- package/lib/exercises/math/calcul/ordering/compareFracAndDec.js +1 -1
- package/lib/exercises/math/calcul/proportionality/findCoeffInProportionalTableNonIntegers.js +1 -1
- package/lib/exercises/math/calcul/proportionality/isTableProportionalNonInteger.d.ts.map +1 -1
- package/lib/exercises/math/calcul/proportionality/isTableProportionalNonInteger.js +2 -0
- package/lib/exercises/math/calcul/rounding/rounding.d.ts +1 -1
- package/lib/exercises/math/calcul/rounding/rounding.d.ts.map +1 -1
- package/lib/exercises/math/calcul/rounding/rounding.js +7 -6
- package/lib/exercises/math/calculLitteral/equation/equationWithDistributivity.d.ts.map +1 -1
- package/lib/exercises/math/calculLitteral/equation/equationWithDistributivity.js +15 -11
- package/lib/exercises/math/calculLitteral/equation/multiplicationEquation.d.ts.map +1 -1
- package/lib/exercises/math/calculLitteral/equation/multiplicationEquation.js +6 -5
- package/lib/exercises/math/calculLitteral/factorisation/index.d.ts +0 -1
- package/lib/exercises/math/calculLitteral/factorisation/index.d.ts.map +1 -1
- package/lib/exercises/math/calculLitteral/factorisation/index.js +1 -1
- package/lib/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.d.ts.map +1 -1
- package/lib/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.js +15 -60
- package/lib/exercises/math/conversion/kmPerMinToKmPerHourConversion.js +14 -10
- package/lib/exercises/math/conversion/lengthConversion.d.ts.map +1 -1
- package/lib/exercises/math/conversion/lengthConversion.js +1 -0
- package/lib/exercises/math/conversion/prefixToNumber.d.ts.map +1 -1
- package/lib/exercises/math/conversion/prefixToNumber.js +10 -8
- package/lib/exercises/math/conversion/secondsToHours.js +1 -1
- package/lib/exercises/math/functions/affines/drawAffineFromPointAndLeadingCoeff.d.ts.map +1 -1
- package/lib/exercises/math/functions/affines/drawAffineFromPointAndLeadingCoeff.js +2 -1
- package/lib/exercises/math/functions/affines/drawAffineFromProgCalc.d.ts +1 -1
- package/lib/exercises/math/functions/affines/drawAffineFromProgCalc.d.ts.map +1 -1
- package/lib/exercises/math/functions/affines/drawAffineFromProgCalc.js +4 -5
- package/lib/exercises/math/functions/affines/leadingCoefficient.js +1 -1
- package/lib/exercises/math/geometry/angles/anglesUsingIsParallel.d.ts +1 -1
- package/lib/exercises/math/geometry/angles/anglesUsingIsParallel.d.ts.map +1 -1
- package/lib/exercises/math/geometry/angles/anglesUsingIsParallel.js +10 -11
- package/lib/exercises/math/geometry/angles/isParallelUsingAngles.d.ts +1 -1
- package/lib/exercises/math/geometry/angles/isParallelUsingAngles.d.ts.map +1 -1
- package/lib/exercises/math/geometry/angles/isParallelUsingAngles.js +8 -8
- package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.js +2 -2
- package/lib/exercises/math/percent/evolutions/evolutionRateFromValues.d.ts.map +1 -1
- package/lib/exercises/math/percent/evolutions/evolutionRateFromValues.js +29 -16
- package/lib/exercises/math/percent/evolutions/globalPercent.d.ts +4 -1
- package/lib/exercises/math/percent/evolutions/globalPercent.d.ts.map +1 -1
- package/lib/exercises/math/percent/evolutions/globalPercent.js +37 -21
- package/lib/exercises/math/percent/findProportion.d.ts +1 -5
- package/lib/exercises/math/percent/findProportion.d.ts.map +1 -1
- package/lib/exercises/math/percent/findProportion.js +67 -75
- package/lib/exercises/math/percent/percentToDecimal.d.ts +4 -1
- package/lib/exercises/math/percent/percentToDecimal.d.ts.map +1 -1
- package/lib/exercises/math/percent/percentToDecimal.js +55 -35
- package/lib/exercises/math/powers/calculateNegativePower.d.ts +1 -1
- package/lib/exercises/math/powers/calculateNegativePower.d.ts.map +1 -1
- package/lib/exercises/math/powers/calculateNegativePower.js +17 -10
- package/lib/exercises/math/probaStat/basicStats/calculateFrequencyInList.d.ts +5 -1
- package/lib/exercises/math/probaStat/basicStats/calculateFrequencyInList.d.ts.map +1 -1
- package/lib/exercises/math/probaStat/basicStats/calculateFrequencyInList.js +76 -12
- package/lib/exercises/math/probaStat/conditionalProbaWriteFromFrench.js +1 -1
- package/lib/exercises/math/probaStat/probaAsSumOfProbas.d.ts +3 -3
- package/lib/exercises/math/probaStat/probaAsSumOfProbas.d.ts.map +1 -1
- package/lib/exercises/math/probaStat/probaAsSumOfProbas.js +17 -45
- package/lib/exercises/math/probaStat/probaFromTableWithContext.d.ts +12 -5
- package/lib/exercises/math/probaStat/probaFromTableWithContext.d.ts.map +1 -1
- package/lib/exercises/math/probaStat/probaFromTableWithContext.js +354 -94
- package/lib/exercises/math/probaStat/randomVariable/randomVariableAverage.js +1 -1
- package/lib/exercises/math/probaStat/stats1var/medianWithList.d.ts +4 -1
- package/lib/exercises/math/probaStat/stats1var/medianWithList.d.ts.map +1 -1
- package/lib/exercises/math/probaStat/stats1var/medianWithList.js +43 -23
- package/lib/exercises/math/probaStat/stats1var/quartilesList.d.ts +1 -1
- package/lib/exercises/math/probaStat/stats1var/quartilesList.d.ts.map +1 -1
- package/lib/exercises/math/probaStat/stats1var/quartilesList.js +4 -4
- package/lib/exercises/pc/motion/averageSpeed.d.ts.map +1 -1
- package/lib/exercises/pc/motion/averageSpeed.js +13 -10
- package/lib/exercises/pc/optics/lensFormula.d.ts +1 -2
- package/lib/exercises/pc/optics/lensFormula.d.ts.map +1 -1
- package/lib/exercises/pc/optics/lensFormula.js +7 -10
- package/lib/exercises/pc/weight/calculateWeight.d.ts +1 -2
- package/lib/exercises/pc/weight/calculateWeight.d.ts.map +1 -1
- package/lib/exercises/pc/weight/calculateWeight.js +15 -14
- package/lib/exercises/vea/isNodesEqual.d.ts +3 -0
- package/lib/exercises/vea/isNodesEqual.d.ts.map +1 -0
- package/lib/exercises/vea/isNodesEqual.js +6 -0
- package/lib/exercises/vea/setVEA.d.ts +5 -0
- package/lib/exercises/vea/setVEA.d.ts.map +1 -0
- package/lib/exercises/vea/setVEA.js +25 -0
- package/lib/index.d.ts +932 -934
- package/lib/index.d.ts.map +1 -1
- package/lib/math/progCalc/progCalc.d.ts +2 -2
- package/lib/math/progCalc/progCalc.d.ts.map +1 -1
- package/lib/math/progCalc/progCalc.js +4 -11
- package/lib/tests/exoTest.d.ts.map +1 -1
- package/lib/tests/exoTest.js +13 -0
- package/lib/types/keyIds.d.ts +1 -1
- package/lib/types/keyIds.d.ts.map +1 -1
- package/package.json +1 -1
package/lib/index.d.ts
CHANGED
|
@@ -6,170 +6,170 @@ declare const mathExercises: (Exercise<{
|
|
|
6
6
|
numbers: number[];
|
|
7
7
|
}, {
|
|
8
8
|
explicitWriting?: string;
|
|
9
|
-
}
|
|
9
|
+
}> | Exercise<{
|
|
10
10
|
numbers: number[];
|
|
11
|
-
},
|
|
11
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
12
12
|
dividend: number;
|
|
13
13
|
divisor: number;
|
|
14
14
|
quotient: number;
|
|
15
15
|
remainder: number;
|
|
16
|
-
},
|
|
16
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
17
17
|
type: number;
|
|
18
|
-
},
|
|
18
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
19
19
|
nb: number;
|
|
20
20
|
}, {
|
|
21
21
|
asPowers?: boolean;
|
|
22
|
-
}
|
|
22
|
+
}> | Exercise<{
|
|
23
23
|
a: number;
|
|
24
24
|
b: number;
|
|
25
|
-
},
|
|
25
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
26
26
|
a: number;
|
|
27
|
-
},
|
|
27
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
28
28
|
a: number;
|
|
29
29
|
b: number;
|
|
30
|
-
},
|
|
30
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
31
31
|
nb: number;
|
|
32
32
|
divisor: number;
|
|
33
|
-
},
|
|
33
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
34
34
|
a: number;
|
|
35
35
|
b: number;
|
|
36
|
-
},
|
|
36
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
37
37
|
a: number;
|
|
38
38
|
b: number;
|
|
39
39
|
isAskingParity: boolean;
|
|
40
|
-
},
|
|
40
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
41
41
|
n: number;
|
|
42
|
-
},
|
|
42
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
43
43
|
n: number;
|
|
44
44
|
threshold: number;
|
|
45
45
|
mode: "sup\u00E9rieur" | "inf\u00E9rieur";
|
|
46
|
-
},
|
|
46
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
47
47
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
48
48
|
b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
49
|
-
},
|
|
49
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
50
50
|
integerFirst: boolean;
|
|
51
51
|
integer: number;
|
|
52
52
|
rational: number[];
|
|
53
|
-
},
|
|
53
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
54
54
|
integer: number;
|
|
55
55
|
rational: number[];
|
|
56
56
|
integerFirst: boolean;
|
|
57
57
|
}, {
|
|
58
58
|
allowNonIrreductible?: boolean;
|
|
59
|
-
}
|
|
59
|
+
}> | Exercise<{
|
|
60
60
|
isIntegerFirst: boolean;
|
|
61
61
|
integer: number;
|
|
62
62
|
rational: [number, number];
|
|
63
63
|
}, {
|
|
64
64
|
allowNonIrreductible?: boolean;
|
|
65
|
-
}
|
|
65
|
+
}> | Exercise<{
|
|
66
66
|
rand: number;
|
|
67
67
|
numerator: number;
|
|
68
68
|
denominator: number;
|
|
69
|
-
},
|
|
69
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
70
70
|
rationalNum: number[];
|
|
71
71
|
rationalDenum: number[];
|
|
72
72
|
}, {
|
|
73
73
|
allowNonIrreductible?: boolean;
|
|
74
|
-
}
|
|
74
|
+
}> | Exercise<{
|
|
75
75
|
rationalNum: number[];
|
|
76
76
|
rationalDenum: number[];
|
|
77
77
|
}, {
|
|
78
78
|
allowNonIrreductible?: boolean;
|
|
79
|
-
}
|
|
79
|
+
}> | Exercise<{
|
|
80
80
|
rational: number[];
|
|
81
81
|
rational2: number[];
|
|
82
82
|
}, {
|
|
83
83
|
allowNonIrreductible?: boolean;
|
|
84
|
-
}
|
|
84
|
+
}> | Exercise<{
|
|
85
85
|
num: number;
|
|
86
86
|
denum: number;
|
|
87
|
-
},
|
|
87
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
88
88
|
num: number;
|
|
89
89
|
denum: number;
|
|
90
90
|
}, {
|
|
91
91
|
withoutGivenPrimeFactors?: boolean;
|
|
92
|
-
}
|
|
92
|
+
}> | Exercise<{
|
|
93
93
|
num: number;
|
|
94
94
|
denum: number;
|
|
95
95
|
leadingPart: number;
|
|
96
96
|
periodicPart: number[];
|
|
97
|
-
},
|
|
97
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
98
98
|
denom: number;
|
|
99
99
|
num1: number;
|
|
100
100
|
num2: number;
|
|
101
|
-
},
|
|
101
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
102
102
|
num1: number;
|
|
103
103
|
num2: number;
|
|
104
104
|
denom1: number;
|
|
105
105
|
denom2: number;
|
|
106
106
|
}, {
|
|
107
107
|
allowNonIrreductible?: boolean;
|
|
108
|
-
}
|
|
108
|
+
}> | Exercise<{
|
|
109
109
|
num1: number;
|
|
110
110
|
num2: number;
|
|
111
111
|
denom1: number;
|
|
112
112
|
denom2: number;
|
|
113
|
-
},
|
|
113
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
114
114
|
statementIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
115
|
-
},
|
|
115
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
116
116
|
num: number;
|
|
117
117
|
denum: number;
|
|
118
|
-
},
|
|
118
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
119
119
|
frac1: number[];
|
|
120
120
|
frac2: number[];
|
|
121
121
|
}, {
|
|
122
122
|
allowNonIrreductible?: boolean;
|
|
123
|
-
}
|
|
123
|
+
}> | Exercise<{
|
|
124
124
|
a: number;
|
|
125
125
|
b: number;
|
|
126
126
|
c: number;
|
|
127
127
|
d: number;
|
|
128
|
-
},
|
|
128
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
129
129
|
type: number;
|
|
130
130
|
expr: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
131
|
-
},
|
|
131
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
132
132
|
expr: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
133
133
|
x: number;
|
|
134
|
-
},
|
|
134
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
135
135
|
type: number;
|
|
136
136
|
a: number;
|
|
137
137
|
b: number;
|
|
138
138
|
c: number;
|
|
139
139
|
d: number;
|
|
140
140
|
e: number;
|
|
141
|
-
},
|
|
141
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
142
142
|
numbers: number[];
|
|
143
|
-
},
|
|
143
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
144
144
|
rand: number;
|
|
145
145
|
a: number;
|
|
146
146
|
b: number;
|
|
147
147
|
c: number;
|
|
148
|
-
},
|
|
148
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
149
149
|
numbers: number[];
|
|
150
|
-
},
|
|
150
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
151
151
|
rand: number;
|
|
152
152
|
a: number;
|
|
153
153
|
b: number;
|
|
154
|
-
},
|
|
154
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
155
155
|
numbers: number[];
|
|
156
|
-
},
|
|
156
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
157
157
|
numbers: number[];
|
|
158
|
-
},
|
|
158
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
159
159
|
nodeIdsStartingNumber: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
160
160
|
progCalcIds: import("./math/progCalc/progCalc.js").ProgCalcIdentifiers;
|
|
161
161
|
}, {
|
|
162
|
-
numberType: "
|
|
163
|
-
nbSteps:
|
|
164
|
-
nbDigits:
|
|
165
|
-
}
|
|
162
|
+
numberType: "Integer" | "Decimal";
|
|
163
|
+
nbSteps: string;
|
|
164
|
+
nbDigits: string;
|
|
165
|
+
}> | Exercise<{
|
|
166
166
|
type: number;
|
|
167
167
|
a: number;
|
|
168
168
|
b: number;
|
|
169
169
|
c: number;
|
|
170
170
|
d: number | undefined;
|
|
171
171
|
statementIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
172
|
-
},
|
|
172
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
173
173
|
type: number;
|
|
174
174
|
flip: number;
|
|
175
175
|
subFlip: boolean;
|
|
@@ -177,37 +177,37 @@ declare const mathExercises: (Exercise<{
|
|
|
177
177
|
b: number;
|
|
178
178
|
c: number;
|
|
179
179
|
d: number;
|
|
180
|
-
},
|
|
180
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
181
181
|
nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
182
182
|
type: number;
|
|
183
183
|
subType: number;
|
|
184
|
-
},
|
|
184
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
185
185
|
nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
186
186
|
type: number;
|
|
187
|
-
},
|
|
187
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
188
188
|
nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
189
189
|
type: number;
|
|
190
|
-
},
|
|
190
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
191
191
|
nb: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
192
|
-
},
|
|
192
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
193
193
|
randQuation: number;
|
|
194
194
|
x1: string | number;
|
|
195
195
|
x2: string | number;
|
|
196
196
|
x3: string | number;
|
|
197
197
|
x4: string | number;
|
|
198
|
-
},
|
|
198
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
199
199
|
xValues: number[];
|
|
200
200
|
yValues: number[];
|
|
201
|
-
},
|
|
201
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
202
202
|
scale: number;
|
|
203
203
|
isSmallScale: boolean;
|
|
204
204
|
fakeDistance: number;
|
|
205
|
-
},
|
|
205
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
206
206
|
scale: number;
|
|
207
207
|
isSmallScale: boolean;
|
|
208
208
|
isFakeAsked: boolean;
|
|
209
209
|
fakeDistance: number;
|
|
210
|
-
},
|
|
210
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
211
211
|
coeffIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
212
212
|
xValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
213
213
|
yValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
@@ -217,7 +217,7 @@ declare const mathExercises: (Exercise<{
|
|
|
217
217
|
}, {
|
|
218
218
|
coeffNumberTypes: string[];
|
|
219
219
|
valuesNumberTypes: string[];
|
|
220
|
-
}
|
|
220
|
+
}> | Exercise<{
|
|
221
221
|
coeffIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
222
222
|
xValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
223
223
|
yValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
@@ -226,55 +226,55 @@ declare const mathExercises: (Exercise<{
|
|
|
226
226
|
}, {
|
|
227
227
|
coeffNumberTypes: string[];
|
|
228
228
|
valuesNumberTypes: string[];
|
|
229
|
-
}
|
|
229
|
+
}> | Exercise<{
|
|
230
230
|
xValues: number[];
|
|
231
231
|
yValues: number[];
|
|
232
|
-
},
|
|
232
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
233
233
|
lengths: number[];
|
|
234
|
-
},
|
|
234
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
235
235
|
precisionAsked: number;
|
|
236
236
|
decimal: number;
|
|
237
237
|
precision: number;
|
|
238
238
|
}, {
|
|
239
|
-
precisionAsked:
|
|
240
|
-
}
|
|
239
|
+
precisionAsked: string;
|
|
240
|
+
}> | Exercise<{
|
|
241
241
|
factIndex: number;
|
|
242
|
-
},
|
|
242
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
243
243
|
n: number;
|
|
244
244
|
varName: string;
|
|
245
|
-
},
|
|
245
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
246
246
|
n: number;
|
|
247
247
|
c: number;
|
|
248
248
|
d: number;
|
|
249
|
-
},
|
|
249
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
250
250
|
nb: number;
|
|
251
251
|
rankAsked: number;
|
|
252
|
-
},
|
|
252
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
253
253
|
nb: string;
|
|
254
254
|
rankAsked: number;
|
|
255
|
-
},
|
|
255
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
256
256
|
nb: number;
|
|
257
257
|
rankAsked: number;
|
|
258
|
-
},
|
|
258
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
259
259
|
nb: number;
|
|
260
260
|
rankAsked: number;
|
|
261
|
-
},
|
|
261
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
262
262
|
a: number;
|
|
263
263
|
b: number;
|
|
264
|
-
},
|
|
264
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
265
265
|
type: number;
|
|
266
266
|
a: number;
|
|
267
267
|
b: number;
|
|
268
|
-
},
|
|
268
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
269
269
|
type: number;
|
|
270
270
|
nbIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
271
271
|
nbValue: number;
|
|
272
272
|
pow: number;
|
|
273
|
-
},
|
|
273
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
274
274
|
type: number;
|
|
275
275
|
a: number;
|
|
276
276
|
b: number;
|
|
277
|
-
},
|
|
277
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
278
278
|
questionParams: {
|
|
279
279
|
letter: string;
|
|
280
280
|
trueName: string;
|
|
@@ -288,9 +288,9 @@ declare const mathExercises: (Exercise<{
|
|
|
288
288
|
}[];
|
|
289
289
|
}, {
|
|
290
290
|
isUseABC: boolean;
|
|
291
|
-
nbDecimalFormat:
|
|
291
|
+
nbDecimalFormat: string;
|
|
292
292
|
isAllowingNegativeNumbers: boolean;
|
|
293
|
-
}
|
|
293
|
+
}> | Exercise<{
|
|
294
294
|
signType: string;
|
|
295
295
|
a10Ns: {
|
|
296
296
|
a: number;
|
|
@@ -302,142 +302,142 @@ declare const mathExercises: (Exercise<{
|
|
|
302
302
|
}[];
|
|
303
303
|
}, {
|
|
304
304
|
signTypes: string[];
|
|
305
|
-
nbCollisions:
|
|
306
|
-
}
|
|
305
|
+
nbCollisions: string[];
|
|
306
|
+
}> | Exercise<{
|
|
307
307
|
orderedNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
308
|
-
},
|
|
308
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
309
309
|
items: {
|
|
310
310
|
name: string;
|
|
311
311
|
nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
312
312
|
}[];
|
|
313
|
-
},
|
|
313
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
314
314
|
nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
315
315
|
texAnswers: string[];
|
|
316
316
|
}, {
|
|
317
317
|
isFracOfSums: boolean;
|
|
318
|
-
}
|
|
318
|
+
}> | Exercise<{
|
|
319
319
|
a: number;
|
|
320
320
|
b: number;
|
|
321
321
|
isAdd: boolean;
|
|
322
|
-
},
|
|
322
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
323
323
|
dec: number;
|
|
324
324
|
pow: number;
|
|
325
325
|
isDivide: boolean;
|
|
326
|
-
},
|
|
326
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
327
327
|
dec: number;
|
|
328
328
|
pow: number;
|
|
329
|
-
},
|
|
329
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
330
330
|
point: import("./math/geometry/point.js").PointIdentifiers;
|
|
331
331
|
bounding: number;
|
|
332
|
-
},
|
|
332
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
333
333
|
choices: {
|
|
334
334
|
node: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
335
335
|
irrationalUsed: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers | null;
|
|
336
336
|
}[];
|
|
337
|
-
},
|
|
337
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
338
338
|
a: number;
|
|
339
339
|
sign: number;
|
|
340
|
-
},
|
|
340
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
341
341
|
n: number;
|
|
342
|
-
},
|
|
342
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
343
343
|
a: number;
|
|
344
344
|
isOpposite: boolean;
|
|
345
|
-
},
|
|
345
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
346
346
|
a: number;
|
|
347
347
|
b: number;
|
|
348
|
-
},
|
|
348
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
349
349
|
a: number;
|
|
350
350
|
b: number;
|
|
351
|
-
},
|
|
351
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
352
352
|
affine1Coeffs: number[];
|
|
353
353
|
affine2Coeffs: number[];
|
|
354
|
-
},
|
|
354
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
355
355
|
type: number;
|
|
356
356
|
a?: number;
|
|
357
357
|
b?: number;
|
|
358
358
|
affine1Coeffs?: number[];
|
|
359
359
|
affine2Coeffs?: number[];
|
|
360
|
-
},
|
|
360
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
361
361
|
affine1Coeffs: number[];
|
|
362
362
|
affine2Coeffs: number[];
|
|
363
|
-
},
|
|
363
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
364
364
|
a: number;
|
|
365
365
|
b: number;
|
|
366
366
|
coeff: number;
|
|
367
|
-
},
|
|
367
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
368
368
|
coeff: number;
|
|
369
369
|
affine1: number[];
|
|
370
370
|
affine2: number[];
|
|
371
|
-
},
|
|
371
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
372
372
|
coeffs: number[];
|
|
373
|
-
},
|
|
373
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
374
374
|
a: number;
|
|
375
375
|
b: number;
|
|
376
376
|
c: number;
|
|
377
|
-
},
|
|
377
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
378
378
|
type: number;
|
|
379
379
|
affine1: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
|
|
380
380
|
affine2: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
|
|
381
381
|
affine3: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
|
|
382
382
|
affine4?: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
|
|
383
|
-
},
|
|
383
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
384
384
|
type: number;
|
|
385
385
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
386
386
|
b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
387
|
-
},
|
|
387
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
388
388
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
389
389
|
b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
390
390
|
isAdd: boolean;
|
|
391
|
-
},
|
|
391
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
392
392
|
randNbr: number;
|
|
393
|
-
},
|
|
393
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
394
394
|
a: number;
|
|
395
395
|
b: number;
|
|
396
|
-
},
|
|
396
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
397
397
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
398
398
|
b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
399
399
|
isXRight: boolean;
|
|
400
400
|
aNumberType: string;
|
|
401
401
|
}, {
|
|
402
402
|
aNumberType: string[];
|
|
403
|
-
}
|
|
403
|
+
}> | Exercise<{
|
|
404
404
|
a: number;
|
|
405
405
|
b: number;
|
|
406
406
|
c: number;
|
|
407
|
-
},
|
|
407
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
408
408
|
a: number;
|
|
409
409
|
b: number;
|
|
410
410
|
c: number;
|
|
411
411
|
d: number;
|
|
412
|
-
},
|
|
412
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
413
413
|
a: number;
|
|
414
414
|
b: number;
|
|
415
415
|
c: number;
|
|
416
416
|
d: number;
|
|
417
|
-
},
|
|
417
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
418
418
|
a: number;
|
|
419
419
|
b: number;
|
|
420
420
|
c: number;
|
|
421
421
|
d: number;
|
|
422
|
-
},
|
|
422
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
423
423
|
a: number;
|
|
424
424
|
b: number;
|
|
425
|
-
},
|
|
425
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
426
426
|
a: number;
|
|
427
427
|
b: number;
|
|
428
428
|
x: number;
|
|
429
|
-
},
|
|
429
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
430
430
|
a: number;
|
|
431
431
|
x: number;
|
|
432
432
|
b: number;
|
|
433
433
|
c: number;
|
|
434
|
-
},
|
|
434
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
435
435
|
a: number;
|
|
436
436
|
x: number;
|
|
437
437
|
b: number;
|
|
438
438
|
c: number;
|
|
439
439
|
d: number;
|
|
440
|
-
},
|
|
440
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
441
441
|
type: number;
|
|
442
442
|
vars: {
|
|
443
443
|
flip: boolean;
|
|
@@ -445,12 +445,12 @@ declare const mathExercises: (Exercise<{
|
|
|
445
445
|
randAdd?: number;
|
|
446
446
|
op2?: string;
|
|
447
447
|
};
|
|
448
|
-
},
|
|
448
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
449
449
|
solutionNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
450
450
|
equationNodeIds: import("./tree/nodes/equations/equalNode.js").EqualNodeIdentifiers;
|
|
451
451
|
}, {
|
|
452
452
|
degree: string;
|
|
453
|
-
}
|
|
453
|
+
}> | Exercise<{
|
|
454
454
|
type: number;
|
|
455
455
|
a: number;
|
|
456
456
|
b: number;
|
|
@@ -460,74 +460,69 @@ declare const mathExercises: (Exercise<{
|
|
|
460
460
|
f: number;
|
|
461
461
|
}, {
|
|
462
462
|
integerSolutions: boolean;
|
|
463
|
-
}
|
|
463
|
+
}> | Exercise<{
|
|
464
464
|
a: number;
|
|
465
465
|
b: number;
|
|
466
466
|
c?: number;
|
|
467
467
|
type: number;
|
|
468
|
-
},
|
|
468
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
469
469
|
a: number;
|
|
470
470
|
isSum: boolean;
|
|
471
471
|
b: number;
|
|
472
|
-
},
|
|
472
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
473
473
|
problemSkeletonIndex: number;
|
|
474
474
|
groupNameToVarNameToValue: Record<string, Record<string, import("./tree/nodes/algebraicNode.js").AlgebraicNode>>;
|
|
475
475
|
mysteryVarPath: string;
|
|
476
476
|
shuffleArrays: number[][];
|
|
477
477
|
equalNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
478
|
-
},
|
|
478
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
479
479
|
a: number;
|
|
480
480
|
b: number;
|
|
481
|
-
},
|
|
481
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
482
482
|
a: number;
|
|
483
483
|
b: number;
|
|
484
|
-
},
|
|
484
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
485
485
|
affine1Coeffs: number[];
|
|
486
486
|
affine2Coeffs: number[];
|
|
487
|
-
},
|
|
487
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
488
488
|
affinesCoeffs: number[][];
|
|
489
489
|
operation: string;
|
|
490
490
|
affinesOrder: number[];
|
|
491
|
-
},
|
|
491
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
492
492
|
a: number;
|
|
493
493
|
b: number;
|
|
494
|
-
},
|
|
494
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
495
495
|
a: number;
|
|
496
496
|
bOperand: number;
|
|
497
|
-
},
|
|
497
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
498
498
|
a: number;
|
|
499
499
|
b: number;
|
|
500
500
|
c: number;
|
|
501
501
|
d: number;
|
|
502
502
|
isSubstract: boolean;
|
|
503
|
-
},
|
|
503
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
504
504
|
a: number;
|
|
505
505
|
b: number;
|
|
506
|
-
},
|
|
507
|
-
a: number;
|
|
508
|
-
b: number;
|
|
509
|
-
isAdd: boolean;
|
|
510
|
-
varName: string;
|
|
511
|
-
}, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
|
|
506
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
512
507
|
b: number;
|
|
513
508
|
c: number;
|
|
514
509
|
ineqType: import("./math/inequations/inequation.js").InegalitySymbols;
|
|
515
510
|
}, {
|
|
516
511
|
inequationSolutionFormat: string;
|
|
517
|
-
}
|
|
512
|
+
}> | Exercise<{
|
|
518
513
|
a: number;
|
|
519
514
|
b: number;
|
|
520
515
|
ineqType: import("./math/inequations/inequation.js").InegalitySymbols;
|
|
521
516
|
}, {
|
|
522
517
|
inequationSolutionFormat: string;
|
|
523
|
-
}
|
|
518
|
+
}> | Exercise<{
|
|
524
519
|
ineqType: import("./math/inequations/inequation.js").InegalitySymbols;
|
|
525
520
|
a: number;
|
|
526
521
|
b: number;
|
|
527
522
|
c: number;
|
|
528
523
|
}, {
|
|
529
524
|
inequationSolutionFormat: string;
|
|
530
|
-
}
|
|
525
|
+
}> | Exercise<{
|
|
531
526
|
coeff: number;
|
|
532
527
|
ineqType: import("./math/inequations/inequation.js").InegalitySymbols;
|
|
533
528
|
a: number;
|
|
@@ -536,25 +531,25 @@ declare const mathExercises: (Exercise<{
|
|
|
536
531
|
d: number;
|
|
537
532
|
}, {
|
|
538
533
|
inequationSolutionFormat: string;
|
|
539
|
-
}
|
|
534
|
+
}> | Exercise<{
|
|
540
535
|
k: number;
|
|
541
536
|
inequationSymbol: import("./math/inequations/inequation.js").InegalitySymbols;
|
|
542
|
-
},
|
|
537
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
543
538
|
k: number;
|
|
544
539
|
inequationSymbol: import("./math/inequations/inequation.js").InegalitySymbols;
|
|
545
|
-
},
|
|
540
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
546
541
|
a: number;
|
|
547
542
|
lt: boolean;
|
|
548
543
|
b: number;
|
|
549
544
|
isStrict: boolean;
|
|
550
|
-
},
|
|
545
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
551
546
|
aLimit: number;
|
|
552
547
|
bLimit: number;
|
|
553
548
|
x: number;
|
|
554
549
|
y: number;
|
|
555
550
|
case: "lt" | "lte" | "lt_gt";
|
|
556
551
|
expressionToCheck: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
557
|
-
},
|
|
552
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
558
553
|
a: number;
|
|
559
554
|
b: number;
|
|
560
555
|
c: number;
|
|
@@ -564,19 +559,19 @@ declare const mathExercises: (Exercise<{
|
|
|
564
559
|
right: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
565
560
|
inequalitySign: boolean;
|
|
566
561
|
isStrict: boolean;
|
|
567
|
-
},
|
|
562
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
568
563
|
k: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
569
564
|
inequationSymbol: import("./math/inequations/inequation.js").InegalitySymbols;
|
|
570
|
-
},
|
|
565
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
571
566
|
rand: boolean;
|
|
572
567
|
poly1: number[];
|
|
573
568
|
poly2: number[];
|
|
574
569
|
xValue: number;
|
|
575
|
-
},
|
|
570
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
576
571
|
variable: string;
|
|
577
572
|
coeffs: number[][];
|
|
578
573
|
order: number[];
|
|
579
|
-
},
|
|
574
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
580
575
|
firstTermIsAffine: boolean;
|
|
581
576
|
a: number;
|
|
582
577
|
b: number;
|
|
@@ -585,164 +580,164 @@ declare const mathExercises: (Exercise<{
|
|
|
585
580
|
e: number;
|
|
586
581
|
f: number;
|
|
587
582
|
g: number;
|
|
588
|
-
},
|
|
583
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
589
584
|
xValue: number;
|
|
590
585
|
a: number;
|
|
591
586
|
b: number;
|
|
592
587
|
monomFirst: boolean;
|
|
593
|
-
},
|
|
588
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
594
589
|
a: number;
|
|
595
590
|
b: number;
|
|
596
591
|
items: {
|
|
597
592
|
tex: string;
|
|
598
593
|
isValidAnswer: boolean;
|
|
599
594
|
}[];
|
|
600
|
-
},
|
|
595
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
601
596
|
items: {
|
|
602
597
|
tex: string;
|
|
603
598
|
isValidAnswer: boolean;
|
|
604
599
|
}[];
|
|
605
|
-
},
|
|
600
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
606
601
|
a: number;
|
|
607
602
|
b: number;
|
|
608
603
|
items: {
|
|
609
604
|
tex: string;
|
|
610
605
|
isValidAnswer: boolean;
|
|
611
606
|
}[];
|
|
612
|
-
},
|
|
607
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
613
608
|
items: {
|
|
614
609
|
tex: string;
|
|
615
610
|
isValidAnswer: boolean;
|
|
616
611
|
}[];
|
|
617
|
-
},
|
|
612
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
618
613
|
nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
619
|
-
},
|
|
614
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
620
615
|
coeffsIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[][];
|
|
621
|
-
},
|
|
616
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
622
617
|
coeffsIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[][];
|
|
623
|
-
},
|
|
618
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
624
619
|
sysIds: import("./math/systems/generalSystem.js").GeneralSystemIdentifiers;
|
|
625
620
|
x: number;
|
|
626
621
|
y: number;
|
|
627
|
-
},
|
|
622
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
628
623
|
varNames: string[];
|
|
629
|
-
},
|
|
624
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
630
625
|
varNames: string[];
|
|
631
|
-
},
|
|
626
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
632
627
|
operatorName: "opposite" | "inverse" | "add" | "subtract" | "multiply" | "divide";
|
|
633
628
|
a: number | string;
|
|
634
629
|
b: number | string | undefined;
|
|
635
630
|
isUsingFrenchFactorNouns: boolean;
|
|
636
|
-
},
|
|
631
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
637
632
|
formulaId: string;
|
|
638
633
|
values: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
639
|
-
},
|
|
634
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
640
635
|
names: string[];
|
|
641
636
|
texInstruction: string;
|
|
642
637
|
texsCorrection: string[];
|
|
643
638
|
texsAnswer: string[];
|
|
644
|
-
},
|
|
639
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
645
640
|
names: string[];
|
|
646
641
|
texInstruction: string;
|
|
647
642
|
texAnswers: string[];
|
|
648
|
-
},
|
|
643
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
649
644
|
word: string;
|
|
650
|
-
},
|
|
645
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
651
646
|
type: number;
|
|
652
647
|
reds: number;
|
|
653
648
|
greens: number;
|
|
654
649
|
blacks: number;
|
|
655
|
-
},
|
|
650
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
656
651
|
type: number;
|
|
657
652
|
face1?: number;
|
|
658
653
|
face2?: number;
|
|
659
654
|
face3?: number;
|
|
660
|
-
},
|
|
655
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
661
656
|
z1Re: number;
|
|
662
657
|
z1Im: number;
|
|
663
658
|
z2Re: number;
|
|
664
659
|
z2Im: number;
|
|
665
|
-
},
|
|
660
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
666
661
|
re: number;
|
|
667
662
|
im: number;
|
|
668
|
-
},
|
|
663
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
669
664
|
z1: number[];
|
|
670
665
|
z2: number[];
|
|
671
|
-
},
|
|
666
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
672
667
|
z1: number[];
|
|
673
668
|
z2: number[];
|
|
674
|
-
},
|
|
669
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
675
670
|
z1: number[];
|
|
676
671
|
z2: number[];
|
|
677
|
-
},
|
|
672
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
678
673
|
re: number;
|
|
679
674
|
im: number;
|
|
680
|
-
},
|
|
675
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
681
676
|
a: number;
|
|
682
677
|
b: number;
|
|
683
678
|
z1: number[];
|
|
684
679
|
z2: number[];
|
|
685
|
-
},
|
|
680
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
686
681
|
re: number;
|
|
687
682
|
im: number;
|
|
688
|
-
},
|
|
683
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
689
684
|
z1: number[];
|
|
690
685
|
z2: number[];
|
|
691
|
-
},
|
|
686
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
692
687
|
re: number;
|
|
693
688
|
im: number;
|
|
694
689
|
isRe: boolean;
|
|
695
|
-
},
|
|
690
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
696
691
|
arg: number;
|
|
697
692
|
zTex: string;
|
|
698
|
-
},
|
|
693
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
699
694
|
randomUnitIndex: number;
|
|
700
695
|
randomUnitInstructionIndex: number;
|
|
701
696
|
randomAera: number;
|
|
702
|
-
},
|
|
697
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
703
698
|
randomUnitIndex: number;
|
|
704
699
|
randomUnitInstructionIndex: number;
|
|
705
700
|
randomCapacity: number;
|
|
706
|
-
},
|
|
701
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
707
702
|
randomUnitIndex: number;
|
|
708
703
|
randomUnitInstructionIndex: number;
|
|
709
704
|
randomLength: number;
|
|
710
705
|
}, {
|
|
711
706
|
units: string[];
|
|
712
|
-
}
|
|
707
|
+
}> | Exercise<{
|
|
713
708
|
randomUnitIndex: number;
|
|
714
709
|
randomUnitInstructionIndex: number;
|
|
715
710
|
randomMass: number;
|
|
716
|
-
},
|
|
711
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
717
712
|
randomUnitIndex: number;
|
|
718
713
|
randomUnitInstructionIndex: number;
|
|
719
714
|
randomValue: number;
|
|
720
715
|
isVolumeToCapacity: boolean;
|
|
721
|
-
},
|
|
716
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
722
717
|
randomUnitIndex: number;
|
|
723
718
|
randomUnitInstructionIndex: number;
|
|
724
719
|
randomVolume: number;
|
|
725
|
-
},
|
|
720
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
726
721
|
dec: number;
|
|
727
722
|
isDecimalToHours: boolean;
|
|
728
|
-
},
|
|
723
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
729
724
|
hours: number;
|
|
730
725
|
mins: number;
|
|
731
726
|
seconds: number;
|
|
732
|
-
},
|
|
727
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
733
728
|
isMinutesToHours: boolean;
|
|
734
729
|
nodeIdsMinutes: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
735
730
|
nodeIdsHours: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
736
|
-
},
|
|
731
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
737
732
|
distance: number;
|
|
738
733
|
minutes: number;
|
|
739
734
|
}, {
|
|
740
735
|
unitTex: string;
|
|
741
|
-
}
|
|
736
|
+
}> | Exercise<{
|
|
742
737
|
isSecondsToHours: boolean;
|
|
743
738
|
nodeIdsSeconds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
744
739
|
nodeIdsHours: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
745
|
-
},
|
|
740
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
746
741
|
prefixIndexesPool: number[];
|
|
747
742
|
prefixIndex: number;
|
|
748
743
|
isToPow10: boolean;
|
|
@@ -751,241 +746,241 @@ declare const mathExercises: (Exercise<{
|
|
|
751
746
|
prefixPool: string[];
|
|
752
747
|
isToPow10: boolean;
|
|
753
748
|
isFromSymbol: boolean;
|
|
754
|
-
}
|
|
749
|
+
}> | Exercise<{
|
|
755
750
|
point: import("./math/geometry/point.js").PointIdentifiers;
|
|
756
|
-
},
|
|
751
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
757
752
|
point: import("./math/geometry/point.js").PointIdentifiers;
|
|
758
|
-
},
|
|
753
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
759
754
|
a: number;
|
|
760
|
-
},
|
|
755
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
761
756
|
poly1Coeffs: number[];
|
|
762
757
|
poly2Coeffs: number[];
|
|
763
|
-
},
|
|
758
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
764
759
|
poly1Coeffs: number[];
|
|
765
760
|
poly2Coeffs: number[];
|
|
766
|
-
},
|
|
761
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
767
762
|
a: number;
|
|
768
763
|
b: number;
|
|
769
|
-
},
|
|
764
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
770
765
|
a: number;
|
|
771
766
|
b: number;
|
|
772
|
-
},
|
|
767
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
773
768
|
a: number;
|
|
774
769
|
b: number;
|
|
775
|
-
},
|
|
770
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
776
771
|
affine1Coeffs: number[];
|
|
777
772
|
affine2Coeffs: number[];
|
|
778
|
-
},
|
|
773
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
779
774
|
coeffs: number[];
|
|
780
|
-
},
|
|
775
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
781
776
|
a: number;
|
|
782
777
|
b: number;
|
|
783
|
-
},
|
|
778
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
784
779
|
a: number;
|
|
785
780
|
b: number;
|
|
786
|
-
},
|
|
781
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
787
782
|
a: number;
|
|
788
783
|
b: number;
|
|
789
|
-
},
|
|
784
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
790
785
|
coefficients: number[];
|
|
791
|
-
},
|
|
786
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
792
787
|
coefficients: number[];
|
|
793
|
-
},
|
|
788
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
794
789
|
tex: string;
|
|
795
|
-
},
|
|
790
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
796
791
|
a: number;
|
|
797
792
|
b: number;
|
|
798
|
-
},
|
|
793
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
799
794
|
type: number;
|
|
800
795
|
a?: number;
|
|
801
796
|
b?: number;
|
|
802
797
|
coefficients?: number[];
|
|
803
798
|
tex?: string;
|
|
804
|
-
},
|
|
799
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
805
800
|
a: number;
|
|
806
801
|
b: number;
|
|
807
802
|
c: number;
|
|
808
|
-
},
|
|
803
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
809
804
|
a: number;
|
|
810
805
|
b: number;
|
|
811
806
|
c: number;
|
|
812
807
|
d: number;
|
|
813
|
-
},
|
|
808
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
814
809
|
affineA: number;
|
|
815
810
|
affineB: number;
|
|
816
|
-
},
|
|
811
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
817
812
|
affineA: number;
|
|
818
813
|
affineB: number;
|
|
819
|
-
},
|
|
814
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
820
815
|
affinecoeffs: number[];
|
|
821
|
-
},
|
|
816
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
822
817
|
affinecoeffs: number[];
|
|
823
|
-
},
|
|
818
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
824
819
|
affineA: number;
|
|
825
820
|
affineB: number;
|
|
826
821
|
power: number;
|
|
827
|
-
},
|
|
822
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
828
823
|
a: number;
|
|
829
824
|
power: number;
|
|
830
|
-
},
|
|
825
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
831
826
|
affineA: number;
|
|
832
827
|
affineB: number;
|
|
833
|
-
},
|
|
828
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
834
829
|
a: number;
|
|
835
|
-
},
|
|
830
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
836
831
|
coeffs: number[];
|
|
837
832
|
x: number;
|
|
838
|
-
},
|
|
833
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
839
834
|
abscisse: number;
|
|
840
835
|
trinome: number[];
|
|
841
|
-
},
|
|
836
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
842
837
|
A: number[];
|
|
843
838
|
B: number[];
|
|
844
839
|
coeffs: number[];
|
|
845
|
-
},
|
|
840
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
846
841
|
xA: number;
|
|
847
842
|
yA: number;
|
|
848
843
|
yPrimeA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
849
844
|
trinomCoeffs: number[];
|
|
850
|
-
},
|
|
845
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
851
846
|
a: number;
|
|
852
847
|
fa: number;
|
|
853
848
|
fprimea: number;
|
|
854
|
-
},
|
|
849
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
855
850
|
A: number[];
|
|
856
851
|
B: number[];
|
|
857
852
|
coeffs: number[];
|
|
858
853
|
isAskingDerivative: boolean;
|
|
859
|
-
},
|
|
854
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
860
855
|
trinomCoeffs: number[];
|
|
861
|
-
},
|
|
856
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
862
857
|
a: number;
|
|
863
858
|
c: number;
|
|
864
859
|
coin: number;
|
|
865
860
|
racine1: number;
|
|
866
861
|
racine2: number;
|
|
867
|
-
},
|
|
862
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
868
863
|
a: number;
|
|
869
864
|
coin: number;
|
|
870
865
|
r1: number;
|
|
871
866
|
r2: number;
|
|
872
|
-
},
|
|
867
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
873
868
|
a: number;
|
|
874
869
|
b: number;
|
|
875
870
|
c: number;
|
|
876
871
|
d: number;
|
|
877
|
-
},
|
|
872
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
878
873
|
coeffs: number[];
|
|
879
|
-
},
|
|
874
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
880
875
|
askConvex: boolean;
|
|
881
876
|
quadcoeffs: number[];
|
|
882
|
-
},
|
|
877
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
883
878
|
quadcoeffs: number[];
|
|
884
|
-
},
|
|
879
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
885
880
|
a: number;
|
|
886
|
-
},
|
|
881
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
887
882
|
a: number;
|
|
888
883
|
initialY: number;
|
|
889
|
-
},
|
|
884
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
890
885
|
type: string;
|
|
891
886
|
randFuncIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
892
887
|
equaDiffIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
893
888
|
isSolution: boolean;
|
|
894
|
-
},
|
|
889
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
895
890
|
a: number;
|
|
896
891
|
b: number;
|
|
897
|
-
},
|
|
892
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
898
893
|
a: number;
|
|
899
894
|
b: number;
|
|
900
|
-
},
|
|
895
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
901
896
|
a: number;
|
|
902
897
|
b: number;
|
|
903
898
|
isStrict: boolean;
|
|
904
|
-
},
|
|
899
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
905
900
|
firstAffine: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
|
|
906
901
|
secondAffine: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
|
|
907
|
-
},
|
|
902
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
908
903
|
a: number;
|
|
909
904
|
b: number;
|
|
910
905
|
c: number;
|
|
911
906
|
isStrict: boolean;
|
|
912
|
-
},
|
|
907
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
913
908
|
isSup: boolean;
|
|
914
909
|
n: number;
|
|
915
|
-
},
|
|
910
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
916
911
|
isSup: boolean;
|
|
917
912
|
n: number;
|
|
918
|
-
},
|
|
913
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
919
914
|
a: number;
|
|
920
915
|
b: number;
|
|
921
|
-
},
|
|
916
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
922
917
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
923
918
|
b: number;
|
|
924
919
|
c: number;
|
|
925
|
-
},
|
|
920
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
926
921
|
expression: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
927
|
-
},
|
|
922
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
928
923
|
xA: number;
|
|
929
924
|
yA: number;
|
|
930
925
|
xB: number;
|
|
931
926
|
yB: number;
|
|
932
927
|
}, {
|
|
933
928
|
functionType?: string;
|
|
934
|
-
}
|
|
929
|
+
}> | Exercise<{
|
|
935
930
|
xA: number;
|
|
936
931
|
xB: number;
|
|
937
932
|
yA: number;
|
|
938
933
|
yB: number;
|
|
939
|
-
},
|
|
934
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
940
935
|
xA: number;
|
|
941
936
|
xB: number;
|
|
942
937
|
yA: number;
|
|
943
938
|
yB: number;
|
|
944
|
-
},
|
|
939
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
945
940
|
a: number;
|
|
946
941
|
b: number;
|
|
947
942
|
askingPositive: boolean;
|
|
948
|
-
},
|
|
943
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
949
944
|
b: number;
|
|
950
945
|
secondPoint: number[];
|
|
951
|
-
},
|
|
946
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
952
947
|
b: number;
|
|
953
948
|
secondPoint: number[];
|
|
954
|
-
},
|
|
949
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
955
950
|
a: number;
|
|
956
951
|
b: number;
|
|
957
952
|
isCoeffFirst: boolean;
|
|
958
|
-
},
|
|
953
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
959
954
|
a: number;
|
|
960
955
|
b: number;
|
|
961
956
|
isAskingA: boolean;
|
|
962
|
-
},
|
|
957
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
963
958
|
xValues: number[];
|
|
964
959
|
yValues: number[];
|
|
965
|
-
},
|
|
960
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
966
961
|
xValues: number[];
|
|
967
962
|
yValues: number[];
|
|
968
|
-
},
|
|
963
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
969
964
|
xValues: number[];
|
|
970
965
|
yValues: number[];
|
|
971
|
-
},
|
|
966
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
972
967
|
trinomial: number[];
|
|
973
968
|
leftbound: number;
|
|
974
969
|
rightbound: number;
|
|
975
|
-
},
|
|
970
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
976
971
|
xA: number;
|
|
977
972
|
xB: number;
|
|
978
973
|
yA: number;
|
|
979
974
|
yB: number;
|
|
980
|
-
},
|
|
975
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
981
976
|
situationIndex: number;
|
|
982
977
|
initial: number;
|
|
983
978
|
growth: number;
|
|
984
|
-
},
|
|
979
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
985
980
|
correctA: number;
|
|
986
981
|
correctB: number;
|
|
987
982
|
nameFunc: string;
|
|
988
|
-
},
|
|
983
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
989
984
|
items: {
|
|
990
985
|
fName: string;
|
|
991
986
|
tex: string;
|
|
@@ -996,11 +991,11 @@ declare const mathExercises: (Exercise<{
|
|
|
996
991
|
askedType: "affine" | "linear";
|
|
997
992
|
}, {
|
|
998
993
|
askedType: "affine" | "linear";
|
|
999
|
-
}
|
|
994
|
+
}> | Exercise<{
|
|
1000
995
|
pointIdsA: import("./math/geometry/point.js").PointIdentifiers;
|
|
1001
996
|
pointIdsB: import("./math/geometry/point.js").PointIdentifiers;
|
|
1002
997
|
funcName: string;
|
|
1003
|
-
},
|
|
998
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1004
999
|
arrFProps: {
|
|
1005
1000
|
fName: string;
|
|
1006
1001
|
colorProps: {
|
|
@@ -1011,13 +1006,13 @@ declare const mathExercises: (Exercise<{
|
|
|
1011
1006
|
isAnswer: boolean;
|
|
1012
1007
|
}[];
|
|
1013
1008
|
isLinear: boolean;
|
|
1014
|
-
},
|
|
1009
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1015
1010
|
coeffs: number[];
|
|
1016
1011
|
yValue: number;
|
|
1017
|
-
},
|
|
1012
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1018
1013
|
coeffs: number[];
|
|
1019
1014
|
xValue: number;
|
|
1020
|
-
},
|
|
1015
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1021
1016
|
fName: string;
|
|
1022
1017
|
coeffs: number[];
|
|
1023
1018
|
items: {
|
|
@@ -1026,7 +1021,7 @@ declare const mathExercises: (Exercise<{
|
|
|
1026
1021
|
point?: import("./math/geometry/point.js").PointIdentifiers | undefined;
|
|
1027
1022
|
isPointValid?: boolean;
|
|
1028
1023
|
}[];
|
|
1029
|
-
},
|
|
1024
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1030
1025
|
pointIdsA: import("./math/geometry/point.js").PointIdentifiers;
|
|
1031
1026
|
leadingCoeff: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1032
1027
|
numberType: string;
|
|
@@ -1034,13 +1029,13 @@ declare const mathExercises: (Exercise<{
|
|
|
1034
1029
|
funcName: string;
|
|
1035
1030
|
}, {
|
|
1036
1031
|
numberTypes: string[];
|
|
1037
|
-
}
|
|
1032
|
+
}> | Exercise<{
|
|
1038
1033
|
progCalcIds: import("./math/progCalc/progCalc.js").ProgCalcIdentifiers;
|
|
1039
1034
|
funcName: string;
|
|
1040
1035
|
}, {
|
|
1041
|
-
nbSteps:
|
|
1036
|
+
nbSteps: string;
|
|
1042
1037
|
isSingleUseOperators: boolean;
|
|
1043
|
-
}
|
|
1038
|
+
}> | Exercise<{
|
|
1044
1039
|
xValue: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1045
1040
|
polynomeCoeffs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
1046
1041
|
imageSyntaxText: boolean;
|
|
@@ -1048,7 +1043,7 @@ declare const mathExercises: (Exercise<{
|
|
|
1048
1043
|
functionType: string[];
|
|
1049
1044
|
coeffsType: string[];
|
|
1050
1045
|
xType: string[];
|
|
1051
|
-
}
|
|
1046
|
+
}> | Exercise<{
|
|
1052
1047
|
functionType: string;
|
|
1053
1048
|
x: number;
|
|
1054
1049
|
y?: number;
|
|
@@ -1057,16 +1052,16 @@ declare const mathExercises: (Exercise<{
|
|
|
1057
1052
|
functionCommand?: string;
|
|
1058
1053
|
}, {
|
|
1059
1054
|
curveTypes: string[];
|
|
1060
|
-
}
|
|
1055
|
+
}> | Exercise<{
|
|
1061
1056
|
coeffs: number[];
|
|
1062
1057
|
yValue: number;
|
|
1063
|
-
},
|
|
1058
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1064
1059
|
yValue: number;
|
|
1065
1060
|
points: number[][];
|
|
1066
|
-
},
|
|
1061
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1067
1062
|
yValue: number;
|
|
1068
1063
|
splinePoints: [number, number][];
|
|
1069
|
-
},
|
|
1064
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1070
1065
|
yValue: number;
|
|
1071
1066
|
splinePoints: [number, number][];
|
|
1072
1067
|
isStrict: boolean;
|
|
@@ -1076,12 +1071,12 @@ declare const mathExercises: (Exercise<{
|
|
|
1076
1071
|
b: number;
|
|
1077
1072
|
closure: import("./tree/nodes/sets/closure.js").ClosureType;
|
|
1078
1073
|
}[];
|
|
1079
|
-
},
|
|
1074
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1080
1075
|
yValue: number;
|
|
1081
1076
|
fSplinePoints: number[][];
|
|
1082
1077
|
gSplinePoints: number[][];
|
|
1083
1078
|
xSolutions: number[];
|
|
1084
|
-
},
|
|
1079
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1085
1080
|
yValue: number;
|
|
1086
1081
|
fSplinePoints: number[][];
|
|
1087
1082
|
gSplinePoints: number[][];
|
|
@@ -1091,177 +1086,177 @@ declare const mathExercises: (Exercise<{
|
|
|
1091
1086
|
b: number;
|
|
1092
1087
|
closure: import("./tree/nodes/sets/closure.js").ClosureType;
|
|
1093
1088
|
}[];
|
|
1094
|
-
},
|
|
1089
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1095
1090
|
xValues: number[];
|
|
1096
1091
|
imageValues: number[];
|
|
1097
1092
|
isAskingImage: boolean;
|
|
1098
1093
|
value: number;
|
|
1099
|
-
},
|
|
1094
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1100
1095
|
isImage: boolean;
|
|
1101
1096
|
x: number;
|
|
1102
1097
|
y: number;
|
|
1103
|
-
},
|
|
1098
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1104
1099
|
yValue: number;
|
|
1105
1100
|
xValue: number;
|
|
1106
1101
|
inegalitySymbol: import("./math/inequations/inequation.js").InegalitySymbols;
|
|
1107
1102
|
a: number;
|
|
1108
1103
|
b: number;
|
|
1109
|
-
},
|
|
1104
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1110
1105
|
a: number;
|
|
1111
1106
|
type: number;
|
|
1112
|
-
},
|
|
1107
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1113
1108
|
coeffs: number[];
|
|
1114
1109
|
initTable: string[][];
|
|
1115
|
-
},
|
|
1110
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1116
1111
|
points: number[][];
|
|
1117
1112
|
initTable: string[][];
|
|
1118
|
-
},
|
|
1113
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1119
1114
|
point: import("./math/geometry/point.js").PointIdentifiers;
|
|
1120
1115
|
func: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1121
|
-
},
|
|
1116
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1122
1117
|
type: number;
|
|
1123
1118
|
a: number;
|
|
1124
1119
|
b: number;
|
|
1125
1120
|
c: number;
|
|
1126
1121
|
d: number;
|
|
1127
|
-
},
|
|
1122
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1128
1123
|
type: number;
|
|
1129
1124
|
a: number;
|
|
1130
1125
|
b?: number;
|
|
1131
1126
|
c?: number;
|
|
1132
1127
|
d?: number;
|
|
1133
|
-
},
|
|
1128
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1134
1129
|
questionFunc: {
|
|
1135
1130
|
type: "...x^2" | "...x^3" | "(x-...)(x-...)" | "(x+...)(x-...)" | "(x+...)(x+...)" | "a/(x+...)" | "(x+...)/(x+...)";
|
|
1136
1131
|
nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1137
1132
|
};
|
|
1138
1133
|
xValue: number;
|
|
1139
|
-
},
|
|
1134
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1140
1135
|
k: number;
|
|
1141
|
-
},
|
|
1136
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1142
1137
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1143
|
-
},
|
|
1138
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1144
1139
|
a: number;
|
|
1145
1140
|
b: number;
|
|
1146
|
-
},
|
|
1141
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1147
1142
|
x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1148
1143
|
y: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1149
|
-
},
|
|
1144
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1150
1145
|
a: number;
|
|
1151
1146
|
b: number;
|
|
1152
1147
|
c: number;
|
|
1153
1148
|
d: number;
|
|
1154
|
-
},
|
|
1149
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1155
1150
|
quadrinomial: number[];
|
|
1156
1151
|
leftbound: number;
|
|
1157
1152
|
rightbound: number;
|
|
1158
|
-
},
|
|
1153
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1159
1154
|
aIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1160
1155
|
bIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1161
1156
|
cIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1162
1157
|
isAsking: string;
|
|
1163
|
-
},
|
|
1158
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1164
1159
|
a: number;
|
|
1165
1160
|
b: number;
|
|
1166
1161
|
c: number;
|
|
1167
1162
|
isDevForm: boolean;
|
|
1168
|
-
},
|
|
1163
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1169
1164
|
a: number;
|
|
1170
1165
|
b: number;
|
|
1171
1166
|
c: number;
|
|
1172
|
-
},
|
|
1167
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1173
1168
|
a: number;
|
|
1174
1169
|
b: number;
|
|
1175
1170
|
c: number;
|
|
1176
1171
|
ineqType: import("./math/inequations/inequation.js").InegalitySymbols;
|
|
1177
|
-
},
|
|
1172
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1178
1173
|
a: number;
|
|
1179
1174
|
b: number;
|
|
1180
1175
|
type: number;
|
|
1181
|
-
},
|
|
1176
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1182
1177
|
coeffs: number[];
|
|
1183
|
-
},
|
|
1178
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1184
1179
|
roots: number[];
|
|
1185
1180
|
a: number;
|
|
1186
|
-
},
|
|
1181
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1187
1182
|
trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode.js").TrinomNodeIdentifiers;
|
|
1188
1183
|
firstRootIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1189
|
-
},
|
|
1184
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1190
1185
|
a: number;
|
|
1191
1186
|
b: number;
|
|
1192
1187
|
c: number;
|
|
1193
|
-
},
|
|
1188
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1194
1189
|
a: number;
|
|
1195
1190
|
b: number;
|
|
1196
1191
|
c: number;
|
|
1197
|
-
},
|
|
1192
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1198
1193
|
a: number;
|
|
1199
1194
|
b: number;
|
|
1200
1195
|
c: number;
|
|
1201
|
-
},
|
|
1196
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1202
1197
|
trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode.js").TrinomNodeIdentifiers;
|
|
1203
|
-
},
|
|
1198
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1204
1199
|
a: number;
|
|
1205
1200
|
b: number;
|
|
1206
1201
|
c: number;
|
|
1207
|
-
},
|
|
1202
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1208
1203
|
trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode.js").TrinomNodeIdentifiers;
|
|
1209
|
-
},
|
|
1204
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1210
1205
|
trinomCoeffs: number[];
|
|
1211
1206
|
isAskingPositive: boolean;
|
|
1212
|
-
},
|
|
1207
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1213
1208
|
trinomCoeffs: number[];
|
|
1214
1209
|
isAskingPositive: boolean;
|
|
1215
1210
|
isStrict: boolean;
|
|
1216
|
-
},
|
|
1211
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1217
1212
|
param: string;
|
|
1218
1213
|
coeffs: number[];
|
|
1219
|
-
},
|
|
1214
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1220
1215
|
param: string;
|
|
1221
1216
|
a: number;
|
|
1222
1217
|
alpha: number;
|
|
1223
1218
|
beta: number;
|
|
1224
|
-
},
|
|
1219
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1225
1220
|
a: number;
|
|
1226
1221
|
b: number;
|
|
1227
1222
|
c: number;
|
|
1228
|
-
},
|
|
1223
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1229
1224
|
a: number;
|
|
1230
1225
|
b: number;
|
|
1231
1226
|
c: number;
|
|
1232
|
-
},
|
|
1227
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1233
1228
|
a: number;
|
|
1234
1229
|
b: number;
|
|
1235
1230
|
c: number;
|
|
1236
1231
|
isDevForm: boolean;
|
|
1237
|
-
},
|
|
1232
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1238
1233
|
a: number;
|
|
1239
1234
|
b: number;
|
|
1240
1235
|
c: number;
|
|
1241
|
-
},
|
|
1236
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1242
1237
|
a: number;
|
|
1243
1238
|
b: number;
|
|
1244
1239
|
c: number;
|
|
1245
|
-
},
|
|
1240
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1246
1241
|
a: number;
|
|
1247
1242
|
b: number;
|
|
1248
1243
|
c: number;
|
|
1249
|
-
},
|
|
1244
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1250
1245
|
type: number;
|
|
1251
1246
|
points: number[][];
|
|
1252
|
-
},
|
|
1247
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1253
1248
|
a: number;
|
|
1254
1249
|
x1: number;
|
|
1255
1250
|
x2: number;
|
|
1256
|
-
},
|
|
1251
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1257
1252
|
a: number;
|
|
1258
1253
|
k: number;
|
|
1259
|
-
},
|
|
1254
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1260
1255
|
random: number;
|
|
1261
1256
|
a?: number;
|
|
1262
1257
|
uCoeffs: number[];
|
|
1263
1258
|
vCoeffs: number[];
|
|
1264
|
-
},
|
|
1259
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1265
1260
|
a: number;
|
|
1266
1261
|
b: number;
|
|
1267
1262
|
c: number;
|
|
@@ -1269,16 +1264,16 @@ declare const mathExercises: (Exercise<{
|
|
|
1269
1264
|
e: number;
|
|
1270
1265
|
f: number;
|
|
1271
1266
|
uA: number;
|
|
1272
|
-
},
|
|
1267
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1273
1268
|
a: number;
|
|
1274
1269
|
k: number;
|
|
1275
|
-
},
|
|
1270
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1276
1271
|
pm: number;
|
|
1277
1272
|
a: number;
|
|
1278
1273
|
b: number;
|
|
1279
|
-
},
|
|
1274
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1280
1275
|
tenthPower: number;
|
|
1281
|
-
},
|
|
1276
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1282
1277
|
a: number;
|
|
1283
1278
|
powered: number;
|
|
1284
1279
|
c: number;
|
|
@@ -1286,132 +1281,132 @@ declare const mathExercises: (Exercise<{
|
|
|
1286
1281
|
isLog10: boolean;
|
|
1287
1282
|
}, {
|
|
1288
1283
|
isLog10: boolean;
|
|
1289
|
-
}
|
|
1284
|
+
}> | Exercise<{
|
|
1290
1285
|
nb: number;
|
|
1291
1286
|
powers: number[];
|
|
1292
1287
|
signs: number[];
|
|
1293
1288
|
isLog10: boolean;
|
|
1294
1289
|
}, {
|
|
1295
1290
|
isLog10: boolean;
|
|
1296
|
-
}
|
|
1291
|
+
}> | Exercise<{
|
|
1297
1292
|
a: number;
|
|
1298
1293
|
b: number;
|
|
1299
1294
|
}, {
|
|
1300
1295
|
useLog10?: boolean;
|
|
1301
|
-
}
|
|
1296
|
+
}> | Exercise<{
|
|
1302
1297
|
type: string;
|
|
1303
1298
|
fctTex: string;
|
|
1304
|
-
},
|
|
1299
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1305
1300
|
type: string;
|
|
1306
1301
|
fctCmd: string;
|
|
1307
|
-
},
|
|
1302
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1308
1303
|
isEven: boolean;
|
|
1309
1304
|
isLeftSideGiven: boolean;
|
|
1310
1305
|
givenPointsCoords: number[][];
|
|
1311
|
-
},
|
|
1306
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1312
1307
|
a: number;
|
|
1313
1308
|
b: number;
|
|
1314
1309
|
closure: import("./tree/nodes/sets/closure.js").ClosureType;
|
|
1315
1310
|
type: number;
|
|
1316
|
-
},
|
|
1311
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1317
1312
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1318
|
-
},
|
|
1313
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1319
1314
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1320
1315
|
b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1321
|
-
},
|
|
1316
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1322
1317
|
a: number;
|
|
1323
1318
|
b: number;
|
|
1324
1319
|
closure: import("./tree/nodes/sets/closure.js").ClosureType;
|
|
1325
1320
|
type: number;
|
|
1326
|
-
},
|
|
1321
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1327
1322
|
k: number;
|
|
1328
1323
|
inequationSymbol: import("./math/inequations/inequation.js").InegalitySymbols;
|
|
1329
|
-
},
|
|
1324
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1330
1325
|
lowerBound: number;
|
|
1331
1326
|
upperBound: number;
|
|
1332
1327
|
trinomial: number[];
|
|
1333
|
-
},
|
|
1328
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1334
1329
|
lowerBound: number;
|
|
1335
1330
|
upperBound: number;
|
|
1336
1331
|
quadrinomial: number[];
|
|
1337
|
-
},
|
|
1332
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1338
1333
|
lowerBoundIndex: number;
|
|
1339
1334
|
upperBoundIndex: number;
|
|
1340
1335
|
k: number;
|
|
1341
|
-
},
|
|
1336
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1342
1337
|
lowerBoundIndex: number;
|
|
1343
1338
|
upperBoundIndex: number;
|
|
1344
1339
|
k: number;
|
|
1345
|
-
},
|
|
1340
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1346
1341
|
questionType: string;
|
|
1347
1342
|
trinomial: number[];
|
|
1348
1343
|
upperBound: number;
|
|
1349
1344
|
lowerBound: number;
|
|
1350
|
-
},
|
|
1345
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1351
1346
|
questionType: string;
|
|
1352
1347
|
trinomial: number[];
|
|
1353
1348
|
upperBound: number;
|
|
1354
1349
|
lowerBound: number;
|
|
1355
|
-
},
|
|
1350
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1356
1351
|
a: number;
|
|
1357
1352
|
b: number;
|
|
1358
1353
|
aX: number;
|
|
1359
1354
|
bX: number;
|
|
1360
|
-
},
|
|
1355
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1361
1356
|
a: number;
|
|
1362
1357
|
b: number;
|
|
1363
1358
|
aU: number;
|
|
1364
1359
|
bU: number;
|
|
1365
|
-
},
|
|
1360
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1366
1361
|
a: number;
|
|
1367
1362
|
b: number;
|
|
1368
1363
|
aU: number;
|
|
1369
1364
|
bU: number;
|
|
1370
|
-
},
|
|
1365
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1371
1366
|
q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1372
1367
|
a: number;
|
|
1373
|
-
},
|
|
1368
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1374
1369
|
affine1Ids: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
|
|
1375
1370
|
affine2Ids: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
|
|
1376
1371
|
isAskingPositive: boolean;
|
|
1377
1372
|
}, {
|
|
1378
1373
|
instructionType: string;
|
|
1379
|
-
}
|
|
1374
|
+
}> | Exercise<{
|
|
1380
1375
|
affineCoeffs: number[];
|
|
1381
1376
|
initTable: string[][];
|
|
1382
|
-
},
|
|
1377
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1383
1378
|
affine1Coeffs: number[];
|
|
1384
1379
|
affine2Coeffs: number[];
|
|
1385
1380
|
initTable: string[][];
|
|
1386
|
-
},
|
|
1381
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1387
1382
|
signs: string[];
|
|
1388
1383
|
xs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
1389
1384
|
x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1390
|
-
},
|
|
1385
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1391
1386
|
initTable: string[][];
|
|
1392
1387
|
a: number;
|
|
1393
1388
|
x1: number;
|
|
1394
1389
|
x2: number;
|
|
1395
1390
|
x3: number;
|
|
1396
|
-
},
|
|
1391
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1397
1392
|
signs: string[];
|
|
1398
1393
|
xs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
1399
1394
|
type: number;
|
|
1400
1395
|
ineqSymbol?: string;
|
|
1401
1396
|
}, {
|
|
1402
1397
|
questionType: string;
|
|
1403
|
-
}
|
|
1398
|
+
}> | Exercise<{
|
|
1404
1399
|
initTable: string[][];
|
|
1405
1400
|
a: number;
|
|
1406
1401
|
x1: number;
|
|
1407
1402
|
x2: number;
|
|
1408
1403
|
x3: number;
|
|
1409
1404
|
lineAsked: number;
|
|
1410
|
-
},
|
|
1405
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1411
1406
|
affine1Coeffs: number[];
|
|
1412
1407
|
affine2Coeffs: number[];
|
|
1413
1408
|
initTable: string[][];
|
|
1414
|
-
},
|
|
1409
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1415
1410
|
xValues: number[];
|
|
1416
1411
|
yValues: number[];
|
|
1417
1412
|
isAskingX: boolean;
|
|
@@ -1419,34 +1414,34 @@ declare const mathExercises: (Exercise<{
|
|
|
1419
1414
|
intervalXIndexes: number[];
|
|
1420
1415
|
}, {
|
|
1421
1416
|
extremumType: string;
|
|
1422
|
-
}
|
|
1417
|
+
}> | Exercise<{
|
|
1423
1418
|
type: number;
|
|
1424
1419
|
coeffs: number[];
|
|
1425
1420
|
initTable: string[][];
|
|
1426
|
-
},
|
|
1421
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1427
1422
|
xs: number[];
|
|
1428
1423
|
ys: number[];
|
|
1429
1424
|
vars: string[];
|
|
1430
1425
|
a: number;
|
|
1431
1426
|
b: number;
|
|
1432
|
-
},
|
|
1427
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1433
1428
|
type: number;
|
|
1434
1429
|
coeffs: number[];
|
|
1435
1430
|
initTable: string[][];
|
|
1436
1431
|
lineAsked: number;
|
|
1437
|
-
},
|
|
1432
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1438
1433
|
vars: string[];
|
|
1439
1434
|
xs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
1440
1435
|
initTable: string[][];
|
|
1441
|
-
},
|
|
1436
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1442
1437
|
type: number;
|
|
1443
1438
|
coeffs: number[];
|
|
1444
1439
|
intervalAskedIndex: number;
|
|
1445
|
-
},
|
|
1440
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1446
1441
|
type: number;
|
|
1447
1442
|
coeffs: number[];
|
|
1448
1443
|
askingIncreasing: boolean;
|
|
1449
|
-
},
|
|
1444
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1450
1445
|
askingMax: boolean;
|
|
1451
1446
|
askingX: boolean;
|
|
1452
1447
|
splinePoints: number[][];
|
|
@@ -1454,112 +1449,112 @@ declare const mathExercises: (Exercise<{
|
|
|
1454
1449
|
}, {
|
|
1455
1450
|
coordAsked: string;
|
|
1456
1451
|
extremumType: string;
|
|
1457
|
-
}
|
|
1452
|
+
}> | Exercise<{
|
|
1458
1453
|
a: number;
|
|
1459
1454
|
b: number;
|
|
1460
|
-
},
|
|
1455
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1461
1456
|
twoSided: boolean;
|
|
1462
1457
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1463
1458
|
b?: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1464
|
-
},
|
|
1459
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1465
1460
|
x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1466
|
-
},
|
|
1461
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1467
1462
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1468
|
-
},
|
|
1463
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1469
1464
|
x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1470
1465
|
y: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1471
|
-
},
|
|
1466
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1472
1467
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1473
1468
|
b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1474
1469
|
isMinusInside: boolean;
|
|
1475
|
-
},
|
|
1470
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1476
1471
|
k: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1477
|
-
},
|
|
1472
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1478
1473
|
nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
1479
|
-
},
|
|
1474
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1480
1475
|
coin: boolean;
|
|
1481
1476
|
radius: number;
|
|
1482
1477
|
diametre: number;
|
|
1483
|
-
},
|
|
1478
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1484
1479
|
length: number;
|
|
1485
1480
|
width: number;
|
|
1486
|
-
},
|
|
1481
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1487
1482
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
1488
|
-
},
|
|
1483
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1489
1484
|
side: number;
|
|
1490
|
-
},
|
|
1485
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1491
1486
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
1492
1487
|
heightIdentifiers: import("./math/geometry/segment.js").SegmentIdentifiers;
|
|
1493
1488
|
height: number;
|
|
1494
1489
|
base: number;
|
|
1495
|
-
},
|
|
1490
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1496
1491
|
randomSide: number;
|
|
1497
|
-
},
|
|
1492
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1498
1493
|
area: number;
|
|
1499
1494
|
isPerfectSquare: boolean;
|
|
1500
|
-
},
|
|
1495
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1501
1496
|
area: number;
|
|
1502
1497
|
width: number;
|
|
1503
|
-
},
|
|
1498
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1504
1499
|
area: number;
|
|
1505
|
-
},
|
|
1500
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1506
1501
|
shape: number;
|
|
1507
1502
|
height: number;
|
|
1508
1503
|
width: number;
|
|
1509
|
-
},
|
|
1504
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1510
1505
|
coords1: number[];
|
|
1511
1506
|
coords2: number[];
|
|
1512
|
-
},
|
|
1507
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1513
1508
|
coordsA: number[];
|
|
1514
1509
|
coordsB: number[];
|
|
1515
|
-
},
|
|
1510
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1516
1511
|
aX: number;
|
|
1517
1512
|
aY: number;
|
|
1518
1513
|
bX: number;
|
|
1519
1514
|
bY: number;
|
|
1520
|
-
},
|
|
1515
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1521
1516
|
x: number;
|
|
1522
1517
|
y: number;
|
|
1523
|
-
},
|
|
1518
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1524
1519
|
x1: number;
|
|
1525
1520
|
x2: number;
|
|
1526
1521
|
y1: number;
|
|
1527
1522
|
y2: number;
|
|
1528
|
-
},
|
|
1523
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1529
1524
|
xValue: number;
|
|
1530
1525
|
yValue: number;
|
|
1531
1526
|
c: number;
|
|
1532
|
-
},
|
|
1527
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1533
1528
|
correctA: number;
|
|
1534
1529
|
correctB: number;
|
|
1535
|
-
},
|
|
1530
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1536
1531
|
x: number;
|
|
1537
1532
|
y: number;
|
|
1538
|
-
},
|
|
1533
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1539
1534
|
x: number;
|
|
1540
1535
|
y: number;
|
|
1541
|
-
},
|
|
1536
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1542
1537
|
abscissType: import("./math/numbers/nombre.js").NumberType;
|
|
1543
1538
|
axisUnit: number;
|
|
1544
1539
|
oneUnitTex: string;
|
|
1545
1540
|
absciss: number;
|
|
1546
1541
|
abscissTex: string;
|
|
1547
1542
|
coeff: number;
|
|
1548
|
-
},
|
|
1543
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1549
1544
|
abscissType: import("./math/numbers/nombre.js").NumberType;
|
|
1550
1545
|
axisUnit: number;
|
|
1551
1546
|
oneUnitTex: string;
|
|
1552
1547
|
absciss: number;
|
|
1553
1548
|
abscissTex: string;
|
|
1554
1549
|
coeff: number;
|
|
1555
|
-
},
|
|
1550
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1556
1551
|
abscissType: import("./math/numbers/nombre.js").NumberType;
|
|
1557
1552
|
axisUnit: number;
|
|
1558
1553
|
oneUnitTex: string;
|
|
1559
1554
|
absciss: number;
|
|
1560
1555
|
abscissTex: string;
|
|
1561
1556
|
coeff: number;
|
|
1562
|
-
},
|
|
1557
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1563
1558
|
abscissType: import("./math/numbers/nombre.js").NumberType;
|
|
1564
1559
|
axisUnit: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1565
1560
|
absciss1: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
@@ -1567,57 +1562,57 @@ declare const mathExercises: (Exercise<{
|
|
|
1567
1562
|
}, {
|
|
1568
1563
|
questionType: "standard" | "\u00E9viter le comptage";
|
|
1569
1564
|
numberType: "Entiers" | "Rationnels" | "D\u00E9cimaux";
|
|
1570
|
-
}
|
|
1565
|
+
}> | Exercise<{
|
|
1571
1566
|
vectorIdentifiers: import("./math/geometry/vector.js").VectorIdentifiers;
|
|
1572
1567
|
pointIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
|
|
1573
|
-
},
|
|
1568
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1574
1569
|
pointIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
|
|
1575
1570
|
pointBIdentifiers: import("./math/geometry/point.js").PointIdentifiers;
|
|
1576
|
-
},
|
|
1571
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1577
1572
|
coin: boolean;
|
|
1578
1573
|
radius: number;
|
|
1579
1574
|
diametre: number;
|
|
1580
|
-
},
|
|
1575
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1581
1576
|
length: number;
|
|
1582
1577
|
width: number;
|
|
1583
|
-
},
|
|
1578
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1584
1579
|
side: number;
|
|
1585
|
-
},
|
|
1580
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1586
1581
|
sides: number[];
|
|
1587
|
-
},
|
|
1582
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1588
1583
|
perimeter: number;
|
|
1589
|
-
},
|
|
1584
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1590
1585
|
perimeter: number;
|
|
1591
1586
|
width: number;
|
|
1592
|
-
},
|
|
1587
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1593
1588
|
perimeter: number;
|
|
1594
|
-
},
|
|
1589
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1595
1590
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
1596
|
-
},
|
|
1591
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1597
1592
|
sideAsked: number;
|
|
1598
1593
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
1599
|
-
},
|
|
1594
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1600
1595
|
isRight: boolean;
|
|
1601
1596
|
a: number;
|
|
1602
1597
|
b: number;
|
|
1603
1598
|
c: number;
|
|
1604
1599
|
vertices: string[];
|
|
1605
|
-
},
|
|
1600
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1606
1601
|
shape: "square" | "rectangle";
|
|
1607
1602
|
side: number;
|
|
1608
1603
|
side2?: number;
|
|
1609
|
-
},
|
|
1604
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1610
1605
|
isEqui: boolean;
|
|
1611
1606
|
side: number;
|
|
1612
1607
|
base?: number;
|
|
1613
|
-
},
|
|
1608
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1614
1609
|
ratio: number;
|
|
1615
1610
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
1616
1611
|
insidePointsNames: string[];
|
|
1617
1612
|
isPapillon: boolean;
|
|
1618
1613
|
}, {
|
|
1619
1614
|
configurationType: string;
|
|
1620
|
-
}
|
|
1615
|
+
}> | Exercise<{
|
|
1621
1616
|
ratio: number;
|
|
1622
1617
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
1623
1618
|
insidePointsNames: string[];
|
|
@@ -1625,20 +1620,20 @@ declare const mathExercises: (Exercise<{
|
|
|
1625
1620
|
isPapillon: boolean;
|
|
1626
1621
|
}, {
|
|
1627
1622
|
configurationType: string;
|
|
1628
|
-
}
|
|
1623
|
+
}> | Exercise<{
|
|
1629
1624
|
randLetters: string[];
|
|
1630
1625
|
vectors: string[];
|
|
1631
|
-
},
|
|
1626
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1632
1627
|
xA: number;
|
|
1633
1628
|
xB: number;
|
|
1634
1629
|
yA: number;
|
|
1635
1630
|
yB: number;
|
|
1636
|
-
},
|
|
1631
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1637
1632
|
A: number[];
|
|
1638
1633
|
B: number[];
|
|
1639
1634
|
startLetter: string;
|
|
1640
1635
|
endLetter: string;
|
|
1641
|
-
},
|
|
1636
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1642
1637
|
xA: number;
|
|
1643
1638
|
xB: number;
|
|
1644
1639
|
xC: number;
|
|
@@ -1647,7 +1642,7 @@ declare const mathExercises: (Exercise<{
|
|
|
1647
1642
|
yB: number;
|
|
1648
1643
|
yC: number;
|
|
1649
1644
|
yD: number;
|
|
1650
|
-
},
|
|
1645
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1651
1646
|
caracAsked: string;
|
|
1652
1647
|
uPoints: number[][];
|
|
1653
1648
|
vPoints: number[][];
|
|
@@ -1655,7 +1650,7 @@ declare const mathExercises: (Exercise<{
|
|
|
1655
1650
|
sameDirection?: boolean;
|
|
1656
1651
|
sameNorm?: boolean;
|
|
1657
1652
|
sameSens?: boolean;
|
|
1658
|
-
},
|
|
1653
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1659
1654
|
a: number;
|
|
1660
1655
|
b: number;
|
|
1661
1656
|
u: {
|
|
@@ -1666,23 +1661,23 @@ declare const mathExercises: (Exercise<{
|
|
|
1666
1661
|
x: number;
|
|
1667
1662
|
y: number;
|
|
1668
1663
|
};
|
|
1669
|
-
},
|
|
1664
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1670
1665
|
x: number;
|
|
1671
1666
|
y: number;
|
|
1672
|
-
},
|
|
1667
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1673
1668
|
uX: number;
|
|
1674
1669
|
uY: number;
|
|
1675
1670
|
aX: number;
|
|
1676
1671
|
aY: number;
|
|
1677
|
-
},
|
|
1672
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1678
1673
|
uCoords: string[];
|
|
1679
1674
|
vCoords: string[];
|
|
1680
|
-
},
|
|
1675
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1681
1676
|
AB: number;
|
|
1682
1677
|
AC: number;
|
|
1683
1678
|
trigoPoint: string;
|
|
1684
1679
|
letters: string[];
|
|
1685
|
-
},
|
|
1680
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1686
1681
|
c: number;
|
|
1687
1682
|
vec1Name: string;
|
|
1688
1683
|
vec2Name: string;
|
|
@@ -1690,19 +1685,19 @@ declare const mathExercises: (Exercise<{
|
|
|
1690
1685
|
vec1ProjLength: number;
|
|
1691
1686
|
vec2ProjLength: number;
|
|
1692
1687
|
rotationAngle: number;
|
|
1693
|
-
},
|
|
1688
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1694
1689
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
1695
|
-
},
|
|
1690
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1696
1691
|
type: number;
|
|
1697
1692
|
normU: number;
|
|
1698
1693
|
normV: number;
|
|
1699
1694
|
udotv: number;
|
|
1700
|
-
},
|
|
1695
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1701
1696
|
pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1702
|
-
},
|
|
1697
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1703
1698
|
uIds: import("./math/geometry/vector.js").VectorIdentifiers;
|
|
1704
1699
|
vIds: import("./math/geometry/vector.js").VectorIdentifiers;
|
|
1705
|
-
},
|
|
1700
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1706
1701
|
xA: number;
|
|
1707
1702
|
xB: number;
|
|
1708
1703
|
xC: number;
|
|
@@ -1711,7 +1706,7 @@ declare const mathExercises: (Exercise<{
|
|
|
1711
1706
|
yB: number;
|
|
1712
1707
|
yC: number;
|
|
1713
1708
|
yD: number;
|
|
1714
|
-
},
|
|
1709
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1715
1710
|
xA: number;
|
|
1716
1711
|
xB: number;
|
|
1717
1712
|
xC: number;
|
|
@@ -1720,305 +1715,305 @@ declare const mathExercises: (Exercise<{
|
|
|
1720
1715
|
yB: number;
|
|
1721
1716
|
yC: number;
|
|
1722
1717
|
yD: number;
|
|
1723
|
-
},
|
|
1718
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1724
1719
|
isAskingParallelogramName: boolean;
|
|
1725
1720
|
pointNames: string[];
|
|
1726
|
-
},
|
|
1721
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1727
1722
|
pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1728
|
-
},
|
|
1723
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1729
1724
|
xu: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1730
1725
|
yu: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1731
1726
|
xv: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1732
1727
|
yv: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1733
|
-
},
|
|
1728
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1734
1729
|
xA: number;
|
|
1735
1730
|
xB: number;
|
|
1736
1731
|
xC: number;
|
|
1737
1732
|
yA: number;
|
|
1738
1733
|
yB: number;
|
|
1739
1734
|
yC: number;
|
|
1740
|
-
},
|
|
1735
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1741
1736
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1742
1737
|
b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1743
1738
|
c: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1744
1739
|
d: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1745
|
-
},
|
|
1740
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1746
1741
|
firstVec: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1747
1742
|
secondVec: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1748
|
-
},
|
|
1743
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1749
1744
|
uCoords: string[];
|
|
1750
1745
|
vCoords: string[];
|
|
1751
|
-
},
|
|
1746
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1752
1747
|
expression: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1753
1748
|
type: number;
|
|
1754
|
-
},
|
|
1749
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1755
1750
|
points: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1756
1751
|
startPointIndex: number;
|
|
1757
1752
|
firstVectorPointsIndexes: number[];
|
|
1758
1753
|
secondVectorPointsIndexes: number[];
|
|
1759
|
-
},
|
|
1754
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1760
1755
|
points: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1761
1756
|
startPointIndex: number;
|
|
1762
1757
|
firstVectorPointsIndexes: number[];
|
|
1763
1758
|
secondVectorPointsIndexes: number[];
|
|
1764
|
-
},
|
|
1759
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1765
1760
|
points: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1766
1761
|
startPointIndex: number;
|
|
1767
1762
|
vectorPointsIndexes: number[];
|
|
1768
|
-
},
|
|
1763
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1769
1764
|
points: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1770
1765
|
startPointIndex: number;
|
|
1771
1766
|
vectorPointsIndexes: number[];
|
|
1772
1767
|
coeff: number;
|
|
1773
|
-
},
|
|
1768
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1774
1769
|
x: number;
|
|
1775
1770
|
y: number;
|
|
1776
|
-
},
|
|
1771
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1777
1772
|
pointIds: import("./math/geometry/point.js").PointIdentifiers;
|
|
1778
1773
|
isStartingPointAsked: boolean;
|
|
1779
1774
|
vectorIds: import("./math/geometry/vector.js").VectorIdentifiers;
|
|
1780
1775
|
pointAskedName: string;
|
|
1781
|
-
},
|
|
1776
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1782
1777
|
vCoords: number[];
|
|
1783
1778
|
wCoords: number[];
|
|
1784
1779
|
uCoords: number[];
|
|
1785
|
-
},
|
|
1780
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1786
1781
|
points: string[][];
|
|
1787
1782
|
pointAskedIndex: number[];
|
|
1788
|
-
},
|
|
1783
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1789
1784
|
vec: string;
|
|
1790
1785
|
vecsProposed: string[];
|
|
1791
|
-
},
|
|
1786
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1792
1787
|
trinom: number[];
|
|
1793
|
-
},
|
|
1788
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1794
1789
|
askConvex: boolean;
|
|
1795
1790
|
quadcoeffs: number[];
|
|
1796
1791
|
inflexionPoint: number;
|
|
1797
|
-
},
|
|
1792
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1798
1793
|
cubeSide: number;
|
|
1799
|
-
},
|
|
1794
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1800
1795
|
h: number;
|
|
1801
1796
|
baseOfPyramid: {
|
|
1802
1797
|
type: string;
|
|
1803
1798
|
sideSizes: number[];
|
|
1804
1799
|
};
|
|
1805
|
-
},
|
|
1800
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1806
1801
|
h: number;
|
|
1807
1802
|
baseOfPyramidSides: {
|
|
1808
1803
|
ABSide: number;
|
|
1809
1804
|
ACSide: number;
|
|
1810
1805
|
BCSide: number;
|
|
1811
1806
|
};
|
|
1812
|
-
},
|
|
1807
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1813
1808
|
h: number;
|
|
1814
1809
|
baseOfPyramidSides: {
|
|
1815
1810
|
ABSide: number;
|
|
1816
1811
|
ACSide: number;
|
|
1817
1812
|
BCSide: number;
|
|
1818
1813
|
};
|
|
1819
|
-
},
|
|
1814
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1820
1815
|
radius: number;
|
|
1821
1816
|
height: number;
|
|
1822
|
-
},
|
|
1817
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1823
1818
|
radius: number;
|
|
1824
|
-
},
|
|
1819
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1825
1820
|
length: number;
|
|
1826
1821
|
width: number;
|
|
1827
1822
|
height: number;
|
|
1828
1823
|
angle: number;
|
|
1829
|
-
},
|
|
1824
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1830
1825
|
width: number;
|
|
1831
1826
|
height: number;
|
|
1832
1827
|
depth: number;
|
|
1833
|
-
},
|
|
1828
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1834
1829
|
A: number[];
|
|
1835
1830
|
B: number[];
|
|
1836
1831
|
nameA: string;
|
|
1837
1832
|
nameB: string;
|
|
1838
|
-
},
|
|
1833
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1839
1834
|
lengths: number[];
|
|
1840
|
-
},
|
|
1835
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1841
1836
|
points: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1842
1837
|
startPoint: string;
|
|
1843
1838
|
translationPoints: string[];
|
|
1844
1839
|
}, {
|
|
1845
1840
|
useVector: boolean;
|
|
1846
|
-
}
|
|
1841
|
+
}> | Exercise<{
|
|
1847
1842
|
point: import("./math/geometry/point.js").PointIdentifiers;
|
|
1848
1843
|
line: import("./math/geometry/line.js").LineIdentifiers;
|
|
1849
|
-
},
|
|
1844
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1850
1845
|
type: number;
|
|
1851
1846
|
commands: string[];
|
|
1852
|
-
},
|
|
1847
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1853
1848
|
type: number;
|
|
1854
1849
|
objIds: import("./math/geometry/segment.js").SegmentIdentifiers | import("./math/geometry/ray.js").RayIdentifiers | import("./math/geometry/line.js").LineIdentifiers;
|
|
1855
|
-
},
|
|
1850
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1856
1851
|
isAskingLength: boolean;
|
|
1857
1852
|
isSegmentHeight: boolean;
|
|
1858
1853
|
pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1859
1854
|
lengths: number[];
|
|
1860
|
-
},
|
|
1855
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1861
1856
|
point: string;
|
|
1862
1857
|
line: string;
|
|
1863
|
-
},
|
|
1858
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1864
1859
|
startPoint: number[];
|
|
1865
1860
|
vector: number[];
|
|
1866
1861
|
askedPointCoords: number[];
|
|
1867
1862
|
askedPointName: string;
|
|
1868
1863
|
isOnLine: boolean;
|
|
1869
1864
|
coeff?: number;
|
|
1870
|
-
},
|
|
1865
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1871
1866
|
startPoint: number[];
|
|
1872
1867
|
vector: number[];
|
|
1873
|
-
},
|
|
1868
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1874
1869
|
startPoint: number[];
|
|
1875
1870
|
vector: number[];
|
|
1876
|
-
},
|
|
1871
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1877
1872
|
shape: string;
|
|
1878
1873
|
showDiagonals: boolean;
|
|
1879
1874
|
drawAngles: boolean;
|
|
1880
1875
|
shapeIdentifiers: import("./math/geometry/quadrilaterals/rectangle.js").RectangleIdentifiers | import("./math/geometry/quadrilaterals/square.js").SquareIdentifiers | import("./math/geometry/quadrilaterals/rhombus.js").RhombusIdentifiers | import("./math/geometry/quadrilaterals/parallelogram.js").ParallelogramIdentifiers;
|
|
1881
|
-
},
|
|
1876
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1882
1877
|
paraIdentifiers: import("./math/geometry/quadrilaterals/parallelogram.js").ParallelogramIdentifiers;
|
|
1883
1878
|
givenAngleIndex: number;
|
|
1884
1879
|
askedAngleIndex: number;
|
|
1885
|
-
},
|
|
1880
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1886
1881
|
CB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1887
1882
|
CO: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1888
1883
|
BO: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1889
1884
|
isLosange: boolean;
|
|
1890
|
-
},
|
|
1885
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1891
1886
|
BC: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1892
1887
|
BA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1893
1888
|
AC: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1894
1889
|
isRectangle: boolean;
|
|
1895
|
-
},
|
|
1890
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1896
1891
|
points: import("./math/geometry/point.js").PointIdentifiers[];
|
|
1897
1892
|
angleType: string;
|
|
1898
1893
|
angleIndex: number;
|
|
1899
1894
|
apexIndex: number;
|
|
1900
1895
|
}, {
|
|
1901
1896
|
angleTypes: string[];
|
|
1902
|
-
}
|
|
1897
|
+
}> | Exercise<{
|
|
1903
1898
|
doubleAngle: number;
|
|
1904
1899
|
singleAngle: number;
|
|
1905
|
-
},
|
|
1900
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1906
1901
|
lines: {
|
|
1907
1902
|
pointA: number[];
|
|
1908
1903
|
pointB: number[];
|
|
1909
1904
|
label: string;
|
|
1910
1905
|
}[];
|
|
1911
1906
|
coupleAsked: number;
|
|
1912
|
-
},
|
|
1907
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1913
1908
|
a: number;
|
|
1914
1909
|
b: number;
|
|
1915
|
-
},
|
|
1910
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1916
1911
|
a: number;
|
|
1917
1912
|
b: number;
|
|
1918
1913
|
c: number;
|
|
1919
1914
|
toReduced: boolean;
|
|
1920
|
-
},
|
|
1915
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1921
1916
|
a: number;
|
|
1922
1917
|
b: number;
|
|
1923
1918
|
c: number;
|
|
1924
|
-
},
|
|
1919
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1925
1920
|
affineA: number;
|
|
1926
1921
|
affineB: number;
|
|
1927
1922
|
x: number;
|
|
1928
1923
|
y: number;
|
|
1929
1924
|
isOnLine: boolean;
|
|
1930
|
-
},
|
|
1925
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1931
1926
|
a: number;
|
|
1932
1927
|
b: number;
|
|
1933
1928
|
c: number;
|
|
1934
1929
|
x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1935
1930
|
y: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1936
1931
|
isOnLine: boolean;
|
|
1937
|
-
},
|
|
1932
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1938
1933
|
pointIds: import("./math/geometry/point.js").PointIdentifiers;
|
|
1939
1934
|
vectorIds: import("./math/geometry/vector.js").VectorIdentifiers;
|
|
1940
|
-
},
|
|
1935
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1941
1936
|
aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1942
1937
|
bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1943
1938
|
xIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1944
|
-
},
|
|
1939
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1945
1940
|
b: number;
|
|
1946
1941
|
secondPoint: number[];
|
|
1947
|
-
},
|
|
1942
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1948
1943
|
a: number;
|
|
1949
1944
|
b: number;
|
|
1950
1945
|
isAskingA: boolean;
|
|
1951
|
-
},
|
|
1946
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1952
1947
|
xA: number;
|
|
1953
1948
|
xB: number;
|
|
1954
1949
|
yA: number;
|
|
1955
1950
|
yB: number;
|
|
1956
|
-
},
|
|
1951
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1957
1952
|
aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1958
1953
|
bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1959
|
-
},
|
|
1954
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1960
1955
|
aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1961
1956
|
bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1962
1957
|
fakeBIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1963
|
-
},
|
|
1958
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1964
1959
|
aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1965
1960
|
bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1966
1961
|
cIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1967
1962
|
colinearityCoeffIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1968
1963
|
fakeCIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1969
|
-
},
|
|
1964
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1970
1965
|
pointIds: import("./math/geometry/point.js").PointIdentifiers;
|
|
1971
1966
|
vectorIds: import("./math/geometry/vector.js").VectorIdentifiers;
|
|
1972
|
-
},
|
|
1967
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1973
1968
|
cartesianCoeffs1: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
1974
1969
|
cartesianCoeffs2: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
1975
|
-
},
|
|
1970
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1976
1971
|
aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1977
1972
|
bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
1978
|
-
},
|
|
1973
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1979
1974
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
1980
1975
|
type: number;
|
|
1981
1976
|
useAngles: boolean;
|
|
1982
|
-
},
|
|
1977
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1983
1978
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
1984
1979
|
angleAsked: number;
|
|
1985
|
-
},
|
|
1980
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1986
1981
|
perimeter: number;
|
|
1987
1982
|
askingX: boolean;
|
|
1988
|
-
},
|
|
1983
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1989
1984
|
shape: number;
|
|
1990
1985
|
side: number;
|
|
1991
|
-
},
|
|
1986
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1992
1987
|
shape: number;
|
|
1993
1988
|
side: number;
|
|
1994
|
-
},
|
|
1989
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1995
1990
|
coeffs: number[];
|
|
1996
1991
|
to: "+\\infty" | "-\\infty";
|
|
1997
|
-
},
|
|
1992
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
1998
1993
|
coeffs: number[];
|
|
1999
1994
|
to: "+\\infty" | "-\\infty";
|
|
2000
|
-
},
|
|
1995
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2001
1996
|
numCoeffs: number[];
|
|
2002
1997
|
denumCoeffs: number[];
|
|
2003
1998
|
isRight: boolean;
|
|
2004
|
-
},
|
|
1999
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2005
2000
|
limitTo: "+\\infty" | "-\\infty";
|
|
2006
2001
|
numCoeffs: number[];
|
|
2007
2002
|
denumCoeffs: number[];
|
|
2008
|
-
},
|
|
2003
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2009
2004
|
reason: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2010
2005
|
firstTerm: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2011
|
-
},
|
|
2006
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2012
2007
|
coeffs: number[];
|
|
2013
|
-
},
|
|
2008
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2014
2009
|
coeffs: number[];
|
|
2015
|
-
},
|
|
2010
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2016
2011
|
polyNumCoeffs: number[];
|
|
2017
2012
|
polyDenumCoeffs: number[];
|
|
2018
|
-
},
|
|
2013
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2019
2014
|
numCoeffs: number[];
|
|
2020
2015
|
denumCoeffs: number[];
|
|
2021
|
-
},
|
|
2016
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2022
2017
|
type: number;
|
|
2023
2018
|
to: string;
|
|
2024
2019
|
from: "+" | "-" | undefined;
|
|
@@ -2027,197 +2022,194 @@ declare const mathExercises: (Exercise<{
|
|
|
2027
2022
|
b?: number;
|
|
2028
2023
|
c?: number;
|
|
2029
2024
|
polyPoints?: number[][];
|
|
2030
|
-
},
|
|
2025
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2031
2026
|
a: string;
|
|
2032
2027
|
b: string;
|
|
2033
2028
|
c: string;
|
|
2034
2029
|
d: string;
|
|
2035
|
-
},
|
|
2030
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2036
2031
|
AiCoeff: number;
|
|
2037
2032
|
AjCoeff: number;
|
|
2038
2033
|
BiCoeff: number;
|
|
2039
2034
|
BjCoeff: number;
|
|
2040
2035
|
i: number;
|
|
2041
2036
|
j: number;
|
|
2042
|
-
},
|
|
2037
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2043
2038
|
isPercentToDecimal: boolean;
|
|
2044
2039
|
nb: number;
|
|
2045
|
-
},
|
|
2040
|
+
}, {
|
|
2041
|
+
conversionType: string;
|
|
2042
|
+
}> | Exercise<{
|
|
2046
2043
|
percent: number;
|
|
2047
2044
|
nb: number;
|
|
2048
|
-
},
|
|
2045
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2049
2046
|
indexSituation: number;
|
|
2050
2047
|
total: number;
|
|
2051
2048
|
lefties: number;
|
|
2052
|
-
|
|
2053
|
-
isPercentSymbolRequired: boolean;
|
|
2054
|
-
};
|
|
2055
|
-
}, {
|
|
2056
|
-
isPercentSymbolRequired: boolean;
|
|
2057
|
-
}, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
|
|
2049
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2058
2050
|
TVA: number;
|
|
2059
2051
|
ht: number;
|
|
2060
|
-
},
|
|
2052
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2061
2053
|
TTC: number;
|
|
2062
2054
|
TVA: number;
|
|
2063
|
-
},
|
|
2055
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2064
2056
|
ttc: number;
|
|
2065
2057
|
ht: number;
|
|
2066
2058
|
tva: number;
|
|
2067
|
-
},
|
|
2059
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2068
2060
|
contextType: number;
|
|
2069
2061
|
total: number;
|
|
2070
2062
|
populationPercent: number;
|
|
2071
|
-
},
|
|
2063
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2072
2064
|
subPopulationEffectif: number;
|
|
2073
2065
|
subPopulationPercent: number;
|
|
2074
2066
|
contextType: number;
|
|
2075
|
-
},
|
|
2067
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2076
2068
|
percent: number;
|
|
2077
2069
|
target: "decimalToPercent" | "fractionToPercent" | "percentToDecimal" | "percentToFraction";
|
|
2078
|
-
},
|
|
2070
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2079
2071
|
randNbr: number;
|
|
2080
2072
|
randPercent: number;
|
|
2081
2073
|
isUp: boolean;
|
|
2082
|
-
},
|
|
2074
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2083
2075
|
rate: number;
|
|
2084
2076
|
nbMois: number;
|
|
2085
|
-
},
|
|
2077
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2086
2078
|
evolution: number;
|
|
2087
|
-
},
|
|
2079
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2088
2080
|
evolutions: string[];
|
|
2089
|
-
},
|
|
2081
|
+
}, {
|
|
2082
|
+
nbEvos: string;
|
|
2083
|
+
}> | Exercise<{
|
|
2090
2084
|
randPercent: number;
|
|
2091
2085
|
isUp: boolean;
|
|
2092
|
-
},
|
|
2086
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2093
2087
|
evolution: number;
|
|
2094
|
-
},
|
|
2088
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2095
2089
|
vd: number;
|
|
2096
2090
|
vf: number;
|
|
2097
|
-
},
|
|
2091
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2098
2092
|
vf: number;
|
|
2099
2093
|
percentRate: number;
|
|
2100
|
-
},
|
|
2094
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2101
2095
|
vd: number;
|
|
2102
2096
|
percentRate: number;
|
|
2103
|
-
},
|
|
2097
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2104
2098
|
type: number;
|
|
2105
2099
|
price: number;
|
|
2106
2100
|
evolution: number;
|
|
2107
2101
|
askingFinalPrice: boolean;
|
|
2108
|
-
},
|
|
2102
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2109
2103
|
evolutions: number[];
|
|
2110
|
-
},
|
|
2104
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2111
2105
|
initialCapital: number;
|
|
2112
2106
|
rate: number;
|
|
2113
2107
|
duration: number;
|
|
2114
2108
|
}, {
|
|
2115
2109
|
withFormula?: boolean;
|
|
2116
|
-
}
|
|
2110
|
+
}> | Exercise<{
|
|
2117
2111
|
finalCapital: number;
|
|
2118
2112
|
rate: number;
|
|
2119
2113
|
duration: number;
|
|
2120
2114
|
}, {
|
|
2121
2115
|
withFormula?: boolean;
|
|
2122
|
-
}
|
|
2116
|
+
}> | Exercise<{
|
|
2123
2117
|
x: number;
|
|
2124
2118
|
y: number;
|
|
2125
|
-
},
|
|
2119
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2126
2120
|
x: number;
|
|
2127
2121
|
y: number;
|
|
2128
2122
|
z: number;
|
|
2129
|
-
},
|
|
2123
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2130
2124
|
int: number;
|
|
2131
2125
|
power: number;
|
|
2132
|
-
|
|
2133
|
-
isPowerAllowed: boolean;
|
|
2134
|
-
};
|
|
2126
|
+
isPowerAllowed: boolean;
|
|
2135
2127
|
}, {
|
|
2136
2128
|
isPowerAllowed: boolean;
|
|
2137
|
-
}
|
|
2129
|
+
}> | Exercise<{
|
|
2138
2130
|
int: number;
|
|
2139
2131
|
power: number;
|
|
2140
|
-
},
|
|
2132
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2141
2133
|
decimal: number;
|
|
2142
|
-
},
|
|
2134
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2143
2135
|
int: number;
|
|
2144
2136
|
power: number;
|
|
2145
|
-
},
|
|
2137
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2146
2138
|
a: number;
|
|
2147
2139
|
b: number;
|
|
2148
2140
|
c: number;
|
|
2149
2141
|
}, {
|
|
2150
2142
|
useOnlyPowersOfTen: boolean;
|
|
2151
|
-
}
|
|
2143
|
+
}> | Exercise<{
|
|
2152
2144
|
randPower: number;
|
|
2153
|
-
},
|
|
2145
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2154
2146
|
a: number;
|
|
2155
2147
|
b: number;
|
|
2156
2148
|
c: number;
|
|
2157
2149
|
}, {
|
|
2158
2150
|
useOnlyPowersOfTen: boolean;
|
|
2159
|
-
}
|
|
2151
|
+
}> | Exercise<{
|
|
2160
2152
|
a: number;
|
|
2161
2153
|
b: number;
|
|
2162
2154
|
c: number;
|
|
2163
2155
|
}, {
|
|
2164
2156
|
useOnlyPowersOfTen: boolean;
|
|
2165
2157
|
forbidNegativePower?: boolean;
|
|
2166
|
-
}
|
|
2158
|
+
}> | Exercise<{
|
|
2167
2159
|
tenPower: number;
|
|
2168
2160
|
decimal: number;
|
|
2169
|
-
},
|
|
2161
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2170
2162
|
a: number;
|
|
2171
2163
|
b: number;
|
|
2172
2164
|
k: number;
|
|
2173
2165
|
l: number;
|
|
2174
2166
|
m: number;
|
|
2175
2167
|
n: number | undefined;
|
|
2176
|
-
},
|
|
2168
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2177
2169
|
a: number;
|
|
2178
2170
|
b: number;
|
|
2179
2171
|
c: number;
|
|
2180
2172
|
d: number;
|
|
2181
|
-
},
|
|
2173
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2182
2174
|
a: number;
|
|
2183
2175
|
n: number;
|
|
2184
2176
|
isSimplified: boolean;
|
|
2185
|
-
},
|
|
2177
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2186
2178
|
c: number;
|
|
2187
|
-
},
|
|
2179
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2188
2180
|
coeffs: number[];
|
|
2189
|
-
},
|
|
2181
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2190
2182
|
a: number;
|
|
2191
|
-
},
|
|
2183
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2192
2184
|
coeffs: number[];
|
|
2193
|
-
},
|
|
2185
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2194
2186
|
coeffs: number[];
|
|
2195
|
-
},
|
|
2187
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2196
2188
|
a: number;
|
|
2197
2189
|
isCos: boolean;
|
|
2198
|
-
},
|
|
2190
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2199
2191
|
coeffs: number[];
|
|
2200
2192
|
isCos: boolean;
|
|
2201
|
-
},
|
|
2193
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2202
2194
|
type: number;
|
|
2203
2195
|
a?: number;
|
|
2204
2196
|
coeffs?: number[];
|
|
2205
2197
|
isCos?: boolean;
|
|
2206
2198
|
c?: number;
|
|
2207
|
-
},
|
|
2199
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2208
2200
|
kIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2209
2201
|
uCoeffs: number[];
|
|
2210
|
-
},
|
|
2202
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2211
2203
|
kIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2212
2204
|
uCoeffs: number[];
|
|
2213
|
-
},
|
|
2205
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2214
2206
|
flip: number;
|
|
2215
2207
|
pA?: number;
|
|
2216
2208
|
pB?: number;
|
|
2217
2209
|
pAB?: number;
|
|
2218
2210
|
pA_B?: number;
|
|
2219
2211
|
pB_A?: number;
|
|
2220
|
-
},
|
|
2212
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2221
2213
|
A: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2222
2214
|
B: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2223
2215
|
AC: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
@@ -2229,58 +2221,60 @@ declare const mathExercises: (Exercise<{
|
|
|
2229
2221
|
allowApproximate: string;
|
|
2230
2222
|
eventTypes: string[];
|
|
2231
2223
|
probaType: string;
|
|
2232
|
-
}
|
|
2224
|
+
}> | Exercise<{
|
|
2233
2225
|
randomValues: number[];
|
|
2234
2226
|
randomEffectives: number[];
|
|
2235
|
-
},
|
|
2227
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2236
2228
|
x1: number;
|
|
2237
2229
|
x2: number;
|
|
2238
2230
|
x3: number;
|
|
2239
2231
|
x4: number;
|
|
2240
2232
|
rand: number;
|
|
2241
|
-
},
|
|
2233
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2242
2234
|
randomValues: number[];
|
|
2243
2235
|
randomEffectives: number[];
|
|
2244
|
-
},
|
|
2236
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2245
2237
|
sortedValues: number[];
|
|
2246
|
-
},
|
|
2238
|
+
}, {
|
|
2239
|
+
nbValues: string;
|
|
2240
|
+
}> | Exercise<{
|
|
2247
2241
|
randomValues: number[];
|
|
2248
2242
|
randomEffectives: number[];
|
|
2249
2243
|
randomQuartile: number;
|
|
2250
|
-
},
|
|
2244
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2251
2245
|
randomValues: number[];
|
|
2252
2246
|
randomQuartile: number;
|
|
2253
2247
|
}, {
|
|
2254
|
-
nbValues:
|
|
2255
|
-
}
|
|
2248
|
+
nbValues: string;
|
|
2249
|
+
}> | Exercise<{
|
|
2256
2250
|
sortedValues: number[];
|
|
2257
|
-
},
|
|
2251
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2258
2252
|
sortedValues: number[];
|
|
2259
|
-
},
|
|
2253
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2260
2254
|
sortedValues: number[];
|
|
2261
|
-
},
|
|
2255
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2262
2256
|
sortedValues: number[];
|
|
2263
2257
|
effectifs: number[];
|
|
2264
|
-
},
|
|
2258
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2265
2259
|
sortedValues: number[];
|
|
2266
|
-
},
|
|
2260
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2267
2261
|
sortedValues: number[];
|
|
2268
2262
|
effectifs: number[];
|
|
2269
|
-
},
|
|
2263
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2270
2264
|
sortedValues: number[];
|
|
2271
|
-
},
|
|
2265
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2272
2266
|
sortedValues: number[];
|
|
2273
2267
|
effectifs: number[];
|
|
2274
|
-
},
|
|
2268
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2275
2269
|
indicatorAsked: string;
|
|
2276
2270
|
values: number[];
|
|
2277
2271
|
}, {
|
|
2278
2272
|
indicators: string[];
|
|
2279
|
-
}
|
|
2273
|
+
}> | Exercise<{
|
|
2280
2274
|
labels: number[];
|
|
2281
2275
|
serie1: number[];
|
|
2282
2276
|
serie2: number[];
|
|
2283
|
-
},
|
|
2277
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2284
2278
|
kind: "factor";
|
|
2285
2279
|
a: number;
|
|
2286
2280
|
operator: "multiplication" | "division" | "soustraction" | "addition";
|
|
@@ -2290,44 +2284,44 @@ declare const mathExercises: (Exercise<{
|
|
|
2290
2284
|
series: number[];
|
|
2291
2285
|
operator: "multiplication" | "division" | "soustraction" | "addition";
|
|
2292
2286
|
factor: number;
|
|
2293
|
-
},
|
|
2287
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2294
2288
|
xValues: number[];
|
|
2295
2289
|
yValues: number[];
|
|
2296
|
-
},
|
|
2290
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2297
2291
|
xVals: number[];
|
|
2298
2292
|
yVals: number[];
|
|
2299
2293
|
x: number;
|
|
2300
|
-
},
|
|
2294
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2301
2295
|
labels: string[];
|
|
2302
2296
|
serie1: number[];
|
|
2303
2297
|
serie2: number[];
|
|
2304
2298
|
a?: number;
|
|
2305
2299
|
b: number;
|
|
2306
2300
|
isBetween: boolean;
|
|
2307
|
-
},
|
|
2301
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2308
2302
|
dictNameForSerie: Record<string, number[]>;
|
|
2309
2303
|
answerName: string;
|
|
2310
2304
|
isLess: boolean;
|
|
2311
|
-
},
|
|
2305
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2312
2306
|
a: number;
|
|
2313
2307
|
values: number[];
|
|
2314
2308
|
isAboveA: boolean;
|
|
2315
2309
|
isQuestionIsAboveA: boolean;
|
|
2316
|
-
},
|
|
2310
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2317
2311
|
xValues: number[];
|
|
2318
2312
|
yValues: number[];
|
|
2319
|
-
},
|
|
2313
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2320
2314
|
isJustified: boolean;
|
|
2321
2315
|
cloudPointsIdentifiers: import("./math/geometry/CloudPoints.js").CloudPointsIdentifiers;
|
|
2322
|
-
},
|
|
2316
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2323
2317
|
pA: number;
|
|
2324
2318
|
pB: number;
|
|
2325
2319
|
pUnion: number;
|
|
2326
|
-
},
|
|
2320
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2327
2321
|
questionType: string;
|
|
2328
2322
|
value?: string;
|
|
2329
2323
|
color?: string;
|
|
2330
|
-
},
|
|
2324
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2331
2325
|
aCapB: number;
|
|
2332
2326
|
aCapBBarre: number;
|
|
2333
2327
|
aBarreCapB: number;
|
|
@@ -2337,30 +2331,36 @@ declare const mathExercises: (Exercise<{
|
|
|
2337
2331
|
probaFrac: number[];
|
|
2338
2332
|
}, {
|
|
2339
2333
|
forbidConditionnal?: boolean;
|
|
2340
|
-
}
|
|
2341
|
-
|
|
2342
|
-
|
|
2343
|
-
|
|
2344
|
-
|
|
2334
|
+
}> | Exercise<{
|
|
2335
|
+
indexSituation: number;
|
|
2336
|
+
values: {
|
|
2337
|
+
"A \\cap B": number;
|
|
2338
|
+
"A \\cap \\overline{B}": number;
|
|
2339
|
+
"\\overline{A} \\cap B": number;
|
|
2340
|
+
"\\overline{A} \\cap \\overline{B}": number;
|
|
2341
|
+
};
|
|
2345
2342
|
event: string;
|
|
2346
2343
|
type: string;
|
|
2347
2344
|
probaFrac: number[];
|
|
2348
|
-
|
|
2345
|
+
allowedAnsType: string[];
|
|
2346
|
+
}, {
|
|
2347
|
+
allowedAnsType: string[];
|
|
2348
|
+
}> | Exercise<{
|
|
2349
2349
|
exerciseVars: {
|
|
2350
2350
|
n: number;
|
|
2351
2351
|
k: number;
|
|
2352
2352
|
a: number;
|
|
2353
2353
|
b: number;
|
|
2354
2354
|
};
|
|
2355
|
-
},
|
|
2355
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2356
2356
|
nX: number;
|
|
2357
2357
|
a: number;
|
|
2358
2358
|
b: number;
|
|
2359
|
-
},
|
|
2359
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2360
2360
|
nX: number;
|
|
2361
2361
|
a: number;
|
|
2362
2362
|
b: number;
|
|
2363
|
-
},
|
|
2363
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2364
2364
|
n: number;
|
|
2365
2365
|
p: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2366
2366
|
interval: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
|
|
@@ -2368,40 +2368,43 @@ declare const mathExercises: (Exercise<{
|
|
|
2368
2368
|
isSentence: boolean;
|
|
2369
2369
|
}, {
|
|
2370
2370
|
instructionType: string;
|
|
2371
|
-
}
|
|
2371
|
+
}> | Exercise<{
|
|
2372
2372
|
type: number;
|
|
2373
2373
|
caracType: string;
|
|
2374
2374
|
k: number;
|
|
2375
2375
|
nbEssais: number;
|
|
2376
2376
|
}, {
|
|
2377
2377
|
useFractions?: boolean;
|
|
2378
|
-
}
|
|
2378
|
+
}> | Exercise<{
|
|
2379
2379
|
values: number[];
|
|
2380
2380
|
target: number;
|
|
2381
|
-
|
|
2381
|
+
allowedAnsType: string[];
|
|
2382
|
+
}, {
|
|
2383
|
+
allowedAnsType: string[];
|
|
2384
|
+
}> | Exercise<{
|
|
2382
2385
|
xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
2383
2386
|
yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
2384
|
-
},
|
|
2387
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2385
2388
|
xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
2386
2389
|
yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
2387
|
-
},
|
|
2390
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2388
2391
|
xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
2389
2392
|
yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
2390
2393
|
isLaw: boolean;
|
|
2391
|
-
},
|
|
2394
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2392
2395
|
xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
2393
2396
|
yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
2394
|
-
},
|
|
2397
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2395
2398
|
pA: number;
|
|
2396
2399
|
pB: number;
|
|
2397
2400
|
pUnion: number;
|
|
2398
2401
|
pIntersection: number;
|
|
2399
2402
|
target: "pA" | "pB" | "pUnion" | "pIntersection";
|
|
2400
|
-
},
|
|
2403
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2401
2404
|
total: number;
|
|
2402
2405
|
distribution: number[];
|
|
2403
2406
|
observe: boolean;
|
|
2404
|
-
},
|
|
2407
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2405
2408
|
eventA: {
|
|
2406
2409
|
desc: string;
|
|
2407
2410
|
isComplementary: boolean;
|
|
@@ -2411,7 +2414,7 @@ declare const mathExercises: (Exercise<{
|
|
|
2411
2414
|
isComplementary: boolean;
|
|
2412
2415
|
};
|
|
2413
2416
|
question: "union" | "intersection" | "comp";
|
|
2414
|
-
},
|
|
2417
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2415
2418
|
eventA: {
|
|
2416
2419
|
desc: string;
|
|
2417
2420
|
isComplementary: boolean;
|
|
@@ -2421,33 +2424,33 @@ declare const mathExercises: (Exercise<{
|
|
|
2421
2424
|
isComplementary: boolean;
|
|
2422
2425
|
};
|
|
2423
2426
|
question: "union" | "intersection" | "comp";
|
|
2424
|
-
},
|
|
2427
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2425
2428
|
repartitions: number[];
|
|
2426
2429
|
colorAskedIndex: number;
|
|
2427
|
-
},
|
|
2430
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2428
2431
|
questionType: string;
|
|
2429
2432
|
value?: string;
|
|
2430
2433
|
color?: import("./exercises/utils/cardsData.js").CardsColor;
|
|
2431
|
-
},
|
|
2434
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2432
2435
|
isParityQuestion: boolean;
|
|
2433
2436
|
isEvenQuestion: boolean;
|
|
2434
2437
|
nbFaces: number;
|
|
2435
2438
|
faceAsked: number;
|
|
2436
|
-
},
|
|
2439
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2437
2440
|
pA: number;
|
|
2438
|
-
},
|
|
2441
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2439
2442
|
labels: string[];
|
|
2440
2443
|
pValues: number[];
|
|
2441
2444
|
missingIndex: number;
|
|
2442
|
-
},
|
|
2445
|
+
}, Record<string, string | boolean | string[]>> | Exercise<MathExercises.Identifiers, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2443
2446
|
a: number;
|
|
2444
2447
|
type: number;
|
|
2445
|
-
},
|
|
2448
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2446
2449
|
arrayOfNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
2447
2450
|
isFilterPossibleProba: boolean;
|
|
2448
2451
|
}, {
|
|
2449
2452
|
numberTypes: string[];
|
|
2450
|
-
}
|
|
2453
|
+
}> | Exercise<{
|
|
2451
2454
|
indexSituation: number;
|
|
2452
2455
|
eventIds: {
|
|
2453
2456
|
type: "elementary";
|
|
@@ -2471,181 +2474,181 @@ declare const mathExercises: (Exercise<{
|
|
|
2471
2474
|
};
|
|
2472
2475
|
arrProba: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
|
|
2473
2476
|
}, {
|
|
2474
|
-
nbElem:
|
|
2475
|
-
unionLength:
|
|
2476
|
-
isProbasAreNumbers: boolean
|
|
2477
|
-
}
|
|
2477
|
+
nbElem: string[];
|
|
2478
|
+
unionLength: string[];
|
|
2479
|
+
isProbasAreNumbers: boolean;
|
|
2480
|
+
}> | Exercise<{
|
|
2478
2481
|
situationIndex: number;
|
|
2479
2482
|
dictShuffle: Record<string, string>;
|
|
2480
2483
|
pType: string;
|
|
2481
|
-
},
|
|
2484
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2482
2485
|
firstValue: number;
|
|
2483
2486
|
askedRank: number;
|
|
2484
2487
|
reason: number;
|
|
2485
|
-
},
|
|
2488
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2486
2489
|
firstValue: number;
|
|
2487
2490
|
reason: number;
|
|
2488
|
-
},
|
|
2491
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2489
2492
|
rank1: number;
|
|
2490
2493
|
reason: number;
|
|
2491
2494
|
value1: number;
|
|
2492
|
-
},
|
|
2495
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2493
2496
|
reason: number;
|
|
2494
2497
|
startRank: number;
|
|
2495
2498
|
startValue: number;
|
|
2496
|
-
},
|
|
2499
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2497
2500
|
firstRank: number;
|
|
2498
2501
|
firstValue: number;
|
|
2499
2502
|
reason: number;
|
|
2500
|
-
},
|
|
2503
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2501
2504
|
firstValue: number;
|
|
2502
2505
|
reason: number;
|
|
2503
2506
|
randValue: number;
|
|
2504
|
-
},
|
|
2507
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2505
2508
|
final: number;
|
|
2506
|
-
},
|
|
2509
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2507
2510
|
sequences: number[][];
|
|
2508
2511
|
answerIndex: number;
|
|
2509
|
-
},
|
|
2512
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2510
2513
|
reason: number;
|
|
2511
2514
|
sequence: number[];
|
|
2512
|
-
},
|
|
2515
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2513
2516
|
reason: number;
|
|
2514
2517
|
sequence: number[];
|
|
2515
|
-
},
|
|
2518
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2516
2519
|
isAri: boolean;
|
|
2517
2520
|
sequence: number[];
|
|
2518
|
-
},
|
|
2521
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2519
2522
|
firstRank: number;
|
|
2520
2523
|
firstValue: number;
|
|
2521
2524
|
reason: number;
|
|
2522
2525
|
nbTerms: number;
|
|
2523
|
-
},
|
|
2526
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2524
2527
|
firstValue: number;
|
|
2525
2528
|
reason: number;
|
|
2526
2529
|
firstRank: number;
|
|
2527
|
-
},
|
|
2530
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2528
2531
|
rank1: number;
|
|
2529
2532
|
rank2: number;
|
|
2530
2533
|
reason: number;
|
|
2531
2534
|
value1: number;
|
|
2532
|
-
},
|
|
2535
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2533
2536
|
rank1: number;
|
|
2534
2537
|
value1: number;
|
|
2535
2538
|
rank2: number;
|
|
2536
2539
|
value2: number;
|
|
2537
2540
|
rankAsked: number;
|
|
2538
|
-
},
|
|
2541
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2539
2542
|
firstRank: number;
|
|
2540
2543
|
firstTerm: number;
|
|
2541
2544
|
reason: number;
|
|
2542
2545
|
askedRank: number;
|
|
2543
|
-
},
|
|
2546
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2544
2547
|
a: number;
|
|
2545
2548
|
b: number;
|
|
2546
2549
|
n: number;
|
|
2547
|
-
},
|
|
2550
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2548
2551
|
firstValue: number;
|
|
2549
2552
|
reason: number;
|
|
2550
2553
|
askedRank: number;
|
|
2551
|
-
},
|
|
2554
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2552
2555
|
reason: number;
|
|
2553
2556
|
firstValue: number;
|
|
2554
|
-
},
|
|
2557
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2555
2558
|
value1: number;
|
|
2556
2559
|
reason: number;
|
|
2557
2560
|
rank1: number;
|
|
2558
|
-
},
|
|
2561
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2559
2562
|
raison: number;
|
|
2560
2563
|
final: number;
|
|
2561
|
-
},
|
|
2564
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2562
2565
|
reason: number;
|
|
2563
2566
|
startRank: number;
|
|
2564
2567
|
askedRank: number;
|
|
2565
2568
|
startValue: number;
|
|
2566
|
-
},
|
|
2569
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2567
2570
|
firstValue: number;
|
|
2568
2571
|
reason: number;
|
|
2569
2572
|
firstRank: number;
|
|
2570
|
-
},
|
|
2573
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2571
2574
|
reason: number;
|
|
2572
2575
|
firstValue: number;
|
|
2573
2576
|
firstRank: number;
|
|
2574
|
-
},
|
|
2577
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2575
2578
|
firstRank: number;
|
|
2576
2579
|
firstTerm: number;
|
|
2577
2580
|
reason: number;
|
|
2578
2581
|
askedRank: number;
|
|
2579
|
-
},
|
|
2582
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2580
2583
|
sequence: number[];
|
|
2581
2584
|
reason: number;
|
|
2582
|
-
},
|
|
2585
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2583
2586
|
firstRank: number;
|
|
2584
2587
|
firstValue: number;
|
|
2585
2588
|
reason: number;
|
|
2586
2589
|
nbTerms: number;
|
|
2587
|
-
},
|
|
2590
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2588
2591
|
q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2589
2592
|
a: number;
|
|
2590
|
-
},
|
|
2593
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2591
2594
|
rank: number;
|
|
2592
2595
|
coeffs: number[];
|
|
2593
|
-
},
|
|
2596
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2594
2597
|
coeffs: number[];
|
|
2595
|
-
},
|
|
2598
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2596
2599
|
rank: number;
|
|
2597
2600
|
u0: number;
|
|
2598
2601
|
coeffs: number[];
|
|
2599
|
-
},
|
|
2602
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2600
2603
|
termeid: number;
|
|
2601
2604
|
affine: number[];
|
|
2602
2605
|
termeAdd: number;
|
|
2603
2606
|
termeMult: number;
|
|
2604
|
-
},
|
|
2607
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2605
2608
|
nValue: number;
|
|
2606
2609
|
points: number[][];
|
|
2607
2610
|
isArithmetic: boolean;
|
|
2608
|
-
},
|
|
2611
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2609
2612
|
intervalIdentifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
|
|
2610
|
-
},
|
|
2613
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2611
2614
|
int1Identifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
|
|
2612
2615
|
int2Identifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
|
|
2613
|
-
},
|
|
2616
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2614
2617
|
int1Identifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
|
|
2615
2618
|
int2Identifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
|
|
2616
|
-
},
|
|
2619
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2617
2620
|
intervalIdentifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
|
|
2618
|
-
},
|
|
2621
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2619
2622
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2620
2623
|
interval: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2621
|
-
},
|
|
2624
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2622
2625
|
intervalNodeIdentifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
|
|
2623
|
-
},
|
|
2626
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2624
2627
|
type: number;
|
|
2625
2628
|
nb: string;
|
|
2626
|
-
},
|
|
2629
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2627
2630
|
isQuestionAboutNotation: boolean;
|
|
2628
2631
|
caseNumber: number;
|
|
2629
|
-
},
|
|
2632
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2630
2633
|
subset: number;
|
|
2631
2634
|
set: number;
|
|
2632
|
-
},
|
|
2635
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2633
2636
|
options: {
|
|
2634
2637
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2635
2638
|
isDecimal: boolean;
|
|
2636
2639
|
}[];
|
|
2637
|
-
},
|
|
2640
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2638
2641
|
x: number;
|
|
2639
2642
|
y: number;
|
|
2640
2643
|
z: number;
|
|
2641
|
-
},
|
|
2644
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2642
2645
|
ax: number;
|
|
2643
2646
|
ay: number;
|
|
2644
2647
|
az: number;
|
|
2645
2648
|
bx: number;
|
|
2646
2649
|
by: number;
|
|
2647
2650
|
bz: number;
|
|
2648
|
-
},
|
|
2651
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2649
2652
|
a: number;
|
|
2650
2653
|
b: number;
|
|
2651
2654
|
ux: number;
|
|
@@ -2654,29 +2657,29 @@ declare const mathExercises: (Exercise<{
|
|
|
2654
2657
|
vx: number;
|
|
2655
2658
|
vy: number;
|
|
2656
2659
|
vz: number;
|
|
2657
|
-
},
|
|
2660
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2658
2661
|
l: number;
|
|
2659
2662
|
L: number;
|
|
2660
2663
|
h: number;
|
|
2661
2664
|
askedPoint: string;
|
|
2662
2665
|
givenPoints: string[];
|
|
2663
|
-
},
|
|
2666
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2664
2667
|
sqrtOperand: number;
|
|
2665
|
-
},
|
|
2668
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2666
2669
|
k: number;
|
|
2667
|
-
},
|
|
2670
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2668
2671
|
type: number;
|
|
2669
2672
|
a: number;
|
|
2670
2673
|
x: number;
|
|
2671
2674
|
b: number | undefined;
|
|
2672
2675
|
y: number;
|
|
2673
2676
|
otherTermIsSqrt: boolean;
|
|
2674
|
-
},
|
|
2677
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2675
2678
|
a: number;
|
|
2676
2679
|
b: number;
|
|
2677
2680
|
c: number;
|
|
2678
2681
|
d: number;
|
|
2679
|
-
},
|
|
2682
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2680
2683
|
a: number;
|
|
2681
2684
|
b: number;
|
|
2682
2685
|
c: number;
|
|
@@ -2684,213 +2687,213 @@ declare const mathExercises: (Exercise<{
|
|
|
2684
2687
|
x: number;
|
|
2685
2688
|
y: number;
|
|
2686
2689
|
z: number | undefined;
|
|
2687
|
-
},
|
|
2690
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2688
2691
|
a: number;
|
|
2689
2692
|
b: number;
|
|
2690
2693
|
c: number;
|
|
2691
2694
|
d: number;
|
|
2692
|
-
},
|
|
2695
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2693
2696
|
a: number;
|
|
2694
2697
|
b: number;
|
|
2695
2698
|
c: number;
|
|
2696
2699
|
d: number;
|
|
2697
|
-
},
|
|
2700
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2698
2701
|
a: number;
|
|
2699
2702
|
k: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2700
2703
|
isSquareInside: boolean;
|
|
2701
|
-
},
|
|
2704
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2702
2705
|
valueIndex: number;
|
|
2703
2706
|
isCos: boolean;
|
|
2704
|
-
},
|
|
2707
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2705
2708
|
mainValue: number;
|
|
2706
2709
|
isCos: boolean;
|
|
2707
2710
|
angleIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2708
|
-
},
|
|
2711
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2709
2712
|
randAngle: number;
|
|
2710
2713
|
randTrigo: number;
|
|
2711
2714
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
2712
|
-
},
|
|
2715
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2713
2716
|
randAngle: number;
|
|
2714
2717
|
hiddenSide: number;
|
|
2715
2718
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
2716
|
-
},
|
|
2719
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2717
2720
|
sideAsked: number;
|
|
2718
2721
|
givenSide: number;
|
|
2719
2722
|
givenAngle: number;
|
|
2720
2723
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
2721
|
-
},
|
|
2724
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2722
2725
|
angleValue: number;
|
|
2723
2726
|
angleIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2724
2727
|
point: string;
|
|
2725
|
-
},
|
|
2728
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2726
2729
|
trigFunction: string;
|
|
2727
2730
|
trigValue: number;
|
|
2728
2731
|
angleInDegrees: number;
|
|
2729
|
-
},
|
|
2732
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2730
2733
|
degree: number;
|
|
2731
2734
|
trigoFunct: string;
|
|
2732
|
-
},
|
|
2735
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2733
2736
|
degree: number;
|
|
2734
|
-
},
|
|
2737
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2735
2738
|
degree: number;
|
|
2736
|
-
},
|
|
2739
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2737
2740
|
degree: number;
|
|
2738
|
-
},
|
|
2741
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2739
2742
|
degree: number;
|
|
2740
2743
|
multipleOf2PiToAdd: number;
|
|
2741
2744
|
nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2742
|
-
},
|
|
2745
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2743
2746
|
degree: number;
|
|
2744
2747
|
radianNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2745
2748
|
isDegreeToRadian: boolean;
|
|
2746
|
-
},
|
|
2749
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2747
2750
|
radius: number;
|
|
2748
2751
|
thetaInDegree: number | undefined;
|
|
2749
2752
|
thetaInRadNodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers | undefined;
|
|
2750
2753
|
isThetaInDegree: boolean;
|
|
2751
|
-
},
|
|
2754
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2752
2755
|
degree: number;
|
|
2753
2756
|
leftBoundPiMultiple: number;
|
|
2754
|
-
},
|
|
2757
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2755
2758
|
givenValue: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
2756
2759
|
isCosGiven: boolean;
|
|
2757
|
-
},
|
|
2760
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2758
2761
|
initialValue: number;
|
|
2759
2762
|
step: number;
|
|
2760
2763
|
iterations: number;
|
|
2761
2764
|
opIndex: number;
|
|
2762
|
-
},
|
|
2765
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2763
2766
|
a: number;
|
|
2764
2767
|
b: number;
|
|
2765
2768
|
op: string;
|
|
2766
|
-
},
|
|
2769
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2767
2770
|
a: number;
|
|
2768
2771
|
b: number;
|
|
2769
2772
|
id1: number;
|
|
2770
2773
|
id2: number;
|
|
2771
|
-
},
|
|
2774
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2772
2775
|
initialValue: number;
|
|
2773
2776
|
step: number;
|
|
2774
2777
|
iterations: number;
|
|
2775
2778
|
opIndex: number;
|
|
2776
|
-
},
|
|
2779
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2777
2780
|
initialValue: number;
|
|
2778
2781
|
step: number;
|
|
2779
2782
|
opIndex: number;
|
|
2780
2783
|
a: number;
|
|
2781
2784
|
x: number;
|
|
2782
|
-
},
|
|
2785
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2783
2786
|
x: number;
|
|
2784
2787
|
trinom: number[];
|
|
2785
2788
|
image: number;
|
|
2786
|
-
},
|
|
2789
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2787
2790
|
a: number;
|
|
2788
2791
|
b: number;
|
|
2789
2792
|
opName: string;
|
|
2790
2793
|
condition: string;
|
|
2791
|
-
},
|
|
2794
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2792
2795
|
op: string;
|
|
2793
2796
|
n: number;
|
|
2794
2797
|
p: number;
|
|
2795
|
-
},
|
|
2798
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2796
2799
|
isCondition: boolean;
|
|
2797
2800
|
inputValue: number;
|
|
2798
|
-
},
|
|
2801
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2799
2802
|
v: string | number;
|
|
2800
2803
|
vType: string;
|
|
2801
|
-
},
|
|
2804
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2802
2805
|
inputValue: number;
|
|
2803
2806
|
threshold: number;
|
|
2804
|
-
},
|
|
2807
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2805
2808
|
a: number;
|
|
2806
2809
|
b: number;
|
|
2807
2810
|
opName: string;
|
|
2808
2811
|
condition: string;
|
|
2809
|
-
},
|
|
2812
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2810
2813
|
variableName: string;
|
|
2811
2814
|
initialVariable: number;
|
|
2812
2815
|
affines: import("./math/polynomials/affine.js").Affine[];
|
|
2813
|
-
},
|
|
2816
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2814
2817
|
a: number;
|
|
2815
2818
|
b: number;
|
|
2816
2819
|
opName: string;
|
|
2817
2820
|
ineqs: string[];
|
|
2818
|
-
},
|
|
2821
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2819
2822
|
coeff: number;
|
|
2820
2823
|
iterations: number;
|
|
2821
2824
|
operation: string;
|
|
2822
|
-
},
|
|
2825
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2823
2826
|
ineq: string;
|
|
2824
2827
|
coeff: number;
|
|
2825
|
-
},
|
|
2828
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2826
2829
|
threshold: number;
|
|
2827
|
-
},
|
|
2830
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2828
2831
|
operation: string;
|
|
2829
2832
|
coeff: number;
|
|
2830
|
-
},
|
|
2833
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2831
2834
|
coeff: number;
|
|
2832
2835
|
iterations: number;
|
|
2833
2836
|
operation: string;
|
|
2834
|
-
},
|
|
2837
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2835
2838
|
m: number;
|
|
2836
2839
|
p: number;
|
|
2837
|
-
},
|
|
2840
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2838
2841
|
p: number;
|
|
2839
2842
|
n: number;
|
|
2840
2843
|
wordingType: number;
|
|
2841
|
-
},
|
|
2844
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2842
2845
|
k: number;
|
|
2843
2846
|
n: number;
|
|
2844
2847
|
wordingType: number;
|
|
2845
|
-
},
|
|
2848
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2846
2849
|
p: number;
|
|
2847
2850
|
k: number;
|
|
2848
2851
|
n: number;
|
|
2849
2852
|
isRepresentative: boolean;
|
|
2850
2853
|
wordingType: number;
|
|
2851
|
-
},
|
|
2854
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2852
2855
|
expCount: number;
|
|
2853
2856
|
repCount: number;
|
|
2854
2857
|
isSize: boolean;
|
|
2855
2858
|
}, {
|
|
2856
2859
|
isSize?: boolean;
|
|
2857
|
-
}
|
|
2860
|
+
}> | Exercise<{
|
|
2858
2861
|
samples: number[];
|
|
2859
|
-
},
|
|
2862
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2860
2863
|
values: number[][];
|
|
2861
2864
|
caseAsked: number;
|
|
2862
|
-
},
|
|
2865
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2863
2866
|
labels: string[];
|
|
2864
2867
|
data: number[];
|
|
2865
2868
|
itemAsked: number;
|
|
2866
|
-
},
|
|
2869
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2867
2870
|
isAskingX: boolean;
|
|
2868
2871
|
xValue?: number;
|
|
2869
2872
|
yValue?: number;
|
|
2870
2873
|
a: number;
|
|
2871
2874
|
b: number;
|
|
2872
|
-
},
|
|
2875
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2873
2876
|
points: number[][];
|
|
2874
2877
|
labels: string[];
|
|
2875
|
-
},
|
|
2878
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2876
2879
|
bounds: number[];
|
|
2877
2880
|
data: number[];
|
|
2878
2881
|
itemAsked: number;
|
|
2879
|
-
},
|
|
2882
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2880
2883
|
quartiles: number[];
|
|
2881
2884
|
arrQuartileIndex: (0 | 1 | 2 | 3 | 4)[];
|
|
2882
2885
|
typeQ: "below" | "between" | "above";
|
|
2883
|
-
},
|
|
2886
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2884
2887
|
quartileIndex: 0 | 1 | 2 | 3 | 4;
|
|
2885
2888
|
quartiles: number[];
|
|
2886
|
-
},
|
|
2889
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2887
2890
|
indexTopic: number;
|
|
2888
2891
|
isLess: boolean;
|
|
2889
2892
|
arrDistrib: {
|
|
2890
2893
|
name: string;
|
|
2891
2894
|
indicators: number[];
|
|
2892
2895
|
}[];
|
|
2893
|
-
},
|
|
2896
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2894
2897
|
barChart: {
|
|
2895
2898
|
description: string;
|
|
2896
2899
|
axisLabels: string[];
|
|
@@ -2928,30 +2931,30 @@ declare const mathExercises: (Exercise<{
|
|
|
2928
2931
|
displayType: string;
|
|
2929
2932
|
}, {
|
|
2930
2933
|
displayType: string;
|
|
2931
|
-
}
|
|
2934
|
+
}> | Exercise<{
|
|
2932
2935
|
indexSituation: number;
|
|
2933
2936
|
bigNumber: number;
|
|
2934
|
-
},
|
|
2937
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2935
2938
|
xValues: number[];
|
|
2936
2939
|
yValues: number[];
|
|
2937
2940
|
answerIndex: number;
|
|
2938
2941
|
isLess: boolean;
|
|
2939
|
-
},
|
|
2942
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2940
2943
|
cloudPointsIdentifiers: import("./math/geometry/CloudPoints.js").CloudPointsIdentifiers;
|
|
2941
2944
|
evolutionType: string;
|
|
2942
|
-
},
|
|
2945
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2943
2946
|
quartiles: number[];
|
|
2944
|
-
},
|
|
2947
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2945
2948
|
indexSituation: number;
|
|
2946
2949
|
maxOrScam: number;
|
|
2947
|
-
},
|
|
2950
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2948
2951
|
indexSituation: number;
|
|
2949
2952
|
bigNumber: number;
|
|
2950
2953
|
values: number[];
|
|
2951
|
-
},
|
|
2954
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2952
2955
|
points: number[][];
|
|
2953
2956
|
labels: string[];
|
|
2954
|
-
},
|
|
2957
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2955
2958
|
points: number[][];
|
|
2956
2959
|
parties: {
|
|
2957
2960
|
name: string;
|
|
@@ -2966,80 +2969,80 @@ declare const mathExercises: (Exercise<{
|
|
|
2966
2969
|
}[];
|
|
2967
2970
|
p: number;
|
|
2968
2971
|
}[];
|
|
2969
|
-
},
|
|
2972
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2970
2973
|
epsilon: number;
|
|
2971
2974
|
l: number;
|
|
2972
2975
|
molecule: string;
|
|
2973
|
-
},
|
|
2976
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2974
2977
|
concentrationMere: number;
|
|
2975
2978
|
volumeFille: number;
|
|
2976
2979
|
concentrationFille: number;
|
|
2977
|
-
},
|
|
2980
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2978
2981
|
randomMoleculeIndex: number;
|
|
2979
|
-
},
|
|
2982
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2980
2983
|
atomicMass: number;
|
|
2981
2984
|
atomicNumber: number;
|
|
2982
2985
|
isAsking: string;
|
|
2983
2986
|
symbol: string;
|
|
2984
|
-
},
|
|
2987
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2985
2988
|
mass: number;
|
|
2986
2989
|
velocity: number;
|
|
2987
|
-
},
|
|
2990
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2988
2991
|
mG: number;
|
|
2989
2992
|
randomMoleculeIndex: number;
|
|
2990
|
-
},
|
|
2993
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2991
2994
|
randomMoleculeIndex: number;
|
|
2992
|
-
},
|
|
2995
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2993
2996
|
randomMoleculeIndex: number;
|
|
2994
|
-
},
|
|
2997
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2995
2998
|
order: number;
|
|
2996
2999
|
multiplier: number;
|
|
2997
|
-
},
|
|
3000
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
2998
3001
|
randomNumber: number;
|
|
2999
3002
|
randomTenPower: number;
|
|
3000
|
-
},
|
|
3003
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3001
3004
|
frequencyEmitted: number;
|
|
3002
3005
|
ambulanceSpeed: number;
|
|
3003
|
-
},
|
|
3006
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3004
3007
|
mass: number;
|
|
3005
3008
|
height: number;
|
|
3006
|
-
},
|
|
3009
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3007
3010
|
isAsking: string;
|
|
3008
3011
|
enteringLightX: number;
|
|
3009
3012
|
enteringLightY: number;
|
|
3010
|
-
},
|
|
3013
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3011
3014
|
randomMaterial1: number;
|
|
3012
3015
|
randomMaterial2: number;
|
|
3013
3016
|
ramdonAngleIncidenceDeg: number;
|
|
3014
|
-
},
|
|
3017
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3015
3018
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3016
|
-
},
|
|
3019
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3017
3020
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3018
|
-
},
|
|
3021
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3019
3022
|
m: number;
|
|
3020
3023
|
t: number;
|
|
3021
3024
|
v: number;
|
|
3022
3025
|
type: number;
|
|
3023
|
-
},
|
|
3026
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3024
3027
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3025
3028
|
elementToFind: "proton" | "neutron" | "electron";
|
|
3026
|
-
},
|
|
3029
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3027
3030
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3028
|
-
},
|
|
3031
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3029
3032
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3030
3033
|
sampleMass: number;
|
|
3031
|
-
},
|
|
3034
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3032
3035
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3033
|
-
},
|
|
3036
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3034
3037
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3035
|
-
},
|
|
3038
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3036
3039
|
totalMass: number;
|
|
3037
3040
|
totalVolume: number;
|
|
3038
3041
|
elementMass: number;
|
|
3039
3042
|
elementVolume: number;
|
|
3040
3043
|
targetProportion: "massique" | "volumique";
|
|
3041
3044
|
moleculeName: string;
|
|
3042
|
-
},
|
|
3045
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3043
3046
|
nA: number;
|
|
3044
3047
|
nB: number;
|
|
3045
3048
|
nC: number;
|
|
@@ -3049,133 +3052,133 @@ declare const mathExercises: (Exercise<{
|
|
|
3049
3052
|
c: number;
|
|
3050
3053
|
d: number;
|
|
3051
3054
|
isStoechiometric: boolean;
|
|
3052
|
-
},
|
|
3055
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3053
3056
|
reactionProduct: string;
|
|
3054
3057
|
vA: number;
|
|
3055
3058
|
vB: number;
|
|
3056
3059
|
cB: number;
|
|
3057
|
-
},
|
|
3060
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3058
3061
|
totalWeight: number;
|
|
3059
3062
|
percent: number;
|
|
3060
3063
|
elWeight: number;
|
|
3061
3064
|
type: number;
|
|
3062
|
-
},
|
|
3065
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3063
3066
|
reactionArray: import("./pc/constants/molecularChemistry/reaction.js").ReactionSpecies[];
|
|
3064
|
-
},
|
|
3067
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3065
3068
|
reactionArray: import("./pc/constants/molecularChemistry/reaction.js").ReactionSpecies[];
|
|
3066
3069
|
randomSpacieIndex: number;
|
|
3067
|
-
},
|
|
3070
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3068
3071
|
maxQuantity: number;
|
|
3069
3072
|
productQuantity: number;
|
|
3070
|
-
},
|
|
3073
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3071
3074
|
combustibleName: string;
|
|
3072
3075
|
combustibleQuantity: number;
|
|
3073
|
-
},
|
|
3076
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3074
3077
|
firstReagentVariables: number[];
|
|
3075
3078
|
secondReagentVariables: number[];
|
|
3076
|
-
},
|
|
3079
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3077
3080
|
firstReagentVariables: number[];
|
|
3078
3081
|
secondReagentVariables: number[];
|
|
3079
3082
|
isForcedStoichiometric: boolean;
|
|
3080
|
-
},
|
|
3083
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3081
3084
|
moleculeName: string;
|
|
3082
3085
|
concentration: number;
|
|
3083
3086
|
molarAbsorptivity: number;
|
|
3084
3087
|
pathLength: number;
|
|
3085
3088
|
absorbance: number;
|
|
3086
3089
|
targetVariableName: string;
|
|
3087
|
-
},
|
|
3090
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3088
3091
|
concentration: number;
|
|
3089
3092
|
quantity: number;
|
|
3090
3093
|
volume: number;
|
|
3091
3094
|
variable: "C" | "n" | "V";
|
|
3092
|
-
},
|
|
3095
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3093
3096
|
concentration: number;
|
|
3094
3097
|
mass: number;
|
|
3095
3098
|
molarMass: number;
|
|
3096
3099
|
variable: "C" | "t" | "M";
|
|
3097
|
-
},
|
|
3100
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3098
3101
|
E: number;
|
|
3099
3102
|
I: number;
|
|
3100
3103
|
r: number;
|
|
3101
3104
|
R: number;
|
|
3102
3105
|
isAsking: string;
|
|
3103
|
-
},
|
|
3106
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3104
3107
|
voltage: number;
|
|
3105
3108
|
current: number;
|
|
3106
3109
|
resistance: number;
|
|
3107
3110
|
target: string;
|
|
3108
3111
|
targetValue: number;
|
|
3109
|
-
},
|
|
3112
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3110
3113
|
l1: number;
|
|
3111
3114
|
l2: number;
|
|
3112
|
-
},
|
|
3115
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3113
3116
|
l1: number;
|
|
3114
3117
|
l2: number;
|
|
3115
3118
|
isAsking: string;
|
|
3116
3119
|
circuit: string;
|
|
3117
|
-
},
|
|
3120
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3118
3121
|
isAsking: string;
|
|
3119
3122
|
uAB: number;
|
|
3120
3123
|
uED: number;
|
|
3121
3124
|
uDC: number;
|
|
3122
|
-
},
|
|
3125
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3123
3126
|
end: number;
|
|
3124
3127
|
type: string;
|
|
3125
|
-
},
|
|
3128
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3126
3129
|
power: number;
|
|
3127
3130
|
seconds: number;
|
|
3128
3131
|
energy: number;
|
|
3129
3132
|
isCalculatingEnergy: boolean;
|
|
3130
|
-
},
|
|
3133
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3131
3134
|
intensity: number;
|
|
3132
3135
|
seconds: number;
|
|
3133
|
-
},
|
|
3136
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3134
3137
|
power: number;
|
|
3135
3138
|
seconds: number;
|
|
3136
|
-
},
|
|
3139
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3137
3140
|
pc: number;
|
|
3138
3141
|
mass: number;
|
|
3139
|
-
},
|
|
3142
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3140
3143
|
substance: string;
|
|
3141
3144
|
mass: number;
|
|
3142
|
-
},
|
|
3145
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3143
3146
|
mass: number;
|
|
3144
3147
|
specificHeat: number;
|
|
3145
3148
|
initialTemp: number;
|
|
3146
3149
|
finalTemp: number;
|
|
3147
3150
|
variable: "E_th" | "m" | "c" | "deltaT";
|
|
3148
|
-
},
|
|
3151
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3149
3152
|
inputPower: number;
|
|
3150
3153
|
outputPower: number;
|
|
3151
3154
|
efficiency: number;
|
|
3152
3155
|
variable: "P_in" | "P_out" | "\u03B7";
|
|
3153
|
-
},
|
|
3156
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3154
3157
|
eComb: number;
|
|
3155
3158
|
quantity: number;
|
|
3156
|
-
},
|
|
3159
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3157
3160
|
type: number;
|
|
3158
3161
|
pc?: number;
|
|
3159
3162
|
mass?: number;
|
|
3160
3163
|
eComb?: number;
|
|
3161
3164
|
quantity?: number;
|
|
3162
|
-
},
|
|
3165
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3163
3166
|
entry: number;
|
|
3164
3167
|
out: number;
|
|
3165
|
-
},
|
|
3168
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3166
3169
|
p1: number;
|
|
3167
3170
|
v1: number;
|
|
3168
3171
|
p2: number | undefined;
|
|
3169
3172
|
v2: number | undefined;
|
|
3170
3173
|
isAskingPressure: boolean;
|
|
3171
|
-
},
|
|
3174
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3172
3175
|
length: number;
|
|
3173
3176
|
forceValue: number;
|
|
3174
3177
|
angleDegree: number;
|
|
3175
|
-
},
|
|
3178
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3176
3179
|
planet: string;
|
|
3177
3180
|
mass: number;
|
|
3178
|
-
},
|
|
3181
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3179
3182
|
varAsked: string;
|
|
3180
3183
|
F: {
|
|
3181
3184
|
significantPart: number;
|
|
@@ -3189,22 +3192,22 @@ declare const mathExercises: (Exercise<{
|
|
|
3189
3192
|
significantPart: number;
|
|
3190
3193
|
exponent: number;
|
|
3191
3194
|
};
|
|
3192
|
-
},
|
|
3195
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3193
3196
|
mass: number;
|
|
3194
3197
|
isAsking: string;
|
|
3195
|
-
},
|
|
3198
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3196
3199
|
mass: number;
|
|
3197
3200
|
force: number;
|
|
3198
3201
|
target: "le poids" | "la masse";
|
|
3199
|
-
},
|
|
3202
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3200
3203
|
planet: string;
|
|
3201
3204
|
mass: import("./pc/measure/measure.js").Measure;
|
|
3202
3205
|
distance: import("./pc/measure/measure.js").Measure;
|
|
3203
|
-
},
|
|
3206
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3204
3207
|
planet: string;
|
|
3205
3208
|
mass: number;
|
|
3206
3209
|
h: number;
|
|
3207
|
-
},
|
|
3210
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3208
3211
|
qA: {
|
|
3209
3212
|
significant: number;
|
|
3210
3213
|
exponent: number;
|
|
@@ -3214,29 +3217,29 @@ declare const mathExercises: (Exercise<{
|
|
|
3214
3217
|
exponent: number;
|
|
3215
3218
|
};
|
|
3216
3219
|
distance: number;
|
|
3217
|
-
},
|
|
3220
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3218
3221
|
xA: number;
|
|
3219
3222
|
yA: number;
|
|
3220
3223
|
xB: number;
|
|
3221
3224
|
yB: number;
|
|
3222
|
-
},
|
|
3225
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3223
3226
|
amplitude: number;
|
|
3224
3227
|
period: number;
|
|
3225
|
-
},
|
|
3228
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3226
3229
|
molecule: string;
|
|
3227
|
-
},
|
|
3230
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3228
3231
|
mol: number;
|
|
3229
3232
|
molarMass: number;
|
|
3230
|
-
},
|
|
3233
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3231
3234
|
mass: number;
|
|
3232
3235
|
molarMass: number;
|
|
3233
|
-
},
|
|
3236
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3234
3237
|
moleculeName: string;
|
|
3235
3238
|
sampleMass: number;
|
|
3236
3239
|
molarMass: number;
|
|
3237
|
-
},
|
|
3240
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3238
3241
|
quantity: number;
|
|
3239
|
-
},
|
|
3242
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3240
3243
|
distance: {
|
|
3241
3244
|
value: number;
|
|
3242
3245
|
unitIndex: number;
|
|
@@ -3252,131 +3255,131 @@ declare const mathExercises: (Exercise<{
|
|
|
3252
3255
|
}, {
|
|
3253
3256
|
acceptedInputType: string;
|
|
3254
3257
|
unitTex: string;
|
|
3255
|
-
}
|
|
3258
|
+
}> | Exercise<{
|
|
3256
3259
|
speed: number;
|
|
3257
3260
|
distance: number;
|
|
3258
3261
|
deltaTime: number;
|
|
3259
3262
|
target: "vitesse moyenne" | "distance" | "temps";
|
|
3260
|
-
},
|
|
3263
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3261
3264
|
typeOfAcceleration: string;
|
|
3262
3265
|
step: number;
|
|
3263
|
-
},
|
|
3266
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3264
3267
|
movementType: string;
|
|
3265
3268
|
a: number;
|
|
3266
3269
|
b: number;
|
|
3267
|
-
},
|
|
3270
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3268
3271
|
object1: string;
|
|
3269
3272
|
object2: string;
|
|
3270
3273
|
reference: "\u00E0 l'autre" | "au sol";
|
|
3271
3274
|
isAskingObject1: boolean;
|
|
3272
|
-
},
|
|
3275
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3273
3276
|
delta: number;
|
|
3274
3277
|
constant: number;
|
|
3275
3278
|
step: number;
|
|
3276
3279
|
speedVectorX1: number;
|
|
3277
|
-
},
|
|
3280
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3278
3281
|
frequency: number;
|
|
3279
|
-
},
|
|
3282
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3280
3283
|
period: number;
|
|
3281
|
-
},
|
|
3284
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3282
3285
|
period: number;
|
|
3283
3286
|
splinePoints: number[][];
|
|
3284
|
-
},
|
|
3287
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3285
3288
|
period: number;
|
|
3286
3289
|
frequency: number;
|
|
3287
3290
|
splinePoints: number[][];
|
|
3288
3291
|
isAsking: "p\u00E9riode" | "fr\u00E9quence";
|
|
3289
|
-
},
|
|
3292
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3290
3293
|
frequency1: number;
|
|
3291
3294
|
frequency2: number;
|
|
3292
3295
|
soundAsked: number;
|
|
3293
|
-
},
|
|
3296
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3294
3297
|
wavelengths: number[];
|
|
3295
3298
|
targetColor: "bleue" | "verte" | "rouge";
|
|
3296
|
-
},
|
|
3299
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3297
3300
|
lightYear: number;
|
|
3298
|
-
},
|
|
3301
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3299
3302
|
lightYear: number;
|
|
3300
3303
|
distanceMeters: import("./pc/measure/measure.js").Measure;
|
|
3301
3304
|
isLightYearToMeters: boolean;
|
|
3302
|
-
},
|
|
3305
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3303
3306
|
varAsked: string;
|
|
3304
3307
|
v: number;
|
|
3305
3308
|
l: number;
|
|
3306
3309
|
T: number;
|
|
3307
|
-
},
|
|
3310
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3308
3311
|
mass: number;
|
|
3309
3312
|
optsIdent: {
|
|
3310
3313
|
inputType: "decimal" | "sci";
|
|
3311
|
-
nbDigits:
|
|
3314
|
+
nbDigits: string;
|
|
3312
3315
|
};
|
|
3313
3316
|
}, {
|
|
3314
3317
|
inputType: "decimal" | "sci";
|
|
3315
|
-
nbDigits:
|
|
3316
|
-
}
|
|
3318
|
+
nbDigits: string;
|
|
3319
|
+
}> | Exercise<{
|
|
3317
3320
|
weight: number;
|
|
3318
3321
|
originIsMoon: boolean;
|
|
3319
|
-
},
|
|
3322
|
+
}, Record<string, string | boolean | string[]>>)[];
|
|
3320
3323
|
declare const pcExercises: (Exercise<{
|
|
3321
3324
|
numbers: number[];
|
|
3322
|
-
},
|
|
3325
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3323
3326
|
randQuation: number;
|
|
3324
3327
|
x1: string | number;
|
|
3325
3328
|
x2: string | number;
|
|
3326
3329
|
x3: string | number;
|
|
3327
3330
|
x4: string | number;
|
|
3328
|
-
},
|
|
3331
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3329
3332
|
a: number;
|
|
3330
3333
|
b: number;
|
|
3331
|
-
},
|
|
3334
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3332
3335
|
a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
3333
3336
|
b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
3334
3337
|
isXRight: boolean;
|
|
3335
3338
|
aNumberType: string;
|
|
3336
3339
|
}, {
|
|
3337
3340
|
aNumberType: string[];
|
|
3338
|
-
}
|
|
3341
|
+
}> | Exercise<{
|
|
3339
3342
|
a: number;
|
|
3340
3343
|
b: number;
|
|
3341
3344
|
c: number;
|
|
3342
|
-
},
|
|
3345
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3343
3346
|
a: number;
|
|
3344
3347
|
b: number;
|
|
3345
3348
|
c: number;
|
|
3346
3349
|
d: number;
|
|
3347
|
-
},
|
|
3350
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3348
3351
|
coefficients: number[];
|
|
3349
|
-
},
|
|
3352
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3350
3353
|
coefficients: number[];
|
|
3351
|
-
},
|
|
3354
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3352
3355
|
a: number;
|
|
3353
3356
|
b: number;
|
|
3354
|
-
},
|
|
3357
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3355
3358
|
type: number;
|
|
3356
3359
|
a?: number;
|
|
3357
3360
|
b?: number;
|
|
3358
3361
|
coefficients?: number[];
|
|
3359
3362
|
tex?: string;
|
|
3360
|
-
},
|
|
3363
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3361
3364
|
A: number[];
|
|
3362
3365
|
B: number[];
|
|
3363
3366
|
coeffs: number[];
|
|
3364
|
-
},
|
|
3367
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3365
3368
|
a: number;
|
|
3366
|
-
},
|
|
3369
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3367
3370
|
a: number;
|
|
3368
3371
|
initialY: number;
|
|
3369
|
-
},
|
|
3372
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3370
3373
|
type: string;
|
|
3371
3374
|
randFuncIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
3372
3375
|
equaDiffIdentifiers: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
3373
3376
|
isSolution: boolean;
|
|
3374
|
-
},
|
|
3377
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3375
3378
|
b: number;
|
|
3376
3379
|
secondPoint: number[];
|
|
3377
|
-
},
|
|
3380
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3378
3381
|
tenthPower: number;
|
|
3379
|
-
},
|
|
3382
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3380
3383
|
a: number;
|
|
3381
3384
|
powered: number;
|
|
3382
3385
|
c: number;
|
|
@@ -3384,21 +3387,21 @@ declare const pcExercises: (Exercise<{
|
|
|
3384
3387
|
isLog10: boolean;
|
|
3385
3388
|
}, {
|
|
3386
3389
|
isLog10: boolean;
|
|
3387
|
-
}
|
|
3390
|
+
}> | Exercise<{
|
|
3388
3391
|
nb: number;
|
|
3389
3392
|
powers: number[];
|
|
3390
3393
|
signs: number[];
|
|
3391
3394
|
isLog10: boolean;
|
|
3392
3395
|
}, {
|
|
3393
3396
|
isLog10: boolean;
|
|
3394
|
-
}
|
|
3397
|
+
}> | Exercise<{
|
|
3395
3398
|
ratio: number;
|
|
3396
3399
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
3397
3400
|
insidePointsNames: string[];
|
|
3398
3401
|
isPapillon: boolean;
|
|
3399
3402
|
}, {
|
|
3400
3403
|
configurationType: string;
|
|
3401
|
-
}
|
|
3404
|
+
}> | Exercise<{
|
|
3402
3405
|
ratio: number;
|
|
3403
3406
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
3404
3407
|
insidePointsNames: string[];
|
|
@@ -3406,119 +3409,114 @@ declare const pcExercises: (Exercise<{
|
|
|
3406
3409
|
isPapillon: boolean;
|
|
3407
3410
|
}, {
|
|
3408
3411
|
configurationType: string;
|
|
3409
|
-
}
|
|
3412
|
+
}> | Exercise<{
|
|
3410
3413
|
xA: number;
|
|
3411
3414
|
xB: number;
|
|
3412
3415
|
yA: number;
|
|
3413
3416
|
yB: number;
|
|
3414
|
-
},
|
|
3417
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3415
3418
|
uCoords: string[];
|
|
3416
3419
|
vCoords: string[];
|
|
3417
|
-
},
|
|
3420
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3418
3421
|
AB: number;
|
|
3419
3422
|
AC: number;
|
|
3420
3423
|
trigoPoint: string;
|
|
3421
3424
|
letters: string[];
|
|
3422
|
-
},
|
|
3425
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3423
3426
|
indexSituation: number;
|
|
3424
3427
|
total: number;
|
|
3425
3428
|
lefties: number;
|
|
3426
|
-
|
|
3427
|
-
isPercentSymbolRequired: boolean;
|
|
3428
|
-
};
|
|
3429
|
-
}, {
|
|
3430
|
-
isPercentSymbolRequired: boolean;
|
|
3431
|
-
}, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
|
|
3429
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3432
3430
|
decimal: number;
|
|
3433
|
-
},
|
|
3431
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3434
3432
|
a: number;
|
|
3435
3433
|
b: number;
|
|
3436
3434
|
c: number;
|
|
3437
3435
|
}, {
|
|
3438
3436
|
useOnlyPowersOfTen: boolean;
|
|
3439
|
-
}
|
|
3437
|
+
}> | Exercise<{
|
|
3440
3438
|
randAngle: number;
|
|
3441
3439
|
hiddenSide: number;
|
|
3442
3440
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
3443
|
-
},
|
|
3441
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3444
3442
|
sideAsked: number;
|
|
3445
3443
|
givenSide: number;
|
|
3446
3444
|
givenAngle: number;
|
|
3447
3445
|
triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
|
|
3448
|
-
},
|
|
3446
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3449
3447
|
epsilon: number;
|
|
3450
3448
|
l: number;
|
|
3451
3449
|
molecule: string;
|
|
3452
|
-
},
|
|
3450
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3453
3451
|
concentrationMere: number;
|
|
3454
3452
|
volumeFille: number;
|
|
3455
3453
|
concentrationFille: number;
|
|
3456
|
-
},
|
|
3454
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3457
3455
|
randomMoleculeIndex: number;
|
|
3458
|
-
},
|
|
3456
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3459
3457
|
atomicMass: number;
|
|
3460
3458
|
atomicNumber: number;
|
|
3461
3459
|
isAsking: string;
|
|
3462
3460
|
symbol: string;
|
|
3463
|
-
},
|
|
3461
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3464
3462
|
mass: number;
|
|
3465
3463
|
velocity: number;
|
|
3466
|
-
},
|
|
3464
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3467
3465
|
mG: number;
|
|
3468
3466
|
randomMoleculeIndex: number;
|
|
3469
|
-
},
|
|
3467
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3470
3468
|
randomMoleculeIndex: number;
|
|
3471
|
-
},
|
|
3469
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3472
3470
|
randomMoleculeIndex: number;
|
|
3473
|
-
},
|
|
3471
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3474
3472
|
order: number;
|
|
3475
3473
|
multiplier: number;
|
|
3476
|
-
},
|
|
3474
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3477
3475
|
randomNumber: number;
|
|
3478
3476
|
randomTenPower: number;
|
|
3479
|
-
},
|
|
3477
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3480
3478
|
frequencyEmitted: number;
|
|
3481
3479
|
ambulanceSpeed: number;
|
|
3482
|
-
},
|
|
3480
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3483
3481
|
mass: number;
|
|
3484
3482
|
height: number;
|
|
3485
|
-
},
|
|
3483
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3486
3484
|
isAsking: string;
|
|
3487
3485
|
enteringLightX: number;
|
|
3488
3486
|
enteringLightY: number;
|
|
3489
|
-
},
|
|
3487
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3490
3488
|
randomMaterial1: number;
|
|
3491
3489
|
randomMaterial2: number;
|
|
3492
3490
|
ramdonAngleIncidenceDeg: number;
|
|
3493
|
-
},
|
|
3491
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3494
3492
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3495
|
-
},
|
|
3493
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3496
3494
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3497
|
-
},
|
|
3495
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3498
3496
|
m: number;
|
|
3499
3497
|
t: number;
|
|
3500
3498
|
v: number;
|
|
3501
3499
|
type: number;
|
|
3502
|
-
},
|
|
3500
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3503
3501
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3504
3502
|
elementToFind: "proton" | "neutron" | "electron";
|
|
3505
|
-
},
|
|
3503
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3506
3504
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3507
|
-
},
|
|
3505
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3508
3506
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3509
3507
|
sampleMass: number;
|
|
3510
|
-
},
|
|
3508
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3511
3509
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3512
|
-
},
|
|
3510
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3513
3511
|
atomSymbol: import("./pc/constants/molecularChemistry/atomSymbols.js").AtomSymbols;
|
|
3514
|
-
},
|
|
3512
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3515
3513
|
totalMass: number;
|
|
3516
3514
|
totalVolume: number;
|
|
3517
3515
|
elementMass: number;
|
|
3518
3516
|
elementVolume: number;
|
|
3519
3517
|
targetProportion: "massique" | "volumique";
|
|
3520
3518
|
moleculeName: string;
|
|
3521
|
-
},
|
|
3519
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3522
3520
|
nA: number;
|
|
3523
3521
|
nB: number;
|
|
3524
3522
|
nC: number;
|
|
@@ -3528,133 +3526,133 @@ declare const pcExercises: (Exercise<{
|
|
|
3528
3526
|
c: number;
|
|
3529
3527
|
d: number;
|
|
3530
3528
|
isStoechiometric: boolean;
|
|
3531
|
-
},
|
|
3529
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3532
3530
|
reactionProduct: string;
|
|
3533
3531
|
vA: number;
|
|
3534
3532
|
vB: number;
|
|
3535
3533
|
cB: number;
|
|
3536
|
-
},
|
|
3534
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3537
3535
|
totalWeight: number;
|
|
3538
3536
|
percent: number;
|
|
3539
3537
|
elWeight: number;
|
|
3540
3538
|
type: number;
|
|
3541
|
-
},
|
|
3539
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3542
3540
|
reactionArray: import("./pc/constants/molecularChemistry/reaction.js").ReactionSpecies[];
|
|
3543
|
-
},
|
|
3541
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3544
3542
|
reactionArray: import("./pc/constants/molecularChemistry/reaction.js").ReactionSpecies[];
|
|
3545
3543
|
randomSpacieIndex: number;
|
|
3546
|
-
},
|
|
3544
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3547
3545
|
maxQuantity: number;
|
|
3548
3546
|
productQuantity: number;
|
|
3549
|
-
},
|
|
3547
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3550
3548
|
combustibleName: string;
|
|
3551
3549
|
combustibleQuantity: number;
|
|
3552
|
-
},
|
|
3550
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3553
3551
|
firstReagentVariables: number[];
|
|
3554
3552
|
secondReagentVariables: number[];
|
|
3555
|
-
},
|
|
3553
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3556
3554
|
firstReagentVariables: number[];
|
|
3557
3555
|
secondReagentVariables: number[];
|
|
3558
3556
|
isForcedStoichiometric: boolean;
|
|
3559
|
-
},
|
|
3557
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3560
3558
|
moleculeName: string;
|
|
3561
3559
|
concentration: number;
|
|
3562
3560
|
molarAbsorptivity: number;
|
|
3563
3561
|
pathLength: number;
|
|
3564
3562
|
absorbance: number;
|
|
3565
3563
|
targetVariableName: string;
|
|
3566
|
-
},
|
|
3564
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3567
3565
|
concentration: number;
|
|
3568
3566
|
quantity: number;
|
|
3569
3567
|
volume: number;
|
|
3570
3568
|
variable: "C" | "n" | "V";
|
|
3571
|
-
},
|
|
3569
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3572
3570
|
concentration: number;
|
|
3573
3571
|
mass: number;
|
|
3574
3572
|
molarMass: number;
|
|
3575
3573
|
variable: "C" | "t" | "M";
|
|
3576
|
-
},
|
|
3574
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3577
3575
|
E: number;
|
|
3578
3576
|
I: number;
|
|
3579
3577
|
r: number;
|
|
3580
3578
|
R: number;
|
|
3581
3579
|
isAsking: string;
|
|
3582
|
-
},
|
|
3580
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3583
3581
|
voltage: number;
|
|
3584
3582
|
current: number;
|
|
3585
3583
|
resistance: number;
|
|
3586
3584
|
target: string;
|
|
3587
3585
|
targetValue: number;
|
|
3588
|
-
},
|
|
3586
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3589
3587
|
l1: number;
|
|
3590
3588
|
l2: number;
|
|
3591
|
-
},
|
|
3589
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3592
3590
|
l1: number;
|
|
3593
3591
|
l2: number;
|
|
3594
3592
|
isAsking: string;
|
|
3595
3593
|
circuit: string;
|
|
3596
|
-
},
|
|
3594
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3597
3595
|
isAsking: string;
|
|
3598
3596
|
uAB: number;
|
|
3599
3597
|
uED: number;
|
|
3600
3598
|
uDC: number;
|
|
3601
|
-
},
|
|
3599
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3602
3600
|
end: number;
|
|
3603
3601
|
type: string;
|
|
3604
|
-
},
|
|
3602
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3605
3603
|
power: number;
|
|
3606
3604
|
seconds: number;
|
|
3607
3605
|
energy: number;
|
|
3608
3606
|
isCalculatingEnergy: boolean;
|
|
3609
|
-
},
|
|
3607
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3610
3608
|
intensity: number;
|
|
3611
3609
|
seconds: number;
|
|
3612
|
-
},
|
|
3610
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3613
3611
|
power: number;
|
|
3614
3612
|
seconds: number;
|
|
3615
|
-
},
|
|
3613
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3616
3614
|
pc: number;
|
|
3617
3615
|
mass: number;
|
|
3618
|
-
},
|
|
3616
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3619
3617
|
substance: string;
|
|
3620
3618
|
mass: number;
|
|
3621
|
-
},
|
|
3619
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3622
3620
|
mass: number;
|
|
3623
3621
|
specificHeat: number;
|
|
3624
3622
|
initialTemp: number;
|
|
3625
3623
|
finalTemp: number;
|
|
3626
3624
|
variable: "E_th" | "m" | "c" | "deltaT";
|
|
3627
|
-
},
|
|
3625
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3628
3626
|
inputPower: number;
|
|
3629
3627
|
outputPower: number;
|
|
3630
3628
|
efficiency: number;
|
|
3631
3629
|
variable: "P_in" | "P_out" | "\u03B7";
|
|
3632
|
-
},
|
|
3630
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3633
3631
|
eComb: number;
|
|
3634
3632
|
quantity: number;
|
|
3635
|
-
},
|
|
3633
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3636
3634
|
type: number;
|
|
3637
3635
|
pc?: number;
|
|
3638
3636
|
mass?: number;
|
|
3639
3637
|
eComb?: number;
|
|
3640
3638
|
quantity?: number;
|
|
3641
|
-
},
|
|
3639
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3642
3640
|
entry: number;
|
|
3643
3641
|
out: number;
|
|
3644
|
-
},
|
|
3642
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3645
3643
|
p1: number;
|
|
3646
3644
|
v1: number;
|
|
3647
3645
|
p2: number | undefined;
|
|
3648
3646
|
v2: number | undefined;
|
|
3649
3647
|
isAskingPressure: boolean;
|
|
3650
|
-
},
|
|
3648
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3651
3649
|
length: number;
|
|
3652
3650
|
forceValue: number;
|
|
3653
3651
|
angleDegree: number;
|
|
3654
|
-
},
|
|
3652
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3655
3653
|
planet: string;
|
|
3656
3654
|
mass: number;
|
|
3657
|
-
},
|
|
3655
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3658
3656
|
varAsked: string;
|
|
3659
3657
|
F: {
|
|
3660
3658
|
significantPart: number;
|
|
@@ -3668,22 +3666,22 @@ declare const pcExercises: (Exercise<{
|
|
|
3668
3666
|
significantPart: number;
|
|
3669
3667
|
exponent: number;
|
|
3670
3668
|
};
|
|
3671
|
-
},
|
|
3669
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3672
3670
|
mass: number;
|
|
3673
3671
|
isAsking: string;
|
|
3674
|
-
},
|
|
3672
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3675
3673
|
mass: number;
|
|
3676
3674
|
force: number;
|
|
3677
3675
|
target: "le poids" | "la masse";
|
|
3678
|
-
},
|
|
3676
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3679
3677
|
planet: string;
|
|
3680
3678
|
mass: import("./pc/measure/measure.js").Measure;
|
|
3681
3679
|
distance: import("./pc/measure/measure.js").Measure;
|
|
3682
|
-
},
|
|
3680
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3683
3681
|
planet: string;
|
|
3684
3682
|
mass: number;
|
|
3685
3683
|
h: number;
|
|
3686
|
-
},
|
|
3684
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3687
3685
|
qA: {
|
|
3688
3686
|
significant: number;
|
|
3689
3687
|
exponent: number;
|
|
@@ -3693,29 +3691,29 @@ declare const pcExercises: (Exercise<{
|
|
|
3693
3691
|
exponent: number;
|
|
3694
3692
|
};
|
|
3695
3693
|
distance: number;
|
|
3696
|
-
},
|
|
3694
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3697
3695
|
xA: number;
|
|
3698
3696
|
yA: number;
|
|
3699
3697
|
xB: number;
|
|
3700
3698
|
yB: number;
|
|
3701
|
-
},
|
|
3699
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3702
3700
|
amplitude: number;
|
|
3703
3701
|
period: number;
|
|
3704
|
-
},
|
|
3702
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3705
3703
|
molecule: string;
|
|
3706
|
-
},
|
|
3704
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3707
3705
|
mol: number;
|
|
3708
3706
|
molarMass: number;
|
|
3709
|
-
},
|
|
3707
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3710
3708
|
mass: number;
|
|
3711
3709
|
molarMass: number;
|
|
3712
|
-
},
|
|
3710
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3713
3711
|
moleculeName: string;
|
|
3714
3712
|
sampleMass: number;
|
|
3715
3713
|
molarMass: number;
|
|
3716
|
-
},
|
|
3714
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3717
3715
|
quantity: number;
|
|
3718
|
-
},
|
|
3716
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3719
3717
|
distance: {
|
|
3720
3718
|
value: number;
|
|
3721
3719
|
unitIndex: number;
|
|
@@ -3731,81 +3729,81 @@ declare const pcExercises: (Exercise<{
|
|
|
3731
3729
|
}, {
|
|
3732
3730
|
acceptedInputType: string;
|
|
3733
3731
|
unitTex: string;
|
|
3734
|
-
}
|
|
3732
|
+
}> | Exercise<{
|
|
3735
3733
|
speed: number;
|
|
3736
3734
|
distance: number;
|
|
3737
3735
|
deltaTime: number;
|
|
3738
3736
|
target: "vitesse moyenne" | "distance" | "temps";
|
|
3739
|
-
},
|
|
3737
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3740
3738
|
typeOfAcceleration: string;
|
|
3741
3739
|
step: number;
|
|
3742
|
-
},
|
|
3740
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3743
3741
|
movementType: string;
|
|
3744
3742
|
a: number;
|
|
3745
3743
|
b: number;
|
|
3746
|
-
},
|
|
3744
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3747
3745
|
object1: string;
|
|
3748
3746
|
object2: string;
|
|
3749
3747
|
reference: "\u00E0 l'autre" | "au sol";
|
|
3750
3748
|
isAskingObject1: boolean;
|
|
3751
|
-
},
|
|
3749
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3752
3750
|
delta: number;
|
|
3753
3751
|
constant: number;
|
|
3754
3752
|
step: number;
|
|
3755
3753
|
speedVectorX1: number;
|
|
3756
|
-
},
|
|
3754
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3757
3755
|
frequency: number;
|
|
3758
|
-
},
|
|
3756
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3759
3757
|
period: number;
|
|
3760
|
-
},
|
|
3758
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3761
3759
|
period: number;
|
|
3762
3760
|
splinePoints: number[][];
|
|
3763
|
-
},
|
|
3761
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3764
3762
|
period: number;
|
|
3765
3763
|
frequency: number;
|
|
3766
3764
|
splinePoints: number[][];
|
|
3767
3765
|
isAsking: "p\u00E9riode" | "fr\u00E9quence";
|
|
3768
|
-
},
|
|
3766
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3769
3767
|
frequency1: number;
|
|
3770
3768
|
frequency2: number;
|
|
3771
3769
|
soundAsked: number;
|
|
3772
|
-
},
|
|
3770
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3773
3771
|
wavelengths: number[];
|
|
3774
3772
|
targetColor: "bleue" | "verte" | "rouge";
|
|
3775
|
-
},
|
|
3773
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3776
3774
|
lightYear: number;
|
|
3777
|
-
},
|
|
3775
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3778
3776
|
lightYear: number;
|
|
3779
3777
|
distanceMeters: import("./pc/measure/measure.js").Measure;
|
|
3780
3778
|
isLightYearToMeters: boolean;
|
|
3781
|
-
},
|
|
3779
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3782
3780
|
varAsked: string;
|
|
3783
3781
|
v: number;
|
|
3784
3782
|
l: number;
|
|
3785
3783
|
T: number;
|
|
3786
|
-
},
|
|
3784
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3787
3785
|
mass: number;
|
|
3788
3786
|
optsIdent: {
|
|
3789
3787
|
inputType: "decimal" | "sci";
|
|
3790
|
-
nbDigits:
|
|
3788
|
+
nbDigits: string;
|
|
3791
3789
|
};
|
|
3792
3790
|
}, {
|
|
3793
3791
|
inputType: "decimal" | "sci";
|
|
3794
|
-
nbDigits:
|
|
3795
|
-
}
|
|
3792
|
+
nbDigits: string;
|
|
3793
|
+
}> | Exercise<{
|
|
3796
3794
|
weight: number;
|
|
3797
3795
|
originIsMoon: boolean;
|
|
3798
|
-
},
|
|
3796
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3799
3797
|
I: number;
|
|
3800
|
-
},
|
|
3798
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3801
3799
|
isAsking: string;
|
|
3802
3800
|
mass: number;
|
|
3803
3801
|
velocity: number;
|
|
3804
3802
|
kineticEnergy: number;
|
|
3805
|
-
},
|
|
3803
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3806
3804
|
E: number[];
|
|
3807
3805
|
S: number[];
|
|
3808
|
-
},
|
|
3806
|
+
}, Record<string, string | boolean | string[]>> | Exercise<{
|
|
3809
3807
|
OFPrime: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
3810
3808
|
OA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
3811
3809
|
OAPrime: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
|
|
@@ -3813,13 +3811,13 @@ declare const pcExercises: (Exercise<{
|
|
|
3813
3811
|
typeDistance: "distance focale" | "distance image" | "distance objet";
|
|
3814
3812
|
typeImage: "réelle finie" | "réelle infinie" | "imaginaire finie" | "imaginaire infinie";
|
|
3815
3813
|
unit: "cm" | "m";
|
|
3816
|
-
roundTo:
|
|
3814
|
+
roundTo: string;
|
|
3817
3815
|
};
|
|
3818
3816
|
}, {
|
|
3819
3817
|
typeDistance: "distance focale" | "distance image" | "distance objet";
|
|
3820
3818
|
typeImage: "réelle finie" | "réelle infinie" | "imaginaire finie" | "imaginaire infinie";
|
|
3821
3819
|
unit: "cm" | "m";
|
|
3822
|
-
roundTo:
|
|
3823
|
-
}
|
|
3820
|
+
roundTo: string;
|
|
3821
|
+
}>)[];
|
|
3824
3822
|
export { mathExercises, pcExercises, Exercise, Question, parseAlgebraic };
|
|
3825
3823
|
//# sourceMappingURL=index.d.ts.map
|