heisenberg

package module
v0.0.0-...-b5387b9 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 1, 2023 License: BSD-3-Clause Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// CutoffPercent is the precent for sparse matrix cutoff
	CutoffPercent = .1
	// CutoffSize is the size of a matrix row required for dense
	CutoffSize = 256
)

Variables

This section is empty.

Functions

func Optimize 

func Optimize(width, depth int, probabilities [][2][]float64)

Optimize is an implementation of genetic optimize

Types

type Dense128 

type Dense128 struct {
	R, C   int
	Matrix []complex128
}

Dense128 is an algebriac matrix

func HDense128 

func HDense128() *Dense128

HDense128 Hadamard matrix

func IDense128 

func IDense128() *Dense128

IDense128 identity matrix

func RXDense128 

func RXDense128(theta complex128) *Dense128

RXDense128 x rotation matrix

func RYDense128 

func RYDense128(theta complex128) *Dense128

RYDense128 y rotation matrix

func RZDense128 

func RZDense128(theta complex128) *Dense128

RZDense128 z rotation matrix

func SDense128 

func SDense128() *Dense128

SDense128 phase gate

func TDense128 

func TDense128() *Dense128

TDense128 T gate

func UDense128 

func UDense128(theta, phi, lambda float64) *Dense128

UDense128 U gate

func XDense128 

func XDense128() *Dense128

XDense128 Pauli X matrix

func YDense128 

func YDense128() *Dense128

YDense128 Pauli Y matrix

func ZDense128 

func ZDense128() *Dense128

ZDense128 Pauli Z matrix

func (*Dense128) Conjugate 

func (a *Dense128) Conjugate()

Conjugate computes the complex conjugate

func (*Dense128) Copy 

func (a *Dense128) Copy() *Dense128

Copy copies a matrix`

func (*Dense128) Mul 

func (a *Dense128) Mul(b *Dense128)

ComplexMul multiplies two complex matrices

func (*Dense128) Multiply 

func (a *Dense128) Multiply(b *Dense128) *Dense128

Multiply multiplies to matricies

func (Dense128) String 

func (a Dense128) String() string

func (*Dense128) Sub 

func (a *Dense128) Sub(b *Dense128)

Sub subtracts two matrices

func (*Dense128) Tensor 

func (a *Dense128) Tensor(b *Dense128) *Dense128

Tensor product is the tensor product

func (*Dense128) Transpose 

func (a *Dense128) Transpose()

Transpose transposes a matrix

type Dense64 

type Dense64 struct {
	R, C   int
	Matrix []complex64
}

Dense64 is an algebriac matrix

func HDense64 

func HDense64() *Dense64

HDense64 Hadamard matrix

func IDense64 

func IDense64() *Dense64

IDense64 identity matrix

func RXDense64 

func RXDense64(theta complex128) *Dense64

RXDense64 x rotation matrix

func RYDense64 

func RYDense64(theta complex128) *Dense64

RYDense64 y rotation matrix

func RZDense64 

func RZDense64(theta complex128) *Dense64

RZDense64 z rotation matrix

func SDense64 

func SDense64() *Dense64

SDense64 phase gate

func TDense64 

func TDense64() *Dense64

TDense64 T gate

func UDense64 

func UDense64(theta, phi, lambda float64) *Dense64

UDense64 U gate

func XDense64 

func XDense64() *Dense64

XDense64 Pauli X matrix

func YDense64 

func YDense64() *Dense64

YDense64 Pauli Y matrix

func ZDense64 

func ZDense64() *Dense64

ZDense64 Pauli Z matrix

func (*Dense64) Copy 

func (a *Dense64) Copy() *Dense64

Copy copies a matrix`

func (*Dense64) Multiply 

func (a *Dense64) Multiply(b *Dense64) *Dense64

Multiply multiplies to matricies

func (Dense64) String 

func (a Dense64) String() string

func (*Dense64) Tensor 

func (a *Dense64) Tensor(b *Dense64) *Dense64

Tensor product is the tensor product

func (*Dense64) Transpose 

func (a *Dense64) Transpose()

Transpose transposes a matrix

type Gate 

type Gate struct {
	GateType
	Qubits             []Qubit
	Target             Qubit
	Theta, Phi, Lambda float64
}

Gate is a gate

