Las matemáticas enteras pueden generar patrones sorprendentes cuando se distribuyen sobre una cuadrícula. ¡Incluso las funciones más básicas pueden producir diseños increíblemente elaborados!

Tu reto

Escriba 3 cuerpos de función Tweetable (que significa 140 caracteres o menos) para los valores rojo, verde y azul para una imagen de 1024x1024.

La entrada a las funciones será dos enteros i (número de columna para el píxel dado) y j (número de fila para el píxel dado) y la salida será un corto sin signo entre 0 y 1023, inclusive, que representa la cantidad de color presente en el píxel (i, j).

Por ejemplo, las siguientes tres funciones producen la siguiente imagen:

/* RED */
    return (unsigned short)sqrt((double)(_sq(i-DIM/2)*_sq(j-DIM/2))*2.0);
/* GREEN */
    return (unsigned short)sqrt((double)(
        (_sq(i-DIM/2)|_sq(j-DIM/2))*
        (_sq(i-DIM/2)&_sq(j-DIM/2))
    )); 
/* BLUE */
    return (unsigned short)sqrt((double)(_sq(i-DIM/2)&_sq(j-DIM/2))*2.0);

/* RED */
    return i&&j?(i%j)&(j%i):0;
/* GREEN */
    return i&&j?(i%j)+(j%i):0;
/* BLUE */
    return i&&j?(i%j)|(j%i):0;

Las normas

• Dado este código C ++ , sustituya en sus funciones. He proporcionado algunas macros y he incluido la biblioteca, y puede incluir complex.h. Puede usar cualquier función de estas bibliotecas y / o mis macros. No utilice ningún recurso externo más allá de esto.

• Si esa versión no funciona para usted, asegúrese de estar compilando con:

  g++ filename.cpp -std=c++11
  

  Si eso no funciona, utilice la versión alternativa con caracteres sin signo en lugar de cortos sin signo.

Michaelangelo ha proporcionado una versión limpia de salida de color de 24 o 48 bits .

• Puede implementar su propia versión en otro idioma, pero debe comportarse de la misma manera que la versión de C ++ provista, y solo las funciones de las funciones integradas de C ++, la biblioteca o las macros proporcionadas pueden usarse para hacerlo justo.
• Publique solo sus tres cuerpos de funciones; no incluya mi código en su publicación
• Incluya una versión más pequeña o una copia incrustada de su imagen. Están hechos en un formato de ppm y es posible que necesiten convertirse a otro para una visualización adecuada en stackexchange.
• Los cuerpos de las funciones (sin incluir la firma) deben tener 140 caracteres o menos.
• Este es un concurso de popularidad: la mayoría de los votos gana

Mandelbrot 3 x 133 caracteres

Lo primero que me vino a la mente fue "Mandelbrot!".

Sí, sé que ya hay una presentación de Mandelbrot. Después de confirmar que puedo obtener menos de 140 caracteres, he tomado los trucos y las optimizaciones de esa solución en la mía (gracias Martin y Todd). Eso dejó espacio para elegir una ubicación interesante y hacer zoom, así como un buen tema de color:

unsigned char RD(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,3.);
}
unsigned char GR(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,.7);
}
unsigned char BL(int i,int j){
   double a=0,b=0,c,d,n=0;
   while((c=a*a)+(d=b*b)<4&&n++<880)
   {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
   return 255*pow((n-80)/800,.5);
}

132 caracteres en total

Traté de bajarlo a 140 para los 3 canales. Hay un poco de ruido de color cerca del borde, y la ubicación no es tan interesante como la primera, pero: 132 caracteres

unsigned char RD(int i,int j){
  double a=0,b=0,d,n=0;
  for(;a*a+(d=b*b)<4&&n++<8192;b=2*a*b+j/5e4+.06,a=a*a-d+i/5e4+.34);
  return n/4;
}
unsigned char GR(int i,int j){
  return 2*RD(i,j);
}
unsigned char BL(int i,int j){
  return 4*RD(i,j);
}

Manteles

Plano

Comencé poniendo un patrón de cuadros / cuadros en perspectiva como un mantel sin límites:

unsigned char RD(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    return (int((i+DIM)*s+j*s)%2+int((DIM*2-i)*s+j*s)%2)*127;
}

Onda

Luego introduje una onda (perspectiva no estrictamente correcta, pero aún en 140 caracteres):

unsigned char RD(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}

Color

Luego hice algunos de los colores más finos para dar detalles en una gama más amplia de escalas y hacer que la imagen sea más colorida ...

unsigned char RD(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;
}
unsigned char GR(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127;
}
unsigned char BL(int i,int j){
    float s=3./(j+99);
    float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s;
    return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127;
}

En movimiento

Reducir el código un poco más permite definir una fase de onda P con 2 decimales, lo cual es suficiente para cuadros lo suficientemente cercanos como para una animación suave. Reduje la amplitud en esta etapa para evitar provocar mareos, y cambié la imagen completa otros 151 píxeles (al costo de 1 carácter adicional) para eliminar el alias de la parte superior de la imagen. El alias animado es fascinante.

unsigned char RD(int i,int j){
#define P 6.03
float s=3./(j+250),y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127;}

unsigned char GR(int i,int j){
float s=3./(j+250);
float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;
return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127;}

unsigned char BL(int i,int j){
float s=3./(j+250);
float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM+P)*15)*s;
return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127;}

Pintor al azar

char red_fn(int i,int j){
#define r(n)(rand()%n)
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):red_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}
char green_fn(int i,int j){
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):green_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}
char blue_fn(int i,int j){
    static char c[1024][1024];return!c[i][j]?c[i][j]=!r(999)?r(256):blue_fn((i+r(2))%1024,(j+r(2))%1024):c[i][j];
}

Aquí hay una entrada basada en la aleatoriedad. Para aproximadamente el 0.1% de los píxeles elige un color aleatorio, para los demás usa el mismo color que un píxel adyacente aleatorio. Tenga en cuenta que cada color hace esto de forma independiente, por lo que en realidad es solo una superposición de una imagen aleatoria de verde, azul y rojo. Para obtener diferentes resultados en diferentes ejecuciones, deberá agregar srand(time(NULL))a la mainfunción.

Ahora para algunas variaciones.

Al omitir píxeles, podemos hacerlo un poco más borroso.

Y luego podemos cambiar lentamente los colores, donde los desbordamientos resultan en cambios abruptos que hacen que esto se vea aún más como pinceladas

Cosas que necesito resolver:

• Por alguna razón, no puedo poner sranddentro de esas funciones sin obtener un segfault.
• Si pudiera hacer que las caminatas aleatorias sean las mismas en los tres colores, podría parecer un poco más ordenado.

También puede hacer que la caminata aleatoria sea isotrópica, como

static char c[1024][1024];return!c[i][j]?c[i][j]=r(999)?red_fn((i+r(5)+1022)%1024,(j+r(5)+1022)%1024):r(256):c[i][j];

darte

Más cuadros al azar

