Joachim Mohr   Mathematik Musik Delphi
Suche

zur Seite 1

Delphi

Delphi
   Die Programmiersprache 
Seite 2

Delphi


  • Download des Programms zum Darstellen von Multiplikationstafeln der Gruppe Zn: hier klicken
    Zum Beispiel:
    Multiplikationstabelle für Z modulo 10 (kein Integritätsbereich!)
    * 1 2 3 4 5 6 7 8 9
    1 1 2 3 4 5 6 7 8 9
    2 2 4 6 8 0 2 4 6 8
    3 3 6 9 2 5 8 1 4 7
    4 4 8 2 6 0 4 8 2 6
    5 5 0 5 0 5 0 5 0 5
    6 6 2 8 4 0 6 2 8 4
    7 7 4 1 8 5 2 9 6 3
    8 8 6 4 2 0 8 6 4 2
    9 9 8 7 6 5 4 3 2 1


    x 1 2 3 4 5 6 7 8 9
    Inverses 1 - 7 - - - 3 - 9
                Multiplikationstabelle für Z modulo 11 (Gruppe)
    * 1 2 3 4 5 6 7 8 9 10
    1 1 2 3 4 5 6 7 8 9 10
    2 2 4 6 8 10 1 3 5 7 9
    3 3 6 9 1 4 7 10 2 5 8
    4 4 8 1 5 9 2 6 10 3 7
    5 5 10 4 9 3 8 2 7 1 6
    6 6 1 7 2 8 3 9 4 10 5
    7 7 3 10 6 2 9 5 1 8 4
    8 8 5 2 10 7 4 1 9 6 3
    9 9 7 5 3 1 10 8 6 4 2
    10 10 9 8 7 6 5 4 3 2 1


    x 1 2 3 4 5 6 7 8 9 10
    Inverses 1 6 4 3 9 2 8 7 5 10
  • Und wenn wir schon dabei sind: Auch die Multiplikationstabelle der symmetrischen Gruppe. Downloadseite

    weiter Permutationen
    Aber Achtung: Bei zu großem n werden leicht die Kapazitäten Ihres Computers erschöpft.

    Zum Beispiel die symmetrische Gruppe für n=4 in zwei Darstellungen. Verknüpfungstabelle a*b=a nach b
    * abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb cbad cbda cdab cdba dabc dacb dbac dbca dcab
    abcd abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb cbad cbda cdab cdba dabc dacb dbac dbca dcab
    abdc abdc abcd adbc adcb acbd acdb badc bacd bdac bdca bcad bcda dabc dacb dbac dbca dcab dcba cabd cadb cbad cbda cdab
    acbd acbd acdb abcd abdc adcb adbc cabd cadb cbad cbda cdab cdba bacd badc bcad bcda bdac bdca dacb dabc dcab dcba dbac
    acdb acdb acbd adcb adbc abcd abdc cadb cabd cdab cdba cbad cbda dacb dabc dcab dcba dbac dbca bacd badc bcad bcda bdac
    adbc adbc adcb abdc abcd acdb acbd dabc dacb dbac dbca dcab dcba badc bacd bdac bdca bcad bcda cadb cabd cdab cdba cbad
    adcb adcb adbc acdb acbd abdc abcd dacb dabc dcab dcba dbac dbca cadb cabd cdab cdba cbad cbda badc bacd bdac bdca bcad
    bacd bacd badc bcad bcda bdac bdca abcd abdc acbd acdb adbc adcb cbad cbda cabd cadb cdba cdab dbac dbca dabc dacb dcba
    badc badc bacd bdac bdca bcad bcda abdc abcd adbc adcb acbd acdb dbac dbca dabc dacb dcba dcab cbad cbda cabd cadb cdba
    bcad bcad bcda bacd badc bdca bdac cbad cbda cabd cadb cdba cdab abcd abdc acbd acdb adbc adcb dbca dbac dcba dcab dabc
    bcda bcda bcad bdca bdac bacd badc cbda cbad cdba cdab cabd cadb dbca dbac dcba dcab dabc dacb abcd abdc acbd acdb adbc
    bdac bdac bdca badc bacd bcda bcad dbac dbca dabc dacb dcba dcab abdc abcd adbc adcb acbd acdb cbda cbad cdba cdab cabd
    bdca bdca bdac bcda bcad badc bacd dbca dbac dcba dcab dabc dacb cbda cbad cdba cdab cabd cadb abdc abcd adbc adcb acbd
    cabd cabd cadb cbad cbda cdab cdba acbd acdb abcd abdc adcb adbc bcad bcda bacd badc bdca bdac dcab dcba dacb dabc dbca
    cadb cadb cabd cdab cdba cbad cbda acdb acbd adcb adbc abcd abdc dcab dcba dacb dabc dbca dbac bcad bcda bacd badc bdca
    cbad cbad cbda cabd cadb cdba cdab bcad bcda bacd badc bdca bdac acbd acdb abcd abdc adcb adbc dcba dcab dbca dbac dacb
    cbda cbda cbad cdba cdab cabd cadb bcda bcad bdca bdac bacd badc dcba dcab dbca dbac dacb dabc acbd acdb abcd abdc adcb
    cdab cdab cdba cadb cabd cbda cbad dcab dcba dacb dabc dbca dbac acdb acbd adcb adbc abcd abdc bcda bcad bdca bdac bacd
    cdba cdba cdab cbda cbad cadb cabd dcba dcab dbca dbac dacb dabc bcda bcad bdca bdac bacd badc acdb acbd adcb adbc abcd
    dabc dabc dacb dbac dbca dcab dcba adbc adcb abdc abcd acdb acbd bdac bdca badc bacd bcda bcad cdab cdba cadb cabd cbda
    dacb dacb dabc dcab dcba dbac dbca adcb adbc acdb acbd abdc abcd cdab cdba cadb cabd cbda cbad bdac bdca badc bacd bcda
    dbac dbac dbca dabc dacb dcba dcab bdac bdca badc bacd bcda bcad adbc adcb abdc abcd acdb acbd cdba cdab cbda cbad cadb
    dbca dbca dbac dcba dcab dabc dacb bdca bdac bcda bcad badc bacd cdba cdab cbda cbad cadb cabd adbc adcb abdc abcd acdb
    dcab dcab dcba dacb dabc dbca dbac cdab cdba cadb cabd cbda cbad adcb adbc acdb acbd abdc abcd bdca bdac bcda bcad badc


    x abcd abdc acbd acdb adbc adcb bacd badc bcad bcda bdac bdca cabd cadb cbad cbda cdab cdba dabc dacb dbac dbca dcab
    Inverses abcd abdc acbd adbc acdb adcb bacd badc cabd dabc cadb dacb bcad bdac cbad dbac cdab dcab bcda bdca cbda dbca cdba


    Mit durchnummerierten Permutationen 1=(abcd) 2=(abdc) ...

    * 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
    1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
    2 2 1 5 6 3 4 8 7 11 12 9 10 19 20 21 22 23 24 13 14 15 16 17
    3 3 4 1 2 6 5 13 14 15 16 17 18 7 8 9 10 11 12 20 19 23 24 21
    4 4 3 6 5 1 2 14 13 17 18 15 16 20 19 23 24 21 22 7 8 9 10 11
    5 5 6 2 1 4 3 19 20 21 22 23 24 8 7 11 12 9 10 14 13 17 18 15
    6 6 5 4 3 2 1 20 19 23 24 21 22 14 13 17 18 15 16 8 7 11 12 9
    7 7 8 9 10 11 12 1 2 3 4 5 6 15 16 13 14 18 17 21 22 19 20 24
    8 8 7 11 12 9 10 2 1 5 6 3 4 21 22 19 20 24 23 15 16 13 14 18
    9 9 10 7 8 12 11 15 16 13 14 18 17 1 2 3 4 5 6 22 21 24 23 19
    10 10 9 12 11 7 8 16 15 18 17 13 14 22 21 24 23 19 20 1 2 3 4 5
    11 11 12 8 7 10 9 21 22 19 20 24 23 2 1 5 6 3 4 16 15 18 17 13
    12 12 11 10 9 8 7 22 21 24 23 19 20 16 15 18 17 13 14 2 1 5 6 3
    13 13 14 15 16 17 18 3 4 1 2 6 5 9 10 7 8 12 11 23 24 20 19 22
    14 14 13 17 18 15 16 4 3 6 5 1 2 23 24 20 19 22 21 9 10 7 8 12
    15 15 16 13 14 18 17 9 10 7 8 12 11 3 4 1 2 6 5 24 23 22 21 20
    16 16 15 18 17 13 14 10 9 12 11 7 8 24 23 22 21 20 19 3 4 1 2 6
    17 17 18 14 13 16 15 23 24 20 19 22 21 4 3 6 5 1 2 10 9 12 11 7
    18 18 17 16 15 14 13 24 23 22 21 20 19 10 9 12 11 7 8 4 3 6 5 1
    19 19 20 21 22 23 24 5 6 2 1 4 3 11 12 8 7 10 9 17 18 14 13 16
    20 20 19 23 24 21 22 6 5 4 3 2 1 17 18 14 13 16 15 11 12 8 7 10
    21 21 22 19 20 24 23 11 12 8 7 10 9 5 6 2 1 4 3 18 17 16 15 14
    22 22 21 24 23 19 20 12 11 10 9 8 7 18 17 16 15 14 13 5 6 2 1 4
    23 23 24 20 19 22 21 17 18 14 13 16 15 6 5 4 3 2 1 12 11 10 9 8


    x 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
    x -1 1 2 3 5 4 6 7 8 13 19 14 20 9 11 15 21 17 23 10 12 16 22 18


  • Allgemeine Gruppe. Downloadseite

    Schließlich kann noch von jeder Untergruppe der Symmetrischen Gruppe die Gruppentafel und die Untergruppen berechnet werden. Sie müssen nur die erzeugenden Elemente eingeben.
    Zum Beispiel die Symmmetriegruppe des regelmäßigen Sechseckes:
                                  d
                             e         c
                             f         b
                                  a
    
     
    Erzeugende Elemente:
    Drehung: a->b b->c c->d d->e   e->f   f->a   Bezeichnung: ( bcdefa )
    Spiegelung: a->a   b<->f   c<->e   d->d     Bezeichnung: ( afedcb )
    Gruppe wird definiert durch erzeugende Elemente: G = [bcdefa, afedcb]
    
    Es wird berechnet: G = {abcdef, afedcb, bafedc, bcdefa, cbafed, cdefab, dcbafe, defabc, edcbaf, efabcd, fabcde fedcba}

    Verknüpfungstabelle a*b=a nach b
    * abcdef afedcb bafedc bcdefa cbafed cdefab dcbafe defabc edcbaf efabcd fabcde fedcba
    abcdef abcdef afedcb bafedc bcdefa cbafed cdefab dcbafe defabc edcbaf efabcd fabcde fedcba
    afedcb afedcb abcdef fabcde fedcba efabcd edcbaf defabc dcbafe cdefab cbafed bafedc bcdefa
    bafedc bafedc bcdefa abcdef afedcb fabcde fedcba efabcd edcbaf defabc dcbafe cbafed cdefab
    bcdefa bcdefa bafedc cbafed cdefab dcbafe defabc edcbaf efabcd fedcba fabcde abcdef afedcb
    cbafed cbafed cdefab bcdefa bafedc abcdef afedcb fabcde fedcba efabcd edcbaf dcbafe defabc
    cdefab cdefab cbafed dcbafe defabc edcbaf efabcd fedcba fabcde afedcb abcdef bcdefa bafedc
    dcbafe dcbafe defabc cdefab cbafed bcdefa bafedc abcdef afedcb fabcde fedcba edcbaf efabcd
    defabc defabc dcbafe edcbaf efabcd fedcba fabcde afedcb abcdef bafedc bcdefa cdefab cbafed
    edcbaf edcbaf efabcd defabc dcbafe cdefab cbafed bcdefa bafedc abcdef afedcb fedcba fabcde
    efabcd efabcd edcbaf fedcba fabcde afedcb abcdef bafedc bcdefa cbafed cdefab defabc dcbafe
    fabcde fabcde fedcba afedcb abcdef bafedc bcdefa cbafed cdefab dcbafe defabc efabcd edcbaf
    fedcba fedcba fabcde efabcd edcbaf defabc dcbafe cdefab cbafed bcdefa bafedc afedcb abcdef
    x abcdef afedcb bafedc bcdefa cbafed cdefab dcbafe defabc edcbaf efabcd fabcde fedcba
    invers abcdef afedcb bafedc fabcde cbafed efabcd dcbafe defabc edcbaf cdefab bcdefa fedcba
    Und die Untergruppen:
    {abcdef} =[abcdef]
    {abcdef afedcb} =[afedcb]
    {abcdef bafedc} =[bafedc]
    {abcdef cbafed} =[cbafed]
    {abcdef dcbafe} =[dcbafe]
    {abcdef defabc} =[defabc]
    {abcdef edcbaf} =[edcbaf]
    {abcdef fedcba} =[fedcba]
    {abcdef cdefab efabcd} =[cdefab] = [efabcd]
    {abcdef bcdefa cdefab defabc efabcd fabcde} =[bcdefa] = [fabcde]
              (bisher alle zyklisch, daher kommutativ)
    {abcdef afedcb dcbafe defabc, kommutativ} =[afedcb dcbafe] = [afedcb defabc] = [dcbafe defabc]
    {abcdef bafedc defabc edcbaf, kommutativ} =[bafedc defabc] = [bafedc edcbaf] = [defabc edcbaf]
    {abcdef cbafed defabc fedcba, kommutativ} =[cbafed defabc] = [cbafed fedcba] = [defabc fedcba]
    {abcdef afedcb cbafed cdefab edcbaf efabcd, nicht komm.} =[afedcb cbafed] = [afedcb cdefab] = [afedcb edcbaf]
       = [afedcb efabcd] = [cbafed cdefab] = [cbafed edcbaf] = [cbafed efabcd] = [cdefab edcbaf] = [edcbaf efabcd]
    {abcdef bafedc cdefab dcbafe efabcd fedcba, nicht komm.} =[bafedc cdefab] = [bafedc dcbafe] = [bafedc efabcd]
       = [bafedc fedcba] = [cdefab dcbafe] = [cdefab fedcba] = [dcbafe efabcd] = [dcbafe fedcba] = [efabcd fedcba]
    {Ganze Gruppe, nicht komm.} =[afedcb bafedc] = [afedcb bcdefa] = [afedcb fabcde] = [afedcb fedcba]
       = [bafedc bcdefa] = [bafedc cbafed] = [bafedc fabcde] = [bcdefa cbafed] = [bcdefa dcbafe] = [bcdefa edcbaf]
       = [bcdefa fedcba] = [cbafed dcbafe] = [cbafed fabcde] = [dcbafe edcbaf] = [dcbafe fabcde] = [edcbaf fabcde]
       = [edcbaf fedcba] = [fabcde fedcba]
    Schließlich noch die Kommutatorgruppen
     Kommutatorenuntergruppen:
       Ganze Gruppe
       { abcdef cdefab efabcd }
       { abcdef }
     Die Gruppe ist also auflösbar.
    
    Mit durchnummerierten Permutationen:
    1=abcdef ... 12=fedcba
    Verknüpfungstabelle für die Gruppe
    * 1 2 3 4 5 6 7 8 9 10 11 12
    1 1 2 3 4 5 6 7 8 9 10 11 12
    2 2 1 11 12 10 9 8 7 6 5 3 4
    3 3 4 1 2 11 12 10 9 8 7 5 6
    4 4 3 5 6 7 8 9 10 12 11 1 2
    5 5 6 4 3 1 2 11 12 10 9 7 8
    6 6 5 7 8 9 10 12 11 2 1 4 3
    7 7 8 6 5 4 3 1 2 11 12 9 10
    8 8 7 9 10 12 11 2 1 3 4 6 5
    9 9 10 8 7 6 5 4 3 1 2 12 11
    10 10 9 12 11 2 1 3 4 5 6 8 7
    11 11 12 2 1 3 4 5 6 7 8 10 9
    12 12 11 10 9 8 7 6 5 4 3 2 1
    x 1 2 3 4 5 6 7 8 9 10 11 12
    invers 1 2 3 11 5 10 7 8 9 6 4 12
    Untergruppen:
    {1} =[1]
    {1 2} =[2]
    {1 3} =[3]
    {1 5} =[5]
    {1 7} =[7]
    {1 8} =[8]
    {1 9} =[9]
    {1 12}=[12]
    {1 6 10} =[6] = [10]
    {1 4 6 8 10 11} =[4] = [11]
    (bisher alle zyklisch, also kommutativ)
    {1 2 7 8,  kommutativ} =[2 7] = [2 8] = [7 8]
    {1 3 8 9,  kommutativ} =[3 8] = [3 9] = [8 9]
    {1 5 8 12, kommutativ} =[5 8] = [5 12] = [8 12]
    {1 2 5 6 9 10,  nicht komm.} =[2 5] = [2 6] = [2 9] = [2 10] = [5 6] = [5 9] = [5 10] = [6 9] = [9 10]
    {1 3 6 7 10 12, nicht komm.} =[3 6] = [3 7] = [3 10] = [3 12] = [6 7] = [6 12] = [7 10] = [7 12] = [10 12]
    {Ganze Gruppe,  nicht komm.} =[2 3] = [2 4] = [2 11] = [2 12] = [3 4] = [3 5] = [3 11] = [4 5] = [4 7]
       = [4 9] = [4 12] = [5 7] = [5 11] = [7 9] = [7 11] = [9 11] = [9 12] = [11 12]
    Schließlich noch die Kommutatorgruppen
     Kommutatorenuntergruppen:
       Ganze Gruppe
       { 1 6 10 }
       { 1 }
     Die Gruppe ist also auflösbar.
    
  • Lösen von linearen Gleichungssystemen. Zum Beispiel 3 Gleichungen mit drei Unbekannten.
    koeff  *x0 + koeff  *x1 + koeff * x2 = koeff
         00           01           02           03
    koeff  *x0 + koeff  *x1 + koeff * x2 = koeff
         10           11           12           13
    koeff  *x0 + koeff  *x1 + koeff * x2 = koeff
         20           21           22           23
    
    Siehe Lektion 15

    Damit ist es möglich auch folgende Formeln zu berechnen:
     
    1^0 + 2^0 + 3^0 ...  + n^0 =  n
    1^1 + 2^1 + 3^1 ...  + n^1 =  1/2n^2 + 1/2n
    1^2 + 2^2 + 3^2 ...  + n^2 =  1/3n^3 + 1/2n^2 + 1/6n
    1^3 + 2^3 + 3^3 ...  + n^3 =  1/4n^4 + 1/2n^3 + 1/4n^2
    1^4 + 2^4 + 3^4 ...  + n^4 =  1/5n^5 + 1/2n^4 + 1/3n^3 - 1/30n
    1^5 + 2^5 + 3^5 ...  + n^5 =  1/6n^6 + 1/2n^5 + 5/12n^4 - 1/12n^2
    1^6 + 2^6 + 3^6 ...  + n^6 =  1/7n^7 + 1/2n^6 + 1/2n^5 - 1/6n^3 + 1/42n
    1^7 + 2^7 + 3^7 ...  + n^7 =  1/8n^8 + 1/2n^7 + 7/12n^6 - 7/24n^4 + 1/12n^2
    1^8 + 2^8 + 3^8 ...  + n^8 =  1/9n^9 + 1/2n^8 + 2/3n^7 - 7/15n^5 + 2/9n^3 - 1/30n
    1^9 + 2^9 + 3^9 ...  + n^9 =  1/10n^10 + 1/2n^9 + 3/4n^8 - 7/10n^6 + 1/2n^4 - 3/20n^2
    1^10 + 2^10 + 3^10 ...  + n^10 =  1/11n^11 + 1/2n^10 + 5/6n^9 - 1n^7 + 1n^5 - 1/2n^3 + 5/66n
    1^11 + 2^11 + 3^11 ...  + n^11 =  1/12n^12 + 1/2n^11 + 11/12n^10 - 11/8n^8 + 11/6n^6 - 11/8n^4 + 5/12n^2
    
    Programm dazu: Berechnung der Formel S(n,k)=1k + 2k + ... nk
  • Siehe auch Faulhaber-Formel

    Kryptologie

    Musik

    Das Programm TTMusik (Downloadseite) spielt Akkorde und berechnet dazu genauen Frequenzen, Frequenzverhältnisse und die Intervalle.
    Der Unterschied der reinen Stimmung zur gleichschwebenden Stimmung wird hörbar.
    (Tonerzeugung nicht über Midi oder Synthesizer sondern als WAV-Datei.)

    Mathematisch wird dabei der Logarithmus zur "Tripelbasis" (2,3,5) berechnet. z.B.wird aus dem Frequenzverhältnis q=1,4222222222 der "Tripellogarithmus" (auch "Sigel" genannt) [x,y,z]=[2,-2,-1] ermittelt, der die Gleichung
    q=2x·(3/2)y·(5/4)z ganzzahlig erfüllt, d.h.

    ergibt das Frequenzverhältnis 64/45=1,4222222222. Eine so gar nicht einfache Aufgabe, wenn man bedenkt, dass "double" ja nur endlich viele Nachkommastellen verarbeitet.


    In der folgenden Unit, die ich auch in anderen Programmen einsetzte, wird gezeigt, wie man wav-Dateien mit exakten Frequenzen und "schöner" Klangfarbe erzeugt (und das langweilie "beep" vermeidet).

    Ein KLang mit beliebiger Klangfarbe aus bis zu acht Tönen wird erzeugt.
    (Danksagung an das Forum "de.comp.lang.delphi.misc", wo ich erfuhr, wie die Prozedur "PlaySound" funktioniert.)
    unit tt_wav;
    {Ausgerichtete Recordfelder aus!!!}
    {$A-}
    interface
    uses Classes, mmsystem, WinProcs;
    const sampl441 = 441; //für eine 1/100-Sekunde
      sampl22050 = 50*sampl441; //22050
    type
      TRiffHeader = record
        riff: Array[0..3] OF Char;
        filesize: LongInt;
        typeStr: Array[0..3] OF Char;
      end;
      TChunkRec = record
        id: Array[0..3] OF Char;
        size: LongInt;
      end;
      TWaveFormatRec = record
        tag: Word;
        channels: Word;
        samplesPerSec: LongInt;
        bytesPerSec: LongInt;
        blockAlign: Word;
      end;
      TPCMWaveFormatRec = record
        wf: TWaveFormatRec;
        bitsPerSample: Word;
      end;
      TWAVHeader = record { WAV Format }
        riffHdr: TRiffHeader;
        fmtChunk: TChunkRec;
        fmt: TPCMWaveFormatRec;
        dataChunk: TChunkRec;
        { data follows here }
      end;
    var lautstaerke: integer = 3200; //wird bei tondauer gesetzt
        WAVDauerEinmalig: single = 0;
    function tondauer: integer;
    procedure spiele(fr1, fr2, fr3, fr4, fr5, fr6, fr7, fr8: double);
    procedure spieleton(fr: double);
    procedure tontief;
    procedure ton;
    procedure tonhoch;
    procedure alarmton;
    implementation
    procedure HeadInit(var Header: TWAVHeader);
    begin
      with Header do
      begin
        with riffHdr do
        begin
            //Schreibe 'RIFF' in die ersten 4 bytes
          riff[0] := char($52); riff[1] := char($49); riff[2] := char($46); riff[3] := char($46);
            // wird spaeter gesetzt;
          filesize := 0;
            //Schreibe 'WAVE' in die naechsten 4 bytes
          typeStr[0] := char($57); typeStr[1] := char($41); typeStr[2] := char($56); typeStr[3] := char($45);
        end;
        with fmtChunk do
        begin
            //Schreibe 'fmt' + char($20) in die naechsten 4 bytes
          id[0] := char($66); id[1] := char($6D); id[2] := char($74); id[3] := char($20);
          size := $10;
        end;
        with fmt.wf do
        begin
            //its 16 bit, 44kHz Stereo
          tag := 1; channels := 2;
          samplesPerSec := $AC44;
          bytesPerSec := MakeLong($B110, $2);
          blockAlign := 4;
          fmt.bitsPerSample := $10;
        end;
        with dataChunk do
        begin
            //Schreibe 'data' in die naechsten 4 bytes
          id[0] := char($64); id[1] := char($61); id[2] := char($74); id[3] := char($61);
          size := 0;
        end;
      end;
    end;
    function f0(const k: double): SmallInt;
    begin {Hier Frequenzen ganz exakt. Üblich sind Tabellen (wesentlich schneller, da nur
          einmal berechnet wird}
      //result := Round(sin(k*Pi/sampl22050)*lautstaerke); //reiner sinus
      result := Round(sin((k * Pi) / sampl22050) * lautstaerke) div 2 +
          Round(sin((2 * k * Pi) / sampl22050) * lautstaerke) div 4 + //1.Oberton
          Round(sin((3 * k * Pi) / sampl22050) * lautstaerke) div 6; //2.Oberton}
    end;
    function Abtastwert(const k1,k2,k3,k4,k5,k6,k7,k8: double): SmallInt; //
      var f:Smallint;
    begin //z.B. k=i*frw1 (für i=441*500(5Sek) frw1=100)=max=sampl220500000
                                               //Longword=0..4294967295
      if k1=0 then Begin result:=0; exit End else f:=f0(k1);
      result:=f;
      if k2=0 then exit;
      if k2<>k1 then f:=f0(k2); //else f=f0(k1)
      result:=result+f;
      if k3=0 then exit;
      if k3<>k2 then f:=f0(k3); //else f=f0(k2)
      result:=result+f;
      if k4=0 then exit;
      if k4<>k3 then f:=f0(k4); //else f=f0(k3)
      result:=result+f;
      if k5=0 then exit;
      if k5<>k4 then f:=f0(k5); //else f=f0(k4)
      result:=result+f;
      if k6=0 then exit;
      if k6<>k5 then f:=f0(k6); //else f=f0(k5)
      result:=result+f;
      if k7=0 then exit;
      if k7<>k6 then f:=f0(k7); //else f=f0(k6)
      result:=result+f;
      if k8=0 then exit;
      if k8<>k7 then result:=result+f0(k8) else result:=result+f;
    end;
    procedure spiele(fr1, fr2, fr3, fr4, fr5, fr6, fr7, fr8: double);
      var ms: TMemoryStream;
          Header: TWavHeader;
          i: integer; //z.B. i=0 to 441*500=441500 (5 Sekunden)
          s: SmallInt;
    begin
      HeadInit(Header);
      Header.Datachunk.size := sampl441 * tondauer * 2 * 2; //441*cs Samples pro sekunde,
                                                      //2 Channels, 2Bytes (16bit)
      //FileSize = DataSize + HeaderSize
      Header.riffHdr.FileSize := Header.Datachunk.size + 24;
      ms := TMemoryStream.Create;
      try
        ms.Seek(0, 0);
        //Write Header to Stream
        ms.Write(Header, sizeof(header));
        //form here: just data chunks. in this case (16bit stereo):
        // 16bit LeftValue, 16bit Right Value, 16bit LeftValue, 16bit Right Value ...
        // in the range of a SmallInt
        if tondauer <= 0 then exit; //kein Ton. Sollte nicht vorkommen
        for i := 0 to sampl441 * tondauer - 2 do BEgin
            //Writing left channel
            s := Abtastwert(i * fr1, i * fr2, i * fr3, i * fr4,
                            i * fr5, i * fr6, i * fr7, i * fr8);
            ms.Write(s, 2);
            //Writing to right channel
            ms.Write(s, 2);
        ENd;
      Finally
        if not PlaySound(ms.Memory,SND_FILENAME, SND_MEMORY or SND_SYNC) then
           PlaySound(Nil,SND_FILENAME, SND_MEMORY or SND_SYNC);
        ms.Free;
      End;
    end;
    procedure spieleton(fr: double);
    begin
      spiele(fr, fr, fr, fr, fr, fr, fr, fr);
    end;
    function tondauer: integer; //standard 10 Centisekunten
      var parameterlautstaerke: integer;
    begin
        result := 100;
        parameterlautstaerke := 100;
        lautstaerke := parameterlautstaerke*32;
    end;
    procedure tontief;
    begin
      spieleTon(220);
    end;
    procedure ton;
    begin
      spieleTon(440);
    end;
    procedure tonhoch;
    begin
      spieleTon(880);
    end;
    procedure alarmton;
    begin
      WAVDauerEinmalig := 1/4;
      spieleTon(440);
      WAVDauerEinmalig := 1/4;
      spieleTon(528);
      WAVDauerEinmalig := 1/2;
      spieleTon(660);
    end;
    end.
    

    Objektorientiertes Programmieren

    Sortieren

    Geometrie

    Warum noch mit dem Geodreieck zeichnen und umständlich berechnen, wenn alles viel schneller und exakter mit dem Computer geht? Ausschnitte der Zeichnung können dann z.B. in MSWord eingefügt werden.
    Erläuterung TTGEO     Downloadseite

    TTWeb

    Foto Ein einfacher Browser. Besonderheit:
    Man kann leicht in lokal gespeicherten HTML-Seiten blättern.
    Hinweis: TTweb wurde in TTText integriert.



    Downloadseite

    Bildschirmausschnitt

    Screenshot Dieses Programm ermöglicht Ihnen, den ganzen Bildschirm oder einen Teil davon "abzufotografieren" und als JPG-Datei zu speichern.

    Menüpunkte

    Bildschirm (Str+B): Der ganze Bildschirm wird abfotografiert und kann dann als JPG-Datei abgespeichert werden.

    Teilausschnitt (Str+S): Ein Teil des Bildschirms wird abfotografiert und kann dann als JPG-Datei abgespeichert werden (nochmal Str+S). Das Rechteck des Bereichs wird bestimmt durch die linke obere Ecke von "links oben" und die rechte untere Ecke von "rechts unten".

    Timer: Der Bildschirmausschnitt wird erst nach 10, 20, ... Sekunden aufgenommen. Das Programm wartet im Hintergrund. Solange haben Sie die Möglichkeit, Menüs aufzuklappen und Fenster sichtbar zu machen u.s.w., so dass auch dies aufs Bild kommt. Das Problem, dass Fenster verschwinden, wenn Sie dieses Programm aktivieren ,ist damit gelöst.

    Markierungen: Die Markierungen werden in die Nähe des Hauptfensters von Bildschirmausschnitt bewegt. Die Markierungen können Sie an die richtige Stelle ziehen.


    Downloadseite

    Hinweis: Mit TTText kann man eine Screenshot machen und anschließend ebenfalls einen passenden Bildschirmausschnitt herstellen.

    Bildbearbeitung

    Das Bildbearbeitungsprogramm ermmöglich: Bemerkung: In TTText sind noch mehr Bilbearbeitungsfunktionen, die man zur Gestaltung einer Webseite benötigt, integriert.

    Programmmanager

    Screenshot Einfacher zu bedienen als das Startmenüprogramm von Windows.

    Downloadseite

    Galton-Brett

    Galton-Brett

    Kugeln fallen über ein Nagelbrett, werden bei jedem Nagel nach links oder nach rechts abgelenkt und landen schließlich unten in Sammelbehältern.

    Eine schöne Veranschaulichung der Binomialverteilung.
    Galton
    Downloadseite

    Stichwortverzeichnis
      nach oben siehe Download
    Kommentieren  ↑nach oben