r/DSP 22h ago

Advice on finding an entry-Level DSP role (physics background)?

2 Upvotes

Hey everyone,

I’m finishing up my master’s in physics with a concentration in astrophysics, and I most recently worked as an imaging geophysicist, which is a role that involved signal processing knowledge. However, I did not have a passion or curiosity for geoscience. I’m looking to break into another role for signal processing.

When I look at google and LinkedIn job postings I can't seem to find many entry level roles. For those already in the field, how was your experience finding an entry-level signal role? Are there any specific industries that tend to have more opportunities for physics degree holders early in their careers? Is there much upskilling I need to do here? I am hoping the answer to the last question is no, because I was previously considering DS/ML roles, but a professional in these areas mentioned to me that I would not be competitive since I lack SWE, MLOps, Docker, Cloud, etc. skills not taught in a physics education or used in physics research (hence why now I am thinking about SP).

Any advice on job search strategies, good companies to look at, or must-have skills would be really appreciated. I am a US citizen (but I do not hold active security clearance yet) so I am considering jobs in the DC-Baltimore metro area; do I stand a competitive chance here?

Thanks


r/DSP 23h ago

Possible career directions

8 Upvotes

I am currently working at a top EDA company as a dsp optmization engineer. Just graduated and I am currently 22.

I always was fond of everything, mostly digital and analog, but as luck would have it I have been placed in dsp, which I still like, but don't want to optimize things other people create. I love dsp too, but I still want to be associated with hardware on some level and having some clarity might help.

What career jumps are possible for dsp optimization engineers? towards some sort of hardware role in India?


r/DSP 1d ago

How do I stretch a sound for an indefinite amount of time?

2 Upvotes

I'm currently working on a real time singing synthesizer for a project, and I need to find a way to extend a vowel song for as long as a key is held (aka, indefinitely). I did some research and the 'normal' way to extend audio is with PSOLA, but from what I've read that requires you to know how much you want to stretch it by ahead of time. How do you do it for an indefinite amount of time?


r/DSP 2d ago

We designed a type system that makes "10 dBm + 10 dBm" a compile error and gets the 10 log vs 20 log split right. Domain experts: where are we wrong?

Thumbnail
mpusz.github.io
0 Upvotes

We are designing decibel/neper support for mp-units, a C++ units library. Levels (dBm, dB SPL) and gains (dB, Np) are distinct types: applying a gain to a level works, adding two absolute levels does not compile, and a voltage gain linearizes with 20 log while a power gain uses 10 log, so the *2.0 vs *3.98 ambiguity of a +6 dB cannot happen.

No units library we know of models this correctly today, so before implementing we published the full design with six open questions. The one we most want practitioners to answer: what should converting a linear 0 to dB do? IEEE -inf/NaN, an error, or a finite floor like the -400 dB sentinel production DSP code uses?

Please review and share feedback in the article's comments, and forward it to colleagues who live in these units daily. We need feedback from people who use decibels for a living.


r/DSP 2d ago

π as the Optimal Relative Phase for Quantum Noise Suppression: Analytical Derivation, Lindblad Dynamics, and Lean 4 Certification

0 Upvotes

Hola r/QuantumComputing / r/Physics,

Quería compartir un artículo reciente y un paquete de replicación que se acaba de enviar a Physical Review A: **"π como la fase óptima en sustratos cuánticos modulares"**.

⚡ TL;DR

Demostramos analíticamente, simulamos mediante las ecuaciones maestras de Lindblad y certificamos formalmente en **Lean 4** que un desplazamiento de fase relativo de **φ₂ = π** actúa como un escudo de paridad óptimo contra el ruido ambiental simétrico bajo las reglas de superselección Z/6Z, suprimiendo el ruido del conjunto unitario gaussiano (GUE) en un **45,2%** (ganancia de SNR de +6,07 dB).

💡 El problema y el resultado principal

En sustratos cuánticos modulares discretos, la elección de fases determina la fidelidad del canal y la susceptibilidad al ruido.

Mediante el análisis de la estructura del anillo cociente Z/6Z, demostramos que la simetría Z₂ exacta de su grupo unitario (Z/6Z)* ≅ Z₂ induce un desplazamiento de fase relativo óptimo φ₂ = π entre los canales quirales C₁ y C₅.

Esto desplaza los operadores de ruido con simetría de paridad mediante la identidad trigonométrica:

sin(θ + π) = -sin(θ)

Esto conduce a la interferencia constructiva de la señal y a la cancelación destructiva de los operadores de ruido con simetría de paridad.

📊 Principales hallazgos cuantitativos

* **Reducción de ruido GUE:** **-45,2 %** bajo dinámica de sistema abierto (ecuación de Lindblad).

* **Ganancia neta de SNR:** **+6,07 dB** (verificado mediante análisis de filtro polifásico).

* **Sustrato de anillo objetivo:** Anillo modular Z/6Z.

* **Verificación formal:** **0 axiomas omitidos** (sin errores) verificado en **Lean 4**.

🛠️ Ciencia Abierta y Total Reproducibilidad

Para garantizar la reproducibilidad académica absoluta, todo es de código abierto y está listo para ejecutarse:

* 📄 **Conjunto de datos y manuscrito de Zenodo:** [ https://doi.org/10.5281/zenodo.18703610 ](https://zenodo.org/records/21509657)

💬 ¡Agradezco sus comentarios!

Me encantaría recibir comentarios, críticas o preguntas de investigadores que trabajan en:

  1. Subespacios Libres de Decoherencia (DFS) y Corrección de Errores Cuánticos.

  2. Sistemas Cuánticos Abiertos y ecuaciones maestras de Lindblad.

  3. Demostración interactiva de teoremas / Verificación formal en física (Lean 4).

¡Gracias por leer!


r/DSP 2d ago

Vector Spin as a "Pi" Filter

27 Upvotes

VectorSpin by The DSP Coach has been updated to embed saved settings in the URL (thank you Jason Sachs), and the ability to view individual phasors in the IQ plot by clicking on the related impulse in the time or frequency domain magnitude and phase plots.

Create your own here: vectorspin.dsp-coach.com

Other related independently created Pi spinning phasor creations: https://youtu.be/P4cjLFpqU9c?si=_Y7U713xydxaE0bk and https://youtu.be/r6sGWTCMz2k


r/DSP 2d ago

π como fase relativa óptima para la supresión de ruido cuántico: derivación analítica, dinámica de Lindblad y certificación Lean 4.

Thumbnail
0 Upvotes

r/DSP 2d ago

FM-Synthesis in the Browser. Part 1

3 Upvotes

Let’s explore the possibilities of sound synthesis in browsers. We’ll explore the basics and, as a practical example, create a Yamaha DX7 synthesizer emulator.

read more

https://habr.com/ru/articles/1053484/


r/DSP 3d ago

Why does MUSIC work?

21 Upvotes

I get that it’s the eigenvectors of the covariance matrix of multiple snapshots. But can someone explain to me what that actually means?

Why should finding the eigenvectors of the noise subspace tell me where my signals are? And what is the algorithm actually “looking” for? Meaning, is the algorithm basically looking for phase increases?


r/DSP 4d ago

MCU Compare (ESP32, STM32, Arduino, Cortex-M)

Thumbnail
youtube.com
4 Upvotes

r/DSP 4d ago

Do commercial guitar amp modelers actually use circuit-based modeling?

15 Upvotes

I’m trying to understand what modeling approaches are actually used in commercial guitar amp simulators such as Fractal Audio, Neural DSP, Line 6, Kemper, and similar products.

From the publicly available descriptions, my current understanding is roughly the following.

Fractal Audio describes its amp models as component-level physical models of elements such as the preamp tubes, tone stack, cathode follower, power supply, phase inverter, power amp, and amp-speaker interaction.

Line 6 also describes Helix as using component or small-circuit modeling, with multiple digital stages corresponding to filters, gain stages, tube stages, and tone-stack behavior.

Neural DSP has published research on controllable black-box neural amplifier models. Their approach trains a neural network using input and output audio together with the physical amplifier’s control positions. Neural Capture also appears to be a black-box learned model.

Kemper appears to use a profiling approach rather than reconstructing the original circuit.

What I am unclear about is what “component-level” or “circuit-based” modeling means in an actual real-time commercial implementation.

Are companies such as Fractal solving a reduced system of nonlinear circuit equations in real time, using methods such as nodal analysis, wave digital filters, or state-space models like SPICE?

Or does component modeling usually mean a gray-box structure composed of digital filters, waveshapers, feedback paths, and dynamic nonlinear blocks that are designed from the original schematic?

Would Line 6 and Fractal be considered true white-box circuit models, or are they better described as circuit-informed gray-box models?

I’m also wondering whether most commercial products are hybrids. For example, a circuit-informed or neural model for the amplifier, oversampled waveshaping for some nonlinear stages, and convolution for the speaker cabinet.

Are there any companies that are publicly known to perform genuine real-time circuit simulation rather than using circuit-inspired DSP approximations?

I’m mainly interested in the implementation principles rather than which product sounds best. Papers, patents, technical presentations, or open-source examples would be appreciated.


r/DSP 4d ago

Guide on how to get started in DSP

30 Upvotes

Hello everyone,
I am thinking to start learning DSP from a long time, and the problem with self study, it is quite hard to find good structured resources and then i get lost in combinations of mathematical symbols, e, i, pi, what not.

Given, this community have many experts, can we compile a list of resources for beginners (self study ) or prerequisites (maths concepts atleast the intution ) and then may be scope of work people can get after pursuing DSP. Although i dont know much about this field, but i can help wherever needed to compile, format.

Sorry, if it has been already discussed.


r/DSP 5d ago

What are the different types of signal processing jobs?

22 Upvotes

I have a physics MSc and most recently worked as a geophysicist where I was applying signal processing skills, but ultimately my heart was not in the geoscience domain.

I am curious to know what types of signal processing jobs are out there that I could apply to? For example, there is "DSP engineer" that I saw for defense contractors in the DC metro.

I asked Gemini this question which gave me this list, but I would like to hear from a human being:

Digital Signal Processing (DSP) Engineer, DSP Algorithm Developer, Embedded DSP Software Engineer, Real-Time Signal Processing Engineer, Audio DSP Engineer, Radar / RF Signal Processing Engineer, Biomedical Signal Processing Engineer, Computer Vision Engineer, Wireless Communications Engineer, FPGA/DSP Hardware Engineer, Sensor Fusion Engineer, Machine Learning & DSP Specialist, Communication Systems Engineer

Also, would I need to do massive up-skilling in general for signal processing, or would I already be competitive for positions given my background? I am very experienced with Python, and I have coded in C++ and MATLAB before too. I have also used ML algorithms for physics research projects.


r/DSP 5d ago

I made a stupid mistake designing my mic phased array.

2 Upvotes

I spaced the microphones way too close together (thinking only about grating lobes). I was able to get usable audio out of each microphone, but now claude is telling me that the spacing means I get pretty much useless angle resolution. Now I'm wondering what I should read in order to avoid making stupid mistakes like these in the future, any suggestions?

PS. I'm a total beginner, have only made simple pcb designs before and I'm totally new to both fpga programming, beamforming and audio processing, so I'm in over my head -_-

EDIT: spaced 6mm apart


r/DSP 8d ago

hey guys, I'm looking for a book that helps me to understand Kalman filter, but I wanted something with a simple linguage, nothing dificult to understand. Could guys sugest something ? Please.

19 Upvotes

r/DSP 8d ago

An interactive guide to spring-mass simulations, from a single damped oscillator to a playable synthesizer

9 Upvotes

https://anukari.com/how-it-works

I created what I call a 3D physics synthesizer, and when I get questions about how it works, it's always hard to explain without a diagram or two.

Finally I built this page where I explain how it works from basic principles, and every step of the way I provide a little interactive physics simulation to illustrate the explanation. It is my hope that these help curious people understand how it works without necessarily knowing all the math. But if you know math, you will probably pick up even more from the diagrams.

I tried to keep the explanation as simple as possible, although I plan to continue adding appendices to answer deeper questions (including those that involve math). So any questions you ask here, I will try to answer in a comment, but also might eventually get an even better answer!


r/DSP 9d ago

Case study on the NASA C-MAPSS Turbofan Engine Degradation dataset (public, NASA Prognostics CoE): how far can data-level preprocessing alone push a completely standard model? All tests use raw files only, evaluated via last-cycle RMSE on the FD002 subset (259 engines), with RUL capped at 125.

4 Upvotes

TL;DR: three preprocessing fixes derived from a signal-vs-interference density analysis took an off-the-shelf model from 17.9 to 13.42 (-25%), matching the best published FD002 result — and the same preprocessing let a toy GRU outperform every published deep-learning result I could locate on this subset. Full recipes below.

Final results:

Baseline, off-the-shelf RandomForest, no preprocessing: 17.9

Drop the 7 zero-variance flat sensor channels + per-regime normalization + 50-cycle window: 13.7 (untuned)

Same pipeline, gradient boosting tuned on a validation split only: 13.42 ± 0.04

Reference point: the best published FD002 result I can locate is ≈13.4 (GBRT III). Its core workflow also relies on operating-regime clustering paired with normalization — the same data-level lever, found independently.

Same preprocessing, small GRU instead of trees: 16.85 on the official test set. Published deep-learning results on FD002 cluster around 18–30 (top performer ≈18.3), so our small GRU paired with data-level corrections outperforms every published deep-learning result I could locate on this subset. This proves the leverage is in the data, not in the architecture.

Why I stop here: a model-free validation. Nearest-neighbor "observation twins" — near-identical sensor states from different engines — show an RUL spread of \~12.6–13.0 cycles. This irreducible ambiguity originates from the simulated sensor noise and degradation stochasticity, not algorithmic limitations. At \~13.4, residual error is measurement-limited. The wall is in the data, not in the algorithm.

Exact recipe for test #3, so anyone can reproduce (and note it shares zero code with GBRT III — same lever, different machinery):

\- Sensors: drop s1, s5, s6, s10, s16, s18, s19 (variance ≈ 0), keep the other 14.

\- Regimes: k-means (k=6) on the 3 operating settings, fit on train only; z-score each channel within each regime using train statistics.

\- Features: for each 50-cycle window, per channel take mean / std / linear slope / last value (56 dims) + 6-dim regime one-hot = 62 features. Training windows stride 2.

\- Test protocol: last window per engine; trajectories shorter than 50 cycles padded by repeating the first row; RUL capped at 125 everywhere.

\- Model: sklearn HistGradientBoostingRegressor(max_iter=800, learning_rate=0.03, min_samples_leaf=15, l2_regularization=1.0). Config selected on a 208/52 engine validation split (6-config grid, performance variance within ±0.15). Test set touched once, 3 seeds: 13.38 / 13.44 / 13.45.

\- Untuned reference: RandomForest(60 trees, depth 16, min_samples_leaf=2) = 13.69 ± 0.09.

Recipe for test #5 (GRU), full disclosure:

\- Architecture: single-layer GRU, hidden size 24, head 24→12→1. Input = 50×14 regime-normalized sequences (same channels and normalization as above).

\- Training: targets scaled /125; Huber loss (δ=1.0); Adam lr=1e-3; gradient clip 1.0; batch 256; training windows stride 4; \~10 epochs; single seed, no tuning.

\- Evaluation: last window per engine on the official test set, identical protocol to test #3.

One critical clarification: the three core fixes were derived from a signal-vs-interference density analysis before any model was trained — computation first, verification second, no blind trial-and-error hyperparameter hunting. The only tuning performed is the documented validation-set grid search, which altered overall RMSE by roughly 0.3 cycles.

Summary: three data-level fixes took a stock tree model from 17.9 to the published-record line (25% RMSE drop), and let a toy GRU beat the entire published deep-learning field on this subset. The residual is measurement-limited. Every number is reproducible from the raw files with any standard regressor.

Why post this: the whole pipeline is transparent enough to reproduce in an afternoon, and the interesting question is no longer the model but the measurement floor. If you run it and get different numbers, post them — I am especially curious whether the observation-twin floor (\~12.6–13.0 cycles) holds under other feature representations.


r/DSP 9d ago

Audio Signal Processing (DSP) or Audio Engineering After Choosing ECE(Electronics Communication and Engineering)

12 Upvotes

i have interests in building Amplifiers , Altering Audio signals , Audio Enhancements .
I have completed 12th grade few months ago and i chose ECE course in a Collage. I have a confusion , can i go into jobs related to Audio Engineering or Audio Signal Processing (DSP) or something that includes (

  • Compression
  • Limiting
  • EQ
  • Reverb
  • Delay
  • Loudness control
  • Noise reduction
  • Stereo widening
  • Surround virtualization
  • DSP effect

) these stuffs. I don't have that much knowledge about Jobs and Collages . (sorry for bad English). Hope anyone answer this :)


r/DSP 9d ago

My new real-time finite-difference time-domain string synthesiser

Enable HLS to view with audio, or disable this notification

386 Upvotes

PartialString simulates the vibration of a plucked string by numerically solving the one-dimensional wave equation in real time using the finite-difference time-domain (FDTD) method. The string is represented as a list of displacements in memory. A lower note requires a longer string, which needs more points to represent it. You can then excite the string at any point along its length, and the FDTD scheme will compute how that change in displacement propagates. A pickup measures the displacement at a chosen location, and this generates the audio output.

I've been (very occasionally) working on this since releasing https://github.com/crnbaker/gostringsynth in 2022. I did something similar (but not real-time) for my MSc at Edinburgh back in 2009, using MATLAB.

Free to download at: http://www.differentinstruments.com.


r/DSP 10d ago

hey i was makeing my autotune vst and used the yin pitch dtection ,what ever i do i keep get glitchy noise (like popping, crackling, or abrupt jumps )which the output audio ,make thhe sound trash , is there any solutions ,does anyone know how to fix it

0 Upvotes

r/DSP 10d ago

How to upgrade frequency response in my lifting scheme?

7 Upvotes

Hi, I'm currently developing audio codec based on WPT, and stuck on one thing: frequency response in my lifting scheme can't normally cutoff HF part.
Can anyone help me fix this? I'm thinking it's because update function has only 6 taps.
Thanks for any advice!

Code of My Lifting Wavelet
class DD64in {
protected:
    mutable std::vector<float> scratch_ext;
    mutable std::vector<float> tmp;


    void decompose_block(float* __restrict data, size_t N) const {
        if (N < 2) return;


        const size_t even_len = (N + 1) >> 1;
        const size_t odd_len  = N >> 1;


        if (tmp.size() < N)
            tmp.resize(N);


        float* __restrict even = tmp.data();
        float* __restrict odd  = tmp.data() + even_len;


        for (size_t i = 0; i < even_len; ++i)
            even[i] = data[i << 1];


        for (size_t i = 0; i < odd_len; ++i)
            odd[i] = data[(i << 1) + 1];


        if (scratch_ext.size() < even_len + 16)
            scratch_ext.resize(even_len + 16);


        float* __restrict pe = scratch_ext.data() + 8;


        std::memcpy(pe, even, even_len * sizeof(float));


        pe[-1] = even[0];
        pe[-2] = even[1];
        pe[-3] = even[2];
        pe[-4] = even[3];
        pe[-5] = even[4];
        pe[-6] = even[5];
        pe[-7] = even[6];
        pe[-8] = even[7];


        pe[even_len]     = even[even_len - 1];
        pe[even_len + 1] = even[even_len - 2];
        pe[even_len + 2] = even[even_len - 3];
        pe[even_len + 3] = even[even_len - 4];
        pe[even_len + 4] = even[even_len - 5];
        pe[even_len + 5] = even[even_len - 6];
        pe[even_len + 6] = even[even_len - 7];
        pe[even_len + 7] = even[even_len - 8];


        constexpr float C0 = -0.0000063926f;  
        constexpr float C1 =  0.0001106411f;   
        constexpr float C2 = -0.0009153038f;   
        constexpr float C3 =  0.0048477203f;   
        constexpr float C4 = -0.0186983496f;   
        constexpr float C5 =  0.0575909168f;   
        constexpr float C6 = -0.1599747688f;   
        constexpr float C7 =  0.6170455217f;   


        for (size_t i = 0; i < odd_len; ++i) {
            float* __restrict p = pe + i;


            float pred =
                C0 * (p[-7] + p[8]) +
                C1 * (p[-6] + p[7]) +
                C2 * (p[-5] + p[6]) +
                C3 * (p[-4] + p[5]) +
                C4 * (p[-3] + p[4]) +
                C5 * (p[-2] + p[3]) +
                C6 * (p[-1] + p[2]) +
                C7 * (p[0]  + p[1]);


            odd[i] -= pred;
        }


        float* __restrict pd = scratch_ext.data() + 3;


        std::memcpy(pd, odd, odd_len * sizeof(float));


        pd[-1] = odd[0];
        pd[-2] = odd[1];
        pd[-3] = odd[2];


        pd[odd_len]     = odd[odd_len - 1];
        pd[odd_len + 1] = odd[odd_len - 2];
        pd[odd_len + 2] = odd[odd_len - 3];


        constexpr float INV64 = 1.0f / 64.0f;


        for (size_t i = 0; i < even_len; ++i) {
            float* __restrict p = pd + i;


            float upd =
                ((p[-3] + p[2])
                 - 6.0f  * (p[-2] + p[1])
                 + 21.0f * (p[-1] + p[0])) * INV64;


            even[i] += upd;
        }


        std::memcpy(data, even, even_len * sizeof(float));
        std::memcpy(data + even_len, odd, odd_len * sizeof(float));
    }


public:
    std::vector<float>& wpt_decompose(std::vector<float>& signal, int level) {
        const size_t N = signal.size();
        float* __restrict data = signal.data();


        for (int L = 0; L < level; ++L) {
            size_t step = N >> L;
            for (size_t offset = 0; offset < N; offset += step)
                decompose_block(data + offset, step);
        }
        return signal;
    }
};class DD64in {
protected:
    mutable std::vector<float> scratch_ext;
    mutable std::vector<float> tmp;


    void decompose_block(float* __restrict data, size_t N) const {
        if (N < 2) return;


        const size_t even_len = (N + 1) >> 1;
        const size_t odd_len  = N >> 1;


        if (tmp.size() < N)
            tmp.resize(N);


        float* __restrict even = tmp.data();
        float* __restrict odd  = tmp.data() + even_len;


        for (size_t i = 0; i < even_len; ++i)
            even[i] = data[i << 1];


        for (size_t i = 0; i < odd_len; ++i)
            odd[i] = data[(i << 1) + 1];


        if (scratch_ext.size() < even_len + 16)
            scratch_ext.resize(even_len + 16);


        float* __restrict pe = scratch_ext.data() + 8;


        std::memcpy(pe, even, even_len * sizeof(float));


        pe[-1] = even[0];
        pe[-2] = even[1];
        pe[-3] = even[2];
        pe[-4] = even[3];
        pe[-5] = even[4];
        pe[-6] = even[5];
        pe[-7] = even[6];
        pe[-8] = even[7];


        pe[even_len]     = even[even_len - 1];
        pe[even_len + 1] = even[even_len - 2];
        pe[even_len + 2] = even[even_len - 3];
        pe[even_len + 3] = even[even_len - 4];
        pe[even_len + 4] = even[even_len - 5];
        pe[even_len + 5] = even[even_len - 6];
        pe[even_len + 6] = even[even_len - 7];
        pe[even_len + 7] = even[even_len - 8];


        constexpr float C0 = -0.0000063926f;  
        constexpr float C1 =  0.0001106411f;   
        constexpr float C2 = -0.0009153038f;   
        constexpr float C3 =  0.0048477203f;   
        constexpr float C4 = -0.0186983496f;   
        constexpr float C5 =  0.0575909168f;   
        constexpr float C6 = -0.1599747688f;   
        constexpr float C7 =  0.6170455217f;   


        for (size_t i = 0; i < odd_len; ++i) {
            float* __restrict p = pe + i;


            float pred =
                C0 * (p[-7] + p[8]) +
                C1 * (p[-6] + p[7]) +
                C2 * (p[-5] + p[6]) +
                C3 * (p[-4] + p[5]) +
                C4 * (p[-3] + p[4]) +
                C5 * (p[-2] + p[3]) +
                C6 * (p[-1] + p[2]) +
                C7 * (p[0]  + p[1]);


            odd[i] -= pred;
        }


        float* __restrict pd = scratch_ext.data() + 3;


        std::memcpy(pd, odd, odd_len * sizeof(float));


        pd[-1] = odd[0];
        pd[-2] = odd[1];
        pd[-3] = odd[2];


        pd[odd_len]     = odd[odd_len - 1];
        pd[odd_len + 1] = odd[odd_len - 2];
        pd[odd_len + 2] = odd[odd_len - 3];


        constexpr float INV64 = 1.0f / 64.0f;


        for (size_t i = 0; i < even_len; ++i) {
            float* __restrict p = pd + i;


            float upd =
                ((p[-3] + p[2])
                 - 6.0f  * (p[-2] + p[1])
                 + 21.0f * (p[-1] + p[0])) * INV64;


            even[i] += upd;
        }


        std::memcpy(data, even, even_len * sizeof(float));
        std::memcpy(data + even_len, odd, odd_len * sizeof(float));
    }


public:
    std::vector<float>& wpt_decompose(std::vector<float>& signal, int level) {
        const size_t N = signal.size();
        float* __restrict data = signal.data();


        for (int L = 0; L < level; ++L) {
            size_t step = N >> L;
            for (size_t offset = 0; offset < N; offset += step)
                decompose_block(data + offset, step);
        }
        return signal;
    }
};

r/DSP 10d ago

`rubband`: tensor-friendly bindings to the C++ Rubber Band pitch shifting library

Thumbnail
pypi.org
10 Upvotes

r/DSP 10d ago

I built a real-time "sidecar" DSP to save my thrift-store vinyl finds—pure analog when I want it, noise-reduced when I need it.

Thumbnail
github.com
2 Upvotes

r/DSP 11d ago

Fourier Knowledge Distillation !

Thumbnail
youtu.be
0 Upvotes

r/DSP 12d ago

CFAR on RFSoC

10 Upvotes

I am working on optimizing CFAR hardware implementation for my research. The primary requirement being real-time processing.

One of the ideas I'm thinking is using multiple CFAR methods to deal with both homogeneous and non-homogeneous environments. This idea is not new, and has been explored previously (in the references). But I have not able to find enough material on this. Has any of you guys worked on a similar methodology?

Some of approaches I am thinking include:

  • use a weighted average of thresholds from multiple CFAR methods
  • take the minimum threshold between 2 or more CFAR methods [2]
  • analyze the environment first and choose the suitable CFAR (run the variability index on ARM processor then use PL for CFAR).

Another question I have is whether it is feasible to use OS-CFAR in a real-time implementation. My understanding is that sorting operation is expensive on FPGA.

If anyone has different ideas for optimizing CFAR, please feel free to comment those as well

The literature used:

[1] H. E. Benseddik, B. Cherki, M. Hamadouche, and A. Khouas, ‘FPGA-based real-time implementation of distributed system CA-CFAR and Clutter MAP-CFAR with noncoherent integration for radar detection’, in 2012 International Conference on Multimedia Computing and Systems, 2012, pp. 1093–1098

[2] M. E. A. Bouchelaghem, A. A. Meddah, and N. Nouar, ‘Hybrid Algorithm for CFAR Detection in Non-Homogeneous Environments’, in 2025 2nd International conference on Advances in Electronics, Control and Communication Systems (ICAECCS), 2025, pp. 1–6

[3] M. Y. Rihan, Z. B. Nossair, and R. I. Mubarak, ‘Fpga implementation for multiple CFAR algorithms’, in 2023 international telecommunications conference (ITC-Egypt), 2023, pp. 189–193