/*
author:
	seth from http://www.bierdatenbank.de
tab size:
	2 (otherwise hardly readable!)
*/
#include <iostream>   // fuer cout, endl, max...
#include <cmath>      // fuer mathe-funktionen
#include "seth_std.h"

namespace seth_std{
	// sgn(a, sgn(0)) (vorzeichenfunktion)
	template<typename T>
	inline int sgn(T a, int zero){
		return (a>0)?1:(a==0)?zero:-1;
	}
	// x^y, x,y int, y>=0
	int pow(int basis, int exponent){
		if(exponent<0) std::cout <<"error: exponent bei int pow(int, int) muss ganzzahlig nichtnegativ sein"<<std::endl;
		int res=1;
		for(int i=0;i<exponent;++i) res*=basis;
		return res;
	}

	// mem_usage:: speichernutzungs-informationen
	int mem_usage::mem_in_use=0;     // momentan benutzter speicher
	int mem_usage::max_mem_in_use=0; // max. benutzter speicher
	// liefer max_mem_in_use
	int mem_usage::get_max_mem(){ return max_mem_in_use;}
	// speichernutzungs-informationen
	int mem_usage::mem_info(bool verbose){
		if(verbose){
			printf(" memory used: %.3fkiB\n",max_mem_in_use/1024.0);
			if(mem_in_use) printf(" memory still in use: %.3fkiB\n", mem_in_use/1024.0);
		}
		return mem_in_use;
	}
	// speicher, der benutzt wird
	int mem_usage::used_mem(int mem){
		mem_in_use+=mem;
		max_mem_in_use=std::max(max_mem_in_use, mem_in_use);
		return mem_in_use;
	}
	// speicher, der freigegeben wird
	int mem_usage::released_mem(int mem){
		mem_in_use-=mem;
		return mem_in_use;
	}

	// chronometer:: zeitmessung
	// starte uhr
	void chronometer::start_time(){
		t_start=clock();
		t_end=t_start;
	}
	// stoppe uhr
	void chronometer::stop_time(){ t_end=clock();}
	// zeit_mess_informationen
	unsigned chronometer::time_info(bool verbose){
		clock_t h;
		h=(t_start==t_end)?clock():t_end;
		unsigned time_used=(((h-t_start)*1000)/CLOCKS_PER_SEC);
		if(verbose) std::cout <<" time needed: "<<time_used<<" msec"<<std::endl;
		return time_used;
	}

