def __pow__(self, power, modulo=None):
        if value_ops.equivalent(self.raw, 0.0, 1e-5):
            return self.__class__(self.raw, self.raw_uncertainty)

        val = self.raw**power
        unc = abs(val * float(power) * self.raw_uncertainty / self.raw)
        return self.__class__(val, unc)
    def __pow__(self, power, modulo=None):
        if value_ops.equivalent(self.raw, 0.0, 1e-5):
            return self.__class__(self.raw, self.raw_uncertainty)

        val = self.raw ** power
        unc = abs(val * float(power) * self.raw_uncertainty / self.raw)
        return self.__class__(val, unc)
    def __truediv__(self, other):
        try:
            val = self.raw / other.raw
            unc = abs(val) * math.sqrt((self.raw_uncertainty / self.raw)**2 +
                                       (other.raw_uncertainty / other.raw)**2)
        except ZeroDivisionError:
            if value_ops.equivalent(self.raw, 0.0, 1e-6):
                val = 0.0
                unc = math.sqrt(self.raw_uncertainty**2 +
                                other.raw_uncertainty**2)
            else:
                raise
        except Exception:
            val = self.raw / float(other)
            unc = abs(self.raw_uncertainty / float(other))

        return self.__class__(val, unc)
    def __truediv__(self, other):
        try:
            val = self.raw / other.raw
            unc = abs(val) * math.sqrt(
                (self.raw_uncertainty / self.raw) ** 2 +
                (other.raw_uncertainty / other.raw) ** 2)
        except ZeroDivisionError:
            if value_ops.equivalent(self.raw, 0.0, 1e-6):
                val = 0.0
                unc = math.sqrt(
                    self.raw_uncertainty ** 2 +
                    other.raw_uncertainty ** 2
                )
            else:
                raise
        except Exception:
            val = self.raw / float(other)
            unc = abs(self.raw_uncertainty / float(other))

        return self.__class__(val, unc)