Well. There's a chance, but what I say now might change. Furthermore, I don't have a set schedule for alphas as I add new features.

The first alpha release should have the basic four, exponents, roots, log, ln, trig functions cos-acsch, variable support, and text input. Making it look like a is optional.

After that, sets and matrices need to be handled. Once the datatypes are recognized properly, basic statistics operations will be added. Don't expect to see geometpdf() just then. For matrices, the basic four and inverses will likely be a temporary stopping point. If sets are handled properly the first time, another alpha will be released here.

After that? Who knows. Program support would likely be a good idea, but graphing needs code as well. Furthermore, while the strict-TI parser we're using works, I'd rather have a different one at least available.

Extending the math library (ML) will be last on the list. If any of what has already been mentioned requires change in the ML, the changes will be easier on a smaller ML.

Coolness. I guess you're not planning on any TI-BASIC parsing support then?

That would be the program support mentioned in the same paragraph as graphing...

:blush: /me didn't read the last few lines carefully enough.

Well, the backend is ready for an alpha release...
Unfortunately, I haven't been able to locate the cause of a GUI<->Backend compatibility bug, so I can't release the GUI yet...
I will put a release on SF, but you won't be able to use it unless you follow instructions:
1. CD to the directory you extracted everything to
2. run 'python -i calcMan.py'
3. To evaluate an expression, run 'print calc.exec_str("expr")' with the expression-string as the only argument. You will receive a TON of debugging output, most of it allowing you to track progress through the parser and executer, the last line should be the answer.
Currently supported (in theory, not necessarily practice):
+, -, *, /, ^, nPr, nCr, !, abs(), ln(), log(), log(x, b), ceil(), mod(x, y), conj(), real(), imag(), angle(), exp(), rand(), randInt(), randBin(), randNorm(), fPart(), iPart(), gcd(), lcm(), cos(), sin(), tan(), csc(), sec(), cot(), acos(), asin(), atan(), acsc(), asec(), acot(), cosh(), sinh(), tanh(), csch(), sech(), coth(), acosh(), asinh(), atanh(), acsch(), asech(), acoth(), sqrt(), not()
NOTE: I do not guarantee it will be able to stand any particular form of use, or that it is accurate. You should check every answer against another calculator.

cool finally the fist alpha
i will not get to testing it anytime soon as i now have many things to do now

in the python command proegssilb said, that is a LOWERCASE i, not an upper case one

However, here is a simpler way to use it (save this with the .py extension, and if you are on linux, chmod +x it)


Code:


I'll go ahead and make this the default behavior for calcMan.py for future versions (i also replaced all of the debug outputs in calcMan with a function call, which checks to see if debug output is enabled or not - enable it with the -d or --debug switch, or at the run-time command prompt via DEBUG <ON|OFF> command)

NOTE TO ANYONE HELPING DEVELOP! Please use d_print() instead of print for any non-critical output messages (such as debug output). It takes 1 string argument and passes that to print if debug is enabled. Please use the printf style string formatting in python rather than adding strings. d_print() can be copied into any module, all that is needed is that sys must be imported in that module

EDIT:
Release updated and posted, the file is available here: http://prdownloads.sourceforge.net/t83/t83-0.0.01a.tar.bz2?download

To use it just run calcMan.py ( "python calcMan.py" ), and it will give you a prompt ( ":" ), just type what you want and hit enter. "help" shows the currently supported options/commands of the mini-interface (which is just the DEBUG mentioned above)

Very nice! I like it a lot so far. Only comments are the accuracy of exponential stuff (which you explained to me has to do with the constant in use for "e") and the nonfunctioning of sin, cos, and tan.

Actually, It's to do with how ln() is implemented...
I borrow MPFR's implementation:
The computation of log(a) is done using the formula,
if we want p bits of the result,

ln(a) = pi/( 2*ArithmeticGeometricMean(1, 4/s) ) - m*ln(2)
where s = x*2^m, and x*2^m > 2^(p/2)

I make p a constant and hope all works out well. I'll look into converting to a loop of increasing accuracy, although that will be a little interesting; I use a loop of increasing accuracy for sine and cosine, but I borrow the results of the previous loop. Think Taylor Series.

Yeah, definitely. I think you should do what the TI-OS does: if more than about the first 10 or 12 digits after the decimal point are 9999999999 or 00000000, then round to the integer.

I believe what TI does is track 14, then only display 10. Good try, though.

It tracks 14 digits and 2 exponents, but displays up to 12 digits and 2 exponents.

Tablet 83 v. 0.0.02a has been posted (https://sourceforge.net/projects/t83). The most notable change is the addition of the GUI by running python App1.py. The command-line is still available by running python calcMan.py. Don't forget the -d flag to get debugging output!
The GUI might look like you could type an expression in and hit enter, but unfortunately that doesn't quite work yet...
Neither does the executer. Enter 2+3, and you get a long tree amounting to 2+3. I'll be working on that...

What's wrong with that? It's so much more visually appealing than a simple, boring "5" on the screen.

I'll make sure I include a "Useless" mode for you, Kerm. It's really easy to code, too...

Awesome. Seriously though, the GUI is an excellent step towards making it usable. I tried using it in Tablet mode, but obviously you didn't write that part yet. Nevertheless, I could use it to some extent.

You should have been able to use the input panel to input text, correct?

Indeed I was, and it worked quite sufficiently. I rather like that fun tree though. Hehe... I think I'll check the trig functions this time.

Once the team gets the parser together and does some minor testng, T83 might be ready for another release Don't get excited yet; the parser is being radically re-done. It could very well take until August to get it together. Anyone who insists on any specific form of input, post your demands on the poll thread for the UI... I'll at least total who wants what.

For the non-Tablet GUIs, make sure you have the Unicode version of wxPython installed.

Tablet PC Users wil have to wait on the tablet-optimized version. Since I plan on using a custom recognizer, there will be a TON of work going into it, even though TPCs (Tablet PC's) provide an API to help. IronPython, if it helps at all, will only get rid of the Automation issues. Regardless of what's used, the WXPTE GUI will depend on one specific runtime/library that the non-tablet version doesn't need.

Wow, your own custom handwriting recognition?? I look forward to seeing how that turns out.