He jugado un poco más con esto y he creado algunas otras pinturas al azar. No todos estos son posibles dentro de las limitaciones de este desafío, por lo que no quiero incluirlos aquí. Pero puedes verlos en esta galería de imágenes junto con algunas descripciones de cómo los produje .

Estoy tentado a desarrollar todas estas posibilidades en un marco y ponerlo en GitHub. (No es que cosas como esta aún no existan, ¡pero es divertido de todos modos!)

Algunas cosas puntiagudas

Sí, sabía exactamente cómo llamarlo.

unsigned short RD(int i,int j){
    return(sqrt(_sq(73.-i)+_sq(609-j))+1)/(sqrt(abs(sin((sqrt(_sq(860.-i)+_sq(162-j)))/115.0)))+1)/200;
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(160.-i)+_sq(60-j))+1)/(sqrt(abs(sin((sqrt(_sq(86.-i)+_sq(860-j)))/115.0)))+1)/200;
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(844.-i)+_sq(200-j))+1)/(sqrt(abs(sin((sqrt(_sq(250.-i)+_sq(20-j)))/115.0)))+1)/200;
}

EDITAR: ya no se usa pow. EDIT 2: @PhiNotPi señaló que no necesito usar abdominales tanto.

Puede cambiar los puntos de referencia con bastante facilidad para obtener una imagen diferente:

unsigned short RD(int i,int j){
    return(sqrt(_sq(148.-i)+_sq(1000-j))+1)/(sqrt(abs(sin((sqrt(_sq(500.-i)+_sq(400-j)))/115.0)))+1)/200;
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(610.-i)+_sq(60-j))+1)/(sqrt(abs(sin((sqrt(_sq(864.-i)+_sq(860-j)))/115.0)))+1)/200;
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(180.-i)+_sq(100-j))+1)/(sqrt(abs(sin((sqrt(_sq(503.-i)+_sq(103-j)))/115.0)))+1)/200;
}

@EricTressler señaló que mis fotos tienen Batman en ellas.

Por supuesto, tiene que haber una presentación de Mandelbrot.

char red_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k>31?256:k*8;
}
char green_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k>63?256:k*4;
}
char blue_fn(int i,int j){
    float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;}return k;
}

Intentando mejorar el esquema de color ahora. ¿Es engañoso si defino el cálculo como una macro red_fny uso esa macro en las otras dos para tener más caracteres para la selección de colores elegantes en verde y azul?

Editar: es realmente difícil crear esquemas de color decentes con estos pocos bytes restantes. Aquí hay otra versión:

/* RED   */ return log(k)*47;
/* GREEN */ return log(k)*47;
/* BLUE  */ return 128-log(k)*23;

Y según la sugerencia de los gitofagocitos y con las mejoras de Todd Lehman, podemos elegir fácilmente secciones más pequeñas:

P.ej

char red_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return log(k)/10.15*256;
}
char green_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return log(k)/10.15*256;
}
char blue_fn(int i,int j){
    float x=0,y=0,k=0,X,Y;while(k++<256e2&&(X=x*x)+(Y=y*y)<4)y=2*x*y+(j-89500)/102400.,x=X-Y+(i-14680)/102400.;return 128-k/200;
}

da

Juegos de julia

Si hay un Mandelbrot, también debería haber un conjunto de Julia.

Puede pasar horas ajustando los parámetros y funciones, por lo que este es solo uno rápido que parece decente.

Inspirado en la participación de Martin.

unsigned short red_fn(int i, int j){
#define D(x) (x-DIM/2.)/(DIM/2.)
float x=D(i),y=D(j),X,Y,n=0;while(n++<200&&(X=x*x)+(Y=y*y)<4){x=X-Y+.36237;y=2*x*y+.32;}return log(n)*256;}

unsigned short green_fn(int i, int j){
float x=D(i),y=D(j),X,Y,n=0;while(n++<200&&(x*x+y*y)<4){X=x;Y=y;x=X*X-Y*Y+-.7;y=2*X*Y+.27015;}return log(n)*128;}

unsigned short blue_fn(int i, int j){
float x=D(i),y=D(j),X,Y,n=0;while(n++<600&&(x*x+y*y)<4){X=x;Y=y;x=X*X-Y*Y+.36237;y=2*X*Y+.32;}return log(n)*128;}

¿Quieres un poco de RNG?

Bien, el comentario de Sparr me puso en la pista para aleatorizar los parámetros de estas pequeñas Julias. Primero intenté hacer piratería a nivel de bits con el resultado de, time(0)pero C ++ no permite literales hexadecimales de coma flotante, por lo que este fue un callejón sin salida (al menos con mi conocimiento limitado). Podría haber usado un casting pesado para lograrlo, pero eso no habría encajado en los 140 bytes.

No me quedaba mucho espacio de todos modos, así que tuve que soltar la Julia roja para poner mis macros y tener un RNG más convencional ( timed seed y real rand(), ¡woohoo!).

Vaya, falta algo. Obviamente, estos parámetros tienen que ser estáticos o, de lo contrario, tendrá algunos resultados extraños (pero divertido, tal vez investigaré un poco más tarde si encuentro algo interesante).

Así que aquí estamos, con solo canales verdes y azules:

Ahora agreguemos un patrón rojo simple para llenar el vacío. No es realmente imaginativo, pero no soy un programador gráfico ... todavía :-)

Y finalmente el nuevo código con parámetros aleatorios:

unsigned short red_fn(int i, int j){
static int n=1;if(n){--n;srand(time(0));}
#define R rand()/16384.-1
#define S static float r=R,k=R;float
return _cb(i^j);}

unsigned short green_fn(int i, int j){
#define D(x) (x-DIM/2.)/(DIM/2.),
S x=D(i)y=D(j)X,Y;int n=0;while(n++<200&&(X=x)*x+(Y=y)*y<4){x=X*X-Y*Y+r;y=2*X*Y+k;}return log(n)*512;}

unsigned short blue_fn(int i, int j){
S x=D(i)y=D(j)X,Y;int n=0;while(n++<200&&(X=x)*x+(Y=y)*y<4){x=X*X-Y*Y+r;y=2*X*Y+k;}return log(n)*512;}

Todavía queda espacio ahora ...

Este es interesante porque no utiliza los parámetros i, j en absoluto. En cambio, recuerda el estado en una variable estática.

unsigned char RD(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}
unsigned char GR(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}
unsigned char BL(int i,int j){
   static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l;
}

/* RED */
    int a=(j?i%j:i)*4;int b=i-32;int c=j-32;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((b+c)/2))^_cb((b-c)*2);
/* GREEN */
    int a=(j?i%j:i)*4;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((i+j)/2))^_cb((i-j)*2);
/* BLUE */
    int a=(j?i%j:i)*4;int b=i+32;int c=j+32;return _sq(abs(i-512))+_sq(abs(j-512))>_sq(384)?a:int(sqrt((b+c)/2))^_cb((b-c)*2);

Buddhabrot (+ Antibuddhabrot)

Editar: ¡ Ahora es un Buddhabrot apropiado!

Editar: logré limitar la intensidad del color dentro del límite de bytes, por lo que no hay más píxeles falsamente negros debido al desbordamiento.

