The first key is to realize that every affect comes with a direction of affect and each and every 3D direction has its own equation of space for every point in space. All of those listed change rates are different for every possible direction. So for example, headed directly to the right, the following value set might apply for point A:
E{right} = [0.5, 0.01, 0.0001, 0.023, …]
But also at the exact same time at point A, headed in the upward direction, the following equation applies:
E{upward} = [0.5, 0.001, 0.02, 0.7, …]
Of course every angle must be handled and there are an infinite number of such directions in 3D, so the challenge got a bit tough. I not only had an infinite series for a billion points, but an infinite number of infinite series for each of a billion points, all of which had to be calculated for each picosecond tic.
The resolve took a very long time for my little brain to figure out. I basically had to prove that each preferred method (due to simplicity or speed) of emulating space would not work.
The project was to emulate affects propagating through a small bit of space in whatever direction they might take.
If you allow space to be represented by a matrix of points (locations), the question arises as to how these points are to be situated. Aristotle proposed that a tetrahedron could properly fill space. That turned out to be incorrect, although pretty close. What is called “space-filling” became my study for a while. I tried all kinds of combinations of shapes with which to fill space along with which equations would have to be used to emulate the propagation of an affect in any direction. I wanted to simplify for sake of speed and memory usage, but that turned out to be quite a challenge.
Not being able to use any of the standard methods and after getting very, very creative in coming up with new methods (that didn’t quite cut it), I almost gave up on being able to realistically emulate space. Eventually, it dawned on me that I could use the simple cube matrix to fill space, but I couldn’t calculate each point for each tic of time. Merely a 1000x1000x1000 pixel matrix, 1 billion points, would represent perhaps 10 nanometers of space and leave a matrix of 1 billion simultaneous equations to have to resolve for every tic of time (one “frame”), which might represent merely one picosecond or less. That would take an average PC possibly years to calculate each picosecond of time. So I had to find a way to update the state of that tiny metaspace without losing accuracy concerning the propagation of affects through the space and calculate thousands of tic frames within a reasonable completion time.
Eventually I figured out the “Afflate”.
An afflate (an affectance oblate) is a proposed, or selected, small portion of affectance that can be treated as a single propagating affect and a “virtual particle” (even though it is not an actual particle at all). And an afflate might have any small size or shape. An afflate is very similar to a photon, although greatly smaller than a light photon. Each afflate has many characteristics such as density, potential, and propagation direction.
What I finally realized is that I could track millions of these random afflates as they each propagated in their own direction rather than trying to calculate the changes that were occurring at each of a billion points. And that allowed for me to emulate the propagation of affects within the space. The end result eventually led to being able to watch particles form merely because of the manner in which random affects naturally occur, such as in these renderings: