Esempio n. 1
0
// exitAxis reports which axis the directed line L exits the cube face F on.
// The directed line L is represented by its CCW normal N in the (u,v,w) coordinates
// of F. It returns axisU if L exits through the u=-1 or u=+1 edge, and axisV if L exits
// through the v=-1 or v=+1 edge. Either result is acceptable if L exits exactly
// through a corner vertex of the cube face.
func (p pointUVW) exitAxis() axis {
	if p.intersectsOppositeEdges() {
		// The line passes through through opposite edges of the face.
		// It exits through the v=+1 or v=-1 edge if the u-component of N has a
		// larger absolute magnitude than the v-component.
		if math.Abs(p.X) >= math.Abs(p.Y) {
			return axisV
		}
		return axisU
	}

	// The line passes through through two adjacent edges of the face.
	// It exits the v=+1 or v=-1 edge if an even number of the components of N
	// are negative. We test this using signbit() rather than multiplication
	// to avoid the possibility of underflow.
	var x, y, z int
	if math.Signbit(p.X) {
		x = 1
	}
	if math.Signbit(p.Y) {
		y = 1
	}
	if math.Signbit(p.Z) {
		z = 1
	}

	if x^y^z == 0 {
		return axisV
	}
	return axisU
}
Esempio n. 2
0
//'true' if opposite signs; false otherwise
func opp(x float64, y float64) bool {
	if math.Signbit(x) == math.Signbit(y) {
		return false
	} else {
		return true
	}
}
Esempio n. 3
0
// randomSchurCanonical returns a random, general matrix in Schur canonical
// form, that is, block upper triangular with 1×1 and 2×2 diagonal blocks where
// each 2×2 diagonal block has its diagonal elements equal and its off-diagonal
// elements of opposite sign.
func randomSchurCanonical(n, stride int, rnd *rand.Rand) blas64.General {
	t := randomGeneral(n, n, stride, rnd)
	// Zero out the lower triangle.
	for i := 0; i < t.Rows; i++ {
		for j := 0; j < i; j++ {
			t.Data[i*t.Stride+j] = 0
		}
	}
	// Randomly create 2×2 diagonal blocks.
	for i := 0; i < t.Rows; {
		if i == t.Rows-1 || rnd.Float64() < 0.5 {
			// 1×1 block.
			i++
			continue
		}
		// 2×2 block.
		// Diagonal elements equal.
		t.Data[(i+1)*t.Stride+i+1] = t.Data[i*t.Stride+i]
		// Off-diagonal elements of opposite sign.
		c := rnd.NormFloat64()
		if math.Signbit(c) == math.Signbit(t.Data[i*t.Stride+i+1]) {
			c *= -1
		}
		t.Data[(i+1)*t.Stride+i] = c
		i += 2
	}
	return t
}
Esempio n. 4
0
func sameValue(x Value, y Value) bool {
	if x.kind != y.kind {
		return false
	}
	result := false
	switch x.kind {
	case valueUndefined, valueNull:
		result = true
	case valueNumber:
		x := x.float64()
		y := y.float64()
		if math.IsNaN(x) && math.IsNaN(y) {
			result = true
		} else {
			result = x == y
			if result && x == 0 {
				// Since +0 != -0
				result = math.Signbit(x) == math.Signbit(y)
			}
		}
	case valueString:
		result = x.string() == y.string()
	case valueBoolean:
		result = x.bool() == y.bool()
	case valueObject:
		result = x._object() == y._object()
	default:
		panic(hereBeDragons())
	}

	return result
}
Esempio n. 5
0
// Creates knockback for a vehicle
func (p *Physics) VehicleKnockback(vehicle *state.Vehicle, kbAngle, kbVelocity float64) {
	// Get vehicle velocity vectors
	vehAngleX, vehAngleY := splitComponent(vehicle.Angle)
	vehVectorX := vehAngleX * vehicle.Velocity
	vehVectorY := vehAngleY * vehicle.Velocity

	// Get knockback velocity vectors
	kbAngleX, kbAngleY := splitComponent(kbAngle)
	kbVectorX := kbAngleX * kbVelocity
	kbVectorY := kbAngleY * kbVelocity

	// Combine vectors
	vectorX := vehVectorX + kbVectorX
	vectorY := vehVectorY + kbVectorY
	vehVelocity := combineComponents(vectorX, vectorY)

	// Calculate angle perpendicularity as a percent
	angleFactor := math.Mod(math.Abs(vehicle.Angle-kbAngle+90), 180) / 90.0

	// Set vehicle velocity
	if math.Signbit(vehicle.Velocity) == math.Signbit(vehVelocity) {
		vehicle.Velocity = -vehVelocity * angleFactor
	} else {
		vehicle.Velocity = vehVelocity * angleFactor
	}
}
Esempio n. 6
0
func (f *andFeature) Predict(e Example) float64 {
	if !math.Signbit(f.f1.Predict(e)) && !math.Signbit(f.f2.Predict(e)) {
		return 1.0
	} else {
		return -1.0
	}
}
Esempio n. 7
0
// CombineClusters combines freshly found clusters with existing clusters.
//
//  Algorithm:
//    Run clustering and pick out the "Interesting" clusters.
//    Compare all the Interesting clusters to all the existing relevant clusters,
//      where "relevant" clusters are ones whose Hash/timestamp of the step
//      exists in the current tile.
//    Start with an empty "list".
//    For each cluster:
//      For each relevant existing cluster:
//        Take the top 20 keys from the existing cluster and count how many appear
//        in the cluster.
//      If there are no matches then this is a new cluster, add it to the "list".
//      If there are matches, possibly to multiple existing clusters, find the
//      existing cluster with the most matches.
//        Take the cluster (old/new) with the most members, or the best fit if
//        they have the same number of matches.
//    Return all the updated clusters.
func CombineClusters(freshSummaries, oldSummaries []*types.ClusterSummary) []*types.ClusterSummary {
	ret := []*types.ClusterSummary{}

	stillFresh := []*types.ClusterSummary{}
	// If two cluster summaries have the same hash and same Regression direction
	// then they are the same, merge them together.
	for _, fresh := range freshSummaries {
		for _, old := range oldSummaries {
			if fresh.Hash == old.Hash && math.Signbit(fresh.StepFit.Regression) == math.Signbit(old.StepFit.Regression) {
				old.Merge(fresh)
				ret = append(ret, old)
				break
			}
		}
		stillFresh = append(stillFresh, fresh)
	}

	// Even if a summary has a different hash it might still be the same event if
	// there is an overlap in the traces each summary contains.
	for _, fresh := range stillFresh {
		var bestMatch *types.ClusterSummary = nil
		bestMatchHits := 0
		for _, old := range oldSummaries {
			hits := 0
			for _, key := range util.AtMost(old.Keys, 20) {
				if util.In(key, fresh.Keys) {
					hits += 1
				}
			}
			if hits > bestMatchHits {
				bestMatchHits = hits
				bestMatch = old
			}
		}
		if bestMatch != nil {
			keysLengthEqual := len(fresh.Keys) == len(bestMatch.Keys)
			regressionInSameDirection := math.Signbit(fresh.StepFit.Regression) == math.Signbit(bestMatch.StepFit.Regression)
			freshHasBetterFit := math.Abs(fresh.StepFit.Regression) > math.Abs(bestMatch.StepFit.Regression)
			freshHasMoreKeys := len(fresh.Keys) > len(bestMatch.Keys)
			if freshHasMoreKeys || (keysLengthEqual && regressionInSameDirection && freshHasBetterFit) {
				fresh.Status = bestMatch.Status
				fresh.Message = bestMatch.Message
				fresh.ID = bestMatch.ID
				fresh.Bugs = bestMatch.Bugs
				ret = append(ret, fresh)
				// Find the bestMatch in oldSummaries and replace it with fresh.
				for i, oldBest := range oldSummaries {
					if oldBest == bestMatch {
						oldSummaries[i] = fresh
						break
					}
				}
			}
		} else {
			ret = append(ret, fresh)
		}
	}
	return ret
}
Esempio n. 8
0
func alike(a, b float64) bool {
	switch {
	case math.IsNaN(a) && math.IsNaN(b):
		return true
	case a == b:
		return math.Signbit(a) == math.Signbit(b)
	}
	return false
}
Esempio n. 9
0
func cAlike(a, b complex128) bool {
	switch {
	case IsNaN(a) && IsNaN(b):
		return true
	case a == b:
		return math.Signbit(real(a)) == math.Signbit(real(b)) && math.Signbit(imag(a)) == math.Signbit(imag(b))
	}
	return false
}
Esempio n. 10
0
// AreDifferent(x, y) bekaves like x != y, but sees NaN() as equal to NaN()
func AreDifferent(x float64, y float64) bool {
	if math.IsNaN(x) && math.IsNaN(y) {
		return false
	}

	if x == y && math.Signbit(x) != math.Signbit(y) { // 0 != -0
		return true
	}

	return x != y
}
Esempio n. 11
0
// EqualWithinULP returns true if a and b are equal to within
// the specified number of floating point units in the last place.
func EqualWithinULP(a, b float64, ulp uint) bool {
	if a == b {
		return true
	}
	if math.IsNaN(a) || math.IsNaN(b) {
		return false
	}
	if math.Signbit(a) != math.Signbit(b) {
		return math.Float64bits(math.Abs(a))+math.Float64bits(math.Abs(b)) <= uint64(ulp)
	}
	return ulpDiff(math.Float64bits(a), math.Float64bits(b)) <= uint64(ulp)
}
Esempio n. 12
0
func testPrefixBoundary(t *testing.T, scales []float64, prefixes string, mode int, wrap func(string) string) {
	var str, str1, str2, pre string
	var flt, fabs, fnum float64
	var err error

	base := 1024.0
	if mode == SI {
		base = 1000.0
	}

	for _, sign := range []float64{-1, +1} {
		for i, f := range scales {
			// Round towards zero.
			str = FormatPrefix(math.Nextafter(sign*f, sign*ninf), mode, -1)
			flt, err = ParsePrefix(str, mode)
			fabs = math.Abs(flt)

			pre = string(prefixes[0])
			if i > 0 {
				pre = string(prefixes[i-1])
			}
			pre = wrap(pre)
			str1, str2 = split(str)
			fnum = math.Abs(atof(str1))
			if i == 0 {
				assert.True(t, 1.0*loThres <= fnum && fnum <= 1.0)
			} else {
				assert.True(t, base*loThres <= fnum && fnum <= base)
			}
			assert.Equal(t, pre, str2)
			assert.True(t, f*loThres <= fabs && fabs <= f)
			assert.Equal(t, math.Signbit(flt), math.Signbit(sign))
			assert.Equal(t, nil, err)

			// Round away from zero.
			str = FormatPrefix(math.Nextafter(sign*f, sign*pinf), mode, -1)
			flt, err = ParsePrefix(str, mode)
			fabs = math.Abs(flt)

			pre = wrap(string(prefixes[i]))
			str1, str2 = split(str)
			fnum = math.Abs(atof(str1))
			assert.True(t, 1.0 <= fnum && fnum <= 1.0*hiThres)
			assert.Equal(t, pre, str2)
			assert.True(t, f <= fabs && fabs <= f*hiThres)
			assert.Equal(t, math.Signbit(flt), math.Signbit(sign))
			assert.Equal(t, nil, err)
		}
	}
}
Esempio n. 13
0
func numberOperator(left, right tree.Result, f *xpFilt, op string) error {
	lt, lOK := left.(tree.IsNum)
	rt, rOK := right.(tree.IsNum)
	if !lOK || !rOK {
		return fmt.Errorf("Cannot convert data type to number")
	}

	ln, rn := lt.Num(), rt.Num()

	switch op {
	case "*":
		f.ctx = ln * rn
	case "div":
		if rn != 0 {
			f.ctx = ln / rn
		} else {
			if ln == 0 {
				f.ctx = tree.Num(math.NaN())
			} else {
				if math.Signbit(float64(ln)) == math.Signbit(float64(rn)) {
					f.ctx = tree.Num(math.Inf(1))
				} else {
					f.ctx = tree.Num(math.Inf(-1))
				}
			}
		}
	case "mod":
		f.ctx = tree.Num(int(ln) % int(rn))
	case "+":
		f.ctx = ln + rn
	case "-":
		f.ctx = ln - rn
	case "=":
		f.ctx = tree.Bool(ln == rn)
	case "!=":
		f.ctx = tree.Bool(ln != rn)
	case "<":
		f.ctx = tree.Bool(ln < rn)
	case "<=":
		f.ctx = tree.Bool(ln <= rn)
	case ">":
		f.ctx = tree.Bool(ln > rn)
	case ">=":
		f.ctx = tree.Bool(ln >= rn)
	}

	return nil
}
Esempio n. 14
0
// convert float64 to int64 where f == i / 2^exp
func float64ToIntExp(f float64) (i int64, exp int) {
	if f == 0 {
		return 0, 0
	}

	isNegative := math.Signbit(f)
	f = math.Abs(f)

	machineEpsilon := math.Nextafter(1, 2) - 1
	exp = 0
	// really large float, bring down to within MaxInt64
	for f > float64(math.MaxInt64) {
		f /= 2
		exp--
	}

	for !float64IsInt(f, machineEpsilon) {
		f *= 2
		exp++
	}
	if isNegative {
		f *= -1
	}
	return int64(f), exp
}
Esempio n. 15
0
func genVolumeTable() {
	//   0/127 = -INFdB
	//  63/127 =  -14dB
	// 127/127 =    0dB
	for n := uint8(0); n <= 127; n++ {
		db := MIDItoDB(n)
		//fmt.Printf("\"%+5.1f\", // %d == %d\n", db, n, dBtoMIDI(db))

		posdb := math.Abs(db)

		// Represent as u16 in BCD:
		bcd0 := uint16((posdb - math.Floor(posdb)) * 10)
		bcd1 := uint16(((posdb / 10.0) - math.Floor(posdb/10.0)) * 10)
		bcd2 := uint16(((posdb / 100.0) - math.Floor(posdb/100.0)) * 10)
		var bcd3 uint16
		if math.Signbit(db) {
			bcd3 = 0x0F
		} else {
			bcd3 = 0x00
		}
		db10s := (bcd3 << 12) | (bcd2 << 8) | (bcd1 << 4) | bcd0
		if math.IsInf(db, -1) {
			db10s = math.MaxUint16
		}
		fmt.Printf("0x%04X, // %d\n", db10s, n)
	}
}
Esempio n. 16
0
func extractFeatures(examples []ml.Example) (features []ml.Feature) {
	features = nil

	featureDeDup := make(map[string]ml.Feature)
	for _, example := range examples {
		for word := range example.(*IssueExample).titleWords {
			feature := &titleFeature{word}
			featureDeDup[feature.String()] = feature
		}
		for word := range example.(*IssueExample).contentWords {
			feature := &contentFeature{word}
			featureDeDup[feature.String()] = feature
		}
	}

	minExamples := int(0.001 * float64(len(examples)))
	maxExamples := len(examples)
	for _, feature := range featureDeDup {
		count := 0
		for _, example := range examples {
			if !math.Signbit(feature.Predict(example)) {
				count++
			}
		}

		if minExamples <= count && count <= maxExamples {
			features = append(features, feature)
		}
	}

	return
}
Esempio n. 17
0
// Reference implementation of Drotg
func refDrotg(a, b float64) (c, s, r, z float64) {
	roe := b
	if math.Abs(a) > math.Abs(b) {
		roe = a
	}
	scale := math.Abs(a) + math.Abs(b)
	if scale == 0 {
		c = 1
	} else {
		r = scale * math.Sqrt((a/scale)*(a/scale)+(b/scale)*(b/scale))
		if math.Signbit(roe) {
			r = -r
		}
		c = a / r
		s = b / r
		z = 1
		if math.Abs(a) > math.Abs(b) {
			z = s
		}
		if math.Abs(b) >= math.Abs(a) && c != 0 {
			z = 1 / c
		}
	}
	return
}
Esempio n. 18
0
/* From LAPACK/dlarfg.f
 *
 * DLARFG generates a real elementary reflector H of order n, such
 * that
 *
 *       H * ( alpha ) = ( beta ),   H**T * H = I.
 *           (   x   )   (   0  )
 *
 * where alpha and beta are scalars, and x is an (n-1)-element real
 * vector. H is represented in the form
 *
 *       H = I - tau * ( 1 ) * ( 1 v**T ) ,
 *                     ( v )
 *
 * where tau is a real scalar and v is a real (n-1)-element
 * vector.
 *
 * If the elements of x are all zero, then tau = 0 and H is taken to be
 * the unit matrix.
 *
 * Otherwise  1 <= tau <= 2.
 */
