if(document.all||document.getElementBtId)
 document.body.style.background="url('watermark.jpg') white center no_repeat fixed"
//////////////////////////STRING FUNCTIONS from c++///////////////////////
function charINstr(str,chr)
{
for(i=0;i<str.length;i++)
 if(str.charAt(i)==chr)
  return 1
return 0
}
//---------------------------------------------------------------

function chkReturn()
{
f=Evaluate.expre.value
var sy=0
var sx=0
var x=0
var y=0
var r=0
////////////////////////////////
if(isStat)
 {
 if(f=='s=sqrt((sigma(y^2)-((sigma(y))^2)/n)/(n-1))')
 sy=1
 if(f=='s=sqrt((sigma(x^2)-((sigma(x))^2)/n)/(n-1))')
  sx=1
 if(f=='X=(y-A)/B')
  x=1
 if(f=='Y=A+B*x')
  y=1
 if(f=='r=(sigma(x*y)-(sigma(x)*sigma(y))/n)/(sqrt((sigma(x^2)-((sigma(x))^2)/n)*(sigma(y^2)-((sigma(y))^2)/n)))')
  r=1
 if(sx||sy||x||y||r);
 else
  isStat=0
 }
 
///////////////////////////////
re=/[a-z]?=/i
if(!re.test(f)||isStat);//the only time to use enter button is for your own formulas
else
if(enteraval)
 {
 enteraval=0
 isFormula=1
 wasFormula=1
 getVarsAndValues()
 }
}
//-------------------------------------------------------------------------
var cnt=0
function redoFormula()
{
if(wasFormula)
 {
 isFormula=1
 wasFormula=0
 cnt=0
 Evaluate.expre.value=currentFormula
 }
}
//--------------------------------------------------------------------------

function getVarsAndValues()//NEW old 9-10 allow formulas with vars
{
var tox=0
var toy=0
var vars=''
var tokn=''
var i=0
var agg=''
var strng=''
var varCnt=0
var sgmx=0
var sgmy=0
var nosgmx=0
var nosgmy=0
formulaStr=Evaluate.expre.value
var resgmx=/sigma\([^a-z]*x[^a-z]*\)/i
var resgmy=/sigma\([^a-z]*y[^a-z]*\)/i
sgmx=resgmx.test(formulaStr)
sgmy=resgmy.test(formulaStr)
//////////////////////////////////
if(sgmx)
 formulaStr=formulaStr.replace(resgmx,'')
if(sgmy)
 formulaStr=formulaStr.replace(resgmy,'')
//////////////////////////////
if(!cnt)
 {
 currentFormula=Evaluate.expre.value
 cnt=1
 }
result=formulaStr.match(/[a-z]+/ig)
strng=strng+result  //cheated here so could use result value
tokn=strng.split(/,/)//split fails for result-has to do that result is obtained from re.match????
///////////////////////
//////////////////////////

while(i<tokn.length)
 {
 if(tokn[i].length==1)//have a var
  {
  agg+=' '
  agg+=tokn[i]
  }
 i++
 } 
vars=agg.split(/ /)
/////////////
for(j=0;j<vars.length;j++)
 {
 if(vars[j]==vars[j+1])
   vars[j+1]=vars[j+2]
 if(j>1000)
  break 
 } 
/////////////////
if(/[a-z]=/i.test(formulaStr))
 {
 varTocalculate=vars[0]
 vars[0]=''
 i=1
 }
else
 i=0
///////////////
handleBadFormula(vars)//no t=...u..t...  
if(illegalFormula==1)
 {
 alert("Invalid Formula: The same variable cannot appear on both sides of =")
 illegalFormula=0
 Evaluate.expre.focus()
 return
 }
if(illegalFormula==2)
 {
 alert("Invalid Formula: The same variable cannot appear both as a stand alone variable and in a summation")
 illegalFormula=0
 Evaluate.expre.focus()
 return
 }
 
////////////////// 
while(i<vars.length)
 {
 Evaluate.varName.value=vars[i] 
 if(Evaluate.varValue.value)
  {
  replaceVar()
  if(vars[i+1]==undefined)
   {
   Evaluate.varName.value=''  
   if(sgmy)
    {
    toy=1
    Evaluate.yVal.focus()
    }
   if(sgmx)
    {
    tox=1
    Evaluate.xVal.focus()
    }
   }
  else
   Evaluate.varName.value=vars[i+1]
  Evaluate.varValue.value=''
  if(tox||toy)
   tox=toy=0
  else
   Evaluate.varValue.focus()
  }
 i++
 lastI=i
 return
 }
lastI=0 
//////////////////////
/////////////////////
}
//-----------------------------------------------------------------------

function replaceVar()
{
var formula=Evaluate.expre.value

formula=formula.replace(varTocalculate,'')
formula=formula+' '//add space since re with ? fails
var v=Evaluate.varName.value
var i=0
var k=0
var arr
var ar
var re
var reg
var a
////////////building a reg expression (re) with a variable and re symbols/////////////
a="[^a-zA-Z]"     //no replace unless 1 char(a var) if >1char in a row it is a function
a+=v         
a+="[^a-zA-Z]"
re= new RegExp(a)
////////////////////////////////////////////////////////////////////////
reg=new RegExp(v)//regexp =var only
arr=re.exec(formula)
k=0
while(arr)//new arr at ea iteration since ....exec starts at lastIndex
 {
 ///////////
 whlCnt++
 if(whlCnt>1000)
  {
  whlCnt=0
  //alert("169")
  break
  }
/////////////
 ar=' '//cheated else replace won't work w/ar
 ar+=arr
 ar=ar.replace(reg,Evaluate.varValue.value)
 //alert(formula)
 formula=formula.replace(re,ar)
 //alert(formula)
 arr=re.exec(formula)
 }
var tmp=varTocalculate
tmp+=formula
while(/\s/.test(tmp))
 {
 whlCnt++
  if(whlCnt>1000)
   {
   whlCnt=0
  // alert("192")
   break
   }
 
 tmp=tmp.replace(/\s/,'')
 }
formula=tmp 

Evaluate.expre.value=formula
}
//-----------------------------------------------------------------

