Lua would be more suited than TI basic (which is quite limited on the Nspire). Other than that, programming logic is easy since programming /is/ logic.

Unfortunately, the computer with my TI Software on it has a virus so it's currently unstable. Also, in terms of Lua, I have no experience with it. Loulou 54, by any chance could I have the code for the truth table portion of your program? That way, I could paste it into an emulator and use it that way until my computer is up and running.

So here are the interesting extracts in Basic :

INPUT : a string in the following format :
example : eq:="a+/(b*/c)"
/!\ use only letters between "a" and "f".

* Formating into a boolean expression : (with "and", "or", "1-" for not)

inString(eq,"*")→tr:While tr≠0:left(eq,tr-1)&" and "&right(eq,dim(eq)-tr)→eq:inString(eq,"*",tr)→tr:EndWhile::inString(eq,"+")→tr:While tr≠0:left(eq,tr-1)&" or "&right(eq,dim(eq)-tr)→eq:inString(eq,"+",tr)→tr:EndWhile::inString(eq,"//")→tr:While tr≠0:left(eq,tr-1)&mid(eq,tr+2)→eq:inString(eq,"//",tr)→tr:EndWhile::inString(eq,"/")→tr:While tr≠0:left(eq,tr-1)&"1-"&right(eq,dim(eq)-tr)→eq:inString(eq,"/",tr)→tr:EndWhile

* Building the list of the involved variables :

{}→v:{}→vv:For aba,1,8:If inString(eql,char(aba+96))≠0 Then:augment(v,{char(aba+96)})→v:augment(vv,{aba+96})→vv:EndIf:EndFor

* Building the natural truth table :

Disp " ★ Table de vérité (naturel)":newMat(2^(dim(v))+1,dim(v)+1)→tb:"S="→tb[1,dim(v)+1]:For aba,1,dim(v):v[aba]→tb[1,aba]:EndFor::For aba,0,2^(dim(v))-1:setMode(7,3):mid(string(aba),3)→n:setMode(7,1):While dim(n)≠dim(v):"0"&n→n:EndWhile:For cpt,1,dim(v):expr(mid(n,cpt,1))→#(v[cpt]):#(v[cpt])→tb[aba+2,cpt]:EndFor:expr(eq)→tb[aba+2,dim(v)+1]:EndFor::Disp tb

* Building the gray truth table : (reflected binary coding)

{0,1,2,1,3,1,2,1,4,1,2,1,3,1,2,1,5,1,2,1,3,1,2,1,4,1,2,1,3,1,2,1,6,1,2,1,3,1,2,1,4,1,2,1,3,1,2,1,5,1,2,1,3,1,2,1,4,1,2,1,3,1,2,1}→chg
Disp " ★ Table de vérité (Gray)":newMat(2^(dim(v)),dim(v)+1)→tbg::For aba,1,dim(v):0→#(v[aba]):EndFor::For aba,1,2^(dim(v)):If aba≠1:1-expr(v[dim(v)+1-chg[aba]])→#(v[dim(v)+1-chg[aba]]):For cp,1,dim(v):expr(v[cp])→tbg[aba,cp]:EndFor:expr(eq)→tbg[aba,dim(v)+1]:EndFor::newMat(1,dim(v)+1)→t:"S="→t[1,dim(v)+1]:For aba,1,dim(v):v[aba]→t[1,aba]:EndFor::Disp colAugment(t,tbg)


NOTE : if you're under OS 3.2 there are risks it doesn't work ! (TI has changed some things about boolean operators. Especially, they added the logical => and <=>. I don't know why, but using the boolean operators with 0 and 1 wasn't always working through Lua. That's why I had to replace all the calculations using "false" and "true" statements. Anyway, try it first !)

Ok I see. Yeah it's a good idea, but then you have to find a way to evaluate the expressions..

Me, (I have not clearly explained) I'm using the boolean evaluation of the calculator on 0 and 1. Like this :
a+/(b*/c) => a or 1-(b and 1-c)
and then I affect every value to a,b,c and calculate it.

Your solution may be cool also, and maybe more efficient.
Maybe we could do so :
a:={0,0,0,0,1,1,1,1}
b:={0,0,1,1,0,0,1,1}
c:={0,1,0,1,0,1,0,1}
and replace :
"a*b" => a*b
"a+b" => ceiling((a+b)/2)
"/a" => (1-a)

but then, when you'll have to evaluate a complex equation, you'll have to place some extra parenthesis at the right position.
The best way to handle this is to do it recursively. Moreover, the TI-Basic "part(" function, may help you a lot to determine both argument of a binary operator :
example : evaluate(a+b*c)
part(a+b*c,0) ==> "+" the operator with the priority
part(a+b*c,1) ==>a first part
part(a+b*c+c,2) ==>b*c second part

so you know you have to do : ceiling((evaluate(a)+evaluate(b*c))/2)
- evaluate(a) will return a
- evaluate(b*c) will return evaluate(b)*evaluate(c)
     evaluate(b) will return b
     evaluate(c) will return c


Well, as you like ! ^^ Good luck anyway !

Ok let me know, good luck !