def get_radius(mesh, nodes, edge):
"""
Compute the radius of the mesh at a given edge.
Given the mesh and a set of nodes, edges obtained
e.g. via get_graph(mesh, ...), for a given edge
u, v we approximate the radius as follows:
1. c = (u+v)/2
2. n = v-u
2. cut mesh throuch c with normal n
3. compute length of intersection (only one CC)
4. infer radius
This is a rought approximation but seems the best we can
do in this situation. Also, a rought approximation will
be more than enough for our needs.
"""
u, v = nodes[edge]
section = mesh.section(v - u, (u + v) / 2)
connected_comps = list(nx.connected_components(section.vertex_graph))
cut_centers = [
section.vertices[list(H)].mean(axis=0) for H in connected_comps
]
mycut_idx = np.argmin(norm(cut_centers - v, axis=1))
lengths = [
norm(section.vertices[line.end_points[0]] -
section.vertices[line.end_points[1]]) for line in section.entities
if (line.end_points[0] in connected_comps[mycut_idx])
]
radius = np.sum(lengths) / (2 * np.math.pi)
return radius
def Executar(self):
self.Inicializar()
global media_anterior
valores = []
suporte = []
solucao_geral = []
for i in range(self.execucoes):
print("\n---------------------------- Execução: ", i , "------------------------------------------------------")
ambiente = self.Pendulum()
self.Relembrar_Ambiente(self.ambiente_atual)
self.Detectar_mudanca(ambiente, media_anterior)
if((self.congelar == False)):
self.Swarm_Finder(ambiente)
print("-> Finder: ", self.finder.gbest.fitness)
self.Exclusion(self.finder)
suporte.append(self.finder.gbest.fitness)
global current_particle
current_particle.append(self.finder.gbest)
#finderConvergenceChecking
if(i >= 4):
if(((suporte[i-3] - self.finder.gbest.fitness) < r_conv) or (sp.norm(current_particle[i-3].dimensao-self.finder.gbest.dimensao) < (r_conv/5))):
self.tracker.particulas = copy.deepcopy(self.finder.particulas)
self.tracker.gbest = copy.deepcopy(self.finder.gbest)
self.Swarm_Tracker(ambiente)
print("-> Tracker: ", self.tracker.gbest.fitness)
print("-> Melhor solução: ", self.tracker.gbest.fitness)
solucao_geral.append(self.tracker.gbest.fitness)
valores.append(self.finder.gbest.fitness)
#Swarm_freezing
if(i >= 4):
if(((valores[i-2] - self.finder.gbest.fitness) < r_conv) or (sp.norm(current_particle[i-2].dimensao-self.finder.gbest.dimensao) < (r_conv/5))):
self.congelar = True
print("\nMedia:" , np.mean(solucao_geral))
print("Desvio:" , np.std(solucao_geral))
def join_graphs(nodes1, edges1, nodes2, edges2, vertex):
"""
Join two graphs using an auxiliary vertex.
At the moment simply look for the closest node
of each tree to the aux vertex, and link.
"""
closest_n1 = np.argmin(norm(nodes1 - vertex, axis=1))
closest_n2 = np.argmin(norm(nodes2 - vertex, axis=1))
nodes = np.concatenate([nodes1, nodes2, [vertex]])
edges = np.concatenate([
edges1, edges2 + len(nodes1), [[len(nodes) - 1, closest_n1]],
[[len(nodes) - 1, len(nodes1) + closest_n2]]
])
return nodes, edges
def _color_point(self,
colors,
filled,
clustering_truth,
cluster_idx,
max_dist,
point,
offset=np.array([0, 0, 0])):
"""
Internal function used to color voxels in the draw_pixel function and to color the noise voxels
:param colors: The np.array containing the HTML color strings for every voxel
:param filled: The np.array containing the presence information for every voxel (if a voxel is drawn or not)
:param clustering_truth: The np.array containing the ground truth labels for the points
:param cluster_idx: The index of the current cluster
:param point: The coordinates of a voxel for the use in the colors/filled np.array
:param color: The color the point will have in HTML format with alpha value --> #RRGGBBAA or #RRGGBB
:param offset: The offset for the point. This is currently only used for adding noise
:return: the altered colors, filled np.array
"""
offset_point = point + offset
if max(offset_point) < (len(colors) - 1) and min(offset_point) > 0 and \
colors[offset_point[0]][offset_point[1]][offset_point[2]] != self._point_color:
color = self._calculate_point_color(norm(point - offset_point),
max_dist,
variant="curve")
colors[offset_point[0]][offset_point[1]][offset_point[2]] = \
"#" + 3 * color + "50" if self._alpha_voxels else "#" + 3 * color
filled[offset_point[0]][offset_point[1]][offset_point[2]] = 1
clustering_truth[offset_point[0], offset_point[1],
offset_point[2]] = cluster_idx
return colors, filled, clustering_truth
def apply_textures(self, vectors, fnames):
ids = self.segment_ids()
count = ids.shape[0]
done = 0
picked_textures = np.ones(vectors.shape[0])
for segment_id in ids:
print float(done) / count * 100
done += 1
mask = self.segment_mask(segment_id)
vector = feature_vector(self.raw_img[np.nonzero(mask)])
# compute cosine similarity
dots = np.einsum('ij,ij->i', vectors, np.resize(vector, vectors.shape))
v_norm = np.resize(distance.norm(vector), vectors.shape[0])
m_norm = norms(vectors)
scales = v_norm * m_norm
cosine_similarities = dots / scales
similarities = cosine_similarities / picked_textures
idx = np.argmax(similarities)
picked_textures[idx] += (picked_textures[idx] * 10)
#picked_textures[idx] += 1
fname = fnames[idx]
texture = self.load_image(fname, self.raw_img.shape)
self.raw_img[mask] = texture[mask]
def functionToFindRootOf(X):
# define airplane
definingParameters = setDefiningParameters(drivingParameters, X)
initialAirplane = defineSpecificAirplane(definingParameters)
initialAirplane.passengers = ceil(designMission.passengerFactor *
initialAirplane.maxPassengers)
# simulate airplane
simulationResult = simulateAirplane(initialAirplane,
designMission,
silent=silent)
initialAirplane = simulationResult["initial airplane"]
simulation = simulationResult["simulation"]
finalAirplane = simulationResult["final airplane"]
succeeded = simulationResult["succeeded"]
# calculate resultant point
if succeeded:
guessedGrossWeight = definingParameters["initial gross weight"]
predictedGrossWeight = AirplaneWeight(initialAirplane)
grossWeightDifference = abs(guessedGrossWeight -
predictedGrossWeight)
emptyFuelMass = finalAirplane.powerplant.emptyFuelMass
finalFuelMass = finalAirplane.powerplant.fuelMass
result = [
convert(grossWeightDifference, "N", "lb"),
convert(finalFuelMass * g - emptyFuelMass * g, "N", "lb")
] # W0 guess = W0 predicted, Wf capacity is all used up by end of mission
else:
result = [1e10, 1e10] # pseudo bound
print(X, "->", result, "=>", norm(
[0, 0], result)) if not silent else None # show convergence
return result
def rel_err(get, expect):
a = euclidean(get, expect)
b = norm(expect)
if b == 0:
return a
else:
return a / b
def rel_err(get, expect):
a = euclidean(get, expect)
b = norm(expect)
if b == 0:
return a
else:
return a/b
def functionToFindRootOf(X):
# define airplane
initialAirplane, referenceMissionChanged = setInitialConfiguration(
baseConfiguration, referenceMission, X)
# simulation
simulationResult = simulateAirplane(initialAirplane,
referenceMissionChanged,
silent=silent)
initialAirplane = simulationResult["initial airplane"]
simulation = simulationResult["simulation"]
finalAirplane = simulationResult["final airplane"]
succeeded = simulationResult["succeeded"]
# post-validation
if succeeded:
Wgs = [mg * g for mg in simulation["gas mass"]]
range = simulation["position"][lastIndex(
simulation["segment"], lambda s: s == "descent"
)] # the range not including the loiter segments
# FIXME: range getting beginning of descent
result = [
Wgs[-1], convert(range - referenceRange, "m", "nmi")
] # no gas left after whole mission & range flown = desired range
else:
result = [1e10, 1e10] # pseudo bound
print(X, "->", result, "=>", norm([0, 0], result))
return result
def Hellinger_distance(p, q, norm='l2'):
"""Hellinger distance of two discrete pdfs
Parameters
---------
p : array-like, the reference distribution
q : array-like, the estimate of the reference
Returns
-------
distance : array-like shape (n_samples,)
"""
p, q = _check_metric_arrays((p, q))
if norm == 'l1':
hellinger = np.vectorize(
(lambda p, q: norm(np.sqrt(p) - np.sqrt(q)) / _SQRT2),
signature='(n),(n)->()')
elif norm == 'l2':
hellinger = np.vectorize(
(lambda p, q: euclidean(np.sqrt(p), np.sqrt(q)) / _SQRT2),
signature='(n),(n)->()')
else:
raise ValueError(
'Norm must be specified to be l1 or l2, got {}'.format(norm))
return hellinger(p, q)
def apply_textures(self, vectors, fnames):
ids = self.segment_ids()
count = ids.shape[0]
done = 0
picked_textures = np.ones(vectors.shape[0])
for segment_id in ids:
print float(done) / count * 100
done += 1
mask = self.segment_mask(segment_id)
vector = feature_vector(self.raw_img[np.nonzero(mask)])
# compute cosine similarity
dots = np.einsum('ij,ij->i', vectors,
np.resize(vector, vectors.shape))
v_norm = np.resize(distance.norm(vector), vectors.shape[0])
m_norm = norms(vectors)
scales = v_norm * m_norm
cosine_similarities = dots / scales
similarities = cosine_similarities / picked_textures
idx = np.argmax(similarities)
picked_textures[idx] += (picked_textures[idx] * 10)
#picked_textures[idx] += 1
fname = fnames[idx]
texture = self.load_image(fname, self.raw_img.shape)
self.raw_img[mask] = texture[mask]
def visit(self, node, x):
if (node is None):
return
dis = x[node.sp] - self.data[node.data, node.sp]
if (dis > 0):
self.visit(node.right, x)
else:
self.visit(node.left, x)
if (dis > -self.neighbors[0].key): #dis是查询点到node分
# 割数据的距离以及另一
# 边所有数据的距离的一个下界,如果dis都没有资格进入knn
# 那么node上的数据以及node分割的另一边区域的所有数据都无需查询
return
#如果node上的数据点能进knn，就进knn
dis0 = -norm(self.data[node.data] - x)
if (dis0 > self.neighbors[0].key): #大家都是负数 大说明绝对值小，即更近，有资格进knn
heapq.heappushpop(self.neighbors, Temp(dis0, node.data))
#visit node的另一边区域
if (dis > 0):
self.visit(node.left, x)
else:
self.visit(node.right, x)
def _get_edge_cylinder(node0, node1, radius=0.1):
center = (node0 + node1) / 2
normal = node1 - node0
cyl = _get_cylinder(radius=radius,
normal=normal,
center=center,
height=norm(normal),
sections=6)
return cyl
def Exclusion(self, swarm):
r_excel = 0.5
for i in swarm.particulas:
if((sp.norm(i.dimensao-swarm.gbest.dimensao)) < r_excel):
swarm = PSO(1000, 10, 1, 2, 2, 1000)
swarm.Criar_Particula()
return swarm
def Distancia_vetores(self, a, b):
'''
método para calcular a distancia entre dois arrays
:param a: primeiro array
:param b: segundo array
:return: retorna a distancia entre os dois
'''
distancia = sp.norm(a-b)
return distancia
def step(self):
self._iteration_k += 1
subgradient = self.state().middle_subgradient()
subgradient_norm = distance.norm(subgradient, ord=2)
t_k = self._step_size_selector.step_size(subgradient_norm,
self._state.score(),
self._iteration_k)
shifted = self.state().x() - t_k * subgradient
projected = l1_projection.project_into_simplex(shifted)
self._state = self.state().move_to_x(projected)
def generate_displacement_word(self, word, timepoints):
L = []
for ot, nt in timepoints:
modelo = self.get_predictor(ot)
modeln = self.get_predictor(nt)
tuples = self.get_tuples(word, ot, nt)
for tup in tuples:
word1 = tup[0]
timepoint1 = tup[1]
word2 = tup[2]
timepoint2 = tup[3]
if self.is_present(timepoint1, word1) and self.is_present(
timepoint2, word2):
vec1 = self.get_vector(timepoint1, word1)
vec2 = self.get_vector(timepoint2, word2)
if self.norm_embedding:
assert (np.isclose(norm(vec1), 1.0))
assert (np.isclose(norm(vec2), 1.0))
vec1_pred = modelo.predict(vec1)
vec2_pred = modeln.predict(vec2)
if self.norm_embedding:
vec1_pred = normalize_vector(vec1_pred)
vec2_pred = normalize_vector(vec2_pred)
assert (np.isclose(norm(vec1), 1.0))
assert (np.isclose(norm(vec2), 1.0))
d = self.calculate_distance(vec1_pred, vec2_pred)
assert (len(d) == self.number_distance_metrics())
L.append([word1, timepoint1, word2, timepoint2] + d)
else:
# Word is not present in both time periods
L.append([word1, timepoint1, word2, timepoint2] + list(
itertools.repeat(np.nan,
self.number_distance_metrics())))
return L
def prepare_distances(self, data):
"""
Preprocess the given data.
Must be called before calling log_likelihood, or distances.
:param data:
:return:
"""
self._distances = np.sum((data - self._u)**2, axis=1)
assert abs(self._distances[1] -
distance.norm(data[1] - self._u, ord=2)**2) < 0.00001
assert len(self._distances) == len(data)
def set_center_no_inter(self):
"""
Set the center of the bridge.
To be used only when there is not intersection between the bodyparts.
"""
m0 = self.bp0.mesh.vertices
m1 = self.bp1.mesh.vertices
a = np.array([norm(m1 - v, axis=1) for v in m0])
i0, i1 = np.unravel_index(np.argmin(a, axis=None), a.shape)
self.center = 0.5 * (m0[i0] + m1[i1])
def _transform_to_similarity(v, s):
v = v / norm(v)
if s >= 0:
u = numpy.copy(v)
else:
u = -v
n = v.shape[0]
m = numpy.abs(v).argmax()
u[m] = 0
if count_nonzero(v) == 1:
u[(m+1)%n] = sin(arccos(s))
A = dot(u, v)
B = dot(u, u)
a = v[m]**2 - s**2
b = 2 * A * v[m]
c = A**2 - B * s**2
umx = -b / (2 * a)
umy_inner = max(b**2 - 4*a*c, 0) # To handle precision errors
umy = numpy.sqrt(umy_inner) / (2 * a)
um1 = umx + umy
um2 = umx - umy
if (
abs((um1*v[m] + A) / numpy.sqrt(um1**2 + B) - s)
< abs((um2*v[m] + A) / numpy.sqrt(um2**2 + B) - s)):
u[m] = um1
else:
u[m] = um2
u /= norm(u)
return u
def check_emptyness(mesh, nodes, edges):
"""
Try to guess if there are empty spaces.
Computes the distance of each vertex to its closest
graph node, rescaled by average mesh radius. Assumes
something is wrong if there are vertex with dist > th
Parameters
----------
...
"""
radiuses = [get_radius(mesh, nodes, edge) for edge in edges]
mean_rad = np.mean(radiuses)
vertices_dist_to_closest_node = [min(norm(nodes - v, axis=1))
for v in mesh.vertices]
vertices_dist_to_closest_node /= mean_rad
return max(vertices_dist_to_closest_node)
def _incremental_update(self, data_set, c_eta, c_nhr):
total_qE = 0
for fv in data_set:
bm_units, c_qE = self.get_winners(fv)
total_qE += c_qE
# update activation map
self.whist[bm_units] += 1
# get bmu's multi index
bmu_midx = _np.unravel_index(bm_units, self.shape)
# calculate neighbourhood over bmu given current radius
c_nh = self._neighbourhood(bmu_midx, c_nhr)
# update lattice
u = self.weights + c_eta * fv
self.weights = u / _distance.norm(u)
self.quantization_error.append(total_qE)
def value(self, functional='tv', **kwargs):
r"""
Compute value capturing some meaure of similarity using the
evaluated densities on a shared comparison set.
If either density evaluation is missing, re-compute it.
:param funtional: a function representing a measure of similarity
:type functional: method that takes in two lists/arrays and returns
a scalar value (measure of similarity)
:rtype: float
:returns: value representing a measurement between the left and right
sample sets, ideally a measure of similarity, a distance, a metric.
"""
left_den, right_den = self.get_left_densities(), self.get_right_densities()
if left_den is None:
# logging.log(20,"Left density missing. Estimating now.")
left_den = self.estimate_densities_left()
if right_den is None:
# logging.log(20,"Right density missing. Estimating now.")
right_den = self.estimate_densities_right()
if functional in ['tv', 'totvar',
'total variation', 'total-variation', '1']:
dist = ds.minkowski(left_den, right_den, 1, w=0.5, **kwargs)
elif functional in ['mink', 'minkowski']:
dist = ds.minkowski(left_den, right_den, **kwargs)
elif functional in ['norm']:
dist = ds.norm(left_den - right_den, **kwargs)
elif functional in ['euclidean', '2-norm', '2']:
dist = ds.minkowski(left_den, right_den, 2, **kwargs)
elif functional in ['sqhell', 'sqhellinger']:
dist = ds.sqeuclidean(np.sqrt(left_den), np.sqrt(right_den)) / 2.0
elif functional in ['hell', 'hellinger']:
return np.sqrt(self.value('sqhell'))
else:
dist = functional(left_den, right_den, **kwargs)
return dist / self._comparison_sample_set.check_num()
def cal_similarity(seq1, seq2, method):
if method == 'pear':
sim = pearsonr(seq1, seq2)[0]
return sim
elif method == 'cos':
sim = 1 - 0.5 * distance.cosine(seq1, seq2)
return sim
elif method == 'norm':
d_norm = distance.norm(np.array(seq1) - np.array(seq2), ord=2)
sim = 1 / (1 + d_norm)
return sim
elif method == 'diff':
_error = []
_diff = []
for i in range(len(seq1)):
_error.append(seq2[i] - seq1[i])
for i in range(len(_error) - 1):
_diff.append(abs(_error[i + 1] - _error[i]))
d_diff = np.mean(_diff)
sim = np.exp(-10 * d_diff)
return sim
else:
return -1
def visit(self, node, x):
if (node is None):
return
dis = x[node.sp] - self.data[node.data, node.sp]
if (dis > 0):
self.visit(node.right, x)
else:
self.visit(node.left, x)
if (dis > -self.neighbors[0].key): # 剪枝
return
# 如果node上的数据点能进knn，就进knn
dis0 = -norm(self.data[node.data] - x)
if (dis0 > self.neighbors[0].key): # 大家都是负数 大说明绝对值小，即更近，有资格进knn
heapq.heappushpop(self.neighbors, Temp(dis0, node.data))
# visit node的另一边区域
if (dis > 0):
self.visit(node.left, x)
else:
self.visit(node.right, x)
def cmc(self, model):
"""
1. How to compute CMC?
We use one camera view as the probe set, and the other as the gallery set.
For the gallery, we randomly sample one image for each identity.
For the probe, we use all the images, getting the CMC curve for each of them, and then average over them.
This evaluation process is repeated for 100 times and the mean value is reported as the final result.
See the Matlab function for more details.
:param model:
:return:
"""
model.eval()
final_feature = None
final_id_list = []
final_cam_id_list = []
for ii, (image_data_list, id_data_list,
cam_id_list) in enumerate(self._valid_dataloader):
final_id_list.extend(id_data_list.numpy().flatten().tolist())
final_cam_id_list.extend(cam_id_list.numpy().flatten().tolist())
dat_list = [image_data_list]
dat_list = [Variable(x) for x in dat_list]
dat_list = [x.cuda() for x in dat_list]
image_data_list = dat_list[0]
feature_list = model.forward(image_data_list)
feature_list_arr = feature_list.cpu().data.numpy()
if final_feature is None:
final_feature = feature_list_arr
else:
final_feature = np.vstack([final_feature, feature_list_arr])
norm_arr = norm(final_feature, ord=2, axis=-1)[:, np.newaxis]
final_feature /= norm_arr
final_id_list = np.array(final_id_list)
final_cam_id_list = np.array(final_cam_id_list)
unique_id, unique_idx = np.unique(final_id_list, return_inverse=True)
nb_id = unique_id.shape[0]
nb_data = final_id_list.shape[0]
count = 0
probe_view = random.randint(0, 1)
gallery_view = 1 - probe_view
probe_view_list = final_cam_id_list == probe_view
gallery_view_list = final_cam_id_list == gallery_view
range_arr = np.arange(nb_data)
gallery_view_idx_list = []
probe_view_idx_list = range_arr[probe_view_list]
for identity in unique_id:
same_id_list = identity == final_id_list
same_id_list *= gallery_view_list
sample_idx = random.choice(range_arr[same_id_list])
gallery_view_idx_list.append(sample_idx)
gallery_view_idx_list = np.array(gallery_view_idx_list)
probe_identity_list = final_id_list[probe_view_idx_list]
gallery_identity_list = final_id_list[gallery_view_idx_list]
probe_feature_list = final_feature[probe_view_idx_list]
gallery_feature_list = final_feature[gallery_view_idx_list]
mat_dist = cdist(probe_feature_list, gallery_feature_list)
sort_mat = np.argsort(mat_dist, axis=-1)
# compute cmc
# top1 top5 top10
top1 = 0
top5 = 0
top10 = 0
for i, sort_res in enumerate(sort_mat):
match_res = probe_identity_list[i] == gallery_identity_list[
sort_res]
top1 += match_res[0]
top5 += 1 if np.sum(match_res[0:5]) > 0 else 0
top10 += 1 if np.sum(match_res[:10]) > 0 else 0
# compute top10
return top1 / (0. + mat_dist.shape[0]), top5 / (
0. + mat_dist.shape[0]), top10 / (0. + mat_dist.shape[0])
def update_m(obj, ia, rcut=9.0, pbc=None):
"""
retrieve local structure around atom `ia
for periodic systems (or very large system)
"""
zs, coords, c = obj
v1, v2, v3 = c
vs = ssd.norm(c, axis=0)
ds = ssd.squareform(ssd.pdist(coords))
nns = []
for i, vi in enumerate(vs):
n1_doulbe = rcut / vi
n1 = int(n1_doulbe)
if n1 - n1_doulbe == 0:
n1s = range(-n1, n1 + 1) if pbc[i] else [
0,
]
elif n1 == 0:
n1s = [-1, 0, 1] if pbc[i] else [
0,
]
else:
n1s = range(-n1 - 1, n1 + 2) if pbc[i] else [
0,
]
nns.append(n1s)
n1s, n2s, n3s = nns
n123s_ = np.array(list(itl.product(n1s, n2s, n3s)))
n123s = []
for n123 in n123s_:
n123u = list(n123)
if n123u != [0, 0, 0]: n123s.append(n123u)
nau = len(n123s)
n123s = np.array(n123s, np.float)
na = len(zs)
cia = coords[ia]
zs_u = []
coords_u = []
zs_u.append(zs[ia])
coords_u.append(coords[ia])
for i in range(na):
di = ds[i, ia]
if (di > 0) and (di <= rcut):
zs_u.append(zs[i])
coords_u.append(coords[i])
# add new coords by translation
ts = np.zeros((nau, 3))
for iau in range(nau):
ts[iau] = np.dot(n123s[iau], c)
coords_iu = coords[i] + ts #np.dot(n123s, c)
dsi = ssd.norm(coords_iu - cia, axis=1)
filt = np.logical_and(dsi > 0, dsi <= rcut)
nx = filt.sum()
zs_u += [
zs[i],
] * nx
coords_u += [list(ci) for ci in coords_iu[filt, :]]
#for ci in coords_u: print(ci)
obj_u = [np.array(zs_u, dtype=int), np.array(coords_u)]
assert np.all(ssd.pdist(coords_u) > 0)
return obj_u
def Distancia_vetores(self, a, b):
resultado = sp.norm(a - b)
return resultado
def f(x, y): return distance.norm(x - y)
if metric == "euclidean":
def deterministic_gradient_size(self):
return distance.norm(self.middle_subgradient(), ord=2)
def score(self):
return distance.norm(np.dot(self.A(), self.x()) - self.b(), ord=1)
def closeAircraftDesign(defineSpecificAirplane,
drivingParameters,
designMission,
silent=False):
# DEPENDENCIES
def setDefiningParameters(drivingParameters, X):
definingParameters = copy.deepcopy(drivingParameters)
definingParameters["initial gross weight"] = X[0]
definingParameters["initial fuel weight"] = X[1]
return definingParameters
def functionToFindRootOf(X):
# define airplane
definingParameters = setDefiningParameters(drivingParameters, X)
initialAirplane = defineSpecificAirplane(definingParameters)
initialAirplane.passengers = ceil(designMission.passengerFactor *
initialAirplane.maxPassengers)
# simulate airplane
simulationResult = simulateAirplane(initialAirplane,
designMission,
silent=silent)
initialAirplane = simulationResult["initial airplane"]
simulation = simulationResult["simulation"]
finalAirplane = simulationResult["final airplane"]
succeeded = simulationResult["succeeded"]
# calculate resultant point
if succeeded:
guessedGrossWeight = definingParameters["initial gross weight"]
predictedGrossWeight = AirplaneWeight(initialAirplane)
grossWeightDifference = abs(guessedGrossWeight -
predictedGrossWeight)
emptyFuelMass = finalAirplane.powerplant.emptyFuelMass
finalFuelMass = finalAirplane.powerplant.fuelMass
result = [
convert(grossWeightDifference, "N", "lb"),
convert(finalFuelMass * g - emptyFuelMass * g, "N", "lb")
] # W0 guess = W0 predicted, Wf capacity is all used up by end of mission
else:
result = [1e10, 1e10] # pseudo bound
print(X, "->", result, "=>", norm(
[0, 0], result)) if not silent else None # show convergence
return result
# INITIALIZATION
guess = [convert(3000, "lb", "N"), convert(300, "lb", "N")]
# ROOT FINDING
result = root(functionToFindRootOf, guess, tol=1e-4)
closestGuess = result["x"]
airplane = defineSpecificAirplane(
setDefiningParameters(drivingParameters, closestGuess))
closed = norm([0, 0], result["fun"]) <= sqrt(2) # within 1 lb & 1 lb
return {"airplane": airplane, "closed": closed}
def closeReferenceMissionByFuelWeightAndRange(baseConfiguration,
referenceMission,
silent=False):
# DEPENDENCIES
def setInitialConfiguration(airplane, referenceMission, X):
WFguess = X[0]
rangeGuess = X[1]
A = copy.deepcopy(airplane)
referenceMission.segments[
"cruise"].completed = lambda birplane, t, t0: rangeGuess <= birplane.position
A.powerplant.gas.mass = WFguess / g
return (A, referenceMission)
def functionToFindRootOf(X):
# define airplane
initialAirplane, referenceMissionChanged = setInitialConfiguration(
baseConfiguration, referenceMission, X)
# simulation
simulationResult = simulateAirplane(initialAirplane,
referenceMissionChanged,
silent=silent)
initialAirplane = simulationResult["initial airplane"]
simulation = simulationResult["simulation"]
finalAirplane = simulationResult["final airplane"]
succeeded = simulationResult["succeeded"]
# post-validation
if succeeded:
Wgs = [mg * g for mg in simulation["gas mass"]]
range = simulation["position"][lastIndex(
simulation["segment"], lambda s: s == "descent"
)] # the range not including the loiter segments
# FIXME: range getting beginning of descent
result = [
Wgs[-1], convert(range - referenceRange, "m", "nmi")
] # no gas left after whole mission & range flown = desired range
else:
result = [1e10, 1e10] # pseudo bound
print(X, "->", result, "=>", norm([0, 0], result))
return result
# INITIALIZATION
Wg = baseConfiguration.powerplant.gas.mass * g if baseConfiguration.powerplant.gas else 0
guess = [Wg, convert(100, "nmi", "m")]
# ROOT FINDING
result = root(functionToFindRootOf, guess, tol=1e-4, options={"eps": 25})
closestGuess = result["x"]
initialAirplane, referenceMissionChanged = setInitialConfiguration(
baseConfiguration, referenceMission, closestGuess)
closed = norm([0, 0], result["fun"]) <= sqrt(2) # within 1 N & 1 nmi
return {
"airplane": initialAirplane,
"mission": referenceMissionChanged,
"closed": closed
}
if (dis > -self.neighbors[0].key): #dis是查询点到node分
# 割数据的距离以及另一
# 边所有数据的距离的一个下界,如果dis都没有资格进入knn
# 那么node上的数据以及node分割的另一边区域的所有数据都无需查询
return
#如果node上的数据点能进knn，就进knn
dis0 = -norm(self.data[node.data] - x)
if (dis0 > self.neighbors[0].key): #大家都是负数 大说明绝对值小，即更近，有资格进knn
heapq.heappushpop(self.neighbors, Temp(dis0, node.data))
#visit node的另一边区域
if (dis > 0):
self.visit(node.left, x)
else:
self.visit(node.right, x)
if __name__ == '__main__':
n_samples = 1000
n_features = 50
k = 20
a = np.random.randn(n_samples, n_features)
x = np.random.rand(n_features)
kdtree = KDTree(data=a)
ans1 = kdtree.k_neighbers(x, k=k)
ans2 = np.array(sorted(a, key=lambda y: norm(x - y))[:k])
print((ans1 == ans2).all())
def Distancia_vetores(self, a, b):
resultado = sp.norm(a-b)
return resultado
