自学教程：C++ ssSetOptions函数代码示例

static void mdlSetWorkWidths_c20_adcs_v15_integral_Power_nom(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable("adcs_v15_integral_Power_nom",      "adcs_v15_integral_Power_nom",20);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop("adcs_v15_integral_Power_nom",                "adcs_v15_integral_Power_nom",20,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(      "adcs_v15_integral_Power_nom","adcs_v15_integral_Power_nom",20,      "gatewayCannotBeInlinedMultipleTimes"));    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,"adcs_v15_integral_Power_nom",        "adcs_v15_integral_Power_nom",20,2);      sf_mark_chart_reusable_outputs(S,"adcs_v15_integral_Power_nom",        "adcs_v15_integral_Power_nom",20,1);    }    sf_set_rtw_dwork_info(S,"adcs_v15_integral_Power_nom",                          "adcs_v15_integral_Power_nom",20);    ssSetHasSubFunctions(S,!(chartIsInlinable));    ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  } else {    sf_set_sfun_dwork_info(S);  }  ssSetChecksum0(S,(1438108338U));  ssSetChecksum1(S,(2004638737U));  ssSetChecksum2(S,(2564207442U));  ssSetChecksum3(S,(1506645853U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);}

/* Function: mdlInitializeSizes =============================================== * Abstract: *   Setup sizes of the various vectors. */static void mdlInitializeSizes(SimStruct *S){    ssSetNumSFcnParams(S, 0);     if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {	 return; /* Parameter mismatch will be reported by Simulink */     }    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 1)) return;    ssSetInputPortWidth(S, 0, 1);    ssSetInputPortDataType(S, 0, DYNAMICALLY_TYPED );    ssSetInputPortDirectFeedThrough(S, 0, 1);    ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, 1);    ssSetOutputPortDataType(S, 0, DYNAMICALLY_TYPED);    ssSetOutputPortComplexSignal(S, 0, COMPLEX_NO);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE);      ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE |                     SS_OPTION_USE_TLC_WITH_ACCELERATOR |                     SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME |                     SS_OPTION_NONVOLATILE |                         SS_OPTION_WORKS_WITH_CODE_REUSE));        ssSupportsMultipleExecInstances(S, true);}

/* Function: mdlInitializeSizes =============================================== * Abstract: *    The sizes information is used by Simulink to determine the S-function *    block's characteristics (number of inputs, outputs, states, etc.). */static void mdlInitializeSizes(SimStruct *S) {  ssSetNumSFcnParams(S, 3);  /* Number of expected parameters */    // Parameter mismatch will be reported by Simulink  if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) {    mdlCheckParameters(S);    if (ssGetErrorStatus(S) != NULL) {      return;    }  } else {    return; /* Parameter mismatch will be reported by Simulink */  }  ssSetSFcnParamTunable(S, 0, 0);  ssSetNumContStates(S, 0);  ssSetNumDiscStates(S, 0);  if (!ssSetNumInputPorts(S, 0)) return;  //  ssSetInputPortDirectFeedThrough(S, 0, 1);        if (!ssSetNumOutputPorts(S, 1)) return;  ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED);    ssSetNumSampleTimes(S, 1);  ssSetNumPWork(S, 2); // reserve element in the pointers vector  ssSetNumModes(S, 0); // to store a C++ object  ssSetNumNonsampledZCs(S, 0);  ssSetSimStateCompliance(S, USE_CUSTOM_SIM_STATE);  ssSetOptions(S, 0);}

static void mdlInitializeSizes(SimStruct * S) {        ssSetNumSFcnParams(S, NUMBER_OF_ARGS);    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        sprintf(msg, "Wrong number of input arguments passed./n"        "%d arguments are expected/n", NUMBER_OF_ARGS);        ssSetErrorStatus(S, msg);        return;    }        if ( mxGetM(NO_BYTES_ARG)!=1 | mxGetN(NO_BYTES_ARG)!=1 ) {        sprintf(msg,"Output port width argument must be a scalar/n");        ssSetErrorStatus(S,msg);        return;    }        ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);        ssSetNumOutputPorts(S, 2);    ssSetOutputPortWidth(S, 0, PORT_WIDTH);    ssSetOutputPortDataType(S, 0, SS_UINT8);        ssSetOutputPortWidth(S, 1, 1);      /* received flag */        ssSetNumInputPorts(S, 0);        ssSetNumSampleTimes(S, 1);        ssSetNumRWork(S, NO_R_WORKS);    ssSetNumIWork(S, NO_I_WORKS);    ssSetNumPWork(S, NO_P_WORKS);        ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);        ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE | SS_OPTION_PLACE_ASAP);}

