I am done

rl/Lib/site-packages/sympy/physics/optics/tests/test_gaussopt.py

@@ -0,0 +1,102 @@
+from sympy.core.evalf import N
+from sympy.core.numbers import (Float, I, oo, pi)
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import atan2
+from sympy.matrices.dense import Matrix
+from sympy.polys.polytools import factor
+
+from sympy.physics.optics import (BeamParameter, CurvedMirror,
+  CurvedRefraction, FlatMirror, FlatRefraction, FreeSpace, GeometricRay,
+  RayTransferMatrix, ThinLens, conjugate_gauss_beams,
+  gaussian_conj, geometric_conj_ab, geometric_conj_af, geometric_conj_bf,
+  rayleigh2waist, waist2rayleigh)
+
+
+def streq(a, b):
+    return str(a) == str(b)
+
+
+def test_gauss_opt():
+    mat = RayTransferMatrix(1, 2, 3, 4)
+    assert mat == Matrix([[1, 2], [3, 4]])
+    assert mat == RayTransferMatrix( Matrix([[1, 2], [3, 4]]) )
+    assert [mat.A, mat.B, mat.C, mat.D] == [1, 2, 3, 4]
+
+    d, f, h, n1, n2, R = symbols('d f h n1 n2 R')
+    lens = ThinLens(f)
+    assert lens == Matrix([[   1, 0], [-1/f, 1]])
+    assert lens.C == -1/f
+    assert FreeSpace(d) == Matrix([[ 1, d], [0, 1]])
+    assert FlatRefraction(n1, n2) == Matrix([[1, 0], [0, n1/n2]])
+    assert CurvedRefraction(
+        R, n1, n2) == Matrix([[1, 0], [(n1 - n2)/(R*n2), n1/n2]])
+    assert FlatMirror() == Matrix([[1, 0], [0, 1]])
+    assert CurvedMirror(R) == Matrix([[   1, 0], [-2/R, 1]])
+    assert ThinLens(f) == Matrix([[   1, 0], [-1/f, 1]])
+
+    mul = CurvedMirror(R)*FreeSpace(d)
+    mul_mat = Matrix([[   1, 0], [-2/R, 1]])*Matrix([[ 1, d], [0, 1]])
+    assert mul.A == mul_mat[0, 0]
+    assert mul.B == mul_mat[0, 1]
+    assert mul.C == mul_mat[1, 0]
+    assert mul.D == mul_mat[1, 1]
+
+    angle = symbols('angle')
+    assert GeometricRay(h, angle) == Matrix([[    h], [angle]])
+    assert FreeSpace(
+        d)*GeometricRay(h, angle) == Matrix([[angle*d + h], [angle]])
+    assert GeometricRay( Matrix( ((h,), (angle,)) ) ) == Matrix([[h], [angle]])
+    assert (FreeSpace(d)*GeometricRay(h, angle)).height == angle*d + h
+    assert (FreeSpace(d)*GeometricRay(h, angle)).angle == angle
+
+    p = BeamParameter(530e-9, 1, w=1e-3)
+    assert streq(p.q, 1 + 1.88679245283019*I*pi)
+    assert streq(N(p.q), 1.0 + 5.92753330865999*I)
+    assert streq(N(p.w_0), Float(0.00100000000000000))
+    assert streq(N(p.z_r), Float(5.92753330865999))
+    fs = FreeSpace(10)
+    p1 = fs*p
+    assert streq(N(p.w), Float(0.00101413072159615))
+    assert streq(N(p1.w), Float(0.00210803120913829))
+
+    w, wavelen = symbols('w wavelen')
+    assert waist2rayleigh(w, wavelen) == pi*w**2/wavelen
+    z_r, wavelen = symbols('z_r wavelen')
+    assert rayleigh2waist(z_r, wavelen) == sqrt(wavelen*z_r)/sqrt(pi)
+
+    a, b, f = symbols('a b f')
+    assert geometric_conj_ab(a, b) == a*b/(a + b)
+    assert geometric_conj_af(a, f) == a*f/(a - f)
+    assert geometric_conj_bf(b, f) == b*f/(b - f)
+    assert geometric_conj_ab(oo, b) == b
+    assert geometric_conj_ab(a, oo) == a
+
+    s_in, z_r_in, f = symbols('s_in z_r_in f')
+    assert gaussian_conj(
+        s_in, z_r_in, f)[0] == 1/(-1/(s_in + z_r_in**2/(-f + s_in)) + 1/f)
+    assert gaussian_conj(
+        s_in, z_r_in, f)[1] == z_r_in/(1 - s_in**2/f**2 + z_r_in**2/f**2)
+    assert gaussian_conj(
+        s_in, z_r_in, f)[2] == 1/sqrt(1 - s_in**2/f**2 + z_r_in**2/f**2)
+
+    l, w_i, w_o, f = symbols('l w_i w_o f')
+    assert conjugate_gauss_beams(l, w_i, w_o, f=f)[0] == f*(
+        -sqrt(w_i**2/w_o**2 - pi**2*w_i**4/(f**2*l**2)) + 1)
+    assert factor(conjugate_gauss_beams(l, w_i, w_o, f=f)[1]) == f*w_o**2*(
+        w_i**2/w_o**2 - sqrt(w_i**2/w_o**2 - pi**2*w_i**4/(f**2*l**2)))/w_i**2
+    assert conjugate_gauss_beams(l, w_i, w_o, f=f)[2] == f
+
+    z, l, w_0 = symbols('z l w_0', positive=True)
+    p = BeamParameter(l, z, w=w_0)
+    assert p.radius == z*(pi**2*w_0**4/(l**2*z**2) + 1)
+    assert p.w == w_0*sqrt(l**2*z**2/(pi**2*w_0**4) + 1)
+    assert p.w_0 == w_0
+    assert p.divergence == l/(pi*w_0)
+    assert p.gouy == atan2(z, pi*w_0**2/l)
+    assert p.waist_approximation_limit == 2*l/pi
+
+    p = BeamParameter(530e-9, 1, w=1e-3, n=2)
+    assert streq(p.q, 1 + 3.77358490566038*I*pi)
+    assert streq(N(p.z_r), Float(11.8550666173200))
+    assert streq(N(p.w_0), Float(0.00100000000000000))

rl/Lib/site-packages/sympy/physics/optics/tests/test_medium.py

@@ -0,0 +1,48 @@
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.physics.optics import Medium
+from sympy.abc import epsilon, mu, n
+from sympy.physics.units import speed_of_light, u0, e0, m, kg, s, A
+
+from sympy.testing.pytest import raises
+
+c = speed_of_light.convert_to(m/s)
+e0 = e0.convert_to(A**2*s**4/(kg*m**3))
+u0 = u0.convert_to(m*kg/(A**2*s**2))
+
+
+def test_medium():
+    m1 = Medium('m1')
+    assert m1.intrinsic_impedance == sqrt(u0/e0)
+    assert m1.speed == 1/sqrt(e0*u0)
+    assert m1.refractive_index == c*sqrt(e0*u0)
+    assert m1.permittivity == e0
+    assert m1.permeability == u0
+    m2 = Medium('m2', epsilon, mu)
+    assert m2.intrinsic_impedance == sqrt(mu/epsilon)
+    assert m2.speed == 1/sqrt(epsilon*mu)
+    assert m2.refractive_index == c*sqrt(epsilon*mu)
+    assert m2.permittivity == epsilon
+    assert m2.permeability == mu
+    # Increasing electric permittivity and magnetic permeability
+    # by small amount from its value in vacuum.
+    m3 = Medium('m3', 9.0*10**(-12)*s**4*A**2/(m**3*kg), 1.45*10**(-6)*kg*m/(A**2*s**2))
+    assert m3.refractive_index > m1.refractive_index
+    assert m3 != m1
+    # Decreasing electric permittivity and magnetic permeability
+    # by small amount from its value in vacuum.
+    m4 = Medium('m4', 7.0*10**(-12)*s**4*A**2/(m**3*kg), 1.15*10**(-6)*kg*m/(A**2*s**2))
+    assert m4.refractive_index < m1.refractive_index
+    m5 = Medium('m5', permittivity=710*10**(-12)*s**4*A**2/(m**3*kg), n=1.33)
+    assert abs(m5.intrinsic_impedance - 6.24845417765552*kg*m**2/(A**2*s**3)) \
+                < 1e-12*kg*m**2/(A**2*s**3)
+    assert abs(m5.speed - 225407863.157895*m/s) < 1e-6*m/s
+    assert abs(m5.refractive_index - 1.33000000000000) < 1e-12
+    assert abs(m5.permittivity - 7.1e-10*A**2*s**4/(kg*m**3)) \
+                < 1e-20*A**2*s**4/(kg*m**3)
+    assert abs(m5.permeability - 2.77206575232851e-8*kg*m/(A**2*s**2)) \
+                < 1e-20*kg*m/(A**2*s**2)
+    m6 = Medium('m6', None, mu, n)
+    assert m6.permittivity == n**2/(c**2*mu)
+    # test for equality of refractive indices
+    assert Medium('m7').refractive_index == Medium('m8', e0, u0).refractive_index
+    raises(ValueError, lambda:Medium('m9', e0, u0, 2))

rl/Lib/site-packages/sympy/physics/optics/tests/test_polarization.py

@@ -0,0 +1,57 @@
+from sympy.physics.optics.polarization import (jones_vector, stokes_vector,
+    jones_2_stokes, linear_polarizer, phase_retarder, half_wave_retarder,
+    quarter_wave_retarder, transmissive_filter, reflective_filter,
+    mueller_matrix, polarizing_beam_splitter)
+from sympy.core.numbers import (I, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.matrices.dense import Matrix
+
+
+def test_polarization():
+    assert jones_vector(0, 0) == Matrix([1, 0])
+    assert jones_vector(pi/2, 0) == Matrix([0, 1])
+    #################################################################
+    assert stokes_vector(0, 0) == Matrix([1, 1, 0, 0])
+    assert stokes_vector(pi/2, 0) == Matrix([1, -1, 0, 0])
+    #################################################################
+    H = jones_vector(0, 0)
+    V = jones_vector(pi/2, 0)
+    D = jones_vector(pi/4, 0)
+    A = jones_vector(-pi/4, 0)
+    R = jones_vector(0, pi/4)
+    L = jones_vector(0, -pi/4)
+
+    res = [Matrix([1, 1, 0, 0]),
+           Matrix([1, -1, 0, 0]),
+           Matrix([1, 0, 1, 0]),
+           Matrix([1, 0, -1, 0]),
+           Matrix([1, 0, 0, 1]),
+           Matrix([1, 0, 0, -1])]
+
+    assert [jones_2_stokes(e) for e in [H, V, D, A, R, L]] == res
+    #################################################################
+    assert linear_polarizer(0) == Matrix([[1, 0], [0, 0]])
+    #################################################################
+    delta = symbols("delta", real=True)
+    res = Matrix([[exp(-I*delta/2), 0], [0, exp(I*delta/2)]])
+    assert phase_retarder(0, delta) == res
+    #################################################################
+    assert half_wave_retarder(0) == Matrix([[-I, 0], [0, I]])
+    #################################################################
+    res = Matrix([[exp(-I*pi/4), 0], [0, I*exp(-I*pi/4)]])
+    assert quarter_wave_retarder(0) == res
+    #################################################################
+    assert transmissive_filter(1) == Matrix([[1, 0], [0, 1]])
+    #################################################################
+    assert reflective_filter(1) == Matrix([[1, 0], [0, -1]])
+
+    res = Matrix([[S(1)/2, S(1)/2, 0, 0],
+                  [S(1)/2, S(1)/2, 0, 0],
+                  [0, 0, 0, 0],
+                  [0, 0, 0, 0]])
+    assert mueller_matrix(linear_polarizer(0)) == res
+    #################################################################
+    res = Matrix([[1, 0, 0, 0], [0, 0, 0, -I], [0, 0, 1, 0], [0, -I, 0, 0]])
+    assert polarizing_beam_splitter() == res

rl/Lib/site-packages/sympy/physics/optics/tests/test_utils.py

@@ -0,0 +1,202 @@
+from sympy.core.numbers import comp, Rational
+from sympy.physics.optics.utils import (refraction_angle, fresnel_coefficients,
+        deviation, brewster_angle, critical_angle, lens_makers_formula,
+        mirror_formula, lens_formula, hyperfocal_distance,
+        transverse_magnification)
+from sympy.physics.optics.medium import Medium
+from sympy.physics.units import e0
+
+from sympy.core.numbers import oo
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.matrices.dense import Matrix
+from sympy.geometry.point import Point3D
+from sympy.geometry.line import Ray3D
+from sympy.geometry.plane import Plane
+
+from sympy.testing.pytest import raises
+
+
+ae = lambda a, b, n: comp(a, b, 10**-n)
+
+
+def test_refraction_angle():
+    n1, n2 = symbols('n1, n2')
+    m1 = Medium('m1')
+    m2 = Medium('m2')
+    r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
+    i = Matrix([1, 1, 1])
+    n = Matrix([0, 0, 1])
+    normal_ray = Ray3D(Point3D(0, 0, 0), Point3D(0, 0, 1))
+    P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
+    assert refraction_angle(r1, 1, 1, n) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle([1, 1, 1], 1, 1, n) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle((1, 1, 1), 1, 1, n) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle(i, 1, 1, [0, 0, 1]) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle(i, 1, 1, (0, 0, 1)) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle(i, 1, 1, normal_ray) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle(i, 1, 1, plane=P) == Matrix([
+                                            [ 1],
+                                            [ 1],
+                                            [-1]])
+    assert refraction_angle(r1, 1, 1, plane=P) == \
+        Ray3D(Point3D(0, 0, 0), Point3D(1, 1, -1))
+    assert refraction_angle(r1, m1, 1.33, plane=P) == \
+        Ray3D(Point3D(0, 0, 0), Point3D(Rational(100, 133), Rational(100, 133), -789378201649271*sqrt(3)/1000000000000000))
+    assert refraction_angle(r1, 1, m2, plane=P) == \
+        Ray3D(Point3D(0, 0, 0), Point3D(1, 1, -1))
+    assert refraction_angle(r1, n1, n2, plane=P) == \
+        Ray3D(Point3D(0, 0, 0), Point3D(n1/n2, n1/n2, -sqrt(3)*sqrt(-2*n1**2/(3*n2**2) + 1)))
+    assert refraction_angle(r1, 1.33, 1, plane=P) == 0  # TIR
+    assert refraction_angle(r1, 1, 1, normal_ray) == \
+        Ray3D(Point3D(0, 0, 0), direction_ratio=[1, 1, -1])
+    assert ae(refraction_angle(0.5, 1, 2), 0.24207, 5)
+    assert ae(refraction_angle(0.5, 2, 1), 1.28293, 5)
+    raises(ValueError, lambda: refraction_angle(r1, m1, m2, normal_ray, P))
+    raises(TypeError, lambda: refraction_angle(m1, m1, m2)) # can add other values for arg[0]
+    raises(TypeError, lambda: refraction_angle(r1, m1, m2, None, i))
+    raises(TypeError, lambda: refraction_angle(r1, m1, m2, m2))
+
+
+def test_fresnel_coefficients():
+    assert all(ae(i, j, 5) for i, j in zip(
+        fresnel_coefficients(0.5, 1, 1.33),
+        [0.11163, -0.17138, 0.83581, 0.82862]))
+    assert all(ae(i, j, 5) for i, j in zip(
+        fresnel_coefficients(0.5, 1.33, 1),
+        [-0.07726, 0.20482, 1.22724, 1.20482]))
+    m1 = Medium('m1')
+    m2 = Medium('m2', n=2)
+    assert all(ae(i, j, 5) for i, j in zip(
+        fresnel_coefficients(0.3, m1, m2),
+        [0.31784, -0.34865, 0.65892, 0.65135]))
+    ans = [[-0.23563, -0.97184], [0.81648, -0.57738]]
+    got = fresnel_coefficients(0.6, m2, m1)
+    for i, j in zip(got, ans):
+        for a, b in zip(i.as_real_imag(), j):
+            assert ae(a, b, 5)
+
+
+def test_deviation():
+    n1, n2 = symbols('n1, n2')
+    r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
+    n = Matrix([0, 0, 1])
+    i = Matrix([-1, -1, -1])
+    normal_ray = Ray3D(Point3D(0, 0, 0), Point3D(0, 0, 1))
+    P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
+    assert deviation(r1, 1, 1, normal=n) == 0
+    assert deviation(r1, 1, 1, plane=P) == 0
+    assert deviation(r1, 1, 1.1, plane=P).evalf(3) + 0.119 < 1e-3
+    assert deviation(i, 1, 1.1, normal=normal_ray).evalf(3) + 0.119 < 1e-3
+    assert deviation(r1, 1.33, 1, plane=P) is None  # TIR
+    assert deviation(r1, 1, 1, normal=[0, 0, 1]) == 0
+    assert deviation([-1, -1, -1], 1, 1, normal=[0, 0, 1]) == 0
+    assert ae(deviation(0.5, 1, 2), -0.25793, 5)
+    assert ae(deviation(0.5, 2, 1), 0.78293, 5)
+
+
+def test_brewster_angle():
+    m1 = Medium('m1', n=1)
+    m2 = Medium('m2', n=1.33)
+    assert ae(brewster_angle(m1, m2), 0.93, 2)
+    m1 = Medium('m1', permittivity=e0, n=1)
+    m2 = Medium('m2', permittivity=e0, n=1.33)
+    assert ae(brewster_angle(m1, m2), 0.93, 2)
+    assert ae(brewster_angle(1, 1.33), 0.93, 2)
+
+
+def test_critical_angle():
+    m1 = Medium('m1', n=1)
+    m2 = Medium('m2', n=1.33)
+    assert ae(critical_angle(m2, m1), 0.85, 2)
+
+
+def test_lens_makers_formula():
+    n1, n2 = symbols('n1, n2')
+    m1 = Medium('m1', permittivity=e0, n=1)
+    m2 = Medium('m2', permittivity=e0, n=1.33)
+    assert lens_makers_formula(n1, n2, 10, -10) == 5.0*n2/(n1 - n2)
+    assert ae(lens_makers_formula(m1, m2, 10, -10), -20.15, 2)
+    assert ae(lens_makers_formula(1.33, 1, 10, -10),  15.15, 2)
+
+
+def test_mirror_formula():
+    u, v, f = symbols('u, v, f')
+    assert mirror_formula(focal_length=f, u=u) == f*u/(-f + u)
+    assert mirror_formula(focal_length=f, v=v) == f*v/(-f + v)
+    assert mirror_formula(u=u, v=v) == u*v/(u + v)
+    assert mirror_formula(u=oo, v=v) == v
+    assert mirror_formula(u=oo, v=oo) is oo
+    assert mirror_formula(focal_length=oo, u=u) == -u
+    assert mirror_formula(u=u, v=oo) == u
+    assert mirror_formula(focal_length=oo, v=oo) is oo
+    assert mirror_formula(focal_length=f, v=oo) == f
+    assert mirror_formula(focal_length=oo, v=v) == -v
+    assert mirror_formula(focal_length=oo, u=oo) is oo
+    assert mirror_formula(focal_length=f, u=oo) == f
+    assert mirror_formula(focal_length=oo, u=u) == -u
+    raises(ValueError, lambda: mirror_formula(focal_length=f, u=u, v=v))
+
+
+def test_lens_formula():
+    u, v, f = symbols('u, v, f')
+    assert lens_formula(focal_length=f, u=u) == f*u/(f + u)
+    assert lens_formula(focal_length=f, v=v) == f*v/(f - v)
+    assert lens_formula(u=u, v=v) == u*v/(u - v)
+    assert lens_formula(u=oo, v=v) == v
+    assert lens_formula(u=oo, v=oo) is oo
+    assert lens_formula(focal_length=oo, u=u) == u
+    assert lens_formula(u=u, v=oo) == -u
+    assert lens_formula(focal_length=oo, v=oo) is -oo
+    assert lens_formula(focal_length=oo, v=v) == v
+    assert lens_formula(focal_length=f, v=oo) == -f
+    assert lens_formula(focal_length=oo, u=oo) is oo
+    assert lens_formula(focal_length=oo, u=u) == u
+    assert lens_formula(focal_length=f, u=oo) == f
+    raises(ValueError, lambda: lens_formula(focal_length=f, u=u, v=v))
+
+
+def test_hyperfocal_distance():
+    f, N, c = symbols('f, N, c')
+    assert hyperfocal_distance(f=f, N=N, c=c) == f**2/(N*c)
+    assert ae(hyperfocal_distance(f=0.5, N=8, c=0.0033), 9.47, 2)
+
+
+def test_transverse_magnification():
+    si, so = symbols('si, so')
+    assert transverse_magnification(si, so) == -si/so
+    assert transverse_magnification(30, 15) == -2
+
+
+def test_lens_makers_formula_thick_lens():
+    n1, n2 = symbols('n1, n2')
+    m1 = Medium('m1', permittivity=e0, n=1)
+    m2 = Medium('m2', permittivity=e0, n=1.33)
+    assert ae(lens_makers_formula(m1, m2, 10, -10, d=1), -19.82, 2)
+    assert lens_makers_formula(n1, n2, 1, -1, d=0.1) == n2/((2.0 - (0.1*n1 - 0.1*n2)/n1)*(n1 - n2))
+
+
+def test_lens_makers_formula_plano_lens():
+    n1, n2 = symbols('n1, n2')
+    m1 = Medium('m1', permittivity=e0, n=1)
+    m2 = Medium('m2', permittivity=e0, n=1.33)
+    assert ae(lens_makers_formula(m1, m2, 10, oo), -40.30, 2)
+    assert lens_makers_formula(n1, n2, 10, oo) == 10.0*n2/(n1 - n2)

rl/Lib/site-packages/sympy/physics/optics/tests/test_waves.py

@@ -0,0 +1,82 @@
+from sympy.core.function import (Derivative, Function)
+from sympy.core.numbers import (I, pi)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan2, cos, sin)
+from sympy.simplify.simplify import simplify
+from sympy.abc import epsilon, mu
+from sympy.functions.elementary.exponential import exp
+from sympy.physics.units import speed_of_light, m, s
+from sympy.physics.optics import TWave
+
+from sympy.testing.pytest import raises
+
+c = speed_of_light.convert_to(m/s)
+
+def test_twave():
+    A1, phi1, A2, phi2, f = symbols('A1, phi1, A2, phi2, f')
+    n = Symbol('n')  # Refractive index
+    t = Symbol('t')  # Time
+    x = Symbol('x')  # Spatial variable
+    E = Function('E')
+    w1 = TWave(A1, f, phi1)
+    w2 = TWave(A2, f, phi2)
+    assert w1.amplitude == A1
+    assert w1.frequency == f
+    assert w1.phase == phi1
+    assert w1.wavelength == c/(f*n)
+    assert w1.time_period == 1/f
+    assert w1.angular_velocity == 2*pi*f
+    assert w1.wavenumber == 2*pi*f*n/c
+    assert w1.speed == c/n
+
+    w3 = w1 + w2
+    assert w3.amplitude == sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2) + A2**2)
+    assert w3.frequency == f
+    assert w3.phase == atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2))
+    assert w3.wavelength == c/(f*n)
+    assert w3.time_period == 1/f
+    assert w3.angular_velocity == 2*pi*f
+    assert w3.wavenumber == 2*pi*f*n/c
+    assert w3.speed == c/n
+    assert simplify(w3.rewrite(sin) - w2.rewrite(sin) - w1.rewrite(sin)) == 0
+    assert w3.rewrite('pde') == epsilon*mu*Derivative(E(x, t), t, t) + Derivative(E(x, t), x, x)
+    assert w3.rewrite(cos) == sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2)
+        + A2**2)*cos(pi*f*n*x*s/(149896229*m) - 2*pi*f*t + atan2(A1*sin(phi1)
+        + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2)))
+    assert w3.rewrite(exp) == sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2)
+        + A2**2)*exp(I*(-2*pi*f*t + atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1)
+        + A2*cos(phi2)) + pi*s*f*n*x/(149896229*m)))
+
+    w4 = TWave(A1, None, 0, 1/f)
+    assert w4.frequency == f
+
+    w5 = w1 - w2
+    assert w5.amplitude == sqrt(A1**2 - 2*A1*A2*cos(phi1 - phi2) + A2**2)
+    assert w5.frequency == f
+    assert w5.phase == atan2(A1*sin(phi1) - A2*sin(phi2), A1*cos(phi1) - A2*cos(phi2))
+    assert w5.wavelength == c/(f*n)
+    assert w5.time_period == 1/f
+    assert w5.angular_velocity == 2*pi*f
+    assert w5.wavenumber == 2*pi*f*n/c
+    assert w5.speed == c/n
+    assert simplify(w5.rewrite(sin) - w1.rewrite(sin) + w2.rewrite(sin)) == 0
+    assert w5.rewrite('pde') == epsilon*mu*Derivative(E(x, t), t, t) + Derivative(E(x, t), x, x)
+    assert w5.rewrite(cos) == sqrt(A1**2 - 2*A1*A2*cos(phi1 - phi2)
+        + A2**2)*cos(-2*pi*f*t + atan2(A1*sin(phi1) - A2*sin(phi2), A1*cos(phi1)
+        - A2*cos(phi2)) + pi*s*f*n*x/(149896229*m))
+    assert w5.rewrite(exp) == sqrt(A1**2 - 2*A1*A2*cos(phi1 - phi2)
+        + A2**2)*exp(I*(-2*pi*f*t + atan2(A1*sin(phi1) - A2*sin(phi2), A1*cos(phi1)
+        - A2*cos(phi2)) + pi*s*f*n*x/(149896229*m)))
+
+    w6 = 2*w1
+    assert w6.amplitude == 2*A1
+    assert w6.frequency == f
+    assert w6.phase == phi1
+    w7 = -w6
+    assert w7.amplitude == -2*A1
+    assert w7.frequency == f
+    assert w7.phase == phi1
+
+    raises(ValueError, lambda:TWave(A1))
+    raises(ValueError, lambda:TWave(A1, f, phi1, t))