type GateType 

type GateType int

GateType is a type of gate 

const (
	// GateTypeControlledNot controlled not gate
	GateTypeControlledNot GateType = iota
	// GateTypeI multiply by identity
	GateTypeI
	// GateTypeH multiply by Hadamard gate
	GateTypeH
	// GateTypeX multiply by Pauli X matrix
	GateTypeX
	// GateTypeY multiply by Pauli Y matrix
	GateTypeY
	// GateTypeZ multiply by Pauli Z matrix
	GateTypeZ
	// GateTypeS multiply by phase matrix
	GateTypeS
	// GateTypeT multiply by T matrix
	GateTypeT
	// GateTypeU multiply by U matrix
	GateTypeU
	// GateTypeRX rotate X gate
	GateTypeRX
	// GateTypeRY rotate Y gate
	GateTypeRY
	// GateTypeRZ rotate Z gate
	GateTypeRZ
)

type Genome 

type Genome struct {
	Gates         []Gate
	Fitness       float64
	Width         int
	Probabilities [][2][]float64
}

Genome is a quantum circuit

func (*Genome) Copy 

func (g *Genome) Copy() Genome

Copy copies a genome

func (*Genome) Execute 

func (g *Genome) Execute()

Execute the gates

type MachineDense128 

type MachineDense128 struct {
	Dense128
	Qubits int
}

MachineDense128 is a 128 bit dense matrix machine

func (*MachineDense128) ControlledNot 

func (a *MachineDense128) ControlledNot(c []Qubit, t Qubit) *Dense128

ControlledNot controlled not gate

func (*MachineDense128) H 

func (a *MachineDense128) H(qubits ...Qubit) *MachineDense128

H multiply by Hadamard gate

func (*MachineDense128) I 

func (a *MachineDense128) I(qubits ...Qubit) *MachineDense128

I multiply by identity

func (*MachineDense128) Multiply 

func (a *MachineDense128) Multiply(b *Dense128, c ...Qubit)

Multiply multiplies the machine by a matrix

func (*MachineDense128) One 

func (a *MachineDense128) One() Qubit

One adds a one to the matrix

func (*MachineDense128) Points 

func (d *MachineDense128) Points() []Point

Points returns the point representation of the quantum algorithm.

func (*MachineDense128) RX 

func (a *MachineDense128) RX(theta float64, qubits ...Qubit) *MachineDense128

RX rotate X gate

func (*MachineDense128) RY 

func (a *MachineDense128) RY(theta float64, qubits ...Qubit) *MachineDense128

RY rotate Y gate

func (*MachineDense128) RZ 

func (a *MachineDense128) RZ(theta float64, qubits ...Qubit) *MachineDense128

RZ rotate Z gate

func (*MachineDense128) S 

func (a *MachineDense128) S(qubits ...Qubit) *MachineDense128

S multiply by phase matrix

func (*MachineDense128) Swap 

func (a *MachineDense128) Swap(qubits ...Qubit) *MachineDense128

Swap swaps qubits`

func (*MachineDense128) T 

func (a *MachineDense128) T(qubits ...Qubit) *MachineDense128

T multiply by T matrix

func (*MachineDense128) U 

func (a *MachineDense128) U(theta, phi, lambda float64, qubits ...Qubit) *MachineDense128

U multiply by U matrix

func (*MachineDense128) X 

func (a *MachineDense128) X(qubits ...Qubit) *MachineDense128

X multiply by Pauli X matrix

func (*MachineDense128) Y 

func (a *MachineDense128) Y(qubits ...Qubit) *MachineDense128

Y multiply by Pauli Y matrix

func (*MachineDense128) Z 

func (a *MachineDense128) Z(qubits ...Qubit) *MachineDense128

Z multiply by Pauli Z matrix

func (*MachineDense128) Zero 

func (a *MachineDense128) Zero() Qubit

Zero adds a zero to the matrix

type MachineDense64 

type MachineDense64 struct {
	Dense64
	Qubits int
}

MachineDense64 is a 64 bit dense matrix machine

func (*MachineDense64) ControlledNot 

func (a *MachineDense64) ControlledNot(c []Qubit, t Qubit) *Dense64

ControlledNot controlled not gate

func (*MachineDense64) H 

func (a *MachineDense64) H(qubits ...Qubit) *MachineDense64

H multiply by Hadamard gate

func (*MachineDense64) I 

func (a *MachineDense64) I(qubits ...Qubit) *MachineDense64

I multiply by identity

func (*MachineDense64) Multiply 

func (a *MachineDense64) Multiply(b *Dense64, qubits ...Qubit)

Multiply multiplies the machine by a matrix

func (*MachineDense64) One 

func (a *MachineDense64) One() Qubit

One adds a one to the matrix

func (*MachineDense64) RX 

func (a *MachineDense64) RX(theta float64, qubits ...Qubit) *MachineDense64

RX rotate X gate

func (*MachineDense64) RY 

func (a *MachineDense64) RY(theta float64, qubits ...Qubit) *MachineDense64

RY rotate Y gate

func (*MachineDense64) RZ 

func (a *MachineDense64) RZ(theta float64, qubits ...Qubit) *MachineDense64

RZ rotate Z gate

func (*MachineDense64) S 

func (a *MachineDense64) S(qubits ...Qubit) *MachineDense64

S multiply by phase matrix

func (*MachineDense64) Swap 

func (a *MachineDense64) Swap(qubits ...Qubit) *MachineDense64

Swap swaps qubits`

