LabVIEW
find indices of elements in 1d array
Solved!
This is one way to do it..
You would wire your array to "Your Array" Control and the output is a 1D array with the indeces of elements in between -1 and 1
Well let's talk you through it. You'll have to do some sort of boolean logic for <1 and >-1. You'll have to do this for every element in the array. And then you'll have to output the indices of those elements.
You can use the In Range function to get an array of booleans corresponding with your array. This should result in an array where all elements that fall within your criteria are now a True boolean.
The next part is a little tricky. You could iterate through the array and output indices for all True values... but guess what, there's an awesome VI set that you can use called OpenG. OpenG contains a function called Search Array, which can receive an array and output an array of indices. (Find the OpenG in VI Package Manager and install)
Edit: Careful with Chris's solution because the In Range function is set to include upper and lower limits as in-range. You can change these settings using the right-click menu on that input.
I'm sorry, but Chris's solution is definitely Rube Goldberg code compared to how simple this issue is. The shift registered For loop with a Build Array function and performing the In Range calculation each iteration is not the way to do this. Here is how you can simplify that without OpenG:
This is 5x faster that that and doesn't involve building up unnecessary memory buffers.
@James.M wrote:
This is 5x faster that that and doesn't involve building up unnecessary memory buffers.
You are still creating an unecessary memory buffer for the boolean array, which could make a difference for very large arrays.
Here's what I would do instead. (We should benchmark if the absolute value function should be before or in the loop. If it is before it can probably reuse the existing buffer, but could benefit from SSE instriuctions. Impossible to tell without trying, especially since the compiler might do its own magic behind the scenes... 😄 )
(Only newer LabVIEW versions have conditional tunnels, so we don't really know if the OP can use any of this.)
@ChrisK88 wrote:This is one way to do it..
You would wire your array to "Your Array" Control and the output is a 1D array with the indeces of elements in between -1 and 1
That's pretty pointless for integer array, you might as well use an "equal zero" instead of "in range and coerce". 😄
It is also wrong for the original problem, because you are including the boundaries.
It would probably also be more efficient to preallocate the output array, replace elements as needed keeping track of the inser point, then trim at the end.
Here's a benchmark for inside and outside the loop. The results are all very close and jump ahead and behind each other. I always thought it makes sense for the compiler to use a whole array at a time instead of point by point inside of a loop, but you're the expert, so I'll go with your solution 
Thanks, I haven't tried yet, but my guess was that "in range and coerce" is more expensive because several comparisons need to be made. In contrast, taking the absolute value is supposed to be dirt cheap.
The compiler itself has quite a few tricks up its sleave, so it is possible that all diagrams result in very similar code. (See also this page and this presentation for a historical perspective. I am sure you've seen them, so these are links for the general reader of this thread :D))
