big.Float.Copy()

このメソッドの主な機能は、指定されたbig.Float型の値を、レシーバ（メソッドを呼び出す側のbig.Floatインスタンス）にコピーすることです。より具体的に言うと、以下の要素がコピーされます。

• 丸めモード（Mode）: その浮動小数点数に設定されている丸めモード。
• 精度（Prec）: その浮動小数点数が持つビット数での精度。
• 値（数）: 浮動小数点数としての正確な値。

なぜCopy()が必要なのか？

Go言語では、big.Floatのような大きな数値型はポインタや構造体として扱われます。直接 = 演算子で代入すると、多くの場合、参照渡し（同じメモリを指す）になってしまいます。しかし、Copy()メソッドを使うことで、新しいbig.Floatオブジェクトに、元のオブジェクトと同じ内容を独立してコピーすることができます。これにより、コピー元のオブジェクトを変更しても、コピー先のオブジェクトには影響がありません。

使用例

以下に簡単な使用例を示します。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// 元のbig.Floatを作成
	f1 := new(big.Float).SetPrec(64).SetFloat64(123.456)
	f1.SetMode(big.ToNearestEven) // 丸めモードを設定

	// コピー先のbig.Floatを宣言
	f2 := new(big.Float)

	// f1の内容をf2にコピー
	f2.Copy(f1)

	fmt.Printf("f1: %s (精度: %d, 丸めモード: %s)\n", f1.Text('g', -1), f1.Prec(), f1.Mode())
	fmt.Printf("f2: %s (精度: %d, 丸めモード: %s)\n", f2.Text('g', -1), f2.Prec(), f2.Mode())

	// f1の値を変更してもf2には影響しないことを確認
	f1.SetFloat64(789.0)
	f1.SetMode(big.ToZero)

	fmt.Println("\nf1の値を変更後:")
	fmt.Printf("f1: %s (精度: %d, 丸めモード: %s)\n", f1.Text('g', -1), f1.Prec(), f1.Mode())
	fmt.Printf("f2: %s (精度: %d, 丸めモード: %s)\n", f2.Text('g', -1), f2.Prec(), f2.Mode())
}

出力例

f1: 123.456 (精度: 64, 丸めモード: ToNearestEven)
f2: 123.456 (精度: 64, 丸めモード: ToNearestEven)

f1の値を変更後:
f1: 789 (精度: 64, 丸めモード: ToZero)
f2: 123.456 (精度: 64, 丸めモード: ToNearestEven)

この出力からわかるように、f1.Copy(f1)を実行した後、f1の値を変更してもf2の値は元のまま保持されています。これは、Copy()がディープコピー（内容の複製）を行っているためです。

---

シャローコピー（浅いコピー）と勘違いする

間違い
big.Float型の変数を = 演算子で代入すると、内容がコピーされると誤解する。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f1 := new(big.Float).SetPrec(64).SetFloat64(1.0)
	f3 := f1 // これはシャローコピー！
	f3.SetFloat64(2.0) // f3を変更するとf1も変わる

	fmt.Printf("f1: %s\n", f1.Text('g', -1)) // 出力: f1: 2
	fmt.Printf("f3: %s\n", f3.Text('g', -1)) // 出力: f3: 2
}

理由
big.Floatは構造体であり、その内部にはポインタが含まれています。= 演算子で代入すると、このポインタが指す先のメモリも同じになるため、実質的に同じオブジェクトを参照することになります。

トラブルシューティング
big.Float.Copy()メソッドを必ず使用して、新しいbig.Floatインスタンスに値をコピーします。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	f1 := new(big.Float).SetPrec(64).SetFloat64(1.0)
	f2 := new(big.Float) // 新しいbig.Floatを初期化
	f2.Copy(f1)           // f1の内容をf2にコピー (ディープコピー)

	f1.SetFloat64(2.0) // f1を変更してもf2には影響しない

	fmt.Printf("f1: %s\n", f1.Text('g', -1)) // 出力: f1: 2
	fmt.Printf("f2: %s\n", f2.Text('g', -1)) // 出力: f2: 1
}

