Was ist hecalc ?
---------------

Acalc ist ein Taschenrechner, welcher auch mit ausgeschriebenen Zahlen
rechnen kann.


Installation
------------

Tippen Sie 
> make 

Um den Taschenrechner zu compilieren.


Tippen Sie 
> make tests

Mit diesem Befehl knnen Sie den Taschenrechner testen.
In der Datei "testin" stehen die Testaufgaben fr den Rechner.

Der Rechner generiert die Datei "testerg", diese sollte mit der 
Datei "testout" bereinstimmen.

In diesem Beispiel wurde das Ergebnis manuell eingetragen.


> make install

hecalc wird nach /usr/local/bin  installiert.



Start
-----

> hecalc 

Beachten Sie das in $PATH auch /usr/local/bin eingetragen ist. 

Dann knnen Sie Ihre Formel eingeben.

Untersttzt werden alle Ziffern [0-9] die Operatoren "+", "-", "*" und "/".
Selbstverstndlich wird Punkt- vor Strich beachtet.
Klammern "(" und ")" knnen gesetzt werden.

Ausgeschriebene Zahlen muessen ohne Umlaute eingegeben werden.
Also dreissig, fuenfzig und zwoelf.
Bei den ausgeschriebenen Operatoren werden 
"mal", "mul", "add", "plus", "div", "durch", "minus" und "sub" untersttzt.


Programmende ist mit: "^C".
Die Eingabe von ";" oder "q" bei der Berechnungsformel beendet das Programm.



Zahlen die vom Taschenrechner "verstanden" werden:
--------------------------------------------------


Zahlen:
eins, zwei, drei, vier, fuenf, sechs, sieben, acht, neun


Zehner:
zehn, elf, zwoelf
zwanzig, dreissig, vierzig, fuenfzig, sechzig, siebzig, achtzig, neunzig


Alle Kombinationen mit "und":
vierundzwanzig, zweiunddreissig ...

Kombinationen mit "hundert":
vierhundert, dreihundert ...

Kombinationen mit "zehn":
dreizehn, vierzehn ...

Kombinationen mit "millionen":
dreimillion, siebenmillionen, bis neunmillionen ...

Kombinationen mit "tausend":
eintausend, zweitausend, neuntausend ...


und natrlich alle Kombinationen miteinander "Kombiniert" ...

Das System zhlt einfach nach oben:


Potenz	Name
1e0	eins
1e1	zehn
1e2	hundert
1e3	tausend
1e6	millionen 
1e9	1000 millionen | milliarden
1e12	billion 
1e15	1000 billion 
1e18 	trillion
1e21	1000 ...
1e24 	quadrillion
1e +3	1000 ...
1e30 	quintillion
1e +3	1000 ...
1e36 	sextillion

1e42 	septillion

1e48 	octillion

1e54 	nonillion

1e60 	decillion

1e66 	undecillion

1e72 	duodecillion

1e78 	tredecillion

1e84 	quattuordecillion

1e90 	quindecillion

1e96 	sexdecillion

1e102	septendecillion

1e108	octodecillion

1e114 	novemdecillion	

1e120 	vigintillion

1e600 	centillion


Beispielrechnungen:
-------------------

user@erde:~>hecalc
Bitte geben Sie die Berechnungsformel ein:
>dreihundertzweiundneunzig mal 7 <Enter>
Ergebnis: 2744.000000


Beim Tippen der Eingabe knnen alle Ziffern mit Kommastelle als 
"." sowie ausgeschriebene deutsche Ziffern eingegeben werden.

>2.7 * 3<Enter>
Ergebnis: 8.100000

Oder 
>2.7 mal drei<Enter>

Die Eingabe des Vorzeichens erfolgt mit "-". Bsp:
>-27 durch -neun<Enter>
Ergebnis: 3.000000

Soll die Addition "vor" der Multiplikation erfolgen dann ist zu Klammern:

>3+2*6<Enter>
Ergebnis: 15.000000

>(3+2)*6<Enter>
Ergebnis: 30.000000


Pipe:

Zur Verarbeitung von vielen Daten in Shellscripten kann der Rechner in einen "nicht Interaktiven" Modus geschaltet werden. Die Kommandozeilenoption ist -b.

user@erde:~> echo "einhundert mal 2" | hecalc -b<Enter>
200.000000

oder 
hecalc -b < input > output

Wobei in "input" jede Zeile eine Formel sein kann, somit steht dann in "output" auf jeder Zeile das entsprechende Ergebnis.



Was geht nicht?
---------------

Ausgeschriebene Zahlen mit Komma.
Ausgeschriebene Zahlen mit ausgeschriebenen Vorzeichen. 
(das Vorzeichen ist mit "-" anzugeben.)


Was sollte Zuknftig noch funktionieren?
----------------------------------------

vieleicht noch bessere Testroutinen, oder eine Oberflche mit Tk, um die Zahlen auch per Mausklick eingeben zu knnen.




Die definierten Konstanten
--------------------------
e		2.7182818284590452353602874713526625L  /* e */
log2e		1.4426950408889634073599246810018921L  /* log_2 e */
log10e		0.4342944819032518276511289189166051L  /* log_10 e */
ln2		0.6931471805599453094172321214581766L  /* log_e 2 */
ln10		2.3025850929940456840179914546843642L  /* log_e 10 */
pi		3.1415926535897932384626433832795029L  /* pi */
pi_2		1.5707963267948966192313216916397514L  /* pi/2 */
pi_4		0.7853981633974483096156608458198757L  /* pi/4 */
1_pi		0.3183098861837906715377675267450287L  /* 1/pi */
2_pi		0.6366197723675813430755350534900574L  /* 2/pi */
2_sqrtpi	1.1283791670955125738961589031215452L  /* 2/sqrt(pi) */
sqrt2		1.4142135623730950488016887242096981L  /* sqrt(2) */
sqrt1_2		0.7071067811865475244008443621048490L  /* 1/sqrt(2) */


Die definierten Funktionen
--------------------------

Winkelfunktionen:

acos(x)		/* Arc cosine of X.  */
asin(x)		/* Arc sine of X.  */
atan(x)    	/* Arc tangent of X.  */
cos(x)     	/* Cosine of X.  */
sin(x)     	/* Sine of X.  */
tan(x)		/* Tangent of X.  */
acosh(x) 	/* Hyperbolic arc cosine of X.  */
asinh(x) 	/* Hyperbolic arc sine of X.  */ 
atanh(x)	/* Hyperbolic arc tangent of X.  */
cosh(x)		/* Hyperbolic cosine of X.  */
sinh(x)		/* Hyperbolic sine of X.  */
tanh(x)		/* Hyperbolic tangent of X.  */


Expotentialfunktionen und Logarithmen:

exp(x)		/* Exponential function of X.  */
frexp(x) 	/* Break VALUE into a normalized fraction and 
		an integral power of 2.  */
  		Der exp ist im Speicher frexpmem
		
ldexp(x,y) 	/* X times (two to the EXP power).  */

log(x) 		/* Natural logarithm of X.  */
log10(x) 	/* Base-ten logarithm of X.  */

expm1(x) 	/* Return exp(X) - 1.  */
log1p(x) 	/* Return log(1 + X).  */

logb(x) 	/* Return the base 2 signed integral exponent of X.  */

exp2(x) 	/* Compute base-2 exponential of X.  */ 
log2(x) 	/* Compute base-2 logarithm of X.  */

Quadrate:

pow(x)		/* Return X to the last return */
sqrt(x) 	/* Return the square root of X.  */
hypot(x,y)   	/* Return `sqrt(X*X + Y*Y)'.  Y is last return */ 
cbrt(x)    	/* Return the cube root of X.  */


Rundungen und Betrge:

ceil(x)		/* Smallest integral value not less than X.  */
fabs(x)		/* Absolute value of X.  */
floor(x)	/* Largest integer not greater than X.  */
fmod(x)		/* Floating-point modulo remainder of X/Y.  */
nbi(x)		/* Round X to integral valuein floating-point 
		format using current rounding direction, but 
		do not raise inexact exception.  */
   
round(x)	/* Round X to nearest integral value, rounding 
		halfway cases away from zero.  */
trunc(x)/	* Round X to the integral value in floating-point
		format nearest but not larger in magnitude.  */

remquo(x,y)   
/* Compute remainder of X and Y and put in *QUO a value with sign of x/y
 *    and magnitude congruent `mod 2^n' to the magnitude of the integral
 *       quotient x/y, with n >= 3.  */


lrint(x)	/* Round X to nearest integral value according to 
		current rounding direction.  */
lround(x) 	/* Round X to nearest integral value, rounding 
		halfway cases away from zero.  */
copysign(x,y)	/* Return X with its signed changed to Y's.  */

 
erf(x)		/* Error and gamma functions.  */
erfc(x)
tgamma(x)
lgamma(x)


rint(x)	/* Return the integer nearest X in the direction of the
   prevailing rounding mode.  */

nextafter(x,y)
      /* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
nexttoward(x,y)
 

remainder(x,y)  /* Return the remainder of integer divison X / Y with
			infinite precision.  */

scalb(x,y)  	/* Return X times (2 to the Nth power).  */
scalbn(x,y) 	/* Return X times (2 to the Nth power).  */
scalbln(x,y) 	/* Return X times (2 to the Nth power).  */

ilogb(x)  	/* Return the binary exponent of X, which must be nonzero.  */
fdim(x,y)	/* Return positive difference between X and Y.  */
fmax(x,y)	/* Return maximum numeric value from X and Y.  */
fmin(x,y)	/* Return minimum numeric value from X and Y.  */

fma(x,y,z) 	/* Multiply-add function computed as a ternary operation.  */

Absolute value, conjugates, and projection. 
carg(x) 	/* Argument value of Z.  */
conj(x) 	/* Complex conjugate of Z.  */

// Absturz
// cproj(x) /* Projection of Z onto the Riemann sphere.  */*/

/* Decomposing complex values.  */
cimag(x) 	/* Imaginary part of Z.  */
creal(x) 	/* Real part of Z.  */


Funktionen mit Parametern
-------------------------

pow:
----
Bitte geben Sie die Berechnungsformel ein:
>pow(7,3)
Ergebnis: 343.000000

Bitte geben Sie die Berechnungsformel ein:
>pow(2,2)
Ergebnis: 4.000000

hypot:
------

Bitte geben Sie die Berechnungsformel ein:
>hypot(3,4)
Ergebnis: 5.000000



Arbeiten mit dem Speicher
-------------------------
>mem=2.56789
>mem
Ergebnis: 2.567890


>mem=27
>mem*2
Ergebnis: 54.000000




frexp:
------

>frexp (27.32)
Ergebnis: 0.853750

Ganzzahliger Anteil in mem:
>mem
Ergebnis: 5.000000


fma:
----

> fma ( 2.0, 2.0, 2.0 )
Ergebnis: 6.000000


remquo:
-------
remquo  ( 2.0, 0.23 )
Ergebnis: -0.070000

>mem
Ergebnis: 1.000000



Weitere Hilfe:
--------------

Zu fast allen Funktionen gibt es eine Manual-Page:
z.B.

Verwenden Sie xman oder geben Sie ein

man funktion 

also 

man asin


gibt Information zu Arc-Sinus.





Viel Spass ....





















