Arrays (negative index)

please help me with this question i do not know what is meant by a negative index
Write a method called initInverse() which initialises each component of a one dimensional array called list with its negative index
(i.e, list[0] = 0; list[1] = -1

If there is an ayyar, each member has a number to identify it.
array[0]
array[1]
array[2]
This number is its 'index'
Now you are to write a programm that goes through each array-member and sets its value to its negative Index.

Similar Messages

I need help with event structure. I am trying to feed the index of the array, the index can vary from 0 to 7. Based on the logic ouput of a comparison, the index buffer should increment ?

I need help with event structure.
I am trying to feed the index of the array, the index number can vary from 0 to 7.
Based on the logic ouput of a comparison, the index buffer should increment
or decrement every time the output of comparsion changes(event change). I guess I need to use event structure?
(My event code doesn't execute when there is an event at its input /comparator changes its boolean state.
Anyone coded on similar lines? Any ideas appreciated.
Thanks in advance!

You don't need an Event Structure, a simple State Machine would be more appropriate.
There are many examples of State Machines within this forum.
RayR

Array from index 1 to x

Hi
is there a way to create arrays from index 1 to something, like
double[][] data = new double[1:2][1:64]I can, off course, create an array like
double[][] data = new double[3][65];
but this will cost me a lot of rewriting.
Luca

> double[][] complex = new double[2][<huge number>] >changing the 2 into a 3 would increase the array a lot, and slow-down the program even more memory).
Well, if you really have to, you could always do this -- double[3][] = { null, new double[<huge number>], new double[<huge number] }; This way it would only cost you one 32 bit reference. I don't find it very elegant though ...
kind regards,
Jos

There should be a way to index an array with an array of indexes or booleans (without a loop)

Hi, often I would love to index an array with an array of indexes or an array of booleans without having to loop it. I.e: let the IndexArray function accept an array of indexes instead of discrete indexes. The output should then be an array of indexes values.
Another use case is to index with an array of booleans, so each TRUE element would index the input array and FALSE elements are not indexed.
arrResult = arrInput[ arrIndexes ]; or
arrResult = arrInput[ arrVal > 20 ];
Would this be useful? Possibly it could be implemented in future versions?

You forgot the link.

Array Control allows Negative Index on FPGA

I couldn't find anything on this topic through NIs search or Google. I can't be the only one who's seen it though.
I have an array control on the front panel of my FPGA VI and I was trying to get back to the start using the indexing arrows. Much to my surprise it let me blow right by the start, index 0, and into the negative indices. Is this intended? Why? Bug?
When I try to initialize the value on the FP it goes back to it's default grey disabled state, so it seems like it knows I shouldn't be there. Also at -1 all visible elements are grey instead of just the first.
(Also it seems I found a bug in whatever version of CCT I'm using, the index is cut off my main array)
Tim Elsey
LabVIEW 2010, 2012
Certified LabVIEW Architect

It's a bug, reported as CAR 130548. It's primarily cosmetic, as you can't assign values to any of the array elements at negative indices.
Darren Nattinger, CLA
LabVIEW Artisan and Nugget Penman

String array, integer index

class TetrisBoard {
     public static void main(String[] args) {
          String board[][] = new String[5][5];
          int column;
          int row;
          char piece;
          String board[][] = {{"| ","| ","| ","| ","| ",},
                                   {"| ","| ","| ","| ","| ",},
                                   {"| ","| ","| ","| ","| ",},
                                   {"| ","| ","| ","| ","| ",},
                                   {"| ","| ","| ","| ","| ",}};
          for(int row = 0; row < board.length; row ++) {
               for(int col = 0; col < board[row].length; col++) {
               System.out.print(board[row][col]);
}hey, this is the code i have. How do i make the indexes be integers, so that board[row][col] is compatible with String board[5][5]? thanks for the help :D

You are declaring the variable 'board' twice. Thats the first problem.
The second is you have to use the array constatant only when initializing the array.
Do this instead
class TetrisBoard {
     public static void main(String[] args) {
          String board[][] = new String[][]
               { "| ", "| ", "| ", "| ", "| ", },
               { "| ", "| ", "| ", "| ", "| ", },
               { "| ", "| ", "| ", "| ", "| ", },
               { "| ", "| ", "| ", "| ", "| ", },
               { "| ", "| ", "| ", "| ", "| ", }
...- Roy

Which index values can be sent to "Insert Into Array" without changing the present array ? E.g. index -1 ?

Which index values can be sent to "Insert Into Array" without changing the present array ? E.g. index -1 ?
Could not find this info via the "Context Help" window.

If you have to handle situations where you do not want to insert something in an array, then you can either use a negative index value as you suggested, or put the insert node in a case structure, with the "do not insert" case empty (almost...just crossed by the array wire!..)
Chilly Charly (aka CC)
E-List Master - Kudos glutton - Press the yellow button on the left...

How can I create sub-arrays based on the positions of indicies in a separate index array?

Please forgive me if this question is basic or obvious. I am fairly new to LabVIEW and I'm trying to learn as I go along.
I have a 1D array of index values (the number of possible index values is not fixed, but can vary between uses of the application; it could be just {0, 1} on one day and {1, 5, 11, 678} on another) and a 1D array of measurement values (doubles). I'd like to parse the measurement values into sub-arrays for each index, so that if my index array was:
[0 1 1 1 1 5 5 0 5 5 1 0 1 1 5]
and my measurement array was:
[0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.10 0.11 0.12 0.13 0.14 0.15]
I would get back 3 sub-arrays:
[0.1 0.8 0.12]
[0.2 0.3 0.4 0.5 0.11 0.13 0.14]
[0.6 0.7 0.9 0.10 0.15]
I know there must be a simple way to do this, I guess I'm just stuck too much in matlab-array thinking to figure it out... please help!
-- jph
Solved!
Go to Solution.

jamespherman wrote:
Thus, I figured it might be possible to generalize this idea and send multiple sets of XY values to an XY graph.
OK, all we need is a trivial modification of what we already have. XY graph data is easiest handled using complex data. Here's a quick rewrite. See if this works for you.
LabVIEW Champion . Do more with less code and in less time .
Attachments:
SplitInGroupsGraph.vi ‏14 KB

Iteration Speed issue when Indexing 3D array wried to a while-loop

Brief Description of my Program:
I am working on the real-time signal generation by using LabView and DAQmx (PCI-6110 card). My vi reads the big data file (typically 8MB txt file containing about 400,000 samples (complex double precision). Then, the signal is pre-processed and I end up with a huge 3D array to feed while-loop (typically 3D array dimension is N x 7 x M where N & M >> 7). Inside the loop, that 3D array is indexed and processed before the results are written to the DAQmx outputs. I have a speed issue when indexing the large 3D array (i.e, 3D array having a large sub-array size). My while-loop could not run fast enough to top-up the DAQmx AO buffer (at the output rate of 96kHz). It could run faster only if I use smaller 3D array (i.e, smaller-sized sub-arrays). I do not quite understand why the size of 3D sub-array affects the rate of looping although I am indexing same sub-array size at each iteration. I really appreciate your comments, advices and helps.
I include my 3D array format as a picture below.
Question on LabView:
How does indexing an 3D array which wires to the while-loop affect the speed of the loop iteration? I found that large dimension of sub-arrays in the 3D array slows down the iteration speed by comparing to indexing the same size of sub-array from smaller-sized sub-arrays of the 3D array to perform signal processing inside the while-loop. Why? Is there any other way of designing LabView Program to improve speed of iteration?
attachment:

Thank you all for your prompt replies and your interests. I am sorry about my attachment. But, I have now attached a jpg format image file as you suggested.
I had read the few papers on large data handling such as "LabVIEW Performance and Memory Management". Thus, I had already tried to avoid making unnecessary copies of data and growing arrays in my while-loop. I am not an expert on LabView, so I am not sure if the issues I have are just LabView fundamental limitations or there are any other ways to improve the iteration speed without reducing the input file size and DAQ output rate.
As you request, I also attach my top-level vi showing essential sections such as while-loop and its indexing. The attached file is as an image jpg format because the actual vi including Sub-VIs are as big as 3MB in total. I hope my attachment would be useful for anyone who would like to reply my question. If anyone would like to see my whole vi & llb files, I would be interesting to send it to you by an e-mail privately and thus please provide your e-mail address.
The dimension of my 3D array is N x 7 x M (Page x Row x Column), where N represents number of pages in 3D array, and M represents the size of 1D array. The file I am currently using forms 3D array of N = 28, & M = 10,731. Refering to the top-level vi picture I attached, my while-loop indexes each page per iteration and wrap-around. The sub-VI called "channel" inside the while-loop will further index its input (2D array) into seven of 1D arrays for other signal processsing. The output from that "channel" sub-VI is the superposition of those seven arrays. I hope my explaination is clear.
Attachement: 3Darray.jpg and MyVi.jpg
Kind Regards,
Shein
Attachments:
3Darray.jpg ‏30 KB
MyVI.jpg ‏87 KB

Create sub-arrays based on the positions of indicies in a separate index array?

I have a 1D array of index values and a 1D array of measured values. As an example:
Index array: 1, 2, 4, 7, 126, 127,129, 214, 215
Measurement array: 5, 6, 8, 4, 4, 9, 8, 7, 5
I want to get sub-arrays of measurement array (three for this example):
[5,6,8,4], [4,9,8],[7,5]
A sub-array is generated when there is a big gap (this value is known) between consecutive elements of Index array (126-7, 214-129, this value is known, say 80).
How to do this in labview.
Thanks
Solved!
Go to Solution.

Alice12 wrote:
I tried to generate your program but there is some problem (I dont know the false case).
And I want to find the maxima of each sub-array and then find their average (this should be the final output).
You have it mostly right. I explained in my post what's in the false case: an increment (+1) for the top shift register. The other wires pass straight through. The image I posted is a "snippet" - it's actual code. You can drag it into a block diagram (with some web browsers, you will need to drag to your desktop first, and from there to the block diagram). There is a bug in the snippet creation where it does not always show cluster contents properly, and that's what happened here. The array constant wired to the left side of the lower shift register contains a cluster containing an array of numeric values. You will see this if you load the snippet. I hope that you were able to understand the logic of this code as you were constructing it, but if not, please ask for an explanation.
From there it is trivial to find the max and averages. Connect the output of my code to a for loop. Inside the for loop, unbundle the array, and compute the maximum and average. Functions to do these operations on any numeric array already exist (look for Array Max & Min, and Mean).

Auto-indexing is slow for arrays with 1 dimensions

Hi,
I was looking at the performance of operations on all individual elements in 3D arrays, especially the difference between auto-indexing (left image) and manual-indexing (right image, calling "Index array" and "Replace array subset" in the innermost loop). I'm a bit puzzled by the results and post it here for discussion and hopefully somebody's benefit in the future.
Left: auto-indexing; right: manual-indexing
In the tests I added a different random number to all individual elements in a 3D array. I found that auto-indexing is 1.2 to 1.5 times slower than manual-indexing. I also found that the performance of auto-indexing is much more dependent on the size the dimensions: an array with 1000x200x40 elements is 20% slower than an array with 1000x40x200 elements. For manual-indexing there is hardly any difference. The detailed results can be found at the end of this post.
I was under the impression that auto-indexing was the preferred method for this kind of operation: it achieves exactly the same result and it is much clearer in the block diagram. I also expected that auto-indexing would have been optimized in LabView, but the the tests show this is clearly not the case.
What is auto-indexing doing?
With two tests I looked at how auto-index works.
First, I looked if auto-indexing reorganizes the data in an inefficient way. To do this I made a method "fake-auto-indexing" which calls "Array subset" and "Reshape array" (or "Index array" for a 1D-array) when it enters _every_ loop and calls "Replace array subset" when exiting _every_ loop (as opposed to manual-indexing, where I do this only in the inner loop). I replicated this in a test (calling it fake-auto-indexing) and found that the performance is very similar to auto-indexing, especially looking at the trend for the different array lengths.
Fake-auto-indexing
Second, I looked if Locality of reference (how the 3D array is stored in memory and how efficiently you can iterate over that) may be an issue. Auto-indexing loops over pages-rows-columns (i.e. pages in the outer for-loop, rows in the middle for-loop, columns in the inner for-loop). This can't be changed for auto-indexing, but I did change it for manual and fake-indexing. The performance of manual-indexing is now similar to auto-indexing, except for two cases that I can't explain. Fake-auto-indexing performs way worse in all cases.
It seems that the performance problem with auto-indexing is due to inefficient data organization.
Other tests
I did the same tests for 1D and 2D arrays. For 1D arrays the three methods perform identical. For 2D arrays auto-indexing is 15% slower than manual-indexing, while fake-auto-indexing is 8% slower than manual-indexing. I find it interesting that auto-indexing is the slowest of the three methods.
Finally, I tested the performance of operating on entire columns (instead of every single element) of a 3D array. In all cases it is a lot faster than iterating over individual elements. Auto-indexing is more than 1.8 to 3.4 times slower than manual-indexing, while fake-auto-indexing is about 1.5 to 2.7 times slower. Because of the number of iterations that has to be done, the effect of the size of the column is important: an array with 1000x200x40 elements is in all cases much slower than an array with 1000x40x200 elements.
Discussion & conclusions
In all the cases I tested, auto-indexing is significantly slower than manual-indexing. Because auto-indexing is the standard way of indexing arrays in LabView I expected the method to be highly optimized. Judging by the tests I did, that is not the case. I find this puzzling.
Does anybody know any best practices when it comes to working with >1D arrays? It seems there is a lack of documentation about the performance, surprising given the significant differences I found.
It is of course possible that I made mistakes. I tried to keep the code as straightforward as possible to minimize that risk. Still, I hope somebody can double-check the work I did.
Results
I ran the tests on a computer with a i5-4570 @ 3.20 GHz processor (4 cores, but only 1 is used), 8 GB RAM running Windows 7 64-bit and LabView 2013 32-bit. The tests were averaged 10 times. The results are in milliseconds.
3D-arrays, iterate pages-rows-columns
pages x rows x cols : auto    manual fake
   40 x 200 x 1000 : 268.9   202.0   268.8
   40 x 1000 x 200 : 276.9   204.1   263.8
200 x   40 x 1000 : 264.6   202.8   260.6
200 x 1000 x   40 : 306.9   205.0   300.0
1000 x   40 x 200 : 253.7   203.1   259.3
1000 x 200 x   40 : 307.2   206.2   288.5
100 x 100 x 100 : 36.2    25.7    33.9
3D-arrays, iterate columns-rows-pages
pages x rows x cols : manual fake
   40 x 200 x 1000 : 277.6   457
   40 x 1000 x 200 : 291.6   461.5
200 x   40 x 1000 : 277.4   431.9
200 x 1000 x   40 : 452.5   572.1
1000 x   40 x 200 : 298.1   460.4
1000 x 200 x   40 : 460.5   583.8
100 x 100 x 100 : 31.7    51.9
2D-arrays, iterate rows-columns
rows x cols : auto     manual   fake
200 x 20000 : 123.5    106.1    113.2
20000 x   200 : 119.5    106.1    115.0
10000 x 10000 : 3080.25 2659.65 2835.1
1D-arrays, iterate over columns
cols   : auto manual fake
500000 : 11.5 11.8    11.6
3D-arrays, iterate pages-rows, operate on columns
pages x rows x cols : auto    manual fake
   40 x 200 x 1000 : 83.9   23.3     62.9
   40 x 1000 x 200 : 89.6   31.9     69.0
200 x   40 x 1000 : 74.3   27.6     62.2
200 x 1000 x   40 : 135.6   76.2    107.1
1000 x   40 x 200 : 75.3   31.2     68.6
1000 x 200 x   40 : 133.6   71.7    108.7
100 x 100 x 100 : 13.0    5.4      9.9
VI's
I attached the VI's I used for testing. "ND_add_random_number.vi" (where N is 1, 2 or 3) is where all the action happens, taking a selector with a method and an array with the N dimensions as input. It returns the result and time in milliseconds. Using "ND_add_random_number_automated_test.vi" I run this for a few different situations (auto/manual/fake-indexing, interchanging the dimensions). The VI's starting with "3D_locality_" are used for the locality tests. The VI's starting with "3D_norows_" are used for the iterations over pages and columns only.
Attachments:
3D_arrays_2.zip ‏222 KB

Robert,
the copy-thing is not specific for auto-indexing. It is common for all tunnels. A tunnel is first of all a unique data space.
This sounds hard, but there is an optimization in the compiler trying to reduce the number of copies the VI will create. This optimization is called "in-placeness".
The in-placeness algorithm checks, if the wire passing data to the is connected to anything else ("branch"). If there is no other connection then the tunnel, chance is high that the tunnel won't create an additional copy.
Speaking of loops, tunnels always copies. The in-placeness algorithm cannot opt that out.
You can do a small test to elaborate on this: Simply wire "0" (or anything less than the array sizy of the input array) to the 'N' terminal.......
Norbert
PS: Auto-indexing is perfect for a "by element" operation of analysis without modification of the element in the array. If you want to modify values, use shift registers and Replace Array Subset.
CEO: What exactly is stopping us from doing this?
Expert: Geometry
Marketing Manager: Just ignore it.

Indexing array of references element by element

Hello,
I have a simple question. How do I go about indexing an array of references element by element? For example, when using a cluster reference, there is a property node called "controls [ ]" that we can pass into a for loop. For a normal array, "enable indexing" is usually automatically turned on when entering a for loop. Why is it that for an array of references, this is not the case? Thanks for the help.
Solved!
Go to Solution.
Attachments:
array_of_references.JPG ‏35 KB

Since the Get Image is a method, it has to work on something, and that would be a picture control or indicator. (If you look at the Get Image Method for the array, you'll notice it only returns an image of the front panel object, so I think you'd just get a picture of the array as it looks on the FP).
So you'd send the picture to an indicator, then use the Get image method on that indicator immediately afterwards. See attached. I didn't try this out so I can't be sure it would work, but I think it would. But it would still be a major hack compared to just using the Picture to Pixmap VI.
Message Edited by Ravens Fan on 03-27-2009 01:03 AM
Attachments:
Array_of_References[1]_BD.png ‏12 KB

Push value in index 0 in array

Hi, all I am creating a row which have 8 thumbnails in it, I save these in a array, When user drag row right to left then first Movieclip shift to last position, then i splice array 0 index and push to last position.. it works fine but when i drag it left to right then I need to cut last index of array and i need to push on first position, but it is overwrite the last value of array and after push the value(myrow[0]=thumb) array showing it's length 7 before it was 8. What is the right way to push value at 0 index value in an array.

1. All of these are different ways of adding item to array at 0 index .
someArray.unshift(someValue); : add first item
someArray[index] = someValue; : set item somewhere
someArray.splice(index, 0, someValue); : insert item somewhere

1D Index Array Extraction

Hey all,
I'm relatively new to using LabView and cannot figure out how to get this done.
I have 2 arrays, aray A and array B. I want to look up the specific values from Array B by analyzing Array A first and noting what locations, indexes, they are.
From Array A I am able to locate the locations, but it is in the form of a 1-D array of double. Now that I know the indexes of locations in interest,how do I extract the data from Array B?
When I try to use Index Array LabView gives the following error, 'source is 1-D array and sink is long'. Any help would be greately appreciated on how I can extract the data points from Array B by having an array of indexes of interest.
Example of what I'm trying to do
Input:
Locations / Indexes: 1 3 4
Waveform Array: 0 2 4 6 8 10
Output:
0 4 6
Thank you for your time
Solved!
Go to Solution.
Attachments:
progress.vi ‏28 KB

Arrays are 0 indexed so locations 1,3, & 4 should be 0, 2 & 3 if you want those output values. Attached is a pic of the code to do this. Be sure to disbale indexing on the data set and allow indexing on the 'location/indices' array.
Attachments:
ex code.png ‏17 KB
ex code.jpg ‏41 KB

Determine index of array within event structure

I am doing some testing with dynamically registered events. For these testing purposes, I have 2 separate arrays of boolean references hooked up to the dynamic input terminal. The event structure is executing like I expect it to. The only problem is that I want to know the index within the array for the event that triggered the value change event. I would have thought I could use the CtlRef node to determine this, but instead it returns a reference to the actual boolean control that triggered the event.
I could write a subroutine that searches for the label of the boolean that triggered the event within the arrays, but that is not efficient or good practice.
So for instance, if I click on Boolean 2, I'd want the event structure to know it was array #1, index 1. If I click on Boolean 6, I'd want the event structure to know it was array #2, index 2.
Is this possible?

That is a very good idea. The caption is good to use for the label you show to the user. You can change it to show different things, even programmatically, such as if you need to make your application more international and have it display controls in different languages to different users. It lets you use longer or more descriptive names, without having those long names eat up block diagram space.
Another thing I've done is take the control reference and search for it among the array of control ireference. Search 1-D array will give you the index of the control within the array. Then I can use that index and apply it to a different array and index out a value from that. It could be a name, or perhaps a numeric value I use as a multiplier or something like that. Just make sure there is a one to one correlation between the references in the array and whatever is the other array you are getting additional data from. For what you have drawn now, it could be a little bit complicated because you actually have two different 1-D arrays of references. But if you concatenated those arrays together, you'd have a single 1-D array you can search.

Arrays (negative index)

Similar Messages

Maybe you are looking for