// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Package big implements arbitrary-precision arithmetic (big numbers).
The following numeric types are supported:

	Int    signed integers
	Rat    rational numbers
	Float  floating-point numbers

The zero value for an [Int], [Rat], or [Float] correspond to 0. Thus, new

// license that can be found in the LICENSE file.

//go:build !math_big_pure_go && (mips || mipsle)

#include "textflag.h"

// This file provides fast assembly versions for the elementary
// arithmetic operations on vectors implemented in arith.go.

TEXT ·addVV(SB),NOSPLIT,$0
	JMP	·addVV_g(SB)

TEXT ·subVV(SB),NOSPLIT,$0
	JMP	·subVV_g(SB)

TEXT ·addVW(SB),NOSPLIT,$0
	JMP	·addVW_g(SB)

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

/**
 * Arithmetic functions operating on primitive values and on {@link java.math.BigInteger} and {@link
 * java.math.BigDecimal} instances.
 *
 * <p>This package is a part of the open-source <a href="https://github.com/google/guava">Guava</a>

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

/**
 * Arithmetic functions operating on primitive values and on {@link java.math.BigInteger} and {@link
 * java.math.BigDecimal} instances.
 *
 * <p>This package is a part of the open-source <a href="https://github.com/google/guava">Guava</a>

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package codegen

// This file contains codegen tests related to arithmetic
// simplifications and optimizations on float types.
// For codegen tests on integer types, see arithmetic.go.

// --------------------- //
//    Strength-reduce    //
// --------------------- //

func Mul2(f float64) float64 {
	// 386/sse2:"ADDSD",-"MULSD"

package sys

import (
	"internal/goarch"
	"internal/goos"
)

// AIX requires a larger stack for syscalls.
// The race build also needs more stack. See issue 54291.
// This arithmetic must match that in cmd/internal/objabi/stack.go:stackGuardMultiplier.
const StackGuardMultiplier = 1 + goos.IsAix + isRace

// DefaultPhysPageSize is the default physical page size.

				return true
			}
		}
	}

	// "(3) Conversion of a Pointer to a uintptr and back, with arithmetic."
	return isSafeArith(info, x)
}

// isSafeArith reports whether x is a pointer arithmetic expression that is safe
// to convert to unsafe.Pointer.
func isSafeArith(info *types.Info, x ast.Expr) bool {
	switch x := astutil.Unparen(x).(type) {

func convert(p *float64) *uint64 { // ERROR "leaking param: p to result ~r0 level=0$"
	return (*uint64)(unsafe.Pointer(p))
}

// (3) Conversion of a Pointer to a uintptr and back, with arithmetic.

func arithAdd() unsafe.Pointer {
	var x [2]byte // ERROR "moved to heap: x"
	return unsafe.Pointer(uintptr(unsafe.Pointer(&x[0])) + 1)
}

func arithSub() unsafe.Pointer {

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This program generates a test to verify that the standard arithmetic
// operators properly handle some special cases. The test file should be
// generated with a known working version of go.
// launch with `go run arithBoundaryGen.go` a file called arithBoundary.go

//
// Raises complex A to the complex Zth power.
// Definition is per AMS55 # 4.2.8,
// analytically equivalent to cpow(a,z) = cexp(z clog(a)).
//
// ACCURACY:
//
//                      Relative error:
// arithmetic   domain     # trials      peak         rms
//    IEEE      -10,+10     30000       9.4e-15     1.5e-15

// Pow returns x**y, the base-x exponential of y.
// For generalized compatibility with [math.Pow]:
//