function handleBadFormula(vs)
{
var summAndalone=0
var str=Evaluate.expre.value
var i=1
while(vs[i])
 {
 if(varTocalculate==vs[i])
  {
  illegalFormula=1
  return
  }
 i++
 }
 //////////////////////
re=/sigma\(.*?x\)[^x]/i
SIGMAx=re.exec(str)
re=/[^sigma][^a-z]x/i
noSIGMAx=re.exec(str)
if(SIGMAx&&noSIGMAx)
 {
 illegalFormula=2  
 return
 }
 ///////
re=/sigma\(.*?y\)[^y]/i
SIGMAy=re.exec(str)
re=/[^sigma][^a-z]y/i
noSIGMAy=re.exec(str)
if(SIGMAy&&noSIGMAy)
 {
 illegalFormula=2  
 return
 }

}
//-------------------------------------------------

function insertPi()
{
var str=Evaluate.expre.value
var formula=str
var cnt=0
var re=/p/
if(re.test(formula))
 {
 while(re.test(formula))
  {
  formula=formula.replace(re,"3.141592653")
  cnt++
  if(cnt>1000)
  break;
  }
 Evaluate.varValue.value=""
 }
Evaluate.expre.value=formula
}
//------------------------------------------------------------------

function insertE()
{
var str=Evaluate.expre.value
var formula=str
var cnt=0
var re=/e/
if(re.test(formula))
 {
 while(re.test(formula))
  {
  formula=formula.replace(re,"2.718281828")
  cnt++
  if(cnt>1000)
  break;
  }
 Evaluate.varValue.value=""
 }
Evaluate.expre.value=formula
}
//--------------------------------------------------------------------

function ent_chg(num)
{
var img=document.getElementById("enter")
if(num==1)
 {
 img.src="enterup.bmp"
 enteraval=1
 }
else if(num==2) 
 img.src="enterdon.bmp"
Evaluate.varValue.focus() 
}

//---------------------------------------------------


function replace_str(main,old_str,new_str,pos)
{
lft=main.substr(0,pos)
lft+=new_str
rht=main.substr(pos+old_str.length)
return lft+rht
}
//-----------------------------

function insert_str(main,sub,pos)
{
lft=main.substr(0,pos)
lft+=sub
rht=main.substr(pos)
return lft+rht
}
//----------------------------

function insert_char(main,sub,pos)
{
lft=main.substr(0,pos)
lft+=sub
rht=main.substr(pos)
return lft+rht
}
//----------------------------

function delete_str(main,sub,pos)
{
lft=main.substr(0,pos)
rht=main.substr(pos+sub.length)
return lft+rht
}
//-----------------------------

function strngpos(str1,str2)
{
j=0
k=0
txt_length=0
pos=0;
txt_length=str2.length
for(k=0;k<str1.length;k++)
 {
 if(str1.charAt(k)==str2.charAt(0)&&str1.charAt(k+txt_length-1)==str2.charAt(txt_length-1))
  {                 
  j=k;
  while(str1.charAt(j)==str2.charAt(j-k))   
   {
    whlCnt++
   if(whlCnt>1000)
    {
    whlCnt=0
    //alert("249")
    break
    }

   if(j>=str1.length) 
    break;
   j++;
   }
  if(j-k>=txt_length)
   {
   pos=k
 {

 }
   break
   }
  }
 }
 return pos
}
//--------------------------------------------------------------

function strngPos(str1,str2)
{
return str1.indexOf(str2)
}
////////////////////////////////////////////////////////////////
//////////////////////////END STRING FUNCTIONS//////////////////////////////////////
///////////////////////////////////////////////////////////////


function handle_nFact(str)
{
var result=str
result=result.split(/[\(\+\-\*\/\)\^]/)
var i=0
while(i<result.length)
 {
 if(/!/.test(result[i]))
  {
  if(/\./.test(result[i]))
   {
   alert('Factorial (!) can be of an integer only')
   Evaluate.ans.value=''
   return
   } 
  result[i]=xfactorial(result[i])
  str=str.replace(/(\d+!)/,result[i])
  }
 i++
 }
return str
}
//---------------------------------------------------------------

function xfactorial(n)
{
n=n.replace(/!/,'')
////////////////////////////
var i;
var product=1;
for(i=n;i>0;i--)
 {
 if(i>0&&(i-1)>0)
  {
  product*=i*(i-1);
  i--;
  }
 }
return(product);
}
//-----------------------------------------------------------------

function btn_chg(num)
{
////////////////

if(X)//New 3-10 
   Evaluate.expre.value='X=(y-A)/B'
if(Y)
 Evaluate.expre.value='Y=A+B*x'
////////////////
var img=document.getElementById("btn")
if(num==1)
 {
 img.src="buttonup1.bmp"
 Evaluate.expre.focus() 
 calculate(Evaluate.expre.value)
 }
else if(num==2) 
 img.src="buttondwn1.bmp"
/////////////////////////

}
//------------------------------------------------------------------