Tenía muchas ganas de parar después de las cuatro ... pero ...

Esto se comprime ligeramente durante la carga (y se reduce al incrustar), por lo que si desea admirar todos los detalles, aquí está el interesante 512x512 recortado (que no se comprime y se muestra en su tamaño completo):

Gracias a githubphagocyte por la idea. Esto requirió un abuso bastante complicado de las tres funciones de color:

unsigned short RD(int i,int j){
    #define f(a,b)for(a=0;++a<b;)
    #define D float x=0,y=0
    static int z,m,n;if(!z){z=1;f(m,4096)f(n,4096)BL(m-4096,n-4096);};return GR(i,j);
}
unsigned short GR(int i,int j){
    #define R a=x*x-y*y+i/1024.+2;y=2*x*y+j/1024.+2
    static float c[DIM][DIM],p;if(i>=0)return(p=c[i][j])>DM1?DM1:p;c[j+DIM][i/2+DIM]+=i%2*2+1;
}
unsigned short BL(int i,int j){
    D,a,k,p=0;if(i<0)f(k,5e5){R;x=a;if(x*x>4||y*y>4)break;GR(int((x-2)*256)*2-p,(y-2)*256);if(!p&&k==5e5-1){x=y=k=0;p=1;}}else{return GR(i,j);}
}

Quedan algunos bytes para un mejor esquema de color, pero hasta ahora no he encontrado nada que supere la imagen en escala de grises.

El código que se proporciona utiliza 4096x4096 puntos de partida y realiza hasta 500,000 iteraciones en cada uno de ellos para determinar si las trayectorias escapan o no. Eso tomó entre 6 y 7 horas en mi máquina. Puede obtener resultados decentes con una cuadrícula de 2k por 2k y 10k iteraciones, lo que lleva dos minutos, e incluso solo una cuadrícula de 1k por 1k con 1k iteraciones se ve bastante bien (eso lleva unos 3 segundos). Si desea jugar con esos parámetros, hay algunos lugares que deben cambiar:

• Para cambiar el nivel de recursividad de Mandelbrot, ajuste ambas instancias de 5e5en BLa su cuenta de iteración.
• Para cambiar la resolución de la cuadrícula, cambiar los cuatro 4096en RDque la resolución deseada y 1024.en GRel mismo factor para mantener la escala correcta.
• Es probable que también tenga que escalar la return c[i][j]en GRya que sólo contiene el número absoluto de visitas de cada píxel. El color máximo parece ser mayormente independiente del recuento de iteraciones y se escala linealmente con el número total de puntos de partida. Entonces, si desea usar una cuadrícula de 1k por 1k, es posible que desee return c[i][j]*16;o similar, pero ese factor a veces necesita un poco de violín.

Para aquellos que no están familiarizados con el Buddhabrot (como yo hace un par de días), se basa en el cálculo de Mandelbrot, pero la intensidad de cada píxel es la frecuencia con la que se visitó ese píxel en las iteraciones de las trayectorias de escape. Si estamos contando las visitas durante las trayectorias que no escapan, es un Antibuddhabrot. Existe una versión aún más sofisticada llamada Nebulabrot, donde utiliza una profundidad de recursión diferente para cada canal de color. Pero se lo dejaré a otra persona. Para más información, como siempre, Wikipedia .

Originalmente, no distinguí entre las trayectorias de escape y las de no escape. Eso generó una trama que es la unión de un Buddhabrot y un Antibuddhabrot (como lo señala el githubphagocyte).

unsigned short RD(int i,int j){
    #define f(a)for(a=0;++a<DIM;)
    static int z;float x=0,y=0,m,n,k;if(!z){z=1;f(m)f(n)GR(m-DIM,n-DIM);};return BL(i,j);
}
unsigned short GR(int i,int j){
    float x=0,y=0,a,k;if(i<0)f(k){a=x*x-y*y+(i+256.0)/512;y=2*x*y+(j+512.0)/512;x=a;if(x*x+y*y>4)break;BL((x-.6)*512,(y-1)*512);}return BL(i,j);
}
unsigned short BL(int i,int j){
    static float c[DIM][DIM];if(i<0&&i>-DIM-1&&j<0&&j>-DIM-1)c[j+DIM][i+DIM]++;else if(i>0&&i<DIM&&j>0&&j<DIM)return log(c[i][j])*110;
}

Esta se parece un poco a una fotografía desvaída ... Me gusta eso.

Pentágono de Sierpinski

Es posible que hayas visto el método del juego del caos para aproximar el Triángulo de Sierpinski al trazar puntos a la mitad de un vértice elegido al azar. Aquí he tomado el mismo enfoque usando 5 vértices. El código más corto en el que podía establecerme incluía la codificación rígida de los 5 vértices, y no había forma de que lo ajustara todo en 140 caracteres. Así que delegué el componente rojo a un fondo simple, y usé el espacio libre en la función roja para definir una macro para que las otras dos funciones también sean inferiores a 140. Entonces, todo es válido a costa de no tener un componente rojo en el pentágono.

unsigned char RD(int i,int j){
#define A int x=0,y=0,p[10]={512,9,0,381,196,981,827,981,DM1,381}
auto s=99./(j+99);return GR(i,j)?0:abs(53-int((3e3-i)*s+j*s)%107);}

unsigned char GR(int i,int j){static int c[DIM][DIM];if(i+j<1){A;for(int n=0;n<2e7;n++){int v=(rand()%11+1)%5*2;x+=p[v];x/=2;y+=p[v+1];y/=2;c[x][y]++;}}return c[i][j];}

unsigned char BL(int i,int j){static int c[DIM][DIM];if(i+j<1){A;for(int n=0;n<3e7;n++){int v=(rand()%11+4)%5*2;x+=p[v];x/=2;y+=p[v+1];y/=2;c[x][y]++;}}return c[i][j];}

Gracias a Martin Büttner por la idea mencionada en los comentarios de la pregunta sobre la definición de una macro en una función para luego usarla en otra, y también por usar la memorización para llenar los píxeles en un orden arbitrario en lugar de estar restringida al orden ráster de la función principal .

La imagen tiene más de 500 KB, por lo que se convierte automáticamente a jpg por intercambio de pila. Esto difumina algunos de los detalles más finos, por lo que también he incluido solo el cuarto superior derecho como png para mostrar el aspecto original:

Partitura

La música de Sierpinski. : D Los chicos en el chat dicen que se parece más al papel perforado para cajas de música.

unsigned short RD(int i,int j){
    return ((int)(100*sin((i+400)*(j+100)/11115)))&i;
}
unsigned short GR(int i,int j){
    return RD(i,j);
}
unsigned short BL(int i,int j){
    return RD(i,j);
}

Algunos detalles sobre cómo funciona ... um, en realidad es solo un acercamiento en una representación de algunos triángulos ondulados de Sierpinski. El aspecto de la partitura (y también el bloqueo) es el resultado del truncamiento de enteros. Si cambio la función roja a, digamos,

return ((int)(100*sin((i+400)*(j+100)/11115.0)));

