return a.d[nd] >= '5'
}

// Round a to nd digits (or fewer).
// If nd is zero, it means we're rounding
// just to the left of the digits, as in
// 0.09 -> 0.1.
func (a *decimal) Round(nd int) {
	if nd < 0 || nd >= a.nd {
		return
	}
	if shouldRoundUp(a, nd) {
		a.RoundUp(nd)
	} else {
		a.RoundDown(nd)
	}
}

// Round a down to nd digits (or fewer).
func (a *decimal) RoundDown(nd int) {

		test := &roundtests[i]
		d := NewDecimal(test.i)
		d.RoundDown(test.nd)
		s := d.String()
		if s != test.down {
			t.Errorf("Decimal %v RoundDown %d = %v, want %v",
				test.i, test.nd, s, test.down)
		}
		d = NewDecimal(test.i)
		d.Round(test.nd)
		s = d.String()
		if s != test.round {
			t.Errorf("Decimal %v Round %d = %v, want %v",
				test.i, test.nd, s, test.down)
		}
		d = NewDecimal(test.i)
		d.RoundUp(test.nd)

	shortest := prec < 0
	if shortest {
		roundShortest(d, mant, exp, flt)
		digs = decimalSlice{d: d.d[:], nd: d.nd, dp: d.dp}
		// Precision for shortest representation mode.
		switch fmt {
		case 'e', 'E':
			prec = digs.nd - 1
		case 'f':
			prec = max(digs.nd-digs.dp, 0)
		case 'g', 'G':
			prec = digs.nd
		}
	} else {
		// Round appropriately.
		switch fmt {
		case 'e', 'E':
			d.Round(prec + 1)

		d.dp += 9
	} else {
		d.nd = 0
		// emit high part
		n := uint(9)
		for v := chi; v > 0; {
			v1, v2 := v/10, v%10
			v = v1
			n--
			d.d[n] = byte(v2 + '0')
		}
		d.d = d.d[n:]
		d.nd = int(9 - n)
		// emit low part
		ryuDigits32(d, llo, clo, ulo,
			c0, cup, d.nd+8)
	}
	// trim trailing zeros
	for d.nd > 0 && d.d[d.nd-1] == '0' {
		d.nd--
	}

		case s[i] == '.':
			if sawdot {
				return
			}
			sawdot = true
			b.dp = b.nd
			continue

		case '0' <= s[i] && s[i] <= '9':
			sawdigits = true
			if s[i] == '0' && b.nd == 0 { // ignore leading zeros
				b.dp--
				continue
			}
			if b.nd < len(b.d) {
				b.d[b.nd] = s[i]
				b.nd++
			} else if s[i] != '0' {
				b.trunc = true
			}
			continue
		}
		break
	}

strings
""
"abc123²³¼½¾₀₉"
regexps
"\\p{Nd}+"
-;-;-;-
-;3-6;-;3-6
"^(?:\\p{Nd}+)$"
-;-;-;-
-;-;-;-
"^(?:\\p{Nd}+)"
-;-;-;-
-;-;-;-
"(?:\\p{Nd}+)$"
-;-;-;-
-;-;-;-
strings
""
"abc123²³¼½¾₀₉"
regexps
"\\p{^Nd}+"
-;-;-;-
-;0-3;-;0-3
"^(?:\\p{^Nd}+)$"
-;-;-;-
-;-;-;-
"^(?:\\p{^Nd}+)"
-;-;-;-
-;0-3;-;0-3
"(?:\\p{^Nd}+)$"

		return false
	}

	// room for data?
	nd := countSub(br.dataCount(), bw.dataCount()) + len(b.data)
	want := 2 + int(b.hdrsize) + nstk
	i := int(bw.dataCount() % uint32(len(b.data)))
	if i+want > len(b.data) {
		// Can't fit in trailing fragment of slice.
		// Skip over that and start over at beginning of slice.
		nd -= len(b.data) - i
	}
	return nd >= want
}

				packageNames = []string{}
			}

			if nd.RawArg == "-args" || nd.RawArg == "--args" {
				// -args or --args signals that everything that follows
				// should be passed to the test.
				explicitArgs = append(explicitArgs, remainingArgs...)
				break
			}

			if firstUnknownFlag == "" {
				firstUnknownFlag = nd.RawArg
			}

			explicitArgs = append(explicitArgs, nd.RawArg)
			args = remainingArgs

 */

package org.gradle.api.reporting.model
/**
 *
 * Represents a node of a hierarchical report
 * Extends from groovy's {@code groovy.util.Node} and hence GPath expressions can be used to search and identify report nodes nd values.
 *
 * See https://www.groovy-lang.org/processing-xml.html#_gpath
 *
 * E.g:
 * <pre>
 *      modelReport.reportNode.'**'.primaryCredentials.username.@nodeValue[0] == 'uname'

		that will test the REST endpoint to ensure it is working.
	</p>
	<p>
		For the complete feature documentation, see the <a
			href="http://www.ibm.com/support/knowledgecenter/SSAW57_8.5.5/com.ibm.websphere.wlp.nd.multiplatform.doc/ae/rwlp_feat.html%23rwlp_feat__jaxrs-2.0">jaxrs-2.0</a>
		feature description in IBM Knowledge Center.
	</p>
</div>
<div id="technologies">
    
    </div>
</body>
</html>