////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
///////////////////////////////////
////////////////////

var illegal_calculation=0; var token=''; var Token=''; var tokn=''; var Conversion=0; var sRESULT=''; var Base=10;cannotConvert=0
var binery=''; var expreshun=''; var CT='';var Baas=10; var X; var Y; var isStat; var varNme=new Array();var vn; 
var requestedX; var requestedY; var lastI=0; var enteringValues=0; var enteraval=0; var varTocalculate; illegalFormula=0;
var isFormula; var wasFormula; var currentFormula; var whlCnt=0;var nosgmx=0;var nosgmy=0;var formulaStr=''

/////////////////////////////////////////////////////////////////////
haveSummation=0;hav_x=0;hav_y=0;var sumStrings=new Array();doneEdit='false';did_prompt=0;B=0;xm=0;ym=0;A=0;formulaNme='';FN='';new_x='';new_y=''
//----------------------------------------------------------------------------





////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
var binery=''; var expreshun=''; var CT='';
function get_bin_val(str)
{
//
var i
var num
var agg=0
for(i=0;i<4;i++)
 {
 if(str.charAt(i)=='1')
  {
  switch(i)
   {
   case 0:
   num=8;
   agg+=num;
   break;
   case 1:
   num=4;
   agg+=num;
   break;
   case 2:
   num=2;
   agg+=num;
   break;
   case 3:
   num=1;
   agg+=num;
   break;
   }
  }
 }
return agg;
}
//------------------------------------------------------------------------

function to_dec()
{
// to dec
MT=''
sRESULT=Evaluate.expre.value
re=/\s/
switch(Base)
 {
 case 10:
 break;
 case 2:
 Conversion=10;
 MT=sRESULT
 if(!re.test(MT))
  {
  format_bin(MT);
  sRESULT=MT;
  }

 handle_an_expression();
 //bin_to_dec();
 break;
 case 16:
 Conversion=2;
 handle_an_expression();
 //hex_to_bin();
 Conversion=10;
 MT=sRESULT
 if(!re.test(MT))
  {
  format_bin(MT);
  sRESULT=MT;
  }
 handle_an_expression();
 //bin_to_dec();
 break;
 }
Base=10;
}
//---------------------------------------------------------------------------

function to_binary()
{
//       to binary
sRESULT=Evaluate.expre.value
cannotConvert=0
re=/(abs)|(fact)|sin|cos|tan|log|ln|exp|pow|max|min|sqrt|sigma|\^/i
if(re.test(sRESULT))
 {
 cannotConvert=1
 Base=10
 Baas=10
 Evaluate.bse.value='Decimal'
 }
if(cannotConvert)
 {
 alert('This expression cannot be converted to hex or bin')
 sRESULT=''
 Evaluate.expre.value=''
 return
 }
//////////////////////////////////////////////////////
switch(Base)
 {
 case 10:
 Conversion=2;
 handle_an_expression();
 //dec_to_bin();
 break;
 case 2:
 break;
 case 16:
 Conversion=2;
 handle_an_expression();
 //hex_to_bin();
 break;
 }
Base=2;
}
//---------------------------------------------------------------------------

function to_hex()
{
//       to hex
sRESULT=Evaluate.expre.value
///////////////////////////////
cannotConvert=0
re=/(abs)|(fact)|(sin)|(cos)|(tan)|(log)|(ln)|(exp)|(pow)|(max)|(min)|(sqrt)|(sigma)|\^/i

if(re.test(sRESULT))
 {
 cannotConvert=1
 Base=10
 Baas=10
 Evaluate.bse.value='Decimal'
 }
if(cannotConvert)
 {
 alert('This expression cannot be converted to hex or bin')
 sRESULT=''
 Evaluate.expre.value=''
 return
 }
//////////////////////////////////
/////////////////////////////
re=/[a-fA-F]+[^g-zG-Z]/
if(re.test(sRESULT))
 {
 re=/(X=)|(Y=)/
 if(re.test(sRESULT))
  return
 Base=16
 Evaluate.bse.value='Hexadecimal'
 sRESULT=sRESULT.toUpperCase()
 Evaluate.expre.value=sRESULT
 return sRESULT
 }
///////////////////////////////////////////////
Evaluate.expre.value=Evaluate.expre.value.toUpperCase()
sRESULT=Evaluate.expre.value
///////////////////////////////////////////////////////////////
MT=''
re=/\s/
switch(Base)
 {
 case 10:
 Conversion=2;
 handle_an_expression();

// dec_to_bin();
 Conversion=16;
 MT=sRESULT
 if(!re.test(MT))
  {
  format_bin(MT);
  sRESULT=MT;
  }
 handle_an_expression();
// bin_to_hex();
 break;
 case 2:
 Conversion=16;
 MT=sRESULT
 if(!re.test(MT))
  {
  format_bin(MT);
  sRESULT=MT;
  }
 handle_an_expression();
 //bin_to_hex();
 break;
 case 16:
 break;
 }
Base=16;
}
//--------------------------------------------------------------------




