Basic Geometry

Basic Geometry

	#include <bits/stdc++.h>
	using namespace std;
	#define INF 1<<30
	#define endl '\n'
	#define maxn 100005
	#define tc printf("Case %d: ", cs)
	#define tcn printf("Case %d:\n", cs);
	#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	typedef long long ll;
	const double PI = acos(-1.0);
	#define dbg1(x) cerr << #x << " = " << x << endl;
	#define dbg2(x, y) cerr << #x << " = " << x << ", " << #y << " = " << y << endl;
	#define dbg3(x, y, z) cerr << #x << " = " << x << ", " << #y << " = " << y << ", " << #z << " = " << z << endl;
	#define dbg4(w,x, y, z) cerr << #w << " = " << w << ", " <<#x << " = " << x << ", " << #y << " = " << y << ", " << #z << " = " << z << endl;
	template < typename F, typename S >
	ostream& operator << ( ostream& os, const pair< F, S > & p ) {
	return os << "(" << p.first << ", " << p.second << ")";
	}
	template < typename T >
	ostream &operator << ( ostream & os, const vector< T > &v ) {
	os << "{";
	for (auto it = v.begin(); it != v.end(); ++it) {
	if ( it != v.begin() ) os << ", ";
	os << *it;
	}
	return os << "}";
	}
	template < typename T >
	ostream &operator << ( ostream & os, const set< T > &v ) {
	os << "[";
	for (auto it = v.begin(); it != v.end(); ++it) {
	if ( it != v.begin()) os << ", ";
	os << *it;
	}
	return os << "]";
	}
	template < typename F, typename S >
	ostream &operator << ( ostream & os, const map< F, S > &v ) {
	os << "[";
	for (auto it = v.begin(); it != v.end(); ++it) {
	if ( it != v.begin() ) os << ", ";
	os << it -> first << " = " << it -> second ;
	}
	return os << "]";
	}
	#define dbg(args...) do {cerr << #args << " : "; faltu(args); } while(0)
	clock_t tStart = clock();
	#define timeStamp dbg("Execution Time: ", (double)(clock() - tStart)/CLOCKS_PER_SEC)
	void faltu () { cerr << endl; }
	template <typename T>
	void faltu( T a[], int n ) {
	for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
	cerr << endl;
	}
	template <typename T, typename ... hello>
	void faltu( T arg, const hello &... rest) { cerr << arg << ' '; faltu(rest...); }
	// Program showing a policy-based data structure.
	#include <ext/pb_ds/assoc_container.hpp> // Common file
	#include <ext/pb_ds/tree_policy.hpp>
	#include <functional> // for less
	#include <iostream>
	using namespace __gnu_pbds;
	using namespace std;
	// GNU link : https://goo.gl/WVDL6g
	typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
	tree_order_statistics_node_update>
	new_data_set;
	/**___________________________________________________**/
	truct point2d {
	ftype x, y;
	point2d() {}
	point2d(ftype x, ftype y): x(x), y(y) {}
	point2d& operator+=(const point2d & t) {
	x += t.x;
	y += t.y;
	return *this;
	}
	point2d& operator-=(const point2d & t) {
	x -= t.x;
	y -= t.y;
	return *this;
	}
	point2d& operator*=(ftype t) {
	x *= t;
	y *= t;
	return *this;
	}
	point2d& operator/=(ftype t) {
	x /= t;
	y /= t;
	return *this;
	}
	point2d operator+(const point2d & t) const {
	return point2d(*this) += t;
	}
	point2d operator-(const point2d & t) const {
	return point2d(*this) -= t;
	}
	point2d operator*(ftype t) const {
	return point2d(*this) *= t;
	}
	point2d operator/(ftype t) const {
	return point2d(*this) /= t;
	}
	};
	point2d operator*(ftype a, point2d b) {
	return b * a;
	}
	///-----------------------------------------------------
	struct point3d {
	ftype x, y, z;
	point3d() {}
	point3d(ftype x, ftype y, ftype z): x(x), y(y), z(z) {}
	point3d& operator+=(const point3d &t) {
	x += t.x;
	y += t.y;
	z += t.z;
	return *this;
	}
	point3d& operator-=(const point3d &t) {
	x -= t.x;
	y -= t.y;
	z -= t.z;
	return *this;
	}
	point3d& operator*=(ftype t) {
	x *= t;
	y *= t;
	z *= t;
	return *this;
	}
	point3d& operator/=(ftype t) {
	x /= t;
	y /= t;
	z /= t;
	return *this;
	}
	point3d operator+(const point3d &t) const {
	return point3d(*this) += t;
	}
	point3d operator-(const point3d &t) const {
	return point3d(*this) -= t;
	}
	point3d operator*(ftype t) const {
	return point3d(*this) *= t;
	}
	point3d operator/(ftype t) const {
	return point3d(*this) /= t;
	}
	};
	point3d operator*(ftype a, point3d b) {
	return b * a;
	}
	///Here ftype is some type used for coordinates, usually int, double or long long.
	ftype dot(point2d a, point2d b) {
	return a.x * b.x + a.y * b.y;
	}
	ftype dot(point3d a, point3d b) {
	return a.x * b.x + a.y * b.y + a.z * b.z;
	}
	///----------------------------------------------------
	ftype norm(point2d a) {
	return dot(a, a);
	}
	double abs(point2d a) {
	return sqrt(norm(a));
	}
	double proj(point2d a, point2d b) {
	return dot(a, b) / abs(b);
	}
	double angle(point2d a, point2d b) {
	return acos(dot(a, b) / abs(a) / abs(b));
	}
	///--------------------------------------------------------
	point3d cross(point3d a, point3d b) {
	return point3d(a.y * b.z - a.z * b.y,
	a.z * b.x - a.x * b.z,
	a.x * b.y - a.y * b.x);
	}
	ftype triple(point3d a, point3d b, point3d c) {
	return dot(a, cross(b, c));
	}
	ftype cross(point2d a, point2d b) {
	return a.x * b.y - a.y * b.x;
	}
	///------------------------------------------------------------------------
	///Line intersection::
	///where a is initial point, d is direction and t is some real parameter.
	point2d intersect(point2d a1, point2d d1, point2d a2, point2d d2) {
	return a1 + cross(a2 - a1, d2) / cross(d1, d2) * d1;
	}
	///Planes intersection::
	point3d intersect(point3d a1, point3d n1, point3d a2, point3d n2, point3d a3, point3d n3) {
	point3d x(n1.x, n2.x, n3.x);
	point3d y(n1.y, n2.y, n3.y);
	point3d z(n1.z, n2.z, n3.z);
	point3d d(dot(a1, n1), dot(a2, n2), dot(a3, n3));
	return point3d(triple(d, y, z),
	triple(x, d, z),
	triple(x, y, d)) / triple(n1, n2, n3);
	}
	int main()
	{
	FASTIO
	///*
	#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
	freopen("out.txt", "w", stdout);
	freopen("error.txt", "w", stderr);
	#endif
	//*/
	int T;
	//scanf("%d", &T);
	T = 1;
	for (int cs = 1; cs <= T; cs++) {
	}
	return 0;
	}

view raw BasicGeo.cpp hosted with ❤ by GitHub

Share: