Float

Overview

Location

  • Reference: Go.fx
  • Namespace: go.math.big
  • Platforms: Island

Implements

Instance Methods


constructor

 

constructor

 

Float()

 

init()

 

Sub New()

constructor (Float)

 

constructor(value: Float)

 

Float(Float value)

 

init(_ value: Float)

 

Sub New(value As Float)

Parameters:

  • value:

Format (State, rune)

 

method Format(s: State; format: rune)

 

void Format(State s, rune format)

 

func Format(_ s: State, _ format: rune)

 

func Format(s State, format rune)

 

Sub Format(s As State, format As rune)

Parameters:

  • s:
  • format:

Scan (ScanState, rune): error

 

method Scan(s: ScanState; ch: rune): error

 

error Scan(ScanState s, rune ch)

 

func Scan(_ s: ScanState, _ ch: rune) -> error

 

func Scan(s ScanState, ch rune) error

 

Function Scan(s As ScanState, ch As rune) As error

Parameters:

  • s:
  • ch:

Abs

 

method Abs(x: Reference<Float>): Reference<Float>

 

func Abs(_ x: Reference<Float>) -> Reference<Float>

 

func Abs(x Reference<Float>) Reference<Float>

 

Function Abs(x As Reference<Float>) As Reference<Float>

Parameters:

  • x:

Acc

 

method Acc: Accuracy

 

Accuracy Acc()

 

func Acc() -> Accuracy

 

func Acc() Accuracy

 

Function Acc() As Accuracy

Add

 

method Add(x: Reference<Float>; y: Reference<Float>): Reference<Float>

 

func Add(_ x: Reference<Float>, _ y: Reference<Float>) -> Reference<Float>

 

func Add(x Reference<Float>, y Reference<Float>) Reference<Float>

 

Function Add(x As Reference<Float>, y As Reference<Float>) As Reference<Float>

Parameters:

  • x:
  • y:

Append

 

method Append(buf: Slice<Byte>; fmt: byte; prec: int): Slice<Byte>

 

Slice<Byte> Append(Slice<Byte> buf, byte fmt, int prec)

 

func Append(_ buf: Slice<Byte>, _ fmt: byte, _ prec: int) -> Slice<Byte>

 

func Append(buf Slice<Byte>, fmt byte, prec int) Slice<Byte>

 

Function Append(buf As Slice<Byte>, fmt As byte, prec As int) As Slice<Byte>

Parameters:

  • buf:
  • fmt:
  • prec:

Cmp

 

method Cmp(y: Reference<Float>): int

 

int Cmp(Reference<Float> y)

 

func Cmp(_ y: Reference<Float>) -> int

 

func Cmp(y Reference<Float>) int

 

Function Cmp(y As Reference<Float>) As int

Parameters:

  • y:

Copy

 

method Copy(x: Reference<Float>): Reference<Float>

 

func Copy(_ x: Reference<Float>) -> Reference<Float>

 

func Copy(x Reference<Float>) Reference<Float>

 

Function Copy(x As Reference<Float>) As Reference<Float>

Parameters:

  • x:

Float32

 

method Float32: tuple of (Single, Accuracy)

 

(Single, Accuracy) Float32()

 

func Float32() -> (Single, Accuracy)

 

func Float32() (Single, Accuracy)

 

Function Float32() As Tuple (Of Single, Accuracy)

Float64

 

method Float64: tuple of (Double, Accuracy)

 

(Double, Accuracy) Float64()

 

func Float64() -> (Double, Accuracy)

 

func Float64() (Double, Accuracy)

 

Function Float64() As Tuple (Of Double, Accuracy)

Format (State, rune)

 

method Format(s: State; format: rune)

 

void Format(State s, rune format)

 

func Format(_ s: State, _ format: rune)

 

func Format(s State, format rune)

 

Sub Format(s As State, format As rune)

Parameters:

  • s:
  • format:

GobDecode

 

method GobDecode(buf: Slice<Byte>): error

 

error GobDecode(Slice<Byte> buf)

 

func GobDecode(_ buf: Slice<Byte>) -> error

 

func GobDecode(buf Slice<Byte>) error

 

Function GobDecode(buf As Slice<Byte>) As error

Parameters:

  • buf:

GobEncode

 

method GobEncode: tuple of (Slice<Byte>, error)

 

(Slice<Byte>, error) GobEncode()

 

func GobEncode() -> (Slice<Byte>, error)

 

func GobEncode() (Slice<Byte>, error)

 

Function GobEncode() As Tuple (Of Slice<Byte>, error)

Int

 

method Int(z: Reference<Int>): tuple of (Int, Accuracy)

 

(Int, Accuracy) Int(Reference<Int> z)

 

func Int(_ z: Reference<Int>) -> (Int, Accuracy)

 

func Int(z Reference<Int>) (Int, Accuracy)

 

Function Int(z As Reference<Int>) As Tuple (Of Int, Accuracy)

Parameters:

  • z:

Int64

 

method Int64: tuple of (int64, Accuracy)

 

(int64, Accuracy) Int64()

 

