using System;

namespace Science.Physics.GeneralPhysics
{
	/// <summary>
	/// Variable is inherited into almost all.
	/// DimensionL = Length dimension
	/// DimensionM = Mass dimension
	/// DimensionT = Time dimension
	/// </summary>
	public class Scalar : Dimension
	{
        public delegate Scalar Field(Position x, Time t);
        public delegate Scalar FunctionOfPosition(Position x);
        public delegate Scalar FunctionOfTime(Time t);

        private double magnitude = 0.0;
        private double sd = 0.0;
        private bool v = false;

		public Scalar()
		{
		}

        private Scalar.Field g;
        public Scalar(Scalar.Field f)
		{
			g = f;
		}
        public Scalar.Field ScalarField
        {
            get { return g; }
            set { g = value; }
        }

        private Scalar.FunctionOfPosition gp;
        public Scalar(Scalar.FunctionOfPosition fp)
		{
			gp = fp;
		}
        public Scalar.FunctionOfPosition ScalarFunctionOfPosition
        {
            get { return gp; }
            set { gp = value; }
        }

        private Scalar.FunctionOfTime gt;
        public Scalar(Scalar.FunctionOfTime ft)
        {
            gt = ft;
        }
        public Scalar.FunctionOfTime ScalarFunctionOfTime
        {
            get { return gt; }
            set { gt = value; }
        }

		public void Set(Position x, Time t)
		{
			magnitude = g(x,t).Magnitude;
		}

		public void Set(Position x)
		{
			magnitude = gp(x).Magnitude;
		}

        public void Set(Time t)
        {
            magnitude = gt(t).Magnitude;
        }

		public bool VariableQ
		{
			get{return v;}
			set{v = value;}
		}

		public double Magnitude
		{
			get{return magnitude;}
			set{magnitude=value;}
		}

        public double StandardDeviation
        {
            get { return sd; }
            set { sd = value; }
        }	


		public static Scalar operator +(Scalar a, Scalar b)
		{
			Scalar c = new Scalar();
			c.Magnitude = a.Magnitude + b.Magnitude;
			return c;
		}
		public static Scalar operator -(Scalar a, Scalar b)
		{
			Scalar c = new Scalar();
			c.Magnitude = a.Magnitude - b.Magnitude;
			return c;
		}
		public static Scalar operator *(Scalar a, Scalar b)
		{
			Scalar c = new Scalar();
			c.Magnitude = a.Magnitude * b.Magnitude;
			return c;
		}
		public static Scalar operator /(Scalar a, Scalar b)
		{
			Scalar c = new Scalar();
			c.Magnitude = a.Magnitude / b.Magnitude;
			return c;
		}
        public static Scalar operator *(double a, Scalar b)
        {
            Scalar c = new Scalar();
            c.Magnitude = a * b.Magnitude;
            return c;
        }
        public static Scalar operator /(Scalar a, double b)
        {
            Scalar c = new Scalar();
            c.Magnitude = a.Magnitude / b;
            return c;
        }
        public static Scalar operator *(Scalar a, double b)
        {
            Scalar c = new Scalar();
            c.Magnitude = a.Magnitude * b;
            return c;
        }
        public static Scalar operator /(double a, Scalar b)
        {
            Scalar c = new Scalar();
            c.Magnitude = a / b.Magnitude;
            return c;
        }

        public override string ToString()
        {
            string res = "";
            res += this.Magnitude.ToString() + " +/- " + this.StandardDeviation.ToString()+" ";
            return res;
        }
        public string ToONLYmks()
        {
            string res = "";
            this.DimensionTransformCharge();
            res += "(kg^" + this.DimensionMass.ToString();
            res += " m^" + this.DimensionLength.ToString();
            res += " s^" + this.DimensionTime.ToString() + ")";
            return res;
        }
	}
}