LabVIEW Idea Exchange

Interpolate 2D Scattered uses triangulation which is fairly CPU intensive.

The most difficult part, (and the part that most of the CPU time is spent on) is defining the triangles.  Once the triangles are specified, the interpolation is fairly quick (and could possibly be done on an FPGA).  This is the same idea as using the scatteredInterpolant class in Matlab (see : http://www.mathworks.com/help/matlab/math/interpolating-scattered-data.html#bsow6g6-1 )

The Interpolate 2D Scattered function needs to be broken up into two pieces just like Spline Interpolant, Spline Interpolate are. 

It would be useful to have a configurable tool for generating swept values for RFSA/RFSG mainly.

This is actually present in Signal Express. You can insert and even nest the "sweep"-step here, but as far as I can see SigEx doesn´t have support for RFSA/RFSG.

So the next thing coming to my mind was to export the configured sweep as LabVIEW code from SigEx. Unfortunately the resulting Express VI cannot be converted into a regular subVI.

It would be very useful for debugging and prototyping to get this feature!

kind regards

Marco Brauner AES NIG Munich

After applying my own subjective intellisense (see also ;)), I noticed that "replace array subset" is almost invariably followed by a calculation of the "index past replacement". Most of the time this index is kept in a shift register for efficient in-place algorithm implementations (see example at the bottom of the picture copied from here).

I suggest new additional output terminals for "replace array subset". The new output should be aligned with the corresponding index input and outputs the "index past replacement" value. This would eliminate the need for external calculation of this typically needed value and would also eliminate the need for "wire tunneling" as in the example in the bottom right. (sure we can wire around as in the top right examples, but this is one of the cases where I always hide the wire to keep things aligned with the shift register).

If course the idea needs to be extended for multidimensional arrays. I am sure if can be all made consistent and intuitive. There should be no performance impact, because the compiler can remove the extra code if the new output is not wired.

Several String functions have an "offset past ..." output (e.g. "search and replace string", "match pattern", etc.) and I suggest to re-use the same glyph on the icon.

Here is how it could look like (left) after implementing the idea. equivalent legacy code is shown on the right.

Idea Summary: "Replace array subset" should have new outputs, one for each index input, that provides the "index past replacement" position.

This is an extension of Darin's excellent idea and touches on my earlier comment there.

I suggest that it should be allowed to mix booleans with numeric operations, in which case the boolean would be "coerced" (for lack of a better word) to 0,1, where FALSE=0 and TRUE=1. This would dramatically simplify certain code fragments without loss in clarity. For example to count the number of TRUEs on a boolean array, we could simply use an "add array elements".

(A possible extension would be to also allow mixing of error wires and numerics in the same way, in which case the error would coerce to 0,1 (0=No Error, 1=Error))

Here's how it could look like (left). Equivalent legacy code is shown on the right. Counting the number of TRUEs in a boolean array is an often needed function and this idea would eliminate two primitives. This is only a very small sampling of the possible applications.

Idea Summary: When a boolean (or possibly error wire) is wired to a function that accepts numerics, it should be automatically coerced to 0 or 1 of the dominant datatype connected to the other inputs. If there is no other input, e.g. in the case of "add array elements", it should be coreced to I32.

Why doesn't LabVIEW Provide any Simulation for real time hardwares.... What i mean to say that Just as if we build some hardware circuits using microcontroller ... We can simulate the values in almost actual environment using some simulation software such as proteas.... I came up with this when i tried generating a PWM Signals as i ordered the Digital I/O card from LAbVIEW which did took time for shipping... 

After looking at the problem encountered here, it turns out that LabVIEW seems to make some insane choices when mixing a waveform with simple datatypes. Some behavior is good and intuitive. For example multiplying a waveform with a scalar applies the multiplication to the Y component only, because it would not make sense to e.g. also multiply the t0 or dt values.

It is less clear what should happen if multiplying a waveform with an array. Intuitively, one would expect something similar to the above, where the Y component is multiplied with the array. Unfortunately, LabVIEW chooses something else: It creates a huge array of waveforms, one for each element in the array. (as if wrapping a FOR loop around it, see image). If the waveform and the array both have thousands of elements, we can easily blow the lid off all available memory as in the quoted case. Pop! 😄 But the code looks so innocent!

I suggest that operations mixing waveform and simple datatypes (scalars, arrays) simply act on the Y component as shown.

(not sure how much existing code this would break, but it actually might fix some existing code!!! :D)