Go言語 big.Floatのテキスト出力：MarshalText()以外の代替メソッドと使い分け

2025-06-01

`big.Float.MarshalText()`とは何か？

big.Float.MarshalText()は、Go言語のmath/bigパッケージが提供する、任意の精度を持つ浮動小数点数型である*big.Floatの値を、人間が読めるテキスト形式（バイトスライス）に変換するためのメソッドです。

このメソッドは、encoding.TextMarshalerインターフェースを実装しています。encoding.TextMarshalerインターフェースは、次のように定義されています。

type TextMarshaler interface {
    MarshalText() (text []byte, err error)
}

このインターフェースを実装することで、jsonパッケージのようなテキストベースのエンコーダーが、big.Floatの値を自動的に文字列としてエンコードできるようになります。

MarshalText()メソッドは、*big.Floatの値をその「完全な精度（full precision）」で文字列に変換し、そのバイトスライスを返します。この際、big.Floatが持つ精度や丸めモードといった属性は無視されます。

簡単に言えば、big.Floatが保持している数値情報を、可能な限り正確な10進数表現の文字列に変換して出力します。

使用例

例えば、big.Floatの値をJSONとしてエンコードしたい場合に、MarshalText()がどのように利用されるかを見てみましょう。

package main

import (
	"encoding/json"
	"fmt"
	"math/big"
)

type MyData struct {
	Value *big.Float `json:"value"`
}

func main() {
	// 新しいbig.Floatを作成し、値をセット
	f := new(big.Float).SetFloat64(123456789.12345678912345) // float64では表現しきれない桁数

	// 構造体にbig.Floatを埋め込む
	data := MyData{
		Value: f,
	}

	// JSONとしてエンコード
	jsonData, err := json.Marshal(data)
	if err != nil {
		fmt.Println("Error marshaling JSON:", err)
		return
	}

	fmt.Println(string(jsonData))

	// nilの場合の挙動
	var nilFloat *big.Float
	nilData := MyData{
		Value: nilFloat,
	}
	nilJsonData, err := json.Marshal(nilData)
	if err != nil {
		fmt.Println("Error marshaling nil JSON:", err)
		return
	}
	fmt.Println(string(nilJsonData))
}

出力例

{"value":"123456789.12345678912345"}
{"value":null}

この例では、MyData構造体のValueフィールドが*big.Float型であり、json:"value"タグが付いています。json.Marshal関数がこの構造体を処理する際に、*big.Float型がencoding.TextMarshalerインターフェース（つまりMarshalText()メソッド）を実装していることを検出し、そのメソッドを呼び出して文字列形式に変換し、JSONの文字列値として埋め込みます。

もしbig.Floatがnilの場合、MarshalText()はnilを処理し、JSONではnullとしてエンコードされます。

なぜ`MarshalText()`を使うのか？

人間が読める形式
バイナリ形式ではなく、文字列として出力されるため、デバッグやログ出力、設定ファイルなどでの利用に適しています。
汎用性
encoding.TextMarshalerインターフェースを実装しているため、JSONだけでなく、他のテキストベースのエンコーディング（例: YAML）でも特別な設定なしに利用できます。
正確な表現
big.Floatは非常に大きな数や非常に小さな数を高い精度で扱うために設計されています。通常のfloat64などでは精度が失われる可能性がありますが、MarshalText()は可能な限りその精度を保ったままテキスト化します。

このメソッドは、big.Floatの「値」のみをテキスト化します。精度や丸めモードといったbig.Floatの内部設定は、エンコードされる文字列には含まれません。
MarshalText()は完全な精度で出力するため、非常に大きな桁数のbig.Floatの場合、出力される文字列も非常に長くなる可能性があります。

big.Float.MarshalText()メソッド自体は、内部で大きな数値を扱うため、いくつかの点で注意が必要です。

nilポインタのデリファレンス (Nil Pointer Dereference)

これは最もよくあるエラーの一つです。big.Floatはポインタ型 (*big.Float) であるため、初期化されていないnilの*big.Floatに対してメソッドを呼び出すと、panic: runtime error: invalid memory address or nil pointer dereferenceが発生します。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	var f *big.Float // 初期化されていないnilポインタ
	text, err := f.MarshalText() // ここでパニック
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println(string(text))
}

トラブルシューティング

