1 /* -*- Mode: C; tab-width: 4 -*- */
2 /* apollonian --- Apollonian Circles */
5 static const char sccsid[] = "@(#)apollonian.c 5.02 2001/07/01 xlockmore";
9 * Copyright (c) 2000, 2001 by Allan R. Wilks <allan@research.att.com>.
11 * Permission to use, copy, modify, and distribute this software and its
12 * documentation for any purpose and without fee is hereby granted,
13 * provided that the above copyright notice appear in all copies and that
14 * both that copyright notice and this permission notice appear in
15 * supporting documentation.
17 * This file is provided AS IS with no warranties of any kind. The author
18 * shall have no liability with respect to the infringement of copyrights,
19 * trade secrets or any patents by this file or any part thereof. In no
20 * event will the author be liable for any lost revenue or profits or
21 * other special, indirect and consequential damages.
23 * radius r = 1 / c (curvature)
25 * Descartes Circle Theorem: (a, b, c, d are curvatures of tangential circles)
26 * Let a, b, c, d be the curvatures of for mutually (externally) tangent
27 * circles in the plane. Then
28 * a^2 + b^2 + c^2 + d^2 = (a + b + c + d)^2 / 2
30 * Complex Descartes Theorem: If the oriented curvatues and (complex) centers
31 * of an oriented Descrates configuration in the plane are a, b, c, d and
32 * w, x, y, z respectively, then
33 * a^2*w^2 + b^2*x^2 + c^2*y^2 + d^2*z^2 = (aw + bx + cy + dz)^2 / 2
34 * In addition these quantities satisfy
35 * a^2*w + b^2*x + c^2*y + d^2*z = (aw + bx + cy + dz)(a + b + c + d) / 2
37 * Enumerate root integer Descartes quadruples (a,b,c,d) satisfying the
38 * Descartes condition:
39 * 2(a^2+b^2+c^2+d^2) = (a+b+c+d)^2
40 * i.e., quadruples for which no application of the "pollinate" operator
41 * z <- 2(a+b+c+d) - 3*z,
42 * where z is in {a,b,c,d}, gives a quad of strictly smaller sum. This
43 * is equivalent to the condition:
44 * sum(a,b,c,d) >= 2*max(a,b,c,d)
45 * which, because of the Descartes condition, is equivalent to
46 * sum(a^2,b^2,c^2,d^2) >= 2*max(a,b,c,d)^2
53 * 25-Jun-2001: Converted from C and Postscript code by David Bagley
54 * Original code by Allan R. Wilks <allan@research.att.com>.
56 * From Circle Math Science News April 21, 2001 VOL. 254-255
57 * http://www.sciencenews.org/20010421/toc.asp
58 * Apollonian Circle Packings Assorted papers from Ronald L Graham,
59 * Jeffrey Lagarias, Colin Mallows, Allan Wilks, Catherine Yan
60 * http://front.math.ucdavis.edu/math.NT/0009113
61 * http://front.math.ucdavis.edu/math.MG/0101066
62 * http://front.math.ucdavis.edu/math.MG/0010298
63 * http://front.math.ucdavis.edu/math.MG/0010302
64 * http://front.math.ucdavis.edu/math.MG/0010324
68 # define MODE_apollonian
69 # define DEFAULTS "*delay: 1000000 \n" \
73 # define refresh_apollonian 0
74 # define reshape_apollonian 0
75 # define apollonian_handle_event 0
76 # include "xlockmore.h" /* in xscreensaver distribution */
78 #else /* STANDALONE */
79 # include "xlock.h" /* in xlockmore distribution */
80 #endif /* STANDALONE */
82 #ifdef MODE_apollonian
84 #define DEF_ALTGEOM "True"
85 #define DEF_LABEL "True"
90 static XrmOptionDescRec opts[] =
92 {"-altgeom", ".apollonian.altgeom", XrmoptionNoArg, "on"},
93 {"+altgeom", ".apollonian.altgeom", XrmoptionNoArg, "off"},
94 {"-label", ".apollonian.label", XrmoptionNoArg, "on"},
95 {"+label", ".apollonian.label", XrmoptionNoArg, "off"},
97 static argtype vars[] =
99 {&altgeom, "altgeom", "AltGeom", DEF_ALTGEOM, t_Bool},
100 {&label, "label", "Label", DEF_LABEL, t_Bool},
102 static OptionStruct desc[] =
104 {"-/+altgeom", "turn on/off alternate geometries (off euclidean space, on includes spherical and hyperbolic)"},
105 {"-/+label", "turn on/off alternate space and number labeling"},
108 ENTRYPOINT ModeSpecOpt apollonian_opts =
109 {sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, desc};
112 extern XFontStruct *getFont(Display * display);
116 ModStruct apollonian_description =
117 {"apollonian", "init_apollonian", "draw_apollonian", "release_apollonian",
118 "init_apollonian", "init_apollonian", (char *) NULL, &apollonian_opts,
119 1000000, 64, 20, 1, 64, 1.0, "",
120 "Shows Apollonian Circles", 0, NULL};
126 } apollonian_quadruple;
129 double e; /* euclidean bend */
130 double s; /* spherical bend */
131 double h; /* hyperbolic bend */
132 double x, y; /* euclidean bend times euclidean position */
135 euclidean = 0, spherical, hyperbolic
138 static const char * space_string[] = {
145 Generate Apollonian packing starting with a quadruple of circles.
146 The four input lines each contain the 5-tuple (e,s,h,x,y) representing
147 the circle with radius 1/e and center (x/e,y/e). The s and h is propagated
148 like e, x and y, but can differ from e so as to represent different
149 geometries, spherical and hyperbolic, respectively. The "standard" picture,
150 for example (-1, 2, 2, 3), can be labeled for the three geometries.
151 Origins of circles z1, z2, z3, z4
154 c * z3 = (q123 + a * i)^2/(a*(a+b)) where q123 = sqrt(a*b+a*c+b*c)
155 d * z4 = (q124 + a * i)^2/(a*(a+b)) where q124 = q123 - a - b
156 If (e,x,y) represents the Euclidean circle (1/e,x/e,y/e) (so that e is
157 the label in the standard picture) then the "spherical label" is
158 (e^2+x^2+y^2-1)/(2*e) (an integer!) and the "hyperbolic label", is
159 calulated by h + s = e.
161 static circle examples[][4] = {
162 { /* double semi-bounded */
175 { /* next simplest */
176 {-2, -1, -1, 0.0, 0},
182 {-3, -2, -1, 0.0, 0},
183 { 4, 3, 1, 1.0 / 3.0, 0},
185 {13, 8, 5, -8.0 / 3.0, 2}
188 {-3, -2, -1, 0.0, 0},
189 { 5, 4, 1, 2.0 / 3.0, 0},
190 { 8, 5, 3, -4.0 / 3.0, -1},
191 { 8, 5, 3, -4.0 / 3.0, 1}
194 {-4, -3, -1, 0.00, 0},
196 {20, 13, 7, -4.00, 0},
197 {21, 14, 7, -3.75, 2}
200 {-4, -2, -2, 0.0, 0},
202 { 9, 5, 4, -0.75, -1},
206 {-5, -4, -1, 0.0, 0},
208 {18, 13, 5, -2.4, -1},
212 {-6, -5, -1, 0.0, 0},
213 { 7, 6, 1, 1.0 / 6.0, 0},
214 {42, 31, 11, -6.0, 0},
215 {43, 32, 11, -35.0 / 6.0, 2}
218 {-6, -3, -3, 0.0, 0},
219 {10, 5, 5, 2.0 / 3.0, 0},
221 {19, 10, 9, -5.0 / 6.0, 2}
224 {-6, -5, -1, 0.0, 0.0},
225 {11, 10, 1, 5.0 / 6.0, 0.0},
226 {14, 11, 3, -16.0 / 15.0, -0.8},
227 {15, 12, 3, -0.9, 1.2}
230 /* Non integer stuff */
231 #define DELTA 2.154700538 /* ((3+2*sqrt(3))/3) */
232 { /* 3 fold symmetric bounded (x, y calculated later) */
233 { -1, -1, -1, 0.0, 0.0},
234 {DELTA, DELTA, DELTA, 1.0, 0.0},
235 {DELTA, DELTA, DELTA, 1.0, -1.0},
236 {DELTA, DELTA, DELTA, -1.0, 1.0}
238 { /* semi-bounded (x, y calculated later) */
239 #define ALPHA 2.618033989 /* ((3+sqrt(5))/2) */
240 { 1.0, 1.0, 1.0, 0, 0},
241 { 0.0, 0.0, 0.0, 0, -1},
242 {1.0/(ALPHA*ALPHA), 1.0/(ALPHA*ALPHA), 1.0/(ALPHA*ALPHA), -1, 0},
243 { 1.0/ALPHA, 1.0/ALPHA, 1.0/ALPHA, -1, 0}
245 { /* unbounded (x, y calculated later) */
246 /* #define PHI 1.618033989 *//* ((1+sqrt(5))/2) */
247 #define BETA 2.890053638 /* (PHI+sqrt(PHI)) */
248 { 1.0, 1.0, 1.0, 0, 0},
249 {1.0/(BETA*BETA*BETA), 1.0/(BETA*BETA*BETA), 1.0/(BETA*BETA*BETA), 1, 0},
250 { 1.0/(BETA*BETA), 1.0/(BETA*BETA), 1.0/(BETA*BETA), 1, 0},
251 { 1.0/BETA, 1.0/BETA, 1.0/BETA, 1, 0}
255 #define PREDEF_CIRCLE_GAMES (sizeof (examples) / (4 * sizeof (circle)))
288 circle c1, c2, c3, c4;
292 apollonian_quadruple *quad;
299 eraser_state *eraser;
303 static apollonianstruct *apollonians = (apollonianstruct *) NULL;
305 #define FONT_HEIGHT 19
306 #define FONT_WIDTH 15
307 #define FONT_LENGTH 20
309 #define K 2.15470053837925152902 /* 1+2/sqrt(3) */
310 #define MAXBEND 100 /* Do not want configurable by user since it will take too
311 much time if increased. */
333 y = (int) (sqrt((double) n) + 0.5);
334 return ((n == y*y) ? y : -1);
338 dquad(int n, apollonian_quadruple *quad)
341 int counter = 0, B, C;
343 for (a = 0; a < MAXBEND; a++) {
345 for (b = a + 1; b <= B; b++) {
346 C = (int) (((a + b) * (a + b)) / (4.0 * (b - a)));
347 for (c = b; c <= C; c++) {
348 d = isqrt(b*c-a*(b+c));
349 if (d >= 0 && (gcd(a,gcd(b,c)) <= 1)) {
350 quad[counter].a = -a;
353 quad[counter].d = -a+b+c-2*d;
354 if (++counter >= n) {
361 (void) printf("found only %d below maximum bend of %d\n",
363 for (; counter < n; counter++) {
364 quad[counter].a = -1;
373 * Given a Descartes quadruple of bends (a,b,c,d), with a<0, find a
374 * quadruple of circles, represented by (bend,bend*x,bend*y), such
375 * that the circles have the given bends and the bends times the
376 * centers are integers.
378 * This just performs an exaustive search, assuming that the outer
379 * circle has center in the unit square.
381 * It is always sufficient to look in {(x,y):0<=y<=x<=1/2} for the
382 * center of the outer circle, but this may not lead to a packing
383 * that can be labelled with integer spherical and hyperbolic labels.
384 * To effect the smaller search, replace FOR(a) with
386 * for (pa = ea/2; pa <= 0; pa++) for (qa = pa; qa <= 0; qa++)
389 #define For(v,l,h) for (v = l; v <= h; v++)
390 #define FOR(z) For(p##z,lop##z,hip##z) For(q##z,loq##z,hiq##z)
391 #define H(z) ((e##z*e##z+p##z*p##z+q##z*q##z)%2)
392 #define UNIT(z) ((abs(e##z)-1)*(abs(e##z)-1) >= p##z*p##z+q##z*q##z)
393 #define T(z,w) is_tangent(e##z,p##z,q##z,e##w,p##w,q##w)
394 #define LO(r,z) lo##r##z = iceil(e##z*(r##a+1),ea)-1
395 #define HI(r,z) hi##r##z = iflor(e##z*(r##a-1),ea)-1
396 #define B(z) LO(p,z); HI(p,z); LO(q,z); HI(q,z)
399 is_quad(int a, int b, int c, int d)
404 return 2*(a*a+b*b+c*c+d*d) == s*s;
408 is_tangent(int e1, int p1, int q1, int e2, int p2, int q2)
415 return dx*dx + dy*dy == s*s;
424 (void) printf("iflor: b = 0\n");
430 return ((a<0)^(b<0)) ? -q-1 : q;
439 (void) printf("iceil: b = 0\n");
445 return ((a<0)^(b<0)) ? -q : 1+q;
449 geom(int geometry, int e, int p, int q)
451 int g = (geometry == spherical) ? -1 :
452 (geometry == hyperbolic) ? 1 : 0;
455 return (e*e + (1.0 - p*p - q*q) * g) / (2.0*e);
456 (void) printf("geom: g = 0\n");
461 cquad(circle *c1, circle *c2, circle *c3, circle *c4)
466 int lopa, lopb, lopc, lopd;
467 int hipa, hipb, hipc, hipd;
468 int loqa, loqb, loqc, loqd;
469 int hiqa, hiqb, hiqc, hiqd;
476 (void) printf("ea = %d\n", ea);
477 if (!is_quad(ea,eb,ec,ed))
478 (void) printf("Error not quad %d %d %d %d\n", ea, eb, ec, ed);
483 if (H(a) && UNIT(a)) FOR(b) {
484 if (H(b) && T(a,b)) FOR(c) {
485 if (H(c) && T(a,c) && T(b,c)) FOR(d) {
486 if (H(d) && T(a,d) && T(b,d) && T(c,d)) {
487 c1->s = geom(spherical, ea, pa, qa);
488 c1->h = geom(hyperbolic, ea, pa, qa);
489 c2->s = geom(spherical, eb, pb, qb);
490 c2->h = geom(hyperbolic, eb, pb, qb);
491 c3->s = geom(spherical, ec, pc, qc);
492 c3->h = geom(hyperbolic, ec, pc, qc);
493 c4->s = geom(spherical, ed, pd, qd);
494 c4->h = geom(hyperbolic, ed, pd, qd);
503 p(ModeInfo *mi, circle c)
505 apollonianstruct *cp = &apollonians[MI_SCREEN(mi)];
511 (void) printf("c.e=%g c.s=%g c.h=%g c.x=%g c.y=%g\n",
512 c.e, c.s, c.h, c.x, c.y);
514 g = (cp->geometry == spherical) ? c.s : (cp->geometry == hyperbolic) ?
519 if (MI_NPIXELS(mi) <= 2)
520 XSetForeground(MI_DISPLAY(mi), MI_GC(mi),
523 XSetForeground(MI_DISPLAY(mi), MI_GC(mi),
524 MI_PIXEL(mi, ((int) ((g + cp->color_offset) *
525 g)) % MI_NPIXELS(mi)));
526 XDrawArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
527 ((int) (cp->size * (-cp->c1.e) * (c.x - 1.0) /
528 (-2.0 * c.e) + cp->size / 2.0 + cp->offset.x)),
529 ((int) (cp->size * (-cp->c1.e) * (c.y - 1.0) /
530 (-2.0 * c.e) + cp->size / 2.0 + cp->offset.y)),
531 (int) (cp->c1.e * cp->size / c.e),
532 (int) (cp->c1.e * cp->size / c.e), 0, 23040);
535 (void) printf("%g\n", -g);
539 (void) sprintf(string, "%g", (g == 0.0) ? 0 : -g);
540 if (cp->size >= 10 * FONT_WIDTH) {
541 /* hard code these to corners */
542 XDrawString(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
543 ((int) (cp->size * c.x / (2.0 * c.e))) + cp->offset.x,
544 ((int) (cp->size * c.y / (2.0 * c.e))) + FONT_HEIGHT,
545 string, (g == 0.0) ? 1 : ((g < 10.0) ? 2 :
546 ((g < 100.0) ? 3 : 4)));
548 if (cp->altgeom && MI_HEIGHT(mi) >= 30 * FONT_WIDTH) {
549 XDrawString(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
550 ((int) (cp->size * c.x / (2.0 * c.e) + cp->offset.x)),
551 ((int) (cp->size * c.y / (2.0 * c.e) + MI_HEIGHT(mi) -
552 FONT_HEIGHT / 2)), (char *) space_string[cp->geometry],
553 strlen(space_string[cp->geometry]));
557 if (MI_NPIXELS(mi) <= 2)
558 XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_WHITE_PIXEL(mi));
560 XSetForeground(MI_DISPLAY(mi), MI_GC(mi),
561 MI_PIXEL(mi, ((int) ((g + cp->color_offset) * g)) %
564 if (c.x == 0.0 && c.y != 0.0) {
565 XDrawLine(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
566 0, (int) ((c.y + 1.0) * cp->size / 2.0 + cp->offset.y),
568 (int) ((c.y + 1.0) * cp->size / 2.0 + cp->offset.y));
569 } else if (c.y == 0.0 && c.x != 0.0) {
570 XDrawLine(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
571 (int) ((c.x + 1.0) * cp->size / 2.0 + cp->offset.x), 0,
572 (int) ((c.x + 1.0) * cp->size / 2.0 + cp->offset.x),
577 e = (cp->c1.e >= 0.0) ? 1.0 : -cp->c1.e;
578 XFillArc(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
579 ((int) (cp->size * e * (c.x - 1.0) / (2.0 * c.e) +
580 cp->size / 2.0 + cp->offset.x)),
581 ((int) (cp->size * e * (c.y - 1.0) / (2.0 * c.e) +
582 cp->size / 2.0 + cp->offset.y)),
583 (int) (e * cp->size / c.e), (int) (e * cp->size / c.e),
587 (void) printf("%g\n", g);
591 if (MI_NPIXELS(mi) <= 2)
592 XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_BLACK_PIXEL(mi));
594 XSetForeground(MI_DISPLAY(mi), MI_GC(mi),
595 MI_PIXEL(mi, ((int) ((g + cp->color_offset) * g) +
596 MI_NPIXELS(mi) / 2) % MI_NPIXELS(mi)));
597 g_width = (g < 10.0) ? 1: ((g < 100.0) ? 2 : 3);
598 if (c.e < e * cp->size / (FONT_LENGTH + 5 * g_width) && g < 1000.0) {
599 (void) sprintf(string, "%g", g);
600 XDrawString(MI_DISPLAY(mi), MI_WINDOW(mi), MI_GC(mi),
601 ((int) (cp->size * e * c.x / (2.0 * c.e) +
602 cp->size / 2.0 + cp->offset.x)) -
603 g_width * FONT_WIDTH / 2,
604 ((int) (cp->size * e * c.y / (2.0 * c.e) +
605 cp->size / 2.0 + cp->offset.y)) +
613 f(ModeInfo *mi, circle c1, circle c2, circle c3, circle c4)
615 apollonianstruct *cp = &apollonians[MI_SCREEN(mi)];
616 int e = (int) ((cp->c1.e >= 0.0) ? 1.0 : -cp->c1.e);
619 c.e = 2*(c1.e+c2.e+c3.e) - c4.e;
620 c.s = 2*(c1.s+c2.s+c3.s) - c4.s;
621 c.h = 2*(c1.h+c2.h+c3.h) - c4.h;
622 c.x = 2*(c1.x+c2.x+c3.x) - c4.x;
623 c.y = 2*(c1.y+c2.y+c3.y) - c4.y;
624 if (c.e > cp->size * e || c.x / c.e > BIG || c.y / c.e > BIG ||
625 c.x / c.e < -BIG || c.y / c.e < -BIG)
628 f(mi, c2, c3, c, c1);
629 f(mi, c1, c3, c, c2);
630 f(mi, c1, c2, c, c3);
634 free_apollonian (Display *display, apollonianstruct *cp)
636 if (cp->quad != NULL) {
637 (void) free((void *) cp->quad);
638 cp->quad = (apollonian_quadruple *) NULL;
641 if (cp->gc != None) {
642 XFreeGC(display, cp->gc);
645 if (cp->font != None) {
646 XFreeFont(display, cp->font);
654 randomize_c(int randomize, circle * c)
671 init_apollonian (ModeInfo * mi)
673 apollonianstruct *cp;
676 if (apollonians == NULL) {
677 if ((apollonians = (apollonianstruct *) calloc(MI_NUM_SCREENS(mi),
678 sizeof (apollonianstruct))) == NULL)
681 cp = &apollonians[MI_SCREEN(mi)];
683 cp->size = MAX(MIN(MI_WIDTH(mi), MI_HEIGHT(mi)) - 1, 1);
684 cp->offset.x = (MI_WIDTH(mi) - cp->size) / 2;
685 cp->offset.y = (MI_HEIGHT(mi) - cp->size) / 2;
686 cp->color_offset = NRAND(MI_NPIXELS(mi));
689 if (cp->font == None) {
690 if ((cp->font = getFont(MI_DISPLAY(mi))) == None)
695 cp->altgeom = cp->label && altgeom;
697 if (cp->quad == NULL) {
698 cp->count = ABS(MI_COUNT(mi));
699 if ((cp->quad = (apollonian_quadruple *) malloc(cp->count *
700 sizeof (apollonian_quadruple))) == NULL) {
703 dquad(cp->count, cp->quad);
705 cp->game = NRAND(PREDEF_CIRCLE_GAMES + cp->count);
706 cp->geometry = (cp->game && cp->altgeom) ? NRAND(3) : 0;
708 if (cp->game < PREDEF_CIRCLE_GAMES) {
709 cp->c1 = examples[cp->game][0];
710 cp->c2 = examples[cp->game][1];
711 cp->c3 = examples[cp->game][2];
712 cp->c4 = examples[cp->game][3];
713 /* do not label non int */
714 cp->label = cp->label && (cp->c4.e == (int) cp->c4.e);
715 } else { /* uses results of dquad, all int */
716 i = cp->game - PREDEF_CIRCLE_GAMES;
717 cp->c1.e = cp->quad[i].a;
718 cp->c2.e = cp->quad[i].b;
719 cp->c3.e = cp->quad[i].c;
720 cp->c4.e = cp->quad[i].d;
722 cquad(&(cp->c1), &(cp->c2), &(cp->c3), &(cp->c4));
731 if (cp->c1.e == 0.0 || cp->c1.e == -cp->c2.e)
735 cp->c2.x = -(cp->c1.e + cp->c2.e) / cp->c1.e;
737 q123 = sqrt(cp->c1.e * cp->c2.e + cp->c1.e * cp->c3.e +
738 cp->c2.e * cp->c3.e);
740 (void) printf("q123 = %g, ", q123);
742 cp->c3.x = (cp->c1.e * cp->c1.e - q123 * q123) / (cp->c1.e *
743 (cp->c1.e + cp->c2.e));
744 cp->c3.y = -2.0 * q123 / (cp->c1.e + cp->c2.e);
745 q123 = -cp->c1.e - cp->c2.e + q123;
746 cp->c4.x = (cp->c1.e * cp->c1.e - q123 * q123) / (cp->c1.e *
747 (cp->c1.e + cp->c2.e));
748 cp->c4.y = -2.0 * q123 / (cp->c1.e + cp->c2.e);
750 (void) printf("q124 = %g\n", q123);
751 (void) printf("%g %g %g %g %g %g %g %g\n",
752 cp->c1.x, cp->c1.y, cp->c2.x, cp->c2.y,
753 cp->c3.x, cp->c3.y, cp->c4.x, cp->c4.y);
758 cp->c3.y = -cp->c3.y;
759 cp->c4.y = -cp->c4.y;
762 randomize_c(i, &(cp->c1));
763 randomize_c(i, &(cp->c2));
764 randomize_c(i, &(cp->c3));
765 randomize_c(i, &(cp->c4));
770 draw_apollonian (ModeInfo * mi)
772 apollonianstruct *cp;
774 if (apollonians == NULL)
776 cp = &apollonians[MI_SCREEN(mi)];
780 cp->eraser = erase_window (MI_DISPLAY(mi), MI_WINDOW(mi), cp->eraser);
785 MI_IS_DRAWN(mi) = True;
796 f(mi, cp->c1, cp->c2, cp->c3, cp->c4);
799 f(mi, cp->c1, cp->c2, cp->c4, cp->c3);
802 f(mi, cp->c1, cp->c3, cp->c4, cp->c2);
805 f(mi, cp->c2, cp->c3, cp->c4, cp->c1);
808 if (++cp->time > MI_CYCLES(mi))
811 cp->eraser = erase_window (MI_DISPLAY(mi), MI_WINDOW(mi), cp->eraser);
812 #endif /* STANDALONE */
818 release_apollonian (ModeInfo * mi)
820 if (apollonians != NULL) {
823 for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
824 free_apollonian(MI_DISPLAY(mi), &apollonians[screen]);
825 (void) free((void *) apollonians);
826 apollonians = (apollonianstruct *) NULL;
830 XSCREENSAVER_MODULE ("Apollonian", apollonian)
832 #endif /* MODE_apollonian */