Asscalc Expressions

Expressions sind reine Mathefunktionen zum berechnen verschiedenster Dinge. Es sind die absoluten Basics an Mathe, aber die meißten Funktionen wie ein Bezier oder ähnliches lassen sich auch leicht damit beschreiben. Grundsätzlich beachtet Calc keine Punkt vor Strich Rechnung, sondern berechnet alles schön der Reihe nach. Um dies zu kontrollieren sollte man viel auf die () und Notepad C++ zurück greifen mit der Scriptvieweinstellung für Lua. Alle Mathefunktionen können in Variablen abgelegt werden oder direkt in anderen Expressions oder Commands wieder benutzt und verschachtelt werden. (Achtung Commands können nicht ineinander verschachtelt werden, dies gilt nur für Expressions!).

Addieren

      |       expr '+' expr { $$.value = $1.value + $3.value }

Addition von zwei Variablen oder Zahlen.

Beispiel:

test1=test2+4

Subtrahieren

      |       expr '-' expr   { $$.value = $1.value - $3.value }

Subtraktion von zwei Variablen oder Zahlen.

Beispiel:

test1=test2-4

Multiplizieren

      |       expr '*' expr   { $$.value = $1.value * $3.value }

Multiplikation von zwei Variablen oder Zahlen.

Beispiel:

test1=test2*4

Dividieren

      |       expr '/' expr   { $$.value = $1.value / $3.value }

Division von zwei Variablen oder Zahlen.

Beispiel:

test1=test2/4

Potenzieren

      |       expr '^' expr   { $$.value = pow($1.value, $3.value) }

Potenzieren mit zwei Variablen oder Zahlen. Um eine Wurzel 2. Grades zu ziehen schreibt man es als Potenz X^1/2 ; für die dritte Wurzel X^1/3 usw.

Beispiel:

test1=test2^4

Benutzung von Klammern

      |       '(' expr ')'    { $$.value = $2.value }

Einklammern von Rechnungen. Wird benötigt, da ASSCalc kein Punkt vor Strich Rechnung kennt sondern von links nach rechts rechnet!

Beispiel:

test1=test2-(test3*5)

Sinus

      |       SIN '(' expr ')'    { $$.value = sin($3.value); }

Gibt den Sinus einer Variablen oder Zahl zurück.

Beispiel:

test1=SIN(Winkel)

COSinus

      |       COS '(' expr ')'    { $$.value = cos($3.value); }

Gibt den Cosinus einer Variablen oder Zahl zurück.

Beispiel:

test1=COS(Winkel)

Intround

      |       INTROUND '(' expr ',' expr ')'    { $$.value = (double)(((int)($3.value+0.5)) % ((int)($5.value+0.5))); }

WICHTIG: Die zweite variable/expression darf niemals kleiner als 0.5 werden, sonst stürzt ASSCalc ab!! MAX(var,0.5) sollte hier also zwingend eingesetzt werden!!

weitere erklärung folgt, bekomme es durch testen nicht raus, werde beim hersteller nachfragen ^^

Trunc

      |       TRUNC '(' expr ')'    { $$.value = floor($3.value); }

Rundet eine Variable oder Zahl IMMER AB. Man kann mit dieser Funktion auch Fließkommastellen realisieren, welche Calc bei der Standardausgabe TVAL OF einfach abschneidet (so wie TRUNC ^^). Bei Berechnungen werden diese aber weiterhin berücksichtig, weswegen eine TRUNC Funktion manchmal sehr sinnvoll sein kann, wenn man im Berechnungsprozess eine Ganzzahl braucht. Hierfür solltet ihr euch mit dem Rundungssystem von ASSCalc auskennen => TVAL OF und POS OF in Commands anschauen!

Beispiel:

test1=TRUNC(33.44) => 33

test1=TRUNC(1.9999) => 1

Beispiel für Kommaausgabe mit POS OF:

test=1.123456

=> Setzt die Variable

ganzzahl=TRUNC(test)

=> Schneidet die Kommastellen ab => 1

rest=test-ganzzahl

=> speichert die Kommastellen ab => 0.123456

kommastellen=10000

=> Gibt bei der POS OF Lösung die Anzahl der Kommastellen an

pos of ganzzahl

=> Gibt die Ganzzahl aus => 1

"."

=> Gibt den Punkt aus => .

pos of rest*kommastellen

=> Gibt die Kommastellen aus, die Anzahl definiert sich durch die Variable kommmastellen (10er,100er,1000er Stelle usw.)

=> POS OF gibt die Zahl aus ohne ab oder aufzurunden!!!

=> 1.12345

Beispiel für Kommaausgabe mit TVAL OF:

test=1.123456

=> Setzt die Variable

ganzzahl=TRUNC(test)

=> Schneidet die Kommastellen ab => 1

rest=test-ganzzahl

=> speichert die Kommastellen ab => 0.123456

pos of ganzzahl

=> Gibt die Ganzzahl aus => 1

"."

=> Gibt den Punkt aus => .

rest

