Skip to content
Snippets Groups Projects
Commit e7b807a7 authored by Syed Farzad Husain's avatar Syed Farzad Husain
Browse files

remove svn folder

parent bab56657
Branches master
No related tags found
No related merge requests found
Pipeline #
Hide whitespace changes
Inline Side-by-side
Showing
with 0 additions and 1629 deletions
.svn/entries deleted 100644 → 0
+ 0
− 1
View file @ bab56657
12
.svn/format deleted 100644 → 0
+ 0
− 1
View file @ bab56657
12
.svn/pristine/01/01916e317b2d5c9d0bf60312e2b458b12fe3ec61.svn-base deleted 100644 → 0
+ 0
− 23
View file @ bab56657
/*
* rtGetInf.h
*
* Code generation for function 'Optimal_affine_tracking_3d16_fast_realtime'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
#ifndef __RTGETINF_H__
#define __RTGETINF_H__
#include <stddef.h>
#include "rtwtypes.h"
#include "rt_nonfinite.h"
extern real_T rtGetInf(void);
extern real32_T rtGetInfF(void);
extern real_T rtGetMinusInf(void);
extern real32_T rtGetMinusInfF(void);
#endif
/* End of code generation (rtGetInf.h) */
.svn/pristine/01/01e8927fa3dca4f3a95c9d07afa24b36a15e3da6.svn-base deleted 100644 → 0
+ 0
− 34
View file @ bab56657
/*
* Optimal_affine_tracking_3d16_fast_realtime.h
*
* Code generation for function 'Optimal_affine_tracking_3d16_fast_realtime'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
#ifndef __OPTIMAL_AFFINE_TRACKING_3D16_FAST_REALTIME_H__
#define __OPTIMAL_AFFINE_TRACKING_3D16_FAST_REALTIME_H__
/* Include files */
#include <math.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "rt_defines.h"
#include "rt_nonfinite.h"
#include "rtwtypes.h"
#include "Optimal_affine_tracking_3d16_fast_realtime_types.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
extern void Optimal_affine_tracking_3d16_fast_realtime(const real_T pty[4], const real_T ptx[4], real_T p[12]);
#endif
/* End of code generation (Optimal_affine_tracking_3d16_fast_realtime.h) */
.svn/pristine/02/026e658b46833cb3a537f165daf7c9fdc0fe41aa.svn-base deleted 100644 → 0
+ 0
− 96
View file @ bab56657
/*
* rtGetNaN.cpp
*
* Code generation for function 'Optimal_affine_tracking_3d16_fast_realtime'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
/*
* Abstract:
* MATLAB for code generation function to initialize non-finite, NaN
*/
#include "rtGetNaN.h"
#define NumBitsPerChar 8U
/* Function: rtGetNaN ==================================================
* Abstract:
* Initialize rtNaN needed by the generated code.
* NaN is initialized as non-signaling. Assumes IEEE.
*/
real_T rtGetNaN(void)
{
size_t bitsPerReal = sizeof(real_T) * (NumBitsPerChar);
real_T nan = 0.0;
if (bitsPerReal == 32U) {
nan = rtGetNaNF();
} else {
uint16_T one = 1U;
enum {
LittleEndian,
BigEndian
} machByteOrder = (*((uint8_T *) &one) == 1U) ? LittleEndian : BigEndian;
switch (machByteOrder) {
case LittleEndian:
{
union {
LittleEndianIEEEDouble bitVal;
real_T fltVal;
} tmpVal;
tmpVal.bitVal.words.wordH = 0xFFF80000U;
tmpVal.bitVal.words.wordL = 0x00000000U;
nan = tmpVal.fltVal;
break;
}
case BigEndian:
{
union {
BigEndianIEEEDouble bitVal;
real_T fltVal;
} tmpVal;
tmpVal.bitVal.words.wordH = 0x7FFFFFFFU;
tmpVal.bitVal.words.wordL = 0xFFFFFFFFU;
nan = tmpVal.fltVal;
break;
}
}
}
return nan;
}
/* Function: rtGetNaNF ==================================================
* Abstract:
* Initialize rtNaNF needed by the generated code.
* NaN is initialized as non-signaling. Assumes IEEE.
*/
real32_T rtGetNaNF(void)
{
IEEESingle nanF = { { 0 } };
uint16_T one = 1U;
enum {
LittleEndian,
BigEndian
} machByteOrder = (*((uint8_T *) &one) == 1U) ? LittleEndian : BigEndian;
switch (machByteOrder) {
case LittleEndian:
{
nanF.wordL.wordLuint = 0xFFC00000U;
break;
}
case BigEndian:
{
nanF.wordL.wordLuint = 0x7FFFFFFFU;
break;
}
}
return nanF.wordL.wordLreal;
}
/* End of code generation (rtGetNaN.cpp) */
.svn/pristine/0a/0a9c657a0e30c25f7f111bca8e72e7822e3ab1c2.svn-base deleted 100644 → 0
+ 0
− 22
View file @ bab56657
<package>
<description brief="iri_depth_tracker">
iri_depth_tracker
</description>
<author>shusain</author>
<license>BSD</license>
<review status="unreviewed" notes=""/>
<url>http://ros.org/wiki/iri_depth_tracker</url>
<depend package="std_msgs"/>
<depend package="rospy"/>
<depend package="roscpp"/>
<depend package="pcl_ros"/>
<depend package="sensor_msgs"/>
<depend package="openni_camera"/>
<depend package="opencv2"/>
<depend package="cv_bridge"/>
</package>
.svn/pristine/0b/0b5a2ad59fc732434fc5c3673a75e2cd9a5f6a24.svn-base deleted 100644 → 0
+ 0
− 21
View file @ bab56657
/*
* rtGetNaN.h
*
* Code generation for function 'Optimal_affine_tracking_3d16_fast_realtime'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
#ifndef __RTGETNAN_H__
#define __RTGETNAN_H__
#include <stddef.h>
#include "rtwtypes.h"
#include "rt_nonfinite.h"
extern real_T rtGetNaN(void);
extern real32_T rtGetNaNF(void);
#endif
/* End of code generation (rtGetNaN.h) */
.svn/pristine/10/109b44a55bd31b137e51e730cd7188ab908d80f9.svn-base deleted 100644 → 0
+ 0
− 34
View file @ bab56657
/*
* Optimal_affine_tracking_3d16_fast_realtime_rtwutil.h
*
* Code generation for function 'Optimal_affine_tracking_3d16_fast_realtime_rtwutil'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
#ifndef __OPTIMAL_AFFINE_TRACKING_3D16_FAST_REALTIME_RTWUTIL_H__
#define __OPTIMAL_AFFINE_TRACKING_3D16_FAST_REALTIME_RTWUTIL_H__
/* Include files */
#include <math.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "rt_defines.h"
#include "rt_nonfinite.h"
#include "rtwtypes.h"
#include "Optimal_affine_tracking_3d16_fast_realtime_types.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
extern real_T rt_hypotd_snf(real_T u0, real_T u1);
#endif
/* End of code generation (Optimal_affine_tracking_3d16_fast_realtime_rtwutil.h) */
.svn/pristine/13/131763b6af4a6c040ecc6be52d0a6d111923eacc.svn-base deleted 100644 → 0
+ 0
− 36
View file @ bab56657
/*
* mean.h
*
* Code generation for function 'mean'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
#ifndef __MEAN_H__
#define __MEAN_H__
/* Include files */
#include <math.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "rt_defines.h"
#include "rt_nonfinite.h"
#include "rtwtypes.h"
#include "Optimal_affine_tracking_3d16_fast_realtime_types.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
extern void b_mean(const real_T x[50], real_T y[2]);
extern void c_mean(const real_T x[3888], real_T y[3]);
extern real_T mean(const real_T x_data[1296], const int32_T x_size[1]);
#endif
/* End of code generation (mean.h) */
.svn/pristine/14/14f6c159607ca491fc1c8adb68044c9f6e8d68e4.svn-base deleted 100644 → 0
+ 0
− 98
View file @ bab56657
/*
* mean.cpp
*
* Code generation for function 'mean'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
/* Include files */
#include "rt_nonfinite.h"
#include "Optimal_affine_tracking_3d16_fast_realtime.h"
#include "mean.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
/* Function Definitions */
void b_mean(const real_T x[50], real_T y[2])
{
int32_T iy;
int32_T ixstart;
int32_T j;
int32_T ix;
real_T s;
int32_T k;
iy = -1;
ixstart = -1;
for (j = 0; j < 2; j++) {
ixstart++;
ix = ixstart;
s = x[ixstart];
for (k = 0; k < 24; k++) {
ix += 2;
s += x[ix];
}
iy++;
y[iy] = s;
}
for (iy = 0; iy < 2; iy++) {
y[iy] /= 25.0;
}
}
void c_mean(const real_T x[3888], real_T y[3])
{
int32_T ix;
int32_T iy;
int32_T i;
int32_T ixstart;
real_T s;
ix = -1;
iy = -1;
for (i = 0; i < 3; i++) {
ixstart = ix + 1;
ix++;
s = x[ixstart];
for (ixstart = 0; ixstart < 1295; ixstart++) {
ix++;
s += x[ix];
}
iy++;
y[iy] = s;
}
for (ixstart = 0; ixstart < 3; ixstart++) {
y[ixstart] /= 1296.0;
}
}
real_T mean(const real_T x_data[1296], const int32_T x_size[1])
{
real_T y;
int32_T k;
if (x_size[0] == 0) {
y = 0.0;
} else {
y = x_data[0];
for (k = 2; k <= x_size[0]; k++) {
y += x_data[k - 1];
}
}
y /= (real_T)x_size[0];
return y;
}
/* End of code generation (mean.cpp) */
.svn/pristine/16/167f1d3c43a2cfc6e986153883d57f83ec4ea7b3.svn-base deleted 100644 → 0
+ 0
− 36
View file @ bab56657
/*
* sum.h
*
* Code generation for function 'sum'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
#ifndef __SUM_H__
#define __SUM_H__
/* Include files */
#include <math.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "rt_defines.h"
#include "rt_nonfinite.h"
#include "rtwtypes.h"
#include "Optimal_affine_tracking_3d16_fast_realtime_types.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
extern void b_sum(const real_T x[7776], real_T y[6]);
extern real_T c_sum(const real_T x[25]);
extern void sum(const real_T x[3888], real_T y[3]);
#endif
/* End of code generation (sum.h) */
.svn/pristine/1b/1bac313be96fde1deb7d0d4494cd4e84559c4b52.svn-base deleted 100644 → 0
+ 0
− 44
View file @ bab56657
/*
* eye.cpp
*
* Code generation for function 'eye'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
/* Include files */
#include "rt_nonfinite.h"
#include "Optimal_affine_tracking_3d16_fast_realtime.h"
#include "eye.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
/* Function Definitions */
void b_eye(real_T I[9])
{
int32_T i;
memset(&I[0], 0, 9U * sizeof(real_T));
for (i = 0; i < 3; i++) {
I[i + 3 * i] = 1.0;
}
}
void eye(real_T I[9])
{
int32_T i;
memset(&I[0], 0, 9U * sizeof(real_T));
for (i = 0; i < 3; i++) {
I[i + 3 * i] = 1.0;
}
}
/* End of code generation (eye.cpp) */
.svn/pristine/1b/1bb4c9d470acd9ee06afb7017a591d8e10c0cd59.svn-base deleted 100644 → 0
+ 0
− 617
View file @ bab56657
/*
* mrdivide.cpp
*
* Code generation for function 'mrdivide'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
/* Include files */
#include "rt_nonfinite.h"
#include "Optimal_affine_tracking_3d16_fast_realtime.h"
#include "mrdivide.h"
#include "log.h"
#include "Optimal_affine_tracking_3d16_fast_realtime_rtwutil.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
static real_T b_eml_xnrm2(int32_T n, const real_T x[12], int32_T ix0);
static real_T eml_xnrm2(int32_T n, const real_T x[12], int32_T ix0);
/* Function Definitions */
static real_T b_eml_xnrm2(int32_T n, const real_T x[12], int32_T ix0)
{
real_T y;
real_T scale;
int32_T kend;
int32_T k;
real_T absxk;
real_T t;
y = 0.0;
if (n == 1) {
y = fabs(x[ix0 - 1]);
} else {
scale = 2.2250738585072014E-308;
kend = (ix0 + n) - 1;
for (k = ix0; k <= kend; k++) {
absxk = fabs(x[k - 1]);
if (absxk > scale) {
t = scale / absxk;
y = 1.0 + y * t * t;
scale = absxk;
} else {
t = absxk / scale;
y += t * t;
}
}
y = scale * sqrt(y);
}
return y;
}
static real_T eml_xnrm2(int32_T n, const real_T x[12], int32_T ix0)
{
real_T y;
real_T scale;
int32_T kend;
int32_T k;
real_T absxk;
real_T t;
y = 0.0;
if (n == 1) {
y = fabs(x[ix0 - 1]);
} else {
scale = 2.2250738585072014E-308;
kend = (ix0 + n) - 1;
for (k = ix0; k <= kend; k++) {
absxk = fabs(x[k - 1]);
if (absxk > scale) {
t = scale / absxk;
y = 1.0 + y * t * t;
scale = absxk;
} else {
t = absxk / scale;
y += t * t;
}
}
y = scale * sqrt(y);
}
return y;
}
void b_mrdivide(const creal_T A[9], const creal_T B[9], creal_T y[9])
{
creal_T b_A[9];
creal_T b_B[9];
int32_T rtemp;
int32_T k;
int32_T r1;
int32_T r2;
int32_T r3;
real_T maxval;
real_T a21;
creal_T Y[9];
for (rtemp = 0; rtemp < 3; rtemp++) {
for (k = 0; k < 3; k++) {
b_A[k + 3 * rtemp].re = B[rtemp + 3 * k].re;
b_A[k + 3 * rtemp].im = -B[rtemp + 3 * k].im;
b_B[k + 3 * rtemp].re = A[rtemp + 3 * k].re;
b_B[k + 3 * rtemp].im = -A[rtemp + 3 * k].im;
}
}
r1 = 0;
r2 = 1;
r3 = 2;
maxval = fabs(b_A[0].re) + fabs(b_A[0].im);
a21 = fabs(b_A[1].re) + fabs(b_A[1].im);
if (a21 > maxval) {
maxval = a21;
r1 = 1;
r2 = 0;
}
if (fabs(b_A[2].re) + fabs(b_A[2].im) > maxval) {
r1 = 2;
r2 = 1;
r3 = 0;
}
b_A[r2] = c_eml_div(b_A[r2], b_A[r1]);
b_A[r3] = c_eml_div(b_A[r3], b_A[r1]);
maxval = b_A[r2].re * b_A[3 + r1].im + b_A[r2].im * b_A[3 + r1].re;
b_A[3 + r2].re -= b_A[r2].re * b_A[3 + r1].re - b_A[r2].im * b_A[3 + r1].im;
b_A[3 + r2].im -= maxval;
maxval = b_A[r3].re * b_A[3 + r1].im + b_A[r3].im * b_A[3 + r1].re;
b_A[3 + r3].re -= b_A[r3].re * b_A[3 + r1].re - b_A[r3].im * b_A[3 + r1].im;
b_A[3 + r3].im -= maxval;
maxval = b_A[r2].re * b_A[6 + r1].im + b_A[r2].im * b_A[6 + r1].re;
b_A[6 + r2].re -= b_A[r2].re * b_A[6 + r1].re - b_A[r2].im * b_A[6 + r1].im;
b_A[6 + r2].im -= maxval;
maxval = b_A[r3].re * b_A[6 + r1].im + b_A[r3].im * b_A[6 + r1].re;
b_A[6 + r3].re -= b_A[r3].re * b_A[6 + r1].re - b_A[r3].im * b_A[6 + r1].im;
b_A[6 + r3].im -= maxval;
if (fabs(b_A[3 + r3].re) + fabs(b_A[3 + r3].im) > fabs(b_A[3 + r2].re) + fabs
(b_A[3 + r2].im)) {
rtemp = r2;
r2 = r3;
r3 = rtemp;
}
b_A[3 + r3] = c_eml_div(b_A[3 + r3], b_A[3 + r2]);
maxval = b_A[3 + r3].re * b_A[6 + r2].im + b_A[3 + r3].im * b_A[6 + r2].re;
b_A[6 + r3].re -= b_A[3 + r3].re * b_A[6 + r2].re - b_A[3 + r3].im * b_A[6 +
r2].im;
b_A[6 + r3].im -= maxval;
for (k = 0; k < 3; k++) {
Y[3 * k] = b_B[r1 + 3 * k];
maxval = Y[3 * k].re * b_A[r2].im + Y[3 * k].im * b_A[r2].re;
Y[1 + 3 * k].re = b_B[r2 + 3 * k].re - (Y[3 * k].re * b_A[r2].re - Y[3 * k].
im * b_A[r2].im);
Y[1 + 3 * k].im = b_B[r2 + 3 * k].im - maxval;
maxval = Y[3 * k].re * b_A[r3].im + Y[3 * k].im * b_A[r3].re;
a21 = Y[1 + 3 * k].re * b_A[3 + r3].im + Y[1 + 3 * k].im * b_A[3 + r3].re;
Y[2 + 3 * k].re = (b_B[r3 + 3 * k].re - (Y[3 * k].re * b_A[r3].re - Y[3 * k]
.im * b_A[r3].im)) - (Y[1 + 3 * k].re * b_A[3 + r3].re - Y[1 + 3 * k].im *
b_A[3 + r3].im);
Y[2 + 3 * k].im = (b_B[r3 + 3 * k].im - maxval) - a21;
Y[2 + 3 * k] = c_eml_div(Y[2 + 3 * k], b_A[6 + r3]);
maxval = Y[2 + 3 * k].re * b_A[6 + r1].im + Y[2 + 3 * k].im * b_A[6 + r1].re;
Y[3 * k].re -= Y[2 + 3 * k].re * b_A[6 + r1].re - Y[2 + 3 * k].im * b_A[6 +
r1].im;
Y[3 * k].im -= maxval;
maxval = Y[2 + 3 * k].re * b_A[6 + r2].im + Y[2 + 3 * k].im * b_A[6 + r2].re;
Y[1 + 3 * k].re -= Y[2 + 3 * k].re * b_A[6 + r2].re - Y[2 + 3 * k].im * b_A
[6 + r2].im;
Y[1 + 3 * k].im -= maxval;
Y[1 + 3 * k] = c_eml_div(Y[1 + 3 * k], b_A[3 + r2]);
maxval = Y[1 + 3 * k].re * b_A[3 + r1].im + Y[1 + 3 * k].im * b_A[3 + r1].re;
Y[3 * k].re -= Y[1 + 3 * k].re * b_A[3 + r1].re - Y[1 + 3 * k].im * b_A[3 +
r1].im;
Y[3 * k].im -= maxval;
Y[3 * k] = c_eml_div(Y[3 * k], b_A[r1]);
}
for (rtemp = 0; rtemp < 3; rtemp++) {
for (k = 0; k < 3; k++) {
y[k + 3 * rtemp].re = Y[rtemp + 3 * k].re;
y[k + 3 * rtemp].im = -Y[rtemp + 3 * k].im;
}
}
}
creal_T c_eml_div(const creal_T x, const creal_T y)
{
creal_T z;
real_T brm;
real_T bim;
real_T d;
if (y.im == 0.0) {
if (x.im == 0.0) {
z.re = x.re / y.re;
z.im = 0.0;
} else if (x.re == 0.0) {
z.re = 0.0;
z.im = x.im / y.re;
} else {
z.re = x.re / y.re;
z.im = x.im / y.re;
}
} else if (y.re == 0.0) {
if (x.re == 0.0) {
z.re = x.im / y.im;
z.im = 0.0;
} else if (x.im == 0.0) {
z.re = 0.0;
z.im = -(x.re / y.im);
} else {
z.re = x.im / y.im;
z.im = -(x.re / y.im);
}
} else {
brm = fabs(y.re);
bim = fabs(y.im);
if (brm > bim) {
bim = y.im / y.re;
d = y.re + bim * y.im;
z.re = (x.re + bim * x.im) / d;
z.im = (x.im - bim * x.re) / d;
} else if (bim == brm) {
if (y.re > 0.0) {
bim = 0.5;
} else {
bim = -0.5;
}
if (y.im > 0.0) {
d = 0.5;
} else {
d = -0.5;
}
z.re = (x.re * bim + x.im * d) / brm;
z.im = (x.im * bim - x.re * d) / brm;
} else {
bim = y.re / y.im;
d = y.im + bim * y.re;
z.re = (bim * x.re + x.im) / d;
z.im = (bim * x.im - x.re) / d;
}
}
return z;
}
void c_mrdivide(const creal_T A[4], const creal_T B[4], creal_T y[4])
{
creal_T b_A[4];
creal_T b_B[4];
int32_T r1;
int32_T r2;
creal_T a21;
creal_T a22;
creal_T Y[4];
int32_T k;
creal_T c_B;
creal_T d_B;
for (r1 = 0; r1 < 2; r1++) {
for (r2 = 0; r2 < 2; r2++) {
b_A[r2 + (r1 << 1)].re = B[r1 + (r2 << 1)].re;
b_A[r2 + (r1 << 1)].im = -B[r1 + (r2 << 1)].im;
b_B[r2 + (r1 << 1)].re = A[r1 + (r2 << 1)].re;
b_B[r2 + (r1 << 1)].im = -A[r1 + (r2 << 1)].im;
}
}
if (fabs(b_A[1].re) + fabs(b_A[1].im) > fabs(b_A[0].re) + fabs(b_A[0].im)) {
r1 = 1;
r2 = 0;
} else {
r1 = 0;
r2 = 1;
}
a21 = c_eml_div(b_A[r2], b_A[r1]);
a22.re = b_A[2 + r2].re - (a21.re * b_A[2 + r1].re - a21.im * b_A[2 + r1].im);
a22.im = b_A[2 + r2].im - (a21.re * b_A[2 + r1].im + a21.im * b_A[2 + r1].re);
for (k = 0; k < 2; k++) {
c_B.re = b_B[r2 + (k << 1)].re - (b_B[r1 + (k << 1)].re * a21.re - b_B[r1 +
(k << 1)].im * a21.im);
c_B.im = b_B[r2 + (k << 1)].im - (b_B[r1 + (k << 1)].re * a21.im + b_B[r1 +
(k << 1)].im * a21.re);
Y[1 + (k << 1)] = c_eml_div(c_B, a22);
d_B.re = b_B[r1 + (k << 1)].re - (Y[1 + (k << 1)].re * b_A[2 + r1].re - Y[1
+ (k << 1)].im * b_A[2 + r1].im);
d_B.im = b_B[r1 + (k << 1)].im - (Y[1 + (k << 1)].re * b_A[2 + r1].im + Y[1
+ (k << 1)].im * b_A[2 + r1].re);
Y[k << 1] = c_eml_div(d_B, b_A[r1]);
}
for (r1 = 0; r1 < 2; r1++) {
for (r2 = 0; r2 < 2; r2++) {
y[r2 + (r1 << 1)].re = Y[r1 + (r2 << 1)].re;
y[r2 + (r1 << 1)].im = -Y[r1 + (r2 << 1)].im;
}
}
}
void mrdivide(const real_T A[12], const real_T B[12], real_T y[9])
{
real_T tau[3];
real_T b_A[12];
real_T b_B[12];
int8_T jpvt[3];
real_T work[3];
int32_T i4;
int32_T itemp;
real_T vn1[3];
real_T vn2[3];
int32_T k;
int32_T iy;
real_T b_y;
real_T wj;
real_T rankR;
real_T t;
int32_T i;
int32_T i_i;
int32_T ix;
int32_T pvt;
int32_T i_ip1;
int32_T lastv;
int32_T lastc;
boolean_T exitg2;
int32_T exitg1;
real_T Y[9];
for (i4 = 0; i4 < 3; i4++) {
for (itemp = 0; itemp < 4; itemp++) {
b_A[itemp + (i4 << 2)] = B[i4 + 3 * itemp];
b_B[itemp + (i4 << 2)] = A[i4 + 3 * itemp];
}
jpvt[i4] = (int8_T)(1 + i4);
work[i4] = 0.0;
}
k = 1;
for (iy = 0; iy < 3; iy++) {
b_y = 0.0;
wj = 2.2250738585072014E-308;
for (itemp = k; itemp <= k + 3; itemp++) {
rankR = fabs(b_A[itemp - 1]);
if (rankR > wj) {
t = wj / rankR;
b_y = 1.0 + b_y * t * t;
wj = rankR;
} else {
t = rankR / wj;
b_y += t * t;
}
}
b_y = wj * sqrt(b_y);
vn1[iy] = b_y;
vn2[iy] = vn1[iy];
k += 4;
}
for (i = 0; i < 3; i++) {
i_i = i + (i << 2);
itemp = 0;
if (3 - i > 1) {
ix = i;
wj = fabs(vn1[i]);
for (k = 1; k + 1 <= 3 - i; k++) {
ix++;
rankR = fabs(vn1[ix]);
if (rankR > wj) {
itemp = k;
wj = rankR;
}
}
}
pvt = i + itemp;
if (pvt + 1 != i + 1) {
ix = pvt << 2;
iy = i << 2;
for (k = 0; k < 4; k++) {
wj = b_A[ix];
b_A[ix] = b_A[iy];
b_A[iy] = wj;
ix++;
iy++;
}
itemp = jpvt[pvt];
jpvt[pvt] = jpvt[i];
jpvt[i] = (int8_T)itemp;
vn1[pvt] = vn1[i];
vn2[pvt] = vn2[i];
}
t = b_A[i_i];
rankR = 0.0;
wj = eml_xnrm2(3 - i, b_A, i_i + 2);
if (wj != 0.0) {
wj = rt_hypotd_snf(fabs(b_A[i_i]), fabs(wj));
if (b_A[i_i] >= 0.0) {
wj = -wj;
}
if (fabs(wj) < 1.0020841800044864E-292) {
itemp = 0;
do {
itemp++;
i4 = i_i - i;
for (k = i_i + 1; k + 1 <= i4 + 4; k++) {
b_A[k] *= 9.9792015476736E+291;
}
wj *= 9.9792015476736E+291;
t *= 9.9792015476736E+291;
} while (!(fabs(wj) >= 1.0020841800044864E-292));
wj = rt_hypotd_snf(fabs(t), fabs(eml_xnrm2(3 - i, b_A, i_i + 2)));
if (t >= 0.0) {
wj = -wj;
}
rankR = (wj - t) / wj;
t = 1.0 / (t - wj);
i4 = i_i - i;
for (k = i_i + 1; k + 1 <= i4 + 4; k++) {
b_A[k] *= t;
}
for (k = 1; k <= itemp; k++) {
wj *= 1.0020841800044864E-292;
}
t = wj;
} else {
rankR = (wj - b_A[i_i]) / wj;
t = 1.0 / (b_A[i_i] - wj);
i4 = i_i - i;
for (k = i_i + 1; k + 1 <= i4 + 4; k++) {
b_A[k] *= t;
}
t = wj;
}
}
tau[i] = rankR;
b_A[i_i] = t;
if (i + 1 < 3) {
t = b_A[i_i];
b_A[i_i] = 1.0;
i_ip1 = (i + ((i + 1) << 2)) + 1;
if (tau[i] != 0.0) {
lastv = 4 - i;
itemp = i_i - i;
while ((lastv > 0) && (b_A[itemp + 3] == 0.0)) {
lastv--;
itemp--;
}
lastc = 2 - i;
exitg2 = FALSE;
while ((exitg2 == FALSE) && (lastc > 0)) {
itemp = i_ip1 + ((lastc - 1) << 2);
k = itemp;
do {
exitg1 = 0;
if (k <= (itemp + lastv) - 1) {
if (b_A[k - 1] != 0.0) {
exitg1 = 1;
} else {
k++;
}
} else {
lastc--;
exitg1 = 2;
}
} while (exitg1 == 0);
if (exitg1 == 1) {
exitg2 = TRUE;
}
}
} else {
lastv = 0;
lastc = 0;
}
if (lastv > 0) {
if (lastc == 0) {
} else {
for (iy = 1; iy <= lastc; iy++) {
work[iy - 1] = 0.0;
}
iy = 0;
i4 = i_ip1 + ((lastc - 1) << 2);
for (pvt = i_ip1; pvt <= i4; pvt += 4) {
ix = i_i;
wj = 0.0;
itemp = (pvt + lastv) - 1;
for (k = pvt; k <= itemp; k++) {
wj += b_A[k - 1] * b_A[ix];
ix++;
}
work[iy] += wj;
iy++;
}
}
if (-tau[i] == 0.0) {
} else {
itemp = i_ip1 - 1;
pvt = 0;
for (iy = 1; iy <= lastc; iy++) {
if (work[pvt] != 0.0) {
wj = work[pvt] * -tau[i];
ix = i_i;
i4 = lastv + itemp;
for (k = itemp; k + 1 <= i4; k++) {
b_A[k] += b_A[ix] * wj;
ix++;
}
}
pvt++;
itemp += 4;
}
}
}
b_A[i_i] = t;
}
for (iy = i + 1; iy + 1 < 4; iy++) {
if (vn1[iy] != 0.0) {
rankR = fabs(b_A[i + (iy << 2)]) / vn1[iy];
b_y = rankR * rankR;
rankR = 1.0 - rankR * rankR;
if (1.0 - b_y < 0.0) {
rankR = 0.0;
}
wj = vn1[iy] / vn2[iy];
if (rankR * (wj * wj) <= 1.4901161193847656E-8) {
vn1[iy] = b_eml_xnrm2(3 - i, b_A, (i + (iy << 2)) + 2);
vn2[iy] = vn1[iy];
} else {
vn1[iy] *= sqrt(rankR);
}
}
}
}
rankR = 0.0;
k = 0;
while ((k < 3) && (!(fabs(b_A[k + (k << 2)]) <= 4.0 * fabs(b_A[0]) *
2.2204460492503131E-16))) {
rankR++;
k++;
}
memset(&Y[0], 0, 9U * sizeof(real_T));
for (iy = 0; iy < 3; iy++) {
if (tau[iy] != 0.0) {
for (k = 0; k < 3; k++) {
wj = b_B[iy + (k << 2)];
for (i = 0; i <= 2 - iy; i++) {
itemp = (iy + i) + 1;
wj += b_A[itemp + (iy << 2)] * b_B[itemp + (k << 2)];
}
wj *= tau[iy];
if (wj != 0.0) {
b_B[iy + (k << 2)] -= wj;
for (i = 0; i <= 2 - iy; i++) {
itemp = (iy + i) + 1;
b_B[itemp + (k << 2)] -= b_A[itemp + (iy << 2)] * wj;
}
}
}
}
}
for (k = 0; k < 3; k++) {
for (i = 0; i < (int32_T)rankR; i++) {
Y[(jpvt[i] + 3 * k) - 1] = b_B[i + (k << 2)];
}
for (iy = 0; iy < (int32_T)-(1.0 + (-1.0 - rankR)); iy++) {
wj = rankR + -(real_T)iy;
Y[(jpvt[(int32_T)wj - 1] + 3 * k) - 1] /= b_A[((int32_T)wj + (((int32_T)wj
- 1) << 2)) - 1];
for (i = 0; i <= (int32_T)wj - 2; i++) {
Y[(jpvt[i] + 3 * k) - 1] -= Y[(jpvt[(int32_T)wj - 1] + 3 * k) - 1] *
b_A[i + (((int32_T)wj - 1) << 2)];
}
}
}
for (i4 = 0; i4 < 3; i4++) {
for (itemp = 0; itemp < 3; itemp++) {
y[itemp + 3 * i4] = Y[i4 + 3 * itemp];
}
}
}
/* End of code generation (mrdivide.cpp) */
.svn/pristine/26/26d14e1a5bddf080c4290eb3d20525c508ba8580.svn-base deleted 100644 → 0
+ 0
− 34
View file @ bab56657
/*
* round.h
*
* Code generation for function 'round'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
#ifndef __ROUND_H__
#define __ROUND_H__
/* Include files */
#include <math.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "rt_defines.h"
#include "rt_nonfinite.h"
#include "rtwtypes.h"
#include "Optimal_affine_tracking_3d16_fast_realtime_types.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
extern void b_round(real_T x[1296]);
#endif
/* End of code generation (round.h) */
.svn/pristine/2c/2c0543c79a50a8ad90a6919d6492c9163a6fd89a.svn-base deleted 100644 → 0
+ 0
− 34
View file @ bab56657
/*
* sqrt.h
*
* Code generation for function 'sqrt'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
#ifndef __SQRT_H__
#define __SQRT_H__
/* Include files */
#include <math.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "rt_defines.h"
#include "rt_nonfinite.h"
#include "rtwtypes.h"
#include "Optimal_affine_tracking_3d16_fast_realtime_types.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
extern void b_sqrt(creal_T *x);
#endif
/* End of code generation (sqrt.h) */
.svn/pristine/32/3244c66cdb9d5a50128e4308eea94f4adeecd3cb.svn-base deleted 100644 → 0
+ 0
− 235
View file @ bab56657
/*
* estimateRigidTransform.cpp
*
* Code generation for function 'estimateRigidTransform'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
/* Include files */
#include "rt_nonfinite.h"
#include "Optimal_affine_tracking_3d16_fast_realtime.h"
#include "estimateRigidTransform.h"
#include "quat2rot.h"
#include "eye.h"
#include "svd.h"
#include "crossTimesMatrix.h"
#include "sum.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
/* Function Definitions */
void estimateRigidTransform(const real_T x[3888], const real_T y[3888], real_T
T[16])
{
static real_T b_x[3888];
static real_T b_y[3888];
int32_T i12;
int32_T i13;
real_T x_centroid[3];
real_T y_centroid[3];
real_T x_centrized[3888];
real_T y_centrized[3888];
real_T b_y_centrized[3888];
static real_T R22[11664];
real_T B[16];
static real_T A[20736];
int32_T ii;
real_T d2;
int32_T i14;
real_T b_B[16];
real_T V[16];
real_T unusedU1[16];
real_T dv6[9];
real_T dv7[9];
real_T dv8[9];
static const int8_T iv6[4] = { 0, 0, 0, 1 };
real_T dv9[16];
/* ESTIMATERIGIDTRANSFORM */
/* [T, EPS] = ESTIMATERIGIDTRANSFORM(X, Y) estimates the rigid transformation */
/* that best aligns x with y (in the least-squares sense). */
/* */
/* Reference: "Estimating Rigid Transformations" in */
/* "Computer Vision, a modern approach" by Forsyth and Ponce (1993), page 480 */
/* (page 717(?) of the newer edition) */
/* */
/* Input: */
/* X: 3xN, N 3-D points (N>=3) */
/* Y: 3xN, N 3-D points (N>=3) */
/* */
/* Output */
/* T: the rigid transformation that aligns x and y as: xh = T * yh */
/* (h denotes homogenous coordinates) */
/* (corrspondence between points x(:,i) and y(:,i) is assumed) */
/* */
/* EPS: the smallest singular value. The closer this value it is */
/* to 0, the better the estimate is. (large values mean that the */
/* transform between the two data sets cannot be approximated */
/* well with a rigid transform. */
/* */
/* Babak Taati, 2003 */
/* (revised 2009) */
for (i12 = 0; i12 < 1296; i12++) {
for (i13 = 0; i13 < 3; i13++) {
b_x[i13 + 3 * i12] = x[i12 + 1296 * i13];
b_y[i13 + 3 * i12] = y[i12 + 1296 * i13];
}
}
/* if nargin ~= 2 */
/* error('Requires two input arguments.') */
/* end */
/* */
/* if size(x,1)~=3 || size(y,1)~=3 */
/* error('Input point clouds must be a 3xN matrix.'); */
/* end */
/* */
/* if size(x, 2) ~= size(y,2) */
/* error('Input point clouds must be of the same size'); */
/* end */
/* */
/* if size(x,2)<3 || size(y,2)<3 */
/* error('At least 3 point matches are needed'); */
/* end */
/* since x has N=3+ points, length shows the number of points */
sum(b_x, x_centroid);
sum(b_y, y_centroid);
for (i12 = 0; i12 < 3; i12++) {
y_centroid[i12] /= 1296.0;
x_centroid[i12] /= 1296.0;
}
for (i12 = 0; i12 < 1296; i12++) {
x_centrized[3 * i12] = b_x[3 * i12] - x_centroid[0];
x_centrized[1 + 3 * i12] = b_x[1 + 3 * i12] - x_centroid[1];
x_centrized[2 + 3 * i12] = b_x[2 + 3 * i12] - x_centroid[2];
y_centrized[3 * i12] = b_y[3 * i12] - y_centroid[0];
y_centrized[1 + 3 * i12] = b_y[1 + 3 * i12] - y_centroid[1];
y_centrized[2 + 3 * i12] = b_y[2 + 3 * i12] - y_centroid[2];
}
for (i12 = 0; i12 < 3; i12++) {
for (i13 = 0; i13 < 1296; i13++) {
b_y[i13 + 1296 * i12] = y_centrized[i12 + 3 * i13] - x_centrized[i12 + 3 *
i13];
}
}
for (i12 = 0; i12 < 3888; i12++) {
b_x[i12] = x_centrized[i12] - y_centrized[i12];
b_y_centrized[i12] = y_centrized[i12] + x_centrized[i12];
}
crossTimesMatrix(b_y_centrized, R22);
memset(&B[0], 0, sizeof(real_T) << 4);
memset(&A[0], 0, 20736U * sizeof(real_T));
for (ii = 0; ii < 1296; ii++) {
A[ii << 4] = 0.0;
for (i12 = 0; i12 < 3; i12++) {
A[((i12 + 1) << 2) + (ii << 4)] = b_y[ii + 1296 * i12];
}
for (i12 = 0; i12 < 3; i12++) {
A[(i12 + (ii << 4)) + 1] = b_x[i12 + 3 * ii];
}
for (i12 = 0; i12 < 3; i12++) {
for (i13 = 0; i13 < 3; i13++) {
A[((i13 + ((i12 + 1) << 2)) + (ii << 4)) + 1] = R22[(i13 + 3 * i12) + 9 *
ii];
}
}
for (i12 = 0; i12 < 4; i12++) {
for (i13 = 0; i13 < 4; i13++) {
d2 = 0.0;
for (i14 = 0; i14 < 4; i14++) {
d2 += A[(i14 + (i12 << 2)) + (ii << 4)] * A[(i14 + (i13 << 2)) + (ii <<
4)];
}
B[i12 + (i13 << 2)] += d2;
}
}
}
memcpy(&b_B[0], &B[0], sizeof(real_T) << 4);
svd(b_B, B, unusedU1, V);
b_eye(dv6);
b_eye(dv7);
quat2rot(*(real_T (*)[4])&V[12], dv8);
for (i12 = 0; i12 < 3; i12++) {
for (i13 = 0; i13 < 3; i13++) {
unusedU1[i13 + (i12 << 2)] = dv7[i13 + 3 * i12];
}
}
for (i12 = 0; i12 < 3; i12++) {
unusedU1[12 + i12] = x_centroid[i12];
}
for (i12 = 0; i12 < 4; i12++) {
unusedU1[3 + (i12 << 2)] = (real_T)iv6[i12];
}
for (i12 = 0; i12 < 3; i12++) {
for (i13 = 0; i13 < 3; i13++) {
V[i13 + (i12 << 2)] = dv8[i13 + 3 * i12];
}
}
for (i12 = 0; i12 < 3; i12++) {
V[12 + i12] = 0.0;
}
for (i12 = 0; i12 < 4; i12++) {
V[3 + (i12 << 2)] = (real_T)iv6[i12];
}
for (i12 = 0; i12 < 4; i12++) {
for (i13 = 0; i13 < 4; i13++) {
dv9[i12 + (i13 << 2)] = 0.0;
for (i14 = 0; i14 < 4; i14++) {
dv9[i12 + (i13 << 2)] += unusedU1[i12 + (i14 << 2)] * V[i14 + (i13 << 2)];
}
}
}
for (i12 = 0; i12 < 3; i12++) {
for (i13 = 0; i13 < 3; i13++) {
unusedU1[i13 + (i12 << 2)] = dv6[i13 + 3 * i12];
}
}
for (i12 = 0; i12 < 3; i12++) {
unusedU1[12 + i12] = -y_centroid[i12];
}
for (i12 = 0; i12 < 4; i12++) {
unusedU1[3 + (i12 << 2)] = (real_T)iv6[i12];
}
for (i12 = 0; i12 < 4; i12++) {
for (i13 = 0; i13 < 4; i13++) {
T[i12 + (i13 << 2)] = 0.0;
for (i14 = 0; i14 < 4; i14++) {
T[i12 + (i13 << 2)] += dv9[i12 + (i14 << 2)] * unusedU1[i14 + (i13 << 2)];
}
}
}
/* Eps = S(4,4); */
}
/* End of code generation (estimateRigidTransform.cpp) */
.svn/pristine/35/35cc346aed2cc126725020b9a95f554bb32c7400.svn-base deleted 100644 → 0
+ 0
− 53
View file @ bab56657
/*
* rt_nonfinite.h
*
* Code generation for function 'Optimal_affine_tracking_3d16_fast_realtime'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
#ifndef __RT_NONFINITE_H__
#define __RT_NONFINITE_H__
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
#include <float.h>
#endif
#include <stddef.h>
#include "rtwtypes.h"
extern real_T rtInf;
extern real_T rtMinusInf;
extern real_T rtNaN;
extern real32_T rtInfF;
extern real32_T rtMinusInfF;
extern real32_T rtNaNF;
extern void rt_InitInfAndNaN(size_t realSize);
extern boolean_T rtIsInf(real_T value);
extern boolean_T rtIsInfF(real32_T value);
extern boolean_T rtIsNaN(real_T value);
extern boolean_T rtIsNaNF(real32_T value);
typedef struct {
struct {
uint32_T wordH;
uint32_T wordL;
} words;
} BigEndianIEEEDouble;
typedef struct {
struct {
uint32_T wordL;
uint32_T wordH;
} words;
} LittleEndianIEEEDouble;
typedef struct {
union {
real32_T wordLreal;
uint32_T wordLuint;
} wordL;
} IEEESingle;
#endif
/* End of code generation (rt_nonfinite.h) */
.svn/pristine/43/43b7b714ed92cd2b3010bbf7055ac637bcafbe67.svn-base deleted 100644 → 0
+ 0
− 58
View file @ bab56657
/*
* crossTimesMatrix.cpp
*
* Code generation for function 'crossTimesMatrix'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
/* Include files */
#include "rt_nonfinite.h"
#include "Optimal_affine_tracking_3d16_fast_realtime.h"
#include "crossTimesMatrix.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
/* Function Definitions */
void crossTimesMatrix(const real_T V[3888], real_T V_times[11664])
{
int32_T i15;
/* CROSSTIMESMATRIX */
/* V_TIMES = CROSSTIMESMATRIX(V) returns a 3x3 (or a series of 3x3) cross times matrices of input vector(s) V */
/* */
/* Input: */
/* V a 3xN matrix, rpresenting a series of 3x1 vectors */
/* */
/* Output: */
/* V_TIMES (Vx) a series of 3x3 matrices where V_times(:,:,i) is the Vx matrix for the vector V(:,i) */
/* */
/* Babak Taati, 2003 */
/* (revised 2009) */
memset(&V_times[0], 0, 11664U * sizeof(real_T));
/* V_times(1,1,:) = 0; */
for (i15 = 0; i15 < 1296; i15++) {
V_times[3 + 9 * i15] = -V[2 + 3 * i15];
V_times[6 + 9 * i15] = V[1 + 3 * i15];
V_times[1 + 9 * i15] = V[2 + 3 * i15];
/* V_times(2,2,:) = 0; */
V_times[7 + 9 * i15] = -V[3 * i15];
V_times[2 + 9 * i15] = -V[1 + 3 * i15];
V_times[5 + 9 * i15] = V[3 * i15];
}
/* V_times(3,3,:) = 0; */
}
/* End of code generation (crossTimesMatrix.cpp) */
.svn/pristine/49/4952aa6db3d613cdb82cfb293b24a1ecb736bc41.svn-base deleted 100644 → 0
+ 0
− 104
View file @ bab56657
/*
* mldivide.cpp
*
* Code generation for function 'mldivide'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
/* Include files */
#include "rt_nonfinite.h"
#include "Optimal_affine_tracking_3d16_fast_realtime.h"
#include "mldivide.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
/* Function Definitions */
void b_mldivide(const real_T A[4], const real_T B[4], real_T Y[4])
{
int32_T r1;
int32_T r2;
real_T a21;
real_T a22;
int32_T k;
if (fabs(A[1]) > fabs(A[0])) {
r1 = 1;
r2 = 0;
} else {
r1 = 0;
r2 = 1;
}
a21 = A[r2] / A[r1];
a22 = A[2 + r2] - a21 * A[2 + r1];
for (k = 0; k < 2; k++) {
Y[1 + (k << 1)] = (B[r2 + (k << 1)] - B[r1 + (k << 1)] * a21) / a22;
Y[k << 1] = (B[r1 + (k << 1)] - Y[1 + (k << 1)] * A[2 + r1]) / A[r1];
}
}
void mldivide(const real_T A[9], const real_T B[9], real_T Y[9])
{
real_T b_A[9];
int32_T r1;
int32_T r2;
int32_T r3;
real_T maxval;
real_T a21;
int32_T rtemp;
memcpy(&b_A[0], (real_T *)&A[0], 9U * sizeof(real_T));
r1 = 0;
r2 = 1;
r3 = 2;
maxval = fabs(A[0]);
a21 = fabs(A[1]);
if (a21 > maxval) {
maxval = a21;
r1 = 1;
r2 = 0;
}
if (fabs(A[2]) > maxval) {
r1 = 2;
r2 = 1;
r3 = 0;
}
b_A[r2] = A[r2] / A[r1];
b_A[r3] /= b_A[r1];
b_A[3 + r2] -= b_A[r2] * b_A[3 + r1];
b_A[3 + r3] -= b_A[r3] * b_A[3 + r1];
b_A[6 + r2] -= b_A[r2] * b_A[6 + r1];
b_A[6 + r3] -= b_A[r3] * b_A[6 + r1];
if (fabs(b_A[3 + r3]) > fabs(b_A[3 + r2])) {
rtemp = r2;
r2 = r3;
r3 = rtemp;
}
b_A[3 + r3] /= b_A[3 + r2];
b_A[6 + r3] -= b_A[3 + r3] * b_A[6 + r2];
for (rtemp = 0; rtemp < 3; rtemp++) {
Y[3 * rtemp] = B[r1 + 3 * rtemp];
Y[1 + 3 * rtemp] = B[r2 + 3 * rtemp] - Y[3 * rtemp] * b_A[r2];
Y[2 + 3 * rtemp] = (B[r3 + 3 * rtemp] - Y[3 * rtemp] * b_A[r3]) - Y[1 + 3 *
rtemp] * b_A[3 + r3];
Y[2 + 3 * rtemp] /= b_A[6 + r3];
Y[3 * rtemp] -= Y[2 + 3 * rtemp] * b_A[6 + r1];
Y[1 + 3 * rtemp] -= Y[2 + 3 * rtemp] * b_A[6 + r2];
Y[1 + 3 * rtemp] /= b_A[3 + r2];
Y[3 * rtemp] -= Y[1 + 3 * rtemp] * b_A[3 + r1];
Y[3 * rtemp] /= b_A[r1];
}
}
/* End of code generation (mldivide.cpp) */
.svn/pristine/49/496c94545f5d6ac147083320a46496bc2e19ce28.svn-base deleted 100644 → 0
+ 0
− 48
View file @ bab56657
/*
* Optimal_affine_tracking_3d16_fast_realtime_rtwutil.cpp
*
* Code generation for function 'Optimal_affine_tracking_3d16_fast_realtime_rtwutil'
*
* C source code generated on: Tue Apr 1 12:30:12 2014
*
*/
/* Include files */
#include "rt_nonfinite.h"
#include "Optimal_affine_tracking_3d16_fast_realtime.h"
#include "Optimal_affine_tracking_3d16_fast_realtime_rtwutil.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
/* Function Definitions */
real_T rt_hypotd_snf(real_T u0, real_T u1)
{
real_T y;
real_T a;
real_T b;
a = fabs(u0);
b = fabs(u1);
if (a < b) {
a /= b;
y = b * sqrt(a * a + 1.0);
} else if (a > b) {
b /= a;
y = a * sqrt(b * b + 1.0);
} else if (rtIsNaN(b)) {
y = b;
} else {
y = a * 1.4142135623730951;
}
return y;
}
/* End of code generation (Optimal_affine_tracking_3d16_fast_realtime_rtwutil.cpp) */
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment