Lines Matching full:parameter
5 Given parameter blocks $\left[x_{i_1}, \hdots , x_{i_k}\right]$, a
27 The signature of the function (number and sizes of input parameter blocks and number of outputs)
28 is stored in \texttt{parameter\_block\_sizes\_} and \texttt{num\_residuals\_} respectively. User
35 \texttt{parameters} is an array of pointers to arrays containing the various parameter blocks. parameters has the same number of elements as parameter\_block\_sizes\_. Parameter blocks are in the same order as parameter\_block\_sizes\_.
41 \texttt{jacobians} is an array of size \texttt{parameter\_block\_sizes\_} containing pointers to storage for Jacobian matrices corresponding to each parameter block. The Jacobian matrices are in the same order as \texttt{parameter\_block\_sizes\_}. \texttt{jacobians[i]} is an array that contains \texttt{num\_residuals\_} $\times$ \texttt{parameter\_block\_sizes\_[i]} elements. Each Jacobian matrix is stored in row-major order, i.e.,
44 \texttt{jacobians[i][r * parameter\_block\_size\_[i] + c]} =
49 If \texttt{jacobians} is \texttt{NULL}, then no derivatives are returned; this is the case when computing cost only. If \texttt{jacobians[i]} is \texttt{NULL}, then the Jacobian matrix corresponding to the $i^{\textrm{th}}$ parameter block must not be returned, this is the case when the a parameter block is marked constant.
52 If the size of the parameter blocks and the size of the residual vector is known at compile time (this is the common case), Ceres provides \texttt{SizedCostFunction}, where these values can be specified as template parameters.
70 the template parameter \texttt{T}. The autodiff framework substitutes appropriate
106 input parameters, then the third input parameter would come after \texttt{y}. The
107 output is always the last parameter, and is also a pointer to an array. In
139 instead of passing a dimension parameter for {\em every parameter block}. In the
149 parameter. The numeric differentiation wrapper will fill in the jacobians array
171 where \texttt{MyCostFunction} has 1 residual and 2 parameter blocks with sizes 4 and 8
261 Let us consider a problem with a single problem and a single parameter
335 \texttt{GlobalSize} is the dimension of the ambient space in which the parameter
357 \texttt{SubsetParameterization} generalizes this construction to hold any part of a parameter block constant.
416 For example a problem containing 3 parameter blocks of sizes 3, 4 and 5
430 \texttt{AddResidualBlock} as the name implies, adds a residual block to the problem. It adds a cost function, an optional loss function, and connects the cost function to a set of parameter blocks.
434 parameter blocks it expects. The function checks that these match
435 the sizes of the parameter blocks listed in \texttt{parameter\_blocks}. The
440 The user has the option of explicitly adding the parameter blocks
442 checking; however, \texttt{AddResidualBlock} implicitly adds the parameter
460 \texttt{AddParameterBlock} explicitly adds a parameter block to the \texttt{Problem}. Optionally it allows the user to associate a LocalParameterization object with the parameter block too. Repeated calls with the same arguments are ignored. Repeated
463 You can set any parameter block to be constant using
471 In fact you can set any number of parameter blocks to be constant, and Ceres is smart enough to figure out what part of the problem you have constructed depends on the parameter blocks that are free to change and only spends time solving it. So for example if you constructed a problem with a million parameter blocks and 2 million residual blocks, but then set all but one parameter blocks to be constant and say only 10 residual blocks depend on this one non-constant parameter block. Then the computational effort Ceres spends in solving this problem will be the same if you had defined a problem with one parameter block and 10 residual blocks.
477 do this by setting the corresponding enums in the \texttt{Options} struct. Even though \texttt{Problem} takes ownership of these pointers, it does not preclude the user from re-using them in another residual or parameter block. The destructor takes care to call
