text: golang.org/x/text/internal/number Index | Files

package number

import "golang.org/x/text/internal/number"

Package number contains tools and data for formatting numbers.

Index

Package Files

common.go decimal.go format.go number.go pattern.go roundingmode_string.go tables.go

Constants

const CLDRVersion = "31"

CLDRVersion is the CLDR version from which the tables in this package are derived.

type Converter Uses

type Converter interface {
    Convert(d *Decimal, r *RoundingContext)
}

A Converter converts a number into decimals according to the given rounding criteria.

type Decimal Uses

type Decimal struct {
    Digits []byte // mantissa digits, big-endian
    Exp    int32  // exponent
    // End indicates the end position of the number.
    End int32 // For decimals Exp <= End. For scientific len(Digits) <= End.
    // Comma is used for the comma position for scientific (always 0 or 1) and
    // engineering notation (always 0, 1, 2, or 3).
    Comma uint8

    Neg bool
    Inf bool // Takes precedence over Digits and Exp.
    NaN bool // Takes precedence over Inf.
    // contains filtered or unexported fields
}

A Decimal represents floating point number represented in digits of the base in which a number is to be displayed. Digits represents a number [0, 1.0), and the absolute value represented by Decimal is Digits * 10^Exp. Leading and trailing zeros may be omitted and Exp may point outside a valid position in Digits.

Examples:

  Number     Decimal
decimal
  12345      Digits: [1, 2, 3, 4, 5], Exp: 5  End: 5
  12.345     Digits: [1, 2, 3, 4, 5], Exp: 2  End: 5
  12000      Digits: [1, 2],          Exp: 5  End: 5
  12000.00   Digits: [1, 2],          Exp: 5  End: 7
  0.00123    Digits: [1, 2, 3],       Exp: -2 End: 3
  0          Digits: [],              Exp: 0  End: 1
scientific:
  0          Digits: [],              Exp: 0, End: 1, Comma: 0
  1.23e4     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 1
engineering
  12.3e3     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 2

func (*Decimal) Convert Uses

func (d *Decimal) Convert(r *RoundingContext, number interface{})

Convert converts the given number to the decimal representation using the supplied RoundingContext.

func (*Decimal) ConvertFloat Uses

func (d *Decimal) ConvertFloat(r *RoundingContext, x float64, size int)

ConvertFloat converts a floating point number to decimals.

func (*Decimal) ConvertInt Uses

func (d *Decimal) ConvertInt(r *RoundingContext, signed bool, x uint64)

ConvertInt converts an integer to decimals.

func (*Decimal) String Uses

func (x *Decimal) String() string

type Formatter Uses

type Formatter struct {
    Pattern
    Info
    RoundingContext
}

Formatter contains all the information needed to render a number.

func (*Formatter) Append Uses

func (f *Formatter) Append(dst []byte, x interface{}) []byte

func (*Formatter) Format Uses

func (f *Formatter) Format(dst []byte, d *Decimal) []byte

func (*Formatter) InitDecimal Uses

func (f *Formatter) InitDecimal(t language.Tag)

InitDecimal initializes a Formatter using the default Pattern for the given language.

func (*Formatter) InitEngineering Uses

func (f *Formatter) InitEngineering(t language.Tag)

InitEngineering initializes a Formatter using the default Pattern for the given language.

func (*Formatter) InitPattern Uses

func (f *Formatter) InitPattern(t language.Tag, pat *Pattern)

InitPattern initializes a Formatter for the given Pattern.

func (*Formatter) InitPerMille Uses

func (f *Formatter) InitPerMille(t language.Tag)

InitPerMille initializes a Formatter using the default Pattern for the given language.

func (*Formatter) InitPercent Uses

func (f *Formatter) InitPercent(t language.Tag)

InitPercent initializes a Formatter using the default Pattern for the given language.

func (*Formatter) InitScientific Uses

func (f *Formatter) InitScientific(t language.Tag)

InitScientific initializes a Formatter using the default Pattern for the given language.

type Info Uses

type Info struct {
    // contains filtered or unexported fields
}

Info holds number formatting configuration data.

func InfoFromLangID Uses

func InfoFromLangID(compactIndex int, numberSystem string) Info

InfoFromLangID returns a Info for the given compact language identifier and numbering system identifier. If system is the empty string, the default numbering system will be taken for that language.

func InfoFromTag Uses

func InfoFromTag(t language.Tag) Info

InfoFromTag returns a Info for the given language tag.

func (Info) AppendDigit Uses

func (n Info) AppendDigit(dst []byte, digit byte) []byte

