void CtcPolytopeHull::NeumaierShcherbina_postprocessing ( int nr, int var, Interval & obj, IntervalVector& box,
Matrix & A_trans, IntervalVector& B, Vector & dual_solution, bool minimization) {
//std::cout <<" BOUND_test "<<std::endl;
IntervalVector Rest(nb_var);
IntervalVector Lambda(nr);
for (int i=0; i<nr; i++) {
Lambda[i]=dual_solution[i];
}
Rest = A_trans * Lambda ; // Rest = Transpose(As) * Lambda
if (minimization==true)
Rest[var] -=1; // because C is a vector of zero except for the coef "var"
else
Rest[var] +=1;
// cout << " Rest " << Rest << endl;
// cout << " dual " << Lambda << endl;
// cout << " dual B " << Lambda * B << endl;
// cout << " rest box " << Rest * box << endl;
if(minimization==true)
obj = Lambda * B - Rest * box;
else
obj = -(Lambda * B - Rest * box);
}
void TStringKernel::WhoAmI(const TStr& intro) const {
switch (KernelType.Val) {
case 0: printf("%s KDynamic [Lambda=%.3f, LinComb=", intro.CStr(), Lambda());
for (int i = 0; i < LinCombV.Len(); i++) printf(" %d:%g", i+2, LinCombV[i]());
printf("]\n"); break;
case 1: printf("%s [KDynamicLCW]: LinComb = ", intro.CStr());
for (int i = 0; i < LinCombV.Len(); i++) printf("%d:%g ", i+2, LinCombV[i]());
printf("\n"); break;
case 2: printf("%s KTrie [Lambda = %g, SeqLen = %d, GapLen = %d, AlphN = %d]\n",
intro.CStr(), Lambda(), SeqLen(), GapLen(), AlphN()); break;
case 3: printf("%s KTrie2 [Lambda = %g, SeqLen = %d, GapLen = %d, AlphN = %d]\n",
intro.CStr(), Lambda(), SeqLen(), GapLen(), AlphN()); break;
case 4: printf("%s KDynamicSM+WordNet [Lambda=%.3f LinComb=", intro.CStr(), Lambda());
for (int i = 0; i < LinCombV.Len(); i++) printf(" %d:%g", i+2, LinCombV[i]());
printf("]\n"); break;
}
}
int main(){
std::array<size_t, 10> array;
using range = boost::mpl::range_c<size_t, 1, 12>;
boost::mpl::for_each<range>(Lambda(array));
for(auto a : array)
std::cout << a << std::endl;
return 0;
}
bool Application::unapplyVariables(const Object& e,
const Object& l,
const Object& r,
Environment &env)
{
auto lId = checkType<Identifier>(env, l);
auto rId = checkType<Identifier>(env, r);
auto lvalue = lId ? env.getEqual(cast<Identifier>(env, l)->name) : l;
if (auto q = cast<Quote>(env, lvalue))
{
auto qe = cast<QuotedExpression>(env, q->apply(r, env));
return qe->unapplyVariables(e, env);
}
if (auto f = cast<Morphism>(env, lvalue))
{
auto inverse = cast<Morphism>(env, f->inverse());
if (inverse)
if (!checkType<Void>(env, inverse))
{
auto inversed = inverse->apply(e, env);
auto unapplied = r->unapplyVariables(inversed, env);
return unapplied;
}
}
if (lId)
{
auto newEnv = env;
newEnv.addEqual(cast<Identifier>(env, l)->name,
makeOperation<Lambda>(r, e), true);
auto closure = Lambda().operate(r, e, newEnv);
env.addEqual(cast<Identifier>(env, l)->name,
closure, false);
auto ret = env.get(cast<Identifier>(env, l)->name);
return !checkType<Void>(env, ret);
}
// Otherwise, 'unapply' the application, turning right side into function
// For example, `f x = y ----> f = x -> y`
auto closure = makeOperation<Lambda>(r, e);
return l->unapplyVariables(closure, env);
}
void CNMFModel::NormalizeW()
{
assert(m_iNbBasis==m_H.NRows());
assert(m_iDataDimension==m_W.NRows());
CVisDMatrix Lambda(m_iNbBasis, m_iNbBasis), InvLambda(m_iNbBasis, m_iNbBasis);
Lambda = 0.0;
InvLambda = 0.0;
for ( int i=0; i<m_iNbBasis; i++ )
{
double tempf = VisDVectorSumL2(m_W.Column(i)) + 1e-9;
Lambda[i][i] = tempf;
InvLambda[i][i] = 1./tempf;
}
m_W = m_W * InvLambda;
m_H = Lambda * m_H;
}
bool CtcPolytopeHull::NeumaierShcherbina_infeasibilitytest(int nr, IntervalVector& box,
Matrix& A_trans, IntervalVector& B, Vector& infeasible_dir) {
IntervalVector Lambda(nr);
for (int i =0; i<nr; i++) {
Lambda[i]=infeasible_dir[i];
}
IntervalVector Rest(nb_var);
Rest = A_trans * Lambda ;
Interval d= Rest *box - Lambda * B;
// if 0 does not belong to d, the infeasibility is proved
if (d.contains(0.0))
return false;
else
return true;
}
int main()
{
double Av[9] = {2.0, 1.0, 1.0,
1.0, 2.0, 1.0,
1.0, 1.0, 2.0, };
Matrix<double> A(3, 3, Av);
Matrix<double> B = 0.5 * Transpose(A) * A;
printf("Matrix:\n");
B.Print();
char outputFilename[96] = "BMatrix";
B.Save(outputFilename);
Matrix<double> Q(3,3); // will hold eigenvectors
Matrix<double> Lambda(3,1); // will hold eigenvalues
B.SymmetricEigenDecomposition(Q, Lambda);
printf("Eigenvalues:\n");
Lambda.Print();
return 0;
}
double delta(int jd) {
double sdelta = sin(oblique(jd)) * sin(Lambda(jd));
return atan(sdelta / sqrt(1.0 - sdelta * sdelta));
}
bool Reed_Solomon::decode(const bvec &coded_bits, const ivec &erasure_positions, bvec &decoded_message, bvec &cw_isvalid)
{
bool decoderfailure, no_dec_failure;
int j, i, kk, l, L, foundzeros, iterations = floor_i(static_cast<double>(coded_bits.length()) / (n * m));
bvec mbit(m * k);
decoded_message.set_size(iterations * k * m, false);
cw_isvalid.set_length(iterations);
GFX rx(q, n - 1), cx(q, n - 1), mx(q, k - 1), ex(q, n - 1), S(q, 2 * t), Xi(q, 2 * t), Gamma(q), Lambda(q),
Psiprime(q), OldLambda(q), T(q), Omega(q);
GFX dummy(q), One(q, (char*)"0"), Omegatemp(q);
GF delta(q), tempsum(q), rtemp(q), temp(q), Xk(q), Xkinv(q);
ivec errorpos;
if ( erasure_positions.length() ) {
it_assert(max(erasure_positions) < iterations*n, "Reed_Solomon::decode: erasure position is invalid.");
}
no_dec_failure = true;
for (i = 0; i < iterations; i++) {
decoderfailure = false;
//Fix the received polynomial r(x)
for (j = 0; j < n; j++) {
rtemp.set(q, coded_bits.mid(i * n * m + j * m, m));
rx[j] = rtemp;
}
// Fix the Erasure polynomial Gamma(x)
// and replace erased coordinates with zeros
rtemp.set(q, -1);
ivec alphapow = - ones_i(2);
Gamma = One;
for (j = 0; j < erasure_positions.length(); j++) {
rx[erasure_positions(j)] = rtemp;
alphapow(1) = erasure_positions(j);
Gamma *= (One - GFX(q, alphapow));
}
//Fix the syndrome polynomial S(x).
S.clear();
for (j = 1; j <= 2 * t; j++) {
S[j] = rx(GF(q, b + j - 1));
}
// calculate the modified syndrome polynomial Xi(x) = Gamma * (1+S) - 1
Xi = Gamma * (One + S) - One;
// Apply Berlekam-Massey algorithm
if (Xi.get_true_degree() >= 1) { //Errors in the received word
// Iterate to find Lambda(x), which hold all error locations
kk = 0;
Lambda = One;
L = 0;
T = GFX(q, (char*)"-1 0");
while (kk < 2 * t) {
kk = kk + 1;
tempsum = GF(q, -1);
for (l = 1; l <= L; l++) {
tempsum += Lambda[l] * Xi[kk - l];
}
delta = Xi[kk] - tempsum;
if (delta != GF(q, -1)) {
OldLambda = Lambda;
Lambda -= delta * T;
if (2 * L < kk) {
L = kk - L;
T = OldLambda / delta;
}
}
T = GFX(q, (char*)"-1 0") * T;
}
// Find the zeros to Lambda(x)
errorpos.set_size(Lambda.get_true_degree());
foundzeros = 0;
for (j = q - 2; j >= 0; j--) {
if (Lambda(GF(q, j)) == GF(q, -1)) {
errorpos(foundzeros) = (n - j) % n;
foundzeros += 1;
if (foundzeros >= Lambda.get_true_degree()) {
break;
}
}
}
if (foundzeros != Lambda.get_true_degree()) {
decoderfailure = true;
}
else { // Forney algorithm...
//Compute Omega(x) using the key equation for RS-decoding
Omega.set_degree(2 * t);
Omegatemp = Lambda * (One + Xi);
for (j = 0; j <= 2 * t; j++) {
Omega[j] = Omegatemp[j];
}
//Find the error/erasure magnitude polynomial by treating them the same
Psiprime = formal_derivate(Lambda*Gamma);
errorpos = concat(errorpos, erasure_positions);
ex.clear();
for (j = 0; j < errorpos.length(); j++) {
Xk = GF(q, errorpos(j));
Xkinv = GF(q, 0) / Xk;
// we calculate ex = - error polynomial, in order to avoid the
// subtraction when recunstructing the corrected codeword
ex[errorpos(j)] = (Xk * Omega(Xkinv)) / Psiprime(Xkinv);
if (b != 1) { // non-narrow-sense code needs corrected error magnitudes
int correction_exp = ( errorpos(j)*(1-b) ) % n;
ex[errorpos(j)] *= GF(q, correction_exp + ( (correction_exp < 0) ? n : 0 ));
}
}
//Reconstruct the corrected codeword.
// instead of subtracting the error/erasures, we calculated
// the negative error with 'ex' above
cx = rx + ex;
//Code word validation
S.clear();
for (j = 1; j <= 2 * t; j++) {
S[j] = cx(GF(q, b + j - 1));
}
if (S.get_true_degree() >= 1) {
decoderfailure = true;
}
}
}
else {
cx = rx;
decoderfailure = false;
}
//Find the message polynomial
mbit.clear();
if (decoderfailure == false) {
if (cx.get_true_degree() >= 1) { // A nonzero codeword was transmitted
if (systematic) {
for (j = 0; j < k; j++) {
mx[j] = cx[j];
}
}
else {
mx = divgfx(cx, g);
}
for (j = 0; j <= mx.get_true_degree(); j++) {
mbit.replace_mid(j * m, mx[j].get_vectorspace());
}
}
}
else { //Decoder failure.
// for a systematic code it is better to extract the undecoded message
// from the received code word, i.e. obtaining a bit error
// prob. p_b << 1/2, than setting all-zero (p_b = 1/2)
if (systematic) {
mbit = coded_bits.mid(i * n * m, k * m);
}
else {
mbit = zeros_b(k);
}
no_dec_failure = false;
}
decoded_message.replace_mid(i * m * k, mbit);
cw_isvalid(i) = (!decoderfailure);
}
return no_dec_failure;
}
DEM read_dem ()
{
int c;
DEM f, a, b, d, x;
int i;
char buf[200];
DEM s;
DEM d1;
int flags1;
DEM used1;
extern DEM used;
loop:
do c = readchar ();
while (c==' ' || c=='\t' || c=='\n' || c==0);
switch (c)
{
case 'I': return I;
case 'K': return K;
case 'S': return S;
case 'E': return E;
case 'F': return If;
case 'O': return Ord;
case '-':
f = read_dem ();
a = read_dem ();
return ap (f, a);
case '/':
a = read_dem ();
b = read_dem ();
return transym (a, b);
case 'T':
a = read_dem ();
b = read_dem ();
return trans (a, b);
case 'X':
a = read_dem ();
return sym (a);
case '#':
a = read_dem ();
b = read_dem ();
return Axm (a, b);
case 'i':
a = read_dem ();
return defI (a);
case 'k':
a = read_dem ();
b = read_dem ();
return defK (a, b);
case 's':
a = read_dem ();
b = read_dem ();
d = read_dem ();
return defS (a, b, d);
case ')':
a = read_dem ();
b = read_dem ();
return IfNode (a, b);
case '1': return Ext1;
case '2': return Ext2;
case '3': return Ext3;
case '4': return Ext4;
case '5': return Ext5;
case '6': return Ext6;
case 'e': return AE;
case 'f': return EA0;
/*
a = read_dem ();
return EA (a);
*/
case 'm': return MP;
case 'a': return AI;
case 'b': return AK;
case 'c': return AS;
case 'r': return RPA;
case '0': return ZeroIsOrd;
case '+': return SucIsOrd;
case 'w': return LimIsOrd;
case 'p': return PredIsOrd;
case 'n': return StepIsOrd;
case 'W': return TfI;
case '<':
a = read_dem ();
return left (a);
case '>':
a = read_dem ();
return right (a);
case '\'':
a = read_dem ();
return rep(a);
case '%':
/*printf ("*1*");*/
a = read_dem ();
/*printf ("*2*");*/
trace_dem ("read", a);
/*printf ("*3*");*/
b = red (a);
/*printf ("*4*");*/
trace_dem ("red", b);
return b;
/* return red (a); */
case 'R':
a = read_dem ();
return red1 (a, 0);
case '@':
a = read_dem ();
return reduc (a, 1);
case '~':
a = read_dem ();
return reduc (a, 0);
case '$':
a = read_dem ();
return redu (a);
case 'x':
a = read_dem ();
b = read_dem ();
return ext (a, b);
case '\\':
a = read_dem ();
b = read_dem ();
trace_dem ("^(0)", a);
trace_dem ("^(1)", b);
d = exten (a, b);
trace_dem ("^(r)", d);
return d;
case ']':
a = read_dem ();
b = read_dem ();
d = dbextens (a, b);
return d;
case 'l':
a = read_dem ();
b = read_dem ();
return Ext (a, b);
/* return Lambda (a, b); */
case 'L':
a = read_dem ();
b = read_dem ();
return Lambda (a, b);
case '.':
a = read_dem ();
return DBLambda (a);
case '!':
a = read_dem ();
b = read_dem ();
return DB_lambda (a, b);
/* return DBLambda (DBname (0, a, b)); */
case '?':
a = read_dem ();
b = read_dem ();
return DB_Subst (a, b);
case '_':
a = read_dem ();
b = read_dem ();
d = read_dem ();
return Subst (a, b, d);
case ':':
a = read_dem ();
b = read_dem ();
d = read_dem ();
return ap (exten(a,d) ,b);
case 'V':
x = read_dem ();
d = read_dem ();
a = mk_dem (node(d), 0, NULL,
DB_lambda (x, subdem(0,d)),
DB_lambda (x, subdem(1,d)),
subdem(2,d) == NULL ? NULL :
DB_lambda (x, subdem(2,d)),
NULL, NULL, NULL);
return a;
case 'A':
x = read_dem ();
d = read_dem ();
a = mk_dem (node(d), 0, NULL,
ap (x, subdem(0,d)),
ap (x, subdem(1,d)),
subdem(2,d) == NULL ? NULL :
ap (x, subdem(2,d)),
NULL, NULL, NULL);
return a;
case '"':
a = read_dem ();
/* return NoRed (a); */
no_red[nnr++] = a;
return a;
case '|':
a = read_dem ();
no_red[nnr++] = a;
b = read_dem ();
return b;
case 'u':
used1 = used;
used = read_dem ();
a = read_dem ();
used = used1;
return a;
case '(':
flags1 = flags;
i = 0;
for (;;)
{
c = readchar ();
if (c == ')')
break;
buf[i++] = c;
}
buf[i] = 0;
sscanf (buf, "%x", &flags);
a = read_dem ();
if ((flags & FLAG_PERM) == 0)
flags = flags1;
return a;
case ',':
a = read_dem ();
return step (a);
case '*':
a = read_dem ();
return rstep (a);
case '`':
a = read_dem ();
return list_ap (a, nil);
case '&':
c = readchar ();
switch (c)
{
case '/': return itransym;
case 'i': return idefI;
case 'k': return idefK;
case 's': return idefS;
case '<': return ileft;
case '>': return iright;
case '=': return ieq;
case '#': return inode;
case '0': return isubdem0;
case '1': return isubdem1;
case '2': return isubdem2;
case '%': return ired;
case '$': return iredu;
case '\\': return iext;
case ',': return istep;
case '*': return irstep;
default:
fprintf (stderr, "Undefined &%c.\n",
c);
return I;
}
break;
case '[':
/* trace_dem ("read symbol", I); */
for (i=0; i<sizeof(buf); i++)
{
c = readchar();
if (c == ']')
{
buf[i] = 0;
#ifdef TRACE1
printf ("buf=<%s>\n", buf);
#endif
if (buf[0] >= '0' && buf[0] <= '9')
{
#ifdef TRACE
printf ("\nDBVar <%s>", buf);
#endif
d1 = DBVar (atoi(buf));
trace_dem ("", d);
return d1;
}
s = Sym(buf);
#ifdef TRACE1
trace_dem ("read symbol", s);
#endif
if (subdem(0,s) == NULL)
{
#ifdef TRACE1
trace_dem ("return symbol", s);
#endif
return s;
}
else
{
#ifdef TRACE
trace_dem ("return value of", s);
#endif
return subdem(0,s);
}
}
buf[i] = c;
}
fprintf (stderr, "Symbol too long\n");
return Sym(buf);
default:
return defined_dems[(unsigned char)c];
/*
printf ("Illegal character 0x%02X\n", c);
goto loop;
*/
}
}
Vector SchemeRoe(const Cell& Cell1,const Cell& Cell2,const Cell& Cell3,const Cell& Cell4, int AxisNo)
{
// Local variables
Vector V1, V2, V3, V4; // Velocities
real rho1, rho2, rho3, rho4; // Densities
real p1, p2, p3, p4; // Pressures
real rhoE1, rhoE2, rhoE3, rhoE4; // Energies
Vector Result(QuantityNb);
Vector F1(QuantityNb); // Fluxes
Vector F2(QuantityNb);
Vector F3(QuantityNb);
Vector F4(QuantityNb);
Vector Q1, Q2, Q3, Q4; // Conservative quantities
Vector FL(QuantityNb),FR(QuantityNb); // Left and right fluxex
Vector QL(QuantityNb),QR(QuantityNb); // Left and right conservative quantities
real rhoL, rhoR; // Left and right densities
real pL, pR; // Left and right pressures
real rhoEL, rhoER; // Left and right energies
Vector VL(Dimension), VR(Dimension); // Left and right velocities
Vector One(QuantityNb);
real rho; // central density with Roe's average
Vector V(Dimension); // central velocity with Roe's average
real H; // central enthalpy with Roe's average
real c; // central speed of sound with Roe's average
real Roe; // Coefficient for Roe's average
Matrix L, R; // left and right eigenmatrix
Matrix Lambda(QuantityNb); // diagonal matrix containing the eigenvalues
Matrix A; // absolute value of the jacobian matrix
Vector Lim; // limiter (Van Leer)
int i; // coutner
// vector one.
for(i=1; i<=QuantityNb; i++ )
One.setValue(i,1.);
// --- Get conservative quantities ---
Q1 = Cell1.average();
Q2 = Cell2.average();
Q3 = Cell3.average();
Q4 = Cell4.average();
// --- Get primitive variables ---
// density
rho1 = Cell1.density();
rho2 = Cell2.density();
rho3 = Cell3.density();
rho4 = Cell4.density();
// velocity
V1 = Cell1.velocity();
V2 = Cell2.velocity();
V3 = Cell3.velocity();
V4 = Cell4.velocity();
// energy
rhoE1 = Cell1.energy();
rhoE2 = Cell2.energy();
rhoE3 = Cell3.energy();
rhoE4 = Cell4.energy();
// pressure
p1 = Cell1.pressure();
p2 = Cell2.pressure();
p3 = Cell3.pressure();
p4 = Cell4.pressure();
// --- Compute Euler fluxes ---
F1.setValue(1,rho1*V1.value(AxisNo));
F2.setValue(1,rho2*V2.value(AxisNo));
F3.setValue(1,rho3*V3.value(AxisNo));
F4.setValue(1,rho4*V4.value(AxisNo));
for(i=1; i<=Dimension; i++)
{
F1.setValue(i+1, rho1*V1.value(AxisNo)*V1.value(i) + ((AxisNo == i)? p1 : 0.));
F2.setValue(i+1, rho2*V2.value(AxisNo)*V2.value(i) + ((AxisNo == i)? p2 : 0.));
F3.setValue(i+1, rho3*V3.value(AxisNo)*V3.value(i) + ((AxisNo == i)? p3 : 0.));
F4.setValue(i+1, rho4*V4.value(AxisNo)*V4.value(i) + ((AxisNo == i)? p4 : 0.));
}
F1.setValue(QuantityNb,(rhoE1+p1)*V1.value(AxisNo));
F2.setValue(QuantityNb,(rhoE2+p2)*V2.value(AxisNo));
F3.setValue(QuantityNb,(rhoE3+p3)*V3.value(AxisNo));
F4.setValue(QuantityNb,(rhoE4+p4)*V4.value(AxisNo));
// --- Van Leer limiter ---
// Left
Lim = Limiter(Q3-Q2, Q2-Q1);
FL = F2 + 0.5*(Lim|(F2-F1)) + 0.5*((One-Lim)|(F3-F2));
QL = Q2 + 0.5*(Lim|(Q2-Q1)) + 0.5*((One-Lim)|(Q3-Q2));
// Right
Lim = Limiter(Q3-Q2, Q4-Q3);
FR = F3 - 0.5*(Lim|(F4-F3)) - 0.5*((One-Lim)|(F3-F2));
QR = Q3 - 0.5*(Lim|(Q4-Q3)) - 0.5*((One-Lim)|(Q3-Q2));
/*
FL = F2;
FR = F3;
QL = Q2;
QR = Q3;
*/
// --- Extract left and right primitive variables ---
rhoL = QL.value(1);
rhoR = QR.value(1);
for (i=1; i<= Dimension; i++)
{
VL.setValue(i,QL.value(i+1)/rhoL);
VR.setValue(i,QR.value(i+1)/rhoR);
}
rhoEL=QL.value(QuantityNb);
rhoER=QR.value(QuantityNb);
pL = (Gamma-1)*(rhoEL - .5*rhoL*(VL*VL));
pR = (Gamma-1)*(rhoER - .5*rhoR*(VR*VR));
// --- Compute Roe's averages ---
Roe = sqrt(rhoR/rhoL);
rho = Roe*rhoL;
V = 1./(1.+Roe)*( Roe*VR + VL );
H = 1./(1.+Roe)*( Roe*(rhoER+pR)/rhoR + (rhoEL+pL)/rhoL );
c = sqrt ( (Gamma-1)*( H - 0.5*(V*V) ) );
// --- Compute diagonal matrix containing the absolute value of the eigenvalues ---
for (i=1;i<=Dimension;i++)
Lambda.setValue(i,i, fabs(V.value(AxisNo)));
Lambda.setValue(Dimension+1, Dimension+1, fabs(V.value(AxisNo)+c));
Lambda.setValue(Dimension+2, Dimension+2, fabs(V.value(AxisNo)-c));
// --- Set left and right eigenmatrices ---
L.setEigenMatrix(true, AxisNo, V, c);
R.setEigenMatrix(false, AxisNo, V, c, H);
// --- Compute absolute Jacobian matrix ---
A = R*Lambda*L;
// --- Compute Euler Flux ---
Result = 0.5*(FL+FR) - 0.5*(A*(QR-QL));
return Result;
}
