| /external/aac/libFDK/include/ |
| FDK_trigFcts.h | 142 * Returns delta x residual.
146 FIXP_DBL residual; local
152 residual = fMult(x, FL2FXCONST_DBL(1.0/M_PI));
153 s = ((LONG)residual) >> shift;
155 residual &= ( (1<<shift) - 1 );
156 residual = fMult(residual, FL2FXCONST_DBL(M_PI/4.0)) << 2;
157 residual <<= scale;
202 return residual;
215 FIXP_DBL residual, error0, error1, sine, cosine local
[all...] |
| /external/ceres-solver/examples/ |
| powell.cc | 62 T* residual) const {
64 residual[0] = x1[0] + T(10.0) * x2[0];
73 T* residual) const {
75 residual[0] = T(sqrt(5.0)) * (x3[0] - x4[0]);
84 T* residual) const {
86 residual[0] = (x2[0] - T(2.0) * x4[0]) * (x2[0] - T(2.0) * x4[0]);
95 T* residual) const {
97 residual[0] = T(sqrt(10.0)) * (x1[0] - x4[0]) * (x1[0] - x4[0]);
112 // Add residual terms to the problem using the using the autodiff
|
| quadratic_auto_diff.cc | 47 // A templated cost function that implements the residual r = 10 - x. The method
52 template <typename T> bool operator()(const T* const x, T* residual) const {
53 residual[0] = T(10.0) - x[0];
69 // Set up the only cost function (also known as residual). This uses
|
| circle_fit.cc | 71 // The cost for a single sample. The returned residual is related to the
82 T* residual) const {
92 // residual[0] = r - sqrt(xp*xp + yp*yp);
100 residual[0] = r*r - xp*xp - yp*yp;
|
| data_fitting.cc | 128 T* residual) const {
129 residual[0] = T(y_) - exp(m[0] * T(x_) + c[0]);
|
| /external/flac/libFLAC/include/private/ |
| lpc.h | 130 * Compute the residual signal obtained from sutracting the predicted
138 * OUT residual[0,data_len-1] residual signal
140 void FLAC__lpc_compute_residual_from_qlp_coefficients(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
141 void FLAC__lpc_compute_residual_from_qlp_coefficients_wide(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
145 void FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
146 void FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[]);
156 * Restore the original signal by summing the residual and the
159 * IN residual[0,data_len-1] residual signa
[all...] |
| fixed.h | 46 * of the residual signal for each order. The _wide() version uses
72 * Compute the residual signal obtained from sutracting the predicted
78 * OUT residual[0,data_len-1] residual signal
80 void FLAC__fixed_compute_residual(const FLAC__int32 data[], unsigned data_len, unsigned order, FLAC__int32 residual[]);
85 * Restore the original signal by summing the residual and the
88 * IN residual[0,data_len-1] residual signal
95 void FLAC__fixed_restore_signal(const FLAC__int32 residual[], unsigned data_len, unsigned order, FLAC__int32 data[]);
|
| /frameworks/av/media/libstagefright/codecs/on2/h264dec/source/ |
| h264bsd_image.h | 64 i32 residual[][16]);
|
| h264bsd_util.h | 71 /* macro to mark a residual block empty, i.e. contain zero coefficients */
72 #define MARK_RESIDUAL_EMPTY(residual) ((residual)[0] = EMPTY_RESIDUAL_INDICATOR)
73 /* macro to check if residual block is empty */
74 #define IS_RESIDUAL_EMPTY(residual) ((residual)[0] == EMPTY_RESIDUAL_INDICATOR)
|
| h264bsd_intra_prediction.h | 57 u32 h264bsdIntra16x16Prediction(mbStorage_t *pMb, u8 *data, i32 residual[][16],
60 u32 h264bsdIntraChromaPrediction(mbStorage_t *pMb, u8 *data, i32 residual[][16],
|
| /external/flac/libFLAC/ |
| fixed.c | 58 /* rbps stands for residual bits per sample
256 /* Estimate the expected number of bits per residual signal sample. */
257 /* 'total_error*' is linearly related to the variance of the residual */
318 /* Estimate the expected number of bits per residual signal sample. */
319 /* 'total_error*' is linearly related to the variance of the residual */
352 void FLAC__fixed_compute_residual(const FLAC__int32 data[], unsigned data_len, unsigned order, FLAC__int32 residual[])
359 FLAC__ASSERT(sizeof(residual[0]) == sizeof(data[0]));
360 memcpy(residual, data, sizeof(residual[0])*data_len);
364 residual[i] = data[i] - data[i-1]
[all...] |
| lpc.c | 265 void FLAC__lpc_compute_residual_from_qlp_coefficients(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[])
296 *(residual++) = *(data++) - (sum >> lp_quantization);
304 residual[i] = data[i] - (sum >> lp_quantization);
339 residual[i] = data[i] - (sum >> lp_quantization);
356 residual[i] = data[i] - (sum >> lp_quantization);
374 residual[i] = data[i] - (sum >> lp_quantization);
389 residual[i] = data[i] - (sum >> lp_quantization);
407 residual[i] = data[i] - (sum >> lp_quantization);
420 residual[i] = data[i] - (sum >> lp_quantization);
434 residual[i] = data[i] - (sum >> lp_quantization)
[all...] |
| /external/aac/libFDK/src/ |
| FDK_trigFcts.cpp | 298 FIXP_DBL residual, error, sine, cosine; local
300 residual = fixp_sin_cos_residual_inline(x, scale, &sine, &cosine);
301 error = fMult(sine, residual);
308 FIXP_DBL residual, error, sine, cosine; local
310 residual = fixp_sin_cos_residual_inline(x, scale, &sine, &cosine);
311 error = fMult(cosine, residual);
318 FIXP_DBL residual, error0, error1, sine, cosine; local
320 residual = fixp_sin_cos_residual_inline(x, scale, &sine, &cosine);
321 error0 = fMult(sine, residual);
322 error1 = fMult(cosine, residual);
[all...] |
| /external/compiler-rt/lib/ |
| divdf3.c | 138 // In either case, we are going to compute a residual of the form
150 rep_t residual; local
152 residual = (aSignificand << 53) - quotient * bSignificand;
156 residual = (aSignificand << 52) - quotient * bSignificand;
173 const bool round = (residual << 1) > bSignificand;
|
| divsf3.c | 123 // In either case, we are going to compute a residual of the form
135 rep_t residual; local
137 residual = (aSignificand << 24) - quotient * bSignificand;
141 residual = (aSignificand << 23) - quotient * bSignificand;
158 const bool round = (residual << 1) > bSignificand;
|
| /external/eigen/Eigen/src/IterativeLinearSolvers/ |
| ConjugateGradient.h | 43 VectorType residual = rhs - mat * x; //initial residual local
46 p = precond.solve(residual); //initial search direction
49 RealScalar absNew = internal::real(residual.dot(p)); // the square of the absolute value of r scaled by invM
60 residual -= alpha * tmp; // update residue
62 residualNorm2 = residual.squaredNorm();
66 z = precond.solve(residual); // approximately solve for "A z = residual"
69 absNew = internal::real(residual.dot(z)); // update the absolute value of r
|
| /external/ceres-solver/docs/ |
| curvefitting.tex | 10 We begin by defining a templated object to evaluate the residual. There will be a residual for each observation.
19 T* residual) const {
20 residual[0] = T(y_) - exp(m[0] * T(x_) + c[0]); // $y - e^{mx + c}$
30 %\caption{Templated functor to compute the residual for the exponential model fitting problem. Note that one instance of the functor is responsible for computing the residual for one observation.}
|
| helloworld.tex | 11 Let us write this problem as a non-linear least squares problem by defining the scalar residual function $f_1(x) = 10 - x$. Then $F(x) = [f_1(x)]$ is a residual vector with exactly one component.
13 When solving a problem with Ceres, the first thing to do is to define a subclass of \texttt{CostFunction}. It is responsible for computing the value of the residual function and its derivative (also known as the Jacobian) with respect to $x$.
33 \texttt{SimpleCostFunction} is provided with an input array of parameters, an output array for residuals and an optional output array for Jacobians. In our example, there is just one parameter and one residual and this is known at compile time, therefore we can save some code and instead of inheriting from \texttt{CostFunction}, we can instaed inherit from the templated \texttt{SizedCostFunction} class.
36 The \texttt{jacobians} array is optional, \texttt{Evaluate} is expected to check when it is non-null, and if it is the case then fill it with the values of the derivative of the residual function. In this case since the residual function is linear, the Jacobian is constant.
38 Once we have a way of computing the residual vector, it is now time to construct a Non-linear least squares problem using it and have Ceres solve it.
|
| faq.tex | 21 In most problems there is a natural parameter block structure, as there is a semantic meaning associated with groups of scalars -- mean vector of a distribution, color of a pixel etc. To group two scalar variables, ask yourself if residual blocks will always use these two variables together. If the answer is yes, then the two variables belong to the same parameter block.
28 While it is often the case that problems have a natural blocking of parameters into parameter blocks, it is not always clear what a good residual block structure is. One rule of thumb for non-linear least squares problems since they often come from data fitting problems is to create one residual block per observation. So if you are solving a Structure from Motion problem, one 2 dimensional residual block per 2d image projection is a good idea.
30 The flips side is that sometimes, when modeling the problem it is tempting to group a large number of residuals together into a single residual block as it reduces the number of CostFunctions you have to define.
32 For example consider the following residual block of size 18 which depends on four parameter blocks of size 4 each. Shown below is the Jacobian structure of this residual block, the numbers in the columns indicate the size, and the numbers in the rows show a grouping of the matrix that best capture its sparsity structure. \texttt{X} indicates a non-zero block, the rest of the blocks are zero.
45 Notice that out of the 20 cells, only 8 are non-zero, in fact out of the 288 entries only 48 entries are non-zero, thus we are hiding substantial sparsity from the solver, and using up much more memory. It is much better to break this up into 5 residual blocks. One residual block of size 2 that depends on all four parameter block and four residual blocks of size 4 each that depend on one parameter block at a time
[all...] |
| reference-overview.tex | 10 The term $ \rho_i\left(\left\|f_i\left(x_{i_1},\hdots,x_{i_k}\right)\right\|^2\right)$ is known as a Residual Block. A Ceres problem is a collection of residual blocks, each of which depends on a subset of the parameter blocks.
14 \item{Modeling} Define parameter blocks and residual blocks and build a \texttt{Problem} object containing them.
|
| powell.tex | 14 \texttt{CostFunction} objects that compute the residual and Jacobians. \eg the following code shows the implementation for $f_4(x)$.
41 With its automatic differentiation support, Ceres allows you to define templated objects/functors that will compute the residual and it takes care of computing the Jacobians as needed and filling the \texttt{jacobians} arrays with them. For example, for $f_4(x)$ we define
47 T* residual) const {
49 residual[0] = T(sqrt(10.0)) * (x1[0] - x4[0]) * (x1[0] - x4[0]);
57 some type \texttt{T}. The reason for using templates here is because Ceres will call \texttt{F4::operator<T>()}, with $\texttt{T=double}$ when just the residual is needed, and with a special type $T=\texttt{Jet}$ when the Jacobians are needed.
65 // Add residual terms to the problem using the using the autodiff
78 \texttt{AutoDiffCostFunction} with \texttt{F1}, \texttt{F2}, \texttt{F3} and \texttt{F4} as template parameters. Second, each \texttt{ResidualBlock} only depends on the two parameters that the corresponding residual object depends on and not on all four parameters.
|
| /external/ceres-solver/internal/ceres/ |
| gradient_checking_cost_function_test.cc | 149 double residual; local
154 // Since residual is one dimensional the jacobians have the same
174 &residual,
176 EXPECT_EQ(original_residual, residual);
205 double residual; local
208 // Since residual is one dimensional the jacobians have the same size as the
233 &residual,
251 &residual,
|
| levenberg_marquardt_strategy_test.cc | 121 double residual = 1.0; local
151 TrustRegionStrategy::Summary summary = lms.ComputeStep(pso, &dsm, &residual, x);
|
| system_test.cc | 158 // solutions by comparing their residual vectors. We do not
171 << "Not close enough residual:" << j
229 T* residual) const {
231 *residual = *x1 + T(10.0) * *x2;
240 T* residual) const {
242 *residual = T(sqrt(5.0)) * (*x3 - *x4);
251 T* residual) const {
253 residual[0] = (x2[0] - T(2.0) * x4[0]) * (x2[0] - T(2.0) * x4[0]);
262 T* residual) const {
264 residual[0] = T(sqrt(10.0)) * (x1[0] - x4[0]) * (x1[0] - x4[0])
[all...] |
| /frameworks/av/media/libstagefright/codecs/m4v_h263/dec/src/ |
| vlc_decode.h | 97 PV_STATUS PV_DeScaleMVD(int f_code, int residual, int vlc_code_mag, MOT *vector);
|