static void mdlSetWorkWidths_c25_BuckBoost1(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    mxArray *infoStruct = load_BuckBoost1_optimization_info();    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct,      25);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(),                infoStruct,25,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S,      sf_get_instance_specialization(),infoStruct,25,      "gatewayCannotBeInlinedMultipleTimes"));    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(),        infoStruct,25,2);      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),        infoStruct,25,1);    }    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,25);    ssSetHasSubFunctions(S,!(chartIsInlinable));  } else {  }  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  ssSetChecksum0(S,(4024182556U));  ssSetChecksum1(S,(1214747070U));  ssSetChecksum2(S,(4268353638U));  ssSetChecksum3(S,(1673958578U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);  ssSupportsMultipleExecInstances(S,1);}

static void mdlSetWorkWidths_c23_ArregloSeisPorSeis(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    mxArray *infoStruct = load_ArregloSeisPorSeis_optimization_info();    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct,      23);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(),                infoStruct,23,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S,      sf_get_instance_specialization(),infoStruct,23,      "gatewayCannotBeInlinedMultipleTimes"));    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL);      ssSetInputPortOptimOpts(S, 2, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(),        infoStruct,23,3);      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),        infoStruct,23,1);    }    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,23);    ssSetHasSubFunctions(S,!(chartIsInlinable));  } else {  }  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  ssSetChecksum0(S,(2281720516U));  ssSetChecksum1(S,(4132229721U));  ssSetChecksum2(S,(175296108U));  ssSetChecksum3(S,(991465833U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);}

/* Function: mdlInitializeSizes =============================================== * Abstract: *   Setup sizes of the various vectors. */static void mdlInitializeSizes(SimStruct *S){    DECL_AND_INIT_DIMSINFO(inputDimsInfo);    DECL_AND_INIT_DIMSINFO(outputDimsInfo);    ssSetNumSFcnParams(S, NPARAMS);     if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {	 return; /* Parameter mismatch will be reported by Simulink */     }    ssSetNumContStates(S, NUM_CONT_STATES);    ssSetNumDiscStates(S, NUM_DISC_STATES);    if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;    /*Input Port 0 */    inputDimsInfo.width = INPUT_0_WIDTH;    ssSetInputPortDimensionInfo(S, 0, &inputDimsInfo);    ssSetInputPortMatrixDimensions(  S ,0, INPUT_0_WIDTH, INPUT_DIMS_0_COL);    ssSetInputPortFrameData(S, 0, IN_0_FRAME_BASED);    ssSetInputPortDataType(S, 0, SS_DOUBLE);    ssSetInputPortComplexSignal(S, 0, INPUT_0_COMPLEX);    ssSetInputPortDirectFeedThrough(S, 0, INPUT_0_FEEDTHROUGH);    ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/    if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    /* Take care when specifying exception free code - see sfuntmpl_doc.c */    ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE |		     SS_OPTION_WORKS_WITH_CODE_REUSE));}

static void mdlSetWorkWidths_c31_adcs_v15_integral_Power_dist(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable("adcs_v15_integral_Power_dist",      "adcs_v15_integral_Power_dist",31);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop("adcs_v15_integral_Power_dist",                "adcs_v15_integral_Power_dist",31,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(      "adcs_v15_integral_Power_dist","adcs_v15_integral_Power_dist",31,      "gatewayCannotBeInlinedMultipleTimes"));    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,"adcs_v15_integral_Power_dist",        "adcs_v15_integral_Power_dist",31,2);      sf_mark_chart_reusable_outputs(S,"adcs_v15_integral_Power_dist",        "adcs_v15_integral_Power_dist",31,1);    }    sf_set_rtw_dwork_info(S,"adcs_v15_integral_Power_dist",                          "adcs_v15_integral_Power_dist",31);    ssSetHasSubFunctions(S,!(chartIsInlinable));    ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  } else {    sf_set_sfun_dwork_info(S);  }  ssSetChecksum0(S,(879351951U));  ssSetChecksum1(S,(3790118364U));  ssSetChecksum2(S,(4250711417U));  ssSetChecksum3(S,(1688137038U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);}

static void mdlInitializeSizes(SimStruct *S){    int i;    ssSetNumSFcnParams(S, NPARAMS);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        /* Return if number of expected != number of actual parameters */        return;    }    for (i = 0; i < NPARAMS; i++)        ssSetSFcnParamTunable(S, i, 0);    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 2)) return;    ssSetInputPortWidth(S, 0, 7);    ssSetInputPortRequiredContiguous(S, 0, true);    ssSetInputPortDirectFeedThrough(S, 0, 1);    ssSetInputPortWidth(S, 1, DYNAMICALLY_SIZED);    ssSetInputPortRequiredContiguous(S, 1, true);    ssSetInputPortDirectFeedThrough(S, 1, 1);    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, 12);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 5);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    ssSetOptions(S,            SS_OPTION_WORKS_WITH_CODE_REUSE |            SS_OPTION_USE_TLC_WITH_ACCELERATOR);}

static void mdlSetWorkWidths_c1_QPSK_Transmit_v5_w_FIFO(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    mxArray *infoStruct = load_QPSK_Transmit_v5_w_FIFO_optimization_info();    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct,      1);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(),                infoStruct,1,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S,      sf_get_instance_specialization(),infoStruct,1,      "gatewayCannotBeInlinedMultipleTimes"));    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(),        infoStruct,1,1);      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),        infoStruct,1,1);    }    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,1);    ssSetHasSubFunctions(S,!(chartIsInlinable));  } else {  }  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  ssSetChecksum0(S,(1382727465U));  ssSetChecksum1(S,(1826769868U));  ssSetChecksum2(S,(2925688491U));  ssSetChecksum3(S,(2188971603U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);  ssSupportsMultipleExecInstances(S,1);}

static void mdlSetWorkWidths_c19_adcs_v15_integral_Power(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable("adcs_v15_integral_Power",      "adcs_v15_integral_Power",19);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop("adcs_v15_integral_Power",                "adcs_v15_integral_Power",19,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop("adcs_v15_integral_Power",      "adcs_v15_integral_Power",19,"gatewayCannotBeInlinedMultipleTimes"));    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,"adcs_v15_integral_Power",        "adcs_v15_integral_Power",19,2);      sf_mark_chart_reusable_outputs(S,"adcs_v15_integral_Power",        "adcs_v15_integral_Power",19,4);    }    sf_set_rtw_dwork_info(S,"adcs_v15_integral_Power","adcs_v15_integral_Power",                          19);    ssSetHasSubFunctions(S,!(chartIsInlinable));    ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  } else {    sf_set_sfun_dwork_info(S);  }  ssSetChecksum0(S,(2325183243U));  ssSetChecksum1(S,(1124782313U));  ssSetChecksum2(S,(3778958781U));  ssSetChecksum3(S,(3844299426U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);}

