Resolved: Operator overloading in Rust not working for reference types

use std::ops::*;

pub struct Point3
{
    pub x: f64,
    pub y: f64,
    pub z: f64,
    pub res_type: u8,
    pub atom_type: u8,
    pub chain_id: u16
}

impl Sub for Point3
{
    type Output = Point3;
    fn sub(self, other: Point3) -> Point3
    {
        Point3
        {
            x: self.x - other.x,
            y: self.y - other.y,
            z: self.z - other.z,
            res_type: 0,
            atom_type: 0,
            chain_id: 0
        }
    }
}

impl Point3
{
    pub fn new(a:f64, b:f64, c:f64)-> Self
    {
        Point3
        {
            x: a,
            y: b,
            z: c,
            res_type: 0,
            atom_type: 0,
            chain_id: 0
        }
    }
    pub fn show(self)
    {
        println!("x:{}, y:{}, z:{}", self.x, self.y, self.z);
    }
}

pub fn vec_ref_pass(v1: &Point3, v2: &Point3) -> Point3
{
    return v1 - v2;
}

extern crate operator_overloading_lib;

use operator_overloading_lib::point3::*;

fn main()
{
    let v1 = Point3::new(1.0,2.0,3.0);
    let v2 = Point3::new(3.0,2.0,1.0);
    let vv = vec_ref_pass(&v1, &v2);
    vv.show();
}

C:\git\Rust examples\operator_overloading>cargo run
   Compiling operator_overloading_lib v0.1.0 (C:\git\Rust examples\operator_overloading)
error[E0369]: cannot subtract `&Point3` from `&Point3`
  --> src\point3.rs:52:15
   |
52 |     return v1 - v2;
   |            -- ^ -- &Point3
   |            |
   |            &Point3

For more information about this error, try `rustc --explain E0369`.
error: could not compile `operator_overloading_lib` due to previous error

C:\git\Rust examples\operator_overloading>

impl Sub for &Point3
{
    type Output = Point3;
    fn sub(self, other: &Point3) -> Point3
    {
        Point3
        {
            x: self.x - other.x,
            y: self.y - other.y,
            z: self.z - other.z,
            res_type: 0,
            atom_type: 0,
            chain_id: 0
        }
    }
}

#[derive(Copy, Clone)]
pub struct Point3

pub fn vec_ref_pass(v1: Point3, v2: Point3) -> Point3

fn sub(self, other: &Point3) -> Point3
{
    *self - *other
}