Java MathUtils.distance方法代码示例

import org.apache.commons.math.util.MathUtils; //导入方法依赖的package包/类
/**
 * 指定した対象点、データセットを基に対象点とデータセット中の各点間の距離を算出し、距離の昇順のリストを生成して返す。
 * 
 * @param targetPoint 判定対象点
 * @param dataSet 全体データ
 * @return 距離算出結果リスト。距離＞データIDの優先度でソートした状態で返す。
 */
protected static List<DistanceResult> calculateDistances(LofPoint targetPoint,
        LofDataSet dataSet)
{
    List<DistanceResult> distances = new ArrayList<>();
    for (Map.Entry<String, LofPoint> targetEntry : dataSet.getDataMap().entrySet())
    {
        // 同一データの場合除外する
        if (StringUtils.equals(targetEntry.getKey(), targetPoint.getDataId()) == true)
        {
            continue;
        }

        double distance = MathUtils.distance(targetEntry.getValue().getDataPoint(),
                targetPoint.getDataPoint());

        DistanceResult result = new DistanceResult(targetEntry.getKey(), distance);

        // リストに保持し、算出後ソート
        distances.add(result);
    }

    Collections.sort(distances, new DistanceResultComparator());
    return distances;
}
 

import org.apache.commons.math.util.MathUtils; //导入方法依赖的package包/类
/**
 * クラスタリングが収束したかを判定する。
 * 
 * @param basePoints 前回の中心点リスト
 * @param newPoints 今回の中心点リスト
 * @param convergenceThres 収束閾値
 * @return 収束した場合true、収束していない場合false
 */
public static boolean isConvergenced(List<KmeansPoint> basePoints, List<KmeansPoint> newPoints,
        double convergenceThres)
{
    boolean result = true;

    for (int pointIndex = 0; pointIndex < basePoints.size(); pointIndex++)
    {
        double distance = MathUtils.distance(basePoints.get(pointIndex).getDataPoint(),
                newPoints.get(pointIndex).getDataPoint());
        if (distance > convergenceThres)
        {
            result = false;
            break;
        }
    }

    return result;
}
 

import org.apache.commons.math.util.MathUtils; //导入方法依赖的package包/类
/**
 * 点リストを用いて重みつき確率分布を算出する。
 * 
 * @param basePoints 算出元となる点リスト
 * @param centroids 現状の中心点リスト
 * @return 重みつき確率分布
 */
public static double[] computeDxs(List<KmeansPoint> basePoints, List<KmeansPoint> centroids)
{
    double[] dxs = new double[basePoints.size()];

    double sum = 0.0d;
    double[] nearestCentroid;
    for (int pointIndex = 0; pointIndex < basePoints.size(); pointIndex++)
    {
        // 対象点に対する最近傍中心との距離(dx)を算出し、二乗に比例する重み付き確率分布値を算出
        KmeansPoint targetPoint = basePoints.get(pointIndex);
        KmeansResult kmeanResult = KmeansCalculator.nearestCentroid(targetPoint, centroids);
        nearestCentroid = kmeanResult.getCentroid();
        double dx = MathUtils.distance(targetPoint.getDataPoint(), nearestCentroid);
        double probabilityDist = Math.pow(dx, 2);
        sum += probabilityDist;
        dxs[pointIndex] = sum;
    }

    return dxs;
}
 

import org.apache.commons.math.util.MathUtils; //导入方法依赖的package包/类
/**
 * ベース中心点配列とマージ対象中心点配列の各々のユークリッド距離を算出する。
 * 
 * @param baseCentroids ベース中心点配列
 * @param targetCentroids マージ対象中心点配列 
 * @param centroidNum 中心点数
 * @return ユークリッド距離リスト
 */
protected static List<CentroidMapping> calculateDistances(double[][] baseCentroids,
        double[][] targetCentroids, int centroidNum)
{
    // ベース中心点配列とマージ対象中心点配列の各々のユークリッド距離を算出
    List<CentroidMapping> allDistance = new ArrayList<>();

    for (int baseIndex = 0; baseIndex < centroidNum; baseIndex++)
    {
        for (int targetIndex = 0; targetIndex < centroidNum; targetIndex++)
        {
            CentroidMapping centroidMapping = new CentroidMapping();
            centroidMapping.setBaseIndex(baseIndex);
            centroidMapping.setTargetIndex(targetIndex);
            double distance = MathUtils.distance(baseCentroids[baseIndex],
                    targetCentroids[targetIndex]);
            centroidMapping.setEuclideanDistance(distance);
            allDistance.add(centroidMapping);
        }
    }
    return allDistance;
}
 

import org.apache.commons.math.util.MathUtils; //导入方法依赖的package包/类
/**
 * 対象点と中心点配列を指定し、対象点に最も近い中心点のインデックスを取得し、結果エンティティを返す
 * 
 * @param targetPoint 判定対象ポイント
 * @param centroids 中心点配列
 * @return Kmeans算出結果
 */