/* Function: mdlInitializeSizes =============================================== * Abstract: *    The sizes information is used by Simulink to determine the S-function *    block's characteristics (number of inputs, outputs, states, etc.). */static void mdlInitializeSizes(SimStruct *S){    ssSetNumSFcnParams(S, 1);		// Number of expected parameters    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        return;						// Parameter mismatch will be reported by Simulink    }    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 1);		// Usado para actualizar las entradas    if (!ssSetNumInputPorts(S,1)) return;	ssSetInputPortWidth( S, 0, NENTRADAS );	ssSetInputPortRequiredContiguous( S, 0, 1 );	//for( k=0; k<NENTRADAS; k++ )	//{	//	ssSetInputPortWidth(S,k,1);	//	ssSetInputPortDirectFeedThrough(S,k,1);		// Existen llamadas de la entrada en la funcion mdlOutputs	//	ssSetInputPortRequiredContiguous(S,k,1);	// sacado del ejemplo (?)	//}        if (!ssSetNumOutputPorts(S,1)) return;	ssSetOutputPortWidth( S, 0, NSALIDAS );	//for( k=0; k<NSALIDAS; k++ )	//{	//    ssSetOutputPortWidth(S, k, 1);	//}    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);			// reserve element in the float vector    ssSetNumIWork(S, 0);			// reserve element in the int vector    ssSetNumPWork(S, 1);			// reserve element in the pointers vector    ssSetNumModes(S, 0);			// to store a C++ object    ssSetNumNonsampledZCs(S, 0);	// number of states for which a block detects zero crossings    ssSetOptions(S, 0);				// set the simulation options that this block implements}

static void mdlSetWorkWidths_c8_WorkstationModel(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    mxArray *infoStruct = load_WorkstationModel_optimization_info();    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct,      8);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(),                infoStruct,8,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S,      sf_get_instance_specialization(),infoStruct,8,      "gatewayCannotBeInlinedMultipleTimes"));    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(),        infoStruct,8,2);      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),        infoStruct,8,1);    }    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,8);    ssSetHasSubFunctions(S,!(chartIsInlinable));  } else {  }  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  ssSetChecksum0(S,(357763525U));  ssSetChecksum1(S,(3399102434U));  ssSetChecksum2(S,(2626699010U));  ssSetChecksum3(S,(3249110271U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);}

static void mdlSetWorkWidths_c14_test(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    mxArray *infoStruct = load_test_optimization_info();    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct,      14);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(),                infoStruct,14,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S,      sf_get_instance_specialization(),infoStruct,14,      "gatewayCannotBeInlinedMultipleTimes"));    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(),        infoStruct,14,1);      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),        infoStruct,14,1);    }    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,14);    ssSetHasSubFunctions(S,!(chartIsInlinable));  } else {  }  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  ssSetChecksum0(S,(3719952874U));  ssSetChecksum1(S,(3080967292U));  ssSetChecksum2(S,(1156275868U));  ssSetChecksum3(S,(83615345U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);  ssSupportsMultipleExecInstances(S,1);}

static void mdlInitializeSizes(SimStruct *S){    int i;    ssSetNumSFcnParams(S, 4);  /* B,x0,U,P Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S))        return;    else    {        if (CheckPar(S))            return;    }    ssSetNumContStates(S, (int) B(S,"CStates"));    ssSetNumDiscStates(S, (int) B(S,"DStates"));    if (!ssSetNumInputPorts(S, 1)) return;    ssSetInputPortWidth(S, 0, (int)  (U(S,"Number")+B(S,"Setpoints")));    ssSetInputPortDirectFeedThrough(S, 0, (int) B(S,"Direct"));    ssSetInputPortRequiredContiguous(S, 0, 1); /*direct input signal access*/    if (!ssSetNumOutputPorts(S,1)) return;    ssSetOutputPortWidth(S, 0, (int) (U(S,"Number")+B(S,"Measurements")) );    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    /* Take care when specifying exception free code - see sfuntmpl_doc.c */    ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE |                 SS_OPTION_USE_TLC_WITH_ACCELERATOR);}

