Rosetta Code

Horner's rule for polynomial evaluation: Difference between revisions

Page Discussion

Horner's rule for polynomial evaluation (view source)

Revision as of 18:30, 17 March 2024

36,180 bytes added ,  2 months ago
Added Easylang
(→‎{{header|Perl}}: adding Perl as a comment in sub-titles so it shows up in summaries)
(Added Easylang)
 
(116 intermediate revisions by 67 users not shown)
Line 20:
 
Cf. [[Formal power series]]
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">F horner(coeffs, x)
V acc = 0
L(c) reversed(coeffs)
acc = acc * x + c
R acc
 
print(horner([-19, 7, -4, 6], 3))</syntaxhighlight>
 
{{out}}
<pre>
128
</pre>
 
=={{header|360 Assembly}}==
<syntaxhighlight lang="360asm">* Horner's rule for polynomial evaluation - 07/10/2015
HORNER CSECT
USING HORNER,R15 set base register
SR R5,R5 accumulator=0
LA R2,N i=number_of_coeff
LOOP M R4,X accumulator=accumulator*x
LR R1,R2 i
SLA R1,2 i*4
L R3,COEF-4(R1) coef(i)
AR R5,R3 accumulator=accumulator+coef(i)
BCT R2,LOOP i=i-1; loop n times
XDECO R5,PG edit accumulator
XPRNT PG,12 print buffer
XR R15,R15 set return code
BR R14 return to caller
COEF DC F'-19',F'7',F'-4',F'6' <== input values
X DC F'3' <== input value
N EQU (X-COEF)/4 number of coefficients
PG DS CL12 buffer
YREGS
END HORNER</syntaxhighlight>
{{out}}
<pre>
128
</pre>
 
=={{header|ACL2}}==
<langsyntaxhighlight Lisplang="lisp">(defun horner (ps x)
(if (endp ps)
0
(+ (first ps)
(* x (horner (rest ps) x)))))</langsyntaxhighlight>
 
=={{header|Action!}}==
<syntaxhighlight lang="action!">INT FUNC Horner(INT ARRAY coeffs INT count,x)
INT v,i
 
v=0 i=count-1
WHILE i>=0
DO
v=v*x+coeffs(i)
i==-1
OD
RETURN (v)
 
PROC Main()
INT ARRAY coeffs=[65517 7 65532 6]
INT res,x=[3],i,count=[4]
 
PrintF("x=%I%E",x)
FOR i=0 TO count-1
DO
PrintI(coeffs(i))
IF i=1 THEN
Print("x")
ELSEIF i>1 THEN
PrintF("x^%I",i)
FI
IF i<count-1 AND coeffs(i+1)>=0 THEN
Print("+")
FI
OD
res=Horner(coeffs,4,x)
PrintF("=%I%E",res)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Horner's_rule_for_polynomial_evaluation.png Screenshot from Atari 8-bit computer]
<pre>
x=3
-19+7x-4x^2+6x^3=128
</pre>
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Float_Text_IO; use Ada.Float_Text_IO;
 
procedure Horners_Rule is
Line 45 ⟶ 127:
begin
Put(Horner(Coeffs => (-19.0, 7.0, -4.0, 6.0), Val => 3.0), Aft=>1, Exp=>0);
end Horners_Rule;</langsyntaxhighlight>
Output:
<pre>128.0</pre>
 
=={{header|Aime}}==
<langsyntaxhighlight lang="aime">real
horner(list coeffs, real x)
{
integerreal ic, z;
real z;
 
z = 0;
 
ifor = l_length(, c of coeffs); {
while (i) { z *= x;
i - z += 1c;
z *= x;
z += l_q_real(coeffs, i);
}
 
return z;
}
 
 
integer
main(void)
{
o_plano_(horner(l_effectlist(-19r, 7.0, -real(4)4r, 6r), 3), "\n");
 
return 0;
}</langsyntaxhighlight>
 
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G}}
<langsyntaxhighlight lang="algol68">PROC horner = ([]REAL c, REAL x)REAL :
(
REAL res := 0.0;
Line 91 ⟶ 170:
[4]REAL coeffs := (-19.0, 7.0, -4.0, 6.0);
print( horner(coeffs, 3.0) )
)</langsyntaxhighlight>
 
=={{header|ALGOL W}}==
<syntaxhighlight lang="algolw">begin
% Horner's rule for polynominal evaluation %
% returns the value of the polynominal defined by coefficients, %
% at the point x. The number of coefficients must be in ub %
% the coefficients should be in order with x^0 first, x^n last %
real procedure Horner( real array coefficients ( * )
; integer value ub
; real value x
) ;
begin
real xValue;
xValue := 0;
for i := ub step -1 until 1 do xValue := ( xValue * x ) + coefficients( i );
xValue
end Horner ;
% task test case %
begin
real array coefficients ( 1 :: 4 );
integer cPos;
cPos := 1;
for i := -19, 7, -4, 6 do begin
coefficients( cPos ) := i;
cPos := cPos + 1
end for_i ;
write( r_format := "A", r_w := 8, r_d := 2, Horner( coefficients, 4, 3 ) )
end test_cases
end.</syntaxhighlight>
{{out}}
<pre>
128.00
</pre>
 
=={{header|APL}}==
Works in [[Dyalog APL]]
<syntaxhighlight lang="apl">h←⊥∘⌽</syntaxhighlight>
{{output}}
<pre>
3 h ¯19 7 ¯4 6
128
</pre>
 
=={{header|ATS}}==
<syntaxhighlight lang="ats">#include
<lang ATS>staload "prelude/SATS/list.sats"
"share/atspre_staload.hats"
staload "prelude/DATS/list.dats"
 
fun
fun horner (x: int, coeff: List int): int = let
horner
val f = lam (a: int, b: int) =<cloref1> a + b*x
(
x: int, cs: List int
) : int = let
//
implement
list_foldright$fopr<int><int> (a, b) = a + b * x
//
in
list_foldright<int><int> (cs, 0)
list_fold_right_cloref (f, coeff, 0)
end // end of [horner]
end
 
implement main () = let
main0 () = let
val x = 3
val coeffcs = '[$list{int}(~19, 7, ~4, 6])
val res = horner (x, coeffcs)
in
printprintln! (res, "\n")
end // end of [main0]</syntaxhighlight>
end</lang>
 
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">horner: function [coeffs, x][
result: 0
loop reverse coeffs 'c ->
result: c + result * x
return result
]
 
print horner @[neg 19, 7, neg 4, 6] 3</syntaxhighlight>
{{out}}
<pre>128</pre>
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight lang="autohotkey">Coefficients = -19, 7, -4, 6
x := 3
 
Line 127 ⟶ 268:
i := Co0 - A_Index + 1, Result := Result * x + Co%i%
Return, Result
}</langsyntaxhighlight>
Message box shows:
<pre>128</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">#!/usr/bin/awk -f
function horner(x, A) {
acc = 0;
for (i = length(A); 0<i; i--) {
acc = acc*x + A[i];
}
return acc;
}
BEGIN {
split(p,P);
print horner(x,P);
}</syntaxhighlight>
 
{{out}}
<pre>
awk -v X=3 -v p="-19 7 -4 6" -f horner.awk
128
</pre>
 
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
{{works with|Chipmunk Basic}}
{{works with|GW-BASIC}}
<syntaxhighlight lang="qbasic">100 HOME : REM 100 CLS for Chipmunk Basic and GW-BASIC
100 CLS : REM 100 HOME for Applesoft BASIC
110 X = 3
120 DIM COEFFS(3)
130 COEFFS(0) = -19
140 COEFFS(1) = 7
150 COEFFS(2) = -4
160 COEFFS(3) = 6
170 PRINT "Horner's algorithm for the polynomial "
180 PRINT "6*x^3 - 4*x^2 + 7*x - 19 when x = 3 is: ";
190 ACCUM = 0
200 FOR I = 3 TO 0 STEP -1
210 ACCUM = (ACCUM*X)+COEFFS(I)
220 NEXT I
230 PRINT ACCUM
240 END</syntaxhighlight>
 
==={{header|BASIC256}}===
<syntaxhighlight lang="vb">x = 3
dim coeficientes = {-19, 7, -4, 6}
print "Horner's algorithm for the polynomial ";
print "6*x^3 - 4*x^2 + 7*x - 19 when x = 3: ";
print AlgoritmoHorner(coeficientes, x)
end
 
function AlgoritmoHorner(coeffs, x)
acumulador = 0
for i = coeffs[?]-1 to 0 step -1
acumulador = (acumulador * x) + coeffs[i]
next i
return acumulador
end function</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">100 CLS
110 x = 3
120 DIM coeffs(3)
130 coeffs(0) = -19
140 coeffs(1) = 7
150 coeffs(2) = -4
160 coeffs(3) = 6
170 PRINT "Horner's algorithm for the polynomial "
180 PRINT "6*x^3 - 4*x^2 + 7*x - 19 when x = 3 is: ";
190 accum = 0
200 FOR i = UBOUND(coeffs,1) TO 0 STEP -1
210 accum = (accum*x)+coeffs(i)
220 NEXT i
230 PRINT accum
240 END</syntaxhighlight>
{{out}}
<pre>Horner's algorithm for the polynomial
6*x^3 - 4*x^2 + 7*x - 19 when x = 3 is: 128</pre>
 
==={{header|Gambas}}===
<syntaxhighlight lang="vbnet">Public coeficientes As New Integer[4]
 
Public Function AlgoritmoHorner(coeficientes As Integer[], x As Integer) As Integer
coeficientes[0] = -19
coeficientes[1] = 7
coeficientes[2] = -4
coeficientes[3] = 6
Dim i As Integer, acumulador As Integer = 0
 
