• C#，数值计算——插值和外推，Base_interp的计算方法与源程序

    1 文本格式

    using System;

    namespace Legalsoft.Truffer
    {
        ///


        /// Abstract base class used by all interpolation routines in this chapter.
        /// Only the routine interp is called directly by the user.
        ///
        public abstract class Base_interp
        {
            public int n { get; set; }
            public int mm { get; set; }
            public int jsav { get; set; }
            public int cor { get; set; }
            public int dj { get; set; }
            public double[] xx { get; set; }
            public double[] yy { get; set; }

            ///


            /// Set up for interpolating on a table of x's and y's of length m. Normally
            /// called by a derived class, not by the user.
            ///
            ///
            ///
            ///
            public Base_interp(double[] x, double y, int m)
            {
                this.n = x.Length;
                this.mm = m;
                this.jsav = 0;
                this.cor = 0;
                this.xx = x;
                this.yy = new double[x.Length];
                for (int i = 0; i < yy.Length; i++)
                {
                    yy[i] = y;
                }
                dj = Math.Max(1, (int)Math.Pow((double)n, 0.25));
            }

            public double interp(double x)
            {
                int jlo = (cor != 0) ? hunt(x) : locate(x);
                return rawinterp(jlo, x);
            }

            ///


            /// Given a value x, return a value j such that x is (insofar as possible)
            /// centered in the subrange xx[j..j + mm - 1], where xx is the stored pointer.
            /// The values in xx must be monotonic, either increasing or decreasing.
            /// The returned value is not less than 0, nor greater than n-1.
            ///
            ///
            ///
            ///
            public int locate(double x)
            {
                if (n < 2 || mm < 2 || mm > n)
                {
                    throw new Exception("locate size error");
                }
                bool ascnd = (xx[n - 1] >= xx[0]);
                int jl = 0;
                int ju = n - 1;
                while (ju - jl > 1)
                {
                    int jm = (ju + jl) >> 1;
                    if (x >= xx[jm] == ascnd)
                    {
                        jl = jm;
                    }
                    else
                    {
                        ju = jm;
                    }
                }
                cor = Math.Abs(jl - jsav) > dj ? 0 : 1;
                jsav = jl;
                return Math.Max(0, Math.Min(n - mm, jl - ((mm - 2) >> 1)));
            }

            ///


            /// Given a value x, return a value j such that x is (insofar as possible)
            /// centered in the subrange xx[j..j + mm - 1], where xx is the stored pointer.
            /// The values in xx must be monotonic, either increasing or decreasing.
            /// The returned value is not less than 0, nor greater than n-1.
            ///
            ///
            ///
            ///
            public int hunt(double x)
            {
                int jl = jsav;
                int inc = 1;
                if (n < 2 || mm < 2 || mm > n)
                {
                    throw new Exception("hunt size error");
                }
                bool ascnd = (xx[n - 1] >= xx[0]);
                int ju;
                if (jl < 0 || jl > n - 1)
                {
                    jl = 0;
                    ju = n - 1;
                }
                else
                {
                    if (x >= xx[jl] == ascnd)
                    {
                        for (; ; )
                        {
                            ju = jl + inc;
                            if (ju >= n - 1)
                            {
                                ju = n - 1;
                                break;
                            }
                            else if (x < xx[ju] == ascnd)
                            {
                                break;
                            }
                            else
                            {
                                jl = ju;
                                inc += inc;
                            }
                        }
                    }
                    else
                    {
                        ju = jl;
                        for (; ; )
                        {
                            jl = jl - inc;
                            if (jl <= 0)
                            {
                                jl = 0;
                                break;
                            }
                            else if (x >= xx[jl] == ascnd)
                            {
                                break;
                            }
                            else
                            {
                                ju = jl;
                                inc += inc;
                            }
                        }
                    }
                }
                while (ju - jl > 1)
                {
                    int jm = (ju + jl) >> 1;
                    if (x >= xx[jm] == ascnd)
                    {
                        jl = jm;
                    }
                    else
                    {
                        ju = jm;
                    }
                }
                cor = Math.Abs(jl - jsav) > dj ? 0 : 1;
                jsav = jl;
                return Math.Max(0, Math.Min(n - mm, jl - ((mm - 2) >> 1)));
            }

            public abstract double rawinterp(int jlo, double x);

        }
    }
     

    2 代码格式

    1. using System;
    2.  
    3. namespace Legalsoft.Truffer
    4. {
    5.     /// 
    6.     /// Abstract base class used by all interpolation routines in this chapter.
    7.     /// Only the routine interp is called directly by the user.
    8.     /// 
    9.     public abstract class Base_interp
    10.     {
    11.         public int n { get; set; }
    12.         public int mm { get; set; }
    13.         public int jsav { get; set; }
    14.         public int cor { get; set; }
    15.         public int dj { get; set; }
    16.         public double[] xx { get; set; }
    17.         public double[] yy { get; set; }
    18.  
    19.         /// 
    20.         /// Set up for interpolating on a table of x's and y's of length m. Normally
    21.         /// called by a derived class, not by the user.
    22.         /// 
    23.         /// 
    24.         /// 
    25.         /// 
    26.         public Base_interp(double[] x, double y, int m)
    27.         {
    28.             this.n = x.Length;
    29.             this.mm = m;
    30.             this.jsav = 0;
    31.             this.cor = 0;
    32.             this.xx = x;
    33.             this.yy = new double[x.Length];
    34.             for (int i = 0; i < yy.Length; i++)
    35.             {
    36.                 yy[i] = y;
    37.             }
    38.             dj = Math.Max(1, (int)Math.Pow((double)n, 0.25));
    39.         }
    40.  
    41.         public double interp(double x)
    42.         {
    43.             int jlo = (cor != 0) ? hunt(x) : locate(x);
    44.             return rawinterp(jlo, x);
    45.         }
    46.  
    47.         /// 
    48.         /// Given a value x, return a value j such that x is (insofar as possible)
    49.         /// centered in the subrange xx[j..j + mm - 1], where xx is the stored pointer.
    50.         /// The values in xx must be monotonic, either increasing or decreasing.
    51.         /// The returned value is not less than 0, nor greater than n-1.
    52.         /// 
    53.         /// 
    54.         /// 
    55.         /// 
    56.         public int locate(double x)
    57.         {
    58.             if (n < 2 || mm < 2 || mm > n)
    59.             {
    60.                 throw new Exception("locate size error");
    61.             }
    62.             bool ascnd = (xx[n - 1] >= xx[0]);
    63.             int jl = 0;
    64.             int ju = n - 1;
    65.             while (ju - jl > 1)
    66.             {
    67.                 int jm = (ju + jl) >> 1;
    68.                 if (x >= xx[jm] == ascnd)
    69.                 {
    70.                     jl = jm;
    71.                 }
    72.                 else
    73.                 {
    74.                     ju = jm;
    75.                 }
    76.             }
    77.             cor = Math.Abs(jl - jsav) > dj ? 0 : 1;
    78.             jsav = jl;
    79.             return Math.Max(0, Math.Min(n - mm, jl - ((mm - 2) >> 1)));
    80.         }
    81.  
    82.         /// 
    83.         /// Given a value x, return a value j such that x is (insofar as possible)
    84.         /// centered in the subrange xx[j..j + mm - 1], where xx is the stored pointer.
    85.         /// The values in xx must be monotonic, either increasing or decreasing.
    86.         /// The returned value is not less than 0, nor greater than n-1.
    87.         /// 
    88.         /// 
    89.         /// 
    90.         /// 
    91.         public int hunt(double x)
    92.         {
    93.             int jl = jsav;
    94.             int inc = 1;
    95.             if (n < 2 || mm < 2 || mm > n)
    96.             {
    97.                 throw new Exception("hunt size error");
    98.             }
    99.             bool ascnd = (xx[n - 1] >= xx[0]);
    100.             int ju;
    101.             if (jl < 0 || jl > n - 1)
    102.             {
    103.                 jl = 0;
    104.                 ju = n - 1;
    105.             }
    106.             else
    107.             {
    108.                 if (x >= xx[jl] == ascnd)
    109.                 {
    110.                     for (; ; )
    111.                     {
    112.                         ju = jl + inc;
    113.                         if (ju >= n - 1)
    114.                         {
    115.                             ju = n - 1;
    116.                             break;
    117.                         }
    118.                         else if (x < xx[ju] == ascnd)
    119.                         {
    120.                             break;
    121.                         }
    122.                         else
    123.                         {
    124.                             jl = ju;
    125.                             inc += inc;
    126.                         }
    127.                     }
    128.                 }
    129.                 else
    130.                 {
    131.                     ju = jl;
    132.                     for (; ; )
    133.                     {
    134.                         jl = jl - inc;
    135.                         if (jl <= 0)
    136.                         {
    137.                             jl = 0;
    138.                             break;
    139.                         }
    140.                         else if (x >= xx[jl] == ascnd)
    141.                         {
    142.                             break;
    143.                         }
    144.                         else
    145.                         {
    146.                             ju = jl;
    147.                             inc += inc;
    148.                         }
    149.                     }
    150.                 }
    151.             }
    152.             while (ju - jl > 1)
    153.             {
    154.                 int jm = (ju + jl) >> 1;
    155.                 if (x >= xx[jm] == ascnd)
    156.                 {
    157.                     jl = jm;
    158.                 }
    159.                 else
    160.                 {
    161.                     ju = jm;
    162.                 }
    163.             }
    164.             cor = Math.Abs(jl - jsav) > dj ? 0 : 1;
    165.             jsav = jl;
    166.             return Math.Max(0, Math.Min(n - mm, jl - ((mm - 2) >> 1)));
    167.         }
    168.  
    169.         public abstract double rawinterp(int jlo, double x);
    170.  
    171.     }
    172. }

  • 相关阅读:
    串（KMP算法）
    AtomicReference实现单例模式
    spring容器
    Vue与TypeScript的配合：如何在Vue项目中使用TypeScript，利用静态类型提高代码的可维护性
    CUDA安装
    python txt 读取 写入
    Python数学基础-识图一、平面直角坐标系
    CoT 的方式使用 LLM 设计测试用例实践
    【Linux C | 网络编程】入门知识：UDP协议、一个最简单的UDP客户端、一个最简单的UDP服务端
    Scala语言用Selenium库写一个爬虫模版
  • 原文地址：https://blog.csdn.net/beijinghorn/article/details/134347571