WEBVTT

00:00.120 --> 00:06.210
If you just go through the numeric standard package, you'll be finding we have a tap shift and rotate

00:06.210 --> 00:10.450
function, which include all the shift as well as rotate function.

00:10.470 --> 00:10.680
Right.

00:10.680 --> 00:16.590
So first, when we have the shift left, OK, which have an argument, as I'm saying, and it basically

00:16.590 --> 00:23.550
returns on, say, right now I'm saying leadership is declaring and I Atripla Numeric Standard Library,

00:23.620 --> 00:23.900
right?

00:23.910 --> 00:27.320
So here we need to use an unsigned today rate.

00:27.330 --> 00:31.800
So in the previous example, we considered standard analytical logic.

00:32.110 --> 00:34.320
Right here we will be discussing Unsane.

00:34.320 --> 00:41.190
And whenever you are in a situation where you want to perform and conversion between this to how you

00:41.190 --> 00:43.150
handle this will be our understanding next, right?

00:43.170 --> 00:47.640
So first shift left is used to perform the logical left shift right.

00:47.640 --> 00:53.610
So whenever we specified the argument to be Unsane, that basically is the logical shift.

00:53.610 --> 00:58.650
Right to similarly shift right with an unseen argument will give us the logical right shift.

00:58.650 --> 01:05.040
Right shift left within sine argument will basically provide us an automatic shift rate again, since

01:05.040 --> 01:12.420
we already know that the shift left and whether it is logical or not metric is exactly correct, right?

01:12.420 --> 01:14.910
So you won't be finding any differences between them.

01:15.300 --> 01:24.150
But when we consider the shift to right with Sinochem, right, so this gives us the automatic right

01:24.300 --> 01:24.990
shift, right?

01:24.990 --> 01:29.190
So you could clearly see perform a shift right on the sine vector.

01:29.370 --> 01:29.730
OK.

01:30.060 --> 01:35.300
And then the vacated positions are filled with the left most element right and left.

01:35.310 --> 01:38.340
Mostly elements basically represent the sign MC rate.

01:38.520 --> 01:42.180
So this is what we refer to as an Hartmut ActionScript.

01:42.210 --> 01:47.870
This makes it so let it just go ahead and try to work with this shift, right?

01:47.880 --> 01:49.290
So we go ahead.

01:49.860 --> 01:54.300
And first thing that we declare is this is you a library, right?

01:54.300 --> 01:59.730
So we need to include a library that allow us to work with all those operating right.

01:59.740 --> 02:04.600
So we like to use AI Tripoli Dot Numeric.

02:05.220 --> 02:06.400
OK, standard.

02:06.530 --> 02:08.160
All right, this makes sense.

02:08.640 --> 02:15.210
So this is how we include the numeric standard library, which consists of all the shift function.

02:15.540 --> 02:19.120
And along with that declaration, four are unsigned unsigned.

02:19.590 --> 02:21.240
Right now, we proceed with the signal.

02:22.320 --> 02:22.710
OK?

02:23.250 --> 02:26.550
We declare resumed in Rachel, which represent.

02:26.790 --> 02:29.930
So which basically represent the original data.

02:29.940 --> 02:32.030
OK, before a shift operation, right?

02:32.820 --> 02:35.430
We're now we declared an on type right.

02:35.640 --> 02:38.970
Again, similar to a standard underscore logic underscore vector.

02:39.180 --> 02:46.430
We could specify the multiple, but by utilizing three down to zero or 0.3, right.

02:46.440 --> 02:49.340
So I'm saying, let's assume that we work on forward.

02:49.350 --> 02:50.790
So three down to zero.

02:50.970 --> 02:53.900
OK, and we'll be initializing this tool.

02:53.980 --> 02:56.220
This is in one zero one zero.

02:56.370 --> 02:56.720
Right.

02:56.730 --> 03:00.000
So this complete the declaration of a sickness temp, right?

03:00.000 --> 03:07.200
And then we declared the two move signal right to one will be holding the result of a right logical

03:07.200 --> 03:11.250
shift, and they will be holding a result of left logical shift right.

03:11.250 --> 03:14.560
So the left logic shift?

03:14.580 --> 03:14.920
OK.

03:14.940 --> 03:18.270
This should again be when we work with Unsane D Drive.

03:18.270 --> 03:26.580
So this should also be an Unsane way because then if we add an argument, OK, so if we add an argument

03:26.580 --> 03:33.270
as an unsane visited in an unsafe rate to the variable which hold the result must also be of an unsigned.

03:33.460 --> 03:36.010
So here also we are on st.

03:36.180 --> 03:36.540
OK.

03:36.630 --> 03:38.490
Three down to zero.

03:38.610 --> 03:40.710
OK, and let it just initialize this too.

03:41.190 --> 03:43.110
All right, this makes sense.

03:44.670 --> 03:45.030
OK.

03:45.420 --> 03:51.750
Next one is let's just declare one more variable, which will be holding the result of logical right

03:51.750 --> 03:52.320
shift, right?

03:52.680 --> 03:54.420
So logical, right?

