| /third_party/gstreamer/gstplugins_good/gst/videofilter/ |
| D | gstgamma.c | 102 static void gst_gamma_calculate_tables (GstGamma * gamma);
105 GST_ELEMENT_REGISTER_DEFINE (gamma, "gamma", GST_RANK_NONE, GST_TYPE_GAMMA);
144 gst_gamma_init (GstGamma * gamma) in gst_gamma_init() argument
147 gamma->gamma = DEFAULT_PROP_GAMMA; in gst_gamma_init()
148 gst_gamma_calculate_tables (gamma); in gst_gamma_init()
155 GstGamma *gamma = GST_GAMMA (object); in gst_gamma_set_property() local
161 GST_DEBUG_OBJECT (gamma, "Changing gamma from %lf to %lf", gamma->gamma, in gst_gamma_set_property()
163 GST_OBJECT_LOCK (gamma); in gst_gamma_set_property()
164 gamma->gamma = val; in gst_gamma_set_property()
165 GST_OBJECT_UNLOCK (gamma); in gst_gamma_set_property()
[all …]
|
| /third_party/python/Lib/test/ |
| D | math_testcases.txt | 170 -- lgamma: log of absolute value of the gamma function --
250 -- inputs for which gamma(x) is tiny
275 -- gamma: Gamma function --
279 gam0000 gamma 0.0 -> inf divide-by-zero
280 gam0001 gamma -0.0 -> -inf divide-by-zero
281 gam0002 gamma inf -> inf
282 gam0003 gamma -inf -> nan invalid
283 gam0004 gamma nan -> nan
286 gam0010 gamma -1 -> nan invalid
287 gam0011 gamma -2 -> nan invalid
[all …]
|
| /third_party/flutter/skia/src/core/ |
| D | SkMaskGamma.cpp | 16 SkScalar toLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luminance) const override { in toLuma() argument
17 SkASSERT(SK_Scalar1 == gamma); in toLuma()
20 SkScalar fromLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luma) const override { in fromLuma() argument
21 SkASSERT(SK_Scalar1 == gamma); in fromLuma()
27 SkScalar toLuma(SkScalar gamma, SkScalar luminance) const override { in toLuma() argument
28 return SkScalarPow(luminance, gamma); in toLuma()
30 SkScalar fromLuma(SkScalar gamma, SkScalar luma) const override { in fromLuma() argument
31 return SkScalarPow(luma, SkScalarInvert(gamma)); in fromLuma()
36 SkScalar toLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luminance) const override { in toLuma() argument
37 SkASSERT(0 == gamma); in toLuma()
[all …]
|
| D | 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) { in computeLuminance() argument
35 const SkColorSpaceLuminance& luminance = Fetch(gamma); in computeLuminance()
36 SkScalar r = luminance.toLuma(gamma, SkIntToScalar(SkColorGetR(c)) / 255); in computeLuminance()
37 SkScalar g = luminance.toLuma(gamma, SkIntToScalar(SkColorGetG(c)) / 255); in computeLuminance()
38 SkScalar b = luminance.toLuma(gamma, SkIntToScalar(SkColorGetB(c)) / 255); in computeLuminance()
43 return SkScalarRoundToInt(luminance.fromLuma(gamma, luma) * 255); in computeLuminance()
47 static const SkColorSpaceLuminance& Fetch(SkScalar gamma);
|
| /third_party/skia/src/core/ |
| D | SkMaskGamma.cpp | 16 SkScalar toLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luminance) const override { in toLuma() argument
17 SkASSERT(SK_Scalar1 == gamma); in toLuma()
20 SkScalar fromLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luma) const override { in fromLuma() argument
21 SkASSERT(SK_Scalar1 == gamma); in fromLuma()
27 SkScalar toLuma(SkScalar gamma, SkScalar luminance) const override { in toLuma() argument
28 return SkScalarPow(luminance, gamma); in toLuma()
30 SkScalar fromLuma(SkScalar gamma, SkScalar luma) const override { in fromLuma() argument
31 return SkScalarPow(luma, SkScalarInvert(gamma)); in fromLuma()
36 SkScalar toLuma(SkScalar SkDEBUGCODE(gamma), SkScalar luminance) const override { in toLuma() argument
37 SkASSERT(0 == gamma); in toLuma()
[all …]
|
| /third_party/skia/third_party/externals/opengl-registry/extensions/I3D/ |
| D | WGL_I3D_gamma.txt | 34 The gamma extension provides an interface to read and load the
35 gamma table. Other options such as having gamma only affect
107 Gamma correction for each monitor that supports a gamma table is
108 controlled by loading the gamma table and setting the appropriate
109 parameters. The function wglSetGammaTableI3D loads the gamma
119 residing on a monitor whose graphics adapter supports the gamma
120 extension. For multiple monitor systems, only the gamma table
123 The red, green, and blue data for the gamma table are pointed to by
126 the hardware gamma table are ignored.
129 If the hardware gamma table has less than 16 bits of precision, the
[all …]
|
| /third_party/openGLES/extensions/I3D/ |
| D | WGL_I3D_gamma.txt | 34 The gamma extension provides an interface to read and load the
35 gamma table. Other options such as having gamma only affect
107 Gamma correction for each monitor that supports a gamma table is
108 controlled by loading the gamma table and setting the appropriate
109 parameters. The function wglSetGammaTableI3D loads the gamma
119 residing on a monitor whose graphics adapter supports the gamma
120 extension. For multiple monitor systems, only the gamma table
123 The red, green, and blue data for the gamma table are pointed to by
126 the hardware gamma table are ignored.
129 If the hardware gamma table has less than 16 bits of precision, the
[all …]
|
| /third_party/mindspore/tests/st/ops/gpu/ |
| D | test_batchnorm_fold2_op.py | 35 …def construct(self, x, beta, gamma, batch_std, batch_mean, running_std, running_mean, current_step… argument
36 … return self.op(x, beta, gamma, batch_std, batch_mean, running_std, running_mean, current_step)
47 …def construct(self, x, beta, gamma, batch_std, batch_mean, running_std, running_mean, current_step… argument
49 out = self.correct_add(out, gamma, batch_std, batch_mean,
51 out = self.add_fold(out, beta, gamma, batch_std, batch_mean)
64 gamma = np.random.uniform(1, 2, size=[c]).astype('float32')
70 output = net(Tensor(x), Tensor(beta), Tensor(gamma), Tensor(batch_std), Tensor(batch_mean),
73 1) - (gamma * running_mean / running_std).reshape(-1, 1,
75 …x * (running_std / batch_std).reshape(-1, 1, 1) + (beta - gamma * batch_mean / batch_std).reshape(…
83 …output = net(Tensor(x), Tensor(beta), Tensor(gamma), Tensor(batch_std), Tensor(batch_mean), Tensor…
[all …]
|
| /third_party/mindspore/tests/st/ops/ascend/test_tbe_ops/ |
| D | test_layernorm.py | 29 def __init__(self, input_shape, begin_norm_axis, begin_params_axis, gamma, beta): argument
31 self.layernorm = LayerNorm(input_shape, begin_norm_axis, begin_params_axis, gamma, beta)
38 def pt_me_layernorm(input_data, normalized_shape, gamma, beta, axis): argument
41 gamma=Tensor(gamma),
56 gamma = np.random.randn(1024).astype(np.float32)
57 gamma.fill(1.1)
60 pt_me_layernorm(input_data, (1024,), gamma, beta, 2)
|
| D | test_layernorm_grad.py | 39 def __init__(self, input_shape, begin_norm_axis, begin_params_axis, gamma, beta): argument
41 self.layernorm = LayerNorm(input_shape, begin_norm_axis, begin_params_axis, gamma, beta)
48 def py_me_layernorm_grad(input_data, normalized_shape, gamma, beta, axis, gradients): argument
52 gamma=Tensor(gamma),
67 gamma = np.random.randn(1024).astype(np.float32)
68 gamma.fill(1.1)
71 py_me_layernorm_grad(input_data, (1024,), gamma, beta, 2, gradients)
|
| /third_party/mindspore/tests/ut/python/nn/probability/distribution/ |
| D | test_gamma.py | 73 self.gamma = msd.Gamma([3.0, 4.0], [1.0, 1.0], dtype=dtype.float32)
76 prob = self.gamma.prob(value)
77 log_prob = self.gamma.log_prob(value)
78 cdf = self.gamma.cdf(value)
79 log_cdf = self.gamma.log_cdf(value)
80 sf = self.gamma.survival_function(value)
81 log_sf = self.gamma.log_survival(value)
100 self.gamma = msd.Gamma()
103 prob = self.gamma.prob(value, concentration, rate)
104 log_prob = self.gamma.log_prob(value, concentration, rate)
[all …]
|
| /third_party/libpng/tests/ |
| D | pngstest | 16 gamma="$1"
27 test "$gamma" = "linear" && g="$f";;
30 test "$gamma" = "sRGB" && g="$f";;
33 test "$gamma" = "1.8" && g="$f";;
36 test "$gamma" = "none" && g="$f";;
54 exec ./pngstest --tmpfile "${gamma}-${alpha}-" --log ${1+"$@"} $args
|
| /third_party/skia/third_party/externals/libpng/tests/ |
| D | pngstest | 16 gamma="$1"
27 test "$gamma" = "linear" && g="$f";;
30 test "$gamma" = "sRGB" && g="$f";;
33 test "$gamma" = "1.8" && g="$f";;
36 test "$gamma" = "none" && g="$f";;
54 exec ./pngstest --tmpfile "${gamma}-${alpha}-" --log ${1+"$@"} $args
|
| /third_party/flutter/skia/third_party/externals/libpng/tests/ |
| D | pngstest | 16 gamma="$1"
27 test "$gamma" = "linear" && g="$f";;
30 test "$gamma" = "sRGB" && g="$f";;
33 test "$gamma" = "1.8" && g="$f";;
36 test "$gamma" = "none" && g="$f";;
54 exec ./pngstest --tmpfile "${gamma}-${alpha}-" --log ${1+"$@"} $args
|
| /third_party/mindspore/tests/st/ops/graph_kernel/ |
| D | test_layernorm.py | 32 def construct(self, x, gamma, beta): argument
33 return self.layernorm(x, gamma, beta)
41 def construct(self, dy, x, var, mean, gamma): argument
42 return self.layernorm_grad(dy, x, var, mean, gamma)
44 def get_layernorm_output(x, gamma, beta, begin_norm_axis, begin_params_axis, enable_graph_kernel=Fa… argument
48 output = net(x, gamma, beta)
53 def get_layernorm_grad_output(x, dy, var, mean, gamma, begin_norm_axis, begin_params_axis, enable_g… argument
57 output = net(x, dy, var, mean, gamma)
89 gamma = Tensor(np.random.normal(0, 1, normalized_shape).astype(dtype))
92 expect = get_layernorm_output(x, gamma, beta, begin_norm_axis, begin_params_axis, False)
[all …]
|
| /third_party/typescript/tests/baselines/reference/ |
| D | jsdocParseMatchingBackticks.types | 11 * @param {string} gamma
13 export function f(x, y, z, alpha, beta, gamma) {
14 >f : (x: string, y: string, z: string, alpha: string, beta: string, gamma: string) => string
20 >gamma : string
22 return x + y + z + alpha + beta + gamma
23 >x + y + z + alpha + beta + gamma : string
33 >gamma : string
|
| D | jsdocParseMatchingBackticks.symbols | 11 * @param {string} gamma
13 export function f(x, y, z, alpha, beta, gamma) {
20 >gamma : Symbol(gamma, Decl(jsdocParseMatchingBackticks.js, 11, 39))
22 return x + y + z + alpha + beta + gamma
28 >gamma : Symbol(gamma, Decl(jsdocParseMatchingBackticks.js, 11, 39))
|
| /third_party/mindspore/mindspore/lite/src/runtime/kernel/arm/fp16/ |
| D | instance_norm_fp16.cc | 48 auto gamma = in_tensors_.at(1); in Init() local
49 CHECK_NULL_RETURN(gamma->data()); in Init()
50 if (gamma->data_type() == kNumberTypeFloat32) { in Init()
51 gamma_data_ = reinterpret_cast<float16_t *>(malloc(gamma->ElementsNum() * sizeof(float16_t))); in Init()
56 Float32ToFloat16(reinterpret_cast<float *>(gamma->data()), gamma_data_, gamma->ElementsNum()); in Init()
57 } else if (gamma->data_type() == kNumberTypeFloat16) { in Init()
58 gamma_data_ = reinterpret_cast<float16_t *>(gamma->data()); in Init()
|
| /third_party/boost/libs/math/doc/distributions/ |
| D | inverse_gamma.qbk | 24 of the reciprocal of a variable distributed according to the gamma distribution.
28 See [@http://en.wikipedia.org/wiki/Inverse-gamma_distribution inverse gamma distribution].
30 [@http://rss.acs.unt.edu/Rdoc/library/pscl/html/igamma.html R inverse gamma distribution functions].
32 [@http://reference.wolfram.com/mathematica/ref/InverseGammaDistribution.html Wolfram inverse gamma …
37 In spite of potential confusion with the inverse gamma function, this
40 ``typedef inverse_gamma_distribution<double> gamma;``
42 If you want a `double` precision gamma distribution you can use
57 The following graphs illustrate how the PDF and CDF of the inverse gamma distribution
68 Constructs an inverse gamma distribution with shape [alpha] and scale [beta].
75 Returns the [alpha] shape parameter of this inverse gamma distribution.
[all …]
|
| /third_party/mindspore/mindspore/compression/quant/ |
| D | quant_utils.py | 163 gamma = cell_quant.gamma.data.asnumpy()
168 if gamma.shape[0] == weight.shape[0]:
171 _gamma = gamma.reshape(shape_list)
173 elif gamma.shape[0] == weight.shape[1]:
176 _gamma = gamma.reshape(shape_list)
182 bias = beta - gamma * mean / sigma
202 gamma = cell_quant.batchnorm.gamma.data.asnumpy()
207 if gamma.shape[0] == weight.shape[0]:
210 _gamma = gamma.reshape(shape_list)
212 elif gamma.shape[0] == weight.shape[1]:
[all …]
|
| /third_party/ffmpeg/libavutil/ |
| D | color_utils.c | 30 double gamma; in avpriv_get_gamma_from_trc() local
40 gamma = 1.961; in avpriv_get_gamma_from_trc()
44 gamma = 2.2; in avpriv_get_gamma_from_trc()
47 gamma = 2.8; in avpriv_get_gamma_from_trc()
50 gamma = 1.0; in avpriv_get_gamma_from_trc()
53 gamma = 0.0; // Unknown value representation in avpriv_get_gamma_from_trc()
55 return gamma; in avpriv_get_gamma_from_trc()
|
| /third_party/mindspore/mindspore/ccsrc/backend/kernel_compiler/gpu/cuda_impl/ |
| D | layer_norm_grad_impl.cu | 112 const T *var, const T *gamma) { in InputThreadReduce() argument
123 T v1 = dy[pos] * gamma[gamma_offset]; in InputThreadReduce()
136 const half *mean, const half *var, const half *gamma) { in InputThreadReduce() argument
147 half v1 = dy[pos] * gamma[gamma_offset]; in InputThreadReduce()
191 … const T *dy, const T *x, const T *mean, const T *var, const T *gamma, T *dx, in InputProp() argument
196 T v1 = dy[pos] * gamma[gamma_offset]; in InputProp()
206 … const half *dy, const half *x, const half *mean, const half *var, const half *gamma, in InputProp() argument
211 half v1 = dy[pos] * gamma[gamma_offset]; in InputProp()
222 const T *x, const T *mean, const T *var, const T *gamma, T *dx) { in InputPropKernel() argument
228 … InputThreadReduce(row, col_dim, param_dim, epsilon, &sum1, &sum2, &sum3, dy, x, mean, var, gamma); in InputPropKernel()
[all …]
|
| D | layer_norm_impl.cu | 104 … const T *share_mem, const T *gamma, const T *beta, const T epsilon, T *y) { in LayerNorm() argument
108 y[pos] = (x[pos] - share_mem[0]) / sqrt(share_mem[1] + epsilon) * gamma[i] + beta[i]; in LayerNorm()
114 … const half *share_mem, const half *gamma, const half *beta, const half epsilon, in LayerNorm() argument
119 y[pos] = (x[pos] - share_mem[0]) / hsqrt(share_mem[1] + epsilon) * gamma[i] + beta[i]; in LayerNorm()
125 const T *gamma, const T *beta, T *y, T *mean_addr, T *var_addr) { in LayerNormKernel() argument
138 LayerNorm(row, col_dim, param_dim, x, share_mem.addr(), gamma, beta, epsilon, y); in LayerNormKernel()
144 const T *gamma, const T *beta, T *y, T *mean, T *var, cudaStream_t stream) { in LayerNorm() argument
148 …ow_dim, thread_per_block, share_mem_size, stream>>>(row_dim, col_dim, param_dim, epsilon, x, gamma, in LayerNorm()
153 … const float *x, const float *gamma, const float *beta, float *y, float *mean, float *var,
156 … const half *x, const half *gamma, const half *beta, half *y, half *mean, half *var,
|
| /third_party/mesa3d/docs/ |
| D | xlibdriver.rst | 84 displayed intensities, there is a gamma correction feature in Mesa. Some
85 systems, such as Silicon Graphics, support gamma correction in hardware
86 (man gamma) so you won't need to use Mesa's gamma facility. Other
87 systems, however, may need gamma adjustment to produce images which look
92 is the red gamma value, Gg is the green gamma value, Gb is the blue
93 gamma value and G is one gamma value to use for all three channels. Each
95 defaults are all 1.0, effectively disabling gamma correction. Examples:
100 % export MESA_GAMMA="2.0" # same gamma for R,G,B
102 The ``demos/gamma.c`` program in mesa/demos repository may help you to
103 determine reasonable gamma value for your display. With correct gamma
[all …]
|
| /third_party/mindspore/tests/st/model_zoo_tests/yolov3_darknet53/src/ |
| D | lr_scheduler.py | 29 def warmup_step_lr(lr, lr_epochs, steps_per_epoch, warmup_epochs, max_epoch, gamma=0.1): argument
48 lr = lr * gamma**milestones_steps_counter[i]
54 def multi_step_lr(lr, milestones, steps_per_epoch, max_epoch, gamma=0.1): argument
55 return warmup_step_lr(lr, milestones, steps_per_epoch, 0, max_epoch, gamma=gamma)
58 def step_lr(lr, epoch_size, steps_per_epoch, max_epoch, gamma=0.1): argument
63 return multi_step_lr(lr, lr_epochs, steps_per_epoch, max_epoch, gamma=gamma)
155 gamma=args.lr_gamma,
|