精度の違いによる予期せぬ結果

間違い
Copy()によって値が完全に同じになると思いがちですが、コピー元のbig.Floatとコピー先のbig.Floatの精度（Prec）や丸めモード（Mode）が異なる場合、見た目の値が異なることがあります。

理由
Copy()は、コピー元のPrecとModeもコピーします。しかし、もしコピー先のbig.Floatを明示的にSetPrecなどで初期化していた場合、その設定が上書きされます。また、浮動小数点数の特性として、異なる精度で表現されるとわずかな違いが生じることがあります。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	// 元のbig.Float (高精度)
	f1 := new(big.Float).SetPrec(128).SetFloat64(0.1234567890123456789)

	// コピー先のbig.Float (低精度で初期化)
	f2 := new(big.Float).SetPrec(53) // float64と同じ精度

	f2.Copy(f1) // f1の精度 (128) がf2にコピーされ、f2の元の53は上書きされる

	fmt.Printf("f1: %s (Prec: %d)\n", f1.Text('g', -1), f1.Prec())
	fmt.Printf("f2: %s (Prec: %d)\n", f2.Text('g', -1), f2.Prec())

	// 出力例:
	// f1: 0.1234567890123456789 (Prec: 128)
	// f2: 0.1234567890123456789 (Prec: 128) // f2の精度がf1の精度に変わっている
}

トラブルシューティング

• 浮動小数点数の比較にはCmp()を使う
  厳密な等価性チェックではなく、ある範囲内での近似値を比較する場合、big.Float.Cmp()メソッドや許容誤差（epsilon）を用いた比較を検討します。
• 必要に応じてコピー後に精度を再設定する
  Copy()後に特定の精度や丸めモードにしたい場合は、再度SetPrec()やSetMode()を呼び出します。ただし、これにより元の値が丸められる可能性があることに注意してください。
• コピー元の精度を常に意識する
  Copy()が元のPrecとModeをコピーすることを理解しておく。

無効な値 (NaN) や無限大 (Inf) の扱い

big.FloatはNaN (Not a Number) を直接サポートしておらず、NaNになるような演算（例: 0/0）を行うとpanicが発生します。これはbig.Float.Copy()の直接的なエラーではありませんが、コピー元のbig.FloatがNaNの内部状態を持つことはありません。

トラブルシューティング

• big.Floatは無限大（+Inf, -Inf）はサポートしており、Copy()はこれらの無限大の値も正しくコピーします。
• math/bigパッケージはIEEE 754のNaNを直接扱わないため、計算の途中でNaNになるような場合は、ErrNaNというpanicが発生します。これに対処するには、recoverを使用するか、計算がNaNを生成しないようにロジックを設計する必要があります。

パフォーマンスへの考慮

big.Floatは任意精度演算を行うため、通常のfloat64に比べて計算コストが高いです。Copy()自体は比較的軽量な操作ですが、大量のbig.Floatを頻繁にコピーするようなシナリオでは、パフォーマンスに影響を与える可能性があります。

• 不必要なコピーを避ける
  必要最低限のコピーに留め、可能であれば参照渡し（ポインタを渡す）で済ませるように設計します。ただし、これにより意図しない変更が発生しないよう注意が必要です。
• 本当にbig.Floatが必要か検討する
  多くのケースでfloat64で十分な精度が得られる場合があります。必要に応じてfloat64への変換を検討します。

---

例1: シャローコピー（浅いコピー）とディープコピー（深いコピー）の違い

