use std::fmt;
use std::iter;
struct LinearFunctionIterator {
fun: LinearFunction,
x: i32,
stop: i32,
}
impl LinearFunctionIterator {
fn new(fun: LinearFunction, begin: i32, stop: i32) -> LinearFunctionIterator {
LinearFunctionIterator {
fun: fun,
x: begin,
stop: stop,
}
}
}
impl iter::Iterator for LinearFunctionIterator {
type Item = f64;
fn next(&mut self) -> Option<Self::Item> {
if self.x == self.stop {
return None
}
let result = self.fun.feed(self.x as f64);
if self.x < self.stop {
self.x += 1;
}
else {
self.x -= 1;
}
return Some(result);
}
}
struct LinearFunction {
a: f64,
b: f64,
}
impl LinearFunction {
fn new(a: f64, b: f64) -> LinearFunction {
LinearFunction {
a: a,
b: b,
}
}
fn feed(&self, x: f64) -> f64 {
self.a * x + self.b
}
}
impl fmt::Display for LinearFunction {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "f(x) = {} * x + {}", self.a, self.b)
}
}
impl iter::IntoIterator for LinearFunction {
type Item = f64;
type IntoIter = LinearFunctionIterator;
fn into_iter(self) -> Self::IntoIter {
LinearFunctionIterator::new(self, 0, 10)
}
}
fn main() {
let fun = LinearFunction::new(2.0, 1.0);
println!("{}", fun);
for y in fun.into_iter() {
println!("{}", y.round());
}
}
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