| /external/python/cpython3/Doc/reference/ |
| D | expressions.rst | 16 .. productionlist:: python-grammar
32 implementation for built-in types works as follows:
34 * If either argument is a complex number, the other is converted to complex;
36 * otherwise, if either argument is a floating point number, the other is
39 * otherwise, both must be integers and no conversion is necessary.
55 also categorized syntactically as atoms. The syntax for atoms is:
57 .. productionlist:: python-grammar
63 .. _atom-identifiers:
66 -------------------
70 An identifier occurring as an atom is a name. See section :ref:`identifiers`
[all …]
|
| /external/sdv/vsomeip/third_party/boost/iterator/doc/ |
| D | generator_iterator.htm | 1 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
5 <meta http-equiv="Content-Language" content="en-us">
6 <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
8 <title>Generator Iterator Adaptor Documentation</title>
15 <h1>Generator Iterator Adaptor</h1>
20 <p>The generator iterator adaptor makes it easier to create custom input
21 iterators from 0-ary functions and function objects. The adaptor takes a
22 <a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a> and
25 increment retrieves an item from the generator and makes it available to be
26 retrieved by dereferencing. The motivation for this iterator is that some
[all …]
|
| D | function_input_iterator.rst | 11 Function Input Iterator
14 The Function Input Iterator allows for creating iterators that encapsulate
15 a nullary function object and a state object which tracks the number of times
16 the iterator has been incremented. A Function Input Iterator models the
17 `InputIterator`_ concept and is useful for creating bounded input iterators.
21 The Function Input Iterator takes a function that models the Generator_ concept
22 (which is basically a nullary or 0-arity function object). The first dereference
23 of the iterator at a given position invokes the generator function and stores
27 invokation of the generator function. This ensures the generator function is
28 invoked precisely when the iterator is requested to return a (new) value.
[all …]
|
| /external/python/cpython2/Doc/library/ |
| D | random.rst | 1 :mod:`random` --- Generate pseudo-random numbers
5 :synopsis: Generate pseudo-random numbers with various common distributions.
9 --------------
11 This module implements pseudo-random number generators for various
15 of a random element, a function to generate a random permutation of a list
16 in-place, and a function for random sampling without replacement.
20 distributions of angles, the von Mises distribution is available.
22 Almost all module functions depend on the basic function :func:`.random`, which
23 generates a random float uniformly in the semi-open range [0.0, 1.0). Python
24 uses the Mersenne Twister as the core generator. It produces 53-bit precision
[all …]
|
| /external/python/cpython3/Doc/c-api/ |
| D | gen.rst | 3 .. _gen-objects:
5 Generator Objects
6 -----------------
8 Generator objects are what Python uses to implement generator iterators. They
9 are normally created by iterating over a function that yields values, rather
15 The C structure used for generator objects.
20 The type object corresponding to generator objects.
23 .. c:function:: int PyGen_Check(PyObject *ob)
25 Return true if *ob* is a generator object; *ob* must not be ``NULL``. This
26 function always succeeds.
[all …]
|
| /external/tensorflow/tensorflow/python/kernel_tests/random/ |
| D | stateful_random_ops_test.py | 7 # http://www.apache.org/licenses/LICENSE-2.0
10 # distributed under the License is distributed on an "AS IS" BASIS,
63 """Tests `create_rng_state` when `seed` is int."""
70 [0] * (random.PHILOX_STATE_SIZE - 2))),
79 tensors = [array_ops.reshape(t, shape=[-1]) for t in tensors]
87 This test is flaky, but with very low probability of failing.
103 gen = random.Generator.from_seed(1234)
116 @def_function.function
133 gen = random.Generator.from_seed(1234) # gen is on CPU
141 g = random.Generator.from_seed(1)
[all …]
|
| /external/sdv/vsomeip/third_party/boost/spirit/doc/karma/ |
| D | action.qbk | 2 Copyright (C) 2001-2011 Joel de Guzman
3 Copyright (C) 2001-2011 Hartmut Kaiser
14 They allow to call a function or function object in order to provide the value
15 output by the generator attached to the semantic action. Semantic
16 actions are associated with a generator using the syntax `g[]`, where `g` is an
17 arbitrary generator expression.
31 [[`a`, `g`][Instances of a generator, `G`]]
32 [[`A`] [Attribute type exposed by a generator, `a`]]
33 [[`fa`] [A (semantic action) function with signature `void(Attrib&, Context&, bool&)`.
34 The third parameter is a boolean flag that can be set to false to
[all …]
|
| D | auxiliary.qbk | 2 Copyright (C) 2001-2011 Hartmut Kaiser
3 Copyright (C) 2001-2011 Joel de Guzman
23 [section:attr_cast Attribute Transformation Pseudo Generator (`attr_cast`)]
27 The `attr_cast<Exposed, Transformed>()` component invokes the embedded generator
58 generator `g`.] [__unused_type__]]
61 The `attr_cast` is a function template. It is possible to invoke it using the
76 [[`g`] [A generator object.]]
81 Semantics of an expression is defined only where it differs from, or is
87 generator `g` while passing an attribute of the type
92 This generator does not fail unless `g` fails.]]
[all …]
|
| D | actions.qbk | 2 Copyright (C) 2001-2011 Joel de Guzman
3 Copyright (C) 2001-2011 Hartmut Kaiser
9 [section:semantic_actions Generator Semantic Actions]
14 of passing data to the generator by supplying it as a parameter to one of the
16 But sometimes this is not possible or not desirable.
20 These actions are C++ functions or function objects that are called whenever a
21 part of the generator is about to be invoked. Say you have a generator `G`,
22 and a C++ function `F`, you can make the generator call `F` just before it gets
27 The expression above links `F` to the generator, `G`.
30 matches its input and the matched value is passed into the
[all …]
|
| D | warming_up.qbk | 2 Copyright (C) 2001-2011 Joel de Guzman
3 Copyright (C) 2001-2011 Hartmut Kaiser
11 Learning how to use __karma__ is really simple. We will start from trivial
17 Let's create a generator that will output a floating-point number:
22 generator (a built-in generator). Spirit has many pre-defined generators and
24 Especially important to note is that things related to identical entities (as
27 refer to a floating point generator or parser: `double_`.
32 Now, let's create a generator that will output a line consisting of two
33 floating-point numbers.
37 Here you see the familiar floating-point numeric generator `double_` used twice,
[all …]
|
| D | numeric.qbk | 2 Copyright (C) 2001-2011 Hartmut Kaiser
3 Copyright (C) 2001-2011 Joel de Guzman
38 The `uint_generator` class is the simplest among the members of the
40 arbitrary length and size. The `uint_generator` generator can be used to
45 The `uint_generator` is a template class. Template parameters fine tune its behavior.
69 platforms where the preprocessor constant `BOOST_HAS_LONG_LONG` is
73 [note `lit` is reused by the [karma_string String Generators], the
75 general, a char generator is created when you pass in a
76 character, a string generator is created when you pass in a string, and a
77 numeric generator is created when you use a numeric literal.]
[all …]
|
| /external/federated-compute/fcp/secagg/server/ |
| D | secagg_scheduler.h | 8 * http://www.apache.org/licenses/LICENSE-2.0
11 * distributed under the License is distributed on an "AS IS" BASIS,
36 // Simple callback waiter that runs the function on Wakeup.
39 explicit CallbackWaiter(std::function<void()> callback) in CallbackWaiter()
45 std::function<void()> callback_;
68 std::function<std::unique_ptr<T>(const T&, const T&)> accumulator_func, in Accumulator()
77 inline static std::function<void()> GetParallelScheduleFunc( in GetParallelScheduleFunc()
79 std::function<std::unique_ptr<T>()> generator) { in GetParallelScheduleFunc() argument
80 return [accumulator, generator] { in GetParallelScheduleFunc()
81 // Increment active count if the accumulator is not canceled, otherwise in GetParallelScheduleFunc()
[all …]
|
| D | secagg_scheduler_test.cc | 8 * http://www.apache.org/licenses/LICENSE-2.0
11 * distributed under the License is distributed on an "AS IS" BASIS,
46 MOCK_METHOD(void, Schedule, (std::function<void()>), (override));
50 // Wrap int in a struct to keep Clang-tidy happy.
57 std::vector<std::function<std::unique_ptr<Integer>()>> IntGenerators(int n) { in IntGenerators()
58 std::vector<std::function<std::unique_ptr<Integer>()>> generators; in IntGenerators()
68 constexpr auto call_fn = [](const std::function<void()>& f) { f(); }; in __anon4e9995c40402()
94 // runner is alive. in TEST()
97 std::vector<std::function<std::unique_ptr<Integer>()>> generators = in TEST()
103 for (const auto& generator : generators) { in TEST() local
[all …]
|
| /external/python/cpython2/Doc/c-api/ |
| D | gen.rst | 3 .. _gen-objects:
5 Generator Objects
6 -----------------
8 Generator objects are what Python uses to implement generator iterators. They
9 are normally created by iterating over a function that yields values, rather
15 The C structure used for generator objects.
20 The type object corresponding to generator objects.
23 .. c:function:: int PyGen_Check(ob)
25 Return true if *ob* is a generator object; *ob* must not be *NULL*.
28 .. c:function:: int PyGen_CheckExact(ob)
[all …]
|
| /external/mbedtls/include/mbedtls/ |
| D | psa_util.h | 8 * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
25 /* The type of a `f_rng` random generator function that many library functions
28 * This type name is not part of the Mbed TLS stable API. It may be renamed
35 /** The random generator function for the PSA subsystem.
37 * This function is suitable as the `f_rng` random generator function
41 * The implementation of this function depends on the configuration of the
44 * \note Depending on the configuration, this may be a function or
45 * a pointer to a function.
47 * \note This function may only be used if the PSA crypto subsystem is active.
49 * this function, and you must not call this function after calling
[all …]
|
| /external/python/cpython3/Doc/howto/ |
| D | functional.rst | 11 :term:`iterator`\s and :term:`generator`\s and relevant library modules such as
20 skip to the next section on :ref:`functional-howto-iterators`.
30 perform the computation efficiently. SQL is the declarative language you're
35 * **Object-oriented** programs manipulate collections of objects. Objects have
37 some way. Smalltalk and Java are object-oriented languages. C++ and Python
38 are languages that support object-oriented programming, but don't force the
39 use of object-oriented features.
43 internal state that affects the output produced for a given input. Well-known
50 multi-paradigm languages that support several different approaches.
51 Lisp, C++, and Python are multi-paradigm; you can write programs or
[all …]
|
| /external/cronet/third_party/icu/source/i18n/unicode/ |
| D | udatpg.h | 6 * Copyright (C) 2007-2015, International Business Machines
11 * encoding: UTF-8
35 * like "yy-MM-dd". The user can build up the generator by adding successive
36 * patterns. Once that is done, a query can be made using a "skeleton", which is
37 * a pattern which just includes the desired fields and lengths. The generator
39 * <p>The main method people will use is udatpg_getBestPattern, since normally
40 * UDateTimePatternGenerator is pre-built with data from a particular locale.
42 * <p><i>Issue: may be useful to also have a function that returns the list of
48 * Opaque type for a date/time pattern generator object.
56 * because some fields are merged for the date/time pattern generator.
[all …]
|
| /external/icu/libicu/cts_headers/unicode/ |
| D | udatpg.h | 6 * Copyright (C) 2007-2015, International Business Machines
11 * encoding: UTF-8
35 * like "yy-MM-dd". The user can build up the generator by adding successive
36 * patterns. Once that is done, a query can be made using a "skeleton", which is
37 * a pattern which just includes the desired fields and lengths. The generator
39 * <p>The main method people will use is udatpg_getBestPattern, since normally
40 * UDateTimePatternGenerator is pre-built with data from a particular locale.
42 * <p><i>Issue: may be useful to also have a function that returns the list of
48 * Opaque type for a date/time pattern generator object.
56 * because some fields are merged for the date/time pattern generator.
[all …]
|
| /external/icu/libandroidicu/include/unicode/ |
| D | udatpg.h | 6 * Copyright (C) 2007-2015, International Business Machines
11 * encoding: UTF-8
35 * like "yy-MM-dd". The user can build up the generator by adding successive
36 * patterns. Once that is done, a query can be made using a "skeleton", which is
37 * a pattern which just includes the desired fields and lengths. The generator
39 * <p>The main method people will use is udatpg_getBestPattern, since normally
40 * UDateTimePatternGenerator is pre-built with data from a particular locale.
42 * <p><i>Issue: may be useful to also have a function that returns the list of
48 * Opaque type for a date/time pattern generator object.
56 * because some fields are merged for the date/time pattern generator.
[all …]
|
| /external/icu/icu4c/source/i18n/unicode/ |
| D | udatpg.h | 6 * Copyright (C) 2007-2015, International Business Machines
11 * encoding: UTF-8
35 * like "yy-MM-dd". The user can build up the generator by adding successive
36 * patterns. Once that is done, a query can be made using a "skeleton", which is
37 * a pattern which just includes the desired fields and lengths. The generator
39 * <p>The main method people will use is udatpg_getBestPattern, since normally
40 * UDateTimePatternGenerator is pre-built with data from a particular locale.
42 * <p><i>Issue: may be useful to also have a function that returns the list of
48 * Opaque type for a date/time pattern generator object.
56 * because some fields are merged for the date/time pattern generator.
[all …]
|
| /external/python/cpython2/Doc/howto/ |
| D | functional.rst | 11 :term:`iterator`\s and :term:`generator`\s and relevant library modules such as
30 perform the computation efficiently. SQL is the declarative language you're
35 * **Object-oriented** programs manipulate collections of objects. Objects have
37 some way. Smalltalk and Java are object-oriented languages. C++ and Python
38 are languages that support object-oriented programming, but don't force the
39 use of object-oriented features.
43 internal state that affects the output produced for a given input. Well-known
49 use a different approach. Other languages are multi-paradigm languages that
51 multi-paradigm; you can write programs or libraries that are largely
52 procedural, object-oriented, or functional in all of these languages. In a
[all …]
|
| /external/python/cpython2/Doc/reference/ |
| D | expressions.rst | 36 coercion rules listed at :ref:`coercion-rules`. If both arguments are standard
39 * If either argument is a complex number, the other is converted to complex;
41 * otherwise, if either argument is a floating point number, the other is
44 * otherwise, if either argument is a long integer, the other is converted to
47 * otherwise, both must be plain integers and no conversion is necessary.
63 atoms is:
72 .. _atom-identifiers:
75 -------------------
81 An identifier occurring as an atom is a name. See section :ref:`identifiers`
87 When the name is bound to an object, evaluation of the atom yields that object.
[all …]
|
| /external/sandboxed-api/sandboxed_api/tools/generator2/ |
| D | code_test.py | 7 # https://www.apache.org/licenses/LICENSE-2.0
10 # distributed under the License is distributed on an "AS IS" BASIS,
77 function_body = 'extern "C" int function(bool a1) { return a1 ? 1 : 2; }'
81 # cursor.get_definition() is None when we skip parsing function bodies
85 translation_unit = analyze_string('extern "C" int function(char* a);')
104 function_body = 'extern "C" int function(bool a1) { return a1 ? 1 : 2; }'
108 fn = code.Function(translation_unit, cursor)
129 generator = code.Generator([analyze_string(body)])
130 result = generator.generate('Test', functions, 'sapi::Tests', None, None)
136 extern "C" int function(struct x a) { return a.a; }
[all …]
|
| /external/sdv/vsomeip/third_party/boost/spirit/repository/doc/karma/ |
| D | confix.qbk | 2 Copyright (C) 2001-2011 Hartmut Kaiser
3 Copyright (C) 2001-2011 Joel de Guzman
9 [section Karma Confix Generator]
13 The __karma__ `confix` generator is a generator directive component
15 closing (a suffix). A simple example is a C comment: `/* This is a C comment */`
16 which can be generated using the `confix` generator as:
17 `confix("/*", "*/")["This is a C comment"]`. The general syntax for using the
18 `confix` is:
27 of being able to encapsulate the prefix and the suffix into a separate generator
42 // Define a helper function allowing to create a confix() construct from
[all …]
|
| /external/sdv/vsomeip/third_party/boost/proto/doc/ |
| D | glossary.qbk | 18 [A transform of the form `R(A0,A1,...)` (i.e., a function type) where
19 `proto::is_callable<R>::value` is `true`. `R` is treated as a polymorphic
20 function object and the arguments are treated as transforms that yield the
21 arguments to the function object.] ]
24 with an expression to evaluate, to the `proto::eval()` function. The context
25 determines how the expression is evaluated. All context structs define a
27 `proto::tag::plus`), is a binary polymorphic function object that accepts an
32 within that domain with a /generator/ for that domain and optionally a
38 [ [ [anchor dsl] domain-specific language]
42 [ [ [anchor edsl] embedded domain-specific language]
[all …]
|