For i = coeficientes.Count - 1 To 0 Step -1
acumulador = (acumulador * x) + coeficientes[i]
Next
Return acumulador
End Function
 
Public Sub Main()
Dim x As Integer = 3
Print "Horner's algorithm for the polynomial 6*x^3 - 4*x^2 + 7*x - 19 when x = 3: ";
Print AlgoritmoHorner(coeficientes, x)
End </syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
==={{header|GW-BASIC}}===
{{works with|BASICA}}
{{works with|Chipmunk Basic}}
{{works with|PC-BASIC|any}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">100 CLS : REM 100 HOME for Applesoft BASIC
110 X = 3
120 DIM COEFFS(3)
130 COEFFS(0) = -19
140 COEFFS(1) = 7
150 COEFFS(2) = -4
160 COEFFS(3) = 6
170 PRINT "Horner's algorithm for the polynomial "
180 PRINT "6*x^3 - 4*x^2 + 7*x - 19 when x = 3 is: ";
190 ACCUM = 0
200 FOR I = 3 TO 0 STEP -1
210 ACCUM = (ACCUM*X)+COEFFS(I)
220 NEXT I
230 PRINT ACCUM
240 END</syntaxhighlight>
{{out}}
<pre>Same as Chipmunk Basic entry.</pre>
 
==={{header|Minimal BASIC}}===
{{works with|QBasic}}
{{works with|QuickBasic}}
{{works with|Applesoft BASIC}}
{{works with|BASICA}}
{{works with|Chipmunk Basic}}
{{works with|GW-BASIC}}
{{works with|MSX BASIC}}
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
{{works with|Run BASIC}}
{{works with|Yabasic}}
<syntaxhighlight lang="qbasic">20 LET X = 3
30 DIM C(3)
40 LET C(0) = -19
50 LET C(1) = 7
60 LET C(2) = -4
70 LET C(3) = 6
80 PRINT "HORNER'S ALGORITHM FOR THE POLYNOMIAL"
90 PRINT "6*X^3 - 4*X^2 + 7*X - 19 WHEN X = 3 : ";
100 LET A = 0
110 FOR I = 3 TO 0 STEP -1
120 LET A = (A*X)+C(I)
130 NEXT I
140 PRINT A
150 END</syntaxhighlight>
{{out}}
<pre>Same as Chipmunk Basic entry.</pre>
 
==={{header|MSX Basic}}===
The [[#Minimal_BASIC|Minimal BASIC]] solution works without any changes.
 
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">FUNCTION Horner (coeffs(), x)
acumulador = 0
FOR i = UBOUND(coeffs) TO LBOUND(coeffs) STEP -1
acumulador = (acumulador * x) + coeffs(i)
NEXT i
Horner = acumulador
END FUNCTION
 
x = 3
DIM coeffs(3)
DATA -19, 7, -4, 6
FOR a = LBOUND(coeffs) TO UBOUND(coeffs)
READ coeffs(a)
NEXT a
 
PRINT "Horner's algorithm for the polynomial 6*x^3 - 4*x^2 + 7*x - 19 when x = 3 is: ";
PRINT Horner(coeffs(), x)
END</syntaxhighlight>
 
==={{header|Quite BASIC}}===
The [[#Minimal_BASIC|Minimal BASIC]] solution works without any changes.
 
==={{header|Yabasic}}===
<syntaxhighlight lang="vb">x = 3
dim coeffs(4)
coeffs(0) = -19
coeffs(1) = 7
coeffs(2) = -4
coeffs(3) = 6
print "Horner's algorithm for the polynomial ";
print "6*x^3 - 4*x^2 + 7*x - 19 when x = 3: ";
print AlgoritmoHorner(coeffs, x)
end
 
sub AlgoritmoHorner(coeffs, x)
local acumulador, i
acumulador = 0
for i = arraysize(coeffs(),1) to 0 step -1
acumulador = (acumulador * x) + coeffs(i)
next i
return acumulador
end sub</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
 
=={{header|Batch File}}==
<syntaxhighlight lang="dos">
@echo off
 
call:horners a:-19 b:7 c:-4 d:6 x:3
call:horners x:3 a:-19 c:-4 d:6 b:7
pause>nul
exit /b
 
:horners
setlocal enabledelayedexpansion
set a=0
set b=0
set c=0
set d=0
set x=0
 
for %%i in (%*) do (
for /f "tokens=1,2 delims=:" %%j in ("%%i") do (
set %%j=%%k
)
)
set /a return=((((0)*%x%+%d%)*%x%+(%c%))*%x%+%b%)*%x%+(%a%)
echo %return%
exit /b
</syntaxhighlight>
{{out}}
<pre>
>a:-19 b:7 c:-4 d:6 x:3
128
>x:3 a:-19 c:-4 d:6 b:7
128
</pre>
 
=={{header|BBC BASIC}}==
<langsyntaxhighlight lang="bbcbasic"> DIM coefficients(3)
coefficients() = -19, 7, -4, 6
PRINT FNhorner(coefficients(), 3)
Line 142 ⟶ 531:
v = v * x + coeffs(i%)
NEXT
= v</langsyntaxhighlight>
 
=={{header|Bracmat}}==
<syntaxhighlight lang="bracmat">( ( Horner
= accumulator coefficients x coeff
. !arg:(?coefficients.?x)
& 0:?accumulator
& whl
' ( !coefficients:?coefficients #%@?coeff
& !accumulator*!x+!coeff:?accumulator
)
& !accumulator
)
& Horner$(-19 7 -4 6.3)
);</syntaxhighlight>
Output:
<pre>128</pre>
 
=={{header|C}}==
{{trans|Fortran}}
<langsyntaxhighlight lang="c">#include <stdio.h>
 
double horner(double *coeffs, int s, double x)
Line 167 ⟶ 572:
printf("%5.1f\n", horner(coeffs, sizeof(coeffs)/sizeof(double), 3.0));
return 0;
}</langsyntaxhighlight>
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">using System;
using System.Linq;
 
Line 185 ⟶ 590:
Console.WriteLine(Horner(new[] { -19.0, 7.0, -4.0, 6.0 }, 3.0));
}
}</langsyntaxhighlight>
Output:
<pre>128</pre>
Line 192 ⟶ 597:
The same C function works too, but another solution could be:
 
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <vector>
 
Line 212 ⟶ 617:
cout << horner(v, 3.0) << endl;
return 0;
}</langsyntaxhighlight>
 
Yet another solution, which is more idiomatic in C++ and works on any bidirectional sequence:
 
<langsyntaxhighlight lang="cpp">
#include <iostream>
 
Line 233 ⟶ 638:
std::cout << horner(c, c + 4, 3) << std::endl;
}
</syntaxhighlight>
</lang>
 
