//******************************************************************************************************//  InverseDistanceWeightingFunction.cs - Gbtc////  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://opensource.org/licenses/MIT////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  08/20/2016 - Stephen C. Wills//       Generated original version of source code.////****************************************************************************************************** using System; namespace GSF.NumericalAnalysis.Interpolation{    /// <summary>    /// Function definition for the inverse distance weighting algorithm.    /// </summary>    /// <param name="x">The x-coordinate of the point at which the value is to be calculated.</param>    /// <param name="y">The y-coordinate of the point at which the value is to be calculated.</param>    /// <returns>The calculated value at the given location.</returns>    public delegate double IDWFunc(double x, double y);     /// <summary>    /// Function defintion for calculating the distance between two points.    /// </summary>    /// <param name="x1">The x-coordinate of the first point.</param>    /// <param name="y1">The y-coordinate of the first point.</param>    /// <param name="x2">The x-coordinate of the second point.</param>    /// <param name="y2">The y-coordinate of the second point.</param>    /// <returns>The distance between the two given points.</returns>    public delegate double DistanceFunc(double x1, double y1, double x2, double y2);     /// <summary>    /// Represents a function for calculating values    /// at given coordinates based on sparse data sets.    /// </summary>    /// <remarks>    /// Usage is similar to the <see cref="PiecewiseLinearFunction"/> class.    /// </remarks>    public class InverseDistanceWeightingFunction    {        #region [ Members ]         // Fields        private IDWFunc m_converter;        private DistanceFunc m_distanceFunction;        private double[] m_xCoordinates;        private double[] m_yCoordinates;        private double[] m_values;        private double m_power;         #endregion         #region [ Constructors ]         /// <summary>        /// Creates a new instance of the <see cref="InverseDistanceWeightingFunction"/> class.        /// </summary>        public InverseDistanceWeightingFunction()        {            m_distanceFunction = DefaultDistanceFunction;            m_power = 1;        }         #endregion         #region [ Properties ]         /// <summary>        /// Gets the collection of x-coordinates of points at which the values are known.        /// </summary>        public double[] XCoordinates        {            get            {                return m_xCoordinates;            }        }         /// <summary>        /// Gets the collection of y-coordinates of points at which the values are known.        /// </summary>        public double[] YCoordinates        {            get            {                return m_yCoordinates;            }        }         /// <summary>        /// Gets the collection of values of points at which the values are known.        /// </summary>        public double[] Values        {            get            {                return m_values;            }        }         /// <summary>        /// Gets the power applied to the inverse distance to control the speed of value's decay.        /// </summary>        public double Power        {            get            {                return m_power;            }        }         /// <summary>        /// Gets the function to be used to calculate the distance between two points.        /// </summary>        public DistanceFunc DistanceFunction        {            get            {                return m_distanceFunction;            }        }         #endregion         #region [ Methods ]         /// <summary>        /// Sets the collection of x-coordinates of points at which the values are known.        /// </summary>        /// <param name="xCoordinates">The x-coordinates of points at which the values are known.</param>        /// <returns>A reference to the inverse distance weighting function.</returns>        public InverseDistanceWeightingFunction SetXCoordinates(params double[] xCoordinates)        {            m_converter = null;            m_xCoordinates = xCoordinates;            return this;        }         /// <summary>        /// Sets the collection of y-coordinates of points at which the values are known.        /// </summary>        /// <param name="yCoordinates">The y-coordinates of points at which the values are known.</param>        /// <returns>A reference to the inverse distance weighting function.</returns>        public InverseDistanceWeightingFunction SetYCoordinates(params double[] yCoordinates)        {            m_converter = null;            m_yCoordinates = yCoordinates;            return this;        }         /// <summary>        /// Sets the collection of values of points at which the values are known.        /// </summary>        /// <param name="values">The values of points at which the values are known.</param>        /// <returns>A reference to the inverse distance weighting function.</returns>        public InverseDistanceWeightingFunction SetValues(params double[] values)        {            m_converter = null;            m_values = values;            return this;        }         /// <summary>        /// Sets the power applied to the inverse distance to control the speed of value's decay.        /// </summary>        /// <param name="power">The power applied to the inverse of the distance.</param>        /// <returns>A reference to the inverse distance weighting function.</returns>        /// <remarks>Larger values increase the speed of decay such that a known value affects a smaller area.</remarks>        public InverseDistanceWeightingFunction SetPower(double power)        {            m_converter = null;            m_power = power;            return this;        }         /// <summary>        /// Sets the function to be used to calculate the distance between two points.        /// </summary>        /// <param name="distanceFunction">The function used to calculate distance between two points.</param>        /// <returns>A reference to the inverse distance weighting function.</returns>        public InverseDistanceWeightingFunction SetDistanceFunction(DistanceFunc distanceFunction)        {            m_converter = null;            m_distanceFunction = distanceFunction ?? DefaultDistanceFunction;            return this;        }         private IDWFunc GetConverter()        {            DistanceFunc distanceFunction = m_distanceFunction;            double[] xCoordinates = m_xCoordinates ?? new double[0];            double[] yCoordinates = m_yCoordinates ?? new double[0];            double[] values = m_values ?? new double[0];            double power = m_power;             if (xCoordinates.Length != yCoordinates.Length)                throw new InvalidOperationException($"The number of x-coordinates must match the number of y-coordinates. ({xCoordinates.Length} != {yCoordinates.Length})");             if (xCoordinates.Length != values.Length)                throw new InvalidOperationException($"The number of coordinates must match the number of values. ({xCoordinates.Length} != {values.Length})");             if (xCoordinates.Length == 0)                return (x, y) => 0.0D;             return m_converter ?? (m_converter = (x, y) =>            {                double numerator = 0.0D;                double denominator = 0.0D;                 for (int i = 0; i < xCoordinates.Length; i++)                {                    double distance = distanceFunction(x, y, xCoordinates[i], yCoordinates[i]);                     if (distance == 0.0D)                        return values[i];                     double inverseDistance = Math.Pow(1.0D / distance, power);                    numerator += values[i] * inverseDistance;                    denominator += inverseDistance;                }                 return numerator / denominator;            });        }         #endregion         #region [ Operators ]         /// <summary>        /// Converts the <see cref="InverseDistanceWeightingFunction"/>        /// object to an <see cref="IDWFunc"/> to start converting values.        /// </summary>        /// <param name="idwFunction">The inverse distance wieghting function to be converted.</param>        /// <exception cref="InvalidOperationException">        /// <para>the number of x-coordinates does not equal the number of y-coordinates</para>        /// <para>- or -</para>        /// <para>the number of coordinates does not equal the number of values</para>        /// </exception>        public static implicit operator IDWFunc(InverseDistanceWeightingFunction idwFunction)        {            return idwFunction.GetConverter();        }         #endregion         #region [ Static ]         // Static Methods         /// <summary>        /// Calculates the distance between two points.        /// </summary>        /// <param name="x1">The x-coordinate of the first point.</param>        /// <param name="y1">The y-coordinate of the first point.</param>        /// <param name="x2">The x-coordinate of the second point.</param>        /// <param name="y2">The y-coordinate of the second point.</param>        /// <returns></returns>        public static double DefaultDistanceFunction(double x1, double y1, double x2, double y2)        {            double xDiff = x1 - x2;            double yDiff = y1 - y2;            return Math.Sqrt(xDiff * xDiff + yDiff * yDiff);        }         #endregion    }}