shellsim 0.1.5__tar.gz → 0.1.7__tar.gz

{shellsim-0.1.5 → shellsim-0.1.7}/Cargo.lock

@@ -330,7 +330,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.5"
+version = "0.1.7"
 dependencies = [
  "base64",
  "crc32fast",

{shellsim-0.1.5 → shellsim-0.1.7}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "shellsim"
-version = "0.1.5"
+version = "0.1.7"
 edition = "2021"
 description = "In-process BusyBox-like environment for RL rollouts and agent tests"
 license = "Apache-2.0"

{shellsim-0.1.5 → shellsim-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shellsim
-Version: 0.1.5
+Version: 0.1.7
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS :: MacOS X

{shellsim-0.1.5 → shellsim-0.1.7}/python/native/Cargo.lock

@@ -406,7 +406,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.5"
+version = "0.1.7"
 dependencies = [
  "base64",
  "crc32fast",
@@ -427,7 +427,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim-python-bindings"
-version = "0.1.5"
+version = "0.1.7"
 dependencies = [
  "pyo3",
  "serde",

{shellsim-0.1.5 → shellsim-0.1.7}/python/native/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "shellsim-python-bindings"
-version = "0.1.5"
+version = "0.1.7"
 edition = "2021"
 description = "Python bindings for shellsim"
 license = "Apache-2.0"

{shellsim-0.1.5 → shellsim-0.1.7}/python/shellsim/_cli.py

@@ -148,7 +148,10 @@ def _interactive(environment: Environment, stdin: Any, stdout: Any, stderr: Any)
 def main(arguments: Optional[Sequence[str]] = None) -> int:
     """Run the package CLI and return the simulated or usage exit status."""
 
-    options = _parser().parse_args(sys.argv[1:] if arguments is None else arguments)
+    parsed_arguments = list(sys.argv[1:] if arguments is None else arguments)
+    if parsed_arguments[-1:] == ["--"]:
+        parsed_arguments.pop()
+    options = _parser().parse_args(parsed_arguments)
     environment, preparation_status = _prepare_environment(options, sys.stdout, sys.stderr)
     if environment is None:
         return preparation_status

{shellsim-0.1.5 → shellsim-0.1.7}/src/python/heap.rs

@@ -48,6 +48,10 @@ impl SymbolId {
     pub(super) const fn index(self) -> usize {
         self.0 as usize
     }
+
+    pub(super) fn from_index(index: usize) -> Option<Self> {
+        u32::try_from(index).ok().map(Self)
+    }
 }
 
 /// Runtime-local identity for one append-only instance storage layout.
@@ -386,6 +390,43 @@ impl Heap {
         self.symbol_ids.get(name).copied()
     }
 
+    /// Resolve a symbol identity back to its interpreter-owned name.
+    pub fn symbol_name(&self, symbol: SymbolId) -> Option<&str> {
+        self.symbol_names.get(symbol.index()).map(AsRef::as_ref)
+    }
+
+    /// Snapshot the names stored directly on an instance in either attribute representation.
+    pub fn instance_attribute_names(&self, id: ObjectId) -> Result<Vec<String>, String> {
+        let object = self
+            .objects
+            .get(id.0)
+            .and_then(Option::as_ref)
+            .ok_or("invalid object reference")?;
+        let Object::Instance { attributes, .. } = &object.payload else {
+            return Err("object does not have instance attributes".into());
+        };
+        match attributes {
+            InstanceAttributes::Shaped { shape, values } => (0..values.len())
+                .map(|slot| {
+                    let symbol = self
+                        .shape_attribute_at(*shape, slot)
+                        .ok_or("invalid instance shape slot")?;
+                    self.symbol_name(symbol)
+                        .map(str::to_string)
+                        .ok_or_else(|| "invalid instance attribute symbol".into())
+                })
+                .collect(),
+            InstanceAttributes::Dictionary(values) => values
+                .keys()
+                .map(|symbol| {
+                    self.symbol_name(*symbol)
+                        .map(str::to_string)
+                        .ok_or_else(|| "invalid instance attribute symbol".into())
+                })
+                .collect(),
+        }
+    }
+
     /// Intern one identifier, charging its process-lifetime storage before mutation.
     pub fn intern_symbol(
         &mut self,

{shellsim-0.1.5 → shellsim-0.1.7}/src/python/object_model.rs

@@ -883,6 +883,7 @@ fn install_builtin_slots(types: &mut [PyType]) {
     slots.add = Some(intrinsic(super::stdlib::core::slot_string_add));
     slots.multiply = Some(intrinsic(super::stdlib::core::slot_string_multiply));
     slots.reflected_multiply = Some(intrinsic(super::stdlib::core::slot_string_multiply));
+    slots.remainder = Some(intrinsic(super::stdlib::core::slot_string_remainder));
 
     let slots = &mut types[BuiltinType::Bytes as usize].slots;
     slots.length = Some(unary(super::stdlib::core::slot_bytes_length));

{shellsim-0.1.5 → shellsim-0.1.7}/src/python/stdlib/core.rs

@@ -13,7 +13,7 @@ use super::super::native::PyValue as Value;
 use super::super::native::{
     CallArgs, FunctionDef, MethodDef, NativeTypeDef, OwnedPyString, PyByteArray, PyBytes,
     PyCallable, PyDict, PyError, PyKind, PyList, PyProperty, PyResult, PyRuntime, PySequence,
-    PySet, PyValue, PyValueCast,
+    PySet, PyTuple, PyValue, PyValueCast,
 };
 use super::super::number::PyNumber;
 use super::super::slice::SlicePlan;
@@ -56,6 +56,8 @@ pub(crate) static STRING_TYPE: NativeTypeDef = NativeTypeDef {
         method("str", "join", string_join),
         method("str", "replace", string_replace),
         method("str", "format", string_format),
+        method("str", "ljust", string_ljust),
+        method("str", "rjust", string_rjust),
         method("str", "encode", string_encode),
         method("str", "lower", string_lower),
         method("str", "upper", string_upper),
@@ -737,6 +739,293 @@ fn string_replace(runtime: &mut dyn PyRuntime, receiver: PyValue, args: CallArgs
     runtime.new_string(result)
 }
 
+fn string_ljust(runtime: &mut dyn PyRuntime, receiver: PyValue, args: CallArgs) -> PyResult {
+    string_justify(runtime, receiver, args, false)
+}
+
+fn string_rjust(runtime: &mut dyn PyRuntime, receiver: PyValue, args: CallArgs) -> PyResult {
+    string_justify(runtime, receiver, args, true)
+}
+
+fn string_justify(
+    runtime: &mut dyn PyRuntime,
+    receiver: PyValue,
+    args: CallArgs,
+    right: bool,
+) -> PyResult {
+    let name = if right { "str.rjust" } else { "str.ljust" };
+    args.expect_positional(name, 1, 2)?;
+    args.reject_keywords(name)?;
+    let OwnedPyString(value) = receiver.cast(runtime)?;
+    let width = runtime
+        .int_value(&args.positional()[0])
+        .ok_or_else(|| PyError::type_error("width must be an integer"))?;
+    let fill = if let Some(fill) = args.positional().get(1) {
+        let OwnedPyString(fill) = (*fill).cast(runtime)?;
+        if fill.chars().count() != 1 {
+            return Err(PyError::type_error(
+                "the fill character must be exactly one character long",
+            ));
+        }
+        fill
+    } else {
+        " ".to_string()
+    };
+    let padding = usize::try_from(width)
+        .ok()
+        .unwrap_or_default()
+        .saturating_sub(value.chars().count());
+    let added = fill
+        .len()
+        .checked_mul(padding)
+        .ok_or_else(|| PyError::resource_error("justified string is too large"))?;
+    let capacity = value
+        .len()
+        .checked_add(added)
+        .ok_or_else(|| PyError::resource_error("justified string is too large"))?;
+    runtime.reserve_memory(capacity)?;
+    runtime.charge_cpu(u64::try_from(capacity).unwrap_or(u64::MAX))?;
+    let padding = fill.repeat(padding);
+    runtime.new_string(if right {
+        format!("{padding}{value}")
+    } else {
+        format!("{value}{padding}")
+    })
+}
+
+/// Implement the established string `%` protocol without routing numeric remainder through it.
+pub(crate) fn slot_string_remainder(
+    runtime: &mut dyn PyRuntime,
+    left: PyValue,
+    right: PyValue,
+) -> PyResult<Option<PyValue>> {
+    let OwnedPyString(template) = left.cast(runtime)?;
+    runtime.reserve_memory(template.len())?;
+    let arguments = if runtime.kind(&right)? == PyKind::Tuple {
+        right.cast::<PyTuple>(runtime)?.items(runtime)?
+    } else {
+        vec![right]
+    };
+    let mut argument = 0usize;
+    let mut used_mapping = false;
+    let mut output = String::new();
+    let characters = template.chars().collect::<Vec<_>>();
+    let mut index = 0usize;
+    while index < characters.len() {
+        runtime.charge_cpu(1)?;
+        if characters[index] != '%' {
+            output.push(characters[index]);
+            index += 1;
+            continue;
+        }
+        index += 1;
+        if characters.get(index) == Some(&'%') {
+            output.push('%');
+            index += 1;
+            continue;
+        }
+        let mapping_key = if characters.get(index) == Some(&'(') {
+            index += 1;
+            let start = index;
+            while characters
+                .get(index)
+                .is_some_and(|character| *character != ')')
+            {
+                index += 1;
+            }
+            if characters.get(index) != Some(&')') {
+                return Err(PyError::value_error("incomplete format key"));
+            }
+            let key = characters[start..index].iter().collect::<String>();
+            index += 1;
+            Some(key)
+        } else {
+            None
+        };
+        let mut left_align = false;
+        let mut plus = false;
+        let mut space = false;
+        let mut alternate = false;
+        let mut zero = false;
+        while let Some(flag) = characters.get(index) {
+            match flag {
+                '-' => left_align = true,
+                '+' => plus = true,
+                ' ' => space = true,
+                '#' => alternate = true,
+                '0' => zero = true,
+                _ => break,
+            }
+            index += 1;
+        }
+        let width = parse_format_digits(&characters, &mut index)?;
+        let precision = if characters.get(index) == Some(&'.') {
+            index += 1;
+            Some(parse_format_digits(&characters, &mut index)?.unwrap_or(0))
+        } else {
+            None
+        };
+        let requested = width.unwrap_or_default().max(precision.unwrap_or_default());
+        runtime.reserve_memory(requested)?;
+        runtime.charge_cpu(u64::try_from(requested).unwrap_or(u64::MAX))?;
+        let conversion = *characters
+            .get(index)
+            .ok_or_else(|| PyError::value_error("incomplete format"))?;
+        index += 1;
+        let value = if let Some(key) = mapping_key {
+            used_mapping = true;
+            let mapping = right.cast::<PyDict>(runtime)?;
+            let key_value = runtime.new_string(key.clone())?;
+            runtime
+                .dict_get(mapping, &key_value)?
+                .ok_or_else(|| PyError::exception("KeyError", key))?
+        } else {
+            let value = arguments
+                .get(argument)
+                .copied()
+                .ok_or_else(|| PyError::type_error("not enough arguments for format string"))?;
+            argument += 1;
+            value
+        };
+        let mut rendered = match conversion {
+            's' => runtime.display(&value)?,
+            'r' | 'a' => runtime.repr(&value)?,
+            'd' | 'i' | 'u' => runtime
+                .integer_text(&value)?
+                .ok_or_else(|| PyError::type_error("%d format: a real number is required"))?,
+            'x' | 'X' | 'o' => {
+                let decimal = runtime
+                    .integer_text(&value)?
+                    .ok_or_else(|| PyError::type_error("integer format requires an integer"))?;
+                let integer = decimal
+                    .parse::<BigInt>()
+                    .map_err(|_| PyError::runtime_error("invalid internal integer"))?;
+                let digits = match conversion {
+                    'x' => format!("{integer:x}"),
+                    'X' => format!("{integer:X}"),
+                    'o' => format!("{integer:o}"),
+                    _ => unreachable!(),
+                };
+                if alternate && integer != BigInt::zero() {
+                    match conversion {
+                        'x' => format!("0x{digits}"),
+                        'X' => format!("0X{digits}"),
+                        'o' => format!("0o{digits}"),
+                        _ => unreachable!(),
+                    }
+                } else {
+                    digits
+                }
+            }
+            'f' | 'F' | 'e' | 'E' | 'g' | 'G' => {
+                let number = value.cast::<PyNumber>(runtime)?.into_f64()?;
+                let precision = precision.unwrap_or(6);
+                match conversion {
+                    'f' | 'F' => format!("{number:.precision$}"),
+                    'e' => format!("{number:.precision$e}"),
+                    'E' => format!("{number:.precision$E}"),
+                    'g' | 'G' => {
+                        let mut text = format!("{number:.precision$}");
+                        if conversion == 'G' {
+                            text.make_ascii_uppercase();
+                        }
+                        text
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            'c' => {
+                if let Some(integer) = runtime.int_value(&value) {
+                    u32::try_from(integer)
+                        .ok()
+                        .and_then(char::from_u32)
+                        .ok_or_else(|| PyError::overflow_error("%c arg not in range"))?
+                        .to_string()
+                } else {
+                    let OwnedPyString(text) = value.cast(runtime)?;
+                    if text.chars().count() != 1 {
+                        return Err(PyError::type_error("%c requires int or char"));
+                    }
+                    text
+                }
+            }
+            other => {
+                return Err(PyError::value_error(format!(
+                    "unsupported format character {other:?}"
+                )))
+            }
+        };
+        if matches!(conversion, 's' | 'r' | 'a') {
+            if let Some(precision) = precision {
+                rendered = rendered.chars().take(precision).collect();
+            }
+        } else if matches!(conversion, 'd' | 'i' | 'u') {
+            rendered = pad_integer_precision(rendered, precision);
+        }
+        if matches!(
+            conversion,
+            'd' | 'i' | 'u' | 'f' | 'F' | 'e' | 'E' | 'g' | 'G'
+        ) && !rendered.starts_with('-')
+        {
+            if plus {
+                rendered.insert(0, '+');
+            } else if space {
+                rendered.insert(0, ' ');
+            }
+        }
+        if let Some(width) = width {
+            let padding = width.saturating_sub(rendered.chars().count());
+            if padding > 0 {
+                let fill = if zero && !left_align { '0' } else { ' ' };
+                if left_align {
+                    rendered.extend(std::iter::repeat_n(fill, padding));
+                } else if fill == '0' && matches!(rendered.chars().next(), Some('+' | '-' | ' ')) {
+                    let sign = rendered.remove(0);
+                    rendered = format!("{sign}{}{rendered}", "0".repeat(padding));
+                } else {
+                    rendered = format!("{}{rendered}", fill.to_string().repeat(padding));
+                }
+            }
+        }
+        runtime.reserve_memory(rendered.len())?;
+        output.push_str(&rendered);
+    }
+    if !used_mapping && argument < arguments.len() {
+        return Err(PyError::type_error(
+            "not all arguments converted during string formatting",
+        ));
+    }
+    runtime.reserve_memory(output.len())?;
+    Ok(Some(runtime.new_string(output)?))
+}
+
+fn parse_format_digits(characters: &[char], index: &mut usize) -> PyResult<Option<usize>> {
+    let start = *index;
+    let mut value = 0usize;
+    while let Some(character) = characters.get(*index).and_then(|value| value.to_digit(10)) {
+        value = value
+            .checked_mul(10)
+            .and_then(|value| value.checked_add(character as usize))
+            .ok_or_else(|| PyError::resource_error("format width is too large"))?;
+        *index += 1;
+    }
+    Ok((*index != start).then_some(value))
+}
+
+fn pad_integer_precision(mut value: String, precision: Option<usize>) -> String {
+    let Some(precision) = precision else {
+        return value;
+    };
+    let sign = value.starts_with('-').then(|| value.remove(0));
+    if value.len() < precision {
+        value = format!("{}{value}", "0".repeat(precision - value.len()));
+    }
+    if let Some(sign) = sign {
+        value.insert(0, sign);
+    }
+    value
+}
+
 fn string_format(runtime: &mut dyn PyRuntime, receiver: PyValue, args: CallArgs) -> PyResult {
     let OwnedPyString(template) = receiver.cast(runtime)?;
     let mut result = String::new();

{shellsim-0.1.5 → shellsim-0.1.7}/src/python/stdlib/frozen.rs

@@ -10,6 +10,8 @@ pub(super) fn module_source(name: &str) -> Option<&'static str> {
         "abc" => Some(include_str!("source/abc.py")),
         "base64" => Some(include_str!("source/base64.py")),
         "codecs" => Some(include_str!("source/codecs.py")),
+        "_complex" => Some(include_str!("source/complex.py")),
+        "cmath" => Some(include_str!("source/cmath.py")),
         "csv" => Some(include_str!("source/csv.py")),
         "datetime" => Some(include_str!("source/datetime.py")),
         "collections" => Some(include_str!("source/collections.py")),

{shellsim-0.1.5 → shellsim-0.1.7}/src/python/stdlib/math.rs

@@ -17,6 +17,26 @@ use super::super::number::PyNumber;
 pub(super) static MODULE: ModuleDef = ModuleDef {
     name: "math",
     functions: &[
+        FunctionDef {
+            module: "math",
+            name: "acos",
+            call: native_acos,
+        },
+        FunctionDef {
+            module: "math",
+            name: "asin",
+            call: native_asin,
+        },
+        FunctionDef {
+            module: "math",
+            name: "atan",
+            call: native_atan,
+        },
+        FunctionDef {
+            module: "math",
+            name: "atan2",
+            call: native_atan2,
+        },
         FunctionDef {
             module: "math",
             name: "ceil",
@@ -27,11 +47,21 @@ pub(super) static MODULE: ModuleDef = ModuleDef {
             name: "cos",
             call: native_cos,
         },
+        FunctionDef {
+            module: "math",
+            name: "degrees",
+            call: native_degrees,
+        },
         FunctionDef {
             module: "math",
             name: "exp",
             call: native_exp,
         },
+        FunctionDef {
+            module: "math",
+            name: "hypot",
+            call: native_hypot,
+        },
         FunctionDef {
             module: "math",
             name: "isinf",
@@ -47,6 +77,21 @@ pub(super) static MODULE: ModuleDef = ModuleDef {
             name: "log",
             call: native_log,
         },
+        FunctionDef {
+            module: "math",
+            name: "log10",
+            call: native_log10,
+        },
+        FunctionDef {
+            module: "math",
+            name: "pow",
+            call: native_pow,
+        },
+        FunctionDef {
+            module: "math",
+            name: "radians",
+            call: native_radians,
+        },
         FunctionDef {
             module: "math",
             name: "sin",
@@ -87,6 +132,22 @@ pub(super) static MODULE: ModuleDef = ModuleDef {
     ],
 };
 
+fn native_acos(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_call(runtime, args, "acos")
+}
+
+fn native_asin(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_call(runtime, args, "asin")
+}
+
+fn native_atan(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_call(runtime, args, "atan")
+}
+
+fn native_atan2(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_call(runtime, args, "atan2")
+}
+
 fn native_ceil(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
     native_call(runtime, args, "ceil")
 }
@@ -95,10 +156,18 @@ fn native_cos(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
     native_call(runtime, args, "cos")
 }
 
+fn native_degrees(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_call(runtime, args, "degrees")
+}
+
 fn native_exp(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
     native_call(runtime, args, "exp")
 }
 
+fn native_hypot(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_call(runtime, args, "hypot")
+}
+
 fn native_isinf(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
     native_call(runtime, args, "isinf")
 }
@@ -111,6 +180,18 @@ fn native_log(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
     native_call(runtime, args, "log")
 }
 
+fn native_log10(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_call(runtime, args, "log10")
+}
+
+fn native_pow(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_call(runtime, args, "pow")
+}
+
+fn native_radians(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_call(runtime, args, "radians")
+}
+
 fn native_sin(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
     native_call(runtime, args, "sin")
 }
@@ -220,9 +301,19 @@ pub fn constant(name: &str) -> Option<MathValue> {
 /// Dispatch one of the observed/reviewer-requested `math` functions.
 pub fn call(name: &str, args: &[f64]) -> MathResult {
     match name {
+        "acos" => unary("acos", args, acos),
+        "asin" => unary("asin", args, asin),
+        "atan" => unary("atan", args, |value| Ok(MathValue::Float(value.atan()))),
+        "atan2" => binary("atan2", args, |y, x| Ok(MathValue::Float(y.atan2(x)))),
         "ceil" => unary("ceil", args, ceil),
         "cos" => unary("cos", args, cos),
+        "degrees" => unary("degrees", args, |value| {
+            Ok(MathValue::Float(value.to_degrees()))
+        }),
         "exp" => unary("exp", args, exp),
+        "hypot" => Ok(MathValue::Float(
+            args.iter().copied().fold(0.0_f64, f64::hypot),
+        )),
         "isinf" => unary("isinf", args, |value| Ok(MathValue::Bool(isinf(value)))),
         "isnan" => unary("isnan", args, |value| Ok(MathValue::Bool(isnan(value)))),
         "log" => match args {
@@ -234,6 +325,11 @@ pub fn call(name: &str, args: &[f64]) -> MathResult {
                 actual: args.len(),
             }),
         },
+        "log10" => unary("log10", args, log10),
+        "pow" => binary("pow", args, pow),
+        "radians" => unary("radians", args, |value| {
+            Ok(MathValue::Float(value.to_radians()))
+        }),
         "sin" => unary("sin", args, sin),
         "sqrt" => unary("sqrt", args, sqrt),
         "tan" => unary("tan", args, tan),
@@ -241,6 +337,21 @@ pub fn call(name: &str, args: &[f64]) -> MathResult {
     }
 }
 
+fn binary(
+    function: &'static str,
+    args: &[f64],
+    operation: impl FnOnce(f64, f64) -> MathResult,
+) -> MathResult {
+    let [left, right] = args else {
+        return Err(MathError::Arity {
+            function,
+            expected: "exactly 2",
+            actual: args.len(),
+        });
+    };
+    operation(*left, *right)
+}
+
 fn unary(
     function: &'static str,
     args: &[f64],
@@ -288,6 +399,45 @@ pub fn exp(value: f64) -> MathResult {
     Ok(MathValue::Float(result))
 }
 
+/// Return the inverse sine in radians.
+pub fn asin(value: f64) -> MathResult {
+    if !(-1.0..=1.0).contains(&value) {
+        return Err(MathError::ValueError("math domain error"));
+    }
+    Ok(MathValue::Float(value.asin()))
+}
+
+/// Return the inverse cosine in radians.
+pub fn acos(value: f64) -> MathResult {
+    if !(-1.0..=1.0).contains(&value) {
+        return Err(MathError::ValueError("math domain error"));
+    }
+    Ok(MathValue::Float(value.acos()))
+}
+
+/// Return the base-ten logarithm of a positive value.
+pub fn log10(value: f64) -> MathResult {
+    if value <= 0.0 {
+        return Err(MathError::ValueError("math domain error"));
+    }
+    Ok(MathValue::Float(value.log10()))
+}
+
+/// Return `left**right` with Python's real-number domain and overflow errors.
+pub fn pow(left: f64, right: f64) -> MathResult {
+    if left == 0.0 && right < 0.0 {
+        return Err(MathError::ValueError("math domain error"));
+    }
+    let value = left.powf(right);
+    if value.is_nan() && !(left.is_nan() || right.is_nan()) {
+        return Err(MathError::ValueError("math domain error"));
+    }
+    if value.is_infinite() && left.is_finite() && right.is_finite() {
+        return Err(MathError::OverflowError("math range error"));
+    }
+    Ok(MathValue::Float(value))
+}
+
 /// Return whether `value` is positive or negative infinity.
 pub const fn isinf(value: f64) -> bool {
     value.is_infinite()