/* Function: mdlInitializeSizes =============================================== * Abstract: *   Setup sizes of the various vectors. */static void mdlInitializeSizes(SimStruct *S){    DECL_AND_INIT_DIMSINFO(outputDimsInfo);    ssSetNumSFcnParams(S, NPARAMS);     if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {	 return; /* Parameter mismatch will be reported by Simulink */     }    ssSetNumContStates(S, NUM_CONT_STATES);    ssSetNumDiscStates(S, NUM_DISC_STATES);    if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;    if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;    /* Output Port 0 */    outputDimsInfo.width = OUTPUT_0_WIDTH;    ssSetOutputPortDimensionInfo(S, 0, &outputDimsInfo);    ssSetOutputPortMatrixDimensions( S ,0, OUTPUT_0_WIDTH, OUTPUT_DIMS_0_COL);    ssSetOutputPortFrameData(S, 0, OUT_0_FRAME_BASED);    ssSetOutputPortDataType(S, 0, SS_INT32);    ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    //ssSetSimulinkVersionGeneratedIn(S, "8.3");    /* Take care when specifying exception free code - see sfuntmpl_doc.c */    ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE |                     SS_OPTION_USE_TLC_WITH_ACCELERATOR | 		     SS_OPTION_WORKS_WITH_CODE_REUSE));}

/* Function: mdlInitializeSizes =============================================== * Abstract: *   Setup sizes of the various vectors. */static void mdlInitializeSizes(SimStruct *S){    DECL_AND_INIT_DIMSINFO(outputDimsInfo);    ssSetNumSFcnParams(S, NPARAMS);  /* Number of expected parameters */      #if defined(MATLAB_MEX_FILE)	if (ssGetNumSFcnParams(S) == ssGetSFcnParamsCount(S)) {	  mdlCheckParameters(S);	  if (ssGetErrorStatus(S) != NULL) {	    return;	  }	 } else {	   return; /* Parameter mismatch will be reported by Simulink */	 }      #endif    ssSetNumContStates(S, NUM_CONT_STATES);    ssSetNumDiscStates(S, NUM_DISC_STATES);    if (!ssSetNumInputPorts(S, NUM_INPUTS)) return;    if (!ssSetNumOutputPorts(S, NUM_OUTPUTS)) return;    ssSetOutputPortWidth(S, 0, OUTPUT_0_WIDTH);    ssSetOutputPortDataType(S, 0, SS_DOUBLE);    ssSetOutputPortComplexSignal(S, 0, OUTPUT_0_COMPLEX);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    /* Take care when specifying exception free code - see sfuntmpl_doc.c */    ssSetOptions(S, (SS_OPTION_EXCEPTION_FREE_CODE |                     SS_OPTION_USE_TLC_WITH_ACCELERATOR | 		     SS_OPTION_WORKS_WITH_CODE_REUSE));}

static void mdlInitializeSizes(SimStruct *S){    ssSetNumSFcnParams(S, 0);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        return;    }    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 1)) return;    ssSetInputPortWidth(S, 0, 3);    ssSetInputPortRequiredContiguous(S, 0, true);    ssSetInputPortDirectFeedThrough(S, 0, 0);    //ssSetInputPortDataType(S,0,SS_DOUBLE);    if (!ssSetNumOutputPorts(S, 1)) return;    ssSetOutputPortWidth(S, 0, 3);    ssSetNumSampleTimes(S, 1);    ssSetNumDWork(S, 2);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, 0);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    //Pointer SHM_IN    ssSetDWorkWidth(S, DVECSHMIN, 1);    ssSetDWorkDataType(S, DVECSHMIN, SS_POINTER);    //Pointer SHM_OUT    ssSetDWorkWidth(S, DVECSHMOUT, 1);    ssSetDWorkDataType(S, DVECSHMOUT, SS_POINTER);    ssSetOptions(S, 0);}

static void mdlSetWorkWidths_c3_ErdMond(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    mxArray *infoStruct = load_ErdMond_optimization_info();    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct,      3);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(),                infoStruct,3,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S,      sf_get_instance_specialization(),infoStruct,3,      "gatewayCannotBeInlinedMultipleTimes"));    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(),        infoStruct,3,1);      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),        infoStruct,3,1);    }    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,3);    ssSetHasSubFunctions(S,!(chartIsInlinable));  } else {  }  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  ssSetChecksum0(S,(3937887197U));  ssSetChecksum1(S,(3357586017U));  ssSetChecksum2(S,(2777667438U));  ssSetChecksum3(S,(527445158U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);}

static void mdlInitializeSizes(SimStruct *S){  ssSetNumSFcnParams(S,NUMSFCNPARAMS);  if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {    return; /* Parameter mismatch will be reported by Simulink */  }  ssSetNumContStates(S,NUMCONTSTATES);  ssSetNumDiscStates(S,NUMDISCSTATES);  if (!ssSetNumInputPorts(S,NUMINPUTPORTS)) return;  ssSetInputPortWidth(S,0,INPUTPORT0WIDTH);  ssSetInputPortDirectFeedThrough(S,0,FEEDTHROUGHPORT0);  if (!ssSetNumOutputPorts(S,NUMOUTPUTPORTS)) return;  ssSetOutputPortWidth(S,0,OUTPUTPORT0WIDTH);  ssSetNumSampleTimes(S,1);  ssSetNumRWork(S,0);  ssSetNumIWork(S,0);  ssSetNumPWork(S,0);  ssSetNumModes(S,0);  ssSetNumNonsampledZCs(S,0);  ssSetOptions(S,0);}

static void mdlSetWorkWidths_c10_dynamics_kinematics(SimStruct *S){  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    mxArray *infoStruct = load_dynamics_kinematics_optimization_info();    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct,      10);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(),                infoStruct,10,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S,      sf_get_instance_specialization(),infoStruct,10,      "gatewayCannotBeInlinedMultipleTimes"));    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(),        infoStruct,10,1);      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),        infoStruct,10,1);    }    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,10);    ssSetHasSubFunctions(S,!(chartIsInlinable));  } else {  }  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  ssSetChecksum0(S,(3513034449U));  ssSetChecksum1(S,(1851740193U));  ssSetChecksum2(S,(3113117094U));  ssSetChecksum3(S,(3357094068U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);}

P_6 * ( ( BlockIO_main * ) _ssGetBlockIO ( S ) ) -> B_0_16_0 ; } } staticvoid mdlInitializeSizes ( SimStruct * S ) { ssSetChecksumVal ( S , 0 ,3089498090U ) ; ssSetChecksumVal ( S , 1 , 49919693U ) ; ssSetChecksumVal ( S, 2 , 412083875U ) ; ssSetChecksumVal ( S , 3 , 3370502334U ) ; { mxArray *slVerStructMat = NULL ; mxArray * slStrMat = mxCreateString ( "simulink" ) ;char slVerChar [ 10 ] ; int status = mexCallMATLAB ( 1 , & slVerStructMat , 1, & slStrMat , "ver" ) ; if ( status == 0 ) { mxArray * slVerMat = mxGetField( slVerStructMat , 0 , "Version" ) ; if ( slVerMat == NULL ) { status = 1 ; }else { status = mxGetString ( slVerMat , slVerChar , 10 ) ; } }mxDestroyArray ( slStrMat ) ; mxDestroyArray ( slVerStructMat ) ; if ( (status == 1 ) || ( strcmp ( slVerChar , "8.0" ) != 0 ) ) { return ; } }ssSetOptions ( S , SS_OPTION_EXCEPTION_FREE_CODE ) ; if ( ssGetSizeofDWork (S ) != sizeof ( D_Work_main ) ) { ssSetErrorStatus ( S ,"Unexpected error: Internal DWork sizes do ""not match for accelerator mex file." ) ; } if ( ssGetSizeofGlobalBlockIO ( S) != sizeof ( BlockIO_main ) ) { ssSetErrorStatus ( S ,"Unexpected error: Internal BlockIO sizes do ""not match for accelerator mex file." ) ; } { int ssSizeofParams ;ssGetSizeofParams ( S , & ssSizeofParams ) ; if ( ssSizeofParams != sizeof (Parameters_main ) ) { static char msg [ 256 ] ; sprintf ( msg ,"Unexpected error: Internal Parameters sizes do ""not match for accelerator mex file." ) ; } } _ssSetDefaultParam ( S , (real_T * ) & main_rtDefaultParameters ) ; rt_InitInfAndNaN ( sizeof ( real_T) ) ; } static void mdlInitializeSampleTimes ( SimStruct * S ) { } static