AppendDigit appends the UTF-8 sequence for n corresponding to the given digit to dst and reports the number of bytes written. dst must be large enough to hold the rune (can be up to utf8.UTFMax bytes).

func (Info) Digit Uses

func (n Info) Digit(asciiDigit rune) rune

Digit returns the digit for the numbering system for the corresponding ASCII value. For example, ni.Digit('3') could return '三'. Note that the argument is the rune constant '3', which equals 51, not the integer constant 3.

func (Info) IsDecimal Uses

func (n Info) IsDecimal() bool

IsDecimal reports if the numbering system can convert decimal to native symbols one-to-one.

func (Info) Symbol Uses

func (n Info) Symbol(t SymbolType) string

Symbol returns the string for the given symbol type.

func (Info) WriteDigit Uses

func (n Info) WriteDigit(dst []byte, asciiDigit rune) int

WriteDigit writes the UTF-8 sequence for n corresponding to the given ASCII digit to dst and reports the number of bytes written. dst must be large enough to hold the rune (can be up to utf8.UTFMax bytes).

type Pattern Uses

type Pattern struct {
    Affix     string // includes prefix and suffix. First byte is prefix length.
    Offset    uint16 // Offset into Affix for prefix and suffix
    NegOffset uint16 // Offset into Affix for negative prefix and suffix or 0.

    FormatWidth uint16

    RoundIncrement uint32 // Use Min*Digits to determine scale
    PadRune        rune
    DigitShift     uint8 // Number of decimals to shift. Used for % and ‰.

    GroupingSize [2]uint8
    Flags        PatternFlag

    // Number of digits.
    // TODO: consider using uint32
    MinIntegerDigits     uint8
    MaxIntegerDigits     uint8
    MinFractionDigits    uint8
    MaxFractionDigits    uint8
    MinSignificantDigits uint8
    MaxSignificantDigits uint8
    MinExponentDigits    uint8
}

Pattern holds information for formatting numbers. It is designed to hold information from CLDR number patterns.

This pattern is precompiled for all patterns for all languages. Even though the number of patterns is not very large, we want to keep this small.

This type is only intended for internal use.

func ParsePattern Uses

func ParsePattern(s string) (f *Pattern, err error)

ParsePattern extracts formatting information from a CLDR number pattern.

See http://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns.

type PatternFlag Uses

type PatternFlag uint8

A PatternFlag is a bit mask for the flag field of a Pattern.

const (
    AlwaysSign PatternFlag = 1 << iota
    ElideSign              // Use space instead of plus sign. AlwaysSign must be true.
    AlwaysExpSign
    AlwaysDecimalSeparator
    ParenthesisForNegative // Common pattern. Saves space.

    PadAfterNumber
    PadAfterAffix

    PadBeforePrefix = 0 // Default
    PadAfterPrefix  = PadAfterAffix
    PadBeforeSuffix = PadAfterNumber
    PadAfterSuffix  = PadAfterNumber | PadAfterAffix
    PadMask         = PadAfterNumber | PadAfterAffix
)

type RoundingContext Uses

type RoundingContext struct {
    Mode      RoundingMode
    Increment int32 // if > 0, round to Increment * 10^-Scale

    Precision int32 // maximum number of significant digits.
    Scale     int32 // maximum number of decimals after the dot.
}

A RoundingContext indicates how a number should be converted to digits.

type RoundingMode Uses

type RoundingMode byte

RoundingMode determines how a number is rounded to the desired precision.

const (
    ToNearestEven RoundingMode = iota // towards the nearest integer, or towards an even number if equidistant.
    ToNearestZero                     // towards the nearest integer, or towards zero if equidistant.
    ToNearestAway                     // towards the nearest integer, or away from zero if equidistant.
    ToPositiveInf                     // towards infinity
    ToNegativeInf                     // towards negative infinity
    ToZero                            // towards zero
    AwayFromZero                      // away from zero

)

func (RoundingMode) String Uses

func (i RoundingMode) String() string

type SymbolType Uses

type SymbolType int

A SymbolType identifies a symbol of a specific kind.

const (
    SymDecimal SymbolType = iota
    SymGroup
    SymList
    SymPercentSign
    SymPlusSign
    SymMinusSign
    SymExponential
    SymSuperscriptingExponent
    SymPerMille
    SymInfinity
    SymNan
    SymTimeSeparator

    NumSymbolTypes
)

Package number imports 8 packages (graph) and is imported by 1 packages. Updated 2017-08-15. Refresh now. Tools for package owners.