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.