この例は、=演算子によるシャローコピーと、Copy()メソッドによるディープコピーの違いを明確に示します。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("--- 例1: シャローコピーとディープコピーの違い ---")

	// 1. 元のbig.Floatを作成
	original := new(big.Float).SetPrec(64).SetFloat64(123.456)
	fmt.Printf("元の値 (original): %s (精度: %d, モード: %s)\n",
		original.Text('g', -1), original.Prec(), original.Mode())

	// --- シャローコピーの例 ---
	// "=" 演算子による代入は、同じメモリ領域を指す参照をコピーします。
	shallowCopy := original
	fmt.Printf("\nシャローコピー後 (shallowCopy): %s\n", shallowCopy.Text('g', -1))

	// shallowCopy の値を変更すると、original の値も変わります。
	shallowCopy.SetFloat64(789.0)
	fmt.Println("shallowCopy の値を変更後:")
	fmt.Printf("元の値 (original): %s\n", original.Text('g', -1))       // 789.0 に変わっている
	fmt.Printf("シャローコピー後 (shallowCopy): %s\n", shallowCopy.Text('g', -1)) // 789.0

	// --- ディープコピーの例 ---
	// big.Float.Copy() メソッドは、新しいメモリ領域に値を複製します。
	deepCopy := new(big.Float) // 新しい big.Float インスタンスを作成
	deepCopy.Copy(original)    // original の内容を deepCopy にコピー

	fmt.Printf("\nディープコピー後 (deepCopy): %s\n", deepCopy.Text('g', -1))

	// original の値を再度変更してみる
	original.SetFloat64(10.20)
	fmt.Println("original の値を再度変更後:")
	fmt.Printf("元の値 (original): %s\n", original.Text('g', -1)) // 10.20
	fmt.Printf("ディープコピー後 (deepCopy): %s\n", deepCopy.Text('g', -1))   // 789.0 のまま（影響を受けていない）
}

解説

• deepCopy := new(big.Float)で新しい空のbig.Floatを作成し、deepCopy.Copy(original)とすることで、originalの値、精度、丸めモードがdeepCopyに完全に複製されます。このため、originalを変更してもdeepCopyには影響がありません。
• shallowCopy := originalでは、originalが指すメモリ番地がshallowCopyにも代入されるため、両者は同じbig.Floatオブジェクトを指します。したがって、どちらか一方を変更すると、もう一方もその変更を反映します。

例2: 関数の引数としてbig.Floatを渡す際の注意点

関数内でbig.Floatを操作し、その変更を関数の外に影響させたくない場合にCopy()が役立ちます。

package main

import (
	"fmt"
	"math/big"
)

// changeFloatNotEffectingOriginal は big.Float の値を変更するが、元の引数には影響を与えない
func changeFloatNotEffectingOriginal(f *big.Float) {
	// f はポインタなので、直接変更すると呼び出し元の値も変わってしまう
	// f.SetFloat64(999.999) // これをすると呼び出し元の値が変わってしまう

	// そこで、f のコピーを作成し、そのコピーを操作する
	tempF := new(big.Float)
	tempF.Copy(f) // f の内容を tempF にコピー

	tempF.SetFloat64(999.999) // tempF を変更しても f には影響しない

	fmt.Printf("  関数内 (tempF): %s\n", tempF.Text('g', -1))
}

// changeFloatEffectingOriginal は big.Float の値を変更し、元の引数にも影響を与える
func changeFloatEffectingOriginal(f *big.Float) {
	// f が指すオブジェクトを直接変更する
	f.SetFloat64(888.888)
	fmt.Printf("  関数内 (f): %s\n", f.Text('g', -1))
}

func main() {
	fmt.Println("--- 例2: 関数の引数として big.Float を渡す際の注意点 ---")

	myFloat := new(big.Float).SetPrec(64).SetFloat64(123.0)
	fmt.Printf("関数呼び出し前 (myFloat): %s\n", myFloat.Text('g', -1))

	// changeFloatNotEffectingOriginal を呼び出す
	// ここでは myFloat の値は変わらない
	changeFloatNotEffectingOriginal(myFloat)
	fmt.Printf("changeFloatNotEffectingOriginal 呼び出し後 (myFloat): %s\n", myFloat.Text('g', -1)) // 123.0 のまま

	fmt.Println()

	// changeFloatEffectingOriginal を呼び出す
	// ここでは myFloat の値が変わる
	changeFloatEffectingOriginal(myFloat)
	fmt.Printf("changeFloatEffectingOriginal 呼び出し後 (myFloat): %s\n", myFloat.Text('g', -1)) // 888.888 に変わる
}

