WEBVTT

00:00.150 --> 00:04.680
Let us trade one understand how we use our different function that we discuss rate, so we declared

00:04.680 --> 00:09.500
NSD, which is of type Unsane, OK, and having a say is a full right.

00:09.870 --> 00:12.830
So we initialize it to one zero zero zero.

00:12.840 --> 00:14.820
So this is equal to it, right?

00:14.840 --> 00:19.770
Similarly, we declared an entity which is of standard and this logic or disco vector type, right?

00:19.770 --> 00:21.770
And this is having a value of food, right?

00:21.780 --> 00:23.160
So we initialize it to a halt.

00:23.190 --> 00:29.190
We also declared one variable, which is of integer type rate, so we utilize a range from zero to 100

00:29.190 --> 00:31.140
and we initialized it to 56, right?

00:31.470 --> 00:36.120
So when we say 56 and minimum be required, a six bit variable rate.

00:36.420 --> 00:41.130
This is it's a bit variable to hold this evaluator to these to six 64.

00:41.130 --> 00:45.520
So this is within this range of 50 to 56 is within that range.

00:45.540 --> 00:52.740
So we required a variable of at least say, six bit when we convert from integer to one say right now

00:52.740 --> 00:53.110
here.

00:53.130 --> 00:59.960
If you could see we declare the result right now, we want to convert from unsigned to standard underscore

00:59.970 --> 01:01.260
logic on this correct right.

01:01.260 --> 01:04.430
So we need to make sure that the size that we have, right?

01:04.440 --> 01:06.450
So here we have a size of Folbigg.

01:06.660 --> 01:09.690
So this should also be off size for bitrate.

01:09.690 --> 01:10.730
So remember this thing.

01:10.740 --> 01:16.380
And when we consider the converting standard and the school logic on the score vector to an unseen rate.

01:16.390 --> 01:21.090
So since this, I would say it's a whole bit so Unsane should also have a size of a bitrate.

01:21.090 --> 01:22.650
So that is what we did over here.

01:23.070 --> 01:28.560
And when we consider deciding to rate, so we initialize it to a value of fifty six right now.

01:28.560 --> 01:35.670
In fact, when we consider the range OK and we have specified some range from zero to 100, so we need

01:35.670 --> 01:41.640
to make sure that the maximum value that we specified in the range so our variable must be capable of

01:41.640 --> 01:42.380
handling it right.

01:42.390 --> 01:45.210
So here we have a maximum value of 100, right?

01:45.450 --> 01:52.140
So we need to have a variable that is capable of holding at least that rate.

01:52.150 --> 01:57.810
So if you calculate to rise to seven, so that is one, 28 and 100 is below that, right?

01:57.810 --> 01:59.580
So we need to declare the variable.

01:59.880 --> 02:00.270
OK.

02:00.420 --> 02:02.610
That should be of use at least seven.

02:02.610 --> 02:08.460
But if you want to store the Unsane value of this integer variable rate.

02:08.460 --> 02:14.460
So for that reason, we have a result three, which is of Unsane type and we declared it to be of,

02:14.460 --> 02:16.020
say, seven, right?

02:16.170 --> 02:20.730
We'll also be doing one more conversion that is from one same to integer right now.

02:20.730 --> 02:26.670
Here we could specify the range, but we are considering the maximum size that this study took great.

02:27.180 --> 02:29.080
So the first conversion rate?

02:29.100 --> 02:31.950
So here we have the variable of standard and a score.

02:31.950 --> 02:32.850
Logical disconnect.

02:32.910 --> 02:35.850
So we need to convert from an S. to this type, right?

02:36.120 --> 02:39.630
So we just need to add standard and the score logic on the score vector.

02:39.870 --> 02:47.100
And then we need to specify an unsigned variable, which is SD de S. So this is how you convert from

02:47.250 --> 02:50.670
the unsigned to standard and disco logic and disco vector.

02:50.670 --> 02:56.340
Similarly result, we will be holding the result of conversion of standard and disco logic or disco

02:56.340 --> 02:57.960
vector to an unsafe rate.

02:58.200 --> 03:03.930
So we just need to add an unsane in the front of the variable and dog will be L, though, which is

03:03.930 --> 03:11.490
wholly the standard and disco logic and disco vector value right now to convert from integer to the

03:11.490 --> 03:12.090
unsay.

03:12.120 --> 03:14.040
OK, so this is a variable.

03:14.100 --> 03:16.500
This will serve as an argument to our function.

03:16.800 --> 03:17.160
OK.

03:17.340 --> 03:20.640
And we want to convert it into an unsafe so result.

03:20.650 --> 03:21.060
Three.

03:21.090 --> 03:21.480
OK.

03:21.510 --> 03:22.380
To one S..

03:22.590 --> 03:27.330
And then the variable which is having an integer value is indent right?

03:27.330 --> 03:31.020
And the size of our variable is seven.

03:31.210 --> 03:37.650
So we just need to add an argument as well rate similarly to convert from unsigned to integer.

03:37.890 --> 03:43.520
So you just need to add two integer and you need to pass the Unsane number as an argument.

03:43.710 --> 03:49.140
So sometime if you want to change the size of a variable rate and this works specifically with, then

03:49.140 --> 03:54.020
sign an unsigned type only right to this one, be working with the central disco logic.

03:54.030 --> 03:57.690
They need to assume you have an unchanged of size four bitrate.

