making a flowstone game

[wlangfor@uoguelph.ca]

In ultimative HiFi mode the program would have a sample rate at 2 * ( 1 / ( 5.39 × pow(10,-44) ) ), which covers the frequency up to planck length. To get the most subsonic bass wave however, you would need to record for a very very long time. A problem still not solved in normal HiFi Apps. So most apps cut at something like 50hz bc that is the minimum usual recording time anyways (20 milliseconds) for the human to differentiate. Any sound longer than this may contain residue Low wave frequency content however, since the filter is never perfect. There are many more interesting problems in digital representations, this is just one.

Yes, and the speed is recursive, not at all due to any given linear plain but instead as a precursor and exponent acting as a multiplier. It's that I think that is the error in its inception.

[wlangfor@uoguelph.ca]

In ultimative HiFi mode the program would have a sample rate at 2 * ( 1 / ( 5.39 × pow(10,-44) ) ), which covers the frequency up to planck length. To get the most subsonic bass wave however, you would need to record for a very very long time. A problem still not solved in normal HiFi Apps. So most apps cut at something like 50hz bc that is the minimum usual recording time anyways (20 milliseconds) for the human to differentiate. Any sound longer than this may contain residue Low wave frequency content however, since the filter is never perfect. There are many more interesting problems in digital representations, this is just one.

Please excuse my ignorance but I just don’t understand what you wrote, sorry.

May I ask for a simpler explanation, suitable for an old fool like me?

I don’t really understand the connection between frequency, data rate and recording time.

Cheers
Spogg

What he is explaining is that due to complexity and length of linear decay of bass and many low mid signals (rarefaction) there is a required tail that is cutoff. There is various breakpoints called compression and those thresholds can also be referred to as trap, certain zones where compression takes place and results in reduced speed. It is this phenomenon which naturally creates treble and bass.

Think of sound like a spherical wave, the bass is the initial sound and carries for miles. But the sound which competes with the air breaks into smaller pieces, it is refracted by the air pressure and particles. It is the frequency of this exchange that creates the frequencies which we can hear.

So Michael is explaining that the earlier of waves could never be captured due to the fact that to capture that wave in its entirety would take hella range and sensitivity not possible even today.

What I was suggesting is that it would be intriguing to collect the original impact of the sound itself. If you were to have the bass only and then create the sound from that, you could hear a sound actually being formed. It's a way of audio that does not exist but it would sound good. Albeit, the treatment of that sound would be time based as it would be a true continuous time signal. I call it AAP for analog archetype promotion. It's a fancy type of wavetable that contains very complex data theoretically. Later adding the locale and other parameters would be a matter of choice.

[MichaelBenjamin]

.

[tulamide]

I still don't understand some relations:

First we have planck length. A unit to measure light speed.
Then we have most subsonic bass. That would be a sound wave that tends towards 0 Hz.

Planck length doesn't need to be covered, since sound waves (in air) travel 332 m/s, not 300,000 km/s like light.
A sound wave that tends towards 0 Hz is a (theoretical) standing wave and serves no purpose in music.

To record such a wave you would not only record for near infinity time, but also would need a microphone that's able to sense it (which doesn't exist).

Gödel is where you completely lost me:
"The first incompleteness theorem states that no consistent system of axioms whose theorems can be listed by an effective procedure (i.e., an algorithm) is capable of proving all truths about the arithmetic of natural numbers. The second incompleteness theorem, an extension of the first, shows that the system cannot demonstrate its own consistency."
What has that to do with recording sound waves?

So, while certainly interesting in a philosophical sense, I don't see the practical usage of what you stated?

[MichaelBenjamin]

.

[MichaelBenjamin]

.

[MichaelBenjamin]

.

[wlangfor@uoguelph.ca]

That's sick and you may be right about FFT. In regards to Tulamide; yes I often wonder about theorists. In all honesty I think the wave of bass is a bit simpler than they like to emphasize.

If for instance walls were a collection of specially made deep chasms of polys it may be possible theoretically. I guess it would come down to the material. Maybe wood.

What I was suggesting is that it would be intriguing to collect the original impact of the sound itself. If you were to have the bass only and then create the sound from that, you could hear a sound actually being formed. It's a way of audio that does not exist but it would sound good.

