Return the parameters of the layer.

@throws \RuntimeException
@return \Generator
505679
public function parameters() : Generator
    {
        if (!$this->weights or !$this->biases) {
            throw new RuntimeException('Layer is not initialized');
        }

        yield $this->weights;
        yield $this->biases;
    }
603873
public function parametric() : Generator
    {
        foreach ($this->hidden as $layer) {
            if ($layer instanceof Parametric) {
                yield $layer;
            }
        }

        if ($this->output instanceof Parametric) {
            yield $this->output;
        }
    }
1024885
public function parameters(): MapInterface
    {
        if ($this->parameters) {
            return $this->parameters;
        }

        return $this->parameters = $this->elements->reduce(
            new Map('string', Parameter::class),
            function(Map $carry, $element): Map {
                return $carry->merge($element->parameters());
            }
        );
    }
1106833
private function getRecordListParams()
    {
        $metadataPrefix = null;
        $from = null;
        $until = null;
        $fromGranularity = null;
        $untilGranularity  = null;
        $set = isset($this->params['set']) ? $this->params['set'] : null;


        $checks = [
            function () use (&$from, &$fromGranularity) {
                if (isset($this->params['from'])) {
                    list($from, $fromGranularity)  = $this->parseRequestDate($this->params['from']);
                }
            },
            function () use (&$until, &$untilGranularity) {
                if (isset($this->params['until'])) {
                    list($until, $untilGranularity) = $this->parseRequestDate($this->params['until']);
                }
            },
            function () use (&$from, &$until) {
                if ($from !== null and $until !== null && $from > $until) {
                    throw new BadArgumentException(
                        'The `from` argument must be less than or equal to the `until` argument'
                    );
                }
            },
            function () use (&$from, &$until, &$fromGranularity, &$untilGranularity) {
                if ($from !== null and $until !== null && $fromGranularity !== $untilGranularity) {
                    throw new BadArgumentException('The `from` and `until` arguments have different granularity');
                }
            },
            function () use (&$fromGranularity) {
                if ($fromGranularity !== null &&
                    $fromGranularity === Identity::GRANULARITY_YYYY_MM_DDTHH_MM_SSZ &&
                    $this->repository->getGranularity() === Identity::GRANULARITY_YYYY_MM_DD) {
                    throw new BadArgumentException(
                        'The granularity of the `from` argument is not supported by this repository'
                    );
                }
            },
            function () use (&$untilGranularity) {
                if ($untilGranularity !== null &&
                    $untilGranularity === Identity::GRANULARITY_YYYY_MM_DDTHH_MM_SSZ &&
                    $this->repository->getGranularity() === Identity::GRANULARITY_YYYY_MM_DD) {
                    throw new BadArgumentException(
                        'The granularity of the `until` argument is not supported by this repository'
                    );
                }
            },
            function () use (&$metadataPrefix) {
                if (!isset($this->params['metadataPrefix'])) {
                    throw new BadArgumentException("Missing required argument metadataPrefix");
                }
                $metadataPrefix = $this->params['metadataPrefix'];
                if (is_array($metadataPrefix)) {
                    throw new BadArgumentException("Only one metadataPrefix allowed");
                }
                $this->checkMetadataPrefix($metadataPrefix);
            }
        ];

        $this->doChecks($checks);
        return [$metadataPrefix, $from, $until, $set];
    }
46882
public function getParameters()
    {
        $lastIndent = null;
        $parameters = array();

        if ($parameterComment = $this->getParametersComment()) {
            $parameterLines = explode("\n", $parameterComment);
            foreach ($parameterLines as $line) {
                if (empty($line)) {
                    continue;
                }

                $lineParts = explode(' - ', $line);

                $name = trim(array_shift($lineParts));

                $description = '';
                if (!empty($lineParts)) {
                    $description = trim(implode(' - ', $lineParts));
                }
                $parameter = new Parameter($name, $description);

                $parameters[] = $parameter;
            }
        }

        return $parameters;
    }
511228
public function getRuntimeConfigurableWrapper()
    {
        if ($this->wrapper === null) {
            $this->wrapper = new RuntimeConfigurable($this, $this->getTaskName());
        }

        return $this->wrapper;
    }
1079814
public function getWroteBlocks()
    {
        if (!is_dir($this->blocks)) {
            throw new RuntimeException("cannot obtain the blocks ({$this->blocks})");
        }
        $files = array_filter(array_map(function($file) {
            $basename = basename($file);
            if (!is_numeric($basename)) {
                return false;
            }
            return [
                'offset' => (int)$basename,
                'file' => $file,
                'size' => filesize($file)
            ];
        }, glob($this->blocks . "*")));

        uasort($files, function($a, $b) {
            return $a['offset'] - $b['offset'];
        });

        return $files;
    }