03:57.700 --> 04:00.330
So here we have an unsigned of size phobic.

04:00.630 --> 04:05.350
Now we want to to work or we want to convert this to a favorite great.

04:05.370 --> 04:07.890
So let it just declared one variable signal.

04:08.790 --> 04:09.120
OK.

04:09.360 --> 04:13.650
This will be Richard Y and say, OK.

04:14.190 --> 04:19.740
And then this will be like, This is you five down to zero, right?

04:19.740 --> 04:25.980
So this is having a size of six fit right and are all additional variable is having a size of full bitrate.

04:25.980 --> 04:30.350
So to convert or to change the size of an unseen, insane iterate rate.

04:30.360 --> 04:33.170
So we have a function referred to as a resize rate.

04:33.170 --> 04:36.780
So how we do a conversion is so reserved.

04:37.080 --> 04:41.250
Five will be equal to rate, so research y will be close to.

04:41.460 --> 04:43.710
We just need to use resize size.

04:44.190 --> 04:44.580
OK.

04:45.090 --> 04:51.560
And then the first argument for it will be the variable, which you want to say three.

04:51.600 --> 04:54.760
So in this case, we want to say this data, right?

04:54.780 --> 04:59.260
So we'll just be adding in this data and then you need to specify the size.

04:59.940 --> 05:05.910
So we want to convert it into six big crates of fly down down to zero is basically six feet, so you

05:05.910 --> 05:11.940
just need to add an argument at the size that you want to do days of space.

05:12.910 --> 05:19.600
Phobic and by utilizing a rhesus function, right, so you could convert this to sixth grade, so this

05:19.600 --> 05:22.150
is something very handy and useful, right?

05:22.150 --> 05:28.000
So let it just go ahead and see you are caught and try to perform a simulation, right?

05:28.000 --> 05:28.870
So will go ahead.

05:29.330 --> 05:34.090
Will lose an existing simulation and in the form of behavior simulation.

05:34.240 --> 05:39.520
OK, so what I'll do is I'll just be selecting all the variable and change the relics to one saying

05:39.520 --> 05:44.460
this right now, you will see SDR to OK is having a value of it.

05:44.710 --> 05:47.760
So the result one is holding it and saying, Well, you right?

05:47.770 --> 05:54.160
So if you can see so SD days on scene and result when restoring the standard underscore logic and this

05:54.160 --> 05:59.440
corrective surgery to this to lose our matching right, then a data.

05:59.720 --> 06:05.260
OK, so where data is holding a standard underscore logic on the score vector and result two is holding

06:05.260 --> 06:07.010
its own saying equal and greater rate.

06:07.030 --> 06:12.160
So here we have a value of four for and data, and the other two is also having a value of four, right?

06:12.520 --> 06:14.830
The next one that we have is indent.

06:14.890 --> 06:15.250
OK.

06:15.520 --> 06:22.620
And Result three is holding its equivalent Unsane value ratio and then have a value of 56, a result

06:22.630 --> 06:25.510
range also having a value 56.

06:25.750 --> 06:26.470
This makes it.

06:26.800 --> 06:36.640
And if you consider reserve for bogey, so that is basically holding an equivalent of this unseen rate.

06:36.640 --> 06:41.430
So this untamed value is so it is holding the result off.

06:41.440 --> 06:49.030
If you can see reserved for we have converted SD to OK to an integer, so SD data is having a value

06:49.030 --> 06:49.450
of eight.

06:49.870 --> 06:54.160
So this is also having a value of it right now, and if you could see it is verify.

06:54.190 --> 06:59.080
So here we converted are Fobbit to six eight 10.

06:59.080 --> 07:01.090
Again, it have a value of eight right now.

07:01.090 --> 07:03.730
Let's assume that you choose the let's say so.

07:03.730 --> 07:09.520
When we are converting from an integer to an unsigned, you have chosen the less size rate.

07:09.550 --> 07:15.310
So here we can guess we required a minimum size of six, but there is a dummy declare it to be only

07:15.310 --> 07:16.110
full bitrate.

07:16.120 --> 07:17.710
So when we consider.

07:17.920 --> 07:22.960
So we change this to forward rate the three down to zero, let it just go ahead and try to perform a

07:22.960 --> 07:26.240
reload simulation again and try to observe to reiterate.

07:26.260 --> 07:33.820
So here we have chosen the size, which is less than the maximum size that we are expecting for an integer.

07:33.950 --> 07:38.740
So if you do that, you will be finding that RSI is do not match.

07:38.770 --> 07:41.530
OK, left lefty has four element and writer.

07:41.530 --> 07:48.280
He has four element that is the expected size is seven, but we have specified only a size of four bitrate.

07:48.580 --> 07:50.140
And if you all do the research.

07:50.560 --> 07:56.140
OK, since our core consists of an error, OK, you won't be able to find anything right.

07:56.380 --> 08:04.840
So it is mandatory that when you convert from Unsane to Vector or Unsane two integer, you correctly

08:05.170 --> 08:07.100
match the size rate.

08:07.120 --> 08:14.140
So if you incorrectly specify the size you getting an error, you will you won't be simply allowed to

08:14.140 --> 08:14.920
process further.

08:15.160 --> 08:20.950
And since we usually strongly type language, it won't be automatically truncating IRIS or it will be

08:21.250 --> 08:22.360
doing an error rate.
