On this page:
*
+
-
/
<
<=
=
>
>=
abs
acos
angle
asin
atan
ceiling
complex?
cos
current-seconds
denominator
even?
exact->inexact
exact?
exp
expt
floor
gcd
imag-part
inexact->exact
inexact?
integer?
lcm
log
magnitude
make-polar
max
min
modulo
natural?
negative?
number->string
number?
numerator
odd?
positive?
quotient
random
rational?
real-part
real?
remainder
round
sin
sqrt
string->number
tan
zero?
boolean=?
boolean?
equal?
false?
not
true?
append
cons
cons?
empty
empty?
filter
first
fold
length
list
list-ref
rest
reverse
string->strings-list
string-append
string-length
string<=?
string<?
string=?
string>=?
string>?
string?
strings-list->string
for-each
map
read
signature?
violation
write-newline
write-string

2.4 Primitive Operationen 🔗

function

* : (number number number ... -> number)

Produkt berechnen

function

+ : (number number number ... -> number)

Summe berechnen

function

- : (number number ... -> number)

bei mehr als einem Argument Differenz zwischen der ersten und der Summe aller weiteren Argumente berechnen; bei einem Argument Zahl negieren

function

/ : (number number number ... -> number)

das erste Argument durch das Produkt aller weiteren Argumente berechnen

function

< : (real real real ... -> boolean)

Zahlen auf kleiner-als testen

function

<= : (real real real ... -> boolean)

Zahlen auf kleiner-gleich testen

function

= : (number number number ... -> boolean)

Zahlen auf Gleichheit testen

function

> : (real real real ... -> boolean)

Zahlen auf größer-als testen

function

>= : (real real real ... -> boolean)

Zahlen auf größer-gleich testen

function

abs : (real -> real)

Absolutwert berechnen

function

acos : (number -> number)

Arcuscosinus berechnen (in Radian)

function

angle : (number -> real)

Winkel einer komplexen Zahl berechnen

function

asin : (number -> number)

Arcussinus berechnen (in Radian)

function

atan : (number -> number)

Arcustangens berechnen (in Radian)

function

ceiling : (real -> integer)

nächste ganze Zahl oberhalb einer rellen Zahlen berechnen

function

complex? : (any -> boolean)

feststellen, ob ein Wert eine komplexe Zahl ist

function

cos : (number -> number)

Cosinus berechnen (Argument in Radian)

function

current-seconds : (-> natural)

aktuelle Zeit in Sekunden seit einem unspezifizierten Startzeitpunkt berechnen

function

denominator : (rational -> natural)

Nenner eines Bruchs berechnen

function

even? : (integer -> boolean)

feststellen, ob eine Zahl gerade ist

function

exact->inexact : (number -> number)

eine Zahl durch eine inexakte Zahl annähern

function

exact? : (number -> boolean)

feststellen, ob eine Zahl exakt ist

function

exp : (number -> number)

Exponentialfunktion berechnen (e hoch Argument)

function

expt : (number number -> number)

Potenz berechnen (erstes Argument hoch zweites Argument)

function

floor : (real -> integer)

nächste ganze Zahl unterhalb einer rellen Zahlen berechnen

function

gcd : (integer integer ... -> natural)

größten gemeinsamen Teiler berechnen

function

imag-part : (number -> real)

imaginären Anteil einer komplexen Zahl extrahieren

function

inexact->exact : (number -> number)

eine Zahl durch eine exakte Zahl annähern

function

inexact? : (number -> boolean)

feststellen, ob eine Zahl inexakt ist

function

integer? : (any -> boolean)

feststellen, ob ein Wert eine ganze Zahl ist

function

lcm : (integer integer ... -> natural)

kleinstes gemeinsames Vielfaches berechnen

function

log : (number -> number)

natürlichen Logarithmus (Basis e) berechnen

function

magnitude : (number -> real)

Abstand zum Ursprung einer komplexen Zahl berechnen

function

make-polar : (real real -> number)

komplexe Zahl aus Abstand zum Ursprung und Winkel berechnen

function

max : (real real ... -> real)

Maximum berechnen

function

min : (real real ... -> real)

Minimum berechnen

function

modulo : (integer integer -> integer)

Divisionsmodulo berechnen

function

natural? : (any -> boolean)

feststellen, ob ein Wert eine natürliche Zahl (inkl. 0) ist

function

negative? : (number -> boolean)

feststellen, ob eine Zahl negativ ist

function

number->string : (number -> string)

Zahl in Zeichenkette umwandeln

function

number? : (any -> boolean)

feststellen, ob ein Wert eine Zahl ist

function

numerator : (rational -> integer)

Zähler eines Bruchs berechnen

function

odd? : (integer -> boolean)

feststellen, ob eine Zahl ungerade ist