function dec_to_bin()
{
// convert decimal to binary
binery=''
S=sRESULT
if(S=="")
 {
 Base=2;
 return;
 }
expreshun=S
var str=''
var cRemainder=''
var RemainderStr=''
var dividend=0
var divisor=2
var remainder=0
var quotient=7
var cnt=0
str=S
dividend=str
while(quotient>=1)
 {
 quotient=dividend/divisor;
 remainder=dividend%divisor;
 if(remainder>1)
  remainder=1
 if(remainder<1)
  remainder=0
 cRemainder=remainder
 dividend=quotient;
 if(cnt%4==0)
  binery=insert_char(binery,' ',0);
 RemainderStr=cRemainder
 binery=insert_char(binery,RemainderStr,0);

 cnt++;
 if(cnt>500)
  break;
 }

var result=binery
cnt=0;
var i
for(i=0;i<5;i++)
 {
 if(binery.charAt(i)==' '&&cnt<4)
  binery=insert_char(binery,'0',0);
 cnt++;
 }
sRESULT=result;
}
//-------------------------------------------------------------------------





function bin_to_hex()
{
// bin to hex=============================================PARSE===================================
//////////////////////////////(1) parse binary into sets of 4
token=''
var i=0
var str=''
var bin=new Array

str=binery

re=/\s/
token=str.split(re)

//////////////////////////////////(2) get val of ea tokn
i=0
S=''
//while(token[i]!='')
for(;i<token.length;i++)
 {

 bin[i]=get_bin_val(token[i]);
 switch(bin[i])
  {
  case 0:
  S+="0";
  break;
  case 1:
  S+="1";
  break;
  case 2:
  S+="2";
  break;
  case 3:
  S+="3";
  break;
  case 4:
  S+="4";
  break;
  case 5:
  S+="5";
  break;
  case 6:
  S+="6";
  break;
  case 7:
  S+="7";
  break;
  case 8:
  S+="8";
  break;
  case 9:
  S+="9";
  break;
  case 10:
  S+="A";
  break;
  case 11:
  S+="B";
  break;
  case 12:
  S+="C";
  break;
  case 13:
  S+="D";
  break;
  case 14:
  S+="E";
  break;
  case 15:
  S+="F";
  break;
  }
// i++;
 }
////////////////////////////////////////////////////3 convert to hex & build hex result

sRESULT=S;

}
//---------------------------------------------------------------------------





function hex_to_bin()
{
// hex to binary
var S=sRESULT
var bin=''
var c=''
var cBin=''
c=S
if(S=="")
 {
 Base=2;
 return;
 }
expreshun=S
var i=0;
var x=4;
while(c.charAt(i)!='')
 {
 switch(c.charAt(i))
  {
  case '0':
  if(i)
   bin+="0000";
  break;
  case '1':
  if(!i)
   {
   x=1;
   bin+="1";
   }
  else
  bin+="0001";
  break;
  case '2':
  if(!i)
   {
   x=2;
   bin+="10";
   }
  else
  bin+="0010";
  break;
  case '3':
  if(!i)
   {
   x=2;
   bin+="11";
   }
  else
  bin+="0011";
  break;
  case '4':
  if(!i)
   {
   x=3;
   bin+="100";
   }
  else
   bin+="0100";
  break;
  case '5':
  if(!i)
   {
   x=3;
   bin+="101";
   }
  else
  bin+="0101";
  break;
  case '6':
  if(!i)
   {
   x=3;
   bin+="110";
   }
  else
  bin+="0110";
  break;
  case '7':
  if(!i)
   {
   x=3;
   bin+="111";
   }
  else
  bin+="0111";
  break;
  case '8':
  bin+="1000";
  break;
  case '9':
  bin+="1001";
  break;
  case 'A':     //10
  bin+="1010";
  break;
  case 'B':     //11
  bin+="1011";
  break;
  case 'C':     //12
  bin+="1100";
  break;
  case 'D':     //13
  bin+="1101";
  break;
  case 'E':    //14
  bin+="1110";
  break;
  case 'F':   //15
  bin+="1111";
  break;
  }
 i++;
 }

cBin=bin
var cnt=0;
for(i=0;i<cBin.length;i++)
 {
 if(cnt==x)
  {
  x=4;
  cBin=insert_char(cBin,' ',i);
  i++;
  cnt=0;
  }
 cnt++;
 }
sRESULT=cBin;
// Memo1->SetFocus();
}
//---------------------------------------------------------------------------



function bin_to_dec()
{
//binary to decimal
var i=0,sum=0,cnt=0,factor=1,agg=0;
//bin output
var s=sRESULT
if(s=="")
 {
 Base=10;
 return;
 }
expreshun=s
var str=''
var tkn=''
str=s
var i=0;
re=/\s/
Token=str.split(re)
cnt=Token.length-1;


for(i=0;i<cnt;i++)
 factor*=16;
i=0;
//while(Token[i]!='')
while(i<Token.length)
 {
 tkn=Token[i]
 if(!i&&tkn.length<4)
  while(tkn.length<4)
   tkn=insert_char(tkn,'0',0);
 sum=get_bin_val(tkn);
 sum*=factor;
 factor/=16;
 agg+=sum;
 i++;
 }
var cAgg='';
 cAgg=agg
 result=cAgg;
sRESULT=result;
}
//---------------------------------------------------------------------------

function doConversion()
{
re=/[SNG\^]/
if(re.test(expreshun))//math fun
 {
 sRESULT="0";
 illegal_calculation=1;
 return;
 }
switch(Base)
  {
  case 2: //of base
  switch(Conversion)
   {
   case 10:   //of conv
   bin_to_dec();
   break;
   case 16:   //of conv
   bin_to_hex();
   break;
   }
  break;
  case 10://of base
  switch(Conversion)
   {
   case 2:      //of conv
   dec_to_bin();
   break;
   case 16:    //of conv
   bin_to_hex();
   break;
   }
  break;
  case 16://of base
  switch(Conversion)
   {
   case 2:      //of conv
   hex_to_bin();
   break;
   case 10:    //of conv
   bin_to_dec();
   break;
   }
  break;
  }
 }
