def test_rmultiply_named_scalar():
    """Scalars * Named quantities"""
    m_per_s = NamedComposedUnit('vel', 
                                unit('m') / unit('s'))

    assert (2 * Quantity(8, m_per_s) ==
            Quantity(16, m_per_s))

def test_divide_named_scalar():
    """Named quantities / scalars"""
    m_per_s = NamedComposedUnit('vel', 
                                unit('m') / unit('s'))

    assert (Quantity(8, m_per_s) / 2 ==
            Quantity(4, m_per_s))

def test_multiply_named_scalar():
    """Named quantities * scalars"""
    m_per_s = NamedComposedUnit('vel', 
                                unit('m') / unit('s'))
    
    assert (Quantity(8, m_per_s) * 2 ==
            Quantity(16, m_per_s))

def test_valid_basic_to_composed():
    """Test conversion to composed units."""
    composed_cm = unit('cm').composed_unit
    
    one_m_in_cm = composed_cm(Quantity(1, unit('m')))
    
    assert one_m_in_cm == Quantity(1, unit('m'))

def test_rdivide_named_scalar():
    """Scalars / Named quantities"""
    m_per_s = NamedComposedUnit('vel', 
                                unit('m') / unit('s'))

    assert (4 / Quantity(2, m_per_s) ==
            Quantity(2, unit('s') / unit('m')))

def test_valid_composed_to_basic():
    """Composed units should convert to basic equivalents."""
    metre = unit('m')
    
    hundred_cm_in_metres = metre(Quantity(100, unit('cm')))
    assert hundred_cm_in_metres == Quantity(1.0, metre)
    assert str(hundred_cm_in_metres) == '1.0 m'

def test_valid_basic_to_named():
    """Basic units should convert into named equivalents."""
    metre = unit('m')
    thousand_m_in_km = unit('km')(Quantity(1000, metre))
    
    assert thousand_m_in_km == Quantity(1, unit('km'))
    assert thousand_m_in_km.unit == unit('km')
    assert str(thousand_m_in_km) == '1 km'

def test_valid_named_to_named():
    """Named units should convert to named equivalents."""
    
    gray = unit('Gy')
    sievert = unit('Sv')
    
    one_gray_in_sievert = sievert(Quantity(1, gray))
    assert one_gray_in_sievert == Quantity(1, gray)
    assert str(one_gray_in_sievert) == '1 Sv'

def define_imperial_units():
    """Define some common imperial units."""

    assert unit("m").is_si()  # Ensure SI units already defined

    # scaled_unit measures
    scaled_unit("inch", "cm", 2.54, name="inch")
    scaled_unit("in", "cm", 2.54, name="inch")  # 'in' is a python keyword
    scaled_unit("ft", "inch", 12.0, name="foot")
    scaled_unit("yd", "ft", 3.0, name="yard")
    scaled_unit("fm", "ft", 6.0, name="fathom")
    scaled_unit("rd", "yd", 5.5, name="rod")
    scaled_unit("fur", "rd", 40.0, name="furlong")
    scaled_unit("mi", "fur", 8.0, name="mile")
    scaled_unit("lea", "mi", 3.0, name="leage")

    # nautical scaled_unit measures
    scaled_unit("NM", "m", 1852.0, name="nautical mile")
    scaled_unit("cable", "NM", 0.1, name="cable length")

    # chain measure
    scaled_unit("li", "inch", 7.92, name="link")
    scaled_unit("ch", "li", 100.0, name="chain")

    # area measure
    NamedComposedUnit("acre", ComposedUnit([unit("rd")] * 2, [], 160.0), name="acre")

    # liquid measures
    NamedComposedUnit("pt", ComposedUnit([unit("inch")] * 3, [], 28.875), name="pint")

    scaled_unit("gi", "pt", 0.25, name="gills")
    scaled_unit("qt", "pt", 2.0, name="quarts")
    scaled_unit("gal", "qt", 4.0, name="gallons")

    scaled_unit("fl oz", "pt", 1.0 / 16.0, name="fluid ounce")
    scaled_unit("fl dr", "fl oz", 1.0 / 8.0, name="fluid drachm")
    scaled_unit("minim", "fl dr", 1.0 / 60.0, name="minim")

    # weight
    scaled_unit("oz", "g", 28.375, name="ounce")
    scaled_unit("lb", "oz", 16.0, name="pound")
    scaled_unit("ton", "lb", 2000.0, name="ton")
    scaled_unit("grain", "lb", 1.0 / 7000.0, name="grain")
    scaled_unit("dr", "lb", 1.0 / 256.0, name="dram")
    scaled_unit("cwt", "lb", 100.0, name="hundredweight")

    scaled_unit("dwt", "grain", 24.0, name="pennyweight")
    scaled_unit("oz t", "dwt", 20.0, name="ounce troy")
    scaled_unit("lb t", "oz t", 12.0, name="pound troy")

    # power
    scaled_unit("hpl", "W", 746.9999, name="mechanical")
    scaled_unit("hpm", "W", 735.49875, name="metric horsepower")
    scaled_unit("hpe", "W", 746.0, name="electric horsepower")

    # energy
    scaled_unit("BTU", "J", 1055.056, name="ISO BTU", is_si=True)

def test_volume():
    """Volume units should interchange correctly with cubed area units."""
    litres = unit('L')
    millilitres = unit('mL')
    centimetres = unit('cm')
    cm_cubed = centimetres * centimetres * centimetres
    
    assert Quantity(1, litres) == Quantity(1000, millilitres)
    assert Quantity(1, millilitres) == Quantity(1, cm_cubed)

def test_valid_named_to_basic():
    """Named units should convert to their basic equivalents"""
    
    kilometre = unit('km')
    one_km_in_m = unit('m')(Quantity(1, kilometre))
    
    assert one_km_in_m == Quantity(1000, unit('m'))
    assert one_km_in_m.unit == unit('m')
    assert str(one_km_in_m) == '1000 m'

 def setUp(self):
     self.laminate = CathodeLaminate(mass_active_material=0.9,
                                     mass_carbon=0.05,
                                     mass_binder=0.05,
                                     name="LMO-NEI")
     self.electrode = CoinCellElectrode(total_mass=unit('mg')(15),
                                        substrate_mass=unit('mg')(5),
                                        laminate=self.laminate,
                                        name="DummyElectrode",
                                        diameter=unit('mm')(12.7))

def test_composed_unit_repr():
    """Developer-friendly string representation of composed units."""
    
    test_repr = (repr(unit('m') * unit('g') / unit('s')))
    
    # non-deterministic
    assert test_repr in [
        "ComposedUnit([LeafUnit('g', True), " + "LeafUnit('m', True)], " + "[LeafUnit('s', True)], 1)",
        "ComposedUnit([LeafUnit('m', True), " + "LeafUnit('g', True)], " + "[LeafUnit('s', True)], 1)"
    ]

def test_good_named_add_w_mult():
    """A quantity with a named composed unit that carries a multiplier 
    should add to a composed unit that has a multiplier"""
    
    mile = unit('mi').composed_unit
    kilometre = unit('km')
                                               
    assert within_epsilon(Quantity(1, mile) + Quantity(1, kilometre), 
                          Quantity(1, kilometre) + Quantity(1, mile))
    assert within_epsilon(Quantity(2609.344, unit('m')),
                          Quantity(1, kilometre) + Quantity(1, mile))

def test_good_named_add_w_mults():
    """Two quantities with compatible but differently-named and 
    differently-multiplied units should add together."""
    
    mile = unit('mi')
    kilometre = unit('km')
    
    assert within_epsilon(Quantity(1, mile) + Quantity(1, kilometre),
                          Quantity(1, kilometre) + Quantity(1, mile))
    assert within_epsilon(Quantity(2609.344, unit('m')),
                          Quantity(1, kilometre) + Quantity(1, mile))

    def ConvertElectricFieldAtomicFromIntensitySI(self, intensity):
        """
        Intensity [W/cm**2] -> E-field strength [a.u.]

        Relation obtained from time-averaging over one cycle,

          E0 = sqrt( (2 <I>) / (eps0 * c) )

        """
        watt_per_squarecm = unit('W') / unit('cm')**2
        val = sqrt(2.0 * intensity / (self.electrostatic_constant.squeeze() /
                (4*pi) * self.lightspeed))
        return val * 100.0 / self.electric_field_strength.squeeze()

 def test_read_current(self):
     run = GalvanostatRun(mptfile)
     # These are practically equal but assertEqual fails due to rounding in units package
     self.assertApproximatelyEqual(
         run.charge_current,
         unit('mA')(0.33570),
         tolerance=10**-15
     )
     self.assertApproximatelyEqual(
         run.discharge_current,
         unit('mA')(-335.70),
         tolerance=10**-15
     )

def test_valid_composed_to_composed():
    """Valid composed units in terms of others."""
    metric_vel = unit('km') / unit('h')
    imp_vel = unit('mi') / unit('h')
    
    highway_kph = Quantity(100, metric_vel)
    highway_mph = Quantity(62.1371192237334, imp_vel)
    
    assert str(highway_kph) == '100 km / h'
    assert str(highway_mph) == '62.1371192237 mi / h'
    
    assert within_epsilon(imp_vel(highway_kph), highway_mph)
    
    assert str(imp_vel(highway_kph)) == '62.1371192237 mi / h'

def define_computer_units():
    """Define some units for technology.
    
    >>> define_units()
    >>> unit('GiB')(200) > unit('GB')(200) # bastard marketers
    True
    """

    NamedComposedUnit("flop", unit("operation") / unit("s"), name="flop", is_si=True)
    scaled_unit("B", "bit", 8.0, name="byte", is_si=True)
    scaled_unit("KiB", "B", 1024.0, name="kilobyte")
    scaled_unit("MiB", "KiB", 1024.0, name="megabyte")
    scaled_unit("GiB", "MiB", 1024.0, name="gigabyte")
    scaled_unit("TiB", "GiB", 1024.0, name="terabyte")
    scaled_unit("PiB", "TiB", 1024.0, name="petabyte")

def test_good_sub_w_mults():
    """Two quantities with compatible units should sub together 
    even when they have different multipliers"""
    
    mile = unit('mi').composed_unit
    kilometre = unit('km').composed_unit   
    
    m_on_left = Quantity(1, mile) - Quantity(1, kilometre)
    km_on_left = Quantity(1, kilometre) - Quantity(1, mile)
    m_on_left_diff = Quantity(609.344, unit('m'))
    km_on_left_diff = Quantity(-609.344, unit('m'))
            
    assert within_epsilon(m_on_left, m_on_left_diff)
    assert within_epsilon(km_on_left, km_on_left_diff)
    assert within_epsilon(m_on_left_diff, -km_on_left_diff)