cross-posted from: https://lemmy.sdf.org/post/3732588

A nice trip up and down the scale of things. I especially like the ones from 10^1 to 10^14, inhumane numbers attempting to be brought to a human scale.

Source: CRC Standard Mathematical Tables and Formulas (Zwillinger, Daniel) (Z-Library)

cross-posted from: https://lemmy.sdf.org/post/3152363

Figs and fig wasps have a tightly coordinated reproductive cycle, and have been cospeciating for 70 to 90 million years. The pollination of figs is accomplished in an internal cavity only accessible to a specific species of wasp. The wasp enters through an opening that is only just large enough for it to get through, loosing it's wings and antenna in the process. Pollen on the wasp pollinate the fig's internal flowers, and the wasp lays it's eggs in some of the flowers before dying there. When the male wasps hatch, they fertilize the unhatched females, and burrow tunnels out of the fig before also dying inside it. When the females hatch, they exit the fig through the tunnels, taking pollen with them to search for a fig within which to lay their eggs.

https://en.wikipedia.org/wiki/Syconium https://en.wikipedia.org/wiki/Fig_wasp

It's the only browser I have installed besides Safari, and my default browser but instead of just opening the link with my default browser, it advertises these other browsers to me and makes me click 'Default browser app' by default. wtf I'll be turning that off, should have never been a feature.

This is a jar full of only water (liquid and vapor). It boils at any temperature when you apply something cold enough to the top, like ice.

cross-posted from: https://lemmy.sdf.org/post/2697716

I put water in a jar and sealed it while it was boiling, and now it boils at any temperature. Super fun demo to try.

I've been playing with shadertoy a bit, and here is a lil demo. It's probably not the best way to do it, code suggestions welcome.

https://www.shadertoy.com/view/dtlBRM

Here's most of the code for reference:

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    // fetch neighbor values from last frame, loop back onto screen if off screen
    mat3 n;
    n[0][0] = texelFetch(iChannel0, ivec2(mod(vec2(fragCoord) + vec2(-1., -1.), iResolution.xy)), 0).g;
    n[1][0] = texelFetch(iChannel0, ivec2(mod(vec2(fragCoord) + vec2(0., -1.), iResolution.xy)), 0).g;
    n[2][0] = texelFetch(iChannel0, ivec2(mod(vec2(fragCoord) + vec2(1., -1.), iResolution.xy)), 0).g;
    n[0][1] = texelFetch(iChannel0, ivec2(mod(vec2(fragCoord) + vec2(-1., 0.), iResolution.xy)), 0).g;
    n[1][1] = texelFetch(iChannel0, ivec2(mod(vec2(fragCoord) + vec2(0., 0.), iResolution.xy)), 0).g;
    n[2][1] = texelFetch(iChannel0, ivec2(mod(vec2(fragCoord) + vec2(1., 0.), iResolution.xy)), 0).g;
    n[0][2] = texelFetch(iChannel0, ivec2(mod(vec2(fragCoord) + vec2(-1., 1.), iResolution.xy)), 0).g;
    n[1][2] = texelFetch(iChannel0, ivec2(mod(vec2(fragCoord) + vec2(0., 1.), iResolution.xy)), 0).g;
    n[2][2] = texelFetch(iChannel0, ivec2(mod(vec2(fragCoord) + vec2(1., 1.), iResolution.xy)), 0).g;
    
    // sum of neighbors
    float sum = n[0][0] + n[1][0] + n[2][0] +
                n[0][1] +           n[2][1] +
                n[0][2] + n[1][2] + n[2][2];
                
    if(n[1][1] == 0.) {
        if(sum == 3.) {
            // if dead and has 3 neighbors, come alive
            fragColor = vec4(0., 1., 0., 1.);
        } else {
            // otherwise stay dead
            fragColor = vec4(0., 0., 0., 1.);
        }
    } else {
        if(sum == 2. || sum == 3.) {
            // if alive and has 2 or 3 neighbors, stay alive
            fragColor = vec4(0., 1., 0., 1.);
        } else {
            // otherwise, die
            fragColor = vec4(0., 0., 0., 1.);
        }
    }
}

A GLSL shader computed painstakingly by hand by almost 2000 people

Now a set of useful mutations are implemented, and balanced so that the number of nodes or edges doesn't explode.

The mutations I've implemented (node are genes are nodes):

add random gene
delete node
delete group of nodes (range of indexes)
split edge    create new node in place of an edge (insertNode)
flip edge
duplicate node
duplicated group of nodes (range of indexes)
change node index (regrouping/separating functional groups)
change group of nodes index (transposable elements)
create random edge
delete random existing edge
scale existing edge weight
negate weight
redirect existing edge to random node
scale parameter (k1, b, k2)
negate bias

This is the next installment from the Gene Regulatory Network saga.

previously: https://lemmy.sdf.org/post/1967056######

Nice article reviewing hash tables and how python dictionaries are implemented with them.