[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 73. stringproc

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 73.1 Einführung in die Verarbeitung von Zeichenketten

Das Paket `stringproc` enthält Funktionen für die Verarbeitung von Zeichen und Zeichenketten, was Formatierung, Zeichenkodierung und die Behandlung von Datenströmen mit einschließt. Abgerundet wird dieses Paket durch Werkzeuge für die Kryptographie, wie z.B. Base64 und Hashfunktionen.

Das Paket kann explizit durch `load(stringproc)` geladen werden oder automatisch durch die Verwendung einer der enthaltenden Funktionen.

Fragen und Fehlerberichte senden Sie bitte direkt an den Autor, dessen e-Mail-Adresse durch den folgenden Befehl ausgegeben wird.

`printf(true, "~{~a~}@gmail.com", split(sdowncase("Volker van Nek")))$`

Eine Zeichenkette wird durch die Eingabe von z.B. `"Text"` erzeugt. Ist die Optionsvariable `stringdisp` auf `false` gesetzt, was standardmäßig der Fall ist, werden die (doppelten) Anführungszeichen nicht mit ausgegeben. stringp ist ein Test, ob ein Objekt eine Zeichenkette ist.

    (%i1) str: "Text";
    (%o1)                         Text
    (%i2) stringp(str);
    (%o2)                         true

Schriftzeichen werden in Maxima durch Zeichenketten der Länge 1 dargestellt. charp ist hier der entsprechende Test.

    (%i1) char: "e";
    (%o1)                           e
    (%i2) charp(char);
    (%o2)                         true

Positionsindizes in Zeichenketten sind in Maxima genau so wie in Listen 1-indiziert, wodurch die folgende Übereinstimmung entsteht.

    (%i1) is(charat("Lisp",1) = charlist("Lisp")[1]);
    (%o1)                         true

Eine Zeichenkette kann Ausdrücke enthalten, die Maxima versteht. Diese können mit parse_string heraus gelöst werden.

    (%i1) map(parse_string, ["42" ,"sqrt(2)", "%pi"]);
    (%o1)                   [42, sqrt(2), %pi]
    (%i2) map('float, %);
    (%o2)        [42.0, 1.414213562373095, 3.141592653589793]

Zeichenketten können als Schriftzeichen und binär als Oktette verarbeitet werden. string_to_octets bzw. octets_to_string dienen hierbei zur Umrechnung. Die verwendbaren Kodierungen sind dabei von der Plattform, der Anwendung und vom unter Maxima liegenden Lisp abhängig. (Folgend Maxima in GNU/Linux, kompiliert mit SBCL.)

    (%i1) obase: 16.$
    (%i2) string_to_octets("$£€", "cp1252");
    (%o2)                     [24, 0A3, 80]
    (%i3) string_to_octets("$£€", "utf-8");
    (%o3)               [24, 0C2, 0A3, 0E2, 82, 0AC]

Dem entsprechend können Zeichenketten an Datenströme für Schriftzeichen und als Oktette an binäre Ströme weiter gegeben werden. Das folgende Beispiel zeigt das Schreiben und Lesen von Schriftzeichen in bzw. aus einer Datei.

openw gibt dabei einen Ausgabestrom in eine Datei zurück, mit printf wird formatiert in diesen Strom geschrieben und mit z.B. close werden die im Strom enthaltenden Zeichen in die Datei geschrieben.

    (%i1) s: openw("file.txt");
    (%o1)                #<output stream file.txt>
    (%i2) printf(s, "~%~d ~f ~a ~a ~f ~e ~a~%",
    42, 1.234, sqrt(2), %pi, 1.0e-2, 1.0e-2, 1.0b-2)$
    (%i3) close(s)$

openr gibt folgend einen Eingabestrom aus der obigen Datei zurück und readline die gelesene Zeile als Zeichenkette. Mit z.B. split oder tokens kann die Zeichenkette anschließend in seine Bestandteile zerlegt werden. parse_string verwandelt diese dann in auswertbare Ausdrücke.

    (%i4) s: openr("file.txt");
    (%o4)                 #<input stream file.txt>
    (%i5) readline(s);
    (%o5)          42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
    (%i6) map(parse_string, split(%));
    (%o6)       [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
    (%i7) close(s)$

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 73.2 Ein- und Ausgabe

Beispiel: Formatiertes Schreiben in eine Datei mit anschließendem Lesen.

    (%i1) s: openw("file.txt");
    (%o1)                      #<output stream file.txt>
    (%i2) control:
    "~2tAn atom: ~20t~a~%~2tand a list: ~20t~{~r ~}~%~2t\
    and an integer: ~20t~d~%"$
    (%i3) printf(s, control, 'true,[1,2,3],42)$
    (%o3)                                false
    (%i4) close(s);
    (%o4)                                true
    (%i5) s: openr("file.txt");
    (%o5)                      #<input stream file.txt>
    (%i6) while stringp(tmp:readline(s)) do print(tmp)$
      An atom:          true
      and a list:       one two three
      and an integer:   42
    (%i7) close(s)$

Beispiel: Lesen aus einer binären Datei. Siehe readbyte.

Funktion: close (stream)

  Schließt den Datenstrom stream und gibt `true` zurück, wenn stream noch geöffnet war.

Funktion: flength (stream)

  stream muss ein geöffneter Datenstrom in eine oder aus einer Datei sein. `flength` gibt dann die Anzahl der Bytes zurück, die sich momentan in dieser Datei befinden.

  Beispiel: Siehe writebyte .

Funktion: flush_output (stream)

  Leert den Inhalt des Dateiausgabestroms stream in die Datei.

  Beispiel: Siehe writebyte .

Function: fposition (stream)
Function: fposition (stream, pos)

  Ohne das optionale Argument pos gibt `fposition` die aktuelle Position in dem Datenstrom stream zurück. Wird pos verwendet, legt `fposition` diesen Wert als aktuelle Position in stream fest. pos muss eine positive Zahl sein.

  Die Positionen in Datenströmen sind wie in Zeichenketten und Listen 1-indiziert, d.h. das erste Element in stream hat die Position 1.

Function: freshline ()
Function: freshline (stream)

  Schreibt einen Zeilenumbruch in den Standardausgabestrom, falls die aktuelle Ausgabeposition nicht gerade der Anfang einer Zeile ist und gibt `true` zurück. Bei der Verwendung des optionalen Arguments stream wird der Umbruch in diesen Datenstrom geschrieben.

  Es gibt Situationen, in denen `freshline()` nicht wie erwartet funktioniert.

  Siehe auch newline.

Funktion: get_output_stream_string (stream)

  Gibt Schriftzeichen, die aktuell in dem geöffneten Datenstrom stream enthalten sind, in einer Zeichenkette zurück. Die zurück gegebenen Zeichen werden dabei aus dem Datenstrom entfernt. stream muss durch `make_string_output_stream` erzeugt worden sein.

  Beispiel: Siehe make_string_output_stream .

Funktion: make_string_input_stream (string)
Funktion: make_string_input_stream (string, start)
Funktion: make_string_input_stream (string, start, end)

  Gibt einen Datenstrom zurück, der Teile der Zeichenkette string und ein Dateiende enthält. Ohne optionale Argumente enthält der Strom die gesamte Zeichenkette und ist vor dem ersten Zeichen positioniert. Mit den optionalen Argumenten start und end lässt sich der Abschnitt der Zeichenkette festlegen, den der Datenstrom enthält. Das erste Zeichen befindet sich dabei an der Position 1.

      (%i1) istream : make_string_input_stream("text", 1, 4);
      (%o1)              #<string-input stream from "text">
      (%i2) (while (c : readchar(istream)) # false do sprint(c), newline())$
      t e x
      (%i3) close(istream)$

Funktion: make_string_output_stream ()

  Gibt einen Datenstrom zurück, der Schriftzeichen aufnehmen kann. Die aktuell im Strom enthaltenden Zeichen können mit get_output_stream_string entnommen werden.

      (%i1) ostream : make_string_output_stream();
      (%o1)               #<string-output stream 09622ea0>
      (%i2) printf(ostream, "foo")$

      (%i3) printf(ostream, "bar")$

      (%i4) string : get_output_stream_string(ostream);
      (%o4)                            foobar
      (%i5) printf(ostream, "baz")$

      (%i6) string : get_output_stream_string(ostream);
      (%o6)                              baz
      (%i7) close(ostream)$

Funktion: newline ()
Funktion: newline (stream)

  Schreibt einen Zeilenumbruch in den Standardausgabestrom und gibt `false` zurück. Bei der Verwendung des optionalen Arguments stream wird der Umbruch in diesen Datenstrom geschrieben. Es gibt Situationen, in denen `newline()` nicht wie erwartet funktioniert.

  Beispiel: Siehe sprint.

Funktion: opena (file)

  Gibt einen Dateiausgabestrom für Schriftzeichen zurück. Sollte die Textdatei file nicht existieren, wird sie erzeugt. Wird eine bereits vorhandene Datei geöffnet, werden alle Ausgaben in die Datei am Ende hinzugefügt.

  opena_binary ist die entsprechende Funktion für die Ausgabe in eine Binärdatei.

Funktion: openr (file)

  Gibt einen Dateieingabestrom für Schriftzeichen aus einer Textdatei zurück. Voraussetzung ist, dass die Datei file bereits existiert.

  openr_binary ist die entsprechende Funktion für die Eingabe aus einer Binärdatei.

Funktion: openw (file)

  Gibt einen Dateiausgabestrom für Schriftzeichen zurück. Sollte die Textdatei file nicht existieren, wird sie erzeugt. Wird eine bereits vorhandene Datei geöffnet, wird sie destruktiv verändert.

  openw_binary ist die entsprechende Funktion für die Ausgabe in eine Binärdatei.

Function: printf (dest, string)
Function: printf (dest, string, expr_1, …, expr_n)

  Erzeugt eine formatierte Ausgabe. Der Zielparameter dest gibt an, wo die Ausgabe erfolgen soll. Möglich sind hier ein Ausgabestrom oder die globalen Variablen `true` und `false`. `true` bewirkt eine Ausgabe im Terminal. Der Rückgabewert von `printf` ist in diesem Fall `false`. `false` als Zielparameter bewirkt die Ausgabe im Rückgabewert.

  Die Zeichen des Kontrollparameters string werden der Reihe nach ausgegeben, wobei jedoch eine Tilde eine Direktive einleitet. Die Direktiven verwenden dann im Allgemeinen die nachstehenden Parameter expr_1, …, expr_n, um die Ausgabe zu erzeugen. Das Zeichen nach der Tilde gibt dabei an, welche Art der Formatierung gewünscht ist.

  `printf` stellt die Common Lisp Funktion `format` in Maxima zur Verfügung. Das folgende Beispiel zeigt die grundsätzliche Beziehung zwischen diesen beiden Funktionen.

      (%i1) printf(true, "R~dD~d~%", 2, 2);
      R2D2
      (%o1)                                false
      (%i2) :lisp (format t "R~dD~d~%" 2 2)
      R2D2
      NIL

  Die folgende Beschreibung und die Beispiele beschränken sich auf eine grobe Skizze der Verwendungsmöglichkeiten von `printf`. Die Lisp Funktion `format` ist in vielen Referenzbüchern ausführlich beschrieben. Eine hilfreiche Quelle ist z.B. das frei verfügbare Online-Manual "Common Lisp the Language" von Guy L. Steele. Siehe dort das Kapitel 22.3.3.

         ~%       new line
         ~&       fresh line
         ~t       tab
         ~$       monetary
         ~d       decimal integer
         ~b       binary integer
         ~o       octal integer
         ~x       hexadecimal integer
         ~br      base-b integer
         ~r       spell an integer
         ~p       plural
         ~f       floating point
         ~e       scientific notation
         ~g       ~f or ~e, depending upon magnitude
         ~h       bigfloat
         ~a       uses Maxima function string
         ~s       like ~a, but output enclosed in "double quotes"
         ~~       ~
         ~<       justification, ~> terminates
         ~(       case conversion, ~) terminates
         ~[       selection, ~] terminates
         ~{       iteration, ~} terminates

  Die Direktive ~h für Gleitkommazahlen mit beliebiger Genauigkeit entspricht nicht dem Lisp-Standard und wird daher unten näher beschrieben.

  Die Direktive ~* wird nicht unterstützt.

  Ist dest ein Datenstrom oder `true`, gibt `printf` `false` zurück. Andernfalls ist der Rückgabewert eine Zeichenkette.

      (%i1) printf( false, "~a ~a ~4f ~a ~@r",
                    "String",sym,bound,sqrt(12),144), bound = 1.234;
      (%o1)                 String sym 1.23 2*sqrt(3) CXLIV
      (%i2) printf( false,"~{~a ~}",["one",2,"THREE"] );
      (%o2)                          one 2 THREE
      (%i3) printf( true,"~{~{~9,1f ~}~%~}",mat ),
                mat = args(matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]))$
            1.1       2.0       3.3
            4.0       5.0       6.0
            7.0       8.9       9.0
      (%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
      (%i5) printf( false, control, n,n, if n = 1 then 1 else 2 ), n = 2;
      (%o5)                    Two birds are singing.

  Die Direktive ~h wurde für Gleitkommazahlen mit beliebiger Genauigkeit eingeführt.

      ~w,d,e,x,o,p@H
       w : width
       d : decimal digits behind floating point
       e : minimal exponent digits
       x : preferred exponent
       o : overflow character
       p : padding character
       @ : display sign for positive numbers

      (%i1) fpprec : 1000$
      (%i2) printf(true, "|~h|~%", 2.b0^-64)$
      |0.0000000000000000000542101086242752217003726400434970855712890625|
      (%i3) fpprec : 26$
      (%i4) printf(true, "|~h|~%", sqrt(2))$
      |1.4142135623730950488016887|
      (%i5) fpprec : 24$
      (%i6) printf(true, "|~h|~%", sqrt(2))$
      |1.41421356237309504880169|
      (%i7) printf(true, "|~28h|~%", sqrt(2))$
      |   1.41421356237309504880169|
      (%i8) printf(true, "|~28,,,,,'*h|~%", sqrt(2))$
      |***1.41421356237309504880169|
      (%i9) printf(true, "|~,18h|~%", sqrt(2))$
      |1.414213562373095049|
      (%i10) printf(true, "|~,,,-3h|~%", sqrt(2))$
      |1414.21356237309504880169b-3|
      (%i11) printf(true, "|~,,2,-3h|~%", sqrt(2))$
      |1414.21356237309504880169b-03|
      (%i12) printf(true, "|~20h|~%", sqrt(2))$
      |1.41421356237309504880169|
      (%i13) printf(true, "|~20,,,,'+h|~%", sqrt(2))$
      |++++++++++++++++++++|

Funktion: readbyte (stream)

  Entfernt das erste Byte aus dem binären Eingabestrom stream und gibt es zurück. Ist das Ende der Datei (EOF) erreicht, wird `false` zurück gegeben.

  Beispiel: Die ersten 16 Byte aus einer mit AES in OpenSSL verschlüsselten Datei werden gelesen und ausgewertet.

      (%i1) ibase: obase: 16.$

      (%i2) in: openr_binary("msg.bin");
      (%o2)                       #<input stream msg.bin>
      (%i3) (L:[],  thru 16. do push(readbyte(in), L),  L:reverse(L));
      (%o3) [53, 61, 6C, 74, 65, 64, 5F, 5F, 88, 56, 0DE, 8A, 74, 0FD, 0AD, 0F0]
      (%i4) close(in);
      (%o4)                                true
      (%i5) map(ascii, rest(L,-8));
      (%o5)                      [S, a, l, t, e, d, _, _]
      (%i6) salt: octets_to_number(rest(L,8));
      (%o6)                          8856de8a74fdadf0

Funktion: readchar (stream)

  Entfernt und gibt das erste Schriftzeichen in stream zurück. Falls das Ende des Streams erreicht sein sollte, gibt `readchar` `false` zurück.

  Beispiel: Siehe make_string_input_stream.

Function: readline (stream)

  Gibt die Zeichenkette zurück, die sämtliche Zeichen von der aktuellen Position in stream bis zum Ende der Zeile enthält oder `false`, falls das Ende der Datei erreicht wurde.

Funktion: sprint (expr_1, …, expr_n)

  Wertet ihre Argumente der Reihe nach von links nach rechts aus und gibt sie dann auf einer Linie aus. Zeilenbegrenzungen werden dabei außer Acht gelassen. An die ausgegebenen Ausdrücke wird jeweils rechts ein Leerzeichen angefügt.

  Beispiel: Sequentielle Ausgabe mit `sprint`. Zeilenumbrüche werden hier mit `newline()` erzeugt.

      (%i1) for n:0 thru 19 do sprint(fib(n))$
      0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
      (%i2) for n:0 thru 22 do (
               sprint(fib(n)),
               if mod(n,10) = 9 then newline() )$
      0 1 1 2 3 5 8 13 21 34
      55 89 144 233 377 610 987 1597 2584 4181
      6765 10946 17711

Funktion: writebyte (byte, stream)

  Schreibt das Byte byte in den binären Ausgabestrom stream. `writebyte` gibt `byte` zurück.

  Beispiel: Es werden Bytes in eine Binärdatei geschrieben. In diesem Beispiel entsprechen sämtliche Bytes druckbaren Zeichen, die mit Hilfe von `printfile` ausgegeben werden können. Die Bytes verbleiben so lange im Datenstrom, bis die Funktionen `flush_output` oder `close` aufgerufen werden.

      (%i1) ibase: obase: 16.$

      (%i2) bytes: string_to_octets("GNU/Linux");
      (%o2)                [47, 4E, 55, 2F, 4C, 69, 6E, 75, 78]
      (%i3) out: openw_binary("test.bin");
      (%o3)                      #<output stream test.bin>
      (%i4) for i thru 3 do writebyte(bytes[i], out);
      (%o4)                                done
      (%i5) printfile("test.bin")$

      (%i6) flength(out);
      (%o6)                                  0
      (%i7) flush_output(out);
      (%o7)                                true
      (%i8) flength(out);
      (%o8)                                  3
      (%i9) printfile("test.bin")$
      GNU
      (%i0A) for b in rest(bytes,3) do writebyte(b, out);
      (%o0A)                               done
      (%i0B) close(out);
      (%o0B)                               true
      (%i0C) printfile("test.bin")$
      GNU/Linux

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 73.3 Schriftzeichen

In Maxima sind Schriftzeichen Zeichenketten der Länge 1.

Function: adjust_external_format ()

  Gibt Informationen zum aktuellen externen Format des Lisp Lesers aus und in dem Fall, dass die Kodierung des externen Formats nicht mit der Kodierung der Anwendung, in der Maxima läuft, übereinstimmt, versucht `adjust_external_format`, die Kodierung anzupassen oder gibt entsprechende Hilfen oder Anleitungen aus. `adjust_external_format` gibt `true` zurück, wenn das externe Format geändert wurde und `false`, wenn nicht.

  Funktionen wie cint, unicode, octets_to_string und string_to_octets benötigen UTF-8 als das externe Format des Lisp Lesers, um über dem vollständigen Bereich der Unicode-Zeichen korrekt arbeiten zu können.

  Beispiele (Maxima in Windows, März 2016): Die Verwendung von `adjust_external_format` in dem Fall, dass das externe Format nicht mit der Kodierung der Anwendung, in der Maxima läuft, übereinstimmt.

  1. Maxima in der Kommandozeile

  Für die Sitzung in einem Terminal wird empfohlen, ein mit SBCL kompiliertes Maxima zu verwenden. Unicode wird hier standardmäßig unterstützt und ein Aufruf von `adjust_external_format` ist nicht notwendig.

  Falls Maxima mit CLISP oder GCL kompiliert wurde, wird empfohlen, die Kodierung des Terminals von CP850 in CP1252 abzuändern. `adjust_external_format` gibt eine entsprechende Hilfe aus.

  CCL liest UTF-8, obwohl der Input vom Terminal standardmäßig in CP850 kodiert ist. CP1252 wird jedoch von CCL nicht unterstützt. `adjust_external_format` gibt deshalb eine Anleitung aus, wie die Kodierung des Terminals und die des externen Formats beide auf ISO-8859-1 abgeändert werden können.

  2. wxMaxima

  In wxMaxima liest SBCL standardmäßig CP1252. Der Input von der Anwendung (wxMaxima) ist jedoch UTF-8-kodiert. Hier ist eine Anpassung erforderlich.

  Ein Aufruf von `adjust_external_format` und ein Neustart von Maxima ändern das standardmäßige externe Format auf UTF-8.

      (%i1)adjust_external_format();
      The line
      (setf sb-impl::*default-external-format* :utf-8)
      has been appended to the init file
      C:/Users/Username/.sbclrc
      Please restart Maxima to set the external format to UTF-8.
      (%i1) false

  Maxima wird neu gestartet.

      (%i1) adjust_external_format();
      The external format is currently UTF-8
      and has not been changed.
      (%i1) false

Function: alphacharp (char)

  Gibt `true` zurück, falls char ein Buchstabe eines Alphabets ist.

  Um ein Nicht-US-ASCII-Zeichen als Buchstaben eines Alphabets erkennen zu können, muss das unter Maxima liegende Lisp Unicode voll unterstützen. So wird z.B. ein Umlaut mit SBCL in GNU/Linux als Buchstabe erkannt, mit GCL jedoch nicht. (In Windows muss ein mit SBCL kompiliertes Maxima auf UTF-8 umgestellt worden sein. Siehe hierzu adjust_external_format.)

  Beispiele:

  Das unter Maxima liegende Lisp (SBCL, GNU/Linux) kann das eingegebene Zeichen in ein Lisp-Schriftzeichen umwandeln und untersuchen.

      (%i1) alphacharp("ü");
      (%o1)                          true

  Mit GCL ist dies nicht möglich. Es kommt zu einem Fehlerabbruch.

      (%i1) alphacharp("u");
      (%o1)                          true
      (%i2) alphacharp("ü");

      package stringproc: ü cannot be converted into a Lisp character.
       -- an error.

Function: alphanumericp (char)

  Gibt `true` zurück, falls char ein Buchstabe eines Alphabets oder ein Zahlzeichen ist (als Zahlzeichen werden hier nur entprechende US-ASCII-Zeichen betrachtet).

  Hinweis: Siehe Bemerkungen zu alphacharp.

Funktion: ascii (int)

  Gibt das US-ASCII-Zeichen zurück, das der Ganzzahl int entspricht. int muss dabei kleiner als `128` sein.

  Siehe unicode für die Umwandlung von Codepunkten größer `127`.

  Beispiele:

      (%i1) for n from 0 thru 127 do (
              ch: ascii(n),
              if alphacharp(ch) then sprint(ch),
              if n = 96 then newline() )$
      A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
      a b c d e f g h i j k l m n o p q r s t u v w x y z

Function: cequal (char_1, char_2)

  Gibt `true` zurück, falls char_1 und char_2 ein und das selbe Schriftzeichen sind.

Function: cequalignore (char_1, char_2)

  Arbeitet wie cequal, ignoriert jedoch die Groß- und Kleinschreibung, was für Nicht-US-ASCII-Zeichen nur möglich ist, wenn das unter Maxima liegende Lisp einen Buchstaben auch als Buchstaben eines Alphabets erkennen kann. Siehe hierzu die Bemerkungen zu alphacharp.

Function: cgreaterp (char_1, char_2)

  Gibt `true` zurück, wenn der Codepunkt des Zeichens char_1 größer ist als der des Zeichens char_2.

Funktion: cgreaterpignore (char_1, char_2)

  Arbeitet wie cgreaterp, ignoriert jedoch die Groß- und Kleinschreibung, was für Nicht-US-ASCII-Zeichen nur möglich ist, wenn das unter Maxima liegende Lisp einen Buchstaben auch als Buchstaben eines Alphabets erkennen kann. Siehe hierzu die Bemerkungen zu alphacharp.

Funktion: charp (obj)

  Gibt `true` zurück, wenn obj ein Schriftzeichen ist.

  Beispiel: Siehe Einführung.

Funktion: cint (char)

  Gibt den Unicode Codepunkt des Arguments char zurück, das ein Schriftzeichen sein muss, d.h. eine Zeichenkette der Länge `1`.

  Beispiele: Der hexadedimale Codepunkt von Schriftzeichen (Maxima kompiliert mit SBCL in GNU/Linux).

      (%i1) obase: 16.$
      (%i2) map(cint, ["$","£","€"]);
      (%o2)                           [24, 0A3, 20AC]

  Warnung: In Windows ist es nicht möglich, Schriftzeichen, die Codepunkten größer 16 Bit entsprechen, in wxMaxima einzugeben, wenn Maxima mit SBCL kompiliert wurde und das aktuelle externe Format nicht UTF-8 ist. Siehe adjust_external_format für weitere Informationen.

  CMUCL verarbeitet solche Zeichen nicht als ein einziges Zeichen und `cint` gibt dann `false` zurück. Als Ausweg kann hier die Umwandlung von Schriftzeichen in Codepunkte über UTF-8-Oktette dienen:
  `utf8_to_unicode(string_to_octets(character));`

  Siehe utf8_to_unicode, string_to_octets.

Function: clessp (char_1, char_2)

  Gibt `true` zurück, wenn der Codepunkt des Zeichens char_1 kleiner ist als der des Zeichens char_2.

Funktion: clesspignore (char_1, char_2)

  Arbeitet wie clessp, ignoriert jedoch die Groß- und Kleinschreibung, was für Nicht-US-ASCII-Zeichen nur möglich ist, wenn das unter Maxima liegende Lisp einen Buchstaben auch als Buchstaben eines Alphabets erkennen kann. Siehe hierzu die Bemerkungen zu alphacharp.

Funktion: constituent (char)

  Gibt `true` zurück, wenn char ein graphisches Schriftzeichen, aber kein Leerzeichen ist. Ein graphisches Schriftzeichen ist ein Leerzeichen oder ein Zeichen, das man sehen kann. (`constituent` wurde definiert von Paul Graham. Siehe Paul Graham, ANSI Common Lisp, 1996, Seite 67.)

  Beispiel:

      (%i1) for n from 0 thru 255 do (
      tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
      ! " #  %  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B
      C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c
      d e f g h i j k l m n o p q r s t u v w x y z { | } ~

  Hinweis: Siehe Bemerkungen zu alphacharp.

Funktion: digitcharp (char)

  Gibt `true` zurück, wenn char ein Zahlzeichen ist, wobei als Zahlzeichen hier nur entsprechende US-ASCII-Zeichen betrachtet werden.

Funktion: lowercasep (char)

  Gibt `true` zurück, wenn char ein Kleinbuchstabe ist.

  Hinweis: Siehe Bemerkungen zu alphacharp.

Variable: newline

  Das Steuerzeichen für den Zeilenvorschub (ASCII-Zeichen 10).

Variable: space

  Das Leerzeichen.

Variable: tab

  Das Tabulatorzeichen.

Funktion: unicode (arg)

  Gibt das durch arg definierte Schriftzeichen zurück. arg kann ein Unicode Codepunkt oder auch eine Zeichenkette mit einem Namen sein, falls das unter Maxima liegende Lisp Unicode vollständig unterstützt.

  Beispiel: Durch hexadezimale Codepunkte definierte Schriftzeichen (Maxima kompiliert mit SBCL in GNU/Linux).

      (%i1) ibase: 16.$
      (%i2) map(unicode, [24, 0A3, 20AC]);
      (%o2)                            [$, £, €]

  Warnung: In wxMaxima in Windows ist es nicht möglich, Codepunkte größer 16 Bit in Schriftzeichen umzuwandeln, wenn Maxima mit SBCL kompiliert wurde und das aktuelle externe Format nicht UTF-8 ist. Siehe adjust_external_format für weitere Informationen.

  CMUCL verarbeitet keine Codepunkte größer 16 Bit. `unicode` gibt dann `false` zurück. Als Ausweg kann hier die Umwandlung der Codepunkte in Schriftzeichen über UTF-8-Oktette dienen:

  `octets_to_string(unicode_to_utf8(code_point));`

  Siehe octets_to_string, unicode_to_utf8.

  Falls das unter Maxima liegende Lisp Unicode vollständig unterstützt, kann ein Schriftzeichen durch seinen Namen angegeben werden.

  Das folgende Beispiel ist mit ECL, CLISP und SBCL möglich, wobei mit SBCL in wxMaxima in Windows das externe Format auf UTF-8 gesetzt werden muss. `unicode(name)` wird auch von CMUCL unterstützt, jedoch wieder beschränkt auf 16-Bit-Zeichen.

  Die Zeichenkette als Argument für `unicode` muss prinzipiell die sein, die `printf` mit der Spezifikation "~@c" zurück gibt, jedoch, wie unten gezeigt, ohne den Präfix "#\". Unterstriche können durch Leerzeichen und Groß- durch Kleinbuchstaben ersetzt werden.

  Beispiel (fortgesetzt): Ein Schriftzeichen ist durch seinen Namen gegeben (Maxima kompiliert mit SBCL in GNU/Linux).

      (%i3) printf(false, "~@c", unicode(0DF));
      (%o3)                    #\LATIN_SMALL_LETTER_SHARP_S
      (%i4) unicode("LATIN_SMALL_LETTER_SHARP_S");
      (%o4)                                  ß
      (%i5) unicode("Latin small letter sharp S");
      (%o5)                                  ß

Funktion: unicode_to_utf8 (code_point)

  Gibt eine Liste mit UTF-8-Code zurück, der dem Unicode code_point entspricht.

  Beispiel: Umwandlung von Unicode Codepunkten in UTF-8 und umgekehrt.

      (%i1) ibase: obase: 16.$
      (%i2) map(cint, ["$","£","€"]);
      (%o2)                           [24, 0A3, 20AC]
      (%i3) map(unicode_to_utf8, %);
      (%o3)                 [[24], [0C2, 0A3], [0E2, 82, 0AC]]
      (%i4) map(utf8_to_unicode, %);
      (%o4)                           [24, 0A3, 20AC]

Funktion: uppercasep (char)

  Gibt `true` zurück, wenn char ein Großbuchstabe ist.

  Hinweis: Siehe Bemerkungen zu alphacharp.

Variable: us_ascii_only

  Diese Optionsvariable beeinflusst Maxima, wenn die Zeichenkodierung der Anwendung, in der Maxima läuft, UTF-8 ist, das externe Format des Lisp Readers jedoch nicht.

  In GNU/Linux trifft dies zu, wenn Maxima mit GCL kompiliert wurde und in Windows in wxMaxima in GCL- und SBCL-Versionen. Es wird empfohlen, in der SBCL-Version das externe Format in UTF-8 abzuändern. Eine Festlegung von `us_ascii_only` wird damit unnötig. Siehe adjust_external_format für Details.

  `us_ascii_only` ist standardmäßig `false`. Maxima analysiert dann (d.h. in der oben beschriebenen Situation) selbst die UTF-8-Kodierung.

  Wurde `us_ascii_only` auf `true` gesetzt, wird angenommen, dass alle Zeichenketten, die als Argumente für Funktionen des Pakets `stringproc` verwendet werden, nur ausschließlich US-ASCII-Zeichen enthalten. Durch diese Vereinbarung wird die UTF-8-Analyse des Inputs überflüssig und Zeichenketten können effizienter verarbeitet werden.

Function: utf8_to_unicode (list)

  Gibt den Unicode Codepunkt zurück, der der Liste list entspricht, die die UTF-8-Kodierung eines einzelnen Schriftzeichens enthalten muss.

  Beispiel: Siehe unicode_to_utf8.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 73.4 Verarbeitung von Zeichenketten

Positionsindizes in Strings sind in Maxima genau so wie Listen 1-indiziert. Siehe hierzu das Beispiel in charat.

Funktion: charat (string, n)

  Gibt das n-te Schriftzeichen in string zurück. Das erste Zeichen in string erhält man mit n = 1.

  Beispiel:

      (%i1) charat("Lisp",1);
      (%o1)                           L
      (%i2) charlist("Lisp")[1];
      (%o2)                           L

Funktion: charlist (string)

  Gibt eine Liste mit allen Schriftzeichen in string zurück.

  Beispiel:

      (%i1) charlist("Lisp");
      (%o1)                     [L, i, s, p]

Function: eval_string (str)

  Parse the string str as a Maxima expression and evaluate it. The string str may or may not have a terminator (dollar sign `$` or semicolon `;`). Only the first expression is parsed and evaluated, if there is more than one.

  Complain if str is not a string.

  See also parse_string.

  Examples:

      (%i1) eval_string ("foo: 42; bar: foo^2 + baz");
      (%o1)                       42
      (%i2) eval_string ("(foo: 42, bar: foo^2 + baz)");
      (%o2)                   baz + 1764

Function: parse_string (str)

  Parse the string str as a Maxima expression (do not evaluate it). The string str may or may not have a terminator (dollar sign `$` or semicolon `;`). Only the first expression is parsed, if there is more than one.

  Complain if str is not a string.

  See also eval_string.

  Examples:

      (%i1) parse_string ("foo: 42; bar: foo^2 + baz");
      (%o1)                    foo : 42
      (%i2) parse_string ("(foo: 42, bar: foo^2 + baz)");
                                         2
      (%o2)          (foo : 42, bar : foo  + baz)

Funktion: scopy (string)

  Gibt eine Kopie der Zeichenkette string als neue Zeichenkette zurück.

Funktion: sdowncase (string)
Funktion: sdowncase (string, start)
Funktion: sdowncase (string, start, end)

  Arbeitet wie supcase, jedoch werden Groß- in Kleinbuchstaben umgewandelt.

Funktion: sequal (string_1, string_2)

  Gibt `true` zurück, wenn string_1 und string_2 die selbe Zeichensequenz enthalten.

Funktion: sequalignore (string_1, string_2)

  Arbeitet wie sequal, ignoriert jedoch die Groß- und Kleinschreibung, was für Nicht-US-ASCII-Zeichen nur möglich ist, wenn das unter Maxima liegende Lisp einen Buchstaben auch als Buchstaben eines Alphabets erkennen kann. Siehe hierzu die Bemerkungen zu alphacharp.

Funktion: sexplode (string)

  `sexplode` ist ein Alias für die Funktion charlist.

Function: simplode (list)
Function: simplode (list, delim)

  `simplode` takes a list of expressions and concatenates them into a string. If no delimiter delim is specified, `simplode` uses no delimiter. delim can be any string.

  Examples:

      (%i1) simplode(["xx[",3,"]:",expand((x+y)^3)]);
      (%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
      (%i2) simplode( sexplode("stars")," * " );
      (%o2)                   s * t * a * r * s
      (%i3) simplode( ["One","more","coffee."]," " );
      (%o3)                   One more coffee.

Function: sinsert (seq, string, pos)

  Returns a string that is a concatenation of `substring (string, 1, pos - 1)`, the string seq and `substring (string, pos)`. Note that the first character in string is in position 1.

  Examples:

      (%i1) s: "A submarine."$
      (%i2) concat( substring(s,1,3),"yellow ",substring(s,3) );
      (%o2)                  A yellow submarine.
      (%i3) sinsert("hollow ",s,3);
      (%o3)                  A hollow submarine.

Function: sinvertcase (string)
Function: sinvertcase (string, start)
Function: sinvertcase (string, start, end)

  Returns string except that each character from position start to end is inverted. If end is not given, all characters from start to the end of string are replaced.

  Examples:

      (%i1) sinvertcase("sInvertCase");
      (%o1)                      SiNVERTcASE

Funktion: slength (string)

  Gibt die Anzahl der Zeichen in der Zeichenkette string zurück.

Funktion: smake (num, char)

  Gibt eine neue Zeichenkette mit num Zeichen char zurück.

  Beispiel:

      (%i1) smake(3,"w");
      (%o1)                          www

Function: smismatch (string_1, string_2)
Function: smismatch (string_1, string_2, test)

  Returns the position of the first character of string_1 at which string_1 and string_2 differ or `false`. Default test function for matching is sequal. If `smismatch` should ignore case, use sequalignore as test.

  Example:

      (%i1) smismatch("seven","seventh");
      (%o1)                           6

Function: split (string)
Function: split (string, delim)
Function: split (string, delim, multiple)

  Returns the list of all tokens in string. Each token is an unparsed string. `split` uses delim as delimiter. If delim is not given, the space character is the default delimiter. multiple is a boolean variable with `true` by default. Multiple delimiters are read as one. This is useful if tabs are saved as multiple space characters. If multiple is set to `false`, each delimiter is noted.

  Examples:

      (%i1) split("1.2   2.3   3.4   4.5");
      (%o1)                 [1.2, 2.3, 3.4, 4.5]
      (%i2) split("first;;third;fourth",";",false);
      (%o2)               [first, , third, fourth]

Function: sposition (char, string)

  Returns the position of the first character in string which matches char. The first character in string is in position 1. For matching characters ignoring case see ssearch.

Function: sremove (seq, string)
Function: sremove (seq, string, test)
Function: sremove (seq, string, test, start)
Function: sremove (seq, string, test, start, end)

  Returns a string like string but without all substrings matching seq. Default test function for matching is sequal. If `sremove` should ignore case while searching for seq, use sequalignore as test. Use start and end to limit searching. Note that the first character in string is in position 1.

  Examples:

      (%i1) sremove("n't","I don't like coffee.");
      (%o1)                   I do like coffee.
      (%i2) sremove ("DO ",%,'sequalignore);
      (%o2)                    I like coffee.

Function: sremovefirst (seq, string)
Function: sremovefirst (seq, string, test)
Function: sremovefirst (seq, string, test, start)
Function: sremovefirst (seq, string, test, start, end)

  Like `sremove` except that only the first substring that matches `seq` is removed.

Funktion: sreverse (string)

  Gibt eine Zeichenkette mit allen Zeichen von string in umgekehrter Reihenfolge zurück.

Function: ssearch (seq, string)
Function: ssearch (seq, string, test)
Function: ssearch (seq, string, test, start)
Function: ssearch (seq, string, test, start, end)

  Returns the position of the first substring of string that matches the string seq. Default test function for matching is sequal. If `ssearch` should ignore case, use sequalignore as test. Use start and end to limit searching. Note that the first character in string is in position 1.

      (%i1) ssearch("~s","~{~S ~}~%",'sequalignore);
      (%o1)                                  4

Function: ssort (string)
Function: ssort (string, test)

  Returns a string that contains all characters from string in an order such there are no two successive characters c and d such that `test (c, d)` is `false` and `test (d, c)` is `true`. Default test function for sorting is clessp. The set of test functions is `{clessp, clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore}`.

      (%i1) ssort("I don't like Mondays.");
      (%o1)                    '.IMaddeiklnnoosty
      (%i2) ssort("I don't like Mondays.",'cgreaterpignore);
      (%o2)                 ytsoonnMlkIiedda.'

Function: ssubst (new, old, string)
Function: ssubst (new, old, string, test)
Function: ssubst (new, old, string, test, start)
Function: ssubst (new, old, string, test, start, end)

  Returns a string like string except that all substrings matching old are replaced by new. old and new need not to be of the same length. Default test function for matching is sequal. If `ssubst` should ignore case while searching for old, use sequalignore as test. Use start and end to limit searching. Note that the first character in string is in position 1.

      (%i1) ssubst("like","hate","I hate Thai food. I hate green tea.");
      (%o1)          I like Thai food. I like green tea.
      (%i2) ssubst("Indian","thai",%,'sequalignore,8,12);
      (%o2)         I like Indian food. I like green tea.

Function: ssubstfirst (new, old, string)
Function: ssubstfirst (new, old, string, test)
Function: ssubstfirst (new, old, string, test, start)
Function: ssubstfirst (new, old, string, test, start, end)

  Like subst except that only the first substring that matches old is replaced.

Function: strim (seq,string)

  Returns a string like string, but with all characters that appear in seq removed from both ends.

      (%i1) "/* comment */"$
      (%i2) strim(" /*",%);
      (%o2)                        comment
      (%i3) slength(%);
      (%o3)                           7

Function: striml (seq, string)

  Like strim except that only the left end of string is trimmed.

Function: strimr (seq, string)

  Like strim except that only the right end of string is trimmed.

Funktion: stringp (obj)

  Gibt `true` zurück, wenn obj eine Zeichenkette ist.

  Beispiel: Siehe Einführung.

Function: substring (string, start)
Function: substring (string, start, end)

  Returns the substring of string beginning at position start and ending at position end. The character at position end is not included. If end is not given, the substring contains the rest of the string. Note that the first character in string is in position 1.

      (%i1) substring("substring",4);
      (%o1)                        string
      (%i2) substring(%,4,6);
      (%o2)                          in

Function: supcase (string)
Function: supcase (string, start)
Function: supcase (string, start, end)

  Returns string except that lowercase characters from position start to end are replaced by the corresponding uppercase ones. If end is not given, all lowercase characters from start to the end of string are replaced.

      (%i1) supcase("english",1,2);
      (%o1)                        English

Function: tokens (string)
Function: tokens (string, test)

  Returns a list of tokens, which have been extracted from string. The tokens are substrings whose characters satisfy a certain test function. If test is not given, constituent is used as the default test. `{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp}` is the set of test functions. (The Lisp-version of `tokens` is written by Paul Graham. ANSI Common Lisp, 1996, page 67.)

      (%i1) tokens("24 October 2005");
      (%o1)                  [24, October, 2005]
      (%i2) tokens("05-10-24",'digitcharp);
      (%o2)                     [05, 10, 24]
      (%i3) map(parse_string,%);
      (%o3)                      [5, 10, 24]

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 73.5 Oktette und Werkzeuge für die Kryptographie

Funktion: base64 (arg)

  Gibt eine Base64-Darstellung von arg zurück. Das Argument arg kann eine Zeichenkette, eine nicht-negative Ganzzahl oder eine Liste von Oktetten sein.

  Beispiel:

      (%i1) base64: base64("foo bar baz");
      (%o1)                          Zm9vIGJhciBiYXo=
      (%i2) string: base64_decode(base64);
      (%o2)                            foo bar baz
      (%i3) obase: 16.$
      (%i4) integer: base64_decode(base64, 'number);
      (%o4)                       666f6f206261722062617a
      (%i5) octets: base64_decode(base64, 'list);
      (%o5)            [66, 6F, 6F, 20, 62, 61, 72, 20, 62, 61, 7A]
      (%i6) ibase: 16.$
      (%i7) base64(octets);
      (%o7)                          Zm9vIGJhciBiYXo=

  Sind in arg Umlaute oder Eszett enthalten (bzw. Oktette größer als 127), ist das Ergebnis von der verwendeten Plattform abhängig. Es wird aber durch eine Anwendung von base64_decode in jedem Fall wieder in die ursprüngliche Zeichenkette zurück verwandelt.

Funktion: base64_decode (base64-string)
Funktion: base64_decode (base64-string, return-type)

  Dekodiert die Base64-kodierte Zeichenkette base64-string standardmäßig wieder zurück in die ursprüngliche Zeichenkette.

  Das optionale Argument return-type erlaubt es `base64_decode`, alternativ hierzu auch die entsprechende Ganzzahl oder Liste von Oktetten zurück zu geben. return-type kann `string`, `number` oder `list` sein.

  Beispiel: Siehe base64.

Funktion: crc24sum (octets)
Funktion: crc24sum (octets, return-type)

  Gibt standardmäßig die `CRC24`-Prüfsumme einer Oktett-Liste als Zeichenkette zurück.

  Das optionale Argument return-type erlaubt es `crc24sum`, alternativ hierzu auch die entsprechende Ganzzahl oder Liste von Oktetten zurück zu geben. return-type kann `string`, `number` oder `list` sein.

  Beispiel:

      -----BEGIN PGP SIGNATURE-----
      Version: GnuPG v2.0.22 (GNU/Linux)

      iQEcBAEBAgAGBQJVdCTzAAoJEG/1Mgf2DWAqCSYH/AhVFwhu1D89C3/QFcgVvZTM
      wnOYzBUURJAL/cT+IngkLEpp3hEbREcugWp+Tm6aw3R4CdJ7G3FLxExBH/5KnDHi
      rBQu+I7+3ySK2hpryQ6Wx5J9uZSa4YmfsNteR8up0zGkaulJeWkS4pjiRM+auWVe
      vajlKZCIK52P080DG7Q2dpshh4fgTeNwqCuCiBhQ73t8g1IaLdhDN6EzJVjGIzam
      /spqT/sTo6sw8yDOJjvU+Qvn6/mSMjC/YxjhRMaQt9EMrR1AZ4ukBF5uG1S7mXOH
      WdiwkSPZ3gnIBhM9SuC076gLWZUNs6NqTeE3UzMjDAFhH3jYk1T7mysCvdtIkms=
      =WmeC
      -----END PGP SIGNATURE-----

      (%i1) ibase : obase : 16.$
      (%i2) sig64 : sconcat(
       "iQEcBAEBAgAGBQJVdCTzAAoJEG/1Mgf2DWAqCSYH/AhVFwhu1D89C3/QFcgVvZTM",
       "wnOYzBUURJAL/cT+IngkLEpp3hEbREcugWp+Tm6aw3R4CdJ7G3FLxExBH/5KnDHi",
       "rBQu+I7+3ySK2hpryQ6Wx5J9uZSa4YmfsNteR8up0zGkaulJeWkS4pjiRM+auWVe",
       "vajlKZCIK52P080DG7Q2dpshh4fgTeNwqCuCiBhQ73t8g1IaLdhDN6EzJVjGIzam",
       "/spqT/sTo6sw8yDOJjvU+Qvn6/mSMjC/YxjhRMaQt9EMrR1AZ4ukBF5uG1S7mXOH",
       "WdiwkSPZ3gnIBhM9SuC076gLWZUNs6NqTeE3UzMjDAFhH3jYk1T7mysCvdtIkms=" )$
      (%i3) octets: base64_decode(sig64, 'list)$
      (%i4) crc24: crc24sum(octets, 'list);
      (%o4)                          [5A, 67, 82]
      (%i5) base64(crc24);
      (%o5)                              WmeC

Funktion: md5sum (arg)
Funktion: md5sum (arg, return-type)

  Gibt die `md5`-Prüfsumme einer Zeichenkette, einer nicht-negativen Ganzzahl oder einer Liste von Oktetten zurück. Der standardmäßige Rückgabewert ist eine Zeichenkette mit 32 hexadezimalen Zeichen.

  Das optionale Argument return-type erlaubt es `md5sum`, alternativ hierzu auch die entsprechende Ganzzahl oder Liste von Oktetten zurück zu geben. return-type kann `string`, `number` oder `list` sein.

  Beispiel:

      (%i1) ibase: obase: 16.$
      (%i2) msg: "foo bar baz"$
      (%i3) string: md5sum(msg);
      (%o3)                  ab07acbb1e496801937adfa772424bf7
      (%i4) integer: md5sum(msg, 'number);
      (%o4)                 0ab07acbb1e496801937adfa772424bf7
      (%i5) octets: md5sum(msg, 'list);
      (%o5)        [0AB,7,0AC,0BB,1E,49,68,1,93,7A,0DF,0A7,72,42,4B,0F7]
      (%i6) sdowncase( printf(false, "~{~2,'0x~^:~}", octets) );
      (%o6)           ab:07:ac:bb:1e:49:68:01:93:7a:df:a7:72:42:4b:f7

  Sind in arg Umlaute oder andere Nicht-US-ASCII-Zeichen enthalten (bzw. Oktette größer als 127), ist das Ergebnis von der verwendeten Plattform abhängig.

Funktion: mgf1_sha1 (seed, len)
Funktion: mgf1_sha1 (seed, len, return-type)

  Gibt eine Pseudozufallszahl variabler Länge zurück. Standardmäßig ist dies eine Zahl mit einer Länge von len Oktetten.

  Das optionale Argument return-type erlaubt es `mgf1_sha1`, alternativ hierzu die Liste mit den len entsprechenden Oktetten zurück zu geben. return-type kann `number` oder `list` sein.

  Die Berechnung des Rückgabewerts wird in der `RFC 3447` im Anhang `B.2.1 MGF1` beschrieben. Verwendet wird dabei `SHA1` als Hashfunktion, d.h. die Zufälligkeit der berechneten Zahl beruht auf der Zufälligkeit von `SHA1`-Hashwerten.

  Beispiel:

      (%i1) ibase: obase: 16.$
      (%i2) number: mgf1_sha1(4711., 8);
      (%o2)                        0e0252e5a2a42fea1
      (%i3) octets: mgf1_sha1(4711., 8, 'list);
      (%o3)                  [0E0,25,2E,5A,2A,42,0FE,0A1]

Funktion: number_to_octets (number)

  Gibt eine Oktett-Darstellung der nicht-negativen Ganzzahl number in Form einer Liste zurück.

  Beispiel:

      (%i1) ibase : obase : 16.$
      (%i2) octets: [0ca,0fe,0ba,0be]$
      (%i3) number: octets_to_number(octets);
      (%o3)                            0cafebabe
      (%i4) number_to_octets(number);
      (%o4)                      [0CA, 0FE, 0BA, 0BE]

Funktion: octets_to_number (octets)

  Fügt die in der Liste octets enthaltenden Oktette zu einer Zahl zusammen und gibt diese zurück.

  Beispiel: Siehe number_to_octets.

Funktion: octets_to_oid (octets)

  Berechnet eine Objektkennung (OID) aus einer Liste von Oktetten.

  Beispiel: RSA encryption OID

      (%i1) ibase : obase : 16.$
      (%i2) oid: octets_to_oid([2A,86,48,86,0F7,0D,1,1,1]);
      (%o2)                      1.2.840.113549.1.1.1
      (%i3) oid_to_octets(oid);
      (%o3)               [2A, 86, 48, 86, 0F7, 0D, 1, 1, 1]

Funktion: octets_to_string (octets)
Funktion: octets_to_string (octets, encoding)

  Dekodiert den aktuellen Systemstandards entsprechend die Liste octets in eine Zeichenkette. Bei der Dekodierung von Oktetten, die nicht ausschließlich US-ASCII-Zeichen entsprechen, ist das Ergebnis abhängig von der Plattform, der Anwendung und vom unter Maxima liegenden Lisp.

  Beispiel: Die Verwendung des Systemstandards (Maxima kompiliert mit GCL, das keine Format-Definition verwendet und die vom GNU/Linux Terminal kodierten UTF-8-Oktette ungeändert an Maxima weitergibt).

      (%i1) octets: string_to_octets("abc");
      (%o1)                            [61, 62, 63]
      (%i2) octets_to_string(octets);
      (%o2)                                 abc
      (%i3) ibase: obase: 16.$
      (%i4) unicode(20AC);
      (%o4)                                  €
      (%i5) octets: string_to_octets(%);
      (%o5)                           [0E2, 82, 0AC]
      (%i6) octets_to_string(octets);
      (%o6)                                  €
      (%i7) utf8_to_unicode(octets);
      (%o7)                                20AC

  In dem Fall, dass UTF-8 das externe Format des Lisp Readers ist, kann das optionale Argument encoding genutzt werden, um für die Oktett-String-Umwandlung eine gewÃ¼nschte Kodierung auszuwählen. Siehe adjust_external_format, falls es notwendig sein sollte, hierfür das externe Format zu ändern.

  Die Namen einiger unterstützter Kodierungen (weitere siehe das entsprechende Lisp Manual):
  CCL, CLISP, SBCL: `utf-8, ucs-2be, ucs-4be, iso-8859-1, cp1252, cp850`
  CMUCL: `utf-8, utf-16-be, utf-32-be, iso8859-1, cp1252`
  ECL: `utf-8, ucs-2be, ucs-4be, iso-8859-1, windows-cp1252, dos-cp850`

  Beispiel (fortgesetzt): Die Verwendung des optionalen Arguments (Maxima kompiliert mit SBCL, GNU/Linux Terminal).

      (%i8) string_to_octets("€", "ucs-2be");
      (%o8)                              [20, 0AC]

Funktion: oid_to_octets (oid-string)

  Verwandelt eine Objektkennung (OID) in eine Liste von Oktetten.

  Beispiel: Siehe octets_to_oid.

Funktion: sha1sum (arg)
Funktion: sha1sum (arg, return-type)

  Gibt den `SHA1`-Fingerabdruck einer Zeichenkette, einer nicht-negativen Ganzzahl oder einer Liste von Oktetten zurück. Der standardmäßige Rückgabewert ist eine Zeichenkette mit 40 hexadezimalen Zeichen.

  Das optionale Argument return-type erlaubt es `sha1sum`, alternativ hierzu auch die entsprechende Ganzzahl oder Liste von Oktetten zurück zu geben. return-type kann `string`, `number` oder `list` sein.

  Beispiel:

      (%i1) ibase: obase: 16.$
      (%i2) msg: "foo bar baz"$
      (%i3) string: sha1sum(msg);
      (%o3)              c7567e8b39e2428e38bf9c9226ac68de4c67dc39
      (%i4) integer: sha1sum(msg, 'number);
      (%o4)             0c7567e8b39e2428e38bf9c9226ac68de4c67dc39
      (%i5) octets: sha1sum(msg, 'list);
      (%o5)  [0C7,56,7E,8B,39,0E2,42,8E,38,0BF,9C,92,26,0AC,68,0DE,4C,67,0DC,39]
      (%i6) sdowncase( printf(false, "~{~2,'0x~^:~}", octets) );
      (%o6)     c7:56:7e:8b:39:e2:42:8e:38:bf:9c:92:26:ac:68:de:4c:67:dc:39

  Sind in arg Umlaute oder andere Nicht-US-ASCII-Zeichen enthalten (bzw. Oktette größer als 127), ist der `SHA1`-Fingerabdruck von der verwendeten Plattform abhängig.

Funktion: sha256sum (arg)
Funktion: sha256sum (arg, return-type)

  Gibt den `SHA256`-Fingerabdruck einer Zeichenkette, einer nicht-negativen Ganzzahl oder einer Liste von Oktetten zurück. Der standardmäßige Rückgabewert ist eine Zeichenkette mit 64 hexadezimalen Zeichen.

  Das optionale Argument return-type erlaubt es `sha256sum`, alternativ hierzu auch die entsprechende Ganzzahl oder Liste von Oktetten zurück zu geben (siehe sha1sum).

  Beispiel:

      (%i1) string: sha256sum("foo bar baz");
      (%o1)  dbd318c1c462aee872f41109a4dfd3048871a03dedd0fe0e757ced57dad6f2d7

  Sind in arg Umlaute oder andere Nicht-US-ASCII-Zeichen enthalten (bzw. Oktette größer als 127), ist der `SHA256`-Fingerabdruck von der verwendeten Plattform abhängig.

Funktion: string_to_octets (string)
Funktion: string_to_octets (string, encoding)

  Kodiert den aktuellen Systemstandards entsprechend die Zeichenkette string in eine Liste von Oktetten. Bei der Kodierung von Zeichenketten, die nicht ausschließlich US-ASCII-Zeichen enthalten, ist das Ergebnis abhängig von der Plattform, der Anwendung und vom unter Maxima liegenden Lisp.

  In dem Fall, dass UTF-8 das externe Format des Lisp Readers ist, kann das optionale Argument encoding genutzt werden, um für die String-Oktett-Umwandlung eine gewÃ¼nschte Kodierung auszuwählen. Siehe adjust_external_format, falls es notwendig sein sollte, hierfür das externe Format zu ändern.

  Siehe octets_to_string für Beispiele und zusätzliche Informationen.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by U-Cygwin\ASSI on Oktober, 20 2018 using texi2html 1.76.