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

[Projectos] [Projectos anteriores] [Diversos]
[Página principal]

Current project
Azevedo's personal page

### Algebra - Equation editor for windows. (developing...)

• Dowload the 32bits application here (Win32 v039 beta, 777kb)
• Please send me an e-mail with your opinion/sugestions about my work. Thanks.
• This software is intended to be used just like a demo, I do not give permition for modification or inclusion.

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

Application snap-shot:

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

### Quick help

#### key sequences

 Key seq. Operator generated ^ raise to power @ root >= greater or equal <= less or equal <=> equivalent => implication <> not equal &brkbar; logical OR & logical AND -/ ± operator

#### Functions

To generate functions simply type the function name followed by a space, or '(' after a user defined function name, or start typing at the left of an operator.

#### Expression focus and results

Moving the cursor using the arrow keys causes operator hilight (focus).
The focused expression will influenciate the result of calculations or rule application.
ie:

#### Programmable calculator functionality

• Write your user defined functions on the rules.sol file.
• Enter function name and parameters on a document.
• Hilite the function (set focus) by pressing [End] key.
• Choose Tools &brkbar; Test Rule to get the function expanded.
• Hilite the expanded expression and choose Tools &brkbar; Calculate.
• ie:
writing f(x,y)=x+2*y on rules.sol file will allow the expansion of f(4,3) to f(4,3)=4+2*3
its legal to define functions with the same name as long as they have different number or variables.
After defining a constant in the rules.sol file you can hilite any expression on your document and ask for the replacement.

#### Use constants

This option allows the replacement of constants defined in rules.sol file.
Constants are defined as constant text=value expression, where constant text must be a single literal and value expression can be any expression (not containing operators like = or ≤=≥).

#### The 'rules' system

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).
Some '?' special elements must be used in a rule in order to refrain the rule engine
ie: a*?+b*?=(a+b)*?
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 will not be considered to be (x+y)*1, avoiding a redundant and recursive path.

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.

### Project steps

#### Equation Editor and parser

This phase is completed (beta). Implemented support for several operators and functions, operators are supported by implementation of an internal list of operators prototypes allowing adding or removing of prototypes at runtime.
• 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...).

#### Calculation

This phase is completed (beta). Supported numerical calculations of all prototyped operators.

#### Rules system

This phase is under development and will serve as a base for the simplification process.
The rules system allows the aplication of rules by sample and programmable calculator functionalities.
This systems also allows some kind of simplifications.

#### Rules database

Not implemented. Will store the rules system support.

#### Simplification

Not implemented. The simplification process will be supported by the rules system and some simple rules that at this moment are supported only by that system will be ported to C++ code for performance reasons.

#### Resolution

Not implemented. The resolution system will work expressions isolating a selected literal.
(only implemented on a previous project)

#### Units and formulas

Not implemented. Will require the definition of measurement units as well as formulas and convertions, this step will allow the application to work with a database of formulas in order to manage physics and other applyed sciences problems.
(only implemented on a previous project)

#### Plotting

Not implemented. I would apreciate an hand on this.

#### Programming language

Not implemented. And possibly wont be implemented unless i start typing with my foot fingers too. :)

Special thanks to:
"Shamino" at Undernet #c++ #owl - for some OWL help :)
Ruben Armas - Beta tester and structure considerations
Nelson Mão de Ferro - Beta tester
Adams Casinha - Beta tester
Prof. Manuel José - encouragement and theoric discution
Rui F.F. Ribeiro (University of West of England, Bristol - Undernet "frog" #porto #c++) - encouragement and some opinions
"Unf" at Undernet #coders - lots of encouragement, [ thanks "Unf" (; ]
"Obercoder" at Undernet #c++ - good C++ MFC help

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

This page hosted by Get your own Free Home Page

Member of Software HyperBanner