*The things that I used to do…*

*En masse* is a French term meaning “as a whole” or “all together”; treating a group of something as a single unit. LabVIEW has the ability to treat arrays this way, which can greatly reduce your workload. If you come to LabVIEW from a text-based language, it’s easy to miss the capabilities that are right at your fingertips.

For example, if you need to scale a series of readings into percent of the total (a procedure called normalizing), then you tend to think:

I need to find the total:

- I need to start with a zero sum
*sum = 0.0;* - I need to loop over every element
*for (int i = 0; i < nElements; i++)* - I need to add this element to the sum
*sum += array[i]*

Now I need to divide each entry by the total, to get the fraction of the total:

*for (int i = 0; i < nElements; i++)**array[i] /= sum;*

Now I need to multiply by 100 to get percentages:

*for (int i = 0; i < nElements; i++)**array[i] *= 100.0;*

That’s all well and good, and you could translate that literally into LabVIEW and it will get you the answer you want to see. But that’s not the LabVIEW way of thinking.

What newcomers often fail to realize is that most primitive numeric functions (the ones with yellowish icons) will accept an array of numbers directly. This goes for basic arithmetic (add,subtract, multiply, divide), comparisons (greater than, less than, MAX/MIN), and many other operations. It will happily multiply an array of numbers by a single scaler number, to produce an array of numbers.

This has great power to reduce the work that you do as the programmer. Consider the literal translation of the above code:

If that’s as good as it gets then why should I go with LabVIEW?

Well, it does get better. There is a function in the numeric palette called ADD ARRAY ELEMENTS. If we replace the entire first loop with this function, then we get to this:

Now for the *en masse* parts: You can replace the entire second loop with a single operation as well:

Any guesses what we can do with the third loop? Yes, that’s right:

Now you have SO much more room to add comments about what you’re doing!

Now THIS is what makes you more productive in LabVIEW than in C; your chances for error are far less when you let the *en masse *operators handle the details, and you don’t even have to think about the details.

But be aware of what’s going on, however; there is no magic here. Under the hood there is still a loop somewhere. It’s now hidden somewhat; it’s not as obvious, but the work is still being done. Don’t let the simplicity obscure the real processing that’s going on.

Here is an example of the normalizing function in use, from the real LabVIEW example examples\general\graphs\charts.llb\Draw Stacked Graph.vi (in LabVIEW 8.6. anyway).

This amounts to the same as our last part above. In the example, the array given contains five elements and this is executed only once, so efficiency is not a concern.

But consider if the array was 10,000 elements. Don’t forget that the first operation is doing 10,000 divide operations, and the second is doing 10,000 multiplications. Can you improve things?

Well, certainly! What you have to realize is that, by the associative property of numbers, (X / sum) * 100 is equal to (100 / sum) * X. You also have to realize that 100 / sum, in this context, is a constant, and therefore needs to be calculated only once. In effect, you are dividing by sum and multiplying by 100, but you are doing it 10,000 times!

With any luck at all, you get the same answer every time, so you only need to do it once:

THIS is why we use LabVIEW!

**NOTE**: *En masse *is my term for this feature, it is not an official LabVIEW term.