func Int64() -> (int64, Accuracy)

 

func Int64() (int64, Accuracy)

 

Function Int64() As Tuple (Of int64, Accuracy)

IsInf

 

method IsInf: bool

 

bool IsInf()

 

func IsInf() -> bool

 

func IsInf() bool

 

Function IsInf() As bool

IsInt

 

method IsInt: bool

 

bool IsInt()

 

func IsInt() -> bool

 

func IsInt() bool

 

Function IsInt() As bool

MantExp

 

method MantExp(mant: Reference<Float>): int

 

int MantExp(Reference<Float> mant)

 

func MantExp(_ mant: Reference<Float>) -> int

 

func MantExp(mant Reference<Float>) int

 

Function MantExp(mant As Reference<Float>) As int

Parameters:

  • mant:

MarshalText

 

method MarshalText: tuple of (text: Slice<Byte>, err: error)

 

(Slice<Byte>text, error err) MarshalText()

 

func MarshalText() -> (Slice<Byte>, error)

 

func MarshalText() (text Slice<Byte>, err error)

 

Function MarshalText() As Tuple (Of Slice<Byte>, error)

MinPrec

 

method MinPrec: uint

 

uint MinPrec()

 

func MinPrec() -> uint

 

func MinPrec() uint

 

Function MinPrec() As uint

Mode

 

method Mode: RoundingMode

 

RoundingMode Mode()

 

func Mode() -> RoundingMode

 

func Mode() RoundingMode

 

Function Mode() As RoundingMode

Mul

 

method Mul(x: Reference<Float>; y: Reference<Float>): Reference<Float>

 

func Mul(_ x: Reference<Float>, _ y: Reference<Float>) -> Reference<Float>

 

func Mul(x Reference<Float>, y Reference<Float>) Reference<Float>

 

Function Mul(x As Reference<Float>, y As Reference<Float>) As Reference<Float>

Parameters:

  • x:
  • y:

Neg

 

method Neg(x: Reference<Float>): Reference<Float>

 

func Neg(_ x: Reference<Float>) -> Reference<Float>

 

func Neg(x Reference<Float>) Reference<Float>

 

Function Neg(x As Reference<Float>) As Reference<Float>

Parameters:

  • x:

Parse

 

method Parse(s: string; base: int): tuple of (f: Float, b: Int64, err: error)

 

(Float f, Int64 b, error err) Parse(string s, int base)

 

func Parse(_ s: string, _ base: int) -> (Float, Int64, error)

 

func Parse(s string, base int) (f Float, b Int64, err error)

 

Function Parse(s As string, base As int) As Tuple (Of Float, Int64, error)

Parameters:

  • s:
  • base:

Prec

 

method Prec: uint

 

uint Prec()

 

func Prec() -> uint

 

func Prec() uint

 

Function Prec() As uint

Quo

 

method Quo(x: Reference<Float>; y: Reference<Float>): Reference<Float>

 

func Quo(_ x: Reference<Float>, _ y: Reference<Float>) -> Reference<Float>

 

func Quo(x Reference<Float>, y Reference<Float>) Reference<Float>

 

Function Quo(x As Reference<Float>, y As Reference<Float>) As Reference<Float>

Parameters:

  • x:
  • y:

Rat

 

method Rat(z: Reference<Rat>): tuple of (Rat, Accuracy)

 

(Rat, Accuracy) Rat(Reference<Rat> z)

 

func Rat(_ z: Reference<Rat>) -> (Rat, Accuracy)

 

func Rat(z Reference<Rat>) (Rat, Accuracy)

 

Function Rat(z As Reference<Rat>) As Tuple (Of Rat, Accuracy)

Parameters:

  • z:

Scan (ScanState, rune): error

 

method Scan(s: ScanState; ch: rune): error

 

error Scan(ScanState s, rune ch)

 

func Scan(_ s: ScanState, _ ch: rune) -> error

 

func Scan(s ScanState, ch rune) error

 

Function Scan(s As ScanState, ch As rune) As error

Parameters:

  • s:
  • ch:

Set

 

method Set(x: Reference<Float>): Reference<Float>

 

func Set(_ x: Reference<Float>) -> Reference<Float>

 

func Set(x Reference<Float>) Reference<Float>

 

Function Set(x As Reference<Float>) As Reference<Float>

Parameters:

  • x:

SetFloat64

 

method SetFloat64(x: float64): Reference<Float>

 

Reference<Float> SetFloat64(float64 x)

 

func SetFloat64(_ x: float64) -> Reference<Float>

 

func SetFloat64(x float64) Reference<Float>

 

Function SetFloat64(x As float64) As Reference<Float>

Parameters:

  • x:

SetInf

 

method SetInf(signbit: bool): Reference<Float>

 

Reference<Float> SetInf(bool signbit)

 

func SetInf(_ signbit: bool) -> Reference<Float>

 

func SetInf(signbit bool) Reference<Float>

 

Function SetInf(signbit As bool) As Reference<Float>

Parameters:

  • signbit:

SetInt

 

