Copyright: Salieri(c)-Hilfe Version 1.1


Inhaltsverzeichnis
_____________________________________________________________________________

_____________________________________________________________________________

       Grundsätzliches                       Datentypen und Funktionen

        	Was ist SALIERI ? 	            	Objekte

         	Installation	           	Objekttypen

         	Kommandozeileneingabe        	Musikalische Objekttypen

        	Dateien und Programme         	Funktionen und Kommandos

       	Workspace                          	Index der Funktionen

       	Info

 	An english version of this helpfile will be soon available.

Please have a look at http://www.informatik.th-darmstadt.de/AFS/CM/SAL


Salieri-Einführung
Was ist SALIERI ?

Das SALIERI-System ist ein experimentelles System zur strukturorientierten Erzeugung und Bearbeitung von Musik. Die SALIERI-Sprache ist eine universelle, im wesentlichen funktionale Sprache, die insbesondere die strukturorientierte Darstellung ein- und mehrstimmigen musikalischen Materials unterstützt. Zur Darstellung von musikalischen Objekten wird ein einfaches, wahrnehmungsbezogenes Tonmodell verwendet, das wesentliche Teile der konventionellen Musiknotation in einer symbolischen Schreibweise umfaßt.

Die Sprache verfügt neben den Typen für musikalische Objekte über Basistypen für Wahrheitswerte, Zahlen und Zeichenketten. Zur Realisierung komplexerer Datenstrukturen können Listen über Objekten beliebiger, auch verschiedener Typen gebildet werden. SALIERI verfügt über ca. 100 vordefinierte Funktionen; diese realisieren Operationen auf den verschiedenen Datentypen, Kontrollstrukturen und Systemkommandos. Das SALIERI-System entstand in erster Linie in der Absicht, grundlegende Prinzipien und Aspekte der strukturorientierten Darstellung und Bearbeitung von Musik in Form eines interaktiven Systems zu realisieren.


  Installation

SALIERI läßt sich auf einem IBM-kompatiblen PC unter Windows 3.1x installieren.  Folgende Mindestanforderungen sind empfehlenswert:  386 Prozessor,  4 MB Arbeitsspeicher (RAM),  10 MB freier Plattenspeicher, Betriebssystem MS-DOS, Version  5.0

Für den Aufruf musikalischer Objekte sollten folgende Systemanforderungen erfüllt sein: MIDI-fähige Soundkarte, MS Windows Version 3.1

Musikalische Objekte werden im MIDI-Dateiformat ausgegeben und lassen sich auch in SALIERI weiterverarbeiten. Andere Programme welche das MIDI-Format verwerten können, sind für einige Anwendungen in speziellen Fällen erforderlich.

Durch den Aufruf der Datei SALIERI.EXE wird das System gestartet. Zum Verlassen von SALIERI ist "exit( )" einzugeben.


HERZLICHEN GLÜCKWUNSCH

Du hast die SALIERI Rätselseite getroffen. Wenn Du folgende Frage innerhalb von 15 Minuten beantwortet hast, dann bist Du ein Genie:

Ein Mann wohnt im 15.Stock eines Hochhauses. Natürlich benutzt er den Fahrstuhl um sich unnötige Anstrengung zu ersparen. Er hat allerdings ein kleines Problem wenn er vom Erdgeschoss zu seiner Wohnung will. Wenn die Sonne scheint fährt er nur bis zum 12.Stock und geht den Rest zu Fuß. Regnet es allerdings, kommt er mit dem Fahrstuhl im 15.Stock an. Warum ?


Objekte erzeugen
  Objekte

Alle Objekte haben einen Namen, einen Typ und einen Wert. Die Objektnamen beginnen mit einem Buchstaben oder einem Unterstrich ("_"), gefolgt von beliebig vielen Buchstaben, Ziffern, Punkten (".") oder Unterstrichen. Umlaute wie sind nicht zulässig. Groß und Kleinbuchstaben werden als verschieden angesehen. Die Namen werden in lexikographischer Reihenfolge im Workspace abgelegt.

Beispiel:

Robinson_Crusoe, _Don.Quichote, zweiplus1, Rocky.34.7 und Tic.Tac_Toe sind gültige Objektnamen. Falsch wären: 1.Gymnopädie, .Erik_Satie oder 3mal5

Objekte deren Namen mit einem Unterstrich beginnen, sind sogenannte Systemobjekte und sollten nur von erfahrenen Benutzern angewandt werden, da diese in der Regel durch Ausgabekommandos nicht angezeigt werden.

Ein Objekt wird durch eine Wertzuweisung erzeugt, wobei der Typ sich aus der Zuweisung ableiten läßt. Die SYNTAX der Wertzuweisung sieht dabei so aus:

name:= expression

Dabei ist name ein gültiger Objektname und expression ein beliebiger Ausdruck. Ein Ausdruck kann eine Konstante, ein Objektname oder ein aus Ausdrücken zusammengesetzter Ausdruck sein. Letzterer entsteht aus der Anwendung von Funktionen bzw. Präfixoperatoren oder der Verknüpfung mit Infixoperatoren. Außerdem können Ausdrücke geklammert werden.

Ist c eine Konstante, x ein beliebiger Objektname, f Name einer n-stelligen Funktion, p ein Präfixoperator, i ein Infixoperator und sind expression1, ...., expression n gültige Ausdrücke, so sind genau die folgenden Ausdrücke ebenfalls gültig. SYNTAX von Ausdrücken:

c

x

f (expression 1, . . . , expression n)

p expression

epression1 i expression2

(expression)

Falls einem bereits vorhandenen Objekt ein Wert zugewiesen wird, so wird der alte Wert durch den neuen ersetzt und der Typ entsprechend angepaßt.


 Objekttypen

Wahrheitswerte

Integer

Reals

Reihen (Zeichenketten, Listen und Sequenzen)

Zeichenketten

Listen


Wahrheitswerte (bool)
Wahrheitswerte

Wahrheitswerte werden durch den Objekttypen bool realisiert. Die Konstanten TRUE und FALSE stehen ebenso zur Verfügung, wie die die logischen Operationen "not", "and", "or". Es gilt: "not" bindet stärker als "and", dieses stärker als "or".

   Boolsche Operationen

Beispiel:

>Arbeit:=FALSE

>Einsame_Insel:=TRUE

>Arbeit and Einsame_Insel

Result= FALSE

>Arbeit or Einsame_Insel

Result= TRUE

>not Arbeit and Einsame_Insel

Result= TRUE

>


Integer, Objekttypen, Typen
Integer

Der Typ int stellt ganze Zahlen im Bereich -32768 und 32767 dar. Konstanten werden als Zahlen mit Vorzeichen geschrieben, wobei "+" weggelassen werden kann (+345=345). Die üblichen arithmetischen Operationen wie Addition, Subtraktion, Multiplikation, gerundete Division, Divisionsrest sind genauso definiert, wie Funktionen zur Betragsbildung und Zufallszahlenerzeugung.

  Integeroperationen

 Beispiel:

>7 div 3	(* gerundete Division *)

Result= 2

>7 mod 3	(* Divisionsrest *)

Result= 1

>abs(-42)

Result= 42

>rndUniform (1,6) 	(*Wuerfel*)

Result= 6

>


Gleitkommazahlen (Reals)
Reals

Für Gleitpunktzahlen steht der Objekttyp real zur Verfügung. Konstanten werden mit Dezimalpunkt und Vorzeichen geschrieben (+12.3=12.3). Neben den Operationen zur Addition, Subtraktion, Multiplikation und Division sind desweiteren noch Funktionen zur Betragsbildung und gleichverteilten Zufallszahlenerzeugung realisiert. Gleitpunktzahlen können außerdem durch Auf- oder Abrunden in Ganzzahlen  umgewandelt werden. Umgekehrt kann eine ganze Zahl int, in eine Gleitpunktzahl durch Multiplikation mit 1.0 konvertiert werden. Eine automatische Konvertierung findet dann statt, wenn Ausdrücke wie 5/2 vorkommen. Diese werden in die entsprechende Gleitpunktzahl umgesetzt.

SALIERI gibt Gleitpunktzahlen immer mit 8 Nachkommastellen aus (wobei die letzte Stelle gerundet wird), intern wird jedoch im allgemeinen mit weiteren Stellen gerechnet. Überschreitungen des Zahlbereichs führen in der Regel zum Absturz des Systems. Bei betragsmäßig großen Zahlen, können Ungenauigkeiten in den hinteren Stellen auftreten.

  Realoperationen

Beispiel:

>rnd()

Result= 0.64876247

>abs(12.345)

Result= 12.34500000

>


Reihenförmige Objekte
Reihen

Reihen werden durch den Objekttyp series repräsentiert. Es stehen die Operationen Konkatenation, Extrahieren, Einfügen und Löschen von Teilketten zur Verfügung. Eine Reihe kann eine Zeichenkette, eine Sequenz oder eine Liste sein.

  Reihenoperationen

Beispiel (Konkatenation von reihenförmigen Objekten):

>Parmenides:="Im Unterschied zu Parmenides war fuer"

>Beethoven:=" Beethoven die Schwere offenbar etwas Positives"

>write(Parmenides+Beethoven)

Im Unterschied zu Parmenides war fuer Beethoven die Schwere offenbar etwas Positives

>Entschluss:=LIST("Der schwer gefasste Entschluss ist verbunden")

>Schicksal:=LIST(" mit der Stimme des Schicksals (Es muss sein)")

>write(Entschluss+Schicksal)

LIST("Der schwer gefasste Entschluss ist verbunden"," mit der Stimme des Schicksals (Es muss sein)")

>Es_muss_sein1:=[a/4 c2/2 g2/2]

>Es_muss_sein2:=[_/2 _/4 g/4 h&/2 f/2]  (* L.v.Beethoven op.131, 7.Satz *)

>write(Es_muss_sein1 + Es_muss_sein2)

