WEBVTT

00:00.150 --> 00:05.490
We already discussed on how we use a logical operator, OK, with the data flow modeling state.

00:05.520 --> 00:09.470
Now we want to understand the next operator, right?

00:09.480 --> 00:15.750
Remember that the operator that we are covering over here are equally eligible for either modeling styles.

00:15.840 --> 00:22.850
So this operator that we are discussing in the data flow modeling state are not restricted only to data

00:22.860 --> 00:28.260
flow modeling state, but operator in general are eligible for all the modeling state, right?

00:28.500 --> 00:33.720
So we'll just be building up our foundation of an operator in this data flow modeling state and as we

00:33.720 --> 00:39.000
progress to other modeling state, will discuss some of an important concept related to that right?

00:39.330 --> 00:40.980
So we already have a logical operator.

00:40.980 --> 00:46.170
The next operator that we're going to discuss is shift operator, as well as the rotation of it, right?

00:46.530 --> 00:51.480
So the rest was discussed the fundamentals of shift down rotation operator.

00:51.480 --> 00:57.420
And then we proceed to discuss the ways we have in a deal to achieve it, right?

00:57.720 --> 01:02.190
So shift could be categorized into two.

01:02.910 --> 01:05.830
So it could either be a logical shift, OK?

01:06.300 --> 01:10.370
Or it could also be an automatic shift, right?

01:10.380 --> 01:16.710
So in this case, when we perform a right shift, we basically preserve the but that is the only difference

01:16.710 --> 01:19.770
that we have with an automatic ideological operation.

01:19.770 --> 01:23.400
So we'll be discussing in a word that means OK, logical.

01:23.910 --> 01:25.320
Operator OK.

01:25.330 --> 01:27.690
Could be further categorized into two.

01:27.870 --> 01:34.080
OK, so it could either be a left logical shift, OK, or it could be a radiological shift.

01:34.110 --> 01:34.410
All right.

01:34.890 --> 01:41.310
So if you consider automatic, there are also two categories rated could either be a lift automatic

01:41.310 --> 01:43.500
shift or it could be right.

01:43.680 --> 01:49.950
Automatic shift data automatically left shift and logical left shift are exactly equivalent right.

01:49.950 --> 01:56.190
So we see that they do not exist anything like automatic left shift right because both of them operating

01:56.190 --> 01:58.170
in exactly same fashion.

01:58.530 --> 02:03.950
But when we consider an automatic right and logic lights, there exists a huge difference, right?

02:03.960 --> 02:05.160
That is what we want to discuss.

02:05.170 --> 02:09.890
So first, let's just understand how a logical shift work, right?

02:09.900 --> 02:13.020
So we consider first a logical shift.

02:13.020 --> 02:16.770
OK, assume that we have a full arbitrate this, right?

02:16.770 --> 02:23.280
So this is the full bit registered that we have and the container that we have in a register is one

02:23.280 --> 02:27.480
zero zero right now if you want to perform a left shift right.

02:27.480 --> 02:32.760
So when we see a left shift, we basically add the zero in and Elizabeth little betrayed.

02:32.770 --> 02:34.850
So here we have our end gesture.

02:34.860 --> 02:42.000
So when we considered the left shift right, so left shift by this specific position, let's assume

02:42.000 --> 02:43.430
the position is one.

02:43.440 --> 02:49.290
So we basically add a single zero right single zero at 10, unless be saved right?

02:49.620 --> 02:54.730
And then you'll be noticing that since we already have a full present in our gesture.

02:54.810 --> 03:00.670
OK, so the big or the value that we have on an MSP will be automatically true.

03:00.690 --> 03:06.120
Not great because we have added a new value, which is zero at LSP.

03:06.130 --> 03:09.300
Say now when we consider the right shift.

03:09.300 --> 03:18.150
OK, so the operation is exactly opposite, so we add a zero on an MSP site and whatever we have the

03:18.150 --> 03:21.300
canteen on and this debate will be thrown out great.

03:21.780 --> 03:25.590
So this bit basically make the position where we could c, right?

03:25.590 --> 03:29.220
So those are the two logical shift operations that we have right now.

03:29.220 --> 03:37.380
What we're going to do is let it just work with one zero zero hand with the register that we have granted.

03:37.740 --> 03:42.090
Now if you want to perform the left shift, OK and the bit.

03:42.840 --> 03:46.860
So we just want to shift by one right, so left shift by one.

03:47.250 --> 03:52.410
What that will do is basically whatever we have on and it may be saying, OK, so that will be thrown

03:52.410 --> 03:52.650
out.