03:54.600 --> 03:56.210
And shift, OK.

03:56.520 --> 04:05.670
Again, this would be off day one saying OK, saves would be three down to zero, and then we will be

04:05.760 --> 04:07.700
adding again for zero three.

04:07.950 --> 04:09.030
So this makes sense.

04:09.330 --> 04:12.930
So now we proceed right when we consider the data flow more like states.

04:12.930 --> 04:18.770
So how we assign your value to signal or a book is by utilizing the signal assignment operator, right?

04:18.790 --> 04:25.590
So they just use the left logical shift right, then the signal assignment operator, right?

04:26.280 --> 04:28.040
Then we use the function rate.

04:28.050 --> 04:31.110
The function for us is to perform the shift left.

04:31.140 --> 04:34.180
We will just be invoking shift left right.

04:34.200 --> 04:36.910
Now this have two argument, right?

04:36.910 --> 04:45.180
So first one is the value OK, or the variable whose value we want to shift and then the number of big

04:45.180 --> 04:46.920
positions that we want to shift, right?

04:46.920 --> 04:52.150
So let's assume we want to perform the left and right shift by a factor of one right.

04:52.380 --> 04:55.290
So we want to shift by a single bit position, right?

04:55.290 --> 04:59.910
So we add shift left the variable whose value we want to shift.

04:59.990 --> 05:04.070
Is Dean right, so this represent the data source for us, which is Dean.

05:04.310 --> 05:08.270
And then we want to perform the shift by a single big party.

05:08.750 --> 05:12.590
So this is how we use shift left similarly right.

05:12.860 --> 05:14.390
OK, so logical, right?

05:14.390 --> 05:14.750
Shift.

05:15.710 --> 05:21.620
OK, and this again, we will be utilizing the signal assignment operator.

05:21.680 --> 05:23.660
OK, so the function is shift.

05:24.230 --> 05:25.640
Then we have all right again.

05:25.640 --> 05:29.870
We need to specify the source of our data, which is Dean, OK?

05:29.870 --> 05:33.110
And then there are a number of additions that we want to shift, right?

05:33.120 --> 05:34.370
So this completes the call.

05:34.700 --> 05:41.420
Now what we going to do, it will just be receiving a call and we first perform simulation of this right

05:41.420 --> 05:45.830
and then later on, we will be working with an automatic right.

05:45.830 --> 05:53.210
So let's just go ahead and try to perform simulation rates or we'll go ahead and perform a behavioral

05:53.210 --> 05:53.840
simulation.

05:55.070 --> 05:56.230
Now if you also.

05:56.280 --> 05:56.600
Right.

05:56.600 --> 06:01.700
So let me just go ahead and change the radius of all the bus to the binary.

06:02.060 --> 06:04.530
OK, so relics and binary.

06:04.580 --> 06:09.560
So right click on a bus, OK, then change the rates to a binary.

06:11.710 --> 06:14.590
Now, if you observe, right, so if I just zoom in a bit.

06:14.990 --> 06:19.400
So we have an additional canteen in our register as one zero one zero.

06:19.420 --> 06:19.720
Right.

06:19.720 --> 06:23.050
So left, right or left shift will be left.

06:23.050 --> 06:28.990
Shift will be adding the 08 and MSP saved rate.

06:28.990 --> 06:31.700
So you could clearly see this one zero one.

06:32.710 --> 06:33.030
OK.

06:33.250 --> 06:40.180
So when we consider the left shift right, then that gives zero will be added at analyst bit rate and

06:40.180 --> 06:44.710
whatever we have it and MSP will be simply doing all right.

06:44.710 --> 06:50.980
So we have one at the MSB, so that will be thrown out again and then zero one zero will be shifted

06:50.980 --> 06:52.000
in this direction, right?

06:52.000 --> 06:54.310
So you can see we have zero one zero.

06:54.550 --> 06:54.850
OK.

06:54.850 --> 06:58.240
And then we have added zero and it's be great.

06:58.240 --> 06:59.410
So this is our left shift.

06:59.920 --> 07:02.200
And when we consider, all right, shift, right?

07:02.440 --> 07:07.720
So in this case, the value that we have on any list, we will be thrown out, right?

07:07.730 --> 07:12.170
So this zero will be one and one zero one will be shifted in the right direction, right?

07:12.190 --> 07:16.660
So we have one zero one over here and we add zero right and it must be said great.

07:16.670 --> 07:19.210
So this is working as expected right now.

07:19.210 --> 07:22.450
We proceed and first load the simulation right.

07:23.770 --> 07:30.450
Then we proceed to declare now if you remember, OK, so our package.

07:30.460 --> 07:36.670
So just as that, whenever we want to perform an automatic shift, OK, so the data that we need to

07:36.670 --> 07:41.830
feed as an argument should be sine and the variable that will be holding the result should also be assigned

07:41.830 --> 07:42.130
right.

07:42.400 --> 07:48.310
So we could not simply work with this data because we declare it to be the Unsane day right now.

07:48.310 --> 07:52.250
What we're going to do is we declare signal right to be in to.

