_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q7600 | RegisterEncoder | train | func (e *Encoder) RegisterEncoder(value interface{}, encoder func(reflect.Value) string) {
e.regenc[reflect.TypeOf(value)] = encoder
} | go | {
"resource": ""
} |
q7601 | isValidStructPointer | train | func isValidStructPointer(v reflect.Value) bool {
return v.Type().Kind() == reflect.Ptr && v.Elem().IsValid() && v.Elem().Type().Kind() == reflect.Struct
} | go | {
"resource": ""
} |
q7602 | Or | train | func Or(conds ...Cond) Cond {
var result = make(condOr, 0, len(conds))
for _, cond := range conds {
if cond == nil || !cond.IsValid() {
continue
}
result = append(result, cond)
}
return result
} | go | {
"resource": ""
} |
q7603 | WriteTo | train | func (o condOr) WriteTo(w Writer) error {
for i, cond := range o {
var needQuote bool
switch cond.(type) {
case condAnd, expr:
needQuote = true
case Eq:
needQuote = (len(cond.(Eq)) > 1)
case Neq:
needQuote = (len(cond.(Neq)) > 1)
}
if needQuote {
fmt.Fprint(w, "(")
}
err := cond.WriteTo(w)
if err != nil {
return err
}
if needQuote {
fmt.Fprint(w, ")")
}
if i != len(o)-1 {
fmt.Fprint(w, " OR ")
}
}
return nil
} | go | {
"resource": ""
} |
q7604 | WriteByte | train | func (b *StringBuilder) WriteByte(c byte) error {
b.copyCheck()
b.buf = append(b.buf, c)
return nil
} | go | {
"resource": ""
} |
q7605 | WriteRune | train | func (b *StringBuilder) WriteRune(r rune) (int, error) {
b.copyCheck()
if r < utf8.RuneSelf {
b.buf = append(b.buf, byte(r))
return 1, nil
}
l := len(b.buf)
if cap(b.buf)-l < utf8.UTFMax {
b.grow(utf8.UTFMax)
}
n := utf8.EncodeRune(b.buf[l:l+utf8.UTFMax], r)
b.buf = b.buf[:l+n]
return n, nil
} | go | {
"resource": ""
} |
q7606 | WriteString | train | func (b *StringBuilder) WriteString(s string) (int, error) {
b.copyCheck()
b.buf = append(b.buf, s...)
return len(s), nil
} | go | {
"resource": ""
} |
q7607 | Delete | train | func Delete(conds ...Cond) *Builder {
builder := &Builder{cond: NewCond()}
return builder.Delete(conds...)
} | go | {
"resource": ""
} |
q7608 | If | train | func If(condition bool, condTrue Cond, condFalse ...Cond) Cond {
var c = condIf{
condition: condition,
condTrue: condTrue,
}
if len(condFalse) > 0 {
c.condFalse = condFalse[0]
}
return c
} | go | {
"resource": ""
} |
q7609 | Dialect | train | func Dialect(dialect string) *Builder {
builder := &Builder{cond: NewCond(), dialect: dialect}
return builder
} | go | {
"resource": ""
} |
q7610 | Where | train | func (b *Builder) Where(cond Cond) *Builder {
if b.cond.IsValid() {
b.cond = b.cond.And(cond)
} else {
b.cond = cond
}
return b
} | go | {
"resource": ""
} |
q7611 | TableName | train | func (b *Builder) TableName() string {
if b.optype == insertType {
return b.into
}
return b.from
} | go | {
"resource": ""
} |
q7612 | Join | train | func (b *Builder) Join(joinType, joinTable string, joinCond interface{}) *Builder {
switch joinCond.(type) {
case Cond:
b.joins = append(b.joins, join{joinType, joinTable, joinCond.(Cond)})
case string:
b.joins = append(b.joins, join{joinType, joinTable, Expr(joinCond.(string))})
}
return b
} | go | {
"resource": ""
} |
q7613 | Union | train | func (b *Builder) Union(unionTp string, unionCond *Builder) *Builder {
var builder *Builder
if b.optype != unionType {
builder = &Builder{cond: NewCond()}
builder.optype = unionType
builder.dialect = b.dialect
builder.selects = b.selects
currentUnions := b.unions
// erase sub unions (actually append to new Builder.unions)
b.unions = nil
for e := range currentUnions {
currentUnions[e].builder.dialect = b.dialect
}
builder.unions = append(append(builder.unions, union{"", b}), currentUnions...)
} else {
builder = b
}
if unionCond != nil {
if unionCond.dialect == "" && builder.dialect != "" {
unionCond.dialect = builder.dialect
}
builder.unions = append(builder.unions, union{unionTp, unionCond})
}
return builder
} | go | {
"resource": ""
} |
q7614 | Limit | train | func (b *Builder) Limit(limitN int, offset ...int) *Builder {
b.limitation = &limit{limitN: limitN}
if len(offset) > 0 {
b.limitation.offset = offset[0]
}
return b
} | go | {
"resource": ""
} |
q7615 | InnerJoin | train | func (b *Builder) InnerJoin(joinTable string, joinCond interface{}) *Builder {
return b.Join("INNER", joinTable, joinCond)
} | go | {
"resource": ""
} |
q7616 | LeftJoin | train | func (b *Builder) LeftJoin(joinTable string, joinCond interface{}) *Builder {
return b.Join("LEFT", joinTable, joinCond)
} | go | {
"resource": ""
} |
q7617 | RightJoin | train | func (b *Builder) RightJoin(joinTable string, joinCond interface{}) *Builder {
return b.Join("RIGHT", joinTable, joinCond)
} | go | {
"resource": ""
} |
q7618 | CrossJoin | train | func (b *Builder) CrossJoin(joinTable string, joinCond interface{}) *Builder {
return b.Join("CROSS", joinTable, joinCond)
} | go | {
"resource": ""
} |
q7619 | FullJoin | train | func (b *Builder) FullJoin(joinTable string, joinCond interface{}) *Builder {
return b.Join("FULL", joinTable, joinCond)
} | go | {
"resource": ""
} |
q7620 | And | train | func (b *Builder) And(cond Cond) *Builder {
b.cond = And(b.cond, cond)
return b
} | go | {
"resource": ""
} |
q7621 | Or | train | func (b *Builder) Or(cond Cond) *Builder {
b.cond = Or(b.cond, cond)
return b
} | go | {
"resource": ""
} |
q7622 | Delete | train | func (b *Builder) Delete(conds ...Cond) *Builder {
b.cond = b.cond.And(conds...)
b.optype = deleteType
return b
} | go | {
"resource": ""
} |
q7623 | And | train | func And(conds ...Cond) Cond {
var result = make(condAnd, 0, len(conds))
for _, cond := range conds {
if cond == nil || !cond.IsValid() {
continue
}
result = append(result, cond)
}
return result
} | go | {
"resource": ""
} |
q7624 | Update | train | func Update(updates ...Eq) *Builder {
builder := &Builder{cond: NewCond()}
return builder.Update(updates...)
} | go | {
"resource": ""
} |
q7625 | And | train | func (between Between) And(conds ...Cond) Cond {
return And(between, And(conds...))
} | go | {
"resource": ""
} |
q7626 | Or | train | func (between Between) Or(conds ...Cond) Cond {
return Or(between, Or(conds...))
} | go | {
"resource": ""
} |
q7627 | Select | train | func Select(cols ...string) *Builder {
builder := &Builder{cond: NewCond()}
return builder.Select(cols...)
} | go | {
"resource": ""
} |
q7628 | OrderBy | train | func (b *Builder) OrderBy(orderBy string) *Builder {
b.orderBy = orderBy
return b
} | go | {
"resource": ""
} |
q7629 | GroupBy | train | func (b *Builder) GroupBy(groupby string) *Builder {
b.groupBy = groupby
return b
} | go | {
"resource": ""
} |
q7630 | Having | train | func (b *Builder) Having(having string) *Builder {
b.having = having
return b
} | go | {
"resource": ""
} |
q7631 | Insert | train | func Insert(eq ...interface{}) *Builder {
builder := &Builder{cond: NewCond()}
return builder.Insert(eq...)
} | go | {
"resource": ""
} |
q7632 | Write | train | func (s *BytesWriter) Write(buf []byte) (int, error) {
return s.writer.Write(buf)
} | go | {
"resource": ""
} |
q7633 | Append | train | func (s *BytesWriter) Append(args ...interface{}) {
s.args = append(s.args, args...)
} | go | {
"resource": ""
} |
q7634 | ToSQL | train | func ToSQL(cond interface{}) (string, []interface{}, error) {
switch cond.(type) {
case Cond:
return condToSQL(cond.(Cond))
case *Builder:
return cond.(*Builder).ToSQL()
}
return "", nil, ErrNotSupportType
} | go | {
"resource": ""
} |
q7635 | ToBoundSQL | train | func ToBoundSQL(cond interface{}) (string, error) {
switch cond.(type) {
case Cond:
return condToBoundSQL(cond.(Cond))
case *Builder:
return cond.(*Builder).ToBoundSQL()
}
return "", ErrNotSupportType
} | go | {
"resource": ""
} |
q7636 | ConvertToBoundSQL | train | func ConvertToBoundSQL(sql string, args []interface{}) (string, error) {
buf := StringBuilder{}
var i, j, start int
for ; i < len(sql); i++ {
if sql[i] == '?' {
_, err := buf.WriteString(sql[start:i])
if err != nil {
return "", err
}
start = i + 1
if len(args) == j {
return "", ErrNeedMoreArguments
}
arg := args[j]
if namedArg, ok := arg.(sql2.NamedArg); ok {
arg = namedArg.Value
}
if noSQLQuoteNeeded(arg) {
_, err = fmt.Fprint(&buf, arg)
} else {
_, err = fmt.Fprintf(&buf, "'%v'", arg)
}
if err != nil {
return "", err
}
j = j + 1
}
}
_, err := buf.WriteString(sql[start:])
if err != nil {
return "", err
}
return buf.String(), nil
} | go | {
"resource": ""
} |
q7637 | Freeze | train | func (coff *Coff) Freeze() {
switch coff.SectionHeader32.Name {
case STRING_RSRC:
coff.freezeRSRC()
case STRING_RDATA:
coff.freezeRDATA()
}
} | go | {
"resource": ""
} |
q7638 | Max | train | func Max(input Float64Data) (max float64, err error) {
// Return an error if there are no numbers
if input.Len() == 0 {
return math.NaN(), EmptyInputErr
}
// Get the first value as the starting point
max = input.Get(0)
// Loop and replace higher values
for i := 1; i < input.Len(); i++ {
if input.Get(i) > max {
max = input.Get(i)
}
}
return max, nil
} | go | {
"resource": ""
} |
q7639 | PercentileNearestRank | train | func PercentileNearestRank(input Float64Data, percent float64) (percentile float64, err error) {
// Find the length of items in the slice
il := input.Len()
// Return an error for empty slices
if il == 0 {
return math.NaN(), EmptyInputErr
}
// Return error for less than 0 or greater than 100 percentages
if percent < 0 || percent > 100 {
return math.NaN(), BoundsErr
}
// Start by sorting a copy of the slice
c := sortedCopy(input)
// Return the last item
if percent == 100.0 {
return c[il-1], nil
}
// Find ordinal ranking
or := int(math.Ceil(float64(il) * percent / 100))
// Return the item that is in the place of the ordinal rank
if or == 0 {
return c[0], nil
}
return c[or-1], nil
} | go | {
"resource": ""
} |
q7640 | QuartileOutliers | train | func QuartileOutliers(input Float64Data) (Outliers, error) {
if input.Len() == 0 {
return Outliers{}, EmptyInputErr
}
// Start by sorting a copy of the slice
copy := sortedCopy(input)
// Calculate the quartiles and interquartile range
qs, _ := Quartile(copy)
iqr, _ := InterQuartileRange(copy)
// Calculate the lower and upper inner and outer fences
lif := qs.Q1 - (1.5 * iqr)
uif := qs.Q3 + (1.5 * iqr)
lof := qs.Q1 - (3 * iqr)
uof := qs.Q3 + (3 * iqr)
// Find the data points that are outside of the
// inner and upper fences and add them to mild
// and extreme outlier slices
var mild Float64Data
var extreme Float64Data
for _, v := range copy {
if v < lof || v > uof {
extreme = append(extreme, v)
} else if v < lif || v > uif {
mild = append(mild, v)
}
}
// Wrap them into our struct
return Outliers{mild, extreme}, nil
} | go | {
"resource": ""
} |
q7641 | Quartile | train | func Quartile(input Float64Data) (Quartiles, error) {
il := input.Len()
if il == 0 {
return Quartiles{}, EmptyInputErr
}
// Start by sorting a copy of the slice
copy := sortedCopy(input)
// Find the cutoff places depeding on if
// the input slice length is even or odd
var c1 int
var c2 int
if il%2 == 0 {
c1 = il / 2
c2 = il / 2
} else {
c1 = (il - 1) / 2
c2 = c1 + 1
}
// Find the Medians with the cutoff points
Q1, _ := Median(copy[:c1])
Q2, _ := Median(copy)
Q3, _ := Median(copy[c2:])
return Quartiles{Q1, Q2, Q3}, nil
} | go | {
"resource": ""
} |
q7642 | InterQuartileRange | train | func InterQuartileRange(input Float64Data) (float64, error) {
if input.Len() == 0 {
return math.NaN(), EmptyInputErr
}
qs, _ := Quartile(input)
iqr := qs.Q3 - qs.Q1
return iqr, nil
} | go | {
"resource": ""
} |
q7643 | Midhinge | train | func Midhinge(input Float64Data) (float64, error) {
if input.Len() == 0 {
return math.NaN(), EmptyInputErr
}
qs, _ := Quartile(input)
mh := (qs.Q1 + qs.Q3) / 2
return mh, nil
} | go | {
"resource": ""
} |
q7644 | Trimean | train | func Trimean(input Float64Data) (float64, error) {
if input.Len() == 0 {
return math.NaN(), EmptyInputErr
}
c := sortedCopy(input)
q, _ := Quartile(c)
return (q.Q1 + (q.Q2 * 2) + q.Q3) / 4, nil
} | go | {
"resource": ""
} |
q7645 | Min | train | func Min(input Float64Data) (min float64, err error) {
// Get the count of numbers in the slice
l := input.Len()
// Return an error if there are no numbers
if l == 0 {
return math.NaN(), EmptyInputErr
}
// Get the first value as the starting point
min = input.Get(0)
// Iterate until done checking for a lower value
for i := 1; i < l; i++ {
if input.Get(i) < min {
min = input.Get(i)
}
}
return min, nil
} | go | {
"resource": ""
} |
q7646 | Round | train | func Round(input float64, places int) (rounded float64, err error) {
// If the float is not a number
if math.IsNaN(input) {
return math.NaN(), NaNErr
}
// Find out the actual sign and correct the input for later
sign := 1.0
if input < 0 {
sign = -1
input *= -1
}
// Use the places arg to get the amount of precision wanted
precision := math.Pow(10, float64(places))
// Find the decimal place we are looking to round
digit := input * precision
// Get the actual decimal number as a fraction to be compared
_, decimal := math.Modf(digit)
// If the decimal is less than .5 we round down otherwise up
if decimal >= 0.5 {
rounded = math.Ceil(digit)
} else {
rounded = math.Floor(digit)
}
// Finally we do the math to actually create a rounded number
return rounded / precision * sign, nil
} | go | {
"resource": ""
} |
q7647 | Entropy | train | func Entropy(input Float64Data) (float64, error) {
input, err := normalize(input)
if err != nil {
return math.NaN(), err
}
var result float64
for i := 0; i < input.Len(); i++ {
v := input.Get(i)
if v == 0 {
continue
}
result += (v * math.Log(v))
}
return -result, nil
} | go | {
"resource": ""
} |
q7648 | CumulativeSum | train | func CumulativeSum(input Float64Data) ([]float64, error) {
if input.Len() == 0 {
return Float64Data{}, EmptyInput
}
cumSum := make([]float64, input.Len())
for i, val := range input {
if i == 0 {
cumSum[i] = val
} else {
cumSum[i] = cumSum[i-1] + val
}
}
return cumSum, nil
} | go | {
"resource": ""
} |
q7649 | SoftMax | train | func SoftMax(input Float64Data) ([]float64, error) {
if input.Len() == 0 {
return Float64Data{}, EmptyInput
}
s := 0.0
c, _ := Max(input)
for _, e := range input {
s += math.Exp(e - c)
}
sm := make([]float64, len(input))
for i, v := range input {
sm[i] = math.Exp(v-c) / s
}
return sm, nil
} | go | {
"resource": ""
} |
q7650 | MedianAbsoluteDeviationPopulation | train | func MedianAbsoluteDeviationPopulation(input Float64Data) (mad float64, err error) {
if input.Len() == 0 {
return math.NaN(), EmptyInputErr
}
i := copyslice(input)
m, _ := Median(i)
for key, value := range i {
i[key] = math.Abs(value - m)
}
return Median(i)
} | go | {
"resource": ""
} |
q7651 | StandardDeviationPopulation | train | func StandardDeviationPopulation(input Float64Data) (sdev float64, err error) {
if input.Len() == 0 {
return math.NaN(), EmptyInputErr
}
// Get the population variance
vp, _ := PopulationVariance(input)
// Return the population standard deviation
return math.Pow(vp, 0.5), nil
} | go | {
"resource": ""
} |
q7652 | StandardDeviationSample | train | func StandardDeviationSample(input Float64Data) (sdev float64, err error) {
if input.Len() == 0 {
return math.NaN(), EmptyInputErr
}
// Get the sample variance
vs, _ := SampleVariance(input)
// Return the sample standard deviation
return math.Pow(vs, 0.5), nil
} | go | {
"resource": ""
} |
q7653 | validateData | train | func validateData(dataPointX, dataPointY Float64Data) error {
if len(dataPointX) == 0 || len(dataPointY) == 0 {
return EmptyInputErr
}
if len(dataPointX) != len(dataPointY) {
return SizeErr
}
return nil
} | go | {
"resource": ""
} |
q7654 | ChebyshevDistance | train | func ChebyshevDistance(dataPointX, dataPointY Float64Data) (distance float64, err error) {
err = validateData(dataPointX, dataPointY)
if err != nil {
return math.NaN(), err
}
var tempDistance float64
for i := 0; i < len(dataPointY); i++ {
tempDistance = math.Abs(dataPointX[i] - dataPointY[i])
if distance < tempDistance {
distance = tempDistance
}
}
return distance, nil
} | go | {
"resource": ""
} |
q7655 | EuclideanDistance | train | func EuclideanDistance(dataPointX, dataPointY Float64Data) (distance float64, err error) {
err = validateData(dataPointX, dataPointY)
if err != nil {
return math.NaN(), err
}
distance = 0
for i := 0; i < len(dataPointX); i++ {
distance = distance + ((dataPointX[i] - dataPointY[i]) * (dataPointX[i] - dataPointY[i]))
}
return math.Sqrt(distance), nil
} | go | {
"resource": ""
} |
q7656 | Mean | train | func Mean(input Float64Data) (float64, error) {
if input.Len() == 0 {
return math.NaN(), EmptyInputErr
}
sum, _ := input.Sum()
return sum / float64(input.Len()), nil
} | go | {
"resource": ""
} |
q7657 | GeometricMean | train | func GeometricMean(input Float64Data) (float64, error) {
l := input.Len()
if l == 0 {
return math.NaN(), EmptyInputErr
}
// Get the product of all the numbers
var p float64
for _, n := range input {
if p == 0 {
p = n
} else {
p *= n
}
}
// Calculate the geometric mean
return math.Pow(p, 1/float64(l)), nil
} | go | {
"resource": ""
} |
q7658 | HarmonicMean | train | func HarmonicMean(input Float64Data) (float64, error) {
l := input.Len()
if l == 0 {
return math.NaN(), EmptyInputErr
}
// Get the sum of all the numbers reciprocals and return an
// error for values that cannot be included in harmonic mean
var p float64
for _, n := range input {
if n < 0 {
return math.NaN(), NegativeErr
} else if n == 0 {
return math.NaN(), ZeroErr
}
p += (1 / n)
}
return float64(l) / p, nil
} | go | {
"resource": ""
} |
q7659 | Sum | train | func Sum(input Float64Data) (sum float64, err error) {
if input.Len() == 0 {
return math.NaN(), EmptyInputErr
}
// Add em up
for _, n := range input {
sum += n
}
return sum, nil
} | go | {
"resource": ""
} |
q7660 | LinearRegression | train | func LinearRegression(s Series) (regressions Series, err error) {
if len(s) == 0 {
return nil, EmptyInputErr
}
// Placeholder for the math to be done
var sum [5]float64
// Loop over data keeping index in place
i := 0
for ; i < len(s); i++ {
sum[0] += s[i].X
sum[1] += s[i].Y
sum[2] += s[i].X * s[i].X
sum[3] += s[i].X * s[i].Y
sum[4] += s[i].Y * s[i].Y
}
// Find gradient and intercept
f := float64(i)
gradient := (f*sum[3] - sum[0]*sum[1]) / (f*sum[2] - sum[0]*sum[0])
intercept := (sum[1] / f) - (gradient * sum[0] / f)
// Create the new regression series
for j := 0; j < len(s); j++ {
regressions = append(regressions, Coordinate{
X: s[j].X,
Y: s[j].X*gradient + intercept,
})
}
return regressions, nil
} | go | {
"resource": ""
} |
q7661 | ExponentialRegression | train | func ExponentialRegression(s Series) (regressions Series, err error) {
if len(s) == 0 {
return nil, EmptyInputErr
}
var sum [6]float64
for i := 0; i < len(s); i++ {
if s[i].Y < 0 {
return nil, YCoordErr
}
sum[0] += s[i].X
sum[1] += s[i].Y
sum[2] += s[i].X * s[i].X * s[i].Y
sum[3] += s[i].Y * math.Log(s[i].Y)
sum[4] += s[i].X * s[i].Y * math.Log(s[i].Y)
sum[5] += s[i].X * s[i].Y
}
denominator := (sum[1]*sum[2] - sum[5]*sum[5])
a := math.Pow(math.E, (sum[2]*sum[3]-sum[5]*sum[4])/denominator)
b := (sum[1]*sum[4] - sum[5]*sum[3]) / denominator
for j := 0; j < len(s); j++ {
regressions = append(regressions, Coordinate{
X: s[j].X,
Y: a * math.Exp(b*s[j].X),
})
}
return regressions, nil
} | go | {
"resource": ""
} |
q7662 | LogarithmicRegression | train | func LogarithmicRegression(s Series) (regressions Series, err error) {
if len(s) == 0 {
return nil, EmptyInputErr
}
var sum [4]float64
i := 0
for ; i < len(s); i++ {
sum[0] += math.Log(s[i].X)
sum[1] += s[i].Y * math.Log(s[i].X)
sum[2] += s[i].Y
sum[3] += math.Pow(math.Log(s[i].X), 2)
}
f := float64(i)
a := (f*sum[1] - sum[2]*sum[0]) / (f*sum[3] - sum[0]*sum[0])
b := (sum[2] - a*sum[0]) / f
for j := 0; j < len(s); j++ {
regressions = append(regressions, Coordinate{
X: s[j].X,
Y: b + a*math.Log(s[j].X),
})
}
return regressions, nil
} | go | {
"resource": ""
} |
q7663 | Median | train | func Median(input Float64Data) (median float64, err error) {
// Start by sorting a copy of the slice
c := sortedCopy(input)
// No math is needed if there are no numbers
// For even numbers we add the two middle numbers
// and divide by two using the mean function above
// For odd numbers we just use the middle number
l := len(c)
if l == 0 {
return math.NaN(), EmptyInputErr
} else if l%2 == 0 {
median, _ = Mean(c[l/2-1 : l/2+1])
} else {
median = c[l/2]
}
return median, nil
} | go | {
"resource": ""
} |
q7664 | _variance | train | func _variance(input Float64Data, sample int) (variance float64, err error) {
if input.Len() == 0 {
return math.NaN(), EmptyInputErr
}
// Sum the square of the mean subtracted from each number
m, _ := Mean(input)
for _, n := range input {
variance += (n - m) * (n - m)
}
// When getting the mean of the squared differences
// "sample" will allow us to know if it's a sample
// or population and wether to subtract by one or not
return variance / float64((input.Len() - (1 * sample))), nil
} | go | {
"resource": ""
} |
q7665 | PopulationVariance | train | func PopulationVariance(input Float64Data) (pvar float64, err error) {
v, err := _variance(input, 0)
if err != nil {
return math.NaN(), err
}
return v, nil
} | go | {
"resource": ""
} |
q7666 | SampleVariance | train | func SampleVariance(input Float64Data) (svar float64, err error) {
v, err := _variance(input, 1)
if err != nil {
return math.NaN(), err
}
return v, nil
} | go | {
"resource": ""
} |
q7667 | Sigmoid | train | func Sigmoid(input Float64Data) ([]float64, error) {
if input.Len() == 0 {
return Float64Data{}, EmptyInput
}
s := make([]float64, len(input))
for i, v := range input {
s[i] = 1 / (1 + math.Exp(-v))
}
return s, nil
} | go | {
"resource": ""
} |
q7668 | float64ToInt | train | func float64ToInt(input float64) (output int) {
r, _ := Round(input, 0)
return int(r)
} | go | {
"resource": ""
} |
q7669 | copyslice | train | func copyslice(input Float64Data) Float64Data {
s := make(Float64Data, input.Len())
copy(s, input)
return s
} | go | {
"resource": ""
} |
q7670 | sortedCopyDif | train | func sortedCopyDif(input Float64Data) (copy Float64Data) {
if sort.Float64sAreSorted(input) {
return input
}
copy = copyslice(input)
sort.Float64s(copy)
return
} | go | {
"resource": ""
} |
q7671 | PercentileNearestRank | train | func (f Float64Data) PercentileNearestRank(p float64) (float64, error) {
return PercentileNearestRank(f, p)
} | go | {
"resource": ""
} |
q7672 | Pearson | train | func (f Float64Data) Pearson(d Float64Data) (float64, error) {
return Pearson(f, d)
} | go | {
"resource": ""
} |
q7673 | CovariancePopulation | train | func (f Float64Data) CovariancePopulation(d Float64Data) (float64, error) {
return CovariancePopulation(f, d)
} | go | {
"resource": ""
} |
q7674 | Check | train | func (f *LevelFilter) Check(line []byte) bool {
f.once.Do(f.init)
// Check for a log level
var level LogLevel
x := bytes.IndexByte(line, '[')
if x >= 0 {
y := bytes.IndexByte(line[x:], ']')
if y >= 0 {
level = LogLevel(line[x+1 : x+y])
}
}
_, ok := f.badLevels[level]
return !ok
} | go | {
"resource": ""
} |
q7675 | SetMinLevel | train | func (f *LevelFilter) SetMinLevel(min LogLevel) {
f.MinLevel = min
f.init()
} | go | {
"resource": ""
} |
q7676 | mkArgs | train | func mkArgs(paths []string) string {
escaped := make([]string, len(paths))
for i, s := range paths {
escaped[i] = quotePath(realRel(s))
}
return strings.Join(escaped, " ")
} | go | {
"resource": ""
} |
q7677 | get | train | func (v *VarCmd) get(name string) (string, error) {
if val, ok := v.Vars[name]; ok {
return val, nil
}
if (name == "@mods" || name == "@dirmods") && v.Block != nil {
var modified []string
if v.Modified == nil {
var err error
modified, err = moddwatch.List(".", v.Block.Include, v.Block.Exclude)
if err != nil {
return "", err
}
} else {
modified = v.Modified
}
v.Vars["@mods"] = mkArgs(modified)
v.Vars["@dirmods"] = mkArgs(getDirs(modified))
return v.Vars[name], nil
}
return "", fmt.Errorf("No such variable: %s", name)
} | go | {
"resource": ""
} |
q7678 | Render | train | func (v *VarCmd) Render(cmd string) (string, error) {
var err error
cmd = string(
name.ReplaceAllFunc(
[]byte(cmd),
func(key []byte) []byte {
cnt := 0
for _, c := range key {
if c != esc {
break
}
cnt++
}
ks := strings.TrimLeft(string(key), string(esc))
if cnt%2 != 0 {
return []byte(strings.Repeat(string(esc), (cnt-1)/2) + ks)
}
val, errv := v.get(ks)
if errv != nil {
err = fmt.Errorf("No such variable: %s", ks)
return nil
}
val = strings.Repeat(string(esc), cnt/2) + val
return []byte(val)
},
),
)
if err != nil {
return "", err
}
return cmd, nil
} | go | {
"resource": ""
} |
q7679 | Push | train | func (GrowlNotifier) Push(title string, text string, iconPath string) {
cmd := exec.Command(
"growlnotify", "-n", prog, "-d", prog, "-m", text, prog,
)
go cmd.Run()
} | go | {
"resource": ""
} |
q7680 | RunProc | train | func RunProc(cmd string, shellMethod string, dir string, log termlog.Stream) error {
log.Header()
ex, err := shell.NewExecutor(shellMethod, cmd, dir)
if err != nil {
return err
}
start := time.Now()
err, estate := ex.Run(log, true)
if err != nil {
return err
} else if estate.Error != nil {
log.Shout("%s", estate.Error)
return ProcError{estate.Error.Error(), estate.ErrOutput}
}
log.Notice(">> done (%s)", time.Since(start))
return nil
} | go | {
"resource": ""
} |
q7681 | RunPreps | train | func RunPreps(
b conf.Block,
vars map[string]string,
mod *moddwatch.Mod,
log termlog.TermLog,
notifiers []notify.Notifier,
initial bool,
) error {
sh, err := shell.GetShellName(vars[shellVarName])
if err != nil {
return err
}
var modified []string
if mod != nil {
modified = mod.All()
}
vcmd := varcmd.VarCmd{Block: &b, Modified: modified, Vars: vars}
for _, p := range b.Preps {
cmd, err := vcmd.Render(p.Command)
if initial && p.Onchange {
log.Say(niceHeader("skipping prep: ", cmd))
continue
}
if err != nil {
return err
}
err = RunProc(cmd, sh, b.InDir, log.Stream(niceHeader("prep: ", cmd)))
if err != nil {
if pe, ok := err.(ProcError); ok {
for _, n := range notifiers {
n.Push("modd error", pe.Output, "")
}
}
return err
}
}
return nil
} | go | {
"resource": ""
} |
q7682 | acceptFunc | train | func (l *lexer) acceptFunc(match func(rune) bool) {
for match(l.peek()) {
l.next()
}
} | go | {
"resource": ""
} |
q7683 | maybeSpace | train | func (l *lexer) maybeSpace() rune {
for {
n := l.next()
if any(n, whitespace) {
l.acceptRun(whitespace)
l.emit(itemSpace)
} else {
return n
}
}
} | go | {
"resource": ""
} |
q7684 | eatSpaceAndComments | train | func (l *lexer) eatSpaceAndComments() rune {
for {
n := l.next()
if n == '#' {
l.acceptLine(false)
l.emit(itemComment)
} else if any(n, whitespace) {
l.acceptRun(whitespace)
l.emit(itemSpace)
} else {
return n
}
}
} | go | {
"resource": ""
} |
q7685 | nextSignificantItem | train | func (l *lexer) nextSignificantItem() item {
for {
item := l.nextItem()
switch item.typ {
case itemSpace:
continue
case itemComment:
continue
default:
return item
}
}
} | go | {
"resource": ""
} |
q7686 | acceptLine | train | func (l *lexer) acceptLine(permitEscaping bool) {
escaped := false
for {
if !permitEscaping {
escaped = false
}
nxt := l.peek()
switch nxt {
case '\n':
l.next()
if !escaped {
return
}
case eof:
return
case '\\':
escaped = true
l.next()
continue
default:
l.next()
}
escaped = false
}
} | go | {
"resource": ""
} |
q7687 | acceptBareString | train | func (l *lexer) acceptBareString() {
l.acceptFunc(
func(r rune) bool {
return !any(r, bareStringDisallowed) && r != eof
},
)
} | go | {
"resource": ""
} |
q7688 | acceptWord | train | func (l *lexer) acceptWord() {
l.acceptFunc(
func(r rune) bool {
return any(r, wordRunes)
},
)
} | go | {
"resource": ""
} |
q7689 | acceptQuotedString | train | func (l *lexer) acceptQuotedString(quote rune) error {
Loop:
for {
switch l.next() {
case '\\':
if r := l.next(); r != eof {
break
}
fallthrough
case eof:
return fmt.Errorf("unterminated quoted string")
case quote:
break Loop
}
}
return nil
} | go | {
"resource": ""
} |
q7690 | lexPatterns | train | func lexPatterns(l *lexer) stateFn {
for {
n := l.eatSpaceAndComments()
if n == eof {
l.emit(itemEOF)
return nil
} else if n == '!' {
pk := l.next()
if any(pk, quotes) {
err := l.acceptQuotedString(pk)
if err != nil {
l.errorf("%s", err)
return nil
}
l.emit(itemQuotedString)
} else if !any(pk, bareStringDisallowed) {
l.acceptBareString()
l.emit(itemBareString)
} else {
l.errorf("! must be followed by a string")
return nil
}
} else if any(n, quotes) {
err := l.acceptQuotedString(n)
if err != nil {
l.errorf("%s", err)
return nil
}
l.emit(itemQuotedString)
} else if !any(n, bareStringDisallowed) {
l.acceptBareString()
l.emit(itemBareString)
} else {
l.backup()
return lexBlockStart
}
}
} | go | {
"resource": ""
} |
q7691 | lexVariables | train | func lexVariables(l *lexer) stateFn {
for {
n := l.eatSpaceAndComments()
if n == '@' {
l.acceptWord()
l.emit(itemVarName)
n = l.maybeSpace()
if n == '=' {
l.emit(itemEquals)
}
n = l.maybeSpace()
if n == eof {
l.errorf("unterminated variable assignment")
return nil
} else if any(n, quotes) {
err := l.acceptQuotedString(n)
if err != nil {
l.errorf("%s", err)
return nil
}
l.emit(itemQuotedString)
} else if !any(n, bareStringDisallowed) {
l.acceptLine(true)
l.emit(itemBareString)
} else {
l.errorf("= must be followed by a string")
return nil
}
} else {
l.backup()
return lexPatterns
}
}
} | go | {
"resource": ""
} |
q7692 | lexOptions | train | func lexOptions(l *lexer) stateFn {
for {
n := l.next()
if any(n, spaces) {
l.acceptRun(spaces)
l.emit(itemSpace)
} else if n == ':' {
l.emit(itemColon)
return lexCommand
} else if n == '+' {
l.acceptWord()
l.emit(itemBareString)
} else {
l.errorf("invalid command option")
return nil
}
}
} | go | {
"resource": ""
} |
q7693 | lexCommand | train | func lexCommand(l *lexer) stateFn {
for {
n := l.next()
if n == '\n' {
l.errorf("empty command specification")
return nil
} else if any(n, quotes) {
err := l.acceptQuotedString(n)
if err != nil {
l.errorf("%s", err)
return nil
}
l.emit(itemQuotedString)
return lexInside
} else if any(n, spaces) {
l.acceptRun(spaces)
l.emit(itemSpace)
} else {
l.acceptLine(true)
l.emit(itemBareString)
return lexInside
}
}
} | go | {
"resource": ""
} |
q7694 | NewModRunner | train | func NewModRunner(confPath string, log termlog.TermLog, notifiers []notify.Notifier, confreload bool) (*ModRunner, error) {
mr := &ModRunner{
Log: log,
ConfPath: confPath,
ConfReload: confreload,
Notifiers: notifiers,
}
err := mr.ReadConfig()
if err != nil {
return nil, err
}
return mr, nil
} | go | {
"resource": ""
} |
q7695 | ReadConfig | train | func (mr *ModRunner) ReadConfig() error {
ret, err := ioutil.ReadFile(mr.ConfPath)
if err != nil {
return fmt.Errorf("Error reading config file %s: %s", mr.ConfPath, err)
}
newcnf, err := conf.Parse(mr.ConfPath, string(ret))
if err != nil {
return fmt.Errorf("Error reading config file %s: %s", mr.ConfPath, err)
}
if _, err := shell.GetShellName(newcnf.GetVariables()[shellVarName]); err != nil {
return err
}
newcnf.CommonExcludes(CommonExcludes)
mr.Config = newcnf
return nil
} | go | {
"resource": ""
} |
q7696 | PrepOnly | train | func (mr *ModRunner) PrepOnly(initial bool) error {
for _, b := range mr.Config.Blocks {
err := RunPreps(b, mr.Config.GetVariables(), nil, mr.Log, mr.Notifiers, initial)
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q7697 | runOnChan | train | func (mr *ModRunner) runOnChan(modchan chan *moddwatch.Mod, readyCallback func()) error {
dworld, err := NewDaemonWorld(mr.Config, mr.Log)
if err != nil {
return err
}
defer dworld.Shutdown(os.Kill)
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, os.Kill)
defer signal.Reset(os.Interrupt, os.Kill)
go func() {
dworld.Shutdown(<-c)
os.Exit(0)
}()
ipatts := mr.Config.IncludePatterns()
if mr.ConfReload {
ipatts = append(ipatts, filepath.Dir(mr.ConfPath))
}
currentDir, err := os.Getwd()
if err != nil {
return err
}
// FIXME: This takes a long time. We could start it in parallel with the
// first process run in a goroutine
watcher, err := moddwatch.Watch(currentDir, ipatts, []string{}, lullTime, modchan)
if err != nil {
return fmt.Errorf("Error watching: %s", err)
}
defer watcher.Stop()
mr.trigger(currentDir, nil, dworld)
go readyCallback()
for mod := range modchan {
if mod == nil {
break
}
if mr.ConfReload && mod.Has(mr.ConfPath) {
mr.Log.Notice("Reloading config %s", mr.ConfPath)
err := mr.ReadConfig()
if err != nil {
mr.Log.Warn("%s", err)
continue
} else {
return nil
}
}
mr.Log.SayAs("debug", "Delta: \n%s", mod.String())
mr.trigger(currentDir, mod, dworld)
}
return nil
} | go | {
"resource": ""
} |
q7698 | Run | train | func (mr *ModRunner) Run() error {
for {
modchan := make(chan *moddwatch.Mod, 1024)
err := mr.runOnChan(modchan, func() {})
if err != nil {
return err
}
}
} | go | {
"resource": ""
} |
q7699 | Restart | train | func (d *daemon) Restart() {
d.Lock()
defer d.Unlock()
if d.ex == nil {
ex, err := shell.NewExecutor(d.shell, d.conf.Command, d.indir)
if err != nil {
d.log.Shout("Could not create executor: %s", err)
}
d.ex = ex
go d.Run()
} else {
d.log.Notice(">> sending signal %s", d.conf.RestartSignal)
err := d.ex.Signal(d.conf.RestartSignal)
if err != nil {
d.log.Warn(
"failed to send %s signal to %s: %v", d.conf.RestartSignal, d.conf.Command, err,
)
}
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.