void coding(std::vector<std::string> code, std::string file)
{
char filename[] = "c://files//test.txt"; // 此处写入文件名;
std::ofstream yout(filename, ios::out);
std::string abundant_code,shell_code,final_code;
int n = 0;
for (int i = 0; i < 128; i++)
{
if (counting[i] != 0)
n = n + 1;
}
yout << n;
for (int i = 0; i < 128; i++)
{
if (counting[i] != 0)
yout << " " << (char)i << " " << code[i];
}
yout << " ";
yout << file.size();
yout << " ";
for (int i=0; i<file.size();i++)
{
if (abundant_code.size()!=0)
{
shell_code=shell_code+abundant_code;
abundant_code="";
}
shell_code=shell_code+code[(int)file[i]];
if (shell_code.size()>=8)
{
string abuntdant_code(shell_code,8,8);
abundant_code = abuntdant_code;
string final_code(shell_code,0,8);
yout << output(final_code);
shell_code="";
}
}
int size = shell_code.size();
if (size != 0)
for (int i = 0; i < 8 - size; i++)
shell_code = shell_code + "0";
yout<<output(shell_code);
}
bool qp_box(
size_t level ,
const Vector& a ,
const Vector& b ,
const Vector& c ,
const Vector& C ,
const Vector& g ,
const Vector& G ,
double epsilon ,
size_t maxitr ,
const Vector& xin ,
Vector& xout )
// END PROTOTYPE
{ double inf = std::numeric_limits<double>::infinity();
//
size_t n = a.size();
size_t m = c.size();
//
CPPAD_ASSERT_KNOWN(level <= 2, "qp_interior: level is greater than 2");
CPPAD_ASSERT_KNOWN(
size_t(b.size()) == n, "qp_box: size of b is not n"
);
CPPAD_ASSERT_KNOWN(
size_t(C.size()) == m * n, "qp_box: size of C is not m * n"
);
CPPAD_ASSERT_KNOWN(
size_t(g.size()) == n, "qp_box: size of g is not n"
);
CPPAD_ASSERT_KNOWN(
size_t(G.size()) == n * n, "qp_box: size of G is not n * n"
);
if( level > 0 )
{ std::cout << "start qp_box\n";
CppAD::abs_print_mat("a", n, 1, a);
CppAD::abs_print_mat("b", n, 1, b);
CppAD::abs_print_mat("c", m, 1, c);
CppAD::abs_print_mat("C", m, n, C);
CppAD::abs_print_mat("g", 1, n, g);
CppAD::abs_print_mat("G", n, n, G);
CppAD::abs_print_mat("xin", n, 1, xin);
}
//
// count number of lower and upper limits
size_t n_limit = 0;
for(size_t j = 0; j < n; j++)
{ CPPAD_ASSERT_KNOWN(G[j * n + j] >= 0.0, "qp_box: G_{j,j} < 0.0");
if( -inf < a[j] )
++n_limit;
if( b[j] < inf )
++n_limit;
}
//
// C_int and c_int define the extended constraints
Vector C_int((m + n_limit) * n ), c_int(m + n_limit);
for(size_t i = 0; i < size_t(C_int.size()); i++)
C_int[i] = 0.0;
//
// put C * x + c <= 0 in C_int, c_int
for(size_t i = 0; i < m; i++)
{ c_int[i] = c[i];
for(size_t j = 0; j < n; j++)
C_int[i * n + j] = C[i * n + j];
}
//
// put I * x - b <= 0 in C_int, c_int
size_t i_limit = 0;
for(size_t j = 0; j < n; j++) if( b[j] < inf )
{ c_int[m + i_limit] = - b[j];
C_int[(m + i_limit) * n + j] = 1.0;
++i_limit;
}
//
// put a - I * x <= 0 in C_int, c_int
for(size_t j = 0; j < n; j++) if( -inf < a[j] )
{ c_int[m + i_limit] = a[j];
C_int[(m + i_limit) * n + j] = -1.0;
++i_limit;
}
Vector yout(m + n_limit), sout(m + n_limit);
size_t level_int = 0;
if( level == 2 )
level_int = 1;
bool ok = qp_interior( level_int,
c_int, C_int, g, G, epsilon, maxitr, xin, xout, yout, sout
);
if( level > 0 )
{ if( level < 2 )
CppAD::abs_print_mat("xout", n, 1, xout);
if( ok )
std::cout << "end q_box: ok = true\n";
else
std::cout << "end q_box: ok = false\n";
}
return ok;
}
void DebugMap::print(raw_ostream &OS) const {
yaml::Output yout(OS, /* Ctxt = */ nullptr, /* WrapColumn = */ 0);
yout << const_cast<DebugMap &>(*this);
}
//---------------------------------------------------------
DMat& NDG2D::ConformingHrefine2D(IMat& edgerefineflag, const DMat& Qin)
//---------------------------------------------------------
{
#if (0)
OutputNodes(false); // volume nodes
//OutputNodes(true); // face nodes
#endif
// function newQ = ConformingHrefine2D(edgerefineflag, Q)
// Purpose: apply edge splits as requested by edgerefineflag
IVec v1("v1"), v2("v2"), v3("v3"), tvi;
DVec x1("x1"), x2("x2"), x3("x3"), y1("y1"), y2("y2"), y3("y3");
DVec a1("a1"), a2("a2"), a3("a3");
// count vertices
assert (VX.size() == Nv);
// find vertex triplets for elements to be refined
v1 = EToV(All,1); v2 = EToV(All,2); v3 = EToV(All,3);
x1 = VX(v1); x2 = VX(v2); x3 = VX(v3);
y1 = VY(v1); y2 = VY(v2); y3 = VY(v3);
// find angles at each element vertex (in radians)
VertexAngles(x1,x2,x3,y1,y2,y3, a1,a2,a3);
// absolute value of angle size
a1.set_abs(); a2.set_abs(); a3.set_abs();
int k=0,k1=0,f1=0,k2=0,f2=0, e1=0,e2=0,e3=0, b1=0,b2=0,b3=0, ref=0;
IVec m1,m2,m3; DVec mx1, my1, mx2, my2, mx3, my3;
// create new vertices at edge centers of marked elements
// (use unique numbering derived from unique edge number))
m1 = max(IVec(Nv*(v1-1)+v2+1), IVec(Nv*(v2-1)+v1+1)); mx1=0.5*(x1+x2); my1=0.5*(y1+y2);
m2 = max(IVec(Nv*(v2-1)+v3+1), IVec(Nv*(v3-1)+v2+1)); mx2=0.5*(x2+x3); my2=0.5*(y2+y3);
m3 = max(IVec(Nv*(v1-1)+v3+1), IVec(Nv*(v3-1)+v1+1)); mx3=0.5*(x3+x1); my3=0.5*(y3+y1);
// ensure that both elements sharing an edge are split
for (k1=1; k1<=K; ++k1) {
for (f1=1; f1<=Nfaces; ++f1) {
if (edgerefineflag(k1,f1)) {
k2 = EToE(k1,f1);
f2 = EToF(k1,f1);
edgerefineflag(k2,f2) = 1;
}
}
}
// store old data
IMat oldEToV = EToV; DVec oldVX = VX, oldVY = VY;
// count the number of elements in the refined mesh
int newK = countrefinefaces(edgerefineflag);
EToV.resize(newK, Nfaces, true, 0);
IMat newBCType(newK,3, "newBCType");
// kold = [];
IVec kold(newK, "kold"); Index1D KI,KIo;
int sk=1, skstart=0, skend=0;
for (k=1; k<=K; ++k)
{
skstart = sk;
e1 = edgerefineflag(k,1); b1 = BCType(k,1);
e2 = edgerefineflag(k,2); b2 = BCType(k,2);
e3 = edgerefineflag(k,3); b3 = BCType(k,3);
ref = e1 + 2*e2 + 4*e3;
switch (ref) {
case 0:
EToV(sk, All) = IVec(v1(k),v2(k),v3(k)); newBCType(sk,All) = IVec(b1, b2, b3); ++sk;
break;
case 1:
EToV(sk, All) = IVec(v1(k),m1(k),v3(k)); newBCType(sk,All) = IVec(b1, 0, b3); ++sk;
EToV(sk, All) = IVec(m1(k),v2(k),v3(k)); newBCType(sk,All) = IVec(b1, b2, 0); ++sk;
break;
case 2:
EToV(sk, All) = IVec(v2(k),m2(k),v1(k)); newBCType(sk,All) = IVec(b2, 0, b1); ++sk;
EToV(sk, All) = IVec(m2(k),v3(k),v1(k)); newBCType(sk,All) = IVec(b2, b3, 0); ++sk;
break;
case 4:
EToV(sk, All) = IVec(v3(k),m3(k),v2(k)); newBCType(sk,All) = IVec(b3, 0, b2); ++sk;
EToV(sk, All) = IVec(m3(k),v1(k),v2(k)); newBCType(sk,All) = IVec(b3, b1, 0); ++sk;
break;
case 3:
EToV(sk, All) = IVec(m1(k),v2(k),m2(k)); newBCType(sk,All) = IVec(b1, b2, 0); ++sk;
if (a1(k) > a3(k)) { // split largest angle
EToV(sk, All) = IVec(v1(k),m1(k),m2(k)); newBCType(sk,All) = IVec(b1, 0, 0); ++sk;
EToV(sk, All) = IVec(v1(k),m2(k),v3(k)); newBCType(sk,All) = IVec( 0, b2, b3); ++sk;
} else {
EToV(sk, All) = IVec(v3(k),m1(k),m2(k)); newBCType(sk,All) = IVec( 0, 0, b2); ++sk;
EToV(sk, All) = IVec(v3(k),v1(k),m1(k)); newBCType(sk,All) = IVec(b3, b1, 0); ++sk;
}
break;
case 5:
EToV(sk, All) = IVec(v1(k),m1(k),m3(k)); newBCType(sk,All) = IVec(b1, 0, b3); ++sk;
if (a2(k) > a3(k)) {
// split largest angle
EToV(sk, All) = IVec(v2(k),m3(k),m1(k)); newBCType(sk,All) = IVec( 0, 0, b1); ++sk;
EToV(sk, All) = IVec(v2(k),v3(k),m3(k)); newBCType(sk,All) = IVec(b2, b3, 0); ++sk;
} else {
EToV(sk, All) = IVec(v3(k),m3(k),m1(k)); newBCType(sk,All) = IVec(b3, 0, 0); ++sk;
EToV(sk, All) = IVec(v3(k),m1(k),v2(k)); newBCType(sk,All) = IVec( 0, b1, b2); ++sk;
}
break;
case 6:
EToV(sk, All) = IVec(v3(k),m3(k),m2(k)); newBCType(sk,All) = IVec(b3, 0, b2); ++sk;
if (a1(k) > a2(k)) {
// split largest angle
EToV(sk, All) = IVec(v1(k),m2(k),m3(k)); newBCType(sk,All) = IVec( 0, 0, b3); ++sk;
EToV(sk, All) = IVec(v1(k),v2(k),m2(k)); newBCType(sk,All) = IVec(b1, b2, 0); ++sk;
} else {
EToV(sk, All) = IVec(v2(k),m2(k),m3(k)); newBCType(sk,All) = IVec(b2, 0, 0); ++sk;
EToV(sk, All) = IVec(v2(k),m3(k),v1(k)); newBCType(sk,All) = IVec( 0 , b3, b1); ++sk;
}
break;
default:
// split all
EToV(sk, All) = IVec(m1(k),m2(k),m3(k)); newBCType(sk, All) = IVec( 0, 0, 0); ++sk;
EToV(sk, All) = IVec(v1(k),m1(k),m3(k)); newBCType(sk, All) = IVec(b1, 0, b3); ++sk;
EToV(sk, All) = IVec(v2(k),m2(k),m1(k)); newBCType(sk, All) = IVec(b2, 0, b1); ++sk;
EToV(sk, All) = IVec(v3(k),m3(k),m2(k)); newBCType(sk, All) = IVec(b3, 0, b2); ++sk;
break;
}
skend = sk;
// kold = [kold; k*ones(skend-skstart, 1)];
// element k is to be refined into (1:4) child elements.
// store parent element numbers in array "kold" to help
// with accessing parent vertex data during refinement.
KI.reset(skstart, skend-1); // ids of child elements
kold(KI) = k; // mark as children of element k
}
// Finished with edgerefineflag. Delete if OBJ_temp
if (edgerefineflag.get_mode() == OBJ_temp) {
delete (&edgerefineflag);
}
// renumber new nodes contiguously
// ids = unique([v1;v2;v3;m1;m2;m3]);
bool unique=true; IVec IDS, ids;
IDS = concat( concat(v1,v2,v3), concat(m1,m2,m3) );
ids = sort(IDS, unique);
Nv = ids.size();
int max_id = EToV.max_val();
umMSG(1, "max id in EToV is %d\n", max_id);
// M N nnz vals triplet
CSi newids(max_id,1, Nv, 1, 1 );
// newids = sparse(max(max(EToV)),1);
int i=0, j=1;
for (i=1; i<=Nv; ++i) {
// newids(ids)= (1:Nv);
newids.set1(ids(i),j, i); // load 1-based triplets
} // row col x
newids.compress(); // convert to csc form
// Matlab -----------------------------------------------
// v1 = newids(v1); v2 = newids(v2); v3 = newids(v3);
// m1 = newids(m1); m2 = newids(m2); m3 = newids(m3);
//-------------------------------------------------------
int KVi=v1.size(), KMi=m1.size();
// read from copies, overwrite originals
// 1. reload ids for new vertices
tvi = v1; for (i=1;i<=KVi;++i) {v1(i) = newids(tvi(i), 1);}
tvi = v2; for (i=1;i<=KVi;++i) {v2(i) = newids(tvi(i), 1);}
tvi = v3; for (i=1;i<=KVi;++i) {v3(i) = newids(tvi(i), 1);}
// 2. load ids for new (midpoint) vertices
tvi = m1; for (i=1;i<=KMi;++i) {m1(i) = newids(tvi(i), 1);}
tvi = m2; for (i=1;i<=KMi;++i) {m2(i) = newids(tvi(i), 1);}
tvi = m3; for (i=1;i<=KMi;++i) {m3(i) = newids(tvi(i), 1);}
VX.resize(Nv); VY.resize(Nv);
VX(v1) = x1; VX(v2) = x2; VX(v3) = x3;
VY(v1) = y1; VY(v2) = y2; VY(v3) = y3;
VX(m1) = mx1; VX(m2) = mx2; VX(m3) = mx3;
VY(m1) = my1; VY(m2) = my2; VY(m3) = my3;
if (newK != (sk-1)) {
umERROR("NDG2D::ConformingHrefine2D", "Inconsistent element count: expect %d, but sk = %d", newK, (sk-1));
} else {
K = newK; // sk-1;
}
// dumpIMat(EToV, "EToV (before)");
// EToV = newids(EToV);
for (j=1; j<=3; ++j) {
for (k=1; k<=K; ++k) {
EToV(k,j) = newids(EToV(k,j), 1);
}
}
#if (0)
dumpIMat(EToV, "EToV (after)");
// umERROR("Checking ids", "Nigel, check EToV");
#endif
BCType = newBCType;
Nv = VX.size();
// xold = x; yold = y;
StartUp2D();
#if (1)
OutputNodes(false); // volume nodes
//OutputNodes(true); // face nodes
//umERROR("Exiting early", "Check adapted {volume,face} nodes");
#endif
// allocate return object
int Nfields = Qin.num_cols();
DMat* tmpQ = new DMat(Np*K, Nfields, "newQ", OBJ_temp);
DMat& newQ = *tmpQ; // use a reference for syntax
// quick return, if no interpolation is required
if (Qin.size()<1) {
return newQ;
}
DVec rOUT(Np),sOUT(Np),xout,yout,xy1(2),xy2(2),xy3(2),tmp(2),rhs;
int ko=0,kv1=0,kv2=0,kv3=0,n=0; DMat A(2,2), interp;
DMat oldQ = const_cast<DMat&>(Qin);
for (k=1; k<=K; ++k)
{
ko = kold(k); xout = x(All,k); yout = y(All,k);
kv1=oldEToV(ko,1); kv2=oldEToV(ko,2); kv3=oldEToV(ko,3);
xy1.set(oldVX(kv1), oldVY(kv1));
xy2.set(oldVX(kv2), oldVY(kv2));
xy3.set(oldVX(kv3), oldVY(kv3));
A.set_col(1, xy2-xy1); A.set_col(2, xy3-xy1);
for (i=1; i<=Np; ++i) {
tmp.set(xout(i), yout(i));
rhs = 2.0*tmp - xy2 - xy3;
tmp = A|rhs;
rOUT(i) = tmp(1);
sOUT(i) = tmp(2);
}
KI.reset (Np*(k -1)+1, Np*k ); // nodes in new element k
KIo.reset(Np*(ko-1)+1, Np*ko); // nodes in old element ko
interp = Vandermonde2D(N, rOUT, sOUT)*invV;
for (n=1; n<=Nfields; ++n)
{
//newQ(:,k,n)= interp* Q(:,ko,n);
//DVec tm1 = interp*oldQ(KIo,n);
//dumpDVec(tm1, "tm1");
newQ(KI,n) = interp*oldQ(KIo,n);
}
}
return newQ;
}