text stringlengths 11 6.3k | embedding listlengths 768 768 |
|---|---|
func (c *Client) Disconnect() error {
return c.socket.Close()
} | [
0.04749516025185585,
0.6022592782974243,
0.41053757071495056,
-0.5498290657997131,
-0.6529011130332947,
0.20327821373939514,
0.37251099944114685,
-0.5589665770530701,
-0.41443270444869995,
-0.19972863793373108,
0.20651456713676453,
0.8488300442695618,
-0.8474079966545105,
-0.28211197257041... |
func (c *Client) Reset() error {
if err := c.Disconnect(); err != nil {
return fmt.Errorf("Error trying to reset the shelley client %s", err)
}
socket, err := NewUnixSocket(c.socket.filename, defaultReadTimeoutMs, defaultWriteTimeoutMs)
if err == nil {
c.socket = socket
}
if err := c.handshake(); err != ni... | [
-0.3808763921260834,
0.6500948667526245,
0.5598265528678894,
-0.4918585419654846,
0.8575575351715088,
-0.7293832898139954,
0.4500757157802582,
0.16154472529888153,
-0.9003657698631287,
-0.13079634308815002,
-0.07855680584907532,
0.7116934061050415,
-0.8754863739013672,
-0.6702314615249634,... |
func (c *Client) handshake() error {
messageResponse, err := c.queryNode(multiplex.MiniProtocolIDMuxControl, handshakeRequest())
if err != nil {
log.WithError(err).Error("Error querying node")
}
response, err := parseHandshakeResponse(messageResponse)
if err != nil {
log.WithError(err).Error("Error parsing h... | [
0.16676929593086243,
0.6543674468994141,
0.7076137661933899,
-0.10147897899150848,
0.5261965394020081,
-0.10986795276403427,
-0.03177611529827118,
-0.16135047376155853,
-0.35131219029426575,
-0.6148942708969116,
0.3639857769012451,
0.30954787135124207,
-0.8330618143081665,
-0.1699945479631... |
func (c *Client) StakePools(slotNumber uint32, hash []byte) (*multiplex.ServiceDataUnit, error) {
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> R E Q U E S T # 1 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// MiniProtocol: 7 / MessageMode: 0
// Array: [2]
// PositiveInteger8(0)
// Array: [2]
// PositiveInteger32... | [
-0.7483544945716858,
-0.1836657077074051,
1.277188777923584,
-0.4545283019542694,
-0.4276350140571594,
0.37865474820137024,
0.9892619252204895,
-0.6545272469520569,
0.16481491923332214,
0.9477125406265259,
-0.5613524913787842,
0.26526740193367004,
-1.2126020193099976,
0.09180804342031479,
... |
func (c *Client) QueryTip() (uint32, []byte, uint32, error) {
// Step 1: Send the chain sync request object
log.Debug("Sending command: msgRequestNext")
chainSyncRequest := cbor.NewArray()
chainSyncRequest.Add(cbor.NewPositiveInteger(0)) // msgRequestNext
messageResponse, err := c.queryNode(multiplex.MiniProtocol... | [
0.22195583581924438,
-0.04417981952428818,
1.0300498008728027,
0.1493549942970276,
-0.3071085214614868,
-0.3479178249835968,
-0.11771571636199951,
-1.178250789642334,
-0.42425766587257385,
0.0878140851855278,
-0.37139302492141724,
0.15654931962490082,
-0.3453900218009949,
-0.40030178427696... |
func (c *Client) queryNode(miniProtocol multiplex.MiniProtocol, dataItems []cbor.DataItem) (*multiplex.ServiceDataUnit, error) {
// Step 1: Create message for the request
sdu := multiplex.NewServiceDataUnit(miniProtocol, multiplex.MessageModeInitiator, dataItems)
if log.IsLevelEnabled(log.DebugLevel) {
log.Debug(... | [
-0.7119553089141846,
0.6180965900421143,
0.9334880709648132,
-0.8076537847518921,
0.109806127846241,
-0.39834728837013245,
-0.7721657752990723,
-0.06916069984436035,
0.02725284732878208,
-0.10159412026405334,
-0.06667019426822662,
1.190921664237976,
-1.409741997718811,
0.19957967102527618,... |
func loadTestData() {
//Pull / Convert Test Data
cfg.salt = "qhebZTd7PVqGBCH0rTyl0w=="
cfg.saltBA = []byte(cfg.salt)
cfg.saltScrypt = "wYr2y5H5T2/LCqWURBfVQQ=="
cfg.saltScryptBA = []byte(cfg.saltScrypt)
cfg.testPassword = "thisismysuperlongandcomplexpass"
cfg.plaintext = "My Original plain text used for test... | [
-0.08573231846094131,
-0.15932556986808777,
0.7608731389045715,
-0.7697715759277344,
-0.4165664613246918,
0.5283025503158569,
0.11796066910028458,
-0.011074407026171684,
0.45974069833755493,
-0.011395088396966457,
-1.2150179147720337,
-0.044225677847862244,
-0.820061981678009,
-0.076429694... |
func Register(j Job) {
if j == nil {
panic("Can't register nil job")
}
registry = append(registry, j)
} | [
0.27824851870536804,
1.5434377193450928,
0.2886486053466797,
0.883235514163971,
0.2210376113653183,
-0.2232378125190735,
-0.2938845753669739,
0.02704767882823944,
-0.06080608069896698,
-0.44820764660835266,
-1.4192254543304443,
0.4414406716823578,
-0.2479473501443863,
0.7962506413459778,
... |
func PreOrder(node *Node) {
if node != nil {
fmt.Println(node.val)
PreOrder(node.left)
PreOrder(node.right)
}
} | [
0.37075191736221313,
0.6421482563018799,
0.6700206398963928,
0.07567311823368073,
-0.18169797956943512,
-0.3696284294128418,
0.02464292384684086,
0.36148130893707275,
0.2719660997390747,
-0.7198929190635681,
-0.5995619297027588,
0.15787583589553833,
0.34861454367637634,
2.141788959503174,
... |
func InOrder(node *Node) {
if node != nil {
InOrder(node.left)
fmt.Println(node.val)
InOrder(node.right)
}
} | [
0.17234720289707184,
0.0482017807662487,
0.6924206614494324,
0.253070592880249,
-0.7753255367279053,
-0.25253286957740784,
-0.6898968815803528,
0.3004828691482544,
-0.18252921104431152,
-0.18019933998584747,
-0.22742390632629395,
0.8476053476333618,
0.030098045244812965,
1.9185360670089722... |
func leftMost(node *Node) *Node {
if node == nil {
return nil
}
current := node
for {
if current.left == nil {
return current
}
current = current.left
}
} | [
0.2920762896537781,
-0.03912733122706413,
0.4013180732727051,
-0.3682153820991516,
0.3180907964706421,
-0.20119035243988037,
-1.2626726627349854,
-0.8596509695053101,
0.19473573565483093,
1.0577378273010254,
0.10568910837173462,
-0.16867446899414062,
-0.6731383800506592,
1.0544133186340332... |
func InOrderSuccessor(node *Node) *Node {
if node == nil {
return nil
}
current := node
if current.right != nil {
return leftMost(current.right)
}
ancestor := current.parent
for {
if ancestor == nil || ancestor.left == current {
break
}
current = ancestor
ancestor = ancestor.parent
}
return ... | [
-0.3283650279045105,
-0.10449457913637161,
0.7442908883094788,
-0.435716837644577,
-1.7190665006637573,
-0.6937934756278992,
0.13849149644374847,
0.14292852580547333,
0.2272343784570694,
0.6807141900062561,
-0.497479110956192,
0.58135586977005,
-0.4424501061439514,
1.3366520404815674,
0.... |
func rightMost(node *Node) *Node {
if node == nil {
return nil
}
current := node
for {
if current.right == nil {
return current
}
current = current.right
}
} | [
0.08913543075323105,
0.2749324440956116,
0.6137241125106812,
0.1468914896249771,
0.10462494194507599,
-0.8620222806930542,
-1.0118577480316162,
-1.1542013883590698,
-0.3697947859764099,
0.9202607870101929,
0.2952614724636078,
0.3729504346847534,
-0.4852704405784607,
0.7821656465530396,
0... |
func InOrderPredecessor(node *Node) *Node {
if node == nil {
return nil
}
current := node
if current.left != nil {
return rightMost(current.left)
}
ancestor := current.parent
for {
if ancestor == nil || ancestor.right == current {
break
}
current = ancestor
ancestor = ancestor.parent
}
retur... | [
-0.48892414569854736,
-0.07075895369052887,
1.076089859008789,
-0.6841247081756592,
-1.558779001235962,
-0.6741061210632324,
0.031813979148864746,
0.26787838339805603,
0.40380457043647766,
0.3954823315143585,
0.052063897252082825,
0.47314441204071045,
-0.8537756204605103,
1.626224160194397... |
func PostOrder(node *Node) {
if node != nil {
PostOrder(node.left)
PostOrder(node.right)
fmt.Println(node.val)
}
} | [
0.3106032609939575,
0.04111165553331375,
0.7015435695648193,
-0.13593144714832306,
-0.9153149127960205,
-0.24462592601776123,
-0.5083075761795044,
0.17733041942119598,
-0.2477516382932663,
-0.6256533861160278,
-0.9989091753959656,
-0.04239496961236,
0.2359454184770584,
2.0156009197235107,
... |
func LevelOrder(node *Node) {
queue := make([]*Node, 0)
if node != nil {
queue = append(queue, node)
}
for len(queue) > 0 {
currentNode := queue[0]
queue = queue[1:] // Dequeue
fmt.Println(currentNode.val)
if currentNode.left != nil {
queue = append(queue, currentNode.left) // Enqueue
}
if curr... | [
0.395992249250412,
-0.5488677620887756,
1.094143033027649,
-0.20082888007164001,
0.039810772985219955,
0.023420603945851326,
-0.9455074667930603,
0.2191765010356903,
-0.9168278574943542,
0.8274853229522705,
-0.7293189764022827,
0.06360915303230286,
-0.2626452147960663,
2.1760928630828857,
... |
func NewUpdateCommand() cli.Command {
return cli.Command{
Name: "update",
Usage: "Update app",
ArgsUsage: "[name]",
Flags: []cli.Flag{
cli.StringFlag{
Name: "version",
Usage: "version to updated to",
},
},
Action: func(c *cli.Context) error {
if err := updateApp(c); err != nil {
... | [
-0.5223926305770874,
-1.282583236694336,
0.5047967433929443,
0.2838945686817169,
0.2018621563911438,
0.42570993304252625,
-0.38293635845184326,
-0.19433929026126862,
-0.13693687319755554,
0.6258437633514404,
0.1662658452987671,
0.8554644584655762,
0.4147239029407501,
0.4728032350540161,
... |
func NewFrac(n, d int) Frac {
if d == 0 {
panic("Zero denominator not acceptable!")
}
f := Frac{n: n, d: d}
f.normalizeSignage()
return f
} | [
1.1147816181182861,
0.4097727835178375,
0.18227139115333557,
0.2948939800262451,
-0.9852049946784973,
-0.45074737071990967,
-0.0480722039937973,
-0.36062106490135193,
0.09788014739751816,
-1.282067894935608,
1.1425522565841675,
0.4694611430168152,
0.8099498152732849,
0.32236769795417786,
... |
func NewScalarFrac(s int) Frac {
return Frac{n: s, d: 1}
} | [
-0.1615266352891922,
0.0833875760436058,
0.15826432406902313,
-0.7307165861129761,
-1.224399447441101,
-1.255279302597046,
0.3100242614746094,
-1.1455470323562622,
0.2286100685596466,
-1.6496857404708862,
-0.25011584162712097,
0.10576015710830688,
0.6117527484893799,
0.8353240489959717,
... |
func ParseFrac(s string) (Frac, error) {
fields := strings.Split(s, "/")
if len(fields) == 1 {
fields = append(fields, "1")
}
n, err := strconv.Atoi(fields[0])
if err != nil {
return Frac{}, err
}
d, err := strconv.Atoi(fields[1])
if err != nil {
return Frac{}, err
}
return NewFrac(n, d), nil
} | [
0.2726013660430908,
0.40921545028686523,
0.5519819259643555,
-0.11533234268426895,
-0.8914966583251953,
-1.394973635673523,
1.1355549097061157,
-0.5780482292175293,
-0.47258830070495605,
-1.2275779247283936,
0.058969076722860336,
0.11472512036561966,
0.9320586323738098,
0.4977584183216095,... |
func (f Frac) Integer() int {
return f.n / f.d
} | [
0.4233481287956238,
0.5839889645576477,
0.19368240237236023,
-0.584600031375885,
-0.04853987693786621,
0.11246344447135925,
1.073790431022644,
-0.9403424859046936,
-0.6024031639099121,
-1.5603924989700317,
0.1468353122472763,
-0.6308189630508423,
0.17638613283634186,
0.7936908602714539,
... |
func (f Frac) Equals(f1 Frac) bool {
f = f.Reduce()
f1 = f1.Reduce()
return f.n == f1.n && f.d == f1.d
} | [
-1.1309059858322144,
0.24910029768943787,
0.26224809885025024,
-0.4613502323627472,
0.6593192219734192,
-0.5790721774101257,
0.3891094923019409,
-0.3990047872066498,
-0.26496002078056335,
-1.3235338926315308,
-0.34898635745048523,
-0.21912819147109985,
0.6184638142585754,
0.210130110383033... |
func (f Frac) String() string {
if f.d == 1 {
return strconv.Itoa(f.n)
}
return strconv.Itoa(f.n) + "/" + strconv.Itoa(f.d)
} | [
-0.11796249449253082,
0.1469293087720871,
0.2123417854309082,
-0.5756887793540955,
-0.10904629528522491,
0.16806666553020477,
1.3327957391738892,
-1.442992091178894,
-0.10531039535999298,
-1.1207491159439087,
0.7463922500610352,
-0.28402820229530334,
0.7076950073242188,
0.10399803519248962... |
func (f Frac) IsZero() bool {
return f.n == 0
} | [
-0.22924017906188965,
0.07227107137441635,
0.08627407252788544,
1.006683588027954,
1.236895203590393,
-0.19100384414196014,
0.3453786373138428,
0.16192187368869781,
0.02034822851419449,
-1.0512566566467285,
-0.25013267993927,
0.0070264083333313465,
-0.452764093875885,
0.17207464575767517,
... |
func (f Frac) IsWhole() bool {
return f.Reduce().d == 1
} | [
-0.6650214195251465,
0.2747323513031006,
0.4500783681869507,
-0.038123395293951035,
0.3860214650630951,
0.0371781624853611,
0.500688910484314,
-0.7137895822525024,
0.2452508807182312,
-0.37829384207725525,
-0.33065342903137207,
-0.20805566012859344,
-0.1406828612089157,
0.30802401900291443... |
func (f *Frac) normalizeSignage() {
//Switch signs if n and d are both negative, or if d is negative but n is not (to always keep negative on top)
if f.n < 0 && f.d < 0 || f.d < 0 {
f.n *= -1
f.d *= -1
}
} | [
-0.776164174079895,
0.06977413594722748,
0.6282810568809509,
0.020096896216273308,
-0.1788126826286316,
-0.18520338833332062,
0.2262369841337204,
-0.3213251531124115,
0.3186456561088562,
-0.010901356115937233,
0.8732091784477234,
-1.0266165733337402,
-0.518474280834198,
0.9488043189048767,... |
func (f Frac) Numerator() int {
return f.n
} | [
-1.1600406169891357,
0.6092501282691956,
0.11605275422334671,
-0.2331867665052414,
-0.6798281669616699,
-0.42867952585220337,
1.1931415796279907,
1.1895596981048584,
-0.28290268778800964,
-2.2255337238311768,
-0.5266706347465515,
-0.6103858947753906,
-0.012727185152471066,
0.71347862482070... |
func (f Frac) Denominator() int {
return f.d
} | [
-0.380124032497406,
0.6535366177558899,
0.2803913950920105,
-0.7667500376701355,
-0.46994921565055847,
-0.13559910655021667,
1.442980170249939,
0.7544490694999695,
-0.13194166123867035,
-2.0288970470428467,
-0.10871342569589615,
-0.9503567218780518,
0.34558674693107605,
-0.3539102673530578... |
func (f1 Frac) Mul(f2 Frac) Frac {
f := Frac{n: f1.n * f2.n, d: f1.d * f2.d}
f.normalizeSignage()
return f
} | [
0.2780376374721527,
0.47718095779418945,
0.5230287313461304,
0.15939900279045105,
-0.4861760139465332,
0.0014741598861292005,
0.1373891532421112,
0.18167108297348022,
0.0948675125837326,
-0.9388923048973083,
0.039495013654232025,
-0.22306549549102783,
1.0438090562820435,
-0.297693043947219... |
func (f1 Frac) Div(f2 Frac) Frac {
return f1.Mul(f2.Reciprocal())
} | [
-0.03664334863424301,
0.2903369665145874,
0.6310623288154602,
0.009589292109012604,
0.5526379346847534,
-0.015268318355083466,
-0.2866309881210327,
0.0929795429110527,
-1.3005820512771606,
-1.0343962907791138,
-0.2905030846595764,
0.6668411493301392,
0.5480824708938599,
-0.2127556651830673... |
func (f1 Frac) Add(f2 Frac) Frac {
f := Frac{n: f1.n*f2.d + f2.n*f1.d, d: f1.d * f2.d}
f.normalizeSignage()
return f
} | [
-0.17749032378196716,
0.07538451999425888,
0.5913453102111816,
-0.13404972851276398,
-0.15975321829319,
-0.014345564879477024,
0.039324644953012466,
-0.21244102716445923,
0.10896134376525879,
-1.2198106050491333,
0.45693448185920715,
0.07270020246505737,
0.21675822138786316,
0.096740402281... |
func (f Frac) Reciprocal() Frac {
f1 := Frac{n: f.d, d: f.n}
f1.normalizeSignage()
return f1
} | [
0.1202637255191803,
0.6924048662185669,
0.5016756653785706,
-0.6206440925598145,
-0.04213539510965347,
-0.9107601046562195,
0.22204472124576569,
0.47069790959358215,
-0.16373030841350555,
-1.3612823486328125,
0.19741091132164001,
-0.4816414713859558,
0.31784650683403015,
-0.693798959255218... |
func (f Frac) Neg() Frac {
return Frac{n: f.n * -1, d: f.d}
} | [
-0.743729293346405,
0.3625500500202179,
0.42230141162872314,
-0.33083823323249817,
0.468311607837677,
0.6264537572860718,
0.12800846993923187,
0.11055571585893631,
-0.38186943531036377,
-1.3076260089874268,
0.35967355966567993,
0.21864990890026093,
0.7624649405479431,
0.496865451335907,
... |
func (f Frac) Reduce() Frac {
if f.n == 0 {
return Frac{n: 0, d: 1}
}
d := gcd(f.n, f.d)
f1 := Frac{n: f.n / d, d: f.d / d}
f1.normalizeSignage()
return f1
} | [
-0.46983930468559265,
1.1972088813781738,
0.4738590717315674,
-0.22929276525974274,
0.16211076080799103,
-0.16553528606891632,
1.3216331005096436,
0.16044881939888,
0.17909900844097137,
-0.7018598318099976,
0.8400602340698242,
-0.47991040349006653,
-0.14404141902923584,
0.5377949476242065,... |
func NewWithValues(r, c int, vals []Frac) M {
return M{r: r, c: c, values: vals}
} | [
0.41516920924186707,
-0.09514688700437546,
0.25571170449256897,
-0.3980620205402374,
-0.42673105001449585,
-0.2049238681793213,
0.04618567228317261,
-1.1482174396514893,
-0.4267309010028839,
-1.2678889036178589,
-0.01202639751136303,
-1.186394214630127,
0.03853461518883705,
0.3530024886131... |
func New(r, c int) M {
vals := make([]Frac, r*c)
for i := range vals {
vals[i] = NewScalarFrac(0)
}
return M{r: r, c: c, values: vals}
} | [
0.33598092198371887,
-0.13061144948005676,
0.27735310792922974,
-0.5924520492553711,
-0.002272767247632146,
-0.30664917826652527,
0.00525075476616621,
-1.008459448814392,
-1.0722836256027222,
-1.1209264993667603,
-0.16556021571159363,
-0.33066239953041077,
0.4486508369445801,
0.81084650754... |
func (m M) Equals(m1 M) bool {
if m.Cols() != m1.Cols() || m.Rows() != m1.Rows() {
return false
}
for r := 1; r <= m.Rows(); r++ {
for c := 1; c <= m.Cols(); c++ {
if !m.Get(r, c).Equals(m1.Get(r, c)) {
return false
}
}
}
return true
} | [
-1.2633414268493652,
-0.5253724455833435,
0.4088508188724518,
-0.30205389857292175,
0.09455034136772156,
0.05003587529063225,
-0.34267929196357727,
-0.5489446520805359,
-0.05929102003574371,
0.42983782291412354,
-0.5188053846359253,
-0.010498321615159512,
-0.7266270518302917,
0.27439507842... |
func (m M) String() string {
var buff bytes.Buffer
buff.WriteString("┌ ")
for c := 1; c < m.Cols(); c++ {
buff.WriteString(" \t")
}
buff.WriteString(" ┐\n")
for r := 1; r <= m.Rows(); r++ {
buff.WriteString("│ ")
buff.WriteString(m.Get(r, 1).String())
for c := 2; c <= m.Cols(); c++ {
buff.WriteStrin... | [
0.12317394465208054,
-0.4306093454360962,
0.7045650482177734,
-0.7723641991615295,
-0.8422598242759705,
0.547240674495697,
0.8670586943626404,
-0.9216216206550598,
-0.866402804851532,
0.31786611676216125,
0.358365923166275,
-0.1638452708721161,
0.23091596364974976,
-0.19739791750907898,
... |
func (m M) Rows() int {
return m.r
} | [
-0.3761409521102905,
1.1101841926574707,
0.05369855836033821,
-0.21322597563266754,
-0.49378180503845215,
-0.02364927902817726,
0.5847758650779724,
0.3609532117843628,
0.31852272152900696,
-0.9860937595367432,
0.6450085639953613,
-0.3930252492427826,
-0.9188987016677856,
0.6485331058502197... |
func (m M) Cols() int {
return m.c
} | [
-0.2993372082710266,
-0.07964158058166504,
0.25406625866889954,
-0.43890783190727234,
-0.32159316539764404,
-0.019022682681679726,
0.6029028296470642,
-0.6176208257675171,
-0.7872174382209778,
-0.6458351016044617,
-0.118594229221344,
-0.1933513581752777,
-0.4695458710193634,
-0.34207609295... |
func (m M) Get(r, c int) Frac {
r, c = r-1, c-1
return m.values[r*m.c+c]
} | [
0.5218971967697144,
-0.020725442096590996,
0.33717265725135803,
-0.7197652459144592,
0.15405142307281494,
-0.17107193171977997,
0.24126385152339935,
-1.3041977882385254,
-1.0539478063583374,
-0.6093542575836182,
0.23022150993347168,
0.4266050159931183,
-0.48997634649276733,
-0.454662859439... |
func (m *M) Set(r, c int, v Frac) {
r, c = r-1, c-1
m.values[r*m.c+c] = v.Reduce()
} | [
0.37749090790748596,
0.060743413865566254,
0.10469668358564377,
-0.971363365650177,
0.4344448745250702,
0.13482870161533356,
1.0435726642608643,
-0.7558466196060181,
-0.9979022741317749,
0.11568273603916168,
-0.5069883465766907,
-0.18988290429115295,
-0.5051658153533936,
-0.191900148987770... |
func (m *M) SwitchRows(r1, r2 int) {
r1, r2 = r1-1, r2-1
for c := 0; c < m.c; c++ {
tmp := m.values[r1*m.c+c]
m.values[r1*m.c+c] = m.values[r2*m.c+c]
m.values[r2*m.c+c] = tmp
}
} | [
-0.2730414569377899,
0.11406586319208145,
0.5234860181808472,
-0.40572866797447205,
-0.27390891313552856,
-0.025849180296063423,
-0.005083967000246048,
0.03776213154196739,
-0.7422682642936707,
0.35512906312942505,
0.6930049061775208,
0.5558371543884277,
-0.3011418581008911,
0.181532606482... |
func (m *M) MultiplyRow(r int, s Frac) {
r = r - 1
for c := 0; c < m.c; c++ {
m.values[r*m.c+c] = m.values[r*m.c+c].Mul(s).Reduce()
}
} | [
0.000813824764918536,
0.560515284538269,
0.3782052993774414,
-0.1101820319890976,
-0.10169114917516708,
-0.8715876936912537,
0.3158285915851593,
-0.4330194592475891,
0.2233213484287262,
-0.07878812402486801,
0.2781867980957031,
-0.8807416558265686,
0.45417219400405884,
1.0518227815628052,
... |
func (m *M) MultiplyAndAddRow(r1 int, s Frac, r2 int) {
r1, r2 = r1-1, r2-1
for c := 0; c < m.c; c++ {
m.values[r2*m.c+c] = m.values[r2*m.c+c].Add(m.values[r1*m.c+c].Mul(s)).Reduce()
}
} | [
-0.09109324961900711,
0.29073917865753174,
0.7222491502761841,
0.5210354328155518,
-0.03040928579866886,
-0.7488784790039062,
0.07966218888759613,
-0.4408147931098938,
0.3939177691936493,
-0.2798078656196594,
0.3290329873561859,
-0.4993506669998169,
0.5178719162940979,
0.7078816890716553,
... |
func CopyMatrix(m M) M {
mm := M{r: m.r, c: m.c, values: make([]Frac, len(m.values))}
copy(mm.values, m.values)
return mm
} | [
0.2253863513469696,
-0.5965311527252197,
0.23689627647399902,
-0.02264530025422573,
-0.5209929943084717,
1.3285290002822876,
0.5703296661376953,
-0.9340537190437317,
0.2193932831287384,
-0.05816972255706787,
0.06063259020447731,
-0.1542784422636032,
-0.17853380739688873,
-0.105868928134441... |
func Transpose(m M) M {
rm := M{r: m.c, c: m.r, values: make([]Frac, m.c*m.r)}
for r := 1; r <= m.r; r++ {
for c := 1; c <= m.c; c++ {
rm.Set(c, r, m.Get(r, c))
}
}
return rm
} | [
0.5273288488388062,
0.30971768498420715,
0.6328164339065552,
-0.6627439856529236,
-0.2218511551618576,
-0.6103343963623047,
0.6008390188217163,
-1.0323034524917603,
-0.6633688807487488,
0.15616673231124878,
0.0286159235984087,
-1.392168641090393,
-1.2373769283294678,
0.16354210674762726,
... |
func Ref(m M) M {
m = CopyMatrix(m)
startr := 1
for c := 1; c <= m.Cols(); c++ { // find a leading entry in this column
found := false
for r := startr; r <= m.Rows(); r++ {
if isLeadingEntry(m, r, c) {
found = true
m.SwitchRows(startr, r) // move it to the top, son!
break
}
}
if !found { ... | [
0.6874260306358337,
-0.11976873874664307,
0.8183764815330505,
-0.437409371137619,
-0.8723078966140747,
0.019474975764751434,
1.2963457107543945,
-0.08090046048164368,
0.14961940050125122,
1.0244431495666504,
1.332162857055664,
-0.04101342707872391,
-0.07612580806016922,
0.6446979641914368,... |
func Rref(m M) M {
m = CopyMatrix(m)
m = Ref(m)
for c := 1; c <= m.Cols(); c++ {
for r := 1; r <= m.Rows(); r++ {
if isLeadingEntry(m, r, c) {
m.MultiplyRow(r, m.Get(r, c).Reciprocal()) // make the leading entry 1
for rr := r - 1; rr > 0; rr-- { // for each row above the current row...
... | [
1.0956058502197266,
0.5317499041557312,
0.6429089307785034,
-0.41283944249153137,
-0.7847772836685181,
-0.09714260697364807,
0.8367080092430115,
-0.12157436460256577,
0.1660175323486328,
1.0079104900360107,
0.7679564356803894,
0.4347054958343506,
-0.5174530744552612,
0.5603553056716919,
... |
func Inverse(m M) (M, error) {
m = CopyMatrix(m)
if m.Rows() != m.Cols() {
return m, errors.New("non-square matrices have no inverse")
}
m, _ = Augment(m, Identity(m.r)) // ignore error because Identity will always match m row size
m = Rref(m)
for c := 1; c <= m.Rows(); c++ { // must be square, so m.Rows() ... | [
-0.26376819610595703,
-0.059051599353551865,
0.6975398063659668,
-0.004091071430593729,
-0.8559682965278625,
0.2348477691411972,
0.41989487409591675,
-0.12667417526245117,
0.10352897644042969,
0.11042556166648865,
-0.1699291169643402,
-0.5857494473457336,
-1.0281245708465576,
-0.1060869470... |
func Identity(i int) M {
rm := M{r: i, c: i, values: make([]Frac, i*i)}
for r := 1; r <= rm.Rows(); r++ {
for c := 1; c <= rm.Cols(); c++ {
if r == c {
rm.Set(r, c, NewScalarFrac(1))
} else {
rm.Set(r, c, NewScalarFrac(0))
}
}
}
return rm
} | [
-0.7158938050270081,
0.04630227014422417,
0.37195006012916565,
0.2555095851421356,
0.4289712607860565,
0.24312080442905426,
1.4917118549346924,
-0.7182624340057373,
0.6321043968200684,
-0.43547818064689636,
-0.6310005187988281,
-1.240686297416687,
-0.5136191248893738,
0.19304364919662476,
... |
func Augment(a, b M) (M, error) {
if a.r != b.r {
return a, errors.New("augmented matrices must have equal row counts")
}
rm := M{r: a.r, c: a.c + b.c}
rm.values = make([]Frac, rm.r*rm.c)
for r := 1; r <= a.Rows(); r++ {
for c := 1; c <= a.Cols(); c++ {
rm.Set(r, c, a.Get(r, c))
}
}
for r := 1; r <=... | [
0.4661848843097687,
-0.008094004355370998,
0.6617373824119568,
-0.5216675400733948,
-0.044527001678943634,
-0.2730831503868103,
0.6606041193008423,
-0.7037400603294373,
-0.05132418870925903,
0.28854671120643616,
0.41379284858703613,
0.44958770275115967,
-0.3103615641593933,
0.0559261590242... |
func Add(a, b M) (M, error) {
if a.r != b.r || a.c != b.c {
return a, errors.New("addition requires two identically-sized matrices")
}
rm := CopyMatrix(b)
for r := 1; r <= rm.Rows(); r++ {
for c := 1; c <= rm.Cols(); c++ {
rm.Set(r, c, rm.Get(r, c).Add(a.Get(r, c)))
}
}
return rm, nil
} | [
0.20099705457687378,
-0.34923985600471497,
0.7320640087127686,
-0.4580831527709961,
-0.40596869587898254,
0.3735581636428833,
0.23171289265155792,
-0.552335798740387,
0.5690137147903442,
0.4347887933254242,
0.5625616908073425,
0.5131350755691528,
-0.6082208156585693,
-0.18420571088790894,
... |
func Scale(s Frac, m M) M {
m = CopyMatrix(m)
for r := 1; r <= m.Rows(); r++ {
m.MultiplyRow(r, s)
}
return m
} | [
0.15382622182369232,
-0.016218414530158043,
0.36430028080940247,
0.0765722393989563,
-0.9595760703086853,
-0.5650047659873962,
-0.07995405793190002,
-0.3363133668899536,
-0.3273215591907501,
0.6996651887893677,
0.9992976784706116,
-0.6558659076690674,
-0.5078789591789246,
-0.23957884311676... |
func Multiply(a, b M) (M, error) {
if a.c != b.r {
return a, errors.New("multiplication can only be done on matrices A and B if the number of columns of A equals the number of rows of B")
}
rm := M{r: a.r, c: b.c, values: make([]Frac, a.r*b.c)}
for r := 1; r <= rm.Rows(); r++ {
for c := 1; c <= rm.Cols(); c++... | [
0.13774169981479645,
0.2853184938430786,
0.7334662079811096,
-0.12493951618671417,
-0.02210022509098053,
-0.4085107147693634,
0.07231856137514114,
-0.7991771101951599,
-0.11997870355844498,
-0.1547345668077469,
0.3631706237792969,
-0.5584116578102112,
-0.6284390687942505,
-0.33434137701988... |
func (b *Balancer) BalanceNodeRes(hostGSL *HostGSL) {
resPressureHost := b.nodeCache.GetResPressureNode()
outLeftHost, left := hostGSL.outLeftXsd(b.ratio)
outRightHost, right := hostGSL.outRightXsd(b.ratio)
klog.Infof("resPressureHost: %v", resPressureHost)
klog.Infof("outLeftHost: %v, left: %v", outLeftHost, left... | [
-0.8191667199134827,
-0.2961215078830719,
0.8470280170440674,
-0.4260421693325043,
0.7970179319381714,
0.6048712134361267,
-0.02162901870906353,
-0.3476591408252716,
-0.8216515183448792,
0.599464476108551,
0.03119692951440811,
-0.3294481039047241,
-0.30341410636901855,
0.5545381903648376,
... |
func DockerRun(t *testing.T) {
t.Logf("DockerRun()...\n")
t.Logf("DockerRun() - End\n\n\n")
} | [
-0.05929728224873543,
-0.7348336577415466,
0.5734941959381104,
0.13915285468101501,
0.1134934052824974,
0.4944400489330292,
0.8792411088943481,
0.6285767555236816,
-0.4126990735530853,
-0.41236022114753723,
-0.970313310623169,
0.6056708693504333,
0.23197609186172485,
0.6760918498039246,
... |
func TermHandler(s os.Signal) {
log.Logger.Info("termHandler(): receive signal[%v], terminate.", s)
log.Logger.Close()
os.Exit(0)
} | [
0.9060503840446472,
-0.9426641464233398,
0.5469782948493958,
-0.11926043778657913,
-0.8071174025535583,
0.7160647511482239,
-0.12617817521095276,
0.4558948874473572,
0.01024834718555212,
0.2395917922258377,
-0.680287778377533,
-0.5395581126213074,
0.156104177236557,
-0.4561971127986908,
... |
func IgnoreHandler(s os.Signal) {
log.Logger.Info("ignoreHandler(): receive signal[%v], ignore.", s)
} | [
0.5678257346153259,
-0.6895133256912231,
0.3285008668899536,
-0.20938263833522797,
-0.41744813323020935,
0.8852189183235168,
0.1393880546092987,
-0.14547374844551086,
0.1556721329689026,
-0.5018033981323242,
-1.0470162630081177,
-0.45335036516189575,
-0.14121773838996887,
-0.12019222229719... |
func New(db *gorm.DB) DataOp {
return DataOp{
User: newUserDao(db),
}
} | [
0.19975316524505615,
0.5654928088188171,
0.1075703501701355,
0.9871381521224976,
-1.401288628578186,
0.19317765533924103,
0.03432264178991318,
0.37937161326408386,
0.015617764554917812,
0.08687404543161392,
-0.6781132221221924,
-0.37148317694664,
1.3132119178771973,
0.17915163934230804,
... |
func (*I2PGatePlugin) Name() string {
return "fwd-i2pgate"
} | [
-0.8401535153388977,
-1.3915982246398926,
0.5145893096923828,
-0.2574194073677063,
-0.8056289553642273,
-0.0020522731356322765,
0.07155250757932663,
-0.6935169696807861,
-0.45419400930404663,
0.4718869924545288,
-0.4905967712402344,
-0.06123926118016243,
-0.17743460834026337,
-0.5277895927... |
func (*I2PGatePlugin) Version() string {
return "0.0.0"
} | [
-0.5889776349067688,
-2.0518341064453125,
0.3617376983165741,
0.4790230691432953,
0.617355227470398,
0.48587101697921753,
0.5873414278030396,
-0.3521314263343811,
-0.8190602660179138,
0.14255903661251068,
-0.7823323011398315,
-0.2704390585422516,
-1.0548434257507324,
0.10349640995264053,
... |
func (i *I2PGatePlugin) Init() error {
/*i := Setup()
if err != nil {
return nil, err
}*/
return nil
} | [
-0.456432044506073,
-0.6329864859580994,
0.46710580587387085,
-0.07184585928916931,
0.355524480342865,
0.01999138668179512,
0.5953654050827026,
0.023617766797542572,
-0.6347794532775879,
0.09692122787237167,
-0.1655406653881073,
0.5219876766204834,
-0.8284803628921509,
-0.6181832551956177,... |
func Setup() (*I2PGatePlugin, error) {
var err error
var i I2PGatePlugin
i.configPath, err = fsrepo.BestKnownPath()
if err != nil {
return nil, err
}
err = os.Setenv("KEYS_PATH", i.configPath)
if err != nil {
return nil, err
}
i.config, err = fsrepo.ConfigAt(i.configPath)
if err != nil {
return nil, err... | [
-0.6582192778587341,
-0.5373616218566895,
0.8588482737541199,
-1.3763673305511475,
0.2714420557022095,
-0.2069990187883377,
0.2943732738494873,
0.11354214698076248,
-0.12768113613128662,
0.5521022081375122,
-0.6721057295799255,
-0.3407517373561859,
-1.1200270652770996,
-0.5291929841041565,... |
func (i *I2PGatePlugin) Start(coreiface.CoreAPI) error {
i2p, err := Setup()
if err != nil {
return err
}
go i2p.transportHTTP()
// only create tunnel if unsafe rpc access is permitted
if os.Getenv("UNSAFE_RPC_ACCESS") == "yes" {
go i2p.transportRPC()
}
return nil
} | [
-0.36717504262924194,
-0.42425134778022766,
0.49292469024658203,
-0.1572803556919098,
0.6724230051040649,
0.04267159104347229,
0.49970728158950806,
-0.2511526942253113,
-0.6185559034347534,
0.9837923049926758,
-0.28253886103630066,
0.9537165760993958,
-1.028340458869934,
-0.706489026546478... |
func (*I2PGatePlugin) Close() error {
return nil
} | [
-0.6019276976585388,
-0.7693061828613281,
0.4277690649032593,
0.10198905318975449,
0.010520520620048046,
0.7332810163497925,
0.6257537603378296,
-0.6879531741142273,
-0.748176634311676,
-0.9107878804206848,
-0.14238804578781128,
0.21545469760894775,
-1.7480530738830566,
-0.1291962862014770... |
func GetSSID() (ssid string) {
// 执行系统命令
// 第一个参数是命令名称
// 后面参数可以有多个，命令参数
cmd := exec.Command("/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport", "-I")
// 获取输出对象，可以从该对象中读取输出结果
stdout, err := cmd.StdoutPipe()
if err != nil {
log.Fatal(err)
}
// 保证关闭输出流
defer stdout.Cl... | [
0.22937904298305511,
-0.5762790441513062,
1.3661994934082031,
0.5705937743186951,
-1.1787620782852173,
0.5215046405792236,
0.7357138395309448,
-0.05106130614876747,
0.8416875004768372,
0.16401009261608124,
-0.1095132827758789,
0.8723500370979309,
-1.1053470373153687,
0.025275995954871178,
... |
func (blk Block) MineRange(start uint64, end uint64, workers uint64, chunks uint64) MiningResult {
result := new(MiningResult)
chuckSize := (end-start) / chunks
queue := work_queue.Create(uint(workers), uint(chunks))
startIndex := start
for i:=uint64(0); i<chunks; i++{
endIndex := startIndex+chuckSize
if endI... | [
-0.4109133183956146,
-0.45950815081596375,
0.9171180725097656,
0.13366466760635376,
-0.22265255451202393,
-0.6766548752784729,
-0.34986740350723267,
-0.9539462924003601,
-1.255986213684082,
0.03804260864853859,
-0.269182026386261,
-0.018690550699830055,
-1.4113357067108154,
0.3072436153888... |
func (blk *Block) Mine(workers uint64) bool {
reasonableRangeEnd := uint64(4 * 1 << blk.Difficulty) // 4 * 2^(bits that must be zero)
mr := blk.MineRange(0, reasonableRangeEnd, workers, 4321)
if mr.Found {
blk.SetProof(mr.Proof)
}
return mr.Found
} | [
-0.9581205248832703,
0.2944456934928894,
0.48016008734703064,
0.9318193793296814,
-0.7012380957603455,
0.6889448165893555,
0.049321629106998444,
-0.22277122735977173,
-0.33169376850128174,
-0.4344135522842407,
-0.39015212655067444,
-0.4799228012561798,
-1.955064296722412,
0.965901672840118... |
func main() {
//set maxproc to number of cpu.
runtime.GOMAXPROCS(runtime.NumCPU())
config.Init()
configFile := "config/hips.conf"
// initialize stuff.
err := InitConfigurations("config/hips.conf")
if err != nil {
//can't log into sentry yet... we don't even have config values.
log.WithFields(log.Fields{
... | [
0.08551643043756485,
0.03219882771372795,
0.8573921918869019,
1.3292118310928345,
0.21219563484191895,
-0.4390719532966614,
0.3300167918205261,
0.31821683049201965,
-0.04138297587633133,
0.31487229466438293,
-0.05810835584998131,
0.34105390310287476,
0.09483933448791504,
-0.260540306568145... |
func (m SHA384Manager) CheckHeader(auth *headerauth.AuthInfo, req *http.Request) (err *headerauth.AuthErr) {
if req.ContentLength != 0 && req.Body == nil {
// Not sure whether net/http or Gin handles these kinds of fun situations.
return &headerauth.AuthErr{400, errors.New("received a forged packet")}
}
// Grabb... | [
-0.4269164800643921,
-0.23642940819263458,
0.8823314309120178,
0.7506895065307617,
-0.053920283913612366,
-0.45962801575660706,
-0.5527887344360352,
-0.10145270079374313,
0.7595415115356445,
-0.30537769198417664,
0.09568468481302261,
0.9545471668243408,
-0.17259149253368378,
0.055491097271... |
func (m TokenManger) CheckHeader(auth *headerauth.AuthInfo, req *http.Request) (err *headerauth.AuthErr) {
auth.Secret = "" // There is no secret key, just an access key.
auth.DataToSign = "" // There is no data to sign in Token auth.
if auth.AccessKey != "valid" {
err = &headerauth.AuthErr{403, errors.New("in... | [
-0.5522804260253906,
-0.7405797839164734,
0.5522509813308716,
0.5709065198898315,
-0.2794707715511322,
-0.08507534116506577,
-0.9163077473640442,
0.06339552998542786,
-0.2536017894744873,
-0.295257568359375,
0.520443856716156,
0.5800197124481201,
0.09943579882383347,
0.36198240518569946,
... |
func (m HTTPBasicManager) Authorize(auth *headerauth.AuthInfo) (val interface{}, err *headerauth.AuthErr) {
if password, ok := m.Accounts[auth.AccessKey]; !ok || password != auth.Secret {
err = &headerauth.AuthErr{401, errors.New("invalid credentials")}
} else {
// In CheckHeader we changed the AccessKey to be th... | [
-0.5807347893714905,
-0.36951130628585815,
0.7274754047393799,
0.8643262982368469,
-0.518250048160553,
-0.5175153017044067,
-0.6389297246932983,
-0.5537524223327637,
0.1697281301021576,
0.006785265170037746,
0.830653190612793,
0.5158462524414062,
-0.5073097348213196,
0.5020612478256226,
... |
func Execute() {
if err := rootCmd.Execute(); err != nil {
fmt.Println(err)
os.Exit(1)
}
} | [
0.8741579055786133,
-0.631639301776886,
0.8534528017044067,
1.2026909589767456,
0.42606523633003235,
0.8930875062942505,
-0.11484168469905853,
0.11600733548402786,
-0.7203778028488159,
-0.3646620810031891,
0.6552295088768005,
0.16867855191230774,
-0.38348233699798584,
0.8589836955070496,
... |
func GetStatus() (string, error) {
body, err := getRequest(GetURL()+getStatusPath, "", false)
if err != nil {
return "Connection failed", err
}
if string(body) != `"any-compute"` {
err = util.ErrServerUnavailable
}
return string(body), err
} | [
-0.6366078853607178,
0.047298531979322433,
0.3905247449874878,
1.2076494693756104,
-0.003886096179485321,
0.05932945758104324,
-0.7192990779876709,
-0.07590365409851074,
0.41844499111175537,
0.04850093647837639,
0.43308740854263306,
1.1772434711456299,
-0.6691910624504089,
0.69387811422348... |
func (c Count) Copy() Count {
c2 := Count{}
for element, count := range c {
c2[element] = count
}
return c2
} | [
0.009901655837893486,
-1.1608291864395142,
0.4502519965171814,
0.21466077864170074,
-1.4906784296035767,
1.2242056131362915,
0.31209471821784973,
-0.24049659073352814,
-0.38720226287841797,
0.4664574861526489,
-0.6020139455795288,
0.09969986975193024,
-0.021799173206090927,
0.0011005070991... |
func (c Count) Total() (x int) {
for _, i := range c {
x += i
}
return
} | [
-0.287361204624176,
0.3769721984863281,
0.45381954312324524,
-0.3159772455692291,
0.8463423848152161,
-0.3026282787322998,
1.039459228515625,
-0.34380361437797546,
-0.3298482894897461,
0.030259905382990837,
-1.0095819234848022,
-0.09682511538267136,
-0.38213181495666504,
-0.973251402378082... |
func (c Count) Test(c2 Count) bool {
c2 = c2.Copy()
for element, count := range c {
for i := 0; i < count; i++ {
if c2[element] > 0 {
c2[element]--
} else {
c2[Nil]--
}
}
}
for _, count := range c2 {
if count > 0 {
return false
}
}
return true
} | [
0.15427009761333466,
-0.3359019160270691,
0.5832868218421936,
0.25082969665527344,
-0.18688783049583435,
0.24555771052837372,
0.2183787077665329,
-0.14763210713863373,
-0.9772687554359436,
-0.44580671191215515,
-0.5375573635101318,
-0.23015174269676208,
-0.4974227249622345,
0.8256118893623... |
func (c Count) Remove(c2 Count) {
c2 = c2.Copy()
for element, count := range c2 {
if element == Nil {
continue
}
c[element] -= count
}
for element := Nil; c2[Nil] > 0; element++ {
if element > Black {
panic("RemoveElements missing count for any type")
}
if c[element] < c2[Nil] {
c2[Nil] -= ... | [
0.022008555009961128,
-0.5185295343399048,
0.6057227849960327,
0.569054126739502,
-0.4795137643814087,
0.10852942615747452,
0.28838396072387695,
0.5093381404876709,
0.059030190110206604,
0.20637619495391846,
-0.3450116515159607,
0.18488043546676636,
-0.49544867873191833,
1.561514139175415,... |
func (c Count) JSON() cast.JSON {
json := cast.JSON{}
for k, v := range c {
json[cast.StringI(int(k))] = v
}
return json
} | [
-0.8764063715934753,
-1.1750870943069458,
0.47536328434944153,
-0.8816342353820801,
-0.6268595457077026,
-0.39085954427719116,
0.4069348871707916,
-0.7830145955085754,
-0.0924418494105339,
0.4797378480434418,
-0.6995705366134644,
0.5478386282920837,
0.38344523310661316,
0.8054754734039307,... |
func (_m *KeyLevelValidationParameterManager) ExtractValidationParameterDependency(blockNum uint64, txNum uint64, rwset []byte) {
_m.Called(blockNum, txNum, rwset)
} | [
0.02089238353073597,
-0.09613507241010666,
0.4173380136489868,
0.2653577923774719,
-1.0499212741851807,
-0.7361338138580322,
0.9801831841468811,
-0.4550548493862152,
0.36972033977508545,
1.070786476135254,
-0.13183452188968658,
-0.5740832090377808,
-0.6997764110565186,
0.4746221899986267,
... |
func (_m *KeyLevelValidationParameterManager) GetValidationParameterForKey(cc string, coll string, key string, blockNum uint64, txNum uint64) ([]byte, error) {
ret := _m.Called(cc, coll, key, blockNum, txNum)
var r0 []byte
if rf, ok := ret.Get(0).(func(string, string, string, uint64, uint64) []byte); ok {
r0 = rf... | [
-0.40539366006851196,
0.5647749900817871,
0.6123685240745544,
0.4295751452445984,
-0.1907002329826355,
-0.7220869660377502,
0.5599481463432312,
-0.08970806747674942,
-0.39896488189697266,
0.26598596572875977,
-0.5606009364128113,
-0.5940914750099182,
0.5770940184593201,
0.6236846446990967,... |
func (_m *KeyLevelValidationParameterManager) SetTxValidationResult(cc string, blockNum uint64, txNum uint64, err error) {
_m.Called(cc, blockNum, txNum, err)
} | [
-0.24142959713935852,
0.4689890444278717,
0.10017881542444229,
-0.10037659108638763,
-1.3090873956680298,
-0.6268436908721924,
0.41164445877075195,
-0.22570012509822845,
0.2269209772348404,
0.8554403185844421,
-0.651841938495636,
-1.1320264339447021,
-0.05405820906162262,
-0.35621863603591... |
func getConfig(configFile string) {
var err error
var input = io.ReadCloser(os.Stdin)
if input, err = os.Open(configFile); err != nil {
log.Fatalln(err)
}
defer input.Close()
// Read the config file
yamlBytes, err := ioutil.ReadAll(input)
if err != nil {
log.Fatalln(err)
}
// Parse the config
if err :... | [
0.6160934567451477,
-0.25283190608024597,
0.9102690815925598,
0.5934067964553833,
0.1995890885591507,
0.38361772894859314,
0.3806423544883728,
1.2697421312332153,
-1.3260351419448853,
0.28830063343048096,
-0.15316979587078094,
0.16131888329982758,
-0.09459565579891205,
0.5768122673034668,
... |
func ToLowerCamel(s string) string {
return ToLowerCamelWithInitialisms(s, CommonInitialisms)
} | [
0.3857857882976532,
-0.8955592513084412,
0.1498803198337555,
-0.3772379159927368,
0.4021759033203125,
-0.20876257121562958,
0.8699659109115601,
-0.6466802358627319,
0.5929099321365356,
0.11998302489519119,
0.28380513191223145,
0.3722655177116394,
-0.49290862679481506,
0.35293319821357727,
... |
func ToLowerCamelWithInitialisms(s string, initialisms map[string]bool) string {
if s == "" {
return s
}
if initialisms == nil {
initialisms = map[string]bool{}
}
ss := SplitIntoWordsWithInitialisms(s, initialisms)
for i, s := range ss {
if i == 0 {
ss[i] = strings.ToLower(s)
continue
}
if initial... | [
0.5048936009407043,
-0.9165259003639221,
0.7796111106872559,
-0.8451783061027527,
-0.2075115293264389,
-1.2631850242614746,
-0.1647132784128189,
0.19027091562747955,
0.5170150399208069,
0.7186105251312256,
0.3942577838897705,
1.0782582759857178,
-0.30993571877479553,
0.03872187063097954,
... |
func (s *StackTemplate) Push(i interface{}) bool {
if s == nil {
return false
}
current := len(*s)
expanded := append(*s, i)
*s = expanded
return current < len(*s)
} | [
-0.4664354622364044,
1.0365506410598755,
0.29092466831207275,
0.16456221044063568,
-1.0761969089508057,
-0.2598704397678375,
0.3724849224090576,
-0.32235032320022583,
0.03163609281182289,
0.47641241550445557,
-0.9527892470359802,
-1.0047880411148071,
-0.9218470454216003,
0.172571063041687,... |
func (s *StackTemplate) Pop() *interface{} {
if s == nil {
return nil
}
if last := len(*s) - 1; last < 0 {
return nil
} else {
item := (*s)[len(*s)-1]
reduced := (*s)[:last]
*s = reduced
return &item
}
} | [
0.03827325627207756,
0.4290924072265625,
0.5792723298072815,
0.3704390525817871,
-0.44047290086746216,
-1.1370337009429932,
0.2586731016635895,
-0.16553844511508942,
0.16619792580604553,
0.6386740803718567,
-0.4440987706184387,
-0.5765296816825867,
-0.5728535056114197,
-0.693053126335144,
... |
func (s *StackTemplate) String() string {
var out string
for _, el := range *s {
out = fmt.Sprintf("%s %s", out, el)
}
return fmt.Sprintf("[%s]<", strings.Trim(out, " "))
} | [
0.09671662002801895,
-0.5801227688789368,
0.45897674560546875,
-0.4746418297290802,
-0.5684434771537781,
0.1732301563024521,
0.520534098148346,
-1.2491371631622314,
-0.7823078632354736,
0.39804306626319885,
-0.510800838470459,
-0.08276762068271637,
-0.20833560824394226,
0.43162500858306885... |
func (s *StackTemplate) GoString() string {
return s.String()
} | [
0.12103239446878433,
0.3840726315975189,
0.1328079253435135,
-0.2032293826341629,
0.08837420493364334,
0.05157671868801117,
0.5855714082717896,
-0.4322296679019928,
-0.8569909334182739,
0.505103588104248,
-0.48687413334846497,
-0.5246046185493469,
-0.7902384400367737,
-0.28012457489967346,... |
func GetACL(ctx context.Context, p vfs.Path, cluster *kops.Cluster) (vfs.ACL, error) {
strategiesMutex.Lock()
defer strategiesMutex.Unlock()
for k, strategy := range strategies {
acl, err := strategy.GetACL(ctx, p, cluster)
if err != nil {
return nil, fmt.Errorf("error from acl provider %q: %w", k, err)
}
... | [
0.6913087964057922,
0.16264459490776062,
0.44352057576179504,
1.3932952880859375,
0.8436963558197021,
-0.31809791922569275,
0.5385733246803284,
-0.8384237885475159,
0.9447535872459412,
0.9529672861099243,
1.2437927722930908,
0.3441658020019531,
0.34850138425827026,
-0.48496824502944946,
... |
func RegisterPlugin(key string, strategy ACLStrategy) {
strategiesMutex.Lock()
defer strategiesMutex.Unlock()
if strategies == nil {
strategies = make(map[string]ACLStrategy)
}
strategies[key] = strategy
} | [
-0.10780945420265198,
0.2260613590478897,
0.32553109526634216,
0.15615133941173553,
0.5970903635025024,
-0.09025374799966812,
-0.48221340775489807,
0.6676644682884216,
1.0299463272094727,
0.2663542330265045,
-0.41136297583580017,
1.0573153495788574,
0.30051836371421814,
0.0366949625313282,... |
func (optr *Operator) getUserAgent() string {
token := "ClusterVersionOperator"
productVersion := version.Version
return fmt.Sprintf("%s/%s", token, productVersion)
} | [
-0.28969627618789673,
-0.840501070022583,
0.4076231122016907,
0.2950904965400696,
-0.38476958870887756,
-0.09623643010854721,
0.4573712646961212,
-0.7119824290275574,
0.6881945729255676,
0.6840229630470276,
-0.5869059562683105,
0.4644533693790436,
-0.1043117493391037,
-0.978317141532898,
... |
func (optr *Operator) getTransport() (*http.Transport, error) {
transport := &http.Transport{}
proxyConfig, err := optr.getProxyConfig()
if err != nil {
return transport, err
} else if proxyConfig != nil {
proxyFunc := proxyConfig.ProxyFunc()
transport.Proxy = func(req *http.Request) (*url.URL, error) {
i... | [
-0.29603663086891174,
0.355216383934021,
0.735551655292511,
0.1957724541425705,
-0.22734332084655762,
-0.6803696751594543,
0.2937178909778595,
-0.023081330582499504,
0.23879799246788025,
-0.1767968237400055,
-0.5117021799087524,
0.1851980984210968,
-0.2634119391441345,
0.27787962555885315,... |
func (optr *Operator) getProxyConfig() (*httpproxy.Config, error) {
proxy, err := optr.proxyLister.Get("cluster")
if apierrors.IsNotFound(err) {
return nil, nil
}
if err != nil {
return nil, err
}
return &httpproxy.Config{
HTTPProxy: proxy.Status.HTTPProxy,
HTTPSProxy: proxy.Status.HTTPSProxy,
NoProx... | [
0.09417186677455902,
0.7312168478965759,
0.7815337777137756,
0.1393868774175644,
0.2285851240158081,
-0.35025519132614136,
-0.4931190311908722,
0.9542118310928345,
-0.24785058200359344,
0.11608905345201492,
-0.6093805432319641,
0.7773188352584839,
-0.5485485196113586,
1.6004838943481445,
... |
func newLoggingMiddleware(logger log.Logger) linkManagerMiddleware {
return func(next om.LinkManager) om.LinkManager {
return loggingMiddleware{next, logger}
}
} | [
-1.1576730012893677,
-0.7100667953491211,
0.37639307975769043,
-0.04917425662279129,
-1.4950368404388428,
-0.6500952243804932,
-1.0285224914550781,
0.4166952669620514,
1.2830157279968262,
-1.053911566734314,
0.33423057198524475,
-0.025363454595208168,
-1.0046231746673584,
0.747483730316162... |
func RequestID(c context.Context) string {
RequestID := c.Value(contextKeyRequestID)
if RequestID == nil {
return ""
}
return RequestID.(string)
} | [
0.009589625522494316,
-0.3691393733024597,
0.2140941023826599,
0.22119435667991638,
0.05290505662560463,
0.48841792345046997,
-0.4511401951313019,
-0.8002230525016785,
1.6186195611953735,
0.5941386818885803,
1.2197704315185547,
0.18605272471904755,
-0.47984880208969116,
0.3733064532279968,... |
func SetRequestID(c context.Context, requestID string) context.Context {
return context.WithValue(c, contextKeyRequestID, requestID)
} | [
0.057893723249435425,
-0.5929360389709473,
0.3472631573677063,
0.4297204613685608,
-0.5804771780967712,
1.045438289642334,
-1.1407190561294556,
-0.24870899319648743,
1.1616601943969727,
0.49161261320114136,
0.5735430717468262,
0.5498796105384827,
0.27779027819633484,
0.17701926827430725,
... |
func elemof(t reflect.Type) reflect.Type {
for t.Kind() == reflect.Ptr {
t = t.Elem()
}
return t
} | [
0.16499987244606018,
0.06259233504533768,
0.3576458990573883,
-0.13318891823291779,
0.20482556521892548,
0.6149328351020813,
0.07885602116584778,
-0.9325980544090271,
0.1230718120932579,
0.35612478852272034,
0.4380667805671692,
0.7476329207420349,
0.021110285073518753,
-0.06186243519186973... |
func nameof(t reflect.Type) string {
t = elemof(t)
if t.Kind() != reflect.Struct && t.Kind() != reflect.Interface {
return ""
} else if iserr(t) {
return ""
}
return strings.Join([]string{t.PkgPath(), t.Name()}, ".")
} | [
-0.09220023453235626,
-0.27863508462905884,
0.6357272267341614,
-0.6574577689170837,
-0.7475224733352661,
0.1863880306482315,
0.17320114374160767,
-1.6001167297363281,
0.4458671808242798,
1.1435188055038452,
0.19975808262825012,
-0.785944938659668,
0.3820611238479614,
0.20082958042621613,
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.