function

positive? : (number -> boolean)

feststellen, ob eine Zahl positiv ist

function

quotient : (integer integer -> integer)

ganzzahlig dividieren

function

random : (natural -> natural)

eine natürliche Zufallszahl berechnen, die kleiner als das Argument ist

function

rational? : (any -> boolean)

feststellen, ob eine Zahl rational ist

function

real-part : (number -> real)

reellen Anteil einer komplexen Zahl extrahieren

function

real? : (any -> boolean)

feststellen, ob ein Wert eine reelle Zahl ist

function

remainder : (integer integer -> integer)

Divisionsrest berechnen

function

round : (real -> integer)

relle Zahl auf eine ganze Zahl runden

function

sin : (number -> number)

Sinus berechnen (Argument in Radian)

function

sqrt : (number -> number)

Quadratwurzel berechnen

function

string->number : (string -> (mixed number false))

Zeichenkette in Zahl umwandeln, falls möglich

function

tan : (number -> number)

Tangens berechnen (Argument in Radian)

function

zero? : (number -> boolean)

feststellen, ob eine Zahl Null ist

function

boolean=? : (boolean boolean -> boolean)

Booleans auf Gleichheit testen

function

boolean? : (any -> boolean)

feststellen, ob ein Wert ein boolescher Wert ist

function

equal? : (any any -> boolean)

feststellen, ob zwei Werte gleich sind

function

false? : (any -> boolean)

feststellen, ob ein Wert #f ist

function

not : (boolean -> boolean)

booleschen Wert negieren

function

true? : (any -> boolean)

feststellen, ob ein Wert #t ist

function

append : ((list-of %a) ... -> (list-of %a))

mehrere Listen aneinanderhängen

function

cons : (%a (list-of %a) -> (list-of %a))

erzeuge ein Cons aus Element und Liste

function

cons? : (any -> boolean)

feststellen, ob ein Wert ein Cons ist

constant

empty : list

die leere Liste

function

empty? : (any -> boolean)

feststellen, ob ein Wert die leere Liste ist

function

filter : ((%a -> boolean) (list-of %a) -> (list-of %a))

Alle Elemente einer Liste extrahieren, für welche die Funktion #t liefert.

function

first : ((list-of %a) -> %a)

erstes Element eines Cons extrahieren

function

fold : (%b (%a %b -> %b) (list-of %a) -> %b)

Liste einfalten.

function

length : ((list-of %a) -> natural)

Länge einer Liste berechnen

function

list : (%a ... -> (list-of %a))

Liste aus den Argumenten konstruieren

function

list-ref : ((list-of %a) natural -> %a)

das Listenelement an der gegebenen Position extrahieren

function

rest : ((list-of %a) -> (list-of %a))

Rest eines Cons extrahieren

function

reverse : ((list-of %a) -> (list-of %a))

Liste in umgekehrte Reihenfolge bringen

function

string->strings-list : (string -> (list-of string))

Eine Zeichenkette in eine Liste von Zeichenketten mit einzelnen Zeichen umwandeln

function

string-append : (string string ... -> string)

Hängt Zeichenketten zu einer Zeichenkette zusammen

function

string-length : (string -> natural)

Liefert Länge einer Zeichenkette

function

string<=? : (string string string ... -> boolean)

Zeichenketten lexikografisch auf kleiner-gleich testen

function

string<? : (string string string ... -> boolean)

Zeichenketten lexikografisch auf kleiner-als testen

function

string=? : (string string string ... -> boolean)

Zeichenketten auf Gleichheit testen

function

string>=? : (string string string ... -> boolean)

Zeichenketten lexikografisch auf größer-gleich testen

function

string>? : (string string string ... -> boolean)

Zeichenketten lexikografisch auf größer-als testen

function

string? : (any -> boolean)

feststellen, ob ein Wert eine Zeichenkette ist

function

strings-list->string : ((list-of string) -> string)

Eine Liste von Zeichenketten in eine Zeichenkette umwandeln

function

for-each : ((%a -> %b) (list-of %a) -> unspecific)

Funktion von vorn nach hinten auf alle Elemente einer Liste anwenden

function

map : ((%a -> %b) (list-of %a) -> (list-of %b))

Funktion auf alle Elemente einer Liste anwenden, Liste der Resultate berechnen

function

read : (-> any)

Externe Repräsentation eines Werts in der REPL einlesen und den zugehörigen Wert liefern

function

signature? : (any -> boolean)

feststellen, ob ein Wert eine Signatur ist

function

violation : (string -> unspecific)

Programmm mit Fehlermeldung abbrechen

function

write-newline : (-> unspecific)

Zeilenumbruch ausgeben

function

write-string : (string -> unspecific)

Zeichenkette in REPL ausgeben