# How to Create New Learning Units

### For the OpenArithmetic Portal

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.

## Introduction

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;

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.

## Problems and Problem Types

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(
[ null, {lb:0,ub:9}, {lb:1,ub:1}],
[ OperatorEL.plus],
);```

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`.

Figure 1. Arithmetic problems and problem types 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

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

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

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

4. 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:

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

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

3. 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` .

• Sorting numbers (`SortingNumbers`). The numbers to be sorted are generated at random within the bounds defined by `numberRanges` .

• 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`)

## Rendering Forms

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.

Table 1. Rendering forms
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

## Exercises and Learning Units

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
[
]
);
oa.learningUnits.push( oa.lu.demo1a);``` 