Basit Shape Sınıfları

Line
1. Paralel Çizgiler
İki çizgi eğimleri eşitse birbirlerine paraleldir.

public boolean isParallelTo (Line other) {
    return other.Slope == this.Slope;
}

2. Dik Çizgiler
İki çizginin dot product sonucu 0 ise bu çizgiler diktir. dot product kodlamak için şöyle yaparız.

float dot_product(float *vector1, float vector2[],int dimension){
  float sum = 0;
  for (int i = 0; i < dimension; i++){
    sum += (vector1[i])*(vector2[i]);
  }
  return sum;
}

Bu kodu C++ ile kodlamak için hazır gelen std::inner_product() meodunu kullanarak şöyle yaparız.

std::inner_product(a.cbegin(), a.cend(), b.cbegin(), float(0.0));

Örnek
Bir çizgiye dik çizgi üretmek için şöyle yaparız

std::vector<float> generate_orthogonal(const std::vector<float>& a) {
  // get some random data
  std::vector<float> b = generate_random(a.size());

  // find the last non zero entry in a
  // We have to turn the reverse iterator into an iterator via std::prev(rit.base())
  auto IsZero = [] (const float f) -> bool { return f == float(0.0);};
  auto end = std::prev(std::find_if_not(a.crbegin(), a.crend(), IsZero).base());

  // determine the dot product up to end
  float dot_product = std::inner_product(a.cbegin(), end, b.cbegin(), float(0.0));

  // set the value of b so that the inner product is zero
  b[std::distance(a.cbegin(), end)] = - dot_product / (*end);

  return b;
}

2 Boyutlu Nokta
2 boyutlu noktanın bir şeklin içinde olup olmadığı şöyle bulunur. Noktanın x değeri [shape.x.min,shape.x.min] kapalı aralığında, y değeride [shape.y.min,shape.y.min] kapalı aralıında ise nokta şeklin içindedir.

class Point {
  public boolean isInside(Shape s) {
    ArrayList<Point> points = s.edgePoints()
    return this.x >= points.map(getX).min && \
           this.x <= points.map(getX).max && \
           this.y >= points.map(getX).min && \
           this.y <= points.map(getX).min 

  } 
} 

3 Boyutlu Nokta
3 boyutlu nokta düz bir dizide şöyle tutulur.

// Thin wrapper around flatten vector
template<typename T>
class Array3D
{
    std::size_t _X, _Y, _Z;
    std::vector<T> _vec;
public:
    Array3D(std::size_t X, std::size_t Y, std::size_t Z):
        _X(X), _Y(Y), _Z(Z), _vec(_X * _Y * _Z) {}
    T& operator()(std::size_t x, std::size_t y, std::size_t z)
    {
        return _vec[(x * _Y + y) * _Z + z];
    }
};

Daire
Basit Shape Sınıfı - Daire yazısına taşıdım.

Üçgen

Dik üçgen olup olmadığını anlamak için şöyle yaparız.

(a,b,c)->                // Method with three integer parameters and boolean return-type
  (a*=a)+(b*=b)==(c*=c)  //  Return if `a*a + b*b == c*c`
  |a+c==b                //  or `a*a + c*c == b*b`
  |b+c==a                //  or `b*b + c*c == a*a`
                         // End of method (implicit / single-line return-statement)

3 kenarın uzunluğunu biliyorsak bunların bir üçgen olup olmadığını anlamak için açıklama şöyle

Checks if a+b+c > max(a,b,c)*2. If, say, c is the biggest one, this is equivalent to a+b+c>2*c, or a+b>c, which is want we want for the triangle inequality.

Şöyle yaparız.

(a,b,c)->a+b>c&a+c>b&b+c>a

Dikdörtgen
Şöyle tanımlarız.

struct rect
{
  int x;
  int y;
  int width;
  int height;
};

overlap metodu
Collision Detection yazısına taşıdım.

Elips
Matematiksel olarak her daire bir elips olarak tarif ediliyor olabilir. Yani aynı değere sahip iki tane odak noktası olarak düşünülüyor deniliyor. Ancak programlama açısından çok doğru değil. Şu kalıtım bir sürü problem sebep oluyor.

class Circle : public Elipse   
{...}

 En iyisi daireden elipse çevrim yapmak. Şöyle yaparız.

class Elipse
{
  // as you defined
};

class Circle
{
  // As you defined
  explicit operator Ellipse()
  {
    Point lower_left, upper_right;
    // calculate the two points
    return Ellipse(lower_left, upper_right);
  }
};

Küre (Sphere)
fi (yatay açı) ve theta (dikey açı) değerlerinden X,Y,Z noktalarına dönmek için şöyle yaparız.

x = x0 + r * Cos(fi)  * Sin(theta)
y = y0 + r * Sin(fi)  * Sin(theta)
z = z0 + r * Cos(theta)

Polygon
N köşeli normal bir polygon'un iç açısını bulmak için şöyle yaparız. 360 /N işleminin sonucunu 180'den çıkarırız.

n=>180-360/n

Vector

Basit bir Vector sınıfı

class Vector {
  private final int x;
  private final int y;

  public Vector(int x, int y) {
    this.x = x;
    this.y = y;
  }

  public Vector add(Vector other) {
    return new Vector(x + other.x, y + other.y);
  }

  public Vector sub(Vector other) {
    return new Vector(x - other.x, y - other.y);
  }

  public Vector mul(Vector other) {
    return new Vector(x * other.x, y * other.y);
  }
}

Çarpma
Açıklaması şöyle.

The two fundamental operations for numbers are "addition" and "multiplication" which obey very nice "laws" of arithmetic. Taking powers is also important. You can do all of those things with complex numbers. You can add two vectors but the "dot" product of two vectors is not a vector and the "cross" product of two vectors does not satisfy the "nice laws". Neither the dot product nor the cross product of vectors can be used to define powers.