/* Function: mdlInitializeSizes =============================================== * Abstract: *   Setup sizes of the various vectors. */static void mdlInitializeSizes(SimStruct *S){    ssSetNumSFcnParams(S, 0);    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        return; /* Parameter mismatch will be reported by Simulink */    }    if (!ssSetNumInputPorts(S, 1)) return;    ssSetInputPortWidth(S, 0, DYNAMICALLY_SIZED);    ssSetInputPortDirectFeedThrough(S, 0, 1);    if (!ssSetNumOutputPorts(S,1)) return;    ssSetOutputPortWidth(S, 0, DYNAMICALLY_SIZED);    ssSetNumSampleTimes(S, 1);    /* specify the sim state compliance to be same as a built-in block */    ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE);    ssSetOptions(S,                 SS_OPTION_WORKS_WITH_CODE_REUSE |                 SS_OPTION_EXCEPTION_FREE_CODE |                 SS_OPTION_USE_TLC_WITH_ACCELERATOR);}

/* Function: mdlInitializeSizes =============================================== * Abstract: *    The sizes information is used by Simulink to determine the S-function *    block's characteristics (number of inputs, outputs, states, etc.). */static void mdlInitializeSizes(SimStruct *S){    ssSetNumSFcnParams(S, NUMBER_OF_ARGS);  /* Number of expected parameters */    if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {        /* Return if number of expected != number of actual parameters */        return;    }    ssSetNumContStates(S, 0);    ssSetNumDiscStates(S, 0);    if (!ssSetNumInputPorts(S, 0)) return;    // ssSetInputPortWidth(S, 0, 1);    ssSetInputPortRequiredContiguous(S, 0, true); /*direct input signal access*/    /*     * Set direct feedthrough flag (1=yes, 0=no).     * A port has direct feedthrough if the input is used in either     * the mdlOutputs or mdlGetTimeOfNextVarHit functions.     */    ssSetInputPortDirectFeedThrough(S, 0, 1);    if (!ssSetNumOutputPorts(S, 0)) return;    // ssSetOutputPortWidth(S, 0, 1);    ssSetNumSampleTimes(S, 1);    ssSetNumRWork(S, 0);    ssSetNumIWork(S, NO_I_WORKS);    ssSetNumPWork(S, 0);    ssSetNumModes(S, 0);    ssSetNumNonsampledZCs(S, 0);    /* Specify the sim state compliance to be same as a built-in block */    ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE);    ssSetOptions(S, 0);}

static void mdlInitializeSizes(SimStruct *S) {  ssSetNumSFcnParams(S, 0); /* Number of expected parameters */  if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {    return;  }  ssSetNumContStates(S, 2);  ssSetNumDiscStates(S, 0);  if (!ssSetNumInputPorts(S, 0)) return;  if (!ssSetNumOutputPorts(S, 1)) return;  ssSetOutputPortWidth(S, 0, 2);  ssSetNumSampleTimes(S, 1);  ssSetNumRWork(S, 0);  ssSetNumIWork(S, 0);  ssSetNumPWork(S, 0);  ssSetNumModes(S, 0);  ssSetNumNonsampledZCs(S, 1);  ssSetSimStateCompliance(S, USE_DEFAULT_SIM_STATE);  ssSetOptions(S, 0);}

static void mdlSetWorkWidths_c25_CusakisME4901arcs2(SimStruct *S){  /* Actual parameters from chart:     m mb mt   */  const char_T *rtParamNames[] = { "m", "mb", "mt" };  ssSetNumRunTimeParams(S,ssGetSFcnParamsCount(S));  /* registration for m*/  ssRegDlgParamAsRunTimeParam(S, 0, 0, rtParamNames[0], SS_DOUBLE);  /* registration for mb*/  ssRegDlgParamAsRunTimeParam(S, 1, 1, rtParamNames[1], SS_DOUBLE);  /* registration for mt*/  ssRegDlgParamAsRunTimeParam(S, 2, 2, rtParamNames[2], SS_DOUBLE);  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    mxArray *infoStruct = load_CusakisME4901arcs2_optimization_info();    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable(S,sf_get_instance_specialization(),infoStruct,      25);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop(S,sf_get_instance_specialization(),                infoStruct,25,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop(S,      sf_get_instance_specialization(),infoStruct,25,      "gatewayCannotBeInlinedMultipleTimes"));    sf_update_buildInfo(S,sf_get_instance_specialization(),infoStruct,25);    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(),        infoStruct,25,1);      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),        infoStruct,25,1);    }    {      unsigned int outPortIdx;      for (outPortIdx=1; outPortIdx<=1; ++outPortIdx) {        ssSetOutputPortOptimizeInIR(S, outPortIdx, 1U);      }    }    {      unsigned int inPortIdx;      for (inPortIdx=0; inPortIdx < 1; ++inPortIdx) {        ssSetInputPortOptimizeInIR(S, inPortIdx, 1U);      }    }    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,25);    ssSetHasSubFunctions(S,!(chartIsInlinable));  } else {  }  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  ssSetChecksum0(S,(2702245221U));  ssSetChecksum1(S,(3247048464U));  ssSetChecksum2(S,(4066746145U));  ssSetChecksum3(S,(3712905929U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);  ssSupportsMultipleExecInstances(S,1);}

