def draw_bond(self, start, end, bond_type, twist_to=None):
double_diff = self.bond_width + self.bond_width/2
triple_diff = 2 * self.bond_width + self.bond_width/2
quadruple_diffs = [double_diff, -double_diff]
diffs = [
[(0, 0)],
[(double_diff, 0), (-double_diff, 0)],
[(triple_diff, 0), (0, 0), (-triple_diff, 0)],
product(quadruple_diffs, quadruple_diffs)
][bond_type-1]
cylinder_default = Vector(0, 0, 1)
vec = end - start
angle = cylinder_default.angle_to(vec)
rv = rotation_vector(cylinder_default, vec)
gl.glPushMatrix()
gl.glTranslate(*start)
if twist_to is not None:
rotated_up = Vector(0, 1, 0).rotate(angle, rv)
twist_angle = rotated_up.right_hand_rule_angle_to(twist_to, vec)
gl.glRotate(twist_angle, *vec)
gl.glRotate(angle, *rv)
gl.glColor(*self.bond_color)
self._draw_cylinders(vec.length(), diffs)
gl.glPopMatrix()
def draw_atoms(self, atom, cur_vector=Vector(0, 0, 0), seen=None):
if seen is None:
seen = set()
seen.add(atom)
gl.glPushMatrix()
gl.glTranslate(*cur_vector)
hydrogen = chemistry.get_element(1)
is_carbon = atom.element == chemistry.get_element(6)
omit_bonds = [
i for i, bond in enumerate(atom.bonds)
if (bond.atom in seen) or (bond.atom.element == hydrogen
and is_carbon and self.hide_hydrogens)
]
self.draw_atom(atom, omit_bonds)
gl.glPopMatrix()
for i, (bond, vec) in enumerate(zip(atom.bonds, atom.geometry)):
if i in omit_bonds or bond.atom in seen:
continue
next_vector = cur_vector + vec * self.bond_length
self.draw_atoms(bond.atom, next_vector, seen)
def draw_atom(self, atom, omit_bonds=None):
self.draw_element(atom.element, (0, 0, 0))
for i, (vec, bond) in enumerate(zip(atom.geometry, atom.bonds)):
if omit_bonds and i in omit_bonds:
continue
self.draw_bond(Vector(0, 0, 0), vec * self.bond_length,
bond.order(), atom.plane_normal())
def draw_bond(self, start, end, bond_type, twist_to=None):
double_diff = self.bond_width + self.bond_width / 2
triple_diff = 2 * self.bond_width + self.bond_width / 2
quadruple_diffs = [double_diff, -double_diff]
diffs = [[(0, 0)], [(double_diff, 0), (-double_diff, 0)],
[(triple_diff, 0), (0, 0), (-triple_diff, 0)],
product(quadruple_diffs, quadruple_diffs)][bond_type - 1]
cylinder_default = Vector(0, 0, 1)
vec = end - start
angle = cylinder_default.angle_to(vec)
rv = rotation_vector(cylinder_default, vec)
gl.glPushMatrix()
gl.glTranslate(*start)
if twist_to is not None:
rotated_up = Vector(0, 1, 0).rotate(angle, rv)
twist_angle = rotated_up.right_hand_rule_angle_to(twist_to, vec)
gl.glRotate(twist_angle, *vec)
gl.glRotate(angle, *rv)
gl.glColor(*self.bond_color)
self._draw_cylinders(vec.length(), diffs)
gl.glPopMatrix()
class linalg_test(unittest.TestCase):
# def __init__(self):
# self.v1 = Vector([1, 2, 3])
# self.v2 = Vector([2, 3, 4])
# this doesn't work because we already have an init built-in with TestCase
def setUp(self):
self.v1 = Vector([1, 2, 3])
self.v2 = Vector([2, 3, 4])
self.v3 = Vector([2, 3, 6])
self.v4 = Vector([1, 1, 4])
def test_start(self):
self.assertEqual(1 + 1, 2)
# TODO add equality test
def test_add(self):
expected_output = [3, 5, 7]
self.assertEqual(self.v1.add(self.v2), Vector(expected_output), 'Addition did not give expected value')
def test_add_magic(self):
self.assertEqual(self.v1 + self.v2, self.v1.add(self.v2), 'Magic method and other did not give the same answer')
def test_subtract(self):
'''
Subtract v2 from v1
'''
expected_output = Vector([1, 1, 1])
self.assertEqual(self.v2.subtract(self.v1), expected_output, 'Subtract does not work')
def test_subtract_magic(self):
self.assertEqual(self.v2 - self.v1, self.v2.subtract(self.v1), 'Subtract magic fails')
def test_scalar_multiply(self):
expected_output = Vector([3, 6, 9])
scalar = 3
self.assertEqual(self.v1.scalar_multiply(scalar), expected_output, 'Scalar multiplication gave incorrect answer')
def test_magnitude(self):
'''
Use vector3 for convenience of pythagorean quadruple
'''
expected_output = 6.855654600401044
self.assertEqual(self.v3.magnitude(), expected_output, 'magnitude does not work')
def test_dot(self):
expected_output = 20
self.assertEqual(self.v1.dot(self.v2), expected_output, 'Dot product gives invalid answer')
def test_dot_magic(self):
self.assertEqual(self.v1.dot(self.v2), self.v2 * self.v1, 'Dot product magic fails')
def test_scalar_multiply_magic(self):
expected_output = Vector([3, 6, 9])
scalar = 3
self.assertEqual(self.v1 * scalar, expected_output, 'Scalar multiplication gave incorrect answer')
def test_distance(self):
'''
subtract v4 from v3 for convenient integer output
'''
expected_output = 3
self.assertEqual(self.v3.distance(self.v4), expected_output)
def test_subtract(self):
'''
Subtract v2 from v1
'''
expected_output = Vector([1, 1, 1])
self.assertEqual(self.v2.subtract(self.v1), expected_output, 'Subtract does not work')
def test_add(self):
expected_output = [3, 5, 7]
self.assertEqual(self.v1.add(self.v2), Vector(expected_output), 'Addition did not give expected value')
def setUp(self):
self.v1 = Vector([1, 2, 3])
self.v2 = Vector([2, 3, 4])
self.v3 = Vector([2, 3, 6])
self.v4 = Vector([1, 1, 4])
def train(self, inputs, ans):
inputs = Vector(inputs)
error = (self.guess(inputs) - ans)**2
self.weights = self.weights - inputs * (2 * error * self.lr)
self.bias = self.bias - 2 * error * self.lr
def __call__(self, u, v):
return Vector([
self.xlayer(u, v),
self.ylayer(u, v),
self.zlayer(u, v)
])
def test_vec_mult(self):
a = Vector([1, 1])
b = Vector([2, 2])
c = Vector([2, 2])
self.assertEqual(a.mult(b), c)
return 0
def avg(l):
total = 0
for x in l:
total += x
return total * 1.0 / len(l)
p = Perceptron(2)
points = []
hist = []
for i in range(0, 10000):
x = random.randint(0, 1)
y = random.randint(0, 1)
s = f(x, y)
p.train(Vector([x, y]), s)
points.append([x, y, s])
hist.append(p.guess([x, y]) - s)
avgs = [avg(hist[:i]) for i in range(1, len(hist) + 1)]
plt.plot(hist)
plt.show()
print 0, 0, p.guess([0, 0])
print 0, 1, p.guess([0, 1])
print 1, 0, p.guess([1, 0])
print 1, 1, p.guess([1, 1])
# print p.weights
# print p.bias
# print p.guess([1,4])
from collections import namedtuple, defaultdict
from linalg import Vector
import math
# these are the idealized geometries for the steric
# numbers from VSEPR theory - we will omit
# bonds (where there are lone pairs) as necessary
geometries = [
# geometry for things with only one bond - steric number 1?
[Vector(0, 1, 0)],
# steric number 2 - linear
[Vector(1, 0, 0), Vector(-1, 0, 0)],
# steric number 3 - trigonal planar, bent
[
Vector(0, 1, 0),
Vector(math.sqrt(3) / 2, -1 / 2, 0),
Vector(-math.sqrt(3) / 2, -1 / 2, 0)
],
# steric number 4 - tetrahedral, trigonal pyramidal, bent
[
Vector(0, 1, 0),
Vector((2 * math.sqrt(2)) / 3, -1 / 3, 0),
Vector(-math.sqrt(2) / 3, -1 / 3, math.sqrt(2 / 3)),
Vector(-math.sqrt(2) / 3, -1 / 3, -math.sqrt(2 / 3))
],
# steric number 5: trigonal bipyramidal, seesaw, t-shaped, linear
[
Vector(0, 1, 0),
Vector(math.sqrt(3) / 2, -1 / 2, 0),
Vector(-math.sqrt(3) / 2, -1 / 2, 0),
Vector(0, 0, -1),
def try_tile():
# python -c 'import splines; splines.try_tile()'
t = Tile(
Vector(0, 0, 0), Vector(1, 0, 0), Vector(1, 1, 0), Vector(0, 1, 0),
Vector(0, -1, -1), Vector(1, -1, -1),
Vector(2, 0, -1), Vector(2, 1, -1),
Vector(1, 2, -1), Vector(0, 2, -1),
Vector(-1, 1, -1), Vector(-1, 0, -1)
)
fnfmt = "tile{0}.dat"
ribs = 12
fns = t.to_gnuplot(fnfmt, ribs)
outf = open("gp.cmd", "w")
outf.write(
'plot ' +
', '.join(['"{0}" with lines notitle'.format(fn) for fn in fns]) +
'; pause 10;'
)
outf.close()
os.system("gnuplot gp.cmd")
for f in (["gp.cmd"] + fns):
os.remove(f)
def rotated(u, v, r=Matrix.rotate_x(5)*Matrix.rotate_z(15)):
h = Vector(0.5, 0.5, 0.5)
return r * (self(u, v) - h) + h
def test_scalar_multiply_magic(self):
expected_output = Vector([3, 6, 9])
scalar = 3
self.assertEqual(self.v1 * scalar, expected_output, 'Scalar multiplication gave incorrect answer')
def __init__(self):
self.pos = Vector([0, 0])
self.history = [[self.pos[0]], [self.pos[1]]]
def __init__(self, numInputs):
self.lr = .1
self.weights = Vector([random.random() for x in range(0, numInputs)])
self.bias = random.random()
def test_Transpose(self):
a = Matrix([Vector([1, 2]), Vector([3, 4])])
b = Matrix([Vector([1, 3]), Vector([2, 4])])
self.assertEqual(a.T(), b)
def guess(self, inputs):
return sign((self.weights | Vector(inputs)) + self.bias)
