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

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

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

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

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

Към профила на Ива Милушева

Резултати

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

Код

use std::ops::*;
#[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 {
equal(self.x, other.x) && equal(self.y, other.y) && equal(self.z, other.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 {
Vector { x : x, y : y, z : z }
}
}
impl PartialEq for Vector {
fn eq(&self, other: &Vector) -> bool {
equal(self.x, other.x) && equal(self.y, other.y) && equal(self.z, other.z)
}
}
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 Add<Point> for Vector {
type Output = Point;
fn add(self, other: Point) -> Point {
Point { x : self.x + other.x, y : self.y + other.y, z : self.z + other.z }
}
}
impl Sub<Point> 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<Vector> 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<Vector> for Vector {
type Output = f64;
fn mul(self, other: Vector) -> f64 {
let result = self.x * other.x + self.y * other.y + self.z * other.z;
result
}
}
impl BitXor<Vector> 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.x - self.x * other.z, z : self.x * other.y - self.y * other.x }
}
}
pub fn equal(x : f64, y : f64) -> bool {
(x.abs() - y.abs()).abs() < std::f64::EPSILON
}
pub fn vector_length(v : Vector) -> f64 {
(v * v).sqrt()
}
impl PartialEq for Line {
fn eq(&self, other: &Line) -> bool {
println!("{}", self.distance(other.x));
println!("{}", self.distance(other.y));
equal(self.distance(other.x), 0.0) && equal(self.distance(other.y), 0.0)
}
}
#[derive(Debug)]
pub struct Line {
// Каквито полета ви трябват
x : Point, y : Point
}
impl Line {
/// Конструиране на линия през две точки, които минават през нея. Две различни точки са
/// достатъчни, за да дефинират еднозначно линия.
///
/// Можете да получите точка и вектор, като извадите едната от другата точка.
///
/// Ако точките са една и съща, очакваме да върнете None.
///
pub fn from_pp(p1: Point, p2: Point) -> Option<Self> {
if p1 != p2
{
Some ( Line { x : p1, y : p2 } )
}
else {
None
}
}
/// Конструиране на линия през точка за начало, и вектор, който определя посоката. Стига
/// вектора да е ненулев, това е достатъчно, за да дефинира еднозначно линия.
///
/// Може да получите две точки, като съберете дадената с вектора.
///
/// Ако вектора е нулев, очакваме да върнете None.
///
pub fn from_pv(p: Point, v: Vector) -> Option<Self> {
if v != (Vector { x : 0.0, y : 0.0, z : 0.0 })
{
Some ( Line { x : p, y : p + v } )
}
else {
None
}
}
pub fn distance(&self, target: Point) -> f64 {
let n = ( self.x - target ) ^ ( self.y - target );

Вектора n предполагам, че е трябвало да бъде вектора-посока на правата. Но начина да го получиш от две точки, лежащи върху нея е просто self.y - self.x. Или self.x - self.y. Тази една промяна би минала всички тестове.

Андрей
let a = ( self.x - target ) ^ n;
if (vector_length(n) == 0.0) {
return 0.0;
}
vector_length(a) / vector_length(n)
}
}

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

Compiling solution v0.1.0 (/tmp/d20190123-22631-xj3lv2/solution)
warning: unnecessary parentheses around `if` condition
   --> src/lib.rs:159:12
    |
159 |         if (vector_length(n) == 0.0) {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these parentheses
    |
    = note: #[warn(unused_parens)] on by default

warning: unnecessary parentheses around `if` condition
   --> src/lib.rs:159:12
    |
159 |         if (vector_length(n) == 0.0) {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove these parentheses
    |
    = note: #[warn(unused_parens)] on by default

    Finished dev [unoptimized + debuginfo] target(s) in 5.20s
     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 ... FAILED
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

failures:

---- solution_test::test_line_equality_by_points_and_vectors stdout ----
0
0
0
0
0
0.6324555320336759
thread 'solution_test::test_line_equality_by_points_and_vectors' panicked at 'assertion failed: `(left == right)`
  left: `Some(Line { x: Point { x: 0.0, y: 0.0, z: 0.0 }, y: Point { x: 0.3, y: -0.1, z: 0.25 } })`,
 right: `Some(Line { x: Point { x: 0.0, y: 0.0, z: 0.0 }, y: Point { x: -0.6, y: 0.2, z: -0.5 } })`', tests/solution_test.rs:245:5
note: Run with `RUST_BACKTRACE=1` for a backtrace.

---- solution_test::test_line_equality_by_vectors stdout ----
0
0
0
0.1825300804627884
thread 'solution_test::test_line_equality_by_vectors' panicked at 'assertion failed: `(left == right)`
  left: `Some(Line { x: Point { x: 0.0, y: 0.4, z: 0.0 }, y: Point { x: 0.1, y: 0.2, z: 0.5 } })`,
 right: `Some(Line { x: Point { x: 0.0, y: 0.4, z: 0.0 }, y: Point { x: 0.03333333333333333, y: 0.33333333333333337, z: 0.16666666666666666 } })`', tests/solution_test.rs:227:5

---- solution_test::test_point_distance stdout ----
thread 'solution_test::test_point_distance' panicked at 'assertion failed: (line.distance(p1) - 2.0f64.sqrt() / 2.0).abs() < EPS * 1000.0', tests/solution_test.rs:183:5


failures:
    solution_test::test_line_equality_by_points_and_vectors
    solution_test::test_line_equality_by_vectors
    solution_test::test_point_distance

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

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

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

Ива качи първо решение на 25.11.2018 22:20 (преди над 4 години)

Разумно решение като цяло, но си сбъркала формулата от линка, което ти е коствало трите теста. Погледни и warning-ите за съвет какво друго да промениш в кода си като стил.