func (*MachineDense64) T 

func (a *MachineDense64) T(qubits ...Qubit) *MachineDense64

T multiply by T matrix

func (*MachineDense64) U 

func (a *MachineDense64) U(theta, phi, lambda float64, qubits ...Qubit) *MachineDense64

U multiply by U matrix

func (*MachineDense64) X 

func (a *MachineDense64) X(qubits ...Qubit) *MachineDense64

X multiply by Pauli X matrix

func (*MachineDense64) Y 

func (a *MachineDense64) Y(qubits ...Qubit) *MachineDense64

Y multiply by Pauli Y matrix

func (*MachineDense64) Z 

func (a *MachineDense64) Z(qubits ...Qubit) *MachineDense64

Z multiply by Pauli Z matrix

func (*MachineDense64) Zero 

func (a *MachineDense64) Zero() Qubit

Zero adds a zero to the matrix

type MachineMatrix128 

type MachineMatrix128 struct {
	Vector128
	Qubits int
}

MachineMatrix128 is a 128 bit sparse matrix machine

func (*MachineMatrix128) ControlledNot 

func (a *MachineMatrix128) ControlledNot(c []Qubit, t Qubit) *Matrix128

ControlledNot controlled not gate

func (*MachineMatrix128) H 

func (a *MachineMatrix128) H(qubits ...Qubit) *MachineMatrix128

H multiply by Hadamard gate

func (*MachineMatrix128) I 

func (a *MachineMatrix128) I(qubits ...Qubit) *MachineMatrix128

I multiply by identity

func (*MachineMatrix128) Multiply 

func (a *MachineMatrix128) Multiply(b *Matrix128, qubits ...Qubit)

Multiply multiplies the machine by a matrix

func (*MachineMatrix128) One 

func (a *MachineMatrix128) One() Qubit

One adds a one to the matrix

func (*MachineMatrix128) RX 

func (a *MachineMatrix128) RX(theta float64, qubits ...Qubit) *MachineMatrix128

RX rotate X gate

func (*MachineMatrix128) RY 

func (a *MachineMatrix128) RY(theta float64, qubits ...Qubit) *MachineMatrix128

RY rotate Y gate

func (*MachineMatrix128) RZ 

func (a *MachineMatrix128) RZ(theta float64, qubits ...Qubit) *MachineMatrix128

RZ rotate Z gate

func (*MachineMatrix128) S 

func (a *MachineMatrix128) S(qubits ...Qubit) *MachineMatrix128

S multiply by phase matrix

func (*MachineMatrix128) Swap 

func (a *MachineMatrix128) Swap(qubits ...Qubit) *MachineMatrix128

Swap swaps qubits`

func (*MachineMatrix128) T 

func (a *MachineMatrix128) T(qubits ...Qubit) *MachineMatrix128

T multiply by T matrix

func (*MachineMatrix128) U 

func (a *MachineMatrix128) U(theta, phi, lambda float64, qubits ...Qubit) *MachineMatrix128

U multiply by U matrix

func (*MachineMatrix128) X 

func (a *MachineMatrix128) X(qubits ...Qubit) *MachineMatrix128

X multiply by Pauli X matrix

func (*MachineMatrix128) Y 

func (a *MachineMatrix128) Y(qubits ...Qubit) *MachineMatrix128

Y multiply by Pauli Y matrix

func (*MachineMatrix128) Z 

func (a *MachineMatrix128) Z(qubits ...Qubit) *MachineMatrix128

Z multiply by Pauli Z matrix

func (*MachineMatrix128) Zero 

func (a *MachineMatrix128) Zero() Qubit

Zero adds a zero to the matrix

type MachineSparse128 

type MachineSparse128 struct {
	Vector128
	Qubits int
}

MachineSparse128 is a 128 bit sparse matrix machine

func (*MachineSparse128) ControlledNot 

func (a *MachineSparse128) ControlledNot(c []Qubit, t Qubit) *Sparse128

ControlledNot controlled not gate

func (*MachineSparse128) H 

func (a *MachineSparse128) H(qubits ...Qubit) *MachineSparse128

H multiply by Hadamard gate

func (*MachineSparse128) I 

func (a *MachineSparse128) I(qubits ...Qubit) *MachineSparse128

I multiply by identity

func (*MachineSparse128) Multiply 

func (a *MachineSparse128) Multiply(b *Sparse128, qubits ...Qubit)

Multiply multiplies the machine by a matrix

func (*MachineSparse128) One 

func (a *MachineSparse128) One() Qubit

One adds a one to the matrix

func (*MachineSparse128) RX 

func (a *MachineSparse128) RX(theta float64, qubits ...Qubit) *MachineSparse128

RX rotate X gate

func (*MachineSparse128) RY 

func (a *MachineSparse128) RY(theta float64, qubits ...Qubit) *MachineSparse128

RY rotate Y gate

func (*MachineSparse128) RZ 

func (a *MachineSparse128) RZ(theta float64, qubits ...Qubit) *MachineSparse128

RZ rotate Z gate

func (*MachineSparse128) S 

func (a *MachineSparse128) S(qubits ...Qubit) *MachineSparse128

S multiply by phase matrix

func (*MachineSparse128) Swap 

func (a *MachineSparse128) Swap(qubits ...Qubit) *MachineSparse128

Swap swaps qubits`

func (*MachineSparse128) T 

func (a *MachineSparse128) T(qubits ...Qubit) *MachineSparse128

T multiply by T matrix

func (*MachineSparse128) U 

func (a *MachineSparse128) U(theta, phi, lambda float64, qubits ...Qubit) *MachineSparse128

U multiply by U matrix

func (*MachineSparse128) X 

func (a *MachineSparse128) X(qubits ...Qubit) *MachineSparse128

X multiply by Pauli X matrix

func (*MachineSparse128) Y 

func (a *MachineSparse128) Y(qubits ...Qubit) *MachineSparse128

Y multiply by Pauli Y matrix

func (*MachineSparse128) Z 

func (a *MachineSparse128) Z(qubits ...Qubit) *MachineSparse128

Z multiply by Pauli Z matrix

func (*MachineSparse128) Zero 

func (a *MachineSparse128) Zero() Qubit

Zero adds a zero to the matrix

type MachineSparse64 

type MachineSparse64 struct {
	Vector64
	Qubits int
}

MachineSparse64 is a 64 bit sparse matrix machine

func (*MachineSparse64) ControlledNot 

func (a *MachineSparse64) ControlledNot(c []Qubit, t Qubit) *Sparse64

ControlledNot controlled not gate

func (*MachineSparse64) H 

func (a *MachineSparse64) H(qubits ...Qubit) *MachineSparse64

H multiply by Hadamard gate

func (*MachineSparse64) I 

func (a *MachineSparse64) I(qubits ...Qubit) *MachineSparse64

I multiply by identity

func (*MachineSparse64) Multiply 

func (a *MachineSparse64) Multiply(b *Sparse64, qubits ...Qubit)

Multiply multiplies the machine by a matrix

func (*MachineSparse64) One 

func (a *MachineSparse64) One() Qubit

One adds a one to the matrix

func (*MachineSparse64) RX 

func (a *MachineSparse64) RX(theta float64, qubits ...Qubit) *MachineSparse64

