waveform | Go package capable of generating waveform images | Audio Utils library

You need to use clusterMap() or another function from the parallel package rather than base::Map.

Look those options up with: ?parallel::clusterMap.

You are also currently mixing things up by introducing registerDoParallel(cl), which is from the foreach package. That would require you to then use foreach() and its helper %dopar%. If you do not use foreach() then you do not need registerDoParallel(cl).

The relevant part of your code would look something like this with clusterMap(). I've tidied it a bit but I can't test it on my machine.

Don't try to do your animation in draw(rect:). That puts all the work on the CPU, not the GPU, and does not take advantage of the hardware-accelerated animation in iOS.

I would suggest instead using a CAShapeLayer and a CABasicAnimation to animate your path.

Install the CGPath from your UIBezierPath into the CAShapeLayer, and then create a CABasicAnimation that changes the path property of the shape layer.

The trick to getting smooth shape animations is to have the same number of control points for every step in the animation. Thus you should not add more and more points to your path, but rather create a new path that contains a graph of the last n points of your waveform.

I would suggest keeping a ring buffer of the n points you want to graph, and building a GCPath/UIBezierPath out of that ring buffer. As you add more points, the older points would "age out" of the ring buffer and you'd always graph the same number of points.

Ok, you need something simpler than a ring buffer: Let's call it a lastNElementsBuffer. It should let you add items, discarding the oldest element, and then always return the most recent elements added.

Here is a simple implementation:

Your signal is a sine wave. You chop it up. Each segment will have the same frequency components, just a different phase (shift). The FFT gives you both the magnitude and phase for each frequency component, but after abs only the magnitude remains. These magnitudes are necessarily the same for all your chunks.

I think you misunderstand how to handle this. Instead of getting very small amounts of new data at a high frequency, you should factor your code to get a larger chunk of data on a longer time interval.

You can then set up your display code to start an animation to animate in a graph of the new data over the time interval you are given. 1/10th of a second is actually a pretty short time interval for an animation.

I would suggest averaging the amplitude of the data for that 1/10th of a second time interval and animating that new average data into place.

BTW, see the update I posted to the answer to your question about creating an animated graph of the data.

The animation I came up with looks like this:

In the testbench, you declared the result signal, but it is not connected to anything. You probably intended it to be driven by the alu output of the same name. In that case, you should connect it to the instance:

Change:

To solve the isseu, you need to know the bound of your curve. You have to change the the orthographic projection:

glOrtho(-6, 6, -6, 6, -1, 1);

In Orthographic Projection, the view space coordinates are linearly mapped to the clip space coordinates. The viewing volume is defined by 6 distances (left, right, bottom, top, near, far). The values for left, right, bottom, top, near and far define a cuboid (box).

If you want to center the view on the curve, the center of the projection must be the center of the curve. e.g.:

It can be wise to look at the reverse, the change in periods. For a frequency f0, you have a period T0 = 1/f0. For a frequency f1, you have a period T1=1/f1.

Now, when you evaluate w_sweep(t), you're not using one period T0, then a period lerp(T0,T1,...) etcetera. Instead, you determine a single period T = 1.0/std::lerp(f0, f1, (t - t0)/(t1 - t0)), and then calculate sin(2*pi*t/T) which is of course sin(2*pi*frac(t/T)).

I think what you want (not entirely sure) is f=1/lerp(1/f0, 1/f1, (t - t0)/(t1 - t0))

The answer is very simple. Add ps and ns to your simulation charts and you will understand why.

At the beginning of your simulation you are in state S0. When the product is bigger than 0 (first yellow mark) you go to state S1. Then you are waiting for EQ or GT, but EQ fall down one clock cycle ago so next GT arrive.

Set EQ and GT one clock cycle later.

Call the constructor directly like this: