Copyright © 2012 Gerd Wagner

Published 9-Nov-2012

**Abstract**

This tutorial explains how to create new arithmetic problem types and combine them with available rendering forms in the creation of new learning units for the OpenArithmetic portal.

**Table of Contents**

OpenAritmetic defines an open education framework for

teachers to create and publish their own interactive learning units by combining arithmetic problem types with suitable rendering forms;

students to invoke the learning units published by their teacher.

The main concepts of the framework are **learning units** consisting of **exercises** combining **problem types** with **rendering forms**. These concepts are further
explained in the following sections.

In OpenAritmetic, a standard problem is given by an **arithmetic term** defined by two lists: a list of
n
**arithmetic operators**, a
list of n+1
**operands** and the
(derived) **result** of
evaluating the term. Notice that this simplified definition supports only parenthesis-free
arithmetic terms that are evaluated from left to right. A general definition would be based
on a tree structure with operands as leaf nodes and operators as non-leaf nodes. But such a
more general concept would only complicate the handling of problem types without providing
much added value.

A standard problem type defines, in addition to a list of arithmetic operators, a list of
**number ranges**, which are
closed intervals [lb,ub], where lb denotes the lower bound and ub the upper
bound of the interval. These number ranges define intervals for selecting the coresponding
operands at random. In this way, a problem type definition is used for generating random
problems of that type.

Problem types are defined in the JavaScript file `arithmeticProblemTypes.js`

. A
simple example of a problem type definition is shown in the following JavaScript code
fragment:

oa.apt.additionOf1 = new ArithmeticProblemType( "AdditionOf1", "Addition of 1", 1, // grade level [ null, {lb:0,ub:9}, {lb:1,ub:1}], [ OperatorEL.plus], 0 // askedFor = 0 means: ask for the result );

Here,
"AdditionOf1" is the unique name of the defined problem type, which is followed by a
description and the grade level 1. Then a sequence of intervals defining the number ranges for
operands is specified: `[ null, {lb:0,ub:9}, {lb:1,ub:1}]`

. This is the JavaScript
Object Notation (JSON), which uses brackets for sequences and curly braces for 'objects'
specified as a lset of attribute-value pairs. In this example, the first element in the number
ranges sequence is "null", which means that no number range is defined for the result, and the
third element, `{lb:1,ub:1}`

, specifies the singleton interval [1,1] for fixing the
second summand to 1.

The next item, `[OperatorEL.plus]`

, denotes a sequence of operators. Here, it
just specifies one operator: addition. The other arithmetic operators would have to be
specified in a similar way: as `OperatorEL.minus`

, `OperatorEL.times`

or
`OperatorEL.dividedBy`

.

Finally, the above problem type definition specifies which value is asked for: either for the result (by specifying 0) or for any of the operands, by specifying its sequence number, such as 1 for the first operand or 2 for the second.

The class diagram below provides an overview of the problem type and problem concepts of the
OpenAritmetic framework. The class `ArithmeticProblem`

defines an array-valued
`operands`

attribute and a `result`

attribute, while the array-valued
`operators`

attribute is defined in the associated instance of
`ArithmeticProblemType`

.

A problem is a basic arithmetic problem if its number type is NonNegativeInteger, it has exactly one operator that is either plus or times, and both operands are greater or equal to 0 and smaller than 10. For basic problems there is a personalized statistics that records the performance of learners on these problems and that is taken into consideration when generating further basic problems.

Each arithmetic problem type has a **number
type**, which is either

the datatype NonNegativeInteger corresponding to the set of natural numbers (N),

the datatype Integer corresponding to the set of integers (Z),

the datatype Decimal corresponding to the set of decimal numbers, or

the complex datatype Fraction corresponding to the set of rational numbers (Q); a fraction is represented as a two-element array, where each element is an integer.

When the number type is Fraction, there are some additional attributes that allow to configure the handling of fraction problems:

askedForNumOrDenomOrBoth: allows to control if the learner is asked to enter 1) only the numerator, 2) only the denominator, or 3) both of them.

reducedFractions: if this Boolean attribute is set to true, only reduced fractions will be generated and accepted as correct answers.

mixedFractions: if this Boolean attribute is set to true, improper fractions will be rendered as mixed fractions.

A standard problem type is based on an arithmetic term
as defined by the `operators`

list. In addition to standard problem types there
are also a few problem types that are either not based on the computation of a term or have
some special constraints. These special problem types can be defined with the help of the
attribute `specialProblemCategory`

. Examples of special problem categories are:

Recognizing a number in a visual pattern (

`RecognizeNumber`

). The numbers to be recognized are generated at random within the bounds defined by the first number range,`numberRanges[0]`

.Sorting numbers (

`SortingNumbers`

). The numbers to be sorted are generated at random within the bounds defined by`numberRanges[0]`