RX rotate X gate

func (*MachineSparse64) RY 

func (a *MachineSparse64) RY(theta float64, qubits ...Qubit) *MachineSparse64

RY rotate Y gate

func (*MachineSparse64) RZ 

func (a *MachineSparse64) RZ(theta float64, qubits ...Qubit) *MachineSparse64

RZ rotate Z gate

func (*MachineSparse64) S 

func (a *MachineSparse64) S(qubits ...Qubit) *MachineSparse64

S multiply by phase matrix

func (*MachineSparse64) Swap 

func (a *MachineSparse64) Swap(qubits ...Qubit) *MachineSparse64

Swap swaps qubits`

func (*MachineSparse64) T 

func (a *MachineSparse64) T(qubits ...Qubit) *MachineSparse64

T multiply by T matrix

func (*MachineSparse64) U 

func (a *MachineSparse64) U(theta, phi, lambda float64, qubits ...Qubit) *MachineSparse64

U multiply by U matrix

func (*MachineSparse64) X 

func (a *MachineSparse64) X(qubits ...Qubit) *MachineSparse64

X multiply by Pauli X matrix

func (*MachineSparse64) Y 

func (a *MachineSparse64) Y(qubits ...Qubit) *MachineSparse64

Y multiply by Pauli Y matrix

func (*MachineSparse64) Z 

func (a *MachineSparse64) Z(qubits ...Qubit) *MachineSparse64

Z multiply by Pauli Z matrix

func (*MachineSparse64) Zero 

func (a *MachineSparse64) Zero() Qubit

Zero adds a zero to the matrix

type Matrix128 

type Matrix128 struct {
	R, C   int
	Matrix []interface{}
}

Matrix128 is an algebriac matrix

func HMatrix128 

func HMatrix128() *Matrix128

HMatrix128 Hadamard matrix

func IMatrix128 

func IMatrix128() *Matrix128

IMatrix128 identity matrix

func RXMatrix128 

func RXMatrix128(theta complex128) *Matrix128

RXMatrix128 x rotation matrix

func RYMatrix128 

func RYMatrix128(theta complex128) *Matrix128

RYMatrix128 y rotation matrix

func RZMatrix128 

func RZMatrix128(theta complex128) *Matrix128

RZMatrix128 z rotation matrix

func SMatrix128 

func SMatrix128() *Matrix128

SMatrix128 phase gate

func TMatrix128 

func TMatrix128() *Matrix128

TMatrix128 T gate

func UMatrix128 

func UMatrix128(theta, phi, lambda float64) *Matrix128

UMatrix128 U gate

func XMatrix128 

func XMatrix128() *Matrix128

XMatrix128 Pauli X matrix

func YMatrix128 

func YMatrix128() *Matrix128

YMatrix128 Pauli Y matrix

func ZMatrix128 

func ZMatrix128() *Matrix128

ZMatrix128 Pauli Z matrix

func (*Matrix128) Copy 

func (a *Matrix128) Copy() *Matrix128

Copy copies a matrix`

func (*Matrix128) Get 

func (a *Matrix128) Get(i, j int) complex128

Get get a value

func (*Matrix128) Multiply 

func (a *Matrix128) Multiply(b *Matrix128) *Matrix128

Multiply multiplies to matricies

func (*Matrix128) MultiplyVector 

func (a *Matrix128) MultiplyVector(b Vector128) Vector128

MultiplyVector multiplies a matrix by a vector

func (*Matrix128) Set 

func (a *Matrix128) Set(i, j int, value complex128)

Set set a value

func (Matrix128) String 

func (a Matrix128) String() string

func (*Matrix128) Tensor 

func (a *Matrix128) Tensor(b *Matrix128) *Matrix128

Tensor product is the tensor product

func (*Matrix128) Transpose 

func (a *Matrix128) Transpose() *Matrix128

Transpose transposes a matrix

type Point 

type Point struct {
	X, Y float64
}

type Qubit 

type Qubit uint64

Qubit is a qubit

type Sparse128 

type Sparse128 struct {
	R, C   int
	Matrix []map[int]complex128
}

Sparse128 is an algebriac matrix

func HSparse128 

func HSparse128() *Sparse128

HSparse128 Hadamard matrix

func ISparse128 

func ISparse128() *Sparse128

