"alias free analog" modular environment

[Architeuthis]

soundemote.io
100% soundemote DSP: https://youtu.be/PpcdN-DXYdc?list=RDMMPpcdN-DXYdc


https://github.com/soundemote/soemdsp/t ... oscillator

• DSFOscillator.hpp:
  • perfect(?) bandlimiting using Discrete Summation Formula
• DistortionOscillator.hpp:
  • near perfect soft-clipped style bandlimiting
• Ellipsoid.hpp:
  • near perfect bandlimiting if you dont go over sharpness thresholds
• Supersaw/Hypersaw.hpp:
  • uses polyBLEP
• JerobeamSpiral.h:
  • naturally bandlimited to some degree
• PolyBLEP.hpp:
  • near perfect bandlimiting

the design philosophy is:
* avoid getters/setters
* avoid branching
* the internal wiring paradigm is array-based (we simply run through a contiguous array of calculations)
* compiled equations (regex-like reduction)
* single truth samplerate and frequency to avoid pitch calculations
* i could perhaps do multithreading by allowing for multiple arrays
* possible GPU processing

the additive synth will be:
-phase
-frequency
-amplitude

control all arbitrarily with formulas and per sine modulation. this is extremely powerful, very musical, very useful. ive used it to model cymbals and hi hats, as well as do extreme sound design. it could probably be repurposed as a resonator and eventually ill do a vocoder

[Architeuthis]

an equation for calculating an nth digit predictably, but digits are also very random. the point is: i need an algorithm that we can check where we are in time based on digit and comparing surrounding digits, and at the same time, use that as a noise floor. so we keep time and noise in the same instance. i could then derive a sinewave out of that noise with a bandpass filter.

before my idea was: generate sine wave, use noise to cover distortion and keep time. but this might be better? i think there are multiple "universe algorithms" that we can go with, perhaps each one will have a different overall sound quality.

Code: Select all

import hashlib

def get_irrational_noise(n: int) -> float:
    """
    Generates a deterministic pseudo-random noise value between -1.0 and +1.0
    for any integer n, representing digits of a chaotic irrational number.
    """
    # 1. Convert the position index to a string and hash it
    encoded_input = str(n).encode('utf-8')
    hash_hex = hashlib.sha256(encoded_input).hexdigest()
    
    # 2. Extract a slice of the hash (first 8 hex chars) and convert to integer
    # 8 hex characters give us 16^8 (4,294,967,296) possible discrete values
    hex_chunk = hash_hex[:8]
    integer_value = int(hex_chunk, 16)
    max_possible_value = 16**8 - 1
    
    # 3. Normalize to a 0.0 to 1.0 range
    zero_to_one = integer_value / max_possible_value
    
    # 4. Map linearly from [0, 1] to [-1, 1]
    noise_value = (zero_to_one * 2.0) - 1.0
    
    return noise_value

# --- Example Usage ---
if __name__ == "__main__":
    print("Sequential samples (simulating a timeline or stream):")
    for i in range(5):
        print(f"Index {i:2d} -> Noise: {get_irrational_noise(i):.6f}")
        
    print("\nInstant infinite lookup (jumping straight to distant indices):")
    print(f"Index 999999 -> Noise: {get_irrational_noise(999999):.6f}")
    print(f"Index 1000000000 -> Noise: {get_irrational_noise(1000000000):.6f}")

[9b0]

good for you, if this works for you, but such overhyped bs posts with 0 evidence or content are a waste of time for everyone.

[nexusfluxx]

…this is the last human problem. ai will solve everything else after this.

There is no known solution to human arrogance that I am aware of.

[Architeuthis]

..

[Architeuthis]

..

[Architeuthis]

..

[Architeuthis]

..

[9b0]

a sawtooth is just a fedback speed-limited sinusoid
an envelope is just a pinged oscillator and we measure the peaks and troughs to find the envelope
a filter can be a simple delay equation or an oscillation network
etc.

sawtooth is not a feedback "speed-limited" sinusoid. i might be wrong, but what you try to describe feels the same as PM (or FM) self-feedback, which really turns a sine wave into a sawtooth-ish waveform, but this is not anti-aliased by definition. you can limit the PM feedback gain so, that your waveform won't create (many, or audible) harmonics above nyquist, but this is not solving aliasing at all.

it's tiring to read AI slop posts all the time in this forum. i know it's exciting to be able to do stuff you've always dreamed of, but never had the time or money or knowledge to really dive into it... but stating that "you solved aliasing" based on LLM feedback to your prompt is disrespectful to all the people who wrote all the technical / scientific papers in the past decades that your LLM hallucinates about.

and i also want to be clear: i'm not anti-AI, i'm using it a lot daily, and it helps me a lot in saving time. but DSP and sound synthesis is not something any LLM is really good at ATM.

these claims do not line up:

i explained proof in my first post

and

i can prove it with 100% clarity given time or money.

if the proof was already provided, you should be able to point to a paper or some documentation that describes your idea clearly and precisely. terminology such as “speed-limit” was never defined by you, so no one can know what you actually mean. that makes your posts a complete waste of everyone’s time. there is nothing else to discuss here, only your posting style and behaviour, while you are just hyping your own site and try to raise traffic with such posts.

some hints: don't publish stuff if you can't handle criticism. and... posting the same answer 3x to different users, in which you claim things that no one even brought up: makes you look exactly like a bot.

[Architeuthis]

..

[9b0]

https://soundemote.io/#/last-clock <- the start of proof. i will need concrete evidence but i don't have time to keep coding right now, out of time and money. the equation in the article is just one example. i already have a more robust sin generator (it needs mathematical reduction still):
the definition of a sawtooth in my universe simulation is described as a sharp impulse followed by a gradual decay. you are over-simplifying my suggestions by saying it's simply a fedback sine to create a sawtooth. but it is what i said, however, that's not the end of the story, that's the tip of the iceberg, and/or just one of many ideas of how to get a sawtooth out of a sinusoid resonator. perfect waveshape is not the goal: no aliasing is.

1. speed limited waveforms creates organic squeaks, hums, growls, screams, gurgles
2. perfect waveshapes create perfect horrible aliasing
3. calculating sin() causes aliasing because of the very nature of perfect time-instant calculations. instantaneous time breaks the laws of physics therefore breaks the universe speed limit and therefore causes aliasing

thanks for the reply. you’ve just confirmed everything i said.

[Architeuthis]

..

[whyterabbyt]

[9b0]

you said this:

based on LLM feedback to your prompt is disrespectful to all the people who wrote all the technical / scientific papers in the past decades that your LLM hallucinates about.

you missed this:

https://github.com/soundemote/soemdsp

the end to aliasing is the last technological problem humans need to solve. this is the last human problem.

i hope you're aware that you can already generate perfectly bandlimited and alias-free saw, square and triangle waves since a few decades using BLIT oscillators. the basic idea is actually related to what you describe, but instead (and opposed to your definition of a saw) of exciting a decay with a sharp, broadband impulse, BLIT uses a bandlimited impulse derived from the sinc function, which is the time-domain representation of an ideally rectangular, bandlimited spectrum. integrating the resulting bandlimited impulse train produces a sawtooth waveform.

related techniques such as BLEP and minBLEP address the same class of discontinuity-related problems, while polyBLEP (and polyBLAMP) is an efficient polynomial approximation of the BLEP (and BLAMP) correction. lately, Signalsmith came up with the idea of elliptic BLEPs (for which he did a really nice presentation).

you can also generate perfectly alias-free periodic and non-periodic waveforms using additive synthesis, although it may not be particularly CPU-efficient. you can also generate perfectly alias-free waveforms using wavetable synthesis.

so, in terms of oscillator waveform generation, humanity solved the problem you are trying to solve a long time ago, while you are approaching it now through completely debatable assumptions.

and i believe humanity has many more, and far more fundamental, problems to solve than aliasing.

[Architeuthis]

..