se elimina el truncamiento y obtenemos el render de resolución completa:

Entonces sí, eso es interesante.

Generador de diagrama de Voronoi al azar alguien

OK, este me hizo pasar un mal rato. Sin embargo, creo que es bastante bueno, incluso si los resultados no son tan artísticos como otros. Ese es el trato con la aleatoriedad. Tal vez algunas imágenes intermedias se vean mejor, pero realmente quería tener un algoritmo completamente funcional con diagramas voronoi.

Editar:

Este es un ejemplo del algoritmo final. La imagen es básicamente la superposición de tres diagramas voronoi, uno para cada componente de color (rojo, verde, azul).

Código

versión no comentada y comentada al final

unsigned short red_fn(int i, int j){
int t[64],k=0,l,e,d=2e7;srand(time(0));while(k<64){t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

unsigned short green_fn(int i, int j){
static int t[64];int k=0,l,e,d=2e7;while(k<64){if(!t[k])t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

unsigned short blue_fn(int i, int j){
static int t[64];int k=0,l,e,d=2e7;while(k<64){if(!t[k])t[k]=rand()%DIM;if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)d=e,l=k;}return t[l];
}

Me tomó muchos esfuerzos, así que tengo ganas de compartir los resultados en diferentes etapas, y hay algunos buenos (incorrectos) para mostrar.

Primer paso: coloque algunos puntos al azar, con x=y

Lo he convertido a jpeg porque el png original era demasiado pesado para cargar ( >2MB), ¡apuesto a que son más de 50 tonos de gris!

Segundo: tener una mejor coordenada y

No podía permitirme tener otra tabla de coordenadas generada aleatoriamente para el yeje, por lo que necesitaba una forma simple de obtener las " aleatorias " en la menor cantidad de caracteres posible. Fui a usar la xcoordenada de otro punto en la tabla, haciendo un bit ANDa bit en el índice del punto.

3 °: no recuerdo pero se está poniendo bien

Pero en este momento tenía más de 140 caracteres, así que necesitaba jugar golf bastante.

4to: líneas de escaneo

Es broma, esto no es deseable, pero me parece genial.

Aún trabajando para reducir el tamaño del algoritmo, me enorgullece presentar:

Edición StarFox

Voronoi instagram

5to: aumentar el número de puntos

Ahora tengo un código funcional, así que pasemos de 25 a 60 puntos.

Eso es difícil de ver desde una sola imagen, pero los puntos están casi todos ubicados en el mismo yrango. Por supuesto, no cambié la operación bit a bit, &42es mucho mejor:

Y aquí estamos, en el mismo punto que la primera imagen de esta publicación. Ahora expliquemos el código para los raros que estarían interesados.

Código sin golf y explicado

unsigned short red_fn(int i, int j)
{
    int t[64],          // table of 64 points's x coordinate
        k = 0,          // used for loops
        l,              // retains the index of the nearest point
        e,              // for intermediary results
        d = 2e7;        // d is the minimum distance to the (i,j) pixel encoutnered so far
        // it is initially set to 2e7=2'000'000 to be greater than the maximum distance 1024²

    srand(time(0));     // seed for random based on time of run
    // if the run overlaps two seconds, a split will be observed on the red diagram but that is
    // the better compromise I found

    while(k < 64)       // for every point
    {
        t[k] = rand() % DIM;        // assign it a random x coordinate in [0, 1023] range
        // this is done at each call unfortunately because static keyword and srand(...)
        // were mutually exclusive, lenght-wise

        if (
            (e=                         // assign the distance between pixel (i,j) and point of index k
                _sq(i - t[k])           // first part of the euclidian distance
                +
                _sq(j - t[42 & k++])    // second part, but this is the trick to have "" random "" y coordinates
                // instead of having another table to generate and look at, this uses the x coordinate of another point
                // 42 is 101010 in binary, which is a better pattern to apply a & on; it doesn't use all the table
                // I could have used 42^k to have a bijection k <-> 42^k but this creates a very visible pattern splitting the image at the diagonal
                // this also post-increments k for the while loop
            ) < d                       // chekcs if the distance we just calculated is lower than the minimal one we knew
        )
        // {                            // if that is the case
            d=e,                        // update the minimal distance
            l=k;                        // retain the index of the point for this distance
            // the comma ',' here is a trick to have multiple expressions in a single statement
            // and therefore avoiding the curly braces for the if
        // }
    }

    return t[l];        // finally, return the x coordinate of the nearest point
    // wait, what ? well, the different areas around points need to have a
    // "" random "" color too, and this does the trick without adding any variables
}

// The general idea is the same so I will only comment the differences from green_fn
unsigned short green_fn(int i, int j)
{
    static int t[64];       // we don't need to bother a srand() call, so we can have these points
    // static and generate their coordinates only once without adding too much characters
    // in C++, objects with static storage are initialized to 0
    // the table is therefore filled with 60 zeros
    // see http://stackoverflow.com/a/201116/1119972

    int k = 0, l, e, d = 2e7;

    while(k<64)
    {
        if( !t[k] )                 // this checks if the value at index k is equal to 0 or not
        // the negation of 0 will cast to true, and any other number to false
            t[k] = rand() % DIM;    // assign it a random x coordinate

        // the following is identical to red_fn
        if((e=_sq(i-t[k])+_sq(j-t[42&k++]))<d)
            d=e,l=k;
    }

    return t[l];
}

Gracias por leer hasta ahora.

El fractal de Lyapunov

La cadena utilizada para generar esto fue AABAB y el espacio del parámetro fue [2,4] x [2,4]. ( explicación de la cadena y el espacio de parámetros aquí )

Con espacio de código limitado, pensé que este color era bastante genial.

    //RED
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return abs(s);
    //GREEN
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return s>0?s:0;
    //BLUE
    float r,s=0,x=.5;for(int k=0;k++<50;)r=k%5==2||k%5==4?(2.*j)/DIM+2:(2.*i)/DIM+2,x*=r*(1-x),s+=log(fabs(r-r*2*x));return abs(s*x);

También hice una variación del conjunto de Mandelbrot. Utiliza un mapa similar al conjunto de mapas de Mandelbrot. Digamos que M (x, y) es el mapa de Mandelbrot. Entonces M (sin (x), cos (y)) es el mapa que uso, y en lugar de verificar los valores de escape, uso x e y, ya que siempre están delimitados.

//RED
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 2.5*(x*x+y*y);
//GREEN
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 15*fabs(x);
//BLUE
float x=0,y=0;for(int k=0;k++<15;){float t=_sq(sin(x))-_sq(cos(y))+(i-512.)/512;y=2*sin(x)*cos(y)+(j-512.0)/512;x=t;}return 15*fabs(y);

EDITAR

Después de mucho dolor finalmente pude crear un gif de la segunda imagen transformándose. Aquí está:

Porque los unicornios.

No pude obtener la versión de OP con unsigned shorty valores de color de hasta 1023 funcionando, así que hasta que se solucione, aquí hay una versión con charun valor de color máximo de 255.

char red_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2))*255);
}
char green_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2-2*acos(-1)/3))*255);
}
char blue_fn(int i,int j){
    return (char)(_sq(cos(atan2(j-512,i-512)/2+2*acos(-1)/3))*255);
}

Colinas logísticas

Las funciones

unsigned char RD(int i,int j){    
    #define A float a=0,b,k,r,x
    #define B int e,o
    #define C(x) x>255?255:x
    #define R return
    #define D DIM
    R BL(i,j)*(D-i)/D;
}
unsigned char GR(int i,int j){      
    #define E DM1
    #define F static float
    #define G for(
    #define H r=a*1.6/D+2.4;x=1.0001*b/D
    R BL(i,j)*(D-j/2)/D;
}
unsigned char BL(int i,int j){
    F c[D][D];if(i+j<1){A;B;G;a<D;a+=0.1){G b=0;b<D;b++){H;G k=0;k<D;k++){x=r*x*(1-x);if(k>D/2){e=a;o=(E*x);c[e][o]+=0.01;}}}}}R C(c[j][i])*i/D;
}

Sin golf

Todos los #defines son para encajar BL bajo 140 caracteres. Aquí está la versión no adaptada del algoritmo azul, ligeramente modificada:

for(double a=0;a<DIM;a+=0.1){       // Incrementing a by 1 will miss points
    for(int b=0;b<DIM;b++){         // 1024 here is arbitrary, but convenient
        double r = a*(1.6/DIM)+2.4; // This is the r in the logistic bifurcation diagram (x axis)
        double x = 1.0001*b/DIM;    // This is x in the logistic bifurcation diagram (y axis). The 1.0001 is because nice fractions can lead to pathological behavior.
        for(int k=0;k<DIM;k++){
            x = r*x*(1-x);          // Apply the logistic map to x
            // We do this DIM/2 times without recording anything, just to get x out of unstable values
            if(k>DIM/2){
                if(c[(int)a][(int)(DM1*x)]<255){
                    c[(int)a][(int)(DM1*x)]+=0.01; // x makes a mark in c[][]
                } // In the golfed code, I just always add 0.01 here, and clip c to 255
            }
        }            
    }    
}

Donde los valores de x caen con mayor frecuencia para un determinado r (valor j), la gráfica se vuelve más clara (generalmente representada como más oscura).

Difusión limitada agregación

Siempre me ha fascinado la agregación limitada por difusión y la cantidad de formas diferentes en que aparece en el mundo real.

Me resultó difícil escribir esto en solo 140 caracteres por función, así que tuve que hacer que el código fuera horrible (o hermoso, si te gustan cosas como ++d%=4y for(n=1;n;n++)). Las tres funciones de color se llaman entre sí y definen macros para que se usen, por lo que no se lee bien, pero cada función tiene poco menos de 140 caracteres.

unsigned char RD(int i,int j){
#define D DIM
#define M m[(x+D+(d==0)-(d==2))%D][(y+D+(d==1)-(d==3))%D]
#define R rand()%D
#define B m[x][y]
return(i+j)?256-(BL(i,j))/2:0;}

unsigned char GR(int i,int j){
#define A static int m[D][D],e,x,y,d,c[4],f,n;if(i+j<1){for(d=D*D;d;d--){m[d%D][d/D]=d%6?0:rand()%2000?1:255;}for(n=1
return RD(i,j);}

unsigned char BL(int i,int j){A;n;n++){x=R;y=R;if(B==1){f=1;for(d=0;d<4;d++){c[d]=M;f=f<c[d]?c[d]:f;}if(f>2){B=f-1;}else{++e%=4;d=e;if(!c[e]){B=0;M=1;}}}}}return m[i][j];}

Para visualizar cómo las partículas se agregan gradualmente, produje instantáneas a intervalos regulares. Cada cuadro se produjo reemplazando el 1 en for(n=1;n;n++)con 0, -1 << 29, -2 << 29, -3 << 29, 4 << 29, 3 << 29, 2 << 29, 1 << 29, 1. Esto lo mantuvo justo por debajo del límite de 140 caracteres para cada ejecución.

Puede ver que los agregados que crecen cerca uno del otro se privan de partículas y crecen más lentamente.

Al hacer un ligero cambio en el código, puede ver las partículas restantes que aún no se han unido a los agregados. Esto muestra las regiones más densas donde el crecimiento ocurrirá más rápidamente y las regiones muy dispersas entre los agregados donde no puede ocurrir más crecimiento debido a que todas las partículas se han agotado.

unsigned char RD(int i,int j){
#define D DIM
#define M m[(x+D+(d==0)-(d==2))%D][(y+D+(d==1)-(d==3))%D]
#define R rand()%D
#define B m[x][y]
return(i+j)?256-BL(i,j):0;}

unsigned char GR(int i,int j){
#define A static int m[D][D],e,x,y,d,c[4],f,n;if(i+j<1){for(d=D*D;d;d--){m[d%D][d/D]=d%6?0:rand()%2000?1:255;}for(n=1
return RD(i,j);}

unsigned char BL(int i,int j){A;n;n++){x=R;y=R;if(B==1){f=1;for(d=0;d<4;d++){c[d]=M;f=f<c[d]?c[d]:f;}if(f>2){B=f-1;}else{++e%=4;d=e;if(!c[e]){B=0;M=1;}}}}}return m[i][j];}

Esto se puede animar de la misma manera que antes:

Espiral (140 exactamente)

Esto es exactamente 140 caracteres si no incluye los encabezados y paréntesis de la función. Es tanta complejidad espiral que podría encajar en el límite de caracteres.

unsigned char RD(int i,int j){
    return DIM-BL(2*i,2*j);
}
unsigned char GR(int i,int j){
    return BL(j,i)+128;
}
unsigned char BL(int i,int j){
    i-=512;j-=512;int d=sqrt(i*i+j*j);return d+atan2(j,i)*82+sin(_cr(d*d))*32+sin(atan2(j,i)*10)*64;
}

Gradualmente construí una espiral simple, agregué patrones a los bordes de la espiral y experimenté cómo se podían combinar diferentes espirales para que se vieran geniales. Aquí hay una versión sin golf con comentarios que explican lo que hace cada pieza. Jugar con los parámetros puede producir algunos resultados interesantes.

unsigned char RD(int i,int j){
    // *2 expand the spiral
    // DIM- reverse the gradient
    return DIM - BL(2*i, 2*j);
}
unsigned char GR(int i,int j){
    // notice swapped parameters
    // 128 changes phase of the spiral
    return BL(j,i)+128;
}
unsigned char BL(int i,int j){
    // center it
    i -= DIM / 2;
    j -= DIM / 2;

    double theta = atan2(j,i); //angle that point is from center
    double prc = theta / 3.14f / 2.0f; // percent around the circle

    int dist = sqrt(i*i + j*j); // distance from center

    // EDIT: if you change this to something like "prc * n * 256" where n
    //   is an integer, the spirals will line up for any arbitrarily sized
    //   DIM value, or if you make separate DIMX and DIMY values!
    int makeSpiral = prc * DIM / 2;

    // makes pattern on edge of the spiral
    int waves = sin(_cr(dist * dist)) * 32 + sin(theta * 10) * 64;

    return dist + makeSpiral + waves;
}

