// Computes sum of the values of a unitary blob on grid points. The blob is
// supposed to be at the origin of the absolute coordinate system
double sum_blob_SimpleGrid(const struct blobtype &blob, const SimpleGrid &grid,
const Matrix2D<double> *D)
{
SPEED_UP_temps012;
Matrix1D<double> gr(3), ur(3), corner1(3), corner2(3);
double actual_radius;
int i, j, k;
double sum = 0.0;
// Compute the limits of the blob in the grid coordinate system
grid.universe2grid(vectorR3(-blob.radius, -blob.radius, -blob.radius), corner1);
grid.universe2grid(vectorR3(blob.radius, blob.radius, blob.radius), corner2);
if (D != NULL)
box_enclosing(corner1, corner2, *D, corner1, corner2);
// Compute the sum in the points inside the grid
// The integer part of the vectors is taken for not picking points
// just in the border of the blob, which we know they are 0.
for (i = (int)XX(corner1); i <= (int)XX(corner2); i++)
for (j = (int)YY(corner1); j <= (int)YY(corner2); j++)
for (k = (int)ZZ(corner1); k <= (int)ZZ(corner2); k++)
{
VECTOR_R3(gr, i, j, k);
grid.grid2universe(gr, ur);
if (D != NULL)
M3x3_BY_V3x1(ur, *D, ur);
actual_radius = ur.module();
if (actual_radius < blob.radius)
sum += kaiser_value(actual_radius,
blob.radius, blob.alpha, blob.order);
}
return sum;
}
static PyObject *extract_list(struct pointerlist *root, int values)
{
PyObject *retval;
int i;
unsigned int *kdata;
import_array();
MARK();
XX(print_pointerlist(root));
if (root->size > 0) {
quicksort(root->lst, 0, root->size-1);
}
MARK();
if (values) {
retval = PyList_New(0);
for (i = 0; i < root->size; i++) {
PyList_Append(retval, root->lst[i]->self);
XX(PyObject_Print(root->lst[i]->self, stdout, 0));
XX(printf(" at address %p\n", root->lst[i]->self));
}
MARK();
return retval;
}
retval = PyArray_FromDims(1, (int*)&(root->size), PyArray_INT);
kdata = (unsigned int *) ((PyArrayObject*) retval)->data;
for (i = 0; i < root->size; i++) {
kdata[i] = root->lst[i]->key;
}
MARK();
return PyArray_Return((PyArrayObject*) retval);
}
void actualPhaseFlip(MultidimArray<double> &I, CTFDescription ctf)
{
// Perform the Fourier transform
FourierTransformer transformer;
MultidimArray< std::complex<double> > M_inFourier;
transformer.FourierTransform(I,M_inFourier,false);
Matrix1D<double> freq(2); // Frequencies for Fourier plane
int yDim=YSIZE(I);
int xDim=XSIZE(I);
double iTm=1.0/ctf.Tm;
for (size_t i=0; i<YSIZE(M_inFourier); ++i)
{
FFT_IDX2DIGFREQ(i, yDim, YY(freq));
YY(freq) *= iTm;
for (size_t j=0; j<XSIZE(M_inFourier); ++j)
{
FFT_IDX2DIGFREQ(j, xDim, XX(freq));
XX(freq) *= iTm;
ctf.precomputeValues(XX(freq),YY(freq));
if (ctf.getValuePureWithoutDampingAt()<0)
DIRECT_A2D_ELEM(M_inFourier,i,j)*=-1;
}
}
// Perform inverse Fourier transform and finish
transformer.inverseFourierTransform();
}
double spatial_Bspline03_integralf(double alpha)
{
XX(global_aux) = XX(global_r) + alpha * XX(global_u);
YY(global_aux) = YY(global_r) + alpha * YY(global_u);
ZZ(global_aux) = ZZ(global_r) + alpha * ZZ(global_u);
return spatial_Bspline03LUT(global_aux);
}
/*
* Take the full line (lf) including the command and split it into a
* sub-line (returned) and a completion context (cmplarray).
*/
static LineInfo *
split_line(const char **cmplarray, const LineInfo *lf)
{
static LineInfo li;
const struct cmd *c;
char *cmdname;
char line[LINESIZE];
char *cp;
size_t len;
len = lf->cursor - lf->buffer;
if (len + 1 > sizeof(line))
return NULL;
(void)strlcpy(line, lf->buffer, len + 1);
li.cursor = line + len;
li.lastchar = line + len;
cp = skip_WSP(line);
cmdname = get_cmdname(cp);
cp += strlen(cmdname);
if (cp == li.cursor) {
*cmplarray = "c";
li.buffer = cmdname;
return &li;
}
c = lex(cmdname);
if (c == NULL)
return NULL;
*cmplarray = c->c_complete;
if (c->c_pipe) {
char *cp2;
if ((cp2 = shellpr(cp)) != NULL) {
cp = cp2;
# define XX(a) ((a) + ((a)[1] == '>' ? 2 : 1))
while ((cp2 = shellpr(XX(cp))) != NULL)
cp = cp2;
if (*cp == '|') {
*cmplarray = "xF";
cp = skip_WSP(cp + 1);
}
else {
assert(*cp == '>');
cp = skip_WSP(XX(cp));
*cmplarray = "f";
}
# undef XX
}
}
li.buffer = cp;
return &li;
}
// Apply transformation ---------------------------------------------------
void applyTransformation(const MultidimArray<double> &V2,
MultidimArray<double> &Vaux,
double *p)
{
Matrix1D<double> r(3);
Matrix2D<double> A, Aaux;
double greyScale = p[0];
double greyShift = p[1];
double rot = p[2];
double tilt = p[3];
double psi = p[4];
double scale = p[5];
ZZ(r) = p[6];
YY(r) = p[7];
XX(r) = p[8];
Euler_angles2matrix(rot, tilt, psi, A, true);
translation3DMatrix(r,Aaux);
A = A * Aaux;
scale3DMatrix(vectorR3(scale, scale, scale),Aaux);
A = A * Aaux;
applyGeometry(LINEAR, Vaux, V2, A, IS_NOT_INV, WRAP);
if (greyScale!=1 || greyShift!=0)
FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(Vaux)
DIRECT_MULTIDIM_ELEM(Vaux,n)=DIRECT_MULTIDIM_ELEM(Vaux,n)*greyScale+greyShift;
}
static void linear_filter_reflect( int ntap, float *wt, int npt, float *x )
{
int ii , nt2=(ntap-1)/2 , jj , np1=npt-1 , np2=2*(npt-1) ;
register float sum ;
static int nfar=0 ;
static float *far=NULL ;
if( ntap >= npt || wt == NULL || x == NULL ) return ;
if( npt > nfar ){
if( far != NULL ) free(far) ;
far = (float *)malloc(sizeof(float)*npt) ; nfar = npt ;
}
#undef XX
#define XX(i) ( ((i)<0) ? far[-(i)] : ((i)>np1) ? far[np2-(i)] : far[(i)] )
memcpy( far , x , sizeof(float)*npt ) ;
for( ii=0 ; ii < npt ; ii++ ){
for( sum=0.0f,jj=0 ; jj < ntap ; jj++ ) sum += wt[jj] * XX(ii-nt2+jj) ;
x[ii] = sum ;
}
return ;
}
// 解析 & 更新
// 并将发生变化的行，打印出来
bool mktdt_file::Parse(char* src, const int32_t src_len, mktdt_file_data& data) {
int32_t pos = 0;
int32_t len = 0;
int32_t i_header = 0, i_md001 = 0, i_md002 = 0, i_md003 = 0, i_md004 = 0, i_trailer = 0;
int32_t CheckSumLine; // 用来存储每行的校验码
mktdt_line dtline;
// header
XX(HEADER, _header);
// 6 为标识符长度
while (pos + 6 < src_len) {
XX(MD001, _md001)
else XX(MD002, _md002)
else XX(MD003, _md003)
else XX(MD004, _md004)
else XX(TRAILER, _trailer)
else {
char pbuf[32];
snprintf(pbuf, sizeof(pbuf) - 1, "%s", src + pos);
fprintf(stdout, "err: %s \n", pbuf);
dtline.find_end(src, len);
}
}
return true;
}
void linear_filter_trend( int ntap , float *wt , int npt , float *x )
{
int ii , nt2=(ntap-1)/2 , jj ;
float sum ;
static int nfar=0 ;
static float *far=NULL ;
float a=0.0,b=0.0 ;
if( npt > nfar ){
if(far != NULL) free(far) ;
far = (float *)malloc(sizeof(float)*npt) ; nfar = npt ;
}
#undef XX
#define XX(i) ( ((i)<0 || (i)>npt-1) ? (a+b*(i)) : far[i] )
memcpy( far , x , sizeof(float)*npt ) ;
get_linear_trend( npt,far , &a,&b ) ; /* cf. thd_detrend.c */
for( ii=0 ; ii < npt ; ii++ ){
for( sum=0.0,jj=0 ; jj < ntap ; jj++ ) sum += wt[jj] * XX(ii-nt2+jj) ;
x[ii] = sum ;
}
return ;
}
int XX(int n){
if (n == 0){
return 0;
}else{
return XX (n/3+1) + n;
}
}
/* \def kernelRBF
* RBF kernel for support vector machine.
*/
Array SVM::kernelRBF(Array &X1, Array &X2, double sigma)
{
int n1 = X1.rows;
int n2 = X2.rows;
int step = X1.cols;
Array XX(n1, n2);
double *_X1 = X1.getData();
double *_X2 = X2.getData();
double *_XX = XX.getData();
double Z = 1 / sqrt(2 * M_PI * sigma * sigma);
for(int i = 0;i < n1;i++)
{
for(int j = 0;j < n2;j++)
{
double dist = 0;
for(int k = 0;k < step;k++)
dist += ( _X1[i * step + k] - _X2[j * step + k] ) * ( _X1[i * step + k] - _X2[j * step + k] );
_XX[i * n2 + j ] = Z * exp( -dist / (2 * sigma * sigma));
}
}
return XX;
}
static int bloch_jacobian(long int N, realtype t,
N_Vector M, N_Vector fM, DlsMat J, void *user_data,
N_Vector tmp1, N_Vector tmp2, N_Vector tmp3)
{
struct bloch_sim *bs = (struct bloch_sim*)user_data;
int i;
for (i=0; i < bs->num_cells; ++i)
{
realtype dw = bs->cell_frequencies[i] - bs->w_avg;
realtype w_1 = bs->rf_on ? bs->w_1 : 0.0;
XX(J,i) = -1 / bs->T_2;
XY(J,i) = dw;
XZ(J,i) = 0.0;
YX(J,i) = -dw;
YY(J,i) = -1 / bs->T_2;
YZ(J,i) = w_1;
ZX(J,i) = 0.0;
ZY(J,i) = -w_1;
ZZ(J,i) = -1 / bs->T_1;
}
return 0;
}
static PyObject * add_to_pointerlist(struct pointerlist *n, struct key_thing *other)
{
HEX(n);
HEX(other);
INT(other->key);
HEX(other->self);
XX(print_pointerlist(n));
if (n == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"add_to_pointerlist: null list??");
return NULL;
}
if (other == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"add_to_pointerlist: second arg is NULL");
return NULL;
}
if (other->key == 0) {
printf("BADNESS: ");
PyObject_Print(other->self, stdout, 0);
printf("\n");
PyErr_SetString(PyExc_RuntimeError,
"add_to_pointerlist: key is zero");
return NULL;
}
/* we already have somebody with the same key, so remove it */
if (has_key(n, other->key) != NULL) {
if (remove_from_pointerlist(n, other->key) == NULL)
return NULL;
}
n->size++;
if (n->size > n->arraysize) {
printf("GROW LIST FROM %d to %d\n", n->arraysize, 2 * n->arraysize);
n->arraysize *= 2;
n->lst = (struct key_thing **)
realloc(n->lst, n->arraysize * sizeof(struct key_thing *));
}
n->lst[n->size-1] = other;
Py_INCREF(other->self);
MARK();
XX(print_pointerlist(n));
Py_INCREF(Py_None);
return Py_None;
}
std::string Ioss::Sym_Tensor_10::label(int which, const char) const
{
assert(which > 0 && which <= component_count());
switch(which) {
case 1: return XX();
default: return "";
}
}
int ds_abort(const char * msg, const char * exp, const char * file, int line)
{
int len;
char buf[2048];
char * pslash = NULL;
PROCESS_MEMORY_COUNTERS pmc;
DWORD error = GetLastError();
DWORD wsa_error = WSAGetLastError();
len = GetModuleFileName(NULL, buf, sizeof(buf));
if (len > 0 && len < sizeof(buf)) {
FILE * exception;
pslash = strstr(buf, ".exe");
if (pslash && !pslash[4]) {
*pslash = 0;
}
strncat(buf, ".exception", sizeof(buf));
exception = fopen(buf, "a");
if (exception != NULL) {
pmc.cb = sizeof(pmc);
XP_GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
fprintf(exception, "msg: %s\n", msg);
fprintf(exception, "exp: %s\n", exp);
fprintf(exception, "time: %ld\n", time(NULL));
fprintf(exception, "error: %d, [%d]\n", error, wsa_error);
fprintf(exception, "file %s, line %d\n", file, line);
#define XX(f) fprintf(exception, "%s: %uK %u\n", #f, pmc.f / 1024, pmc.f);
XX(PageFaultCount);
XX(WorkingSetSize);
XX(QuotaPagedPoolUsage);
XX(QuotaNonPagedPoolUsage);
XX(PagefileUsage);
XX(PeakWorkingSetSize);
XX(QuotaPeakPagedPoolUsage);
XX(QuotaPeakNonPagedPoolUsage);
XX(PeakPagefileUsage);
#undef XX
fclose(exception);
}
}
RaiseException(EXCEPTION_BREAKPOINT, 0, 0, 0);
abort();
return 0;
}
/* Makes fingerprint of file contents (all or part of it of fixed size).
* Returns the fingerprint as a string, which is empty or NULL on error. */
static char *
get_contents_fingerprint(const char path[], const dir_entry_t *entry)
{
#if INTPTR_MAX == INT64_MAX
#define XX_BITS 64
#else
#define XX_BITS 32
#endif
#define XX__(name, bits) XXH ## bits ## _ ## name
#define XX_(name, bits) XX__(name, bits)
#define XX(name) XX_(name, XX_BITS)
XX(state_t) st;
char block[BLOCK_SIZE];
size_t to_read = PREFIX_SIZE;
FILE *in = os_fopen(path, "rb");
if(in == NULL)
{
return strdup("");
}
XX(reset)(&st, 0U);
while(to_read != 0U)
{
const size_t portion = MIN(sizeof(block), to_read);
const size_t nread = fread(&block, 1, portion, in);
if(nread == 0U)
{
break;
}
XX(update)(&st, block, nread);
to_read -= nread;
}
fclose(in);
return format_str("%" PRINTF_ULL "|%" PRINTF_ULL,
(unsigned long long)entry->size, (unsigned long long)XX(digest)(&st));
#undef XX_BITS
#undef XX__
#undef XX_
#undef XX
}
main() {
setlocale(LC_ALL,"Portuguese");
int n;
int x;
printf("Entre com um numero inteiro positivo: ");
scanf("%d",&n);
x = XX(n);
printf("%d",x);
getch();
}
std::string Ioss::Matrix_22::label(int which, const char) const
{
assert(which > 0 && which <= component_count());
switch(which) {
case 1: return XX();
case 2: return XY();
case 3: return YX();
case 4: return YY();
default: return "";
}
}
std::string Ioss::Sym_Tensor_33::label(int which, const char) const
{
assert(which > 0 && which <= component_count());
switch(which) {
case 1: return XX();
case 2: return YY();
case 3: return ZZ();
case 4: return XY();
case 5: return YZ();
case 6: return ZX();
default: return "";
}
}
static PyObject *remove_from_pointerlist(struct pointerlist *head, unsigned int otherkey)
{
int i;
MARK();
XX(printf("\n"));
INT(otherkey);
XX(print_pointerlist(head));
if (head == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"remove_from_pointerlist: empty list");
return NULL;
}
MARK();
/* find item to be removed, if it's here */
for (i = 0; i < head->size; i++) {
if (otherkey == head->lst[i]->key)
break;
}
MARK();
if (i == head->size) {
PyErr_SetString(PyExc_RuntimeError,
"remove_from_pointerlist: no such entry");
return NULL;
}
MARK();
if (head->lst[i]->self == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"remove_from_pointerlist: object to be removed is null");
return NULL;
}
Py_DECREF(head->lst[i]->self);
memmove(&head->lst[i], &head->lst[i+1],
(head->size - 1 - i) * sizeof(void*));
head->size--;
MARK();
XX(print_pointerlist(head));
Py_INCREF(Py_None);
return Py_None;
}
/* Sum spline on a grid ---------------------------------------------------- */
double sum_spatial_Bspline03_SimpleGrid(const SimpleGrid &grid)
{
Matrix1D<double> gr(3), ur(3), corner1(3), corner2(3);
int i, j, k;
double sum = 0.0;
// Compute the limits of the spline in the grid coordinate system
grid.universe2grid(vectorR3(-2.0, -2.0, -2.0), corner1);
grid.universe2grid(vectorR3(2.0, 2.0, 2.0), corner2);
// Compute the sum in the points inside the grid
// The integer part of the vectors is taken for not picking points
// just in the border of the spline, which we know they are 0.
for (i = (int)XX(corner1); i <= (int)XX(corner2); i++)
for (j = (int)YY(corner1); j <= (int)YY(corner2); j++)
for (k = (int)ZZ(corner1); k <= (int)ZZ(corner2); k++)
{
VECTOR_R3(gr, i, j, k);
grid.grid2universe(gr, ur);
sum += spatial_Bspline03(ur);
}
return sum;
}
void do_the_thing(t_env *e, float angle, int length, int change)
{
(void)change;
while (e->inc < 13)
{
// length = LY - e->yn;
length = e->b;
draw_polar(e->xn, e->yn, 270, length, e, VIOLET);
length = e->mp - e->xn;
e->mp = e->xn;
draw_polar(XO, YO, 180, length, e, BLUE);
length = get_both(XX(1), YY(1), LX, LY, e);
draw_polar(XO, YO, angle, length, e, ORANGE);
}
}
/* Transform all coordinates ---------------------------------------------- */
void Micrograph::transform_coordinates(const Matrix2D<double> &M)
{
Matrix1D<double> m(3);
SPEED_UP_temps012;
int imax = coords.size();
for (int i = 0; i < imax; i++)
{
if (coords[i].valid)
{
VECTOR_R3(m, coords[i].X, coords[i].Y, 1);
M3x3_BY_V3x1(m, M, m);
coords[i].X = (int) XX(m);
coords[i].Y = (int) YY(m);
}
}
}
/* Passing to tilted ------------------------------------------------------- */
void TiltPairAligner::passToUntilted(int _mtX, int _mtY, int &_muX, int &_muY)
{
if (Nu > 3)
{
SPEED_UP_temps012;
VECTOR_R3(m, _mtX, _mtY, 1);
M3x3_BY_V3x1(m, Ptu, m);
_muX = (int) XX(m);
_muY = (int) YY(m);
}
else
{
_muX = _mtX;
_muY = _mtY;
}
}
static BOOL
PxImageView_OpenFileDialog(PxImageViewObject* self)
{
OPENFILENAME ofn;
wchar_t szFilter[] = L"Bitmap (*.BMP)\0*.bmp\0";
wchar_t szOpenFileNamePath[MAX_PATH];
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = g.hWin;
ofn.hInstance = NULL;
ofn.lpstrFilter = szFilter;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 0;
ofn.lpstrFile = szOpenFileNamePath;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = MAX_PATH;
ofn.lpstrInitialDir = NULL;
ofn.lpstrTitle = NULL; //L"Select File"
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST; //OFN_HIDEREADONLY | OFN_CREATEPROMPT ;
ofn.nFileOffset = 0;
ofn.nFileExtension = 0;
ofn.lpstrDefExt = L"bmp";
ofn.lCustData = 0L;
ofn.lpfnHook = NULL;
ofn.lpTemplateName = NULL;
OutputDebugString(L"PxImageView_OpenFileDialog\n");
if (GetOpenFileNameW(&ofn)) {
OutputDebugString(L"iv4!\n");
LPCSTR sOpenFileNamePath = toU8(szOpenFileNamePath);
MessageBoxA(NULL, sOpenFileNamePath, "jj", NULL);
PyObject* pyArgs = Py_BuildValue("s", sOpenFileNamePath);
PyObject* pyImage;
PxASSIGN(pyImage = PyObject_CallObject((PyObject*)&PxImageType, pyArgs));
XX(pyImage);
Py_DECREF(pyArgs);
PyMem_RawFree(sOpenFileNamePath);
PxImageView_SetData(self, pyImage);
Py_DECREF(pyImage);
}
return TRUE;
}
/* \def kernelLinear
* Linear kernel for support vector machine.
*/
Array SVM::kernelLinear(Array &X1, Array &X2)
{
int n1 = X1.rows;
int n2 = X2.rows;
Array XX(n1, n2);
double *_X1 = X1.getData();
double *_X2 = X2.getData();
double *_XX = XX.getData();
int step = XX.cols;
for(int i = 0;i < XX.rows;i++)
{
for(int j = 0;j < XX.cols;j++)
_XX[i * step + j ] = _X1[i] * _X2[j];
}
return XX;
}
int main(int argc, char **argv){
ros::init(argc,argv,"observer");
ros::NodeHandle n;
ros::Subscriber drone_sub = n.subscribe<visualization_msgs::Marker>("/drone",1000,callback_drone);
ros::Subscriber est_sub = n.subscribe<visualization_msgs::Marker>("/drone_estimation",1000,callback_estim);
ros::Publisher pub = n.advertise<std_msgs::Float64MultiArray>("/errors", 1000);
ros::Rate loop_rate(100);
std_msgs::Float64MultiArray msg;
msg.layout.dim.push_back(std_msgs::MultiArrayDimension());
msg.layout.dim[0].size = 3;
msg.layout.dim[0].stride = 1;
msg.layout.dim[0].label = "errors";
D_VCT XXd(3,0);
D_VCT XX(3,0);
D_VCT::iterator i1 = XXd.begin();
D_VCT::iterator i2 = XX.begin();
Xd.assign(i1,XXd.end());
X.assign(i2,XX.end());
std::cout << Xd[0] << std::endl;
std::cout << X[1] << std::endl;
D_VCT Y(3,0);
std::cout << "hello" << std::endl;
while(ros::ok()){
msg.data.clear();
Y[0] = Xd[0]-X[0];
Y[1] = Xd[1]-X[1];
Y[2] = Xd[2]-X[2];
std::cout << "hello" << std::endl;
msg.data.insert(msg.data.end(),Y.begin(),Y.end());
pub.publish(msg);
ros::spinOnce();
loop_rate.sleep();
}
}
void * resfunc_fixup(const char * name)
{
#define XX(f) \
if (strcmp(name, #f) == 0) { \
printf("name: %s\n", name); \
return (void *)f##fixup; \
}
XX(LoadIconW);
XX(LoadIconA);
XX(LoadAcceleratorsA);
XX(LoadCursorA);
XX(LoadCursorW);
XX(LoadStringW);
XX(LoadStringA);
#undef XX
return NULL;
};
MVTR::MvtRegModel(const Mat &X,const Mat &Y, bool add_intercept)
: ParamPolicy(new MatrixParams(X.ncol() + add_intercept,Y.ncol()),
new SpdParams(Y.ncol()),
new UnivParams(default_df))
{
Mat XX(add_intercept? cbind(1.0,X) : X);
QR qr(XX);
Mat Beta(qr.solve(qr.QtY(Y)));
Mat resid = Y - XX* Beta;
uint n = XX.nrow();
Spd Sig = resid.t() * resid/n;
set_Beta(Beta);
set_Sigma(Sig);
for(uint i=0; i<n; ++i){
Vec y = Y.row(i);
Vec x = XX.row(i);
NEW(MvRegData, dp)(y,x);
DataPolicy::add_data(dp);
}
}
SVECTORf BackPropagation::predict(const SVECTORf& X0)
{
if ( options.get("mapping_type", "linear") == "linear")
{
size_t D = W.cols();
SVECTORf XX(D);
XX << X0, 1.0f;
SVECTORf Yout = W * XX;
return Yout;
}
else
{
SVECTORf logX0_ = X0.array().log();
SVECTORf log_one_minux_X0_ = (1.0f-X0.array()).log();
SVECTORf Yout = A.array() - (W * logX0_ + Q * log_one_minux_X0_).array();
Yout = Yout.array() / (Yout.array() + B.array() - (S * logX0_ + T * log_one_minux_X0_).array() );
return Yout;
}
std::cerr << "Internal error: BackPropagation::predict: specified method " << options.get("mapping_type", "") << " is not supported." << std::endl;
exit(-1);
}
