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

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

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

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

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

Към профила на Даниела Русева

Резултати

  • 20 точки от тестове
  • 1 бонус точка
  • 21 точки общо
  • 15 успешни тест(а)
  • 0 неуспешни тест(а)

Код

use std::ops::{Add, Sub, Mul, 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 {
Self { x, y, z }
}
}
impl PartialEq for Point {
fn eq(&self, other: &Point) -> bool {
((self.x - other.x).abs() < std::f64::EPSILON) &
((self.y - other.y).abs() < std::f64::EPSILON) &
((self.z - other.z).abs() < std::f64::EPSILON)
}
}
impl Add<Vector> for Point {
type Output = Point;
fn add(self, rhs: Vector) -> Point {
Point { x: self.x + rhs.x, y: self.y + rhs.y, z: self.z + rhs.z }
}
}
impl Sub for Point {
type Output = Vector;
fn sub(self, rhs: Point) -> Vector {
Vector { x: self.x - rhs.x, y: self.y - rhs.y, z: self.z - rhs.z }
}
}
#[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 {
Self { x, y, z }
}
fn vector_norm(self) -> f64 {
(self.x * self.x + self.y * self.y + self.z * self.z).sqrt()
}

Бих го нарекъл просто norm, понеже vector_ донякъде се подразбира -- все пак е метод върху Vector типа. По-долу и го викаш даже като Vector::vector_norm, което ми изглежда като ненужно повторение. Vector::norm би комуникирало същото.

Андрей
}
impl PartialEq for Vector {
fn eq(&self, other: &Vector) -> bool {
((self.x - other.x).abs() < std::f64::EPSILON) &
((self.y - other.y).abs() < std::f64::EPSILON) &
((self.z - other.z).abs() < std::f64::EPSILON)
}
}
impl Add for Vector {
type Output = Vector;
fn add(self, rhs: Vector) -> Vector {
Vector { x: self.x + rhs.x, y: self.y + rhs.y, z: self.z + rhs.z }
}
}
impl Mul<Vector> for f64 {
type Output = Vector;
fn mul(self, rhs: Vector) -> Vector {
Vector { x: self * rhs.x, y: self * rhs.y, z: self * rhs.z }
}
}
impl Mul for Vector {
type Output = f64;
fn mul(self, rhs: Vector) -> f64 {
self.x * rhs.x + self.y * rhs.y + self.z * rhs.z
}
}
impl BitXor for Vector {
type Output = Vector;
fn bitxor(self, rhs: Vector) -> Vector {
Vector { x: self.y * rhs.z - self.z * rhs.y, y: self.z * rhs.x - self.x * rhs.z, z: self.x * rhs.y - self.y * rhs.x }

Бих го разбил на няколко реда. Самия един ред става дълъг, а и ако беше на няколко реда, може би щеше да си личат по-добре зависимостите между координатите.

Андрей
}
}
#[derive(Debug)]
pub struct Line {
p: Point,
v: Vector,
}
impl Line {
pub fn from_pp(p1: Point, p2: Point) -> Option<Self> {
if p1 == p2 {
None
} else {
Some(Line { p: p1, 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 { p, v })
}
}
pub fn distance(&self, target: Point) -> f64 {
Vector::vector_norm((target - self.p) ^ self.v) / Vector::vector_norm(self.v)
}
}
impl PartialEq for Line {
fn eq(&self, other: &Line) -> bool {
(Line::distance(other, self.p) < std::f64::EPSILON) &
(Line::distance(other, self.p + self.v) < std::f64::EPSILON)
}
}

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

Compiling solution v0.1.0 (/tmp/d20190123-22631-6upa2n/solution)
    Finished dev [unoptimized + debuginfo] target(s) in 5.30s
     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 ... ok
test solution_test::test_line_equality_by_vectors ... ok
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 ... ok

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

   Doc-tests solution

running 0 tests

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

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

Даниела качи първо решение на 25.11.2018 20:50 (преди почти 7 години)