解説

• changeFloatNotEffectingOriginalのように、関数内で引数のbig.Floatのコピーを作成し、そのコピーを操作することで、呼び出し元のbig.Floatに影響を与えずに処理を進めることができます。これは「破壊的でない操作」を実現したい場合に非常に有効です。
• big.Floatはポインタで渡されることが多いため、関数内で直接ポインタが指すオブジェクトを変更すると、呼び出し元の値も変わってしまいます。

big.Floatのスライスをコピーする場合にもCopy()が重要になります。

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("--- 例3: big.Float のスライスのコピー ---")

	// 元の big.Float のスライスを作成
	originalSlice := []*big.Float{
		new(big.Float).SetPrec(64).SetFloat64(1.1),
		new(big.Float).SetPrec(64).SetFloat64(2.2),
		new(big.Float).SetPrec(64).SetFloat64(3.3),
	}
	fmt.Println("元のスライス (originalSlice):")
	printFloatSlice(originalSlice)

	// スライス自体をコピーするが、要素はシャローコピーになるため、個々の big.Float は同じオブジェクトを指す
	// これだけではディープコピーにはならない
	copiedSlice := make([]*big.Float, len(originalSlice))
	copy(copiedSlice, originalSlice) // スライス内のポインタがコピーされるだけ

	// コピーされたスライスの最初の要素を変更してみる
	copiedSlice[0].SetFloat64(99.9)

	fmt.Println("\nスライス自体をコピー後、copiedSlice[0] を変更:")
	fmt.Println("元のスライス (originalSlice):")
	printFloatSlice(originalSlice) // originalSlice[0] も変わっている
	fmt.Println("コピーされたスライス (copiedSlice):")
	printFloatSlice(copiedSlice)

	// --- big.Float のディープコピーを含むスライスのコピー ---
	deepCopiedSlice := make([]*big.Float, len(originalSlice))
	for i, f := range originalSlice {
		newF := new(big.Float)
		newF.Copy(f) // 各 big.Float 要素をディープコピー
		deepCopiedSlice[i] = newF
	}

	// originalSlice を再度初期化 (比較のため)
	originalSlice[0].SetFloat64(1.1)
	originalSlice[1].SetFloat64(2.2)
	originalSlice[2].SetFloat64(3.3)

	fmt.Println("\nディープコピーを含むスライスのコピー後:")
	fmt.Println("元のスライス (originalSlice):")
	printFloatSlice(originalSlice)
	fmt.Println("ディープコピーされたスライス (deepCopiedSlice):")
	printFloatSlice(deepCopiedSlice)

	// deepCopiedSlice の最初の要素を変更してみる
	deepCopiedSlice[0].SetFloat64(77.7)

	fmt.Println("\ndeepCopiedSlice[0] を変更後:")
	fmt.Println("元のスライス (originalSlice):")
	printFloatSlice(originalSlice) // originalSlice[0] は変わっていない
	fmt.Println("ディープコピーされたスライス (deepCopiedSlice):")
	printFloatSlice(deepCopiedSlice)
}

// big.Float のスライスを表示するヘルパー関数
func printFloatSlice(s []*big.Float) {
	for i, f := range s {
		fmt.Printf("  [%d]: %s\n", i, f.Text('g', -1))
	}
}

• 各要素をループで回し、new(big.Float)で新しいbig.Floatインスタンスを作成し、そこにCopy()メソッドで元の要素の値を複製することで、スライス全体のディープコピーを実現できます。
• copy(copiedSlice, originalSlice)だけでは、スライス内の*big.Floatのポインタがコピーされるだけで、ポインタが指すbig.Floatオブジェクト自体は複製されません。結果として、copiedSliceの要素を変更するとoriginalSliceの対応する要素も変更されてしまいます。

---

Set() メソッドの使用

Set()メソッドは、既存のbig.Floatに別のbig.Floatの値を設定するために使用できます。結果的にCopy()と同じ効果が得られますが、目的が少し異なります。

• Set(): レシーバに引数のbig.Floatの値を設定します。レシーバの精度と丸めモードは変更しません。ただし、引数がレシーバよりも高精度な場合、レシーバの現在の精度で丸めが行われる可能性があります。
• Copy(): レシーバ（メソッドを呼び出す側のbig.Float）に、引数のbig.Floatの値、精度、丸めモードをコピーします。

コード例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("--- big.Float.Set() の使用 ---")

	f1 := new(big.Float).SetPrec(64).SetFloat64(123.456)
	f1.SetMode(big.ToNearestEven) // 丸めモードを設定

	// f2 を f1 と同じ精度で初期化
	f2 := new(big.Float).SetPrec(f1.Prec())
	f2.SetMode(f1.Mode()) // 必要であれば丸めモードも合わせる

	f2.Set(f1) // f1 の値を f2 に設定

	fmt.Printf("f1: %s (精度: %d, モード: %s)\n", f1.Text('g', -1), f1.Prec(), f1.Mode())
	fmt.Printf("f2: %s (精度: %d, モード: %s)\n", f2.Text('g', -1), f2.Prec(), f2.Mode())

	// f1 を変更しても f2 に影響しないことを確認
	f1.SetFloat64(789.0)
	fmt.Println("\nf1 変更後:")
	fmt.Printf("f1: %s\n", f1.Text('g', -1))
	fmt.Printf("f2: %s\n", f2.Text('g', -1)) // 123.456 のまま
}

利点

• レシーバの精度や丸めモードを明示的に制御したい場合に、SetPrec()やSetMode()と組み合わせて使用できます。
• Copy()と同様に、ディープコピーを実現できます。

欠点

• Copy()が値、精度、丸めモードをすべてコピーするのに対し、Set()は値のみを設定します。精度や丸めモードもコピーしたい場合は、別途それらをレシーバに設定する必要があります。このため、Copy()の方がシンプルで確実な「完全な複製」と言えます。

文字列変換 (SetString/Parse) を介した複製

big.Floatを文字列に変換し、その文字列を新しいbig.Floatにパースすることで、値を複製することができます。これは一般的な方法ではありませんが、デバッグやシリアライズの文脈で役立つことがあります。

コード例

package main

import (
	"fmt"
	"math/big"
)

func main() {
	fmt.Println("--- 文字列変換を介した複製 ---")

	f1 := new(big.Float).SetPrec(64).SetFloat64(0.1234567890123456789)
	f1.SetMode(big.ToNearestEven)

	// big.Float を文字列に変換
	f1Str := f1.Text('g', -1) // 'g' は一般的な書式、-1 は十分な精度で出力

	// 新しい big.Float を作成し、文字列からパース
	f3 := new(big.Float)
	f3.SetPrec(f1.Prec()) // 精度を合わせる
	_, ok := f3.SetString(f1Str)
	if !ok {
		fmt.Println("文字列からのパースに失敗しました")
		return
	}
	f3.SetMode(f1.Mode()) // 丸めモードを合わせる

	fmt.Printf("f1: %s (精度: %d, モード: %s)\n", f1.Text('g', -1), f1.Prec(), f1.Mode())
	fmt.Printf("f3: %s (精度: %d, モード: %s)\n", f3.Text('g', -1), f3.Prec(), f3.Mode())

	// f1 を変更しても f3 に影響しないことを確認
	f1.SetFloat64(0.0001)
	fmt.Println("\nf1 変更後:")
	fmt.Printf("f1: %s\n", f1.Text('g', -1))
	fmt.Printf("f3: %s\n", f3.Text('g', -1)) // 0.123... のまま
}

利点

• デバッグ時や、big.Floatの値をファイルやネットワーク経由でやり取りする際のシリアライズ/デシリアライズの基盤として利用できます。

