📄 pt_print.c
字号:
param[rowIdx*nCols + colIdx] = newValue[rowIdx*nCols + colIdx];
}
}
break;
case rt_MATRIX_COL_MAJOR:
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
for(colIdx = 0; colIdx < nCols; colIdx++) {
param[colIdx*nRows + rowIdx] = newValue[colIdx*nRows + rowIdx];
}
}
break;
default:
return(1);
}
}
break;
case SS_BOOLEAN:
for(paramIdx = 0; paramIdx < nParams; paramIdx++) {
boolean_T *param = (boolean_T *)(pMap[mapOffset + paramIdx]);
boolean_T *newValue = (boolean_T *) _newValue; /* param's new value */
switch( ptinfoGetClass(ptRec) ) {
case rt_SCALAR:
*param = *newValue;
break;
case rt_VECTOR:
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
param[rowIdx] = newValue[rowIdx];
}
break;
case rt_MATRIX_ROW_MAJOR:
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
for(colIdx = 0; colIdx < nCols; colIdx++) {
param[rowIdx*nCols + colIdx] = newValue[rowIdx*nCols + colIdx];
}
}
break;
case rt_MATRIX_COL_MAJOR:
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
for(colIdx = 0; colIdx < nCols; colIdx++) {
param[colIdx*nRows + rowIdx] = newValue[colIdx*nRows + rowIdx];
}
}
break;
default:
return(1);
}
}
break;
default:
/* unknown data type */
return(1);
}
return(0);
}
/* =============================================================================
* Function:
* rt_PrintPTRec
*
* Abstract:
* This function prints and then tests the parameter tuning record which
* represent either a Simulink block parameter or a MATLAB variable. The
* routine illustrates the usage of the parameter tuning record. All
* Simulink data types are supported. Scalar, Vector, 1-3D matrix is
* supported.
*/
int_T rt_PrintPTRec(void *mpi,
ParameterTuning *ptRec)
{
uint_T paramIdx;
uint_T rowIdx;
uint_T colIdx;
uint_T nRows = ptinfoGetNumRows(ptRec);
uint_T nCols = ptinfoGetNumCols(ptRec);
uint_T nParams = ptinfoGetNumInstances(ptRec);
uint_T mapOffset = ptinfoGetParametersOffset(ptRec);
ModelMappingInfo *MMI = (ModelMappingInfo *) mpi;
void * const *pMap = mmiGetParametersMap(MMI);
switch (ptinfoGetDataTypeEnum(ptRec)) {
case SS_DOUBLE:
/* print each instance to standard output */
for(paramIdx = 0; paramIdx < nParams; paramIdx++) {
real_T *param = (real_T *)(pMap[mapOffset + paramIdx]);
switch (ptinfoGetClass(ptRec)) {
case rt_SCALAR:
printf("Scalar (instance %d):\n", paramIdx);
printf("\t%G\n", *param);
break;
case rt_VECTOR:
printf("Column Vector[%d] (instance %d):\n", nCols, paramIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%d: %G\n", colIdx, param[colIdx]);
}
break;
case rt_MATRIX_ROW_MAJOR:
printf("Matrix[%d][%d] (row major, instance %d):\n", nRows, nCols, paramIdx);
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
printf("\trow %d:", rowIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%G", param[rowIdx*nCols + colIdx]);
}
putchar('\n');
}
break;
case rt_MATRIX_COL_MAJOR:
printf("Matrix[%d][%d] (column major, instance %d):\n", nRows, nCols, paramIdx);
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
printf("\trow %d:", rowIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%G", param[colIdx*nRows + rowIdx]);
}
putchar('\n');
}
break;
case rt_MATRIX_COL_MAJOR_ND:
if (ptinfoGetNumDimensions(ptRec) == 3) {
uint_T dim1Idx, dim2Idx, dim3Idx;
uint_T const *dimsMap = mmiGetDimensionsMap(MMI);
uint_T dimsOffset = ptinfoGetDimensionsOffset(ptRec);
uint_T dim1Size = dimsMap[dimsOffset+0];
uint_T dim2Size = dimsMap[dimsOffset+1];
uint_T dim3Size = dimsMap[dimsOffset+2];
printf("Matrix[%d][%d][%d] (3D Matrix, instance %d):\n",
dim1Size, dim2Size, dim3Size, paramIdx);
for (dim3Idx = 0; dim3Idx < dim3Size; dim3Idx++) {
printf("ans(:,:,%d) =\n", dim3Idx+1);
for (dim1Idx = 0; dim1Idx < dim1Size; dim1Idx++) {
for (dim2Idx = 0; dim2Idx < dim2Size; dim2Idx++) {
uint_T idx =
dim1Idx +
dim1Size * dim2Idx +
dim1Size * dim2Size * dim3Idx;
printf("%15.9G", param[idx]);
}
putchar('\n');
}
putchar('\n');
}
}
break;
default:
return(1);
}
/* set the parameter to itself (to test rt_ModifyParameter) */
if(ptinfoGetClass(ptRec) != rt_MATRIX_COL_MAJOR_ND &&
rt_ModifyParameter(mpi, ptRec, (void *)param)) {
fprintf(stderr, "Problem with rt_ModifyParameter\n");
return(1);
}
}
break;
case SS_SINGLE:
/* print each instance to standard output */
for(paramIdx = 0; paramIdx < nParams; paramIdx++) {
real32_T *param = (real32_T *)(pMap[mapOffset + paramIdx]);
switch( ptinfoGetClass(ptRec) ) {
case rt_SCALAR:
printf("Scalar (instance %d):\n", paramIdx);
printf("\t%G\n", *param);
break;
case rt_VECTOR:
printf("Column Vector[%d] (instance %d):\n", nCols, paramIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%d: %G\n", colIdx, param[colIdx]);
}
break;
case rt_MATRIX_ROW_MAJOR:
printf("Matrix[%d][%d] (row major, instance %d):\n", nRows, nCols, paramIdx);
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
printf("\trow %d:", rowIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%G", param[rowIdx*nCols + colIdx]);
}
putchar('\n');
}
break;
case rt_MATRIX_COL_MAJOR:
printf("Matrix[%d][%d] (column major, instance %d):\n", nRows, nCols, paramIdx);
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
printf("\trow %d:", rowIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%G", param[colIdx*nRows + rowIdx]);
}
putchar('\n');
}
break;
default:
return(1);
}
/* set the parameter to itself (to test rt_ModifyParameter) */
if(rt_ModifyParameter(mpi, ptRec, (void *)param)) {
fprintf(stderr, "Problem with rt_ModifyParameter\n");
return(1);
}
}
break;
case SS_INT8:
/* print each instance to standard output */
for(paramIdx = 0; paramIdx < nParams; paramIdx++) {
int8_T *param = (int8_T *)(pMap[mapOffset + paramIdx]);
switch( ptinfoGetClass(ptRec) ) {
case rt_SCALAR:
printf("Scalar (instance %d):\n", paramIdx);
printf("\t%hi\n", (int_T)*param);
break;
case rt_VECTOR:
printf("Column Vector[%d] (instance %d):\n", nCols, paramIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%d: %hi\n", colIdx, (int_T)param[colIdx]);
}
break;
case rt_MATRIX_ROW_MAJOR:
printf("Matrix[%d][%d] (row major, instance %d):\n", nRows, nCols, paramIdx);
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
printf("\trow %d:", rowIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%hi", (int_T)param[rowIdx*nCols + colIdx]);
}
putchar('\n');
}
break;
case rt_MATRIX_COL_MAJOR:
printf("Matrix[%d][%d] (column major, instance %d):\n", nRows, nCols, paramIdx);
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
printf("\trow %d:", rowIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%hi", (int_T)param[colIdx*nRows + rowIdx]);
}
putchar('\n');
}
break;
default:
return(1);
}
/* set the parameter to itself (to test rt_ModifyParameter) */
if(rt_ModifyParameter(mpi, ptRec, (void *)param)) {
fprintf(stderr, "Problem with rt_ModifyParameter\n");
return(1);
}
}
break;
case SS_UINT8:
/* print each instance to standard output */
for(paramIdx = 0; paramIdx < nParams; paramIdx++) {
uint8_T *param = (uint8_T *)(pMap[mapOffset + paramIdx]);
switch( ptinfoGetClass(ptRec) ) {
case rt_SCALAR:
printf("Scalar (instance %d):\n", paramIdx);
printf("\t%hu\n", (int_T)*param);
break;
case rt_VECTOR:
printf("Column Vector[%d] (instance %d):\n", nCols, paramIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%d: %hu\n", colIdx, (int_T)param[colIdx]);
}
break;
case rt_MATRIX_ROW_MAJOR:
printf("Matrix[%d][%d] (row major, instance %d):\n", nRows, nCols, paramIdx);
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
printf("\trow %d:", rowIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%hu", (int_T)param[rowIdx*nCols + colIdx]);
}
putchar('\n');
}
break;
case rt_MATRIX_COL_MAJOR:
printf("Matrix[%d][%d] (column major, instance %d):\n", nRows, nCols, paramIdx);
for(rowIdx = 0; rowIdx < nRows; rowIdx++) {
printf("\trow %d:", rowIdx);
for(colIdx = 0; colIdx < nCols; colIdx++) {
printf("\t%hu", (int_T)param[colIdx*nRows + rowIdx]);
}
putchar('\n');
}
break;
default:
return(1);
}
/* set the parameter to itself (to test rt_ModifyParameter) */
if(rt_ModifyParameter(mpi, ptRec, (void *)param)) {
fprintf(stderr, "Problem with rt_ModifyParameter\n");
return(1);
}
}
break;
case SS_INT16:
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -