| /external/tensorflow/tensorflow/contrib/solvers/python/ops/ |
| linear_equations.py | 80 - gamma: \\(r \dot M \dot r\\), equivalent to \\(||r||_2^2\\) when
84 cg_state = collections.namedtuple("CGState", ["i", "x", "r", "p", "gamma"])
91 alpha = state.gamma / util.dot(state.p, z)
95 gamma = util.dot(r, r)
96 beta = gamma / state.gamma
100 gamma = util.dot(r, q)
101 beta = gamma / state.gamma
103 return i + 1, cg_state(i + 1, x, r, p, gamma)
[all...] |
| /external/apache-commons-math/src/main/java/org/apache/commons/math/optimization/direct/ |
| MultiDirectional.java | 40 private final double gamma; field in class:MultiDirectional
43 * <p>The default values are 2.0 for khi and 0.5 for gamma.</p>
47 this.gamma = 0.5;
52 * @param gamma contraction coefficient
54 public MultiDirectional(final double khi, final double gamma) {
56 this.gamma = gamma;
90 final RealPointValuePair contracted = evaluateNewSimplex(original, gamma, comparator);
|
| NelderMead.java | 42 private final double gamma; field in class:NelderMead
49 * for both gamma and sigma.</p>
54 this.gamma = 0.5;
61 * @param gamma contraction coefficient
65 final double gamma, final double sigma) {
68 this.gamma = gamma;
139 xC[j] = centroid[j] + gamma * (xR[j] - centroid[j]);
154 xC[j] = centroid[j] - gamma * (centroid[j] - xWorst[j]);
|
| /external/libkmsxx/py/tests/ |
| gamma.py | 32 gamma = pykms.Blob(card, arr); variable
34 crtc.set_prop("GAMMA_LUT", gamma.id)
36 input("press enter to remove gamma\n")
|
| /external/pdfium/core/fxcodec/codec/ |
| ccodec_pngmodule.h | 30 double* gamma) = 0;
|
| /external/libaom/libaom/test/ |
| warp_filter_test_util.h | 30 int16_t *alpha, int16_t *beta, int16_t *gamma,
42 int16_t beta, int16_t gamma, int16_t delta);
74 int16_t gamma, int16_t delta);
|
| warp_filter_test_util.cc | 30 int16_t *alpha, int16_t *beta, int16_t *gamma,
68 *gamma = clamp(((int64_t)mat[4] * (1 << WARPEDMODEL_PREC_BITS)) / mat[2],
76 (4 * abs(*gamma) + 4 * abs(*delta) >= (1 << WARPEDMODEL_PREC_BITS)))
83 *gamma = ROUND_POWER_OF_TWO_SIGNED(*gamma, WARP_PARAM_REDUCE_BITS) *
133 int16_t alpha, beta, gamma, delta; local
136 generate_warped_model(&rnd_, mat, &alpha, &beta, &gamma, &delta,
159 sub_x, sub_y, &conv_params, alpha, beta, gamma, delta);
194 int16_t alpha, beta, gamma, delta; local
211 generate_warped_model(&rnd_, mat, &alpha, &beta, &gamma, &delta
325 int16_t alpha, beta, gamma, delta; local
390 int16_t alpha, beta, gamma, delta; local
[all...] |
| /external/tensorflow/tensorflow/contrib/layers/python/layers/ |
| normalization.py | 68 scale: If True, multiply by `gamma`. If False, `gamma` is
74 param_initializers: Optional initializers for beta, gamma, moving mean and
122 # Allocate parameters for the beta and gamma of the normalization.
123 beta, gamma = None, None
142 variables_collections, 'gamma')
144 'gamma', init_ops.ones_initializer())
145 gamma = variables.model_variable('gamma',
152 gamma = array_ops.reshape(gamma, params_shape_broadcast
[all...] |
| /external/skia/src/core/ |
| SkMaskGamma.h | 29 virtual SkScalar toLuma(SkScalar gamma, SkScalar luminance) const = 0;
31 virtual SkScalar fromLuma(SkScalar gamma, SkScalar luma) const = 0;
34 static U8CPU computeLuminance(SkScalar gamma, SkColor c) {
35 const SkColorSpaceLuminance& luminance = Fetch(gamma);
36 SkScalar r = luminance.toLuma(gamma, SkIntToScalar(SkColorGetR(c)) / 255);
37 SkScalar g = luminance.toLuma(gamma, SkIntToScalar(SkColorGetG(c)) / 255);
38 SkScalar b = luminance.toLuma(gamma, SkIntToScalar(SkColorGetB(c)) / 255);
43 return SkScalarRoundToInt(luminance.fromLuma(gamma, luma) * 255);
46 /** Retrieves the SkColorSpaceLuminance for the given gamma. */
47 static const SkColorSpaceLuminance& Fetch(SkScalar gamma);
[all...] |
| /external/skqp/src/core/ |
| SkMaskGamma.h | 29 virtual SkScalar toLuma(SkScalar gamma, SkScalar luminance) const = 0;
31 virtual SkScalar fromLuma(SkScalar gamma, SkScalar luma) const = 0;
34 static U8CPU computeLuminance(SkScalar gamma, SkColor c) {
35 const SkColorSpaceLuminance& luminance = Fetch(gamma);
36 SkScalar r = luminance.toLuma(gamma, SkIntToScalar(SkColorGetR(c)) / 255);
37 SkScalar g = luminance.toLuma(gamma, SkIntToScalar(SkColorGetG(c)) / 255);
38 SkScalar b = luminance.toLuma(gamma, SkIntToScalar(SkColorGetB(c)) / 255);
43 return SkScalarRoundToInt(luminance.fromLuma(gamma, luma) * 255);
46 /** Retrieves the SkColorSpaceLuminance for the given gamma. */
47 static const SkColorSpaceLuminance& Fetch(SkScalar gamma);
[all...] |
| /external/tensorflow/tensorflow/core/kernels/ |
| batch_norm_op.cc | 52 const Tensor& gamma = context->input(4); variable
66 OP_REQUIRES(context, gamma.dims() == 1,
67 errors::InvalidArgument("gamma must be 1-dimensional",
68 gamma.shape().DebugString()));
76 var.vec<T>(), beta.vec<T>(), gamma.vec<T>(), variance_epsilon_,
101 const Tensor& gamma = context->input(3); variable
113 OP_REQUIRES(context, gamma.dims() == 1,
114 errors::InvalidArgument("gamma must be 1-dimensional",
115 gamma.shape().DebugString()));
137 OP_REQUIRES_OK(context, context->allocate_output(4, gamma.shape(), &dg))
[all...] |
| quantized_batch_norm_op.cc | 35 float beta_min, float beta_max, const Tensor& gamma,
43 auto gamma_flat = gamma.flat<T1>();
98 float beta_min, float beta_max, const Tensor& gamma,
106 auto gamma_flat = gamma.flat<T1>();
187 const Tensor& gamma = context->input(12); variable
203 OP_REQUIRES(context, gamma.dims() == 1,
204 errors::InvalidArgument("gamma must be 1-dimensional",
205 gamma.shape().DebugString()));
214 beta_max, gamma, gamma_min, gamma_max,
|
| batch_norm_op.h | 32 typename TTypes<T>::ConstVec gamma, T variance_epsilon,
55 ((var + var.constant(variance_epsilon)).rsqrt() * gamma)
78 typename TTypes<T>::ConstVec gamma,
108 // dv = sum_over_rest(out_backprop * gamma * (x - m)) *
111 // dm = sum_over_rest(out_backprop * gamma) * (-1 / rsqrt(v + epsilon))
113 // dx = out_backprop * (gamma * rsqrt(v + epsilon))
127 out_backprop.reshape(rest_by_depth) * ((scratch1 * gamma)
131 dm.device(d) = -db * (scratch1 * gamma).eval();
138 dg.device(d) = dg.constant(static_cast<T>(0.0)); // Gamma is not learned.
146 dv.device(d) = scratch2 * (scratch1 * gamma).eval()
[all...] |
| /external/ImageMagick/coders/ |
| hdr.c | 148 gamma;
308 if (LocaleCompare(keyword,"gamma") == 0)
310 image->gamma=StringToDouble(value,(char **) NULL);
492 gamma=pow(2.0,pixel[3]-(128.0+8.0));
493 SetPixelRed(image,ClampToQuantum(QuantumRange*gamma*pixel[0]),q);
494 SetPixelGreen(image,ClampToQuantum(QuantumRange*gamma*pixel[1]),q);
495 SetPixelBlue(image,ClampToQuantum(QuantumRange*gamma*pixel[2]),q);
733 if (image->gamma != 0.0)
735 count=FormatLocaleString(header,MagickPathExtent,"GAMMA=%g\n",
736 image->gamma);
144 gamma; local
771 gamma; local
[all...] |
| /external/eigen/unsupported/Eigen/src/EulerAngles/ |
| EulerAngles.h | 31 * - then, rotate the axes system over the gamma axis(which was rotated in the two stages above) in angle gamma
137 /** \returns the axis vector of the third (gamma) rotation */
149 /** Constructs and initialize Euler angles(\p alpha, \p beta, \p gamma). */
150 EulerAngles(const Scalar& alpha, const Scalar& beta, const Scalar& gamma) :
151 m_angles(alpha, beta, gamma) {}
169 * \param positiveRangeGamma If true, gamma will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
199 * \param positiveRangeGamma If true, gamma will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
211 /** \returns The angle values stored in a vector (alpha, beta, gamma). */
213 /** \returns A read-write reference to the angle values stored in a vector (alpha, beta, gamma). *
227 Scalar gamma() const { return m_angles[2]; } function in class:Eigen::EulerAngles
229 Scalar& gamma() { return m_angles[2]; } function in class:Eigen::EulerAngles
[all...] |
| /external/libaom/libaom/av1/common/x86/ |
| warp_plane_sse4.c | 457 static INLINE void prepare_vertical_filter_coeffs(int gamma, int sy,
460 (__m128i *)(warped_filter + ((sy + 0 * gamma) >> WARPEDDIFF_PREC_BITS)));
462 (__m128i *)(warped_filter + ((sy + 2 * gamma) >> WARPEDDIFF_PREC_BITS)));
464 (__m128i *)(warped_filter + ((sy + 4 * gamma) >> WARPEDDIFF_PREC_BITS)));
466 (__m128i *)(warped_filter + ((sy + 6 * gamma) >> WARPEDDIFF_PREC_BITS)));
480 (__m128i *)(warped_filter + ((sy + 1 * gamma) >> WARPEDDIFF_PREC_BITS)));
482 (__m128i *)(warped_filter + ((sy + 3 * gamma) >> WARPEDDIFF_PREC_BITS)));
484 (__m128i *)(warped_filter + ((sy + 5 * gamma) >> WARPEDDIFF_PREC_BITS)));
486 (__m128i *)(warped_filter + ((sy + 7 * gamma) >> WARPEDDIFF_PREC_BITS)));
657 uint8_t *pred, __m128i *tmp, ConvolveParams *conv_params, int16_t gamma,
[all...] |
| /cts/apps/CameraITS/tests/scene1/ |
| test_auto_vs_manual.py | 83 gamma = sum([[i/63.0, math.pow(i/63.0, 1/2.2)] for i in xrange(64)], [])
86 "red": gamma, "green": gamma, "blue": gamma}
|
| /cts/tests/tests/uirendering/src/android/uirendering/cts/bitmapcomparers/ |
| MSSIMComparer.java | 167 * The prime symbols dictate a gamma correction of 1.
170 final double gamma = 1; local
172 l += (0.21f * Math.pow(Color.red(pixel) / 255f, gamma));
173 l += (0.72f * Math.pow(Color.green(pixel) / 255f, gamma));
174 l += (0.07f * Math.pow(Color.blue(pixel) / 255f, gamma));
|
| /external/skia/src/effects/ |
| SkTableMaskFilter.cpp | 112 SkMaskFilter* SkTableMaskFilter::CreateGamma(SkScalar gamma) {
114 MakeGammaTable(table, gamma);
124 void SkTableMaskFilter::MakeGammaTable(uint8_t table[256], SkScalar gamma) {
126 const float g = SkScalarToFloat(gamma);
|
| /external/skqp/src/effects/ |
| SkTableMaskFilter.cpp | 112 SkMaskFilter* SkTableMaskFilter::CreateGamma(SkScalar gamma) {
114 MakeGammaTable(table, gamma);
124 void SkTableMaskFilter::MakeGammaTable(uint8_t table[256], SkScalar gamma) {
126 const float g = SkScalarToFloat(gamma);
|
| /external/libpng/contrib/gregbook/ |
| readpng2.c | 223 double gamma; local
225 png_fixed_point gamma; local
336 * such images have a file gamma of 0.45455, which corresponds to a PC-like
342 * "gamma" value for the entire display system, i.e., the product of
346 if (png_get_gAMA(png_ptr, info_ptr, &gamma))
347 png_set_gamma(png_ptr, mainprog_ptr->display_exponent, gamma);
351 if (png_get_gAMA_fixed(png_ptr, info_ptr, &gamma))
353 (png_fixed_point)(100000*mainprog_ptr->display_exponent+.5), gamma);
|
| /external/webrtc/webrtc/modules/remote_bitrate_estimator/test/estimators/ |
| nada.cc | 248 float gamma = local
252 bitrate_kbps_ = static_cast<int>((1.0f + gamma) * fb.receiving_rate() + 0.5f);
257 float gamma = 3.0f * kMaxCongestionSignalMs / local
259 gamma = std::min(gamma, kGamma0);
260 bitrate_kbps_ = gamma * fb.receiving_rate() + 0.5f;
|
| /external/tensorflow/tensorflow/python/ops/ |
| batch_norm_benchmark.py | 40 def batch_norm_op(tensor, mean, variance, beta, gamma, scale):
46 tensor, mean, variance, beta, gamma, 0.001, scale)
53 # batch_norm *= gamma
55 def batch_norm_py(tensor, mean, variance, beta, gamma, scale):
57 return nn_impl.batch_normalization(tensor, mean, variance, beta, gamma if
61 def batch_norm_slow(tensor, mean, variance, beta, gamma, scale):
64 batch_norm *= gamma
104 gamma = variables.Variable(constant_op.constant(1.0, shape=moment_shape))
106 tensor = batch_norm_py(tensor, mean, variance, beta, gamma, scale)
108 tensor = batch_norm_op(tensor, mean, variance, beta, gamma, scale
[all...] |
| nn_batchnorm_test.py | 40 def _npBatchNorm(self, x, m, v, beta, gamma, epsilon,
43 y = y * gamma if scale_after_normalization else y
46 def _opsBatchNorm(self, x, m, v, beta, gamma, epsilon,
50 y = gamma * y
53 def _tfBatchNormV1(self, x, m, v, beta, gamma, epsilon,
58 x, m, v, beta, gamma, epsilon, scale_after_normalization)
60 def _tfBatchNormV1BW(self, x, m, v, beta, gamma, epsilon,
64 x, m, v, beta, gamma, epsilon, scale_after_normalization)
66 def _tfBatchNormV2(self, x, m, v, beta, gamma, epsilon,
71 gamma if scale_after_normalization els
[all...] |
| /external/u-boot/drivers/video/ |
| fsl_diu_fb.c | 161 __be32 gamma; member in struct:diu
257 struct diu_addr gamma; local
323 /* Initialize the gamma table */
324 if (allocate_buf(&gamma, 256 * 3, 32) < 0) {
328 gamma_table_base = gamma.vaddr;
333 if (gamma_fix == 1) { /* fix the gamma */
334 gamma_table_base = gamma.vaddr;
350 out_be32(&hw->gamma, gamma.paddr);
|
