def M(self,m,m0,b):
from numpy import nditer, ones
from collections import deque
r0 = self.args["r0"]
K = self.args["K"]
# Ambartsumian–Chandrasekhar H -function - second-order aproximation:
H_o2 = vec( lambda x: 1e0/(1e0 - w*x*(r0 + 0.5*(1e0 - 2e0*r0*x)*log((1e0 + x)/(x + TINY)) )) )
# Double Factorial
fac = vec( lambda n: reduce(int.__mul__,range(n,0,-2)) )
# Odd coeficient:
A = vec( lambda n: (1/n)*(fac(n)/fac(n+1))*(-1)**(0.5*(n+1)) )
# Pn --> Legendre polynomials
o = arange(1,order,2) # odd
A_b = A(o)*b
iP = 1e0 - sum(A_b*A(o))
P_m0 = ones(m0.shape)
P_m = ones(m0.shape)
for i, n in enumerate(o):
P_m0 = P_m0 + A_b[i]*P(n)(m0)
P_m = P_m + A_b[i]*P(n)(m)
return P_m0*(H_o2(m/K) - 1e0) + P_m*(H_o2(m0/K) - 1e0) + iP*(H_o2(m/K) - 1e0)*(H_o2(m0/K) - 1e0)
def predict(self, test_X):
dataset = self.__dataset
intercept = self.__intercept
XX_inv = self.__XX_inv
beta = self.__beta
train_X = sm.add_constant(
dataset[:, :-1]) if intercept else dataset[:, :-1]
test_X = sm.add_constant(vec(test_X)) if intercept else vec(test_X)
train_Y = dataset[:, -1:]
train_pred = np.dot(train_X, beta)
# Confidence interval
sig = (np.linalg.norm(train_Y - train_pred)**2 /
(train_X.shape[0] - train_X.shape[1] + 1))**0.5
s = []
for row in range(test_X.shape[0]):
x = test_X[[row], :]
s.append(sig * (1 + np.dot(np.dot(x, XX_inv), x.T))**0.5)
s = np.reshape(np.asarray(s), (test_X.shape[0], 1))
test_pred = np.dot(test_X, beta)
hi_ci = test_pred + 2 * s
lo_ci = test_pred - 2 * s
return test_pred, hi_ci, lo_ci
def predict(self, test_X):
dataset = self.__dataset
intercept = self.__intercept
XX_inv = self.__XX_inv
beta = self.__beta
train_X = sm.add_constant(dataset[:, :-1]) if intercept else dataset[:, :-1]
test_X = sm.add_constant(vec(test_X)) if intercept else vec(test_X)
train_Y = dataset[:, -1:]
train_pred = np.dot(train_X, beta)
# Confidence interval
sig = (np.linalg.norm(train_Y-train_pred)**2/(train_X.shape[0]-train_X.shape[1]+1))**0.5
s = []
for row in range(test_X.shape[0]):
x = test_X[[row], :]
s.append(sig*(1 + np.dot(np.dot(x, XX_inv), x.T))**0.5)
s = np.reshape(np.asarray(s), (test_X.shape[0], 1))
test_pred = np.dot(test_X, beta)
hi_ci = test_pred + 2*s
lo_ci = test_pred - 2*s
return test_pred, hi_ci, lo_ci
def active( ground ):
collision = ground.getChild('user').getChild('collision')
res = []
for cp in collision.getChildren():
dofs = cp.getMechanicalState()
res.extend( [(vec(p), -vec(f))
for p, f in zip( dofs.position, dofs.force )
if np.dot(f, f) > 0
])
return res
def cal00(wave, ebv=0.0, rvp=4.05):
'''Calculates reddening according to Calzetti's 2000 Paper
'''
# Function
vcal00 = vec(_cal00, 3, 2)
return vcal00(wave, ebv, rvp)
def car89(wave, ebv=0.0, rvp=3.1):
'''Calculates reddening according to Cardelli's 1989 Paper
'''
# Function
vcar89 = vec(_car89, 3, 2)
return vcar89(wave, ebv, rvp)
def cal97(wave, ebv=0.0):
'''Calculates reddening according to Calzetti's 1997 Paper
'''
# Function
vcal97 = vec(_cal97, 2, 2)
return vcal97(wave, ebv)
def p_ray(self,g):
pg = vec(lambda x : 1 + 0.5*P(2)(cos(x)))
# Asymmetric Factor:
qsi = quad(lambda x: pg(x),0,pi)
b2 = 5e0*qsi**2
return pg(g) , b2 , qsi
def main():
global window, screen, renderups, ship_sprite
global relief, game_model, cap, ship
relief = model.Relief("surface_heights.csv")
ship = model.Spaceship(1000.0, vec([20.0, 0.0]), vec([0.0, 200.0]))
# cap = captain.BraveCaptain()
cap = captain.CarefulCaptain()
game_model = model.Model(relief, ship, cap)
pygame.init()
# pygame.mixer.init()
pygame.font.init()
ship_sprite = TextSprite(ship)
renderups = pygame.sprite.RenderUpdates(ship_sprite)
window = pygame.display.set_mode((1500, 500), 0, 32)
pygame.display.set_caption("Let's land")
screen = pygame.display.get_surface()
start_game()
def hartmann(x):
outer = 0.0
for i in range(4):
inner = 0.0
for j in range(4):
xj = x[0, j]
Aij = A[i, j]
Pij = P[i, j]
inner += Aij * (xj - Pij) ** 2
new = alpha[i] * np.exp(-inner)
outer += new
return vec(-1 * (1.1 - outer) / 0.839)
def gaussian_mix(query):
# Assign multivariate gaussians to be present in the space.
gaussians = [multivariate_normal(mean=[0.9, 0.1], cov=[[0.05, 0], [0, 0.05]])]
gaussians.append(multivariate_normal(mean=[0.9, 0.9], cov=[[0.07, 0.01], [0.01, 0.07]]))
gaussians.append(multivariate_normal(mean=[0.15, 0.7], cov=[[0.03, 0], [0, 0.03]]))
# Initialize initial value.
value = 0.0
# Iterate through each gaussian in the space.
for j in xrange(len(gaussians)):
value += gaussians[j].pdf(query)
# Take the average.
gaussian_function = value / len(gaussians)
return vec(gaussian_function) # vec(np.array([query.ravel(), gaussian_function]).ravel())
def get_logistic_prob(opt_w, features_mat):
p_y = []
X_test = features_mat
W = opt_w
n = len(X_test)
for i in range(n):
# p_i = exp((X_test[i].T).dot(argmin_w)) / (1 + exp((X_test[i].T).dot(argmin_w)))
p_i = exp((W.T).dot(X_test[i])) / (1 + exp((W.T).dot(X_test[i])))
p_y.append(p_i)
# print(p_i)
p_y = vec(p_y)
return p_y
def __init__(self,
G: float, # гравитационная постоянная
collision_distance: float # всё-таки это не точки
):
"""В начале было... да, а потом тестовая вселенная с пупом мира и двумя камнями"""
super().__init__(G, collision_distance)
self.centrum = Body(self, 500.0, vec([0.0, 0.0]), vec([0.0, 0.0]))
self.p_1 = Body(self, 10.0, vec([50.0, 0.0]), vec([0.0, 15.0]))
self.p_2 = Body(self, 10.0, vec([50.0, 40.0]), vec([-7.0, 7.0]))
def get_transition_matrix(time):
P = []
t = time
for i in range(N):
# print(i)
init_qw = kron(Cs[0], Ps[i])
P_i = get_prob_i(t, init_qw)
P.append(P_i)
P = vec(P)
return P
def get_log_likelihood(coeff_vec, features_mat, class_vec):
w = coeff_vec
X = features_mat
y = class_vec
n = len(X)
log_like_temp = []
log_likelihood = []
for i in range(n):
log_like = log(1 + exp((X[i].T).dot(w))) - y[i] * (X[i].T).dot(w)
log_like_temp.append(log_like)
log_likelihood = vec(sum(log_like_temp, axis=0))
return log_likelihood
def gaussian_mix(query):
# Assign multivariate gaussians to be present in the space.
gaussians = [
multivariate_normal(mean=[0.9, 0.1], cov=[[.05, 0], [0, .05]])
]
gaussians.append(
multivariate_normal(mean=[0.9, 0.9], cov=[[0.07, 0.01], [0.01, .07]]))
gaussians.append(
multivariate_normal(mean=[0.15, 0.7], cov=[[.03, 0], [0, .03]]))
# Initialize initial value.
value = 0.0
# Iterate through each gaussian in the space.
for j in range(len(gaussians)):
value += gaussians[j].pdf(query)
# Take the average.
gaussian_function = value / len(gaussians)
return vec(gaussian_function
) # vec(np.array([query.ravel(), gaussian_function]).ravel())
def advance(self, delta_t: float):
self.position += self.velocity * delta_t
self.velocity += [0.0, -Spaceship._moon_g * delta_t]
thrust_vec = vec([0.0, 0.0])
dm = 0.0
if self.fuel_mass > 0.0:
if Spaceship.Thrust.RIGHT & self.thrust:
thrust_vec += [0.25, 0.0]
dm += 0.25
if Spaceship.Thrust.LEFT & self.thrust:
thrust_vec += [-0.25, 0.0]
dm += 0.25
if Spaceship.Thrust.UP & self.thrust:
thrust_vec += [0.0, 1.0]
dm += 1.0
self.velocity += thrust_vec * delta_t * Spaceship._engine_thrust / self.mass
self.fuel_mass -= Spaceship._engine_mass_per_sec * dm * delta_t
def get_gradient(coeff_vec, features_mat, class_vec):
w_0 = coeff_vec
X = features_mat
y = class_vec
n = len(X)
gradient_mat = []
gradient = []
for i in range(n):
# logit = 1 / (1+exp(-(w_0.T).dot(X[i])))
logit = exp(X[i].T.dot(w_0)) / (1 + exp(X[i].T.dot(w_0)))
grad = X[i] * logit - y[i] * X[i]
gradient_mat.append(grad)
# print(vec(gradient_mat))
gradient = vec(sum(gradient_mat, axis=0))
return gradient
def readCSV(self, infile):
import csv
csvr = csv.reader(infile)
header = next(csvr)
if 0 != len(header) % 3:
raise Exception('Incorrect data format in CSV file')
self.markerLabels = [label[:-2] for label in header[::3]]
self.frames = []
for framerow in csvr:
newFrame = []
for c in range(0, len(framerow), 3):
m = Marker()
try:
m.position = vec([float(v) for v in framerow[c:c + 3]])
m.confidence = 1.
except:
pass
newFrame.append(m)
self.frames.append(newFrame)
self.startFrame = 0
self.endFrame = len(self.frames) - 1
self.scale = 1.
def readCSV(self, infile):
import csv
csvr = csv.reader(infile)
header = next(csvr)
if 0 != len(header) % 3:
raise Exception('Incorrect data format in CSV file')
self.markerLabels = [label[:-2] for label in header[::3]]
self.frames = []
for framerow in csvr:
newFrame = []
for c in range(0, len(framerow), 3):
m = Marker()
try:
m.position = vec([float(v) for v in framerow[c:c + 3]])
m.confidence = 1.
except:
pass
newFrame.append(m)
self.frames.append(newFrame)
self.startFrame = 0
self.endFrame = len(self.frames) - 1
self.scale = 1.
self.bodies[i].apply_force(self.bodies[i].force_induced_by_other(self.bodies[j]))
for i in range(len(self.bodies)):
self.bodies[i].advance()
def add_body(self, b: Body):
self.bodies.append(b)
if __name__ == '__main__':
dimensions = int(input("How many dimensions do you live in?" + '\n'))
un = UniverseWithDimensionsAndBodies(dimensions, 50, 3.08)
bodies_hit_the_floor = [
Body(un, 100.0, vec([0.0, 0.0]), vec([0.0, -15.0])),
Body(un, 100.0, vec([20.0, 0.0]), vec([0.0, 15.0])),
Body(un, 100.0, vec([10.0, 10.0]), vec([-15.0, 0.0])),
Body(un, 100.0, vec([10.0, -10.0]), vec([15.0, 0.0]))
]
for i in range(len(bodies_hit_the_floor)):
un.add_body(bodies_hit_the_floor[i])
MODEL_DELTA_T = 0.01
TIME_TO_MODEL = 5
positions: Union[List[List[float]]] = [[[0 for i in range(int(TIME_TO_MODEL / MODEL_DELTA_T))] for a in range(len(un.bodies))], [[0 for i in range(int(TIME_TO_MODEL / MODEL_DELTA_T))] for a in range(len(un.bodies))]]
for stepn in range(int(TIME_TO_MODEL / MODEL_DELTA_T)):
for i in range(len(un.bodies)):
import model
import captain
def trackship(m: model.Model) -> List[vec]:
poss = []
while m.step():
poss.append(m.spaceship.position.copy())
return poss
if __name__ == '__main__':
rel = model.Relief("surface_heights.csv")
m = model.Model(rel,
model.Spaceship(1000.0, vec([20.0, 0.0]), vec([0.0,
200.0])),
captain.CarefulCaptain()
# captain.BraveCaptain()
)
xs = np.arange(0.0, rel.get_width())
plt.plot(xs, [rel.get_height(x) for x in xs])
poss = trackship(m)
tx, ty = tuple(zip(*poss))
plt.plot(tx, ty)
plt.show()
import numpy as np
from numpy import atleast_2d as vec
alpha = [1.0, 1.2, 3.0, 3.2]
A = vec([[10, 3, 17, 3.5, 1.7, 8],
[0.05, 10, 17, 0.1, 8, 14],
[3, 3.5, 1.7, 10, 17, 8],
[17, 8, 0.05, 10, 0.1, 14]])
P = 10 ** (-4) * vec([[1312, 1696, 5569, 124, 8283, 5886],
[2329, 4135, 8307, 3736, 1004, 9991],
[2348, 1451, 3522, 2883, 3047, 6650],
[4047, 8828, 8732, 5743, 1091, 381]])
def hartmann(x):
outer = 0.0
for i in range(4):
inner = 0.0
for j in range(4):
xj = x[0, j]
Aij = A[i, j]
Pij = P[i, j]
inner += Aij * (xj - Pij) ** 2
new = alpha[i] * np.exp(-inner)
outer += new
return vec(-1 * (1.1 - outer) / 0.839)
if __name__ == "__main__":
print alpha
def m(x):
return vec(-3*x*(1.5+3*x)*(3*x-1.5)*(3*x-2))
def land(self):
self.velocity = vec([0.0, 0.0])
self.navigates = False
def skeleton(scale = 1):
vol = scale * scale * scale
# TODO scale masses
head = {
'mass': vol * 5,
'dim': scale * vec([0.25, 0.25, 0.25]),
}
upperback = {
'mass': vol * 10,
'dim': scale * vec([0.4, 0.4, 0.25])
}
lowerback = {
'mass': vol * 10,
'dim': scale * vec([0.3, 0.25, 0.25])
}
femur = {
'mass': vol * 7,
'dim': scale * vec([0.2, 0.5, 0.2]),
}
tibia = {
'mass': vol * 5,
'dim': scale * vec([0.10, 0.4, 0.1])
}
arm = {
'mass': vol * 4,
'dim': scale * vec([0.1, 0.3, 0.10])
}
forearm = {
'mass': vol * 3,
'dim': scale * vec([0.1, 0.5, 0.1])
}
foot = {
'mass': vol * 2,
'dim': scale * vec([0.1, 0.3, 0.1])
}
stiffness = 1e2
compliance = 1 / stiffness
hard = 1e-8
def hip(side):
sign = 1 if side == 'left' else -1
return {
"coords": [['lowerback', [sign * lowerback['dim'][0] / 2,
- lowerback['dim'][1] / 2,
0]],
['femur_{}'.format(side), [0,
femur['dim'][1] / 2,
0]]],
"rest": Quaternion(),
"compliance": compliance
}
def shoulder(side):
sign = 1 if side == 'left' else -1
return {
"coords": [['upperback', [sign * (1.2 * upperback['dim'][0]) / 2,
upperback['dim'][1] / 2,
0]],
['arm_{}'.format(side), [0, arm['dim'][1] / 2, 0]]],
"rest": Quaternion.exp( sign * math.pi / 6.0 * basis(2, 3)),
"compliance": compliance
}
def elbow(side):
return {
"coords": [['arm_{}'.format(side), [0,
-arm['dim'][1] / 2,
0]],
['forearm_{}'.format(side), [0,
forearm['dim'][1] / 2,
0]]],
"rest": Quaternion.exp( -math.pi / 6 * basis(0, 3) ),
"compliance": [compliance, hard, hard]
}
def knee(side):
return {
"coords": [['femur_{}'.format(side), [0,
-femur['dim'][1] / 2,
0]],
['tibia_{}'.format(side), [0,
tibia['dim'][1] / 2,
0]]],
"rest": Quaternion.exp( math.pi / 6 * basis(0, 3) ),
"compliance": [compliance, hard, hard]
}
# TODO finer ?
def ankle(side):
return {
"coords": [['tibia_{}'.format(side), [0,
-tibia['dim'][1] / 2,
0]],
['foot_{}'.format(side), [0,
foot['dim'][1] / 2,
0]]],
"rest": Quaternion.exp( -math.pi /2 * basis(0, 3) ),
"compliance": compliance
}
def spine():
return {
"coords": [['upperback', [0,
-upperback['dim'][1] / 2,
0]],
['lowerback', [0,
lowerback['dim'][1] / 2,
0]]],
"rest": Quaternion(),
"compliance": 1e-3
}
def neck():
return {
"coords": [['head', [0, -head['dim'][1] / 2, 0]],
['upperback', [0, upperback['dim'][1] / 2, 0]]],
"rest": Quaternion(),
"compliance": compliance
}
skeleton = {
'body': {
'head': head,
'upperback': upperback,
'lowerback': lowerback,
'femur_left': femur,
'femur_right': femur,
'tibia_left': tibia,
'tibia_right': tibia,
'arm_left': arm,
'arm_right': arm,
'forearm_left': forearm,
'forearm_right': forearm,
'foot_left': foot,
'foot_right': foot
},
'joint': {
'neck': neck(),
'shoulder_left': shoulder('left'),
'shoulder_right': shoulder('right'),
'elbow_left': elbow('left'),
'elbow_right': elbow('right'),
'hip_left': hip('left'),
'hip_right': hip('right'),
'knee_left': knee('left'),
'knee_right': knee('right'),
'ankle_left': ankle('left'),
'ankle_right': ankle('right'),
'spine': spine(),
}
}
return skeleton
super().__init__()
self.G = G
self.k = k
self.collision_distance = collision_distance
def gravity_flow_dencity_per_1_1(self, dist):
if dist > self.collision_distance:
return self.G / dist
else:
return -self.k / dist
u = Universe3D(MODEL_G, COLLISION_COEFFICIENT, COLLISION_DISTANCE)
bodies = [
MaterialPoint(u, 35000., vec([0., 0.]), vec([0., 0.])),
MaterialPoint(u, 10., vec([100., 0.]), vec([0., -10.])),
MaterialPoint(u, 10., vec([0., 100.]), vec([15., 0.]))
]
steps = int(TIME_TO_MODEL / MODEL_DELTA_T)
for stepn in range(steps):
u.model_step()
plt.gca().set_aspect('equal')
for b in bodies:
plt.plot(*tuple(map(list, zip(*b.ptrace))))
plt.show()
def skeleton(scale=1):
vol = scale * scale * scale
# TODO scale masses
head = {
'mass': vol * 5,
'dim': scale * vec([0.25, 0.25, 0.25]),
}
upperback = {'mass': vol * 10, 'dim': scale * vec([0.4, 0.4, 0.25])}
lowerback = {'mass': vol * 10, 'dim': scale * vec([0.3, 0.25, 0.25])}
femur = {
'mass': vol * 7,
'dim': scale * vec([0.2, 0.5, 0.2]),
}
tibia = {'mass': vol * 5, 'dim': scale * vec([0.10, 0.4, 0.1])}
arm = {'mass': vol * 4, 'dim': scale * vec([0.1, 0.3, 0.10])}
forearm = {'mass': vol * 3, 'dim': scale * vec([0.1, 0.5, 0.1])}
foot = {'mass': vol * 2, 'dim': scale * vec([0.1, 0.3, 0.1])}
stiffness = 1e2
compliance = 1 / stiffness
hard = 1e-8
def hip(side):
sign = 1 if side == 'left' else -1
return {
"coords": [[
'lowerback',
[sign * lowerback['dim'][0] / 2, -lowerback['dim'][1] / 2, 0]
], ['femur_{}'.format(side), [0, femur['dim'][1] / 2, 0]]],
"rest":
Quaternion(),
"compliance":
compliance
}
def shoulder(side):
sign = 1 if side == 'left' else -1
return {
"coords": [[
'upperback',
[
sign * (1.2 * upperback['dim'][0]) / 2,
upperback['dim'][1] / 2, 0
]
], ['arm_{}'.format(side), [0, arm['dim'][1] / 2, 0]]],
"rest":
Quaternion.exp(sign * math.pi / 6.0 * basis(2, 3)),
"compliance":
compliance
}
def elbow(side):
return {
"coords":
[['arm_{}'.format(side), [0, -arm['dim'][1] / 2, 0]],
['forearm_{}'.format(side), [0, forearm['dim'][1] / 2, 0]]],
"rest":
Quaternion.exp(-math.pi / 6 * basis(0, 3)),
"compliance": [compliance, hard, hard]
}
def knee(side):
return {
"coords": [['femur_{}'.format(side), [0, -femur['dim'][1] / 2, 0]],
['tibia_{}'.format(side), [0, tibia['dim'][1] / 2, 0]]],
"rest":
Quaternion.exp(math.pi / 6 * basis(0, 3)),
"compliance": [compliance, hard, hard]
}
# TODO finer ?
def ankle(side):
return {
"coords": [['tibia_{}'.format(side), [0, -tibia['dim'][1] / 2, 0]],
['foot_{}'.format(side), [0, foot['dim'][1] / 2, 0]]],
"rest":
Quaternion.exp(-math.pi / 2 * basis(0, 3)),
"compliance":
compliance
}
def spine():
return {
"coords": [['upperback', [0, -upperback['dim'][1] / 2, 0]],
['lowerback', [0, lowerback['dim'][1] / 2, 0]]],
"rest":
Quaternion(),
"compliance":
1e-3
}
def neck():
return {
"coords": [['head', [0, -head['dim'][1] / 2, 0]],
['upperback', [0, upperback['dim'][1] / 2, 0]]],
"rest":
Quaternion(),
"compliance":
compliance
}
skeleton = {
'body': {
'head': head,
'upperback': upperback,
'lowerback': lowerback,
'femur_left': femur,
'femur_right': femur,
'tibia_left': tibia,
'tibia_right': tibia,
'arm_left': arm,
'arm_right': arm,
'forearm_left': forearm,
'forearm_right': forearm,
'foot_left': foot,
'foot_right': foot
},
'joint': {
'neck': neck(),
'shoulder_left': shoulder('left'),
'shoulder_right': shoulder('right'),
'elbow_left': elbow('left'),
'elbow_right': elbow('right'),
'hip_left': hip('left'),
'hip_right': hip('right'),
'knee_left': knee('left'),
'knee_right': knee('right'),
'ankle_left': ankle('left'),
'ankle_right': ankle('right'),
'spine': spine(),
}
}
return skeleton
# Date: 02/20/2019, Wednesday # Author: Minwoo Bae ([email protected]) # Institute: The Department of Computer Science and Engineering, UCONN ########################################################################################################################### import numpy as np #kron: Kronecker product (kron): matrix tensor matrix from numpy import sqrt, dot, outer, reshape, kron, append, insert from numpy import transpose as T from numpy import tensordot as tensor from numpy.linalg import inv from numpy.linalg import norm from numpy import array as vec from numpy import eye as id # Hadamard operator: H = (1 / sqrt(2)) * vec([[1, 1], [1, -1]]) h = vec([[1, 1], [1, -1]]) # COIN operators: COIN = vec([[1, 0], [0, 1]]) # Creates a standard basis matrix: def get_pos_space(time): t = time if t == 0: dim = 2 pos_basis = id(dim, dim, 0, dtype=float) else: dim = 2 * abs(t) + 1 pos_basis = id(dim, dim, 0, dtype=float)
def m(x):
return vec(-3*x*(1.5+3*x)*(3*x-1.5)*(3*x-2))
if dist > self.collision_distance:
# Ситуация с обычным потоком поля — просто притяжение
return self.G / dist
else:
# Отталкивание при соударении (притяжение убираем).
# К гравитации не относится, т.к. имеет скорее электростатическую
# природу, так что это sort of hack.
# Никаких конкретных законов не реализует, просто нечто отрицательное =)
return -self.k / dist
u = Universe2D(MODEL_G, COLLISION_COEFFICIENT, COLLISION_DISTANCE)
# u = Universe2D(MODEL_G, 20, 4)
bodies = [
MaterialPoint(u, 10050., vec([0., 0.]), vec([0., 0.])),
MaterialPoint(u, 100., vec([150., 0.]), vec([0., -10.])),
MaterialPoint(u, 100., vec([0., 150.]), vec([15., 0.])),
]
steps = int(TIME_TO_MODEL / MODEL_DELTA_T)
for stepn in range(steps):
u.model_step()
plt.gca().set_aspect('equal')
for b in bodies:
# Вот так понятно
# t = b.ptrace
# xs = [p[0] for p in t]
# ys = [p[1] for p in t]
###########################################################################################################################
import numpy as np
#kron: Kronecker product (kron): matrix tensor matrix
from numpy import sqrt, dot, outer, reshape, kron, append, insert, sum, matmul, add
from numpy import transpose as T
from numpy import tensordot as tensor
from numpy.linalg import inv
from numpy.linalg import norm
from numpy import array as vec
from numpy import eye as id
import heatmaps as ht
import matplotlib
import matplotlib.pyplot as plt
# Hadamard operator:
Hm = (1 / sqrt(2)) * vec([[1, 1], [1, -1]])
# Coin operator (Hm tensor Hm):
C = kron(Hm, Hm)
# COIN space:
Cs = vec([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
# Position space:
Ps = vec([[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0],
[0, 0, 0, 0, 1]])
deg = len(Cs)
N = len(Ps)
from numpy import array as vec va = vec([1, 2]) vb = vec([3, 3]) print(va + vb) S1 = 0.5 * (va + vb) print(S1) print(3 * va) # reálny súčin print(va * vb) # vektorový súčin print(va.dot(vb)) # skalárny súčin
self.bodies[i].apply_force( self.bodies[i].force_induced_by_other( self.bodies[j] ) )
for i in range( len(self.bodies ) ):
self.bodies[i].advance()
if __name__ == '__main__':
dimensions = int(input("Dimensions?" + '\n'))
un = UniverseWithDimensionsAndBodies(dimensions, 50, 3.0)
MODEL_DELTA_T = 0.01
TIME_TO_MODEL = 2
bodies = [
Body(un, 100.0, vec([0.0, 0.0]), vec([0.0, -5.0])),
Body(un, 100.0, vec([10.0, 0.0]), vec([0.0, 5.0]))
]
for i in range(len(bodies)):
un.add_body(bodies[i])
x=[ [ 0 for n in range( int(TIME_TO_MODEL/MODEL_DELTA_T) )] for i in range(len(un.bodies)) ]
y=[ [ 0 for n in range( int(TIME_TO_MODEL/MODEL_DELTA_T) )] for i in range(len(un.bodies)) ]
for i in range( len(un.bodies) ):
for j in range(int(TIME_TO_MODEL/MODEL_DELTA_T)):
x[0][i] = un.bodies[i].position[0]
y[1][i] = un.bodies[i].position[1]
un.model_step()