Float

Overview

Location

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


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) void

 

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: Memory<Float>): Memory<Float>

 

Memory<Float> Abs(Memory<Float> x)

 

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

 

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

 

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

Parameters:

  • x:

Acc

 

method Acc: Accuracy

 

Accuracy Acc()

 

func Acc() -> Accuracy

 

func Acc() Accuracy

 

Function Acc() As Accuracy

Add

 

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

 

Memory<Float> Add(Memory<Float> x, Memory<Float> y)

 

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

 

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

 

Function Add(x As Memory<Float>, y As Memory<Float>) As Memory<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: Memory<Float>): int

 

int Cmp(Memory<Float> y)

 

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

 

func Cmp(y Memory<Float>) int

 

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

Parameters:

  • y:

Copy

 

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

 

Memory<Float> Copy(Memory<Float> x)

 

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

 

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

 

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

Parameters:

  • x:

Float32

 

method Float32: tuple of (Single, Accuracy)

 

(Single, Accuracy) Float32()

 

func Float32() -> (Single, Accuracy)

 

func Float32() tuple of (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() tuple of (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) void

 

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() tuple of (Slice<Byte>, error)

 

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

Int

 

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

 

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

 

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

 

func Int(z Memory<Int>) tuple of (Memory<Int>, Accuracy)

 

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

Parameters:

  • z:

Int64

 

method Int64: tuple of (int64, Accuracy)

 

(int64, Accuracy) Int64()

 

func Int64() -> (int64, Accuracy)

 

func Int64() tuple of (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: Memory<Float>): int

 

int MantExp(Memory<Float> mant)

 

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

 

func MantExp(mant Memory<Float>) int

 

Function MantExp(mant As Memory<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() tuple of (|name=text| Slice<Byte>, |name=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: Memory<Float>; y: Memory<Float>): Memory<Float>

 

Memory<Float> Mul(Memory<Float> x, Memory<Float> y)

 

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

 

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

 

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

Parameters:

  • x:
  • y:

Neg

 

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

 

Memory<Float> Neg(Memory<Float> x)

 

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

 

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

 

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

Parameters:

  • x:

Parse

 

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

 

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

 

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

 

func Parse(s string, base int) tuple of (|name=f| Memory<Float>, |name=b| Int64, |name=err| error)

 

Function Parse(s As string, base As int) As Tuple (Of Memory<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: Memory<Float>; y: Memory<Float>): Memory<Float>

 

Memory<Float> Quo(Memory<Float> x, Memory<Float> y)

 

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

 

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

 

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

Parameters:

  • x:
  • y:

Rat

 

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

 

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

 

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

 

func Rat(z Memory<Rat>) tuple of (Memory<Rat>, Accuracy)

 

Function Rat(z As Memory<Rat>) As Tuple (Of Memory<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: Memory<Float>): Memory<Float>

 

Memory<Float> Set(Memory<Float> x)

 

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

 

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

 

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

Parameters:

  • x:

SetFloat64

 

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

 

Memory<Float> SetFloat64(float64 x)

 

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

 

func SetFloat64(x float64) Memory<Float>

 

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

Parameters:

  • x:

SetInf

 

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

 

Memory<Float> SetInf(bool signbit)

 

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

 

func SetInf(signbit bool) Memory<Float>

 

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

Parameters:

  • signbit:

SetInt

 

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

 

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

 

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

 

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

 

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

Parameters:

  • x:

SetInt64

 

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

 

Memory<Float> SetInt64(int64 x)

 

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

 

func SetInt64(x int64) Memory<Float>

 

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

Parameters:

  • x:

SetMantExp

 

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

 

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

 

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

 

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

 

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

Parameters:

  • mant:
  • exp:

SetMode

 

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

 

Memory<Float> SetMode(RoundingMode mode)

 

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

 

func SetMode(mode RoundingMode) Memory<Float>

 

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

Parameters:

  • mode:

SetPrec

 

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

 

Memory<Float> SetPrec(uint prec)

 

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

 

func SetPrec(prec uint) Memory<Float>

 

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

Parameters:

  • prec:

SetRat

 

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

 

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

 

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

 

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

 

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

Parameters:

  • x:

SetString

 

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

 

(Memory<Float>, Boolean) SetString(string s)

 

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

 

func SetString(s string) tuple of (Memory<Float>, Boolean)

 

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

Parameters:

  • s:

SetUint64

 

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

 

Memory<Float> SetUint64(uint64 x)

 

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

 

func SetUint64(x uint64) Memory<Float>

 

Function SetUint64(x As uint64) As Memory<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: Memory<Float>): Memory<Float>

 

Memory<Float> Sqrt(Memory<Float> x)

 

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

 

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

 

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

Parameters:

  • x:

String

 

method String: string

 

string String()

 

func String() -> string

 

func String() string

 

Function String() As string

Sub

 

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

 

Memory<Float> Sub(Memory<Float> x, Memory<Float> y)

 

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

 

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

 

Function Sub(x As Memory<Float>, y As Memory<Float>) As Memory<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() tuple of (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:

 

Implements