public static IInterpolation Instance(InterpolationType type)
 {
     if (type == InterpolationType.InterpolationTypeSmooth)
         return new SmoothInterpolation();
     else
         return new SmoothInterpolation();
 }

        public ViewMoverKenBurnsStyle(CameraParameters from, CameraParameters to, double time, Date fromDateTime, Date toDateTime, InterpolationType type)
        {
            InterpolationType = type;

            if (Math.Abs(from.Lng - to.Lng) > 180)
            {
                if (from.Lng > to.Lng)
                {
                    from.Lng -= 360;
                }
                else
                {
                    from.Lng += 360;
                }
            }

            this.fromDateTime = fromDateTime;
            this.toDateTime = toDateTime;

            dateTimeSpan = toDateTime - fromDateTime;

            this.from = from.Copy();
            this.to = to.Copy();
            fromTime = Date.Now;
            toTargetTime = time;
        }

 public static bool AllowedLimitedPrefix(InterpolationType x)
 {
     if ((x == InterpolationType.limitedCubic) ||
         (x == InterpolationType.limitedLinear))
         return false;
     return true;
 }

 public FCurveKeyframe(InterpolationType interpolationType = asd.InterpolationType.Linear)
 {
     LeftHandle = new Vector2DF();
     RightHandle = new Vector2DF();
     KeyValue = new Vector2DF();
     Interpolation = interpolationType;
 }

		public double GetInterpolatedValue(double compleatedRatio0To1, InterpolationType interpolationType)
		{
			switch (interpolationType)
			{
				case InterpolationType.LINEAR:
					return compleatedRatio0To1;

				case InterpolationType.EASE_IN:
					return Math.Pow(compleatedRatio0To1, 3);

				case InterpolationType.EASE_OUT:
					return (Math.Pow(compleatedRatio0To1 - 1, 3) + 1);

				case InterpolationType.EASE_IN_OUT:
					if (compleatedRatio0To1 < .5)
					{
						return Math.Pow(compleatedRatio0To1 * 2, 3) / 2;
					}
					else
					{
						return (Math.Pow(compleatedRatio0To1 * 2 - 2, 3) + 2) / 2;
					}

				default:
					throw new NotImplementedException();
			}
		}

 public ArcGISImageCapabilities(string url, long startTime = -1, long endTime = -1, string format = "jpgpng", InterpolationType interpolation = InterpolationType.RSP_NearestNeighbor)
 {
     ServiceUrl = url;
     Format = format;
     Interpolation = interpolation;
     StartTime = startTime;
     EndTime = endTime;           
 }

 public Keyframe(Bone bone, float time, Matrix output, InterpolationType interpolation)
 {
     Bone = bone;
     Time = time;
     Transform = output;
     Interpolation = interpolation;
     Transform.Decompose(out Scale, out Rotation, out Translation);
 }

 static string InterpolationTypeToString(InterpolationType eInterpolationType)
 {
     if (eInterpolationType == InterpolationType.LINEAR)
     {
         return "LINEAR";
     }
     throw new MyException ("Interpolation Type not recognized");
 }

 public ImplicitFractal(FractalType fractalType, BasisType basisType, InterpolationType interpolationType)
 {
     this.Octaves = 8;
     this.Frequency = 1.00;
     this.Lacunarity = 2.00;
     this.Type = fractalType;
     this.SetAllSourceTypes(basisType, interpolationType);
     this.ResetAllSources();
 }

 public TimedInterpolator(double in_numSeconds, double in_startValue, double in_endValue, Repeate in_repeateType, InterpolationType in_interpolationType)
     : this()
 {
     numSeconds = in_numSeconds;
     startValue = in_startValue;
     endValue = in_endValue;
     distance = endValue - startValue;
     repeateType = in_repeateType;
     interpolationType = in_interpolationType;
 }

		public override void Reset()
		{
			mode = InterpolationType.Linear;
			fromFloat = null;
			toFloat = null;
			time = 1.0f;
			storeResult = null;
			finishEvent = null;
			realTime = false;
		}

 public override void Reset()
 {
     mode = InterpolationType.Linear;
     fromVector = new FsmVector3 { UseVariable = true };
     toVector = new FsmVector3 { UseVariable = true };
     time = 1.0f;
     storeResult = null;
     finishEvent = null;
     realTime = false;
 }

 public static bool StrictlyBoundedField(InterpolationType x)
 {
     if ((x == InterpolationType.limitedLinear)
         || (x == InterpolationType.vanLeer)
         || (x == InterpolationType.Gamma)
         || (x == InterpolationType.limitedCubic)
         || (x == InterpolationType.MUSCL)
         ) return true;
     return false;
 }

 public ImplicitFractal(FractalType fractalType, BasisType basisType, InterpolationType interpolationType, Int32 octaves, double frequency, Int32 seed)
 {
     this.seed = seed;
     this.Octaves = octaves;
     this.Frequency = frequency;
     this.Lacunarity = 2.00;
     this.Type = fractalType;
     this.SetAllSourceTypes(basisType, interpolationType);
     this.ResetAllSources();
 }

        /// <summary>
        /// コンストラクター
        /// </summary>
        /// <param name="targetProperty">ターゲット プロパティ名</param>
        /// <param name="interp">補完方法</param>
        public AnimationTrack(string targetProperty,InterpolationType interp)
        {
            if (targetProperty == null || targetProperty == "") {
                throw new ArgumentNullException ("Target Property is null or empty");
            }

            this.targetProperty = targetProperty;
            this.frames = new List<Keyframe>();
            this.interpType = interp;
            this.compCount = 0;
            this.compType = null;
        }

        public CPIBond(int settlementDays,
                double faceAmount,
                bool growthOnly,
                double baseCPI,
                Period observationLag,
                ZeroInflationIndex cpiIndex,
                InterpolationType observationInterpolation,
                Schedule schedule,
                List<double> fixedRate,
                DayCounter accrualDayCounter,
                BusinessDayConvention paymentConvention = BusinessDayConvention.ModifiedFollowing,
                Date issueDate = null,
                Calendar paymentCalendar = null,
                Period exCouponPeriod = null,
                Calendar exCouponCalendar = null,
					 BusinessDayConvention exCouponConvention = BusinessDayConvention.Unadjusted,
                bool exCouponEndOfMonth = false)                
            :base(settlementDays, paymentCalendar == null ? schedule.calendar() : paymentCalendar, issueDate)
        {
            frequency_ = schedule.tenor().frequency();
            dayCounter_ = accrualDayCounter;
            growthOnly_ = growthOnly;
            baseCPI_=baseCPI;
            observationLag_ = observationLag;
            cpiIndex_= cpiIndex;
            observationInterpolation_ = observationInterpolation;

            maturityDate_ = schedule.endDate();

            // a CPIleg know about zero legs and inclusion of base inflation notional
            cashflows_ = new CPILeg(schedule, cpiIndex_,
                                    baseCPI_, observationLag_)
             .withSubtractInflationNominal(growthOnly_)
             .withObservationInterpolation(observationInterpolation_)
             .withPaymentDayCounter(accrualDayCounter)
             .withFixedRates(fixedRate)
             .withPaymentCalendar(calendar_)
             .withExCouponPeriod(exCouponPeriod,
                                exCouponCalendar,
                                exCouponConvention,
                                exCouponEndOfMonth)
             .withNotionals(faceAmount)
             .withPaymentAdjustment(paymentConvention);
            

            calculateNotionalsFromCashflows();

            cpiIndex_.registerWith(update);

            foreach ( CashFlow i in cashflows_) 
                i.registerWith(update);
        }

 public TimedInterpolator(double in_numSeconds, double in_startValue, double in_endValue, Repeate in_repeateType, InterpolationType in_interpolationType)
 {
     if (!runningTimeStarted)
     {
         runningTime.Start();
     }
     numSeconds = in_numSeconds;
     startValue = in_startValue;
     endValue = in_endValue;
     distance = endValue - startValue;
     repeateType = in_repeateType;
     interpolationType = in_interpolationType;
 }

 float interp(float e1, float e2, float t, float tension, InterpolationType type, InterpolationMode mode)
 {
     switch ((int)mode)
     {
         case 0:
             return interpIn(e1, e2, t, tension, type);
         case 1:
             return interpOut(e1, e2, t, tension, type);
         case 2:
             return interpInOut(e1, e2, t, tension, type);
         default:
             return interpOutIn(e1, e2, t, tension, type);
     }
 }

 public static void GlobalInterpolation(InterpolationType typeInterpolation)
 {
     switch (typeInterpolation)
     {
         case InterpolationType.Slerp:
             System.Console.WriteLine("Bezier");
             break;
         case InterpolationType.Linear:
             System.Console.WriteLine("Linear");
             break;
         case InterpolationType.Constant:
             System.Console.WriteLine("Constant");
             break;
     }
 }

        public static Vector2 PixelInterpolate( InterpolationType type, Vector2 from, Vector2 to, float pixelPerSec, float elapsed )
        {
            switch( type )
            {
                case InterpolationType.Linear:
                    return PixelLerp( from, to, pixelPerSec, elapsed );

                case InterpolationType.SinusCurve:
                    return PixelSinus( from, to, pixelPerSec, elapsed );

                case InterpolationType.SmoothStep:
                    return PixelSmoothStep( from, to, pixelPerSec, elapsed );

                default:
                    return Vector2.Zero;
            }
        }