id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c20800 | range vn.vec {
vn.vec[i] = 0
}
} | |
c20801 | dst.vec[2] = vn.vec[1]*other.vec[2]-vn.vec[2]*other.vec[1], vn.vec[2]*other.vec[0]-vn.vec[0]*other.vec[2], vn.vec[0]*other.vec[1]-vn.vec[1]*other.vec[0]
return dst
} | |
c20802 | for i, el := range vn.vec {
dst.vec[i] = el * c
}
return dst
} | |
c20803 | return Vec2{raw[0], raw[1]}
} | |
c20804 | Vec3{raw[0], raw[1], raw[2]}
} | |
c20805 | vn.Raw()
return Vec4{raw[0], raw[1], raw[2], raw[3]}
} | |
c20806 |
dst.Reshape(src.m, src.n)
copy(dst.dat, src.dat)
} | |
c20807 | == j {
dst.Set(i, j, 1)
} else {
dst.Set(i, j, 0)
}
}
}
return dst
} | |
c20808 |
for i := range mat.dat {
mat.dat[i] = 0
}
} | |
c20809 | shouldPool && mat.dat != nil {
returnToPool(mat.dat)
}
mat.m, mat.n = 0, 0
mat.dat = nil
} | |
c20810 | = mat
}()
return mat
} else {
dst = dst.Reshape(mat.n, mat.m)
}
for r := 0; r < mat.m; r++ {
for c := 0; c < mat.n; c++ {
dst.dat[r*dst.m+c] = mat.dat[c*mat.m+r]
}
}
return dst
} | |
c20811 |
return mat.m, mat.n
} | |
c20812 | rows and columns
// since it's element-wise anyway
for i, el := range mat.dat {
dst.dat[i] = el + addend.dat[i]
}
return dst
} | |
c20813 | to care about rows and columns
// since it's element-wise anyway
for i, el := range mat.dat {
dst.dat[i] = el - subtrahend.dat[i]
}
return dst
} | |
c20814 |
for i, el := range mat.dat {
dst.dat[i] = el * c
}
return dst
} | |
c20815 | for r := 0; r < mat.m; r++ {
dst.vec[r] = 0
for c := 0; c < mat.n; c++ {
dst.vec[r] += mat.At(r, c) * v.vec[c]
}
}
return dst
} | |
c20816 | + q2.W, q1.V.Add(q2.V)}
} | |
c20817 | - q2.W, q1.V.Sub(q2.V)}
} | |
c20818 | + q1.V[1]*q1.V[1] + q1.V[2]*q1.V[2])))
} | |
c20819 | + 2*w*x, 0,
2*x*z + 2*w*y, 2*y*z - 2*w*x, 1 - 2*x*x - 2*y*y, 0,
0, 0, 0, 1,
}
} | |
c20820 | q2.W) && q1.V.ApproxEqual(q2.V)
} | |
c20821 | return Quat{
(m[8] - m[2]) / s,
Vec3{
(m[4] + m[1]) / s,
0.25 * s,
(m[9] + m[6]) / s,
},
}
}
s := float64(2.0 * math.Sqrt(float64(1.0+m[10]-m[0]-m[5])))
return Quat{
(m[1] - m[4]) / s,
Vec3{
(m[8] + m[2]) / s,
(m[9] + m[6]) / s,
0.25 * s,
},
}
} | |
c20822 | skip that part if you really want to force up
//right := direction.Cross(up)
//up = right.Cross(direction)
// Because of the 1rst rotation, the up is probably completely screwed up.
// Find the rotation between the "up" of the rotated object, and the desired up
upCur := rotDir.Rotate(Vec3{0, 1, 0})
rotUp := Qua... | |
c20823 | = r * float64(s)
z = r * float64(c)
phi2 = phi
return
} | |
c20824 | phi
theta = float64(math.Atan2(float64(rho), float64(z)))
return
} | |
c20825 | m[9]*m[9] + m[10]*m[10])
return float32(math.Sqrt(math.Max(scaleX, math.Max(scaleY, scaleZ))))
} | |
c20826 | Mat4 {
return LookAtV(Vec3{eyeX, eyeY, eyeZ}, Vec3{centerX, centerY, centerZ}, Vec3{upX, upY, upZ})
} | |
c20827 | pool slice with non-exact cap. If you're a user, please file an issue with github.com/go-gl/mathgl about this bug. This should never happen.")
}
getPool(pool).Put(slice)
} | |
c20828 | 1, this is not an exact
// log, but rather a rounding of it
if val&1 != 0 {
exact = false
}
l++
}
return l, exact
} | |
c20829 | on bezier curve with t out of range [0.0,1.0]")
}
return cPoint1.Mul((1.0 - t) * (1.0 - t)).Add(cPoint2.Mul(2 * (1 - t) * t)).Add(cPoint3.Mul(t * t))
} | |
c20830 | on bezier curve with t out of range [0.0,1.0]")
}
return cPoint1.Mul((1.0 - t) * (1.0 - t)).Add(cPoint2.Mul(2 * (1 - t) * t)).Add(cPoint3.Mul(t * t))
} | |
c20831 | := 1; i <= n; i++ {
point = point.Add(cPoints[i].Mul(float64(float64(choose(n, i)) * math.Pow(float64(1-t), float64(n-i)) * math.Pow(float64(t), float64(i))))) // P += P_i * nCi * (1-t)^(n-i) * t^i
}
return point
} | |
c20832 | == 2 {
line[0] = cPoints[0]
line[1] = cPoints[len(cPoints)-1]
return
}
line[0] = cPoints[0]
for i := 1; i < numPoints-1; i++ {
line[i] = BezierCurve3D(Clamp(float64(i)/float64(numPoints-1), 0.0, 1.0), cPoints)
}
line[numPoints-1] = cPoints[len(cPoints)-1]
return
} | |
c20833 | curveRange[1] {
return BezierCurve2D((t-curveRange[0])/(curveRange[1]-curveRange[0]), cPoints[i])
}
}
panic("t is out of the range of all bezier curves in this spline")
} | |
c20834 | pop from mat stack, at minimum stack length of 1")
}
(*ms) = (*ms)[:len(*ms)-1]
return nil
} | |
c20835 | if !FloatEqual(v1[i], v2[i]) {
return false
}
}
return true
} | |
c20836 | v2[i], threshold) {
return false
}
}
return true
} | |
c20837 | {
if !eq(v1[i], v2[i]) {
return false
}
}
return true
} | |
c20838 | (*ms)[len(*ms)-1]
(*ms) = append(*ms, prev.Mul4(m))
} | |
c20839 | pop last element of the stack; Matrix Stack must have at least one element")
}
retVal := (*ms)[len(*ms)-1]
(*ms) = (*ms)[:len(*ms)-1]
return retVal, nil
} | |
c20840 | return errors.New("Cannot unwind a matrix to below 1 value")
}
(*ms) = (*ms)[:len(*ms)-n]
return nil
} | |
c20841 | our target is the "top" element of the list.
tmp := ms.Copy()
if from == 1 {
(*tmp) = append(*tmp, mgl64.Mat4{})
}
copy((*tmp)[1:], (*tmp)[from-1:])
if from-2 > 0 {
(*tmp) = (*tmp)[:len(*tmp)-(from-2)]
}
err := tmp.Reseed(1, m.Peek())
if err != nil {
return nil, err
}
(*tmp) = append(*m, (*tmp)[2:]..... | |
c20842 | / rml), 0, 0, 0, 0, float32((2. * near) / tmb), 0, 0, float32(A), float32(B), float32(C), -1, 0, 0, float32(D), 0}
} | |
c20843 | s[2], u[2], -f[2], 0,
0, 0, 0, 1,
}
return M.Mul4(Translate3D(float32(-eye[0]), float32(-eye[1]), float32(-eye[2])))
} | |
c20844 | + m[2]*m[2]))),
float64(math.Sqrt(float64(m[4]*m[4] + m[5]*m[5] + m[6]*m[6]))),
float64(math.Sqrt(float64(m[8]*m[8] + m[9]*m[9] + m[10]*m[10])))
} | |
c20845 | / 180.0
c, s := float32(math.Cos(float64(angle/2))), float32(math.Sin(float64(angle/2)))
return Quat{c, axis.Mul(s)}
} | |
c20846 | q2.W, epsilon) && q1.V.ApproxEqualThreshold(q2.V, epsilon)
} | |
c20847 | float32) bool) bool {
return f(q1.W, q2.W) && q1.V.ApproxFuncEqual(q2.V, f)
} | |
c20848 | return Abs(q1.Normalize().Dot(q2.Normalize())) > 1-epsilon
} | |
c20849 | "ideal" rotation axis
// So guess one; any will do as long as it's perpendicular to start
axis := Vec3{1, 0, 0}.Cross(start)
if axis.Dot(axis) < epsilon {
// bad luck, they were parallel, try again!
axis = Vec3{0, 1, 0}.Cross(start)
}
return QuatRotate(math.Pi, axis.Normalize())
}
axis := start.Cro... | |
c20850 | row1[0], row0[1], row1[1]}
} | |
c20851 | col0[1], col1[0], col1[1]}
} | |
c20852 | return Mat2x3{row0[0], row1[0], row0[1], row1[1], row0[2], row1[2]}
} | |
c20853 | col0[1], col1[0], col1[1], col2[0], col2[1]}
} | |
c20854 | Mat2x4{row0[0], row1[0], row0[1], row1[1], row0[2], row1[2], row0[3], row1[3]}
} | |
c20855 | col1[1], col2[0], col2[1], col3[0], col3[1]}
} | |
c20856 | row1[0], row2[0], row0[1], row1[1], row2[1]}
} | |
c20857 | return Mat3x2{col0[0], col0[1], col0[2], col1[0], col1[1], col1[2]}
} | |
c20858 | row1[0], row2[0], row0[1], row1[1], row2[1], row0[2], row1[2], row2[2]}
} | |
c20859 | col0[1], col0[2], col1[0], col1[1], col1[2], col2[0], col2[1], col2[2]}
} | |
c20860 | row2[1], row0[2], row1[2], row2[2], row0[3], row1[3], row2[3]}
} | |
c20861 | col1[2], col2[0], col2[1], col2[2], col3[0], col3[1], col3[2]}
} | |
c20862 | row3[0], row0[1], row1[1], row2[1], row3[1]}
} | |
c20863 | Mat4x2{col0[0], col0[1], col0[2], col0[3], col1[0], col1[1], col1[2], col1[3]}
} | |
c20864 | range m1 {
if !FloatEqual(m1[i], m2[i]) {
return false
}
}
return true
} | |
c20865 | row1[1], row2[1], row3[1], row0[2], row1[2], row2[2], row3[2]}
} | |
c20866 | col1[1], col1[2], col1[3], col2[0], col2[1], col2[2], col2[3]}
} | |
c20867 | row2[0], row3[0], row0[1], row1[1], row2[1], row3[1], row0[2], row1[2], row2[2], row3[2], row0[3], row1[3], row2[3], row3[3]}
} | |
c20868 | col0[2], col0[3], col1[0], col1[1], col1[2], col1[3], col2[0], col2[1], col2[2], col2[3], col3[0], col3[1], col3[2], col3[3]}
} | |
c20869 | {
fmt.Fprintf(w, "%f\t", col)
}
fmt.Fprintln(w, "")
}
w.Flush()
return buf.String()
} | |
c20870 |
return NoInverseError{Loc: i - 1, Mat: curr}
}
ghost := inv.Mul4((*ms)[i])
curr = (*ms)[i]
(*ms)[i] = (*ms)[i-1].Mul4(ghost)
}
return nil
} | |
c20871 | t) * (1 - t)).Add(cPoint2.Mul(3 * (1 - t) * (1 - t) * t)).Add(cPoint3.Mul(3 * (1 - t) * t * t)).Add(cPoint4.Mul(t * t * t))
} | |
c20872 | t) * (1 - t)).Add(cPoint2.Mul(3 * (1 - t) * (1 - t) * t)).Add(cPoint3.Mul(3 * (1 - t) * t * t)).Add(cPoint4.Mul(t * t * t))
} | |
c20873 | curveRange[1] {
return BezierCurve3D((t-curveRange[0])/(curveRange[1]-curveRange[0]), cPoints[i])
}
}
panic("t is out of the range of all bezier curves in this spline")
} | |
c20874 | m2[i], threshold) {
return false
}
}
return true
} | |
c20875 | {
if !eq(m1[i], m2[i]) {
return false
}
}
return true
} | |
c20876 | = append(depTypes, depType)
}
sort.Strings(depTypes)
return depTypes
} | |
c20877 | if total == -1 {
return fmt.Sprintf(
"%s: %v of an unknown total size",
prefix,
ioprogress.ByteUnitStr(progress),
)
}
return fmt.Sprintf(
"%s: %s %s",
prefix,
bar(progress, total),
ioprogress.DrawTextFormatBytes(progress, total),
)
}
return &ioprogress.Reader{
Reader: res.... | |
c20878 | := os.Remove(name); err != nil && !os.IsNotExist(err) {
return err
}
return nil
} | |
c20879 | errwrap.Wrap(errors.New("failed to lock temporary file"), err)
}
log.Printf("another rkt instance is downloading this file, waiting...")
_, err = lock.ExclusiveLock(tmp.Name(), lock.RegFile)
if err != nil {
return nil, errwrap.Wrap(errors.New("failed to lock temporary file"), err)
}
}
return &removeOnC... | |
c20880 |
return "", errwrap.Wrap(errors.New("error unmarshaling stage1 manifest"), err)
}
if ep, ok := s1m.Annotations.Get(entrypoint); ok {
return ep, nil
}
return "", fmt.Errorf("entrypoint %q not found", entrypoint)
} | |
c20881 | != nil {
return -1, errwrap.Wrap(errors.New("error unmarshaling stage1 manifest"), err)
}
if iv, ok := s1m.Annotations.Get(interfaceVersion); ok {
v, err := strconv.Atoi(iv)
if err != nil {
return -1, errwrap.Wrap(errors.New("error parsing interface version"), err)
}
return v, nil
}
// "interface-ve... | |
c20882 | }
// Add the runtime args to the network instances.
// We don't do this earlier because we also load networks in other contexts
for _, n := range nets {
n.runtime.Args = e.netsLoadList.SpecificArgs(n.conf.Name)
}
return netSlice, nil
} | |
c20883 | // Protect kernel tunables by default
if !p.InsecureOptions.DisablePaths {
pa.roPaths = append(pa.roPaths, protectKernelROPaths...)
pa.hiddenPaths = append(pa.hiddenDirs, protectKernelHiddenPaths...)
pa.hiddenDirs = append(pa.hiddenDirs, protectKernelHiddenDirs...)
}
// Seccomp
if !p.InsecureOptions.Disable... | |
c20884 | {
if v.Limit() == nil {
return nil
}
if v.Limit().Value() > MaxMilliValue {
return fmt.Errorf("cpu limit exceeds the maximum millivalue: %v", v.Limit().String())
}
val := uint64(v.Limit().MilliValue() / 10)
res.CPUQuota = &val
return nil
})
case *types.LinuxCPUShares:
err... | |
c20885 | {
return nil, err
}
defer rows.Close()
for rows.Next() {
aciinfo := &ACIInfo{}
if err := aciinfoRowScan(rows, aciinfo); err != nil {
return nil, err
}
aciinfos = append(aciinfos, aciinfo)
}
if err := rows.Err(); err != nil {
return nil, err
}
return aciinfos, err
} | |
c20886 | return nil, false, err
}
aciinfos = append(aciinfos, aciinfo)
}
if err := rows.Err(); err != nil {
return nil, false, err
}
return aciinfos, found, err
} | |
c20887 | err
}
// No more than one row for blobkey must exist.
break
}
if err := rows.Err(); err != nil {
return nil, false, err
}
return aciinfo, found, err
} | |
c20888 | return nil, err
}
defer rows.Close()
for rows.Next() {
aciinfo := &ACIInfo{}
if err := aciinfoRowScan(rows, aciinfo); err != nil {
return nil, err
}
aciinfos = append(aciinfos, aciinfo)
}
if err := rows.Err(); err != nil {
return nil, err
}
return aciinfos, err
} | |
c20889 | err != nil {
return err
}
_, err = tx.Exec("INSERT into aciinfo (blobkey, name, importtime, lastused, latest, size, treestoresize) VALUES ($1, $2, $3, $4, $5, $6, $7)", aciinfo.BlobKey, aciinfo.Name, aciinfo.ImportTime, aciinfo.LastUsed, aciinfo.Latest, aciinfo.Size, aciinfo.TreeStoreSize)
if err != nil {
retur... | |
c20890 | "-kernel", kernelPath,
"-fsdev", "local,id=root,path=stage1/rootfs,security_model=none",
"-device", "virtio-9p-pci,fsdev=root,mount_tag=/dev/root",
"-append", fmt.Sprintf("%s", strings.Join(driverConfiguration.KernelParams, " ")),
"-chardev", "stdio,id=virtiocon0,signal=off",
"-device", "virtio-serial",
"... | |
c20891 | := fmt.Sprintf("tap,ifname=%s,script=no,downscript=no,vhost=on", nd.IfName())
qemuArgs = append(qemuArgs, []string{"-net", qemuNic}...)
}
return qemuArgs
} | |
c20892 | "quiet=vga",
"quiet systemd.log_level=emerg",
}...)
}
customKernelParams := os.Getenv("RKT_HYPERVISOR_EXTRA_KERNEL_PARAMS")
if customKernelParams != "" {
hv.KernelParams = append(hv.KernelParams, customKernelParams)
}
} | |
c20893 | if err != nil {
return "", fmt.Errorf(`invalid docker URL %q; expected syntax is "docker://[REGISTRY_HOST[:REGISTRY_PORT]/]IMAGE_NAME[:TAG]"`, u)
}
latest := dockerURL.Tag == "latest"
return f.fetchImageFrom(u, latest)
} | |
c20894 | return
}
rf.Close()
for _, app := range apps {
ampath := common.ImageManifestPath(root, app.Name)
amf, err := os.Open(ampath)
if err != nil {
rerr = errwrap.Wrap(fmt.Errorf("failed reading app manifest %q", ampath), err)
return
}
err = registerApp(u, app.Name.String(), amf)
amf.Close()
if err ... | |
c20895 |
case err == nil:
pth := path.Join("/pods", uuid.String())
return httpRequest("DELETE", pth, nil)
case os.IsNotExist(err):
return nil
default:
return err
}
} | |
c20896 | err != nil {
return errUnreachable
} else {
conn.Close()
return nil
}
} | |
c20897 |
ni.Mask = net.IP(result.IP4.IP.Mask)
ni.HostIP = result.IP4.Gateway
ni.IP4 = result.IP4
ni.DNS = result.DNS
} | |
c20898 | {
panic(fmt.Errorf("command with name %q already exists", name))
}
commands[name] = fn
return Entrypoint(name)
} | |
c20899 | kind: data.kind,
}
flags.Var(wrapper, data.flag, data.help)
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.