Welcome to Fractal Forums

> Device 0: < GeForce GTX 760 >, Compute SM 3.0 detected
Benchmark:
        Max iterations:         1024
        Number of frames:       1000
        Avg msec per frame:     8.979000

  uint   count = 0;
  double p = r;
  double q = i;
  double a;

  do  {
    if ( p * p + q * q > divergence ) break;

    a  =  p;
    p +=  q;
    p *= (a - q);
    q *= (a + a);
    p +=  r;
    q +=  i;
  }
  while (count++ < maxiter );

  return (count >= maxiter) ? 0 : ( count % maxcol + 2 );

index=y*width+x;
n = array[index]

index=y*width
n = array[index+x]

    do
    {
        a  = p;
        p += q;
        p *= (a - q);
        q *= (a + a);
        p += r;
        q += i;
        if( ( p > 2.0 || p < -2.0 ) && ( q > 2.0 || q < -2.0 ) )
            return ( count );
    }
    while (count++ < maxiter );

    return 0;

n = array[y*width+x]

n = array[fma(y,width, x)]

    // map from threadIdx/BlockIdx to pixel position
    int x = threadIdx.x + blockIdx.x * blockDim.x;
    int y = threadIdx.y + blockIdx.y * blockDim.y;
    // offset into output buffer
    int offset = (y*width);
    int clu;

    clu = fracfunc(lookup.x[offset+x], lookup.y[offset+x], d_divergence, d_maxiter, d_maxcol);

    // set pixel to color
    pixels[offset+x] = clookup[clu];

/usr/local/cuda/include/host_config.h:82:2: error: #error -- unsupported GNU version! gcc 4.5 and up are not supported!

n = array[fma(y,width, x)]

error: expression must have integral or enum type

index=y*width
n = array[index+x]

index=fma(y,width,x)
n = array[index]

/// compute the magnitude of a complex number.
double Approximation::cMag(double re, double im)
{
    double r;

    re = fabs(re);
    im = fabs(im);

    if (re > im) {
        r = fabs(im/re);
        return re*sqrt(1.0+r*r);
    }

    if (im == 0.0)
        return 0.0;

    r = fabs(re/im);
    return im*sqrt(1.0+r*r);
}

            if(cnt > (mBuffer->GetWidth() >> 8)+1 )
            {
                newXOffset=x;
                newYOffset=y;
                break;
            }

#define FLT128_MAX 1.18973149535723176508575932662800702e4932Q
#define FLT128_MIN 3.36210314311209350626267781732175260e-4932Q
#define FLT128_EPSILON 1.92592994438723585305597794258492732e-34Q
#define FLT128_DENORM_MIN 6.475175119438025110924438958227646552e-4966Q
#define FLT128_MANT_DIG 113
#define FLT128_MIN_EXP (-16381)
#define FLT128_MAX_EXP 16384
#define FLT128_DIG 33
#define FLT128_MIN_10_EXP (-4931)
#define FLT128_MAX_10_EXP 4932

#define EPSILON 1.0E-9
#define BIGNUM = 1.0/EPSILON;

           if((max(fabs(c-dx),fabs(ci-dxi))/max(fabs(dx),fabs(dxi)) < EPSILON) || 
	      (max(fabs(c+dx),fabs(ci+dxi))/max(fabs(dx),fabs(dxi)) > BIGNUM))

#define EPSILON 1.0E-15
#define BIGNUM = 1.0/EPSILON;

           if(( min (fabs(c-dx),fabs(ci-dxi))/ max (fabs(dx),fabs(dxi)) < EPSILON) || 
	     ( max (fabs(c+dx),fabs(ci+dxi))/ min (fabs(dx),fabs(dxi)) > BIGNUM))

if(modulus<1.E-10)

if((max(fabs(c-dx),fabs(ci-dxi))/max(fabs(dx),fabs(dxi)) < EPSILON) || 
	      (max(fabs(c+dx),fabs(ci+dxi))/max(fabs(dx),fabs(dxi)) > BIGNUM))

void Details::FillInCubic( mp_real pX, mp_real pY, int aIteration_limit, double aActual_width, int aSize_extra_exponent, double aScreen_offset_x, double aScreen_offset_y )
(...)

                    // The initial size was scaled up.
                    // Now we adjust the ABC coefficients to compensate for the scale.
                    // This will affect the accuracy test, and may allow us to continue
                    do
                    {
                        extra_exponent--;
                        A *= 0.10000000149011612D;
                        (...)
                        csq *= 9.999999747378752E-5D;

                        width *= 0.10000000149011612D;
                    } while (extra_exponent>0 && (csq >=accuracy*accuracy*asq) && csq!=0.0D);

Horizontal Size 2.265005662514156285e-72
Real position:  -1.985548413352953418245678803517026040561987431985854276276406746845711128525331973761520766949399973186380456945
Imaginary Position:  0.0000000000002743067126729694556175287646032154237263455024187599021148863659471173433723750561476242243458678403
Iteration Limit: 11256

   if(mRemains) mPixels_to_recalc = 0; // signal finished final pass 

########################################

Initialise Calculation...
        Details Storage:106056k
        FillInCubic:8:13.493

########################################

Reference Point 1 = 4:5.578
Reference Iterations:49998840   XOff:0.0292969  YOff:0.0898437
        ReFillInCubic: 2:4.684

Reference Point 2 = 0:0.518
Reference Iterations:50240274   XOff:-0.735264  YOff:-0.239156
        ReFillInCubic: 2:5.608

Reference Point 3 = 0:0.534
Reference Iterations:50325223   XOff:-0.707224  YOff:-0.676797
        ReFillInCubic: 2:2.643

Reference Point 4 = 0:0.712
Reference Iterations:50264717   XOff:0.915509   YOff:-0.621909
        ReFillInCubic: 2:3.214

Reference Point 5 = 0:0.516
Reference Iterations:50251112   XOff:0.490445   YOff:-0.702583
        ReFillInCubic: 2:4.884

Total Render Time:212:42.704 @ 1024x768