	// punkt2d<T>::
	// ctor
	template<typename T> inline punkt2d<T>::punkt2d(T a, T b)
			: x (a), y (b){}
	// copy-ctor
	template<typename T> inline punkt2d<T>::punkt2d(const punkt2d<T>& src)
			: x (src.x), y (src.y){}
	// operator= punkt2d
	template<typename T> inline punkt2d<T>& punkt2d<T>::operator=(const punkt2d<T>& src){
		x=src.x;
		y=src.y;
		return *this;
	}
	// operator= skalar
	template<typename T> inline punkt2d<T>& punkt2d<T>::operator=(T skalar){
		x=skalar;
		y=skalar;
		return *this;
	}
	// -pt : unitaerer operator; negiere komponentenweise
	template<typename T> inline punkt2d<T> punkt2d<T>::operator-(){
		punkt2d<T> pt;
		pt.x=-x;
		pt.y=-y;
		return pt;
	}
	// pt+pt = pt
	template<typename T> inline punkt2d<T> punkt2d<T>::operator+(const punkt2d<T>& param) const{
		punkt2d<T> temp(*this);
		temp.x+=param.x;
		temp.y+=param.y;
		return temp;
	}
	// pt+=pt = pt
	template<typename T> inline punkt2d<T>& punkt2d<T>::operator+=(const punkt2d<T>& param){
		x+=param.x;
		y+=param.y;
		return *this;
	}
	// pt+s = pt (komponentenweise)
	template<typename T> inline punkt2d<T> punkt2d<T>::operator+(T skalar) const{
		punkt2d<T> temp(*this);
		temp.x+=skalar;
		temp.y+=skalar;
		return temp;
	}
	// pt+=s = pt
	template<typename T> inline punkt2d<T>& punkt2d<T>::operator+=(T skalar){
		x+=skalar;
		y+=skalar;
		return *this;
	}
	// pt-pt = pt
	template<typename T> inline punkt2d<T> punkt2d<T>::operator-(const punkt2d<T>& param) const{
		punkt2d<T> temp(*this);
		temp.x-=param.x;
		temp.y-=param.y;
		return temp;
	}
	// pt-=pt = pt
	template<typename T> inline punkt2d<T>& punkt2d<T>::operator-=(const punkt2d<T>& param){
		x-=param.x;
		y-=param.y;
		return *this;
	}
	// pt-s = pt (komponentenweise)
	template<typename T> inline punkt2d<T> punkt2d<T>::operator-(T skalar) const{
		punkt2d<T> temp(*this);
		temp.x-=skalar;
		temp.y-=skalar;
		return temp;
	}
	// pt-=s = pt
	template<typename T> inline punkt2d<T>& punkt2d<T>::operator-=(T skalar){
		x-=skalar;
		y-=skalar;
		return *this;
	}
	// pt*pt = pt (komponentenweise)
	template<typename T> inline punkt2d<T> punkt2d<T>::operator*(const punkt2d<T>& param) const{
		punkt2d<T> temp(*this);
		temp.x*=param.x;
		temp.y*=param.y;
		return temp;
	}
	// pt*=pt = pt
	template<typename T> inline punkt2d<T>& punkt2d<T>::operator*=(const punkt2d<T>& param){
		x*=param.x;
		y*=param.y;
		return *this;
	}
	// pt*s = pt (komponentenweise)
	template<typename T> inline punkt2d<T> punkt2d<T>::operator*(T skalar) const{
		punkt2d<T> temp(*this);
		temp.x*=skalar;
		temp.y*=skalar;
		return temp;
	}
	// pt*=s = pt
	template<typename T> inline punkt2d<T>& punkt2d<T>::operator*=(T skalar){
		x*=skalar;
		y*=skalar;
		return *this;
	}
	// pt/pt = pt (komponentenweise)
	template<typename T> inline punkt2d<T> punkt2d<T>::operator/(const punkt2d<T>& param) const{
		punkt2d<T> temp(*this);
		temp.x/=param.x;
		temp.y/=param.y;
		return temp;
	}
	// pt/=pt = pt
	template<typename T> inline punkt2d<T>& punkt2d<T>::operator/=(const punkt2d<T>& param){
		x/=param.x;
		y/=param.y;
		return *this;
	}
	// pt/s = pt (komponentenweise)
	template<typename T> inline punkt2d<T> punkt2d<T>::operator/(T skalar) const{
		punkt2d<T> temp(*this);
		temp.x/=skalar;
		temp.y/=skalar;
		return temp;
	}
	// pt/=s = pt
	template<typename T> inline punkt2d<T>& punkt2d<T>::operator/=(T skalar){
		x/=skalar;
		y/=skalar;
		return *this;
	}
	// operator==
	template<typename T> inline bool punkt2d<T>::operator==(const punkt2d<T>& param) const{
		return (x==param.x && y==param.y);
	}
	// operator!=
	template<typename T> inline bool punkt2d<T>::operator!=(const punkt2d<T>& param) const{
		return !((*this)==param);
	}
	// operator<
	template<typename T> inline bool punkt2d<T>::operator<(const punkt2d<T>& param) const{
		return (x<param.x && y<param.y);
	}
	// operator<=
	template<typename T> inline bool punkt2d<T>::operator<=(const punkt2d<T>& param) const{
		return (x<=param.x && y<=param.y);
	}
	// operator>
	template<typename T> inline bool punkt2d<T>::operator>(const punkt2d<T>& param) const{
		return (x<param.x && y<param.y);
	}
	// operator>=
	template<typename T> inline bool punkt2d<T>::operator>=(const punkt2d<T>& param) const{
		return (x>=param.x && y>=param.y);
	}
	// operator== (skalar)
	template<typename T> inline bool punkt2d<T>::operator==(T param) const{
		return (x==param && y==param);
	}
	// operator!= (skalar)
	template<typename T> inline bool punkt2d<T>::operator!=(T param) const{
		return !((*this)==param);
	}
	// operator< (skalar)
	template<typename T> inline bool punkt2d<T>::operator<(T param) const{
		return (x<param && y<param);
	}
	// operator<= (skalar)
	template<typename T> inline bool punkt2d<T>::operator<=(T param) const{
		return (x<=param && y<=param);
	}
	// operator> (skalar)
	template<typename T> inline bool punkt2d<T>::operator>(T param) const{
		return (x<param && y<param);
	}
	// operator>= (skalar)
	template<typename T> inline bool punkt2d<T>::operator>=(T param) const{
		return (x>=param && y>=param);
	}
	// abs
	template<typename T> inline punkt2d<T> punkt2d<T>::abs() const{
		punkt2d<T> abs_betrag;
		abs_betrag.x=(x<0)?-x:x;
		abs_betrag.y=(y<0)?-y:y;
		return abs_betrag;
	}
	// norm
	template<typename T> inline T punkt2d<T>::norm() const{ return ((T) sqrt(x*x+y*y));}
	// norm*norm
	template<typename T> inline T punkt2d<T>::norm2() const{ return (x*x+y*y);}
	// standard-skalarprodukt
	template<typename T> inline T punkt2d<T>::skp(punkt2d<T> pt) const{ return (x*pt.x+y*pt.y);}
	// drehe einen moore-nachbarschafts-vektor
	template<typename T> inline void punkt2d<T>::nrotate(int direction){
		T h=x;
		x=sgn(x-direction*y);
		y=direction*sgn(h+direction*y);
	}

	//fabs
	template<typename T> inline punkt2d<T> fabs(const punkt2d<T>& p){
		return p.abs();
	}
	// damit die linker-errors verschwinden
	template punkt2d<int>;
	template punkt2d<double>;
	template int sgn<double>(double, int);
	template int sgn<int>(int, int);
	template punkt2d<double> fabs<double>(const punkt2d<double>&);
	template punkt2d<int> fabs<int>(const punkt2d<int>&);
}