//----------------------------------------------------------------------------

function handle_an_expression()
{
var str=''
var tmp=''
var S=sRESULT
expreshun=S
if(/=/.test(expreshun))
 expreshun.replace(/=/,'')
var i=0
var len=expreshun.length;
tokn=''
str=expreshun
re=/[\+\-\/\*\^\(\)]/
for(i=0;i<len;i++)
 if(re.test(str.charAt(i)))
  {
  len+=2;
  str=insert_char(str,'X',i);
  str=insert_char(str,'X',i+2);
  i++;
  }
expreshun=str
re=/X/
tokn=str.split(re)

/////////////////////////////////
i=0;
while(i<tokn.length)
 {
 
  whlCnt++
   if(whlCnt>1000)
    {
    //alert("966")
    break
    }

 
 if(/[\+\-\/\*\^\(\)]/.test(tokn[i]))
  tmp+=tokn[i];           
 else
 if(tokn[i]!='')
  {
  sRESULT=tokn[i];
  var MT=sRESULT;
  binery=MT
  var binTmp='';
  binTmp=binery
  var m
  if(/\s/.test(binTmp))
   {
   for(m=0;m<binTmp.length;m++)
    if(binTmp.charAt(m)==' ')
   binTmp=binTmp.replace(/\s/,'')
   while(binTmp.length%4)
    {
    
     whlCnt++
   if(whlCnt>1000)
    {
    whlCnt=0
    //alert("993")
    break
    }

    
    binTmp=insert_char(binTmp,'0',0);
    binery=insert_char(binery,'0',0);
    }
   }
  doConversion();
  tmp+=sRESULT;
  if(illegal_calculation)
   {
   illegal_calculation=0;
   tmp="0";
   }
  sRESULT=tmp;
  }
 i++
 }

}
//----------------------------------------------------------------------------

function format_bin(str)
{
var i=str.length,cnt=0;
re=/[\+\-\/\*\(\)]/
for(;i>=0;i--)
 {
 if(cnt%4==0)
  str=insert_char(str,' ',i);
 if(!re.test(str.charAt(i)))
  cnt++;
 }
}
//////////////////////////end conversion code//////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////




//////////////////////////begin evaluate code/////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
calculateCnt=0

function calculate_linear_estimation()
{
if(calculateCnt)
 return
//////////////////////////////// 
B=compute('B=(sigma(x*y)-(sigma(x)*sigma(y))/n)/(sigma(x^2)-((sigma(x))^2)/n)')
xm=compute('xm=(sigma(x))/n')
ym=compute('ym=(sigma(y))/n')
A=compute('A=ym-B*xm')
////////////////////////////////////////
//////////////////////////////////////////
//////////////////////////////////////
///////////////////////////////////
expression='A=ym-B*xm'
expression=get_xm_val(expression,xm)
expression=get_ym_val(expression,ym)
expression=get_B_val(expression,B)
///////////////////////////////////
if(FN=='x')
 {
 expression='X=(y-A)/B'
 expression=get_A_val(expression,A)
 expression=get_B_val(expression,B)
 expression=get_y_val(expression,new_y)
 formulaNme='x'
 Evaluate.expre.value=expression
 }
//////////////////////////////////
if(FN=='y')
{
 expression='Y=A+B*x'
 expression=get_A_val(expression,A)
 expression=get_B_val(expression,B)
 expression=get_x_val(expression,new_x)
 formulaNme='y'
 Evaluate.expre.value=expression
 }
//
Evaluate.ans.value=''
calculateCnt=1
}
//-----------------------------------------------------------------------------

function compute(expression)
{
expression=format(expression)


//alert(expression)
//alert(haveSummation)

if(haveSummation)
  expression=getSummationValues(expression)
with(Math)
 {
 result=parseFloat(eval(expression))
 }
return(result)
}
//-------------------------------------------------------------------------------

function calculate_x()
{
Evaluate.newyVal.focus;
if(!Evaluate.yVal.value)
 {
 calculate_linear_estimation()
 Evaluate.expre.value='X=(y-A)/B'
 calculate(Evaluate.expre.value)
 return
 }
//y=prompt('Enter a NEW VALUE for Y','')
y=Evaluate.newyVal.value

//y=newyVal;//NEW old 6-10  prompt fails for server
Evaluate.yVal.value+=','+y
////////////////////////////
var str=Evaluate.yVal.value
re=/,$/
re1=/\s$/
if(re.test(str))
 {
 str=str.replace(re,re1)
 Evaluate.yVal.value=str
 }
////////////////////////////
FN='x'
new_y=y
}
//----------------------------------------------------------------------------

function calculate_y()
{
Evaluate.newxVal.focus;
if(!Evaluate.xVal.value)
 {
 calculate_linear_estimation()
 Evaluate.expre.value='Y=A+B*x'
 calculate(Evaluate.expre.value)
 return
 }
//x=prompt('Enter a NEW VALUE for X','')
//x=newxVal;//NEW old 6-10
x=Evaluate.newxVal.value
Evaluate.xVal.value+=','+x
////////////////////////////NEW 10-10  no , after last entry
var str=Evaluate.xVal.value
re=/,$/
re1=/\s$/
if(re.test(str))
 {
 str=str.replace(re,re1)
 Evaluate.xVal.value=str
 }
////////////////////////////

FN='y'
new_x=x
}
//--------------------------------------------------------------------------


function getSumstrings(str)
{
nme=getSumStrDelm(str)
if(/=/.test(nme))
 nme=nme.substring(nme.indexOf('=')+1)
re=/[sigma()]/
if(re.test(nme))
 {
 re=/\s/
 haveSummation=true
 j=0
 array=nme.split(re)
 re=/[xy]/
 for(i=0;i<array.length;i++)
  {
  if(re.test(array[i]))
   {
   sumStrings[j]=array[i]
   sumStrings[j]=del_sumstr_par(sumStrings[j])
   j++
   }
  }
 re=/x/
 if(re.test(nme))
  hav_x=true
 re=/y/
 if(re.test(nme))
  hav_y=true
 }
else 
 return str
}
//------------------------------------------------------------------

function del_sumstr_par(str)
{
str=delete_str(str,'(',0)
str=delete_str(str,')',str.length-1)
return str
}
//---------------------------------------------------------

function getSumStrDelm(str)
{
cnt=0

re=/sigma/g
str=str.replace(re,'sigma ')
var i=0;j=0
for(;i<str.length;i++)
 if(str.charAt(i)==' ')
  {
  j=cnt=0
  while(str.charAt(i)!=')')
   {
   
    whlCnt++
   if(whlCnt>1000)
    {
    whlCnt=0
    //alert("1196")
    break
    }

   
   i++
   if(str.charAt(i)=='(')
    cnt++
   }
  while(str.charAt(i)==')')
   {
   
    whlCnt++
   if(whlCnt>1000)
    {
    whlCnt=0
    //alert("1211")
    break
    }

   
   j++
   i++
   }
  if(j>=cnt)
   {
   if(j>cnt)
    i--
   str=insert_str(str,' ',i)
   }
  }

return str
}
//-------------------------------------------------------------------


function format(str)
{
//////////////convert ln to log//////////////
str=str.toLowerCase()
re=/ln/g
str=str.replace(re,'log')
/////////////get all sum strings///////////////////
re=/sigma/
if(re.test(str))
/*if(isFormula)//NEW 10-10
 {
 
 str=getSummationValues(str)
 getSumstrings(str)

 
 }
else*/
 {
//alert("str=   "+str)
//alert("gettingsumstrings")


 getSumstrings(str)

 }
///////////////////////////////
re=/=/
if(re.test(str))
 formulaNme=str.charAt(0)
////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////handle expontents syntax:'5^2':(base_exponent) to 'pow(5,2)':(powStr)////////////
base=''
var i=0
strTmp=str
reg=/\^/
while(reg.test(str))
 {
 
  whlCnt++
   if(whlCnt>1000)
    {
    whlCnt=0
   // alert("1273")
    break
    }

 
 if(!i)
  {
  STRING=str 
  re=/\^/
  while(reg.test(STRING))
   {
   
   whlCnt++
   if(whlCnt>1000)
    {
    whlCnt=0
    //alert("1288")
    break
    }
  
   STRING=STRING.replace(re,',')
  }
  }
 powStr=STRING
 if(i)
  powStr=tmp
 else
  str=powStr
 re=/(\(sigma\([x|y]\))?\(*\d*\.?\d*\)*[x|y]?,\w*\(*\d*\.?\d*\)*/
 base_exponent=re.exec(powStr)
 powStr=delete_str(powStr,base_exponent[0],strngpos(powStr,base_exponent[0]))
 tmp=powStr
 re=/,/
 if(re.test(base_exponent[0]))
  {
  powStr=base_exponent[0] 
  powStr=powStr.replace(re,'~')

  if(powStr.charAt(0)=='~')
   powStr=insert_str(powStr,base,0)
  if(powStr.charAt(0)=='(')
   {
   if(powStr.substring(1,6)=='sigma')//have base with sigma in it:(sigma(x))^2
    m=0
   else if(/x|y/.test(powStr))
    m=powStr.search(/x|y/)
   else
    {
    m=1
    while(powStr.charAt(m)=='(')
     m++
    if(m>1)
     m--
    }
   powStr=insert_str(powStr,'pow(',m)
   if(!m)
    m=powStr.length
   else
    m=powStr.search(/\)/)
   if(m==-1)                   
    m=powStr.length
   powStr=insert_str(powStr,')',m)
   p=strngpos(str,base_exponent[0])
  
   
   
   if(/[nsgpwxt\)]/.test(str.charAt(p-1)))//nsg...=cos,sin,ln,tan,log,exp,pow,max,sqrt,)
    powStr=adjust_paren(powStr,i)
   
   }
  else
   {
   
   powStr=insert_str(powStr,'pow(',0)
   
   powStr=insert_str(powStr,')',powStr.length)
   
   }
///////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////

  re=/(\(sigma\([x|y]\))?(\(*(pow\()+.+~(\w){3,4})?\(*\d*\.?\d*\)*[x|y]?,\w*\(*\d*\.?\d*\)*/
  str=str.replace(re,powStr)
  if(charINstr(str,' '))
   re=/\s.+~pow/
  else
   re=/\(\.?\d+\.?~pow/
  str=str.replace(re,' ')
  base=powStr
  }
 reg=/,/
 i++
 }
/////////////////////////////////////

///////////
re=/~/
while(re.test(str))
 str=str.replace(re,',')

return str
}
//----------------------------------------------------


function adjust_paren(str,powCnt)
{
//////////////////////////
if(!powCnt)
 {
 re=/\){2}/
 str=str.replace(re,'')
 }
re=/\){3,}/g
str=str.replace(re,'))')
str+=' '
re=/(\d\)\s){1}/
while(re.test(str))
 {
 str=str.replace(/\s/,'')
 str+='))'
 

 }
re=/\)$/
if(!re.test(str))
 str+='))'
