package number

Import Path
	golang.org/x/text/internal/number (on go.dev)

Dependency Relation
	imports 7 packages, and imported by 3 packages

Involved Source Files

	    common.go
	    decimal.go
	    format.go
	  d number.go
		Package number contains tools and data for formatting numbers.

	    pattern.go
	    roundingmode_string.go
	    tables.go
Package-Level Type Names (total 11)

	/* sort by: alphabet | popularity */
	 type Converter (interface)
		A Converter converts a number into decimals according to the given rounding
		criteria.

		Methods (only one)
			( Converter) Convert(d *Decimal, r RoundingContext)

	 type Decimal (struct)
		A Decimal represents a floating point number in decimal format.
		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
			12345      Digits: [1, 2, 3, 4, 5], Exp: 5
			12.345     Digits: [1, 2, 3, 4, 5], Exp: 2
			12000      Digits: [1, 2],          Exp: 5
			12000.00   Digits: [1, 2],          Exp: 5
			0.00123    Digits: [1, 2, 3],       Exp: -2
			0          Digits: [],              Exp: 0

		Fields (total 5)
			digits.Digits []byte
				// mantissa digits, big-endian

			digits.Exp int32
				// exponent

			digits.Inf bool
				// Takes precedence over Digits and Exp.

			digits.NaN bool
				// Takes precedence over Inf.

			digits.Neg bool
		Methods (total 4)
			(*Decimal) Convert(r RoundingContext, number interface{})
				Convert converts the given number to the decimal representation using the
				supplied RoundingContext.

			(*Decimal) ConvertFloat(r RoundingContext, x float64, size int)
				ConvertFloat converts a floating point number to decimals.

			(*Decimal) ConvertInt(r RoundingContext, signed bool, x uint64)
				ConvertInt converts an integer to decimals.

			(*Decimal) String() string
		Implements (at least 2)
			*Decimal : expvar.Var
			*Decimal : fmt.Stringer
		As Inputs Of (at least 3)
			func FormatDigits(d *Decimal, r RoundingContext) Digits
			func Converter.Convert(d *Decimal, r RoundingContext)
			func (*Formatter).Format(dst []byte, d *Decimal) []byte

	 type Digits (struct)
		Digits represents a floating point number represented in digits of the
		base in which a number is to be displayed. It is similar to Decimal, but
		keeps track of trailing fraction zeros and the comma placement for
		engineering notation. Digits must have at least one digit.
		
		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 (actual exp is Exp - Comma)
			  0e0        Digits: [0],             Exp: 1, End: 1, Comma: 1
			  .0e0       Digits: [0],             Exp: 0, End: 1, Comma: 0
			  0.0e0      Digits: [0],             Exp: 1, End: 2, Comma: 1
			  1.23e4     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 1
			  .123e5     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 0
			engineering
			  12.3e3     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 2

		Fields (total 8)
			Comma uint8
				Comma is used for the comma position for scientific (always 0 or 1) and
				engineering notation (always 0, 1, 2, or 3).

			digits.Digits []byte
				// mantissa digits, big-endian

			digits.Exp int32
				// exponent

			digits.Inf bool
				// Takes precedence over Digits and Exp.

			digits.NaN bool
				// Takes precedence over Inf.

			digits.Neg bool
			End int32
				End indicates the end position of the number.
				// For decimals Exp <= End. For scientific len(Digits) <= End.

			IsScientific bool
				IsScientific indicates whether this number is to be rendered as a
				scientific number.

		Methods (only one)
			(*Digits) NumFracDigits() int
		As Outputs Of (at least 3)
			func FormatDigits(d *Decimal, r RoundingContext) Digits
			func VisibleDigits.Digits(buf []byte, t language.Tag, scale int) Digits
			func golang.org/x/text/number.Formatter.Digits(buf []byte, tag language.Tag, scale int) Digits
		As Inputs Of (at least one exported)
			func (*Formatter).Render(dst []byte, d Digits) []byte

	 type Formatter (struct)
		Formatter contains all the information needed to render a number.

		Fields (total 21)
			Info Info
			Pattern Pattern
			Pattern.Affix string
				// includes prefix and suffix. First byte is prefix length.

			Pattern.Flags PatternFlag
			Pattern.FormatWidth uint16
			Pattern.GroupingSize [2]uint8
			Pattern.NegOffset uint16
				// Offset into Affix for negative prefix and suffix or 0.

			Pattern.Offset uint16
				// Offset into Affix for prefix and suffix

			Pattern.PadRune rune
			Pattern.RoundingContext RoundingContext
			Pattern.RoundingContext.DigitShift uint8
				// Number of decimals to shift. Used for % and ‰.

			Pattern.RoundingContext.Increment uint32
			Pattern.RoundingContext.IncrementScale uint8
				// May differ from printed scale.

			Pattern.RoundingContext.MaxFractionDigits int16
				// -1 is unlimited

			Pattern.RoundingContext.MaxIntegerDigits uint8
			Pattern.RoundingContext.MaxSignificantDigits int16
				TODO: unify these two fields so that there is a more unambiguous meaning
				of how precision is handled.
				// -1 is unlimited

			Pattern.RoundingContext.MinExponentDigits uint8
			Pattern.RoundingContext.MinFractionDigits uint8
			Pattern.RoundingContext.MinIntegerDigits uint8
				Number of digits.

			Pattern.RoundingContext.MinSignificantDigits uint8
			Pattern.RoundingContext.Mode RoundingMode
		Methods (total 18)
			(*Formatter) Append(dst []byte, x interface{}) []byte
			( Formatter) 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).

			( Formatter) 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.

			(*Formatter) Format(dst []byte, d *Decimal) []byte
			(*Formatter) InitDecimal(t language.Tag)
				InitDecimal initializes a Formatter using the default Pattern for the given
				language.

			(*Formatter) InitEngineering(t language.Tag)
				InitEngineering initializes a Formatter using the default Pattern for the
				given language.

			(*Formatter) InitPattern(t language.Tag, pat *Pattern)
				InitPattern initializes a Formatter for the given Pattern.

			(*Formatter) InitPerMille(t language.Tag)
				InitPerMille initializes a Formatter using the default Pattern for the given
				language.

			(*Formatter) InitPercent(t language.Tag)
				InitPercent initializes a Formatter using the default Pattern for the given
				language.

			(*Formatter) InitScientific(t language.Tag)
				InitScientific initializes a Formatter using the default Pattern for the
				given language.

			( Formatter) IsDecimal() bool
				IsDecimal reports if the numbering system can convert decimal to native
				symbols one-to-one.

			(*Formatter) Render(dst []byte, d Digits) []byte
			(*Formatter) RoundFractionDigits() (n int)
				RoundFractionDigits returns the number of fraction digits an implementation
				of Convert may round to or n < 0 if there is no maximum or a maximum is not
				recommended.

			(*Formatter) RoundSignificantDigits() (n int)
				RoundSignificantDigits returns the number of significant digits an
				implementation of Convert may round to or n < 0 if there is no maximum or
				a maximum is not recommended.

			(*Formatter) SetPrecision(prec int)
			(*Formatter) SetScale(scale int)
				SetScale fixes the RoundingContext to a fixed number of fraction digits.

			( Formatter) Symbol(t SymbolType) string
				Symbol returns the string for the given symbol type.

			( Formatter) 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 Info (struct)
		Info holds number formatting configuration data.

		Methods (total 5)
			( 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).

			( 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.

			( Info) IsDecimal() bool
				IsDecimal reports if the numbering system can convert decimal to native
				symbols one-to-one.

			( Info) Symbol(t SymbolType) string
				Symbol returns the string for the given symbol type.

			( 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).

		As Outputs Of (at least 2)
			func InfoFromLangID(compactIndex compact.ID, numberSystem string) Info
			func InfoFromTag(t language.Tag) Info

	 type Pattern (struct)
		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.

		Fields (total 19)
			Affix string
				// includes prefix and suffix. First byte is prefix length.

			Flags PatternFlag
			FormatWidth uint16
			GroupingSize [2]uint8
			NegOffset uint16
				// Offset into Affix for negative prefix and suffix or 0.

			Offset uint16
				// Offset into Affix for prefix and suffix

			PadRune rune
			RoundingContext RoundingContext
			RoundingContext.DigitShift uint8
				// Number of decimals to shift. Used for % and ‰.

			RoundingContext.Increment uint32
			RoundingContext.IncrementScale uint8
				// May differ from printed scale.

			RoundingContext.MaxFractionDigits int16
				// -1 is unlimited

			RoundingContext.MaxIntegerDigits uint8
			RoundingContext.MaxSignificantDigits int16
				TODO: unify these two fields so that there is a more unambiguous meaning
				of how precision is handled.
				// -1 is unlimited

			RoundingContext.MinExponentDigits uint8
			RoundingContext.MinFractionDigits uint8
			RoundingContext.MinIntegerDigits uint8
				Number of digits.

			RoundingContext.MinSignificantDigits uint8
			RoundingContext.Mode RoundingMode
		Methods (total 4)
			(*Pattern) RoundFractionDigits() (n int)
				RoundFractionDigits returns the number of fraction digits an implementation
				of Convert may round to or n < 0 if there is no maximum or a maximum is not
				recommended.

			(*Pattern) RoundSignificantDigits() (n int)
				RoundSignificantDigits returns the number of significant digits an
				implementation of Convert may round to or n < 0 if there is no maximum or
				a maximum is not recommended.

			(*Pattern) SetPrecision(prec int)
			(*Pattern) SetScale(scale int)
				SetScale fixes the RoundingContext to a fixed number of fraction digits.

		As Outputs Of (at least one exported)
			func ParsePattern(s string) (f *Pattern, err error)
		As Inputs Of (at least one exported)
			func (*Formatter).InitPattern(t language.Tag, pat *Pattern)

	 type PatternFlag uint8 (basic type)
		A PatternFlag is a bit mask for the flag field of a Pattern.

		As Types Of (total 11)
			const AlwaysDecimalSeparator
			const AlwaysExpSign
			const AlwaysSign
			const ElideSign
			const PadAfterAffix
			const PadAfterNumber
			const PadAfterPrefix
			const PadAfterSuffix
			const PadBeforeSuffix
			const PadMask
			const ParenthesisForNegative

	 type RoundingContext (struct)
		A RoundingContext indicates how a number should be converted to digits.
		It contains all information needed to determine the "visible digits" as
		required by the pluralization rules.

		Fields (total 11)
			DigitShift uint8
				// Number of decimals to shift. Used for % and ‰.

			Increment uint32
			IncrementScale uint8
				// May differ from printed scale.

			MaxFractionDigits int16
				// -1 is unlimited

			MaxIntegerDigits uint8
			MaxSignificantDigits int16
				TODO: unify these two fields so that there is a more unambiguous meaning
				of how precision is handled.
				// -1 is unlimited

			MinExponentDigits uint8
			MinFractionDigits uint8
			MinIntegerDigits uint8
				Number of digits.

			MinSignificantDigits uint8
			Mode RoundingMode
		Methods (total 4)
			(*RoundingContext) RoundFractionDigits() (n int)
				RoundFractionDigits returns the number of fraction digits an implementation
				of Convert may round to or n < 0 if there is no maximum or a maximum is not
				recommended.

			(*RoundingContext) RoundSignificantDigits() (n int)
				RoundSignificantDigits returns the number of significant digits an
				implementation of Convert may round to or n < 0 if there is no maximum or
				a maximum is not recommended.

			(*RoundingContext) SetPrecision(prec int)
			(*RoundingContext) SetScale(scale int)
				SetScale fixes the RoundingContext to a fixed number of fraction digits.

		As Inputs Of (at least 5)
			func FormatDigits(d *Decimal, r RoundingContext) Digits
			func Converter.Convert(d *Decimal, r RoundingContext)
			func (*Decimal).Convert(r RoundingContext, number interface{})
			func (*Decimal).ConvertFloat(r RoundingContext, x float64, size int)
			func (*Decimal).ConvertInt(r RoundingContext, signed bool, x uint64)

	 type RoundingMode byte (basic type)
		RoundingMode determines how a number is rounded to the desired precision.

		Methods (only one)
			( RoundingMode) String() string
		Implements (at least 2)
			 RoundingMode : expvar.Var
			 RoundingMode : fmt.Stringer
		As Types Of (total 7)
			const AwayFromZero
			const ToNearestAway
			const ToNearestEven
			const ToNearestZero
			const ToNegativeInf
			const ToPositiveInf
			const ToZero

	 type SymbolType int (basic type)
		A SymbolType identifies a symbol of a specific kind.

		As Inputs Of (at least one exported)
			func Info.Symbol(t SymbolType) string
		As Types Of (total 13)
			const NumSymbolTypes
			const SymDecimal
			const SymExponential
			const SymGroup
			const SymInfinity
			const SymList
			const SymMinusSign
			const SymNan
			const SymPercentSign
			const SymPerMille
			const SymPlusSign
			const SymSuperscriptingExponent
			const SymTimeSeparator

	 type VisibleDigits (interface)
		A VisibleDigits computes digits, comma placement and trailing zeros as they
		will be shown to the user.

		Methods (only one)
			( VisibleDigits) Digits(buf []byte, t language.Tag, scale int) Digits
		Implemented By (at least one exported)
			 golang.org/x/text/number.Formatter


Package-Level Functions (total 4)

	 func FormatDigits(d *Decimal, r RoundingContext) Digits
	 func InfoFromLangID(compactIndex compact.ID, 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(t language.Tag) Info
		InfoFromTag returns a Info for the given language tag.

	 func ParsePattern(s string) (f *Pattern, err error)
		ParsePattern extracts formatting information from a CLDR number pattern.
		
		See https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns.


Package-Level Constants (total 33)

	const AlwaysDecimalSeparator PatternFlag = 8
	const AlwaysExpSign PatternFlag = 4
	const AlwaysSign PatternFlag = 1
	const AwayFromZero RoundingMode = 6 // away from zero
	const CLDRVersion = "32"
		CLDRVersion is the CLDR version from which the tables in this package are derived.

	const ElideSign PatternFlag = 2 // Use space instead of plus sign. AlwaysSign must be true.
	const NumSymbolTypes SymbolType = 12
	const PadAfterAffix PatternFlag = 64
	const PadAfterNumber PatternFlag = 32
	const PadAfterPrefix PatternFlag = 64
	const PadAfterSuffix PatternFlag = 96
	const PadBeforePrefix = 0 // Default
	const PadBeforeSuffix PatternFlag = 32
	const PadMask PatternFlag = 96
	const ParenthesisForNegative PatternFlag = 16 // Common pattern. Saves space.
	const SymDecimal SymbolType = 0
	const SymExponential SymbolType = 6
	const SymGroup SymbolType = 1
	const SymInfinity SymbolType = 9
	const SymList SymbolType = 2
	const SymMinusSign SymbolType = 5
	const SymNan SymbolType = 10
	const SymPercentSign SymbolType = 3
	const SymPerMille SymbolType = 8
	const SymPlusSign SymbolType = 4
	const SymSuperscriptingExponent SymbolType = 7
	const SymTimeSeparator SymbolType = 11
	const ToNearestAway RoundingMode = 2 // towards the nearest integer, or away from zero if equidistant.
	const ToNearestEven RoundingMode = 0 // towards the nearest integer, or towards an even number if equidistant.
	const ToNearestZero RoundingMode = 1 // towards the nearest integer, or towards zero if equidistant.
	const ToNegativeInf RoundingMode = 4 // towards negative infinity
	const ToPositiveInf RoundingMode = 3 // towards infinity
	const ToZero RoundingMode = 5 // towards zero

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.