big.Floatを使用する前に、必ずnew(big.Float)などで初期化してください。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f := new(big.Float) // 適切に初期化
	f.SetFloat64(123.45)
	text, err := f.MarshalText()
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println(string(text)) // "123.45"
}

JSONエンコーディングなどでnilが許容される場合（例: json:"value,omitempty"タグが付いている場合）、MarshalTextはnil *big.Floatに対して呼び出されずに、nullとしてエンコードされます。しかし、明示的にMarshalText()を呼び出す場合は、nilチェックが必要です。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	var f *big.Float
	if f == nil {
		fmt.Println("f is nil, cannot call MarshalText()")
		// または、エラーを返すか、適切なデフォルト値を設定する
		return
	}
	// ... f.MarshalText()
}

メモリ使用量の問題 (Memory Exhaustion)

big.Floatは任意の精度を持つため、非常に大きな数や非常に多くの小数点以下の桁数を持つ数を表現できます。これにより、MarshalText()が生成するテキスト（バイトスライス）が非常に大きくなり、メモリを大量に消費する可能性があります。

考えられるシナリオ

極端に多くの小数点以下の桁数: 例えるなら、0.000...001（小数点以下1000桁）。
極端に大きな数: 例えるなら、101000 のような数。

トラブルシューティング

用途の見直し
そもそもそのような高精度の大きな数値をテキストとして出力する必要があるのか、そのシステムで本当に必要とされている精度や範囲は何なのかを再検討します。場合によっては、float64や固定小数点数型（例: shopspring/decimalのようなライブラリ）で十分な場合があります。
ストリーミング処理
もし、MarshalText()の結果を直接メモリに保持するのが問題となる場合、io.Writerに直接書き込むような代替手段を検討するか、より小さなチャンクに分割して処理することを検討します。ただし、MarshalText()自体は[]byteを返すため、直接ストリーミングはできません。そのため、MarshalText()の結果を大きなファイルに書き出す場合は、メモリに一時的にロードされることは避けられません。
入力の検証
big.Floatに設定される値の範囲や精度に上限を設けることで、異常に大きな文字列が生成されるのを防ぎます。

不適切な値のエンコード（NaNやInfinity）

big.FloatはNaN (Not-a-Number) や Infinity (無限大) も表現できます。これらの特殊な値がMarshalText()によってどのようにエンコードされるかを理解しておく必要があります。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// NaN (Not-a-Number)
	nan := new(big.Float).SetNaN(false) // falseはquiet NaN
	textNan, _ := nan.MarshalText()
	fmt.Printf("NaN: %s\n", string(textNan)) // 出力例: "NaN"

	// Infinity (Positive Infinity)
	infPos := new(big.Float).SetInf(true)
	textInfPos, _ := infPos.MarshalText()
	fmt.Printf("Positive Infinity: %s\n", string(textInfPos)) // 出力例: "+Inf"

	// Infinity (Negative Infinity)
	infNeg := new(big.Float).SetInf(false)
	textInfNeg, _ := infNeg.MarshalText()
	fmt.Printf("Negative Infinity: %s\n", string(textInfNeg)) // 出力例: "-Inf"
}

トラブルシューティング

エラーハンドリング
アプリケーションの要件によっては、これらの特殊値が生成されること自体をエラーとみなす場合もあります。その場合は、big.Floatの値が特殊値であるかを事前にチェックし、必要に応じてエラーを返すなどの処理を実装します。
- f.IsNaN()
- f.IsInf()
受信側システムの互換性
NaNや+Inf、-Infといった文字列表現を正しく解釈できることを、データを受信するシステムが保証しているか確認します。特にJSONにおいては、数値型としてこれらの特殊値を直接表現することはできません（文字列としてエンコードされるのが一般的です）。

精度と表示形式の期待値とのずれ

MarshalText()はbig.Floatの完全な精度を文字列として表現します。これは、fmt.Sprintfの%fや%gフォーマット指定子とは異なり、自動的に桁数を丸めたり、指数表記に切り替えたりしません。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f := new(big.Float).SetString("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")
	text, _ := f.MarshalText()
	fmt.Printf("MarshalText: %s\n", string(text)) // 長い0が続く
	fmt.Printf("String() method: %s\n", f.String()) // big.Float.String()は通常、よりコンパクトな表現を試みる
}

出力例（環境による）

MarshalText: 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
String() method: 1e-100

big.Float.String()は通常、よりコンパクトな形式（例: 指数表記）で出力しようとしますが、MarshalText()は生の10進数表現を返します。

