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
- 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|
|>=||greater or equal|
|<=||less or equal|
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.
Programmable calculator functionality
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.
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:
Some '?' special elements must be used in a rule in order to refrain the rule engine
- 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).
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.
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...).
This phase is completed (beta). Supported numerical calculations of all prototyped operators.
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.
Not implemented. Will store the rules system support.
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.
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)
Not implemented. I would apreciate an hand on this.
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
This page hosted by
Get your own Free Home Page
Member of Software HyperBanner