[ I=80 M=100 T=0 a1/4 c2/2 g2/2 _/2 _/4 g1/4 a#1/2 f1/2 ]

>


Objekttyp Zeichenketten
Zeichenketten

Zeichenketten werden durch den Typ string repräsentiert. Die Konstanten des Objekttyps werden in der Form ". . ." notiert, wobei zwischen den Anführungszeichen eine beliebige Zeichenkette stehen darf. Ansonsten sind genau die Operationen auf Zeichenketten definiert, die den Reihen zur Verfügung stehen.

  Reihenoperationen

Beispiel:

>Hamlet:="Was ist der Mensch, wenn seiner Zeit Gewinn, sein hoechstes Gut nur Schlaf und Essen ist ? Ein Vieh, nichts weiter."

>posNext(Hamlet, "Mensch", 1)

Result= 13

>Gewicht:="Ist das Schwere schrecklich und das Leichte herrlich ?"

>write(ins(Gewicht, "wirklich ", 17))

Ist das Schwere wirklich schrecklich und das Leichte herrlich ?


Objekttyp Listen
Listen

Listen werden durch Ausdrücke der Form LIST (obj1, . . . ,objn) erzeugt, wobei obj1 etc. beliebige Objekte sein können, z.B. auch ein Ausdruck der ein Objekt beschreibt. Für Listen sind neben den Reihenoperationen noch fünf weitere Basisoperationen definiert. Die Vergleichsoperatoren "=" und "!=" sind auf Listen anwendar, dabei sind zwei Listen genau dann gleich, wenn sie die gleiche Länge haben und alle Elemente gleich sind. LIST (1,2,3), LIST ([c/4 e g], 0.25) sind gültige Listen. Natürlich ist LIST ( ) eine gültige Liste (die leere Liste). Bei Listenkonstanten kann, bis auf den Fall der einelementigen Liste, der Konstruktor LIST weggelassen werden, also reicht die Notation (obj1, . . . ,objn). Die leere Liste wird dann mit ( ) beschrieben. Der einelementige Fall wird von SALIERI als geklammerter Ausdruck interpretiert.

  Listenfunktionen

Beispiel:

>LIST("Im Anfang war das Wort","und das Wort war bei Gott")

Result= LIST("Im Anfang war das Wort","und das Wort war bei Gott")

>("und Gott war das Wort")        	(* Einelementige Kurznotation *)

Result= "und Gott war das Wort"	(* wird als Ausdruck interpretiert *)

>("Dasselbe","war im Anfang bei Gott")	(* Kurznotation Zweielemt. *)

Result= LIST("Dasselbe","war im Anfang bei Gott")

>( )	(* Leere Liste Kurznotation *)

Result= LIST( )

>LIST( )

Result= LIST( )

>


  Workspace

Alle Objekte von SALIERI sind, nach ihren Namen in lexikographischer Reihenfolge geordnet im Workspace gespeichert. Mit dem Kommando save("filename") kann der aktuelle Workspace unter filename.WSP gespeichert werden. Zum Laden eines gesicherten Workspace ist das Systemkommando load("filename") verfügbar, wobei der aktuelle Workspace durch den Hinzugeladenen ergänzt wird. Existieren im aktuellen Workspace, sowie in der Kopie Objekte mit gleichen Namen, so überschreibt das geladene Objekt das Aktuelle.

Beispiel:

>a:=3

>save("work")

Saving workspace to work.wsp ... Done

>a:=9

>load("work")

Loading workspace from work.wsp ... Done

>a

Result= 3

>

Normalerweise ist der Workspace persistent, wird also bei Beendigung einer Sitzung gespeichert (in der Datei SALIERI.WSP). Beim nächsten Aufruf von SALIERI wird diese Workspace-Kopie wieder geladen, der alte Worspace bleibt also erhalten. Dazu ist es jedoch erforderlich SALIERI mit exit( ) zu verlassen oder während einer Sitzung den Workspace-Inhalt mit dem Kommando sync( ) in der Worspace-Datei zu aktualisieren. Der Befehlt entspricht dem Kommando save ("SALIERI.WSP"). Es empfiehlt sich übrigens, den "sync"-Befehl hin und wieder auszuführen, da SALIERI nicht vollkommen Absturzsicher ist.


Definition: Objekt

Ein Objekt besitzt einen Namen, einen Typ und einen Wert. Objektnamen beginnen immer mit einem Buchstaben oder Unterstrich ("_") gefolgt von beliebig vielen Buchstaben, Ziffern, Punkten (".") oder Unterstrichen. Es wird zwischen Groß-und Kleinbuchstaben unterschieden. Objektnamen die mit einem Unterstrich beginnen sind Systmobjekte und werden in der Regel durch Ausgabekommandos nicht angezeigt.

Beispiel:

Robinson_Crusoe, _Don.Quichote, zweiplus1, Rocky.34.7 und Tic.Tac_Toe sind gültige Objektnamen. Falsch wären: 1.Gymnopädie, .Erik_Satie oder 3mal5

Um ein Objekt zu erzeugen, muß einem noch nicht vergebenen Namen ein Wert zugewiesen werden, wobei sich daraus der Typ des Objekts ableiten läßt. Falls ein Objektname bereits existiert, so wird ihm der neue Wert zugewiesen.

Beispiel:

>Robinson_Crusoe:="Freund von Freitag"

>Erik_Satie:=LIST("Gymnopaedie","Gnossiene")

>Erik_Satie:=LIST("Nocturne","Sarabande")

>Erik_Satie

Result= LIST("Nocturne","Sarabande")


  Funktionen und Kommandos

   	Systemkommandos

 Kontrollfunktionen

   	Numerische Funktionen und Operationen

   	Vergleichsoperationen

   	Konvertierungsfunktionen

   	Infixoperationen

   	Reihenoperationen/Stringoperationen

   	Musikalische Funktionen

   	Listenfunktionen

   	Ein/Ausgabe

    Benutzerdefinierte Funktionen


Systemkommandos

Kommandos zur Systemsteuerung     exit     sync     exec dir it save load ver abort curLine curFunc set	Kommandos auf Objekten     stat      statAll delete deleteAll type exists


Kontrollfunktionen

if

while

loop

loopn


Konvertierungsfunktionen

BOOL

INT

REAL

STR


Ein / Ausgabe

  	read

      	readStr

saveAsMidi

      	play

     	write


Listenfunktionen

consList

getList

      	putList

      	inList

      	LISTINIT

Alle Reihenoperationen sind auch als Listenoperationen verwendbar


Musikalische Funktionen

Deskriptorfunktionen auf Sequenzen     isRest     getPitch     getPitchTonal     ambitus     duration     time     getIntens     getTempo     getInstr Kombinationsfunktionen auf Seq.     comb     merge Basisoperationen auf Segmenten     parts     part     poly	Basisoperationen auf Seq. & Seg.     transp     expand     retro     cresc     accel     instr     +(Konkatenation) Variationsfunktionen auf Seq.&Seg     invert     intvExpand     fragm     transpTonal     transcr     alter     alterTonal


Reihenoperationen
Reihenoperationen / Stringoperationen

      	+  (Konkatenation)

      	infix

     	ins

     	del

     	length

posNext

Achtung !!!

Reihenoperationen können auf Zeichenketten, Sequenzen und Listen angewendet werden.


Vergleichsoperationen

SALIERI bietet sechs verschiedene Vergleichsoperatoren  an:

=	definiert für:  Seq., Segmente, Funkt., Listen, Zahlen, Zeichenketten

!=	definiert für:  Seq., Segmente, Funkt., Listen, Zahlen, Zeichenketten

<	definiert für:  Zahlen, Zeichenketten

>	definiert für:  Zahlen, Zeichenketten

<=	definiert für:  Zahlen, Zeichenketten

>=	definiert für:  Zahlen, Zeichenketten

Bei Zeichenketten, beziehen sich die Operatoren <, >, <=, >=  auf die lexikographische Ordnung. Die Gleichheit bzw. Ungleichheit bei zwei Sequenzen, ist dann gegeben, wenn sie die gleiche Länge haben und alle auftretenden Töne bezüglich ihrer Hauptparameter (Tonhöhe und -dauer) gleich sind. Zwei Segmente sind dann gleich, wenn sie aus gleichen Stimmen (hier gilt die Gleichheit für Sequenzen) bestehen und diese in der gleichen Reihenfolge stehen. Zwei Funktionen sind genau dann gleich, wenn sie beide die gleiche Parameterzahl, sowie zeichenweise identische Funktionskörper vorweisen.

Sämtliche Vergleichsoperatoren liefern "bool" als Ergebnistyp zurück und binden stärker als die logischen Operatoren, aber schwächer als alle anderen Operatoren. Die Ausdrücke "2*x+5 > 10 and not x > 5" und "(((2*x) + 5 and (not(x >5))" sind also gleichbedeutend. Es können ganze Zahlen mit Gleitpunktzahlen verglichen werden, da eine automatische Konvertierung erfolgt. Ein Vergleich kann nur zwischen Objekten des gleichen Typs durchgeführt werden, also wäre z.B. 3 + 4 = "Drei plus Vier" unzulässig und würde einen Fehler, statt dem Ergebnis FALSE liefern.

Beispiel:

>[M=120 c d e] = [M=100 c d e]

Result= TRUE

>[M=120 c d e] = [M=100 c e f g]

Result= FALSE

>{[c d e], [a f]} = {[c d e], [a f]}

Result= TRUE

>{[c d e], [a f]} = {[a f], [c d e]}

Result= FALSE

>LIST("Turm gegen Springer") = LIST("Dame gegen Bauern")

Result= FALSE

>3 <= 0.456

Result= FALSE

>"Bach" > "Beethoven"

Result= FALSE

>"Bremen" < "Berlin"

Result= FALSE

>


Infixoperationen

SALIERI bietet für einige Elementaroperationen auch die Infixnotation an. Weitere Informationen zur konventionellen Schreibweise siehe:

Numerische Operationen

Boolsche Infixoperationen

 •	_NOT (bool)	logische Negation

 •	_AND (bool, bool)	logisches und

 •	_OR (bool, bool)	logisches oder

"_NOT" bindet stärker als "_AND", dieses stärker als "_OR"

Beispiel:

>_NOT (TRUE)

Result= FALSE

>_NOT (FALSE)

Result= TRUE

>_AND (TRUE, 2>3)

Result= FALSE

>_OR (2>3,TRUE)

Result= TRUE

>

Infixoperationen auf Integer

 •	_PLUS (int, int)	Addition

 •	_MINUS (int, int)	Subtraktion

 •	_TIMES (int, int)	Multiplikation

 •	_DIV (int, int)	Ganzzahldivision

 •	_MOD (int, int)	Divisionsrest

Beispiel:

>_PLUS(5,4*3)

Result= 17

>_MINUS(5,4*3)

Result= -7

>_TIMES(_PLUS(2,3),4)

Result= 20

>_DIV(5,2)

Result= 2

>_MOD(5,2)

Result= 1

>

Infixoperationen auf Real

 •	_PLUS (real, real)	Addition

 •	_MINUS (real, real)	Subtraktion

 •	_TIMES (real, real)	Multiplikation

 •	_BY (real, real)	Division

Beispiel:

>_PLUS(5.4,4*3)	(* !!!! Ungenaues Resultat *)

Result= 17.40000010

>_MINUS(5.4,4*3)

Result= -6.59999990

>_TIMES(1.2,1.2)

Result= 1.44000011

>_BY(5,2)

Result= 2.50000000

>

Vergleichsoperationen in der Infixnotation

 •	_EQ (collection, collection)	entspricht "="

 •	_UNEQ (collection, collection)	entspricht "!="

 •	_LE (choice, choice)	entspricht "<"

 •	_GR (choice, choice)	entspricht ">"

 •	_LEQ (choice, choice)	entspricht "<="

 •	_GEQ (choice, choice)	entspricht ">="

Vergleichsoperationen

Beispiel:

>_EQ("Kai Flade","Holger Hoos")

Result= FALSE

>_UNEQ("Matthias Streicher","Thomas Helbich")

Result= TRUE

>_EQ([c d e], LIST("c d e"))   (* Zwei ungleiche Typen !!! *)

Error in command-line: Type mismatch

(occured while executing function "_EQ")

>_EQ([M=100 c d e],[M=100 c d e])

Result= TRUE

>_EQ([M=100 c d e],[M=80 c d e]) (* Gleichheit gegeben obwohl Metrum verschieden *)

Result= TRUE

>


Benutzerdefinierte Funktionen

      	Funktionsdefinition

      	Funktionsaufruf

      	Makros

      	Funktionen mit variabler Parameterzahl

      	Interne Funktionen


Funktionsdefinition

Funktionen werden durch eine Anweisung folgender Form definiert:

name:= FUNC (integer, body)

Dabei ist integer die Anzahl der Parameter, name der Funktionsname und ein gültiger Objektname, sowie body eine durch Hochkomma ` . . . ' geklammerte Anweisungsfolge. Innerhalb des Funktionskörpers werden die Paramter gemäß ihrer Position in der Paramterliste beim Funktionsaufruf als $1, $2 usw. angesprochen. Jede Funktion hat einen eigenen (lokalen) Workspace. Zu Beginn der Funktionsausführung enthält dieser alle Objekte des globalen Workspace (als Kopien !) und die Funktionsparameter und wird am Ende der der Funktionsausführung gelöscht. Ein Objekt, das innerhalb einer Funktion erzeugt wurde, existiert nur bis zum Ende der Funktionsausführung. Objekte des globalen Workspace können innerhalb der Funktionen zwar verwendet werden, allerdings nicht dauerhaft verändert bzw. gelöscht werden. Lokale Objekte sind also ohne Risiko erzeug- und verwendbar.

Eine Funktion wird mit dem Befehl "return" beendet, wobei gegebenenfalls eine Ergebnis-Rückgabe mit einbezogen wird. Durch die Anweisung return(expression) wird die Ausführung der Funktion an dieser Stelle beendet (alle folgenden Anweisungen werden also nicht ausgeführt), wobei der Wert des Ausdrucks expression als Funktionsergebnis zurückgegeben wird. Die Anweisung return( ) wirkt genauso, allerdings wird hierbei kein Ergebnis geliefert.

Beispiel:

>Kubikzahl:=FUNC(1,`return($1*$1*$1)');   (* Funktionsdefinition *)

>Kubikzahl(4)                                             (* Funktionsaufruf     *)

Result= 64

>

Es ist vernünftig, Funktionen als Programmdateien zu schreiben, da Änderungen leichter durchzuführen sind. Da Funktionen gewöhnliche Objekte sind, können sie in Zuweisungen auftreten oder sogar Parameter einer anderen Funktion sein. Die syntaktische Korrektheit von Funktionskörpern, wird erst bei der Ausführung der Funktion überprüft. Tiefergehende Informationen zum Thema Funktionsdefinition entnehme man bitte dem Handbuch.


Funktionsaufruf

Benutzerdefinierte Funktionen werden genauso wie die internen Funktionen in der Form name(par1, . . . , parn) aufgerufen. Hierbei ist name der Funktionsname  und par1 usw. sind die Funktionsparameter. Die Parameter dürfen beliebige Ausdrücke sein. Funktionen ohne Parameter werden mit name( ) aufgerufen.

Eine alternative Form des Funktionsaufrufs benutzt die interne Funktion "apply", dabei entspricht der Aufruf apply (name, par1, . . . , parn) genau der oben angegebenen Aufrufform name(par1, . . . , parn). Im allgemeinen sollte die Verwendung von "apply" aus Gründen der Übersichtlichkeit vermieden werden.

Falls die Funktion ein Resultat liefert, repräsentiert der Funktionsaufruf einen Ausdruck, der stellvertretend für dieses Resultat steht. Es ist zu beachten, daß falls kein Funktionswert zurückgegeben wird, die Funktion einem Kommando entspricht und somit nicht auf der rechten Seite einer Zuweisung stehen darf oder als Funktionsparameter übergeben wird.

 Funktionsdefinition

Beispiel:

>transp([c d e f],3)  (* Funktionsaufruf mit Parametern sequence u. Integer *)

Result= [ I=80 M=100 T=0 d#1/4 f1/4 g1/4 g#1/4 ]

>apply(transp, [c d e f], 3)  (* Alternativer Funktionsaufruf mit "apply" *)

Result= [ I=80 M=100 T=0 e&1/4 f1/4 g1/4 g#1/4 ]

>d:=transp([ a g],4)  (* Zuweisung einer Funktion *)

>d:=exit()      (* Kommando auf der rechten Seite - erwarte Fehlermeldung *)

Error in command-line: Missing Parameter

Saving workspace to salieri.wsp ... Done

See you later!


Makros

Ein Makro ist eine spezielle Funktion, welches durch eine Anweisung der Form:

name:= MACRO (integer, body)

definiert wird. Der einzige Unterschied zu Funktionen besteht darin, daß Makros keinen lokalen Workspace besitzen. Die Objektnamen im Makrokörper, beziehen sich daher auf den globalen Workspace. Es können trotzdem lokale (und somit temporäre) Variablen deklariert werden. Sie müssen mit einem $-Zeichen beginnen. Diese Notation ist auch in Funktionsdeklarationen erlaubt, bringt dort aber keine zusätzliche Funktionalität, da dort lokale Variablen schon unterstützt werden. Makros eignen sich besonders zur Realisierung eigener Systemkommandos, wie beispielsweise dem Anzeigen oder Löschen bestimmter Objektgruppen.

 Funktionsdefinition

 Funktionsaufruf

Beispiel:

>Demo:=MACRO(-1,`writeAll("B*")');

>Demo( )

Bach = "Orchestersuite Nr.3" : string

Beethoven = "Klaviersonate Nr.12" : string

>l_mac:=MACRO(2,`loop(`$i:=1',`$i<=$1',`$i:=$i+1',`write($2)')') (* $i lokal *)

>l_mac(2,"Die weißen Tauben sind Möwen")

Die weißen Tauben sind Möwen

Die weißen Tauben sind Möwen

>

Das bei Funktionen zu empfehlende Verfahren, die Paramter $1, $2, ... umzubenennen ist bei Makros unbedingt zu vermeiden. Makros besitzen keinen lokalen Workspace und daher kann es zum Überschreiben vorhandener Objekte kommen (Seiteneffekt). Die Vergleichsoperatoren "=" und "!=" sind auf Makros anwendbar, dabei sind 2 Makros genau dann gleich, wenn sie die gleiche Parameterzahl sowie zeichenweise identische Funktionskörper haben.


Funktionen mit variabler Parameterzahl

Einer Funktion, die eine beliebige Anzahl von Parametern haben kann, wird bei der Funktionsdefinition eine -1 als Parameterzahl angegeben. Beim Aufruf werden dann alle Parameter zu einer Liste zusammengefasst, auf die mit $1 zugegriffen werden kann. Eine solche Funktion kann mit beliebig vielen Parametern aufgerufen werden, auch ohne Parameter, dann ist die Parameterliste $1 leer. Im Übrigen können Makros mit beliebiger Parameterzahl, auf die gleiche Weise realisiert werden.

Beispiel:

>d:=FUNC(-1,`pl :=$1; write("Parameterzahl: ",#pl)');

>d(3,LIST("HALLO"),"3.Parameter",[d f g])

Parameterzahl: 4

>


Interne Funktionen

Interne Funktionen werden ebenso als Objekte betrachtet, wie benutzerdefinierte Funktionen oder Makros. Insbesondere können sie also ebenfalls in Zuweisungen oder als Funktionsparameter auftreten. Diese Eigenschaft kann z.B. dazu genutzt werden, "Kopien" von Systemkommandos unter einem neuen Namen anzulegen, und so das System eigenen Bedürfnissen anzupassen.

Interne Funktionen können nicht umdefiniert oder gelöscht werden. Es ist zwar möglich ein Objekt namens "exit" zu definieren, beim Aufruf von "exit" wird aber trotzdem auf die vordefinierte interne Funktion zurückgegriffen.

Beispiel:

>schreibe:=write

>schreibe

Result= IFUNC("write")

>schreibe("Des Knaben Wunderhorn")

Des Knaben Wunderhorn

>write:=345

>write

Result= IFUNC("write")

>


  Dateien und Programme

Als zusätzliche Option zur Kommandozeileneingabe besteht die Möglichkeit, SALIERI-Programmdateien auszuführen. Hierzu wird der Befehl exec("filename") eingesetzt, welcher die Programmdatei filename.SAL (aus dem aktuellen Arbeitsverzeichnis) ausführt.

Kommandos innerhalb einer Programmdatei werden durch ";" voneinander getrennt. Leerzeilen und zusätzliche Leerzeichen werden ignoriert, ebenso wie Kommentare, die in folgender Form notiert werden: (* .... *). Im Übrigen dürfen Kommentare beliebig geschachtelt werden. Eine Programmdatei wird so ausgeführt, als ob sie in derselben Reihenfolge in der Kommandozeile eingegeben wurde.

 Alle Programmdateien dürfen beliebig viele Zeilen mit Kommandos oder auch Leerzeilen umfassen. Das letzte Kommando in einer Programmdatei darf ein Ausdruck sein, hiervon wird allerdings abgeraten. Nach dem letzten Kommando muß kein Semikolon stehen, wovon allerdings auch Abstand zu nehmen ist, zwecks späterer Erweiterung der Datei.

Mit Programmdateien lassen sich auch Bibliotheken herstellen. Das Programm besteht dann aus einer Reihe von Zuweisungen und evtl. einigen Initialisierungskommandos.

Beispiel: Programmdatei BSP.SAL

pass:=readStr("Password: ");         (* Eingabeaufforderung, Objekt erzeugen *)

if(`pass="Viel Laerm um nichts" ', (* Zeilenumbruch ist erlaubt *)

   `write();                                    (* Leerzeile erzeugen *)

    write("BENEDICT: Gott erhalte mein gnaediges Fraeulein");

    write("  immer in dieser Gesinnung!");

    write("  So wird doch ein oder der andre ehrliche Mann dem");

    write("  Schicksal eines zerkratzten Gesichts entgehn.");

    write("BEATRICE: Kratzen würde es nicht schlimmer machen,");

    write("  wenn es ein Gesicht wäre wie Eures.");

   ' );

Beispiel: Ausführung von BSP.SAL

>exec("bsp")

Executing bsp.sal ...

Password: Viel Laerm um nichts

BENEDICT: Gott erhalte mein gnaediges Fraeulein

  immer in dieser Gesinnung!

  So wird doch ein oder der andre ehrliche Mann dem

  Schicksal eines zerkratzten Gesichts entgehn.

BEATRICE: Kratzen würde es nicht schlimmer machen,

  wenn es ein Gesicht wäre wie Eures.

>


  Musikalische Objekttypen

Sequenzkonstanten

Segmentkonstanten

Achtung !!!

Operationen auf Sequenzen, Segmenten; s. Musikalische Funktionen


Sequenzkonstanten

In SALIERI wird ein musikalischer Ton durch 5 Parameter beschrieben: die beiden Hauptparameter Tonhöhe und relative Tondauer, sowie die Nebenparameter Intensität, Klangfarbe und Metrum.

Eine Tonbeschreibung in SALIERI sieht folgendermaßen aus:

M=m  T=t  I=i  qr*e/dp

Die Symbole m, t, i, q, r, e, d, p haben dabei folgende Bedeutung:

m	Metrum in 1/4-Noten pro Minute (Metronomzahl), ganze Zahl

zwischen 1 und 255

t	Klangfarbe in Form einer Programmnummer eines MIDI-

Instrumentes, ganze Zahl zwischen 0 und 127

i	(relative) Intensität, ganze Zahl zwischen 0 und 127

q	Tonqualität, entweder einer der Notennamen c, d, e, f, g, a, h,

gegebenenfalls gefolgt von einem Vorzeichen # oder &; oder

"_" für Pausen

r	Register (Oktave), ganze Zahl zwischen 1 und 128

e	Zähler der relativen Tondauer, ganze Zahl zwischen 1 und 128

d	Nenner der relativen Tondauer, ganze Zahl zwischen 1 und 128

p	Punktierter bzw. doppelt punktierter Notenwert, wird durch "." oder

".." angegeben.

Beispiel:

"M=100 T=0 I=80 a1*1/4" und "M=220 T=18 I=4  _*5/27" sind vollständige Tonbeschreibungen. Die Ein- und Ausgabe sieht in SALIERI wiefolgt aus:

>[M=100 T=0 I=80 a#1*1/4]

Result= [ I=80 M=100 T=0 a#1/4 ]

>[M=220 T=18 I=4 _*5/27]

Result= [ I=4 M=220 T=18 _*5/27 ]

>[M=60 T=12 c/4. _ c..]	(* Punktierte Notenwerte *)

Result= [ I=80 M=60 T=12 c1*3/8 _/4 c1*7/16 ]

>

Es ist außerdem möglich, für Intensitäts-, Metrums- und Instrumentkonstanten Namen anzugeben. Diese müssen allerdings aus mindestens zwei Zeichen bestehen.

Beispiel:

>Adagio:=60

>[M=Adagio T=0 I=80 c g f]

Result = [ I=80 M=60 c1/4 g1/4 f1/4 ]

>

Notensequenzkonstanten werden entweder in der Form [n1 n2 ...] oder alternativ als Konstrukt SEQ("n1 n2 ...") notiert, wobei immer der Tonqualitätsparameter q angeben werden muß, alle anderen Angaben sind optional. Werden keine weiteren Angaben gemacht, so werden die der vorherigen Note übernommen. Die relative Tondauer wird allerdings nur dann übernommen, wenn e und d nicht angegeben werden. Ist die Angabe unvollständig (z.B. "/8" oder "*4") wird e=1 bzw. d=1 gesetzt. Punktierungen p werden direkt hinter der Dauerangabe geschtrieben und gelten nur für die entsprechende Note. Falls die Parameterangaben für die erste Note der Sequenz unzureichend sind, so wird die folgende Standardeinstellung verwendet.

r = 1,   e/d = 1/4,   m = 100,   t = 0,   i = 80

SALIERI gibt die Hauptparameter einer Notensequenz vollständig aus, die Nebenparameter jedoch nur am Anfang der Sequenz und an den Stellen, wo ihr Wert sich ändert.

Beispiel: Ausgabeformat von Notensequenzen

>[I=100 M=138 d/8 f c.. d h2. c1/2 f3*3/4]

Result= [ I=100 M=138 T=0 d1/8 f1/8 c1*7/32 d1/8 h2*3/16 c1/2 f3*3/4 ]

>SEQ("I=100 M=138 d/8 f c.. d h2. c1/2 f3*3/4")

Result= [ I=100 M=138 T=127 d/8 f c*7/32 d/8 h2*3/16 c1/2 f3*3/4 ]

>

Die Tonhöhen werden von SALIERI im gleichschwebend temperierten System interpretiert. Die Oktavlagen von h# und c& werden korrekt erkannt, d.h.

[h1# c&1] = [c2 h0]

Mit den Operatoren "=" und "!=" sind Vergleiche auf Notensequenzen zulässig. Zwei Notensequenzen sind genau dann gleich, wenn sie die gleiche Länge haben und alle autretenden Töne bezüglich ihrer Hauptparameter (Tonhöhe und -dauer) gleich sind.


Segmentkonstanten

Ein Segment besteht aus einer Reihe von Notensequenzen, den Stimmen. Alle Stimmen eines Segments beginnen zum gleichen Zeitpunkt und laufen dann parallel ab. Die Konstanten des Typs "segment" können auf zwei verschiedene Arten geschrieben werden.

1) In einfach polyphoner Form sind sie entweder von der Form {seq1, seq2, ...} oder SEGM(seq1, seq2, ...), wobei seq1 usw. Notensequenzen sind.

Beispiel:

{[c d e], [e f g]} und {[c d e]} sind Segmente in einfach polyphoner Form.

>SEGM([c d e], SEQ("e f g")) (* Gleiche Stimmen anders notiert *)

Result= SEGM([ I=100 M=144 T=127 c d e ],[ I=100 M=144 T=127 e f g ])

>

2) Weiterhin können Segmente als Akkordsequenzen in der Form [a1 a2 ...] geschrieben werden, dabei sind a1 usw. entweder Tonbeschreibungen oder Akkordbeschreibungen in der Form {n1, n2, ...} (mit Tonbeschreibungen n1 usw.)

Nicht spezifizierte  Tonparameter werden auch innerhalb eines Akkordes von der letzten Note übernommen, sodaß [{c2/8, e, g}] als [{c2*1/8, e2*1/8, g2*1/8}] interpretiert wird.

Beispiel:

[{c, e, g} {h0, d1, g}] und [{c, d, e}] sind Segmente in Akkordsequenzform.

Notensegmente werden vom SALIERI-System immer in einfach polyphone Normalform transformiert, in dieser Form besteht ein Segment aus einer Reihe paralleler Notensequenzen, die alle die gleiche Dauer haben. Um diese Form zu erreichen, werden in der einfach polyphonen Form an die Stimmen entsprechende Pausen angehängt. Akkordsequenzen werden zunächst in Einzelstimmen aufgelöst, indem die jeweils ersten Töne jedes Akkords die erste Stimme bilden usw. (dabei wird durch Einfügen von Pausen gewährleistet, daß die Noten eines jeden Akkords auch tatsächlich gemeinsam beginnen.)

Beispiel:

>[{c/2, e/4} {g/4, f/8}]  (* Akkordsequenz *)

Result= SEGM([ I=80 M=100 T=0 c1/2 g1/4 ],[ I=80 M=100 T=0 e1/4 _/4 f1/8 _/8 ])

>{[g-1/4], [_/4 h0/2]}    (* Polyphone Form; Auffuellen mit Pausen *)

Result= SEGM([ I=80 M=100 T=0 g-1/4 _/2 ],[ I=80 M=100 T=0 _/4 h0/2 ])

>

Die Vergleichsoperatoren "=" und "!=" sind auf Notensegmente anwendbar, dabei sind zwei Segmente genau dann gleich, wenn sie aus gleichen Stimmen in der gleichen Reihenfolge bestehen.


Numerische Funktionen und Operationen

Boolsche Operationen

 •	not bool	logische Negation

 •	bool and bool	logisches und

 •	bool or bool	logisches oder

"not" bindet stärker als "and", dieses stärker als "or"

Integeroperationen

 • 	+ int	positives Vorzeichen

 •	- int	negatives Vorzeichen

 •	int + int 	Addition

 •	int - int 	Subtraktion

 •	int * int 	Multiplikation

 •	int div int	Ganzzahldivision (8 div 2 = 3)

 •	int mod int	Divisionsrest (8 div 2 = 2)

 •	abs (int)	Absolutbetrag

 •	rndUniform(int1,int2)	liefert Zufallszahl i mit int1  i  int2

Vorzeichen binden stärker als "*", "div", "mod". Diese binden stärker als "+", "-". Ansonsten werden die Ausdrücke von links nach rechts ausgewertet. Überschreitungen des Zahlenbereichs (-32768 bis 32767) verursachen keine Fehlermeldungen, führen aber meistens zu falschen Ergebnissen.

Beispiel:

>rndUniform (1,6)    (* Wuerfel mit Zahlen 1-6 *)

Result= 2

>

Realoperationen

 • 	+ real	positives Vorzeichen

 •	- real	negatives Vorzeichen

 •	real + real	Addition

 •	real - real	Subtraktion

 •	real * real	Multiplikation

 •	real / real	Division

 •	abs (real)	Absolutbetrag

 •	rnd ( )	liefert Zufallszahl r mit 0 < r < 1

 •	floor (real) → int	Abrunden (untere Gaußklammer)

 •	ceil (real) → int	Aufrunden (obere Gaußklammer)

 •	sin (real) → real	Sinus;	Im Bogenmaß

 •	cos (real) → real	Cosinus;	  "	"

 •	tan (real) → real	Tangens;	  "	"

 •	arctan (real)  → real	Arcustangens; "	"

 •	exp (real, [real]) → real	Exponentialfunktion

 •	log ([real], real) → real 	Logarihtmusfunktion

 •	root ([real],real) → real	Wurzelfunktion

Vorzeichen binden stärker als "*", "/", diese binden stärker als "+", "-". Ansonsten werden die Ausdrücke von links nach rechts ausgewertet. Die Gleitpunktarithmetk ist nicht immer genau. Bei besonders großen Zahlen treten Ungenauigkeiten in den hinteren Stellen auf. Wird der Zahlenbereich überschritten, stürzt SALIERI in der Regel ab, was zum Verlust des Workspace-Inhalts führt.


ÜBERSCHRIFT

      •

     	•

      •

      •


ÜBERSCHRIFT

      •

      •

      •

      •


  Kommandozeileneingabe

Tastaturbelegung:

Eingabe abschließen	ENTER

Eingaben wiederholen/abrufen	↑ ↓

Eingabe editieren	← →, Home, Del,Backsp.

      	akt. Zeile löschen	ESC

Der SALIERI - Interpreter unterscheidet zwischen Kommandos und Ausdrücken. Nach Ausführung eines Kommandos, erscheint eine evtl Ausgabe.  Ausdrücke werden ausgewertet und in der Form Result= .... ausgegeben. Wenn während einer Ausführung bzw. Auswertung ein Fehler auftritt, wird eine Fehlermeldung ausgegeben.

Um an das letzte ausgegebene Ergebnis einer Auswertung zu gelangen, kann die Funktion it( ) verwendet werden. Nach Starten des Systems ist it ( ) allerdings undefiniert. Nach einer fehlerhaften Auswertung ändert "it" sich nicht, sondern behält den alten Wert.

Beispiele:

>"Fische sind die besseren Voegel"

Result= "Fische sind die besseren Voegel"

>12 + Hallo_Petra

Error in command-line:  Unknown identifier: Hallo_Petra

>it ( )

Result= "Fische sind die besseren Voegel"

   >


ÜBERSCHRIFT

      •

      •

      •

      •


ÜBERSCHRIFT

      •

      •

      •

      •


Der exit Befehl
exit                                              Systemkommandos

Signatur:	Λ  → Λ

Aufruf:	exit( )

Rückgabewerte:	keine

Beschreibung:

Die parameterlose Funktion exit wird dazu verwendet um SALIERI zu verlassen. Bei Beendigung der Sitzung wird der Workspace (SALIERI.WSP) automatisch gespeichert. Beim erneuten Aufruf von SALIERI, kann somit der Workspace-Inhalt der letzten Sitzung wieder vom System geladen werden. Wenn nur der Workspace gesichert werden soll ohne SALIERI zu verlassen, ist der Befehl sync zu verwenden.

Beispiel:

>exit ( )

Saving workspace to salieri.wsp ... Done

See you later!

C:\SALIERI >


Das Systemkommando curLine
curLine                                       Systemkommandos

Signatur:	Λ  → Λ

Aufruf:	curLine( )

Rückgabewerte:	liefert akt. Zeilennummer des laufenden Programms

Beschreibung:

Die parameterlose Funktion curLine gibt die aktuell ausgeführte Zeilennummer  einer Programmabarbeitung aus. "curLine" eignet sich somit besonders gut zur Fehlersuche in größeren Programmen. Der Name einer aktuell ausgeführten Funktion wird mit Hilfe der Funktion curFunc ausgegeben.

Beispiel:

>Hallo:=FUNC(-1,`curLine( )')

>Hoppla:=FUNC(-1,`Hallo( )')

>Hoppla( )

Result= 1

>write("Dearest, most beloved little Wife!");curLine( )

Dearest, most beloved little Wife!

Result= 0

>exec("zauber")	(*Programmdatei mit curLine in Zeile 4 und 15*)

Executing zauber.sal ...

Mozart an seine Frau in Baden zur Aufführung der Zauberflöte

Samstags Nachts um 1/2 11 Uhr              Wien, 8./9.Oktober 1791

Result= 4

liebstes, bestes Weibchen!

...die Oper ist, obwohl sammstag allezeit, wegen Posttag ein schlechter

Tag ist, mit ganz vollem Theater mit dem gewöhnlichen Beifall

und repetitionen aufgeführt worden;-morgen wird sie noch gegeben,

aber Monntag wird ausgesetzt-folglich muss Siessmayer den Stoll

dienstag herein bringen, wo sie wieder zum Erstenmale gegeben wird-

ich sage zum Erstenmale, weil Sie vermutlich wieder etlichemal

nacheinander gegeben werden wird...Morgen führe ich die Mama hinein;

-das büchel hat ihr schon vorher Hofer zu lesen gegeben-bey der Mama

wirds wohl heissen, die schauet die Oper, aber nicht die hört die Oper...

Result=15

>


Das Systemkommando curFunc
curFunc                                      Systemkommandos

Signatur:	Λ  → Λ

Aufruf:	curFunc( )

Rückgabewerte:	liefert Namen der aktuell ausgeführten Funktion

Beschreibung:

Die parameterlose Funktion curFunc gibt den Namen der aktuell ausgeführten Funktion eines Programms aus. Bei verschachtelten Funktionen wird immer die tatsächlich ausgeführte Ebene berücksichtigt und entsprechend ausgegeben. "curFunc" eignet sich somit besonders gut zur Fehlersuche in größeren Programmen. Die Zeilennummer einer aktuell ausgeführten Funktion wird mit Hilfe von curLine ausgegeben.

Beispiel:

>Hallo:=FUNC(-1,`curFunc( )')

>Hoppla:=FUNC(-1,`Hallo( )')

>Hoppla( ) (* Einmal geschachtelte Funktion *)

Result= "Hallo"


Der loopn Befehl
loopn                                           Kontrollfunktionen

Signatur:	integer × statmt-block   → Λ

Aufruf:	loopn(int , body block)

Rückgabewerte: 	keine

Beschreibung:

Die Kontrollfunktion loopn, bewirkt ein int-maliges durchlaufen des Schleifenkörpers body block. Beim Schleifenkörper handelt es sich um eine Anweisungsliste, in der natürlich loopn nochmal vorkommen darf. Der Befehl  loop  ist eine weitere Möglichkeit einen Schleifenkörper zu durchlaufen.

Beispiel:

> i:=0; loopn (3, ` i:=i+1; write ("Gott ist tot, sprach Zarathustra zum ", i , ". mal !") ')

Gott ist tot, sprach Zarathustra zum 1.mal !

Gott ist tot, sprach Zarathustra zum 2.mal !

Gott ist tot, sprach Zarathustra zum 3.mal !

>


Die Funktion set
set                                                       Systemkommandos

Signaturen:	Λ   →  Λ;  string  →  Λ;  string × valuetype →  Λ

Aufrufe:	set ( ) ;      set (setting) ;  set (setting, newValue)

Rückgabewerte: 	liefert, manipuliert Systemeinstellungen

Beschreibung:

Mit Hilfe der Funktion "set" kann man die Systemeinstellungen manipulieren. Gibt man nur den Befehl set ( ) ohne Parameter ein, so gibt SALIERI eine Liste aller Systemeinstellungen und ihren aktuellen Werten aus. Will man nur den Wert einer ganz bestimmten Systemeinstellung angezeigt bekommen, muß man ihren Namen setting als Parameter angeben. Falls man den Wert einer Einstellung verändern möchte, muß man den Namen der Systemeinstellung setting und den neuen Wert newValue als Parameter angeben. Zu beachten ist, daß der Parameter setting als Zeichenkette angegeben werden muß, während der Typ des Parameters newValue von der Systemeinstellung und ihrem Wertebereich abhängt. Das SALIERI-System besitzt folgende Systemeinstellungen:

debug	seqDispFormat

dispTags	stdInstr

midiHoldFactor	stdIntens

noteNames	stdTempo

Bei persistentem Workspace werden die Systemeinstellungen mitabgespeichert, d.h. die Systemeinstellung ändert sich bei der nächsten Sitzung nicht. Bei nicht persistentem Workspace gehen Änderungen an der Systemeinstellung bei der nächsten Sitzung verloren, da die Standardeinstellungen gewählt werden.


Die Funktion set("debug",...)
set("debug", . . .)                                           Set

debug  dispTags  midiHoldFactor  notenames  seqDispFormat  stdInstr  stdIntens  stdTempo

Signatur:	string   →  Λ

Aufruf:	set ("debug", newValue)

Rückgabewerte: 	keine

Beschreibung:

Hierbei handelt es sich um eine systeminterne Einstellung, die vom Benutzer nicht verändert werden sollte, und hier nur der Vollständigkeit halber aufgeführt wird. Die Parameter für die Funktion sind "on" und "off", wobei "on" die Standardeinstellung ist. Dies mag verwundern, ein Grund hierfür ist die Kompatibilität mit früheren SALIERI-Versionen.

Beispiel:

>set("debug","on")

>set("debug","off")

>set( )

debug=off

dispTags=on

midiHoldFactor=0.80

noteNames=diatonic

seqDispFormat=long

stdInstr=0

stdIntens=80

stdTempo=100

>


Die Funktion set("dispTags",...)
set("dispTags", . . .)                                      Set

debug  dispTags  midiHoldFactor  notenames  seqDispFormat  stdInstr  stdIntens  stdTempo

Signatur:	string   →  Λ

Aufruf:	set ("dispTags", newValue)

Rückgabewerte: 	keine

Beschreibung:

Hierbei handelt es sich um eine systeminterne Einstellung, die vom Benutzer nicht verändert werden sollte, und hier nur der Vollständigkeit halber aufgeführt wird. Die Parameter für die Funktion sind "on" und "off", wobei "on" die Standardeinstellung ist.

Beispiel:

>set("dispTags","on")

>set("dispTags","off")

>set("dispTags" )

dispTags=off

>


Die Funktion set("midiHoldFactor",...)
set("midiHoldFactor", . . .)                  Set

debug  dispTags  midiHoldFactor notenames  seqDispFormat  stdInstr  stdIntens  stdTempo

Signatur:	real   →  Λ

Aufruf:	set ("midiHoldFactor", newValue)

Rückgabewerte: 	keine

Beschreibung:

"midiHoldFactor" bestimmt prozentual zum eigentlichen Notenwert der Notenkonstanten die Haltedauer beim Abspielen (siehe play, saveAsMidi). Ein Wert 0 entspricht einem extrem kurzen Staccato, 1 einem vollen Auspielen der beschriebenen Notendauer. Die Voreinstellung berägt hat den Wert 0.8.

Beispiel:

>set("midiHoldFactor",1.2)

>set("midiHoldFactor")

midiHoldFactor=1.20

>


Die Funktion set("noteNames",...)

set("noteNames", . . .)                                   Set

debug  dispTags  midiHoldFactor  notenames  seqDispFormat  stdInstr  stdIntens  stdTempo

Signatur:	string   →  Λ

Aufruf:	set ("noteNames", newValue)

Rückgabewerte: 	keine

Beschreibung:

Mit "noteNames" wird das Erscheinungsbild der Notennamen festgelegt. Der Parameter newValue kann die Zeichenketten "diatonic", "chromatic" und "DoReMi" als Werte annehmen. Im "diatonic"-Modus setzen sich Notennamen aus den Notenbezeichnern c, d, e, f, g, a, h und einer beliebigen Anzahl der Vorzeichen # und &} zusammen. Im "chromatic"-Modus werden die Notenbezeichner des "diatonic"-Modus durch cis, dis, fis, gis und ais ergänzt. Es findet jedoch keine automatische Umwandlung von c# in cis statt. Diese chromatischen Namen müssen also auch direkt eingegeben werden, um sie in einer Ausgabe angezeigt zu bekommen oder bei Abfragen zu erkennen. Im  "DoReMi-Modus wird die italienische Bezeichnungsweise benutzt. In jedem Modus können generell alle Notationen zur Eingabe von Sequenzen benutzt werden. Werden im "diatonic"-Modus chromatische bzw. italienische Notierungen eingegeben, so erscheinen diese auschließlich als diatonische Zeichen in der Ausgabe. Die Standardeinstellung von "noteNames" ist "diatonic".

Beispiel:

>set("noteNames","diatonic")

>seq:=[c c# cis do do#]

>seq

Result= [ I=80 M=100 T=0 c1/4 c#1/4 c#1/4 c1/4 c#1/4 ]

>set("noteNames","chromatic")

>seq

Result= [ I=80 M=100 T=0 c1/4 c#1/4 cis1/4 c1/4 c#1/4 ]

>set("noteNames","DoReMi")

>seq

Result= [ I=80 M=100 T=0 do1/4 do#1/4 do#1/4 do1/4 do#1/4 ]

>seq:=[c cis d dis e f fis g gis a ais h]

>seq

Result= [ I=80 M=100 T=0 do1/4 do#1/4 re1/4 mi&1/4 mi1/4 fa1/4 fa#1/4 sol1/4 sol#1/4 la1/4 si&1/4 si1/4 ]

>getPitch([cis])

Result= LIST(1,1,0)

>getPitch([c#])

Result= LIST(1,1,1)

>


Die Funktion set("seqDispFormat",...)

set("seqDispFormat", . . .)                            Set

debug  dispTags  midiHoldFactor  notenames  seqDispFormat stdInstr  stdIntens  stdTempo

Signatur:	string   →  Λ

Aufruf:	set ("seqDispFormat", newValue)

Rückgabewerte: 	keine

Beschreibung:

Die Einstellung des Systemparameters "seqDispFormat" bestimmt die Ausführlichkeit des Ausgabeformats von Sequenzen. Der Parameter newValue kann als Werte die Zeichenketten "short" oder "long" annehmen. Im "long"-Modus wird jede Notenkonstante mit Oktav- und Notenlängeninformation angezeigt, während im "short"-Modus nur jeweils bei einer Änderung dieser Noteneigenschaften der geänderte Wert mit angegeben wird. Bei der Eingabe von Sequenzen kann immer die verkürzte Notation benutzt werden. Die Voreinstellung des SALIERI-Systems ist "long".

Beispiel:

>set("seqDispFormat","long")

>[c3/4 d e/2 f1 a1*3/4]

Result= [ I=100 M=144 T=127 c3/4 d3/4 e3/2 f1/2 a1*3/4 ]

>set("seqDispFormat","short")

>[c3/4 d e/2 f1 a1*3/4]

Result= [ I=100 M=144 T=127 c3/4 d e/2 f1 a*3/4 ]

>


Die Funktion set("stdInstr",...)

set("stdInstr", . . .)                                        Set

debug  dispTags  midiHoldFactor  notenames  seqDispFormat  stdInstr  stdIntens  stdTempo

Signatur:	integer  →  Λ

Aufruf:	set ("stdInstr", newValue)

Rückgabewerte: 	keine

Beschreibung:

Mit der Funktion set("stdInstr", ...), läßt sich das Standardinstrument mit dem Parameter newValue setzen. Falls in einer Sequenz kein Instrument explizit angegeben wird, so greift SALIERI auf das Standardinstrument zurück. Dieses ist zunächst die MIDI-Programmnummer 0 (entspricht piano), doch kann der Wert von newValue zwischen 0 und 255 variieren und somit verschiedene Klangfarben als Standardeinstellung annehmen. Die einzelne Zuordnung der Instrumente zu den jeweiligen Zahlen, entnehme man einer entsprechenden Tabelle. Mit dem Aufruf set("stdInstr") kann der Wert des Standardinstrumensät abgefragt werden.

Beispiel:

>set("stdInstr",127)

>set("stdInstr")

stdInstr=127

>


Die Funktion set("stdIntens",...)

set("stdIntens", . . .)                                      Set

debug  dispTags  midiHoldFactor  notenames  seqDispFormat  stdInstr  stdIntens  stdTempo

Signatur:	integer  →  Λ

Aufruf:	set ("stdIntens", newValue)

Rückgabewerte: 	keine

Beschreibung:

Wird bei der Eingabe einer Sequenz keine Intensität (z.B. I=88) angegeben, wird der Wert von "stdIntens" als Standardintensität eingesetzt. Da die Intensität einem MIDI-Volume-Code entspricht, muß newValue zwischen 0 und 127 liegen. Die Grundeinstellung der Intensität beträgt 80 (Mezzoforte). Mit dem Aufruf set("stdIntens") kann der Wert der Standardintensität abgefragt werden.

Beispiel:

>set("stdIntens",100)

>set("stdIntens")

stdIntens=100

>


Die Funktion set("stdTempo",...)

set("stdTempo", . . .)                                   Set

debug  dispTags  midiHoldFactor  notenames  seqDispFormat  stdIntens  stdInstr  stdTempo

Signatur:	integer →  Λ

Aufruf:	set ("stdTempo", newValue)

Rückgabewerte: 	keine

Beschreibung:

Wird bei der Eingabe einer Sequenz kein Metrum (z.B. M=111) angegeben, wird der Wert von "stdTempo" als Standardmetrum eingesetzt. Da der Metrumwert einer Tempoangabe gemäß der MIDI-Spezifikation entspricht, muß newValue zwischen 1 und 255 liegen. Die Voreinstellung für das Metrum beträgt 100 (Andante). Mit dem Aufruf set("stdTempo") kann der Wert des Standardmetrums abgefragt werden.

Beispiel:

>set("stdTempo",144)    (* Allegro *)

>set("stdTempo")

stdTempo=144

>


Der sync Befehl
sync                                                    Systemkommandos

Signatur:	Λ   →  Λ

Aufruf:	sync ( )

Rückgabewerte: 	keine

Beschreibung:

Dieses Kommando speichert den Inhalt des Workspace in die Datei SALIERI.WSP. Es empfiehlt sich übrigens hin und wieder "sync" auszuführen, da gelegentliche Abstürze von SALIERI nicht auszuschließen sind. Soll SALIERI verlassen werden und der Workspace erhalten bleiben, so ist exit zu verwenden.

Beispiel:

>sync ( )

Saving workspace to salieri.wsp ... Done

>


Der if Befehl
 if                                        Kontrollfunktionen

Signatur: 	      	expr-block × stmt-block × stmt-block  →  Λ

Aufruf:	if (cond-block, if-block, [else-block] )

Rückgabewerte: 	keine

Beschreibung:

Die Verzweigungsfunktion "if", führt den if-block genau dann aus, wenn der cond-block den Wahrheitswert TRUE liefert. Optional kann noch ein else-block ausgeführt werden, wenn cond-block den Wert FALSE enthält.

 Beispiel:

>Wetter := "FLAUSCHIG";

>Ja := "Gehe nicht zur Uni; nicht über Los, sondern Staub saugen";

>Nein := "Gehe in Gefängnis";

>if ( ` Wetter = "FLAUSCHIG"  ' , ` write (Ja) ' , ` write(Nein) '    )

Gehe nicht zur Uni; nicht über Los, sondern Staub saugen

>


Der Befehl stat
stat                                              Systemkommandos

Signatur:	Λ   →  Λ

Aufruf:	stat ( )

Rückgabewerte:	schreibt die Objekte desWorkspace auf den 	Bildschirm

Beschreibung:

Mit stat() lassen sich alle Objekte die im Workspace sind auflisten. Als Zugabe wird noch der verfügbare Speicherplatz angezeigt. Sucht man nach einem bestimmten Objekt, so verwendet man statAll.

Beispiel:

>stat( )

25 objects in workspace:

Alter  Faust  MyFairLady  Name  Op  Opus  Sinn  Sokrates  a  c  d  lied

melodie  melodie1  melodie2  square  x  z  z1  z2  z3  z4  z5  z6  z7

holdFactor=0.80

stdInstr=0

stdIntens=80

stdTemp=100

192672 bytes of memory free

>


Der loop Befehl
loop                                              Kontrollfunktionen

Signatur:	stmt-block× expr-block× stmt-block× stmt-block→Λ

Aufruf:	loop (init-block, cond-block, iter-block, body-block)

Rückgabewerte: 	keine

Beschreibung:

Die loop-Schleife ist - im Gegensatz zu loopn - die allgemeine Schleife in SALIERI. In init-block werden Zählvariablen etc. initialisiert. Dieser block wird nur einmal aufgerufen.  Solange cond-block den Wert TRUE ergibt, wird erst der Schleifenkörper body-block und dann der Anweisungsblock iter-block durchlaufen. Dieser sollte zur Iteration der Zählvariablen verwendet werden.

Beispiel:

>MyFairLady :=LIST ("Es grünt" , "so grün" , "wenn Spaniens" , "Blüten blühen");

>Faust := LIST ("Von Zeit" , "zu Zeit" , "seh ich" , "den Alten gern");

>loop (`a:=1' , `a<=5' , `a:=a+1' , ' write(MyFairLady@a); write(Faust@a)')

    Es grünt

    Von Zeit

    so grün

    zu Zeit

    wenn Spaniens

    seh ich

    Blüten blühen

    den Alten gern

>


Der write Befehl
write                                                Ein / Ausgabe

Signatur:	object × object × ... × object   →  Λ

Aufruf:	write (obj1, obj2, ... , objn)

Rückgabewerte:	keine

Beschreibung:

Gibt die Objekte obj1, ... ,objn ohne Zwischenraum auf dem Bildschirm aus. Jedes "write" schreibt die Objekte an den Zeilenanfang.

Beispiel:

>z1:=LIST ("Schon im Kalender steht´s geschrieben,");

>z2:=LIST("das es die Roemer uebertrieben.");

>z3:="Auch die Juden und Pollunder,"

>z4:="ganz zu schweigen vom Hollunder."

>z5:="Denket nur an Elefanten,"

>z6:="Gletscherklempner, Kaffeetanten;"

>z7:=LIST("Struwelpeter, Schnatterliese; " ,  "die Geschichte die ist diese !")

>write (z1@1, z2@1); write(z3, z4); write(z5,z6); write(z7@1, z7@2)

Schon im Kalender steht´s geschrieben, das es die Roemer uebertrieben.

Auch die Juden und Pollunder, ganz zu schweigen vom Hollunder.

Denket nur an Elefanten, Gletscherklempner, Kaffeetanten;

Struwelpeter, Schnatterliese; die Geschichte die ist diese !

>write(47+11, "=Achtundfünfzig")

58=Achtundfünzig


Der read Befehl
read                                                 Ein / Ausgabe

Signatur:	string   →  object

Aufruf:	read (string)

Rückgabewerte: 	liefert das Objekt, welches der Benutzer nach der

                             	Eingabeaufforderung string eingibt.

Beschreibung:

Die Funktion "read" kann Objekte eines beliebigen Typs einlesen (also auch Ausdrücke wie 3<4). SALIERI wertet hierzu die Eingabe aus und weist dem Ergebnis den entsprechenden Typ zu. Achtung !!! Wenn die Eingabe keinen der vorhandenen Typen entspricht, meldet SALIERI einen Fehler. Um beliebige Zeichenketten einzulesen, müssen diese in Anführungszeichen gesetzt werden. Bei readStr ist dies nicht notwendig.

Beispiel:

>Alter := read ("Wie alt bist Du: ");

Wie alt bist Du: 22.6

>Name := read ("Wie heisst Du: ");

Wie heisst Du: "Jim Knopf "

> write ("Du bist ", Alter, " Jahre alt und heisst ", Name)

Du bist 22.6 Jahre alt und heisst Jim Knopf

>read ("Was ist Deine schönste Kindheiterinnerung: ");

Was ist Deine schönste Kindheiterinnerung: Streichholzschachteln

Error in command-line: Unknown identifier: Streichholzschachteln

(occured while executing function "read")

>


Der readStr Befehl
readStr                                           Ein / Ausgabe

Signatur:	string   →  string

Aufruf:	readStr (string)

Rückgabewerte:	liefert die Zeichenkette, welche der Benutzer nach

der Eingabeaufforderung string eingibt.

Beschreibung:

Im Gegensatz zur Funktion read, kann man mit "readStr" die Eingaben des Benutzers selbst auswerten, falls erforderlich. Eine automatische Auswertung und Typzuweisung wird nicht vorgenommen, stattdessen liefert "readStr" die Zeichenkette zurück, welche der Benutzer eingibt. Zur Eingabe von Objekten benutze man die Funktion read.

Beispiel:

>Sinn := readStr ("Was ist fuer Dich der Sinn im Leben: ");

Was ist fuer Dich der Sinn im Leben: Ein Buch schreiben,

>Sinn:= Sinn + readStr("Was noch: ");

   Was noch: ein Kind zeugen,

   >Sinn:= Sinn + readStr("Jetzt vielleicht mal was spannendes: ");

   Jetzt vielleicht mal was spannendes:  einen Baum pflanzen !!!

   >Sinn

   Result=  "Ein Buch schreiben, ein Kind zeugen, einen Baum pflanzen !!!"

   >


Der play Befehl
play                                         Ein / Ausgabe

Signatur:	segment   →  Λ

Aufruf:	play (segm)

Rückgabewerte:	keine

Beschreibung:

Die Funktion "play" spielt das angegebene Segment segm ab. Vorraussetzung hierfür ist, daß der Wiedergabe-Dämon installiert ist, welcher dann von "play" aufgerufen wird. Der Wiedergabe-Prozess läuft vollautomatisch ab und man braucht nur noch die Kopfhörer aufzusetzen, um in den Genuß seines entworfenen Segmentes zu kommen. Auf die gleiche Weise können auch Sequenzen mit "play" abgespielt werden. Zum Abspeichern eines Segmentes bzw. einer Sequenz, kann die Funktion saveAsMidi verwendet werden.

Beispiel:

>Musikfragment := [I=120 M=150 T=12  c d e a h c# d# h#]

Musikfragment

Result= [ I=120  M=150  T=12  c1/4 d1/4 e1/4 a1/4 h1/4 c#1/4 d#1/4 h#1/4  ]

>midPlay (Musikfragment)

Creating MIDI - file  U: \$temp\_tmp0.mid ... Done

Creating MIDI - file  U: \$temp\_tmp0.ply ... Done

>


Der while Befehl
while                                           Kontrollfunktionen

Signatur:	expr-block × stmt-block  →  Λ

Aufruf:	while (cond-block, body-block)

Rückgabewerte: 	keine

Beschreibung:

Eine "while" - Schleife wird solange ausgeführt, wie die Auswertung von cond-block den Wert TRUE ergibt. Falls cond-block TRUE liefert, wird  der Schleifenkörper body-block ausgeführt.

Beispiel:

>z:=1770; c:=[c]; Opus:=[ ]

>while( `z<1827' ,  `Opus:=Opus+transp(c,rndUniform(0,15)); z:=z+1' );

>Opus

Result= [ I=80 M=100 T=0 a#1/4 f1/4 d#1/4 c2/4 f1/4 f#1/4 d1/4 f#1/4 a1/4 c#2/4 c2/4 c#2/4 a#1/4 d2/4 a#1/4 d2/4 g#1/4 d#1/4 e1/4 c#1/4 g#1/4 h1/4 d#1/4 c2/4 c2 /4 ]+[ I=80 M=100 T=0 g1/4 c#1/4 d1/4 c1/4 d#2/4 f#1/4 g#1/4 d#1/4 c#2/4 d1/4 h1/4 c#1/4 c#2/4 h1/4 g1/4 d1/4 c#1/4 d2/4 d#2/4 c1/4 h1/4 e1/4 c#2/4 f1/4 f#1/4 ]+[ I=80 M=100 T=0 d1/4 a#1/4 g#1/4 d#1/4 e1/4 g#1/4 c1/4 ]

>


Das Systemkommando abort
abort                                           Systemkommandos

Signatur:	Λ  →  Λ

Aufruf:	abort ( )

Rückgabewerte:	keine

Beschreibung:

Mit  dem Kommando "abort" kann eine Programmausführung abgebrochen werden. Ein Abbruch des gerade laufenden Programms ist auch innerhalb von Funktionen und Makros zugelassen. Das SALIERI-System gibt nach nach Aufruf von abort( ) eine entsprechende Meldung aus und kehrt (auch bei tiefer geschachtelten Programmen) zurück in die nächste Kommandozeile des Interpreters. "abort" eignet sich gut zur Fehlersuche innerhalb von größeren Proygrammen.

Beispiel:

>write("Bis hierher"); abort( ); write("und nicht weiter")

Bis hierher

Aborted in line 0.

>

Beispiel für den Abbruch einer Funktion:

Abenteuer:=FUNC(1,`

  write("Du stehst in einer staubigen Arena, wo ein Mannmitschlips");

  write("ein Glücksrad betreibt. Folgende Zahlen stehen zur Auswahl:");

  write( ); abort( );

  write("1: Höhlenbär mit Hirse");

  write("2: Eisbären und Rentierschlittenvermieter");

  write("4: Eiswurm plus ein Stern der Klasse C");

  write("6: Schneekrokodil im Nerz-Cape");

  write("7: Eiszombie-Paranoia);

  write("5: Gletschergiraffe, der Mond und ein Bündel Kopfkissen");

  write("9: Schneewittchen unter einer übelriechenden Wolke");

  write("0: Drehe noch einmal");

return($1)')

>Abenteuer(3)

Du stehst in einer staubigen Arena, wo ein Mannmitschlips

ein Glücksrad betreibt. Folgende Zahlen stehen zur Auswahl:

Aborted in function "Abenteuer", line 4.

>


Die Reihenoperation + (Konkatenation)
+  (Konkatenation)    Reihenoperationen / Stringoperationen

Signatur:	series × series  →  series

Aufruf:	series + series

Rückgabewerte:	keine

Beschreibung:

Die Konkatenation "+" hängt zwei reihenförmig organisierte Objekte aneinander. Da wären also zu nennen: Zeichenketten, Notensequenzen und Listen, die jeweils  miteinander verkettet werden können.

Beispiel:

>Parmenides:="Im Unterschied zu Parmenides war fuer"

>Beethoven:=" Beethoven die Schwere offenbar etwas Positives"

>write(Parmenides+Beethoven)

Im Unterschied zu Parmenides war fuer Beethoven die Schwere offenbar etwas Positives

>Entschluss:=LIST("Der schwer gefasste Entschluss ist verbunden")

>Schicksal:=LIST(" mit der Stimme des Schicksals (Es muss sein)")

>write(Entschluss+Schicksal)

LIST("Der schwer gefasste Entschluss ist verbunden"," mit der Stimme des Schicksals (Es muss sein)")

>Es_muss_sein1:=[a/4 c2/2 g2/2]

>Es_muss_sein2:=[_/2 _/4 g/4 h&/2 f/2]  (* L.v.Beethoven op.131, 7.Satz *)

>write(Es_muss_sein1 + Es_muss_sein2)

[ I=80 M=100 T=0 a1/4 c2/2 g2/2 _/2 _/4 g1/4 a#1/2 f1/2 ]

>


Die Reihenoperation infix
infix                             Reihenoperationen / Stringoperationen

Signatur:	series × integer × integer  →  series

Aufruf:	infix (series , integer1, integer2)

Rückgabewerte:	liefert Ausschnitt von series

Beschreibung:

Die Reihenoperation "infix", ist auf Zeichenketten, Notensequenzen und Listen anwendbar. Sie liefert den Auschnitt von series, der bei integer1 beginnt und integer2 Elemente lang ist. Man beachte, daß für positive integer2 nach rechts gezählt wird und für negative nach links. "Infix" akzeptiert Längenangaben integer2, die über die letzte (bzw. erste) Position des Objektes hinausragen, in diesem Falle wird die Längenangabe so interpretiert, als würde sie gerade bis zum Beginn  (bzw. Ende) des Objektes reichen. Wenn integer1 eine ungültige Position enthält (zu groß oder zu klein), wird  ""  als Ergebnis zurückgegeben. SALIERI bietet noch eine vereinfachte Schreibweise für "infix" in folgender Notation an: series(integer1, integer2)

Beispiel:

>infix("Musik ist politisch verdaechtig, entgegnete Settembrini", 20,400)

Result= " verdaechtig, entgegnete Settembrini"

>infix("Form ist ete-pe-tete !",40,-20) (* integer1 hat ungueltige Position *)

Result= ""

>Zauberberg:=LIST("Hans Castorp" , "Naphta", "Behrens" ,"Madame Chauchat")

>infix (Zauberberg, 3, -2)

Result= LIST("Naphta","Behrens")

>wohl_temperiert := [c0 e0 g0 c1 e1 g0 c1 e1] (* J.S.Bach BWV 846 , 1.Takt *)

>infix (wohl_temperiert,2,3)

Result= [ I=80 M=100 T=0 e0/4 g0/4 c1/4 ]

>Richard.III:=("Ein Pferd!","Ein Pferd!","Mein Koenigreich fuer´n Pferd")

>Richard.III(1,2)	(* Vereinfachte Schreibweise *)

Result= LIST("Ein Pferd!","Ein Pferd!")

>


Die Reihenoperation ins
ins                                Reihenoperationen / Stringoperationen

Signatur:	series × series × integer  → series

Aufruf:	ins (series1, series2 , integer)

Rückgabewerte:	liefert series; entstehend aus series2 eingefügt in

series1

Beschreibung:

Die Reihenoperation "ins", ist auf Zeichenketten, Notensequenzen und Listen anwendbar. Sie liefert den Objekttyp series, welcher durch Einfügen von series2 in series1 unmittelbar vor Position integer entsteht; Integer muß zwischen 1 und length(series1)+1 liegen. Wird beim Aufruf von "ins" eine ungültige Position integer angegeben, bleibt series1 unverändert und es erscheint eine Fehlermeldung.

Beispiel:

>Gewicht:="Ist das Schwere schrecklich und das Leichte herrlich ?"

>write(ins(Gewicht, "wirklich ", 17))

Ist das Schwere wirklich schrecklich und das Leichte herrlich ?

>ins("Atlas traegt das Himmelszelt","auf seinen Schultern",45)

Error in command-line: Wrong startposition

(occured while executing function "ins")

>Antwort:=LIST("Je schwerer das Gewicht" , "Leben der Erde.")

>write(ins(Antwort, LIST(", desto naeher ist unser"),2))

LIST("Je schwerer das Gewicht",", desto naeher ist unser","Leben der Erde.")

>falsche_Tonleiter:= [c d f g a h c]

>richtige_Tonleiter:= ins (falsche_Tonleiter, [e], 3)

>write(richtige_Tonleiter)

[ I=80 M=100 T=0 c1/4 d1/4 e1/4 f1/4 g1/4 a1/4 h1/4 c1/4 ]

>


Die Reihenoperation del
del                                Reihenoperationen / Stringoperationen

Signatur:	series × integer × integer  →  series

Aufruf:	del (series , int1, int2)

Rückgabewerte:	liefert series; löscht int2 Elemente; beginnt bei int1

Beschreibung:

Die Reihenoperation "del", ist auf Zeichenketten, Notensequenzen und Listen anzuwenden. Sie liefert den Objekttyp series, welcher durch Löschen von int2 Elementen, beginnend mit dem Element an Position int1 entsteht. Für positive int2 wird nach rechts gezählt, für negative nach links. Es werden auch Längenangaben int2 akzeptiert, welche über die letzte (bzw. erste) Position des Objektes hinausragen. In diesem Falle wird die Längenangabe so interpretiert, als würde sie gerade bis zum Beginn (bzw. Ende) des Objektes reichen. Wird beim Aufruf von "del" eine ungültige Position int1 angegeben, bleibt series unverändert und es erscheint eine Fehlermeldug.

Beispiel:

>Timmy:="Hey Mami, ich glaube Lassie will uns etwas sagen."

>del (Timmy, 22, 7)

Result= "Hey Mami, ich glaube will uns etwas sagen."

>Stimmt:="Richtig, denn am Forellenweiher ist das Atomkraftwerk explodiert"

>del (Stimmt, -3,12)

Error in command-line: Wrong startposition

(occured while executing function "del")

>del ("Ploetzlich fallen Lassie alle Haare aus",11,-16)

Result= "fallen Lassie alle Haare aus"

>Komponisten:=LIST("Mozart","Haydn", [c g h] ,"Beethoven","Ernst Mosch")

>del (Komponisten, 1,4)

Result= LIST("Ernst Mosch")

>Scarborough_Fair:=[a0/2 a0/4 e1/8 e1*3/8 e1/4 h0*3/8 c1/8 h0/4 a0*3/4]

>del(Scarborough_Fair, 4,3)

Result= [ I=80 M=100 T=0 a0/2 a0/4 e1/8 c1/8 h0/4 a0*3/4 ]

>


Die Reihenoperation length
length                          Reihenoperationen / Stringoperationen

Signatur:	series  → integer

Aufruf:	length (series) oder # (series)

Rückgabewerte:	liefert die Länge von series

Beschreibung:

Die Reihenoperation "length" ist auf Listen, Sequenzen ind Zeichenketten anzuwenden. Für "length" kann auch gleichbedeutend das Symbol "#" benutzt werden. Der Rückgabewert der Funktion, ist die Länge des jeweiligen Objekttyps series. Es ist zu beachten, daß der Operator "#" stärker bindet als "*" und "/".

Beispiel:

>Der_Wald:="Ich sah viele tote Baueme, am Rand der Autobahnen"

>length(Der_Wald)

Result= 49

># "Die trugen keine Blaetter mehr, ach so es waren Tannen"

Result= 54

># LIST( "Das Rheingold","DieWalkuere","Siegfried","Goetterdaemmerung")

Result= 4

>Opus67:=[_/8 g/8 g/8 g/8 e&/2]

>length (Opus67)

Result= 5

>


Die Reihenoperation posNext
posNext                       Reihenoperationen / Stringoperationen

Signatur:	series × series × integer  → series

Aufruf:	posNext (series1, series2 , integer)

Rückgabewerte:	liefert Position des nächsten Auftretens von string2 in

string1

Beschreibung:

Die Reihenoperation "posNext" ist auf Zeichenketten, Listen und Sequenzen anzuwenden. Sie liefert die Position des nächsten Auftretens von string2 in string1, wobei ab Position integer nach rechts gesucht wird. Wenn kein Auftreten entdeckt wurde, gibt "posNext" den Wert 0 zurück. Ebenfalls den Wert 0 erhält man, wenn "posNext" mit einer ungültigen Position integer aufgerufen wurde.

Beispiel:

>Macbeth:="Leben ist nur ein wandelnd Schattenbild;"

>posNext(Macbeth, "ist nur", 1)

Result= 7

>Macbeth2:="Ein armer Komoediant, der spreizt und knirscht"

>posNext(Macbeth2,"Komoediant",17) (* kein Auftreten von "Komoediant" *)

Result= 0

>Wieso:="Warum sind Sie denn Ingenieur geworden?"

>posNext(Wieso,"Ingenieur",-12) (* ungueltige Position *)

Result= 0

>Descartes:=LIST("Ich zweifel",3>5 ,"also denke ich.","Ich denke also bin ich")

>posNext(Descartes, 3>5,2)

Error in command-line: Type mismatch

(occured while executing function "posNext")

>posNext(Descartes, LIST(3>5),2)

Result= 2

>Nachtmusik:=[M=80 e2/8 _ e2 _ e2*3/8 g2/8 f2 d2 f2 a2 g2*3/16 e2/16 g2/8]

>posNext(Nachtmusik,[g2/8],2)

Result= 6

>


Der Befehl it
it                                                  Systemkommandos

Signatur:	Λ  → object

Aufruf:	it ( )

Rückgabewerte:	liefert das letzte ausgegebene Ergeb. einer Auswertung

Beschreibung:

Über die Funktion "it" erhält der Benutzer das letzte ausgegebene Ergebnis einer Auswertung. Es ist zu beachten, das mit "it" nur vollständig ausgewertete Ausdrücke abzurufen sind, eine fehlerhafte Auswertung wird von "it" also nicht akzeptiert. Nach Starten des Systems enthält "it" folgende Terminale: " :-) ".

Beispiel:

Loading workspace from N:\SALIERI\streiche\SALIERI.wsp ... Done

>it()

Result= ":-)"

>"W.A.Mozart - Klarinnettenkonzert, KV 622, 2.Satz - Adagio"

Result= "W.A.Mozart - Klarinnettenkonzert, KV 622, 2.Satz - Adagio"

>KV622:=it()

>write(KV622)

W.A.Mozart - Klarinnettenkonzert, KV 622, 2.Satz - Adagio

>Wenn jetzt keine Fehlermeldung kommt, dann hast Du 3 Wuensche frei

Error in command-line: Unknown identifier: Wenn

>it()

Result= "W.A.Mozart - Klarinnettenkonzert, KV 622, 2.Satz - Adagio"

>


Der Befehl dir
dir                                              Systemkommandos

Signatur:	string  → Λ

Aufruf:	dir (maskstr)

Rückgabewerte:	liefert Namen aus akt. Verzeich. worauf maskstr paßt

Beschreibung:

Das Kommando "dir", gibt genau die Namen der Dateien aus dem aktuellen Arbeitsverzeichnis aus, auf welche die Schablone maskstr paßt.

Beispiel:

>dir ("sal*")

Directory-entries matching SAL*:

SALIERI.LOG

SALIERI.WSP

SALENV.EXE

SALIERI.EXE

>


Der Befehl exec
exec                                           Systemkommandos

Signatur:	string  → Λ

Aufruf:	exec ("filename")

Rückgabewerte:	keine

Beschreibung:

Mit dem Befehl "exec" lassen sich SALIERI-Programmdateien ausführen. Dabei wird mit exec("filename") die Datei filename.SAL aus dem aktuellen Arbeitsverzeichnis ausgeführt. Die Endung .SAL wird automatisch an den Dateinamen gehangen.

Beispiel:

>exec("bsp_exec.sal")

Executing bsp_exec.sal ...

[ I=80 M=100 T=0 d#1/4 g#1/4 f1/4 c2/4 c#1/4 a#1/4 ]

[ I=80 M=100 T=0 e1/4 a1/4 f#1/4 c#2/4 d1/4 h1/4 ]

[ I=80 M=100 T=0 f1/4 a#1/4 g1/4 d2/4 d#1/4 c2/4 ]

[ I=80 M=100 T=0 f#1/4 h1/4 g#1/4 d#2/4 e1/4 c#2/4 ]

[ I=80 M=100 T=0 g1/4 c2/4 a1/4 e2/4 f1/4 d2/4 ]

>


Der Befehl delete
delete                                        Systemkommandos

Signatur:	object  → Λ

Aufruf:	delete (name)

Rückgabewerte:	keine; entfernt Objekt name aus dem Workspace

Beschreibung:

Mit dem Kommando "delete" können Objekte mit dem Namen name aus dem Workspace entfernt werden. Wenn der entsprechende Name name nicht gefunden wird erscheint eine Fehlermeldung, ansonsten wird das Objekt unwiederruflich gelöscht. Zum Entfernen mehrerer Objekte bietet SALIERI das Kommando deleteAll an.

Beispiel:

>Anschauungsobjekt:="Irgendetwas" 	(* Objekt erzeugen 	*)

>delete (Anschauungsobjekt)          	(* Objekt loeschen 	*)

Deleted object Anschauungsobjekt.

>


name 	         Systemkommandos

Signatur:	Λ  → Λ

Aufruf:	exit ( )

Rückgabewerte:	keine

Beschreibung:

Blautext.

Beispiel:

>exit ( )


name                                 Systemkommandos

Signatur:	Λ  → Λ

Aufruf:	exit( )

Rückgabewerte:	keine

Beschreibung:

Blautext.

Beispiel:

>exit ( )


Die musikalische Funktion transp
transp                                     Musikalische Funktionen

Signatur:	sequence × integer  → sequence

Aufruf:	transp (sequence, integer)

Rückgabewerte:	liefert um integer Halbtonschr. transponierte sequence

Beschreibung:

Mit der musikalischen Funktion "transp" kann eine Sequenz sequence, um integer Halbtonschritte transponiert werden. Eine positive Zahl integer transponiert hierbei nach oben, während negative integer um die entsprechenden Halbtonschritte nach unten transponieren. Diese Funktion ist auch auf Segmente anzuwenden, wobei die Transposition für jede Stimme einzeln durchgeführt wird. Erweiterte Transpositionsfunktionen sind transpTonal und transcr , welche die tonale Transposition bzw. eine Transkription durchführen.

Beispiel:

>C_DUR:= [c d e f g a h]

>transp(C_DUR, 5)

Result= [ I=80 M=100 T=0 f1/4 g1/4 a1/4 a#1/4 c2/4 d2/4 e2/4 ]

>transp(C_DUR,12)

Result= [ I=80 M=100 T=0 c2/4 d2/4 e2/4 f2/4 g2/4 a2/4 h2/4 ]

>transp(C_DUR,-7)

Result= [ I=80 M=100 T=0 f0/4 g0/4 a0/4 a#0/4 c1/4 d1/4 e1/4 ]

>


Die musikalische Funktion expand
expand                                   Musikalische Funktionen

Signatur:	sequence × integer1 × integer2  → sequence

Aufruf:	expand (sequence, integer1, integer2)

Rückgabewerte:	streckt sequence um Faktor integer1 / integer2

Beschreibung:

Mit der Funktion "expand", läßt sich eine gegebene Sequenz sequence, mithilfe des Faktors integer1 / integer2 zeitlich strecken bzw. stauchen. Dabei wird jede Note der Sequenz, deren relative Tondauer durch e / d beschrieben wird, in der Form e*integer1 / d*integer2 ersetzt. Diese Funktion ist auch auf Segmente anzuwenden, wobei die Expansion für jede Stimme einzeln durchgeführt wird.

Beispiel:

>C_DUR:=[c/8 d/17 e/12 f*3/8 g*7/5 h]

>expand(C_DUR, 3, 4)

Result=[I=80 M=100 T=0 c1*3/32 d1*3/68 e1/16 f1*9/32 g1*21/20 h1*21/20]

>expand(C_DUR, 4, 3)

Result= [ I=80 M=100 T=0 c1/6 d1*4/51 e1/9 f1/2 g1*28/15 h1*28/15 ]

>expand(C_DUR, 1, 2)

Result= [ I=80 M=100 T=0 c1/16 d1/34 e1/24 f1*3/16 g1*7/10 h1*7/10 ]

>expand(C_DUR, 1, 1)

Result= [ I=80 M=100 T=0 c1/8 d1/17 e1/12 f1*3/8 g1*7/5 h1*7/5 ]

>expand(C_DUR, 2, 1)

Result= [ I=80 M=100 T=0 c1/4 d1*2/17 e1/6 f1*3/4 g1*14/5 h1*14/5 ]

>


Die musikalische Funktion retro
retro                                       Musikalische Funktionen

Signatur:	sequence  → sequence

Aufruf:	retro (sequence)

Rückgabewerte:	liefert die zeitliche Umkehrung von sequence

Beschreibung:

Die Funktion "retro" liefert zu einer gegebenen Sequenz sequence die zeitliche Umkehrung ("Krebs"). Es ist zu beachten, daß diese Funktion auch auf Segmente angewandt werden kann, wobei dann jeweils jede Stimme einzeln umgekehrt wird.

Beispiel:

>sq:=[a/8 c/4 d g f# h/16]

>retro(sq)

Result= [ I=80 M=100 T=0 h1/16 f#1/4 g1/4 d1/4 c1/4 a1/8 ]

>retro(retro(sq))  (* Zweimal umkehren ergibt Ausgangssequenz *)

Result= [ I=80 M=100 T=0 a1/8 c1/4 d1/4 g1/4 f#1/4 h1/16 ]

>seg:={[a h c], [c d e]}

>retro(seg)

Result= SEGM([ I=80 M=100 T=0 c1/4 h1/4 a1/4 ],[ I=80 M=100 T=0 e1/4 d1/4 c1/4 ])

>


Die musiklaische Funktion cresc
cresc                                       Musikalische Funktionen

Signatur:	sequence × integer1 × integer2  → sequence

Aufruf:	cresc (sequence, integer1, integer2)

Rückgabewerte:	neuer Intensitätsverlauf anhand integer1, integer2

Beschreibung:

Durch die Funktion "cresc" wird der Intensitätsverlauf (Lautstärke) der Sequenz sequence beeinflußt. Dabei wird anhand von interger1, integer2 ein linearer Intensitätsverlauf erzeugt. Ein Verlauf mit zunehmender Intensität ist dabei genauso möglich, wie  einer mit abnehmender. Diese Funktion ist auch auf Segmente anzuwenden, wobei die Operation für jede Stimme einzeln durchgeführt wird. Die Paramter interger1, integer2 dürfen nur zwischen 0 und 127 liegen, da sonst ein falscher Verlauf berechnet wird.

Beispiel:

>sq:=[a/8 c/4 d g]

>cresc(sq,12,120)

Result= [ I=12 M=100 T=0 a1/8 I=39 c1/4 I=66 d1/4 I=93 g1/4 ]

>cresc(sq,120,12)

Result= [ I=120 M=100 T=0 a1/8 I=93 c1/4 I=66 d1/4 I=39 g1/4 ]

>


Die musikalische Funktion accel
accel                                        Musikalische Funktionen

Signatur:	sequence × integer1 × integer2  → sequence

Aufruf:	accel (sequence, integer1, integer2)

Rückgabewerte:	neuer Metrumsverlauf anhand  integer1, integer2

Beschreibung:

Mit der Funktion "accel" wird der Metrumsverlauf der Sequenz sequence beeinflußt. Die Funktion erzeugt einen linearen Metrumsverlauf, welcher von integer1 nach integer2 läuft. Diese Funktion ist auch auf Segmente anzuwenden, wobei der Metrumsverlauf für jede Stimme einzeln berechnet wird. Es ist darauf zu achten, daß integer1,integer2 zwischen 1 und 255 liegen, da sonst ungewollte Werte erzeugt werden.

Beispiel:

>sq:=[a/8 c/4 d g]

>accel(sq,12,120)

Result= [ I=80 M=12 T=0 a1/8 M=39 c1/4 M=66 d1/4 M=93 g1/4 ]

>accel(sq,200,90)

Result= [ I=80 M=200 T=0 a1/8 M=172 c1/4 M=145 d1/4 M=117 g1/4 ]

>


Die musikalische Funktion instr
instr                                        Musikalische Funktionen

Signatur:	sequence × integer  → sequence

Aufruf:	instr (sequence, integer)

Rückgabewerte:	setzt Klangfarbe der Sequenz sequence

Beschreibung:

Mit der Funktion "instr" wird dir Sequenz sequence so verändert, daß deren Klangfarbe mithilfe von integer durchgehend gesetzt wird. Da es sich hierbei um ein MIDI-Instrument handelt, muß integer zwischen 0 und 127 liegen.  Diese Funktion ist auch auf Segmente anzuwenden, wobei die Klangfarbe für jede Stimme einzeln gesetzt wird.

Beispiel:

>instr(sq)

>instr(sq,100)

Result= [ I=80 M=100 T=100 a1/4 g1/4 h1/4 c1/4 ]

>instr(sq,42)

Result= [ I=80 M=100 T=42 a1/4 g1/4 h1/4 c1/4 ]

>


Die musikalische Funktion parts
parts                                       Musikalische Funktionen

Signatur:	segment → integer

Aufruf:	parts (segment)

Rückgabewerte:	liefert die Anzahl der Stimmen von segment

Beschreibung:

Die Funktion "parts" gibt die Anzahl der Stimmen vom Segment segment zurück. Gleichbedeutend für parts(segment) kann auch #segment geschrieben werden. Die Stimmen eines Segments sind im übrigen mit 1...n numeriert.

Beispiel:

>seg:={[c d e],[a #d e],[h g]}

>parts(seg)

Result= 3

>#seg

Result= 3

>


Die musikalische Funktion part
part                                         Musikalische Funktionen

Signatur:	segment × integer  → sequence

Aufruf:	part (segment, integer)

Rückgabewerte:	liefert Stimme integer von segment

Beschreibung:

Die Stimmen eines Segments sind mit 1...n durchnumeriert. Mit "part" kann eine Stimme integer des Segments segment selektiert werden. Bei dieser ausgewählten Stimme handelt es sich dann um eine Sequenz sequence. Falls integer > n oder integer < 1 wird die leere Sequenz zurückgegeben. Eine vereinfachte und übersichtlichere Notation wird von SALIERI zusätzlich angeboten: segment (integer).

Beispiel:

>seg:={[c d e],[a #d e],[h g]}

>part(seg,2)

Result= [ I=80 M=100 T=0 a#1/4 d1/4 e1/4 ]

>part(seg,3)

Result= [ I=80 M=100 T=0 h1/4 g1/4 _/4 ]

>part(seg,63)

Result= [ ]

>seg(1)

Result= [ I=80 M=100 T=0 c1/4 d1/4 e1/4 ]

>


Die musikalische Funktion poly
poly                                         Musikalische Funktionen

Signatur:	segment1 × ... × segmentn  → segment

Aufruf:	poly (segment1, ..., segmentn)

Rückgabewerte:	verbindet segment1, ..., segmentn zu Segment segment

Beschreibung:

Die Funktion "poly" kombiniert die Segmente segment1, ..., segmentn zu einem neuen Segment segment. Sämtliche Einzelstimmen von segment1, ..., segmentn beginnen gleichzeitig und laufen parallel ab. Alle Stimmen werden am Ende gegebenenfalls mit Pausen aufgefüllt um sicherzustellen, daß die Stimmen des neuen Segments gleiche Dauer haben. Bei der Eingabe von segment1,..., segmentn können beliebige Segmente und auch Sequenzen angegeben werden. Die Sequenzen werden dann wie einstimmige Segmente behandelt. SALIERI bietet noch eine weitere Schreibweise für "poly" an. Die Notation des geschweiften Klammerpaars für mehrstimmige Notensegmente ist ein Synonym für die "poly"-Schreibweise, d.h. es können z.B. Variablennamen oder Ausdrücke verwendet werden.

Beispiel:

>seg1:={[c d e],[f g# a]}; seg2:={[h],[f],[g]}; seq:=[f g h]

>poly(seg1,seg2,seq)

Result= SEGM([ I=80 M=100 T=0 c1/4 d1/4 e1/4 ],[ I=80 M=100 T=0 f1/4 g#1/4 a1/4],[ I=80 M=100 T=0 h1/4 _/2 ],[ I=80 M=100 T=0 f1/4 _/2 ],[ I=80 M=100 T=0 g1/4 _/2 ],[ I=80 M=100 T=0 f1/4 g1/4 h1/4 ])

>poly(seg2,seq)

Result= SEGM([ I=80 M=100 T=0 h1/4 _/2 ],[ I=80 M=100 T=0 f1/4 _/2 ],[ I=80 M=100 T=0 g1/4 _/2 ],[ I=80 M=100 T=0 f1/4 g1/4 h1/4 ])

>{[c d e],seg2, transp(seq,-12)}	(*Kurzschreibweise; Ausdrücke möglich *)

Result= SEGM([ I=80 M=100 T=0 c1/4 d1/4 e1/4 ],[ I=80 M=100 T=0 h1/4 _/2 ],[ I=80 M=100 T=0 f1/4 _/2 ],[ I=80 M=100 T=0 g1/4 _/2 ],[ I=80 M=100 T=0 f0/4 g0/4 h0/4 ])

>


Die musikalische Funktion + (Konkatenation)
+ (Konkatenation)                Musikalische Funktionen

Signatur:	segment1 × segment2  → segment

Aufruf:	segment1 + segment2

Rückgabewerte:	hängt zwei Segmente aneinander

Beschreibung:

Die Konkatenation "+" komponiert die Segmente segment1, segment2 miteinander. Dieses zeitliche Aneinanderhängen geschieht so, indem die erste Stimme von segment2 an die erste Stimme von segment1 gefügt wird und so fort.  (Die Stimmen eines Segmentes haben prinzipiell die gleiche Dauer, was notfalls durch hinzufügen von Pausen ausgeglichen wird). Wenn die Stimmenanzahl von segment1 und segment2 unterschiedlich ist, so wird das entsprechende Segment mit einer leeren Stimme aufgefüllt. Diese Funktion ist im übrigen auch auf Sequenzen definiert. Ebenfalls möglich ist die Verkettung einer Sequenz mit einem Segment.

Beispiel:

>seg1:={[c d],[e f]}; seg2:={[g a]}

>seg1+seg2

Result= SEGM([ I=80 M=100 T=0 c1/4 d1/4 g1/4 a1/4 ],[ I=80 M=100 T=0 e1/4 f1/4 _/2 ])

>seq:=[h c e]

>seg1+seq

Result= SEGM([ I=80 M=100 T=0 c1/4 d1/4 h1/4 c1/4 e1/4 ],[ I=80 M=100 T=0 e1/4 f1/4 _*3/4 ])

>


Die Deskriptorfunktion isRest
isRest                                      Musikalische Funktionen

Signatur:	sequence × integer  → boolean

Aufruf:	isRest (sequence, integer)

Rückgabewerte:	liefert TRUE wenn Note an Pos. integer Pause ist

Beschreibung:

Diese Deskriptorfunktion liefert TRUE, wenn die Note an Position integer der Sequenz sequence eine Pause ist. Ansonsten wird FALSE zurückgegeben.

Beispiel:

>seq:=[g# d& f/8 _/8 a#/16]

>isRest(seq,3)

Result= FALSE

>isRest(seq,4)

Result= TRUE

>


Die Deskriptorfunktion getPitch
getPitch                                  Musikalische Funktionen

Signatur:	sequence × integer  → list

Aufruf:	getPitch (sequence, integer)

Rückgabewerte:	liefert Tonhöhe von Note an Pos. integer als Liste

Beschreibung:

Mit getPitch kann die Tonqualität und die Oktave einer Note an Position integer der Sequenz sequence abgefragt werden. Der Rückgabewert ist eine Liste mit dem Erscheinungsbild LIST(integer1,integer2,integer3). Die Tonqualität wird hierbei durch integer1 beschrieben, wobei 0,1,2, . . . für c, c#, d, . . . stehen. Die Oktave erhält man aus integer2 und hat einen Wert zwischen -4 und +6. Falls an Position integer eine Pause steht, wird der Wert -1 zurückgegeben. Das dritte Element der Liste gibt an, um wieviele Halbtonschritte der Notenwert durch die Vorzeichen verändert wurde. Positive Zahlen stehen hier für Erhöhung und negative Zahlen für Erniedrigung durch Vorzeichen.

Beispiel:

>seq:=[c##1 c&1 _ d-2 e3]

>getPitch(seq,1)

Result= LIST(2,1,2)

>getPitch(seq,2)

Result= LIST(11,0,-1)

>getPitch(seq,3)

Result= LIST(-1,0,0)

>getPitch(seq,4)

Result= LIST(2,-2,0)

>getPitch(seq,5)

Result= LIST(4,3,0)

>


Die Deskriptorfunktion getPitchTona
getPitchTonal                        Musikalische Funktionen

Signatur:	sequence × sequence × integer  → list

Aufruf:	getPitchTonal (sequence, scale, position)

Rückgabewerte:	liefert Liste der Form (scalestep, alteration)

Beschreibung:

Mit "getPitchTonal" kann die relative Tonhöhe einer Note an Position position der Sequenz sequence bezüglich einer frei definierbaren Tonleitersequenz scale bestimmt werden. Die Listenelemente des Rückgabewertes sind Integerwerte, wobei scalestep die Stufe der gefragten Note beschreibt, die sie in Bezug auf die Tonleiter scale einnimmt. Die erste Note der Tonleiter hat den Stufenwert 0, die zweite den Stufenwert 1 und so weiter. Tiefere Noten, als die in der Tonleitersequenz definierten, erhalten entsprechend negative Werte. alteration gibt die Erhöhung bzw. Erniedrigung durch Vorzeichen an. Die Note auf Tonleiterstufe scalestep ist erniedrigt, wenn alteration negativ ist, bzw. erhöht, falls alteration positiv ist. Der Betrag von alteration bestimmt die Anzahl der Halbtonschritte der Alteration. Kommt die untersuchte Note nicht in der Tonleiter scale vor, liegt die Position position außerhalb der Sequenz sequence oder befindet sich bei position eine Pause, so wird die leere Liste als Ergebnis zurückgeliefert.

Beispiel:

>arabischMoll:=[c1 d& e f a& h&]

>getPitchTonal([c1 d& e h&0 a& c1], arabischMoll, 1)

Result= LIST(0,0)

>getPitchTonal([c1 d& e h&0 a& c1], arabischMoll, 1)

Result= LIST(0,0)

>getPitchTonal([c1 d& e h&0 a& c1], arabischMoll, 2)

Result= LIST(1,0)

>getPitchTonal([c1 d& e h&0 a& c1], arabischMoll, 4)

Result= LIST(-1,0)

>getPitchTonal([c1 d& e h&0 a& c1], arabischMoll, 5)

Result= LIST(-2,0)

>getPitchTonal([c1 d& e h&0 a& c1], arabischMoll, 32)

Result= LIST()

>getPitchTonal([h1], arabischMoll, 1)

Result= LIST(5,1)

>


Die Deskriptorfunktion ambitus
ambitus                                  Musikalische Funktionen

Signatur:	sequence → integer

Aufruf:	ambitus (sequence)

Rückgabewerte:	liefert den Tonumfang von sequence

Beschreibung:

Mithilfe von "ambitus" kann der Tonumfang der Sequenz sequence ermittelt werden. Hierzu wird der Abstand zwischen dem höchsten und tiefsten Ton der Sequenz berechnet. Dieser Abstand wird als Anzahl von Halbtonschritten zurückgegeben.

Beispiel:

>seq:=[c1 c0  _ d-2 e3 f4 g-3]

>ambitus(seq)

Result= 82

>seq:=[c1 c0 g-3]

>ambitus(seq)

Result= 41

>seq:=[c1 c0]

>ambitus(seq)

Result= 12

>seq:=[c1 c1]

>ambitus(seq)

Result= 0

>


Die Deskriptorfunktion duration
duration                                 Musikalische Funktionen

Signatur:	sequence → list

Aufruf:	duration (sequence)

Rückgabewerte:	liefert die relative Dauer von sequence

Beschreibung:

Die Funktion "duration" liefert die relative der Sequenz sequence, wobei in der zurückgegebenen Liste LIST(integer1,integer2) der Zähler integer1 und der Nenner integer2 enthalten sind. Die relative Dauer der Sequenz ergibt sich aus der Addition der relativen Dauer aller Töne und Pausen. Zum Berechnen der absoluten Tondauer verwende man die Funktion time.

Beispiel:

>seq:=[a f g c/8]

>duration(seq)

Result= LIST(7,8)

>seq:=[a f/8 g c/8]

>duration(seq)

Result= LIST(5,8)

>seq:=[a/12 f/7 g/9 c/6]

>duration(seq)

Result= LIST(127,252)

>


Die Deskriptorfunktion time
time                                        Musikalische Funktionen

Signatur:	sequence → real

Aufruf:	time (sequence)

Rückgabewerte:	liefert die absolute Tondauer von sequence

Beschreibung:

Die absolute Tondauer wird mithilfe von "time" errechnet. Hierbei wird der Metrumsparameter der Sequenz sequence berücksichtigt. Im Gegensatz dazu steht die relative Tondauer duration

Beispiel:

>seq:=[a f g c/8]

>seq

Result= [ I=80 M=100 T=0 a1/4 f1/4 g1/4 c1/8 ]

>time(seq)

Result= 2.10000014

>seq:=[a f g c]

>seq

Result= [ I=80 M=100 T=0 a1/4 f1/4 g1/4 c1/4 ]

>time(seq)

Result= 2.40000010

>


Die Deskriptorfunktion getIntens
getIntens                                Musikalische Funktionen

Signatur:	sequence × integer  → integer

Aufruf:	getIntens (sequence, integer)

Rückgabewerte:	liefert Intensität der Note an Position integer

Beschreibung:

Die "getIntens" Funktion gibt die Intensität des Tons an Positon integer
aus. Es ist zu beachten, daß Pausen genauso behandelt werden wie Töne, also in SALIERI tatsächlich Intensität haben.

Beispiel:

>seq:=[a f  I=50 g I=120 c]

>seq

Result= [ I=80 M=100 T=0 a1/4 f1/4 I=50 g1/4 I=120 c1/4 ]

>getIntens(seq,1)

Result= 80

>getIntens(seq,3)

Result= 50

>getIntens(seq,4)

Result= 120

>seq:=[I=200 _ I=20 _]

>getIntens(seq,1)

Result= 200

>getIntens(seq,2)

Result= 20

>


Die Deskriptorfunktion getTempo
getTempo                               Musikalische Funktionen

Signatur:	sequence × integer  → integer

Aufruf:	getTempo (sequence, integer)

Rückgabewerte:	liefert Wert des Metrums an Position integer

Beschreibung:

Der Metrumsparameter der Sequenz sequence an Position integer läßt sich mithilfe von "getTempo" ermitteln. Zurückgegeben wird eine Metrumzahl zwischen 1 und 255, wobei diese Zahl die 1/4 Noten pro Minute angibt.

Beispiel:

>seq:=[a f M=70 g M=220 c]

>getTempo(seq,1)

Result= 100

>getTempo(seq,3)

Result= 70

>getTempo(seq,4)

Result= 220

>


Die Deskriptorfunktion getInstr
getInstr                                  Musikalische Funktionen

Signatur:	sequence × integer  → integer

Aufruf:	getInstr (sequence, integer)

Rückgabewerte:	liefert Wert der Klangfarbe an Position integer

Beschreibung:

Die Klangfarbe, welche an Position integer der Sequenz sequence steht, wird mittels "getInstr" geliefert. Bei der zurückgegebenen Zahl handelt es sich um die Programmnummer eines MIDI-Instruments, welche zwischen 0 und 127 liegt und vom dementsprechenden Wiedergabegerät abhängig ist..

Beispiel:

>seq:=[T=0 c T=12 d T=23 _]

>getInstr(seq,1)

Result= 0

>getInstr(seq,2)

Result= 12

>getInstr(seq,3)

Result= 23

>


Die Variationsfunktion invert
invert                                      Musikalische Funktionen

Signatur:	sequence → sequence

Aufruf:	invert (sequence)

Rückgabewerte:	liefert am Anfangston gespiegelte sequence

Beschreibung:

Die Funktion "invert" liefert die Sequenz sequence, welche durch Umkehren aller Intervalle, im Bezug zur ersten Note (Pausen werden prinzipiell ignoriert), aus der Eingabesequenz entsteht. Somit bleiben der Anfangston und die Intervallgrößen erhalten, während die Intervallrichtungen umgedreht werden. Entlang einer horizontal gedachten Achse im Notenbild, wobei vom ersten Ton ausgegangen wird, entsteht nach Bearbeitung mit "invert" eine Spiegelung an der Horizontalen. Diese Funktion läßt sich auch auf Segmente anwenden, wobei die Operation für jede Stimme einzeln ausgefürt wird. Eine Expansion der Intervallgrößen, welche sich auf den ersten Ton bezieht, läßt sich mit der Funktion intvExpand realisieren.

Beispiel:

>seq:=[_/8 g h d2 g1 g2]

>invert(seq)

Result= [ I=80 M=100 T=0 _/8 g1/8 d#1/8 c1/8 g1/8 g0/8 ]

>seq:=[_/8 g h d2 g-1 g-3]

>invert(seq)

Result= [ I=80 M=100 T=0 _/8 g1/8 d#1/8 c1/8 g3/8 g5/8 ]

>


Die Variationsfunktion intvExpand
intvExpand                            Musikalische Funktionen

Signatur:	sequence × integer  → sequence

Aufruf:	intvExpand (sequence, integer)

Rückgabewerte:	liefert sequence, Intervalle um integer

Halbtonschritte vergrößert

Beschreibung:

Gemessen am Anfangston (Pausen werden ignoriert), vergrößert bzw. verkleinert die Funktion "intvExpand", die Intervallgrößen der Sequenz sequence. Eine Vergrößerung der Intervalle erfolgt für positve integer, eine Verkleinerung für negative, um integer Halbtonschritte. Die Intervallrichtungen bleiben hierbei erhalten. Es ist zu beachten, daß kleine Sekunden nicht mehr weiter verkleinert werden, da sich sonst die Intervallrichtung ändern würde. Diese Funktion läßt sich auch auf Segmente anwenden, wobei die Operation für jede Stimme einzeln ausgefürt wird. Um die Intervallrichtungen umzukehren ist die Funktion invert vorgesehen.

Beispiel:

>seq:=[_/8 g h d2 g1 g2]

>intvExpand(seq,2)

Result= [ I=80 M=100 T=0 _/8 g1/8 c#2/8 f#2/8 a1/8 h2/8 ]

>intvExpand(seq,-2)

Result= [ I=80 M=100 T=0 _/8 g1/8 a1/8 a#1/8 f1/8 d#2/8 ]

>intvExpand(seq,-4)

Result= [ I=80 M=100 T=0 _/8 g1/8 g#1/8 a1/8 f#1/8 d2/8 ]

>


Die Variationsfunktion transpTonal
transpTonal                           Musikalische Funktionen

Signatur:	sequence × sequence × integer  → sequence

Aufruf:	transpTonal (sequence1, sequence2, integer)

Rückgabewerte:	transponiert sequence1 anhand von sequence2 tonal

um integer Leiterstufen

Beschreibung:

Die Funktion "transpTonal" liefert die Sequenz,  welche durch tonale Transposition um integer Leiterstufen aus sequence1 entsteht, wobei als Tonleiter sequence2 zugrundeliegt. Es wird also eine Verschiebung der Tonhöhen entlang der gegebenen Tonleiter sequence2 vorgenommen. Wenn nötig wird die Tonleiter durch eine Oktavierung in beide Richtungen fortgesetzt. Der Wert integer kann positive und negative Zahlen enthalten; somit kann in beide Richtungen geschoben werden. Tonqualitäten, welche in der Leiter nicht enthalten sind werden unverändert zurückgegeben, genauso wie Pausen. Eine Tonleiter ist prinzipiell nach aufsteigender Tonhöhe geordnet und ihr Umfang beträgt weniger als eine Oktave. Bei der Eingabe der Tonleiter sollte man sich an diese Konventionen halten, da sonst nicht gewollte Ergebnisse geliefert werden. "transpTonal" kann auch auf Segemente angewandt werden, in diesem Fall wird die Operation für jede Stimme einzeln durchgeführt. Verwandte Funktionen sind transcr und transp zur Transkription bzw. Transposition ohne spezielle Tonleiter.

Beispiel:

>cDur:=[c d e  f  g a  h]

>gDur:=[g a h c2 d e f#]

>seq:=[c f a# _ e3]

>transpTonal(seq,cDur,5)

Result= [ I=80 M=100 T=0 a1/4 d2/4 a#1/4 _/4 c4/4 ]

>transpTonal(seq,gDur,-3)

Result= [ I=80 M=100 T=0 g0/4 f1/4 a#1/4 _/4 h2/4 ]

>


Die Variationsfunktion transcr
transcr                                    Musikalische Funktionen

Signatur:	sequence × sequence × sequence → sequence

Aufruf:	transcr (seq1, seq2, seq3)

Rückgabewerte:	liefert sequence, entstehend durch Transkription

Beschreibung:

Mit der Funktion "transcr" erhält man eine Sequenz, die durch Transkription der Sequenz seq1 von Tonleiter seq2 in Tonleiter seq3 entsteht. Die Töne der gegebenen Sequenz seq1 werden also von einer Tonleiter in die andere schrittweise übersetzt. Zunächst wird die Position des Tons in der Ausgangstonleiter seq2 gesucht und dann durch den Ton an derselben Stelle in der Zieltonleiter ersetzt. Leiterfremde Töne werden übernommen, gleiches gilt für Pausen. Es ist zu beachten, daß eine Tonleiter für gewöhnlich nach aufsteigender Tonhöhe geordnet ist und der Tonumfang weniger als eine Oktave beträgt. Bei der Eingabe der Tonleiter sollte man sich an diese Konventionen halten, da sonst nicht gewollte Ergebnisse geliefert werden. Diese Funktion läßt sich auch auf Segmente anwenden, wobei die Operation für jede Stimme einzeln ausgefürt wird. SALIERI bietet die Funktionen transp und transpTonal zur Transposition bzw. tonalen Transposition an.

Beispiel:

>cDur:=[c d e f g a h]

>gDur:=[g a h c2 d e f#]

>seq:=[_/8 d c f a# h]

>transcr(seq,cDur,gDur)

Result= [ I=80 M=100 T=0 _/8 a1/8 g1/8 c2/8 a#1/8 f#2/8 ]

>transcr(seq,gDur,cDur)

Result= [ I=80 M=100 T=0 _/8 g0/8 f0/8 f1/8 a#1/8 e1/8 ]

>


Die Variationsfunktion fragm
fragm                                      Musikalische Funktionen

Signatur:	sequence × real × real → sequence

Aufruf:	fragm (sequence, real1, real2)

Rückgabewerte:	extrahiert einen zeitlichen Ausschnitt von sequence

Beschreibung:

Mit der Funktion "fragm" läßt sich ein zeitlicher Abschnitt einer Sequenz sequence ausschneiden. Das Fragment der Sequenz, beginnt hierbei an der relativen Zeitposition real1 und hat eine relative Dauer real2. Die leere Sequenz wird zurückgegeben, falls real1 < 0 oder real1 größer als die relative Dauer von sequence. Ist real2 negativ, so bildet real1 den rechten Rand, der Zeitauschnitt wird also von rechts nach links gebildet. Bei Überschreitung des gewählten Ausschnitts am linken oder rechten Rand von sequence, wird der Auschnitt an dieser Stelle abgebrochen und nicht etwa mit Pausen aufgefüllt. Diese Funktion ist auch auf Segmenten definiert, wobei die Operation für jede Stimme einzeln ausgeführt wird.

Beispiel:

>gDur:=[g a h c2 d e f#]

>fragm(gDur, 1/16, 3/4)

Result= [ I=80 M=100 T=0 g1*3/16 a1/4 h1/4 c2/16 ]

>fragm(gDur, 3/8, 3/4)

Result= [ I=80 M=100 T=0 a1/8 h1/4 c2/4 d2/8 ]

>


Die Kombinationsfunktion comb
comb                                       Musikalische Funktionen

Signatur:	sequence × sequence → sequence

Aufruf:	comb (sequence1, sequence2)

Rückgabewerte:	kombiniert Tonhöhen von sequence1 mit Tondauern

von sequence2

Beschreibung:

Um eine gegebene Melodie in sequence1 mit einem Rhythmus aus sequence2 zu unterlegen, empfiehlt sich die Funktion "comb". Die Tonhöhen von sequence1 bleiben erhalten, während die Tondauern aus sequence2 übernommen werden. Bei der Kombination der Sequenzen wird die jeweils längere gegebenfalls wiederholt. Besondere Aufmerksamkeit erfordet das Setzen der Nebenparameter. Die Intensität I und die Klangfarbe T lassen sich nur in sequence1 definieren, während die Metrumszahl M ausschließlich in sequence2 eine Zuweisung erhalten kann. Ansonsten werden die Nebenparameter auf die Standardeinstellungen gesetzt.

Beispiel:

>Rhythmus:=[_/8 _/16 _/16 _16 _/16 _/8]

>Melodie:=[c0 a h f d0 g]

>comb(Melodie, Rhythmus)

Result= [ I=80 M=100 T=0 c0/8 a0/16 h0/16 f0/16 d0/16 g0/8 ]

>Cha_Cha_Cha:=[_/8 _/8 _/16 _/16 _/8]

>comb(Melodie, Cha_Cha_Cha)

Result= [ I=80 M=100 T=0 c0/8 a0/8 h0/16 f0/16 d0/8 g0/8 ]

>


Die Kombinationsfunktion merge
merge                                     Musikalische Funktionen

Signatur:	sequence × sequence → sequence

Aufruf:	merge (sequence1, sequence2)

Rückgabewerte:	verschmelzen von  sequence1 und sequence2

Beschreibung:

Die Funktion "merge" liefert die Sequenz, die durch Anhängen der Sequenz sequence1 an sequence2 entsteht, wobei der letzte Ton t1 von sequence1 mit dem ersten Ton von sequence2  verschmolzen wird. Die Dauer von t1 wird um die Dauer von t2 verlängert und der Ton t2 gelöscht. Das Gegenstück zu "merge" bildet die Funktion fragm mit der ein Zeitauschnitt einer Sequenz extrahiert werden kann.

Beispiel:

>merge([d g f#/8],[d/4 c h&])

Result= [ I=80 M=100 T=0 d1/4 g1/4 f#1*3/8 c1/4 a#1/4 ]

>


Die Variationsfunktion alter
alter                                        Musikalische Funktionen

Signatur:	segment × integer  → segment

Aufruf:	alter (segment, accidentals)

Rückgabewerte:	liefert alterierte Notation eines Segments segment

Beschreibung:

Die Funktion "alter" liefert ein zu Segment segment gleichklingendes Segment, das jedoch abhängig von accidentals alteriert dargestellt wird. D. h. die Töne des gegebenen Segments segment behalten ihre klingende Tonhöhe, werden aber jeweils mit Anzahl accidentals von Vorzeichen notiert (abhängig vom Systemparameter noteNames). Ein positiver Wert accidentals erzeugt dem Wert entsprechend viele Kreuzvorzeichen, ein negativer b-Vorzeichen. Ist accidentals gleich 0, wird das Segment ohne Vorzeichen dargestellt. "alter" kann auch auf einzelne Sequenzen angewendet werden. Bei Verwendung von "alter" ist die Einstellung des Systemparameters noteNames zu Beachten. Um die mit accidentals gewählte Anzahl von Vorzeichen auch bei schon im Ausgangssegment alterierten Noten dargestellt zu bekommen, muß noteNames auf chromatic eingestellt sein. Zur Einstellung der Systemparameter siehe set.

Beispiel:

>set("noteNames")

noteNames=diatonic

>alter({[c d e]},2)

Result= SEGM([ I=80 M=100 T=0 h#0/4 c##1/4 d##1/4 ])

>alter({[c c# _ e]},1)

Result= SEGM([ I=80 M=100 T=0 h#0/4 c#1/4 _/4 e1/4 ])

>set("noteNames","chromatic")

>alter({[c d e]},2)

Result= SEGM([ I=80 M=100 T=0 ais##0/4 c##1/4 d##1/4 ])

>alter({[c c# _ e]},1)

Result= SEGM([ I=80 M=100 T=0 h#0/4 c#1/4 _/4 dis#1/4 ])

>alter([g1],-5)

Result= [ I=80 M=100 T=0 c&&&&&2/4 ]


Die Variationsfunktion alterTonal
alterTonal                              Musikalische Funktionen

Signatur:	segment × integer  → segment

Aufruf:	alterTonal (segment, accidentals)

Rückgabewerte:	liefert tonal alterierte Notation des Segments

Beschreibung:

Die Funktion "alterTonal" liefert ein zu Segment segment gleichklingendes Segment, das jedoch abhängig von accidentals tonal alteriert dargestellt wird. D. h. die Töne des gegebenen Segments segment behalten ihre klingende Tonhöhe, werden aber soweit diatonisch möglich jeweils mit bis zu einer accidentals entsprechenden Anzahl Vorzeichen notiert. Ein positiver Wert accidentals versucht dem Wert entsprechend viele Kreuzvorzeichen, ein negativer b-Vorzeichen zu erzeugen. Ist accidentals gleich 0, wird wo möglich ohne Vorzeichen notiert. accidentals liefert mit alterTonal im Gegensatz zu alter maximal doppelalterierte Noten, Werte $< -2$ oder $> 2$ verursachen keine Änderung. "alterTonal" kann auch auf einzelne Sequenzen angewendet werden.

Beispiel:

>alterTonal({[c d e f#]},1)

Result= SEGM([ I=80 M=100 T=0 h\#0/4 d1/4 e1/4 f\#1/4 ])

>alterTonal({[c d e f#]},0)

Result= SEGM([ I=80 M=100 T=0 c1/4 d1/4 e1/4 f\#1/4 ])

>alterTonal({[c d e f#]},-1)

Result= SEGM([ I=80 M=100 T=0 c1/4 d1/4 f\&1/4 g\&1/4 ])

>alterTonal([g#1],-2)

Result= [ I=80 M=100 T=0 a\&1/4 ]

>alterTonal([g#1],-3)

Result= [ I=80 M=100 T=0 g\#1/4 ]

>


name                                       Musikalische Funktionen

Signatur:	sequence × integer  → sequence

Aufruf:	name (sequence, integer)

Rückgabewerte:	liefert

Beschreibung:

Mi

Beispiel:

>seq:=[c1 c0  _ d-2 e3 f4 g-3]


name                                       Musikalische Funktionen

Signatur:	sequence × integer  → sequence

Aufruf:	name (sequence, integer)

Rückgabewerte:	liefert

Beschreibung:

Mi

Beispiel:

>seq:=[c1 c0  _ d-2 e3 f4 g-3]


name                                       Musikalische Funktionen

Signatur:	sequence × integer  → sequence

Aufruf:	name (sequence, integer)

Rückgabewerte:	liefert

Beschreibung:

Mi

Beispiel:

>seq:=[c1 c0  _ d-2 e3 f4 g-3]


name                                       Musikalische Funktionen

Signatur:	sequence × integer  → sequence

Aufruf:	name (sequence, integer)

Rückgabewerte:	liefert

Beschreibung:

Mi

Beispiel:

>seq:=[c1 c0  _ d-2 e3 f4 g-3]


name                                       Musikalische Funktionen

Signatur:	sequence × integer  → sequence

Aufruf:	name (sequence, integer)

Rückgabewerte:	liefert

Beschreibung:

Mi

Beispiel:

>seq:=[c1 c0  _ d-2 e3 f4 g-3]


name                                       Musikalische Funktionen

Signatur:	sequence × integer  → sequence

Aufruf:	name (sequence, integer)

Rückgabewerte:	liefert

Beschreibung:

Mi

Beispiel:

>seq:=[c1 c0  _ d-2 e3 f4 g-3]


name                                       Musikalische Funktionen

Signatur:	Λ  → Λ

Aufruf:	exit( )

Rückgabewerte:	keine

Beschreibung:

Blautext.

Beispiel:

>>exit ( )


Der Befehl save
save                                   Systemkommandos

Signatur:	string  → Λ

Aufruf:	save (string)

Rückgabewerte:	speichert den aktuellen Workspace in string.WSP

Beschreibung:

Mithilfe der Funktion "save" kann der aktuelle Workspace unter einem beliebigen Namen string.WSP gesichert werden. Im Gegensatz dazu steht das Sichern durch die Kommandos exit und sync. Hier wird automatisch unter dem Namen SALIERI.WSP eine Kopie des aktuellen Workspace angelegt. Es empfiehlt sich also bei der Ausführung von "save" einen anderen Datei-Namen zu verwenden, als SALIERI.WSP wenn verschiedene Workspace-Kopien vorrätig sein sollen. Mit dem Kommando load läßt sich ein gesicherter Workspace vom SALIERI-System aus laden.

Beispiel:

>save("M.Ravel")

Saving workspace to M.Ravel ... Done

>


Der Befehl load
load                                   Systemkommandos

Signatur:	string  → Λ

Aufruf:	load (string)

Rückgabewerte:	lädt Workspace mit Namen string.WSP

Beschreibung:

Um einen mit save gesicherten Workspace wieder zu laden, wird das Kommando "load" aufgerufen. Hierbei wird der aktuelle Workspace durch den mit dem Datei-Namen string.WSP ersetzt.  Falls ein Objektname sowohl im aktuellen Workspace als auch in der gespeicherten Workspace-Kopie benutzt wurde, so wird beim Laden der Workspace-Datei das entsprechende Objekt im aktuellen Workspace überschrieben.

Beispiel:

>load("M.Ravel")

Loading workspace from M.Ravel ... Done

>


Der Befehl type
type                                   Systemkommandos

Signatur:	expression  → string

Aufruf:	type(expression)

Rückgabewerte:	Gibt den Typ vom Ausdruck expression zurück

Beschreibung:

Die Funktion "type" liefert vom Ausdruck expression den Typ als Zeichenkette. Hierbei kann expression auch ein beliebiger Objektname sein.

Beispiel:

>type([d e f])

Result= "sequence"

>Text:="Du musst besessen werden, und besessen bleiben"

>type(Text)

Result= "string"

>Windows95:=LIST("Bleib immer weg von offenen Fenstern")

>type(Windows95)

Result= "list"

>


Der Befehl deleteAll
deleteAll                                  Systemkommandos

Signatur:	maskstring  → Λ

Aufruf:	deleteAll (maskstring)

Rückgabewerte:	löscht alle Objekte worauf maskstring paßt

Beschreibung:

Das Systemkommandso "deleteAll" löscht alle Objekte aus dem Workspace, deren Name auf die Schablone maskstring paßt. Um lediglich ein Objekt zu löschen, steht der Befehl delete zur Verfügung.

Beispiel:

>deleteAll("B*")

Deleting objects B*:

Bach

Beethoven

Berg

Berlioz

Bernstein

Borodin

Brahms

Bruch

Bruckner

>


Der Befehl exists
exists                                         Systemkommandos

Signatur:	string  → boolean

Aufruf:	exists(string)

Rückgabewerte:	liefert TRUE falls Objekt string in Workspace

Beschreibung:

Zur Überprüfung, ob ein Objekt überhaupt im Workspace existiert, dient die Funktion "exists". Sie liefert TRUE, falls ein Objekt mit Namen string definiert ist, FALSE sonst.

Beispiel:

>exists(Felix.Mendelssohn.Bartholdy)

Result= TRUE

>exists(Franz.Schubert)

Result= FALSE

>exists(Peter.Tschaikowsky)

Result= TRUE

>


Der Befehl ver
ver                                              Systemkommandos

Signatur:	Λ  → Λ

Aufruf:	ver ( )

Rückgabewerte:	keine

Beschreibung:

Informiert über die Versionsnummer des SALIERI-Systems.

Beispiel:

>ver( )

This is Salieri - Kernel Version 2.0.3, reg# 0

registered for everyone, please register (96/05/21)

>


Der Befehl statAll
 statAll                                        Systemkommandos

Signatur:	string  → Λ

Aufruf:	statAll (maskStr)

Rückgabewerte:	keine

Beschreibung:

Mit dem Kommando "statAll" werden Informationen über die Objekte, auf welche die Schablone maskStr paßt ausgegeben. Um alle Objekte zu inspizieren kann der Befehl stat verwendet werden.

Beispiel:

>statAll("M*")

Objects matching M*:

Macbeth   : string  (size=53)

Mahler    : sequence  (size=12)

Monteverdi: string  (size=14)

Mozart    : segment  (size=28)

Mussorsky : integer  (size=12)

>


Der Befehl SaveAsMidi
saveAsMidi                                      Ein/Ausgabe

Signatur:	string × segment  → Λ

Aufruf:	saveAsMidi (string, segment, [int1,int2])

Rückgabewerte:	keine

Beschreibung:

"SaveAsMidi" speichert das Segment segment in der Datei string im MIDI-Format ab. Es können auch Notensequenzen sequence als MIDI-Datei abgelegt werden. Die Endung ".mid" wird automatisch an den Dateinamen angehängt, falls keine andere Extension angegeben wurde. Der Funktion können als optionale Parameter der Zähler int1 und Nenner int2 des gewünschten Taktes mitgegeben werden. Der Takt wird in der MIDI-Datei kodiert, ohne weiter vom SALIERI-System unterstützt zu werden. Allerdings kann diese Information von anderen Programmen genutzt werden, welche die MIDI-Datei bearbeiten wollen. Um im interaktivcn Betrieb mit SALIERI sofort sein Segment (bzw. Sequenz) anzuhören, kann die Funktion play genutzt werden.

Beispiel:

>wohl_temperiert

Result= [ I=80 M=100 T=0 c0/4 e0/4 g0/4 c1/4 e1/4 g0/4 c1/4 e1/4 ]

>saveAsMidi("J_S_Bach",wohl_temperiert)

Creating MIDI-file J_S_Bach.mid ... Done

>C_Dur:={[c d e f g a h c]}

>saveAsMidi("T_Leiter", C_Dur)

Creating MIDI-file T_Leiter.mid ... Done

>saveAsMidi("T_Leiter",C_Dur, 3, 4)	(* Mit Taktangabe *)

Creating MIDI-file T_Leiter.mid ... Done

>


Die Listenfunktion putList
putList                                          Listenfunktionen

Signatur:	list × object × integer  → list

Aufruf:	putList (list, object, integer)

Rückgabewerte:	liefert Liste; ersetzt Element an integer mit object

Beschreibung:

Mit der Funktion "putList" kann ein Element der Liste list, an der Position integer mit einem Objekt object ersetzt werden. Die Funktion gibt dann die neu enstandene Liste list zurück. Eine andere Möglichkeit ist es, den neuen Wert direkt zuzuweisen. Die Notation hierfür lautet: list(integer):=object. Soll eine Liste in eine vorhandene Liste eingesetzt werden, ist die Reihenoperation ins einzusetzen.

Beispiel:

>Sokrates:=LIST("Die Kluegste ist die, die","weiss","was, sie nicht weiss")

>putList(Sokrates, "sagt", 2)

Result= LIST("Die Kluegste ist die, die","sagt","was, sie nicht weiss")

>Platon:=LIST("Koerper","Seele","Tugend","Staat",3*9,{[a# _/8 g&]})

>putList(Platon,"Alles fliesst",6)

Result= LIST("Koerper","Seele","Tugend","Staat",27,"Alles fliesst")

>Urlaubsziele:=("Biblis","Erdmittelpunkt","Rigel7","Mercedes-Werke")

>Urlaubsziele(4):="Angeln am Teich"

Result= LIST("Biblis","Erdmittelpunkt","Rigel7","Angeln am Teich")

>


Die Listenfunktion consList
consList                                        Listenfunktionen

Signatur:	object × list → list

Aufruf:	consList (object, list)

Rückgabewerte:	liefert Liste list; fügt object in die Liste vor Pos.1

Beschreibung:

Mit der Listenfunktion "consList", kann ein Objekt object in die Liste list an Position 1 eingefügt werden. "consList" liefert dann die neu entstandene Liste zurück. Soll eine Liste an einer beliebigen Stelle einer anderen Liste eingefügt werden, so ist die Reihenoperation ins einzusetzten.

Beispiel:

>Bunt_gemischt:=LIST([c d e], 3+8, FALSE, 4>5, "Im Fruehtau zu Berge")

>consList("Fallara",Bunt_gemischt)

Result= LIST("Fallara",[ I=80 M=100 T=0 c1/4 d1/4 e1/4,11,FALSE,FALSE, "Im Fruehtau zu Berge")

>Beruf:=LIST("Halbtagspantomime","Serienmoerder", LIST(FUNC(1,`return($1*3')))

>consList("Minigolflehrer",Beruf)

Result= LIST("Minigolflehrer","Halbtagspantomime", "Serienmoerder", LIST(FUNC(1, `return($1*3')))

>


Die Listenfunktion getList
getList                                           Listenfunktionen

Signatur:	list × integer → object

Aufruf:	getList (list, integer)

Rückgabewerte:	liefert Element an Position integer der Liste list

Beschreibung:

Die Listenfunktion "getList" liefert genau das Listenelement object, welches an Position integer der Liste list steht, wobei mit der Zählung bei 1 begonnen wird. Für getList(list, integer) kann auch geschrieben werden: list@int oder list(int). Es ist zu beachten, daß der Operator "@" stärker bindet als alle anderen Operatoren. Um einen Ausschnitt aus einer Liste zu erhalten kann die Reihenoperation infix eingesetzt werden.

Beispiel:

>Wuerfel:=LIST(1,"2",1+2,12/3,LIST("fuenf"),6)

>getList(Wuerfel,5)

Result= LIST("fuenf")

>Wuerfel@4

Result= 4.00000000

>Wuerfel@2

Result= "2"

>Wuerfel(3)

Result= LIST(3)

>


Die Listenfunktion inList
inList                                            Listenfunktionen

Signatur:	list × object  → boolean

Aufruf:	inList (list, obj)

Rückgabewerte:	liefert boolean; TRUE wenn obj in list; sonst FALSE

Beschreibung:

Mit der Funktion "inList" kann überprüft werden, ob ein Element in einer Liste vorhanden ist. Das Ergebnis TRUE wird dann geliefert, wenn das Object obj in der Liste list enthalten ist. Ansonsten ist der Rückgabewert FALSE. Wenn die Position eines Elementes innerhalb einer Liste gefunden werden soll, so läßt sich dies mit der Reihenoperation posNext realisieren.

Beispiel:

>Ahab:=LIST("Maenner, kennt Ihr den weissen Wal ?",12+3<17,[c d#/8],3.14)

>inList(Ahab, 3.14)

Result= TRUE

>inList(Ahab,"Wal, da blaest er !")

Result= FALSE

>


Die Listenfunktion LISTINIT
LISTINIT                                    Listenfunktionen

Signatur:	integer × object  → list

Aufruf:	LISTINIT (integer, object)

Rückgabewerte:	liefert Anzahl integer Objekte in Liste list

Beschreibung:

Mit der Funktion "LISTINIT" kann eine Liste mit dem gleichen Object object, aufgefüllt werden. Die Anzahl der Objekte wird durch den Parameter integer bestimmt, welcher auch ein Ausdruck sein kann. Bei dieser Funktion ist die Schreibweise (Großbuchstaben) einzuhalten, da sonst eine Fehlermeldung erscheint.

Beispiel:

>LISTINIT(2,"Die Welt ist alles, was der Fall ist")   (* Ludwig Wittgenstein *)

Result= LIST("Die Welt ist alles, was der Fall ist","Die Welt ist alles, was der

 Fall ist")

>LISTINIT(2+1,"Dreimal die 3")

Result= LIST("Dreimal die 3","Dreimal die 3","Dreimal die 3")


Die Konvertierungsfunktion STR
STR                                      Konvertierungsfunktionen

Signatur:	object  → string

Aufruf:	STR (object)

Rückgabewerte:	konvertiert object in eine Zeichenkette

Beschreibung:

Die Funktion "STR" konvertiert den Inhalt eines beliebigen Objekts in eine Zeichenkette. Im Gegensatz zu den anderen Konvertierungsfunktionen operiert sie auch auf den Typen function, sequence und segment. Die Konvertierung von Zeichenketten führt zu einer unschönen Anhäufung von Anführungszeichen.

Beispiel:

>STR(LIST("SUCHE","Holzpuppe. Ohne Fäden, dafür Tricknase. Kontakt Gepetto"))

Result= "LIST("SUCHE","Holzpuppe. Ohne Fäden, dafür Tricknase. Kontakt Gepetto")"

>STR("Bilbo. Komm zurück. Alles vergeben. Habe den Ring verkauft - Frodo")

Result= ""Bilbo. Komm zurück. Alles vergeben. Habe den Ring verkauft - Frodo""

>STR(FALSE)

Result= "FALSE"

>STR(2.3)

Result= "2.29999995"

>f:=FUNC(1,`write($1)'); STR(f)

Result= "FUNC(1, `write($1)')"

>STR(transp([c d e], 2))

Result= "[ I=80 M=100 T=0 d1/4 e1/4 f#1/4 ]"


Die Konvertierungsfunktion REAL
REAL                                   Konvertierungsfunktionen

Signatur:	simple  → real

Aufruf:	REAL (object)

Rückgabewerte:	konvertiert object in eine rationale Zahl real

Beschreibung:

Die Funktion "REAL" konvertiert Objekte der einfachen Datentypen bool, integer, real und string in die passenden rationalen Werte. Die Boole'schen Werte FALSE und TRUE werden nach 0.0 und 1.0 konvertiert. Der Inhalt von Zeichenketten wird als rationale Zahl interpretiert.

Falls eine Zahl syntaktisch nicht korrekt angegeben wird, bricht das System mit einer Fehlermeldung ab. Die Interpretation von Zeichenreihen ist robuster. Hier wird immer ein Wert zurückgeliefert, falls in der Zeichenreihe keine Zahl am Anfang steht, ist dies der Wert 0. Durch die interne Zahlendarstellung der Rechner kann es bei der Konvertierung zu Ungenauigkeiten kommen.

Beispiel:

>REAL(TRUE)

Result= 1.00000000

>REAL(2.3)

Result= 2.29999995

>REAL("2.3")

Result= 2.30000000

>REAL("Der Satz der Mathematik drückt keinen Gedanken aus.")

Result= 0.00000000

>REAL("23 am Anfang wird extrahiert.")

Result= 23.00000000

>REAL("Hier steht die 23 mittendrin")

Result= 0.00000000

>REAL(23a)

Error in command-line: parse error


Die Konvertierungsfunktion BOOL
BOOL                                  Konvertierungsfunktionen

Signatur:	simple  → bool

Aufruf:	BOOL (object)

Rückgabewerte:	konvertiert object in Boole'schen Wahrheitswert

Beschreibung:

Die Funktion "BOOL" konvertiert Objekte der einfachen Datentypen bool, integer, real und string in die passenden Boole'schen Wahrheitswerte. Dabei werden die Werte 1, 1.0 und "TRUE" in TRUE konvertiert, alle anderen Werte in FALSE. Beim Datentyp string ist auf die Großschreibung zu achten.

Beispiel:

>BOOL(2<3)

Result= TRUE

>BOOL(0)

Result= FALSE

>BOOL(1)

Result= TRUE

>BOOL(2.0-1.0)

Result= TRUE

>BOOL("TRUE")

Result= TRUE

>BOOL("Tausche 100 Morgen Mischwald gegen neues Image. - Kontakt R.Hood")

Result= FALSE

>BOOL("True")

Result= FALSE


Die Konvertierungsfunktion INT
INT                                       Konvertierungsfunktionen

Signatur:	simple  → integer

Aufruf:	INT (object)

Rückgabewerte:	konvertiert object in ganzzahligen Wert

Beschreibung:

Die Funktion "INT" konvertiert Objekte der einfachen Datentypen bool, integer, real und string in die passenden ganzzahligen Werte. Die Boole'schen Werte FALSE und TRUE werden nach 0 und 1 konvertiert, bei rationalen Zahlen werden die die Nachkommastellen abgeschnitten. Der Inhalt von Zeichenketten wird als ganze Zahl interpretiert. Wird in einer Zeichenreihe eine rationale Zahl übergeben, so werden ihre Nachkommastellen abgeschnitten.

Falls eine Zahl syntaktisch nicht korrekt angegeben wird, bricht das System mit einer Fehlermeldung ab. Die Interpretation von Zeichenreihen ist robuster. Hier wird immer ein Wert zurückgeliefert, falls in der Zeichenreihe keine Zahl am Anfang steht, ist dies der Wert 0.

Beispiel:

>INT(TRUE)

Result= 1

>INT(2.9)

Result= 2

>INT(-2.9)

Result= -2

>INT("Tarzan! sagst Du vorwurfsvoll. 16 und 11 sind zusammen 27")

Result= 0

>INT("16 und 11 ist ein Eau de Cologne, entgegnet Tarzan empört")

Result= 16


Name                  Menuename

Signatur:	[ ]    -->   [ ]

Aufruf:            Blaa ( )

Rückgabewerte: 	keine

Beschreibung:

Blautext

Beispiel:

> sync ( )

>


Definition: block

Ein Block ist eine Anweisungsfolge, die wiefolgt geklammert ist ` block ' .  Man beachte die Hochkomma ! Das erste sollte nach links oben zeigen, während das zweite nach rechts oben zeigen muß, um einen Parse- Error zu vermeiden. Die einzelnen Anweisungen der Anweisungsfolge block werden durch Semikolon voneinander getrennt.

Beispiel:

   ` Einmaleins:=1*1; Zwei:=Einmaleins+1; write(Zwei) '


Objekttyp: series

Der Objekttyp series ist entweder eine Zeichenkette(string) oder eine Liste(list) oder eine Notensequenz (sequence). Auf diese drei genannten Objekttypen sind alle Reihenoperationen  anwendbar. Wenn in der Signatur folgender Ausdruck auftaucht:

series  ×  series × .... × series....

dann sind die einzelnen Objekttypen series jeweils von ein und demselben Typ. Dasselbe Prinzip gilt für den Aufruf.

Beispiel:

series  ×  series   entspricht:

1) string  ×  string

2) list  ×  list

3) sequence  ×  sequence

Falsch wäre: string  ×  list etc.


Schablone: maskstr

Die Schablone maskstr ist eine Zeichenkette,  die an beliebigen Stellen das Zeichen "*" enthalten darf. Dieses Zeichen ist ein Platzhalter für jede beliebige Zeichenkette (es gilt auch die leere Zeichenkette !) an der entsprechenden Position des Objektnamens.

Beispiel:

Die Schablone "Leg*.i*ko*" paßt auf folgende Objektnamen:

Leggins.inkognito

Legion.inkompetent

Legislative.inkorrekt

Folgende Namen passen nicht:

Leierkasten.inkonstant

Legal.inoffiziell


Tangensfunktion: tan

Da der Tangens für Parameter, bei denen der Cosinus Null wird, nicht definiert ist, führt der Aufruf der Tangensfunktion für Parameterwerte Pi/ 2 + 2k*Pi (k ganze Zahl) zu einer Fehlermeldung. Argumente und Funktionswert werden bei allen trigometrischen Funktionen (Sinus, Cosinus, Tangens, Arcustangens) im Bogenmaß angegeben.


Exponentialfunktion: exp

Die Angabe der Basis ist optional, falls sie weggelassen wird, wird die Exponentialfunktion zur Basis e berechnet. Der Aufruf erfolgt in der Form exp(exponent, [basis]).

Beispiel:

>exp(1)	(* Ohne Basisangabe; Berechnung zur Basis e *)

Result= 2.71828183

>exp(10,2)	(* Mit Basisangabe; Berechnung zur Basis 2)

Result= 1024.00000000


Logarithmusfunktion: log

Die Angabe der Basis ist optional. Fehlt bei der Logarithmusfunktion die Basis, so wird der natürliche Logarithmus des Operanden berechnet. Das Argument der Logarithmusfunktion muß positiv (>= 0) sein, sonst wird eine Fehlermeldung ausgegeben. Der Aufruf erfolgt in der Form log ([basis], operand).

Beispiel:

>log(1)

Result= 0.00000000

>log(10,10000)

Result= 4.00000000

>log(0)

Error in command-line: Invalid argument value

(occured while executing function "log")


Objekttyp: collection

Unter dem Objekttyp collection ist eine Sammlung von Objekttypen zu verstehen. Hierzu gehören  Sequencen, Segmente, Funktionen, Listen, Zahlen und Zeichenketten. Ein Vergleich kann nur zwischen Objekten des gleichen Typs durchgeführt werden, also wäre z.B. 3 + 4 = "Drei plus Vier" unzulässig und würde einen Fehler statt dem Ergebnis FALSE liefern.

Beispiel:

>_EQ("Kai Flade","Holger Hoos")

Result= FALSE

>_UNEQ("Matthias Streicher","Thomas Helbich")

Result= TRUE

>_EQ([c d e], LIST("c d e"))   (* Zwei ungleiche Typen !!! *)

Error in command-line: Type mismatch

(occured while executing function "_EQ")

>_EQ([M=100 c d e],[M=100 c d e])

Result= TRUE

>_EQ([M=100 c d e],[M=80 c d e]) (* Gleichheit gegeben obwohl Metrum verschieden *)

Result= TRUE

>


Objekttyp: choice

Der Objekttyp choice ist entweder eine Zahl bzw. eine Zeichenkette. Ein Vergleich kann nur zwischen Objekten des gleichen Typs durchgeführt werden, also wäre z.B. 3 + 4 = "Drei plus Vier" unzulässig und würde einen Fehler statt dem Ergebnis FALSE liefern.

Beispiel:

>_LE(6,7)

Result= TRUE

>_GR(6,7)

Result= FALSE

>_LEQ("Ostern","Weihnachten")

Result= FALSE

>_LEQ("Weihnachten",24.12)

Error in command-line: Type mismatch

(occured while executing function "_LEQ")

>


Wurzelfunktion: root

Die Angabe der Basis ist bei root optional. Wird die Basis weggelassen, wird die Quadratwurzel berechnet. Das Argument der Wurzelfunktion muß positiv (>= 0) sein, sonst wird eine Fehlermeldung ausgegeben. Der Aufruf erfolgt in der Form root([basis], radikant).

Beispiel:

>root(4)

Result= 2.00000000

>root(2)

Result= 1.41421356

>root(3,9)

Result= 2.08008382

>root(3,64)

Result= 4.00000000

>root(-2,4)

Result= 0.50000000

>root(3,-5)

Error in command-line: Invalid argument value

(occured while executing function "root")


Das schwerste Gewicht beugt uns nieder, erdrückt uns, preßt uns zu Boden. In der Liebeslyrik aller Zeiten aber sehnt sich die Frau nach der Schwere des männlichen Körpers. Das schwerste Gewicht ist also gleichzeitig ein Bild intensivster Lebenserfüllung. Je schwerer das Gewicht, desto näher ist unser Leben der Erde, desto wirklicher und wahrer ist es.

Im Gegensatz dazu bewirkt die völlige Abwesenheit von Gewicht, daß der Mensch leichter wird als Luft, daß er emporschwebt und sich von der Erde, vom irdischen Sein entfernt, daß er nur noch zur Hälfte wirklich ist und seine Bewegungen ebenso frei wie bedeutungslos sind.

Was also soll man wählen? Das Schwerer oder das Leichte?

Parmenides hat sich diese Frage im sechsten Jahrhundert vor Christus gestellt. Er sah die ganze Welt in Gegensatzpaare aufgeteilt: Licht-Dunkel; Feinheit-Grobheit; Wärme-Kälte; Sein-Nichtsein. Er betrachtete den einen Pol (Licht, Feinheit, Wärme, Sein) als positiv, den anderen als negativ. Eine solche Aufteilung sieht kinderleicht aus, bringt jedoch eine Schwierigkeit mit sich: was ist positiv, das Schwere oder das Leichte?

Parmenides antwortete: das Leichte ist positiv, das Schwere ist negativ.

Hatte er recht oder nicht? Das ist die Frage. Sicher ist nur eines: der Gegensatz von leicht und schwer ist der geheimnisvollste und vieldeutigste aller Gegensätze.

(aus: "Die unerträgliche Leichtigkeit des Seins", Milan Kundera, S.9, Fischer-Verlag )


Europäisches Urwildpferd (Equus caballus gmelini)

Das europäische Urwildpferd, der Tarpan lebte in den südrussischen Steppen des Dnjeprgebietes noch etwa bis zum Jahre 1870. Durch ihre Neigung, Hauspferde in ihre Rudel mit aufzunehmen und sie so den Bauern zu entführen, wurden sie von den pferdezüchtenden Steppenbewohnern mehr gefürchtet als die Wölfe. Nachgewiesenermaßen ist der letzte Tarpan 1876 durch russische Bauern erschlagen worden. Heute versucht man durch planvolle Kreuzungen mit noch vorhandenen Mischlingen die typischen Merkmale der Urwildpferde wieder herauszuzüchten.

Alle unsere Hauptpferderassen stammen von den Urwildpferden ab. Bei den Indern und Chinesen finden wir das Pferd als Haustier schon um 2000 v. Chr. Nur wenig später wurde es bei den Assyrern, Babyloniern und schließlich in Ägypten gehalten. Wie Knochenfunde aus den Diluvialablagerungen zeigten, ist Westeuropa ohne Zweifel als Hauptursprungsland der schweren Pferde anzusehen.


Ein Klavier ein Klavier !


                               Man at Work


          	    Hilfe zu SALIERI 2.04 (c) 1995-1996

           	     	Hilfe-Version 1.1

----------------------------------------------------------------------------------------------------------------------

        	Autor:              Matthias Streicher, 1995-1996

        	E-Mail:      kilian@iti.informatik.th-darmstadt.de


Wichtige Terminale:

 Λ   →  Λ

←↑→↓


  Index der SALIERI-Funktionen

-Symbole-

+	Positives Vorzeichen, Addition, Konkatenation

-	Negatives Vorzeichen, Subtraktion

*	Multiplikation

/	Division-Realoperation

$	Parameter bei Funktionen

=	Gleichheit

!=	Ungleichheit

<=	Kleiner gleich als

>=	Größer gleich als

>	Größer als

<	Kleiner als

"   "	String

[   ]	Notensequenz

{  }	Notensegment oder Kurze Notation für poly

&	Tonerniedrigung

#	Tonerhöhung

`   '	Block

:=	Zuweisung

..	Punktierte Note

@	Kurze Notation für getList

-A-

abort	Programmausführung abbrechen

abs	Absolutbetrag

alter	Alterierte Notation eines Segments

alterTonal	Tonal alterierte Notation eines Segments

ambitus	Liefert den Tonumfang einer Sequenz

_AND	Infixnotation für logisches und

and	Logisches und

apply	Alternativer Funktionsaufruf

arctan	Arcustangens

-B-

BOOL	Konvertiert Objekt in Wahrheitswert

_BY	Infixnotation für Division auf Real

-C-

ceil	Aufrunden (obere Gaußklammer)

comb	Melodie mit Rythmus unterlegen

consList	Objekt in Liste einfügen

cos	Cosinus

cresc	Intensitätsverlauf ändern

curFunc	Liefert Namen der aktuell ausgeführten Funktion

curLine	Liefert Zeile des aktuell ausgeführten Programms

-D-

debug	Systemintern

del	Löscht Elemente einer Reihe

delete	Löscht ein Objekt aus dem Workspace

deleteAll	Löscht alle Objekte worauf Schablone paßt

dir	Liefert Dateien aus aktuellem Verzeichnis

dispTags	Systemintern

div	Ganzahldivision

_DIV	Infixnotation für Ganzahldivision

duration	Liefert relative Dauer einer Sequenz

-E-

_EQ	Infixnotation für Gleichheit

exec	Ausführen von Programmdateien

exists	Liefert TRUE falls Objekt im Workspace existiert

exit	SALIERI beenden

exp	Exponentialfunktion

expand	Sequenz zeitlich strecken

-F-

floor	Abrunden untere Gaußklammer

fragm	Extrahiert zeitlichen Ausschnitt einer Sequenz

FUNC	Funktionsdefinition

-G-

_GEQ	Infixnotation für Größer gleich als

getInstr	Liefert Wert der Klangfarbe einer Sequenz

getIntens	Liefert Wert der Intensität einer Sequenz

getList	Liefert Element einer Reihe

getPitch	Liefert Tonhöhe und Oktave einer Note

getPitchTonal	Liefert relative Tonhöhe einer Note

getTempo	Liefert den Wert des Metrums

_GR	Infixnotation für Größer als

-I-

if	Verzweigungsfunktion

IFUNC	Interne Funktion

inList	Überprüft, ob Element in Liste vorhanden

infix	Liefert Ausschnitt aus einer Reihe

ins	Reihe/Element in Reihe einfügen

instr	Setzt Klangfarbe einer Sequenz

INT	Konvertiert Objekt in ganzzahligen Wert

intvExpand	Strecken der Intervallgrößen

invert	Liefert eine am Anfangston gespiegelte Sequenz

isRest	Liefert TRUE falls Note eine Pause ist

it	Liefert letztes Ergebnis einer Auswertung

-L-

_LE	Infixnotation für Kleiner als

length	Liefert die Länge einer Reihe

LIST	Konstruktor für Listen

LISTINIT	Liste mit gleichem Objekt auffüllen

load	Workspace laden

log	Logarithmusfunktion

loop	Allgemeine Schleife

loopn	N-maliges durchlaufen einer Schleife

-M-

MACRO	Konstruktor für Makros

merge	Verschmelzen zweier Sequenzen

midiHoldFactor	Setzt Haltedauer beim Abspielen

_MINUS	Infixnotation für Subtraktion

mod	Rest bei der Ganzahldivision

_MOD	Infixnotation für Rest bei der Ganzahldivision

-N-

not	Logische Negation

_NOT	Infixnotation für logische Negation

noteNames	Erscheinungsbild der Notennamen setzen

-O-

or	Logisches oder

_OR	Infixnotation für logisches oder

-P-

part	Liefert Stimme eines Segments

parts	Liefert Anzahl der Stimmen eines Segments

play	Spielt das angegebene Segment ab

_PLUS	Infixnotation für Addition

poly	Verbindet Segmente zu einem neuen Segment

posNext	Sucht innerhalb einer Reihe

putList	Listenelement ersetzen

-R-

REAL	Konvertiert Objekt in rationale Zahl

read	Eingabe von Objekten

readStr	Eingabe von Zeichenketten

retro	Liefert zeitliche Umkehrung einer Sequenz

return	Funktion beenden / evtl. Werterückgabe

rnd	Zufallszahl zwischen 0 und 1

rndUniform	Zufallszahl beliebiger Bereich

root	Wurzelfunktion

-S-

save	Speichert Workspace unter beliebigen Namen

saveAsMidi	Speichert Segment im MIDI-Format

SEGM	Andere Notation für Segmentkonstanten

SEQ	Andere Notation für Sequenzkonstanten

seqDispFormat	Ausgabeformat von Sequenzen

set	Systemeinstellungen manipulieren

sin	Sinus

stat	AlleWorkspace-Objekte auflisten

statAll	Bestimmte Workspace-Objekte auflisten

stdInstr	Standardklangfarbe setzten

stdIntens	Standardintensität setzen

stdTempo	Standardmetrum setzen

STR	Konvertiert Objekt in Zeichenkette

sync	Speichert Workspace unter SALIERI.WSP

-T-

tan	Tangens

time	Liefert die absolute Tondauer einer Sequenz

_TIMES	Infixnotation für Multiplikation

transcr	Transkription

transp	Transposition

transpTonal	Tonale Transposition

type	Liefert Typ als Zeichenkette

-U-

_UNEQ	Infixnotation für Ungleich

-V-

ver	Gibt die aktuelle Versionsnummer aus

-W-

while	While-Schleife

write	Gibt Objekte auf dem Bildschirm aus


Integeroperation

Realoperation

Konkatenation - Reihen

Konkatenation - Segmente


Integeroperation

Realoperation


Segmentkonstanten

Die musikalische Funktion poly