%PDF-
%PDF-
Mini Shell
Mini Shell
/**
* Defines the H5P.ArithmeticQuiz.EquationsGenerator class
*/
H5P.ArithmeticQuiz.EquationsGenerator = (function (EquationType) {
var unknown = ["x", "y", "z", "a", "b"];
var Fraction = algebra.Fraction;
var Expression = algebra.Expression;
var Equation = algebra.Equation;
// Helper functions for creating wrong alternatives
function add (question, param) {
return question.correct + param;
}
function subtract (question, param) {
return question.correct - param;
}
function randomNum (min, max) {
min = min || 1;
max = max || 7;
// Creates random number between min and max:
var num = Math.floor(Math.random()*(max-min+1)+min);
if (num === 0) {
num = randomNum(min, max);
}
return num;
}
function multiply (question, param) {
if (Math.random() > 0.5) {
return (question.x+param) * question.y;
}
else {
return (question.y+param) * question.x;
}
}
function divide (question, param) {
if (Math.random() > 0.5) {
return Math.floor((question.x + param) / question.y);
}
else {
return Math.floor(question.x / (question.y + param));
}
}
//
/**
* Do a random operation on equation expression
* @method randomOperation
* @param {operations} array of operations to choose from randomly
* @param {expr} algebra.js expression
* @param {useFractions} use fractions as number
*/
function randomOperation(operations, expr, useFractions) {
// get a random operation
var operation = operations[Math.floor(Math.random() * operations.length)];
var number = randomNum(1, 7);
switch (operation) {
case "/":
if (number > 0) {
expr = expr.divide(number);
}
break;
case "*":
expr = expr.multiply(number);
break;
case "+":
if (useFractions === true) {
number = new Fraction(randomNum(1, 7), randomNum(3, 7));
}
expr = expr.add(number);
break;
case "-":
if (useFractions === true) {
number = new Fraction(randomNum(1, 7), randomNum(3, 7));
}
expr = expr.subtract(number);
break;
}
return expr;
}
/**
* Generates equation type for a question
* @method generateEquation
* @param {item} variable name of expression
* @param {expr} algebra.js expression
* @param {equationType} type of equation (basic, intermediate, advanced)
* @param {useFractions} use fractions as number
*/
function generateEquation(item, type, equationType, useFractions) {
var equation = undefined;
var solution = undefined;
var number1 = undefined;
var operations = undefined;
number1 = randomNum();
if (useFractions === true) {
number1 = new Fraction(randomNum(), randomNum(3, 7));
}
var expression1 = new Expression(item);
var expression2 = new Expression(item);
switch (equationType) {
case EquationType.BASIC:
// [ 3x = 12 ]
expression1 = expression1.multiply(randomNum(2, 4));
equation = new Equation(expression1, number1);
break;
case EquationType.INTERMEDIATE:
// [ 4x - 3 = 13 ]
operations = ["+", "-"];
expression1 = randomOperation(operations, expression1, useFractions);
expression1 = expression1.multiply(randomNum(2, 3));
equation = new Equation(expression1, number1);
break;
case EquationType.ADVANCED:
// [ 5x + 3 = 3x + 15 ]
operations = ["+", "-"];
// expression1 = expression1.multiply(item); // Quadratic equations ..
expression1 = randomOperation(operations, expression1, useFractions);
expression2 = randomOperation(operations, expression2, useFractions);
expression1 = expression1.multiply(randomNum(2, 3));
expression2 = expression2.multiply(randomNum(2, 3));
expression1 = expression1.simplify();
expression2 = expression2.simplify();
equation = new Equation(expression1, expression2);
break;
}
try {
solution = equation.solveFor(item);
} catch(err) {
equation = generateEquation(item, type, equationType, useFractions);
solution = equation.solveFor(item);
}
if ( (solution.toString() === "0") || (solution.toString() === "1") || solution.toString().length > 4) {
// Rebuild
equation = generateEquation(item, type, equationType, useFractions);
}
return equation;
}
/**
* Equation Questions generator classes
* @method EquationsGenerator
* @constructor
* @param {H5P.ArithmeticQuiz.ArithmeticType} type
* @param {H5P.ArithmeticQuiz.EquationType} equationType
* @param {number} maxQuestions
* @param {boolean} use fractions in equations
*/
function EquationsGenerator(type, equationType, maxQuestions, useFractions) {
var self = this;
var questions = [];
var i, j;
/**
* Generates alternative for a question
* @method generateAlternatives
* @param {Object} question
* @param {H5P.ArithmeticQuiz.EquationType} equation type
* @param {boolean} use fractions in equations
*/
function generateAlternatives(question, equationType, useFractions) {
question.alternatives = [];
var equation = undefined;
// Generate 5 wrong ones:
while (question.alternatives.length !== 5) {
equation = generateEquation(question.variable, question.type, equationType, useFractions);
var solution = equation.solveFor(question.variable).toString();
// check if alternative is present already and is not the correct one
if (solution !== question.correct && question.alternatives.indexOf(solution) === -1) {
question.alternatives.push(solution);
}
}
// Add correct one
question.alternatives.push(question.correct);
// Shuffle alternatives:
question.alternatives = H5P.shuffleArray(question.alternatives);
}
// Generate equations
for (i=50; i>=0; i--) {
for (j=i; j>=0; j--) {
var item = unknown[Math.floor(Math.random()*unknown.length)];
var equation = generateEquation(item, type, equationType, useFractions);
var solution = equation.solveFor(item);
questions.push({
variable: item,
expression: equation.toString(),
correct: solution.toString(),
textual: equation.toString(),
});
}
}
// Let's shuffle
questions = H5P.shuffleArray(questions);
if (questions.length > maxQuestions) {
questions = questions.slice(0, maxQuestions);
}
// Create alternatives
for (i = 0; i < questions.length; i++) {
generateAlternatives(questions[i], equationType, useFractions);
}
/**
* Returns the questions including alternatives and textual representation
* @public
* @return {array}
*/
self.get = function () {
return questions;
};
}
EquationsGenerator.prototype.readableQuestion = function (translations, readableSigns, question) {
return translations.humanizedEquation
.replace(':equation', readableSigns)
.replace(':item', question.variable);
};
EquationsGenerator.prototype.readableText = function (question) {
return question.textual;
};
return EquationsGenerator;
}(H5P.ArithmeticQuiz.EquationType));
Zerion Mini Shell 1.0