カスタムMarshalerの作成
encoding/jsonのようなパッケージで、特定の表示形式を強制したい場合は、big.Floatをラップするカスタム型を作成し、その型にMarshalJSON()メソッドを実装することで、出力形式を完全に制御できます。
明確な目的
MarshalText()の目的は、encoding.TextMarshalerインターフェースを介して、値の「完全な」テキスト表現を提供することです。もし特定の表示形式（例: 固定小数点表記、特定の有効桁数での丸め、指数表記）が必要な場合は、MarshalText()を直接使うのではなく、big.Floatの他のメソッド（例: f.Text('f', N)、f.Text('g', N)、f.Text('e', N)) を使用して、目的の形式の文字列を取得し、それをエンコードすることを検討してください。

package main

import (
	"encoding/json"
	"fmt"
	"math/big"
)

// CustomFloat は big.Float をラップし、カスタムな MarshalJSON を提供します
type CustomFloat struct {
	*big.Float
}

// MarshalJSON は CustomFloat のJSONエンコーディングをカスタマイズします
func (cf CustomFloat) MarshalJSON() ([]byte, error) {
	if cf.Float == nil {
		return []byte("null"), nil
	}
	// 例: 小数点以下2桁に丸めて文字列として出力
	// あるいは、String() メソッドを使って指数表記にするなど
	s := cf.Float.Text('f', 2) // 小数点以下2桁固定
	return json.Marshal(s) // 文字列としてJSONエンコード
}

func main() {
	f := new(big.Float).SetFloat64(123.456789)
	data := struct {
		Value CustomFloat `json:"value"`
	}{
		Value: CustomFloat{Float: f},
	}

	jsonData, err := json.Marshal(data)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println(string(jsonData)) // {"value":"123.46"}
}

big.Float.MarshalText()は、*big.Floatの値をテキスト形式のバイトスライスに変換するメソッドです。主にencoding.TextMarshalerインターフェースの実装として機能し、JSONエンコーディングなどで自動的に利用されます。

例1: `MarshalText()`の基本的な使用方法

この例では、big.Floatの値を直接MarshalText()でテキスト化し、その結果を表示します。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// 新しい big.Float を作成し、値を設定
	f1 := new(big.Float).SetFloat64(123456789.123456789)
	text1, err := f1.MarshalText()
	if err != nil {
		fmt.Println("Error marshaling f1:", err)
		return
	}
	fmt.Printf("f1: %s (Type: %T)\n", string(text1), text1)
	// 出力例: f1: 123456789.123456789 (Type: []uint8)

	// 非常に大きな数を扱う例
	f2 := new(big.Float).SetString("1234567890123456789012345678901234567890.12345678901234567890")
	text2, err := f2.MarshalText()
	if err != nil {
		fmt.Println("Error marshaling f2:", err)
		return
	}
	fmt.Printf("f2: %s\n", string(text2))
	// 出力例: f2: 1234567890123456789012345678901234567890.12345678901234567890

	// 非常に小さな数を扱う例
	f3 := new(big.Float).SetString("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")
	text3, err := f3.MarshalText()
	if err != nil {
		fmt.Println("Error marshaling f3:", err)
		return
	}
	fmt.Printf("f3: %s\n", string(text3))
	// 出力例: f3: 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

	// nil *big.Float の場合 (注意: この例ではMarshalText()を直接呼び出すとパニック)
	var nilFloat *big.Float
	// textNil, err := nilFloat.MarshalText() // ここでパニックが発生する
	// fmt.Println(string(textNil))
	fmt.Println("nil *big.Float cannot call MarshalText() directly without panicking.")
}

解説

MarshalText()は、big.Floatが保持する値を完全な精度でテキスト化します。そのため、fmt.Printfの%fなどとは異なり、自動的な丸めや指数表記への変換は行いません。
戻り値は[]byte型なので、文字列として表示するにはstring()にキャストします。
MarshalText()はエラーを返す可能性がありますが、*big.Floatが正しく初期化されていれば通常はnilを返します。

例2: JSONエンコーディングでの`MarshalText()`の利用（最も一般的なケース）

encoding.TextMarshalerインターフェースを実装しているため、json.Marshal関数が自動的にMarshalText()を呼び出します。

package main

import (
	"encoding/json"
	"fmt"
	"math/big"
)

type Product struct {
	ID    string     `json:"id"`
	Price *big.Float `json:"price"` // big.Float は TextMarshaler を実装
	Stock int        `json:"stock"`
}

func main() {
	// 商品データを作成
	p := Product{
		ID:    "A001",
		Price: new(big.Float).SetString("99.9987654321"), // 小数点以下が多い値
		Stock: 100,
	}

	// 構造体をJSONエンコード
	jsonData, err := json.MarshalIndent(p, "", "  ") // Indentで整形して出力
	if err != nil {
		fmt.Println("JSON encoding error:", err)
		return
	}

	fmt.Println(string(jsonData))
	/*
	出力:
	{
	  "id": "A001",
	  "price": "99.9987654321", // ここでMarshalText()が呼び出されている
	  "stock": 100
	}
	*/

	// Priceがnilの場合
	pNil := Product{
		ID:    "A002",
		Price: nil, // Priceをnilにする
		Stock: 50,
	}
	jsonDataNil, err := json.MarshalIndent(pNil, "", "  ")
	if err != nil {
		fmt.Println("JSON encoding error (nil):", err)
		return
	}
	fmt.Println("\nProduct with nil price:")
	fmt.Println(string(jsonDataNil))
	/*
	出力:
	{
	  "id": "A002",
	  "price": null, // nilの場合はJSONのnullとしてエンコードされる
	  "stock": 50
	}
	*/
}

解説

*big.Floatがnilの場合、json.MarshalはそれをJSONのnullとしてエンコードします。これは、MarshalText()がnilに対して直接呼び出されることを避け、安全に処理するためのGoのjsonパッケージの挙動です。
結果として、JSONのpriceフィールドは文字列としてエンコードされます。これは、JSONの数値型がbig.Floatのような任意精度をネイティブにサポートしていないため、文字列として表現するのが一般的だからです。
Product構造体のPriceフィールドが*big.Float型であるため、json.Marshalがこのフィールドを処理する際に、自動的にbig.Float.MarshalText()を呼び出します。

例3: カスタムの`MarshalJSON`メソッドと`MarshalText()`の組み合わせ

特定のフォーマットでJSONにエンコードしたい場合、MarshalText()で完全な文字列を取得し、それをさらに加工してjson.Marshalに渡すことができます。ここでは、big.Floatを特定の小数点以下桁数に丸めてJSONに含める例を示します。

package main

import (
	"encoding/json"
	"fmt"
	"math/big"
)

// MyCustomFloat は big.Float をラップするカスタム型
type MyCustomFloat struct {
	*big.Float
}

// MarshalJSON は MyCustomFloat のJSONエンコーディングをカスタマイズします。
// big.Float.MarshalText() を直接使わず、Text('f', N) でフォーマットを制御します。
func (mcf MyCustomFloat) MarshalJSON() ([]byte, error) {
	if mcf.Float == nil {
		return []byte("null"), nil
	}

	// ここでbig.Floatの表示形式を制御します。
	// Text('f', 2) は小数点以下2桁の固定小数点表記にします。
	formattedString := mcf.Float.Text('f', 2) 

	// 結果の文字列をJSON文字列としてエンコード
	return json.Marshal(formattedString)
}

type Item struct {
	Name  string        `json:"name"`
	Value MyCustomFloat `json:"value"`
}

func main() {
	item1 := Item{
		Name:  "Widget A",
		Value: MyCustomFloat{Float: new(big.Float).SetFloat64(123.45678)},
	}

	jsonData1, err := json.MarshalIndent(item1, "", "  ")
	if err != nil {
		fmt.Println("Error marshaling item1:", err)
		return
	}
	fmt.Println(string(jsonData1))
	/*
	出力:
	{
	  "name": "Widget A",
	  "value": "123.46" // 小数点以下2桁に丸められている
	}
	*/

	item2 := Item{
		Name:  "Widget B",
		Value: MyCustomFloat{Float: new(big.Float).SetFloat64(99.999)},
	}
	jsonData2, err := json.MarshalIndent(item2, "", "  ")
	if err != nil {
		fmt.Println("Error marshaling item2:", err)
		return
	}
	fmt.Println(string(jsonData2))
	/*
	出力:
	{
	  "name": "Widget B",
	  "value": "100.00" // 99.999 が丸められて 100.00 になっている
	}
	*/
}