you could try to add up several mass springs as approximation maybe.

here is a very crude version written in cython:

Code: Select all

@cython.boundscheck(False)
@cython.wraparound(False)
@cython.cdivision(True)
@cython.nonecheck(False)   
def spring(double semi,double hifreqdamp=0.0,double ampdamp=0.0,
           double randomamp=0.0,double randomdev=0.0, mode="osc",
           double maxdur = 90,double osamp=1.0):
    """mass spring, tuned to c2 65.41hz at 48k (semi 0), osc or env
    tune is the octavedivider
    hidamp 0-1.0 dampens(--) or extends(++) higher freqs
    damping 0-1.0 for amp over time
    HIfreqDAMP is FREQ dependent damp
    ampDAMPING is general TIME damp
    """
    cdef double h0,v0,time,dt,k,m,k1_drag,v,h,lastv,lasth,kk,vv,minv
    cdef double semitone,semimax,damp,tune,semidisplay,dampconv,hidampconv
    cdef int nstep,i,index
    cdef np.ndarray[np.float64_t, ndim = 1] K
    cdef np.ndarray[np.float64_t, ndim = 1] V
    cdef np.ndarray[np.float64_t, ndim = 1] En
    tune = 12.0
    semidisplay=semi
    semi-= 36.0
    hidampconv=max(0.0,min(1.0,hifreqdamp))*14.0-7.0
    dampconv=2.0**(max(0.0,min(1.0,ampdamp))*14-7)##0-1 to -5/5
    h0 = random()*randomdev+(1-randomdev)# initial deviation from equilibrium in m
    v0 = random()*randomamp+(1-randomamp)    # m/s
    time = maxdur        # max duration in sec
    damp = 1.0-(dampconv*0.00001)
    dt = 1.0/(osamp*48000.0)       # time step in sec
    nstep = roundl(time/dt) # number of time steps
    k = 24000      # spring constant in N/m
    #frequency = 2 * 440/Samplerate * 2**((pitch-69)/12)
    semitone = (-semi+15)*(24.0/tune)
    semimax  = fabs(semidisplay)
    m = 0.1*(2**(semitone/12.0))
    k1_drag = 2**(-semidisplay/(7+hidampconv))*0.159+0.5000001# kg/s ## ENVELOPE
    K =  np.zeros((nstep), dtype=np.float64)  # kinetic energy
    V =  np.zeros((nstep), dtype=np.float64)  # potential energy
    En = np.zeros((nstep), dtype=np.float64) # total energy
    #———– initial conditions ———
    i = 0
    index=0
    lastv = v0
    lasth = h0
    K[0] = 0.5 * m * v0*v0
    V[0] = 0.5 * k * h0*h0
    En[0] = K[0] + V[0]
    minv = 1/m
    ## clip max frq
    if semimax>136: return K[:1024]
    else:           pass
    for i from 0 <= i < (nstep-1):
        #———– main loop ———
        index     = i+1
        v         = lastv + (-(k*minv) * lasth - (k1_drag*minv) * lastv) * dt
        h         = lasth + lastv*dt
        kk        = 0.5 * m * lastv*lastv
        vv        = 0.5 * k * lasth*lasth
        K[index]  = kk
        V[index]  = vv
        En[index] = kk + vv
        lastv     = v*damp
        lasth     = h
        if En[index]<16.0:
            En = En[:index]
            K  = K[:index]
            V  = V[:index]               
            break
        else:pass
    print "1DG - MassSpring:",m,"kg at",semimax,"semi" 
    if   mode == "osc" : return K
    elif mode == "both": return K,En
    else:                return En


i think it can be easily translated into ruby to generate a wave array or something else based on basic physics principles.

also look here:
https://www.math24.net/mass-spring-system/

these mechanics are very important to build up sound collections from a physical perspective.

[wlangfor@uoguelph.ca]

Here's a picture of that refracting poly:



They'd be wall and ceiling mounted and about 3-4 feet long. They trap the sound and cause it to bounce around a few times and then refract.

With a special pickup they'd be ideal.
you can only see two but they'd be staggered like a checker board.

[wlangfor@uoguelph.ca]