public static KmeansResult nearestCentroid(double[] targetPoint, double[][] centroids)
{
    int nearestCentroidIndex = 0;
    Double minDistance = Double.MAX_VALUE;
    double[] currentCentroid = null;
    Double currentDistance;
    for (int index = 0; index < centroids.length; index++)
    {
        currentCentroid = centroids[index];
        if (currentCentroid != null)
        {
            currentDistance = MathUtils.distance(targetPoint, currentCentroid);
            if (currentDistance < minDistance)
            {
                minDistance = currentDistance;
                nearestCentroidIndex = index;
            }
        }
    }

    currentCentroid = centroids[nearestCentroidIndex];

    KmeansResult result = new KmeansResult();
    result.setDataPoint(targetPoint);
    result.setCentroidIndex(nearestCentroidIndex);
    result.setCentroid(currentCentroid);
    result.setDistance(minDistance);

    return result;
}
 

import org.apache.commons.math.util.MathUtils; //导入方法依赖的package包/类
/**
 * 対象点と学習モデルを指定し、どのクラスタに判別されるかを取得する。
 * 
 * @param targetPoint 判定対象ポイント
 * @param dataSet 学習モデル
 * @return どのクラスタに判別されるかのインデックス
 */
public static KmeansResult classify(KmeansPoint targetPoint, KmeansDataSet dataSet)
{
    // KMeanクラスタリング結果を算出
    int nearestCentroidIndex = 0;
    Double minDistance = Double.MAX_VALUE;
    double[] currentCentroid = null;
    Double currentDistance;
    for (int index = 0; index < dataSet.getCentroids().length; index++)
    {
        currentCentroid = dataSet.getCentroids()[index];
        if (currentCentroid != null)
        {
            currentDistance = MathUtils.distance(targetPoint.getDataPoint(), currentCentroid);
            if (currentDistance < minDistance)
            {
                minDistance = currentDistance;
                nearestCentroidIndex = index;
            }
        }
    }

    currentCentroid = dataSet.getCentroids()[nearestCentroidIndex];

    KmeansResult result = new KmeansResult();
    result.setDataPoint(targetPoint.getDataPoint());
    result.setCentroidIndex(nearestCentroidIndex);
    result.setCentroid(currentCentroid);
    result.setDistance(minDistance);

    return result;
}
 

import org.apache.commons.math.util.MathUtils; //导入方法依赖的package包/类
/** {@inheritDoc} */
public double distanceFrom(final EuclideanIntegerPoint p) {
    return MathUtils.distance(point, p.getPoint());
}
 

import org.apache.commons.math.util.MathUtils; //导入方法依赖的package包/类
/**
 * 学習データの中間データを更新する必要があるDataIdの一覧を生成する。<br>
 * 以下のいずれかの条件を満たす場合に更新する必要があると判断する。
 * <ol>
 * <li>削除されたデータをK距離近傍に含む</li>
 * <li>追加点との距離がK距離より小さい</li>
 * </ol>
 * 
 * @param addedPoint 追加点
 * @param dataSet 学習データセット
 * @param deleteId 削除データのId
 * @return 学習データの中間データを更新する必要があるDataIdの一覧
 */
protected static Set<String> generateUpdateTargets(LofPoint addedPoint, LofDataSet dataSet,
        String deleteId)
{
    Set<String> updateTargets = new HashSet<>();
    // 以下の条件のいずれかを満たす対象点と追加された対象点に対してK距離、K距離近傍、局所到達可能密度の更新を行う必要がある。
    // 但し、今回追加された対象点は常時対象となるため、判定は行わず、中間データ更新が必要として扱う。
    // 1.削除されたデータをK距離近傍に含む
    // 2.追加された対象点との距離がK距離より小さい。
    updateTargets.add(addedPoint.getDataId());
    Collection<LofPoint> pointList = dataSet.getDataMap().values();
    for (LofPoint targetPoint : pointList)
    {
        boolean isDeteted = false;
        boolean kDistUpdate = false;

        // 今回追加された対象点は判定をスキップ
        if (StringUtils.equals(addedPoint.getDataId(), targetPoint.getDataId()) == true)
        {
            continue;
        }

        // 「1.削除されたデータをK距離近傍に含む」判定
        // K値は高々20～30の値になるのが一般的なため、Listへのcontainsメソッド実行は性能負荷にはならないと判断する。
        if (deleteId != null && targetPoint.getkDistanceNeighbor().contains(deleteId) == true)
        {
            isDeteted = true;
        }

        // 「2.追加された対象点との距離がK距離より小さい。」判定
        if (MathUtils.distance(addedPoint.getDataPoint(), targetPoint.getDataPoint()) < targetPoint.getkDistance())
        {
            kDistUpdate = true;
        }

        if (isDeteted || kDistUpdate)
        {
            updateTargets.add(targetPoint.getDataId());
        }
    }

    return updateTargets;
}