=={{header|Clojure}}==
<langsyntaxhighlight lang="clojure">(defn horner [coeffs x]
(reduce #(fn-> [acc coeff] (+%1 (* acc x) coeff(+ %2)) (reverse coeffs)))
 
(println (horner [-19 7 -4 6] 3))</syntaxhighlight>
 
(println (horner [-19 7 -4 6] 3))</lang>
=={{header|CoffeeScript}}==
<langsyntaxhighlight lang="coffeescript">
eval_poly = (x, coefficients) ->
# coefficients are for ascending powers
Line 251 ⟶ 657:
console.log eval_poly 10, [4, 3, 2, 1] # 1234
console.log eval_poly 2, [1, 1, 0, 0, 1] # 19
</syntaxhighlight>
</lang>
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">(defun horner (coeffs x)
(reduce #'(lambda (coef acc) (+ (* acc x) coef))
coeffs :from-end t :initial-value 0))</langsyntaxhighlight>
 
Alternate version using LOOP. Coefficients are passed in a vector.
 
<syntaxhighlight lang="lisp">(defun horner (x a)
(loop :with y = 0
:for i :from (1- (length a)) :downto 0
:do (setf y (+ (aref a i) (* y x)))
:finally (return y)))
 
(horner 1.414 #(-2 0 1))</syntaxhighlight>
 
=={{header|D}}==
The poly() function of the standard library std.math module uses Horner's rule:
<syntaxhighlight lang="d">void main() {
<lang d>import std.stdio, std.math;
void main() {
import std.stdio, std.math;
double x = 3.0;
static real[] pp = [-19,7,-4,6];
 
poly(x,pp).writeln;
void main() {
}
writeln(poly(3.0, [-19, 7, -4, 6]));
}</langsyntaxhighlight>
Basic implementation:
<langsyntaxhighlight lang="d">import std.stdio, std.traits;
 
CommonType!(U, V) horner(U, V)(U[] p, V x) pure nothrow @nogc {
typeof(return) accumulator = 0;
foreach_reverse (c; p)
Line 276 ⟶ 696:
 
void main() {
writeln([-19, 7, -4, 6].horner(3.0)).writeln;
}</langsyntaxhighlight>
More functional style:
<langsyntaxhighlight lang="d">import std.stdio, std.algorithm, std.range;
 
auto horner(T, U)(in T[] p, in U x) pure nothrow @nogc {
return reduce!((a, b) => a * x + b)(U(0), p.retro);
}
Line 287 ⟶ 707:
void main() {
[-19, 7, -4, 6].horner(3.0).writeln;
}</langsyntaxhighlight>
 
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|Classes,SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
function EvaluatePolynomial(Args: array of double; X: double): double;
{Evaluate polynomial using Horner's rule }
var I: integer;
begin
Result:=0;
for I:=High(Args) downto 0 do
Result:=(Result * X ) + Args[I];
end;
 
function GetPolynomialStr(Args: array of double; VarName: string): string;
{Return a string display the polynomial in normal format}
{for example: 6.0 X^3 - 4.0 X^2 + 7.0 X - 19.0}
var I: integer;
begin
Result:='';
for I:=High(Args) downto 0 do
begin
if Args[I]>0 then
begin
if I<>High(Args) then Result:=Result+' + ';
end
else Result:=Result+' - ';
Result:=Result+FloatToStrF(Abs(Args[I]),ffFixed,18,1);
if I>0 then Result:=Result+' '+VarName;
if I>1 then Result:=Result+'^'+IntToStr(I);
end;
end;
 
 
procedure ShowHornerPoly(Memo: TMemo; Args: array of double; X: double);
{Evaluate polynomial, show formated polynomal and the result}
var R: double;
begin
R:=EvaluatePolynomial(Args,X);
Memo.Lines.Add(FloatToStrF(R,ffFixed, 18,1));
Memo.Lines.Add(GetPolynomialStr(Args,'X'));
end;
 
 
procedure DoHornerPoly(Memo: TMemo);
begin
ShowHornerPoly(Memo,[-19, 7, -4, 6],3)
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
128.0
6.0 X^3 - 4.0 X^2 + 7.0 X - 19.0
</pre>
 
=={{header|E}}==
 
<langsyntaxhighlight lang="e">def makeHornerPolynomial(coefficients :List) {
def indexing := (0..!coefficients.size()).descending()
return def hornerPolynomial(x) {
Line 300 ⟶ 779:
return acc
}
}</langsyntaxhighlight>
 
<langsyntaxhighlight lang="e">? makeHornerPolynomial([-19, 7, -4, 6])(3)
# value: 128</langsyntaxhighlight>
 
=={{header|EasyLang}}==
{{trans|C}}
<syntaxhighlight>
func horner coeffs[] x .
for i = len coeffs[] downto 1
res = res * x + coeffs[i]
.
return res
.
print horner [ -19 7 -4 6 ] 3
</syntaxhighlight>
{{out}}
<pre>
128
</pre>
 
=={{header|EchoLisp}}==
=== Functional version ===
<syntaxhighlight lang="lisp">
(define (horner x poly)
(foldr (lambda (coeff acc) (+ coeff (* acc x))) 0 poly))
 
(horner 3 '(-19 7 -4 6)) → 128
</syntaxhighlight>
=== Library ===
<syntaxhighlight lang="lisp">
(lib 'math)
Lib: math.lib loaded.
 
(define P '(-19 7 -4 6))
(poly->string 'x P) → 6x^3 -4x^2 +7x -19
(poly 3 P) → 128
</syntaxhighlight>
 
=={{header|EDSAC order code}}==
<syntaxhighlight lang="edsac">
[Copyright <2021> <ERIK SARGSYAN>
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.]
[Horner's rule for polynomial evaluation on EDSAC by Erik Sargsyan]
[EDSAC program, Initial Orders 2]
 
 
T 56 K
GK
[0] A 3 F
[1] T 9 F
[2] A 4 F [loading the address of the 1st array element into the accumulator]
[3] A 14 @ [add an instruction code with a zero address field]
[4] T 14 @ [writing the generated instruction, zeroing the accumulator]
[5 loop] A 1 F [load the counter of unprocessed array elements into the accumulator]
[6] S 21 @ [Subtract the constant = 1]
[7] E 10 @ [if (acc >= 0) goto 10 else end]
[8] T 300 F [zeroing the accumulator]
[9] E 0 F [breakpoint, end of program]
[10] T 1 F [update the counter value and reset the accumulator]
[11] V 2 F [multiplying the number in cell 2 by the number in the multiplier register]
[12] L 1024 F [shift the number in the accumulator 12 bits to the left]
[13] L 4 F [shift the number in the accumulator 4 bits to the left]
[14 r1] A 0 F [loading the value from cell 0 into the accumulator]
[15] T 2 F [writing this value to the working cell, zeroing the accumulator]
[16] A 21 @ [loading into accumulator constant value = 1]
[17] L 0 D [shift the number in the accumulator 1 bit to the left]
[18] A 14 @ [add the code of the instruction executed in the previous step]
[19] T 14 @ [write the generated instruction into memory]
[20] E 5 @ [repeat all operations; accumulator zeroed]
[21 const 1] P 0 D [1]
 
GK
[0] H 10 @ [writing X0 to the multiplier register]
[1] A 11 @ [loading into the accumulator of the degree of the polynomial]
[2] T 1 F [writing the degree of a polynomial in cell 1]
[3] A 13 @ [loading the leading coefficient into the accumulator]
[4] T 2 F [writing the senior coefficient to the working cell 2]
[5] A 12 @ [loading the address of the 1st array element into the accumulator]
[6] T 4 F [writing the address of the 1st element of the array]
[7] A 7 @ [\ call]
[8] G 56 F
[9] Z 0 F
[10] P 3 F [X0 is a fixed value of X, by which we calculate the value of the polynomial]
[11 power] P 2 F [polynomial degree times 2]
[12 addr] P 14 @ [address of the 1st element of the array]
[13] P 3 F [a4 = 6]
[14] P 8 D [a3 = 17]
[15] P 9 F [a2 = 18]
[16] P 12 D [a1 = 25]
[17] P 316 F [a0 = 632]
EZPF
</syntaxhighlight>
{{out}}
<pre>
Cell 2 will contain the number 12878
</pre>
 
=={{header|Elena}}==
{{trans|C#}}
ELENA 5.0 :
<syntaxhighlight lang="elena">import extensions;
import system'routines;
horner(coefficients,variable)
{
^ coefficients.clone().sequenceReverse().accumulate(new Real(),(accumulator,coefficient => accumulator * variable + coefficient))
}
public program()
{
console.printLine(horner(new real[]{-19.0r, 7.0r, -4.0r, 6.0r}, 3.0r))
}</syntaxhighlight>
{{out}}
<pre>
128.0
</pre>
 
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">horner = fn(list, x)-> List.foldr(list, 0, fn(c,acc)-> x*acc+c end) end
 
IO.puts horner.([-19,7,-4,6], 3)</syntaxhighlight>
 
{{out}}
<pre>
128
</pre>
 
=={{header|Emacs Lisp}}==
{{trans|Common Lisp}}
<syntaxhighlight lang="lisp">(require 'cl-lib)
 
(defun horner (coeffs x)
(cl-reduce #'(lambda (coef acc) (+ (* acc x) coef))
coeffs :from-end t :initial-value 0))
 
(horner '(-19 7 -4 6) 3)</syntaxhighlight>
 
{{out}}
 
128
 
=={{header|Erlang}}==
<langsyntaxhighlight lang="erlang">
horner(L,X) ->
lists:foldl(fun(C, Acc) -> X*Acc+C end,0, lists:reverse(L)).
t() ->
horner([-19,7,-4,6], 3).
</syntaxhighlight>
</lang>
 
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM HORNER
 
! 2 3
! polynomial is -19+7x-4x +6x
!
 
DIM C[3]
 
PROCEDURE HORNER(C[],X->RES)
LOCAL I%,V
FOR I%=UBOUND(C,1) TO 0 STEP -1 DO
V=V*X+C[I%]
END FOR
RES=V
END PROCEDURE
 
BEGIN
C[]=(-19,7,-4,6)
HORNER(C[],3->RES)
PRINT(RES)
END PROGRAM
</syntaxhighlight>
 
=={{header|Euler Math Toolbox}}==
 
<syntaxhighlight lang="euler math toolbox">
<lang Euler Math Toolbox>
>function horner (x,v) ...
$ n=cols(v); res=v{n};
Line 334 ⟶ 985:
3 2
6 x - 4 x + 7 x - 19
</syntaxhighlight>
</lang>
 
 
=={{header|F Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
let horner l x =
List.rev l |> List.fold ( fun acc c -> x*acc+c) 0
 
horner [-19;7;-4;6] 3
</syntaxhighlight>
</lang>
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">: horner ( coeff x -- res )
[ <reversed> 0 ] dip '[ [ _ * ] dip + ] reduce ;</langsyntaxhighlight>
 
( scratchpad ) { -19 7 -4 6 } 3 horner .
Line 352 ⟶ 1,004:
 
=={{header|Forth}}==
<langsyntaxhighlight lang="forth">: fhorner ( coeffs len F: x -- F: val )
0e
floats bounds ?do
Line 361 ⟶ 1,013:
create coeffs 6e f, -4e f, 7e f, -19e f,
 
coeffs 4 3e fhorner f. \ 128.</langsyntaxhighlight>
 
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<langsyntaxhighlight lang="fortran">program test_horner
 
implicit none
 
write (*, '(f5.1)') horner ((/[-19.0, 7.0, -4.0, 6.0/)], 3.0)
 
contains
Line 376 ⟶ 1,028:
 
implicit none
real, dimension (0:), intent (in) :: coeffs
real, intent (in) :: x
real :: res
integer :: i
 
res = 0.0coeffs(ubound(coeffs,1))
do i = size ubound(coeffs,1)-1, 10, -1
res = res * x + coeffs (i)
end do
Line 388 ⟶ 1,040:
end function horner
 
end program test_horner</langsyntaxhighlight>
Output:
<pre>128.0</pre>
 
=== Fortran 77 ===
<langsyntaxhighlight lang="fortran"> FUNCTION HORNER(N,A,X)
IMPLICIT NONE
INTEGER I,N
DOUBLE PRECISION A(N),X,Y,HORNER
Y = A(N)
DO I = N - 1,1,-1
Y = Y*X + A(I)
END DO
HORNER=Y
END</langsyntaxhighlight>
 
As a matter of fact, computing the derivative is not much more difficult (see [http://www.cs.berkeley.edu/~wkahan/Math128/Poly.pdf Roundoff in Polynomial Evaluation], W. Kahan, 1986). The following subroutine computes both polynomial value and derivative for argument x.
 
<langsyntaxhighlight lang="fortran"> SUBROUTINE HORNER2(N,A,X,Y,Z)
C COMPUTE POLYNOMIAL VALUE AND DERIVATIVE
C SEE "ROUNDOFF IN POLYNOMIAL EVALUATION", W. KAHAN, 1986
C POLY: A(1) + A(2)*X + ... + A(N)*X**(N-1)
C Y: VALUE, Z: DERIVATIVE
IMPLICIT NONE
INTEGER I,N
DOUBLE PRECISION A(N),X,Y,Z
Z = 0.0D0
Y = A(N)
DO 10 I = N - 1,1,-1
Z = Z*X + Y
10 Y = Y*X + A(I)
END</lang>
</syntaxhighlight>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">
Function AlgoritmoHorner(coeffs() As Integer, x As Integer) As Integer
Dim As Integer i, acumulador = 0
For i = Ubound(coeffs, 1) To 0 Step -1
acumulador = (acumulador * x) + coeffs(i)
Next i
Return acumulador
End Function
 
Dim As Integer x = 3
Dim As Integer coeficientes(3) = {-19, 7, -4, 6}
Print "Algoritmo de Horner para el polinomio 6*x^3 - 4*x^2 + 7*x - 19 para x = 3: ";
Print AlgoritmoHorner(coeficientes(), x)
End
</syntaxhighlight>
{{out}}
<pre>
Algoritmo de Horner para el polinomio 6*x^3 - 4*x^2 + 7*x - 19 para x = 3: 128
</pre>
 
=={{header|FunL}}==
{{trans|Haskell}}
<syntaxhighlight lang="funl">import lists.foldr
 
def horner( poly, x ) = foldr( \a, b -> a + b*x, 0, poly )
 
println( horner([-19, 7, -4, 6], 3) )</syntaxhighlight>
 
{{out}}
 
<pre>
128
</pre>
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">include "NSLog.incl"
 
local fn horner( coeffs as CFArrayRef, x as NSInteger ) as double
CFArrayRef reversedCoeffs
CFNumberRef num
double accumulator = 0.0
 
// Reverse coeffs array
reversedCoeffs = fn EnumeratorAllObjects( fn ArrayReverseObjectEnumerator( coeffs ) )
 
// Iterate over CFNumberRefs in reversed array, convert to double values, calculate and add to accumulator
for num in reversedCoeffs
accumulator = ( accumulator * x ) + fn NumberDoubleValue( num )
next
end fn = accumulator
 
CFArrayRef coeffs
 
coeffs = @[@-19.0, @7.0, @-4.0, @6.0]
NSLog( @"%7.1f", fn horner( coeffs, 3 ) )
 
coeffs = @[@4.0, @3.0, @2.0, @1.0]
NSLog( @"%7.1f", fn horner( coeffs, 10 ) )
 
coeffs = @[@1, @1, @0, @0, @1]
NSLog( @"%7.1f", fn horner( coeffs, 2 ) )
 
coeffs = @[@1.2, @2.3, @3.4, @4.5, @5.6]
NSLog( @"%7.1f", fn horner( coeffs, 8 ) )
 
coeffs = @[@1, @0, @1, @1, @1, @0, @0, @1]
NSLog( @"%7.1f", fn horner( coeffs, 2 ) )
 
HandleEvents</syntaxhighlight>
 
{{out}}
 
<pre>
128.0
1234.0
19.0
25478.8
157.0
</pre>
 
=={{header|GAP}}==
<langsyntaxhighlight lang="gap"># The idiomatic way to compute with polynomials
 
x := Indeterminate(Rationals, "x");
Line 453 ⟶ 1,187:
 
Horner(u, 3);
# 128</langsyntaxhighlight>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 469 ⟶ 1,203:
func main() {
fmt.Println(horner(3, []int64{-19, 7, -4, 6}))
}</langsyntaxhighlight>
Output:
<pre>
Line 477 ⟶ 1,211:
=={{header|Groovy}}==
Solution:
<langsyntaxhighlight lang="groovy">def hornersRule = { coeff, x -> coeff.reverse().inject(0) { accum, c -> (accum * x) + c } }</langsyntaxhighlight>
 
Test includes demonstration of [[currying]] to create polynomial functions of one variable from generic Horner's rule calculation. Also demonstrates constructing the derivative function for the given polynomial. And finally demonstrates in the Newton-Raphson method to find one of the polynomial's roots using the polynomial and derivative functions constructed earlier.
<langsyntaxhighlight lang="groovy">def coefficients = [-19g, 7g, -4g, 6g]
println (["p coefficients":coefficients])
 
Line 502 ⟶ 1,236:
 
def root = newtonRaphson(3g, testPoly, testDeriv)
println ([root:root.toString()[0..5], "p(root)":testPoly(root).toString()[0..5], "p'(root)":testDeriv(root).toString()[0..5]])</langsyntaxhighlight>
 
Output:
Line 514 ⟶ 1,248:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">horner :: (Num a) => a -> [a] -> a
horner x = foldr (\a b -> a + b*x) 0
 
main = print $ horner 3 [-19, 7, -4, 6]</langsyntaxhighlight>
 
=={{header|HicEst}}==
<langsyntaxhighlight HicEstlang="hicest">REAL :: x=3, coeffs(4)
DATA coeffs/-19.0, 7.0, -4.0, 6.0/
 
Line 531 ⟶ 1,265:
Horner = x*Horner + c(i)
ENDDO
END</langsyntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
 
<syntaxhighlight lang="icon">
<lang Icon>
procedure poly_eval (x, coeffs)
accumulator := 0
Line 546 ⟶ 1,280:
write (poly_eval (3, [-19, 7, -4, 6]))
end
</syntaxhighlight>
</lang>
 
=={{header|J}}==
'''Solution''':<langsyntaxhighlight lang="j">
horner =: (#."0 _ |.)~ NB. Tacit
horner =: 4 [: +`*/ '[: }: (+,@,. *&y)/x' NB. Alternate tacit (equivalent)
horner =: 4 : ' (+ *&y)/x' NB. Alternate explicit (equivalent)
 
</syntaxhighlight>
horner1 =: (#."0 _ |.)~
'''Example''':<syntaxhighlight lang="j"> _19 7 _4 6 horner 3
 
128</syntaxhighlight>
horner2=: [: +`*/ [: }: ,@,. NB. Alternate
</lang>
'''Example''':<lang j> _19 7 _4 6 horner 3
128</lang>
'''Note:'''<br>
The primitive verb <code>p.</code> would normally be used to evaluate polynomials.
<langsyntaxhighlight lang="j"> _19 7 _4 6 p. 3
128</langsyntaxhighlight>
 
=={{header|Java}}==
{{works with|Java|1.5+}}
<langsyntaxhighlight lang="java5">import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
Line 588 ⟶ 1,319:
return accumulator;
}
}</langsyntaxhighlight>
Output:
<pre>128.0</pre>
Line 596 ⟶ 1,327:
 
{{trans|Haskell}}
<langsyntaxhighlight lang="javascript">function horner(coeffs, x) {
return coeffs.reduceRight( function(acc, coeff) { return(acc * x + coeff) }, 0);
}
printconsole.log(horner([-19,7,-4,6],3)); // ==> 128
</syntaxhighlight>
</lang>
 
=={{header|jq}}==
<syntaxhighlight lang=jq>
# Input: an array of coefficients specifying the polynomial
# to be evaluated at $x, where .[0] is the constant
def horner($x):
. as $coefficients
| reduce range(length-1; -1; -1) as $i (0; . * $x + $coefficients[$i]);
 
# Example
[-19, 7, -4, 6] | horner(3)
</syntaxhighlight>
 
'''Invocation''': $JQ -n -f horner.jq
 
where $JQ is either jq or gojq
 
{{output}}
<pre>
128
</pre>
 
=={{header|Julia}}==
{{works with|Julia|1.x}}
 
'''Imperative''':
<syntaxhighlight lang="julia">function horner(coefs, x)
s = coefs[end] * one(x)
for k in length(coefs)-1:-1:1
s = coefs[k] + x * s
end
return s
end
 
@show horner([-19, 7, -4, 6], 3)</syntaxhighlight>
 
{{out}}
<pre>horner([-19, 7, -4, 6], 3) = 128</pre>
 
'''Functional''':
<syntaxhighlight lang="julia">horner2(coefs, x) = foldr((u, v) -> u + x * v, coefs, init=zero(promote_type(typeof(x),eltype(coefs))))
 
@show horner2([-19, 7, -4, 6], 3)</syntaxhighlight>
 
{{out}}
<pre>horner2([-19, 7, -4, 6], 3) = 128</pre>
 
'''Note''':
In Julia 1.4 or later one would normally use the built-in '''evalpoly''' function for this purpose:
<syntaxhighlight lang="julia">
@show evalpoly(3, [-19, 7, -4, 6]) </syntaxhighlight>
 
{{out}}
<pre>evalpoly(3, [-19, 7, -4, 6]) = 128</pre>
 
=={{header|K}}==
<syntaxhighlight lang="k">
<lang K>
horner:{y _sv|x}
horner[-19 7 -4 6;3]
128
</syntaxhighlight>
</lang>
 
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.2
 
fun horner(coeffs: DoubleArray, x: Double): Double {
var sum = 0.0
for (i in coeffs.size - 1 downTo 0) sum = sum * x + coeffs[i]
return sum
}
 
fun main(args: Array<String>) {
val coeffs = doubleArrayOf(-19.0, 7.0, -4.0, 6.0)
println(horner(coeffs, 3.0))
}</syntaxhighlight>
 
{{out}}
<pre>
128.0
</pre>
 
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def horner
{def horner.r
{lambda {:p :x :r}
{if {A.empty? :p}
then :r
else {horner.r {A.rest :p} :x {+ {A.first :p} {* :x :r}}}}}}
{lambda {:p :x}
{horner.r {A.reverse :p} :x 0}}}
 
{horner {A.new -19 7 -4 6} 3}
-> 128
 
{def φ {/ {+ 1 {sqrt 5}} 2}} = 1.618033988749895
{horner {A.new -1 -1 1} φ}
-> 2.220446049250313e-16 ~ 0
 
</syntaxhighlight>
 
=={{header|Liberty BASIC}}==
<langsyntaxhighlight lang="lb">src$ = "Hello"
coefficients$ = "-19 7 -4 6" ' list coefficients of all x^0..x^n in order
x = 3
Line 629 ⟶ 1,453:
horner = accumulator
end function
</langsyntaxhighlight>
 
=={{header|Logo}}==
<langsyntaxhighlight lang="logo">to horner :x :coeffs
if empty? :coeffs [output 0]
output (first :coeffs) + (:x * horner :x bf :coeffs)
end
 
show horner 3 [-19 7 -4 6] ; 128</langsyntaxhighlight>
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">function horners_rule( coeff, x )
local res = 0
for i = #coeff, 1, -1 do
Line 650 ⟶ 1,474:
x = 3
coefficients = { -19, 7, -4, 6 }
print( horners_rule( coefficients, x ) )</langsyntaxhighlight>
 
 
=={{header|Maple}}==
<syntaxhighlight lang="maple">
<lang Maple>
applyhorner:=(L::list,x)->foldl((s,t)->s*x+t,op(ListTools:-Reverse(L))):
 
Line 660 ⟶ 1,483:
 
applyhorner([-19,7,-4,6],3);
</syntaxhighlight>
</lang>
Output:
<pre>
Line 668 ⟶ 1,491:
</pre>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">Horner[l_List, x_] := Fold[x #1 + #2 &, 0, l]
Horner[{6, -4, 7, -19}, x]
-> -19 + x (7 + x (-4 + 6 x))
 
-19 + x (7 + x (-4 + 6 x)) /. x -> 3
-> 128</langsyntaxhighlight>
 
=={{header|MATLAB}}==
<langsyntaxhighlight MATLABlang="matlab">function accumulator = hornersRule(x,coefficients)
 
accumulator = 0;
Line 685 ⟶ 1,508:
end
end</langsyntaxhighlight>
Output:
<langsyntaxhighlight MATLABlang="matlab">>> hornersRule(3,[-19, 7, -4, 6])
 
ans =
 
128</langsyntaxhighlight>
Matlab also has a built-in function "polyval" which uses Horner's Method to evaluate polynomials. The list of coefficients is in descending order of power, where as to task spec specifies ascending order.
<langsyntaxhighlight MATLABlang="matlab">>> polyval(fliplr([-19, 7, -4, 6]),3)
 
ans =
 
128</langsyntaxhighlight>
 
=={{header|Maxima}}==
<langsyntaxhighlight lang="maxima">/* Function horner already exists in Maxima, though it operates on expressions, not lists of coefficients */
horner(5*x^3+2*x+1);
x*(5*x^2+2)+1
Line 744 ⟶ 1,567:
 
poleval([0, 0, 0, 0, 1], x);
x^4</langsyntaxhighlight>
 
=={{header|Mercury}}==
<langsyntaxhighlight lang="mercury">
:- module horner.
:- interface.
Line 761 ⟶ 1,584:
 
horner(X, Cs) = list.foldr((func(C, Acc) = Acc * X + C), Cs, 0).
</syntaxhighlight>
</lang>
 
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">ИП0 1 + П0
ИПE ИПD * КИП0 + ПE
ИП0 1 - x=0 04
ИПE С/П</langsyntaxhighlight>
 
''Input:'' Р1:РС - coefficients, Р0 - number of the coefficients, РD - ''x''.
 
=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">MODULE Horner;
FROM RealStr IMPORT RealToStr;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;
 
PROCEDURE Horner(coeff : ARRAY OF REAL; x : REAL) : REAL;
VAR
ans : REAL;
i : CARDINAL;
BEGIN
ans := 0.0;
FOR i:=HIGH(coeff) TO 0 BY -1 DO
ans := (ans * x) + coeff[i];
END;
RETURN ans
END Horner;
 
TYPE A = ARRAY[0..3] OF REAL;
VAR
buf : ARRAY[0..63] OF CHAR;
coeff : A;
ans : REAL;
BEGIN
coeff := A{-19.0, 7.0, -4.0, 6.0};
ans := Horner(coeff, 3.0);
RealToStr(ans, buf);
WriteString(buf);
WriteLn;
ReadChar
END Horner.</syntaxhighlight>
 
=={{header|NetRexx}}==
<langsyntaxhighlight lang="netrexx">/* NetRexx */
options replace format comments java crossref savelog symbols nobinary
 
Line 783 ⟶ 1,637:
End
Say r
Say 6*x**3-4*x**2+7*x-19</langsyntaxhighlight>
'''Output:'''
<pre>128
128</pre>
 
=={{header|Nim}}==
<syntaxhighlight lang="nim"># You can also just use `reversed` proc from stdlib `algorithm` module
iterator reversed[T](x: openArray[T]): T =
for i in countdown(x.high, x.low):
yield x[i]
proc horner[T](coeffs: openArray[T], x: T): int =
for c in reversed(coeffs):
result = result * x + c
echo horner([-19, 7, -4, 6], 3)</syntaxhighlight>
 
=={{header|Oberon-2}}==
{{works with|oo2c}}
<syntaxhighlight lang="oberon2">
MODULE HornerRule;
IMPORT
Out;
TYPE
Coefs = POINTER TO ARRAY OF LONGINT;
VAR
coefs: Coefs;
PROCEDURE Eval(coefs: ARRAY OF LONGINT;size,x: LONGINT): LONGINT;
VAR
i,acc: LONGINT;
BEGIN
acc := 0;
FOR i := LEN(coefs) - 1 TO 0 BY -1 DO
acc := acc * x + coefs[i]
END;
RETURN acc
END Eval;
 
BEGIN
NEW(coefs,4);
coefs[0] := -19;
coefs[1] := 7;
coefs[2] := -4;
coefs[3] := 6;
Out.Int(Eval(coefs^,4,3),0);Out.Ln
END HornerRule.
</syntaxhighlight>
{{out}}
<pre>
128
</pre>
 
=={{header|Objeck}}==
<syntaxhighlight lang="objeck">
class Horner {
function : Main(args : String[]) ~ Nil {
coeffs := Collection.FloatVector->New();
coeffs->AddBack(-19.0);
coeffs->AddBack(7.0);
coeffs->AddBack(-4.0);
coeffs->AddBack(6.0);
PolyEval(coeffs, 3)->PrintLine();
}
function : PolyEval(coefficients : Collection.FloatVector , x : Float) ~ Float {
accumulator := coefficients->Get(coefficients->Size() - 1);
for(i := coefficients->Size() - 2; i > -1; i -= 1;) {
accumulator := (accumulator * x) + coefficients->Get(i);
};
return accumulator;
}
}
</syntaxhighlight>
 
=={{header|Objective-C}}==
{{works with|Mac OS X|10.6+}} Using blocks
<langsyntaxhighlight lang="objc">#import <Foundation/Foundation.h>
 
typedef double (^mfunc)(double, double);
Line 831 ⟶ 1,757:
}
return 0;
}</langsyntaxhighlight>
 
=={{header|Objeck}}==
<lang objeck>
class Horner {
function : Main(args : String[]) ~ Nil {
coeffs := Collection.FloatVector->New();
coeffs->AddBack(-19.0);
coeffs->AddBack(7.0);
coeffs->AddBack(-4.0);
coeffs->AddBack(6.0);
PolyEval(coeffs, 3)->PrintLine();
}
function : PolyEval(coefficients : Collection.FloatVector , x : Float) ~ Float {
accumulator := coefficients->Get(coefficients->Size() - 1);
for(i := coefficients->Size() - 2; i > -1; i -= 1;) {
accumulator := (accumulator * x) + coefficients->Get(i);
};
return accumulator;
}
}
</lang>
 
=={{header|OCaml}}==
 
<langsyntaxhighlight lang="ocaml"># let horner coeffs x =
List.fold_left (fun acc coef -> acc * x + coef) 0 (List.rev coeffs) ;;
val horner : int list -> int -> int = <fun>
Line 864 ⟶ 1,767:
# let coeffs = [-19; 7; -4; 6] in
horner coeffs 3 ;;
- : int = 128</langsyntaxhighlight>
It's also possible to do fold_right instead of reversing and doing fold_left; but fold_right is not tail-recursive.
 
=={{header|Octave}}==
<langsyntaxhighlight lang="octave">function r = horner(a, x)
r = 0.0;
for i = length(a):-1:1
Line 875 ⟶ 1,778:
endfunction
 
horner([-19, 7, -4, 6], 3)</langsyntaxhighlight>
 
=={{header|ooRexx}}==
<langsyntaxhighlight lang="oorexx">/* Rexx ---------------------------------------------------------------
* 04.03.2014 Walter Pachl
*--------------------------------------------------------------------*/
Line 889 ⟶ 1,792:
End
Say r
Say 6*x**3-4*x**2+7*x-19</langsyntaxhighlight>
'''Output:'''
<pre>128
128</pre>
 
=={{header|Oz}}==
<langsyntaxhighlight lang="oz">declare
fun {Horner Coeffs X}
{FoldL1 {Reverse Coeffs}
Line 907 ⟶ 1,810:
end
in
{Show {Horner [~19 7 ~4 6] 3}}</langsyntaxhighlight>
 
=={{header|PARI/GP}}==
Also note that Pari has a polynomial type. Evaluating these is as simple as <code>subst(P,variable(P),x)</code>.
<langsyntaxhighlight lang="parigp">horner(v,x)={
my(s=0);
forstep(i=#v,1,-1,s=s*x+v[i]);
s
};</langsyntaxhighlight>
 
=={{header|Pascal}}==
<langsyntaxhighlight lang="pascal">Program HornerDemo(output);
 
function horner(a: array of double; x: double): double;
Line 935 ⟶ 1,838:
write ('Horner calculated polynomial of 6*x^3 - 4*x^2 + 7*x - 19 for x = 3: ');
writeln (horner (poly, 3.0):8:4);
end.</langsyntaxhighlight>
Output:
<pre>Horner calculated polynomial of 6*x^3 - 4*x^2 + 7*x - 19 for x = 3: 128.0000
Line 941 ⟶ 1,844:
 
=={{header|Perl}}==
<langsyntaxhighlight Perllang="perl">use 5.10.0;
use strict;
use warnings;
Line 954 ⟶ 1,857:
my @coeff = (-19.0, 7, -4, 6);
my $x = 3;
say horner @coeff, $x;</langsyntaxhighlight>
 
===<!-- Perl -->Functional version===
<langsyntaxhighlight lang="perl">use strict;
use List::Util qw(reduce);
 
Line 967 ⟶ 1,870:
my @coeff = (-19.0, 7, -4, 6);
my $x = 3;
print horner(\@coeff, $x), "\n";</langsyntaxhighlight>
 
===<!-- Perl -->Recursive version===
<langsyntaxhighlight lang="perl">sub horner {
my ($coeff, $x) = @_;
@$coeff and
Line 976 ⟶ 1,879:
}
print horner( [ -19, 7, -4, 6 ], 3 );</langsyntaxhighlight>
 
=={{header|Perl 6}}==
<lang perl6>sub horner ( @coeffs, $x ) {
@coeffs.reverse.reduce: { $^a * $x + $^b };
}
 
say horner( [ -19, 7, -4, 6 ], 3 );</lang>
 
A recursive version would spare us the need for reversing the list of coeffcients (and thus possibly allowing progressive evaluation with lazy lists?). However, special care must be taken in order to write it, because the way Perl 6 implements lists is not optimized for this kind of treatment. [[Lisp]]-style lists are, and fortunately it is possible to emulate them with [http://doc.perl6.org/type/Pair Pairs] and the reduction meta-operator:
 
<lang perl6>multi horner(Numeric $c, $) { $c }
multi horner(Pair $c, $x) {
$c.key + $x * horner( $c.value, $x )
}
print horner( [=>](-19, 7, -4, 6 ), 3 );</lang>
 
An other possibility would consist in creating a list of functions and chain them with a composition operator.
 
<math>\begin{align}
P(x) & = & c_0 + c_1 x + \ldots + c_n x^n\\
& = & c_0 + x (c_1 + \ldots + c_n x^{n-1})\\
& = & f_0(c_1 + \ldots + c_n x^{n-1})\\
& = & f_0(f_1(c_2 + \ldots + c_n x^{n-2}))\\
& = & (f_0 o f_1 o \ldots o f_n)(0)
\end{align}</math>
 
where <math>(f_n)</math> is a family of function such that:
 
<math>f_n(y) = c_n + x y</math>
 
The Horner rule can then be implemented without reversing the list of coefficients. It could then be applied to a potentially infinite list.
 
<lang perl6>sub infix:<o>(&f, &g) { -> $x { &f(&g($x)) } }
 
sub horner ( @c, $x ) {
[\o] map { -> $u { $_ + $x * $u } }, @c;
}
 
say map { .(0) }, horner( [ -19, 7, -4, 6 ], 3 );
 
# compute progressive approximations of exp(2)
my @c := 1 X/ 1, [\*] 1 ... *;
 
say .(0) for horner( @c, 2 );
</lang>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">horner</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">coeff</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">coeff</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">*</span><span style="color: #000000;">x</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">coeff</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">horner</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,{-</span><span style="color: #000000;">19</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">7</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">6</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>-19 2 -34 128
128
1
</pre>
3
5
6.333333
7
7.266667
7.355556
7.380952
7.387302
^C</pre>
 
=={{header|PHP}}==
<langsyntaxhighlight lang="php"><?php
function horner($coeff, $x) {
$result = 0;
Line 1,049 ⟶ 1,911:
$x = 3;
echo horner($coeff, $x), "\n";
?></langsyntaxhighlight>
 
===Functional version===
{{works with|PHP|5.3+}}
<langsyntaxhighlight lang="php"><?php
function horner($coeff, $x) {
return array_reduce(array_reverse($coeff), function ($a, $b) use ($x) { return $a * $x + $b; }, 0);
Line 1,061 ⟶ 1,923:
$x = 3;
echo horner($coeff, $x), "\n";
?></langsyntaxhighlight>
 
=={{header|Picat}}==
===Recursion===
<syntaxhighlight lang="picat">horner([],_X,0).
horner([H|T],X,V) :-
horner(T,X,V1),
V = V1 * X + H.</syntaxhighlight>
 
===Iterative===
<syntaxhighlight lang="picat">horner2(Coeff, X, V) =>
Acc = 0,
foreach(I in Coeff.length..-1..1)
Acc := Acc*X + Coeff[I]
end,
V = Acc.</syntaxhighlight>
 
===Functional approach===
<syntaxhighlight lang="picat">h3(X,A,B) = A+B*X.
horner3(Coeff, X) = fold($h3(X),0,Coeff.reverse()).</syntaxhighlight>
 
===Test===
<syntaxhighlight lang="picat">go =>
horner([-19, 7, -4, 6], 3, V),
println(V),
horner2([-19, 7, -4, 6], 3, V2),
println(V2),
V3 = horner3([-19, 7, -4, 6], 3),
println(V3),
nl.</syntaxhighlight>
 
{{out}}
<pre>128
128
128</pre>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de horner (Coeffs X)
(let Res 0
(for C (reverse Coeffs)
(setq Res (+ C (* X Res))) ) ) )</langsyntaxhighlight>
<langsyntaxhighlight PicoLisplang="picolisp">: (horner (-19.0 7.0 -4.0 6.0) 3.0)
-> 128</langsyntaxhighlight>
 
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
<lang PL/I>
declare (i, n) fixed binary, (x, value) float; /* 11 May 2010 */
get (x);
Line 1,085 ⟶ 1,983:
put (value);
end;
</syntaxhighlight>
</lang>
 
=={{header|Potion}}==
<syntaxhighlight lang="potion">horner = (x, coef) :
result = 0
coef reverse each (a) :
result = (result * x) + a
.
result
.
 
horner(3, (-19, 7, -4, 6)) print</syntaxhighlight>
 
=={{header|PowerShell}}==
{{works with|PowerShell|4.0}}
<syntaxhighlight lang="powershell">
function horner($coefficients, $x) {
$accumulator = 0
foreach($i in ($coefficients.Count-1)..0){
$accumulator = ( $accumulator * $x ) + $coefficients[$i]
}
$accumulator
}
$coefficients = @(-19, 7, -4, 6)
$x = 3
horner $coefficients $x
</syntaxhighlight>
<b>Output:</b>
<pre>
128
</pre>
 
=={{header|Prolog}}==
Tested with SWI-Prolog. Works with other dialects.
<langsyntaxhighlight Prologlang="prolog">horner([], _X, 0).
 
horner([H|T], X, V) :-
horner(T, X, V1),
V is V1 * X + H.
</syntaxhighlight>
</lang>
Output :
<langsyntaxhighlight Prologlang="prolog"> ?- horner([-19, 7, -4, 6], 3, V).
V = 128.</langsyntaxhighlight>
 
===FunctionnalFunctional approach===
Works with SWI-Prolog and module lambda, written by <b>Ulrich Neumerkel</b> found there http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl
<langsyntaxhighlight Prologlang="prolog">:- use_module(library(lambda)).
 
 
Line 1,113 ⟶ 2,041:
f_horner(L, V, R) :-
foldr(\X^Y^Z^(Z is X * V + Y), 0, L, R).
</syntaxhighlight>
</lang>
 
===Functional syntax (Ciao)===
Works with Ciao (https://github.com/ciao-lang/ciao) and the fsyntax package:
<syntaxhighlight lang="prolog">
:- module(_, [horner/3], [fsyntax, hiord]).
:- use_module(library(hiordlib)).
horner(L, X) := ~foldr((''(H,V0,V) :- V is V0*X + H), L, 0).
</syntaxhighlight>
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">Procedure Horner(List Coefficients(), b)
Define result
ForEach Coefficients()
Line 1,122 ⟶ 2,058:
Next
ProcedureReturn result
EndProcedure</langsyntaxhighlight>
 
'''Implemented as
<langsyntaxhighlight PureBasiclang="purebasic">NewList a()
AddElement(a()): a()= 6
AddElement(a()): a()= -4
AddElement(a()): a()= 7
AddElement(a()): a()=-19
Debug Horner(a(),3)</langsyntaxhighlight>
'''Outputs
128
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">>>> def horner(coeffs, x):
acc = 0
for c in reversed(coeffs):
Line 1,142 ⟶ 2,078:
 
>>> horner( (-19, 7, -4, 6), 3)
128</langsyntaxhighlight>
 
===Functional version===
<langsyntaxhighlight lang="python">>>> try: from functools import reduce
except: pass
 
Line 1,152 ⟶ 2,088:
 
>>> horner( (-19, 7, -4, 6), 3)
128</langsyntaxhighlight>
 
==={{libheader|NumPy}}===
<syntaxhighlight lang="python">>>> import numpy
>>> numpy.polynomial.polynomial.polyval(3, (-19, 7, -4, 6))
128.0</syntaxhighlight>
 
=={{header|R}}==
Procedural style:
<lang r>horner <- function(a, x) {
<syntaxhighlight lang="r">horner <- function(a, x) {
iv <- 0
y <- 0
for(i in length(a):1) {
for(c in rev(a)) {
iv <- iv * x + a[i]
y <- y * x + c
}
ivy
}
 
cat(horner(c(-19, 7, -4, 6), 3), "\n")</langsyntaxhighlight>
Functional style:
<syntaxhighlight lang="r">horner <- function(x, v) {
Reduce(v, right=T, f=function(a, b) {
b * x + a
})
}</syntaxhighlight>
{{out}}
<pre>
> v <- c(-19, 7, -4, 6)
> horner(3, v)
[1] 128
</pre>
 
=={{header|Racket}}==
Translated from Haskell
 
<langsyntaxhighlight lang="racket">
#lang racket
(define (horner x l)
Line 1,175 ⟶ 2,129:
(horner 3 '(-19 7 -4 6))
 
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>sub horner ( @coeffs, $x ) {
@coeffs.reverse.reduce: { $^a * $x + $^b };
}
 
say horner( [ -19, 7, -4, 6 ], 3 );</syntaxhighlight>
 
A recursive version would spare us the need for reversing the list of coefficients. However, special care must be taken in order to write it, because the way Raku implements lists is not optimized for this kind of treatment. [[Lisp]]-style lists are, and fortunately it is possible to emulate them with [http://doc.raku.org/type/Pair Pairs] and the reduction meta-operator:
 
<syntaxhighlight lang="raku" line>multi horner(Numeric $c, $) { $c }
multi horner(Pair $c, $x) {
$c.key + $x * horner( $c.value, $x )
}
say horner( [=>](-19, 7, -4, 6 ), 3 );</syntaxhighlight>
 
We can also use the composition operator:
<syntaxhighlight lang="raku" line>sub horner ( @coeffs, $x ) {
([o] map { $_ + $x * * }, @coeffs)(0);
}
say horner( [ -19, 7, -4, 6 ], 3 );</syntaxhighlight>
 
{{out}}
<pre>128</pre>
 
One advantage of using the composition operator is that it allows for the use of an infinite list of coefficients.
<syntaxhighlight lang="raku" line>sub horner ( @coeffs, $x ) {
map { .(0) }, [\o] map { $_ + $x * * }, @coeffs;
}
say horner( [ 1 X/ (1, |[\*] 1 .. *) ], i*pi )[20];
</syntaxhighlight>
{{out}}
<pre>-0.999999999924349-5.28918515954219e-10i</pre>
 
=={{header|Rascal}}==
<langsyntaxhighlight lang="rascal">import List;
 
public int horners_rule(list[int] coefficients, int x){
Line 1,185 ⟶ 2,176:
acc = acc * x + i;}
return acc;
}</langsyntaxhighlight>
A neater and shorter solution using a reducer:
<langsyntaxhighlight lang="rascal">public int horners_rule2(list[int] coefficients, int x) = (0 | it * x + c | c <- reverse(coefficients));</langsyntaxhighlight>
Output:
<langsyntaxhighlight lang="rascal">rascal>horners_rule([-19, 7, -4, 6], 3)
int: 128
 
rascal>horners_rule2([-19, 7, -4, 6], 3)
int: 128</langsyntaxhighlight>
 
=={{header|REBOL}}==
 
<syntaxhighlight lang="rebol">REBOL []
=={{header|REXX}}==
<lang rexx>/*REXX program shows using Horner's rule for polynomial evaluation.*/
numeric digits 30 /*use extra numeric precision. */
parse arg x poly /*get value of X and coefficients*/
equ= /*start with equation clean slate*/
/*works for any degree equation. */
do deg=0 until poly=='' /*get the equation's coefficients*/
parse var poly c.deg poly /*get a equation coefficient.*/
c.deg = (c.deg+0) / 1 /*normalize it (add 0, div by 1)*/
if c.deg>=0 then c.deg = '+'c.deg /*if ¬ neg, then prefix a + sign.*/
equ=equ c.deg /*concatenate it to the equation.*/
if deg\==0 & c.deg\=0 then /*if not the first coefficient & */
equ = equ'∙x^'deg /* not 0, append power (^) of X.*/
equ = equ ' ' /*insert some blanks, look pretty*/
end /*deg*/
 
horner: func [coeffs x] [
say ' x = ' x
result: 0
say ' degree = ' deg
foreach i reverse coeffs [
say ' equation = ' equ
result: (result * x) + i
a=c.deg
]
do j=deg by -1 for deg /*apply Horner's rule.*/
return result
_ = j-1
]
a = a*x + c._
 
end /*j*/
print horner [-19 7 -4 6] 3</syntaxhighlight>
say
 
say ' answer = ' a
=={{header|REXX}}==
/*stick a fork in it, we're done.*/</lang>
===version 1===
'''output''' when the following is used for input: <tt> 3 -19 7 -4 6 </tt>
<syntaxhighlight lang="rexx">/*REXX program demonstrates using Horner's rule for polynomial evaluation. */
numeric digits 30 /*use extra numeric precision. */
parse arg x poly /*get value of X and the coefficients. */
$= /*start with a clean slate equation. */
do deg=0 until poly=='' /*get the equation's coefficients. */
parse var poly c.deg poly; c.deg=c.deg/1 /*get equation coefficient & normalize.*/
if c.deg>=0 then c.deg= '+'c.deg /*if ¬ negative, then prefix with a + */
$=$ c.deg /*concatenate it to the equation. */
if deg\==0 & c.deg\=0 then $=$'∙x^'deg /*¬1st coefficient & ¬0? Append X pow.*/
$=$ ' ' /*insert some blanks, make it look nice*/
end /*deg*/
say ' x = ' x
say ' degree = ' deg
say ' equation = ' $
a=c.deg /*A: is the accumulator (or answer). */
do j=deg-1 by -1 for deg; a=a*x+c.j /*apply Horner's rule to the equations.*/
end /*j*/
say /*display a blank line for readability.*/
say ' answer = ' a /*stick a fork in it, we're all done. */</syntaxhighlight>
'''output''' &nbsp; when the following is used for input: &nbsp; <tt> 3 &nbsp; -19 &nbsp; 7 &nbsp; -4 &nbsp; 6 </tt>
<pre>
x = 3
Line 1,230 ⟶ 2,228:
 
answer = 128
</pre>
 
===version 2===
<syntaxhighlight lang="rexx">/* REXX ---------------------------------------------------------------
* 27.07.2012 Walter Pachl
* coefficients reversed to descending order of power
* I'm used to x**2+x-3
* equation formatting prettified (coefficients 1 and 0)
*--------------------------------------------------------------------*/
Numeric Digits 30 /* use extra numeric precision. */
Parse Arg x poly /* get value of x and coefficients*/
rpoly=''
Do p=0 To words(poly)-1
rpoly=rpoly word(poly,words(poly)-p)
End
poly=rpoly
equ='' /* start with equation clean slate*/
deg=words(poly)-1
pdeg=deg
Do Until deg<0 /* get the equation's coefficients*/
Parse Var poly c.deg poly /* in descending order of powers */
c.deg=c.deg+0 /* normalize it */
If c.deg>0 & deg<pdeg Then /* positive and not first term */
prefix='+' /* prefix a + sign. */
Else prefix=''
Select
When deg=0 Then term=c.deg
When deg=1 Then
If c.deg=1 Then term='x'
Else term=c.deg'*x'
Otherwise
If c.deg=1 Then term='x^'deg
Else term=c.deg'*x^'deg
End
If c.deg<>0 Then /* build up the equation */
equ=equ||prefix||term
deg=deg-1
End
a=c.pdeg
Do p=pdeg To 1 By -1 /* apply Horner's rule. */
pm1=p-1
a=a*x+c.pm1
End
Say ' x = ' x
Say ' degree = ' pdeg
Say ' equation = ' equ
Say ' '
Say ' result = ' a</syntaxhighlight>
{{out}}
<pre> x = 3
degree = 3
equation = 6*x^3-4*x^2+7*x-19
 
result = 128</pre>
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">
coefficients = [-19, 7, -4, 6]
see "x = 3" + nl +
"degree = 3" + nl +
"equation = 6*x^3-4*x^2+7*x-19" + nl +
"result = " + horner(coefficients, 3) + nl
func horner coeffs, x
w = 0
for n = len(coeffs) to 1 step -1
w = w * x + coeffs[n]
next
return w
</syntaxhighlight>
Output:
<pre>
x = 3
degree = 3
equation = 6*x^3-4*x^2+7*x-19
result = 128
</pre>
 
Line 1,239 ⟶ 2,313:
 
This said, solution to the problem is
<syntaxhighlight lang="rlab">
<lang RLaB>
>> a = [6, -4, 7, -19]
6 -4 7 -19
Line 1,247 ⟶ 2,321:
128
 
</syntaxhighlight>
</lang>
 
=={{header|RPL}}==
===Translation of the algorithm===
Following the pseudocode given [https://web.physics.utah.edu/~detar/lessons/c++/array/node2.html here] to the letter:
≪ OVER DUP SIZE GET → a x0 p
≪ a SIZE 1 - 1 '''FOR''' j
'a(j)+x0*p' EVAL 'p' STO -1 '''STEP'''
p
≫ ≫ ‘'''HORNR'''’ STO
 
===Idiomatic one-liner===
Reducing the loop to its simplest form: one memory call, one multiplication and one addition.
≪ → x0 ≪ LIST→ 2 SWAP '''START''' x0 * + '''NEXT''' ≫ ≫ ‘'''HORNR'''’ STO
{{in}}
<pre>
{ -19 7 -4 6 } 3 HORNR
</pre>
{{out}}
<pre>
1: 128
</pre>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">def horner(coeffs, x)
coeffs.reverse.inject(0) {|acc, coeff| acc * x + coeff}
end
p horner([-19, 7, -4, 6], 3) # ==> 128</langsyntaxhighlight>
 
=={{header|Rust}}==
 
 
<lang Rust>// rust 0.9-pre
 
fn horner(v: ~[f64], x: f64) -> f64 {
let mut accum = 0.0;
let vlen = v.len();
for idx in range(0, vlen) {
accum = accum*x + v[vlen - idx - 1];
};
accum
}
 
fn main() {
let v : ~[f64] = ~[-19., 7., -4., 6.];
println!("result: {}", horner(v, 3.0));
}</lang>
 
Works with any number type. It uses a reversed left fold to accumulate the result, similar to the Haskell solution.
<lang Rust>// rust 0.9-pre
 
fn horner<T:Num>(cs:&[T], x:T) -> T {
cs.rev_iter().fold(std::num::zero::<T>(), |acc, c| (acc*x) + (*c))
}
 
fn main() {
println!("{}", horner([-19, 7, -4, 6], 3));
}</lang>
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">coef$ = "-19 7 -4 6" ' list coefficients of all x^0..x^n in order
x = 3
print horner(coef$,x) '128
Line 1,302 ⟶ 2,367:
next
horner = accum
end function</langsyntaxhighlight>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">fn horner(v: &[f64], x: f64) -> f64 {
v.iter().rev().fold(0.0, |acc, coeff| acc*x + coeff)
}
 
fn main() {
let v = [-19., 7., -4., 6.];
println!("result: {}", horner(&v, 3.0));
}</syntaxhighlight>
 
A generic version that works with any number type and much more. So much more, it's hard to imagine what that may be useful for.
<syntaxhighlight lang="rust">extern crate num; // 0.2.0
use num::Zero;
use std::ops::{Add, Mul};
 
fn horner<Arr, Arg, Out>(v: &[Arr], x: Arg) -> Out
where
Arr: Clone,
Arg: Clone,
Out: Zero + Mul<Arg, Output = Out> + Add<Arr, Output = Out>,
{
v.iter()
.rev()
.fold(Zero::zero(), |acc, coeff| acc * x.clone() + coeff.clone())
}
 
fn main() {
let v = [-19., 7., -4., 6.];
let output: f64 = horner(&v, 3.0);
println!("result: {}", output);
}</syntaxhighlight>
 
=={{header|Sather}}==
<langsyntaxhighlight lang="sather">class MAIN is
action(s, e, x:FLT):FLT is
Line 1,319 ⟶ 2,416:
#OUT + horner(|-19.0, 7.0, -4.0, 6.0|, 3.0) + "\n";
end;
end;</langsyntaxhighlight>
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">def horner(coeffs:List[Double], x:Double)=
coeffs.reverse.foldLeft(0.0){(a,c)=> a*x+c}
</syntaxhighlight>
</lang>
<langsyntaxhighlight lang="scala">val coeffs=List(-19.0, 7.0, -4.0, 6.0)
println(horner(coeffs, 3))
-> 128.0
</syntaxhighlight>
</lang>
 
=={{header|Scheme}}==
{{Works with|Scheme|R<math>^5</math>RS}}
<langsyntaxhighlight lang="scheme">(define (horner lst x)
(define (*horner lst x acc)
(if (null? lst)
Line 1,340 ⟶ 2,437:
 
(display (horner (list -19 7 -4 6) 3))
(newline)</langsyntaxhighlight>
Output:
<syntaxhighlight lang="text">128</langsyntaxhighlight>
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "float.s7i";
 
Line 1,366 ⟶ 2,463:
begin
writeln(horner(coeffs, 3.0) digits 1);
end func;</langsyntaxhighlight>
 
Output:
Line 1,372 ⟶ 2,469:
128.0
</pre>
 
=={{header|Sidef}}==
Functional:
<syntaxhighlight lang="ruby">func horner(coeff, x) {
coeff.reverse.reduce { |a,b| a*x + b };
}
 
say horner([-19, 7, -4, 6], 3); # => 128</syntaxhighlight>
 
Recursive:
<syntaxhighlight lang="ruby">func horner(coeff, x) {
(coeff.len > 0) \
? (coeff[0] + x*horner(coeff.last(-1), x))
: 0
}
 
say horner([-19, 7, -4, 6], 3) # => 128</syntaxhighlight>
 
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<langsyntaxhighlight lang="smalltalk">OrderedCollection extend [
horner: aValue [
^ self reverse inject: 0 into: [:acc :c | acc * aValue + c].
Line 1,381 ⟶ 2,495:
].
 
(#(-19 7 -4 6) asOrderedCollection horner: 3) displayNl.</langsyntaxhighlight>
 
=={{header|Standard ML}}==
<langsyntaxhighlight lang="sml">(* Assuming real type for coefficients and x *)
fun horner coeffList x = foldr (fn (a, b) => a + b * x) (0.0) coeffList</langsyntaxhighlight>
 
=={{header|Swift}}==
<syntaxhighlight lang="swift">func horner(coefs: [Double], x: Double) -> Double {
return reduce(lazy(coefs).reverse(), 0) { $0 * x + $1 }
}
 
println(horner([-19, 7, -4, 6], 3))</syntaxhighlight>
{{out}}
<pre>128.0</pre>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">package require Tcl 8.5
proc horner {coeffs x} {
set y 0
Line 1,395 ⟶ 2,518:
}
return $y
}</langsyntaxhighlight>
Demonstrating:
<langsyntaxhighlight lang="tcl">puts [horner {-19 7 -4 6} 3]</langsyntaxhighlight>
Output:
<pre>128</pre>
Line 1,405 ⟶ 2,528:
Note: this function, "Horner", gets its coefficients as a ParamArray which has no specified length. This array collect all arguments after the first one(s). This means you must specify x first, then the coefficients.
 
<syntaxhighlight lang="vba">
<lang VBA>
Public Function Horner(x, ParamArray coeff())
Dim result As Double
Line 1,418 ⟶ 2,541:
Horner = result
End Function
</syntaxhighlight>
</lang>
 
Output:
Line 1,424 ⟶ 2,547:
print Horner(3, -19, 7, -4, 6)
128
</pre>
 
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Function horners_rule(coefficients,x)
accumulator = 0
For i = UBound(coefficients) To 0 Step -1
accumulator = (accumulator * x) + coefficients(i)
Next
horners_rule = accumulator
End Function
 
WScript.StdOut.WriteLine horners_rule(Array(-19,7,-4,6),3)
</syntaxhighlight>
 
{{Out}}
<pre>128</pre>
 
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">Module Module1
 
Function Horner(coefficients As Double(), variable As Double) As Double
Return coefficients.Reverse().Aggregate(Function(acc, coeff) acc * variable + coeff)
End Function
 
Sub Main()
Console.WriteLine(Horner({-19.0, 7.0, -4.0, 6.0}, 3.0))
End Sub
 
End Module</syntaxhighlight>
{{out}}
<pre>128</pre>
 
=={{header|Visual FoxPro}}==
===Coefficients in ascending order.===
<syntaxhighlight lang="vfp">
LOCAL x As Double
LOCAL ARRAY aCoeffs[1]
CLEAR
CREATE CURSOR coeffs (c1 I, c2 I, c3 I, c4 I)
INSERT INTO coeffs VALUES (-19,7,-4,6)
SCATTER TO aCoeffs
x = VAL(INPUTBOX("Value of x:", "Value"))
? EvalPoly(@aCoeffs, x)
USE IN coeffs
 
FUNCTION EvalPoly(c, x As Double) As Double
LOCAL s As Double, k As Integer, n As Integer
n = ALEN(c)
s = 0
FOR k = n TO 1 STEP -1
s = s*x + c[k]
ENDFOR
RETURN s
ENDFUNC
</syntaxhighlight>
 
===Coefficients in descending order.===
<syntaxhighlight lang="vfp">
LOCAL x As Double
LOCAL ARRAY aCoeffs[1]
CLEAR
CREATE CURSOR tmp (c1 I, c2 I, c3 I, c4 I)
INSERT INTO tmp VALUES (6,-4,7,-19)
SCATTER TO aCoeffs
x = VAL(INPUTBOX("Value of x:", "Value"))
? EvalPolyDesc(@aCoeffs, x)
USE IN tmp
 
FUNCTION EvalPolyDesc(c, x As Double) As Double
LOCAL s As Double, e
s = 0
FOR EACH e IN c FOXOBJECT
s = s*x + e
ENDFOR
RETURN s
ENDFUNC
</syntaxhighlight>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">fn horner(x i64, c []i64) i64 {
mut acc := i64(0)
for i := c.len - 1; i >= 0; i-- {
acc = acc*x + c[i]
}
return acc
}
fn main() {
println(horner(3, [i64(-19), 7, -4, 6]))
}</syntaxhighlight>
 
{{out}}
<pre>
128
</pre>
 
=={{header|Wren}}==
<syntaxhighlight lang="wren">var horner = Fn.new { |x, c|
var count = c.count
if (count == 0) return 0
return (count-1..0).reduce(0) { |acc, index| acc*x + c[index] }
}
 
System.print(horner.call(3, [-19, 7, -4, 6]))</syntaxhighlight>
 
{{out}}
<pre>
128
</pre>
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">code IntOut=11;
 
func Horner(X, N, C); \Return value of polynomial in X
Line 1,438 ⟶ 2,671:
];
 
IntOut(0, Horner(3, 4, [-19, 7, -4, 6]));</langsyntaxhighlight>
 
Output:
<pre>
128
</pre>
 
=={{header|zkl}}==
<syntaxhighlight lang="zkl">fcn horner(coeffs,x)
{ coeffs.reverse().reduce('wrap(a,coeff){ a*x + coeff },0.0) }</syntaxhighlight>
{{out}}
<pre>
horner(T(-19,7,-4,6), 3).println();
128
</pre>
Chkas
2,046

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/144334...362204"