static void mdlSetWorkWidths_c10_experiment_lib2(SimStruct *S){  /* Actual parameters from chart:     a   */  const char_T *rtParamNames[] = { "a" };  ssSetNumRunTimeParams(S,ssGetSFcnParamsCount(S));  /* registration for a*/  ssRegDlgParamAsRunTimeParam(S, 0, 0, rtParamNames[0], SS_DOUBLE);  if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {    mxArray *infoStruct = load_experiment_lib2_optimization_info();    int_T chartIsInlinable =      (int_T)sf_is_chart_inlinable(sf_get_instance_specialization(),infoStruct,      10);    ssSetStateflowIsInlinable(S,chartIsInlinable);    ssSetRTWCG(S,sf_rtw_info_uint_prop(sf_get_instance_specialization(),                infoStruct,10,"RTWCG"));    ssSetEnableFcnIsTrivial(S,1);    ssSetDisableFcnIsTrivial(S,1);    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop      (sf_get_instance_specialization(),infoStruct,10,       "gatewayCannotBeInlinedMultipleTimes"));    sf_update_buildInfo(sf_get_instance_specialization(),infoStruct,10);    if (chartIsInlinable) {      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);      ssSetInputPortOptimOpts(S, 1, SS_REUSABLE_AND_LOCAL);      sf_mark_chart_expressionable_inputs(S,sf_get_instance_specialization(),        infoStruct,10,2);      sf_mark_chart_reusable_outputs(S,sf_get_instance_specialization(),        infoStruct,10,1);    }    {      unsigned int outPortIdx;      for (outPortIdx=1; outPortIdx<=1; ++outPortIdx) {        ssSetOutputPortOptimizeInIR(S, outPortIdx, 1U);      }    }    {      unsigned int inPortIdx;      for (inPortIdx=0; inPortIdx < 2; ++inPortIdx) {        ssSetInputPortOptimizeInIR(S, inPortIdx, 1U);      }    }    sf_set_rtw_dwork_info(S,sf_get_instance_specialization(),infoStruct,10);    ssSetHasSubFunctions(S,!(chartIsInlinable));  } else {  }  ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);  ssSetChecksum0(S,(324921852U));  ssSetChecksum1(S,(3643253733U));  ssSetChecksum2(S,(2128199589U));  ssSetChecksum3(S,(3048879468U));  ssSetmdlDerivatives(S, NULL);  ssSetExplicitFCSSCtrl(S,1);  ssSupportsMultipleExecInstances(S,1);}