polars-df 0.11.0 → 0.12.0

data/lib/polars/utils.rb

@@ -3,150 +3,6 @@ module Polars
   module Utils
     DTYPE_TEMPORAL_UNITS = ["ns", "us", "ms"]
 
-    def self.wrap_s(s)
-      Series._from_rbseries(s)
-    end
-
-    def self.wrap_df(df)
-      DataFrame._from_rbdf(df)
-    end
-
-    def self.wrap_ldf(ldf)
-      LazyFrame._from_rbldf(ldf)
-    end
-
-    def self.wrap_expr(rbexpr)
-      Expr._from_rbexpr(rbexpr)
-    end
-
-    def self.col(name)
-      Polars.col(name)
-    end
-
-    def self.arrlen(obj)
-      if obj.is_a?(Range)
-        # size only works for numeric ranges
-        obj.to_a.length
-      elsif obj.is_a?(::String)
-        nil
-      else
-        obj.length
-      end
-    rescue
-      nil
-    end
-
-    def self._timedelta_to_pl_duration(td)
-      td
-    end
-
-    def self._datetime_to_pl_timestamp(dt, time_unit)
-      dt = dt.to_datetime.to_time
-      if time_unit == "ns"
-        nanos = dt.nsec
-        dt.to_i * 1_000_000_000 + nanos
-      elsif time_unit == "us"
-        micros = dt.usec
-        dt.to_i * 1_000_000 + micros
-      elsif time_unit == "ms"
-        millis = dt.usec / 1000
-        dt.to_i * 1_000 + millis
-      elsif time_unit.nil?
-        # Ruby has ns precision
-        nanos = dt.nsec
-        dt.to_i * 1_000_000_000 + nanos
-      else
-        raise ArgumentError, "time_unit must be one of {{'ns', 'us', 'ms'}}, got #{tu}"
-      end
-    end
-
-    def self._date_to_pl_date(d)
-      dt = d.to_datetime.to_time
-      dt.to_i / (3600 * 24)
-    end
-
-    def self._to_ruby_time(value)
-      if value == 0
-        ::Time.utc(2000, 1, 1)
-      else
-        seconds, nanoseconds = value.divmod(1_000_000_000)
-        minutes, seconds = seconds.divmod(60)
-        hours, minutes = minutes.divmod(60)
-        ::Time.utc(2000, 1, 1, hours, minutes, seconds, nanoseconds / 1000.0)
-      end
-    end
-
-    def self._to_ruby_duration(value, time_unit = "ns")
-      if time_unit == "ns"
-        value / 1e9
-      elsif time_unit == "us"
-        value / 1e6
-      elsif time_unit == "ms"
-        value / 1e3
-      else
-        raise ArgumentError, "time_unit must be one of {{'ns', 'us', 'ms'}}, got #{time_unit}"
-      end
-    end
-
-    def self._to_ruby_date(value)
-      # days to seconds
-      # important to create from utc. Not doing this leads
-      # to inconsistencies dependent on the timezone you are in.
-      ::Time.at(value * 86400).utc.to_date
-    end
-
-    def self._to_ruby_datetime(value, time_unit = "ns", time_zone = nil)
-      if time_zone.nil? || time_zone == ""
-        if time_unit == "ns"
-          return ::Time.at(value / 1000000000, value % 1000000000, :nsec).utc
-        elsif time_unit == "us"
-          return ::Time.at(value / 1000000, value % 1000000, :usec).utc
-        elsif time_unit == "ms"
-          return ::Time.at(value / 1000, value % 1000, :millisecond).utc
-        else
-          raise ArgumentError, "time_unit must be one of {{'ns', 'us', 'ms'}}, got #{time_unit}"
-        end
-      else
-        raise Todo
-      end
-    end
-
-    def self._to_ruby_decimal(digits, scale)
-      BigDecimal("#{digits}e#{scale}")
-    end
-
-    def self.selection_to_rbexpr_list(exprs)
-      if exprs.is_a?(::String) || exprs.is_a?(Symbol) || exprs.is_a?(Expr) || exprs.is_a?(Series)
-        exprs = [exprs]
-      end
-
-      exprs.map { |e| expr_to_lit_or_expr(e, str_to_lit: false)._rbexpr }
-    end
-
-    def self.expr_to_lit_or_expr(expr, str_to_lit: true)
-      if (expr.is_a?(::String) || expr.is_a?(Symbol)) && !str_to_lit
-        col(expr)
-      elsif expr.is_a?(Integer) || expr.is_a?(Float) || expr.is_a?(::String) || expr.is_a?(Symbol) || expr.is_a?(Series) || expr.nil?
-        lit(expr)
-      elsif expr.is_a?(Expr)
-        expr
-      else
-        raise ArgumentError, "did not expect value #{expr} of type #{expr.class.name}, maybe disambiguate with Polars.lit or Polars.col"
-      end
-    end
-
-    def self.lit(value)
-      Polars.lit(value)
-    end
-
-    def self.normalize_filepath(path, check_not_directory: true)
-      path = File.expand_path(path)
-      if check_not_directory && File.exist?(path) && Dir.exist?(path)
-        raise ArgumentError, "Expected a file path; #{path} is a directory"
-      end
-      path
-    end
-
     # TODO fix
     def self.is_polars_dtype(data_type, include_unknown: false)
       if data_type == Unknown
