Notera att C-kodgenerering genererar väldigt mycket kod och skulle man skriva koden själv så skulle det bli en mycket mindre kod.
Detta är bara main filen.
Kod: Markera allt
#include "rt_nonfinite.h"
#include "mpc.h"
#include "main.h"
#include "mpc_terminate.h"
#include "mpc_emxAPI.h"
#include "mpc_initialize.h"
/* Function Declarations */
static emxArray_real_T *argInit_Unboundedx1_real_T(void);
static double argInit_real_T(void);
static emxArray_real_T *c_argInit_UnboundedxUnbounded_r(void);
static void main_mpc(void);
/* Function Definitions */
static emxArray_real_T *argInit_Unboundedx1_real_T(void)
{
emxArray_real_T *result;
static int iv1[1] = { 2 };
int idx0;
/* Set the size of the array.
Change this size to the value that the application requires. */
result = emxCreateND_real_T(1, iv1);
/* Loop over the array to initialize each element. */
for (idx0 = 0; idx0 < result->size[0U]; idx0++) {
/* Set the value of the array element.
Change this value to the value that the application requires. */
result->data[idx0] = argInit_real_T();
}
return result;
}
static double argInit_real_T(void)
{
return 0.0;
}
static emxArray_real_T *c_argInit_UnboundedxUnbounded_r(void)
{
emxArray_real_T *result;
static int iv0[2] = { 2, 2 };
int idx0;
int idx1;
/* Set the size of the array.
Change this size to the value that the application requires. */
result = emxCreateND_real_T(2, iv0);
/* Loop over the array to initialize each element. */
for (idx0 = 0; idx0 < result->size[0U]; idx0++) {
for (idx1 = 0; idx1 < result->size[1U]; idx1++) {
/* Set the value of the array element.
Change this value to the value that the application requires. */
result->data[idx0 + result->size[0] * idx1] = argInit_real_T();
}
}
return result;
}
static void main_mpc(void)
{
emxArray_real_T *U;
emxArray_real_T *A;
emxArray_real_T *B;
emxArray_real_T *C;
emxArray_real_T *x;
emxInitArray_real_T(&U, 1);
/* Initialize function 'mpc' input arguments. */
/* Initialize function input argument 'A'. */
A = c_argInit_UnboundedxUnbounded_r();
/* Initialize function input argument 'B'. */
B = c_argInit_UnboundedxUnbounded_r();
/* Initialize function input argument 'C'. */
C = c_argInit_UnboundedxUnbounded_r();
/* Initialize function input argument 'x'. */
x = argInit_Unboundedx1_real_T();
/* Call the entry-point 'mpc'. */
mpc(A, B, C, x, argInit_real_T(), argInit_real_T(), argInit_real_T(), U);
emxDestroyArray_real_T(U);
emxDestroyArray_real_T(x);
emxDestroyArray_real_T(C);
emxDestroyArray_real_T(B);
emxDestroyArray_real_T(A);
}
int main(int argc, const char * const argv[])
{
(void)argc;
(void)argv;
/* Initialize the application.
You do not need to do this more than one time. */
mpc_initialize();
/* Invoke the entry-point functions.
You can call entry-point functions multiple times. */
main_mpc();
/* Terminate the application.
You do not need to do this more than one time. */
mpc_terminate();
return 0;
}
/* End of code generation (main.c) */
Kod: Markera allt
/* Include files */
#include "rt_nonfinite.h"
#include "mpc.h"
#include "mpc_emxutil.h"
#include "mpower.h"
/* Function Declarations */
static void gammaMat(const emxArray_real_T *A, const emxArray_real_T *B, const
emxArray_real_T *C, double N, emxArray_real_T *GAMMA);
/* Function Definitions */
static void gammaMat(const emxArray_real_T *A, const emxArray_real_T *B, const
emxArray_real_T *C, double N, emxArray_real_T *GAMMA)
{
int i1;
int loop_ub;
int i;
emxArray_real_T *r1;
emxArray_real_T *r2;
emxArray_real_T *y;
emxArray_real_T *CAB;
emxArray_real_T *varargin_1;
int m;
int inner;
int coffset;
int i2;
int boffset;
int b_i;
int c_i;
int k;
int aoffset;
double d0;
double b_N;
boolean_T empty_non_axis_sizes;
/* Create the lower triangular toeplitz matrix */
i1 = GAMMA->size[0] * GAMMA->size[1];
GAMMA->size[0] = (int)((double)C->size[0] * N);
GAMMA->size[1] = (int)((double)B->size[1] * N);
emxEnsureCapacity_real_T(GAMMA, i1);
loop_ub = (int)((double)C->size[0] * N) * (int)((double)B->size[1] * N);
for (i1 = 0; i1 < loop_ub; i1++) {
GAMMA->data[i1] = 0.0;
}
i = 0;
emxInit_real_T(&r1, 2);
emxInit_real_T(&r2, 2);
emxInit_real_T(&y, 2);
emxInit_real_T(&CAB, 2);
emxInit_real_T(&varargin_1, 2);
while (i <= (int)N - 1) {
if ((C->size[1] == 1) || (A->size[0] == 1)) {
i1 = y->size[0] * y->size[1];
y->size[0] = C->size[0];
y->size[1] = A->size[1];
emxEnsureCapacity_real_T(y, i1);
loop_ub = C->size[0];
for (i1 = 0; i1 < loop_ub; i1++) {
coffset = A->size[1];
for (i2 = 0; i2 < coffset; i2++) {
y->data[i1 + y->size[0] * i2] = 0.0;
boffset = C->size[1];
for (c_i = 0; c_i < boffset; c_i++) {
y->data[i1 + y->size[0] * i2] += C->data[i1 + C->size[0] * c_i] *
A->data[c_i + A->size[0] * i2];
}
}
}
} else {
m = C->size[0];
inner = C->size[1];
i1 = y->size[0] * y->size[1];
y->size[0] = C->size[0];
y->size[1] = A->size[1];
emxEnsureCapacity_real_T(y, i1);
for (loop_ub = 0; loop_ub < A->size[1]; loop_ub++) {
coffset = loop_ub * m - 1;
boffset = loop_ub * inner - 1;
for (b_i = 1; b_i <= m; b_i++) {
y->data[coffset + b_i] = 0.0;
}
for (k = 1; k <= inner; k++) {
if (A->data[boffset + k] != 0.0) {
aoffset = (k - 1) * m;
for (b_i = 1; b_i <= m; b_i++) {
y->data[coffset + b_i] += A->data[boffset + k] * C->data[(aoffset
+ b_i) - 1];
}
}
}
}
}
if ((y->size[1] == 1) || (B->size[0] == 1)) {
i1 = r1->size[0] * r1->size[1];
r1->size[0] = y->size[0];
r1->size[1] = B->size[1];
emxEnsureCapacity_real_T(r1, i1);
loop_ub = y->size[0];
for (i1 = 0; i1 < loop_ub; i1++) {
coffset = B->size[1];
for (i2 = 0; i2 < coffset; i2++) {
r1->data[i1 + r1->size[0] * i2] = 0.0;
boffset = y->size[1];
for (c_i = 0; c_i < boffset; c_i++) {
r1->data[i1 + r1->size[0] * i2] += y->data[i1 + y->size[0] * c_i] *
B->data[c_i + B->size[0] * i2];
}
}
}
} else {
m = y->size[0];
inner = y->size[1];
i1 = r1->size[0] * r1->size[1];
r1->size[0] = y->size[0];
r1->size[1] = B->size[1];
emxEnsureCapacity_real_T(r1, i1);
for (loop_ub = 0; loop_ub < B->size[1]; loop_ub++) {
coffset = loop_ub * m - 1;
boffset = loop_ub * inner - 1;
for (b_i = 1; b_i <= m; b_i++) {
r1->data[coffset + b_i] = 0.0;
}
for (k = 1; k <= inner; k++) {
if (B->data[boffset + k] != 0.0) {
aoffset = (k - 1) * m;
for (b_i = 1; b_i <= m; b_i++) {
r1->data[coffset + b_i] += B->data[boffset + k] * y->data[(aoffset
+ b_i) - 1];
}
}
}
}
}
if ((C->size[1] == 1) || (A->size[0] == 1)) {
i1 = y->size[0] * y->size[1];
y->size[0] = C->size[0];
y->size[1] = A->size[1];
emxEnsureCapacity_real_T(y, i1);
loop_ub = C->size[0];
for (i1 = 0; i1 < loop_ub; i1++) {
coffset = A->size[1];
for (i2 = 0; i2 < coffset; i2++) {
y->data[i1 + y->size[0] * i2] = 0.0;
boffset = C->size[1];
for (c_i = 0; c_i < boffset; c_i++) {
y->data[i1 + y->size[0] * i2] += C->data[i1 + C->size[0] * c_i] *
A->data[c_i + A->size[0] * i2];
}
}
}
} else {
m = C->size[0];
inner = C->size[1];
i1 = y->size[0] * y->size[1];
y->size[0] = C->size[0];
y->size[1] = A->size[1];
emxEnsureCapacity_real_T(y, i1);
for (loop_ub = 0; loop_ub < A->size[1]; loop_ub++) {
coffset = loop_ub * m - 1;
boffset = loop_ub * inner - 1;
for (b_i = 1; b_i <= m; b_i++) {
y->data[coffset + b_i] = 0.0;
}
for (k = 1; k <= inner; k++) {
if (A->data[boffset + k] != 0.0) {
aoffset = (k - 1) * m;
for (b_i = 1; b_i <= m; b_i++) {
y->data[coffset + b_i] += A->data[boffset + k] * C->data[(aoffset
+ b_i) - 1];
}
}
}
}
}
if ((y->size[1] == 1) || (B->size[0] == 1)) {
i1 = r2->size[0] * r2->size[1];
r2->size[0] = y->size[0];
r2->size[1] = B->size[1];
emxEnsureCapacity_real_T(r2, i1);
loop_ub = y->size[0];
for (i1 = 0; i1 < loop_ub; i1++) {
coffset = B->size[1];
for (i2 = 0; i2 < coffset; i2++) {
r2->data[i1 + r2->size[0] * i2] = 0.0;
boffset = y->size[1];
for (c_i = 0; c_i < boffset; c_i++) {
r2->data[i1 + r2->size[0] * i2] += y->data[i1 + y->size[0] * c_i] *
B->data[c_i + B->size[0] * i2];
}
}
}
} else {
m = y->size[0];
inner = y->size[1];
i1 = r2->size[0] * r2->size[1];
r2->size[0] = y->size[0];
r2->size[1] = B->size[1];
emxEnsureCapacity_real_T(r2, i1);
for (loop_ub = 0; loop_ub < B->size[1]; loop_ub++) {
coffset = loop_ub * m - 1;
boffset = loop_ub * inner - 1;
for (b_i = 1; b_i <= m; b_i++) {
r2->data[coffset + b_i] = 0.0;
}
for (k = 1; k <= inner; k++) {
if (B->data[boffset + k] != 0.0) {
aoffset = (k - 1) * m;
for (b_i = 1; b_i <= m; b_i++) {
r2->data[coffset + b_i] += B->data[boffset + k] * y->data[(aoffset
+ b_i) - 1];
}
}
}
}
}
d0 = (double)C->size[0] * (1.0 + (double)i);
if (1.0 + (double)i > d0) {
i1 = 1;
} else {
i1 = i + 1;
}
b_N = (N - (1.0 + (double)i)) + 1.0;
/* Create the column for the GAMMA matrix */
i2 = CAB->size[0] * CAB->size[1];
CAB->size[0] = (int)((double)C->size[0] * b_N);
CAB->size[1] = B->size[1];
emxEnsureCapacity_real_T(CAB, i2);
loop_ub = (int)((double)C->size[0] * b_N) * B->size[1];
for (i2 = 0; i2 < loop_ub; i2++) {
CAB->data[i2] = 0.0;
}
for (b_i = 0; b_i < (int)((b_N - 1.0) + 1.0); b_i++) {
d0 = (double)C->size[0] * ((double)b_i + 1.0);
if ((double)b_i + 1.0 > d0) {
i2 = 1;
} else {
i2 = b_i + 1;
}
mpower(A, b_i, varargin_1);
if ((C->size[1] == 1) || (varargin_1->size[0] == 1)) {
c_i = y->size[0] * y->size[1];
y->size[0] = C->size[0];
y->size[1] = varargin_1->size[1];
emxEnsureCapacity_real_T(y, c_i);
loop_ub = C->size[0];
for (c_i = 0; c_i < loop_ub; c_i++) {
coffset = varargin_1->size[1];
for (k = 0; k < coffset; k++) {
y->data[c_i + y->size[0] * k] = 0.0;
boffset = C->size[1];
for (aoffset = 0; aoffset < boffset; aoffset++) {
y->data[c_i + y->size[0] * k] += C->data[c_i + C->size[0] *
aoffset] * varargin_1->data[aoffset + varargin_1->size[0] * k];
}
}
}
} else {
m = C->size[0];
inner = C->size[1];
c_i = y->size[0] * y->size[1];
y->size[0] = C->size[0];
y->size[1] = varargin_1->size[1];
emxEnsureCapacity_real_T(y, c_i);
for (loop_ub = 0; loop_ub < varargin_1->size[1]; loop_ub++) {
coffset = loop_ub * m - 1;
boffset = loop_ub * inner - 1;
for (c_i = 1; c_i <= m; c_i++) {
y->data[coffset + c_i] = 0.0;
}
for (k = 1; k <= inner; k++) {
if (varargin_1->data[boffset + k] != 0.0) {
aoffset = (k - 1) * m;
for (c_i = 1; c_i <= m; c_i++) {
y->data[coffset + c_i] += varargin_1->data[boffset + k] *
C->data[(aoffset + c_i) - 1];
}
}
}
}
}
if ((y->size[1] == 1) || (B->size[0] == 1)) {
c_i = varargin_1->size[0] * varargin_1->size[1];
varargin_1->size[0] = y->size[0];
varargin_1->size[1] = B->size[1];
emxEnsureCapacity_real_T(varargin_1, c_i);
loop_ub = y->size[0];
for (c_i = 0; c_i < loop_ub; c_i++) {
coffset = B->size[1];
for (k = 0; k < coffset; k++) {
varargin_1->data[c_i + varargin_1->size[0] * k] = 0.0;
boffset = y->size[1];
for (aoffset = 0; aoffset < boffset; aoffset++) {
varargin_1->data[c_i + varargin_1->size[0] * k] += y->data[c_i +
y->size[0] * aoffset] * B->data[aoffset + B->size[0] * k];
}
}
}
} else {
m = y->size[0];
inner = y->size[1];
c_i = varargin_1->size[0] * varargin_1->size[1];
varargin_1->size[0] = y->size[0];
varargin_1->size[1] = B->size[1];
emxEnsureCapacity_real_T(varargin_1, c_i);
for (loop_ub = 0; loop_ub < B->size[1]; loop_ub++) {
coffset = loop_ub * m - 1;
boffset = loop_ub * inner - 1;
for (c_i = 1; c_i <= m; c_i++) {
varargin_1->data[coffset + c_i] = 0.0;
}
for (k = 1; k <= inner; k++) {
if (B->data[boffset + k] != 0.0) {
aoffset = (k - 1) * m;
for (c_i = 1; c_i <= m; c_i++) {
varargin_1->data[coffset + c_i] += B->data[boffset + k] *
y->data[(aoffset + c_i) - 1];
}
}
}
}
}
loop_ub = varargin_1->size[1];
for (c_i = 0; c_i < loop_ub; c_i++) {
coffset = varargin_1->size[0];
for (k = 0; k < coffset; k++) {
CAB->data[((i2 + k) + CAB->size[0] * c_i) - 1] = varargin_1->data[k +
varargin_1->size[0] * c_i];
}
}
}
i2 = varargin_1->size[0] * varargin_1->size[1];
varargin_1->size[0] = (int)(((1.0 + (double)i) - 1.0) * (double)r1->size[0]);
varargin_1->size[1] = r2->size[1];
emxEnsureCapacity_real_T(varargin_1, i2);
loop_ub = (int)(((1.0 + (double)i) - 1.0) * (double)r1->size[0]) * r2->size
[1];
for (i2 = 0; i2 < loop_ub; i2++) {
varargin_1->data[i2] = 0.0;
}
coffset = (int)(((1.0 + (double)i) - 1.0) * (double)r1->size[0]);
boffset = r2->size[1];
if (!((coffset == 0) || (boffset == 0))) {
boffset = r2->size[1];
} else if (!((CAB->size[0] == 0) || (CAB->size[1] == 0))) {
boffset = CAB->size[1];
} else {
boffset = r2->size[1];
if (boffset > 0) {
boffset = r2->size[1];
} else {
boffset = 0;
}
if (CAB->size[1] > boffset) {
boffset = CAB->size[1];
}
}
empty_non_axis_sizes = (boffset == 0);
if (empty_non_axis_sizes) {
coffset = (int)(((1.0 + (double)i) - 1.0) * (double)r1->size[0]);
} else {
coffset = (int)(((1.0 + (double)i) - 1.0) * (double)r1->size[0]);
loop_ub = r2->size[1];
if (!((coffset == 0) || (loop_ub == 0))) {
coffset = (int)(((1.0 + (double)i) - 1.0) * (double)r1->size[0]);
} else {
coffset = 0;
}
}
if (empty_non_axis_sizes || (!((CAB->size[0] == 0) || (CAB->size[1] == 0))))
{
loop_ub = CAB->size[0];
} else {
loop_ub = 0;
}
for (i2 = 0; i2 < boffset; i2++) {
for (c_i = 0; c_i < coffset; c_i++) {
GAMMA->data[c_i + GAMMA->size[0] * ((i1 + i2) - 1)] = varargin_1->
data[c_i + coffset * i2];
}
}
for (i2 = 0; i2 < boffset; i2++) {
for (c_i = 0; c_i < loop_ub; c_i++) {
GAMMA->data[(c_i + coffset) + GAMMA->size[0] * ((i1 + i2) - 1)] =
CAB->data[c_i + loop_ub * i2];
}
}
i++;
}
emxFree_real_T(&varargin_1);
emxFree_real_T(&CAB);
emxFree_real_T(&y);
emxFree_real_T(&r2);
emxFree_real_T(&r1);
}
void mpc(const emxArray_real_T *A, const emxArray_real_T *B, const
emxArray_real_T *C, const emxArray_real_T *x, double N, double r,
double lb, emxArray_real_T *U)
{
emxArray_real_T *PHI;
int i0;
int loop_ub;
int i;
emxArray_real_T *GAMMA;
emxArray_real_T *r0;
double u;
int m;
int aoffset;
int inner;
emxArray_real_T *a;
emxArray_real_T *b;
int coffset;
int boffset;
double ub;
int b_i;
int k;
double y;
emxInit_real_T(&PHI, 2);
/* Find matrix */
/* Create the special Observabillity matrix */
i0 = PHI->size[0] * PHI->size[1];
PHI->size[0] = (int)((double)C->size[0] * N);
PHI->size[1] = A->size[1];
emxEnsureCapacity_real_T(PHI, i0);
loop_ub = (int)((double)C->size[0] * N) * A->size[1];
for (i0 = 0; i0 < loop_ub; i0++) {
PHI->data[i0] = 0.0;
}
i = 0;
emxInit_real_T(&GAMMA, 2);
emxInit_real_T(&r0, 2);
while (i <= (int)N - 1) {
u = (double)C->size[0] * (1.0 + (double)i);
if (1.0 + (double)i > u) {
i0 = 1;
} else {
i0 = i + 1;
}
mpower(A, 1.0 + (double)i, GAMMA);
if ((C->size[1] == 1) || (GAMMA->size[0] == 1)) {
aoffset = r0->size[0] * r0->size[1];
r0->size[0] = C->size[0];
r0->size[1] = GAMMA->size[1];
emxEnsureCapacity_real_T(r0, aoffset);
loop_ub = C->size[0];
for (aoffset = 0; aoffset < loop_ub; aoffset++) {
coffset = GAMMA->size[1];
for (boffset = 0; boffset < coffset; boffset++) {
r0->data[aoffset + r0->size[0] * boffset] = 0.0;
b_i = C->size[1];
for (k = 0; k < b_i; k++) {
r0->data[aoffset + r0->size[0] * boffset] += C->data[aoffset +
C->size[0] * k] * GAMMA->data[k + GAMMA->size[0] * boffset];
}
}
}
} else {
m = C->size[0];
inner = C->size[1];
aoffset = r0->size[0] * r0->size[1];
r0->size[0] = C->size[0];
r0->size[1] = GAMMA->size[1];
emxEnsureCapacity_real_T(r0, aoffset);
for (loop_ub = 0; loop_ub < GAMMA->size[1]; loop_ub++) {
coffset = loop_ub * m - 1;
boffset = loop_ub * inner - 1;
for (b_i = 1; b_i <= m; b_i++) {
r0->data[coffset + b_i] = 0.0;
}
for (k = 1; k <= inner; k++) {
if (GAMMA->data[boffset + k] != 0.0) {
aoffset = (k - 1) * m;
for (b_i = 1; b_i <= m; b_i++) {
r0->data[coffset + b_i] += GAMMA->data[boffset + k] * C->data
[(aoffset + b_i) - 1];
}
}
}
}
}
loop_ub = r0->size[1];
for (aoffset = 0; aoffset < loop_ub; aoffset++) {
coffset = r0->size[0];
for (boffset = 0; boffset < coffset; boffset++) {
PHI->data[((i0 + boffset) + PHI->size[0] * aoffset) - 1] = r0->
data[boffset + r0->size[0] * aoffset];
}
}
i++;
}
emxFree_real_T(&r0);
gammaMat(A, B, C, N, GAMMA);
/* Solve first with no constraints */
/* Set U */
i0 = U->size[0];
U->size[0] = (int)N;
emxEnsureCapacity_real_T1(U, i0);
loop_ub = (int)N;
for (i0 = 0; i0 < loop_ub; i0++) {
U->data[i0] = 0.0;
}
/* Iterate Gaussian Elimination */
i = 0;
emxInit_real_T(&a, 2);
emxInit_real_T1(&b, 1);
while (i <= (int)N - 1) {
/* Solve u */
if (1.0 + (double)i == 1.0) {
loop_ub = PHI->size[1];
i0 = a->size[0] * a->size[1];
a->size[0] = 1;
a->size[1] = loop_ub;
emxEnsureCapacity_real_T(a, i0);
for (i0 = 0; i0 < loop_ub; i0++) {
a->data[a->size[0] * i0] = PHI->data[PHI->size[0] * i0];
}
i0 = PHI->size[1];
if ((i0 == 1) || (x->size[0] == 1)) {
u = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
u += a->data[a->size[0] * i0] * x->data[i0];
}
} else {
u = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
u += a->data[a->size[0] * i0] * x->data[i0];
}
}
u = (r - u) / GAMMA->data[0];
} else {
loop_ub = PHI->size[1];
i0 = a->size[0] * a->size[1];
a->size[0] = 1;
a->size[1] = loop_ub;
emxEnsureCapacity_real_T(a, i0);
for (i0 = 0; i0 < loop_ub; i0++) {
a->data[a->size[0] * i0] = PHI->data[i + PHI->size[0] * i0];
}
i0 = PHI->size[1];
if ((i0 == 1) || (x->size[0] == 1)) {
u = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
u += a->data[a->size[0] * i0] * x->data[i0];
}
} else {
u = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
u += a->data[a->size[0] * i0] * x->data[i0];
}
}
loop_ub = (int)((1.0 + (double)i) - 1.0);
i0 = a->size[0] * a->size[1];
a->size[0] = 1;
a->size[1] = (int)((1.0 + (double)i) - 1.0);
emxEnsureCapacity_real_T(a, i0);
for (i0 = 0; i0 < loop_ub; i0++) {
a->data[a->size[0] * i0] = GAMMA->data[i + GAMMA->size[0] * i0];
}
loop_ub = (int)((1.0 + (double)i) - 1.0);
i0 = b->size[0];
b->size[0] = (int)((1.0 + (double)i) - 1.0);
emxEnsureCapacity_real_T1(b, i0);
for (i0 = 0; i0 < loop_ub; i0++) {
b->data[i0] = U->data[i0];
}
if ((1.0 + (double)i) - 1.0 == 1.0) {
y = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
y += a->data[a->size[0] * i0] * b->data[i0];
}
} else {
y = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
y += a->data[a->size[0] * i0] * b->data[i0];
}
}
u = ((r - u) - y) / GAMMA->data[i + GAMMA->size[0] * i];
}
/* Constraints */
/* Save u */
U->data[i] = u;
i++;
}
/* Then use the last U as upper bound */
ub = U->data[U->size[0] - 1];
/* Set U */
i0 = U->size[0];
U->size[0] = (int)N;
emxEnsureCapacity_real_T1(U, i0);
loop_ub = (int)N;
for (i0 = 0; i0 < loop_ub; i0++) {
U->data[i0] = 0.0;
}
/* Iterate Gaussian Elimination */
for (i = 0; i < (int)N; i++) {
/* Solve u */
if (1.0 + (double)i == 1.0) {
loop_ub = PHI->size[1];
i0 = a->size[0] * a->size[1];
a->size[0] = 1;
a->size[1] = loop_ub;
emxEnsureCapacity_real_T(a, i0);
for (i0 = 0; i0 < loop_ub; i0++) {
a->data[a->size[0] * i0] = PHI->data[PHI->size[0] * i0];
}
i0 = PHI->size[1];
if ((i0 == 1) || (x->size[0] == 1)) {
u = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
u += a->data[a->size[0] * i0] * x->data[i0];
}
} else {
u = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
u += a->data[a->size[0] * i0] * x->data[i0];
}
}
u = (r - u) / GAMMA->data[0];
} else {
loop_ub = PHI->size[1];
i0 = a->size[0] * a->size[1];
a->size[0] = 1;
a->size[1] = loop_ub;
emxEnsureCapacity_real_T(a, i0);
for (i0 = 0; i0 < loop_ub; i0++) {
a->data[a->size[0] * i0] = PHI->data[i + PHI->size[0] * i0];
}
i0 = PHI->size[1];
if ((i0 == 1) || (x->size[0] == 1)) {
u = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
u += a->data[a->size[0] * i0] * x->data[i0];
}
} else {
u = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
u += a->data[a->size[0] * i0] * x->data[i0];
}
}
loop_ub = (int)((1.0 + (double)i) - 1.0);
i0 = a->size[0] * a->size[1];
a->size[0] = 1;
a->size[1] = (int)((1.0 + (double)i) - 1.0);
emxEnsureCapacity_real_T(a, i0);
for (i0 = 0; i0 < loop_ub; i0++) {
a->data[a->size[0] * i0] = GAMMA->data[i + GAMMA->size[0] * i0];
}
loop_ub = (int)((1.0 + (double)i) - 1.0);
i0 = b->size[0];
b->size[0] = (int)((1.0 + (double)i) - 1.0);
emxEnsureCapacity_real_T1(b, i0);
for (i0 = 0; i0 < loop_ub; i0++) {
b->data[i0] = U->data[i0];
}
if ((1.0 + (double)i) - 1.0 == 1.0) {
y = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
y += a->data[a->size[0] * i0] * b->data[i0];
}
} else {
y = 0.0;
for (i0 = 0; i0 < a->size[1]; i0++) {
y += a->data[a->size[0] * i0] * b->data[i0];
}
}
u = ((r - u) - y) / GAMMA->data[i + GAMMA->size[0] * i];
}
/* Constraints */
if (u > ub) {
u = ub;
} else {
if (u < lb) {
u = lb;
}
}
/* Save u */
U->data[i] = u;
}
emxFree_real_T(&b);
emxFree_real_T(&a);
emxFree_real_T(&GAMMA);
emxFree_real_T(&PHI);
}
/* End of code generation (mpc.c) */