Exercise "vec"

• Build a class, called "vec" (we reserve the name "vector" for n-dimensional vectors), to represent Eucledean 3D vectors.

Tasks:

1. Devise a class, called "vec", an instance of which should hold three double values: x,y,z.
2. Implement the relevant constructors. In C#: parametrized and default constructors; in C++: parametrized, default, copy, and move constructors, a destructor, and also copy and move assignment operators (hint: most of them can be declared "default" and then the compiler will create them for you).
3. Implement the relevant mathematical operators for 3D vectors.
4. Imlement a simple "print" method for debugging.
5. C#: override the "ToString" method. C++: overload "operator<<".

Hints:

• In C# you only need the implementation file, "vec.cs". It could be something like this,

  public class vec{
  	public double x,y,z; /* the three components of a vector */
  	public vec(){ x=y=z=0; } // default constructor
  	public vec(double x,double y,double z){ // parametrized constructor
  		this.x=x; this.y=y; this.z=z;
  		}
  	/* ... more stuff goes here ... */
  }
  

  In C++ you need both the "vec.h" header file and "vec.cc" implementation file. The header file "vec.h" could be something like this,
  #ifndef HAVE_VEC_H #define HAVE_VEC_H #include<iostream> #include<string> struct vec{ double x,y,z; vec(double x,double y,double z): x(x),y(y),z(z){} // parametrized constructor vec():vec(0,0,0){} // default constructor vec(const vec&)=default; // copy constructor vec(vec&&)=default; // move constructor ~vec()=default; // destructor vec& operator=(const vec&)=default; // copy assignment vec& operator=(vec&&)=default; // move assignment vec& operator+=(const vec&); vec& operator-=(const vec&); vec& operator*=(double); vec& operator/=(double); void set(double a,double b,double c){x=a;y=b;z=c;} void print(std::string s="") const; // for debugging friend std::ostream& operator<<(std::ostream&, const vec&); }; vec operator-(const vec&); vec operator-(const vec&, const vec&); vec operator+(const vec&, const vec&); vec operator*(const vec&, double); vec operator*(double, const vec&); vec operator/(const vec&, double); bool approx(const vec&, const vec&, double acc=1e-6,double eps=1e-6); #endif

  The file "vec.cc" should implement the things that have been decleared in the "vec.h" file.

• Overload mathematical operators. In C#,

  //C# operators:
  public static vec operator*(vec v, double c){return new vec(c*v.x,c*v.y,c*v.z);}
  public static vec operator*(double c, vec v){return v*c;}
  public static vec operator/(vec u, double c){/*...*/}
  public static vec operator+(vec u, vec v){/*...*/}
  public static vec operator-(vec u){return new vec(-u.x,-u.y,-u.z);}
  public static vec operator-(vec u, vec v){/*...*/}
  /* ... */
  

  C++: the implementation file "vec.cc" should implement all the operators defined in the "vec.h" file above.

• Make a "print" method for debugging,

  public void print(string s=""){Write(s);WriteLine($"{x} {y} {z}");}
  

  void vec::print(std::string s) const {
      std::cout << s << x << " " << y << " " << z << std::endl;
      }
  

• Implement methods for dot-product, vector-product, and norm. Something like

  public double dot(vec other) /* to be called as u.dot(v) */
  	{return this.x*other.x+this.y*other.y+this.z*other.z;}
  public static double dot(vec v,vec w) /* to be called as vec.dot(u,v) */
  	{return v.x*w.x+v.y*w.y+v.z*w.z;}
  

  You can also try this C# syntactic sugar,

  public double dot(vec other) => this.x*other.x+this.y*other.y+this.z*other.z;
  public static double dot(vec v,vec w) => v.x*w.x+v.y*w.y+v.z*w.z;
  

• Make an "approx" method to compare two vec's with absolute precision "acc" and relative precision "eps". Something like

  static bool approx(double a,double b,double acc=1e-9,double eps=1e-9){
  	if(Abs(a-b)<acc)return true;
  	if(Abs(a-b)<(Abs(a)+Abs(b))*eps)return true;
  	return false;
  	}
  public bool approx(vec other){
  	if(!approx(this.x,other.x))return false;
  	if(!approx(this.y,other.y))return false;
  	if(!approx(this.z,other.z))return false;
  	return true;
  	}
  public static bool approx(vec u, vec v) => u.approx(v);
  

• C#: override ToString method, something like

  public override string ToString(){ return $"{x} {y} {z}"; }
  

  C++: overload "operator<<", something like

  std::ostream& operator<<(std::ostream& os, const vec& v){
      os << "{ " << v.x << ", " << v.y << ", " << v.z << " } ";
      return os;
      }
  

• Put your "vec" class in the file "vec.cs" and compile it into a library,

  vec.dll: vec.cs
  	mcs -target:library -out:vec.dll vec.cs
  

  Create a "main.cs" file with the "Main" function that illustrates your implementation and link it with "vec.dll" like this,

  main.exe: main.cs vec.dll
  	mcs -target:exe -out:main.exe -reference:vec.dll main.cs
  

• Run extensive tests of your implementation in the Main function (see [../csharp/examples/vec/main.cs] for inspiration).