.Recognizing equivalent fractions (

`EquivalentFractions`

).Fraction problems with special constraints, like

all fractions having the same denominator (

`SameDenominator`

)one or more denominators being the least common multiplier of all the other denominators (

`DenominatorEqualsLCM`

)

The most basic rendering form is called "IndividualEquation". It renders an arithemitic problem in the form of an equation, where the learner has to enter either the result of computing the value of the left-hand-side expression or an operand within the left-hand-side expression.

A rendering form has either the mode "individually", in which case individual problems are
rendered one at a time, or it has the mode "en-bloc", in which case several problems are
rendered altogether in one step. In the "individually" rendering mode, the
`numberOfProblems`

, as defined in an exercise, means that this many problems will
be generated and rendered, one at a time, and then rendered in a loop.

In the "en-bloc" rendering mode, the `numberOfProblems`

means the number of
problems that will be rendered altogether in one step.

The following table lists the currently available rendering forms for operations with natural numbers. Notice that this list will be continuously extended, and you can help to develop new rendering forms, if you are a JavaScript developer. In fact, there are already a number of rendering forms for fractions, which will soon be added to the list.

Name of rendering form | Description | Mode | Applicable to problem types which... |
---|---|---|---|

IndividualEquation (oa.rf.individualEquation) | Renders an equation with an arithmetic term on the left hand side and its evaluation result on the right hand side. | individually | have a number type of either NonNegativeInteger, Integer or Decimal |

AdditionAndSubtractionOfCoins (oa.rf.additionAndSubtractionOfCoins) | Addition and subtraction visualized with the help of coins. | individually | have a number type of NonNegativeInteger, define binary additions or subtractions, and ask for the result |

AdditionWithAnimatedDice (oa.rf.additionWithAnimatedDice) | Renders up to four dice that represent the summands of an addition problem. | individually | have a number type of NonNegativeInteger, have number ranges that are subintervals of [1,6]. define binary, ternary or 4-ary additions, and ask for the result |

InverseOperation (oa.rf.inverseOperation) | Renders four term-result equations for binary addition and multiplication problems and their inverse problems. | individually | have a number type of NonNegativeInteger, define binary additions or multiplications, and ask for the result |

ComputationHouse (oa.rf.compHouse) | Renders a set of binary terms, where the second operand is fixed, into the "rooms" of a stylized house. | en-bloc | have a number type of either NonNegativeInteger, Integer or Decimal, and define binary problems where the second operand is fixed |

Memory (oa.rf.memory) | Successively click on the cells of a memory game grid for finding the right pairs. | en-bloc | have a number type of either NonNegativeInteger, Integer or Decimal and define binary problems |

AnimatedStars (oa.rf.animatedStars) | An aninated multiple-choice rendering form where the possible answers are animated as falling stars. | individually | have a number type of either NonNegativeInteger, Integer or Decimal |

When defining an exercise, a problem type is combined with a suitable rendering form and the number of problems to be rendered in this form is specified, as in the following JavaScript object creation expression:

new ArithmeticExercise( oa.apt.additionOf3, 3, oa.rf.compHouse),

A learning unit is defined as a list of exercises, together with a title, a description and a subject area field. It is normally assigned a grade between 1 and 6. The following example defines a learning unit for grade level 1 with 7 exercises.

oa.lu.demo1a = new LearningUnit( 1, // id "Addition 1", // title "This demo learning unit includes various addition exercises for grade 1.", "Addition", // subject area 1, // grade [ new ArithmeticExercise( oa.apt.additionOf1, 1, oa.rf.individualEquation), new ArithmeticExercise( oa.apt.additionOf3, 3, oa.rf.compHouse), new ArithmeticExercise( oa.apt.simpleAdditionWithAskedForOperand2, 1, oa.rf.individualEquation), new ArithmeticExercise( oa.apt.simpleAdditionUpTo6, 1, oa.rf.additionWithAnimatedDice), new ArithmeticExercise( oa.apt.basicAddition, 3, oa.rf.memory), new ArithmeticExercise( oa.apt.simpleAdditionUpTo6, 1, oa.rf.additionAndSubtractionOfCoins), new ArithmeticExercise( oa.apt.simpleAdditionOf3Numbers, 1, oa.rf.animatedStars) ] ); oa.learningUnits.push( oa.lu.demo1a);

When you have defined your own set of problem types and learning units, you can contact us for uploading them and including them in your own learning units web page.

The OpenArithmetic portal supports teachers to create and publish their own set of learning units. For testing this possibility, just create your own learning units file, possibly reusing our predefined problem types. Then go to our teacher upload app where you first have to create a user account before you can upload your learning units file. If you need help, please contact Gerd Wagner ([email protected]).