method SetInt(x: Reference<Int>): Reference<Float>

 

Reference<Float> SetInt(Reference<Int> x)

 

func SetInt(_ x: Reference<Int>) -> Reference<Float>

 

func SetInt(x Reference<Int>) Reference<Float>

 

Function SetInt(x As Reference<Int>) As Reference<Float>

Parameters:

  • x:

SetInt64

 

method SetInt64(x: int64): Reference<Float>

 

Reference<Float> SetInt64(int64 x)

 

func SetInt64(_ x: int64) -> Reference<Float>

 

func SetInt64(x int64) Reference<Float>

 

Function SetInt64(x As int64) As Reference<Float>

Parameters:

  • x:

SetMantExp

 

method SetMantExp(mant: Reference<Float>; exp: int): Reference<Float>

 

Reference<Float> SetMantExp(Reference<Float> mant, int exp)

 

func SetMantExp(_ mant: Reference<Float>, _ exp: int) -> Reference<Float>

 

func SetMantExp(mant Reference<Float>, exp int) Reference<Float>

 

Function SetMantExp(mant As Reference<Float>, exp As int) As Reference<Float>

Parameters:

  • mant:
  • exp:

SetMode

 

method SetMode(mode: RoundingMode): Reference<Float>

 

Reference<Float> SetMode(RoundingMode mode)

 

func SetMode(_ mode: RoundingMode) -> Reference<Float>

 

func SetMode(mode RoundingMode) Reference<Float>

 

Function SetMode(mode As RoundingMode) As Reference<Float>

Parameters:

  • mode:

SetPrec

 

method SetPrec(prec: uint): Reference<Float>

 

Reference<Float> SetPrec(uint prec)

 

func SetPrec(_ prec: uint) -> Reference<Float>

 

func SetPrec(prec uint) Reference<Float>

 

Function SetPrec(prec As uint) As Reference<Float>

Parameters:

  • prec:

SetRat

 

method SetRat(x: Reference<Rat>): Reference<Float>

 

Reference<Float> SetRat(Reference<Rat> x)

 

func SetRat(_ x: Reference<Rat>) -> Reference<Float>

 

func SetRat(x Reference<Rat>) Reference<Float>

 

Function SetRat(x As Reference<Rat>) As Reference<Float>

Parameters:

  • x:

SetString

 

method SetString(s: string): tuple of (Float, Boolean)

 

(Float, Boolean) SetString(string s)

 

func SetString(_ s: string) -> (Float, Boolean)

 

func SetString(s string) (Float, Boolean)

 

Function SetString(s As string) As Tuple (Of Float, Boolean)

Parameters:

  • s:

SetUint64

 

method SetUint64(x: uint64): Reference<Float>

 

Reference<Float> SetUint64(uint64 x)

 

func SetUint64(_ x: uint64) -> Reference<Float>

 

func SetUint64(x uint64) Reference<Float>

 

Function SetUint64(x As uint64) As Reference<Float>

Parameters:

  • x:

Sign

 

method Sign: int

 

int Sign()

 

func Sign() -> int

 

func Sign() int

 

Function Sign() As int

Signbit

 

method Signbit: bool

 

bool Signbit()

 

func Signbit() -> bool

 

func Signbit() bool

 

Function Signbit() As bool

Sqrt

 

method Sqrt(x: Reference<Float>): Reference<Float>

 

func Sqrt(_ x: Reference<Float>) -> Reference<Float>

 

func Sqrt(x Reference<Float>) Reference<Float>

 

Function Sqrt(x As Reference<Float>) As Reference<Float>

Parameters:

  • x:

String

 

method String: string

 

string String()

 

func String() -> string

 

func String() string

 

Function String() As string

Sub

 

method Sub(x: Reference<Float>; y: Reference<Float>): Reference<Float>

 

func Sub(_ x: Reference<Float>, _ y: Reference<Float>) -> Reference<Float>

 

func Sub(x Reference<Float>, y Reference<Float>) Reference<Float>

 

Function Sub(x As Reference<Float>, y As Reference<Float>) As Reference<Float>

Parameters:

  • x:
  • y:

Text

 

method Text(format: byte; prec: int): string

 

string Text(byte format, int prec)

 

func Text(_ format: byte, _ prec: int) -> string

 

func Text(format byte, prec int) string

 

Function Text(format As byte, prec As int) As string

Parameters:

  • format:
  • prec:

Uint64

 

method Uint64: tuple of (uint64, Accuracy)

 

(uint64, Accuracy) Uint64()

 

func Uint64() -> (uint64, Accuracy)

 

func Uint64() (uint64, Accuracy)

 

Function Uint64() As Tuple (Of uint64, Accuracy)

UnmarshalText

 

method UnmarshalText(text: Slice<Byte>): error

 

error UnmarshalText(Slice<Byte> text)

 

func UnmarshalText(_ text: Slice<Byte>) -> error

 

func UnmarshalText(text Slice<Byte>) error

 

Function UnmarshalText(text As Slice<Byte>) As error

Parameters:

  • text: