定位導航算法高級框架設計

一、前言

在衛星和高端傳感器的數據中。精通《設計模式》和算法，可以幫助您分析並做出更有力和知識淵博的決策，實現導航領域中搜索引擎的強大算法設計。

二、後端算法高級框架設計圖

 

三、相關設計模式的類名詞說明

1、蒙特卡羅樹搜索 - 圖形化模擬 Upper Confidence bound applied to Trees(UCT)

2、 calculation_time來控制時間

3、選舉(selection)是根據當前獲得所有子步驟的統計結果，選擇一個最優的子步驟。

4、擴展(expansion)在當前獲得的統計結果不足以計算出下一個步驟時，隨機選擇一個子步驟。

5、模擬(simulation)模擬決策過程，進入下一步。

6、反向傳播(Back-Propagation)根據決策的結果，計算對應路徑上統計記錄的值。

7、置信區間(confidence intervals)是指由樣本統計量所構造的總體參zhi數的估計區間，窄的置信區間比寬的置信區間能提供更多的有關總體參數的信息。越小的置信區間置信度就越高。

四、工具類設計

工具類：存在了某一類事物的工具方法的類。

工具類存在的包：工具包  tools 。

工具類起名：表示一類事物。比如：在tools包下的Sampler爲取樣器工具類。

該Sampler工具方法全部使用static修飾， 只需要使用工具類名調用即可。

五、設計代碼邏輯

註釋：由於公開，已經去掉中文說明。該類爲取樣器，進行數據的計算邏輯封裝。

package tools;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.Random;
import java.util.Set;

import jdk.internal.dynalink.beans.StaticClass;

public class Sampler {
    private static Random rng = new Random(
            Calendar.getInstance().getTimeInMillis() +
                    Thread.currentThread().getId());

    public static Random getRandom() {
        return rng;
    }

    public static boolean sampleCoin() {
        return rng.nextBoolean();
    }


    public static double sampleBeta(double alpha, double beta) {
        double x, y;
        x = sampleGamma(alpha, 1);
        y = sampleGamma(beta, 1);
        return x / (x + y);
    }

    // Sample from the 1 - X where X ~ beta( alpha , beta)
    public static double one_minus_sampleBeta(double alpha, double beta) {
        double x, y;
        x = sampleGamma(alpha, 1);
        y = sampleGamma(beta, 1);
        return y / (x + y);
    }


    public static long nextPoisson(double lambda) {
        return (long) (-1.0 * Math.log(1.0 - rng.nextDouble() * 1.0) / lambda);
    }


    public static double nextExponential(double b) {
        double randx;
        double result;
        randx = rng.nextDouble();
        result = -1 * b * Math.log(randx);
        return result;
    }

    public static double sampleGamma(double k, double theta) {
        boolean accept = false;
        if (k < 1) {
            // Weibull algorithm
            double c = (1 / k);
            double d = ((1 - k) * Math.pow(k, (k / (1 - k))));
            double u, v, z, e, x;
            do {
                u = rng.nextDouble();
                v = rng.nextDouble();
                z = -Math.log(u);
                e = -Math.log(v);
                x = Math.pow(z, c);
                if ((z + e) >= (d + x)) {
                    accept = true;
                }
            } while (!accept);
            return (x * theta);
        } else {
            // Cheng's algorithm
            double b = (k - Math.log(4));
            double c = (k + Math.sqrt(2 * k - 1));
            double lam = Math.sqrt(2 * k - 1);
            double cheng = (1 + Math.log(4.5));
            double u, v, x, y, z, r;
            do {
                u = rng.nextDouble();
                v = rng.nextDouble();
                y = ((1 / lam) * Math.log(v / (1 - v)));
                x = (k * Math.exp(y));
                z = (u * v * v);
                r = (b + (c * y) - x);
                if ((r >= ((4.5 * z) - cheng)) ||
                        (r >= Math.log(z))) {
                    accept = true;
                }
            } while (!accept);
            return (x * theta);
        }
    }


    public static Double[] subSampleNaive(List<Double> samples, int m) {
        int n = samples.size();
        int nm = Math.min(m, n);
        Double[] sub = new Double[nm];
        if (nm == n) {
            sub = samples.toArray(sub);
            return sub;
        }
        for (int k = 0; k < nm; k++) {
            int i = rng.nextInt(n);
            Double aux = samples.get(k);
            samples.set(k, samples.get(i));
            samples.set(i, aux);
        }
        sub = samples.subList(0, nm).toArray(sub);
        return sub;
    }

    public static Double[] subSample(List<Double> samples, int m) {
        //System.out.println(samples.size() +" " + m);

        int n = samples.size();
        int nm = Math.min(m, n);
        Double[] sub = new Double[nm];
        if (nm == n) {
            sub = samples.toArray(sub);
            return sub;
        }
        if (m < n / 2) {
            for (int k = 0; k < nm; k++) {
                int i = rng.nextInt(n);
                Double aux = samples.get(0);
                samples.set(0, samples.get(i));
                samples.set(i, aux);
            }
            sub = samples.subList(0, nm).toArray(sub);
        } else {
            for (int k = 0; k < n - nm; k++) {
                int i = rng.nextInt(n);
                Double aux = samples.get(0);
                samples.set(0, samples.get(i));
                samples.set(i, aux);
            }
            sub = samples.subList(n - nm, n).toArray(sub);
        }
        return sub;
    }

}