Now, since we get the idea of limit of functions,
let us consider the idea
of comparing functions point wise.
For example, essential thing here is to understand
whether or not the behavior or
a function in the given point coincides.
For example, let us look at our important limit Number 2,
sine x divided x.
Basically, it means that sine x and
x are pretty much the same functions around zero-point.
Basically, it means that they're equivalent,
you can substitute one with another
without any existential error.
So here comes an idea that some functions have
this property that they're basically the
same if we get some kind of limits,
and if you can see this, that our life is just
restricted to the area close to for example,
x approaches zero, neighborhood to x.
But some functions do not.
So we can somehow consider that there is
some class structure around functions at the given point.
Well, sometimes for example,
it's essential in case of
programming and to all the other stuff.
We've considered the case of equivalent function but
some functions are not
equivalent but are extremely close to it.
For example, consider some two polynomial functions
right here, for example,
5x squared minus 100x,
it doesn't actually really matter.
They are different obviously,
and we've actually calculated
the limit of its relation, do you remember?
We spoke about the case of
division of two polynomial function
if x approaches infinity,
so these functions are not equivalent.
Their relation, for example,
first divided by second results
into the limit value of one-fifth,
but it is still extremely close together.
They're closer than the case,
for example x is about three,
and x squared or x and x squared or for example,
natural logarithm of x and x squared.
They're somehow close because they
both relate to the case of quadratic functions of x.
So it's kind of essential for us to
speak about the classes
of polynomial functions as
they relate to the same class here.
Well, sometimes we do not
actually understand what's the difference
between the functions amongst that class,
or we do not know the specifics of functions
except this function belongs to the given class.
It happens for example,
if we consider the time of code implementation,
the time of some algorithm.
So what's an idea here?
Assume that for example,
you're considering some basic programming task.
You have a set of real or natural numbers,
N numbers for example.
Then you need to come up with an idea how to sort
them for example in descending order.
Let us assume how some basic bubble search.
You all know the idea here is that you are
just running some numbers in one direction,
and if two neighbors do not
stand in the right order then you just switch them.
So this [inaudible].
The idea here is that you need to do for example,
n multiplied by n minus 1 divided by 2 switches here.
Okay, that's nice but here comes a problem.
First of all, and that's our algorithm,
so basically we've established as a procedure but we do
not speak about the actual time it took because well,
assume that for example,
you've got real numbers here
but maybe you've got instead of real numbers,
a couple of chapters from [inaudible].
It's quite hard to compare in
comparison real numbers because you have
two strings that are large strings,
for example, then you've got
binary numbers and you need to sort them.
It's kind of different sets
and it takes different time to compare.
The last sort that
gives us a headache is basically just assuming that
you're writing the same algorithm
right now on your very favorite,
I don't know, laptop,
phone, iPad or whatsoever,
and you just time traveled into some past, for example,
you're in the late '90s and you are looking at
this very lump computer which takes the whole room,
and then you just run in and put much
the same algorithm whatsoever, coding language theories,
and then basically you should understand that times
differ; times of implementations,
time that your code works quite differ,
and that's basically the idea.
One, you need to understand that we have
some constant multiplier here which, for example,
can be interpreted as the time your machine
took to compare two numbers or to swap two numbers.
It depends on various things on
the structure of the objects in the set or for example,
well, on the date you've time travel to.
So basically, we do not know the idea,
that exact form of function,
but we do know that the class of its function
is pretty much the same as we spoke earlier,
this is quadratic function.
So it's nice to have an understanding how to
tell whether the other functions
lies in the same class or not.