_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q20800 | Zero | train | func (vn *VecN) Zero(n int) {
vn.Resize(n)
for i := range vn.vec {
vn.vec[i] = 0
}
} | go | {
"resource": ""
} |
q20801 | Cross | train | func (vn *VecN) Cross(dst *VecN, other *VecN) *VecN {
if vn == nil || other == nil {
return nil
}
if len(vn.vec) != 3 || len(other.vec) != 3 {
panic("Cannot take binary cross product of non-3D elements (7D cross product not implemented)")
}
dst = dst.Resize(3)
dst.vec[0], dst.vec[1], dst.vec[2] = vn.vec[1]*o... | go | {
"resource": ""
} |
q20802 | Mul | train | func (vn *VecN) Mul(dst *VecN, c float32) *VecN {
if vn == nil {
return nil
}
dst = dst.Resize(len(vn.vec))
for i, el := range vn.vec {
dst.vec[i] = el * c
}
return dst
} | go | {
"resource": ""
} |
q20803 | Vec2 | train | func (vn *VecN) Vec2() Vec2 {
raw := vn.Raw()
return Vec2{raw[0], raw[1]}
} | go | {
"resource": ""
} |
q20804 | Vec3 | train | func (vn *VecN) Vec3() Vec3 {
raw := vn.Raw()
return Vec3{raw[0], raw[1], raw[2]}
} | go | {
"resource": ""
} |
q20805 | Vec4 | train | func (vn *VecN) Vec4() Vec4 {
raw := vn.Raw()
return Vec4{raw[0], raw[1], raw[2], raw[3]}
} | go | {
"resource": ""
} |
q20806 | CopyMatMN | train | func CopyMatMN(dst, src *MatMxN) {
if dst == nil || src == nil {
return
}
dst.Reshape(src.m, src.n)
copy(dst.dat, src.dat)
} | go | {
"resource": ""
} |
q20807 | IdentN | train | func IdentN(dst *MatMxN, n int) *MatMxN {
dst = dst.Reshape(n, n)
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
if i == j {
dst.Set(i, j, 1)
} else {
dst.Set(i, j, 0)
}
}
}
return dst
} | go | {
"resource": ""
} |
q20808 | Zero | train | func (mat *MatMxN) Zero(m, n int) {
if mat == nil {
return
}
mat.Reshape(m, n)
for i := range mat.dat {
mat.dat[i] = 0
}
} | go | {
"resource": ""
} |
q20809 | destroy | train | func (mat *MatMxN) destroy() {
if mat == nil {
return
}
if shouldPool && mat.dat != nil {
returnToPool(mat.dat)
}
mat.m, mat.n = 0, 0
mat.dat = nil
} | go | {
"resource": ""
} |
q20810 | Transpose | train | func (mat *MatMxN) Transpose(dst *MatMxN) (t *MatMxN) {
if mat == nil {
return nil
}
if dst == mat {
dst = NewMatrix(mat.n, mat.m)
// Copy data to correct matrix,
// delete temporary buffer,
// and set the return value to the
// correct one
defer func() {
copy(mat.dat, dst.dat)
mat.m, mat.n = ... | go | {
"resource": ""
} |
q20811 | NumRowCols | train | func (mat *MatMxN) NumRowCols() (rows, cols int) {
return mat.m, mat.n
} | go | {
"resource": ""
} |
q20812 | Add | train | func (mat *MatMxN) Add(dst *MatMxN, addend *MatMxN) *MatMxN {
if mat == nil || addend == nil || mat.m != addend.m || mat.n != addend.n {
return nil
}
dst = dst.Reshape(mat.m, mat.n)
// No need to care about rows and columns
// since it's element-wise anyway
for i, el := range mat.dat {
dst.dat[i] = el + add... | go | {
"resource": ""
} |
q20813 | Sub | train | func (mat *MatMxN) Sub(dst *MatMxN, subtrahend *MatMxN) *MatMxN {
if mat == nil || subtrahend == nil || mat.m != subtrahend.m || mat.n != subtrahend.n {
return nil
}
dst = dst.Reshape(mat.m, mat.n)
// No need to care about rows and columns
// since it's element-wise anyway
for i, el := range mat.dat {
dst.d... | go | {
"resource": ""
} |
q20814 | Mul | train | func (mat *MatMxN) Mul(dst *MatMxN, c float32) *MatMxN {
if mat == nil {
return nil
}
dst = dst.Reshape(mat.m, mat.n)
for i, el := range mat.dat {
dst.dat[i] = el * c
}
return dst
} | go | {
"resource": ""
} |
q20815 | MulNx1 | train | func (mat *MatMxN) MulNx1(dst, v *VecN) *VecN {
if mat == nil || v == nil || mat.n != len(v.vec) {
return nil
}
if dst == v {
v = NewVecN(len(v.vec))
copy(v.vec, dst.vec)
defer v.destroy()
}
dst = dst.Resize(mat.m)
for r := 0; r < mat.m; r++ {
dst.vec[r] = 0
for c := 0; c < mat.n; c++ {
dst.vec... | go | {
"resource": ""
} |
q20816 | Add | train | func (q1 Quat) Add(q2 Quat) Quat {
return Quat{q1.W + q2.W, q1.V.Add(q2.V)}
} | go | {
"resource": ""
} |
q20817 | Sub | train | func (q1 Quat) Sub(q2 Quat) Quat {
return Quat{q1.W - q2.W, q1.V.Sub(q2.V)}
} | go | {
"resource": ""
} |
q20818 | Len | train | func (q1 Quat) Len() float64 {
return float64(math.Sqrt(float64(q1.W*q1.W + q1.V[0]*q1.V[0] + q1.V[1]*q1.V[1] + q1.V[2]*q1.V[2])))
} | go | {
"resource": ""
} |
q20819 | Mat4 | train | func (q1 Quat) Mat4() Mat4 {
w, x, y, z := q1.W, q1.V[0], q1.V[1], q1.V[2]
return Mat4{
1 - 2*y*y - 2*z*z, 2*x*y + 2*w*z, 2*x*z - 2*w*y, 0,
2*x*y - 2*w*z, 1 - 2*x*x - 2*z*z, 2*y*z + 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,
}
} | go | {
"resource": ""
} |
q20820 | ApproxEqual | train | func (q1 Quat) ApproxEqual(q2 Quat) bool {
return FloatEqual(q1.W, q2.W) && q1.V.ApproxEqual(q2.V)
} | go | {
"resource": ""
} |
q20821 | Mat4ToQuat | train | func Mat4ToQuat(m Mat4) Quat {
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
if tr := m[0] + m[5] + m[10]; tr > 0 {
s := float64(0.5 / math.Sqrt(float64(tr+1.0)))
return Quat{
0.25 / s,
Vec3{
(m[6] - m[9]) * s,
(m[8] - m[2]) * s,
(m[1] - m[4]... | go | {
"resource": ""
} |
q20822 | QuatLookAtV | train | func QuatLookAtV(eye, center, up Vec3) Quat {
// http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-17-quaternions/#I_need_an_equivalent_of_gluLookAt__How_do_I_orient_an_object_towards_a_point__
// https://bitbucket.org/sinbad/ogre/src/d2ef494c4a2f5d6e2f0f17d3bfb9fd936d5423bb/OgreMain/src/OgreCamera.cpp?a... | go | {
"resource": ""
} |
q20823 | SphericalToCylindrical | train | func SphericalToCylindrical(r, theta, phi float64) (rho, phi2, z float64) {
s, c := math.Sincos(float64(theta))
rho = r * float64(s)
z = r * float64(c)
phi2 = phi
return
} | go | {
"resource": ""
} |
q20824 | CylindircalToSpherical | train | func CylindircalToSpherical(rho, phi, z float64) (r, theta, phi2 float64) {
r = float64(math.Hypot(float64(rho), float64(z)))
phi2 = phi
theta = float64(math.Atan2(float64(rho), float64(z)))
return
} | go | {
"resource": ""
} |
q20825 | ExtractMaxScale | train | func ExtractMaxScale(m Mat4) float32 {
scaleX := float64(m[0]*m[0] + m[1]*m[1] + m[2]*m[2])
scaleY := float64(m[4]*m[4] + m[5]*m[5] + m[6]*m[6])
scaleZ := float64(m[8]*m[8] + m[9]*m[9] + m[10]*m[10])
return float32(math.Sqrt(math.Max(scaleX, math.Max(scaleY, scaleZ))))
} | go | {
"resource": ""
} |
q20826 | LookAt | train | func LookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ float64) Mat4 {
return LookAtV(Vec3{eyeX, eyeY, eyeZ}, Vec3{centerX, centerY, centerZ}, Vec3{upX, upY, upZ})
} | go | {
"resource": ""
} |
q20827 | returnToPool | train | func returnToPool(slice []float32) {
if cap(slice) == 0 {
return
}
pool, exact := binLog(cap(slice))
if !exact {
panic("attempt to 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)
} | go | {
"resource": ""
} |
q20828 | binLog | train | func binLog(val int) (int, bool) {
if val <= 0 {
return -1, false
}
exact := true
l := 0
for ; val > 1; val = val >> 1 {
// If the current lsb is 1 and the number
// is not equal to 1, this is not an exact
// log, but rather a rounding of it
if val&1 != 0 {
exact = false
}
l++
}
return l, exac... | go | {
"resource": ""
} |
q20829 | QuadraticBezierCurve2D | train | func QuadraticBezierCurve2D(t float64, cPoint1, cPoint2, cPoint3 Vec2) Vec2 {
if t < 0.0 || t > 1.0 {
panic("Can't interpolate 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))
} | go | {
"resource": ""
} |
q20830 | QuadraticBezierCurve3D | train | func QuadraticBezierCurve3D(t float64, cPoint1, cPoint2, cPoint3 Vec3) Vec3 {
if t < 0.0 || t > 1.0 {
panic("Can't interpolate 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))
} | go | {
"resource": ""
} |
q20831 | BezierCurve3D | train | func BezierCurve3D(t float64, cPoints []Vec3) Vec3 {
if t < 0.0 || t > 1.0 {
panic("Input to bezier has t not in range [0,1]. If you think this is a precision error, use mathgl.Clamp[f|d] before calling this function")
}
n := len(cPoints) - 1
point := cPoints[0].Mul(float64(math.Pow(float64(1.0-t), float64(n))))... | go | {
"resource": ""
} |
q20832 | MakeBezierCurve3D | train | func MakeBezierCurve3D(numPoints int, cPoints []Vec3) (line []Vec3) {
line = make([]Vec3, numPoints)
if numPoints == 0 {
return
} else if numPoints == 1 {
line[0] = cPoints[0]
return
} else if numPoints == 2 {
line[0] = cPoints[0]
line[1] = cPoints[len(cPoints)-1]
return
}
line[0] = cPoints[0]
for i... | go | {
"resource": ""
} |
q20833 | BezierSplineInterpolate2D | train | func BezierSplineInterpolate2D(t float64, ranges [][2]float64, cPoints [][]Vec2) Vec2 {
if len(ranges) != len(cPoints) {
panic("Each bezier curve needs a range")
}
for i, curveRange := range ranges {
if t >= curveRange[0] && t <= curveRange[1] {
return BezierCurve2D((t-curveRange[0])/(curveRange[1]-curveRang... | go | {
"resource": ""
} |
q20834 | Pop | train | func (ms *MatStack) Pop() error {
if len(*ms) == 1 {
return errors.New("Cannot pop from mat stack, at minimum stack length of 1")
}
(*ms) = (*ms)[:len(*ms)-1]
return nil
} | go | {
"resource": ""
} |
q20835 | ApproxEqual | train | func (v1 Vec3) ApproxEqual(v2 Vec3) bool {
for i := range v1 {
if !FloatEqual(v1[i], v2[i]) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q20836 | ApproxEqualThreshold | train | func (v1 Vec3) ApproxEqualThreshold(v2 Vec3, threshold float32) bool {
for i := range v1 {
if !FloatEqualThreshold(v1[i], v2[i], threshold) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q20837 | ApproxFuncEqual | train | func (v1 Vec3) ApproxFuncEqual(v2 Vec3, eq func(float32, float32) bool) bool {
for i := range v1 {
if !eq(v1[i], v2[i]) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q20838 | Push | train | func (ms *TransformStack) Push(m mgl64.Mat4) {
prev := (*ms)[len(*ms)-1]
(*ms) = append(*ms, prev.Mul4(m))
} | go | {
"resource": ""
} |
q20839 | Pop | train | func (ms *TransformStack) Pop() (mgl64.Mat4, error) {
if len(*ms) == 1 {
return mgl64.Mat4{}, errors.New("attempt to 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
} | go | {
"resource": ""
} |
q20840 | Unwind | train | func (ms *TransformStack) Unwind(n int) error {
if n > len(*ms)-1 {
return errors.New("Cannot unwind a matrix to below 1 value")
}
(*ms) = (*ms)[:len(*ms)-n]
return nil
} | go | {
"resource": ""
} |
q20841 | Rebase | train | func Rebase(ms *TransformStack, from int, m *TransformStack) (*TransformStack, error) {
if from <= 0 || from >= len(*ms) {
return nil, errors.New("Cannot rebase, index out of range")
}
// Shift tmp so that the element immediately
// preceding our target is the "top" element of the list.
tmp := ms.Copy()
if fro... | go | {
"resource": ""
} |
q20842 | Frustum | train | func Frustum(left, right, bottom, top, near, far float32) Mat4 {
rml, tmb, fmn := (right - left), (top - bottom), (far - near)
A, B, C, D := (right+left)/rml, (top+bottom)/tmb, -(far+near)/fmn, -(2*far*near)/fmn
return Mat4{float32((2. * near) / rml), 0, 0, 0, 0, float32((2. * near) / tmb), 0, 0, float32(A), float3... | go | {
"resource": ""
} |
q20843 | LookAtV | train | func LookAtV(eye, center, up Vec3) Mat4 {
f := center.Sub(eye).Normalize()
s := f.Cross(up.Normalize()).Normalize()
u := s.Cross(f)
M := Mat4{
s[0], u[0], -f[0], 0,
s[1], u[1], -f[1], 0,
s[2], u[2], -f[2], 0,
0, 0, 0, 1,
}
return M.Mul4(Translate3D(float32(-eye[0]), float32(-eye[1]), float32(-eye[2])))
... | go | {
"resource": ""
} |
q20844 | Extract3DScale | train | func Extract3DScale(m Mat4) (x, y, z float64) {
return float64(math.Sqrt(float64(m[0]*m[0] + m[1]*m[1] + 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])))
} | go | {
"resource": ""
} |
q20845 | QuatRotate | train | func QuatRotate(angle float32, axis Vec3) Quat {
// angle = (float32(math.Pi) * angle) / 180.0
c, s := float32(math.Cos(float64(angle/2))), float32(math.Sin(float64(angle/2)))
return Quat{c, axis.Mul(s)}
} | go | {
"resource": ""
} |
q20846 | ApproxEqualThreshold | train | func (q1 Quat) ApproxEqualThreshold(q2 Quat, epsilon float32) bool {
return FloatEqualThreshold(q1.W, q2.W, epsilon) && q1.V.ApproxEqualThreshold(q2.V, epsilon)
} | go | {
"resource": ""
} |
q20847 | ApproxEqualFunc | train | func (q1 Quat) ApproxEqualFunc(q2 Quat, f func(float32, float32) bool) bool {
return f(q1.W, q2.W) && q1.V.ApproxFuncEqual(q2.V, f)
} | go | {
"resource": ""
} |
q20848 | OrientationEqualThreshold | train | func (q1 Quat) OrientationEqualThreshold(q2 Quat, epsilon float32) bool {
return Abs(q1.Normalize().Dot(q2.Normalize())) > 1-epsilon
} | go | {
"resource": ""
} |
q20849 | QuatBetweenVectors | train | func QuatBetweenVectors(start, dest Vec3) Quat {
// http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-17-quaternions/#I_need_an_equivalent_of_gluLookAt__How_do_I_orient_an_object_towards_a_point__
// https://github.com/g-truc/glm/blob/0.9.5/glm/gtx/quaternion.inl#L225
// https://bitbucket.org/sinbad/ogr... | go | {
"resource": ""
} |
q20850 | Mat2FromRows | train | func Mat2FromRows(row0, row1 Vec2) Mat2 {
return Mat2{row0[0], row1[0], row0[1], row1[1]}
} | go | {
"resource": ""
} |
q20851 | Mat2FromCols | train | func Mat2FromCols(col0, col1 Vec2) Mat2 {
return Mat2{col0[0], col0[1], col1[0], col1[1]}
} | go | {
"resource": ""
} |
q20852 | Mat2x3FromRows | train | func Mat2x3FromRows(row0, row1 Vec3) Mat2x3 {
return Mat2x3{row0[0], row1[0], row0[1], row1[1], row0[2], row1[2]}
} | go | {
"resource": ""
} |
q20853 | Mat2x3FromCols | train | func Mat2x3FromCols(col0, col1, col2 Vec2) Mat2x3 {
return Mat2x3{col0[0], col0[1], col1[0], col1[1], col2[0], col2[1]}
} | go | {
"resource": ""
} |
q20854 | Mat2x4FromRows | train | func Mat2x4FromRows(row0, row1 Vec4) Mat2x4 {
return Mat2x4{row0[0], row1[0], row0[1], row1[1], row0[2], row1[2], row0[3], row1[3]}
} | go | {
"resource": ""
} |
q20855 | Mat2x4FromCols | train | func Mat2x4FromCols(col0, col1, col2, col3 Vec2) Mat2x4 {
return Mat2x4{col0[0], col0[1], col1[0], col1[1], col2[0], col2[1], col3[0], col3[1]}
} | go | {
"resource": ""
} |
q20856 | Mat3x2FromRows | train | func Mat3x2FromRows(row0, row1, row2 Vec2) Mat3x2 {
return Mat3x2{row0[0], row1[0], row2[0], row0[1], row1[1], row2[1]}
} | go | {
"resource": ""
} |
q20857 | Mat3x2FromCols | train | func Mat3x2FromCols(col0, col1 Vec3) Mat3x2 {
return Mat3x2{col0[0], col0[1], col0[2], col1[0], col1[1], col1[2]}
} | go | {
"resource": ""
} |
q20858 | Mat3FromRows | train | func Mat3FromRows(row0, row1, row2 Vec3) Mat3 {
return Mat3{row0[0], row1[0], row2[0], row0[1], row1[1], row2[1], row0[2], row1[2], row2[2]}
} | go | {
"resource": ""
} |
q20859 | Mat3FromCols | train | func Mat3FromCols(col0, col1, col2 Vec3) Mat3 {
return Mat3{col0[0], col0[1], col0[2], col1[0], col1[1], col1[2], col2[0], col2[1], col2[2]}
} | go | {
"resource": ""
} |
q20860 | Mat3x4FromRows | train | func Mat3x4FromRows(row0, row1, row2 Vec4) Mat3x4 {
return Mat3x4{row0[0], row1[0], row2[0], row0[1], row1[1], row2[1], row0[2], row1[2], row2[2], row0[3], row1[3], row2[3]}
} | go | {
"resource": ""
} |
q20861 | Mat3x4FromCols | train | func Mat3x4FromCols(col0, col1, col2, col3 Vec3) Mat3x4 {
return Mat3x4{col0[0], col0[1], col0[2], col1[0], col1[1], col1[2], col2[0], col2[1], col2[2], col3[0], col3[1], col3[2]}
} | go | {
"resource": ""
} |
q20862 | Mat4x2FromRows | train | func Mat4x2FromRows(row0, row1, row2, row3 Vec2) Mat4x2 {
return Mat4x2{row0[0], row1[0], row2[0], row3[0], row0[1], row1[1], row2[1], row3[1]}
} | go | {
"resource": ""
} |
q20863 | Mat4x2FromCols | train | func Mat4x2FromCols(col0, col1 Vec4) Mat4x2 {
return Mat4x2{col0[0], col0[1], col0[2], col0[3], col1[0], col1[1], col1[2], col1[3]}
} | go | {
"resource": ""
} |
q20864 | ApproxEqual | train | func (m1 Mat4x2) ApproxEqual(m2 Mat4x2) bool {
for i := range m1 {
if !FloatEqual(m1[i], m2[i]) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q20865 | Mat4x3FromRows | train | func Mat4x3FromRows(row0, row1, row2, row3 Vec3) Mat4x3 {
return Mat4x3{row0[0], row1[0], row2[0], row3[0], row0[1], row1[1], row2[1], row3[1], row0[2], row1[2], row2[2], row3[2]}
} | go | {
"resource": ""
} |
q20866 | Mat4x3FromCols | train | func Mat4x3FromCols(col0, col1, col2 Vec4) Mat4x3 {
return Mat4x3{col0[0], col0[1], col0[2], col0[3], col1[0], col1[1], col1[2], col1[3], col2[0], col2[1], col2[2], col2[3]}
} | go | {
"resource": ""
} |
q20867 | Mat4FromRows | train | func Mat4FromRows(row0, row1, row2, row3 Vec4) Mat4 {
return Mat4{row0[0], row1[0], 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]}
} | go | {
"resource": ""
} |
q20868 | Mat4FromCols | train | func Mat4FromCols(col0, col1, col2, col3 Vec4) Mat4 {
return Mat4{col0[0], col0[1], 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]}
} | go | {
"resource": ""
} |
q20869 | String | train | func (m Mat4) String() string {
buf := new(bytes.Buffer)
w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight)
for i := 0; i < 4; i++ {
for _, col := range m.Row(i) {
fmt.Fprintf(w, "%f\t", col)
}
fmt.Fprintln(w, "")
}
w.Flush()
return buf.String()
} | go | {
"resource": ""
} |
q20870 | reseed | train | func (ms *TransformStack) reseed(n int, change mgl32.Mat4) error {
backup := []mgl32.Mat4((*ms)[n:])
backup = append([]mgl32.Mat4{}, backup...) // copy into new slice
curr := (*ms)[n]
(*ms)[n] = (*ms)[n-1].Mul4(change)
for i := n + 1; i < len(*ms); i++ {
inv := curr.Inv()
blank := mgl32.Mat4{}
if inv == b... | go | {
"resource": ""
} |
q20871 | CubicBezierCurve2D | train | func CubicBezierCurve2D(t float32, cPoint1, cPoint2, cPoint3, cPoint4 Vec2) Vec2 {
if t < 0.0 || t > 1.0 {
panic("Can't interpolate on bezier curve with t out of range [0.0,1.0]")
}
return cPoint1.Mul((1 - t) * (1 - t) * (1 - t)).Add(cPoint2.Mul(3 * (1 - t) * (1 - t) * t)).Add(cPoint3.Mul(3 * (1 - t) * t * t)).Ad... | go | {
"resource": ""
} |
q20872 | CubicBezierCurve3D | train | func CubicBezierCurve3D(t float32, cPoint1, cPoint2, cPoint3, cPoint4 Vec3) Vec3 {
if t < 0.0 || t > 1.0 {
panic("Can't interpolate on bezier curve with t out of range [0.0,1.0]")
}
return cPoint1.Mul((1 - t) * (1 - t) * (1 - t)).Add(cPoint2.Mul(3 * (1 - t) * (1 - t) * t)).Add(cPoint3.Mul(3 * (1 - t) * t * t)).Ad... | go | {
"resource": ""
} |
q20873 | BezierSplineInterpolate3D | train | func BezierSplineInterpolate3D(t float32, ranges [][2]float32, cPoints [][]Vec3) Vec3 {
if len(ranges) != len(cPoints) {
panic("Each bezier curve needs a range")
}
for i, curveRange := range ranges {
if t >= curveRange[0] && t <= curveRange[1] {
return BezierCurve3D((t-curveRange[0])/(curveRange[1]-curveRang... | go | {
"resource": ""
} |
q20874 | ApproxEqualThreshold | train | func (m1 Mat2) ApproxEqualThreshold(m2 Mat2, threshold float64) bool {
for i := range m1 {
if !FloatEqualThreshold(m1[i], m2[i], threshold) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q20875 | ApproxFuncEqual | train | func (m1 Mat2) ApproxFuncEqual(m2 Mat2, eq func(float64, float64) bool) bool {
for i := range m1 {
if !eq(m1[i], m2[i]) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q20876 | getAllDepTypes | train | func getAllDepTypes() []string {
depTypes := make([]string, 0, len(cmds))
for depType := range cmds {
depTypes = append(depTypes, depType)
}
sort.Strings(depTypes)
return depTypes
} | go | {
"resource": ""
} |
q20877 | getIoProgressReader | train | func getIoProgressReader(label string, res *http.Response) io.Reader {
prefix := "Downloading " + label
fmtBytesSize := 18
barSize := int64(80 - len(prefix) - fmtBytesSize)
bar := ioprogress.DrawTextFormatBarForW(barSize, os.Stderr)
fmtfunc := func(progress, total int64) string {
// Content-Length is set to -1 w... | go | {
"resource": ""
} |
q20878 | Close | train | func (f *removeOnClose) Close() error {
if f == nil || f.File == nil {
return nil
}
name := f.File.Name()
if err := f.File.Close(); err != nil {
return err
}
if err := os.Remove(name); err != nil && !os.IsNotExist(err) {
return err
}
return nil
} | go | {
"resource": ""
} |
q20879 | getTmpROC | train | func getTmpROC(s *imagestore.Store, path string) (*removeOnClose, error) {
h := sha512.New()
h.Write([]byte(path))
pathHash := s.HashToKey(h)
tmp, err := s.TmpNamedFile(pathHash)
if err != nil {
return nil, errwrap.Wrap(errors.New("error setting up temporary file"), err)
}
// let's lock the file to avoid con... | go | {
"resource": ""
} |
q20880 | getStage1Entrypoint | train | func getStage1Entrypoint(cdir string, entrypoint string) (string, error) {
b, err := ioutil.ReadFile(common.Stage1ManifestPath(cdir))
if err != nil {
return "", errwrap.Wrap(errors.New("error reading pod manifest"), err)
}
s1m := schema.ImageManifest{}
if err := json.Unmarshal(b, &s1m); err != nil {
return ""... | go | {
"resource": ""
} |
q20881 | getStage1InterfaceVersion | train | func getStage1InterfaceVersion(cdir string) (int, error) {
b, err := ioutil.ReadFile(common.Stage1ManifestPath(cdir))
if err != nil {
return -1, errwrap.Wrap(errors.New("error reading pod manifest"), err)
}
s1m := schema.ImageManifest{}
if err := json.Unmarshal(b, &s1m); err != nil {
return -1, errwrap.Wrap(e... | go | {
"resource": ""
} |
q20882 | loadNets | train | func (e *podEnv) loadNets() ([]activeNet, error) {
if e.netsLoadList.None() {
stderr.Printf("networking namespace with loopback only")
return nil, nil
}
nets, err := e.newNetLoader().loadNets(e.netsLoadList)
if err != nil {
return nil, err
}
netSlice := make([]activeNet, 0, len(nets))
for _, net := range ... | go | {
"resource": ""
} |
q20883 | prepareApp | train | func prepareApp(p *stage1commontypes.Pod, ra *schema.RuntimeApp) (*preparedApp, error) {
pa := preparedApp{
app: ra,
env: ra.App.Environment,
noNewPrivileges: getAppNoNewPrivileges(ra.App.Isolators),
}
var err error
// Determine numeric uid and gid
u, g, err := ParseUserGroup(p, ra)
... | go | {
"resource": ""
} |
q20884 | computeAppResources | train | func computeAppResources(isolators types.Isolators) (appResources, error) {
res := appResources{}
var err error
withIsolator := func(name string, f func() error) error {
ok, err := cgroup.IsIsolatorSupported(name)
if err != nil {
return errwrap.Wrapf("could not check for isolator "+name, err)
}
if !ok {... | go | {
"resource": ""
} |
q20885 | GetACIInfosWithKeyPrefix | train | func GetACIInfosWithKeyPrefix(tx *sql.Tx, prefix string) ([]*ACIInfo, error) {
var aciinfos []*ACIInfo
rows, err := tx.Query("SELECT * from aciinfo WHERE hasPrefix(blobkey, $1)", prefix)
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
aciinfo := &ACIInfo{}
if err := aciinfoRowScan(row... | go | {
"resource": ""
} |
q20886 | GetACIInfosWithName | train | func GetACIInfosWithName(tx *sql.Tx, name string) ([]*ACIInfo, bool, error) {
var aciinfos []*ACIInfo
found := false
rows, err := tx.Query("SELECT * from aciinfo WHERE name == $1", name)
if err != nil {
return nil, false, err
}
defer rows.Close()
for rows.Next() {
found = true
aciinfo := &ACIInfo{}
if er... | go | {
"resource": ""
} |
q20887 | GetACIInfoWithBlobKey | train | func GetACIInfoWithBlobKey(tx *sql.Tx, blobKey string) (*ACIInfo, bool, error) {
aciinfo := &ACIInfo{}
found := false
rows, err := tx.Query("SELECT * from aciinfo WHERE blobkey == $1", blobKey)
if err != nil {
return nil, false, err
}
defer rows.Close()
for rows.Next() {
found = true
if err := aciinfoRowSc... | go | {
"resource": ""
} |
q20888 | GetAllACIInfos | train | func GetAllACIInfos(tx *sql.Tx, sortfields []string, ascending bool) ([]*ACIInfo, error) {
var aciinfos []*ACIInfo
query := "SELECT * from aciinfo"
if len(sortfields) > 0 {
query += fmt.Sprintf(" ORDER BY %s ", strings.Join(sortfields, ", "))
if ascending {
query += "ASC"
} else {
query += "DESC"
}
}
... | go | {
"resource": ""
} |
q20889 | WriteACIInfo | train | func WriteACIInfo(tx *sql.Tx, aciinfo *ACIInfo) error {
// ql doesn't have an INSERT OR UPDATE function so
// it's faster to remove and reinsert the row
_, err := tx.Exec("DELETE from aciinfo where blobkey == $1", aciinfo.BlobKey)
if err != nil {
return err
}
_, err = tx.Exec("INSERT into aciinfo (blobkey, name... | go | {
"resource": ""
} |
q20890 | StartCmd | train | func StartCmd(wdPath, name, kernelPath string, nds []kvm.NetDescriber, cpu, mem int64, debug bool) []string {
var (
driverConfiguration = hypervisor.KvmHypervisor{
Bin: "./qemu",
KernelParams: []string{
"root=/dev/root",
"rootfstype=9p",
"rootflags=trans=virtio,version=9p2000.L,cache=mmap",
"rw... | go | {
"resource": ""
} |
q20891 | kvmNetArgs | train | func kvmNetArgs(nds []kvm.NetDescriber) []string {
var qemuArgs []string
for _, nd := range nds {
qemuArgs = append(qemuArgs, []string{"-net", "nic,model=virtio"}...)
qemuNic := fmt.Sprintf("tap,ifname=%s,script=no,downscript=no,vhost=on", nd.IfName())
qemuArgs = append(qemuArgs, []string{"-net", qemuNic}...)
... | go | {
"resource": ""
} |
q20892 | InitKernelParams | train | func (hv *KvmHypervisor) InitKernelParams(isDebug bool) {
hv.KernelParams = append(hv.KernelParams, []string{
"console=hvc0",
"init=/usr/lib/systemd/systemd",
"no_timer_check",
"noreplace-smp",
"tsc=reliable"}...)
if isDebug {
hv.KernelParams = append(hv.KernelParams, []string{
"debug",
"systemd.lo... | go | {
"resource": ""
} |
q20893 | Hash | train | func (f *dockerFetcher) Hash(u *url.URL) (string, error) {
ensureLogger(f.Debug)
dockerURL, err := d2acommon.ParseDockerURL(path.Join(u.Host, u.Path))
if err != nil {
return "", fmt.Errorf(`invalid docker URL %q; expected syntax is "docker://[REGISTRY_HOST[:REGISTRY_PORT]/]IMAGE_NAME[:TAG]"`, u)
}
latest := dock... | go | {
"resource": ""
} |
q20894 | registerPod | train | func registerPod(root string, uuid *types.UUID, apps schema.AppList) (token string, rerr error) {
u := uuid.String()
var err error
token, err = generateMDSToken()
if err != nil {
rerr = errwrap.Wrap(errors.New("failed to generate MDS token"), err)
return
}
pmfPath := common.PodManifestPath(root)
pmf, err :... | go | {
"resource": ""
} |
q20895 | unregisterPod | train | func unregisterPod(root string, uuid *types.UUID) error {
_, err := os.Stat(filepath.Join(root, mdsRegisteredFile))
switch {
case err == nil:
pth := path.Join("/pods", uuid.String())
return httpRequest("DELETE", pth, nil)
case os.IsNotExist(err):
return nil
default:
return err
}
} | go | {
"resource": ""
} |
q20896 | CheckMdsAvailability | train | func CheckMdsAvailability() error {
if conn, err := net.Dial("unix", common.MetadataServiceRegSock); err != nil {
return errUnreachable
} else {
conn.Close()
return nil
}
} | go | {
"resource": ""
} |
q20897 | MergeCNIResult | train | func (ni *NetInfo) MergeCNIResult(result types.Result) {
ni.IP = result.IP4.IP.IP
ni.Mask = net.IP(result.IP4.IP.Mask)
ni.HostIP = result.IP4.Gateway
ni.IP4 = result.IP4
ni.DNS = result.DNS
} | go | {
"resource": ""
} |
q20898 | Add | train | func Add(name string, fn commandFn) Entrypoint {
if _, ok := commands[name]; ok {
panic(fmt.Errorf("command with name %q already exists", name))
}
commands[name] = fn
return Entrypoint(name)
} | go | {
"resource": ""
} |
q20899 | addStage1ImageFlags | train | func addStage1ImageFlags(flags *pflag.FlagSet) {
for _, data := range stage1FlagsData {
wrapper := &stage1ImageLocationFlag{
loc: &overriddenStage1Location,
kind: data.kind,
}
flags.Var(wrapper, data.flag, data.help)
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.