Horner's rule for polynomial evaluation: Difference between revisions

(→‎{{header|Python}}: add numpy version)
(→‎{{header|Rust}}: stable Rust)
Line 1,435:
 
=={{header|Rust}}==
<lang rust>fn horner(v: ~&[f64], x: f64) -> f64 {
 
csv.iter().rev().fold(zero::<T>()0.0, |acc, ccoeff| (acc*x) + (*c)coeff)
 
<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>
 
WorksA generic version that works with any number type. Itand usesmuch amore. reversedSo leftmuch foldmore, toit's accumulatehard theto result,imagine similarwhat tothat themay Haskellbe solutionuseful for. <br>
'''Uses a gated feature (the Zero trait), only works in unstable Rust'''
<lang Rust>// rust 0.12-nightly
<lang rust>#![feature(zero_one)
 
use std::num::zeroZero;
use std::ops::{Mul, Add};
 
fn horner<T:NumArr,Arg, Out>(csv: &[TArr], x:T Arg) -> T {Out
where Arr: Clone,
cs.iter().rev().fold(zero::<T>(), |acc, c| (acc*x) + (*c))
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() {
println!("{}",let v = horner([-19i19., 7., -4., 6.], 3i));
let output: f64 = horner(&v, 3.0);
println!("result: {}", output);
}</lang>
 
Anonymous user