Jugar con los parámetros:

Aquí, las espirales están alineadas pero tienen diferentes patrones de borde. En lugar de los bordes en bloque en el ejemplo principal, esto tiene bordes completamente compuestos de ondas sin.

Aquí, el gradiente ha sido eliminado:

Una animación ( que por alguna razón no parece estar repitiéndose después de haberla cargado, lo siento. Además, tuve que reducirla. Simplemente ábrala en una nueva pestaña si se perdió la animación ):

Y aquí está el álbum de imgur con todas las imágenes. Me encantaría ver si alguien puede encontrar otros patrones espirales geniales. Además, debo decir que este es, con mucho, uno de los desafíos más geniales que he visto aquí. ¡Disfrutar!

EDITAR: Aquí hay algunos fondos hechos de estas espirales con parámetros alterados.

Además, al combinar mis patrones de borde en espiral con algunos de los fractales que he visto aquí mediante el uso de xor / y / u operaciones, aquí hay una espiral final:

Homenaje a un clásico

V1 : Inspirado por "Be happy" de DreamWarrior, este envío directo incorpora una pequeña imagen de pixel art en cada canal de color. ¡Ni siquiera tuve que jugar golf el código!
V2 : ahora con un código considerablemente más corto y un borde negro grueso que aísla solo la "pantalla del juego".
V3 : nave espacial, bala, alienígenas dañados y borde azul, ¡ay! Tratando de apuntar a esto , más o menos.

// RED
#define g(I,S,W,M)j/128%8==I&W>>(j/32%4*16+i/64)%M&S[abs(i/4%16-8)-(I%2&i%64<32)]>>j/4%8&1
return g(1,"_\xB6\\\x98\0\0\0",255L<<36,64)?j:0;

// GREEN
#define S g(6,"\xFF\xFE\xF8\xF8\xF8\xF8\xF0\x0",1L<<22,64)|i/4==104&j/24==30
return g(2,"<\xBC\xB6}\30p\0\0",4080,32)|S?j:0;

// BLUE
return g(3,"_7\xB6\xFE\x5E\34\0",0x70000000FD0,64)|S|abs(i/4-128)==80&abs(j/4-128)<96|abs(j/4-128)==96&abs(i/4-128)<80?j:0;

Me topé con una edición de Umber Ferrule cuyo avatar me inspiró a agregar otra entrada basada en pixel art. Dado que la idea central del código es muy similar a la de Space Invaders, la agrego a esta entrada, aunque las dos definitivamente tenían diferentes puntos desafiantes. Para este, obtener el rosa correcto (a expensas del blanco) y el hecho de que es un sprite bastante grande probaron ser buenos desafíos. Los escapes hexadecimales ( \xFFetc.) en el canal rojo representan sus caracteres correspondientes en el archivo fuente (es decir, el canal rojo en el archivo fuente contiene datos binarios), mientras que los escapes octales son literales (es decir, están presentes en el archivo fuente).

// RED
#define g(S)(S[i/29%18*2+j/29/8%2]>>j/29%8&1)*DM1*(abs(i-512)<247&abs(j-464)<232)
return g("\xF3\xF2\xF2\x10\xF4\0\xF2\x10\xE1\xE0\x81\0\x80\0\x80\0\0\0\0\0@\0! \x03d8,=\x2C\x99\x84\xC3\x82\xE1\xE3");

// GREEN
return g(";\376z\34\377\374\372\30k\360\3\200\0\0\0\0\0\0\200\0\300\0\341 \373d\307\354\303\374e\374;\376;\377")? DM1 : BL(i,j)? DM1/2 : 0;

// BLUE
return g("\363\360\362\20\364\0\362\20\341\340\200\0\200\0\200\0\0\0\0\0\0\0\0\0\0\08\0<\0\230\0\300\0\341\340") / 2;

Pintura de acción

Quería intentar recrear algo similar al trabajo de Jackson Pollock : gotear y verter pintura sobre un lienzo horizontal. Aunque me gustaron los resultados, el código fue demasiado largo para publicarlo en esta pregunta y mis mejores esfuerzos solo lo redujeron a unos 600 bytes. Entonces, el código publicado aquí (que tiene funciones de 139 bytes, 140 bytes y 140 bytes respectivamente) fue producido con una enorme cantidad de ayuda de algunos de los genios en el chat . Muchas gracias a:

• Eric Tressler
• Luciérnaga
• PhiNotPi
• Martin Büttner

para una implacable sesión de golf grupal.

unsigned char RD(int i,int j){
#define E(q)return i+j?T-((T-BL(i,j))*q):T;
#define T 255
#define R .1*(rand()%11)
#define M(v)(v>0&v<DIM)*int(v)
#define J [j]*250;
E(21)}

unsigned char GR(int i,int j){
#define S DIM][DIM],n=1e3,r,a,s,c,x,y,d=.1,e,f;for(;i+j<1&&n--;x=R*DM1,y=R*DM1,s=R*R*R*R,a=R*7,r=s*T)for(c=R;r>1;x+=s*cos(a),y+=s*sin
E(21)}

unsigned char BL(int i,int j){static float m[S(a),d=rand()%39?d:-d,a+=d*R,s*=1+R/99,r*=.998)for(e=-r;e++<r;)for(f=-r;f++<r;)m[M(x+e)*(e*e+f*f<r)][M(y+f)]=c;return T-m[i]J}

La macro E (q) se usa en las funciones RD y GR. Cambiar el valor del argumento cambia la forma en que cambian los componentes rojo y verde de los colores. La macro J termina con un número que se utiliza para determinar cuánto cambia el componente azul, lo que a su vez afecta a los componentes rojo y verde porque se calculan a partir de él. He incluido algunas imágenes con los argumentos rojo y verde de E variados para mostrar la variedad de combinaciones de colores posibles. Desplácese sobre las imágenes de los valores rojo y verde si desea ejecutarlas usted mismo.

Todas estas imágenes se pueden ver a tamaño completo si las descarga. El tamaño del archivo es pequeño ya que el color plano se adapta al algoritmo de compresión PNG, por lo que no se requirió compresión con pérdida para cargarlo en el sitio.

Si desea ver imágenes de varias etapas en el proceso de golf mientras probamos diferentes cosas, puede mirar en el chat de pintura de acción .

Pensé que jugaría con los parámetros de este código ... Todo el crédito va a @Manuel Kasten. Estos son tan geniales que no pude resistir publicar.

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 1000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);

BubbleGumRupture http://i57.tinypic.com/3150eqa.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 8000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 40*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+(j)*9e-9-.645411;a=c-d+(i)*9e-9+.356888;}
return 10*pow((n)/800,.5);

SeussZoom http://i59.tinypic.com/am3ypi.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-8-.645411;a=c-d+i*8e-8+.356888;}
return 4000*pow((n)/800,.5);

SeussEternalForest http://i61.tinypic.com/35akv91.png

