# Difference between revisions of "Introduction to MathObjects"

MathObjects are programing objects which behave much as you would expect their true mathematical counterparts to behave. For example `a+b` means one thing if `a` and `b` are vectors or matrices, another if they are real numbers and a third if `a` and `b` are complex numbers. Likewise multiplication: `a b` or `a*b` mean different things depending on the mathematical object (although of course all of the versions of multiplication have certain similarities.)

## How to create a MathObject

```\$a = Real(3.5);
\$b = Complex(3, 4);
\$b = Complex("3 +4i");
```

`\$a` represents a real number 3.5 and `\$b` (defined by either method) represents a complex number.

## Which MathObject types (classes) can be created?

These classes are listed and made available for writing problems in `pg/macros/Value.pl`. It is loaded automatically when you load `MathObjects.pl`.

### Standard types

• Real: Behave like real numbers
• Infinity: The positive infinity of the extended reals. Can be negated, but can't be added to real numbers.
• Complex: Behave like complex numbers. The interpretations of `+` and `*` are those standardly used for mathematical complex numbers.

### List types

List objects are math objects whose description involves delimiters (parentheses) of some type. For example points `(4, 5)` or vectors `<2,5>` . Here are examples of the construction of the List Objects.

• Point: `\$a = Point("(4,5)");`
• Vector: `\$b = Vector("<3,5,6!>");`
• Matrix: `\$c = Matrix("[[1,0],[0,1]]");`
• List: `\$d = List("3, 7, 3+2i");`

### Types that represent some subset of the real numbers

• Interval: `\$I = Interval("[0,1)");`
• Set (a finite collections of points): `\$S = Set("{3,5,6,8}");`
• Union (of intervals and sets): `\$U = Union(""I U J");` (I union J)

### The String type

String is a special purpose type which allows comparison to an arbitrary string.

```String("DNE")
```

### The Formula type

A Formula object represents a functions whose output is one of the MathObject types defined above. Every Formula contains a parse tree which allows you to calculate output values from given input values.

## How to invoke a method of a MathObject

Use the standard Perl method call syntax:

```\$obj->method;
\$obj->method(\$arg1,\$arg2);
```

For example:

```ANS(\$a->cmp);
```

This compares the student's answer with `\$a`. If `\$a` is Real then this comparison will be "fuzzy" which means that equality is checked to a tolerance defined by the current Context.

### Methods shared by all MathObjects

• cmp: Returns an answer checker for the Value. All of the answer checkers are defined in the file lib/Value/AnswerChecker.pm.
• perl -- Returns a string which represents the object as Perl source code.
• perlFunction -- Returns a Perl subroutine which represents the object. (Only available for Formula objects.)
• value -- Returns the value of the object.
• TeX -- Returns a string which represents the object as a TeX math expression.
• string -- Returns a string similar to that used to create the object. May include extra parentheses.
• stringify -- Produces the output of the object when inside quotes. Depending on context this is either a TeX string or a regular string. (This is called automatically by Perl when when an object is used in string context, and should not need to be called explicitly by the problem author.)
• getFlag("flag name") -- Returns the value of one of the object's internal flags. For example: `\$a->getFlag("tolerance");`

## The MathObjects Parser

The parser works "behind the scenes" to create formula. It's purpose is to parse a string representing a formula and turn it into a parse tree. Objects containing a parse tree are of the Formula class and have these additional methods.

Parser methods include:

• eval
• reduce
• perl
• TeX

The parser is defined in the file `pg/lib/Parser.pm` and the files in the `pg/lib/Parser` directory. Even though the subdirectory names under `pg/lib/Parser` are similar to those under `pg/lib/Value` they refer to different although related concepts. Under `pg/lib/Parser` the files refer to tokens in a string that is to be parsed, while the files under `pg/lib/Value` refer to MathObjects.

## The Context

This is essentially a table of values that provides default values for the MathObjects and for the Parser. As a quick example: in Numeric context the answer `(4,5)` is interpreted as a point in the two dimensional plane. in Interval context it is interpreted as the real values x satisfying `4 < x < 5`.

• Define context using: `Context("Numeric");`
• To obtain the current context: `\$context = Context();`
• Context names: defined in pg/lib/Parser/Context/Default.pm
• Numeric: no Matrix, Complex or Vectors (or intervals) are allowed.
• Complex: no Matrix or Vector, can't use "less than".
• Point: really the same as the Vector context below
• Vector: `i`, `j`, and `k` are defined as unit Vectors, no Complex numbers are allowed.
• Vector2D: `i` and `j` are defined as unit Vectors, no Complex numbers are allowed.
• Matrix: square brackets define Matrix instead of Point or Interval
• Interval: similar to Numeric context, but `(,)` and `[,]` create Real Intervals rather than Lists. `{,}` creates finite sets of Reals.
• Full: For internal use. This context is used to seed the others.
• `pi` is defined
• `i` is square root of minus one, but `j` and `k` are unit Vectors
• Matrix, Vector and Complex are all defined.
• `x` is a variable