onelang/packages/implementations/OneLang-BigInteger-Native-v0.1/package.yaml

OneLang transpiler framework core

file-version: 1
vendor: OneLang
name: BigInteger-Native
description: "Implements One.BigInteger via native platform implementation (where available)"
version: 0.1
implements:
  - interface: { name: One.BigInteger, minver: 0.1, maxver: 0.1 }
    language: csharp
    implementation:
      classes:
        OneBigInteger:
          type: "BigInteger"
          includes: [System.Numerics]
          methods:
            fromInt: "new BigInteger({{value}})"

  - interface: { name: One.BigInteger, minver: 0.1, maxver: 0.1 }
    language: go
    implementation:
      classes:
        OneBigInteger:
          type: "big.Int"
          includes: [math/big, one]
          methods:
            fromInt: "big.NewInt({{value}})"
      operators:
        OneBigInteger + OneBigInteger:  "one.BI().Add({{left}}, {{right}})"
        OneBigInteger - OneBigInteger:  "one.BI().Sub({{left}}, {{right}})"
        OneBigInteger * OneBigInteger:  "one.BI().Mul({{left}}, {{right}})"
        OneBigInteger / OneBigInteger:  "one.BI().Div({{left}}, {{right}})"
        OneBigInteger % OneBigInteger:  "one.BI().Mod({{left}}, {{right}})"
        #OneBigInteger << OneBigInteger: "one.BI().Lsh({{left}}, {{right}})"
        #OneBigInteger >> OneBigInteger: "one.BI().Rsh({{left}}, {{right}})"
        OneBigInteger > OneBigInteger:  "({{left}}).Cmp({{right}}) > 0"
        OneBigInteger < OneBigInteger:  "({{left}}).Cmp({{right}}) < 0"
        OneBigInteger >= OneBigInteger: "({{left}}).Cmp({{right}}) >= 0"
        OneBigInteger <= OneBigInteger: "({{left}}).Cmp({{right}}) <= 0"
        OneBigInteger == OneBigInteger: "({{left}}).Cmp({{right}}) == 0"
        OneBigInteger != OneBigInteger: "({{left}}).Cmp({{right}}) != 0"
        OneBigInteger & OneBigInteger:  "one.BI().And({{left}}, {{right}})"
        OneBigInteger | OneBigInteger:  "one.BI().Or({{left}}, {{right}})"
        OneBigInteger ^ OneBigInteger:  "one.BI().Xor({{left}}, {{right}})"
          
        OneBigInteger + OneNumber:  "one.BI().Add({{left}}, big.NewInt(int64({{right}})))"
        OneBigInteger - OneNumber:  "one.BI().Sub({{left}}, big.NewInt(int64({{right}})))"
        OneBigInteger * OneNumber:  "one.BI().Mul({{left}}, big.NewInt(int64({{right}})))"
        OneBigInteger / OneNumber:  "one.BI().Div({{left}}, big.NewInt(int64({{right}})))"
        OneBigInteger % OneNumber:  "one.BI().Mod({{left}}, big.NewInt(int64({{right}})))"
        OneBigInteger << OneNumber: "one.BI().Lsh({{left}}, {{right}})"
        OneBigInteger >> OneNumber: "one.BI().Rsh({{left}}, {{right}})"
        OneBigInteger > OneNumber:  "({{left}}).Cmp(big.NewInt(int64({{right}}))) > 0"
        OneBigInteger < OneNumber:  "({{left}}).Cmp(big.NewInt(int64({{right}}))) < 0"
        OneBigInteger >= OneNumber: "({{left}}).Cmp(big.NewInt(int64({{right}}))) >= 0"
        OneBigInteger <= OneNumber: "({{left}}).Cmp(big.NewInt(int64({{right}}))) <= 0"
        OneBigInteger == OneNumber: "({{left}}).Cmp(big.NewInt(int64({{right}}))) == 0"
        OneBigInteger != OneNumber: "({{left}}).Cmp(big.NewInt(int64({{right}}))) != 0"
        OneBigInteger & OneNumber:  "one.BI().And({{left}}, big.NewInt(int64({{right}})))"
        OneBigInteger | OneNumber:  "one.BI().Or({{left}}, big.NewInt(int64({{right}})))"
        OneBigInteger ^ OneNumber:  "one.BI().Xor({{left}}, big.NewInt(int64({{right}})))"

  - interface: { name: One.BigInteger, minver: 0.1, maxver: 0.1 }
    language: java
    implementation:
      classes:
        OneBigInteger:
          type: "BigInteger"
          includes: [java.math.BigInteger]
          methods:
            fromInt: "BigInteger.valueOf({{value}})"
      operators:
        OneBigInteger + OneBigInteger:  "{{left}}.add({{right}})"
        OneBigInteger - OneBigInteger:  "{{left}}.subtract({{right}})"
        OneBigInteger * OneBigInteger:  "{{left}}.multiply({{right}})"
        OneBigInteger / OneBigInteger:  "{{left}}.divide({{right}})"
        OneBigInteger % OneBigInteger:  "{{left}}.mod({{right}})"
        OneBigInteger << OneBigInteger: "{{left}}.shiftLeft(({{right}}).intValue())"
        OneBigInteger >> OneBigInteger: "{{left}}.shiftRight(({{right}}).intValue())"
        OneBigInteger > OneBigInteger:  "{{left}}.compareTo({{right}}) > 0"
        OneBigInteger < OneBigInteger:  "{{left}}.compareTo({{right}}) < 0"
        OneBigInteger >= OneBigInteger: "{{left}}.compareTo({{right}}) >= 0"
        OneBigInteger <= OneBigInteger: "{{left}}.compareTo({{right}}) <= 0"
        OneBigInteger == OneBigInteger: "{{left}}.compareTo({{right}}) == 0"
        OneBigInteger != OneBigInteger: "{{left}}.compareTo({{right}}) != 0"
        OneBigInteger & OneBigInteger:  "{{left}}.and({{right}})"
        OneBigInteger | OneBigInteger:  "{{left}}.or({{right}})"
        OneBigInteger ^ OneBigInteger:  "{{left}}.xor({{right}})"

        OneBigInteger + OneNumber:  "{{left}}.add(BigInteger.valueOf({{right}}))"
        OneBigInteger - OneNumber:  "{{left}}.subtract(BigInteger.valueOf({{right}}))"
        OneBigInteger * OneNumber:  "{{left}}.multiply(BigInteger.valueOf({{right}}))"
        OneBigInteger / OneNumber:  "{{left}}.divide(BigInteger.valueOf({{right}}))"
        OneBigInteger % OneNumber:  "{{left}}.mod(BigInteger.valueOf({{right}}))"
        OneBigInteger << OneNumber: "{{left}}.shiftLeft({{right}})"
        OneBigInteger >> OneNumber: "{{left}}.shiftRight({{right}})"
        OneBigInteger > OneNumber:  "{{left}}.compareTo(BigInteger.valueOf({{right}})) > 0"
        OneBigInteger < OneNumber:  "{{left}}.compareTo(BigInteger.valueOf({{right}})) < 0"
        OneBigInteger >= OneNumber: "{{left}}.compareTo(BigInteger.valueOf({{right}})) >= 0"
        OneBigInteger <= OneNumber: "{{left}}.compareTo(BigInteger.valueOf({{right}})) <= 0"
        OneBigInteger == OneNumber: "{{left}}.compareTo(BigInteger.valueOf({{right}})) == 0"
        OneBigInteger != OneNumber: "{{left}}.compareTo(BigInteger.valueOf({{right}})) != 0"
        OneBigInteger & OneNumber:  "{{left}}.and(BigInteger.valueOf({{right}}))"
        OneBigInteger | OneNumber:  "{{left}}.or(BigInteger.valueOf({{right}}))"
        OneBigInteger ^ OneNumber:  "{{left}}.xor(BigInteger.valueOf({{right}}))"

  - interface: { name: One.BigInteger, minver: 0.1, maxver: 0.1 }
    language: perl
    implementation:
      classes:
        OneBigInteger:
          includes: [bigint]
          methods:
            fromInt:
              template: "{{value}}"

  - interface: { name: One.BigInteger, minver: 0.1, maxver: 0.1 }
    language: python
    implementation:
      classes:
        OneBigInteger:
          methods:
            fromInt: "{{value}}"

  - interface: { name: One.BigInteger, minver: 0.1, maxver: 0.1 }
    language: ruby
    implementation:
      classes:
        OneBigInteger:
          methods:
            fromInt: "{{value}}"