この方法により、MarshalText()が提供する「完全な精度でのテキスト化」とは異なる、特定の表示要件を満たす文字列フォーマットをJSON出力に適用できます。
その後、この取得した文字列をjson.Marshalで再度エンコードし、JSONの文字列リテラルとして出力させています。
MarshalJSON()の中で、big.FloatのText('f', 2)メソッドを呼び出して、小数点以下2桁の固定小数点表記の文字列を取得しています。
MyCustomFloatというカスタム型を作成し、その上にMarshalJSON()メソッドを実装しています。

MarshalText()はencoding.TextMarshalerインターフェースを実装するために存在し、主にJSONエンコーディングなどで自動的に呼び出されます。しかし、特定の要件（表示形式の制御、異なるデータ形式への変換、パフォーマンスなど）がある場合、他の方法が適切になることがあります。

主な代替方法は以下の通りです。

big.Float.Text(fmt byte, prec int) メソッドの使用
これは最も直接的で柔軟な代替方法です。big.Floatの値を指定した形式と精度で文字列に変換します。
big.Float.String() メソッドの使用
fmt.Stringerインターフェースを実装しているため、デバッグ出力などで簡潔に文字列を得たい場合に便利です。
カスタムの MarshalJSON() メソッドの実装
JSONエンコーディングにおいて、MarshalText()のデフォルトの挙動（完全な精度での文字列化）ではなく、独自のフォーマットで出力したい場合に利用します。
big.Floatの値を整数部と小数部に分解して処理
場合によっては、浮動小数点数としてではなく、特定の固定小数点形式や、整数と小数部分に分けて文字列化したい場合があります。

これらの代替方法について、それぞれ詳しく見ていきましょう。

big.Float.Text(fmt byte, prec int) メソッドの使用

big.Float.Text()メソッドは、big.Floatの値を指定された形式 (fmt) と精度 (prec) で文字列に変換します。これは、MarshalText()が提供する「完全な精度での10進数表現」とは異なり、表示形式を細かく制御したい場合に非常に有用です。

書式
func (x *Float) Text(fmt byte, prec int) string

prec: 精度（小数点以下の桁数、または有効数字の桁数）
fmt: 表示形式を指定する文字（'f', 'e', 'E', 'g', 'G'など）。
- 'f': 固定小数点表記（例: 123.45）
- 'e' / 'E': 指数表記（例: 1.2345e+02）
- 'g' / 'G': 'f'または指数表記のより短い方を選択

使用例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f := new(big.Float).SetFloat64(123.456789)
	f.SetPrec(256) // 精度を高く設定しておく（MarshalText() や Text() に影響しない）

	// 'f' フォーマット: 固定小数点表記
	fmt.Println("Text('f', 2):", f.Text('f', 2))   // 小数点以下2桁: 123.46
	fmt.Println("Text('f', 5):", f.Text('f', 5))   // 小数点以下5桁: 123.45679
	fmt.Println("Text('f', 0):", f.Text('f', 0))   // 小数点以下0桁: 123

	// 'e' フォーマット: 指数表記 (小文字e)
	fmt.Println("Text('e', 2):", f.Text('e', 2))   // 1.23e+02
	fmt.Println("Text('e', 5):", f.Text('e', 5))   // 1.23457e+02

	// 'E' フォーマット: 指数表記 (大文字E)
	fmt.Println("Text('E', 2):", f.Text('E', 2))   // 1.23E+02

	// 'g' フォーマット: 'f' または 'e' の短い方
	fmt.Println("Text('g', 2):", f.Text('g', 2))   // 1.2e+02 (短い方)
	fmt.Println("Text('g', 5):", f.Text('g', 5))   // 123.46 (短い方)

	// MarshalText() との比較 (完全な精度で出力される)
	textMarshal, _ := f.MarshalText()
	fmt.Println("MarshalText():", string(textMarshal)) // 123.456789 (元の値)
}

利点

MarshalText()のように[]byteではなくstringを返すため、直接文字列として扱える。
出力形式（固定小数点、指数表記）と精度を細かく制御できる。

欠点

MarshalText()のようにencoding.TextMarshalerインターフェースを自動的に満たさないため、JSONエンコーディングなどで自動的に呼び出されることはない。

big.Float.String() メソッドの使用

big.Floatはfmt.Stringerインターフェースを実装しており、String()メソッドを持っています。これは、fmt.Println()やfmt.Sprintf()などで暗黙的に呼び出されます。通常、String()は値を表現する最も簡潔な形式（必要に応じて指数表記を含む）を返します。

使用例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f1 := new(big.Float).SetFloat64(123456789.123)
	fmt.Println("String() for f1:", f1.String()) // 1.23456789123e+08 または 123456789.123

	f2 := new(big.Float).SetString("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001")
	fmt.Println("String() for f2:", f2.String()) // 1e-100 (指数表記が優先される)

	f3 := new(big.Float).SetFloat64(1.0)
	fmt.Println("String() for f3:", f3.String()) // 1
}

利点

デバッグ出力やログ出力に便利。
非常にシンプルで使いやすい。

欠点

MarshalText()と同様に、JSONエンコーディングで自動的に使用されることはない（ただし、Stringerも間接的に利用される可能性はあるが、TextMarshalerが優先される）。
出力形式を細かく制御できない（big.Floatが最適な表現を判断する）。

カスタムの MarshalJSON() メソッドの実装

big.Floatがencoding.TextMarshalerを実装しているため、デフォルトではJSONに文字列としてエンコードされます。しかし、その文字列のフォーマットを制御したい場合は、big.Floatをラップするカスタム型を作成し、その型にMarshalJSON()メソッドを実装します。この中で、big.Float.Text()などを使って望むフォーマットの文字列を作成し、それをJSONにエンコードします。

使用例

package main

import (
	"encoding/json"
	"fmt"
	"math/big"
)

// MyCurrency は big.Float をラップし、JSONエンコーディングをカスタマイズします。
type MyCurrency struct {
	*big.Float
}

// MarshalJSON は MyCurrency のJSONエンコーディングを定義します。
// 例: 小数点以下2桁の固定小数点表記で出力し、末尾の0は省略しない。
func (mc MyCurrency) MarshalJSON() ([]byte, error) {
	if mc.Float == nil {
		return []byte("null"), nil // nilの場合はJSON null
	}
	// 'f' フォーマットで小数点以下2桁に丸めて文字列を取得
	s := mc.Float.Text('f', 2)
	// その文字列をJSONエンコード（""で囲まれた文字列になる）
	return json.Marshal(s)
}

type Order struct {
	OrderID    string     `json:"orderId"`
	TotalValue MyCurrency `json:"totalValue"` // カスタム型を使用
}

func main() {
	order := Order{
		OrderID:    "ORD-001",
		TotalValue: MyCurrency{Float: new(big.Float).SetFloat64(1234.56789)},
	}

	jsonData, err := json.MarshalIndent(order, "", "  ")
	if err != nil {
		fmt.Println("Error marshaling JSON:", err)
		return
	}
	fmt.Println(string(jsonData))
	/*
	出力:
	{
	  "orderId": "ORD-001",
	  "totalValue": "1234.57" // 小数点以下2桁に丸められている
	}
	*/

	order2 := Order{
		OrderID:    "ORD-002",
		TotalValue: MyCurrency{Float: new(big.Float).SetFloat64(99.00)},
	}
	jsonData2, err := json.MarshalIndent(order2, "", "  ")
	if err != nil {
		fmt.Println("Error marshaling JSON:", err)
		return
	}
	fmt.Println(string(jsonData2))
	/*
	出力:
	{
	  "orderId": "ORD-002",
	  "totalValue": "99.00" // 末尾のゼロも含まれる
	}
	*/
}

利点

big.Float.Text()の柔軟性をJSONエンコーディングに適用できる。
JSON出力のフォーマットを完全に制御できる。

欠点

UnmarshalJSON()も実装しないと、JSONからのデコード時にはデフォルトの動作（文字列からの解析）になる。
big.Floatをラップするカスタム型を作成する必要があるため、少しコード量が増える。

big.Floatの値を整数部と小数部に分解して処理（特殊なケース）

非常に稀なケースですが、big.Floatの値を小数点表記の文字列として直接出力するのではなく、整数部分と小数部分を別々のデータとして扱いたい場合があります。例えば、特定のプロトコルやファイル形式で、整数部分と小数部分を分離して格納する必要がある場合などです。

この場合、big.Float.Int()やbig.Float.Rat()などのメソッドを使用して、整数部分や有理数表現に変換し、そこから文字列を生成することを検討できます。

