home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / GRAPHICS / MISC / FRPOR172.ZIP / FRACSUBR.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-14  |  34.4 KB  |  1,136 lines
  1. /*
  2. FRACSUBR.C contains subroutines which belong primarily to CALCFRAC.C and
  3. FRACTALS.C, i.e. which are non-fractal-specific fractal engine subroutines.
  4. */
  5.  
  6. #include <stdio.h>
  7. #ifndef XFRACT
  8. #include <stdarg.h>
  9. #else
  10. #include <varargs.h>
  11. #endif
  12. #include <float.h>
  13. #include <sys/types.h>
  14. #include <sys/timeb.h>
  15. #include "fractint.h"
  16. #include "fractype.h"
  17. #include "mpmath.h"
  18.  
  19. /* routines in this module    */
  20.  
  21. void calcfracinit(void);
  22. void adjust_corner(void);
  23. int  alloc_resume(int,int);
  24. #ifndef XFRACT
  25. int  put_resume(int,...);
  26. int  get_resume(int,...);
  27. #else
  28. int  put_resume();
  29. int  get_resume();
  30. #endif
  31. int  start_resume(void);
  32. void end_resume(void);
  33. void iplot_orbit(long,long,int);
  34. void plot_orbit(double,double,int);
  35. void scrub_orbit(void);
  36. int  add_worklist(int,int,int,int,int,int,int);
  37. void tidy_worklist(void);
  38. int  ssg_blocksize(void);
  39. void get_julia_attractor(double,double);
  40.  
  41. static long   _fastcall fudgetolong(double d);
  42. static double _fastcall fudgetodouble(long l);
  43. static void   _fastcall adjust_to_limits(double);
  44. static void   _fastcall smallest_add(double *);
  45. static int    _fastcall ratio_bad(double,double);
  46. static void   _fastcall plotdorbit(double,double,int);
  47. static int    _fastcall combine_worklist(void);
  48.  
  49.  
  50. extern int    calc_status;        /* status of calculations */
  51. extern char far *resume_info;        /* pointer to resume info if allocated */
  52.        int    resume_len;        /* length of resume info */
  53. static int    resume_offset;        /* offset in resume info gets */
  54. extern double plotmx1,plotmx2,plotmy1,plotmy2; /* real->screen conversion */
  55. extern int    orbit_ptr;        /* pointer into save_orbit array */
  56. extern int orbit_delay;         /* orbit delay value */
  57. extern int far *save_orbit;        /* array to save orbit values */
  58. extern int    orbit_color;        /* XOR color */
  59. extern int    num_worklist;        /* resume worklist for standard engine */
  60. extern int    fractype;         /* fractal type */
  61. extern char   stdcalcmode;        /* '1', '2', 'g', 'b'       */
  62. extern char   floatflag;        /* floating-point fractals? */
  63. extern int    integerfractal;        /* TRUE if fractal uses integer math */
  64. extern struct workliststuff worklist[MAXCALCWORK];
  65. extern int    sxdots,sydots;        /* # of dots on the physical screen    */
  66. extern int    sxoffs,syoffs;        /* physical top left of logical screen */
  67. extern int    xdots, ydots;        /* # of dots on the logical screen     */
  68. extern int    colors;            /* maximum colors available */
  69. extern long   fudge;            /* fudge factor (2**n) */
  70. extern int    bitshift;         /* bit shift for fudge */
  71. extern int    inside;            /* inside color: 1=blue     */
  72. extern int    outside;            /* outside color    */
  73. extern double xxmin,xxmax,yymin,yymax,xx3rd,yy3rd; /* corners */
  74. extern long   xmin, xmax, ymin, ymax, x3rd, y3rd;  /* integer equivs */
  75. extern int    maxit;            /* try this many iterations */
  76. extern int    attractors;        /* number of finite attractors    */
  77. extern struct complex  attr[];        /* finite attractor vals (f.p)    */
  78. extern struct lcomplex lattr[];     /* finite attractor vals (int)    */
  79. extern struct complex  old,new;
  80. extern struct lcomplex lold,lnew;
  81. extern double tempsqrx,tempsqry;
  82. extern long   ltempsqrx,ltempsqry;
  83. extern int    xxstart,xxstop;        /* these are same as worklist, */
  84. extern int    yystart,yystop,yybegin;    /* declared as separate items  */
  85. extern int    periodicitycheck;
  86. extern int    basin;
  87. extern int    finattract;
  88. extern int    pixelpi;            /* value of pi in pixels */
  89. extern double closenuff;
  90. extern long   lclosenuff;
  91. extern int    ixstart, ixstop, iystart, iystop;
  92. extern int    color;
  93. extern int    decomp[];
  94. extern double potparam[3];        /* three potential parameters*/
  95. extern int    distest;            /* non-zero if distance estimator */
  96. extern double param[4];         /* up to four parameters */
  97. extern int    invert;            /* non-zero if inversion active */
  98. extern int    biomorph,usr_biomorph;
  99. extern int    debugflag; /* internal use only - you didn't see this */
  100. extern long   creal, cimag;        /* for calcmand */
  101. extern long   delx, dely;        /* screen pixel increments  */
  102. extern long   delx2, dely2;        /* screen pixel increments  */
  103. extern double delxx, delyy;        /* screen pixel increments  */
  104. extern double delxx2, delyy2;        /* screen pixel increments  */
  105. extern long   delmin;            /* for calcfrac/calcmand    */
  106. extern double ddelmin;            /* same as a double        */
  107. extern int    potflag;            /* continuous potential flag */
  108. extern int    bailout;
  109. extern double rqlim;
  110. extern double  dxsize, dysize;        /* xdots-1, ydots-1        */
  111. extern int soundflag;
  112. extern int basehertz;
  113.  
  114. extern long   far *lx0, far *ly0;    /* x, y grid            */
  115. extern long   far *lx1, far *ly1;    /* adjustment for rotate    */
  116. /* note that lx1 & ly1 values can overflow into sign bit; since     */
  117. /* they're used only to add to lx0/ly0, 2s comp straightens it out  */
  118. extern double far *dx0, far *dy0;    /* floating pt equivs */
  119. extern double far *dx1, far *dy1;
  120.  
  121. extern char   usr_floatflag;
  122. extern char   usr_stdcalcmode;
  123. extern int    usr_periodicitycheck;
  124. extern int    usr_distest;
  125.  
  126. extern int StandardFractal(void);
  127. extern int calcmand(void);
  128. extern int calcmandfp(void);
  129.  
  130. #define FUDGEFACTOR    29    /* fudge all values up by 2**this */
  131. #define FUDGEFACTOR2    24    /* (or maybe this)          */
  132.  
  133.  
  134. void calcfracinit() /* initialize a *pile* of stuff for fractal calculation */
  135. {
  136.    int i;
  137.    double ftemp;
  138.  
  139.    floatflag = usr_floatflag;
  140.    if (calc_status == 2) /* on resume, ensure floatflag correct */
  141.       if (curfractalspecific->isinteger)
  142.      floatflag = 0;
  143.       else
  144.      floatflag = 1;
  145.  
  146. init_restart:
  147.  
  148.    /* the following variables may be forced to a different setting due to
  149.       calc routine constraints;  usr_xxx is what the user last said is wanted,
  150.       xxx is what we actually do in the current situation */
  151.    stdcalcmode        = usr_stdcalcmode;
  152.    periodicitycheck = usr_periodicitycheck;
  153.    distest        = usr_distest;
  154.    biomorph        = usr_biomorph;
  155.  
  156.    potflag = 0;
  157.    if (potparam[0] != 0.0
  158.      && colors >= 256
  159.      && (curfractalspecific->calctype == StandardFractal
  160.      || curfractalspecific->calctype == calcmand
  161.      || curfractalspecific->calctype == calcmandfp)) {
  162.       potflag = 1;
  163.       distest = 0;    /* can't do distest too */
  164.       }
  165.  
  166.    if (distest)
  167.       floatflag = 1;  /* force floating point for dist est */
  168.  
  169.    if (floatflag) { /* ensure type matches floatflag */
  170.       if (curfractalspecific->isinteger != 0
  171.     && curfractalspecific->tofloat != NOFRACTAL)
  172.      fractype = curfractalspecific->tofloat;
  173.       }
  174.    else {
  175.       if (curfractalspecific->isinteger == 0
  176.     && curfractalspecific->tofloat != NOFRACTAL)
  177.      fractype = curfractalspecific->tofloat;
  178.       }
  179.    curfractalspecific = &fractalspecific[fractype];
  180.  
  181.    integerfractal = curfractalspecific->isinteger;
  182.  
  183.    if (fractype == JULIBROT)
  184.       rqlim = 4;
  185.    else if (potflag && potparam[2] != 0.0)
  186.       rqlim = potparam[2];
  187. /* else if (decomp[0] > 0 && decomp[1] > 0)
  188.       rqlim = (double)decomp[1]; */
  189.    else if (bailout) /* user input bailout */
  190.       rqlim = bailout;
  191.    else if (biomorph != -1) /* biomorph benefits from larger bailout */
  192.       rqlim = 100;
  193.    else
  194.       rqlim = curfractalspecific->orbit_bailout;
  195.    if (integerfractal) /* the bailout limit mustn't be too high here */
  196.       if (rqlim > 127.0) rqlim = 127.0;
  197.  
  198.    if ((curfractalspecific->flags&NOROTATE) != 0) {
  199.       /* ensure min<max and unrotated rectangle */
  200.       if (xxmin > xxmax) { ftemp = xxmax; xxmax = xxmin; xxmin = ftemp; }
  201.       if (yymin > yymax) { ftemp = yymax; yymax = yymin; yymin = ftemp; }
  202.       xx3rd = xxmin; yy3rd = yymin;
  203.       }
  204.  
  205.    /* set up bitshift for integer math */
  206.    bitshift = FUDGEFACTOR2; /* by default, the smaller shift */
  207.    if (integerfractal > 1)  /* use specific override from table */
  208.       bitshift = integerfractal;
  209.    if (integerfractal == 0) /* float? */
  210.       if ((i = curfractalspecific->tofloat) != NOFRACTAL) /* -> int? */
  211.      if (fractalspecific[i].isinteger > 1) /* specific shift? */
  212.         bitshift = fractalspecific[i].isinteger;
  213.  
  214. /* We want this code if we're using the assembler calcmand */
  215. #ifndef XFRACT
  216.    if (fractype == MANDEL || fractype == JULIA) { /* adust shift bits if.. */
  217.       if (potflag == 0                  /* not using potential */
  218.     && (fractype != MANDEL              /* and not an int mandel */
  219.         || (param[0] == 0.0 && param[1] == 0.0))  /* w/ "fudged" params */
  220.     && !invert                  /* and not inverting */
  221.     && biomorph == -1              /* and not biomorphing */
  222.     && rqlim <= 4.0               /* and bailout not too high */
  223.     && (outside > -2 || outside < -5)      /* and no funny outside stuff */
  224.     && debugflag != 1234)              /* and not debugging */
  225.      bitshift = FUDGEFACTOR;          /* use the larger bitshift */
  226.       if (param[0] < -1.99 || param[0] > 1.99) param[0] = 1.99;
  227.       if (param[1] < -1.99 || param[1] > 1.99) param[1] = 1.99;
  228.       }
  229. #endif
  230.  
  231.    fudge = 1L << bitshift;
  232.  
  233.    l_at_rad = fudge/32768L;
  234.    f_at_rad = 1.0/32768L;
  235.  
  236.    /* now setup arrays of real coordinates corresponding to each pixel */
  237.  
  238.    adjust_to_limits(1.0); /* make sure all corners in valid range */
  239.  
  240.    delxx  = (xxmax - xx3rd) / dxsize; /* calculate stepsizes */
  241.    delyy  = (yymax - yy3rd) / dysize;
  242.    delxx2 = (xx3rd - xxmin) / dysize;
  243.    delyy2 = (yy3rd - yymin) / dxsize;
  244.  
  245.    creal = fudgetolong(param[0]); /* integer equivs for it all */
  246.    cimag = fudgetolong(param[1]);
  247.    xmin  = fudgetolong(xxmin);
  248.    xmax  = fudgetolong(xxmax);
  249.    x3rd  = fudgetolong(xx3rd);
  250.    ymin  = fudgetolong(yymin);
  251.    ymax  = fudgetolong(yymax);
  252.    y3rd  = fudgetolong(yy3rd);
  253.    delx  = fudgetolong(delxx);
  254.    dely  = fudgetolong(delyy);
  255.    delx2 = fudgetolong(delxx2);
  256.    dely2 = fudgetolong(delyy2);
  257.  
  258.    if (fractype != PLASMA) { /* skip this if plasma to avoid 3d problems */
  259.       if (integerfractal && !invert) {
  260.      if (    (delx  == 0 && delxx  != 0.0)
  261.          || (delx2 == 0 && delxx2 != 0.0)
  262.          || (dely  == 0 && delyy  != 0.0)
  263.          || (dely2 == 0 && delyy2 != 0.0) )
  264.         goto expand_retry;
  265.      lx0[0] = xmin;         /* fill up the x, y grids */
  266.      ly0[0] = ymax;
  267.      lx1[0] = ly1[0] = 0;
  268.      for (i = 1; i < xdots; i++ ) {
  269.         lx0[i] = lx0[i-1] + delx;
  270.         ly1[i] = ly1[i-1] - dely2;
  271.         }
  272.      for (i = 1; i < ydots; i++ ) {
  273.         ly0[i] = ly0[i-1] - dely;
  274.         lx1[i] = lx1[i-1] + delx2;
  275.         }
  276.      /* past max res?  check corners within 10% of expected */
  277.      if (    ratio_bad((double)lx0[xdots-1]-xmin,(double)xmax-x3rd)
  278.          || ratio_bad((double)ly0[ydots-1]-ymax,(double)y3rd-ymax)
  279.          || ratio_bad((double)lx1[(ydots>>1)-1],((double)x3rd-xmin)/2)
  280.          || ratio_bad((double)ly1[(xdots>>1)-1],((double)ymin-y3rd)/2) ) {
  281. expand_retry:
  282.         if (integerfractal        /* integer fractal type? */
  283.           && curfractalspecific->tofloat != NOFRACTAL)
  284.            floatflag = 1;        /* switch to floating pt */
  285.         else
  286.            adjust_to_limits(2.0);    /* double the size */
  287.         if (calc_status == 2)    /* due to restore of an old file? */
  288.            calc_status = 0;     /*   whatever, it isn't resumable */
  289.         goto init_restart;
  290.         }
  291.      /* re-set corners to match reality */
  292.      xmax = lx0[xdots-1] + lx1[ydots-1];
  293.      ymin = ly0[ydots-1] + ly1[xdots-1];
  294.      x3rd = xmin + lx1[ydots-1];
  295.      y3rd = ly0[ydots-1];
  296.      xxmin = fudgetodouble(xmin);
  297.      xxmax = fudgetodouble(xmax);
  298.      xx3rd = fudgetodouble(x3rd);
  299.      yymin = fudgetodouble(ymin);
  300.      yymax = fudgetodouble(ymax);
  301.      yy3rd = fudgetodouble(y3rd);
  302.      }
  303.       else {
  304.      /* set up dx0 and dy0 analogs of lx0 and ly0 */
  305.      /* put fractal parameters in doubles */
  306.      dx0[0] = xxmin;        /* fill up the x, y grids */
  307.      dy0[0] = yymax;
  308.      dx1[0] = dy1[0] = 0;
  309.      for (i = 1; i < xdots; i++ ) {
  310.         dx0[i] = dx0[i-1] + delxx;
  311.         dy1[i] = dy1[i-1] - delyy2;
  312.         }
  313.      for (i = 1; i < ydots; i++ ) {
  314.         dy0[i] = dy0[i-1] - delyy;
  315.         dx1[i] = dx1[i-1] + delxx2;
  316.         }
  317.      if (    ratio_bad(dx0[xdots-1]-xxmin,xxmax-xx3rd)
  318.          || ratio_bad(dy0[ydots-1]-yymax,yy3rd-yymax)
  319.          || ratio_bad(dx1[ydots-1],xx3rd-xxmin)
  320.          || ratio_bad(dy1[xdots-1],yymin-yy3rd))
  321.         goto expand_retry;
  322.      /* re-set corners to match reality */
  323.      xxmax = dx0[xdots-1] + dx1[ydots-1];
  324.      yymin = dy0[ydots-1] + dy1[xdots-1];
  325.      xx3rd = xxmin + dx1[ydots-1];
  326.      yy3rd = dy0[ydots-1];
  327.      }
  328.       }
  329.  
  330.    /* for periodicity close-enough, and for unity: */
  331.    /*      min(max(delx,delx2),max(dely,dely2)       */
  332.    ddelmin = fabs(delxx);
  333.    if (fabs(delxx2) > ddelmin)
  334.       ddelmin = fabs(delxx2);
  335.    if (fabs(delyy) > fabs(delyy2)) {
  336.       if (fabs(delyy) < ddelmin)
  337.      ddelmin = fabs(delyy);
  338.       }
  339.    else
  340.       if (fabs(delyy2) < ddelmin)
  341.      ddelmin = fabs(delyy2);
  342.    delmin = fudgetolong(ddelmin);
  343.  
  344.    /* calculate factors which plot real values to screen co-ords */
  345.    /* calcfrac.c plot_orbit routines have comments about this     */
  346.    ftemp = (0.0-delyy2) * delxx2 * dxsize * dysize
  347.        - (xxmax-xx3rd) * (yy3rd-yymax);
  348.    plotmx1 = delxx2 * dxsize * dysize / ftemp;
  349.    plotmx2 = (yy3rd-yymax) * dxsize / ftemp;
  350.    plotmy1 = (0.0-delyy2) * dxsize * dysize / ftemp;
  351.    plotmy2 = (xxmax-xx3rd) * dysize / ftemp;
  352.  
  353. }
  354.  
  355. static long _fastcall fudgetolong(double d)
  356. {
  357.    if ((d *= fudge) > 0) d += 0.5;
  358.    else          d -= 0.5;
  359.    return (long)d;
  360. }
  361.  
  362. static double _fastcall fudgetodouble(long l)
  363. {
  364.    char buf[30];
  365.    double d;
  366.    sprintf(buf,"%.9g",(double)l / fudge);
  367. #ifndef XFRACT
  368.    sscanf(buf,"%lg",&d);
  369. #else
  370.    sscanf(buf,"%lf",&d);
  371. #endif
  372.    return d;
  373. }
  374.  
  375.  
  376. void adjust_corner()
  377. {
  378.    /* make edges very near vert/horiz exact, to ditch rounding errs and */
  379.    /* to avoid problems when delta per axis makes too large a ratio    */
  380.    double ftemp,ftemp2;
  381.    if( (ftemp=fabs(xx3rd-xxmin)) < (ftemp2=fabs(xxmax-xx3rd)) ) {
  382.       if (ftemp*10000 < ftemp2 && yy3rd != yymax)
  383.      xx3rd = xxmin;
  384.       }
  385.    else if (ftemp2*10000 < ftemp && yy3rd != yymin)
  386.       xx3rd = xxmax;
  387.    if( (ftemp=fabs(yy3rd-yymin)) < (ftemp2=fabs(yymax-yy3rd)) ) {
  388.       if (ftemp*10000 < ftemp2 && xx3rd != xxmax)
  389.      yy3rd = yymin;
  390.       }
  391.    else if (ftemp2*10000 < ftemp && xx3rd != xxmin)
  392.       yy3rd = yymax;
  393. }
  394.  
  395. static void _fastcall adjust_to_limits(double expand)
  396. {  double cornerx[4],cornery[4];
  397.    double lowx,highx,lowy,highy,limit,ftemp;
  398.    double centerx,centery,adjx,adjy;
  399.    int i;
  400.    limit = 32767.99;
  401.    if (bitshift >= 24) limit = 31.99;
  402.    if (bitshift >= 29) limit = 3.99;
  403.    centerx = (xxmin+xxmax)/2;
  404.    centery = (yymin+yymax)/2;
  405.    if (xxmin == centerx) { /* ohoh, infinitely thin, fix it */
  406.       smallest_add(&xxmax);
  407.       xxmin -= xxmax-centerx;
  408.       }
  409.    if (yymin == centery) {
  410.       smallest_add(&yymax);
  411.       yymin -= yymax-centery;
  412.       }
  413.    if (xx3rd == centerx)
  414.       smallest_add(&xx3rd);
  415.    if (yy3rd == centery)
  416.       smallest_add(&yy3rd);
  417.    /* setup array for easier manipulation */
  418.    cornerx[0] = xxmin; cornerx[1] = xxmax;
  419.    cornerx[2] = xx3rd; cornerx[3] = xxmin+(xxmax-xx3rd);
  420.    cornery[0] = yymax; cornery[1] = yymin;
  421.    cornery[2] = yy3rd; cornery[3] = yymin+(yymax-yy3rd);
  422.    /* if caller wants image size adjusted, do that first */
  423.    if (expand != 1.0)
  424.       for (i=0; i<4; ++i) {
  425.      cornerx[i] = centerx + (cornerx[i]-centerx)*expand;
  426.      cornery[i] = centery + (cornery[i]-centery)*expand;
  427.       }
  428.    /* get min/max x/y values */
  429.    lowx = highx = cornerx[0];
  430.    lowy = highy = cornery[0];
  431.    for (i=1; i<4; ++i) {
  432.       if (cornerx[i] < lowx)  lowx  = cornerx[i];
  433.       if (cornerx[i] > highx) highx = cornerx[i];
  434.       if (cornery[i] < lowy)  lowy  = cornery[i];
  435.       if (cornery[i] > highy) highy = cornery[i];
  436.       }
  437.    /* if image is too large, downsize it maintaining center */
  438.    ftemp = highx-lowx;
  439.    if (highy-lowy > ftemp) ftemp = highy-lowy;
  440.    if ((ftemp = limit*2/ftemp) < 1.0)
  441.       for (i=0; i<4; ++i) {
  442.      cornerx[i] = centerx + (cornerx[i]-centerx)*ftemp;
  443.      cornery[i] = centery + (cornery[i]-centery)*ftemp;
  444.      }
  445.    /* if any corner has x or y past limit, move the image */
  446.    adjx = adjy = 0;
  447.    for (i=0; i<4; ++i) {
  448.       if (cornerx[i] > limit     && (ftemp = cornerx[i] - limit) > adjx)
  449.      adjx = ftemp;
  450.       if (cornerx[i] < 0.0-limit && (ftemp = cornerx[i] + limit) < adjx)
  451.      adjx = ftemp;
  452.       if (cornery[i] > limit     && (ftemp = cornery[i] - limit) > adjy)
  453.      adjy = ftemp;
  454.       if (cornery[i] < 0.0-limit && (ftemp = cornery[i] + limit) < adjy)
  455.      adjy = ftemp;
  456.       }
  457.    if (calc_status == 2 && (adjx != 0 || adjy != 0))
  458.       calc_status = 0;
  459.    xxmin = cornerx[0] - adjx;
  460.    xxmax = cornerx[1] - adjx;
  461.    xx3rd = cornerx[2] - adjx;
  462.    yymax = cornery[0] - adjy;
  463.    yymin = cornery[1] - adjy;
  464.    yy3rd = cornery[2] - adjy;
  465.    adjust_corner(); /* make 3rd corner exact if very near other co-ords */
  466. }
  467.  
  468. static void _fastcall smallest_add(double *num)
  469. {
  470.    *num += *num * 5.0e-16;
  471. }
  472.  
  473. static int _fastcall ratio_bad(double actual, double desired)
  474. {  double ftemp;
  475.    if (desired != 0)
  476.       if ((ftemp = actual / desired) < 0.95 || ftemp > 1.05)
  477.      return(1);
  478.    return(0);
  479. }
  480.  
  481.  
  482. /* Save/resume stuff:
  483.  
  484.    Engines which aren't resumable can simply ignore all this.
  485.  
  486.    Before calling the (per_image,calctype) routines (engine), calcfract sets:
  487.       "resuming" to 0 if new image, nonzero if resuming a partially done image
  488.       "calc_status" to 1
  489.    If an engine is interrupted and wants to be able to resume it must:
  490.       store whatever status info it needs to be able to resume later
  491.       set calc_status to 2 and return
  492.    If subsequently called with resuming!=0, the engine must restore status
  493.    info and continue from where it left off.
  494.  
  495.    Since the info required for resume can get rather large for some types,
  496.    it is not stored directly in save_info.  Instead, memory is dynamically
  497.    allocated as required, and stored in .fra files as a separate block.
  498.    To save info for later resume, an engine routine can use:
  499.       alloc_resume(maxsize,version)
  500.      Maxsize must be >= max bytes subsequently saved + 2; over-allocation
  501.      is harmless except for possibility of insufficient mem available;
  502.      undersize is not checked and probably causes serious misbehaviour.
  503.      Version is an arbitrary number so that subsequent revisions of the
  504.      engine can be made backward compatible.
  505.      Alloc_resume sets calc_status to 2 (resumable) if it succeeds; to 3
  506.      if it cannot allocate memory (and issues warning to user).
  507.       put_resume({bytes,&argument,} ... 0)
  508.      Can be called as often as required to store the info.
  509.      Arguments must not be far addresses.
  510.      Is not protected against calls which use more space than allocated.
  511.    To reload info when resuming, use:
  512.       start_resume()
  513.      initializes and returns version number
  514.       get_resume({bytes,&argument,} ... 0)
  515.      inverse of store_resume
  516.       end_resume()
  517.      optional, frees the memory area sooner than would happen otherwise
  518.  
  519.    Example, save info:
  520.       alloc_resume(sizeof(parmarray)+100,2);
  521.       put_resume(sizeof(int),&row, sizeof(int),&col,
  522.          sizeof(parmarray),parmarray, 0);
  523.     restore info:
  524.       vsn = start_resume();
  525.       get_resume(sizeof(int),&row, sizeof(int),&col, 0);
  526.       if (vsn >= 2)
  527.      get_resume(sizeof(parmarray),parmarray,0);
  528.       end_resume();
  529.  
  530.    Engines which allocate a large far memory chunk of their own might
  531.    directly set resume_info, resume_len, calc_status to avoid doubling
  532.    transient memory needs by using these routines.
  533.  
  534.    StandardFractal, calcmand, solidguess, and bound_trace_main are a related
  535.    set of engines for escape-time fractals.  They use a common worklist
  536.    structure for save/resume.  Fractals using these must specify calcmand
  537.    or StandardFractal as the engine in fractalspecificinfo.
  538.    Other engines don't get btm nor ssg, don't get off-axis symmetry nor
  539.    panning (the worklist stuff), and are on their own for save/resume.
  540.  
  541.    */
  542.  
  543. #ifndef XFRACT
  544. int put_resume(int len, ...)
  545. #else
  546. int put_resume(va_alist)
  547. va_dcl
  548. #endif
  549. {
  550.    va_list arg_marker;    /* variable arg list */
  551.    char *source_ptr;
  552. #ifdef XFRACT
  553.    int len;
  554. #endif
  555.  
  556.    if (resume_info == NULL)
  557.       return(-1);
  558. #ifndef XFRACT
  559.    va_start(arg_marker,len);
  560. #else
  561.    va_start(arg_marker);
  562.    len = va_arg(arg_marker,int);
  563. #endif
  564.    while (len)
  565.    {
  566.       source_ptr = va_arg(arg_marker,char *);
  567.       far_memcpy(resume_info+resume_len,source_ptr,len);
  568.       resume_len += len;
  569.       len = va_arg(arg_marker,int);
  570.    }
  571.    return(0);
  572. }
  573.  
  574. int alloc_resume(int alloclen, int version)
  575. {
  576.    if (resume_info != NULL) /* free the prior area if there is one */
  577.       farmemfree(resume_info);
  578.    if ((resume_info = farmemalloc((long)alloclen))== NULL)
  579.    {
  580.       static char msg[] = {"\
  581. Warning - insufficient free memory to save status.\n\
  582. You will not be able to resume calculating this image."};
  583.       stopmsg(0,msg);
  584.       calc_status = 3;
  585.       return(-1);
  586.    }
  587.    resume_len = 0;
  588.    put_resume(sizeof(int),&version,0);
  589.    calc_status = 2;
  590.    return(0);
  591. }
  592.  
  593. #ifndef XFRACT
  594. int get_resume(int len, ...)
  595. #else
  596. int get_resume(va_alist)
  597. va_dcl
  598. #endif
  599. {
  600.    va_list arg_marker;    /* variable arg list */
  601.    char *dest_ptr;
  602. #ifdef XFRACT
  603.    int len;
  604. #endif
  605.  
  606.    if (resume_info == NULL)
  607.       return(-1);
  608. #ifndef XFRACT
  609.    va_start(arg_marker,len);
  610. #else
  611.    va_start(arg_marker);
  612.    len = va_arg(arg_marker,int);
  613. #endif
  614.    while (len)
  615.    {
  616.       dest_ptr = va_arg(arg_marker,char *);
  617.       far_memcpy(dest_ptr,resume_info+resume_offset,len);
  618.       resume_offset += len;
  619.       len = va_arg(arg_marker,int);
  620.    }
  621.    return(0);
  622. }
  623.  
  624. int start_resume()
  625. {
  626.    int version;
  627.    if (resume_info == NULL)
  628.       return(-1);
  629.    resume_offset = 0;
  630.    get_resume(sizeof(int),&version,0);
  631.    return(version);
  632. }
  633.  
  634. void end_resume()
  635. {
  636.    if (resume_info != NULL) /* free the prior area if there is one */
  637.    {
  638.       farmemfree(resume_info);
  639.       resume_info = NULL;
  640.    }
  641. }
  642.  
  643.  
  644. /* Showing orbit requires converting real co-ords to screen co-ords.
  645.    Define:
  646.        Xs == xxmax-xx3rd           Ys == yy3rd-yymax
  647.        W  == xdots-1               D  == ydots-1
  648.    We know that:
  649.        realx == lx0[col] + lx1[row]
  650.        realy == ly0[row] + ly1[col]
  651.        lx0[col] == (col/width) * Xs + xxmin
  652.        lx1[row] == row * delxx
  653.        ly0[row] == (row/D) * Ys + yymax
  654.        ly1[col] == col * (0-delyy)
  655.   so:
  656.        realx == (col/W) * Xs + xxmin + row * delxx
  657.        realy == (row/D) * Ys + yymax + col * (0-delyy)
  658.   and therefore:
  659.        row == (realx-xxmin - (col/W)*Xs) / Xv     (1)
  660.        col == (realy-yymax - (row/D)*Ys) / Yv     (2)
  661.   substitute (2) into (1) and solve for row:
  662.        row == ((realx-xxmin)*(0-delyy2)*W*D - (realy-yymax)*Xs*D)
  663.               / ((0-delyy2)*W*delxx2*D-Ys*Xs)
  664.   */
  665.  
  666. /* sleep N * a tenth of a millisecond */
  667.  
  668. void sleepms(long ms)
  669. {
  670.     extern int tabmode;
  671.     static long scalems=0L;
  672.     int savehelpmode,savetabmode;
  673.     struct timeb t1,t2;
  674. #define SLEEPINIT 250 /* milliseconds for calibration */
  675.     savetabmode  = tabmode;
  676.     savehelpmode = helpmode;
  677.     tabmode  = 0;
  678.     helpmode = -1;
  679.     if(scalems==0L) /* calibrate */
  680.     {
  681.     /* selects a value of scalems that makes the units
  682.        10000 per sec independent of CPU speed */
  683.     char msg[80];
  684.     long millisecs;
  685.     int i,elapsed;
  686.  
  687.     scalems = 1L;
  688.     if(keypressed()) /* check at start, hope to get start of timeslice */
  689.        goto sleepexit;
  690.     /* calibrate, assume slow computer first */
  691.     do
  692.     {
  693.        scalems *= 2;
  694.        ftime(&t2);
  695.        do { /* wait for the start of a new tick */
  696.           ftime(&t1);
  697.         }
  698.         while (t2.time == t1.time && t2.millitm == t1.millitm);
  699.        sleepms(10L * SLEEPINIT); /* about 1/4 sec */
  700.        ftime(&t2);
  701.        if(keypressed()) {
  702.           scalems = 0L;
  703.           goto sleepexit;
  704.        }
  705.      }
  706.      while ((elapsed = (int)(t2.time-t1.time)*1000 + t2.millitm-t1.millitm)
  707.         < SLEEPINIT);
  708.     /* once more to see if faster (eg multi-tasking) */
  709.     do { /* wait for the start of a new tick */
  710.        ftime(&t1);
  711.        }
  712.      while (t2.time == t1.time && t2.millitm == t1.millitm);
  713.     sleepms(10L * SLEEPINIT);
  714.     ftime(&t2);
  715.     if ((i = (int)(t2.time-t1.time)*1000 + t2.millitm-t1.millitm) < elapsed)
  716.        elapsed = (i == 0) ? 1 : i;
  717.     scalems = (float)SLEEPINIT/(float)(elapsed) * scalems;
  718.     if (debugflag == 700) {
  719.        sprintf(msg,"scale factor=%ld",scalems);
  720.        stopmsg(0,msg);
  721.     }
  722.     }
  723.     if(ms > 10L * SLEEPINIT) { /* using ftime is probably more accurate */
  724.     ms /= 10;
  725.     ftime(&t1);
  726.     while(1) {
  727.        if(keypressed()) break;
  728.        ftime(&t2);
  729.        if ((t2.time-t1.time)*1000 + t2.millitm-t1.millitm >= ms) break;
  730.     }
  731.     }
  732.     else
  733.     if(!keypressed()) {
  734.        ms *= scalems;
  735.        while(ms-- >= 0);
  736.     }
  737. sleepexit:
  738.     tabmode  = savetabmode;
  739.     helpmode = savehelpmode;
  740. }
  741.  
  742.  
  743. static void _fastcall plotdorbit(double dx, double dy, int color)
  744. {
  745.    int i, j, c;
  746.    int save_sxoffs,save_syoffs;
  747.    if (orbit_ptr >= 1500) return;
  748.    i = dy * plotmx1 - dx * plotmx2; i += sxoffs;
  749.    if (i < 0 || i >= sxdots) return;
  750.    j = dx * plotmy1 - dy * plotmy2; j += syoffs;
  751.    if (j < 0 || j >= sydots) return;
  752.    save_sxoffs = sxoffs;
  753.    save_syoffs = syoffs;
  754.    sxoffs = syoffs = 0;
  755.    /* save orbit value */
  756.    if(color == -1)
  757.    {
  758.       *(save_orbit + orbit_ptr++) = i;
  759.       *(save_orbit + orbit_ptr++) = j;
  760.       *(save_orbit + orbit_ptr++) = c = getcolor(i,j);
  761.       putcolor(i,j,c^orbit_color);
  762.    }
  763.    else
  764.       putcolor(i,j,color);
  765.    sxoffs = save_sxoffs;
  766.    syoffs = save_syoffs;
  767.    if(orbit_delay > 0)
  768.       sleepms(orbit_delay);
  769.    if(soundflag==1)
  770.        snd((int)(i*1000/xdots+basehertz));
  771.    else if(soundflag > 1)
  772.        snd((int)(j*1000/ydots+basehertz));
  773.    /* placing sleepms here delays each dot */
  774. }
  775.  
  776. void iplot_orbit(ix, iy, color)
  777. long ix, iy;
  778. int color;
  779. {
  780.    plotdorbit((double)ix/fudge-xxmin,(double)iy/fudge-yymax,color);
  781. }
  782.  
  783. void plot_orbit(real,imag,color)
  784. double real,imag;
  785. int color;
  786. {
  787.    plotdorbit(real-xxmin,imag-yymax,color);
  788. }
  789.  
  790. void scrub_orbit()
  791. {
  792.    static long oldtime = 0;
  793.    int i,j,c;
  794.    int save_sxoffs,save_syoffs;
  795.    save_sxoffs = sxoffs;
  796.    save_syoffs = syoffs;
  797.    sxoffs = syoffs = 0;
  798.    while(orbit_ptr > 0)
  799.    {
  800.       c = *(save_orbit + --orbit_ptr);
  801.       j = *(save_orbit + --orbit_ptr);
  802.       i = *(save_orbit + --orbit_ptr);
  803.       putcolor(i,j,c);
  804.    }
  805.    sxoffs = save_sxoffs;
  806.    syoffs = save_syoffs;
  807.    nosnd();
  808. }
  809.  
  810.  
  811. int add_worklist(int xfrom, int xto, int yfrom, int yto, int ybegin,
  812. int pass, int sym)
  813. {
  814.    if (num_worklist >= MAXCALCWORK)
  815.       return(-1);
  816.    worklist[num_worklist].xxstart = xfrom;
  817.    worklist[num_worklist].xxstop  = xto;
  818.    worklist[num_worklist].yystart = yfrom;
  819.    worklist[num_worklist].yystop  = yto;
  820.    worklist[num_worklist].yybegin = ybegin;
  821.    worklist[num_worklist].pass      = pass;
  822.    worklist[num_worklist].sym      = sym;
  823.    ++num_worklist;
  824.    tidy_worklist();
  825.    return(0);
  826. }
  827.  
  828. static int _fastcall combine_worklist() /* look for 2 entries which can freely merge */
  829. {
  830.    int i,j;
  831.    for (i=0; i<num_worklist; ++i)
  832.       if (worklist[i].yystart == worklist[i].yybegin)
  833.      for (j=i+1; j<num_worklist; ++j)
  834.         if (worklist[j].sym == worklist[i].sym
  835.         && worklist[j].yystart == worklist[j].yybegin
  836.         && worklist[i].pass == worklist[j].pass)
  837.         {
  838.            if ( worklist[i].xxstart == worklist[j].xxstart
  839.            && worklist[i].xxstop  == worklist[j].xxstop)
  840.            {
  841.           if (worklist[i].yystop+1 == worklist[j].yystart)
  842.           {
  843.              worklist[i].yystop = worklist[j].yystop;
  844.              return(j);
  845.           }
  846.           if (worklist[j].yystop+1 == worklist[i].yystart)
  847.           {
  848.              worklist[i].yystart = worklist[j].yystart;
  849.              worklist[i].yybegin = worklist[j].yybegin;
  850.              return(j);
  851.           }
  852.            }
  853.            if ( worklist[i].yystart == worklist[j].yystart
  854.            && worklist[i].yystop  == worklist[j].yystop)
  855.            {
  856.           if (worklist[i].xxstop+1 == worklist[j].xxstart)
  857.           {
  858.              worklist[i].xxstop = worklist[j].xxstop;
  859.              return(j);
  860.           }
  861.           if (worklist[j].xxstop+1 == worklist[i].xxstart)
  862.           {
  863.              worklist[i].xxstart = worklist[j].xxstart;
  864.              return(j);
  865.           }
  866.            }
  867.         }
  868.    return(0); /* nothing combined */
  869. }
  870.  
  871. void tidy_worklist() /* combine mergeable entries, resort */
  872. {
  873.    int i,j;
  874.    struct workliststuff tempwork;
  875.    while (i=combine_worklist())
  876.    { /* merged two, delete the gone one */
  877.       while (++i < num_worklist)
  878.      worklist[i-1] = worklist[i];
  879.       --num_worklist;
  880.    }
  881.    for (i=0; i<num_worklist; ++i)
  882.       for (j=i+1; j<num_worklist; ++j)
  883.      if (worklist[j].pass < worklist[i].pass
  884.          || (worklist[j].pass == worklist[i].pass
  885.          && (worklist[j].yystart < worklist[i].yystart
  886.          || (   worklist[j].yystart == worklist[i].yystart
  887.          && worklist[j].xxstart <  worklist[i].xxstart))))
  888.      { /* dumb sort, swap 2 entries to correct order */
  889.         tempwork = worklist[i];
  890.         worklist[i] = worklist[j];
  891.         worklist[j] = tempwork;
  892.      }
  893. }
  894.  
  895.  
  896. void get_julia_attractor (double real, double imag)
  897. {
  898.    struct lcomplex lresult;
  899.    struct complex result;
  900.    int savper,savmaxit;
  901.  
  902.    if (attractors == 0 && finattract == 0) /* not magnet & not requested */
  903.       return;
  904.  
  905.    if (attractors >= N_ATTR)     /* space for more attractors ?  */
  906.       return;               /* Bad luck - no room left !    */
  907.  
  908.    savper = periodicitycheck;
  909.    savmaxit = maxit;
  910.    periodicitycheck = 0;
  911.    old.x = real;            /* prepare for f.p orbit calc */
  912.    old.y = imag;
  913.    tempsqrx = sqr(old.x);
  914.    tempsqry = sqr(old.y);
  915.  
  916.    lold.x = real;        /* prepare for int orbit calc */
  917.    lold.y = imag;
  918.    ltempsqrx = tempsqrx;
  919.    ltempsqry = tempsqry;
  920.  
  921.    lold.x = lold.x << bitshift;
  922.    lold.y = lold.y << bitshift;
  923.    ltempsqrx = ltempsqrx << bitshift;
  924.    ltempsqry = ltempsqry << bitshift;
  925.  
  926.    if (maxit < 500)        /* we're going to try at least this hard */
  927.       maxit = 500;
  928.    color = 0;
  929.    while (++color < maxit)
  930.       if(curfractalspecific->orbitcalc())
  931.      break;
  932.    if (color >= maxit)        /* if orbit stays in the lake */
  933.    {
  934.       if (integerfractal)   /* remember where it went to */
  935.      lresult = lnew;
  936.       else
  937.      result =  new;
  938.       if(!curfractalspecific->orbitcalc()) /* if it stays in the lake */
  939.       {                /* and doen't move far, probably */
  940.      if (integerfractal)   /*   found a finite attractor    */
  941.      {
  942.         if(labs(lresult.x-lnew.x) < lclosenuff
  943.         && labs(lresult.y-lnew.y) < lclosenuff)
  944.         {
  945.            lattr[attractors] = lnew;
  946.            attractors++;   /* another attractor - coloured lakes ! */
  947.         }
  948.      }
  949.      else
  950.      {
  951.         if(fabs(result.x-new.x) < closenuff
  952.         && fabs(result.y-new.y) < closenuff)
  953.         {
  954.            attr[attractors] = new;
  955.            attractors++;   /* another attractor - coloured lakes ! */
  956.         }
  957.      }
  958.       }
  959.    }
  960.    if(attractors==0)
  961.       periodicitycheck = savper;
  962.    maxit = savmaxit;
  963. }
  964.  
  965.  
  966. #define maxyblk 7    /* must match calcfrac.c */
  967. #define maxxblk 202  /* must match calcfrac.c */
  968. int ssg_blocksize() /* used by solidguessing and by zoom panning */
  969. {
  970.    int blocksize,i;
  971.    /* blocksize 4 if <300 rows, 8 if 300-599, 16 if 600-1199, 32 if >=1200 */
  972.    blocksize=4;
  973.    i=300;
  974.    while(i<=ydots)
  975.    {
  976.       blocksize+=blocksize;
  977.       i+=i;
  978.    }
  979.    /* increase blocksize if prefix array not big enough */
  980.    while(blocksize*(maxxblk-2)<xdots || blocksize*(maxyblk-2)*16<ydots)
  981.       blocksize+=blocksize;
  982.    return(blocksize);
  983. }
  984.  
  985.  
  986. /* Symmetry plot for period PI */
  987. void _fastcall symPIplot(x, y, color)
  988. int x, y, color ;
  989. {
  990.    while(x <= xxstop)
  991.    {
  992.       putcolor(x, y, color) ;
  993.       x += pixelpi;
  994.    }
  995. }
  996. /* Symmetry plot for period PI plus Origin Symmetry */
  997. void _fastcall symPIplot2J(x, y, color)
  998. int x, y, color ;
  999. {
  1000.    int i,j;
  1001.    while(x <= xxstop)
  1002.    {
  1003.       putcolor(x, y, color) ;
  1004.       if ((i=yystop-(y-yystart)) > iystop && i < ydots
  1005.       && (j=xxstop-(x-xxstart)) < xdots)
  1006.      putcolor(j, i, color) ;
  1007.       x += pixelpi;
  1008.    }
  1009. }
  1010. /* Symmetry plot for period PI plus Both Axis Symmetry */
  1011. void _fastcall symPIplot4J(x, y, color)
  1012. int x, y, color ;
  1013. {
  1014.    int i,j;
  1015.    while(x <= (xxstart+xxstop)/2)
  1016.    {
  1017.       j = xxstop-(x-xxstart);
  1018.       putcolor(       x , y , color) ;
  1019.       if (j < xdots)
  1020.      putcolor(j , y , color) ;
  1021.       if ((i=yystop-(y-yystart)) > iystop && i < ydots)
  1022.       {
  1023.      putcolor(x , i , color) ;
  1024.      if (j < xdots)
  1025.         putcolor(j , i , color) ;
  1026.       }
  1027.       x += pixelpi;
  1028.    }
  1029. }
  1030.  
  1031. /* Symmetry plot for X Axis Symmetry */
  1032. void _fastcall symplot2(x, y, color)
  1033. int x, y, color ;
  1034. {
  1035.    int i;
  1036.    putcolor(x, y, color) ;
  1037.    if ((i=yystop-(y-yystart)) > iystop && i < ydots)
  1038.       putcolor(x, i, color) ;
  1039. }
  1040.  
  1041. /* Symmetry plot for Y Axis Symmetry */
  1042. void _fastcall symplot2Y(x, y, color)
  1043. int x, y, color ;
  1044. {
  1045.    int i;
  1046.    putcolor(x, y, color) ;
  1047.    if ((i=xxstop-(x-xxstart)) < xdots)
  1048.       putcolor(i, y, color) ;
  1049. }
  1050.  
  1051. /* Symmetry plot for Origin Symmetry */
  1052. void _fastcall symplot2J(x, y, color)
  1053. int x, y, color ;
  1054. {
  1055.    int i,j;
  1056.    putcolor(x, y, color) ;
  1057.    if ((i=yystop-(y-yystart)) > iystop && i < ydots
  1058.        && (j=xxstop-(x-xxstart)) < xdots)
  1059.       putcolor(j, i, color) ;
  1060. }
  1061.  
  1062. /* Symmetry plot for Both Axis Symmetry */
  1063. void _fastcall symplot4(x, y, color)
  1064. int x, y, color ;
  1065. {
  1066.    int i,j;
  1067.    j = xxstop-(x-xxstart);
  1068.    putcolor(       x , y, color) ;
  1069.    if (j < xdots)
  1070.       putcolor(    j , y, color) ;
  1071.    if ((i=yystop-(y-yystart)) > iystop && i < ydots)
  1072.    {
  1073.       putcolor(    x , i, color) ;
  1074.       if (j < xdots)
  1075.      putcolor(j , i, color) ;
  1076.    }
  1077. }
  1078.  
  1079. /* Symmetry plot for X Axis Symmetry - Striped Newtbasin version */
  1080. void _fastcall symplot2basin(x, y, color)
  1081. int x, y, color ;
  1082. {
  1083.    int i,stripe;
  1084.    extern int degree;
  1085.    putcolor(x, y, color) ;
  1086.    if(basin==2 && color > 8)
  1087.       stripe=8;
  1088.    else
  1089.       stripe = 0;
  1090.    if ((i=yystop-(y-yystart)) > iystop && i < ydots)
  1091.    {
  1092.       color -= stripe;              /* reconstruct unstriped color */
  1093.       color = (degree+1-color)%degree+1;  /* symmetrical color */
  1094.       color += stripe;              /* add stripe */
  1095.       putcolor(x, i,color)  ;
  1096.    }
  1097. }
  1098.  
  1099. /* Symmetry plot for Both Axis Symmetry  - Newtbasin version */
  1100. void _fastcall symplot4basin(x, y, color)
  1101. int x, y, color ;
  1102. {
  1103.    extern int degree;
  1104.    int i,j,color1,stripe;
  1105.    if(color == 0) /* assumed to be "inside" color */
  1106.    {
  1107.       symplot4(x, y, color);
  1108.       return;
  1109.    }
  1110.    if(basin==2 && color > 8)
  1111.       stripe = 8;
  1112.    else
  1113.       stripe = 0;
  1114.    color -= stripe;          /* reconstruct unstriped color */
  1115.    color1 = degree/2+degree+2 - color;
  1116.    if(color < degree/2+2)
  1117.       color1 = degree/2+2 - color;
  1118.    else
  1119.       color1 = degree/2+degree+2 - color;
  1120.    j = xxstop-(x-xxstart);
  1121.    putcolor(       x, y, color+stripe) ;
  1122.    if (j < xdots)
  1123.       putcolor(    j, y, color1+stripe) ;
  1124.    if ((i=yystop-(y-yystart)) > iystop && i < ydots)
  1125.    {
  1126.       putcolor(    x, i, stripe + (degree+1 - color)%degree+1) ;
  1127.       if (j < xdots)
  1128.      putcolor(j, i, stripe + (degree+1 - color1)%degree+1) ;
  1129.    }
  1130. }
  1131.  
  1132. /* Do nothing plot!!! */
  1133. void _fastcall noplot(int x,int y,int color)
  1134. {
  1135. }
  1136.