関数フィッティング手法基本クラス

最適化
関数フィッティング手法基本クラス

概要
各種関数フィッティング手法クラスに継承される。

ソースコード

namespace DataFitting {
    /// <summary>フィッティング基本クラス</summary>
    public abstract class FittingMethod {

        /// <summary>フィッティング対象のデータ</summary>
        protected readonly FittingData[] data_list;

        /// <summary>コンストラクタ</summary>
        public FittingMethod(FittingData[] data_list, int parameters) {
            if(data_list == null) {
                throw new ArgumentNullException(nameof(data_list));
            }
            if(data_list.Length < 1) {
                throw new ArgumentException(nameof(data_list));
            }
            if(parameters < 1) {
                throw new ArgumentException(nameof(parameters));
            }

            this.data_list = data_list;
            this.ParametersCount = parameters;
        }

        /// <summary>パラメータ数</summary>
        public int ParametersCount {
            get; private set;
        }

        /// <summary>誤差二乗和</summary>
        public double Cost(Vector parameters) {
            if(parameters == null) {
                throw new ArgumentNullException(nameof(parameters));
            }
            if(parameters.Dim != ParametersCount) {
                throw new ArgumentException(nameof(parameters));
            }

            Vector errors = Error(parameters);
            double cost = 0;
            for(int i = 0; i < errors.Dim; i++) {
                cost += errors[i] * errors[i];
            }

            return cost;
        }

        /// <summary>誤差</summary>
        public Vector Error(Vector parameters) {
            if(parameters == null) {
                throw new ArgumentNullException(nameof(parameters));
            }
            if(parameters.Dim != ParametersCount) {
                throw new ArgumentException(nameof(parameters));
            }

            Vector errors = Vector.Zero(data_list.Length);

            for(int i = 0; i < data_list.Length; i++) {
                errors[i] = FittingValue(data_list[i].X, parameters) - data_list[i].Y;
            }

            return errors;
        }

        /// <summary>フィッティング値</summary>
        public abstract double FittingValue(double x, Vector parameters);
    }

    /// <summary>フィッティング関数真値</summary>
    public struct FittingData {

        /// <summary>コンストラクタ</summary>
        public FittingData(double x, double y) {
            this.X = x;
            this.Y = y;
        }

        /// <summary>独立変数</summary>
        public double X { get; set; }

        /// <summary>従属変数</summary>
        public double Y { get; set; }

        /// <summary>文字列化</summary>
        public override string ToString() {
            return $"{X},{Y}";
        }
    }

    /// <summary>フィッティング関数</summary>
    public class FittingFunction {
        readonly Func<double, Vector, double> f;
        readonly Func<double, Vector, Vector> df;

        /// <summary>コンストラクタ</summary>
        public FittingFunction(int parameters_count, Func<double, Vector, double> f, Func<double, Vector, Vector> df) {
            this.ParametersCount = parameters_count;
            this.f = f;
            this.df = df;
        }

        /// <summary>パラメータ数</summary>
        public int ParametersCount {
            get; private set;
        }

        /// <summary>関数値</summary>
        public double F(double x, Vector v) {
            return f(x, v);
        }

        /// <summary>関数勾配</summary>
        public Vector DiffF(double x, Vector v) {
            return df(x, v);
        }
    }
}