flc3_samplea_acc.c

其中提到遺傳學的程式碼與應用提供給次淚相向的研究者參考下載

/*
 * This file is not available for use in any application other than as a
 * MATLAB(R) MEX file for use with the Simulink(R) Accelerator product.
 */

/*
 * flc3_sampleA_acc.c
 * 
 * Real-Time Workshop code generation for Simulink model "flc3_sampleA_acc.mdl".
 *
 * Model Version              : 1.109
 * Real-Time Workshop version : 6.1  (R14SP1)  05-Sep-2004
 * C source code generated on : Sun May 29 10:57:23 2005
 */

#include <math.h>
#include <string.h>
#include "flc3_sampleA_acc.h"
#include "flc3_sampleA_acc_private.h"
#include <stdio.h>
#include "simstruc.h"
#include "fixedpoint.h"

#define CodeFormat                      S-Function
#define AccDefine1                      Accelerator_S-Function

/* Outputs for root system: '<Root>' */
static void mdlOutputs(SimStruct *S, int_T tid)
{
  /* simstruct variables */
  flc3_sampleA_BlockIO *flc3_sampleA_B = (flc3_sampleA_BlockIO *)
    _ssGetBlockIO(S);
  flc3_sampleA_ContinuousStates *flc3_sampleA_X =
    (flc3_sampleA_ContinuousStates*) ssGetContStates(S);
  flc3_sampleA_D_Work *flc3_sampleA_DWork = (flc3_sampleA_D_Work *)
    ssGetRootDWork(S);
  flc3_sampleA_Parameters *flc3_sampleA_P = (flc3_sampleA_Parameters *)
    ssGetDefaultParam(S);

  /* local block i/o variables */

  real_T rtb_Derivative;
  real_T rtb_Saturation;
  real_T rtb_DataConv;
  real_T rtb_Productgaussmf;
  real_T rtb_Exponentialgaussmf;
  real_T rtb_Saturation1;
  real_T rtb_DataConv_p;
  real_T rtb_Productgaussmf_l;
  real_T rtb_Exponentialgaussmf_a;
  real_T rtb_Weighting;
  real_T rtb_Productgaussmf_d;
  real_T rtb_Exponentialgaussmf_g;
  real_T rtb_Weighting_l;
  real_T rtb_Productgaussmf_e;
  real_T rtb_Exponentialgaussmf_i;
  real_T rtb_Weighting_g;
  real_T rtb_Productgaussmf_p;
  real_T rtb_Exponentialgaussmf_k;
  real_T rtb_Weighting_gv;
  real_T rtb_Weighting_f;
  real_T rtb_Weighting_h;
  real_T rtb_Productgaussmf_i;
  real_T rtb_Exponentialgaussmf_b;
  real_T rtb_Weighting_m;
  real_T rtb_Weighting_j;
  real_T rtb_Weighting_o;
  real_T rtb_Switch;
  real_T rtb_Integrator;
  real_T rtb_Prod1[2];
  real_T rtb_Sum_1;
  real_T rtb_impMethod;
  real_T rtb_Prod1_f[2];
  real_T rtb_Sum_1_c;
  real_T rtb_Sum1_l;
  real_T rtb_impMethod_n;
  real_T rtb_Prod1_c[2];
  real_T rtb_Sum_1_a;
  real_T rtb_Sum1_e;
  real_T rtb_impMethod_ne;
  real_T rtb_impMethod_b;
  real_T rtb_impMethod_nv;
  real_T rtb_Prod1_p[2];
  real_T rtb_Sum_1_h;
  real_T rtb_Sum1_n;
  real_T rtb_impMethod_p;
  real_T rtb_impMethod_c;
  real_T rtb_impMethod_k;
  real_T rtb_Prod1_i[2];
  real_T rtb_impMethod_cp;
  real_T rtb_Sum1_h;

  /* Clock: '<Root>/Clock' */
  flc3_sampleA_B->Clock = ssGetT(S);

  /* ToWorkspace: '<Root>/To Workspace4' */
  /* Call into Simulink for To Workspace */
  ssCallAccelRunBlock(S, 3, 1, SS_CALL_MDL_OUTPUTS);

  if (ssIsSampleHit(S, 2, tid)) {       /* Sample time: [-2.0s, 0.0s] */

    /* DiscretePulseGenerator: '<Root>/Pulse Generator' */
    real_T time = ssGetTaskTime(S,tid);
    real_T delay = 0.0;
    if ( (int_T)flc3_sampleA_DWork->justEnabled ) {
      flc3_sampleA_DWork->justEnabled = 0;
      if (time >= delay) {
        real_T ratio = (time - delay)/ flc3_sampleA_P->PulseGenerator_Period;

        flc3_sampleA_DWork->numCompleteCycles = (int)floor(ratio);

        if ( fabs((flc3_sampleA_DWork->numCompleteCycles+1)- ratio ) <
         DBL_EPSILON * ratio )
        {
          flc3_sampleA_DWork->numCompleteCycles =
            flc3_sampleA_DWork->numCompleteCycles+1;
        }
        flc3_sampleA_DWork->numCompleteCycles =
          flc3_sampleA_DWork->numCompleteCycles;
        if (time < delay + flc3_sampleA_DWork->numCompleteCycles *
         flc3_sampleA_P->PulseGenerator_Period
         + flc3_sampleA_P->PulseGenerator_Duty *
         flc3_sampleA_P->PulseGenerator_Period/100) {
          flc3_sampleA_DWork->currentValue = 1;
          flc3_sampleA_DWork->nextTime = delay +
            flc3_sampleA_DWork->numCompleteCycles *
            flc3_sampleA_P->PulseGenerator_Period
            + flc3_sampleA_P->PulseGenerator_Duty *
            flc3_sampleA_P->PulseGenerator_Period/100;
        } else {
          flc3_sampleA_DWork->currentValue = 0;
          flc3_sampleA_DWork->nextTime = delay +
            (flc3_sampleA_DWork->numCompleteCycles + 1) *
            flc3_sampleA_P->PulseGenerator_Period;
        }
      } else {
        flc3_sampleA_DWork->numCompleteCycles = 0;
        flc3_sampleA_DWork->currentValue = 0;
        flc3_sampleA_DWork->nextTime = delay;
      }
    } else {
      /* Determine if any values need to change */
      if (flc3_sampleA_DWork->nextTime <= time) {
        if (flc3_sampleA_DWork->currentValue == 1) {
          flc3_sampleA_DWork->currentValue = 0;
          flc3_sampleA_DWork->nextTime = delay +
            (flc3_sampleA_DWork->numCompleteCycles + 1) *
            flc3_sampleA_P->PulseGenerator_Period;
        } else {
          if ( flc3_sampleA_DWork->nextTime != delay) {
            flc3_sampleA_DWork->numCompleteCycles += 1;
          }
          flc3_sampleA_DWork->currentValue = 1;
          flc3_sampleA_DWork->nextTime = delay +
            flc3_sampleA_DWork->numCompleteCycles *
            flc3_sampleA_P->PulseGenerator_Period
            + 0.01 * flc3_sampleA_P->PulseGenerator_Duty *
            flc3_sampleA_P->PulseGenerator_Period;
        }
      }
    }

    /* Set the next hit time */
    {
      real_T tNext = flc3_sampleA_DWork->nextTime;
      _ssSetVarNextHitTime(S, (int_T)0.0, tNext);
    }

    /* Output the values */
    if (flc3_sampleA_DWork->currentValue == 1){
      flc3_sampleA_B->PulseGenerator = flc3_sampleA_P->PulseGenerator_Amp;
    } else {
      flc3_sampleA_B->PulseGenerator = 0.0;
    }
  }
  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    flc3_sampleA_B->Constant = flc3_sampleA_P->Constant_Value;

    flc3_sampleA_B->Gain = (flc3_sampleA_B->PulseGenerator +
      flc3_sampleA_B->Constant) * flc3_sampleA_P->Gain_Gain;
  }

  /* TransferFcn Block: <Root>/Transfer Fcn2 */
  flc3_sampleA_B->TransferFcn2 =
    flc3_sampleA_P->TransferFcn2_C*flc3_sampleA_X->TransferFcn2_CSTATE[2];

  flc3_sampleA_B->Sum = flc3_sampleA_B->Gain - flc3_sampleA_B->TransferFcn2;

  /* Scope: '<Root>/Scope' */
  /* Call into Simulink for Scope */
  ssCallAccelRunBlock(S, 3, 8, SS_CALL_MDL_OUTPUTS);

  /* Derivative Block: <Root>/Derivative */
  {
    real_T t = ssGetTaskTime(S,tid);
    real_T timeStampA = flc3_sampleA_DWork->Derivative_RWORK.TimeStampA;
    real_T timeStampB = flc3_sampleA_DWork->Derivative_RWORK.TimeStampB;

    if (timeStampA >= t && timeStampB >= t) {
      rtb_Derivative = 0.0;
    } else {
      real_T deltaT;
      real_T *lastBank = &flc3_sampleA_DWork->Derivative_RWORK.TimeStampA;
      if (timeStampA < timeStampB) {
        if (timeStampB < t) {
          lastBank += 2;
        }
      } else if (timeStampA >= t) {
        lastBank += 2;
      }
      deltaT = t - *lastBank++;
      rtb_Derivative = (flc3_sampleA_B->Sum - *lastBank++) / deltaT;
    }
  }

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    flc3_sampleA_B->Weight = flc3_sampleA_P->Weight_Value;
  }

  flc3_sampleA_B->Gain1 = flc3_sampleA_B->Sum * flc3_sampleA_P->Gain1_Gain;

  /* Saturate: '<S2>/Saturation'
   *
   * Regarding '<S2>/Saturation':
   *   Lower limit: flc3_sampleA_P->Saturation_LowerSat
   *   Upper limit: flc3_sampleA_P->Saturation_UpperSat
   */
  if (ssIsMajorTimeStep(S)) {
    if (flc3_sampleA_B->Gain1 >= flc3_sampleA_P->Saturation_UpperSat) {
      flc3_sampleA_DWork->Saturation_MODE = 1;
    } else if (flc3_sampleA_B->Gain1 <= flc3_sampleA_P->Saturation_LowerSat) {
      flc3_sampleA_DWork->Saturation_MODE = -1;
    } else {
      flc3_sampleA_DWork->Saturation_MODE = 0;
    }
  }
  /* Output value */
  if (flc3_sampleA_DWork->Saturation_MODE == 1) {
    rtb_Saturation = flc3_sampleA_P->Saturation_UpperSat;
  } else if (flc3_sampleA_DWork->Saturation_MODE == -1) {
    rtb_Saturation = flc3_sampleA_P->Saturation_LowerSat;
  } else {
    rtb_Saturation = flc3_sampleA_B->Gain1;
  }

  rtb_DataConv = rtb_Saturation;

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    flc3_sampleA_B->mu = flc3_sampleA_P->mu_Value;

    flc3_sampleA_B->sigma = flc3_sampleA_P->sigma_Value;
  }

  rtb_Productgaussmf = (rtb_DataConv - flc3_sampleA_B->mu) /
    flc3_sampleA_B->sigma;

  rtb_Exponentialgaussmf = exp(rtb_Productgaussmf * rtb_Productgaussmf *
    flc3_sampleA_P->Gain_Gain_g);

  flc3_sampleA_B->Gain2 = rtb_Derivative * flc3_sampleA_P->Gain2_Gain;

  /* Saturate: '<S2>/Saturation1'
   *
   * Regarding '<S2>/Saturation1':
   *   Lower limit: flc3_sampleA_P->Saturation1_LowerSat
   *   Upper limit: flc3_sampleA_P->Saturation1_UpperSat
   */
  if (ssIsMajorTimeStep(S)) {
    if (flc3_sampleA_B->Gain2 >= flc3_sampleA_P->Saturation1_UpperSat) {
      flc3_sampleA_DWork->Saturation1_MODE = 1;
    } else if (flc3_sampleA_B->Gain2 <= flc3_sampleA_P->Saturation1_LowerSat) {
      flc3_sampleA_DWork->Saturation1_MODE = -1;
    } else {
      flc3_sampleA_DWork->Saturation1_MODE = 0;
    }
  }
  /* Output value */
  if (flc3_sampleA_DWork->Saturation1_MODE == 1) {
    rtb_Saturation1 = flc3_sampleA_P->Saturation1_UpperSat;
  } else if (flc3_sampleA_DWork->Saturation1_MODE == -1) {
    rtb_Saturation1 = flc3_sampleA_P->Saturation1_LowerSat;
  } else {
    rtb_Saturation1 = flc3_sampleA_B->Gain2;
  }

  rtb_DataConv_p = rtb_Saturation1;

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    flc3_sampleA_B->mu_p = flc3_sampleA_P->mu_Value_b;

    flc3_sampleA_B->sigma_k = flc3_sampleA_P->sigma_Value_p;
  }

  rtb_Productgaussmf_l = (rtb_DataConv_p - flc3_sampleA_B->mu_p) /
    flc3_sampleA_B->sigma_k;

  rtb_Exponentialgaussmf_a = exp(rtb_Productgaussmf_l * rtb_Productgaussmf_l *
    flc3_sampleA_P->Gain_Gain_p);

  rtb_Weighting = flc3_sampleA_B->Weight * (rtb_Exponentialgaussmf *
    rtb_Exponentialgaussmf_a);

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    flc3_sampleA_B->Weight_m = flc3_sampleA_P->Weight_Value_j;

    flc3_sampleA_B->mu_m = flc3_sampleA_P->mu_Value_o;

    flc3_sampleA_B->sigma_i = flc3_sampleA_P->sigma_Value_pa;
  }

  rtb_Productgaussmf_d = (rtb_DataConv_p - flc3_sampleA_B->mu_m) /
    flc3_sampleA_B->sigma_i;

  rtb_Exponentialgaussmf_g = exp(rtb_Productgaussmf_d * rtb_Productgaussmf_d *
    flc3_sampleA_P->Gain_Gain_f);

  rtb_Weighting_l = flc3_sampleA_B->Weight_m * (rtb_Exponentialgaussmf *
    rtb_Exponentialgaussmf_g);

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    flc3_sampleA_B->Weight_b = flc3_sampleA_P->Weight_Value_p;

    flc3_sampleA_B->mu_o = flc3_sampleA_P->mu_Value_m;

    flc3_sampleA_B->sigma_d = flc3_sampleA_P->sigma_Value_b;
  }

  rtb_Productgaussmf_e = (rtb_DataConv_p - flc3_sampleA_B->mu_o) /
    flc3_sampleA_B->sigma_d;

  rtb_Exponentialgaussmf_i = exp(rtb_Productgaussmf_e * rtb_Productgaussmf_e *
    flc3_sampleA_P->Gain_Gain_a);

  rtb_Weighting_g = flc3_sampleA_B->Weight_b * (rtb_Exponentialgaussmf *
    rtb_Exponentialgaussmf_i);

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    flc3_sampleA_B->Weight_c = flc3_sampleA_P->Weight_Value_n;

    flc3_sampleA_B->mu_f = flc3_sampleA_P->mu_Value_mz;

    flc3_sampleA_B->sigma_j = flc3_sampleA_P->sigma_Value_k;
  }

  rtb_Productgaussmf_p = (rtb_DataConv - flc3_sampleA_B->mu_f) /
    flc3_sampleA_B->sigma_j;

  rtb_Exponentialgaussmf_k = exp(rtb_Productgaussmf_p * rtb_Productgaussmf_p *
    flc3_sampleA_P->Gain_Gain_e);

  rtb_Weighting_gv = flc3_sampleA_B->Weight_c * (rtb_Exponentialgaussmf_k *
    rtb_Exponentialgaussmf_a);

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    flc3_sampleA_B->Weight_k = flc3_sampleA_P->Weight_Value_o;
  }

  rtb_Weighting_f = flc3_sampleA_B->Weight_k * (rtb_Exponentialgaussmf_k *
    rtb_Exponentialgaussmf_g);

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    flc3_sampleA_B->Weight_bq = flc3_sampleA_P->Weight_Value_f;
  }

  rtb_Weighting_h = flc3_sampleA_B->Weight_bq * (rtb_Exponentialgaussmf_k *
    rtb_Exponentialgaussmf_i);

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    flc3_sampleA_B->Weight_ka = flc3_sampleA_P->Weight_Value_b;

    flc3_sampleA_B->mu_g = flc3_sampleA_P->mu_Value_n;

    flc3_sampleA_B->sigma_m = flc3_sampleA_P->sigma_Value_c;
  }

  rtb_Productgaussmf_i = (rtb_DataConv - flc3_sampleA_B->mu_g) /
    flc3_sampleA_B->sigma_m;