ISparse128 identity matrix

func RXSparse128 

func RXSparse128(theta complex128) *Sparse128

RXSparse128 x rotation matrix

func RYSparse128 

func RYSparse128(theta complex128) *Sparse128

RYSparse128 y rotation matrix

func RZSparse128 

func RZSparse128(theta complex128) *Sparse128

RZSparse128 z rotation matrix

func SSparse128 

func SSparse128() *Sparse128

SSparse128 phase gate

func TSparse128 

func TSparse128() *Sparse128

TSparse128 T gate

func USparse128 

func USparse128(theta, phi, lambda float64) *Sparse128

USparse128 U gate

func XSparse128 

func XSparse128() *Sparse128

XSparse128 Pauli X matrix

func YSparse128 

func YSparse128() *Sparse128

YSparse128 Pauli Y matrix

func ZSparse128 

func ZSparse128() *Sparse128

ZSparse128 Pauli Z matrix

func (*Sparse128) Copy 

func (a *Sparse128) Copy() *Sparse128

Copy copies a matrix`

func (*Sparse128) Multiply 

func (a *Sparse128) Multiply(b *Sparse128) *Sparse128

Multiply multiplies to matricies

func (*Sparse128) MultiplyVector 

func (a *Sparse128) MultiplyVector(b Vector128) Vector128

MultiplyVector multiplies a matrix by a vector

func (Sparse128) String 

func (a Sparse128) String() string

func (*Sparse128) Tensor 

func (a *Sparse128) Tensor(b *Sparse128) *Sparse128

Tensor product is the tensor product

func (*Sparse128) Transpose 

func (a *Sparse128) Transpose()

Transpose transposes a matrix

type Sparse64 

type Sparse64 struct {
	R, C   int
	Matrix []map[int]complex64
}

Sparse64 is an algebriac matrix

func HSparse64 

func HSparse64() *Sparse64

HSparse64 Hadamard matrix

func ISparse64 

func ISparse64() *Sparse64

ISparse64 identity matrix

func RXSparse64 

func RXSparse64(theta complex128) *Sparse64

RXSparse64 x rotation matrix

func RYSparse64 

func RYSparse64(theta complex128) *Sparse64

RYSparse64 y rotation matrix

func RZSparse64 

func RZSparse64(theta complex128) *Sparse64

RZSparse64 z rotation matrix

func SSparse64 

func SSparse64() *Sparse64

SSparse64 phase gate

func TSparse64 

func TSparse64() *Sparse64

TSparse64 T gate

func USparse64 

func USparse64(theta, phi, lambda float64) *Sparse64

USparse64 U gate

func XSparse64 

func XSparse64() *Sparse64

XSparse64 Pauli X matrix

func YSparse64 

func YSparse64() *Sparse64

YSparse64 Pauli Y matrix

func ZSparse64 

func ZSparse64() *Sparse64

ZSparse64 Pauli Z matrix

func (*Sparse64) Copy 

func (a *Sparse64) Copy() *Sparse64

Copy copies a matrix`

func (*Sparse64) Multiply 

func (a *Sparse64) Multiply(b *Sparse64) *Sparse64

Multiply multiplies to matricies

func (*Sparse64) MultiplyVector 

func (a *Sparse64) MultiplyVector(b Vector64) Vector64

MultiplyVector multiplies a matrix by a vector

func (Sparse64) String 

func (a Sparse64) String() string

func (*Sparse64) Tensor 

func (a *Sparse64) Tensor(b *Sparse64) *Sparse64

Tensor product is the tensor product

func (*Sparse64) Transpose 

func (a *Sparse64) Transpose()

Transpose transposes a matrix

type Vector128 

type Vector128 []complex128

Vector128 is a 128 bit vector

func (Vector128) String 

func (a Vector128) String() string

func (Vector128) Tensor 

func (a Vector128) Tensor(b Vector128) Vector128

Tensor product is the tensor product

type Vector64 

type Vector64 []complex64

Vector64 is a 64 bit vector

func (Vector64) String 

func (a Vector64) String() string

func (Vector64) Tensor 

func (a Vector64) Tensor(b Vector64) Vector64

Tensor product is the tensor product

Source Files

View all Source files

Directories

Path Synopsis
cmd
alchemy
heisenberg

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.