03:53.430 --> 03:57.660
OK, whatever we have on the next big two zero will be coming over here.

03:57.690 --> 04:00.530
OK, so now here we have zero, right?

04:00.690 --> 04:03.480
So we'll again draw a full compartment rate.

04:03.480 --> 04:05.340
So this seal will come over here.

04:05.580 --> 04:08.280
This zero will come over here.

04:08.670 --> 04:11.460
This one will come over here.

04:11.670 --> 04:20.430
And finally, when we considered the left shift, OK, we basically add zero in then l'esprit right.

04:20.650 --> 04:21.450
This makes sense.

04:22.140 --> 04:27.040
Next, if you consider this is you may want to perform shift by factor of two, right?

04:27.050 --> 04:31.170
So here again, we have that is you.

04:31.950 --> 04:34.200
This is our original value, right?

04:34.410 --> 04:37.590
And we want to perform ship by a factor of two, right?

04:38.040 --> 04:45.810
So in this case, if we have this four compartment available, right, so ship by a factor of two.

04:45.810 --> 04:49.290
So two bit for my name is beside will be thrown out, right?

04:49.290 --> 04:50.550
So this debate will be gone.

04:50.940 --> 04:52.440
This will be gone, right?

04:52.620 --> 04:55.260
And whatever we have next, that is zero.

04:55.290 --> 04:55.620
OK.

04:55.950 --> 04:59.490
That will basically come over here right on an MSP.

04:59.740 --> 05:01.300
So we have zero over here.

05:01.680 --> 05:08.920
Then we have one over here, and finally, we need to add to see if this makes sense, why we have to

05:08.920 --> 05:13.150
add two zeros because we want to perform shift by the factor of two.

05:13.160 --> 05:18.640
This is how we get the value for logical shift, right?

05:19.570 --> 05:27.310
Hey, that too in the left direction right now, if you want to perform a logical shift, OK?

05:27.820 --> 05:29.680
And that too in the right direction.

05:29.740 --> 05:37.750
OK, so ladies, you we have to register with the contained of one zero zero one right now if you want

05:37.750 --> 05:43.120
to perform a right check by a factor of one right in that case, and it is just draw four compartments

05:43.120 --> 05:44.680
where we could add the data.

05:44.980 --> 05:51.260
So when we see right shift, so whatever we have on in a list, we bet will be thrown out, right?

05:51.280 --> 05:55.240
And this basically make the place for the zero to be added on.

05:55.240 --> 05:56.230
And I misspoke, right?

05:56.620 --> 05:59.740
So here we have a zero that will be coming over here.

06:00.070 --> 06:02.230
This zero will be coming over here.

06:02.290 --> 06:07.900
This one will be coming over here and this bit will be filled with seat, right?

06:07.960 --> 06:10.340
This is how we perform the right.

06:11.170 --> 06:19.720
We basically throw out whatever bit we have on the LSP side, OK, and then we add the seat right?

06:19.720 --> 06:20.740
And it must be said great.

06:20.740 --> 06:25.010
So this is how we perform the logical shift.

06:25.090 --> 06:25.430
OK.

06:25.720 --> 06:27.480
No advantage with logical shift.

06:27.480 --> 06:33.730
This, for example, let's assume we do not overflow the size of where is this right?

06:33.730 --> 06:40.160
So if you have zero zero one zero right, so this is the container now if you perform the left shift

06:40.240 --> 06:40.550
right.

06:40.550 --> 06:47.560
So if you perform the left shift, so contained will be the zero will be thrown out right.

06:47.560 --> 06:52.840
And then we have this zero right and then maybe this one right and next.

06:52.840 --> 06:54.160
And then this year, right?

06:54.160 --> 06:55.420
And finally, we have been zero.

06:55.690 --> 07:02.950
Now, if you can guess, the equivalent decimal value for this is to right when we both left shift two,

07:02.950 --> 07:06.970
this is equivalent to four right to be able to multiply by two.

07:07.240 --> 07:10.780
So this help us to implement a multiplier.

07:10.810 --> 07:13.510
OK, so depending on the shift.

07:15.930 --> 07:21.990
We perform great, so, for example, and is the number of ship that we want to perform, right?

07:21.990 --> 07:23.010
In this case, it is one.

07:23.400 --> 07:26.820
So whatever value the original value that we have.

07:26.940 --> 07:32.520
So after the shifting operation, we'll be getting the value, which is multiplied by two, restrain

07:32.520 --> 07:36.020
red and represent the number of ships that we perform, right?

07:36.060 --> 07:37.800
So if you want to perform ship, buy one.

07:38.100 --> 07:39.390
So this end will be one.

07:39.410 --> 07:42.300
And in that case, the original value will be multiplied by two.

07:42.690 --> 07:45.840
Similarly, if you consider all right, shift trade.

07:46.170 --> 07:53.530
So in this case, what will happen is so this bit, this bit will be thrown out, right?

07:53.670 --> 07:56.610
We again have four compartments, so this gate will be thrown out.

07:56.940 --> 07:59.550
And then this one will be coming at LSP.

07:59.550 --> 08:04.350
Then we have zero zero and we'll add zero when we consider right ship, right?

08:04.810 --> 08:09.150
If you calculate the equal and value for this register, so it is one.

08:09.180 --> 08:11.460
So you could clearly guess the original value is two.

08:11.700 --> 08:17.100
And when we perform right ship two, we get basically original value divided by two race to end very

08:17.100 --> 08:19.510
and represent the number of ship that we perform, right?

08:19.530 --> 08:24.150
In this case, we perform shift by a single bit position.

08:24.210 --> 08:29.950
OK, in that case, we will be getting additional value by two to one, which is dividing by two to

08:29.960 --> 08:32.910
so to divide by two, it'll basically result into one, right?

08:32.910 --> 08:36.210
So we could easily perform this computation.

08:36.270 --> 08:36.630
OK.

08:36.750 --> 08:42.540
With the logical shift, right, the next one that we have is an automatic shift, right?

08:42.750 --> 08:47.220
So this can again be divided into two categories so left.

08:47.370 --> 08:48.480
And we have.

08:49.320 --> 08:49.950
Right, right.

08:49.950 --> 08:50.520
So left.

08:51.780 --> 08:58.440
Will operate exactly similar to what we discussed in a logical left shift, or guess who will not be

08:58.440 --> 08:59.020
discussing it?

08:59.040 --> 09:05.310
This will be exactly equal to what we discuss with the logical left right when we consider right, for

09:05.310 --> 09:07.590
example, the latest, as you will.

09:07.890 --> 09:11.110
So one see to see it right.

09:11.160 --> 09:16.350
So automatically, if this predominant view delays, when we work with the same number 18, it may be

09:16.350 --> 09:18.690
better present the same bitrate.

09:18.690 --> 09:21.450
So this is the same bit that we have for a number.

09:21.450 --> 09:24.540
And this basically represented the No is the negative number, right?

09:24.870 --> 09:25.980
When by design.

09:26.280 --> 09:30.500
So when we perform right shift, let's assume we perform a shift by a factor of one.

09:30.810 --> 09:33.240
So we again have a four compartment, right?

09:33.600 --> 09:40.290
So this weight will be thrown out, OK, to make the place for one bit rate.

09:40.290 --> 09:41.580
So we will be going.

09:41.820 --> 09:42.540
This will be going.

09:42.870 --> 09:45.490
This zero will be coming over here.

09:45.540 --> 09:47.670
This zero will be coming over here.

09:48.060 --> 09:49.950
This one will be coming over here.

09:50.190 --> 09:57.850
But now when we consider the automatic shift, OK, so it maintains the sine bitrate.

09:57.850 --> 10:00.600
So whatever value that we have on hand is beside.

10:00.650 --> 10:02.100
OK, so that represent the same.

10:02.370 --> 10:06.810
So we maintain the same value at the same rate.

10:06.840 --> 10:13.070
So here we do not have been zero as we are doing with the logical automatic and logical right chip.

10:13.100 --> 10:17.640
OK, but in a case of an automatic right shift, we preserve the same bitrate.

10:17.640 --> 10:23.790
So this will be as it is at whatever value that we have over here will be shifted on the right side,

10:23.790 --> 10:24.030
right?

10:24.030 --> 10:28.830
So to consider one more example, let's assume the same value, right?

10:28.830 --> 10:35.190
We have one zero zero one against the same value, but in this case, the factor of shift is to right.

10:35.250 --> 10:39.540
We need to perform shift by the double digits rate.

10:39.540 --> 10:42.180
So we again draw for compartment.

10:43.170 --> 10:43.470
OK.

10:43.710 --> 10:44.790
Again, same with this one.

10:45.120 --> 10:47.760
So this debate will be gone, right?

10:47.760 --> 10:50.430
So this zero will be coming over here.

10:50.460 --> 10:53.110
This one will be coming over here.

10:53.430 --> 10:54.750
Then again.

10:54.900 --> 10:59.880
OK, so we will whatever value that we have on n same, but will be again.

10:59.880 --> 11:02.850
Our data were here and here.

11:03.390 --> 11:03.730
Right.

