Let us trade one understand how we use our different function that we discuss rate, so we declared
NSD, which is of type Unsane, OK, and having a say is a full right.
So we initialize it to one zero zero zero.
So this is equal to it, right?
Similarly, we declared an entity which is of standard and this logic or disco vector type, right?
And this is having a value of food, right?
So we initialize it to a halt.
We also declared one variable, which is of integer type rate, so we utilize a range from zero to 100
and we initialized it to 56, right?
So when we say 56 and minimum be required, a six bit variable rate.
This is it's a bit variable to hold this evaluator to these to six 64.
So this is within this range of 50 to 56 is within that range.
So we required a variable of at least say, six bit when we convert from integer to one say right now
here.
If you could see we declare the result right now, we want to convert from unsigned to standard underscore
logic on this correct right.
So we need to make sure that the size that we have, right?
So here we have a size of Folbigg.
So this should also be off size for bitrate.
So remember this thing.
And when we consider the converting standard and the school logic on the score vector to an unseen rate.
So since this, I would say it's a whole bit so Unsane should also have a size of a bitrate.
So that is what we did over here.
And when we consider deciding to rate, so we initialize it to a value of fifty six right now.
In fact, when we consider the range OK and we have specified some range from zero to 100, so we need
to make sure that the maximum value that we specified in the range so our variable must be capable of
handling it right.
So here we have a maximum value of 100, right?
So we need to have a variable that is capable of holding at least that rate.
So if you calculate to rise to seven, so that is one, 28 and 100 is below that, right?
So we need to declare the variable.
OK.
That should be of use at least seven.
But if you want to store the Unsane value of this integer variable rate.
So for that reason, we have a result three, which is of Unsane type and we declared it to be of,
say, seven, right?
We'll also be doing one more conversion that is from one same to integer right now.
Here we could specify the range, but we are considering the maximum size that this study took great.
So the first conversion rate?
So here we have the variable of standard and a score.
Logical disconnect.
So we need to convert from an S. to this type, right?
So we just need to add standard and the score logic on the score vector.
And then we need to specify an unsigned variable, which is SD de S. So this is how you convert from
the unsigned to standard and disco logic and disco vector.
Similarly result, we will be holding the result of conversion of standard and disco logic or disco
vector to an unsafe rate.
So we just need to add an unsane in the front of the variable and dog will be L, though, which is
wholly the standard and disco logic and disco vector value right now to convert from integer to the
unsay.
OK, so this is a variable.
This will serve as an argument to our function.
OK.
And we want to convert it into an unsafe so result.
Three.
OK.
To one S..
And then the variable which is having an integer value is indent right?
And the size of our variable is seven.
So we just need to add an argument as well rate similarly to convert from unsigned to integer.
So you just need to add two integer and you need to pass the Unsane number as an argument.
So sometime if you want to change the size of a variable rate and this works specifically with, then
sign an unsigned type only right to this one, be working with the central disco logic.
They need to assume you have an unchanged of size four bitrate.
So here we have an unsigned of size phobic.
Now we want to to work or we want to convert this to a favorite great.
So let it just declared one variable signal.
OK.
This will be Richard Y and say, OK.
And then this will be like, This is you five down to zero, right?
So this is having a size of six fit right and are all additional variable is having a size of full bitrate.
So to convert or to change the size of an unseen, insane iterate rate.
So we have a function referred to as a resize rate.
So how we do a conversion is so reserved.
Five will be equal to rate, so research y will be close to.
We just need to use resize size.
OK.
And then the first argument for it will be the variable, which you want to say three.
So in this case, we want to say this data, right?
So we'll just be adding in this data and then you need to specify the size.
So we want to convert it into six big crates of fly down down to zero is basically six feet, so you
just need to add an argument at the size that you want to do days of space.
Phobic and by utilizing a rhesus function, right, so you could convert this to sixth grade, so this
is something very handy and useful, right?
So let it just go ahead and see you are caught and try to perform a simulation, right?
So will go ahead.
Will lose an existing simulation and in the form of behavior simulation.
OK, so what I'll do is I'll just be selecting all the variable and change the relics to one saying
this right now, you will see SDR to OK is having a value of it.
So the result one is holding it and saying, Well, you right?
So if you can see so SD days on scene and result when restoring the standard underscore logic and this
corrective surgery to this to lose our matching right, then a data.
OK, so where data is holding a standard underscore logic on the score vector and result two is holding
its own saying equal and greater rate.
So here we have a value of four for and data, and the other two is also having a value of four, right?
The next one that we have is indent.
OK.
And Result three is holding its equivalent Unsane value ratio and then have a value of 56, a result
range also having a value 56.
This makes it.
And if you consider reserve for bogey, so that is basically holding an equivalent of this unseen rate.
So this untamed value is so it is holding the result off.
If you can see reserved for we have converted SD to OK to an integer, so SD data is having a value
of eight.
So this is also having a value of it right now, and if you could see it is verify.
So here we converted are Fobbit to six eight 10.
Again, it have a value of eight right now.
Let's assume that you choose the let's say so.
When we are converting from an integer to an unsigned, you have chosen the less size rate.
So here we can guess we required a minimum size of six, but there is a dummy declare it to be only
full bitrate.
So when we consider.
So we change this to forward rate the three down to zero, let it just go ahead and try to perform a
reload simulation again and try to observe to reiterate.
So here we have chosen the size, which is less than the maximum size that we are expecting for an integer.
So if you do that, you will be finding that RSI is do not match.
OK, left lefty has four element and writer.
He has four element that is the expected size is seven, but we have specified only a size of four bitrate.
And if you all do the research.
OK, since our core consists of an error, OK, you won't be able to find anything right.
So it is mandatory that when you convert from Unsane to Vector or Unsane two integer, you correctly
match the size rate.
So if you incorrectly specify the size you getting an error, you will you won't be simply allowed to
process further.
And since we usually strongly type language, it won't be automatically truncating IRIS or it will be
doing an error rate.