07:52.870 --> 07:53.230
OK.

07:53.440 --> 07:55.480
This will be all the same rate.

07:55.480 --> 07:58.570
Again, we need to specify the size.

07:58.960 --> 07:59.320
OK.

07:59.590 --> 08:03.200
And then let it just add some random number, right?

08:03.220 --> 08:04.450
Two one zero one zero.

08:05.050 --> 08:12.520
Then we require two variables which will be holding the value of the automatic left and right.

08:12.520 --> 08:18.070
Shift rates already just declared this to be automatic left shift right.

08:18.430 --> 08:20.410
They should also be off sine die right.

08:20.410 --> 08:24.190
So saying again side will be three down to zero.

08:24.340 --> 08:24.700
OK.

08:25.180 --> 08:27.190
And let's just initialize it to.

08:27.190 --> 08:28.240
All right.

08:29.320 --> 08:35.530
Similarly, we required one more variable, which will be touring the result of our automatic right

08:35.530 --> 08:35.850
shift.

08:35.860 --> 08:36.190
OK?

08:36.670 --> 08:39.970
And again, size will be all fobbit and.

08:41.460 --> 08:44.580
We will be initiating it with you right now, we proceed.

08:44.970 --> 08:51.570
OK, so let me just use it and shift that is automatically left shift and this will be Quest two again.

08:51.570 --> 08:52.710
The operator will remain.

08:53.100 --> 08:55.050
That is Signal assignment operator.

08:55.050 --> 08:56.370
We just need to use shift.

08:56.520 --> 08:57.720
OK, again left.

08:57.900 --> 08:58.980
This will work fine.

08:59.410 --> 09:05.340
OK, so depending on the argument that you specify those specific type of shifts choosing right?

09:05.350 --> 09:13.640
So if you buy an argument as a lot Unsane, OK, in that case, the logical shift will be choosing who

09:13.650 --> 09:17.480
you are will be getting the result, which is equivalent to a logical shift.

09:17.820 --> 09:22.770
And when we specify an argument to be saying in that case, we will be getting the result, which is

09:22.770 --> 09:24.570
equivalent to an automatic shift right.

09:24.570 --> 09:25.260
So shift left.

09:25.860 --> 09:28.530
The source of data for us is Steve to.

09:28.650 --> 09:33.450
OK, and let's assume you may want to perform shift by position of what right?

09:34.500 --> 09:38.500
So this completes the code for our automatic left shift.

09:38.520 --> 09:41.110
Now we have an automatic right shift, right?

09:41.130 --> 09:42.960
This is equal to shift.

09:43.560 --> 09:46.110
OK, and then we'll be utilizing right?

09:46.290 --> 09:46.610
OK.

09:46.950 --> 09:49.290
The source of data for us, this gain do.

09:49.410 --> 09:51.140
And the number of pain.

09:51.390 --> 09:56.660
The number of positions we want to shift is again, what makes this complete the quarter?

09:56.670 --> 09:57.870
They just see output.

09:58.260 --> 10:04.680
OK, and then try to again perform a simulation right now if you observe, right?

10:04.680 --> 10:09.090
So we will just be deleting dean and logical shift rate.

10:09.090 --> 10:13.290
So we'll just be using the bus and then press the delete button, right?

10:13.290 --> 10:21.540
So this will remove the logical shift and dean from our V from you right now, we will be changing the

10:21.540 --> 10:22.410
ratings

10:24.660 --> 10:25.320
for.

10:27.690 --> 10:30.070
All the variables to a binary.

10:30.090 --> 10:36.330
Now you could see we have one zero one zero rate when we consider a left shift right, so left shift,

10:36.330 --> 10:40.800
what it will do is whatever we have, one and a bet will be simply thrown out, right?

10:40.820 --> 10:42.180
So this one will be gone.

10:42.630 --> 10:45.180
Zero one zero will be shift in the left direction.

10:45.180 --> 10:48.930
So we have a zero one zero and then we add zero at Analyst River Trade.

10:48.930 --> 10:54.210
So this is exactly similar to what we been observing in that logical left shift, right?

10:54.570 --> 10:57.300
But when we observe the right shift, right?

10:57.420 --> 10:59.600
So this zero will be thrown out, right?

10:59.610 --> 11:04.140
As usual, this is thrown up in one zero one is shifted in the right direction.

11:04.350 --> 11:09.240
And whatever sign that we have is maintaining, then it must be positioned right.

11:09.240 --> 11:12.270
So whatever recorded position that is being created?

11:12.540 --> 11:12.890
OK.

11:13.110 --> 11:19.080
As we remove the bits that will be filled by those signed, but that we have right.

11:19.080 --> 11:23.760
So you're saying it is until we have a single bracketed position because we are performing shift by

11:24.000 --> 11:24.900
a factor of one.

11:25.150 --> 11:29.650
So that will be filled with the value that we have on and saying.

11:29.670 --> 11:31.650
But in this case, it is what right?

11:33.360 --> 11:38.850
So this is how we work within logical and an automatic shift.