if(/[0-9\.][^0-9\.]/.test(str))//no extra paren if have sin(6+.....
 str=str.replace(/\)\)/,'')
//alert(str) 
return str
}
//---------------------------------------------------------------------

function calculate(expression)
{
if(/\d!/.test(expression))
 expression=handle_nFact(expression)
if(/\d\)?!/.test(expression))
 {
 alert('Factorial (!) can be of an integer only')
 Evaluate.ans.value=''
 return
 }
 //////////////////////////
 
 ////////////////////////
 if(!isFormula)
  findBase(expression)
 if(Base!=10)
  {
  Baas=Base
  to_dec()
  expression=sRESULT 
  }
 
 ////////////////////////////////////////////////////////////// 
 expression=format(expression)
 //alert("after formar  "+expression)
if(haveSummation)
  expression=getSummationValues(expression)



if(isStat)//NEW OLD 10-10   now can have your own formulas   not just stat
 { 
 if(/x/.test(formulaNme))
  {
  calculate_x()
  calculate_linear_estimation()
  }
 if(/y/.test(formulaNme))
  {
  calculate_y()
  calculate_linear_estimation()
  }
 }
///////////////////////////////
//
////////////////////////////
with(Math)
 {
 result=parseFloat(eval(expression))
 }
print_answer(result)

return(result)
}
//---------------------------------------------------------------------

function print_answer(res)
{
tmp=Evaluate.expre.value
if(Baas!=10)
 {
 switch(Baas)
  {
  case 2:
  Evaluate.expre.value=res
  to_binary()
  res=sRESULT
  break
  case 16:
  Evaluate.expre.value=res
  to_hex()
  res=sRESULT
  break
  }
 Evaluate.expre.value=tmp
 }
/////////////////////////////////////////////
with(document.forms.Evaluate)
 {
 if(formulaNme)
  ans.value=formulaNme+'='
 else
  ans.value='' 
 ans.value+=res.toString()

 if(FN=='x')
  {
  FN=''
  xVal.value+=','
  xVal.value+=ans.value.substring(2)
  }
 if(FN=='y')
  {
  FN=''
  yVal.value+=','
  yVal.value+=ans.value.substring(2)
  }
 }
}
//---------------------------------------------------------------------


function findBase(str)
{
cannotConvert=0
re=/abs|fact|sin|cos|tan|log|ln|exp|pow|max|min|sqrt|sigma|\^/i
if(re.test(str))
 {
 cannotConvert=1
 Base=10
 Evaluate.bse.value='Decimal'
 
 return
 }
re=/[a-fA-F]+[^g-zG-Z]/
if(re.test(str))
 {
 re=/(X=)|(Y=)/
 if(re.test(str))
  return
 Base=16
 Evaluate.bse.value='Hexadecimal'
 str=str.toUpperCase()
 Evaluate.expre.value=str
 return str
 }
}
//----------------------------------------------------------------------


function getSummationValues(str)
{

/////////////////////

var needX=0
var needY=0
if(/x/.test(str))
needX=1
if(/y/.test(str))
needY=1
if(/(x.y)|r=/.test(str))
 {
 needX=1
 needY=1
 }
/*if(needX&&!requestedX)// NEW OLD 6-10  'prompt, causes server error
 {
 alert("Please enter all the 'x' values into the x values field");
 requestedX=1;
 }
if(needY&&!requestedY)
 {
 alert("Please enter all the 'y' values into the y values field");
 requestedY=1;
 }*/
needX=0;//NEW old 6-10 avoid using prompt:  causes err in server
needY=0;//''
////////////////////
if((hav_x&&!Evaluate.xVal.value)||(hav_y&&!Evaluate.yVal.value))
{
did_prompt=true
x=''
y=''
////////////////////////////////
if(needX)
if(hav_x)
 {
 while(!isNaN(x))
  {
  x=prompt('Enter a VALUE for X; when DONE entering VALUES, enter a NON-NUMERIC character','')
  if(/\d+/.test(x)&&Evaluate.xVal.value)
   Evaluate.xVal.value+=','
  if(isNaN(x));
  else
   Evaluate.xVal.value+=x
  }
 needX=0
 }
//////////////////////////////////////
if(needY)
if(hav_y)
 {
 while(!isNaN(y))
  {
  y=prompt('Enter a VALUE for Y; when DONE entering VALUES, enter a NON-NUMERIC character','')
  if(/\d+/.test(y)&&Evaluate.yVal.value)
   Evaluate.yVal.value+=','
  if(isNaN(y));
  else
   Evaluate.yVal.value+=y
  }
 }
 needY=0
}
//////////////////////////////////////
//
//////////////////////////////////


////////////

//
var k=0
for(;k<sumStrings.length;k++)
 {
 //
 str=replace_summ_values(str,sumStrings[k])
 //
 //
 }
 
 
//alert(str)
 
 
return str
}
//-----------------------------------------------------------------

