_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5300 | ListContainers | train | func (m *containerManager) ListContainers() ([]instances.Instance, error) {
containers, err := m.server.FilterContainers(m.namespace.Prefix())
if err != nil {
return nil, errors.Trace(err)
}
var result []instances.Instance
for _, i := range containers {
result = append(result, &lxdInstance{i.Name, m.server.Co... | go | {
"resource": ""
} |
q5301 | getContainerSpec | train | func (m *containerManager) getContainerSpec(
instanceConfig *instancecfg.InstanceConfig,
cons constraints.Value,
series string,
networkConfig *container.NetworkConfig,
storageConfig *container.StorageConfig,
callback environs.StatusCallbackFunc,
) (ContainerSpec, error) {
imageSources, err := m.getImageSources()... | go | {
"resource": ""
} |
q5302 | getImageSources | train | func (m *containerManager) getImageSources() ([]ServerSpec, error) {
imURL := m.imageMetadataURL
// Unless the configuration explicitly requests the daily stream,
// an empty image metadata URL results in a search of the default sources.
if imURL == "" && m.imageStream != "daily" {
logger.Debugf("checking defaul... | go | {
"resource": ""
} |
q5303 | networkDevicesFromConfig | train | func (m *containerManager) networkDevicesFromConfig(netConfig *container.NetworkConfig) (map[string]device, []string, error) {
if len(netConfig.Interfaces) > 0 {
return DevicesFromInterfaceInfo(netConfig.Interfaces)
} else if netConfig.Device != "" {
return map[string]device{
"eth0": newNICDevice("eth0", netCo... | go | {
"resource": ""
} |
q5304 | LXDProfileNames | train | func (m *containerManager) LXDProfileNames(containerName string) ([]string, error) {
return m.server.GetContainerProfiles(containerName)
} | go | {
"resource": ""
} |
q5305 | Map | train | func (i *injector) Map(val interface{}) TypeMapper {
i.values[reflect.TypeOf(val)] = reflect.ValueOf(val)
return i
} | go | {
"resource": ""
} |
q5306 | Set | train | func (i *injector) Set(typ reflect.Type, val reflect.Value) TypeMapper {
i.values[typ] = val
return i
} | go | {
"resource": ""
} |
q5307 | Levels | train | func (p *SLSHook) Levels() []logrus.Level {
if p.AcceptedLevels == nil {
return allLevels
}
return p.AcceptedLevels
} | go | {
"resource": ""
} |
q5308 | newFileWriter | train | func newFileWriter() *fileLogWriter {
w := &fileLogWriter{
Daily: true,
MaxDays: 7,
Rotate: true,
RotatePerm: "0440",
Level: LevelDebug,
Perm: "0660",
}
return w
} | go | {
"resource": ""
} |
q5309 | WriteMsg | train | func (w *fileLogWriter) WriteMsg(when time.Time, msg string, level int) error {
if level > w.Level {
return nil
}
h, d := formatTimeHeader(when)
msg = string(h) + msg + "\n"
if w.Rotate {
w.RLock()
if w.needRotate(len(msg), d) {
w.RUnlock()
w.Lock()
if w.needRotate(len(msg), d) {
if err := w.doR... | go | {
"resource": ""
} |
q5310 | Log10 | train | func Log10(z, x *decimal.Big) *decimal.Big {
if logSpecials(z, x) {
return z
}
// If x is a power of 10 the result is the exponent and exact.
var tpow bool
if m, u := decimal.Raw(x); *m != c.Inflated {
tpow = arith.PowOfTen(*m)
} else {
tpow = arith.PowOfTenBig(u)
}
if tpow {
ctx := decimal.Context{Pre... | go | {
"resource": ""
} |
q5311 | Log | train | func Log(z, x *decimal.Big) *decimal.Big {
if logSpecials(z, x) {
return z
}
if x.IsInt() {
if v, ok := x.Uint64(); ok {
switch v {
case 1:
// ln 1 = 0
return z.SetMantScale(0, 0)
case 10:
// Specialized function.
return ln10(z, precision(z))
}
}
}
return log(z, x, false)
} | go | {
"resource": ""
} |
q5312 | Value | train | func (d *Decimal) Value() (driver.Value, error) {
if d.V == nil {
if d.Zero {
return "0", nil
}
return nil, nil
}
v := d.V
if v.IsNaN(0) {
return "NaN", nil
}
if v.IsInf(0) {
return nil, errors.New("Decimal.Value: DECIMAL does not accept Infinities")
}
dl := v.Precision() // length of d
sl := in... | go | {
"resource": ""
} |
q5313 | Length | train | func Length(x uint64) int {
if x < 10 {
return 1
}
// From https://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
r := int((bits.Len64(x) * 1233) >> 12)
if p, _ := Pow10(uint64(r)); x < p {
return r
}
return r + 1
} | go | {
"resource": ""
} |
q5314 | BigLength | train | func BigLength(x *big.Int) int {
if x.Sign() == 0 {
return 1
}
var (
m uint64
nb = uint64(x.BitLen())
)
// overflowCutoff is the largest number where N * 0x268826A1 <= 1<<63 - 1
const overflowCutoff = 14267572532
if nb > overflowCutoff {
// Given the identity ``log_n a + log_n b = log_n a*b''
// and... | go | {
"resource": ""
} |
q5315 | Abs | train | func Abs(x int64) uint64 {
m := x >> 63
return uint64((x ^ m) - m)
} | go | {
"resource": ""
} |
q5316 | CmpBits | train | func CmpBits(x, y []big.Word) (r int) {
// Copied from math/big.nat.go
m := len(x)
n := len(y)
if m != n || m == 0 {
switch {
case m < n:
r = -1
case m > n:
r = 1
}
return
}
i := m - 1
for i > 0 && x[i] == y[i] {
i--
}
switch {
case x[i] < y[i]:
r = -1
case x[i] > y[i]:
r = 1
}
retu... | go | {
"resource": ""
} |
q5317 | Words | train | func Words(x uint64) []big.Word {
if bits.UintSize == 32 {
return []big.Word{big.Word(x), big.Word(x >> 32)}
}
return []big.Word{big.Word(x)}
} | go | {
"resource": ""
} |
q5318 | Add | train | func Add(z, x *big.Int, y uint64) *big.Int {
zw := z.Bits()
switch xw := x.Bits(); {
default:
zw = add(zw, xw, big.Word(y))
case len(xw) == 0:
zw = setW(zw, big.Word(y))
case y == 0:
zw = set(zw, xw)
}
return z.SetBits(zw)
} | go | {
"resource": ""
} |
q5319 | Sub | train | func Sub(z, x *big.Int, y uint64) *big.Int {
zw := z.Bits()
switch xw := x.Bits(); {
default:
zw = sub(zw, xw, big.Word(y))
case y == 0:
zw = set(zw, xw)
case len(xw) == 0:
panic("underflow")
}
return z.SetBits(zw)
} | go | {
"resource": ""
} |
q5320 | Set | train | func Set(z *big.Int, z1, z0 uint64) *big.Int {
ww := makeWord(z.Bits(), 128/bits.UintSize)
if bits.UintSize == 32 {
ww[3] = big.Word(z1 >> 32)
ww[2] = big.Word(z1)
ww[1] = big.Word(z0 >> 32)
ww[0] = big.Word(z0)
} else {
ww[1] = big.Word(z1)
ww[0] = big.Word(z0)
}
return z.SetBits(ww)
} | go | {
"resource": ""
} |
q5321 | add | train | func add(z, x []big.Word, y big.Word) []big.Word {
m := len(x)
const n = 1
// m > 0 && y > 0
z = makeWord(z, m+1)
var c big.Word
// addVV(z[0:m], x, y) but WW since len(y) == 1
c, z[0] = addWW(x[0], y, 0)
if m > n {
c = addVW(z[n:m], x[n:], c)
}
z[m] = c
return norm(z)
} | go | {
"resource": ""
} |
q5322 | sub | train | func sub(z, x []big.Word, y big.Word) []big.Word {
m := len(x)
const n = 1
// m > 0 && y > 0
z = makeWord(z, m)
// subVV(z[0:m], x, y) but WW since len(y) == 1
var c big.Word
c, z[0] = subWW(x[0], y, 0)
if m > n {
c = subVW(z[n:], x[n:], c)
}
if c != 0 {
panic("underflow")
}
return norm(z)
} | go | {
"resource": ""
} |
q5323 | addVW | train | func addVW(z, x []big.Word, y big.Word) (c big.Word) {
c = y
for i, xi := range x[:len(z)] {
zi := xi + c
z[i] = zi
c = xi &^ zi >> (bits.UintSize - 1)
}
return c
} | go | {
"resource": ""
} |
q5324 | E | train | func E(z *decimal.Big) *decimal.Big {
ctx := decimal.Context{Precision: precision(z)}
if ctx.Precision <= constPrec {
return ctx.Set(z, _E)
}
ctx.Precision += 5
var (
sum = z.SetUint64(2)
fac = new(decimal.Big).SetUint64(1)
term = new(decimal.Big)
prev = new(decimal.Big)
)
for i := uint64(2); sum.C... | go | {
"resource": ""
} |
q5325 | Pi | train | func Pi(z *decimal.Big) *decimal.Big {
return pi(z, decimal.Context{Precision: precision(z)})
} | go | {
"resource": ""
} |
q5326 | pi | train | func pi(z *decimal.Big, ctx decimal.Context) *decimal.Big {
if ctx.Precision <= constPrec {
return ctx.Set(z, _Pi)
}
var (
lasts = new(decimal.Big)
t = new(decimal.Big).SetUint64(3)
s = z.SetUint64(3)
n = new(decimal.Big).SetUint64(1)
na = new(decimal.Big)
d = new(decimal.Big)
da ... | go | {
"resource": ""
} |
q5327 | PowOfTenBig | train | func PowOfTenBig(x *big.Int) bool {
if x.Bit(0) != 0 {
return x.Cmp(c.OneInt) == 0
}
if x.Sign() == 0 {
return true
}
q := new(big.Int).Set(x)
r := new(big.Int)
for len := BigLength(x); len > 20; len-- {
q.QuoRem(q, c.TenInt, r)
if r.Sign() != 0 {
return false
}
}
return PowOfTen(q.Uint64())
} | go | {
"resource": ""
} |
q5328 | Floor | train | func Floor(z, x *decimal.Big) *decimal.Big {
if z.CheckNaNs(x, nil) {
return z
}
ctx := z.Context
ctx.RoundingMode = decimal.ToNegativeInf
return ctx.RoundToInt(z.Copy(x))
} | go | {
"resource": ""
} |
q5329 | Ceil | train | func Ceil(z, x *decimal.Big) *decimal.Big {
// ceil(x) = -floor(-x)
return z.Neg(Floor(z, misc.CopyNeg(z, x)))
} | go | {
"resource": ""
} |
q5330 | allZeros | train | func allZeros(b []byte) bool {
for _, c := range b {
if c != '0' {
return false
}
}
return true
} | go | {
"resource": ""
} |
q5331 | formatCompact | train | func formatCompact(x uint64) []byte {
var b [20]byte
return strconv.AppendUint(b[0:0], uint64(x), 10)
} | go | {
"resource": ""
} |
q5332 | formatSci | train | func (f *formatter) formatSci(b []byte, adj int, e byte) {
f.WriteByte(b[0])
if len(b) > 1 {
f.WriteByte('.')
f.Write(b[1:])
}
// If negative, the call to strconv.Itoa will add the minus sign for us.
f.WriteByte(e)
if adj > 0 {
f.WriteByte('+')
}
f.WriteString(strconv.Itoa(adj))
} | go | {
"resource": ""
} |
q5333 | formatPlain | train | func (f *formatter) formatPlain(b []byte, exp int) {
const zeroRadix = "0."
switch radix := len(b) + exp; {
// log10(b) == scale, so immediately before b: 0.123456
case radix == 0:
f.WriteString(zeroRadix)
f.Write(b)
// log10(b) > scale, so somewhere inside b: 123.456
case radix > 0:
f.Write(b[:radix])
... | go | {
"resource": ""
} |
q5334 | alias | train | func alias(z, x *big.Int) *big.Int {
if z != x {
// We have to check the first element of their internal slices since
// Big doesn't store a pointer to a big.Int.
zb, xb := z.Bits(), x.Bits()
if cap(zb) > 0 && cap(xb) > 0 && &zb[0:cap(zb)][cap(zb)-1] != &xb[0:cap(xb)][cap(xb)-1] {
return z
}
}
return ne... | go | {
"resource": ""
} |
q5335 | bigScalex | train | func bigScalex(z, x *big.Int, scale int) *big.Int {
if scale > 0 {
return arith.MulBigPow10(z, x, uint64(scale))
}
return z.Quo(x, arith.BigPow10(uint64(-scale)))
} | go | {
"resource": ""
} |
q5336 | Sqrt | train | func Sqrt(z, x *decimal.Big) *decimal.Big {
if z.CheckNaNs(x, nil) {
return z
}
ideal := -((-x.Scale() - (-x.Scale() & 1)) / 2)
if xs := x.Sign(); xs <= 0 {
if xs == 0 {
return z.SetMantScale(0, ideal).CopySign(z, x)
}
z.Context.Conditions |= decimal.InvalidOperation
return z.SetNaN(false)
}
// Alr... | go | {
"resource": ""
} |
q5337 | Err | train | func (c Context) Err() error {
if m := c.Conditions & c.Traps; m != 0 {
return m
}
return nil
} | go | {
"resource": ""
} |
q5338 | WithContext | train | func WithContext(c Context) *Big {
z := new(Big)
z.Context = c
return z
} | go | {
"resource": ""
} |
q5339 | WithPrecision | train | func WithPrecision(p int) *Big {
z := new(Big)
switch {
case p > 0 && p <= UnlimitedPrecision:
z.Context.Precision = p
case p == 0:
z.Context.Precision = DefaultPrecision
default:
z.setNaN(InvalidContext, qnan, invctxpgtu)
}
return z
} | go | {
"resource": ""
} |
q5340 | Add | train | func (c Context) Add(z, x, y *Big) *Big {
if debug {
x.validate()
y.validate()
}
if z.invalidContext(c) {
return z
}
if x.IsFinite() && y.IsFinite() {
z.form = c.add(z, x, x.form, y, y.form)
return c.round(z)
}
// NaN + NaN
// NaN + y
// x + NaN
if z.checkNaNs(x, y, addition) {
return z
}
if ... | go | {
"resource": ""
} |
q5341 | mul | train | func (c Context) mul(z, x, y *Big) *Big {
if debug {
x.validate()
y.validate()
}
sign := x.form&signbit ^ y.form&signbit
if x.IsFinite() && y.IsFinite() {
z.form = finite | sign
z.exp = x.exp + y.exp
// Multiplication is simple, so inline it.
if x.isCompact() {
if y.isCompact() {
hi, lo := ari... | go | {
"resource": ""
} |
q5342 | Quantize | train | func (c Context) Quantize(z *Big, n int) *Big {
if debug {
z.validate()
}
if z.invalidContext(c) {
return z
}
n = -n
if z.isSpecial() {
if z.form&inf != 0 {
return z.setNaN(InvalidOperation, qnan, quantinf)
}
z.checkNaNs(z, z, quantization)
return z
}
if n > c.maxScale() || n < c.etiny() {
re... | go | {
"resource": ""
} |
q5343 | Reduce | train | func (c Context) Reduce(z *Big) *Big {
if debug {
z.validate()
}
c.Round(z)
return c.simpleReduce(z)
} | go | {
"resource": ""
} |
q5344 | simpleReduce | train | func (c Context) simpleReduce(z *Big) *Big {
if z.isSpecial() {
// Same semantics as plus(z), i.e. z + 0.
z.checkNaNs(z, z, reduction)
return z
}
if z.isZero() {
z.exp = 0
z.precision = 1
return z
}
if z.compact == cst.Inflated {
if z.unscaled.Bit(0) != 0 {
return z
}
var r big.Int
for z.... | go | {
"resource": ""
} |
q5345 | Rem | train | func (c Context) Rem(z, x, y *Big) *Big {
if debug {
x.validate()
y.validate()
}
if z.invalidContext(c) {
return z
}
if x.IsFinite() && y.IsFinite() {
if y.isZero() {
if x.isZero() {
// 0 / 0
return z.setNaN(InvalidOperation|DivisionUndefined, qnan, quo00)
}
// x / 0
return z.setNaN(In... | go | {
"resource": ""
} |
q5346 | RoundToInt | train | func (c Context) RoundToInt(z *Big) *Big {
if z.isSpecial() || z.exp >= 0 {
return z
}
c.Precision = z.Precision()
return c.Quantize(z, 0)
} | go | {
"resource": ""
} |
q5347 | Set | train | func (c Context) Set(z, x *Big) *Big {
return c.Round(z.Copy(x))
} | go | {
"resource": ""
} |
q5348 | SetString | train | func (c Context) SetString(z *Big, s string) (*Big, bool) {
if _, ok := z.SetString(s); !ok {
return nil, false
}
return c.Round(z), true
} | go | {
"resource": ""
} |
q5349 | Sub | train | func (c Context) Sub(z, x, y *Big) *Big {
if debug {
x.validate()
y.validate()
}
if z.invalidContext(c) {
return z
}
if x.IsFinite() && y.IsFinite() {
z.form = c.add(z, x, x.form, y, y.form^signbit)
return c.round(z)
}
// NaN - NaN
// NaN - y
// x - NaN
if z.checkNaNs(x, y, subtraction) {
return... | go | {
"resource": ""
} |
q5350 | CmpTotalAbs | train | func CmpTotalAbs(x, y *decimal.Big) int {
xs := ord(x, true)
ys := ord(y, true)
if xs != ys {
if xs > ys {
return +1
}
return -1
}
if xs != 0 {
return 0
}
return x.CmpAbs(y)
} | go | {
"resource": ""
} |
q5351 | CopyAbs | train | func CopyAbs(z, x *decimal.Big) *decimal.Big {
return z.CopySign(x, pos)
} | go | {
"resource": ""
} |
q5352 | CopyNeg | train | func CopyNeg(z, x *decimal.Big) *decimal.Big {
if x.Signbit() {
return z.CopySign(x, pos)
}
return z.CopySign(x, neg)
} | go | {
"resource": ""
} |
q5353 | Max | train | func Max(x ...*decimal.Big) *decimal.Big {
m := x[0]
for _, v := range x[1:] {
if v.Cmp(m) > 0 {
m = v
}
}
return m
} | go | {
"resource": ""
} |
q5354 | MaxAbs | train | func MaxAbs(x ...*decimal.Big) *decimal.Big {
m := x[0]
for _, v := range x[1:] {
if v.CmpAbs(m) > 0 {
m = v
}
}
return m
} | go | {
"resource": ""
} |
q5355 | Min | train | func Min(x ...*decimal.Big) *decimal.Big {
m := x[0]
for _, v := range x[1:] {
if v.Cmp(m) < 0 {
m = v
}
}
return m
} | go | {
"resource": ""
} |
q5356 | MinAbs | train | func MinAbs(x ...*decimal.Big) *decimal.Big {
m := x[0]
for _, v := range x[1:] {
if v.CmpAbs(m) < 0 {
m = v
}
}
return m
} | go | {
"resource": ""
} |
q5357 | maxfor | train | func maxfor(z *big.Int, n, sign int) {
arith.Sub(z, arith.BigPow10(uint64(n)), 1)
if sign < 0 {
z.Neg(z)
}
} | go | {
"resource": ""
} |
q5358 | NextMinus | train | func NextMinus(z, x *decimal.Big) *decimal.Big {
if z.CheckNaNs(x, nil) {
return z
}
if x.IsInf(0) {
if x.IsInf(-1) {
return z.SetInf(true)
}
_, m := decimal.Raw(z)
maxfor(m, precision(z), +1)
return z.SetBigMantScale(m, -etop(z))
}
ctx := z.Context
ctx.RoundingMode = decimal.ToNegativeInf
ctx.S... | go | {
"resource": ""
} |
q5359 | NextPlus | train | func NextPlus(z, x *decimal.Big) *decimal.Big {
if z.CheckNaNs(x, nil) {
return z
}
if x.IsInf(0) {
if x.IsInf(+1) {
return z.SetInf(false)
}
_, m := decimal.Raw(z)
maxfor(m, precision(z), -1)
return z.SetBigMantScale(m, -etop(z))
}
ctx := z.Context
ctx.RoundingMode = decimal.ToPositiveInf
ctx.S... | go | {
"resource": ""
} |
q5360 | SetSignbit | train | func SetSignbit(z *decimal.Big, sign bool) *decimal.Big {
if sign {
return z.CopySign(z, neg)
}
return z.CopySign(z, pos)
} | go | {
"resource": ""
} |
q5361 | Wallis | train | func Wallis(z *decimal.Big, g Generator) *decimal.Big {
if !g.Next() {
return z
}
ws, ok := g.(Walliser)
if !ok {
ws = walliser{prec: precision(z) + 5}
}
a, a_1, b, b_1, p, eps := ws.Wallis()
t := g.Term()
a_1.SetUint64(1)
a.Copy(t.B)
b.SetUint64(1)
ctx := z.Context
if c, ok := g.(Contexter); ok {
... | go | {
"resource": ""
} |
q5362 | ParseCases | train | func ParseCases(r io.Reader) (cases []Case, err error) {
s := bufio.NewScanner(r)
s.Split(bufio.ScanLines)
for s.Scan() {
p := s.Bytes()
// Skip empty lines and comments.
if len(p) == 0 || p[0] == '#' {
continue
}
c, err := ParseCase(p)
if err != nil {
return nil, err
}
cases = append(cases, ... | go | {
"resource": ""
} |
q5363 | ShortString | train | func (c Case) ShortString(length int) string {
return fmt.Sprintf("%s%d [%s, %s]: %s(%s) = %s %s",
c.Prefix, c.Prec, c.Trap, c.Mode, c.Op,
join(c.Inputs, ", ", length), trunc(c.Output, length), c.Excep)
} | go | {
"resource": ""
} |
q5364 | IsNaN | train | func (i Data) IsNaN() (nan, signal bool) {
if len(i) == 1 {
return (i == "S" || i == "Q"), i == "S"
}
if i[0] == '-' {
i = i[1:]
}
return strings.EqualFold(string(i), "nan") ||
strings.EqualFold(string(i), "qnan") ||
strings.EqualFold(string(i), "snan"), i[0] == 's' || i[0] == 'S'
} | go | {
"resource": ""
} |
q5365 | IsInf | train | func (i Data) IsInf() (int, bool) {
if len(i) != 4 {
return 0, false
}
if strings.EqualFold(string(i), "-Inf") {
return -1, true
}
if strings.EqualFold(string(i), "+Inf") {
return +1, true
}
return 0, false
} | go | {
"resource": ""
} |
q5366 | CheckNaNs | train | func (z *Big) CheckNaNs(x, y *Big) bool {
return z.invalidContext(z.Context) || z.checkNaNs(x, y, 0)
} | go | {
"resource": ""
} |
q5367 | Abs | train | func (z *Big) Abs(x *Big) *Big {
if debug {
x.validate()
}
if !z.invalidContext(z.Context) && !z.checkNaNs(x, x, absvalue) {
z.Context.round(z.copyAbs(x))
}
return z
} | go | {
"resource": ""
} |
q5368 | cmp | train | func cmp(x, y *Big, abs bool) int {
if debug {
x.validate()
y.validate()
}
if x == y {
return 0
}
// NaN cmp x
// z cmp NaN
// NaN cmp NaN
if (x.form|y.form)&nan != 0 {
return 0
}
// Fast path: Catches non-finite forms like zero and ±Inf, possibly signed.
xs := x.ord(abs)
ys := y.ord(abs)
if xs ... | go | {
"resource": ""
} |
q5369 | Copy | train | func (z *Big) Copy(x *Big) *Big {
if debug {
x.validate()
}
if z != x {
sign := x.form & signbit
z.copyAbs(x)
z.form |= sign
}
return z
} | go | {
"resource": ""
} |
q5370 | copyAbs | train | func (z *Big) copyAbs(x *Big) *Big {
if z != x {
z.precision = x.Precision()
z.exp = x.exp
z.compact = x.compact
if x.IsFinite() && x.isInflated() {
z.unscaled.Set(&x.unscaled)
}
}
z.form = x.form & ^signbit
return z
} | go | {
"resource": ""
} |
q5371 | CopySign | train | func (z *Big) CopySign(x, y *Big) *Big {
if debug {
x.validate()
y.validate()
}
// Pre-emptively capture signbit in case z == y.
sign := y.form & signbit
z.copyAbs(x)
z.form |= sign
return z
} | go | {
"resource": ""
} |
q5372 | Float64 | train | func (x *Big) Float64() (f float64, ok bool) {
if debug {
x.validate()
}
if !x.IsFinite() {
switch x.form {
case pinf, ninf:
return math.Inf(int(x.form & signbit)), true
case snan, qnan:
return math.NaN(), true
case ssnan, sqnan:
return math.Copysign(math.NaN(), -1), true
}
}
const (
maxPo... | go | {
"resource": ""
} |
q5373 | Float | train | func (x *Big) Float(z *big.Float) *big.Float {
if debug {
x.validate()
}
if z == nil {
z = new(big.Float)
}
switch x.form {
case finite, finite | signbit:
if x.isZero() {
z.SetUint64(0)
} else {
z.SetRat(x.Rat(nil))
}
case pinf, ninf:
z.SetInf(x.form == pinf)
default: // snan, qnan, ssnan, s... | go | {
"resource": ""
} |
q5374 | Int64 | train | func (x *Big) Int64() (int64, bool) {
if debug {
x.validate()
}
if !x.IsFinite() {
return 0, false
}
// x might be too large to fit into an int64 *now*, but rescaling x might
// shrink it enough. See issue #20.
if !x.isCompact() {
xb := x.Int(nil)
return xb.Int64(), xb.IsInt64()
}
u := x.compact
if... | go | {
"resource": ""
} |
q5375 | Uint64 | train | func (x *Big) Uint64() (uint64, bool) {
if debug {
x.validate()
}
if !x.IsFinite() || x.Signbit() {
return 0, false
}
// x might be too large to fit into an uint64 *now*, but rescaling x might
// shrink it enough. See issue #20.
if !x.isCompact() {
xb := x.Int(nil)
return xb.Uint64(), xb.IsUint64()
}
... | go | {
"resource": ""
} |
q5376 | IsNormal | train | func (x *Big) IsNormal() bool {
return x.IsFinite() && x.adjusted() >= x.Context.minScale()
} | go | {
"resource": ""
} |
q5377 | IsSubnormal | train | func (x *Big) IsSubnormal() bool {
return x.IsFinite() && x.adjusted() < x.Context.minScale()
} | go | {
"resource": ""
} |
q5378 | IsInt | train | func (x *Big) IsInt() bool {
if debug {
x.validate()
}
if !x.IsFinite() {
return false
}
// 0, 5000, 40
if x.isZero() || x.exp >= 0 {
return true
}
xp := x.Precision()
exp := x.exp
// 0.001
// 0.5
if -exp >= xp {
return false
}
// 44.00
// 1.000
if x.isCompact() {
for v := x.compact; v%10... | go | {
"resource": ""
} |
q5379 | Neg | train | func (z *Big) Neg(x *Big) *Big {
if debug {
x.validate()
}
if !z.invalidContext(z.Context) && !z.checkNaNs(x, x, negation) {
xform := x.form // copy in case z == x
z.copyAbs(x)
if !z.IsFinite() || z.compact != 0 || z.Context.RoundingMode == ToNegativeInf {
z.form = xform ^ signbit
}
}
return z.Context... | go | {
"resource": ""
} |
q5380 | Precision | train | func (x *Big) Precision() int {
// Cannot call validate since validate calls this method.
if !x.IsFinite() {
return 0
}
if x.precision == 0 {
return 1
}
return x.precision
} | go | {
"resource": ""
} |
q5381 | Rat | train | func (x *Big) Rat(z *big.Rat) *big.Rat {
if debug {
x.validate()
}
if z == nil {
z = new(big.Rat)
}
if !x.IsFinite() {
return z.SetInt64(0)
}
// Fast path for decimals <= math.MaxInt64.
if x.IsInt() {
if u, ok := x.Int64(); ok {
// If profiled we can call scalex ourselves and save the overhead of
... | go | {
"resource": ""
} |
q5382 | Scan | train | func (z *Big) Scan(state fmt.ScanState, verb rune) error {
return z.scan(byteReader{state})
} | go | {
"resource": ""
} |
q5383 | SetBigMantScale | train | func (z *Big) SetBigMantScale(value *big.Int, scale int) *Big {
// Do this first in case value == z.unscaled. Don't want to clobber the sign.
z.form = finite
if value.Sign() < 0 {
z.form |= signbit
}
z.unscaled.Abs(value)
z.compact = c.Inflated
z.precision = arith.BigLength(value)
if z.unscaled.IsUint64() {... | go | {
"resource": ""
} |
q5384 | SetFloat | train | func (z *Big) SetFloat(x *big.Float) *Big {
if x.IsInf() {
if x.Signbit() {
z.form = ninf
} else {
z.form = pinf
}
return z
}
neg := x.Signbit()
if x.Sign() == 0 {
if neg {
z.form |= signbit
}
z.compact = 0
z.precision = 1
return z
}
z.exp = 0
x0 := new(big.Float).Copy(x).SetPrec(big... | go | {
"resource": ""
} |
q5385 | SetFloat64 | train | func (z *Big) SetFloat64(x float64) *Big {
if x == 0 {
var sign form
if math.Signbit(x) {
sign = signbit
}
return z.setZero(sign, 0)
}
if math.IsNaN(x) {
var sign form
if math.Signbit(x) {
sign = signbit
}
return z.setNaN(0, qnan|sign, 0)
}
if math.IsInf(x, 0) {
if math.IsInf(x, 1) {
z.f... | go | {
"resource": ""
} |
q5386 | SetInf | train | func (z *Big) SetInf(signbit bool) *Big {
if signbit {
z.form = ninf
} else {
z.form = pinf
}
return z
} | go | {
"resource": ""
} |
q5387 | SetMantScale | train | func (z *Big) SetMantScale(value int64, scale int) *Big {
z.SetUint64(arith.Abs(value))
z.exp = -scale // compiler should optimize out z.exp = 0 in SetUint64
if value < 0 {
z.form |= signbit
}
return z
} | go | {
"resource": ""
} |
q5388 | setNaN | train | func (z *Big) setNaN(c Condition, f form, p Payload) *Big {
z.form = f
z.compact = uint64(p)
z.Context.Conditions |= c
if z.Context.OperatingMode == Go {
panic(ErrNaN{Msg: z.Context.Conditions.String()})
}
return z
} | go | {
"resource": ""
} |
q5389 | SetNaN | train | func (z *Big) SetNaN(signal bool) *Big {
if signal {
z.form = snan
} else {
z.form = qnan
}
z.compact = 0 // payload
return z
} | go | {
"resource": ""
} |
q5390 | SetRat | train | func (z *Big) SetRat(x *big.Rat) *Big {
if x.IsInt() {
return z.Context.round(z.SetBigMantScale(x.Num(), 0))
}
var num, denom Big
num.SetBigMantScale(x.Num(), 0)
denom.SetBigMantScale(x.Denom(), 0)
return z.Quo(&num, &denom)
} | go | {
"resource": ""
} |
q5391 | SetScale | train | func (z *Big) SetScale(scale int) *Big {
z.exp = -scale
return z
} | go | {
"resource": ""
} |
q5392 | ord | train | func (x *Big) ord(abs bool) int {
if x.form&inf != 0 {
if x.form == pinf || abs {
return +2
}
return -2
}
r := x.Sign()
if abs && r < 0 {
r = -r
}
return r
} | go | {
"resource": ""
} |
q5393 | Signbit | train | func (x *Big) Signbit() bool {
if debug {
x.validate()
}
return x.form&signbit != 0
} | go | {
"resource": ""
} |
q5394 | String | train | func (x *Big) String() string {
if x == nil {
return "<nil>"
}
var (
b = new(strings.Builder)
f = formatter{w: b, prec: x.Precision(), width: noWidth}
e = sciE[x.Context.OperatingMode]
)
b.Grow(x.Precision())
f.format(x, normal, e)
return b.String()
} | go | {
"resource": ""
} |
q5395 | validate | train | func (x *Big) validate() {
defer func() {
if err := recover(); err != nil {
pc, _, _, ok := runtime.Caller(4)
if caller := runtime.FuncForPC(pc); ok && caller != nil {
fmt.Println("called by:", caller.Name())
}
type Big struct {
Context Context
unscaled big.Int
compact uint64
exp... | go | {
"resource": ""
} |
q5396 | Digits | train | func Digits(digits int) string {
max := int(math.Pow10(digits)) - 1
num := privateRand.Intn(max)
format := fmt.Sprintf("%%0%dd", digits)
return fmt.Sprintf(format, num)
} | go | {
"resource": ""
} |
q5397 | BoundedDigits | train | func BoundedDigits(digits, low, high int) string {
if low > high {
low, high = high, low
}
max := int(math.Pow10(digits)) - 1
if high > max {
high = max
}
num := privateRand.Intn(high-low+1) + low
format := fmt.Sprintf("%%0%dd", digits)
return fmt.Sprintf(format, num)
} | go | {
"resource": ""
} |
q5398 | Title | train | func Title(gender int) string {
var title = ""
switch gender {
case Male:
title = randomFrom(jsonData.MaleTitles)
break
case Female:
title = randomFrom(jsonData.FemaleTitles)
break
default:
title = FirstName(privateRand.Intn(2))
break
}
return title
} | go | {
"resource": ""
} |
q5399 | FirstName | train | func FirstName(gender int) string {
var name = ""
switch gender {
case Male:
name = randomFrom(jsonData.FirstNamesMale)
break
case Female:
name = randomFrom(jsonData.FirstNamesFemale)
break
default:
name = FirstName(rand.Intn(2))
break
}
return name
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.