| /development/vndk/tools/vtable-dumper/tests/ |
| test1.cpp | 18 class Gamma : public Beta {
20 Gamma(int data) : mGCdata(data), Beta(data) {}
22 virtual ~Gamma() {};
31 void Gamma::getData(int *src, int *dst, int data) {}
|
| /external/google-tv-pairing-protocol/cpp/src/polo/pairing/ |
| polochallengeresponse.h | 27 typedef std::vector<uint8_t> Alpha, Gamma, Nonce;
43 // Computes the gamma value based on the given nonce.
44 virtual Gamma* GetGamma(const Nonce& nonce) const;
46 // Extracts the nonce from the given gamma value.
47 virtual Nonce* ExtractNonce(const Gamma& gamma) const;
49 // Verifies that the given gamma value is correct.
50 virtual bool CheckGamma(const Gamma& gamma) const;
|
| pairinglistener.h | 39 // display a decoded secret based on the given gamma value.
40 virtual void OnPerformOutputDeviceRole(const Gamma& gamma) = 0;
|
| polochallengeresponse.cc | 96 Gamma* PoloChallengeResponse::GetGamma(const Nonce& nonce) const {
102 Gamma* gamma = new Gamma(nonce.size() * 2); local
105 memcpy(&(*gamma)[0], &(*alpha)[0], nonce.size());
106 memcpy(&(*gamma)[nonce.size()], &nonce[0], nonce.size());
110 return gamma;
113 Nonce* PoloChallengeResponse::ExtractNonce(const Gamma& gamma) const {
114 if ((gamma.size() < 2) || (gamma.size() % 2 != 0))
[all...] |
| pairingsession.h | 81 bool SetSecret(const Gamma& secret);
194 Gamma* secret_;
|
| /external/google-tv-pairing-protocol/cpp/tests/polo/pairing/ |
| mocks.h | 29 MOCK_CONST_METHOD1(GetGamma, Gamma*(const Nonce& nonce));
30 MOCK_CONST_METHOD1(ExtractNonce, Nonce*(const Gamma& gamma));
31 MOCK_CONST_METHOD1(CheckGamma, bool(const Gamma& gammma));
39 MOCK_METHOD1(OnPerformOutputDeviceRole, void(const Gamma& gamma));
|
| polochallengeresponsetest.cc | 112 const Gamma* gamma = response->GetGamma(nonce); local
113 ASSERT_TRUE(gamma);
116 util::PoloUtil::BytesToHexString(&(*gamma)[0], gamma->size()));
117 delete gamma;
121 const Gamma* gamma = response->GetGamma(nonce); local
122 ASSERT_TRUE(gamma);
124 util::PoloUtil::BytesToHexString(&(*gamma)[0], gamma->size()))
[all...] |
| serverpairingsessiontest.cc | 127 EXPECT_CALL(challenge_, GetGamma(_)).WillOnce(Return(new Gamma(5, 0x5)));
128 EXPECT_CALL(listener_, OnPerformOutputDeviceRole(Gamma(5, 0x5)));
|
| pairingsessiontest.cc | 157 EXPECT_CALL(challenge_, GetGamma(_)).WillOnce(Return(new Gamma(10, 0x5)));
158 EXPECT_CALL(listener_, OnPerformOutputDeviceRole(Gamma(10, 0x5)));
202 Gamma gamma(5, 0x1);
206 EXPECT_CALL(challenge_, CheckGamma(gamma)).WillOnce(Return(true));
207 EXPECT_CALL(challenge_, ExtractNonce(gamma))
215 session_.SetSecret(gamma);
232 Gamma gamma(5, 0x1);
236 EXPECT_CALL(challenge_, CheckGamma(gamma)).WillOnce(Return(true))
[all...] |
| /external/apache-commons-math/src/main/java/org/apache/commons/math/special/ |
| Erf.java | 42 * {@link Gamma#regularizedGammaP(double, double, double, int) regularized gamma function},
52 * @see Gamma#regularizedGammaP(double, double, double, int)
58 double ret = Gamma.regularizedGammaP(0.5, x * x, 1.0e-15, 10000);
71 * {@link Gamma#regularizedGammaQ(double, double, double, int) regularized gamma function},
81 * @see Gamma#regularizedGammaQ(double, double, double, int)
88 final double ret = Gamma.regularizedGammaQ(0.5, x * x, 1.0e-15, 10000);
|
| Beta.java | 196 ret = Gamma.logGamma(a) + Gamma.logGamma(b) -
197 Gamma.logGamma(a + b);
|
| Gamma.java | 26 * Gamma family of functions.
30 public class Gamma {
36 public static final double GAMMA = 0.577215664901532860606512090082;
74 private Gamma() {
79 * Returns the natural logarithm of the gamma function Γ(x).
84 * Gamma Function</a>, equation (28).</li>
87 * <li><a href="http://my.fit.edu/~gabdo/gamma.txt">Paul Godfrey, A note on
88 * the computation of the convergent Lanczos complex Gamma approximation
118 * Returns the regularized gamma function P(a, x).
122 * @return the regularized gamma function P(a, x
[all...] |
| /external/apache-commons-math/src/main/java/org/apache/commons/math/distribution/ |
| BetaDistributionImpl.java | 22 import org.apache.commons.math.special.Gamma;
121 z = Gamma.logGamma(alpha) + Gamma.logGamma(beta) - Gamma.logGamma(alpha + beta);
|
| GammaDistributionImpl.java | 24 import org.apache.commons.math.special.Gamma;
54 * Create a new gamma distribution with the given alpha and beta values.
63 * Create a new gamma distribution with the given alpha and beta values.
100 ret = Gamma.regularizedGammaP(alpha, x / beta);
206 return FastMath.pow(x / beta, alpha - 1) / beta * FastMath.exp(-x / beta) / FastMath.exp(Gamma.logGamma(alpha));
248 // NOTE: gamma is skewed to the left
275 // Gamma is skewed to the left, therefore, P(X < μ) > .5
|
| TDistributionImpl.java | 25 import org.apache.commons.math.special.Gamma;
118 return FastMath.exp(Gamma.logGamma(nPlus1Over2) - 0.5 * (FastMath.log(FastMath.PI) + FastMath.log(n)) -
119 Gamma.logGamma(n/2) - nPlus1Over2 * FastMath.log(1 + x * x /n));
|
| WeibullDistributionImpl.java | 24 import org.apache.commons.math.special.Gamma;
306 * The mean is <code>scale * Gamma(1 + (1 / shape))</code>
307 * where <code>Gamma(...)</code> is the Gamma-function
316 return sc * FastMath.exp(Gamma.logGamma(1 + (1 / sh)));
323 * <code>scale^2 * Gamma(1 + (2 / shape)) - mean^2</code>
324 * where <code>Gamma(...)</code> is the Gamma-function
335 FastMath.exp(Gamma.logGamma(1 + (2 / sh))) -
|
| PoissonDistributionImpl.java | 24 import org.apache.commons.math.special.Gamma;
63 * Gamma#regularizedGammaP or continued fraction approximation of Gamma#regularizedGammaQ.
219 return Gamma.regularizedGammaQ((double) x + 1, mean, epsilon, maxIterations);
|
| SaddlePointExpansion.java | 19 import org.apache.commons.math.special.Gamma;
114 ret = Gamma.logGamma(z + 1.0) - (z + 0.5) * FastMath.log(z) +
|
| /hardware/interfaces/tests/pointer/1.0/ |
| IGraph.hal | 42 struct Gamma {
51 passAGamma(Gamma c);
|
| /prebuilts/go/darwin-x86/src/math/ |
| gamma.go | 8 // below are from http://netlib.sandia.gov/cephes/cprob/gamma.c.
13 // Gamma function
24 // Returns gamma function of the argument. The result is
27 // This variable is also filled in by the logarithmic gamma
60 // source listings for the gamma function and the incomplete beta
93 // Gamma function computed by Stirling's formula.
121 // Gamma returns the Gamma function of x.
124 // Gamma(+Inf) = +Inf
125 // Gamma(+0) = +In
[all...] |
| /prebuilts/go/linux-x86/src/math/ |
| gamma.go | 8 // below are from http://netlib.sandia.gov/cephes/cprob/gamma.c.
13 // Gamma function
24 // Returns gamma function of the argument. The result is
27 // This variable is also filled in by the logarithmic gamma
60 // source listings for the gamma function and the incomplete beta
93 // Gamma function computed by Stirling's formula.
121 // Gamma returns the Gamma function of x.
124 // Gamma(+Inf) = +Inf
125 // Gamma(+0) = +In
[all...] |
| /external/tensorflow/tensorflow/python/kernel_tests/distributions/ |
| gamma_test.py | 29 from tensorflow.python.ops.distributions import gamma as gamma_lib
54 gamma = gamma_lib.Gamma(concentration=alpha, rate=beta)
56 self.assertEqual(gamma.batch_shape_tensor().eval(), (5,))
57 self.assertEqual(gamma.batch_shape, tensor_shape.TensorShape([5]))
58 self.assertAllEqual(gamma.event_shape_tensor().eval(), [])
59 self.assertEqual(gamma.event_shape, tensor_shape.TensorShape([]))
69 gamma = gamma_lib.Gamma(concentration=alpha, rate=beta)
70 log_pdf = gamma.log_prob(x
[all...] |
| /external/clang/test/Sema/ |
| exprs.c | 80 void test7(int *P, _Complex float Gamma) {
81 P = (P-42) + Gamma*4; // expected-error {{invalid operands to binary expression ('int *' and '_Complex float')}}
|
| /hardware/interfaces/tests/pointer/1.0/default/ |
| Graph.h | 28 Return<void> passAGamma(const IGraph::Gamma& c) override;
|
| /external/tensorflow/tensorflow/python/ops/distributions/ |
| gamma.py | 15 """The Gamma distribution class."""
40 "Gamma",
45 @tf_export("distributions.Gamma")
46 class Gamma(distribution.Distribution):
47 """Gamma distribution.
49 The Gamma distribution is defined over positive real numbers using
58 Z = Gamma(alpha) beta**alpha
66 * `Gamma` is the [gamma function](
72 cdf(x; alpha, beta, x > 0) = GammaInc(alpha, beta x) / Gamma(alpha
[all...] |
