math_2d.h

// Copyright 2019 The Darwin Neuroevolution Framework Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#pragma once

#include <cmath>
#include <cstring>
#include <limits>
using namespace std;

namespace math {

using Scalar = double;

constexpr Scalar kInfinity = numeric_limits<Scalar>::infinity();

constexpr Scalar kEpsilon = numeric_limits<Scalar>::epsilon();

constexpr Scalar kPi = 3.141592653589;

constexpr Scalar radiansToDegrees(Scalar radians) {
  return radians / kPi * 180;
}

constexpr Scalar degreesToRadians(Scalar degrees) {
  return degrees / 180 * kPi;
}

struct Vector2d {
  Scalar x;  
  Scalar y;  

  Vector2d() : x(0), y(0) {}

  Vector2d(Scalar x, Scalar y) : x(x), y(y) {}

  Scalar length() const { return sqrt(x * x + y * y); }

  Scalar lengthSquared() const { return x * x + y * y; }

  Vector2d normalized() const { return *this / length(); }

  Vector2d operator+(const Vector2d& v) const { return Vector2d(x + v.x, y + v.y); }

  Vector2d operator-(const Vector2d& v) const { return Vector2d(x - v.x, y - v.y); }

  Vector2d operator*(Scalar s) const { return Vector2d(x * s, y * s); }

  Vector2d operator/(Scalar s) const { return Vector2d(x / s, y / s); }

  Scalar operator*(const Vector2d& v) const { return x * v.x + y * v.y; }

  Scalar cross(const Vector2d& v) const { return x * v.y - y * v.x; }
};

struct Intersection2d {
  Scalar a = 0;  
  Scalar b = 0;  
};

Intersection2d intersect(const Vector2d& a1,
                         const Vector2d& a2,
                         const Vector2d& b1,
                         const Vector2d& b2);

struct HMatrix2d {
  Scalar m[3][3];

  HMatrix2d() { setZero(); }

  void setZero() { ::memset(m, 0, sizeof(m)); }

  void setIdentity();

  void setTranslate(Scalar tx, Scalar ty);

  void setScale(Scalar sx, Scalar sy);

  void setRotation(Scalar angle);

  HMatrix2d operator*(const HMatrix2d& other);

  Vector2d operator*(const Vector2d& v);
};

}  // namespace math