例（概念的、実用的ではない場合が多い）

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f := new(big.Float).SetFloat64(123.456)

	// Int() で整数部を取得 (切り捨てられる)
	intPart, acc := f.Int(nil) // accは正確性を示す (Exact, Below, Above, Unounded)
	fmt.Printf("Integer Part: %s (Accuracy: %s)\n", intPart.String(), acc.String()) // 123

	// Rat() で有理数（分数）として表現
	rat := new(big.Rat).SetFloat64(123.456)
	fmt.Printf("Rational (Fraction): %s\n", rat.String()) // 15432/125 または同等の分数

	// 小数部を別途計算する例 (複雑になることが多い)
	// 123.456 - 123 = 0.456
	intFloat := new(big.Float).SetInt(intPart)
	fracPart := new(big.Float).Sub(f, intFloat)
	fmt.Printf("Fractional Part (as big.Float): %s\n", fracPart.String()) // 0.456

	// 小数部を整数として扱う場合（例: 0.456 -> 456）
	// 通常は固定小数点ライブラリや特定の計算ロジックが必要
	// このような処理は、MarshalText()とは目的が大きく異なります。
}

利点

特定の数値プロトコルやストレージ形式に厳密に合わせる必要がある場合に、より低レベルな制御が可能。

欠点

ほとんどのユースケースでは、Text()やMarshalJSON()で十分。
非常に複雑になりがちで、一般的なテキストエンコーディングには適さない。

big.Float.MarshalText()は、encoding.TextMarshalerインターフェースを実装するための標準的な方法であり、JSONエンコーディングなどで自動的に利用されるのが最も一般的です。

しかし、出力形式の制御、特定の精度での丸め、あるいは異なるデータ形式への変換が必要な場合は、以下の代替方法を検討してください。

シンプルなデバッグ出力や簡潔な文字列が欲しい: big.Float.String()
JSON出力のフォーマットをカスタマイズしたい: カスタムのMarshalJSON()メソッドを実装し、その中でbig.Float.Text()を利用する。
表示形式を細かく制御したい: big.Float.Text(fmt byte, prec int)

これらの代替方法を適切に選択することで、big.Floatの値を柔軟にテキスト形式で扱うことができます。 Go言語のbig.Float.MarshalText()は、encoding.TextMarshalerインターフェースを実装しているため、JSONエンコーディングなどで「標準的なテキスト形式」として値をシリアライズする際に便利です。しかし、特定のフォーマットで出力したい場合や、別のデータ型に変換したい場合には、いくつかの代替手段があります。

big.Float.String()メソッド
String()メソッドは、*big.Floatの値を人間が読める文字列として返します。これは、x.Text('g', 10)と等価であるとドキュメントに記載されています。つまり、指数表記または固定小数点表記を自動的に選択し、有効桁数を10桁に丸めます。
- 用途
  デバッグ出力、ログ記録、おおよその値を表示する場合など、厳密な精度が要求されないが、可読性を重視する場合に適しています。
- 注意点
  MarshalText()のように完全な精度を保持せず、デフォルトで有効桁数が丸められます。
例
```
package main

import (
	"fmt"
	"math/big"
)

func main() {
	f := new(big.Float).SetString("123456789.123456789123456789")
	s := f.String() // String() メソッドを使用
	fmt.Printf("String(): %s\n", s) // 出力例: 1.234567891e+08 (指数表記になる可能性あり)

	f2 := new(big.Float).SetFloat64(0.000000123)
	s2 := f2.String()
	fmt.Printf("String(): %s\n", s2) // 出力例: 1.23e-07
}
```
big.Float.Text(format byte, prec int)メソッド
Text()メソッドは、指定されたフォーマットと精度で*big.Floatの値を文字列に変換します。これは、MarshalText()よりもきめ細やかな制御を可能にします。
- format:
  - 'f' (fixed-point): 固定小数点表記（例: "123.456"）。precは小数点以下の桁数を指定します。
  - 'e' (scientific): 指数表記（例: "1.234e+02"）。precは小数点以下の桁数を指定します。
  - 'g' (general): 値の大きさに応じて 'e' または 'f' を選択します。precは合計有効桁数を指定します。
  - 'E' または 'G' も同様ですが、指数部分が大文字になります。
- prec:
  - 正の値: 指定された桁数で丸めます。
  - -1: 値を一意に識別するために必要な最小限の桁数を使用します（末尾のゼロは省略されます）。これはMarshalText()とは異なり、冗長なゼロを省略するため、よりコンパクトな表現になることがあります。
