_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q11100 | Unlisten | train | func (l *Listener) Unlisten(channel string) error {
l.lock.Lock()
defer l.lock.Unlock()
if l.isClosed {
return errListenerClosed
}
// Similarly to LISTEN, this is not an error in Postgres, but it seems
// useful to distinguish from the normal conditions.
_, exists := l.channels[channel]
if !exists {
retur... | go | {
"resource": ""
} |
q11101 | UnlistenAll | train | func (l *Listener) UnlistenAll() error {
l.lock.Lock()
defer l.lock.Unlock()
if l.isClosed {
return errListenerClosed
}
if l.cn != nil {
// Similarly to Listen (see comment in that function), the caller
// should only be bothered with an error if it came from the backend as
// a response to our query.
... | go | {
"resource": ""
} |
q11102 | Ping | train | func (l *Listener) Ping() error {
l.lock.Lock()
defer l.lock.Unlock()
if l.isClosed {
return errListenerClosed
}
if l.cn == nil {
return errors.New("no connection")
}
return l.cn.Ping()
} | go | {
"resource": ""
} |
q11103 | resync | train | func (l *Listener) resync(cn *ListenerConn, notificationChan <-chan *Notification) error {
doneChan := make(chan error)
go func() {
for channel := range l.channels {
// If we got a response, return that error to our caller as it's
// going to be more descriptive than cn.Err().
gotResponse, err := cn.Listen... | go | {
"resource": ""
} |
q11104 | closed | train | func (l *Listener) closed() bool {
l.lock.Lock()
defer l.lock.Unlock()
return l.isClosed
} | go | {
"resource": ""
} |
q11105 | Close | train | func (l *Listener) Close() error {
l.lock.Lock()
defer l.lock.Unlock()
if l.isClosed {
return errListenerClosed
}
if l.cn != nil {
l.cn.Close()
}
l.isClosed = true
return nil
} | go | {
"resource": ""
} |
q11106 | appendEncodedText | train | func appendEncodedText(parameterStatus *parameterStatus, buf []byte, x interface{}) []byte {
switch v := x.(type) {
case int64:
return strconv.AppendInt(buf, v, 10)
case float64:
return strconv.AppendFloat(buf, v, 'f', -1, 64)
case []byte:
encodedBytea := encodeBytea(parameterStatus.serverVersion, v)
return... | go | {
"resource": ""
} |
q11107 | getLocation | train | func (c *locationCache) getLocation(offset int) *time.Location {
c.lock.Lock()
defer c.lock.Unlock()
location, ok := c.cache[offset]
if !ok {
location = time.FixedZone("", offset)
c.cache[offset] = location
}
return location
} | go | {
"resource": ""
} |
q11108 | formatTs | train | func formatTs(t time.Time) []byte {
if infinityTsEnabled {
// t <= -infinity : ! (t > -infinity)
if !t.After(infinityTsNegative) {
return []byte("-infinity")
}
// t >= infinity : ! (!t < infinity)
if !t.Before(infinityTsPositive) {
return []byte("infinity")
}
}
return FormatTimestamp(t)
} | go | {
"resource": ""
} |
q11109 | FormatTimestamp | train | func FormatTimestamp(t time.Time) []byte {
// Need to send dates before 0001 A.D. with " BC" suffix, instead of the
// minus sign preferred by Go.
// Beware, "0000" in ISO is "1 BC", "-0001" is "2 BC" and so on
bc := false
if t.Year() <= 0 {
// flip year sign, and add 1, e.g: "0" will be "1", and "-10" will be "... | go | {
"resource": ""
} |
q11110 | parseBytea | train | func parseBytea(s []byte) (result []byte, err error) {
if len(s) >= 2 && bytes.Equal(s[:2], []byte("\\x")) {
// bytea_output = hex
s = s[2:] // trim off leading "\\x"
result = make([]byte, hex.DecodedLen(len(s)))
_, err := hex.Decode(result, s)
if err != nil {
return nil, err
}
} else {
// bytea_outp... | go | {
"resource": ""
} |
q11111 | NewSimpleBindRequest | train | func NewSimpleBindRequest(username string, password string, controls []Control) *SimpleBindRequest {
return &SimpleBindRequest{
Username: username,
Password: password,
Controls: controls,
}
} | go | {
"resource": ""
} |
q11112 | SimpleBind | train | func (l *Conn) SimpleBind(simpleBindRequest *SimpleBindRequest) (*SimpleBindResult, error) {
packet := ber.Encode(ber.ClassUniversal, ber.TypeConstructed, ber.TagSequence, nil, "LDAP Request")
packet.AppendChild(ber.NewInteger(ber.ClassUniversal, ber.TypePrimitive, ber.TagInteger, l.nextMessageID(), "MessageID"))
en... | go | {
"resource": ""
} |
q11113 | Bind | train | func (l *Conn) Bind(username, password string) error {
packet := ber.Encode(ber.ClassUniversal, ber.TypeConstructed, ber.TagSequence, nil, "LDAP Request")
packet.AppendChild(ber.NewInteger(ber.ClassUniversal, ber.TypePrimitive, ber.TagInteger, l.nextMessageID(), "MessageID"))
bindRequest := ber.Encode(ber.ClassAppli... | go | {
"resource": ""
} |
q11114 | NewError | train | func NewError(resultCode uint8, err error) error {
return &Error{ResultCode: resultCode, Err: err}
} | go | {
"resource": ""
} |
q11115 | IsErrorWithCode | train | func IsErrorWithCode(err error, desiredResultCode uint8) bool {
if err == nil {
return false
}
serverError, ok := err.(*Error)
if !ok {
return false
}
return serverError.ResultCode == desiredResultCode
} | go | {
"resource": ""
} |
q11116 | CompileFilter | train | func CompileFilter(filter string) (*ber.Packet, error) {
if len(filter) == 0 || filter[0] != '(' {
return nil, NewError(ErrorFilterCompile, errors.New("ldap: filter does not start with an '('"))
}
packet, pos, err := compileFilter(filter, 1)
if err != nil {
return nil, err
}
if pos != len(filter) {
return n... | go | {
"resource": ""
} |
q11117 | escapedStringToEncodedBytes | train | func escapedStringToEncodedBytes(escapedString string) (string, error) {
var buffer bytes.Buffer
i := 0
for i < len(escapedString) {
currentRune, currentWidth := utf8.DecodeRuneInString(escapedString[i:])
if currentRune == utf8.RuneError {
return "", NewError(ErrorFilterCompile, fmt.Errorf("ldap: error readin... | go | {
"resource": ""
} |
q11118 | NewDelRequest | train | func NewDelRequest(DN string,
Controls []Control) *DelRequest {
return &DelRequest{
DN: DN,
Controls: Controls,
}
} | go | {
"resource": ""
} |
q11119 | Del | train | func (l *Conn) Del(delRequest *DelRequest) error {
packet := ber.Encode(ber.ClassUniversal, ber.TypeConstructed, ber.TagSequence, nil, "LDAP Request")
packet.AppendChild(ber.NewInteger(ber.ClassUniversal, ber.TypePrimitive, ber.TagInteger, l.nextMessageID(), "MessageID"))
packet.AppendChild(delRequest.encode())
if ... | go | {
"resource": ""
} |
q11120 | sslCertificatePermissions | train | func sslCertificatePermissions(cert, key os.FileInfo) {
kmode := key.Mode()
if kmode != kmode&0600 {
panic(ErrSSLKeyHasWorldPermissions)
}
} | go | {
"resource": ""
} |
q11121 | hexify | train | func hexify(arr []byte) string {
var hexed bytes.Buffer
for i := 0; i < len(arr); i++ {
hexed.WriteString(strings.ToUpper(hex.EncodeToString(arr[i : i+1])))
if i < len(arr)-1 {
hexed.WriteString(":")
}
}
return hexed.String()
} | go | {
"resource": ""
} |
q11122 | decodeKey | train | func decodeKey(publicKey interface{}) (string, int) {
switch publicKey.(type) {
case *dsa.PublicKey:
return "DSA", publicKey.(*dsa.PublicKey).P.BitLen()
case *ecdsa.PublicKey:
return "ECDSA", publicKey.(*ecdsa.PublicKey).Curve.Params().BitSize
case *rsa.PublicKey:
return "RSA", publicKey.(*rsa.PublicKey).N.Bi... | go | {
"resource": ""
} |
q11123 | certWarnings | train | func certWarnings(cert *x509.Certificate, uriNames []string) (warnings []string) {
if cert.SerialNumber.Sign() != 1 {
warnings = append(warnings, "Serial number in cert appears to be zero/negative")
}
if cert.SerialNumber.BitLen() > 160 {
warnings = append(warnings, "Serial number too long; should be 20 bytes o... | go | {
"resource": ""
} |
q11124 | algWarnings | train | func algWarnings(cert *x509.Certificate) (warnings []string) {
alg, size := decodeKey(cert.PublicKey)
if (alg == "RSA" || alg == "DSA") && size < 2048 {
warnings = append(warnings, fmt.Sprintf("Size of %s key should be at least 2048 bits", alg))
}
if alg == "ECDSA" && size < 224 {
warnings = append(warnings, fm... | go | {
"resource": ""
} |
q11125 | ssl | train | func ssl(o values) func(net.Conn) net.Conn {
verifyCaOnly := false
tlsConf := tls.Config{}
switch mode := o.Get("sslmode"); mode {
// "require" is the default.
case "", "require":
// We must skip TLS's own verification since it requires full
// verification since Go 1.3.
tlsConf.InsecureSkipVerify = true
... | go | {
"resource": ""
} |
q11126 | sslClientCertificates | train | func sslClientCertificates(tlsConf *tls.Config, o values) {
sslkey := o.Get("sslkey")
sslcert := o.Get("sslcert")
var cinfo, kinfo os.FileInfo
var err error
if sslcert != "" && sslkey != "" {
// Check that both files exist. Note that we don't do any more extensive
// checks than this (such as checking that t... | go | {
"resource": ""
} |
q11127 | sslCertificateAuthority | train | func sslCertificateAuthority(tlsConf *tls.Config, o values) {
if sslrootcert := o.Get("sslrootcert"); sslrootcert != "" {
tlsConf.RootCAs = x509.NewCertPool()
cert, err := ioutil.ReadFile(sslrootcert)
if err != nil {
panic(err)
}
ok := tlsConf.RootCAs.AppendCertsFromPEM(cert)
if !ok {
errorf("could... | go | {
"resource": ""
} |
q11128 | sslHomeCertificates | train | func sslHomeCertificates() (cert, key string, cinfo, kinfo os.FileInfo) {
user, err := user.Current()
if err != nil {
// user.Current() might fail when cross-compiling. We have to ignore the
// error and continue without client certificates, since we wouldn't know
// from where to load them.
return
}
cert... | go | {
"resource": ""
} |
q11129 | sslVerifyCertificateAuthority | train | func sslVerifyCertificateAuthority(client *tls.Conn, tlsConf *tls.Config) {
err := client.Handshake()
if err != nil {
panic(err)
}
certs := client.ConnectionState().PeerCertificates
opts := x509.VerifyOptions{
DNSName: client.ConnectionState().ServerName,
Intermediates: x509.NewCertPool(),
Roots: ... | go | {
"resource": ""
} |
q11130 | addLDAPDescriptions | train | func addLDAPDescriptions(packet *ber.Packet) (err error) {
defer func() {
if r := recover(); r != nil {
err = NewError(ErrorDebugging, errors.New("ldap: cannot process packet to add descriptions"))
}
}()
packet.Description = "LDAP Response"
packet.Children[0].Description = "Message ID"
application := uint8... | go | {
"resource": ""
} |
q11131 | DebugBinaryFile | train | func DebugBinaryFile(fileName string) error {
file, err := ioutil.ReadFile(fileName)
if err != nil {
return NewError(ErrorDebugging, err)
}
ber.PrintBytes(os.Stdout, file, "")
packet := ber.DecodePacket(file)
addLDAPDescriptions(packet)
ber.PrintPacket(packet)
return nil
} | go | {
"resource": ""
} |
q11132 | readBytes | train | func readBytes(r io.Reader) ([]byte, error) {
length, err := readInt32(r)
if err != nil {
return nil, err
}
buf := make([]byte, length)
_, err = io.ReadFull(r, buf)
if err != nil {
return nil, err
}
return buf, nil
} | go | {
"resource": ""
} |
q11133 | getPreKeyedHash | train | func getPreKeyedHash(password []byte) hash.Hash {
md := sha1.New()
buf := make([]byte, len(password)*2)
for i := 0; i < len(password); i++ {
buf[i*2+1] = password[i]
}
md.Write(buf)
// Yes, "Mighty Aphrodite" is a constant used by this method.
md.Write([]byte("Mighty Aphrodite"))
return md
} | go | {
"resource": ""
} |
q11134 | Parse | train | func (ks *KeyStore) Parse(r io.Reader, password []byte) error {
var md hash.Hash
if password != nil {
md = getPreKeyedHash(password)
r = io.TeeReader(r, md)
}
version, err := parseHeader(r)
if err != nil {
return err
}
if version != jceksVersion {
return fmt.Errorf("unexpected version: %d != %d", versio... | go | {
"resource": ""
} |
q11135 | GetPrivateKeyAndCerts | train | func (ks *KeyStore) GetPrivateKeyAndCerts(alias string, password []byte) (
key crypto.PrivateKey, certs []*x509.Certificate, err error) {
entry := ks.entries[alias]
if entry == nil {
return
}
switch t := entry.(type) {
case *privateKeyEntry:
if len(t.certs) < 1 {
return nil, nil, fmt.Errorf("key has no ce... | go | {
"resource": ""
} |
q11136 | GetCert | train | func (ks *KeyStore) GetCert(alias string) (*x509.Certificate, error) {
entry := ks.entries[alias]
if entry == nil {
return nil, nil
}
switch t := entry.(type) {
case *trustedCertEntry:
return t.cert, nil
}
return nil, nil
} | go | {
"resource": ""
} |
q11137 | ListPrivateKeys | train | func (ks *KeyStore) ListPrivateKeys() []string {
var r []string
for k, v := range ks.entries {
if _, ok := v.(*privateKeyEntry); ok {
r = append(r, k)
}
}
return r
} | go | {
"resource": ""
} |
q11138 | ListCerts | train | func (ks *KeyStore) ListCerts() []string {
var r []string
for k, v := range ks.entries {
if _, ok := v.(*trustedCertEntry); ok {
r = append(r, k)
}
}
return r
} | go | {
"resource": ""
} |
q11139 | LoadFromFile | train | func LoadFromFile(filename string, password []byte) (*KeyStore, error) {
file, err := os.Open(filename)
if err != nil {
return nil, err
}
defer file.Close()
return LoadFromReader(file, password)
} | go | {
"resource": ""
} |
q11140 | LoadFromReader | train | func LoadFromReader(reader io.Reader, password []byte) (*KeyStore, error) {
ks := &KeyStore{
entries: make(map[string]interface{}),
}
err := ks.Parse(reader, password)
if err != nil {
return nil, err
}
return ks, err
} | go | {
"resource": ""
} |
q11141 | QueryContext | train | func (cn *conn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
list := make([]driver.Value, len(args))
for i, nv := range args {
list[i] = nv.Value
}
var closed chan<- struct{}
if ctx.Done() != nil {
closed = watchCancel(ctx, cn.cancel)
}
r, err := cn.query(q... | go | {
"resource": ""
} |
q11142 | ExecContext | train | func (cn *conn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
list := make([]driver.Value, len(args))
for i, nv := range args {
list[i] = nv.Value
}
if ctx.Done() != nil {
closed := watchCancel(ctx, cn.cancel)
defer close(closed)
}
return cn.Exec(query, ... | go | {
"resource": ""
} |
q11143 | BeginTx | train | func (cn *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
if opts.Isolation != 0 {
return nil, errors.New("isolation levels not supported")
}
if opts.ReadOnly {
return nil, errors.New("read-only transactions not supported")
}
tx, err := cn.Begin()
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q11144 | Printf | train | func (debug debugging) Printf(format string, args ...interface{}) {
if debug {
log.Printf(format, args...)
}
} | go | {
"resource": ""
} |
q11145 | EncodeTLSInfoToText | train | func EncodeTLSInfoToText(tcs *tls.ConnectionState, cri *tls.CertificateRequestInfo) string {
version := lookup(tlsVersions, tcs.Version)
cipher := lookup(cipherSuites, tcs.CipherSuite)
description := TLSDescription{
Version: tlscolor(version),
Cipher: tlscolor(explainCipher(cipher)),
}
tlsInfoContext := tlsIn... | go | {
"resource": ""
} |
q11146 | EncodeTLSToObject | train | func EncodeTLSToObject(t *tls.ConnectionState) interface{} {
version := lookup(tlsVersions, t.Version)
cipher := lookup(cipherSuites, t.CipherSuite)
return &TLSDescription{
version.Slug,
cipher.Slug,
}
} | go | {
"resource": ""
} |
q11147 | EncodeCRIToObject | train | func EncodeCRIToObject(cri *tls.CertificateRequestInfo) (interface{}, error) {
out := &CertificateRequestInfo{}
for _, ca := range cri.AcceptableCAs {
subject, err := parseRawSubject(ca)
if err != nil {
return nil, err
}
out.AcceptableCAs = append(out.AcceptableCAs, simplePKIXName{subject, nil})
}
for _,... | go | {
"resource": ""
} |
q11148 | lookup | train | func lookup(descriptions map[uint16]description, what uint16) description {
v, ok := descriptions[what]
if !ok {
unknown := fmt.Sprintf("UNKNOWN_%x", what)
return description{unknown, unknown, 0}
}
return v
} | go | {
"resource": ""
} |
q11149 | explainCipher | train | func explainCipher(d description) description {
kexAndCipher := strings.Split(d.Slug, "_WITH_")
d.Name = fmt.Sprintf("%s key exchange, %s cipher", kexAndCipher[0][len("TLS_"):], kexAndCipher[1])
return d
} | go | {
"resource": ""
} |
q11150 | FindControl | train | func FindControl(controls []Control, controlType string) Control {
for _, c := range controls {
if c.GetControlType() == controlType {
return c
}
}
return nil
} | go | {
"resource": ""
} |
q11151 | NewControlString | train | func NewControlString(controlType string, criticality bool, controlValue string) *ControlString {
return &ControlString{
ControlType: controlType,
Criticality: criticality,
ControlValue: controlValue,
}
} | go | {
"resource": ""
} |
q11152 | readCertsFromStream | train | func readCertsFromStream(reader io.Reader, filename string, format string, password func(string) string, callback func(*pem.Block)) error {
headers := map[string]string{}
if filename != "" && filename != os.Stdin.Name() {
headers[fileHeader] = filename
}
switch strings.TrimSpace(format) {
case "PEM":
scanner ... | go | {
"resource": ""
} |
q11153 | EncodeX509ToPEM | train | func EncodeX509ToPEM(cert *x509.Certificate, headers map[string]string) *pem.Block {
return &pem.Block{
Type: "CERTIFICATE",
Bytes: cert.Raw,
Headers: headers,
}
} | go | {
"resource": ""
} |
q11154 | pkcs7ToPem | train | func pkcs7ToPem(block *pkcs7.SignedDataEnvelope, headers map[string]string) *pem.Block {
return &pem.Block{
Type: "PKCS7",
Bytes: block.Raw,
Headers: headers,
}
} | go | {
"resource": ""
} |
q11155 | keyToPem | train | func keyToPem(key crypto.PrivateKey, headers map[string]string) (*pem.Block, error) {
switch k := key.(type) {
case *rsa.PrivateKey:
return &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(k),
Headers: headers,
}, nil
case *ecdsa.PrivateKey:
raw, err := x509.MarshalECPrivat... | go | {
"resource": ""
} |
q11156 | pemScanner | train | func pemScanner(reader io.Reader) *bufio.Scanner {
scanner := bufio.NewScanner(reader)
scanner.Split(func(data []byte, atEOF bool) (int, []byte, error) {
block, rest := pem.Decode(data)
if block != nil {
size := len(data) - len(rest)
return size, data[:size], nil
}
return 0, nil, nil
})
return scan... | go | {
"resource": ""
} |
q11157 | TransformVec2 | train | func (mat *T) TransformVec2(v *vec2.T) {
// Use intermediate variables to not alter further computations.
x := mat[0][0]*v[0] + mat[1][0]*v[1]
v[1] = mat[0][1]*v[0] + mat[1][1]*v[1]
v[0] = x
} | go | {
"resource": ""
} |
q11158 | Transpose | train | func (mat *T) Transpose() *T {
temp := mat[0][1]
mat[0][1] = mat[1][0]
mat[1][0] = temp
return mat
} | go | {
"resource": ""
} |
q11159 | Scale | train | func (vec *T) Scale(f float32) *T {
vec[0] *= f
vec[1] *= f
vec[2] *= f
return vec
} | go | {
"resource": ""
} |
q11160 | Invert | train | func (vec *T) Invert() *T {
vec[0] = -vec[0]
vec[1] = -vec[1]
vec[2] = -vec[2]
return vec
} | go | {
"resource": ""
} |
q11161 | Vec3 | train | func (vec *T) Vec3() vec3.T {
return vec3.T{vec[0], vec[1], vec[2]}
} | go | {
"resource": ""
} |
q11162 | AssignVec3 | train | func (vec *T) AssignVec3(v *vec3.T) *T {
vec[0] = v[0]
vec[1] = v[1]
vec[2] = v[2]
vec[3] = 1
return vec
} | go | {
"resource": ""
} |
q11163 | Dot4 | train | func Dot4(a, b *T) float32 {
return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]
} | go | {
"resource": ""
} |
q11164 | Angle | train | func Angle(a, b *T) float32 {
v := Dot(a, b) / (a.Length() * b.Length())
// prevent NaN
if v > 1. {
v = v - 2
} else if v < -1. {
v = v + 2
}
return math.Acos(v)
} | go | {
"resource": ""
} |
q11165 | Clamp | train | func (vec *T) Clamp(min, max *T) *T {
for i := range vec {
if vec[i] < min[i] {
vec[i] = min[i]
} else if vec[i] > max[i] {
vec[i] = max[i]
}
}
return vec
} | go | {
"resource": ""
} |
q11166 | Clamped | train | func (vec *T) Clamped(min, max *T) T {
result := *vec
result.Clamp(min, max)
return result
} | go | {
"resource": ""
} |
q11167 | ContainsPoint | train | func (rect *Rect) ContainsPoint(p *T) bool {
return p[0] >= rect.Min[0] && p[0] <= rect.Max[0] &&
p[1] >= rect.Min[1] && p[1] <= rect.Max[1]
} | go | {
"resource": ""
} |
q11168 | Scaled | train | func (vec *T) Scaled(f float64) T {
return T{vec[0] * f, vec[1] * f, vec[2] * f, vec[3]}
} | go | {
"resource": ""
} |
q11169 | Dot4 | train | func Dot4(a, b *T) float64 {
return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]
} | go | {
"resource": ""
} |
q11170 | RotateAroundPoint | train | func (vec *T) RotateAroundPoint(point *T, angle float32) *T {
return vec.Sub(point).Rotate(angle).Add(point)
} | go | {
"resource": ""
} |
q11171 | IsLeftWinding | train | func IsLeftWinding(a, b *T) bool {
ab := b.Rotated(-a.Angle())
return ab.Angle() > 0
} | go | {
"resource": ""
} |
q11172 | IsRightWinding | train | func IsRightWinding(a, b *T) bool {
ab := b.Rotated(-a.Angle())
return ab.Angle() < 0
} | go | {
"resource": ""
} |
q11173 | Normalize | train | func (quat *T) Normalize() *T {
norm := quat.Norm()
if norm != 1 && norm != 0 {
ool := 1 / math.Sqrt(norm)
quat[0] *= ool
quat[1] *= ool
quat[2] *= ool
quat[3] *= ool
}
return quat
} | go | {
"resource": ""
} |
q11174 | Normalized | train | func (quat *T) Normalized() T {
norm := quat.Norm()
if norm != 1 && norm != 0 {
ool := 1 / math.Sqrt(norm)
return T{
quat[0] * ool,
quat[1] * ool,
quat[2] * ool,
quat[3] * ool,
}
} else {
return *quat
}
} | go | {
"resource": ""
} |
q11175 | Negate | train | func (quat *T) Negate() *T {
quat[0] = -quat[0]
quat[1] = -quat[1]
quat[2] = -quat[2]
quat[3] = -quat[3]
return quat
} | go | {
"resource": ""
} |
q11176 | Invert | train | func (quat *T) Invert() *T {
quat[0] = -quat[0]
quat[1] = -quat[1]
quat[2] = -quat[2]
return quat
} | go | {
"resource": ""
} |
q11177 | RotateVec3 | train | func (quat *T) RotateVec3(v *vec3.T) {
qv := T{v[0], v[1], v[2], 0}
inv := quat.Inverted()
q := Mul3(quat, &qv, &inv)
v[0] = q[0]
v[1] = q[1]
v[2] = q[2]
} | go | {
"resource": ""
} |
q11178 | Dot | train | func Dot(a, b *T) float32 {
return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]
} | go | {
"resource": ""
} |
q11179 | Mul | train | func Mul(a, b *T) T {
q := T{
a[3]*b[0] + a[0]*b[3] + a[1]*b[2] - a[2]*b[1],
a[3]*b[1] + a[1]*b[3] + a[2]*b[0] - a[0]*b[2],
a[3]*b[2] + a[2]*b[3] + a[0]*b[1] - a[1]*b[0],
a[3]*b[3] - a[0]*b[0] - a[1]*b[1] - a[2]*b[2],
}
return q.Normalized()
} | go | {
"resource": ""
} |
q11180 | Mul3 | train | func Mul3(a, b, c *T) T {
q := Mul(a, b)
return Mul(&q, c)
} | go | {
"resource": ""
} |
q11181 | Mul4 | train | func Mul4(a, b, c, d *T) T {
q := Mul(a, b)
q = Mul(&q, c)
return Mul(&q, d)
} | go | {
"resource": ""
} |
q11182 | Vec3Diff | train | func Vec3Diff(a, b *vec3.T) T {
cr := vec3.Cross(a, b)
sr := math.Sqrt(2 * (1 + vec3.Dot(a, b)))
oosr := 1 / sr
q := T{cr[0] * oosr, cr[1] * oosr, cr[2] * oosr, sr * 0.5}
return q.Normalized()
} | go | {
"resource": ""
} |
q11183 | NewRect | train | func NewRect(a, b *T) (rect Rect) {
rect.Min = Min(a, b)
rect.Max = Max(a, b)
return rect
} | go | {
"resource": ""
} |
q11184 | Area | train | func (rect *Rect) Area() float64 {
return (rect.Max[0] - rect.Min[0]) * (rect.Max[1] - rect.Min[1])
} | go | {
"resource": ""
} |
q11185 | Joined | train | func Joined(a, b *Rect) (rect Rect) {
rect.Min = Min(&a.Min, &b.Min)
rect.Max = Max(&a.Max, &b.Max)
return rect
} | go | {
"resource": ""
} |
q11186 | FromAxisAngle | train | func FromAxisAngle(axis *vec3.T, angle float64) T {
angle *= 0.5
sin := math.Sin(angle)
q := T{axis[0] * sin, axis[1] * sin, axis[2] * sin, math.Cos(angle)}
return q.Normalized()
} | go | {
"resource": ""
} |
q11187 | FromEulerAngles | train | func FromEulerAngles(yHead, xPitch, zRoll float64) T {
qy := FromYAxisAngle(yHead)
qx := FromXAxisAngle(xPitch)
qz := FromZAxisAngle(zRoll)
return Mul3(&qy, &qx, &qz)
} | go | {
"resource": ""
} |
q11188 | AxisAngle | train | func (quat *T) AxisAngle() (axis vec3.T, angle float64) {
cos := quat[3]
sin := math.Sqrt(1 - cos*cos)
angle = math.Acos(cos)
var ooSin float64
if math.Abs(sin) < 0.0005 {
ooSin = 1
} else {
ooSin = 1 / sin
}
axis[0] = quat[0] * ooSin
axis[1] = quat[1] * ooSin
axis[2] = quat[2] * ooSin
return axis, ang... | go | {
"resource": ""
} |
q11189 | ScaleVec2 | train | func (mat *T) ScaleVec2(s *vec2.T) *T {
mat[0][0] *= s[0]
mat[1][1] *= s[1]
return mat
} | go | {
"resource": ""
} |
q11190 | SetTranslation | train | func (mat *T) SetTranslation(v *vec2.T) *T {
mat[2][0] = v[0]
mat[2][1] = v[1]
return mat
} | go | {
"resource": ""
} |
q11191 | Translate | train | func (mat *T) Translate(v *vec2.T) *T {
mat[2][0] += v[0]
mat[2][1] += v[1]
return mat
} | go | {
"resource": ""
} |
q11192 | TransformVec3 | train | func (mat *T) TransformVec3(v *vec3.T) {
// Use intermediate variables to not alter further computations.
x := mat[0][0]*v[0] + mat[1][0]*v[1] + mat[2][0]*v[2]
y := mat[0][1]*v[0] + mat[1][1]*v[1] + mat[2][1]*v[2]
v[2] = mat[0][2]*v[0] + mat[1][2]*v[1] + mat[2][2]*v[2]
v[0] = x
v[1] = y
} | go | {
"resource": ""
} |
q11193 | Quaternion | train | func (mat *T) Quaternion() quaternion.T {
tr := mat.Trace()
s := math.Sqrt(tr + 1)
w := s * 0.5
s = 0.5 / s
q := quaternion.T{
(mat[1][2] - mat[2][1]) * s,
(mat[2][0] - mat[0][2]) * s,
(mat[0][1] - mat[1][0]) * s,
w,
}
return q.Normalized()
} | go | {
"resource": ""
} |
q11194 | AssignQuaternion | train | func (mat *T) AssignQuaternion(q *quaternion.T) *T {
xx := q[0] * q[0] * 2
yy := q[1] * q[1] * 2
zz := q[2] * q[2] * 2
xy := q[0] * q[1] * 2
xz := q[0] * q[2] * 2
yz := q[1] * q[2] * 2
wx := q[3] * q[0] * 2
wy := q[3] * q[1] * 2
wz := q[3] * q[2] * 2
mat[0][0] = 1 - (yy + zz)
mat[1][0] = xy - wz
mat[2][0] ... | go | {
"resource": ""
} |
q11195 | AssignCoordinateSystem | train | func (mat *T) AssignCoordinateSystem(x, y, z *vec3.T) *T {
mat[0][0] = x[0]
mat[1][0] = x[1]
mat[2][0] = x[2]
mat[0][1] = y[0]
mat[1][1] = y[1]
mat[2][1] = y[2]
mat[0][2] = z[0]
mat[1][2] = z[1]
mat[2][2] = z[2]
return mat
} | go | {
"resource": ""
} |
q11196 | Scale | train | func (vec *T) Scale(f float64) *T {
vec[0] *= f
vec[1] *= f
return vec
} | go | {
"resource": ""
} |
q11197 | Rotated | train | func (vec *T) Rotated(angle float64) T {
sinus := math.Sin(angle)
cosinus := math.Cos(angle)
return T{
vec[0]*cosinus - vec[1]*sinus,
vec[0]*sinus + vec[1]*cosinus,
}
} | go | {
"resource": ""
} |
q11198 | AssignEulerRotation | train | func (mat *T) AssignEulerRotation(yHead, xPitch, zRoll float64) *T {
sinH := math.Sin(yHead)
cosH := math.Cos(yHead)
sinP := math.Sin(xPitch)
cosP := math.Cos(xPitch)
sinR := math.Sin(zRoll)
cosR := math.Cos(zRoll)
mat[0][0] = cosR*cosH - sinR*sinP*sinH
mat[1][0] = -sinR * cosP
mat[2][0] = cosR*sinH + sinR*si... | go | {
"resource": ""
} |
q11199 | ExtractEulerAngles | train | func (mat *T) ExtractEulerAngles() (yHead, xPitch, zRoll float64) {
xPitch = math.Asin(mat[1][2])
f12 := math.Abs(mat[1][2])
if f12 > (1.0-0.0001) && f12 < (1.0+0.0001) { // f12 == 1.0
yHead = 0.0
zRoll = math.Atan2(mat[0][1], mat[0][0])
} else {
yHead = math.Atan2(-mat[0][2], mat[2][2])
zRoll = math.Atan2(... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.