个软申请 数据预测引擎系统1.0.0 源码1

package org.tinos.deta.classification;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

//Theory yaoguang.luo 20191219， 欧基里德

//Application yaoguang.luo

public class Fissile{

public static Map<Double, List<Position2D>> fissilePosition2D(List<Position2D> groups

, double scale) {

Map<Double, List<Position2D>> distanceGroups= new HashMap<>();

Map<Double, Position2D> distanceHeart= new HashMap<>();

Iterator<Position2D> iterator= groups.iterator();

double i= 0.0;

Here:

distanceHeart.put(i, position2D);

}else {

//遍历所有团

//团重心匹配如果超精度新存，不是就融入。

Iterator<Double> iteratorScale= distanceHeart.keySet().iterator();

boolean isFind= false;

while(iteratorScale.hasNext()) {

Double doubleScale= iteratorScale.next();

Position2D currenctHeart= distanceHeart.get(doubleScale);

double distance= Distance.getDistance2D(currenctHeart, position2D);

list.add(position2D);

distanceGroups.put(doubleScale, list);

//删除当前重心数据，更新重心数据

distanceHeart.put(doubleScale, newHeart);

//找到

isFind= true;

//如果预测 坐标适应状态 可以把 continue 省略。

continue Here;

}

distanceHeart.put(i, position2D);

}

}

}

return distanceGroups;

}

public static Map<Double, List<Position3D>> fissilePosition3D(List<Position3D> groups

, double scale) {

Map<Double, List<Position3D>> distanceGroups= new HashMap<>();

Map<Double, Position3D> distanceHeart= new HashMap<>();

List<Position3D> list= new ArrayList<>();

list.add(position3D);

distanceGroups.put(i, list);

distanceHeart.put(i, position3D);

}else {

//遍历所有团

//团重心匹配如果超精度新存，不是就融入。

Iterator<Double> iteratorScale= distanceHeart.keySet().iterator();

boolean isFind= false;

while(iteratorScale.hasNext()) {

//删除当前增加坐标集，更新坐标集

List<Position3D> list= distanceGroups.get(doubleScale);

list.add(position3D);

distanceGroups.put(doubleScale, list);

//删除当前重心数据，更新重心数据

distanceHeart.put(doubleScale, newHeart);

//找到

isFind= true;

List<Position3D> list= new ArrayList<>();

list.add(position3D);

distanceGroups.put(++i, list);

distanceHeart.put(i, position3D);

}

}

}

return distanceGroups;

}

}

import org.tinos.deta.basic.Distance;

import org.tinos.deta.basic.Euclid;

import org.tinos.deta.demension.Position2D;

import org.tinos.deta.demension.Position3D;

//task 20191219 daytime

//通过 scale 距离来进行 坐标团切裂, 并匹配最短最近重心域融入。

//算法 耗时更长，准确度再增加。

//Theory yaoguang.luo 20191219~23， 欧基里德

//Application yaoguang.luo

public class FissileWithMatch{

while(iterator.hasNext()) {

Position2D position2D= iterator.next();

if(distanceGroups.isEmpty()) {

ArrayList<Position2D> ArrayList= new ArrayList<>();

ArrayList.add(position2D);

distanceGroups.put(i, ArrayList);

distanceHeart.put(i, position2D);

}else {

//遍历所有团

Double doubleScale= iteratorScale.next();

Position2D currenctHeart= distanceHeart.get(doubleScale);

double distance= Distance.getDistance2D(currenctHeart, position2D);

if(distance< scale) {

if(false== isFind) {

isFind= true;

shortest= distance;

shortestDoubleScale= doubleScale;

}else {

if(shortest< distance) {

if(true== isFind) {

Position2D currenctHeart= distanceHeart.get(shortestDoubleScale);

//融入得到新的重心

Position2D newHeart= Euclid.findCryptionPosition2D(currenctHeart, position2D);

//删除当前增加坐标集，更新坐标集

ArrayList<Position2D> ArrayList= distanceGroups.get(shortestDoubleScale);

ArrayList.add(position2D);

distanceGroups.put(shortestDoubleScale, ArrayList);

//删除当前重心数据，更新重心数据

distanceHeart.put(shortestDoubleScale, newHeart);

}

}

return distanceGroups;

}

public static Map<Double, ArrayList<Position3D>>

fissilePosition3DWithMatch(ArrayList<Position3D> groups, double scale) {

Map<Double, ArrayList<Position3D>> distanceGroups= new HashMap<>();

Map<Double, Position3D> distanceHeart= new HashMap<>();

Iterator<Position3D> iterator= groups.iterator();

distanceGroups.put(i, ArrayList);

distanceHeart.put(i, position3D);

}else {

//遍历所有团

//团重心匹配如果超精度新存，不是就融入。

Iterator<Double> iteratorScale= distanceHeart.keySet().iterator();

double shortest= 0;

double shortestDoubleScale= 0;

boolean isFind= false;

while(iteratorScale.hasNext()) {

shortest= distance;

shortestDoubleScale= doubleScale;

}else {

if(shortest< distance) {

}

}

}

}

ArrayList.add(position3D);

distanceGroups.put(shortestDoubleScale, ArrayList);

//删除当前重心数据，更新重心数据