/* RED */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 2000*pow((n)/800,.5);
/* GREEN */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 1000*pow((n)/800,.5);
/* BLUE */
double a=0,b=0,c,d,n=0;
while((c=a*a)+(d=b*b)<4&&n++<880){b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;}
return 4000*pow((n)/800,.5);

Editar: Esta es ahora una respuesta válida, gracias a las declaraciones directas de GRy BL.

¡Divirtiéndose con la secuencia Q de Hofstadter! Si usamos la distancia radial desde algún punto como entrada y la salida como color inverso, obtenemos algo que parece vinilo coloreado.

La secuencia es muy similar a la secuencia de Fibonacci, pero en lugar de retroceder 1 y 2 pasos en la secuencia, toma los dos valores anteriores para determinar qué tan lejos retroceder antes de tomar la suma. Crece más o menos lineal, pero de vez en cuando hay una explosión de caos (a intervalos crecientes) que luego se establece en una secuencia casi lineal nuevamente antes de la próxima explosión:

Puede ver estas ondas en la imagen después de las regiones que se ven muy "planas" en color.

Por supuesto, usar solo un color es aburrido.

Ahora para el código. Necesito la función recursiva para calcular la secuencia. Para hacer eso lo uso RDsiempre que jsea ​​negativo. Desafortunadamente, eso no deja suficientes caracteres para calcular el valor del canal rojo en sí, por lo que RDa su vez llama GRcon un desplazamiento para producir el canal rojo.

unsigned short RD(int i,int j){
    static int h[1000];return j<0?h[i]?h[i]:h[i]=i<2?1:RD(i-RD(i-1,j),j)+RD(i-RD(i-2,j),j):GR(i+256,j+512);
}
unsigned short GR(int i,int j){
    return DIM-4*RD(sqrt((i-512)*(i-512)+(j-768)*(j-768))/2.9,-1);
}
unsigned short BL(int i,int j){
    return DIM-4*RD(sqrt((i-768)*(i-768)+(j-256)*(j-256))/2.9,-1);
}

Por supuesto, este es el uso más simple posible de la secuencia, y quedan muchos caracteres. ¡Siéntase libre de pedirlo prestado y hacer otras locuras con él!

Aquí hay otra versión donde el límite y los colores están determinados por la secuencia Q. En este caso, había suficiente espacio RDpara que ni siquiera necesitara la declaración de avance:

unsigned short RD(int i,int j){
    static int h[1024];return j<0?h[i]?h[i]:h[i]=i<2?1:RD(i-RD(i-1,j),j)+RD(i-RD(i-2,j),j):RD(2*RD(i,-1)-i+512>1023-j?i:1023-i,-1)/0.6;
}
unsigned short GR(int i,int j){
    return RD(i, j);
}
unsigned short BL(int i,int j){
    return RD(i, j);
}

Esto calcula la transformación de Joukowsky de un conjunto de círculos concéntricos centrados en un punto ligeramente desplazado del origen. Modifiqué ligeramente las intensidades en el canal azul para dar un poco de variación de color.

unsigned short RD(int i,int j){
    double r=i/256.-2,s=j/256.-2,q=r*r+s*s,n=hypot(r+(.866-r/2)/q,s+(r*.866+s/2)/q),
    d=.5/log(n);if(d<0||d>1)d=1;return d*(sin(n*10)*511+512);
}
unsigned short GR(int i,int j){
    return 0;
}
unsigned short BL(int i,int j){
    double r=i/256.-2,s=j/256.-2,q=r*r+s*s;return RD(i,j)*sqrt(q/40);
}

C objetivo

Reescribí el código C ++ en Objective-C porque no pude compilarlo ... Dio los mismos resultados que otra respuesta cuando se ejecutaba en mi iPad, así que eso está bien.

Aquí está mi presentación:

El código detrás de esto es bastante simple:

unsigned short red_fn(int i,int j)
{
    return j^j-i^i;
}
unsigned short green_fn(int i,int j)
{
    return (i-DIM)^2+(j-DIM)^2;
}
unsigned short blue_fn(int i,int j)
{
    return i^i-j^j;
}

Puede ampliar los cuadrados multiplicando iy jpor 0.5, 0.25etc. antes de que se procesen.

Salpicadura de pintura de Sierpinski

Quería jugar más con los colores, así que seguí cambiando mi otra respuesta (la swirly) y finalmente terminé con esto.

unsigned short RD(int i,int j){
    return(sqrt(_sq(abs(73.-i))+_sq(abs(609.-j)))+1.)/abs(sin((sqrt(_sq(abs(860.-i))+_sq(abs(162.-j))))/115.)+2)/(115^i&j);
}
unsigned short GR(int i,int j){
    return(sqrt(_sq(abs(160.-i))+_sq(abs(60.-j)))+1.)/abs(sin((sqrt(_sq(abs(73.-i))+_sq(abs(609.-j))))/115.)+2)/(115^i&j);
}
unsigned short BL(int i,int j){
    return(sqrt(_sq(abs(600.-i))+_sq(abs(259.-j)))+1.)/abs(sin((sqrt(_sq(abs(250.-i))+_sq(abs(20.-j))))/115.)+2)/(115^i&j);
}

Es mi avatar ahora. :PAGS

Me siento obligado a enviar esta entrada que llamaré "comportamiento indefinido", que ilustrará lo que hace su compilador con funciones que se supone que devuelven un valor pero no:

unsigned short red_fn(int i,int j){}
unsigned short green_fn(int i,int j){}
unsigned short blue_fn(int i,int j){}

Todos los píxeles negros:

Píxeles seudoaleatorios:

Y, por supuesto, una gran cantidad de otros posibles resultados dependiendo de su compilador, computadora, administrador de memoria, etc.

maravilloso

Solo algunos trigonometría y extraños trucos macro.

RD:

#define I (i-512)
#define J (j-512)
#define A (sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

GRAMO:

#undef A
#define A (M_PI/3+sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

LICENCIADO EN DERECHO:

#undef A
#define A (2*M_PI/3+sin((i+j)/64.)*cos((i-j)/64.))
return atan2(I*cos A-J*sin A,I*sin A+J*cos A)/M_PI*1024+1024;

EDITAR: si M_PIno está permitido debido a que solo está presente en los sistemas compatibles con POSIX, se puede reemplazar con el literal 3.14.

No soy bueno en matemáticas. Siempre fui un estudiante pobre en la clase de matemáticas. Así que hice uno simple.

Usé el código Javascript modificado de user1455003 . Y este es mi código completo .

function red(x, y) {
    return (x + y) & y;
}

function green(x, y) {
    return (255 + x - y) & x;
}

function blue(x, y) {
    // looks like blue channel is useless
    return Math.pow(x, y) & y;
}

Es muy corto, por lo que las tres funciones encajan en un solo tweet.

function red(x, y) {
    return Math.cos(x & y) << 16;
}

function green(x, y) {
    return red(DIM - x, DIM - y);
}

function blue(x, y) {
    return Math.tan(x ^ y) << 8;
}

Otras funciones muy cortas. Encontré este patrón sierpinski (y algún patrón tangente) mientras jugaba con varias funciones matemáticas. Este es el código completo

JavaScript

var can = document.createElement('canvas');
can.width=1024;
can.height=1024;
can.style.position='fixed';
can.style.left='0px';
can.style.top='0px';
can.onclick=function(){
  document.body.removeChild(can);
};

document.body.appendChild(can);

var ctx = can.getContext('2d');
var imageData = ctx.getImageData(0,0,1024,1024);
var data = imageData.data;
var x = 0, y = 0;
for (var i = 0, len = data.length; i < len;) {
    data[i++] = red(x, y) >> 2;
    data[i++] = green(x, y) >> 2;
    data[i++] = blue(x, y) >> 2;
    data[i++] = 255;
    if (++x === 1024) x=0, y++;
}
ctx.putImageData(imageData,0,0);

function red(x,y){
if(x>600||y>560) return 1024
x+=35,y+=41
return y%124<20&&x%108<20?1024:(y+62)%124<20&&(x+54)%108<20?1024:0
}

function green(x,y){
if(x>600||y>560) return y%160<80?0:1024
x+=35,y+=41
return y%124<20&&x%108<20?1024:(y+62)%124<20&&(x+54)%108<20?1024:0
}

function blue(x,y) {
return ((x>600||y>560)&&y%160<80)?0:1024;
}

Otra version. Los cuerpos funcionales son tuiteables.

function red(x,y){
c=x*y%1024
if(x>600||y>560) return c
x+=35,y+=41
return y%124<20&&x%108<20?c:(y+62)%124<20&&(x+54)%108<20?c:0
}

function green(x,y){
c=x*y%1024
if(x>600||y>560) return y%160<80?0:c
x+=35,y+=41
return y%124<20&&x%108<20?c:(y+62)%124<20&&(x+54)%108<20?c:0
}

function blue(x,y) {
return ((x>600||y>560)&&y%160<80)?0:x*y%1024;
}

Función de renderizado de imagen revisada. draw (rgbFunctions, setCloseEvent);

function draw(F,e){
    var D=document
    var c,id,d,x,y,i,L,s=1024,b=D.getElementsByTagName('body')[0]
    c=D.createElement('canvas').getContext('2d')
    if(e)c.canvas.onclick=function(){b.removeChild(c.canvas)}
    b.appendChild(c.canvas)
    c.canvas.width=c.canvas.height=s
    G=c.getImageData(0,0,s,s)
    d=G.data
    x=y=i=0;
    for (L=d.length;i<L;){
        d[i++]=F.r(x,y)>>2
        d[i++]=F.g(x,y)>>2
        d[i++]=F.b(x,y)>>2
        d[i++]=255;
        if(++x===s)x=0,y++
    }
    c.putImageData(G,0,0)
}

Púrpura

var purple = {
    r: function(i,j) {
        if (j < 512) j=1024-j
        return (i % j) | i
    },
    g: function(i,j){
        if (j < 512) j = 1024 -j
        return (1024-i ^ (i %j)) % j
    },
    b: function(i,j){
        if (j < 512) j = 1024 -j
        return 1024-i | i+j %512
    }
};

draw(purple,true);

Pintor planetario

//red
static int r[DIM];int p=rand()%9-4;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;
//green
static int r[DIM];int p=rand()%7-3;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;
//blue
static int r[DIM];int p=rand()%15-7;r[i]=i&r[i]?(r[i]+r[i-1])/2:i?r[i-1]:512;r[i]+=r[i]+p>0?p:0;return r[i]?r[i]<DIM?r[i]:DM1:0;

Inspirado por la entrada obviamente impresionante de Martin , esta es una versión diferente. En lugar de sembrar aleatoriamente una parte de los píxeles, comienzo con la esquina superior izquierda como RGB (512,512,512), y tomo caminatas aleatorias en cada color desde allí. El resultado parece algo de un telescopio (imo).

Cada píxel toma el promedio de los píxeles arriba / a la izquierda y agrega un poco al azar. Puedes jugar con la variabilidad cambiando la pvariable, pero creo que lo que estoy usando es un buen equilibrio (principalmente porque me gusta el azul, por lo que una mayor volatilidad de desenfoque da buenos resultados).

Hay un ligero sesgo negativo de la división de enteros al promediar. Sin embargo, creo que funciona y le da un bonito efecto de oscurecimiento a la esquina inferior.

Por supuesto, para obtener más que un solo resultado, deberá agregar una srand()línea a su función principal.

Olas reflejadas

unsigned char RD(int i,int j){
#define A static double w=8000,l,k,r,d,p,q,a,b,x,y;x=i;y=j;for(a=8;a+9;a--){for(b=8;b+9;b--){l=i-a*DIM-(int(a)%2?227:796);
return 0;}

unsigned char GR(int i,int j){
#define B k=j-b*DIM-(int(b)%2?417:606);r=sqrt(l*l+k*k);d=16*cos((r-w)/7)*exp(-_sq(r-w)/120);p=d*l/r;q=d*k/r;x-=p;y-=q;}}
return 0;}

unsigned char BL(int i,int j){AB
return (int(x/64)+int(y/64))%2*255;}

Un patrón básico de tablero de ajedrez distorsionado de acuerdo con la posición de una ola que se expande desde un punto como una piedra caída en un estanque (¡muy lejos de ser físicamente exacto!). La variable wes el número de píxeles desde ese punto que la onda se ha movido. Si wes lo suficientemente grande, la onda se refleja desde los lados de la imagen.

w = 225

w = 360

w = 5390

Aquí hay un GIF que muestra una sucesión de imágenes a medida que la ola se expande. He proporcionado varios tamaños diferentes, cada uno de los cuales muestra tantos fotogramas como lo permita el límite de tamaño de archivo de 500 KB.

Si puedo encontrar una manera de encajar, idealmente quisiera modelar la interferencia de las olas para que las olas se vean más realistas cuando se crucen. Sin embargo, estoy satisfecho con la reflexión.

Tenga en cuenta que realmente no he modelado la reflexión de onda en 3 lotes de 140 bytes. Realmente no hay ningún reflejo, simplemente parece que es así. He escondido la explicación en caso de que alguien quiera adivinar primero:

La primera onda reflejada es idéntica a una onda que se origina desde el otro lado del borde de la imagen, a la misma distancia que el punto original. Entonces, el código calcula la posición correcta para los 4 puntos necesarios para dar el efecto de reflexión desde cada uno de los 4 bordes. Los niveles adicionales de onda reflejada son todos idénticos a una onda que se origina en un mosaico más alejado, si imagina la imagen como un mosaico en un plano. El código da la ilusión de 8 niveles de reflexión al mostrar 189 círculos de expansión separados, cada uno colocado en el punto correcto en una cuadrícula de 17 por 17, para que pasen por el cuadrado central de la cuadrícula (es decir, el cuadrado de la imagen) en los momentos adecuados para dar la impresión del nivel de reflexión actual requerido. Esto es simple (¡y corto!) Para codificar, pero se ejecuta muy lentamente ...