That is genius, thankyou. Perhaps I may be able to reverse engineer it into math. I like to use straight math for everything because it is faster. This provides Me with the blueprint.

Thanks Michael Benjamin, you're a true innovator.

What I was suggesting is that it would be intriguing to collect the original impact of the sound itself. If you were to have the bass only and then create the sound from that, you could hear a sound actually being formed. It's a way of audio that does not exist but it would sound good.

you could try to add up several mass springs as approximation maybe.

here is a very crude version written in cython:

Code: Select all

@cython.boundscheck(False)
@cython.wraparound(False)
@cython.cdivision(True)
@cython.nonecheck(False)   
def spring(double semi,double hifreqdamp=0.0,double ampdamp=0.0,
           double randomamp=0.0,double randomdev=0.0, mode="osc",
           double maxdur = 90,double osamp=1.0):
    """mass spring, tuned to c2 65.41hz at 48k (semi 0), osc or env
    tune is the octavedivider
    hidamp 0-1.0 dampens(--) or extends(++) higher freqs
    damping 0-1.0 for amp over time
    HIfreqDAMP is FREQ dependent damp
    ampDAMPING is general TIME damp
    """
    cdef double h0,v0,time,dt,k,m,k1_drag,v,h,lastv,lasth,kk,vv,minv
    cdef double semitone,semimax,damp,tune,semidisplay,dampconv,hidampconv
    cdef int nstep,i,index
    cdef np.ndarray[np.float64_t, ndim = 1] K
    cdef np.ndarray[np.float64_t, ndim = 1] V
    cdef np.ndarray[np.float64_t, ndim = 1] En
    tune = 12.0
    semidisplay=semi
    semi-= 36.0
    hidampconv=max(0.0,min(1.0,hifreqdamp))*14.0-7.0
    dampconv=2.0**(max(0.0,min(1.0,ampdamp))*14-7)##0-1 to -5/5
    h0 = random()*randomdev+(1-randomdev)# initial deviation from equilibrium in m
    v0 = random()*randomamp+(1-randomamp)    # m/s
    time = maxdur        # max duration in sec
    damp = 1.0-(dampconv*0.00001)
    dt = 1.0/(osamp*48000.0)       # time step in sec
    nstep = roundl(time/dt) # number of time steps
    k = 24000      # spring constant in N/m
    #frequency = 2 * 440/Samplerate * 2**((pitch-69)/12)
    semitone = (-semi+15)*(24.0/tune)
    semimax  = fabs(semidisplay)
    m = 0.1*(2**(semitone/12.0))
    k1_drag = 2**(-semidisplay/(7+hidampconv))*0.159+0.5000001# kg/s ## ENVELOPE
    K =  np.zeros((nstep), dtype=np.float64)  # kinetic energy
    V =  np.zeros((nstep), dtype=np.float64)  # potential energy
    En = np.zeros((nstep), dtype=np.float64) # total energy
    #———– initial conditions ———
    i = 0
    index=0
    lastv = v0
    lasth = h0
    K[0] = 0.5 * m * v0*v0
    V[0] = 0.5 * k * h0*h0
    En[0] = K[0] + V[0]
    minv = 1/m
    ## clip max frq
    if semimax>136: return K[:1024]
    else:           pass
    for i from 0 <= i < (nstep-1):
        #———– main loop ———
        index     = i+1
        v         = lastv + (-(k*minv) * lasth - (k1_drag*minv) * lastv) * dt
        h         = lasth + lastv*dt
        kk        = 0.5 * m * lastv*lastv
        vv        = 0.5 * k * lasth*lasth
        K[index]  = kk
        V[index]  = vv
        En[index] = kk + vv
        lastv     = v*damp
        lasth     = h
        if En[index]<16.0:
            En = En[:index]
            K  = K[:index]
            V  = V[:index]               
            break
        else:pass
    print "1DG - MassSpring:",m,"kg at",semimax,"semi" 
    if   mode == "osc" : return K
    elif mode == "both": return K,En
    else:                return En


i think it can be easily translated into ruby to generate a wave array or something else based on basic physics principles.

also look here:
https://www.math24.net/mass-spring-system/

these mechanics are very important to build up sound collections from a physical perspective.