=> Gibt die Kommastellen aus. Als Standard wird hierbei die 1000er Variante genutzt, sprich 3 Kommastellen.

=> Will man mehr oder weniger Stellen ausgeben, muss man die Zahl durch 10/100/1000 etc. multiplizieren oder dividieren

=> TVAL OF gibt die Zahl aus und rundet auf oder ab, je nachdem ob die nachfolgende Zahl >= 5 oder <= 5 ist!!!

=> 1.123

rest*10

=> 1.1235

tval of rest*100

=> 1.12346

rest*1000

=> 1.123456

Sign

      |       SIGN '(' expr ')'    { $$.value = $3.value/(abs($3.value)+0.0001); }

Gibt das Vorzeichen einer Variable zurück: 1,0,-1

Bei dieser Expression gibt es ein paar Besonderheiten. Grundlegen sollte hier TRUNC() verwendet werden, auch wenn dies keine Rundung bietet, da alle Zahlen unter 1 oder kleiner als -1 gegenläufig sind. Das heißt SIGN gibt bei 0.12 statt 0 oder 1000 mal 1200000 zurück! Kommazahlen sind eh ein Thema für sich bei dieser Funktion. Betrachtet man die Ausgabe von 18.456, würde man 1456 heraus bekommen im Output. Über POS OF ausgegeben, würde dies natürlich 1 ergeben (oder -1 je nach Vorzeichen). Da man aber sehr warscheinlich weiter mit dem Vorzeichen arbeiten will und dies zum multiplizieren verwendet, würde man die Zahl mit den Kommastellen multiplizieren, was teilweise gewollt sein kann, größtenteils aber nicht.

Man muss sich also überlegen, ob man vor der Funktion TRUNC() benutzt oder danach. Macht bei manchen Berechnungen viel aus. Auch das

Beispiel:

SIGN(-120) -> -999

Info: hier sieht man, das eine vorher mit TRUNC() versehen Funktion keinen Sinn ergibt, genau so wie danach, weil es 0 ergeben würde. Der Trick ist einfach immer eine Kommazahl wie unten die -18.2429 zu benutzen, da diese einen Rest bietet und so die Zahl mindestens -1 groß sein wird beim Output. Danach kann man auf diese wieder TRUNC() anwenden.

SIGN(0) -> 0

SIGN(120) -> 1000

SIGN(0.5429) -> 5429000

SIGN(-18.2429) -> -1012

Min

      |       MIN '(' expr ',' expr ')'    { if( $3.value<$5.value )$$.value = $3.value; else $$.value = $5.value; }

Macht eine Grenzenabfrage, welche eine Variable überprüft und wenn diese einen Wert überschreitet, wird der Wert auf die zweite Variable gesetzt, sprich die Variable ist immer MAXIMAL so groß wie der angegebene Wert.

Max

      |       MAX '(' expr ',' expr ')'    { if( $3.value>$5.value )$$.value = $3.value; else $$.value = $5.value; }

Macht eine Grenzenabfrage, welche eine Variable Überprüft und wenn diese einen Wert unterschreitet, wird der Wert auf die zweite Angabe gesetzt, sprich die Variable ist immer MINIMAL so groß wie der angegebene Wert.

Beispiel:

Alphalevel 0 und 255 im wechsel:

in p1loop:

hex of MAX(onoff,0)

onoff=onoff*(-1)

in p1h:

onoff=255

Switch

      |       SWITCH '(' expr ',' expr ',' expr ')'    { if( $3.value<0.5 )$$.value = $5.value; else $$.value = $7.value; }

Zu allererst, es benötigt 'immer eine zusätzlich Leerzeile unter der Funktion. Gilt allgemein bei Expression- und Command-Fehlern.

Wenn die erste Variable < 0.5 ist, dann ist der zurückgegebene Wert die zweite Variable, ansonsten die dritte Variable.

Beispiel:

wab=wab+1 wab=SWITCH(wab/7,wab,0)

Info: setzt die Variable wab beim erreichen des Wertes 4 auf 0 zurück, da 4/7 = 0,571

Pixbuff

      |       PIXBUF '(' expr ',' expr ')'    { $$.value = get_pixbuf( $3.value, $5.value ); }

Überprüft an einer Position X,Y ob ein von ASSCalc gerenderter Silbenpixel schwarz oder weiß ist und gibt einen bolschen Wert zurück, welcher in LOWKILL als Pixelidentifiere genutzt werden kann.

Nochmal zur Info: loopvar und loopvar2 sind feste AssCalc Variablen, welche automatisch Pro Loop erhöht werden. Reset auf 0 pro P-Layer-Durchlauf

Beispiel:

LOWKILL( pixbuf(loopvar,loopvar2), 0.5 ) => entscheidet ob Code ausgeführt wird für einen Pixel oder nicht. Somit kann man einen Buchstaben leicht als Pixel nachbilden.

Hier noch ein Beitrag von OJ:

UPDATE:

hpsx=TRUNC(curx-nsizthisone*0.5)

