Add MustParseInt

Author: itsubaki

cmd/counting/main.go

@@ -77,12 +77,16 @@ func main() {
 	qsim.InvQFT(c...)
 
 	// results
-	N, size := 1<<len(r), 1<<t
-	for _, s := range q.Top(qsim.State(c, r, s, a), top) {
-		phi := float64(s.Int()[0]) / float64(size)       // phi = k / 2**t
+	N := 1 << len(r)
+	for _, state := range q.Top(qsim.State(c, r, s, a), top) {
+		phi := ldexp(state.Int()[0], -t)                 // phi = k / 2**t
 		theta := 2 * math.Pi * phi                       // theta = 2*pi*phi
 		M := float64(N) * math.Pow(math.Sin(theta/2), 2) // M = N*(sin(theta/2))**2
 
-		fmt.Printf("%v; phi=%.4f, theta=%.4f, M=%.4f, M'=%.4f\n", s, phi, theta, M, float64(N)-M)
+		fmt.Printf("%v; phi=%.4f, theta=%.4f, M=%.4f, M'=%.4f\n", state, phi, theta, M, float64(N)-M)
 	}
 }
+
+func ldexp(a, b int) float64 {
+	return math.Ldexp(float64(a), b)
+}

cmd/grover/main.go

@@ -103,8 +103,8 @@ func main() {
 	}
 
 	// quantum states
-	for _, s := range q.Top(qsim.State(r, s, a), top) {
-		fmt.Println(s)
+	for _, state := range q.Top(qsim.State(r, s, a), top) {
+		fmt.Println(state)
 	}
 
 	// measure

cmd/shor/main.go

@@ -85,23 +85,23 @@ func main() {
 	print("measure reg1", qsim, r0, r1)
 
 	var prop float64
-	for _, s := range qsim.State(r0) {
-		i, m := s.Int()[0], s.BinaryString()[0]
-		ss, r, d, ok := number.FindOrder(a, N, fmt.Sprintf("0.%s", m))
+	for _, state := range qsim.State(r0) {
+		i, m := state.Int()[0], state.BinaryString()[0]
+		s, r, d, ok := number.FindOrder(a, N, fmt.Sprintf("0.%s", m))
 		if !ok || number.IsOdd(r) {
-			fmt.Printf("  i=%4d: N=%d, a=%d, t=%d; s/r=%4d/%4d ([0.%v]~%.4f);\n", i, N, a, t, ss, r, m, d)
+			fmt.Printf("  i=%4d: N=%d, a=%d, t=%d; s/r=%4d/%4d ([0.%v]~%.4f);\n", i, N, a, t, s, r, m, d)
 			continue
 		}
 
 		p0 := number.GCD(number.Pow(a, r/2)-1, N)
 		p1 := number.GCD(number.Pow(a, r/2)+1, N)
 		if number.IsTrivial(N, p0, p1) {
-			fmt.Printf("  i=%4d: N=%d, a=%d, t=%d; s/r=%4d/%4d ([0.%v]~%.4f); p=%v, q=%v.\n", i, N, a, t, ss, r, m, d, p0, p1)
+			fmt.Printf("  i=%4d: N=%d, a=%d, t=%d; s/r=%4d/%4d ([0.%v]~%.4f); p=%v, q=%v.\n", i, N, a, t, s, r, m, d, p0, p1)
 			continue
 		}
 
-		fmt.Printf("* i=%4d: N=%d, a=%d, t=%d; s/r=%4d/%4d ([0.%v]~%.4f); p=%v, q=%v.\n", i, N, a, t, ss, r, m, d, p0, p1)
-		prop += s.Probability()
+		fmt.Printf("* i=%4d: N=%d, a=%d, t=%d; s/r=%4d/%4d ([0.%v]~%.4f); p=%v, q=%v.\n", i, N, a, t, s, r, m, d, p0, p1)
+		prop += state.Probability()
 	}
 
 	fmt.Printf("total probability: %.8f\n", prop)
@@ -111,9 +111,9 @@ func print(desc string, qsim *q.Q, reg ...any) {
 	fmt.Println(desc)
 
 	max := slices.Max(qsim.Probability())
-	for _, s := range qsim.State(reg...) {
-		p := strings.Repeat("*", int(s.Probability()/max*32))
-		fmt.Printf("%s: %s\n", s, p)
+	for _, state := range qsim.State(reg...) {
+		p := strings.Repeat("*", int(state.Probability()/max*32))
+		fmt.Printf("%s: %s\n", state, p)
 	}
 
 	fmt.Println()

math/number/parse.go

@@ -44,3 +44,9 @@ func ParseFloat(binary string) (float64, error) {
 
 	return float64(p) + frac, nil
 }
+
+// MustParseInt returns int from binary string.
+// It panics if error occurs.
+func MustParseInt(binary string) int {
+	return int(Must(strconv.ParseInt(binary, 2, 0)))
+}

quantum/density/matrix.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"iter"
 	"math"
-	"strconv"
 	"strings"
 
 	"github.com/itsubaki/q/math/epsilon"
@@ -202,8 +201,8 @@ func (m *Matrix) PartialTrace(idx ...Qubit) *Matrix {
 				continue
 			}
 
-			r := int(number.Must(strconv.ParseInt(kr, 2, 0)))
-			c := int(number.Must(strconv.ParseInt(lr, 2, 0)))
+			r := number.MustParseInt(kr)
+			c := number.MustParseInt(lr)
 			rho.AddAt(r, c, m.At(i, j))
 
 			// fmt.Printf("[%v][%v] = [%v][%v] + [%v][%v]\n", r, c, r, c, i, j)

quantum/qubit/qubit.go

@@ -3,7 +3,6 @@ package qubit
 import (
 	"math"
 	"math/cmplx"
-	"strconv"
 	"strings"
 
 	"github.com/itsubaki/q/math/epsilon"
@@ -683,8 +682,8 @@ func (q *Qubit) BinaryString() string {
 }
 
 // Int measures the quantum state and returns its int representation.
-func (q *Qubit) Int() int64 {
-	return number.Must(strconv.ParseInt(q.BinaryString(), 2, 0))
+func (q *Qubit) Int() int {
+	return number.MustParseInt(q.BinaryString())
 }
 
 // String returns the string representation of q.

quantum/qubit/qubit_test.go

@@ -990,7 +990,7 @@ func TestClone(t *testing.T) {
 func TestInt(t *testing.T) {
 	cases := []struct {
 		in   *qubit.Qubit
-		want int64
+		want int
 	}{
 		{qubit.Zero(), 0},
 		{qubit.One(), 1},

quantum/qubit/state.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math"
 	"math/cmplx"
-	"strconv"
 
 	"github.com/itsubaki/q/math/epsilon"
 	"github.com/itsubaki/q/math/number"
@@ -15,14 +14,14 @@ type State struct {
 	amp          complex128
 	prob         float64
 	binaryString []string
-	intValue     []int64
+	intValue     []int
 }
 
 // NewState returns a new State.
 func NewState(amp complex128, binary ...string) State {
-	intv := make([]int64, len(binary))
+	intv := make([]int, len(binary))
 	for i, b := range binary {
-		intv[i] = number.Must(strconv.ParseInt(b, 2, 0))
+		intv[i] = number.MustParseInt(b)
 	}
 
 	return State{
@@ -45,7 +44,7 @@ func (s State) BinaryString() []string {
 	return s.binaryString
 }
 
-func (s State) Int() []int64 {
+func (s State) Int() []int {
 	return s.intValue
 }