11:04.380 --> 11:12.090
So whatever we have on assignment, OK, we will be adding that value on the bits that are left when

11:12.090 --> 11:14.680
we remove the bit, for example, distributor input.

11:14.970 --> 11:17.190
OK, so we have this stupid right.

11:17.190 --> 11:23.340
So after we perform shifting right, this two will be shifted right here, right?

11:23.520 --> 11:28.710
And whatever bit left there, we add a sign which greatly in this case you are saying which is one.

11:28.980 --> 11:32.470
OK, so would the position will be filled with the same bit value?

11:32.530 --> 11:35.940
That is what now if we're going to do that, if we have.

11:37.110 --> 11:39.000
OK, zero on insane, right?

11:39.030 --> 11:39.300
Right.

11:39.300 --> 11:41.070
So zero one one zero.

11:41.070 --> 11:42.690
Let's assume this is the value right?

11:43.230 --> 11:45.990
And we perform shift by a factor of two.

11:46.200 --> 11:46.500
Right?

11:46.680 --> 11:49.410
So again, for a compartment we have.

11:49.830 --> 11:50.160
Right.

11:50.250 --> 11:54.520
So this tool will be gone right because we want to perform well, right?

11:54.520 --> 11:55.860
Shift right to this two bit.

11:55.860 --> 11:59.950
This two values will be coming out zero one, whatever value that we have.

11:59.970 --> 12:01.970
So this one will be coming over here.

12:01.980 --> 12:03.660
This zero will be coming over here.

12:03.960 --> 12:09.840
And then the two positions that are left will be filled with whatever value that we have on the same

12:09.840 --> 12:10.260
bit rate.

12:10.260 --> 12:11.760
So here we have a value of zero.

12:12.090 --> 12:14.700
So this two position will be filled with the Z, right?

12:14.700 --> 12:17.600
So this is how we perform automatically, right?

12:17.710 --> 12:18.050
Right.

12:18.120 --> 12:23.070
So these are the four operation that we frequently utilize an automatic operation.

12:23.070 --> 12:25.380
We predominantly work with the same number, right?

12:25.710 --> 12:32.010
And when we discuss the function that are used to specify which type of shift that we are utilizing,

12:32.010 --> 12:37.310
we'll get to the are differentiated on the basis of the data rate that we are specifying.

12:37.320 --> 12:42.880
So when we specify Unsane, so that basically give us the logical shift and then we can the same to

12:43.110 --> 12:48.160
be automatically give us the ultimate ActionScript.

12:49.080 --> 12:56.370
So just to summarize, we have two type of shift, OK, that will either be a logical shift, or it

12:56.370 --> 12:58.890
could either be an automatic

13:01.440 --> 13:02.100
shift, right?

13:02.310 --> 13:07.500
So logic, a shift can be further divided into two could either be right or left.

13:07.560 --> 13:15.120
Similarly, automatic could be divided into right and left right in this case, when we consider a logical

13:15.120 --> 13:15.540
right.

13:15.690 --> 13:18.160
OK, so when we consider logical, right?

13:18.240 --> 13:20.310
So we had zero.

13:20.430 --> 13:24.410
OK, two and pivot again, we removed a lisp, right?

13:24.420 --> 13:29.010
So this is how we perform the right shift and when we consider the logical left right.

13:29.250 --> 13:35.070
So we are zero from an Elizabeth site and we remove the bit from an image we say, right?

13:35.070 --> 13:37.710
So this is how we make a prediction for zero to be added.

13:37.840 --> 13:45.060
And unless we pretend when we consider are automatic so left or exactly operate as we have ideological

13:45.060 --> 13:45.370
left.

13:45.390 --> 13:49.050
OK, so this is exactly similar we will be having.

13:50.580 --> 13:55.200
Who will be adding the euro to analyze the site and reviewing out the mystery bit?

13:55.800 --> 13:59.560
But when we consider the right shift, so we will be maintaining the same bit.

13:59.560 --> 14:05.630
So even though the shift operation will be exactly grueling, that is the bit that we have wanted in

14:05.640 --> 14:06.690
this bill will be removed.

14:06.900 --> 14:14.850
But whatever value that we have, an insane bit is used to feel the Viking position, right, so it

14:14.850 --> 14:16.290
will not be filled with a zero.

14:16.500 --> 14:23.490
Instead, it will be filled with whatever the value that we have for sign bitrate that is the MSP better

14:23.490 --> 14:24.500
off register.

14:24.540 --> 14:31.080
So remember this fundamental because these are useful as we progress to use the functions that are available

14:31.080 --> 14:32.610
to perform shift operation in.
