id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c11200 | col {
mat[i][j] *= f
}
}
return mat
} | |
c11201 | *mat
result.Mul(f)
return result
} | |
c11202 | mat[1][i] = vec4.Dot4(&row, &m[1])
mat[2][i] = vec4.Dot4(&row, &m[2])
mat[3][i] = vec4.Dot4(&row, &m[3])
}
return mat
} | |
c11203 | vec4.T{m[0][2], m[1][2], m[2][2], 0},
vec4.T{0, 0, 0, 1},
}
return mat
} | |
c11204 | y := mat[0][1]*v[0] + mat[1][1]*v[1] + mat[2][1]*v[2] + mat[3][1]*v[3]
z := mat[0][2]*v[0] + mat[1][2]*v[1] + mat[2][2]*v[2] + mat[3][2]*v[3]
v[3] = mat[0][3]*v[0] + mat[1][3]*v[1] + mat[2][3]*v[2] + mat[3][3]*v[3]
v[0] = x
v[1] = y
v[2] = z
} | |
c11205 |
mat[3][0] = v[0]
mat[3][1] = v[1]
mat[3][2] = v[2]
return mat
} | |
c11206 | += v[1]
mat[3][2] += v[2]
return mat
} | |
c11207 | *= s[1]
mat[2][2] *= s[2]
return mat
} | |
c11208 |
mat[0][2] = 0
mat[1][2] = 0
mat[2][2] = -(zfar + znear) * ooFarNear
mat[3][2] = -2 * zfar * znear * ooFarNear
mat[0][3] = 0
mat[1][3] = 0
mat[2][3] = -1
mat[3][3] = 0
return mat
} | |
c11209 | ooTopBottom
mat[0][2] = 0
mat[1][2] = 0
mat[2][2] = -2 * ooFarNear
mat[3][2] = -(zfar + znear) * ooFarNear
mat[0][3] = 0
mat[1][3] = 0
mat[2][3] = 0
mat[3][3] = 1
return mat
} | |
c11210 | swap(&mat[2][1], &mat[1][2])
return mat
} | |
c11211 | mat[i][j] = matOrig.maskedBlock(i, j).Determinant() * sign
}
}
return mat.Transpose()
} | |
c11212 | {
continue
}
m_j := 0
for j := 0; j < 4; j++ {
if j == blockJ {
continue
}
m[m_i][m_j] = mat[i][j]
m_j++
}
m_i++
}
return &m
} | |
c11213 |
mat.Adjugate()
mat.Mul(1 / initialDet)
return mat
} | |
c11214 | * f, vec[1] * f, vec[2] * f}
} | |
c11215 |
vec[2] = math.Abs(vec[2])
return vec
} | |
c11216 | math.Abs(vec[1]), math.Abs(vec[2])}
} | |
c11217 | *= v[0]
vec[1] *= v[1]
vec[2] *= v[2]
return vec
} | |
c11218 | * b[1], a[2] * b[2]}
} | |
c11219 | }
if b[1] < min[1] {
min[1] = b[1]
}
if b[2] < min[2] {
min[2] = b[2]
}
return min
} | |
c11220 | }
if b[1] > max[1] {
max[1] = b[1]
}
if b[2] > max[2] {
max[2] = b[2]
}
return max
} | |
c11221 | return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
} | |
c11222 | 0
mat[3][1] = 0
mat[0][2] = 0
mat[1][2] = 0
mat[2][2] = 1
mat[3][2] = 0
mat[0][3] = 0
mat[1][3] = 0
mat[2][3] = 0
mat[3][3] = 1
return mat
} | |
c11223 | p[1] <= box.Max[1] &&
p[2] >= box.Min[2] && p[2] <= box.Max[2]
} | |
c11224 | Min(&box.Min, &other.Min)
box.Max = Max(&box.Max, &other.Max)
} | |
c11225 | joined.Max = Max(&a.Max, &b.Max)
return joined
} | |
c11226 | flatten(true, flatmap, nested, prefix, style)
if err != nil {
return nil, err
}
return flatmap, nil
} | |
c11227 | := httpserver.GetConfig(c).Addr.Host
httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
return &Auth{
Rules: rules,
Next: next,
Realm: host,
}
})
return nil
} | |
c11228 | := range effectiveTss {
token := tss.ExtractToken(r)
if token != "" {
return token, nil
}
}
return "", fmt.Errorf("no token found")
} | |
c11229 | http.StatusSeeOther
}
w.Header().Add("WWW-Authenticate", fmt.Sprintf("Bearer realm=\"%s\",error=\"invalid_token\"", realm))
return http.StatusUnauthorized
} | |
c11230 |
case []interface{}:
for _, v := range l {
if v == value {
return true
}
}
}
return false
} | |
c11231 | for public key provided")
}
return &LazyPublicKeyBackend{
filename: value,
}, nil
} | |
c11232 | for secret provided")
}
return &LazyHmacKeyBackend{
filename: value,
}, nil
} | |
c11233 | if err != nil {
return nil, fmt.Errorf("public key provided in environment variable %s could not be read: %v", ENV_PUBLIC_KEY, err)
}
result = append(result, &PublicKeyBackend{
publicKey: pub,
})
}
if len(result) == 0 {
return nil, nil
}
if len(result) > 1 {
return nil, fmt.Errorf("cannot configu... | |
c11234 | token); err != nil {
return nil, err
}
return instance.publicKey, nil
} | |
c11235 | nil {
return nil, err
}
return instance.secret, nil
} | |
c11236 | return nil, fmt.Errorf("there is no keybackend available")
} | |
c11237 | &dataPoint{Observed: obs, Variables: vars}
} | |
c11238 |
p := r.Coeff(0)
for j := 1; j < len(r.data[0].Variables)+1; j++ {
p += r.Coeff(j) * vars[j-1]
}
return p, nil
} | |
c11239 | == 0 {
r.names.vars = make(map[int]string, 5)
}
r.names.vars[i] = name
} | |
c11240 | := []string{"X", strconv.Itoa(i)}
return strings.Join(s, "")
}
return x
} | |
c11241 | {
r.crosses = append(r.crosses, cross)
} | |
c11242 | if len(r.data) > 2 {
r.initialised = true
}
} | |
c11243 | := q.T()
qty := new(mat.Dense)
qty.Mul(qtr, observed)
c := make([]float64, n)
for i := n - 1; i >= 0; i-- {
c[i] = qty.At(i, 0)
for j := i + 1; j < n; j++ {
c[i] -= c[j] * reg.At(i, j)
}
c[i] /= reg.At(i, i)
}
// Output the regression results
r.coeff = make(map[int]float64, numOfvars)
for i, val :... | |
c11244 | return 0
}
return r.coeff[i]
} | |
c11245 |
str += fmt.Sprintf("|\t%.2f", v)
}
return str
} | |
c11246 | += fmt.Sprintf("%v\n", d)
}
fmt.Println(r.calcResiduals())
str += fmt.Sprintf("\nN = %v\nVariance observed = %v\nVariance Predicted = %v", len(r.data), r.Varianceobserved, r.VariancePredicted)
str += fmt.Sprintf("\nR2 = %v\n", r.R2)
return str
} | |
c11247 | []int{i},
crossFn: func(vars []float64) []float64 {
return []float64{math.Pow(vars[i], power)}
},
}
} | |
c11248 | {
var output float64 = 1
for _, variableIndex := range vars {
output *= input[variableIndex]
}
return []float64{output}
},
}
} | |
c11249 | *Options) {
o.Service = s
}
} | |
c11250 | o.Flags = append(o.Flags, flags...)
}
} | |
c11251 | *Options) {
o.Action = a
}
} | |
c11252 | appName)).To(ContainSubstring("hello i am nora running on"))
} | |
c11253 |
workflowhelpers.ApiRequest("GET", url, &response, Config.DefaultTimeoutDuration())
resources = append(resources, response.Resources...)
if len(response.Resources) == 0 || response.NextUrl == "" {
break
}
url = response.NextUrl
}
})
return resources
} | |
c11254 | range da.clients {
entries = append(entries, digestCacheEntry{nonce, client.lastSeen})
}
cache := digestCache(entries)
sort.Sort(cache)
for _, client := range cache[:count] {
delete(da.clients, client.nonce)
}
} | |
c11255 | s[0] != "Digest" {
return nil
}
return ParsePairs(s[1])
} | |
c11256 |
ar.Header.Set(AuthUsernameHeader, ar.Username)
wrapped(w, &ar.Request)
})
} | |
c11257 | DefaultClientCacheSize,
ClientCacheTolerance: DefaultClientCacheTolerance,
clients: map[string]*digestClient{}}
return da
} | |
c11258 | {
for _, v := range values {
headers.Add(k, v)
}
}
} | |
c11259 | if !ok {
return nil
}
return info
} | |
c11260 |
ar.Header.Set(AuthUsernameHeader, ar.Username)
wrapped(w, &ar.Request)
})
} | |
c11261 |
panic("rand.Read() failed")
}
bytes += n
}
return base64.StdEncoding.EncodeToString(k)
} | |
c11262 | compare = cmp.compare
break
}
}
return compare([]byte(secret), []byte(password)) == nil
} | |
c11263 | := hf.Users[realm]
if !exists {
return ""
}
digest, exists := hf.Users[realm][user]
if !exists {
return ""
}
return digest
}
} | |
c11264 |
return func(user, realm string) string {
h.ReloadIfNeeded()
h.mu.RLock()
password, exists := h.Users[user]
h.mu.RUnlock()
if !exists {
return ""
}
return password
}
} | |
c11265 | i&1 == 0 {
d2.Write(password)
} else {
d2.Write(final)
}
final = d2.Sum(nil)
}
result := make([]byte, 0, 22)
v := uint(0)
bits := uint(0)
for _, i := range md5CryptSwaps {
v |= (uint(final[i]) << bits)
for bits = bits + 8; bits > 6; bits -= 6 {
result = append(result, itoa64[v&0x3f])
v >>= ... | |
c11266 | if dtoMF.GetType() == dto.MetricType_HISTOGRAM {
mf.Metrics[i] = Histogram{
Labels: makeLabels(m),
Buckets: makeBuckets(m),
Count: fmt.Sprint(m.GetHistogram().GetSampleCount()),
Sum: fmt.Sprint(m.GetSummary().GetSampleSum()),
}
} else {
mf.Metrics[i] = Metric{
Labels: makeLabels(m... | |
c11267 | }
tlsConfig := &tls.Config{
Certificates: []tls.Certificate{cert},
InsecureSkipVerify: skipServerCertCheck,
}
tlsConfig.BuildNameToCertificate()
transport = &http.Transport{TLSClientConfig: tlsConfig}
} else {
transport = &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: skipS... | |
c11268 | == io.EOF {
break
}
return fmt.Errorf("reading metric family protocol buffer failed: %v", err)
}
ch <- mf
}
} else {
if err := ParseReader(resp.Body, ch); err != nil {
return err
}
}
return nil
} | |
c11269 |
metricFamilies, err := parser.TextToMetricFamilies(in)
if err != nil {
return fmt.Errorf("reading text format failed: %v", err)
}
for _, mf := range metricFamilies {
ch <- mf
}
return nil
} | |
c11270 | err, output)
output, err = sshClient.Output("if [ -e /etc/sysconfig/network-scripts/route-eth0 ]; then sed -i '/^172.16.0.0\\/12 via /d' /etc/sysconfig/network-scripts/route-eth0; fi")
log.Debugf("%s | Fix route in /etc/sysconfig/network-scripts/route-eth0 command err, output: %v: %s", d.MachineName, err, output)
} | |
c11271 | err = sshClient.Output("bash ~/machine_autofdisk.sh")
log.Debugf("%s | Auto Fdisk command err, output: %v: %s", d.MachineName, err, output)
} | |
c11272 | spdyConn,
closeChan: make(chan struct{}),
listenChan: make(chan *spdyStream),
}
go spdyConn.Serve(provider.newStreamHandler)
return provider, nil
} | |
c11273 | sync.NewCond(new(sync.Mutex)),
streams: make(map[uint64]*stream),
}
go session.handleStreams()
return session
} | |
c11274 | if err != nil {
return nil, err
}
// TODO check synchronized
return &sender{stream: stream}, nil
} | |
c11275 | !ok {
return nil, io.EOF
}
return r, nil
} | |
c11276 | nil, nil, err
}
return &receiver{stream: stream}, &nopSender{stream: stream}, err
} | |
c11277 | nil, nil, err
}
return &sender{stream: stream}, &nopReceiver{stream: stream}, err
} | |
c11278 |
s.encoder = msgpack.NewEncoder(s.buffer)
s.encoder.AddExtensions(s.stream.initializeExtensions())
}
if err := s.encoder.Encode(message); err != nil {
return err
}
return s.buffer.Flush()
} | |
c11279 | r.decoder.Decode(message)
if decodeErr == io.EOF {
r.stream.Close()
r.decoder = nil
}
return decodeErr
} | |
c11280 |
c := make(chan interface{}, n)
return pReceiver(c), pSender(c)
} | |
c11281 |
if senderErr != nil {
c1.Close()
c2.Close()
return nil, nil, senderErr
}
receiveErr := <-waitError
if receiveErr != nil {
c1.Close()
c2.Close()
return nil, nil, receiveErr
}
return &pipeReceiver{t2, recv.(*receiver)}, &pipeSender{t1, send.(*sender)}, nil
} | |
c11282 | err := r.Receive(&m)
if err != nil {
if err == io.EOF {
break
} else {
return n, err
}
}
err = w.Send(m)
if err != nil {
return n, err
}
n++
}
return n, nil
} | |
c11283 | to Terraform's built-in
// templatefile function instead and we can phase this provider out.)
scope := &tflang.Scope{
BaseDir: ".",
}
ctx.Functions = scope.Functions()
result, diags := expr.Value(ctx)
if diags.HasErrors() {
return "", diags
}
// Our result must always be a string, so we'll try to convert... | |
c11284 | := Flatten(nested, prefix, style)
if err != nil {
return "", err
}
flatb, err := json.Marshal(&flatmap)
if err != nil {
return "", err
}
return string(flatb), nil
} | |
c11285 | cli.StringFlag{Name: "rateVar", Value: "", Usage: "variable to retrieve rates from, e.g. request.header.X-Rates"},
}
return &plugin.MiddlewareSpec{
Type: "ratelimit",
FromOther: FromOther,
FromCli: FromCli,
CliFlags: cliFlags,
}
} | |
c11286 | int64(c.Int("burst")),
Variable: c.String("var"),
RateVar: c.String("rateVar")})
} | |
c11287 | {
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, "Could not get heap profile: %s\n", err)
}
} | |
c11288 | == true {
return r.ParseMultipartForm(0)
}
return r.ParseForm()
} | |
c11289 | {
return NewConnLimit(int64(c.Int("connections")), c.String("var"))
} | |
c11290 | trying to initialize making pauses between
// attempts.
for err != nil {
log.Errorf("sup failed to reinit, err=%v", err)
select {
case <-time.After(retryPeriod):
case <-s.stopC:
return
}
err = s.init()
}
}
} | |
c11291 | *engine.FrontendDeleted:
return p.DeleteFrontend(change.FrontendKey)
case *engine.MiddlewareUpserted:
return p.UpsertMiddleware(change.FrontendKey, change.Middleware)
case *engine.MiddlewareDeleted:
return p.DeleteMiddleware(change.MiddlewareKey)
case *engine.BackendUpserted:
return p.UpsertBackend(chang... | |
c11292 | := MarkAnomalies(stats); err != nil {
return err
}
for i := range stats {
servers[i].Stats = &stats[i]
}
return nil
} | |
c11293 | markLatencies(stats); err != nil {
return err
}
if err := markNetErrorRates(stats); err != nil {
return err
}
return markAppErrorRates(stats)
} | |
c11294 | T{
cfg: cfg,
trustXFDH: opts.TrustForwardHeader,
mwCfgs: mwCfgs,
backend: be,
listeners: listeners,
}
return &fe
} | |
c11295 |
beKey := fe.backend.Key()
fe.mu.Unlock()
return beKey
} | |
c11296 |
fe.mu.Unlock()
return route
} | |
c11297 | engine.MiddlewareKey{FrontendKey: engine.FrontendKey{Id: fe.cfg.Id}, Id: mwCfg.Id}
fe.mwCfgs[mwKey] = mwCfg
fe.ready = false
} | |
c11298 | {
return
}
delete(fe.mwCfgs, mwKey)
fe.ready = false
} | |
c11299 | err = rtmCollect.RTStats(); err != nil {
return engine.Frontend{}, false, errors.Wrap(err, "failed to get stats")
}
return feCfg, true, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.