Roots of a quadratic function: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
| (10 intermediate revisions by 6 users not shown) | |||
Line 7:
(For double-precision floats, set <math>b = -10^9</math>.)
Consider the following implementation in [[Ada]]:
<
with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;
Line 22:
begin
Put_Line ("X1 =" & Float'Image (R (1)) & " X2 =" & Float'Image (R (2)));
end Quadratic_Equation;</
{{out}}
<pre>X1 = 1.00000E+06 X2 = 0.00000E+00</pre>
Line 36:
=={{header|11l}}==
<
V sqd = Complex(b^2 - 4*a*c) ^ 0.5
R ((-b + sqd) / (2 * a),
Line 50:
V (r1, r2) = quad_roots(a, b, c)
print(r1, end' ‘ ’)
print(r2)</
{{out}}
Line 62:
=={{header|Ada}}==
<
with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;
Line 83:
begin
Put_Line ("X1 =" & Float'Image (R (1)) & " X2 =" & Float'Image (R (2)));
end Quadratic_Equation;</
Here precision loss is prevented by checking signs of operands. On errors, Constraint_Error is propagated on numeric errors and when roots are complex.
{{out}}
Line 97:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - probably need to "USE" the compl ENVIRON}}
<
BEGIN
Line 151:
ESAC
OD
END # quadratic_equation #</
{{out}}
<pre>
Line 175:
=={{header|AutoHotkey}}==
ahk forum: [http://www.autohotkey.com/forum/viewtopic.php?p=276617#276617 discussion]
<
MsgBox % quadratic(u,v, 1,3,2) ", " u ", " v
MsgBox % quadratic(u,v, -2,4,-2) ", " u ", " v
Line 197:
x2 := c/a/x1
Return 2
}</
=={{header|BBC BASIC}}==
<
READ a$, b$, c$
PRINT "For a = " ; a$ ", b = " ; b$ ", c = " ; c$ TAB(32) ;
Line 227:
PRINT "the complex roots are " ; -b/2/a " +/- " ; SQR(-d)/2/a "*i"
ENDCASE
ENDPROC</
{{out}}
<pre>For a = 1, b = -1E9, c = 1 the real roots are 1E9 and 1E-9
Line 239:
=={{header|C}}==
Code that tries to avoid floating point overflow and other unfortunate loss of precissions: (compiled with <code>gcc -std=c99</code> for <code>complex</code>, though easily adapted to just real numbers)
<
#include <stdlib.h>
#include <complex.h>
Line 299:
return 0;
}</
{{out}}<pre>(-1e+12 + 0 i), (-1 + 0 i)
(1.00208e+07 + 0 i), (9.9792e-08 + 0 i)</pre>
<
#include <math.h>
#include <complex.h>
Line 314:
x[0] = (-b + csqrt(delta)) / (2.0*a);
x[1] = (-b - csqrt(delta)) / (2.0*a);
}</
{{trans|C++}}
<
{
b /= a;
Line 330:
x[1] = c/sol;
}
}</
<
{
complex double x[2];
Line 346:
return 0;
}</
<pre>x1 = (1.00000000000000000000e+20, 0.00000000000000000000e+00)
Line 355:
=={{header|C sharp|C#}}==
<
using System.Numerics;
Line 370:
Console.WriteLine(Solve(1, -1E20, 1));
}
}</
{{out}}
<pre>((1E+20, 0), (1E-20, 0))</pre>
=={{header|C++}}==
<
#include <utility>
#include <complex>
Line 402:
std::pair<complex, complex> result = solve_quadratic_equation(1, -1e20, 1);
std::cout << result.first << ", " << result.second << std::endl;
}</
{{out}}
(1e+20,0), (1e-20,0)
Line 408:
=={{header|Clojure}}==
<
"Compute the roots of a quadratic in the form ax^2 + bx + c = 1.
Returns any of nil, a float, or a vector."
Line 418:
(zero? sq-d) (f +)
(pos? sq-d) [(f +) (f -)]
:else nil))) ; maybe our number ended up as NaN</
{{out}}
<
nil
user=> (quadratic 1.0 2.0 1.0)
Line 427:
user=> (quadratic 1.0 3.0 1.0)
[2.618033988749895 0.3819660112501051]
</syntaxhighlight>
=={{header|Common Lisp}}==
<
(list
(/ (+ (- b) (sqrt (- (expt b 2) (* 4 a c)))) (* 2 a))
(/ (- (- b) (sqrt (- (expt b 2) (* 4 a c)))) (* 2 a))))</
=={{header|D}}==
<
CommonType!(T1, T2, T3)[] naiveQR(T1, T2, T3)
Line 482:
writefln(" Naive: [%(%g, %)]", naiveQR(1.0L, -10e5L, 1.0L));
writefln("Cautious: [%(%g, %)]", cautiQR(1.0L, -10e5L, 1.0L));
}</
{{out}}
<pre>With 32 bit float type:
Line 500:
=={{header|Elixir}}==
<
def roots(a, b, c) do
IO.puts "Roots of a quadratic function (#{a}, #{b}, #{c})"
Line 523:
Quadratic.roots(1, -1.0e10, 1)
Quadratic.roots(1, 2, 3)
Quadratic.roots(2, -1, -6)</
{{out}}
Line 542:
=={{header|ERRE}}==
<syntaxhighlight lang="text">PROGRAM QUADRATIC
PROCEDURE SOLVE_QUADRATIC
Line 575:
DATA(1,3,2)
DATA(3,4,5)
END PROGRAM</
{{out}}
<pre>For a= 1 ,b=-1E+09 ,c= 1 the real roots are 1E+09 and 1E-09
Line 588:
=={{header|Factor}}==
{{trans|Ada}}
<
b sq a c * 4 * - sqrt :> sd
b 0 <
[ b neg sd + a 2 * / ]
[ b neg sd - a 2 * / ] if :> x
x c a x * / ;</
<
--- Data stack:
1.0e+20
9.999999999999999e-21</
Middlebrook method
<
a c * sqrt b / :> q
1 4 q sq * - sqrt 0.5 * 0.5 + :> f
b neg a / f * c neg b / f / ;
</syntaxhighlight>
<
--- Data stack:
1.0e+20
1.0e-20</
=={{header|Forth}}==
Without locals:
<
frot frot
( c a b )
Line 627:
2e f/ fover f/
( c a r1 )
frot frot f/ fover f/ ;</
With locals:
<
b b f* 4e a f* c f* f-
fdup f0< if abort" imaginary roots" then
Line 638:
\ test
1 set-precision
1e -1e6 1e quadratic fs. fs. \ 1e-6 1e6</
=={{header|Fortran}}==
===Fortran 90===
{{works with|Fortran|90 and later}}
<
IMPLICIT NONE
Line 676:
WRITE(*,*) "The roots are complex:"
WRITE(*,"(2(A,2E23.15,A))") "Root1 = ", croot1, "j ", " Root2 = ", croot2, "j"
END IF</
{{out}}
Coefficients are: a = 0.300000000000000E+01 b = 0.400000000000000E+01 c = 0.133333333330000E+01
Line 696:
===Fortran I===
Source code written in FORTRAN I (october 1956) for the IBM 704.
<
COMPUTE ROOTS OF A QUADRATIC FUNCTION - 1956
READ 100,A,B,C
Line 724:
332 FORMAT(3HX1=,E12.5,4H,X2=,E12.5)
999 STOP
</syntaxhighlight>
=={{header|FreeBASIC}}==
{{libheader|GMP}}
<
' compile with: fbc -s console
Line 853:
Data 1, -1e100, 1
Data 1, -1e200, 1
Data 1, -1e300, 1</
{{out}}
<pre>1: is the naieve way
Line 910:
=={{header|GAP}}==
<
local d;
d := Sqrt(b*b - 4*a*c);
Line 923:
# This works also with floating-point numbers
QuadraticRoots(2.0, 2.0, -1.0);
# [ 0.366025, -1.36603 ]</
=={{header|Go}}==
<
import (
Line 982:
test(c[0], c[1], c[2])
}
}</
{{out}}
<pre>
Line 993:
=={{header|Haskell}}==
<
type CD = Complex Double
Line 1,019:
(1, -10e5, 1),
(1, -10e9, 1)
]</
{{Out}}
<pre>((-0.6666666666666666) :+ 0.0,(-0.6666666666666666) :+ 0.0)
Line 1,032:
Works in both languages.
<
solve(1.0, -10.0e5, 1.0)
end
Line 1,041:
else [r1 := (-b-d)/(2.0*a), c/(a*r1)]
write(a,"*x^2 + ",b,"*x + ",c," has roots ",roots[1]," and ",roots[2])
end</
{{out}}
Line 1,051:
=={{header|IDL}}==
<
print, "input a, press enter, input b, press enter, input c, press enter"
Line 1,067:
e= y/z
print, d,e</
=={{header|IS-BASIC}}==
<syntaxhighlight lang="is-basic">
100 PROGRAM "Quadratic.bas"
110 PRINT "Enter coefficients a, b and c:":INPUT PROMPT "a= ,b= ,c= ":A,B,C
Line 1,085:
220 PRINT "The complex roots are ";-B/2/A;"+/- ";STR$(SQR(-D)/2/A);"*i"
230 END SELECT
240 END IF</
=={{header|J}}==
'''Solution''' use J's built-in polynomial solver:
p.
This primitive converts between the coefficient form of a polynomial (with the exponents being the array indices of the coefficients) and the multiplier-and-roots for of a polynomial (with two boxes, the first containing the multiplier and the second containing the roots).
'''Example''' using inputs from other solutions and the unstable example from the task description:
<
> {:"1 p. coeff
_0.666667 _0.666667
Line 1,098 ⟶ 1,101:
_0.333333j0.471405 _0.333333j_0.471405
1e6 1e_6
1e9 1e_9</
Of course <code>p.</code> generalizes to polynomials of arbitrary order (which isn't as great as that might sound, because of practical limitations). Given the coefficients <code>p.</code> returns the multiplier and roots of the polynomial. Given the multiplier and roots it returns the coefficients. For example using the cubic <math>0 + 16x - 12x^2 + 2x^3</math>:
<
+-+-----+
|2|4 2 0|
+-+-----+
p. 2 ; 4 2 0 NB. return coefficients
0 16 _12 2</
Exploring the limits of precision:
<
100000 1e_5
1 _1e5 1 p. 1{::p. 1 _1e5 1 NB. test roots
Line 1,119 ⟶ 1,122:
1e_5 _1e_15
1 _1e5 1 p. 1e5 1e_5-1e_5 _1e_15 NB. test displayed roots with adjustment
_3.38436e_7 0</
When these "roots" are plugged back into the original polynomial, the results are nowhere near zero. However, double precision floating point does not have enough bits to represent the (extremely close) answers that would give a zero result.
Line 1,125 ⟶ 1,128:
Middlebrook formula implemented in J
<
'a b c' =. y
q=. b %~ %: a * c
Line 1,133 ⟶ 1,136:
q_r 1 _1e6 1
1e6 1e_6</
=={{header|Java}}==
<
private static class Complex {
double re, im;
Line 1,209 ⟶ 1,212:
}
}
}</
{{out}}
<pre>
Line 1,247 ⟶ 1,250:
'''Section 1''': Complex numbers (scrolling window)
<div style="overflow:scroll; height:200px;">
<
def real(z): if (z|type) == "number" then z else z[0] end;
Line 1,312 ⟶ 1,315:
| [ ($r * cos), ($r * sin)]
end
end ;</
'''Section 2:''' quadratic_roots(a;b;c)
<
# if none, emit empty;
# otherwise always emit two.
Line 1,330 ⟶ 1,333:
negate(divide(c; multiply(b; $f)))
end
;</
'''Section 3''':
Produce a table showing [i, error, solution] for solutions to x^2 - 10^i + 1 = 0
<
def pow(i): . as $in | reduce range(0;i) as $i (1; . * $in);
def poly(a;b;c): plus( plus( multiply(a; multiply(.;.)); multiply(b;.)); c);
Line 1,351 ⟶ 1,354:
;
example</
{{Out}} (scrolling window)
<div style="overflow:scroll; height:200px;">
<syntaxhighlight lang="sh">
$ jq -M -r -n -f Roots_of_a_quadratic_function.jq
0: error = +0 x=[0.5,0.8660254037844386]
Line 1,381 ⟶ 1,384:
11: error = +0 x=[1e-11,-0]
12: error = 1 x=[1000000000000,0]
12: error = +0 x=[1e-12,-0]</
=={{header|Julia}}==
Line 1,388 ⟶ 1,391:
Alternative solutions might make use of Julia's Polynomials or Roots packages.
<
function quadroots(x::Real, y::Real, z::Real)
Line 1,412 ⟶ 1,415:
for (x, y, z) in zip(a, b, c)
@printf "The roots of %.2fx² + %.2fx + %.2f\n\tx₀ = (%s)\n" x y z join(round.(quadroots(x, y, z), 2), ", ")
end</
{{out}}
Line 1,423 ⟶ 1,426:
The roots of 10.00x² + 1.00x + 1.00
x₀ = (-0.05 + 0.31im, -0.05 - 0.31im)</pre>
=={{header|K}}==
===K6===
{{works with|ngn/k}}
<syntaxhighlight lang="k"> / naive method
/ sqr[x] and sqrt[x] must be provided
quf:{[a;b;c]; s:sqrt[sqr[b]-4*a*c];(-b+s;-b-s)%2*a}
quf[0.5;-2.5;2]
1.0 4.0
quf[1;8;15]
-5.0 -3.0
quf[1;10;1]
-9.898979485566356 -0.10102051443364424
</syntaxhighlight>
=={{header|Kotlin}}==
{{trans|Java}}
<
data class Equation(val a: Double, val b: Double, val c: Double) {
Line 1,469 ⟶ 1,487:
equations.forEach { println("$it\n" + it.quadraticRoots) }
}</
{{out}}
<pre>Equation(a=1.0, b=22.0, c=-1323.0)
Line 1,485 ⟶ 1,503:
=={{header|lambdatalk}}==
<
1) using lambdas:
Line 1,547 ⟶ 1,565:
x1 = 1
x2 = 1
</syntaxhighlight>
=={{header|Liberty BASIC}}==
<
'assume a<>0
print quad$(a,b,c)
Line 1,563 ⟶ 1,581:
quad$=str$(x/(2*a)+sqr(D)/(2*a));" , ";str$(x/(2*a)-sqr(D)/(2*a))
end if
end function</
=={{header|Logo}}==
<
localmake "d sqrt (:b*:b - 4*:a*:c)
if :b < 0 [make "d minus :d]
output list (:d-:b)/(2*:a) (2*:c)/(:d-:b)
end</
=={{header|Lua}}==
Line 1,576 ⟶ 1,594:
like that from the Complex Numbers article. However, this should be enough to demonstrate its accuracy:
<
if b < 0 then return qsolve(-a, -b, -c) end
val = b + (b^2 - 4*a*c)^(1/2) --this never exhibits instability if b > 0
Line 1,584 ⟶ 1,602:
for i = 1, 12 do
print(qsolve(1, 0-10^i, 1))
end</
The "trick" lies in avoiding subtracting large values that differ by a small amount, which is the source of instability in the "normal" formula. It is trivial to prove that 2c/(b + sqrt(b^2-4ac)) = (b - sqrt(b^2-4ac))/2a.
=={{header|Maple}}==
<
solve(1.0*x^2-10.0^9*x+1.0,x,explicit,allsolutions);
fsolve(x^2-10^9*x+1,x,complex);</
{{out}}
<pre> (1/2) (1/2)
Line 1,606 ⟶ 1,624:
1.000000000 10 , 1.000000000 10 </pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Possible ways to do this are (symbolic and numeric examples):
<
Solve[x^2 - 10^5 x + 1 == 0, x]
Root[#1^2 - 10^5 #1 + 1 &, 1]
Line 1,616 ⟶ 1,634:
FindInstance[x^2 - 10^5 x + 1 == 0, x, Reals, 2]
FindRoot[x^2 - 10^5 x + 1 == 0, {x, 0}]
FindRoot[x^2 - 10^5 x + 1 == 0, {x, 10^6}]</
gives back:
Line 1,656 ⟶ 1,674:
=={{header|MATLAB}} / {{header|Octave}}==
<
=={{header|Maxima}}==
<
/* 2 2
Line 1,674 ⟶ 1,692:
bfloat(%);
/* [x = 1.0000000000000000009999920675269450501b-9,
x = 9.99999999999999998999999999999999999b8] */</
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">П2 С/П /-/ <-> / 2 / П3 x^2 С/П
ИП2 / - Вx <-> КвКор НОП x>=0 28 ИП3
x<0 24 <-> /-/ + / Вx С/П /-/ КвКор
ИП3 С/П</
''Input:'' a С/П b С/П c С/П
Line 1,688 ⟶ 1,706:
=={{header|Modula-3}}==
{{trans|Ada}}
<
IMPORT IO, Fmt, Math;
Line 1,712 ⟶ 1,730:
r := Solve(1.0D0, -10.0D5, 1.0D0);
IO.Put("X1 = " & Fmt.LongReal(r[1]) & " X2 = " & Fmt.LongReal(r[2]) & "\n");
END Quad.</
=={{header|Nim}}==
<
const Epsilon = 1e-15
Line 1,771 ⟶ 1,789:
let roots = quadRoots(a, b, c)
let plural = if roots.kind == solDouble: "" else: "s"
echo &" root{plural}: {roots}"</
{{out}}
Line 1,787 ⟶ 1,805:
=={{header|OCaml}}==
<
| RealRoots of float * float
| ComplexRoots of Complex.t * Complex.t ;;
Line 1,806 ⟶ 1,824:
in
RealRoots (r, c /. (r *. a))
;;</
{{out}}
<
- : quadroots = RealRoots (-1.4142135623730951, 1.4142135623730949)
Line 1,818 ⟶ 1,836:
# quadsolve 1.0 (-1.0e5) 1.0 ;;
- : quadroots = RealRoots (99999.99999, 1.0000000001000001e-005)</
=={{header|Octave}}==
Line 1,825 ⟶ 1,843:
=={{header|PARI/GP}}==
{{works with|PARI/GP|2.8.0+}}
<
{{trans|C}}
Otherwise, coding directly:
<
b /= a;
c /= a;
Line 1,839 ⟶ 1,857:
[sol,c/sol]
)
};</
Either way,
<syntaxhighlight lang
gives one root around 0.000000001000000000000000001 and one root around 999999999.999999999.
=={{header|Pascal}}==
some parts translated from Modula2
<
var
Line 1,875 ⟶ 1,893:
end;
end.
</syntaxhighlight>
{{out}}
<pre>
Line 1,886 ⟶ 1,904:
=={{header|Perl}}==
When using [http://perldoc.perl.org/Math/Complex.html Math::Complex] perl automatically convert numbers when necessary.
<
($x1,$x2) = solveQuad(1,2,3);
Line 1,897 ⟶ 1,915:
my $root = sqrt($b**2 - 4*$a*$c);
return ( -$b + $root )/(2*$a), ( -$b - $root )/(2*$a);
}</
=={{header|Phix}}==
{{trans|ERRE}}
<!--<
<span style="color: #008080;">procedure</span> <span style="color: #000000;">solve_quadratic</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">t3</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span><span style="color: #000000;">c</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">t3</span><span style="color: #0000FF;">,</span>
Line 1,929 ⟶ 1,947:
<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">,</span><span style="color: #000000;">solve_quadratic</span><span style="color: #0000FF;">)</span>
<!--</
<pre>
for a=1,b=-1e+9,c=1 the real roots are 1e+9 and 1e-9
Line 1,941 ⟶ 1,959:
=={{header|PicoLisp}}==
<
(de solveQuad (A B C)
Line 1,955 ⟶ 1,973:
(mapcar round
(solveQuad 1.0 -1000000.0 1.0)
(6 .) )</
{{out}}
<pre>-> ("999,999.999999" "0.000001")</pre>
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
declare (c1, c2) float complex,
(a, b, c, x1, x2) float;
Line 1,977 ⟶ 1,995:
put data (x1, x2);
end;
</syntaxhighlight>
=={{header|Python}}==
{{libheader|NumPy}}
This solution compares the naïve method with three "better" methods.
<
import math
Line 2,054 ⟶ 2,072:
print('\nNumpy:')
for c in testcases:
print(("{:.5} "*2).format(*numpy.roots(c)))</
{{out}}
<pre>
Line 2,095 ⟶ 2,113:
=={{header|R}}==
<
r <- sqrt(b * b - 4 * a * c + 0i)
if (abs(b - r) > abs(b + r)) {
Line 2,109 ⟶ 2,127:
qroots(1, -1e9, 1)
[1] 1e+09+0i 1e-09+0i</
Using the builtin '''polyroot''' function (note the order of coefficients is reversed):
<
[1] -1+1i 1-1i
polyroot(c(1, -1e9, 1))
[1] 1e-09+0i 1e+09+0i</
=={{header|Racket}}==
<
(define (quadratic a b c)
(let* ((-b (- b))
Line 2,132 ⟶ 2,150:
;'(0.99999999999995 -1.00000000000005)
;(quadratic 1 0.0000000000001 1)
;'(-5e-014+1.0i -5e-014-1.0i)</
=={{header|Raku}}==
(formerly Perl 6)
{{Works with|Rakudo|2022.12}}
''Works with previous versions also but will return slightly less precise results.''
Raku has complex number handling built in.
<syntaxhighlight lang="raku"
[1, 2, 1],
[1, 2, 3],
[1, -2, 1],
[1, 0, -4],
[1, -
-> @coefficients {
printf "Roots for %d, %d, %d\t=> (%s, %s)\n",
Line 2,151 ⟶ 2,173:
sub quadroots (*[$a, $b, $c]) {
( -$b + $_ ) / (2
( -$b - $_ ) / (2
given
($b
}</
{{out}}
<pre>Roots for 1, 2, 1
Roots for 1, 2, 3
Roots for 1, -2, 1
Roots for 1, 0, -4
Roots for 1, -1000000, 1
=={{header|REXX}}==
Line 2,173 ⟶ 2,195:
This REXX version supports ''complex numbers'' for the result.
<
parse arg a b c . /*obtain the specified arguments: A B C*/
call quad a,b,c /*solve quadratic function via the sub.*/
Line 2,197 ⟶ 2,219:
g=g*.5'e'_%2; do j=0 while h>9; m.j=h; h=h%2+1; end /*j*/
do k=j+5 to 0 by -1; numeric digits m.k; g=(g+x/g)*.5; end /*k*/
numeric digits d; return (g/1)left('i', ox<0) /*make complex if OX<0. */</
{{out|output|text= when using the input of: <tt> 1 -10e5 1 </tt>}}
<pre>
Line 2,249 ⟶ 2,271:
=== Version 2 ===
<
* 26.07.2913 Walter Pachl
**********************************************************************/
Line 2,312 ⟶ 2,334:
Return (r+0)
exit: Say arg(1)
Exit</
{{out}}
<pre>
Line 2,330 ⟶ 2,352:
=={{header|Ring}}==
<syntaxhighlight lang="text">
x1 = 0
x2 = 0
Line 2,347 ⟶ 2,369:
x2 = (-b - sqrtDiscriminant) / (2.0*a)
return [x1, x2]
</syntaxhighlight>
=={{header|RPL}}==
RPL can solve quadratic functions directly :
'x^2-1E9*x+1' 'x' QUAD
returns
1: '(1000000000+s1*1000000000)/2'
which can then be turned into roots by storing 1 or -1 in the <code>s1</code> variable and evaluating the formula:
DUP 1 's1' STO EVAL SWAP -1 's1' STO EVAL
hence returning
2: 1000000000
1: 0
So let's implement the algorithm proposed by the task:
{| class="wikitable"
! RPL code
! Comment
|-
|
≪
'''IF''' DUP TYPE 1 == '''THEN'''
'''IF''' DUP IM NOT '''THEN''' RE '''END END'''
≫ '<span style="color:blue">REALZ</span>' STO
.
≪ → a b c
≪ '''IF''' b NOT '''THEN''' c a / NEG √ DUP NEG '''ELSE'''
a c * √ b /
1 SWAP SQ 4 * - √ 2 / 0.5 +
b * NEG
DUP a / <span style="color:blue">REALZ</span>
c ROT / <span style="color:blue">REALZ</span> '''END'''
≫ ≫ '<span style="color:blue">QROOT</span>' STO
|
<span style="color:blue">REALZ</span> ''( number → number )''
if number is a complex
with no imaginary part, then turn it into a real
<span style="color:blue">QROOT</span> ''( a b c → r1 r2 ) ''
if b=0 then roots are obvious, else
q = sqrt(a*c)/b
f = 1/2+sqrt(1-4*q^2)/2
get -b*f
root1 = -b/a*f
root2 = -c/(b*f)
|}
1 -1E9 1 <span style="color:blue">QROOT</span>
actually returns a more correct answer:
2: 1000000000
1: .000000001
=={{header|Ruby}}==
{{works with|Ruby|1.9.3+}}
The CMath#sqrt method will return a Complex instance if necessary.
<
def quadratic(a, b, c)
Line 2,366 ⟶ 2,437:
p quadratic(-2, 7, 15) # [-3/2, 5]
p quadratic(1, -2, 1) # [1]
p quadratic(1, 3, 3) # [(-3 + sqrt(3)i)/2), (-3 - sqrt(3)i)/2)]</
{{out}}
<pre>
Line 2,380 ⟶ 2,451:
=={{header|Run BASIC}}==
<
print "FOR 4,5,6 => ";quad$(4,5,6)
Line 2,391 ⟶ 2,462:
quad$ = str$(x/(2*a)+sqr(d)/(2*a))+" , "+str$(x/(2*a)-sqr(d)/(2*a))
end if
END FUNCTION</
FOR 4,5,6 => -0.625 +i1.05326872 , -0.625 -i1.05326872</pre>
=={{header|Scala}}==
Using [[Arithmetic/Complex#Scala|Complex]] class from task Arithmetic/Complex.
<
object QuadraticRoots {
def solve(a:Double, b:Double, c:Double)={
Line 2,412 ⟶ 2,483:
}
}
}</
Usage:
<
(1.0, 22.0, -1323.0), // two distinct real roots
(6.0, -23.0, 20.0), // with a != 1.0
Line 2,430 ⟶ 2,501:
if(roots._1 != roots._2) println("x2="+roots._2)
println
}</
{{out}}
<pre>a=1.00000 b=22.0000 c=-1323.00
Line 2,456 ⟶ 2,527:
=={{header|Scheme}}==
<
(if (= a 0)
(if (= b 0) 'fail (- (/ c b)))
Line 2,495 ⟶ 2,566:
(quadratic 1 -1e5 1)
; (99999.99999 1.0000000001000001e-05)</
=={{header|Seed7}}==
{{trans|Ada}}
<
include "float.s7i";
include "math.s7i";
Line 2,533 ⟶ 2,604:
r := solve(1.0, -10.0E5, 1.0);
writeln("X1 = " <& r.x1 digits 6 <& " X2 = " <& r.x2 digits 6);
end func;</
{{out}}
Line 2,541 ⟶ 2,612:
=={{header|Sidef}}==
<
[1, 2, 1],
[1, 2, 3],
Line 2,559 ⟶ 2,630:
say ("Roots for #{coefficients}",
"=> (#{quadroots(coefficients...).join(', ')})")
}</
{{out}}
<pre>
Line 2,570 ⟶ 2,641:
=={{header|Stata}}==
<
: polyroots((-2,0,1))
1 2
Line 2,581 ⟶ 2,652:
+-------------------------------+
1 | -1.41421356i 1.41421356i |
+-------------------------------+</
=={{header|Tcl}}==
{{tcllib|math::complexnumbers}}
<
namespace import math::complexnumbers::complex math::complexnumbers::tostring
Line 2,621 ⟶ 2,692:
report_quad -2 7 15 ;# {5, -3/2}
report_quad 1 -2 1 ;# {1}
report_quad 1 3 3 ;# {(-3 - sqrt(3)i)/2), (-3 + sqrt(3)i)/2)}</
{{out}}
<pre>3x**2 + 4x + 1.3333333333333333 = 0
Line 2,649 ⟶ 2,720:
TI-89 BASIC has built-in numeric and algebraic solvers.
<syntaxhighlight lang="text">solve(x^2-1E9x+1.0)</
returns
<pre>x=1.E-9 or x=1.E9</pre>
Line 2,656 ⟶ 2,727:
{{trans|Go}}
{{libheader|Wren-complex}}
<
var quadratic = Fn.new { |a, b, c|
Line 2,699 ⟶ 2,770:
]
for (c in coeffs) test.call(c[0], c[1], c[2])</
{{out}}
Line 2,708 ⟶ 2,779:
coefficients: 1, -1000, 1 -> two real roots: 999.998999999 and 0.001000001000002
coefficients: 1, -1000000000, 1 -> two real roots: 1000000000 and 1e-09
</pre>
=={{header|XPL0}}==
{{trans|Go}}
<syntaxhighlight lang "XPL0">include xpllib; \for Print
func real QuadRoots(A, B, C); \Return roots of quadratic equation
real A, B, C;
real D, E, R;
[R:= [0., 0., 0.];
R(0):= 0.; R(1):= 0.; R(2):= 0.;
D:= B*B - 4.*A*C;
case of
D = 0.: [R(0):= -B / (2.*A); \single root
R(1):= R(0);
];
D > 0.: [if B < 0. then \two real roots
E:= sqrt(D) - B
else E:= -sqrt(D) - B;
R(0):= E / (2.*A);
R(1):= 2. * C / E;
];
D < 0.: [R(0):= -B / (2.*A); \real
R(2):= sqrt(-D) /(2.*A); \imaginary
]
other []; \D overflowed or a coefficient was NaN
return R;
];
func Test(A, B, C);
real A, B, C;
real R;
[Print("coefficients: %g, %g, %g -> ", A, B, C);
R:= QuadRoots(A, B, C);
if R(2) # 0. then
Print("two complex roots: %g+%gi, %g-%gi\n", R(0), R(2), R(0), R(2))
else [if R(0) = R(1) then
Print("one real root: %g\n", R(0))
else Print("two real roots: %15.15g, %15.15g\n", R(0), R(1));
];
];
real C; int I;
[C:= [ [1., -2., 1.],
[1., 0., 1.],
[1., -10., 1.],
[1., -1000., 1.],
[1., -1e9, 1.],
[1., -4., 6.] ];
for I:= 0 to 5 do
Test(C(I,0), C(I,1), C(I,2));
]</syntaxhighlight>
{{out}}
<pre>
coefficients: 1, -2, 1 -> one real root: 1
coefficients: 1, 0, 1 -> two complex roots: 0+1i, 0-1i
coefficients: 1, -10, 1 -> two real roots: 9.89897948556636, 0.101020514433644
coefficients: 1, -1000, 1 -> two real roots: 999.998999999, 0.001000001000002
coefficients: 1, -1e9, 1 -> two real roots: 1000000000, 0.000000001
coefficients: 1, -4, 6 -> two complex roots: 2+1.41421i, 2-1.41421i
</pre>
Line 2,713 ⟶ 2,844:
zkl doesn't have a complex number package.
{{trans|Elixir}}
<
println("Roots of a quadratic function %s, %s, %s".fmt(a,b,c));
d,a2:=(b*b - 4*a*c), a+a;
Line 2,725 ⟶ 2,856:
println(" the complex roots are %s and \U00B1;%si".fmt(-b/a2,sd/a2));
}
}</
<
quadratic(a,b,c)
}</
{{out}}
<pre>
| |||