std::string Number::str(unsigned precision) const
{
switch (type())
{
case Number::INTEGER:
return get_i().str(precision);
case Number::FLOATING:
return get_f().str(precision);
case Number::RATIONAL:
return get_r().str();
#ifndef PMP_DISABLE_VECTOR
case Number::VECTOR:
{
std::string s;
if (!empty())
{
s += get_v()[0].str(precision);
for (size_t i = 1; i < size(); ++i)
{
s += ", ";
s += get_v()[i].str(precision);
}
}
return s;
}
#endif
default:
assert(0);
return "";
}
}
double Mask::involution(BYTE* image,int widthBytes,int type,int x,int y){
//type indicates which color tube to use
double sum=0;
if (type==1)//r
{
for (int i = -1; i <= 1; ++i)
for (int j = -1;j<=1;j++)
sum+=get_r(image,widthBytes,x-i,y+j)*mask[(i+1)*3+j+1];
// sum/=16;
}
if (type==2)//g
{
for (int i = -1; i <= 1; ++i)
for (int j = -1;j<=1;j++)
sum+=get_g(image,widthBytes,x-i,y+j)*mask[(i+1)*3+j+1];
// sum/=16;
}
if (type==3)//b
{
for (int i = -1; i <= 1; ++i)
for (int j = -1;j<=1;j++)
sum+=get_b(image,widthBytes,x-i,y+j)*mask[(i+1)*3+j+1];
// sum/=16;
}
return sum;
}
rational_type Number::to_r() const
{
switch (type())
{
case Number::INTEGER:
return i_to_r();
case Number::FLOATING:
return f_to_r();
case Number::RATIONAL:
return get_r();
#ifndef PMP_DISABLE_VECTOR
case Number::VECTOR:
if (empty())
return 0;
else
return get_v()[0].to_r();
#endif
default:
assert(0);
return 0;
}
}
bool Number::is_zero() const
{
switch (type())
{
case Number::INTEGER:
return get_i().is_zero();
case Number::FLOATING:
return get_f().is_zero();
case Number::RATIONAL:
return get_r().is_zero();
#ifndef PMP_DISABLE_VECTOR
case Number::VECTOR:
for (size_t i = 0; i < size(); ++i)
{
if (!get_v()[i].is_zero())
return false;
}
return true;
#endif
default:
assert(0);
return false;
}
}
void Analyze::writeGrid () {
std::ofstream fout ("/Users/fred.christensen/Dropbox/school/Parallel/genetic/result.ppm");
fout << "P3\n640 420\n255\n";
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
double bias = (double)grid[x][y] / (double)max;
fout << get_r(bias) << " " << get_g(bias) << " " << get_b(bias);
if (x < width -1) {
fout << "\t";
} else {
fout << std::endl;
}
}
}
}
static real dispacement(int n, real *x, real *y, real *rmin, real *thetamin, real *pmin, real *qmin){
/* find the distance between two sets of cordinates by finding a suitable
rotation and scaling to minimize the distance */
real dist = 0, theta, normx = 0, r, d, p, q;
int i;
*thetamin = 0.;
dist = get_r(n, x, y, 0., &r, &p, &q);
*rmin = r; *pmin = p; *qmin = q;
for (i = 0; i < 180; i++){
theta = 3.1415626*i/180;
d = get_r(n, x, y, theta, &r, &p, &q);
if (d < dist){
dist = d;
*rmin = r; *pmin = p; *qmin = q;
*thetamin = theta;
}
}
for (i = 0; i < n; i++) normx += x[2*i]*x[2*i]+x[2*i+1]*x[2*i+1];
return sqrt(dist/normx);
}
int Number::sign() const
{
switch (type())
{
case Number::INTEGER:
return get_i().sign();
case Number::FLOATING:
return get_f().sign();;
case Number::RATIONAL:
return get_r().sign();
default:
assert(0);
return 0;
}
}
void Number::trim(unsigned precision/* = s_default_precision*/)
{
switch (type())
{
case Number::INTEGER:
break;
case Number::FLOATING:
{
assign(str(precision, std::ios_base::fixed));
integer_type i = to_i();
floating_type f = static_cast<floating_type>(i);
if (f == get_f())
assign(i);
}
break;
case Number::RATIONAL:
{
rational_type r = get_r();
if (b_mp::denominator(r) == 1)
assign(b_mp::numerator(r));
}
break;
#ifndef PMP_DISABLE_VECTOR
case Number::VECTOR:
for (size_t i = 0; i < get_v().size(); ++i)
get_v()[i].trim(precision);
if (size() == 1)
assign(get_v()[0]);
break;
#endif
default:
assert(0);
break;
}
}
void initialize_potential( ) {
int i, j;
double ro[Dim], rc[Dim], dr[Dim], mdr2 , pref , mdr , k2, kv[Dim] ;
pref = V / ( pow( 2.0 * sqrt(PI) *Range, Dim ) ) ; // Note: the factor of V comes from the FFT
for ( j=0 ; j<Dim ; j++ )
ro[j] = 0.0 ;
for ( i=0 ; i<M ; i++ ) {
get_r( i , rc ) ;
mdr2 = pbc_mdr2( ro, rc, dr ) ;
mdr = sqrt( mdr2 ) ;
uG[i] = exp( -mdr2 / 4.0/Range2 ) * pref ;
r_dudr[i] = -mdr2 * exp( -mdr2 / 4.0/Range2 ) ;
tmp[i] = rho0 / 2.0 * ( 1.0 - erf( ( mdr - Rp ) / Xi ) ) * V;
gammaP[i] = tmp[i] ;
}
// Set up the particle-particle potential //
fftw_fwd( tmp , ktmp ) ;
for ( i=0 ; i<M ; i++ )
ktmp2[i] = ktmp[i] * ktmp[i] ;
fftw_back( ktmp2 , uP ) ;
// Set up particle-polymer potential //
#pragma omp parallel for private(k2,kv)
for ( i=0 ; i<M ; i++ ) {
k2 = get_k( i , kv ) ;
ktmp[i] *= exp( -Range2*k2 /2.0) ;
}
fftw_back( ktmp , uPG ) ;
for ( j=0 ; j<Dim ; j++ ) {
field_gradient( uG , grad_uG[j] , j ) ;
field_gradient( uP , grad_uP[j] , j ) ;
field_gradient( uPG , grad_uPG[j] , j ) ;
}
int j2;
for ( j=0 ; j<Dim ; j++ ) {
#pragma omp parallel for private(j2, mdr2,rc, dr )
for ( i=0 ; i<M ; i++ ) {
get_r( i , rc ) ;
mdr2 = pbc_mdr2( rc , ro , dr ) ;
for ( j2=0 ; j2<Dim ; j2++ ){
vir_func[j][j2][i] = dr[j2] * -grad_uG[j][i] ;
vir_funcpp[j][j2][i] = dr[j2] * -grad_uP[j][i] ;
vir_funcpg[j][j2][i] = dr[j2] * -grad_uPG[j][i] ;
}
}
}
for ( j=0 ; j<Dim ; j++ )
for ( j2=0 ; j2<Dim ; j2++ ){
fftw_fwd( vir_func[j][j2], vir_func_hat[j][j2] ) ;
fftw_fwd( vir_funcpp[j][j2], vir_funcpp_hat[j][j2] ) ;
fftw_fwd( vir_funcpg[j][j2], vir_funcpg_hat[j][j2] ) ;
}
// write_grid_data( "ug.dat" , uG ) ;
// write_grid_data( "up.dat" , uP ) ;
// write_grid_data( "upg.dat" , uPG ) ;
for ( j=0 ; j<Dim ; j++ ) {
char nm[20] ;
fftw_fwd( grad_uG[j] , grad_uG_hat[j] ) ;
// sprintf( nm , "grad_ug_%d.dat" , j ) ;
// write_grid_data( nm , grad_uG[j] ) ;
fftw_fwd( grad_uP[j] , grad_uP_hat[j] ) ;
// sprintf( nm , "grad_up_%d.dat" , j ) ;
// write_grid_data( nm , grad_uP[j] ) ;
fftw_fwd( grad_uPG[j] , grad_uPG_hat[j] ) ;
// sprintf( nm , "grad_upg_%d.dat" , j ) ;
// write_grid_data( nm , grad_uPG[j] ) ;
}
}
uint calc(int x, int y){
// r,g,b color values around center 'c11'
// 00 10 20
// 01 11 21
// 02 12 22
uint c00=get(x-1,y-1);
uint c01=get(x-1,y);
uint c02=get(x-1,y+1);
uint c10=get(x,y-1);
uint c11=get(x,y);
uint c12=get(x,y+1);
uint c20=get(x+1,y-1);
uint c21=get(x+1,y);
uint c22=get(x+1,y+1);
// red
uint r00=get_r(x-1,y-1);
uint r01=get_r(x-1,y) ;
uint r02=get_r(x-1,y+1);
uint r10=get_r(x,y-1) ;
uint r11=get_r(x,y) ;
uint r12=get_r(x,y+1) ;
uint r20=get_r(x+1,y-1);
uint r21=get_r(x+1,y) ;
uint r22=get_r(x+1,y+1);
// green
uint g00=get_g(x-1,y-1);
uint g01=get_g(x-1,y) ;
uint g02=get_g(x-1,y+1);
uint g10=get_g(x,y-1) ;
uint g11=get_g(x,y) ;
uint g12=get_g(x,y+1) ;
uint g20=get_g(x+1,y-1);
uint g21=get_g(x+1,y) ;
uint g22=get_g(x+1,y+1);
// blue
uint b00=get_b(x-1,y-1);
uint b01=get_b(x-1,y) ;
uint b02=get_b(x-1,y+1);
uint b10=get_b(x,y-1) ;
uint b11=get_b(x,y) ;
uint b12=get_b(x,y+1) ;
uint b20=get_b(x+1,y-1);
uint b21=get_b(x+1,y) ;
uint b22=get_b(x+1,y+1);
// center colors of THIS dot
uint r=r11;
uint g=g11;
uint b=b11;
// random colors
uint zr=rand()%256;
uint zg=rand()%256;
uint zb=rand()%256;
// mean color value of surrounding
uint r0=((r10+r01+r21+r12)/4);
uint g0=((g10+g01+g21+g12)/4);
uint b0=(b10+b01+b21+b12)/4;
// Including this dot
// uint r0=((r10+r01+r11+r21+r12)/5);
// uint g0=((g10+g01+g11+g21+g12)/5);
// uint b0=(b10+b01+b11+b21+b12)/5;
float fr=r0/256.0;
float fg=g0/256.0;
float fb=b0/256.0;
uint k=128;
float h=100.0;
//////////
// done with initialization,
// now updated the dot's color based on some crazy experimental whatever function
// feel free to wildly experiment with this algorithm!
// POPULATION UPDATE
// inspired by Conway's game of life:
// if there is a sufficient population, then grow in numbers:
if(b0>=100)b=b0*1.01;
// if the population is small then shrink
if(b0<100)b=b0*(0.99-fr/100);
// if the population is too big then collapse
if(b0>240)b=0;
// repopulate collapsed populations
if(b0<3)b=120;//zb*((1.5-f)+fr*f);
if(r0>=100)r=r0*1.01;
if(r0<100)r=r0*(0.99-fg/100);
if(r11>240)r=0;
if(r11<3)r=120*(1.2-fr*fg);//zb*((1.5-f)+fr*f);
if(g0>=100)g=g0*1.01;
if(g0<100)g=g0*(0.99-f*fb/100);
if(g11>240){g=0;b=b/2;}
if(g11<3)g=120*(1-fb*fr);//zb*((1.5-f)+fr*f);
// END OF POPULATION UPDATE
if(r>255)r=255;
if(g>255)g=255;
if(b>255)b=255;
return (r<<16)+(g<<8)+b;
}
///////////////////////////////////////////////////////////////////////
// Class : CWinDisplay
// Method : data
// Description : Draw the data onto the screen
// Return Value : -
// Comments :
int CWinDisplay::data(int x,int y,int w,int h,float *d) {
int i,j;
clampData(w,h,d);
for (i=0;i<h;i++) {
const float *src = &d[i*w*numSamples];
unsigned int *dest = &imageData[((height-(i+y)-1)*width+x)];
switch(numSamples) {
case 0:
break;
case 1:
for (j=0;j<w;j++) {
unsigned char d = (unsigned char) (src[0]*255);
*dest++ = color(d,d,d,d);
src++;
}
break;
case 2:
for (j=0;j<w;j++) {
const float r = src[0]*src[1]*255 + (1-src[1])*get_r(dest[0]);
const float a = src[1]*255 + (1-src[1])*get_a(dest[0]);
unsigned char dr = (unsigned char) r;
unsigned char da = (unsigned char) a;
*dest++ = color(dr,dr,dr,da);
src += 2;
}
break;
case 3:
for (j=0;j<w;j++) {
unsigned char dr = (unsigned char) (src[0]*255);
unsigned char dg = (unsigned char) (src[1]*255);
unsigned char db = (unsigned char) (src[2]*255);
*dest++ = color(dr,dg,db,(unsigned char) 255);
src += 3;
}
break;
case 4:
for (j=0;j<w;j++) {
const float r = src[0]*src[3]*255 + (1-src[3])*get_r(dest[0]);
const float g = src[1]*src[3]*255 + (1-src[3])*get_g(dest[0]);
const float b = src[2]*src[3]*255 + (1-src[3])*get_b(dest[0]);
const float a = src[3]*255 + (1-src[3])*get_a(dest[0]);
unsigned char dr = (unsigned char) r;
unsigned char dg = (unsigned char) g;
unsigned char db = (unsigned char) b;
unsigned char da = (unsigned char) a;
*dest++ = color(dr,dg,db,da);
src += 4;
}
break;
default:
for (j=0;j<w;j++) {
float r = src[0]*src[3]*255 + (1-src[3])*get_r(*dest);
float g = src[1]*src[3]*255 + (1-src[3])*get_g(*dest);
float b = src[2]*src[3]*255 + (1-src[3])*get_b(*dest);
float a = src[3]*255 + (1-src[3])*get_a(*dest);
unsigned char dr = (unsigned char) r;
unsigned char dg = (unsigned char) g;
unsigned char db = (unsigned char) b;
unsigned char da = (unsigned char) a;
*dest++ = color(dr,dg,db,da);
src += numSamples;
}
break;
}
}
if (active) {
if (willRedraw == FALSE) {
// Pump messages
willRedraw = TRUE;
PostMessage(hWnd,WM_PAINT,(WPARAM) this,0);
}
}
return active;
}
Number& Number::operator+=(const Number& num)
{
#ifndef PMP_DISABLE_VECTOR
if (is_v() || num.is_v())
{
vector_type vec;
for (size_t i = 0; i < size(); ++i)
{
for (size_t j = 0; j < num.size(); ++j)
{
Number tmp((*this)[i]);
tmp += num[j];
vec.push_back(tmp);
}
}
assign(vec);
return *this;
}
#endif // ndef PMP_DISABLE_VECTOR
integer_type i;
floating_type f;
rational_type r;
switch (type())
{
case Number::INTEGER:
switch (num.type())
{
case Number::INTEGER:
i = get_i();
i += num.get_i();
assign(i);
break;
case Number::FLOATING:
f = to_f();
f += num.get_f();
assign(f);
break;
case Number::RATIONAL:
r = to_r();
r += num.get_r();
assign(r);
break;
default:
assert(0);
break;
}
break;
case Number::FLOATING:
switch (num.type())
{
case Number::INTEGER:
f = get_f();
f += num.to_f();
assign(f);
break;
case Number::FLOATING:
f = get_f();
f += num.get_f();
assign(f);
break;
case Number::RATIONAL:
f = get_f();
f += num.to_f();
assign(f);
break;
default:
assert(0);
break;
}
break;
case Number::RATIONAL:
switch (num.type())
{
case Number::INTEGER:
r = get_r();
r += num.to_r();
assign(r);
break;
case Number::FLOATING:
f = to_f();
f += num.get_f();
assign(f);
break;
case Number::RATIONAL:
r = get_r();
r += num.get_r();
assign(r);
break;
default:
assert(0);
break;
}
break;
default:
assert(0);
break;
}
return *this;
}
Number& Number::operator/=(const Number& num)
{
#ifndef PMP_DISABLE_VECTOR
if (is_v() || num.is_v())
{
vector_type vec;
for (size_t i = 0; i < size(); ++i)
{
for (size_t j = 0; j < num.size(); ++j)
{
Number tmp((*this)[i]);
tmp /= num[j];
vec.push_back(tmp);
}
}
assign(vec);
return *this;
}
#endif
integer_type i;
floating_type f;
rational_type r;
switch (type())
{
case Number::INTEGER:
switch (num.type())
{
case Number::INTEGER:
if (s_intdiv_type == Number::INTEGER)
{
i = get_i();
i /= num.get_i();
assign(i);
}
else if (s_intdiv_type == Number::FLOATING)
{
if (b_mp::fmod(to_f(), num.to_f()) != 0)
{
f = to_f();
f /= num.to_f();
assign(f);
}
else
{
i = get_i();
i /= num.get_i();
assign(i);
}
}
else if (s_intdiv_type == Number::RATIONAL)
{
r = rational_type(get_i(), num.get_i());
assign(r);
}
else
{
assert(0);
}
break;
case Number::FLOATING:
f = to_f();
f /= num.get_f();
assign(f);
break;
case Number::RATIONAL:
r = to_r();
r /= num.get_r();
assign(r);
break;
default:
assert(0);
break;
}
break;
case Number::FLOATING:
switch (num.type())
{
case Number::INTEGER:
f = get_f();
f /= num.to_f();
assign(f);
break;
case Number::FLOATING:
f = get_f();
f /= num.get_f();
assign(f);
break;
case Number::RATIONAL:
f = get_f();
f /= num.to_f();
assign(f);
break;
default:
assert(0);
break;
}
break;
case Number::RATIONAL:
switch (num.type())
{
case Number::INTEGER:
r = get_r();
r /= num.to_r();
assign(r);
break;
case Number::FLOATING:
f = to_f();
f /= num.get_f();
assign(f);
break;
case Number::RATIONAL:
r = get_r();
r /= num.get_r();
assign(r);
break;
default:
assert(0);
break;
}
break;
default:
assert(0);
break;
}
return *this;
}