@@ -191,19 +47,11 @@ module Polars
       end
     end
 
-    def self._process_null_values(null_values)
-      if null_values.is_a?(Hash)
-        null_values.to_a
-      else
-        null_values
-      end
-    end
-
-    def self._prepare_row_count_args(row_count_name = nil, row_count_offset = 0)
-      if !row_count_name.nil?
-        [row_count_name, row_count_offset]
-      else
+    def self.parse_row_index_args(row_index_name = nil, row_index_offset = 0)
+      if row_index_name.nil?
         nil
+      else
+        [row_index_name, row_index_offset]
       end
     end
 
@@ -223,21 +71,6 @@ module Polars
       [projection, columns]
     end
 
-    def self.scale_bytes(sz, to:)
-      scaling_factor = {
-        "b" => 1,
-        "k" => 1024,
-        "m" => 1024 ** 2,
-        "g" => 1024 ** 3,
-        "t" => 1024 ** 4
-      }[to[0]]
-      if scaling_factor > 1
-        sz / scaling_factor.to_f
-      else
-        sz
-      end
-    end
-
     def self.bool?(value)
       value.is_a?(TrueClass) || value.is_a?(FalseClass)
     end
@@ -250,108 +83,10 @@ module Polars
       value.is_a?(::String) || (defined?(Pathname) && value.is_a?(Pathname))
     end
 
-    def self._is_iterable_of(val, eltype)
-      val.all? { |x| x.is_a?(eltype) }
-    end
-
-    def self.is_bool_sequence(val)
-      val.is_a?(::Array) && val.all? { |x| x == true || x == false }
-    end
-
-    def self.is_dtype_sequence(val)
-      val.is_a?(::Array) && val.all? { |x| is_polars_dtype(x) }
-    end
-
-    def self.is_int_sequence(val)
-      val.is_a?(::Array) && _is_iterable_of(val, Integer)
-    end
-
-    def self.is_expr_sequence(val)
-      val.is_a?(::Array) && _is_iterable_of(val, Expr)
-    end
-
-    def self.is_rbexpr_sequence(val)
-      val.is_a?(::Array) && _is_iterable_of(val, RbExpr)
-    end
-
-    def self.is_str_sequence(val, allow_str: false)
-      if allow_str == false && val.is_a?(::String)
-        false
-      else
-        val.is_a?(::Array) && _is_iterable_of(val, ::String)
-      end
-    end
-
     def self.local_file?(file)
       Dir.glob(file).any?
     end
 
-    def self.parse_as_list_of_expressions(*inputs, __structify: false, **named_inputs)
-      exprs = _parse_positional_inputs(inputs, structify: __structify)
-      if named_inputs.any?
-        named_exprs = _parse_named_inputs(named_inputs, structify: __structify)
-        exprs.concat(named_exprs)
-      end
-
-      exprs
-    end
-
-    def self._parse_positional_inputs(inputs, structify: false)
-      inputs_iter = _parse_inputs_as_iterable(inputs)
-      inputs_iter.map { |e| parse_as_expression(e, structify: structify) }
-    end
-
-    def self._parse_inputs_as_iterable(inputs)
-      if inputs.empty?
-        return []
-      end
-
-      if inputs.length == 1 && inputs[0].is_a?(::Array)
-        return inputs[0]
-      end
-
-      inputs
-    end
-
-    def self._parse_named_inputs(named_inputs, structify: false)
-      named_inputs.map do |name, input|
-        parse_as_expression(input, structify: structify)._alias(name.to_s)
-      end
-    end
-
-    def self.parse_as_expression(input, str_as_lit: false, list_as_lit: true, structify: false, dtype: nil)
-      if input.is_a?(Expr)
-        expr = input
-      elsif input.is_a?(::String) && !str_as_lit
-        expr = Polars.col(input)
-        structify = false
-      elsif input.is_a?(::Array) && !list_as_lit
-        expr = Polars.lit(Series.new(input), dtype: dtype)
-        structify = false
-      else
-        expr = Polars.lit(input, dtype: dtype)
-        structify = false
-      end
-
-      if structify
-        raise Todo
-      end
-
-      expr._rbexpr
-    end
-
-    USE_EARLIEST_TO_AMBIGUOUS = {
-      true => "earliest",
-      false => "latest"
-    }
-
-    def self.rename_use_earliest_to_ambiguous(use_earliest, ambiguous)
-      unless use_earliest.nil?
-        ambiguous = USE_EARLIEST_TO_AMBIGUOUS.fetch(use_earliest)
-      end
-      ambiguous
-    end
-
     def self._check_arg_is_1byte(arg_name, arg, can_be_empty = false)
       if arg.is_a?(::String)
         arg_byte_length = arg.bytesize
@@ -385,72 +120,11 @@ module Polars
       false
     end
 
-    def self.parse_predicates_constraints_as_expression(*predicates, **constraints)
-      all_predicates = _parse_positional_inputs(predicates)
-
-      if constraints.any?
-        constraint_predicates = _parse_constraints(constraints)
-        all_predicates.concat(constraint_predicates)
-      end
-
-      _combine_predicates(all_predicates)
-    end
-
-    def self._parse_constraints(constraints)
-      constraints.map do |name, value|
-        Polars.col(name).eq(value)._rbexpr
-      end
-    end
-
-    def self._combine_predicates(predicates)
-      if !predicates.any?
-        msg = "at least one predicate or constraint must be provided"
-        raise TypeError, msg
-      end
-
-      if predicates.length == 1
-        return predicates[0]
-      end
-
-      Plr.all_horizontal(predicates)
-    end
-
-    def self.parse_when_inputs(*predicates, **constraints)
-      parse_predicates_constraints_as_expression(*predicates, **constraints)
-    end
-
     def self.parse_interval_argument(interval)
       if interval.include?(" ")
         interval = interval.gsub(" ", "")
       end
       interval.downcase
     end
-
-    def self.validate_rolling_by_aggs_arguments(weights, center:)
-      if !weights.nil?
-        msg = "`weights` is not supported in `rolling_*(..., by=...)` expression"
-        raise InvalidOperationError, msg
-      end
-      if center
-        msg = "`center=True` is not supported in `rolling_*(..., by=...)` expression"
-        raise InvalidOperationError, msg
-      end
-    end
-
-    def self.validate_rolling_aggs_arguments(window_size, closed)
-      if window_size.is_a?(::String)
-        begin
-          window_size = window_size.delete_suffix("i").to_i
-        rescue
-          msg = "Expected a string of the form 'ni', where `n` is a positive integer, got: #{window_size}"
-          raise InvalidOperationError, msg
-        end
-      end
-      if !closed.nil?
-        msg = "`closed` is not supported in `rolling_*(...)` expression"
-        raise InvalidOperationError, msg
-      end
-      window_size
-    end
   end
 end

data/lib/polars/version.rb

@@ -1,4 +1,4 @@
 module Polars
   # @private
-  VERSION = "0.11.0"
+  VERSION = "0.12.0"
 end

data/lib/polars/whenthen.rb

@@ -8,7 +8,7 @@ module Polars
     end
 
     def then(statement)
