// Inputs returns the array of inputs that defines the Env.
198395
func (adsr EnvADSR) Inputs() []Input {
	(&adsr).defaults()

	levels := []Input{
		C(0).Add(adsr.Bias),
		adsr.Peak.Add(adsr.Bias),
		adsr.S.Add(adsr.Bias),
		C(0).Add(adsr.Bias),
	}
	var (
		times = []Input{adsr.A, adsr.D, adsr.R}
		cts   = []Input{C(-4), C(-4), C(-4)}
	)
	return Env{
		Levels:      levels,
		Times:       times,
		Curve:       cts,
		ReleaseNode: C(2),
	}.Inputs()
}
573246
func (s *CreateApplicationInput) SetInputs(v []*Input) *CreateApplicationInput {
	s.Inputs = v
	return s
}
213554
func (nn *FeedForward) Init(inputs, hiddens, outputs int) {
	nn.NInputs = inputs + 1   // +1 for bias
	nn.NHiddens = hiddens + 1 // +1 for bias
	nn.NOutputs = outputs

	nn.InputActivations = vector(nn.NInputs, 1.0)
	nn.HiddenActivations = vector(nn.NHiddens, 1.0)
	nn.OutputActivations = vector(nn.NOutputs, 1.0)

	nn.InputWeights = matrix(nn.NInputs, nn.NHiddens)
	nn.OutputWeights = matrix(nn.NHiddens, nn.NOutputs)

	for i := 0; i < nn.NInputs; i++ {
		for j := 0; j < nn.NHiddens; j++ {
			nn.InputWeights[i][j] = random(-1, 1)
		}
	}

	for i := 0; i < nn.NHiddens; i++ {
		for j := 0; j < nn.NOutputs; j++ {
			nn.OutputWeights[i][j] = random(-1, 1)
		}
	}

	nn.InputChanges = matrix(nn.NInputs, nn.NHiddens)
	nn.OutputChanges = matrix(nn.NHiddens, nn.NOutputs)
}
1066310
func envList(key, def string) []string {
	v := os.Getenv(key)
	if v == "" {
		v = def
	}
	return strings.Fields(v)
}
499343
func (s *InputSecurityGroup) SetInputs(v []*string) *InputSecurityGroup {
	s.Inputs = v
	return s
}
842387
func (env *Env) Flags() (uint, error) {
	var _flags C.uint
	ret := C.mdb_env_get_flags(env._env, &_flags)
	if ret != success {
		return 0, operrno("mdb_env_get_flags", ret)
	}
	return uint(_flags), nil
}
410115
func inputsToEmpties(arr []Input) []interface{} {
	ret := make([]interface{}, len(arr))
	for i, in := range arr {
		ret[i] = in
	}
	return ret
}
291910
func generateEnvList(envs []*runtimeapi.KeyValue) (result []string) {
	for _, env := range envs {
		result = append(result, fmt.Sprintf("%s=%s", env.Key, env.Value))
	}
	return
}
995963
func (tlc EnvTLC) Inputs() []Input {
	sort.Sort(tlc)

	var (
		lp     = len(tlc)
		levels = make([]Input, lp)
		times  = make([]Input, lp-1)
		curves = make([]interface{}, lp-1)
	)
	for i, t := range tlc {
		levels[i] = C(t.Level)
		if i > 0 {
			times[i-1] = C(t.Time - tlc[i-1].Time)
			curves[i-1] = tlc[i-1].Curve
		}
	}
	return Env{
		Levels: levels,
		Times:  times,
		Curve:  curves,
	}.Inputs()
}
105623
func (m *Meta) InputMode() terraform.InputMode {
	if test || !m.input {
		return 0
	}

	if envVar := os.Getenv(InputModeEnvVar); envVar != "" {
		if v, err := strconv.ParseBool(envVar); err == nil {
			if !v {
				return 0
			}
		}
	}

	var mode terraform.InputMode
	mode |= terraform.InputModeProvider
	mode |= terraform.InputModeVar
	mode |= terraform.InputModeVarUnset

	return mode
}
884205
func (conn *Conn) input() {
	err := conn.loop()
	conn.sending.Lock()
	defer conn.sending.Unlock()
	conn.mutex.Lock()
	defer conn.mutex.Unlock()

	if conn.closing || errors.Cause(err) == io.EOF {
		err = ErrShutdown
	} else {
		// Make the error available for Conn.Close to see.
		conn.inputLoopError = err
	}
	// Terminate all client requests.
	for _, call := range conn.clientPending {
		call.Error = err
		call.done()
	}
	conn.clientPending = nil
	conn.shutdown = true
	close(conn.dead)
}
1223469
func (c *Command) AddEnvs(envs ...string) *Command {
	c.envs = append(c.envs, envs...)
	return c
}
358458
func (c *context) Env() map[string]string {
	env := make(map[string]string)
	for _, i := range os.Environ() {
		sep := strings.Index(i, "=")
		env[i[0:sep]] = i[sep+1:]
	}
	return env
}
1339895
func (fs *FileSorter) Input(key []types.Datum, val []types.Datum, handle int64) error {
	if fs.closed {
		return errors.New("FileSorter has been closed")
	}
	if fs.fetched {
		return errors.New("call input after output")
	}

	// Sanity checks
	if len(key) != fs.keySize {
		return errors.New("mismatch in key size and key slice")
	}
	if len(val) != fs.valSize {
		return errors.New("mismatch in value size and val slice")
	}

	if len(fs.buf) >= fs.bufSize {
		err := fs.flushToFile()
		if err != nil {
			return errors.Trace(err)
		}
	}

	row := &comparableRow{
		key:    key,
		val:    val,
		handle: handle,
	}
	fs.buf = append(fs.buf, row)
	return nil
}
204640
func Env(m map[string]string) (env []string) {
	for k, v := range m {
		env = append(env, fmt.Sprintf("%s=%s", k, v))
	}
	return
}
112896
func env(key string, defaultValue string) string {
	val := os.Getenv(key)
	if len(val) == 0 {
		return defaultValue
	}
	return val
}
1334846
func (env *Env) Import(r io.Reader) error {
	scanner := bufio.NewScanner(r)
	for scanner.Scan() {
		line := scanner.Text()
		if strings.HasPrefix(line, "#") || len(line) == 0 {
			continue
		}
		l := strings.SplitN(line, "=", 2)
		if len(l) == 1 {
			return fmt.Errorf("Invalid line: %q", line)
		}
		env.data[l[0]] = l[1]

	}

	return scanner.Err()
}