function replace_summ_values(expression,sumString)
{

/////////////////////////
Agg=0
xString=Evaluate.xVal.value
xArray=xString.split(',')
yString=Evaluate.yVal.value
yArray=yString.split(',')
//alert(xArray)
//alert(yArray)
/////////////////////////////////////
if(hav_x)
 Len=xArray.length
else
 Len=yArray.length
 
//alert(expression) 
 
expression=get_n_val(expression,Len)

//alert(expression)
////////////////////////////////
xLen=yLen=0
if(hav_x)
 xLen=xArray.length
if(hav_y)
 yLen=yArray.length
//////////////////////////////
if(xLen&&yLen)
 {
 if(formulaNme=='s') //str dev
  {
  if(/x/.test(expression))
   Len=xLen
  else
   Len=yLen
  expression=get_n_val(expression,Len)
  }
 else  // lin reg
  {
  if(xLen>yLen)
   Len=yLen
  if(yLen>xLen)
   Len=xLen
  }
 }
 
 //alert(expression)
/////////////////////////////
for(n=0;n<Len;n++)
 {
 reg=/\^/
 if(reg.test(sumString))
  sumString=format_sumstr(sumString)
 /////////////// 
  //alert(sumString)
  /////////////
 agg=sumString
 if(hav_x)
  while(/x/.test(agg))
   {
   whlCnt++
   if(whlCnt>10000)
    {
    whlCnt=0
    //alert("1566")
    break
    }
   agg=replace_str(agg,'x',xArray[n],strngpos(agg,'x'))
   }
///////////////////////////////////////
 if(hav_y)
  while(/y/.test(agg))
   {
    whlCnt++
   if(whlCnt>10000)
    {
    whlCnt=0
   // alert("1786")
    break
    }

/////////////
//alert(agg)
/////////////


   agg=replace_str(agg,'y',yArray[n],strngpos(agg,'y'))
   }
///////////////////
//alert(expression)
////////////   
   
 with(Math)
  {
  //alert("agg=:  "+agg)
  result=parseFloat(eval(agg))
  Agg+=result
  }
 }
/////////////////////////////////////////////////



sAgg=Agg.toString()
str_to_replace='sigma'+'('+sumString+')'
////////////////////////////////////////////
//alert(expression)

if(/sigma/.test(expression))
 expression=replace_str(expression,str_to_replace,sAgg,strngpos(expression,str_to_replace))
///////////////////////////////////////
//alert(expression)

return expression
}
//-----------------------------------------------------------------

function get_n_val(expression,Len)
{

//if(isFormula)//NEW 10-10
// return

re=/n/


if(isStat)
if(re.test(expression))
 {
 N=Len.toString()
 //alert(N)
 //alert(expression)
 while(re.test(expression))
  expression=expression.replace(re,N)
  
 //alert(expression) 
 }





return expression
}
//-----------------------------------------------------

function get_A_val(expression,Len)
{
re=/A/
if(re.test(expression))
 {
 N=Len.toString()
 while(re.test(expression))
  expression=expression.replace(re,N)
 }
return expression
}
//-----------------------------------------------------

function get_B_val(expression,Len)
{
re=/B/
if(re.test(expression))
 {
 N=Len.toString()
 while(re.test(expression))
  expression=expression.replace(re,N)
 }
return expression
}
//-----------------------------------------------------

function get_ym_val(expression,Len)
{
re=/ym/
if(re.test(expression))
 {
 N=Len.toString()
 while(re.test(expression))
  expression=expression.replace(re,N)
 }
return expression
}
//-----------------------------------------------------

function get_xm_val(expression,Len)
{
re=/xm/
if(re.test(expression))
 {
 N=Len.toString()
 while(re.test(expression))
  expression=expression.replace(re,N)
 }
return expression
}
//-----------------------------------------------------

function get_x_val(expression,Len)
{
re=/x/
if(re.test(expression))
 {
 N=Len.toString()
 while(re.test(expression))
  {
   whlCnt++
   if(whlCnt>1000)
    {
    whlCnt=0
    //alert("1688")
    break
    }

  expression=expression.replace(re,N)
  }
 }
return expression
}
//-----------------------------------------------------

function get_y_val(expression,Len)
{
re=/y/
if(re.test(expression))
 {
 N=Len.toString()
 while(re.test(expression))
  {
   whlCnt++
   if(whlCnt>1000)
    {
    whlCnt=0
   // alert("1710")
    break
    }

  expression=expression.replace(re,N)
  }
 }
return expression
}
//-----------------------------------------------------

function format_sumstr(str)
{
re=/\^/
while(re.test(str))
 {
  whlCnt++
   if(whlCnt>1000)
    {
    whlCnt=0
   // alert("1729")
    break
    }

 str=str.replace(re,',')
 }
str=getDelm(str)
Str=str.split(/\s/)
re=/,/
for(i=0;i<Str.length;i++)
 {
 if(re.test(Str[i]))
  {
  if(/[\+\-\/\*]/.test(Str[i]))
   m=1
  else
   m=0
  Str[i]=insert_str(Str[i],'pow(',m)
  m=Str[i].length
  Str[i]=insert_str(Str[i],')',m)
  }
 }
str=''
for(i=0;i<Str.length;i++)
 str+=Str[i]
return(str)
}
//----------------------------------------------------------------

function getDelm(str)//preserve operators
{
re=/[x|y\dx|y]*/
var oprArray=str.split(re)
re=/,/
for(i=0;i<oprArray.length;i++)
 {
 if(re.test(oprArray[i]));
 else
  oprArray[i]=insert_str(oprArray[i],' ',0)
 }
re=/[\*-/\+]/
var numArray=str.split(re)
re=/\^/
for(i=0;i<oprArray.length;i++)
 if(!re.test(oprArray[i]))
  numArray[i]+=oprArray[i]
str=''
i=0
while(numArray[i])
 {
  whlCnt++
   if(whlCnt>1000)
    {
    whlCnt=0
    //alert("1782")
    break
    }

 str+=numArray[i]
 i++
 }
return str
}
//---------------------------------------------------------------