1
00:00:14,000 --> 00:00:15,000
Hello, friends.

2
00:00:15,000 --> 00:00:21,000
Today we work on in place element structure.

3
00:00:21,000 --> 00:00:30,000
Basically it is used to control how the LabVIEW compiler performs common operations more efficiently

4
00:00:30,000 --> 00:00:33,000
than traditional LabVIEW programming methods.

5
00:00:34,000 --> 00:00:39,000
It is used to increase the memory and efficiency efficiency.

6
00:00:39,000 --> 00:00:46,000
So let's check second operations of in place element structure.

7
00:00:46,000 --> 00:00:54,000
So I just again create an array element over here, blank array.

8
00:00:55,000 --> 00:00:59,000
So I just drag and drop.

9
00:01:00,000 --> 00:01:05,000
So over here, in this case, I'm just using floating type array.

10
00:01:06,000 --> 00:01:12,000
So drag and drop this and put some values inside it.

11
00:01:12,000 --> 00:01:22,000
Let's say 23, 58, 64, 78, 96, 13, eight and 37.

12
00:01:22,000 --> 00:01:24,000
Okay, so this is my input array.

13
00:01:27,000 --> 00:01:35,000
This is my input array and I just go to the array operations and over here I'm just using split one

14
00:01:35,000 --> 00:01:36,000
dimensional array.

15
00:01:38,000 --> 00:01:41,000
Split one dimensional array.

16
00:01:41,000 --> 00:01:43,000
So just drag and drop this.

17
00:01:43,000 --> 00:01:45,000
So this is my input array for this.

18
00:01:48,000 --> 00:01:53,000
And I just create an index value from where it can split.

19
00:01:54,000 --> 00:01:56,000
So create control over here.

20
00:01:56,000 --> 00:01:58,000
This is index value.

21
00:01:58,000 --> 00:02:03,000
Now I just perform some operation on it.

22
00:02:04,000 --> 00:02:08,000
So let's say I want to square root the value.

23
00:02:09,000 --> 00:02:12,000
So this is first subset array.

24
00:02:12,000 --> 00:02:18,000
Because split array basically divide my array into two parts.

25
00:02:18,000 --> 00:02:20,000
Let's say the index value is two.

26
00:02:21,000 --> 00:02:24,000
If the index value is two over here.

27
00:02:24,000 --> 00:02:26,000
So it will split from here.

28
00:02:26,000 --> 00:02:32,000
So first subset array contains 23 and 58 and second will contain rest.

29
00:02:33,000 --> 00:02:33,000
Okay.

30
00:02:33,000 --> 00:02:43,000
So let's say it is three and second operation performed is, let's say, square.

31
00:02:46,000 --> 00:02:51,000
Now the second I just use insert into array.

32
00:02:52,000 --> 00:02:57,000
So this is my new element.

33
00:02:58,000 --> 00:03:00,000
And over here, this is my indexing.

34
00:03:04,000 --> 00:03:07,000
This is my indexing and this is my array.

35
00:03:11,000 --> 00:03:13,000
And this is my output.

36
00:03:15,000 --> 00:03:17,000
So let's check the output.

37
00:03:24,000 --> 00:03:37,000
So when you hit on run button, as you see 64 square root, 858 square root 7.6, 23 square root 4.7,

38
00:03:37,000 --> 00:03:42,000
and then it is squaring all the values eight into 864.

39
00:03:42,000 --> 00:03:52,000
So if you want to replace this part, this part you can use in place element structure.

40
00:03:52,000 --> 00:03:54,000
So just drag and drop.

41
00:03:55,000 --> 00:04:00,000
Go to the add array split and replace subset.

42
00:04:00,000 --> 00:04:08,000
So as you see over here, I just got connect input.

43
00:04:10,000 --> 00:04:11,000
Over here.

44
00:04:11,000 --> 00:04:12,000
This is my length.

45
00:04:13,000 --> 00:04:15,000
Or you can say indexing value.

46
00:04:16,000 --> 00:04:19,000
I just use these two operations.

47
00:04:19,000 --> 00:04:21,000
So just drag and drop.

48
00:04:23,000 --> 00:04:24,000
So this is the first part.

49
00:04:24,000 --> 00:04:26,000
This is the second part.

50
00:04:27,000 --> 00:04:28,000
Just connect this.

51
00:04:31,000 --> 00:04:34,000
And over here you got the output.

52
00:04:36,000 --> 00:04:43,000
So the output array and the second one, output two should be same.

53
00:04:45,000 --> 00:04:46,000
Let's check.

54
00:04:47,000 --> 00:04:53,000
So when you hit on run button, as you see the output is same.

55
00:04:53,000 --> 00:04:57,000
So this will work as same this.

56
00:04:57,000 --> 00:05:05,000
So in this case you are just reducing the node border.

57
00:05:05,000 --> 00:05:14,000
It will this will contain less memory and more efficient as compared to the traditional programming

58
00:05:14,000 --> 00:05:15,000
in LabVIEW.

59
00:05:15,000 --> 00:05:27,000
So this is how you can work with split and index array operations in LabVIEW in in-place structure.

60
00:05:27,000 --> 00:05:35,000
If you want to go for multiple operations, let's say again add on more operations.

61
00:05:35,000 --> 00:05:38,000
So let's say this is my input.

62
00:05:38,000 --> 00:05:49,000
And again, over here I just want to perform operations from another value.

63
00:05:51,000 --> 00:05:54,000
Let's say I want to work from fifth indexing.

64
00:05:54,000 --> 00:05:58,000
So this is zero one, two, three, four, five.

65
00:05:58,000 --> 00:06:09,000
So this one is my first one and 13, eight and 1337 is my second one array.

66
00:06:09,000 --> 00:06:13,000
So I just perform another operation over here.

67
00:06:13,000 --> 00:06:18,000
Let's say I want to increment first one and decrement second one.

68
00:06:28,000 --> 00:06:31,000
And over here, this is the output.

69
00:06:39,000 --> 00:06:40,000
This is my output three.

70
00:06:46,000 --> 00:06:47,000
So let's check.

71
00:06:47,000 --> 00:06:56,000
So the output should be 24, 59, 65, 79, 97, 14, nine and 38.

72
00:07:00,000 --> 00:07:01,000
As you see.

73
00:07:03,000 --> 00:07:06,000
So first one is increasing and second one is decreasing.

74
00:07:06,000 --> 00:07:12,000
So 13 becomes 12, eight becomes seven, and 37 become 36.

75
00:07:12,000 --> 00:07:14,000
It is my mistake.

76
00:07:14,000 --> 00:07:16,000
I am just increasing both the values.

77
00:07:16,000 --> 00:07:20,000
But the operation says first one is increasing and second one is decreasing.

78
00:07:20,000 --> 00:07:28,000
So this is how you can work with multiple operations in in place array in place structure in LabVIEW.

79
00:07:29,000 --> 00:07:31,000
So thank you for today.

