Method InDeltaRelative

number.go:321–421

InDeltaRelative succeeds if two numbers are within relative delta of each other. The relative delta is expressed as a decimal. For example, to determine if a number and a value are within 1% of each other, use 0.01. A number and a value are within relative delta if Abs(number-value) / Abs(number)

(value, delta float64)

//	number := NewNumber(t, 123.0)
//	number.InDeltaRelative(126.5, 0.03)
func (n *Number) InDeltaRelative(value, delta float64) *Number {
	opChain := n.chain.enter("InDeltaRelative()")
	defer opChain.leave()

	if opChain.failed() {
		return n
	}

	if math.IsNaN(delta) || math.IsInf(delta, 0) {
		opChain.fail(AssertionFailure{
			Type: AssertUsage,
			Errors: []error{
				fmt.Errorf("unexpected non-number delta argument: %v", delta),
			},
		})
		return n
	}

	if delta < 0 {
		opChain.fail(AssertionFailure{
			Type: AssertUsage,
			Errors: []error{
				fmt.Errorf("unexpected negative delta argument: %v", delta),
			},
		})
		return n
	}

	// Fail if any of the numbers is NaN with specific error message
	anyNumIsNaN := math.IsNaN(n.value) || math.IsNaN(value)
	if anyNumIsNaN {
		var assertionErrors []error
		assertionErrors = append(
			assertionErrors,
			errors.New("expected: can compare values with relative delta"),
		)
		if math.IsNaN(n.value) {
			assertionErrors = append(
				assertionErrors,
				errors.New("actual value is NaN"),
			)
		}
		if math.IsNaN(value) {
			assertionErrors = append(
				assertionErrors,
				errors.New("expected value is NaN"),
			)
		}
		opChain.fail(AssertionFailure{
			Type:     AssertEqual,
			Actual:   &AssertionValue{n.value},
			Expected: &AssertionValue{value},
			Delta:    &AssertionValue{relativeDelta(delta)},
			Errors:   assertionErrors,
		})
		return n
	}