-      statement_rbexpr = Utils.parse_as_expression(statement)
+      statement_rbexpr = Utils.parse_into_expression(statement)
       Then.new(_when.then(statement_rbexpr))
     end
   end
@@ -30,12 +30,12 @@ module Polars
     end
 
     def when(*predicates, **constraints)
-      condition_rbexpr = Utils.parse_when_inputs(*predicates, **constraints)
+      condition_rbexpr = Utils.parse_predicates_constraints_into_expression(*predicates, **constraints)
       ChainedWhen.new(_then.when(condition_rbexpr))
     end
 
     def otherwise(statement)
-      statement_rbexpr = Utils.parse_as_expression(statement)
+      statement_rbexpr = Utils.parse_into_expression(statement)
       Utils.wrap_expr(_then.otherwise(statement_rbexpr))
     end
   end
@@ -49,7 +49,7 @@ module Polars
     end
 
     def then(statement)
-      statement_rbexpr = Utils.parse_as_expression(statement)
+      statement_rbexpr = Utils.parse_into_expression(statement)
       ChainedThen.new(_chained_when.then(statement_rbexpr))
     end
   end
@@ -71,12 +71,12 @@ module Polars
     end
 
     def when(*predicates, **constraints)
-      condition_rbexpr = Utils.parse_when_inputs(*predicates, **constraints)
+      condition_rbexpr = Utils.parse_predicates_constraints_into_expression(*predicates, **constraints)
       ChainedWhen.new(_chained_then.when(condition_rbexpr))
     end
 
     def otherwise(statement)
-      statement_rbexpr = Utils.parse_as_expression(statement)
+      statement_rbexpr = Utils.parse_into_expression(statement)
       Utils.wrap_expr(_chained_then.otherwise(statement_rbexpr))
     end
   end

data/lib/polars.rb

@@ -70,6 +70,11 @@ require_relative "polars/struct_expr"
 require_relative "polars/struct_name_space"
 require_relative "polars/testing"
 require_relative "polars/utils"
+require_relative "polars/utils/constants"
+require_relative "polars/utils/convert"
+require_relative "polars/utils/parse"
+require_relative "polars/utils/various"
+require_relative "polars/utils/wrap"
 require_relative "polars/version"
 require_relative "polars/whenthen"
 
@@ -77,4 +82,10 @@ module Polars
   extend Convert
   extend Functions
   extend IO
+
+  # @private
+  F = self
+
+  # @private
+  N_INFER_DEFAULT = 100
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-03 00:00:00.000000000 Z
+date: 2024-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -54,7 +54,7 @@ files:
 - ext/polars/Cargo.toml
 - ext/polars/extconf.rb
 - ext/polars/src/batched_csv.rs
-- ext/polars/src/conversion/anyvalue.rs
+- ext/polars/src/conversion/any_value.rs
 - ext/polars/src/conversion/chunked_array.rs
 - ext/polars/src/conversion/mod.rs
 - ext/polars/src/dataframe/construction.rs
@@ -172,6 +172,11 @@ files:
 - lib/polars/struct_name_space.rb
 - lib/polars/testing.rb
 - lib/polars/utils.rb
+- lib/polars/utils/constants.rb
+- lib/polars/utils/convert.rb
+- lib/polars/utils/parse.rb
+- lib/polars/utils/various.rb
+- lib/polars/utils/wrap.rb
 - lib/polars/version.rb
 - lib/polars/whenthen.rb
 homepage: https://github.com/ankane/ruby-polars
@@ -193,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: Blazingly fast DataFrames for Ruby

data/ext/polars/src/conversion/anyvalue.rs

@@ -1,186 +0,0 @@
-use magnus::encoding::{EncodingCapable, Index};
-use magnus::{
-    class, prelude::*, r_hash::ForEach, Float, Integer, IntoValue, RArray, RHash, RString, Ruby,
-    TryConvert, Value,
-};
-use polars::prelude::*;
-use polars_core::utils::any_values_to_supertype_and_n_dtypes;
-
-use super::{struct_dict, ObjectValue, Wrap};
-
-use crate::rb_modules::utils;
-use crate::{RbPolarsErr, RbResult, RbSeries};
-
-impl IntoValue for Wrap<AnyValue<'_>> {
-    fn into_value_with(self, ruby: &Ruby) -> Value {
-        match self.0 {
-            AnyValue::UInt8(v) => ruby.into_value(v),
-            AnyValue::UInt16(v) => ruby.into_value(v),
-            AnyValue::UInt32(v) => ruby.into_value(v),
-            AnyValue::UInt64(v) => ruby.into_value(v),
-            AnyValue::Int8(v) => ruby.into_value(v),
-            AnyValue::Int16(v) => ruby.into_value(v),
-            AnyValue::Int32(v) => ruby.into_value(v),
-            AnyValue::Int64(v) => ruby.into_value(v),
-            AnyValue::Float32(v) => ruby.into_value(v),
-            AnyValue::Float64(v) => ruby.into_value(v),
-            AnyValue::Null => ruby.qnil().as_value(),
-            AnyValue::Boolean(v) => ruby.into_value(v),
-            AnyValue::String(v) => ruby.into_value(v),
-            AnyValue::StringOwned(v) => ruby.into_value(v.as_str()),
-            AnyValue::Categorical(idx, rev, arr) | AnyValue::Enum(idx, rev, arr) => {
-                let s = if arr.is_null() {
-                    rev.get(idx)
-                } else {
-                    unsafe { arr.deref_unchecked().value(idx as usize) }
-                };
-                s.into_value()
-            }
-            AnyValue::Date(v) => utils().funcall("_to_ruby_date", (v,)).unwrap(),
-            AnyValue::Datetime(v, time_unit, time_zone) => {
-                let time_unit = time_unit.to_ascii();
-                utils()
-                    .funcall("_to_ruby_datetime", (v, time_unit, time_zone.clone()))
-                    .unwrap()
-            }
-            AnyValue::Duration(v, time_unit) => {
-                let time_unit = time_unit.to_ascii();
-                utils()
-                    .funcall("_to_ruby_duration", (v, time_unit))
-                    .unwrap()
-            }
-            AnyValue::Time(v) => utils().funcall("_to_ruby_time", (v,)).unwrap(),
-            AnyValue::Array(v, _) | AnyValue::List(v) => RbSeries::new(v).to_a().into_value(),
-            ref av @ AnyValue::Struct(_, _, flds) => struct_dict(av._iter_struct_av(), flds),
-            AnyValue::StructOwned(payload) => struct_dict(payload.0.into_iter(), &payload.1),
-            AnyValue::Object(v) => {
-                let object = v.as_any().downcast_ref::<ObjectValue>().unwrap();
-                object.to_object()
-            }
-            AnyValue::ObjectOwned(v) => {
-                let object = v.0.as_any().downcast_ref::<ObjectValue>().unwrap();
-                object.to_object()
-            }
-            AnyValue::Binary(v) => RString::from_slice(v).into_value(),
-            AnyValue::BinaryOwned(v) => RString::from_slice(&v).into_value(),
-            AnyValue::Decimal(v, scale) => utils()
-                .funcall("_to_ruby_decimal", (v.to_string(), -(scale as i32)))
-                .unwrap(),
-        }
-    }
-}
-
-impl<'s> TryConvert for Wrap<AnyValue<'s>> {
-    fn try_convert(ob: Value) -> RbResult<Self> {
-        if ob.is_kind_of(class::true_class()) || ob.is_kind_of(class::false_class()) {
-            Ok(AnyValue::Boolean(bool::try_convert(ob)?).into())
-        } else if let Some(v) = Integer::from_value(ob) {
-            Ok(AnyValue::Int64(v.to_i64()?).into())
-        } else if let Some(v) = Float::from_value(ob) {
-            Ok(AnyValue::Float64(v.to_f64()).into())
-        } else if let Some(v) = RString::from_value(ob) {
-            if v.enc_get() == Index::utf8() {
-                Ok(AnyValue::StringOwned(v.to_string()?.into()).into())
-            } else {
-                Ok(AnyValue::BinaryOwned(unsafe { v.as_slice() }.to_vec()).into())
-            }
-        // call is_a? for ActiveSupport::TimeWithZone
-        } else if ob.funcall::<_, _, bool>("is_a?", (class::time(),))? {
-            let sec = ob.funcall::<_, _, i64>("to_i", ())?;
-            let nsec = ob.funcall::<_, _, i64>("nsec", ())?;
-            let v = sec * 1_000_000_000 + nsec;
-            // TODO support time zone when possible
-            // https://github.com/pola-rs/polars/issues/9103
-            Ok(AnyValue::Datetime(v, TimeUnit::Nanoseconds, &None).into())
-        } else if ob.is_nil() {
-            Ok(AnyValue::Null.into())
-        } else if let Some(dict) = RHash::from_value(ob) {
-            let len = dict.len();
-            let mut keys = Vec::with_capacity(len);
-            let mut vals = Vec::with_capacity(len);
-            dict.foreach(|k: Value, v: Value| {
-                let key = String::try_convert(k)?;
-                let val = Wrap::<AnyValue>::try_convert(v)?.0;
-                let dtype = DataType::from(&val);
-                keys.push(Field::new(&key, dtype));
-                vals.push(val);
-                Ok(ForEach::Continue)
-            })?;
-            Ok(Wrap(AnyValue::StructOwned(Box::new((vals, keys)))))
-        } else if let Some(v) = RArray::from_value(ob) {
-            if v.is_empty() {
-                Ok(Wrap(AnyValue::List(Series::new_empty("", &DataType::Null))))
-            } else {
-                let list = v;
-
-                let mut avs = Vec::with_capacity(25);
-                let mut iter = list.each();
-
-                for item in (&mut iter).take(25) {
-                    avs.push(Wrap::<AnyValue>::try_convert(item?)?.0)
-                }
-
-                let (dtype, _n_types) =
-                    any_values_to_supertype_and_n_dtypes(&avs).map_err(RbPolarsErr::from)?;
-
-                // push the rest
-                avs.reserve(list.len());
-                for item in iter {
-                    avs.push(Wrap::<AnyValue>::try_convert(item?)?.0)
-                }
-
-                let s = Series::from_any_values_and_dtype("", &avs, &dtype, true)
-                    .map_err(RbPolarsErr::from)?;
-                Ok(Wrap(AnyValue::List(s)))
-            }
-        } else if ob.is_kind_of(crate::rb_modules::datetime()) {
-            let sec: i64 = ob.funcall("to_i", ())?;
-            let nsec: i64 = ob.funcall("nsec", ())?;
-            Ok(Wrap(AnyValue::Datetime(
-                sec * 1_000_000_000 + nsec,
-                TimeUnit::Nanoseconds,
-                &None,
-            )))
-        } else if ob.is_kind_of(crate::rb_modules::date()) {
-            // convert to DateTime for UTC
-            let v = ob
-                .funcall::<_, _, Value>("to_datetime", ())?
-                .funcall::<_, _, Value>("to_time", ())?
-                .funcall::<_, _, i64>("to_i", ())?;
-            Ok(Wrap(AnyValue::Date((v / 86400) as i32)))
-        } else if ob.is_kind_of(crate::rb_modules::bigdecimal()) {
-            let (sign, digits, _, exp): (i8, String, i32, i32) = ob.funcall("split", ()).unwrap();
-            let (mut v, scale) = abs_decimal_from_digits(digits, exp).ok_or_else(|| {
-                RbPolarsErr::other("BigDecimal is too large to fit in Decimal128".into())
-            })?;
-            if sign < 0 {
-                // TODO better error
-                v = v.checked_neg().unwrap();
-            }
-            Ok(Wrap(AnyValue::Decimal(v, scale)))
-        } else {
-            Err(RbPolarsErr::other(format!(
-                "object type not supported {:?}",
-                ob
-            )))
-        }
-    }
-}
-
-fn abs_decimal_from_digits(digits: String, exp: i32) -> Option<(i128, usize)> {
-    let exp = exp - (digits.len() as i32);
-    match digits.parse::<i128>() {
-        Ok(mut v) => {
-            let scale = if exp > 0 {
-                v = 10_i128
-                    .checked_pow(exp as u32)
-                    .and_then(|factor| v.checked_mul(factor))?;
-                0
-            } else {
-                (-exp) as usize
-            };
-            Some((v, scale))
-        }
-        Err(_) => None,
-    }
-}