在Matlab中提高二次方程的鲁棒性

Question

The task was to write a code in matlab that solves the quadratic equation.

MY code is below

a=input('a=  ');
b=input('b=  ');
c=input('c=  ');
if a==0
    x=double(-c/b);
    disp(x)
else
    discriminant=b.^2-4*a*c;
    if discriminant<0
        error('Roots are not real')
    else
        e=sqrt(discriminant);
        x1=double((-b+e)/(2*a));
        x2=double((-b-e)/(2*a));
    end
end

disp(x1)
disp(x2)

Now, this gives result. However, when confronted with questions about the "robustness" of the code to guard against division by zero, unnecesary overflow and underflow, cancellation, how can I modify the code? For the first case, division by zero, my code already works, but what do they mean by underflow/overflow?

Answer 1

The overflow/underflow occurs when a value in programming starts occupying extra and unexpected memory cells. In that case, the program runs into a runtime error or sometimes shuts down itself to prevent harm to system. To avoid such severe cases, a program should be managed to exit or return from a bad-valued function or bad code execution whenever needed. This ,of course, should be done using if-else commands, return or break or while loops.

ps your program has still a flaw. It malfunctions when a=b=0 and c!=0. I converted your code to a function in MATLAB (which can now be called in Command Window) and added a MAX_VALUE to avoid out-of-bound variables.

Here is the code

function x=quadroots(a,b,c,MAX_VALUE)
if nargin == 3
    MAX_VALUE=1e50;
end
if abs(a)>MAX_VALUE||abs(b)>MAX_VALUE||abs(c)>MAX_VALUE
    error('Out of bound variables')
end
if a==0 && b~=0
    x=double(-c/b);
    disp(x)
elseif a==0 && b==0 && c==0
    error('0=0')
elseif a==0 && b==0 && c~=0
    error('Infeasible solutions')
else
    discriminant=b.^2-4*a*c;
    if discriminant<0
        error('Roots are not real')
    else
        e=sqrt(discriminant);
        x(1)=double((-b+e)/(2*a));
        x(2)=double((-b-e)/(2*a));
    end
end
end

Answer 2

Let's say I have a variable that is a 2-bit integer. Now, for my variable I can only hold 2^2 in decimal as my max number. Let's take a look at how 2 bits count:

0 0 (add 1) --> 0 1
0 1 (add 1) --> 1 0
1 0 (add 1) --> 1 1
1 1 (add 1) --> 0 0

It wraps back around to 0 0 because I ran out of bits to hold my number so it starts over. This is called overflow. The same is similar for underflow except it wraps back to the max. For matlab, the number of bits can be larger like 32-bits or 64-bits. So what happens when you get a very large number input and you perform math on it? Will it overflow because you ran out of bits? or underflow?

FYI: If you don't know binary, you should take a quick look on wiki to help out because all digits in any computer language will be expressed as bits but luckily we deal with the decimal values.

Also, some hand waving here.