template<class T = double>
class Scaler
{
public:
	Scaler() : mn(0), mx(0) {}
	Scaler(const T& mn, const T& mx) : mn(mn), mx(mx) {}

	inline void Min(const T& t) { mn = t; }
	inline T Min() const { return mn; }
	inline void Max(const T& t) { mx = t; }
	inline T Max() const { return mx; }
	inline void MinMax(const T& _mn, const T& _mx) { mn = _mn; mx = _mx; }

	//scales local dimension value t to foreign dimensions d
	//returned in foreign dimension
	inline T To(const Scaler& d, const T& t) { return (t-mn)*(d.mx-d.mn)/(mx-mn)+d.mn; }
	//scales foreign dimension value t from foreign s to local dimension
	//return in local dimension
	inline T From(const Scaler& s, const T& t) { return (t-s.mn)*(mx-mn)/(s.mx-s.mn)+mn; }

	inline T operator() (const Scaler& s, const T& t) { return From(s, t); }
protected:
	T mn, mx;	
};

	Scaler<double> vsx, psx;

//from draw domain to value domain
	valx = vsx(psx, Point().x);

//from value domain to draw domain
	Point().x = (int) psx(vsx, valx);

class Function2D {
	virtual double GetX(double y) {};		// Get the first value
	virtual double GetY(double x) {};
	virtual Array <double> GetX(double y) {};	// Get all values
	virtual Array <double> GetY(double x) {};
};

class Line : public Function2D {
private:
	Point p1, p2;

public:
	Line(Point p1, Point p2) : p1(p1), p2(p2) {};
	
	virtual double GetX(double y);
	virtual double GetY(double x);
};

class Polynomial : public Function2D {
public:
	Polynomial(Point p1, ...);	// Polynomial defined by points
	Polynomial(double coeff, ...);	// Polynomial defined by coefficients
};

... other functions ...