Apfelmännchen

Ein Apfelmännchen für R/3. Grafisch nicht umwerfend, aber das Prinzip funktioniert. Allzu lange Laufzeiten entstehen auch nicht, da die Bildgröße sehr beschränkt ist.

Auf dem Startbildschirm müssen Sie die mathematischen Eingrenzungen vornehmen:

Starten Sie das Programm und Sie erhalten eine ähnliche Grafik wie hier:

Parameter

Folgende Parameter bringen auf jeden Fall brauchbare Ergebnisse:

A-Min                       1,4000000-
A-Max                       1,0000000
B-Min                       2,0000000-
Iterationen                 5

A-Min                       0,1200000-
A-Max                       0,7200000
B-Min                       0,5000000-
Anzahl Iterationen          15

A-Min                       0,1200000-
A-Max                       0,7200000
B-Min                       0,0030000-
Anzahl Iterationen          10

A-Min                       0,5000000-
A-Max                       0,9000000
B-Min                       0,7000000-
Anzahl Iterationen          16

Das Coding

REPORT zz_fraktal NO STANDARD PAGE HEADING LINE-SIZE 500 LINE-COUNT 500.
**********************************************************************
***                                                                ***
***                   https://tricktresor.com                    ***
***                                                                ***
**********************************************************************
*--------------------------------------------------------------------*
* Autor: Enno Wulff
* Datum: Oktober 2004
*--------------------------------------------------------------------*
*
* Das Programm erzeugt eine Apfelmännchen-Grafik
*
* Die Anzahl der Iterationen sollte nicht größer sein als 100, denn
* je mehr Iterationen ausgeführt werden, desto länger dauert die
* Berechnung. Aufgrund der schlechten grafischen Verhältnisse werden
* jedoch keine besseren Ergebnisse mehr erzielt.
* Zwischen 5 und 50 Iterationen werden sehr unterschiedliche
* Ergebnisse erzielt.
* Mein Dank gilt Dietmar Grätzer dessen "praktische Einführung" zum
* Thema "Fraktale und Chaos" mir geholfen hat, die Programmierung in
* ABAP zu realisieren.
*
* Das Dokument sowie viele andere Informationen können unter
*
*   http://www.fraktale-online.de
*
* abgerufen werden.
*
*--------------------------------------------------------------------*

DATA:
aschritt TYPE f,
bschritt TYPE f,
sx       TYPE i,
zy       TYPE i,
a        TYPE f,
b        TYPE f,
x        TYPE f,
y        TYPE f,
n        TYPE f,
n0       TYPE f,
n1       TYPE i,
n2       TYPE f,
xx       TYPE f,
z1       TYPE f,
bmax     TYPE i.

PARAMETERS:
p_scrbr(3) TYPE n,
px(3)      TYPE n DEFAULT 200,
py(3)      TYPE n DEFAULT 70,
p_modcol   RADIOBUTTON GROUP mod DEFAULT 'X',
p_modchr   RADIOBUTTON GROUP mod,
amin(8)    TYPE p DECIMALS 7 DEFAULT '2-',
amax(8)    TYPE p DECIMALS 7 DEFAULT '1',
bmin(8)    TYPE p DECIMALS 7 DEFAULT '1-',
nmax(4)    TYPE n DEFAULT 20. "Anzahl Iterationen

AT SELECTION-SCREEN OUTPUT.

*-- Aktuelle sichtbare Breite des Bildschirms
p_scrbr = sy-scols - 2.

*-- Feld "Sichtbare Breite" auf "nur anzeigen" stellen
LOOP AT SCREEN.
IF screen-name = 'P_SCRBR'.
screen-input = '0'.
MODIFY SCREEN.
ENDIF.
ENDLOOP.

START-OF-SELECTION.

*-- Init
SET BLANK LINES ON.
WRITE AT /(px) space NO-GAP.

  bmax = 2 / 3 * ( amax - amin ) + bmin.

  aschritt = ( amax - amin ) / px.       "Schrittweite
bschritt = ( bmax - bmin ) / py.

*-- Berechnung der Mandelbrot-Menge
DO px TIMES.
sx = sy-index. "BildschirmSpalten
a = amin + sx * aschritt.
DO py TIMES.                "BildschirmZeilen
zy = sy-index.
b = bmax - zy * bschritt.
x = 0.
y = 0.                  "Startwert z0=0
DO nmax TIMES.                                        "Iteration
n = sy-index.
xx = x * x - y * y + a.        "Hilfsgroesse
y = 2 * x * y + b.             "Imaginaerteil
x = xx.                                             "Realteil
z1 = x * x + y * y.
IF z1 > 4.
n0 = n.
* Der Punkt c = (a, b) gehoert nicht zur Mandelbrot-Menge
EXIT.
ENDIF.
ENDDO. "n
* Punktausgabe
n1 = n0 / 2.
n2 = n0 / 2.
IF n1 = n2.
PERFORM pset USING sx zy 1.
"Darstellung der Niveaulinien
z1 = x * x + y * y.
IF z1 <= 4.
PERFORM pset USING sx zy y.
"Der Punkt c = (a, b) gehoert zur Mandelbrot-Menge
ENDIF.
ELSE.
z1 = x * x + y * y.
IF z1 <= 4.
PERFORM pset USING sx zy y.
"Der Punkt c = (a, b) gehoert zur Mandelbrot-Menge
ENDIF.
ENDIF.
ENDDO. " zy
ENDDO." sx

*---------------------------------------------------------------------*
*       FORM punkt_setzen                                             *
*---------------------------------------------------------------------*
FORM pset USING fx fy farbe TYPE f.

  DATA:
l_char  TYPE c,
l_farbe TYPE i,
l_abcde(26),
l_intens(1) TYPE n.

SKIP TO LINE fy.
POSITION fx.

  IF p_modchr = 'X'.
*** Setzen des Punktes als Zeichen ***
l_farbe = abs( farbe ) * 10.
l_abcde = sy-abcde.
SHIFT l_abcde BY l_farbe PLACES LEFT CIRCULAR.
l_char = l_abcde+0(1).
WRITE l_char NO-GAP.

  ELSE.
*** Setzen eines farbigen "Punktes"
IF farbe < 0.
l_intens = 0.
ELSE.
l_intens = 1.
ENDIF.

    l_farbe = abs( farbe ) * 15.
IF l_farbe = 0.
l_farbe = 6.
ENDIF.
WRITE '  ' COLOR = l_farbe INTENSIFIED = l_intens.

  ENDIF.

ENDFORM.
Enno Wulff
follow me
Letzte Artikel von Enno Wulff (Alle anzeigen)

Leave a Comment

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.