Position X Seite Links => anfang Silbe X

hpsy=TRUNC(cury-nysizthisone*0.5)

Position Y Oben => Anfang Silbe Y

hpex=TRUNC(hpsx+2+nsizthisone)

Position X Seite Rechts => Ende Silbe X

hpey=TRUNC(hpsy+2+nysizthisone)

Position Y Unten => Ende Silbe

loopfile2 "p1 in.txt" ((hpex-hpsx),(hpey-hpsy))

=> loopfile2((Ende X - Anfang X),(Ende Y - Anfang Y))

=> Matrix aus (Silbenbreite,Silbenhöhe)

=> Erster X Achsendurchlauf 0 => loopvar gibt diesen Wert zurück und Zählt automatisch +1 wenn Y Reihe bei erreichen von Ende Y auf 0 resetet wird

=> Erster Y Achsendurchlauf Yposloop 0 -> Ende Y => loopvar2 gibt diesen Wert zurück und Zählt automatisch +1 pro Loopdurchlauf

und resetet sich automatisch bei erreichen von Ende Y

Jeder Pixel des Rechtecks, welches um die Silbe gezogen wurde wird nun auf seinen TRUE Wert überprüft, dh. asscalc generiert den Buchstaben konstant neu und überprüf ob er gefüllt ist oder nicht.

Die wird per Pixbuff überprüft:

pixbuf(loopvar,loopvar2)

=> Aktuelle Position in Achse X und Aktuelle Position in Achse Y ergibt den Standort im Rechteck

=> Ergibt dieser den Wert TRUE, wird von asscalc die Zahl 1 zurück gegeben

=> Bei FALSE wird der Wert 0 zurück gegeben

=> Dies wird mit dem Lowkill überprüft LOWKILL( pixbuf(loopvar,loopvar2), 0.5 )

=> LOWKILL( 1 >= 0.5 ) ergibt "NO", wird also ausgeführt, dh. ein Pixel wird generiert

=> LOWKILL( 0 >= 0.5 ) ergibt "YES", wird also NICHT ausgeführt, dh. kein Pixel wird generiert

In der Datei selbst muss noch die aktuelle Position gebildet werden

=> thisx=hpsx+loopvar+1 die +1 ist eine Korrektur da X nie passgenau sitzt

=> thisy=hpsy+loopvar2+18 die +18 ist eine Korrektur da Y nie passgenau sitzt

UMinus

      |       '-' expr  %prec UMINUS { $$.value = -$2.value }

Setzt eine Variable auf Minus.

Beispiel:

var=(-var)

var=var*(-1)

var=-1

Variablen Erzeugen/Ausgeben

      |       IDENTIFIER { $$.value = get_identifier( $1 ); }

Variable ausgeben in Calc.

Beispiel:

var

Array Erzeugen/Ausgeben

      |       IDENTIFIER '[' expr ']' { $$.value = get_identifier_arr( $1, $3.value ); }

Array ausgeben in Calc.

Beispiel:

array[bla]

array[1]

Findindex

      |       FINDINDEX '(' IDENTIFIER ',' expr ')' { $$.value = find_index_arr( $3, $5.value ); }

Gibt die Position des ersten Werts im Array, der größer ist als der Wert der angegeben wurde. Auch hier gibt es wieder eine Besonderheit, und zwar wird die Arrayposition um minus 1 zurück gegeben. Somit ist die Funktion an zwei Bedingungen geknüpft. Die aktuelle Array Position, welche zurück gegeben wird muss kleiner sein als der Angegebene Wert, die nachfolgende Position muss aber größer sein als der angegebene Wert, sonst wird die nächste Position überprüft. Eine Anwendung wäre eine Liste mit Timings, welche über tstart / tend abgefragt wird, um heraus zu finden, welches Timing in den Bereich der aktuellen Silbe fällt oder umgekehrt.

In dieser Funktion muss der Arrayname ohne [ ] angegeben werden. Sprich arrayname[x] ergibt in der Expression arrayname.

FINDINDEX ( arrayname_ohne_[] , Wert_mit_dem_geprüft_wird )

Beispiel:

arrayt[0] = 22

arrayt[1] = 33

arrayt[2] = 44

arrayt[3] = 55

check=45

FINDINDEX ( arrayt , check )

out.ass: 2000

=> Position 2 wird zurück gegeben.

Texfindbool

      |       TEXTFINDBOOL IDENTIFIER { $$.value = textfind_identifier( $2.name ); }

Sucht in einer Line nach einem TEXT und gibt TRUE / 1 zurück, wenn er in dieser vorkommt. So können TEXTFIND Events z.B. als Trigger im loopfile genutzt werden (loopfile "bla.txt" 1*textcheck) oder in einem LOWKILL(), da 0 oder 1 zurüc gegeben wird. Siehe auch Asscalc Commands zu diesem Thema.

Beispiel:

textfindbool Hallo

Zahl Ausgeben

      |       NUMBER

Zahl ausgeben in Calc.

Beispiel:

1 234 0.3