As a *very* general bit of info: what you need to do is look up the Bauer-Samelson algorithm.  Texts on compilers or programming techniques will discuss this.

One source is:

PROGRAMMING AN INTRODUCTION TO COMPUTER TECHNIQUES, by Ward Douglas Maurer, Holden-Day, 1972, pp. 274.

(This is an older book which I had close at hand.)

You will use two stacks, one for operators, one for operands, and, of course, the input string (the formula to evaluate).

Hope this helps,

Charles

"For God So Loved The World, That He Gave His
 Only Begotten Son, That Whosoever Believeth
 In Him Should Not Perish, But Have Everlasting
 Life"John3:16  * http://pw2.netcom.com/~cbrtjr/wrdthing.html *

I did it for a formal logic program, though I did it in QuickBasic 4.5 at
the time--all the calculations would translate to VB just fine, however.
I have this to say: it made my head hurt. How to do it? I don't know. I
just went at it until it worked. And I wasn't terribly skilled at the
time--it was my first program since I learned BASIC on a c64 in 1980,
some 16 or 17 years later. The result was functional, but man was the
code ugly. However I learned a great deal. Which is all to say: it can be
done; it does not require guru-level technical skills; and it will
probably drive you mad. I was mad before I began, so I had nothing to lose.

Good luck and best wishes,
Paul

I can't give you actual URLs but I found (less than 6 months back) this
stuff on the Web:

        - VB source code for evaluating expressions (with support for some
functions)
        - An OCX
        - A general purpose parser (look for nparse32.zip)

A search with Altavista (altavista.digital.com) should turn up some
useful stuff.

Good luck.

MikeC

PS Would really appreciate it if you post final results of your search.

Please reply to the group.

Good Luck,
Gerry T.

Without a grammer, only a scanner for equations can be implemented. Herefore
I'd suggest to restrict operators to single characters, and hold these in a
single string. Then you can classify every input character with
InStr(Operators, InputChar). If it's found in the string, the previous
non-operator characters are combined into a literal token, then the according
operator token can be created. The handling of white space can be simplified to
Trim$ of the literals, and no token must be created when the trimmed string is
empty.

The string literals can be subdivided into numeric values (starting with a
digit), that can be converted to value tokens with Val, or other names, that
can be searched in the collections of all predefined functions (sin, sqrt...),
of all user defined functions, and finally in the variables collections. If no
matching entry was found, it should be the name of a new variable, and be added
to that collection.

The output of the scanner then consists of operators, values, predefined
functions, user defined functions, and variables. The further handling of these
tokens depends on your grammar.

DoDi

Tokenizing can be accomplished in VB by identifying the type of each string
segment. You look at the first non-blank character you encounter.
Some first characters, such as quote require you to go looking for a
matching
end, while others just grow in length until a character not of that class is
found, such as 123+ where plus isn't a member of numbers. In VB, I'd keep
the
tokens in a collection of objects which expose at least Value (the string
itself), Style (the type, which happens to be reserved) and Precedence which
is
a function of the Style.

Style is fairly simple, tokens are either functions, values, or controls.
For a
simple language, controls usually include (,).  Looking
just at the Value, the Polish for
  3 + 4 * 5
would produce
   3 4 5 * +
because * has higher Precedence than +, where as
  ( 3 + 4 ) * 5
would produce
   3 4 + 5 *
Because the parenthesis force a Precedence.

Evaluation is pretty simple once you have a precedence free statement, such
as
Polish notation.  You take items from the Polish stack and push them on the
result stack.  Each function knows how many items from the result stack to
pop
as its arguments, and it pushes its result back on the result stack.
Evaluation
ends when the Polish stack is empty, and the result stack is the value to
return.  If your language supports assignment statements, then the result
stack
should be empty in those cases.

There is a little more work to do if you want to support other statement
types
such as If or Do While, but these are the basics of statement evaluation.

Paul L Jackson

It's great.

|
|>I would like to develop a VB application that takes a mathematical
|[snip]
|
|You can see my code for this: located at
|http://www.geocities.com/SiliconValley/Lakes/1218/Solve10.zip
|
|it's commented in Italian, but the big problem is that it is a stupid
|way to solve math expression (btw, it solves only +-/* operators and
|parenthesis), very ugly coding, but it might still be a good start.
|
|Bye
|

You can see my code for this: located at
http://www.geocities.com/SiliconValley/Lakes/1218/Solve10.zip

it's commented in Italian, but the big problem is that it is a stupid
way to solve math expression (btw, it solves only +-/* operators and
parenthesis), very ugly coding, but it might still be a good start.

Bye