Макрос за полуавтоматично клониране

Програмиране с Rust

Курс във Факултета по Математика и Информатика към СУ

Решение на (Floating) Points and Vectors от Кирил Костов

Обратно към всички решения

Към профила на Кирил Костов

Резултати

  • 16 точки от тестове
  • 0 бонус точки
  • 16 точки общо
  • 12 успешни тест(а)
  • 3 неуспешни тест(а)

Код

use std::ops::Add;
use std::ops::Sub;
use std::ops::Mul;
use std::ops::BitXor;
#[derive(Debug, Clone, Copy)]
pub struct Point {
x:f64,
y:f64,
z:f64,
}
impl Point {
pub fn new(x: f64, y: f64, z: f64) -> Self {
Point {x: x, y: y, z: z}
}
}
impl PartialEq for Point {
fn eq(&self, other: &Point) -> bool {
let eqx = (self.x - other.x).abs() < std::f64::EPSILON;
let eqy = (self.y - other.y).abs() < std::f64::EPSILON;
let eqz = (self.z - other.z).abs() < std::f64::EPSILON;
eqx && eqy && eqz
}
}
#[derive(Debug, Clone, Copy)]
pub struct Vector {
x:f64,
y:f64,
z:f64,
}
impl Vector {
pub fn new(x: f64, y: f64, z: f64) -> Self {
Vector {x: x, y: y, z: z}
}
pub fn norm(&self) -> f64 {
(self.x * self.x + self.y * self.y + self.z * self.z).sqrt()
}
}
impl PartialEq for Vector {
fn eq(&self, other: &Vector) -> bool {
let eqx = (self.x - other.x).abs() < std::f64::EPSILON;
let eqy = (self.y - other.y).abs() < std::f64::EPSILON;
let eqz = (self.z - other.z).abs() < std::f64::EPSILON;
eqx && eqy && eqz
}
}
impl Add<Vector> for Point {
type Output = Point;
fn add(self, other: Vector) -> Point {
Point {
x : self.x + other.x,
y : self.y + other.y,
z : self.z + other.z,
}
}
}
impl Sub for Point {
type Output = Vector;
fn sub(self, other: Point) -> Vector {
Vector {
x : self.x - other.x,
y : self.y - other.y,
z : self.z - other.z,
}
}
}
impl Add for Vector {
type Output = Vector;
fn add(self, other: Vector) -> Vector {
Vector {
x : self.x + other.x,
y : self.y + other.y,
z : self.z + other.z,
}
}
}
impl Mul<Vector> for f64 {
type Output = Vector;
fn mul(self, other: Vector) -> Vector {
Vector {
x : self * other.x,
y : self * other.y,
z : self * other.z,
}
}
}
impl Mul for Vector {
type Output = f64;
fn mul (self, other : Vector) -> f64 {
self.x * other.x + self.y * other.y + self.z * other.z
}
}
impl BitXor for Vector {
type Output = Vector;
fn bitxor(self, other: Vector) -> Vector {
Vector {
x : self.y * other.z - self.z * other.y,
y : self.z * other.y - self.x * other.z,
z : self.x * other.y - self.y * other.x,
}
}
}
#[derive(Debug)]
pub struct Line {
p1 : Point,
p2 : Point,
v : Vector,
}
impl Line {
pub fn from_pp(p1: Point, p2: Point) -> Option<Self> {
if p1 == p2 {
None
} else {
Some (Line { p1 : p1, p2: p2, v : p2 - p1})
}
}
pub fn from_pv(p: Point, v: Vector) -> Option<Self> {
if v == Vector::new(0.0, 0.0, 0.0) {
None
} else {
Some (Line { p1 : p, p2 : p + v, v : v})
}
}
pub fn distance(&self, target: Point) -> f64 {
let ap : Vector = self.p1 - target;
(ap ^ self.v).norm() / self.v.norm()
}
}
impl PartialEq for Line {
fn eq(&self, other: &Line) -> bool {
(self.distance(other.p1) < std::f64::EPSILON && self.distance(other.p2) < std::f64::EPSILON)
}
}

Лог от изпълнението

Compiling solution v0.1.0 (/tmp/d20190123-22631-14g7a8l/solution)
    Finished dev [unoptimized + debuginfo] target(s) in 4.99s
     Running target/debug/deps/solution-2e785d603b538f71

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

     Running target/debug/deps/solution_test-29808948fb50ed3a

running 15 tests
test solution_test::test_equailty_symmetry ... ok
test solution_test::test_equality_basic ... ok
test solution_test::test_equality_floating ... ok
test solution_test::test_line_constructors ... ok
test solution_test::test_line_equality_by_points ... ok
test solution_test::test_line_equality_by_points_and_vectors ... FAILED
test solution_test::test_line_equality_by_vectors ... FAILED
test solution_test::test_line_validity ... ok
test solution_test::test_number_by_vector ... ok
test solution_test::test_number_vector_multiplication_with_precision ... ok
test solution_test::test_point_distance ... ok
test solution_test::test_points_minus_points ... ok
test solution_test::test_points_plus_vectors ... ok
test solution_test::test_vector_by_vector ... ok
test solution_test::test_vector_by_vector_cross ... FAILED

failures:

---- solution_test::test_line_equality_by_points_and_vectors stdout ----
thread 'solution_test::test_line_equality_by_points_and_vectors' panicked at 'assertion failed: `(left == right)`
  left: `Some(Line { p1: Point { x: 0.0, y: 0.0, z: 0.0 }, p2: Point { x: 0.3, y: -0.1, z: 0.25 }, v: Vector { x: 0.3, y: -0.1, z: 0.25 } })`,
 right: `Some(Line { p1: Point { x: 0.0, y: 0.0, z: 0.0 }, p2: Point { x: 0.3, y: -0.1, z: 0.25 }, v: Vector { x: 0.3, y: -0.1, z: 0.25 } })`', tests/solution_test.rs:243:5
note: Run with `RUST_BACKTRACE=1` for a backtrace.

---- solution_test::test_line_equality_by_vectors stdout ----
thread 'solution_test::test_line_equality_by_vectors' panicked at 'assertion failed: `(left == right)`
  left: `Some(Line { p1: Point { x: 0.0, y: 0.4, z: 0.0 }, p2: Point { x: 0.1, y: 0.2, z: 0.5 }, v: Vector { x: 0.1, y: -0.2, z: 0.5 } })`,
 right: `Some(Line { p1: Point { x: 0.0, y: 0.4, z: 0.0 }, p2: Point { x: 0.2, y: 0.0, z: 1.0 }, v: Vector { x: 0.2, y: -0.4, z: 1.0 } })`', tests/solution_test.rs:226:5

---- solution_test::test_vector_by_vector_cross stdout ----
thread 'solution_test::test_vector_by_vector_cross' panicked at 'assertion failed: `(left == right)`
  left: `Vector { x: -4.0, y: 5.0, z: -4.0 }`,
 right: `Vector { x: -4.0, y: 8.0, z: -4.0 }`', tests/solution_test.rs:136:5


failures:
    solution_test::test_line_equality_by_points_and_vectors
    solution_test::test_line_equality_by_vectors
    solution_test::test_vector_by_vector_cross

test result: FAILED. 12 passed; 3 failed; 0 ignored; 0 measured; 0 filtered out

error: test failed, to rerun pass '--test solution_test'

История (1 версия и 5 коментара)