[Current Project] [Old projects] [Programming details]

[Projectos] [Projectos anteriores] [Diversos]

[Página principal]

**Current project**

Azevedo's personal page

If you are experiencing download problems, I would recomend the usage of GetRight software

- Allows the edition of equations in a graphical (Windows) environment.

- Supports Drag&Drop operations, you can put an expression in a list or into other expression, just by droping it over the target.

- Automaticaly identifies the elements type and uses sintax hilite (draws elements using the type color).

Key seq. | Operator generated |

^ | raise to power |

@ | root |

>= | greater or equal |

<= | less or equal |

<=> | equivalent |

=> | implication |

<> | not equal |

&brkbar; | logical OR |

& | logical AND |

-/ | ± operator |

The focused expression will influenciate the result of calculations or rule application.

ie:

writing

After defining a constant in the

Constants are defined as

Most recent addition to this program, the rules system is a collection of routines that can apply sets of algebraic rules to an expression based on a list of sample expressions (rules).

For testing purposes the rules are stored in a file (rules.sol) and the command **Test rules** from the **Tools** menu will automaticaly use it.
The matching of rules is done considering:

- The rule is a simplification ie: a+a=2*a

will scan the target expression for the occourence of a sum of two equal elements, replacing them by 2*(the elements found) in the result.

- The rule is a resolution ie: a*b=0 <=> a=0 or b=0

check if the target is an equation in the form*multiplication=0*, if so, show all solving steps (as shown on the sample rule).

ie: a*

this special element will act just like any other literal (variable) but will avoid his replacement by the neutral element of the multiplication (1). Therefor the case 2*x+x will be considered by the rule to be (2+1)*a, the case x+x will be considered to be (1+1)*x, but the case x+y

In addition to the introduction of neutrals when the target expression has not enough elements to fit the rule, the rules engine can also generate operators using neutrals to force an operator type match. The match is seeked regardless of the order of the elements on both sides rule and target.

The order switching match is not implemented for simplification operators (like =). Because of this a*b=0 is not the same as 0=a*b from the rules engine point of view.

The usage of literals (leters) on the rule doesn't mean that the rule will only apply to the same leters, it will be applicable on any expression when possible.

**Simple elements**

Literals, Nominals, Booleans and Infinits**Groups, Lists and Operators**

Group, List, Sum, Negation, Division, Multiplication, comparison series (=, <, >, <=, >=, <>), implication and equivalence series (=>, <=>), radicals, raise and other functions like (sin, cos, log, etc...).

The rules system allows the aplication of rules by sample and programmable calculator functionalities.

This systems also allows some kind of simplifications.

(only implemented on a previous project)

(only implemented on a previous project)

top of this page

last update: 97/10/02

See me at Undernet #c++ #coders - nick: "neur" or "Neuron"

Rui H F Azevedo

ruihfazevedo@yahoo.com

Member of Software HyperBanner