778619
public function getConstructorParameters()
    {
        $parameters = new BeanParameterCollection();

        if (($ctor = $this->getClass()->getConstructor()) !== null) {

            foreach ($ctor->getParameters() as $param) {
                if ($this->hasProperty($param->getName()) === true) {
                    $parameters[] = new BeanParameter($this->getClass()->getName(), '__construct', $param->getName());
                }
            }
        }

        return $parameters;
    }
900779
public function getUrlGenerator()
    {
        if (isset($this->urlGenerator)) {
            return $this->urlGenerator;
        }

        // Check if an URL Generator resolver was set.
        else if (! isset(static::$urlGeneratorResolver)) {
            throw new RuntimeException("URL Generator resolver not set on Paginator.");
        }

        return $this->urlGenerator = call_user_func(static::$urlGeneratorResolver, $this);
    }
1080069
public function getGenerator($name)
    {
        if ($this->hasGenerator($name) === false) {
            throw new \RuntimeException(sprintf('Generator not found: "%s".', $name));
        }

        return $this->generators[$name];
    }
462317
protected function getContextParameters()
    {
        if ($this->contextParameters === null) {
            $this->contextParameters    = stream_context_get_params($this->context);
        }
        return $this->contextParameters;
    }
1147549
public function getFilterParameters()
    {
        $parameters = parent::getFilterParameters();

        // build the values array
        if ($this->hasRequest()) {
            /** @var Request $request */
            $request = $this->getRequest();

            $parentAssociationMapping = $this->getParentAssociationMapping();

            // always force the parent value
            if ($parentAssociationMapping && $this->isChild()) {
                /** @var \Sonata\AdminBundle\Admin\AbstractAdmin $parent */
                $parent = $this->getParent();

                $name = str_replace('.', '__', $parentAssociationMapping);

                $idParameter = $parent->getIdParameter();

                $parameters[$name] = ['value' => $request->get($idParameter)];

                if (ClassMetadataInfo::MANY_TO_MANY === $this->getParentAssociationMappingType()) {
                    $parameters[$name] = ['value' => [$request->get($idParameter)]];
                }
            }
        }

        return $parameters;
    }
1142285
public function getConnectionParametersArray($section = 'runtime')
    {
        if (!in_array($section, ['runtime', 'generator'])) {
            return null;
        }

        $output = [];
        foreach ($this->config[$section]['connections'] as $connection) {
            $output[$connection] = $this->config['database']['connections'][$connection];
        }

        return $output;
    }
607512
def get_params(self):
    
    assert tf.executing_eagerly()
    out = []

    # Collecting params from each layer.
    for layer_name in self.layers:
      out += self.get_layer_params(layer_name)
    return out
33722
public function getParameters() {
		$filledvars = array();
		foreach (get_object_vars($this) as $name => $value) {
			if ($value) {
				$filledvars[$name] = (string)$value;
			}
		}

		return $filledvars;
	}
348021
protected function getFacetParameters() {
        $facetParameters = [];
        $facetParameters['facet'] = 'true';
        $facetParameters['facet.mincount'] = $this->getMinCount();
        $facetParameters['facet.limit'] = $this->getLimit();
        $facetParameters['facet.field'] = $this->getFields();

        foreach ($this->getAdditionalParameters() as $additionalParameterKey => $additionalParameterValue) {
            $facetParameters[$additionalParameterKey] = $additionalParameterValue;
        }

        if ($facetParameters['json.facet']) {
            $facetParameters['json.facet'] = json_encode($facetParameters['json.facet']);
        }

        $facetParameters = $this->applySorting($facetParameters);
        return $facetParameters;
    }
121892
public function getData(): array
    {
        $combined = $this->getDelegated()->getData();
        foreach (parent::getData() as $key => $value) {
            if (!array_key_exists($key, $combined)) {
                $combined[$key] = $value;
                continue;
            }
            if (\is_array($value)) {
                if (!is_array($combined[$key])) {
                    throw new \RuntimeException('Can not merge key "' . $key . '", parent value is not an array.');
                }

                /** @noinspection SlowArrayOperationsInLoopInspection - can not optimize here */
                $combined[$key] = array_merge($combined[$key], $value);
                continue;
            }

            $combined[$key] = $value;
        }

        return $combined;
    }