func computeHouseholder(a11, x, tau *matrix.FloatMatrix, flags Flags) {

	// norm_x2 = ||x||_2
	norm_x2 := Norm2(x)
	if norm_x2 == 0.0 {
		//a11.SetAt(0, 0, -a11.GetAt(0, 0))
		tau.SetAt(0, 0, 0.0)
		return
	}

	alpha := a11.GetAt(0, 0)
	sign := 1.0
	if math.Signbit(alpha) {
		sign = -1.0
	}
	// beta = -(alpha / |alpha|) * ||alpha x||
	//      = -sign(alpha) * sqrt(alpha**2, norm_x2**2)
	beta := -sign * sqrtX2Y2(alpha, norm_x2)

	// x = x /(a11 - beta)
	InvScale(x, alpha-beta)

	tau.SetAt(0, 0, (beta-alpha)/beta)
	a11.SetAt(0, 0, beta)
}
Esempio n. 19
0
func (n *FeatureNode) Predict(e Example) float64 {
	if math.Signbit(n.feature.Predict(e)) {
		return n.negative.Predict(e)
	} else {
		return n.positive.Predict(e)
	}
}
Esempio n. 20
0
func roundSliceDown(coord, slice float64) float64 {
	remainder := math.Mod(coord, slice)
	if math.Signbit(coord) {
		return coord - remainder
	}
	return coord - remainder + slice
}
Esempio n. 21
0
// Reference implementation of Srotg
func refSrotg(a, b float32) (c, s, r, z float32) {
	roe := b
	if fabs(a) > fabs(b) {
		roe = a
	}
	scale := fabs(a) + fabs(b)
	if scale == 0 {
		c = 1
	} else {
		r = scale * fsqrt((a/scale)*(a/scale)+(b/scale)*(b/scale))
		if math.Signbit(float64(roe)) {
			r = -r
		}
		c = a / r
		s = b / r
		z = 1
		if fabs(a) > fabs(b) {
			z = s
		}
		if fabs(b) >= fabs(a) && c != 0 {
			z = 1 / c
		}
	}
	return
}
Esempio n. 22
0
File: float.go Progetto: gmwu/go
// SetFloat64 sets z to the (possibly rounded) value of x and returns z.
// If z's precision is 0, it is changed to 53 (and rounding will have
// no effect). SetFloat64 panics with ErrNaN if x is a NaN.
func (z *Float) SetFloat64(x float64) *Float {
	if z.prec == 0 {
		z.prec = 53
	}
	if math.IsNaN(x) {
		panic(ErrNaN{"Float.SetFloat64(NaN)"})
	}
	z.acc = Exact
	z.neg = math.Signbit(x) // handle -0, -Inf correctly
	if x == 0 {
		z.form = zero
		return z
	}
	if math.IsInf(x, 0) {
		z.form = inf
		return z
	}
	// normalized x != 0
	z.form = finite
	fmant, exp := math.Frexp(x) // get normalized mantissa
	z.mant = z.mant.setUint64(1<<63 | math.Float64bits(fmant)<<11)
	z.exp = int32(exp) // always fits
	if z.prec < 53 {
		z.round(0)
	}
	return z
}
Esempio n. 23
0
/*
 * Compute Givens rotation such that
 *
 *   G(s,c)*v = (r)   ==  (  c s ).T ( a ) = ( r )
 *              (0)       ( -s c )   ( b )   ( 0 )
 *
 * and
 *
 *   v*G(s,c) = (r 0 ) == (a b ) (  c  s ) = ( r 0 )
 *                               ( -s  c )
 *
 */
func ComputeGivens(a, b float64) (c float64, s float64, r float64) {

	if b == 0.0 {
		c = 1.0
		s = 0.0
		r = a
	} else if a == 0.0 {
		c = 0.0
		s = 1.0
		r = b
	} else if math.Abs(b) > math.Abs(a) {
		t := a / b
		u := math.Sqrt(1.0 + t*t)
		if math.Signbit(b) {
			u = -u
		}
		s = 1.0 / u
		c = s * t
		r = b * u
	} else {
		t := b / a
		u := math.Sqrt(1.0 + t*t)
		r = a * u
		c = 1.0 / u
		s = c * t
	}
	return
}
Esempio n. 24
0
func (p placesByY) Less(i, j int) bool {
	diff := p.places[i].Center().Y - p.places[j].Center().Y
	if math.Abs(diff) > 1 {
		return math.Signbit(diff)
	} else {
		return p.places[i].Center().X > p.places[j].Center().X
	}
}
Esempio n. 25
0
// BinaryRoot finds a root between given bounds by binary search.
//
// Inputs are a function on x and the bounds on x.  A root must exist between
// the given bounds, otherwise the result is not meaningful.
func BinaryRoot(f RootFunc, lower, upper float64) float64 {
	yLower := f(lower)
	var mid float64
	for j := 0; j < 52; j++ {
		mid = (lower + upper) / 2
		yMid := f(mid)
		if yMid == 0 {
			break
		}
		if math.Signbit(yLower) == math.Signbit(yMid) {
			lower = mid
			yLower = yMid
		} else {
			upper = mid
		}
	}
	return mid
}
Esempio n. 26
0
func evaluateClassifierWeighted(c Classifier, examples []Example, d *Distribution) float64 {
	misclassifications := 0.0
	for i, example := range examples {
		if !math.Signbit(c.Predict(example)) != bool(example.Label()) {
			misclassifications += d.P[i]
		}
	}
	return misclassifications
}
Esempio n. 27
0
func (file *ClassificationFile) Accuracy(set *SVMFile) float64 {
	totalInstances := float64(len(set.Instances))
	correctPreds := 0.
	if len(file.Results) <= len(set.Instances) {
		for i, res := range file.Results {
			if math.Signbit(float64(res)) == math.Signbit(float64(set.Instances[i].Label)) {
				correctPreds++
			}
		}
	} else {
		for i, instance := range set.Instances {
			if math.Signbit(float64(file.Results[i])) == math.Signbit(float64(instance.Label)) {
				correctPreds++
			}
		}
	}

	return correctPreds / totalInstances
}
Esempio n. 28
0
// Solves f(x) = 0 within a bracket (a,b) to precision eps. Terminates after a maximum of Nmax iterations.
// Returns the solution and value of the function achieved or an error.
func Bisection(f func(float64) float64, a, b, eps float64, Nmax int) (x, fx float64, err error) {

	if a == b {
		err = fmt.Errorf("Range (%g,%g) is zero", a, b)
		return
	}

	// a < b is requirement
	if a > b {
		a, b = b, a
	}

	fa := f(a)
	fb := f(b)

	// a and b must bracket root
	if math.Signbit(fa) == math.Signbit(fb) {
		err = fmt.Errorf("Interval does not bracket root: f(%g)=%g, f(%g)=%g", a, fa, b, fb)
		return
	}

	for i := 0; i < Nmax; i++ {

		x = 0.5 * (a + b)
		fx = f(x)

		// Found adequate solution
		if fx == 0 || 0.5*(b-a) < eps {
			return
		}

		// Calculate new interval
		if math.Signbit(fx) == math.Signbit(fa) {
			a = x
			fa = fx
		} else {
			b = x
			fb = fx
		}
	}
	err = fmt.Errorf("Exceeded iteration limit (%d)\n", Nmax)
	return
}
Esempio n. 29
0
File: zset.go Progetto: scozss/setdb
func writeByteSortableFloat(b []byte, f float64) {
	if math.Signbit(f) {
		binary.BigEndian.PutUint64(b, math.Float64bits(f))
		for i, v := range b[:8] {
			b[i] = v ^ 255
		}
	} else {
		binary.BigEndian.PutUint64(b, math.Float64bits(-f))
	}
}
Esempio n. 30
0
func TestComparison(t *testing.T) {
	Terst(t)

	test := runTest()

	test("undefined = 1")
	test("undefined", "1")

	test("result = undefined == undefined")
	test("result", "true")

	test("result = undefined != undefined")
	test("result", "false")

	test("result = null == null")
	test("result", "true")

	test("result = null != null")
	test("result", "false")

	test("result = 0 == 1")
	test("result", "false")

	Is(negativeZero(), "-0")
	Is(positiveZero(), "0")
	IsTrue(math.Signbit(negativeZero()))
	IsTrue(positiveZero() == negativeZero())

	test("result = 1 == 1")
	test("result", "true")

	test("result = 'Hello, World.' == 'Goodbye, World.'")
	test("result", "false")

	test("result = 'Hello, World.' == true")
	test("result", "false")

	test("result = 'Hello, World.' == false")
	test("result", "false")

	test("result = 'Hello, World.' == 1")
	test("result", "false")

	test("result = 1 == 'Hello, World.'")
	test("result", "false")

	Is(stringToFloat("-1"), -1)

	if false {
		fmt.Printf("Hello, World.: %v", toNumber(toValue("Hello, World.")))
	}

	test("result = 0+Object")
	test("result", "0[function]")
}