用途
特定の表示要件（例: 通貨の2桁、グラフ表示の有効桁数など）がある場合に最適です。

例
```
package main

import (
	"fmt"
	"math/big"
)

func main() {
	f := new(big.Float).SetString("123.456789123")

	// 固定小数点表記、小数点以下2桁
	fmt.Printf("Text('f', 2): %s\n", f.Text('f', 2)) // 出力: 123.46

	// 指数表記、小数点以下4桁
	fmt.Printf("Text('e', 4): %s\n", f.Text('e', 4)) // 出力: 1.2346e+02

	// 一般的な表記、合計5桁
	f2 := new(big.Float).SetString("0.00000123456")
	fmt.Printf("Text('g', 5): %s\n", f2.Text('g', 5)) // 出力: 1.2346e-06

	// 必要最小限の桁数（末尾のゼロなし）
	f3 := new(big.Float).SetString("123.00000")
	fmt.Printf("Text('f', -1): %s\n", f3.Text('f', -1)) // 出力: 123
	fmt.Printf("Text('g', -1): %s\n", f3.Text('g', -1)) // 出力: 123
}
```

fmt.Sprintf() / fmt.Fprintf()
big.Floatはfmt.Formatterインターフェースを実装しているため、fmtパッケージのフォーマット動詞（%f, %e, %g, %vなど）を使って直接フォーマットできます。

用途
一般的な文字列フォーマットと同様に、可読性の高い出力や、他の文字列との結合に便利です。
注意点
fmt.Sprintfのデフォルトの動作はString()メソッドと似ていますが、より多くのフォーマットオプションを提供します。

例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f := new(big.Float).SetString("123456789.123456789123")

	// デフォルトのフォーマット（%v は String() に似ている）
	fmt.Printf("%%v: %v\n", f) // 出力例: 1.234567891e+08

	// 固定小数点表記、小数点以下6桁（デフォルト）
	fmt.Printf("%%f: %f\n", f) // 出力例: 123456789.123457

	// 小数点以下2桁に丸める
	fmt.Printf("%%.2f: %.2f\n", f) // 出力例: 123456789.12

	// 指数表記
	fmt.Printf("%%e: %e\n", f) // 出力例: 1.234568e+08

	// 一般的な表記（必要に応じて指数表記）
	fmt.Printf("%%g: %g\n", f) // 出力例: 1.23456789123e+08
}

カスタムMarshalJSON(): jsonパッケージのデフォルトの挙動をオーバーライドし、独自のロジックでJSON文字列を生成する。この中でbig.Float.Text()などを利用してフォーマットを制御できる。
fmt.Sprintf(): fmt.Formatterインターフェースを介して、様々なフォーマット動詞を使用して値を文字列化。
big.Float.Text(format, prec): 指定されたフォーマット（固定小数点、指数表記、一般）と精度で文字列を生成する、最も柔軟なメソッド。
big.Float.String(): デフォルトの有効桁数（通常10桁）で丸められ、自動的に指数表記に切り替わる可読性重視のメソッド。
big.Float.MarshalText(): encoding.TextMarshalerインターフェースを実装しており、完全な精度でテキスト化される。JSONなどで自動的に使用される標準的な方法。

Go言語 big.Floatのテキスト出力：MarshalText()以外の代替メソッドと使い分け

big.Float.MarshalText()とは何か？

使用例

なぜMarshalText()を使うのか？

nilポインタのデリファレンス (Nil Pointer Dereference)

メモリ使用量の問題 (Memory Exhaustion)

不適切な値のエンコード（NaNやInfinity）

精度と表示形式の期待値とのずれ

例1: MarshalText()の基本的な使用方法

例2: JSONエンコーディングでのMarshalText()の利用（最も一般的なケース）

例3: カスタムのMarshalJSONメソッドとMarshalText()の組み合わせ

big.Float.Text(fmt byte, prec int) メソッドの使用

big.Float.String() メソッドの使用

カスタムの MarshalJSON() メソッドの実装

big.Floatの値を整数部と小数部に分解して処理（特殊なケース）

`big.Float.MarshalText()`とは何か？

なぜ`MarshalText()`を使うのか？

例1: `MarshalText()`の基本的な使用方法

例2: JSONエンコーディングでの`MarshalText()`の利用（最も一般的なケース）

例3: カスタムの`MarshalJSON`メソッドと`MarshalText()`の組み合わせ