Полная, эффективная реализация модуля NumericLiteral

Основываясь на обсуждении в этом вопросе, может ли кто-либо предоставить код или ссылку на код, демонстрируя полную реализацию модуля NumericLiteralX (например, этот)? Меня особенно интересует эффективная реализация FromInt32/64 для модуля NumericLiteralX, который облегчает общие числовые операции. Здесь возможно неэффективная реализация, взятая из вышеупомянутого вопроса:

module NumericLiteralG = 
    let inline FromZero() = LanguagePrimitives.GenericZero
    let inline FromOne() = LanguagePrimitives.GenericOne
    let inline FromInt32 (n:int) =
        let one : ^a = FromOne()
        let zero : ^a = FromZero()
        let n_incr = if n > 0 then 1 else -1
        let g_incr = if n > 0 then one else (zero - one)
        let rec loop i g = 
            if i = n then g
            else loop (i + n_incr) (g + g_incr)
        loop 0 zero

Как это можно улучшить и завершить?

ОТВЕТЫ

Ответ 1

Я просто отправлю FromInt32. В идеальном мире мы могли бы определить его просто как

let inline FromInt32 i = 
  ((^t or int) : (static member op_Explicit : int -> ^t) i)

который использовал бы статические ограничения, чтобы обеспечить явное преобразование из int. К сожалению, есть две проблемы. Во-первых, синтаксис недействителен - вы не можете иметь конкретный тип (например, int) в разделе "static-typars" ограничения члена. Мы можем обойти это, определив вспомогательную функцию

let inline cvt i = ((^t or ^u) : (static member op_Explicit : ^u -> ^t) i)
let inline FromInt32 (i:int) = cvt i

Поскольку обе эти функции встроены, это не менее эффективно, чем первая попытка, это просто слово.

Здесь, где мы сталкиваемся со второй проблемой: это будет работать для реальных определений op_Explicit (или op_Implicit, которые обрабатываются специально компилятором, чтобы он был включен op_Explicit). Итак, (10G : bigint) будет вложен так, как если бы вы написали System.Numerics.BigInt.op_Implicit 10, что так же эффективно, как мы можем надеяться. Однако F # также имитирует op_Explicit для многих примитивных типов (например, для преобразований от int до float, byte и т.д.), А так как определение FromInt32 основывается на существовании этих членов, оно будет сбой во время выполнения (т.е. (10G : float) и даже (10G : int) будет компилироваться, но будет генерировать исключение при выполнении). В идеале будущая версия F # может позволить этому работать как есть, но с F # 2.0 нам нужно придумать обходной путь.

Было бы неплохо, если бы мы могли использовать аналогичный подход к тому, как основная библиотека F # справляется с такой проблемой, что потребует специальной оболочки всех подразумеваемых операторов, но приведет к тому, что все будет встроено с максимальной эффективностью:

let inline FromInt32 (i : int) : ^t =
  cvt i
  when ^t : int   = int i
  when ^t : float = float i
  when ^t : byte  = byte i
  ...

Однако компилятор F # отклоняет это сообщение с "Static optimization conditionals are only for use within the F# library" (а компиляция с секретным флагом --compiling-fslib только ухудшает ситуацию:)).

Вместо этого нам нужно использовать несколько дополнительных слоев косвенности для достижения чего-то подобного во время выполнения. Во-первых, мы создадим сопоставление типов во время выполнения с функциями преобразования с помощью статического члена родового типа:

type IntConverterDynamicImplTable<'t>() =
  static let result : int -> 't =
    let ty = typeof< 't> //'
    if   ty.Equals(typeof<sbyte>)      then sbyte      |> box |> unbox
    elif ty.Equals(typeof<int16>)      then int16      |> box |> unbox
    elif ty.Equals(typeof<int32>)      then int        |> box |> unbox
    elif ty.Equals(typeof<int64>)      then int64      |> box |> unbox
    elif ty.Equals(typeof<nativeint>)  then nativeint  |> box |> unbox
    elif ty.Equals(typeof<byte>)       then byte       |> box |> unbox
    elif ty.Equals(typeof<uint16>)     then uint16     |> box |> unbox
    elif ty.Equals(typeof<char>)       then char       |> box |> unbox
    elif ty.Equals(typeof<uint32>)     then uint32     |> box |> unbox
    elif ty.Equals(typeof<uint64>)     then uint64     |> box |> unbox
    elif ty.Equals(typeof<unativeint>) then unativeint |> box |> unbox
    elif ty.Equals(typeof<decimal>)    then decimal    |> box |> unbox
    elif ty.Equals(typeof<float>)      then float      |> box |> unbox
    elif ty.Equals(typeof<float32>)    then float32    |> box |> unbox
    else 
      let m = 
        try ty.GetMethod("op_Implicit", [| typeof<int> |])
        with _ -> ty.GetMethod("op_Explicit", [| typeof<int> |])
      let del =
        System.Delegate.CreateDelegate(typeof<System.Func<int,'t>>, m)
        :?> System.Func<int,'t>
      del.Invoke |> box |> unbox
  static member Result = result

Это похоже на то, что мы пытались достичь с помощью статических условий оптимизации в предыдущей попытке, но откладывается на время выполнения вместо всего, что оценивается во время компиляции. Теперь нам просто нужно определить несколько значений для использования этого типа:

let inline constrain< ^t, ^u when (^t or ^u) : (static member op_Explicit : ^t -> ^u)> () = ()
let inline FromInt32 i : ^t = 
  constrain<int, ^t>()
  IntConverterDynamicImplTable.Result i

Здесь функция constrain используется только для проверки того, что FromInt32 может применяться только к типам, где есть явное преобразование из int (или имитируется компилятором). Фактический вызов constrain() внутри FromInt32 должен быть оптимизирован во время компиляции.

При таком подходе (10G : bigint) будет скомпилирован примерно как IntConverterDynamicImplTable<bigint>.Result 10, а IntConverterDynamicTable<bigint>.Result будет иметь значение, эквивалентное (System.Func<int,bigint>(bigint.op_Implicit)).Invoke (но кэшируется, так что делегат создается только один раз). Точно так же (10G : int64) будет компилироваться в IntConverterDynamicImplTable<int64>.Result 10, а IntConverterDynamicTable<int64>.Result будет иметь значение, эквивалентное функции преобразования (int64 : int -> int64), поэтому есть накладные расходы на несколько вызовов методов, но общая производительность должна быть очень хорошей.

ИЗМЕНИТЬ

Однако, если вы просто ищете что-то более эффективное, чем наивные реализации FromInt32 и FromInt64, занимающие время O (n), здесь версия, которая по-прежнему относительно проста и принимает только O (log n) время:

module SymmetricOps =
  let inline (~-) (x:'a) : 'a = -x
  let inline (+) (x:'a) (y:'a) : 'a = x + y
  let inline (-) (x:'a) (y:'a) : 'a = x - y
  let inline (*) (x:'a) (y:'a) : 'a = x * y
  let inline (/) (x:'a) (y:'a) : 'a = x / y
  let inline (%) (x:'a) (y:'a) : 'a = x % y

module NumericLiteralG = 
  open SymmetricOps
  let inline FromOne() = LanguagePrimitives.GenericOne
  let inline FromZero() = LanguagePrimitives.GenericZero
  let rec compute zero one two (/) (%) Two (+) (-) (*) pow2 rest n =
    if n = zero then rest
    else 
      let rest' =
        let nmod2 = n % two
        if nmod2 = zero then rest
        elif nmod2 = one then rest + pow2
        else rest - pow2
      compute zero one two (/) (%) Two (+) (-) (*) (Two * pow2) rest' (n / two)
  let inline FromInt32 i = compute 0  1  2  (/) (%) (FromOne() + FromOne()) (+) (-) (*) (FromOne()) (FromZero()) i
  let inline FromInt64 i = compute 0L 1L 2L (/) (%) (FromOne() + FromOne()) (+) (-) (*) (FromOne()) (FromZero()) i