欠点

• エラーハンドリング
  SetStringはパースに失敗する可能性があるため、エラーチェックが必要です。
• 精度と丸めモードの扱い
  Text()メソッドの書式や精度指定によっては、元のbig.Floatの全ての情報（特に内部的な精度）が文字列に正確に表現されない場合があります。また、SetStringは精度と丸めモードを直接設定しないため、これらを別に設定する必要があります。
• パフォーマンスが低い
  文字列への変換とパースは、直接メモリをコピーするCopy()に比べて大幅にオーバーヘッドが大きいです。

構造体のフィールドとしてbig.Floatを持つ場合の考慮

もしbig.Floatがカスタム構造体のフィールドとして含まれている場合、その構造体のコピーを行う際に注意が必要です。構造体自体のコピーはフィールドのシャローコピーとなるため、big.Floatフィールドも参照渡しになります。

コード例 (構造体内の big.Float のディープコピーの例)

package main

import (
	"fmt"
	"math/big"
)

// MyData は big.Float を含むカスタム構造体
type MyData struct {
	ID    int
	Value *big.Float
}

// DeepCopy は MyData のディープコピーを作成するメソッド
func (d *MyData) DeepCopy() *MyData {
	copiedValue := new(big.Float)
	if d.Value != nil {
		copiedValue.Copy(d.Value) // big.Float のディープコピー
	}

	return &MyData{
		ID:    d.ID,
		Value: copiedValue,
	}
}

func main() {
	fmt.Println("--- 構造体内の big.Float のディープコピー ---")

	originalData := &MyData{
		ID:    1,
		Value: new(big.Float).SetPrec(64).SetFloat64(1.0 / 3.0),
	}
	fmt.Printf("元のデータ (originalData): %+v (Value: %s)\n",
		originalData, originalData.Value.Text('g', -1))

	// MyData のシャローコピー (Value フィールドは同じ big.Float を指す)
	shallowCopiedData := originalData
	shallowCopiedData.Value.SetFloat64(0.5) // originalData.Value も変更される

	fmt.Printf("\nシャローコピー後 (shallowCopiedData): %+v (Value: %s)\n",
		shallowCopiedData, shallowCopiedData.Value.Text('g', -1))
	fmt.Printf("元のデータ (originalData): %+v (Value: %s)\n",
		originalData, originalData.Value.Text('g', -1)) // 0.5 に変わっている

	// 元のデータをリセット
	originalData.Value.SetFloat64(1.0 / 3.0)

	// MyData のディープコピー (Value フィールドも複製される)
	deepCopiedData := originalData.DeepCopy()
	deepCopiedData.Value.SetFloat64(0.75) // originalData.Value には影響しない

	fmt.Printf("\nディープコピー後 (deepCopiedData): %+v (Value: %s)\n",
		deepCopiedData, deepCopiedData.Value.Text('g', -1))
	fmt.Printf("元のデータ (originalData): %+v (Value: %s)\n",
		originalData, originalData.Value.Text('g', -1)) // 1/3 のまま
}

利点

• 構造体の利用者にとって、内部のbig.Floatがどのように複製されるかを意識する必要がなくなります。
• 複雑なデータ構造全体を安全に複製できます。

欠点

• 各構造体にディープコピー用のメソッドを実装する必要があり、コード量が増えます。

big.Float.Copy()は、big.Floatの完全なディープコピーを行うための最も直接的で推奨される方法です。

代替手段は以下の目的で検討されることがあります。

1. Set(): 精度や丸めモードはレシーバの設定を維持しつつ、値だけをコピーしたい場合。
2. 文字列変換: デバッグ、ロギング、シリアライズなど、人間が読める形式や外部ストレージへの永続化が必要な場合。ただし、パフォーマンスと精度保持に注意が必要です。
3. カスタム構造体内のディープコピー: 複雑なデータ構造の一部としてbig.Floatが存在し、その構造体全体のディープコピーが必要な場合。