sorted_unique_rmat_iterator operator++(int)
{
sorted_unique_rmat_iterator temp(*this);
++(*this);
return temp;
}
void
vec4_tes_visitor::nir_emit_intrinsic(nir_intrinsic_instr *instr)
{
const struct brw_tes_prog_data *tes_prog_data =
(const struct brw_tes_prog_data *) prog_data;
switch (instr->intrinsic) {
case nir_intrinsic_load_tess_coord:
/* gl_TessCoord is part of the payload in g1 channels 0-2 and 4-6. */
emit(MOV(get_nir_dest(instr->dest, BRW_REGISTER_TYPE_F),
src_reg(brw_vec8_grf(1, 0))));
break;
case nir_intrinsic_load_tess_level_outer:
if (tes_prog_data->domain == BRW_TESS_DOMAIN_ISOLINE) {
emit(MOV(get_nir_dest(instr->dest, BRW_REGISTER_TYPE_F),
swizzle(src_reg(ATTR, 1, glsl_type::vec4_type),
BRW_SWIZZLE_ZWZW)));
} else {
emit(MOV(get_nir_dest(instr->dest, BRW_REGISTER_TYPE_F),
swizzle(src_reg(ATTR, 1, glsl_type::vec4_type),
BRW_SWIZZLE_WZYX)));
}
break;
case nir_intrinsic_load_tess_level_inner:
if (tes_prog_data->domain == BRW_TESS_DOMAIN_QUAD) {
emit(MOV(get_nir_dest(instr->dest, BRW_REGISTER_TYPE_F),
swizzle(src_reg(ATTR, 0, glsl_type::vec4_type),
BRW_SWIZZLE_WZYX)));
} else {
emit(MOV(get_nir_dest(instr->dest, BRW_REGISTER_TYPE_F),
src_reg(ATTR, 1, glsl_type::float_type)));
}
break;
case nir_intrinsic_load_primitive_id:
emit(TES_OPCODE_GET_PRIMITIVE_ID,
get_nir_dest(instr->dest, BRW_REGISTER_TYPE_UD));
break;
case nir_intrinsic_load_input:
case nir_intrinsic_load_per_vertex_input: {
src_reg indirect_offset = get_indirect_offset(instr);
unsigned imm_offset = instr->const_index[0];
src_reg header = input_read_header;
bool is_64bit = nir_dest_bit_size(instr->dest) == 64;
unsigned first_component = nir_intrinsic_component(instr);
if (is_64bit)
first_component /= 2;
if (indirect_offset.file != BAD_FILE) {
header = src_reg(this, glsl_type::uvec4_type);
emit(TES_OPCODE_ADD_INDIRECT_URB_OFFSET, dst_reg(header),
input_read_header, indirect_offset);
} else {
/* Arbitrarily only push up to 24 vec4 slots worth of data,
* which is 12 registers (since each holds 2 vec4 slots).
*/
const unsigned max_push_slots = 24;
if (imm_offset < max_push_slots) {
const glsl_type *src_glsl_type =
is_64bit ? glsl_type::dvec4_type : glsl_type::ivec4_type;
src_reg src = src_reg(ATTR, imm_offset, src_glsl_type);
src.swizzle = BRW_SWZ_COMP_INPUT(first_component);
const brw_reg_type dst_reg_type =
is_64bit ? BRW_REGISTER_TYPE_DF : BRW_REGISTER_TYPE_D;
emit(MOV(get_nir_dest(instr->dest, dst_reg_type), src));
prog_data->urb_read_length =
MAX2(prog_data->urb_read_length,
DIV_ROUND_UP(imm_offset + (is_64bit ? 2 : 1), 2));
break;
}
}
if (!is_64bit) {
dst_reg temp(this, glsl_type::ivec4_type);
vec4_instruction *read =
emit(VEC4_OPCODE_URB_READ, temp, src_reg(header));
read->offset = imm_offset;
read->urb_write_flags = BRW_URB_WRITE_PER_SLOT_OFFSET;
src_reg src = src_reg(temp);
src.swizzle = BRW_SWZ_COMP_INPUT(first_component);
/* Copy to target. We might end up with some funky writemasks landing
* in here, but we really don't want them in the above pseudo-ops.
*/
dst_reg dst = get_nir_dest(instr->dest, BRW_REGISTER_TYPE_D);
dst.writemask = brw_writemask_for_size(instr->num_components);
emit(MOV(dst, src));
} else {
/* For 64-bit we need to load twice as many 32-bit components, and for
* dvec3/4 we need to emit 2 URB Read messages
*/
dst_reg temp(this, glsl_type::dvec4_type);
dst_reg temp_d = retype(temp, BRW_REGISTER_TYPE_D);
vec4_instruction *read =
emit(VEC4_OPCODE_URB_READ, temp_d, src_reg(header));
read->offset = imm_offset;
read->urb_write_flags = BRW_URB_WRITE_PER_SLOT_OFFSET;
if (instr->num_components > 2) {
read = emit(VEC4_OPCODE_URB_READ, byte_offset(temp_d, REG_SIZE),
src_reg(header));
read->offset = imm_offset + 1;
read->urb_write_flags = BRW_URB_WRITE_PER_SLOT_OFFSET;
}
src_reg temp_as_src = src_reg(temp);
temp_as_src.swizzle = BRW_SWZ_COMP_INPUT(first_component);
dst_reg shuffled(this, glsl_type::dvec4_type);
shuffle_64bit_data(shuffled, temp_as_src, false);
dst_reg dst = get_nir_dest(instr->dest, BRW_REGISTER_TYPE_DF);
dst.writemask = brw_writemask_for_size(instr->num_components);
emit(MOV(dst, src_reg(shuffled)));
}
break;
}
default:
vec4_visitor::nir_emit_intrinsic(instr);
}
}
ParamValue& ParamValue::operator=( const ParamValue &other )
{
ParamValue temp( other );
swap( temp );
return *this;
}
int gmx_traj(int argc, char *argv[])
{
const char *desc[] = {
"[THISMODULE] plots coordinates, velocities, forces and/or the box.",
"With [TT]-com[tt] the coordinates, velocities and forces are",
"calculated for the center of mass of each group.",
"When [TT]-mol[tt] is set, the numbers in the index file are",
"interpreted as molecule numbers and the same procedure as with",
"[TT]-com[tt] is used for each molecule.[PAR]",
"Option [TT]-ot[tt] plots the temperature of each group,",
"provided velocities are present in the trajectory file.",
"No corrections are made for constrained degrees of freedom!",
"This implies [TT]-com[tt].[PAR]",
"Options [TT]-ekt[tt] and [TT]-ekr[tt] plot the translational and",
"rotational kinetic energy of each group,",
"provided velocities are present in the trajectory file.",
"This implies [TT]-com[tt].[PAR]",
"Options [TT]-cv[tt] and [TT]-cf[tt] write the average velocities",
"and average forces as temperature factors to a [TT].pdb[tt] file with",
"the average coordinates or the coordinates at [TT]-ctime[tt].",
"The temperature factors are scaled such that the maximum is 10.",
"The scaling can be changed with the option [TT]-scale[tt].",
"To get the velocities or forces of one",
"frame set both [TT]-b[tt] and [TT]-e[tt] to the time of",
"desired frame. When averaging over frames you might need to use",
"the [TT]-nojump[tt] option to obtain the correct average coordinates.",
"If you select either of these option the average force and velocity",
"for each atom are written to an [TT].xvg[tt] file as well",
"(specified with [TT]-av[tt] or [TT]-af[tt]).[PAR]",
"Option [TT]-vd[tt] computes a velocity distribution, i.e. the",
"norm of the vector is plotted. In addition in the same graph",
"the kinetic energy distribution is given."
};
static gmx_bool bMol = FALSE, bCom = FALSE, bPBC = TRUE, bNoJump = FALSE;
static gmx_bool bX = TRUE, bY = TRUE, bZ = TRUE, bNorm = FALSE, bFP = FALSE;
static int ngroups = 1;
static real ctime = -1, scale = 0, binwidth = 1;
t_pargs pa[] = {
{ "-com", FALSE, etBOOL, {&bCom},
"Plot data for the com of each group" },
{ "-pbc", FALSE, etBOOL, {&bPBC},
"Make molecules whole for COM" },
{ "-mol", FALSE, etBOOL, {&bMol},
"Index contains molecule numbers iso atom numbers" },
{ "-nojump", FALSE, etBOOL, {&bNoJump},
"Remove jumps of atoms across the box" },
{ "-x", FALSE, etBOOL, {&bX},
"Plot X-component" },
{ "-y", FALSE, etBOOL, {&bY},
"Plot Y-component" },
{ "-z", FALSE, etBOOL, {&bZ},
"Plot Z-component" },
{ "-ng", FALSE, etINT, {&ngroups},
"Number of groups to consider" },
{ "-len", FALSE, etBOOL, {&bNorm},
"Plot vector length" },
{ "-fp", FALSE, etBOOL, {&bFP},
"Full precision output" },
{ "-bin", FALSE, etREAL, {&binwidth},
"Binwidth for velocity histogram (nm/ps)" },
{ "-ctime", FALSE, etREAL, {&ctime},
"Use frame at this time for x in [TT]-cv[tt] and [TT]-cf[tt] instead of the average x" },
{ "-scale", FALSE, etREAL, {&scale},
"Scale factor for [TT].pdb[tt] output, 0 is autoscale" }
};
FILE *outx = NULL, *outv = NULL, *outf = NULL, *outb = NULL, *outt = NULL;
FILE *outekt = NULL, *outekr = NULL;
t_topology top;
int ePBC;
real *mass, time;
char title[STRLEN];
const char *indexfn;
t_trxframe fr, frout;
int flags, nvhisto = 0, *vhisto = NULL;
rvec *xtop, *xp = NULL;
rvec *sumx = NULL, *sumv = NULL, *sumf = NULL;
matrix topbox;
t_trxstatus *status;
t_trxstatus *status_out = NULL;
gmx_rmpbc_t gpbc = NULL;
int i, j, n;
int nr_xfr, nr_vfr, nr_ffr;
char **grpname;
int *isize0, *isize;
atom_id **index0, **index;
atom_id *atndx;
t_block *mols;
gmx_bool bTop, bOX, bOXT, bOV, bOF, bOB, bOT, bEKT, bEKR, bCV, bCF;
gmx_bool bDim[4], bDum[4], bVD;
char *sffmt, sffmt6[1024];
const char *box_leg[6] = { "XX", "YY", "ZZ", "YX", "ZX", "ZY" };
output_env_t oenv;
t_filenm fnm[] = {
{ efTRX, "-f", NULL, ffREAD },
{ efTPS, NULL, NULL, ffREAD },
{ efNDX, NULL, NULL, ffOPTRD },
{ efXVG, "-ox", "coord.xvg", ffOPTWR },
{ efTRX, "-oxt", "coord.xtc", ffOPTWR },
{ efXVG, "-ov", "veloc.xvg", ffOPTWR },
{ efXVG, "-of", "force.xvg", ffOPTWR },
{ efXVG, "-ob", "box.xvg", ffOPTWR },
{ efXVG, "-ot", "temp.xvg", ffOPTWR },
{ efXVG, "-ekt", "ektrans.xvg", ffOPTWR },
{ efXVG, "-ekr", "ekrot.xvg", ffOPTWR },
{ efXVG, "-vd", "veldist.xvg", ffOPTWR },
{ efPDB, "-cv", "veloc.pdb", ffOPTWR },
{ efPDB, "-cf", "force.pdb", ffOPTWR },
{ efXVG, "-av", "all_veloc.xvg", ffOPTWR },
{ efXVG, "-af", "all_force.xvg", ffOPTWR }
};
#define NFILE asize(fnm)
if (!parse_common_args(&argc, argv,
PCA_CAN_TIME | PCA_TIME_UNIT | PCA_CAN_VIEW | PCA_BE_NICE,
NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
{
return 0;
}
if (bMol)
{
fprintf(stderr, "Interpreting indexfile entries as molecules.\n"
"Using center of mass.\n");
}
bOX = opt2bSet("-ox", NFILE, fnm);
bOXT = opt2bSet("-oxt", NFILE, fnm);
bOV = opt2bSet("-ov", NFILE, fnm);
bOF = opt2bSet("-of", NFILE, fnm);
bOB = opt2bSet("-ob", NFILE, fnm);
bOT = opt2bSet("-ot", NFILE, fnm);
bEKT = opt2bSet("-ekt", NFILE, fnm);
bEKR = opt2bSet("-ekr", NFILE, fnm);
bCV = opt2bSet("-cv", NFILE, fnm) || opt2bSet("-av", NFILE, fnm);
bCF = opt2bSet("-cf", NFILE, fnm) || opt2bSet("-af", NFILE, fnm);
bVD = opt2bSet("-vd", NFILE, fnm) || opt2parg_bSet("-bin", asize(pa), pa);
if (bMol || bOT || bEKT || bEKR)
{
bCom = TRUE;
}
bDim[XX] = bX;
bDim[YY] = bY;
bDim[ZZ] = bZ;
bDim[DIM] = bNorm;
if (bFP)
{
sffmt = "\t" gmx_real_fullprecision_pfmt;
}
else
{
sffmt = "\t%g";
}
sprintf(sffmt6, "%s%s%s%s%s%s", sffmt, sffmt, sffmt, sffmt, sffmt, sffmt);
bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC,
&xtop, NULL, topbox,
bCom && (bOX || bOXT || bOV || bOT || bEKT || bEKR));
sfree(xtop);
if ((bMol || bCV || bCF) && !bTop)
{
gmx_fatal(FARGS, "Need a run input file for option -mol, -cv or -cf");
}
if (bMol)
{
indexfn = ftp2fn(efNDX, NFILE, fnm);
}
else
{
indexfn = ftp2fn_null(efNDX, NFILE, fnm);
}
if (!(bCom && !bMol))
{
ngroups = 1;
}
snew(grpname, ngroups);
snew(isize0, ngroups);
snew(index0, ngroups);
get_index(&(top.atoms), indexfn, ngroups, isize0, index0, grpname);
if (bMol)
{
mols = &(top.mols);
atndx = mols->index;
ngroups = isize0[0];
snew(isize, ngroups);
snew(index, ngroups);
for (i = 0; i < ngroups; i++)
{
if (index0[0][i] < 0 || index0[0][i] >= mols->nr)
{
gmx_fatal(FARGS, "Molecule index (%d) is out of range (%d-%d)",
index0[0][i]+1, 1, mols->nr);
}
isize[i] = atndx[index0[0][i]+1] - atndx[index0[0][i]];
snew(index[i], isize[i]);
for (j = 0; j < isize[i]; j++)
{
index[i][j] = atndx[index0[0][i]] + j;
}
}
}
else
{
isize = isize0;
index = index0;
}
if (bCom)
{
snew(mass, top.atoms.nr);
for (i = 0; i < top.atoms.nr; i++)
{
mass[i] = top.atoms.atom[i].m;
}
}
else
{
mass = NULL;
}
flags = 0;
if (bOX)
{
flags = flags | TRX_READ_X;
outx = xvgropen(opt2fn("-ox", NFILE, fnm),
bCom ? "Center of mass" : "Coordinate",
output_env_get_xvgr_tlabel(oenv), "Coordinate (nm)", oenv);
make_legend(outx, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOXT)
{
flags = flags | TRX_READ_X;
status_out = open_trx(opt2fn("-oxt", NFILE, fnm), "w");
}
if (bOV)
{
flags = flags | TRX_READ_V;
outv = xvgropen(opt2fn("-ov", NFILE, fnm),
bCom ? "Center of mass velocity" : "Velocity",
output_env_get_xvgr_tlabel(oenv), "Velocity (nm/ps)", oenv);
make_legend(outv, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOF)
{
flags = flags | TRX_READ_F;
outf = xvgropen(opt2fn("-of", NFILE, fnm), "Force",
output_env_get_xvgr_tlabel(oenv), "Force (kJ mol\\S-1\\N nm\\S-1\\N)",
oenv);
make_legend(outf, ngroups, isize0[0], index0[0], grpname, bCom, bMol, bDim, oenv);
}
if (bOB)
{
outb = xvgropen(opt2fn("-ob", NFILE, fnm), "Box vector elements",
output_env_get_xvgr_tlabel(oenv), "(nm)", oenv);
xvgr_legend(outb, 6, box_leg, oenv);
}
if (bOT)
{
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_V;
outt = xvgropen(opt2fn("-ot", NFILE, fnm), "Temperature",
output_env_get_xvgr_tlabel(oenv), "(K)", oenv);
make_legend(outt, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
if (bEKT)
{
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_V;
outekt = xvgropen(opt2fn("-ekt", NFILE, fnm), "Center of mass translation",
output_env_get_xvgr_tlabel(oenv), "Energy (kJ mol\\S-1\\N)", oenv);
make_legend(outekt, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
if (bEKR)
{
bDum[XX] = FALSE;
bDum[YY] = FALSE;
bDum[ZZ] = FALSE;
bDum[DIM] = TRUE;
flags = flags | TRX_READ_X | TRX_READ_V;
outekr = xvgropen(opt2fn("-ekr", NFILE, fnm), "Center of mass rotation",
output_env_get_xvgr_tlabel(oenv), "Energy (kJ mol\\S-1\\N)", oenv);
make_legend(outekr, ngroups, isize[0], index[0], grpname, bCom, bMol, bDum, oenv);
}
if (bVD)
{
flags = flags | TRX_READ_V;
}
if (bCV)
{
flags = flags | TRX_READ_X | TRX_READ_V;
}
if (bCF)
{
flags = flags | TRX_READ_X | TRX_READ_F;
}
if ((flags == 0) && !bOB)
{
fprintf(stderr, "Please select one or more output file options\n");
exit(0);
}
read_first_frame(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &fr, flags);
if (bCV || bCF)
{
snew(sumx, fr.natoms);
}
if (bCV)
{
snew(sumv, fr.natoms);
}
if (bCF)
{
snew(sumf, fr.natoms);
}
nr_xfr = 0;
nr_vfr = 0;
nr_ffr = 0;
if (bCom && bPBC)
{
gpbc = gmx_rmpbc_init(&top.idef, ePBC, fr.natoms);
}
do
{
time = output_env_conv_time(oenv, fr.time);
if (fr.bX && bNoJump && fr.bBox)
{
if (xp)
{
remove_jump(fr.box, fr.natoms, xp, fr.x);
}
else
{
snew(xp, fr.natoms);
}
for (i = 0; i < fr.natoms; i++)
{
copy_rvec(fr.x[i], xp[i]);
}
}
if (fr.bX && bCom && bPBC)
{
gmx_rmpbc_trxfr(gpbc, &fr);
}
if (bVD && fr.bV)
{
update_histo(isize[0], index[0], fr.v, &nvhisto, &vhisto, binwidth);
}
if (bOX && fr.bX)
{
print_data(outx, time, fr.x, mass, bCom, ngroups, isize, index, bDim, sffmt);
}
if (bOXT && fr.bX)
{
frout = fr;
if (!frout.bAtoms)
{
frout.atoms = &top.atoms;
frout.bAtoms = TRUE;
}
write_trx_x(status_out, &frout, mass, bCom, ngroups, isize, index);
}
if (bOV && fr.bV)
{
print_data(outv, time, fr.v, mass, bCom, ngroups, isize, index, bDim, sffmt);
}
if (bOF && fr.bF)
{
print_data(outf, time, fr.f, NULL, bCom, ngroups, isize, index, bDim, sffmt);
}
if (bOB && fr.bBox)
{
fprintf(outb, "\t%g", fr.time);
fprintf(outb, sffmt6,
fr.box[XX][XX], fr.box[YY][YY], fr.box[ZZ][ZZ],
fr.box[YY][XX], fr.box[ZZ][XX], fr.box[ZZ][YY]);
fprintf(outb, "\n");
}
if (bOT && fr.bV)
{
fprintf(outt, " %g", time);
for (i = 0; i < ngroups; i++)
{
fprintf(outt, sffmt, temp(fr.v, mass, isize[i], index[i]));
}
fprintf(outt, "\n");
}
if (bEKT && fr.bV)
{
fprintf(outekt, " %g", time);
for (i = 0; i < ngroups; i++)
{
fprintf(outekt, sffmt, ektrans(fr.v, mass, isize[i], index[i]));
}
fprintf(outekt, "\n");
}
if (bEKR && fr.bX && fr.bV)
{
fprintf(outekr, " %g", time);
for (i = 0; i < ngroups; i++)
{
fprintf(outekr, sffmt, ekrot(fr.x, fr.v, mass, isize[i], index[i]));
}
fprintf(outekr, "\n");
}
if ((bCV || bCF) && fr.bX &&
(ctime < 0 || (fr.time >= ctime*0.999999 &&
fr.time <= ctime*1.000001)))
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumx[i], fr.x[i]);
}
nr_xfr++;
}
if (bCV && fr.bV)
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumv[i], fr.v[i]);
}
nr_vfr++;
}
if (bCF && fr.bF)
{
for (i = 0; i < fr.natoms; i++)
{
rvec_inc(sumf[i], fr.f[i]);
}
nr_ffr++;
}
}
while (read_next_frame(oenv, status, &fr));
if (gpbc != NULL)
{
gmx_rmpbc_done(gpbc);
}
/* clean up a bit */
close_trj(status);
if (bOX)
{
ffclose(outx);
}
if (bOXT)
{
close_trx(status_out);
}
if (bOV)
{
ffclose(outv);
}
if (bOF)
{
ffclose(outf);
}
if (bOB)
{
ffclose(outb);
}
if (bOT)
{
ffclose(outt);
}
if (bEKT)
{
ffclose(outekt);
}
if (bEKR)
{
ffclose(outekr);
}
if (bVD)
{
print_histo(opt2fn("-vd", NFILE, fnm), nvhisto, vhisto, binwidth, oenv);
}
if (bCV || bCF)
{
if (nr_xfr > 1)
{
if (ePBC != epbcNONE && !bNoJump)
{
fprintf(stderr, "\nWARNING: More than one frame was used for option -cv or -cf\n"
"If atoms jump across the box you should use the -nojump or -ctime option\n\n");
}
for (i = 0; i < isize[0]; i++)
{
svmul(1.0/nr_xfr, sumx[index[0][i]], sumx[index[0][i]]);
}
}
else if (nr_xfr == 0)
{
fprintf(stderr, "\nWARNING: No coordinate frames found for option -cv or -cf\n\n");
}
}
if (bCV)
{
write_pdb_bfac(opt2fn("-cv", NFILE, fnm),
opt2fn("-av", NFILE, fnm), "average velocity", &(top.atoms),
ePBC, topbox, isize[0], index[0], nr_xfr, sumx,
nr_vfr, sumv, bDim, scale, oenv);
}
if (bCF)
{
write_pdb_bfac(opt2fn("-cf", NFILE, fnm),
opt2fn("-af", NFILE, fnm), "average force", &(top.atoms),
ePBC, topbox, isize[0], index[0], nr_xfr, sumx,
nr_ffr, sumf, bDim, scale, oenv);
}
/* view it */
view_all(oenv, NFILE, fnm);
return 0;
}
static std::string WStringToString(std::wstring &s)
{
std::string temp(s.length(), ' ');
std::copy(s.begin(), s.end(), temp.begin());
return temp;
}
void SerializeField(google::protobuf::Message *message, const Reflection *r, const FieldDescriptor *field, Handle<Value> val) {
const EnumValueDescriptor *enumValue = NULL;
bool repeated = field->is_repeated();
if (*val != NULL) {
if (field->is_optional() && (val->IsNull() || val->IsUndefined()))
return;
switch (field->cpp_type()) {
case FieldDescriptor::CPPTYPE_INT32: {
if (repeated)
r->AddInt32(message, field, val->Int32Value());
else
r->SetInt32(message, field, val->Int32Value());
break;
}
case FieldDescriptor::CPPTYPE_INT64:
if (repeated)
if (preserve_int64 && val->IsArray()) {
Handle<Object> n64_array = val->ToObject();
uint64 n64;
uint32 hi = n64_array->Get(0)->Uint32Value(), lo = n64_array->Get(1)->Uint32Value();
n64 = ((uint64)hi << 32) + (uint64)lo;
r->AddInt64(message, field, n64);
} else if (preserve_int64 && val->IsString()) {
String::Utf8Value temp(val->ToString());
std::string value = std::string(*temp);
r->AddInt64(message, field, std::stoll(value, nullptr, 10));
} else
r->AddInt64(message, field, val->NumberValue());
else
if (preserve_int64 && val->IsArray()) {
Handle<Object> n64_array = val->ToObject();
uint64 n64;
uint32 hi = n64_array->Get(0)->Uint32Value(), lo = n64_array->Get(1)->Uint32Value();
n64 = ((uint64)hi << 32) + (uint64)lo;
r->SetInt64(message, field, n64);
} else if (preserve_int64 && val->IsString()) {
String::Utf8Value temp(val->ToString());
std::string value = std::string(*temp);
r->SetInt64(message, field, std::stoll(value, nullptr, 10));
} else
r->SetInt64(message, field, val->NumberValue());
break;
case FieldDescriptor::CPPTYPE_UINT32:
if (repeated)
r->AddUInt32(message, field, val->Uint32Value());
else
r->SetUInt32(message, field, val->Uint32Value());
break;
case FieldDescriptor::CPPTYPE_UINT64:
if (repeated)
if (preserve_int64 && val->IsArray()) {
Handle<Object> n64_array = val->ToObject();
uint64 n64;
uint32 hi = n64_array->Get(0)->Uint32Value(), lo = n64_array->Get(1)->Uint32Value();
n64 = ((uint64)hi << 32) + (uint64)lo;
r->AddUInt64(message, field, n64);
} else if (preserve_int64 && val->IsString()) {
String::Utf8Value temp(val->ToString());
std::string value = std::string(*temp);
r->AddUInt64(message, field, std::stoull(value, nullptr, 10));
} else
r->AddUInt64(message, field, val->NumberValue());
else
if (preserve_int64 && val->IsArray()) {
Handle<Object> n64_array = val->ToObject();
uint64 n64;
uint32 hi = n64_array->Get(0)->Uint32Value(), lo = n64_array->Get(1)->Uint32Value();
n64 = ((uint64)hi << 32) + (uint64)lo;
r->SetUInt64(message, field, n64);
} else if (preserve_int64 && val->IsString()) {
String::Utf8Value temp(val->ToString());
std::string value = std::string(*temp);
r->SetUInt64(message, field, std::stoull(value, nullptr, 10));
} else {
r->SetUInt64(message, field, val->NumberValue());
}
break;
case FieldDescriptor::CPPTYPE_DOUBLE:
if (repeated)
r->AddDouble(message, field, val->NumberValue());
else
r->SetDouble(message, field, val->NumberValue());
break;
case FieldDescriptor::CPPTYPE_FLOAT:
if (repeated)
r->AddFloat(message, field, val->NumberValue());
else
r->SetFloat(message, field, val->NumberValue());
break;
case FieldDescriptor::CPPTYPE_BOOL:
if (repeated)
r->AddBool(message, field, val->BooleanValue());
else
r->SetBool(message, field, val->BooleanValue());
break;
case FieldDescriptor::CPPTYPE_ENUM:
// TODO: possible memory leak?
enumValue =
val->IsNumber() ?
field->enum_type()->FindValueByNumber(val->Int32Value()) :
field->enum_type()->FindValueByName(*String::Utf8Value(val));
if (enumValue != NULL) {
if (repeated)
r->AddEnum(message, field, enumValue);
else
r->SetEnum(message, field, enumValue);
}
break;
case FieldDescriptor::CPPTYPE_MESSAGE:
if (val->IsObject()) {
if (repeated)
SerializePart(r->AddMessage(message, field), val.As<Object>());
else
SerializePart(r->MutableMessage(message, field), val.As<Object>());
}
break;
case FieldDescriptor::CPPTYPE_STRING:
if (Buffer::HasInstance(val)) {
Handle<Object> buf = val->ToObject();
if (repeated)
r->AddString(message, field, std::string(Buffer::Data(buf), Buffer::Length(buf)));
else
r->SetString(message, field, std::string(Buffer::Data(buf), Buffer::Length(buf)));
break;
}
if (val->IsObject()) {
Handle<Object> val2 = val->ToObject();
Handle<Value> converter = val2->Get(Nan::New<String>("toProtobuf").ToLocalChecked());
if (converter->IsFunction()) {
Handle<Function> toProtobuf = Handle<Function>::Cast(converter);
Handle<Value> ret = toProtobuf->Call(val2,0,NULL);
if (Buffer::HasInstance(ret)) {
Handle<Object> buf = ret->ToObject();
if (repeated)
r->AddString(message, field, std::string(Buffer::Data(buf), Buffer::Length(buf)));
else
r->SetString(message, field, std::string(Buffer::Data(buf), Buffer::Length(buf)));
break;
}
}
}
String::Utf8Value temp(val->ToString());
std::string value = std::string(*temp);
if (repeated)
r->AddString(message, field, value);
else
r->SetString(message, field, value);
break;
}
}
}
scalable_rmat_iterator operator++(int)
{
scalable_rmat_iterator temp(*this);
++(*this);
return temp;
}
ReflectedObject::ReflectedObject( const char* upperTexture, GLint reflectedText )
:reflectedTexture( reflectedText )
{
string temp( upperTexture );
tFile = temp;
}
void SecondOrderTrustRegion::doOptimize(OptimizationProblemSecond& problem) {
#ifdef NICE_USELIB_LINAL
bool previousStepSuccessful = true;
double previousError = problem.objective();
problem.computeGradientAndHessian();
double delta = computeInitialDelta(problem.gradientCached(), problem.hessianCached());
double normOldPosition = 0.0;
// iterate
for (int iteration = 0; iteration < maxIterations; iteration++) {
// Log::debug() << "iteration, objective: " << iteration << ", "
// << problem.objective() << std::endl;
if (previousStepSuccessful && iteration > 0) {
problem.computeGradientAndHessian();
}
// gradient-norm stopping condition
if (problem.gradientNormCached() < epsilonG) {
Log::debug() << "SecondOrderTrustRegion stopped: gradientNorm "
<< iteration << std::endl;
break;
}
LinAlVector gradient(problem.gradientCached().linalCol());
LinAlVector negativeGradient(gradient);
negativeGradient.multiply(-1.0);
double lambda;
int lambdaMinIndex = -1;
// FIXME will this copy the matrix? no copy needed here!
LinAlMatrix hessian(problem.hessianCached().linal());
LinAlMatrix l(hessian);
try {
//l.CHdecompose(); // FIXME
choleskyDecompose(hessian, l);
lambda = 0.0;
} catch (...) { //(LinAl::BLException& e) { // FIXME
const LinAlVector& eigenValuesHessian = LinAl::eigensym(hessian);
// find smallest eigenvalue
lambda = std::numeric_limits<double>::infinity();
for (unsigned int i = 0; i < problem.dimension(); i++) {
const double eigenValue = eigenValuesHessian(i);
if (eigenValue < lambda) {
lambda = eigenValue;
lambdaMinIndex = i;
}
}
const double originalLambda = lambda;
lambda = -lambda * (1.0 + epsilonLambda);
l = hessian;
for (unsigned int i = 0; i < problem.dimension(); i++) {
l(i, i) += lambda;
}
try {
//l.CHdecompose(); // FIXME
LinAlMatrix temp(l);
choleskyDecompose(temp, l);
} catch (...) { // LinAl::BLException& e) { // FIXME
/*
* Cholesky factorization failed, which should theortically not be
* possible (can still happen due to numeric problems,
* also note that there seems to be a bug in CHdecompose()).
* Try a really great lambda as last attempt.
*/
// lambda = -originalLambda * (1.0 + epsilonLambda * 100.0)
// + 2.0 * epsilonM;
lambda = fabs(originalLambda) * (1.0 + epsilonLambda * 1E5)
+ 1E3 * epsilonM;
// lambda = fabs(originalLambda);// * 15.0;
l = hessian;
for (unsigned int i = 0; i < problem.dimension(); i++) {
l(i, i) += lambda;
}
try {
//l.CHdecompose(); // FIXME
LinAlMatrix temp(l);
choleskyDecompose(temp, l);
} catch (...) { // (LinAl::BLException& e) { // FIXME
// Cholesky factorization failed again, give up.
l = hessian;
for (unsigned int i = 0; i < problem.dimension(); i++) {
l(i, i) += lambda;
}
const LinAlVector& eigenValuesL = LinAl::eigensym(l);
Log::detail()
<< "l.CHdecompose: exception" << std::endl
//<< e.what() << std::endl // FIXME
<< "lambda=" << lambda << std::endl
<< "l" << std::endl << l
<< "hessian" << std::endl << hessian
<< "gradient" << std::endl << gradient
<< "eigenvalues hessian" << std::endl << eigenValuesHessian
<< "eigenvalues l" << std::endl << eigenValuesL
<< std::endl;
return;
}
}
}
// FIXME will the copy the vector? copy is needed here
LinAlVector step(negativeGradient);
l.CHsubstitute(step);
double normStepSquared = normSquared(step);
double normStep = sqrt(normStepSquared);
// exact: if normStep <= delta
if (normStep - delta <= tolerance) {
// exact: if lambda == 0 || normStep == delta
if (std::fabs(lambda) < tolerance
|| std::fabs(normStep - delta) < tolerance) {
// done
} else {
LinAlMatrix eigenVectors(problem.dimension(), problem.dimension());
eigensym(hessian, eigenVectors);
double a = 0.0;
double b = 0.0;
double c = 0.0;
for (unsigned int i = 0; i < problem.dimension(); i++) {
const double ui = eigenVectors(i, lambdaMinIndex);
const double si = step(i);
a += ui * ui;
b += si * ui;
c += si * si;
}
b *= 2.0;
c -= delta * delta;
const double sq = sqrt(b * b - 4.0 * a * c);
const double root1 = 0.5 * (-b + sq) / a;
const double root2 = 0.5 * (-b - sq) / a;
LinAlVector step1(step);
LinAlVector step2(step);
for (unsigned int i = 0; i < problem.dimension(); i++) {
step1(i) += root1 * eigenVectors(i, lambdaMinIndex);
step2(i) += root2 * eigenVectors(i, lambdaMinIndex);
}
const double psi1
= dotProduct(gradient, step1)
+ 0.5 * productVMV(step1, hessian, step1);
const double psi2
= dotProduct(gradient, step2)
+ 0.5 * productVMV(step2, hessian, step2);
if (psi1 < psi2) {
step = step1;
} else {
step = step2;
}
}
} else {
for (unsigned int subIteration = 0;
subIteration < maxSubIterations;
subIteration++) {
if (std::fabs(normStep - delta) <= kappa * delta) {
break;
}
// NOTE specialized algorithm may be more effifient than solvelineq
// (l is lower triangle!)
// Only lower triangle values of l are valid (other implicitly = 0.0),
// but solvelineq doesn't know that -> explicitly set to 0.0
for (int i = 0; i < l.rows(); i++) {
for (int j = i + 1; j < l.cols(); j++) {
l(i, j) = 0.0;
}
}
LinAlVector y(step.size());
try {
y = solvelineq(l, step);
} catch (LinAl::Exception& e) {
// FIXME if we end up here, something is pretty wrong!
// give up the whole thing
Log::debug() << "SecondOrderTrustRegion stopped: solvelineq failed "
<< iteration << std::endl;
return;
}
lambda += (normStep - delta) / delta
* normStepSquared / normSquared(y);
l = hessian;
for (unsigned int i = 0; i < problem.dimension(); i++) {
l(i, i) += lambda;
}
try {
//l.CHdecompose(); // FIXME
LinAlMatrix temp(l);
choleskyDecompose(temp, l);
} catch (...) { // (LinAl::BLException& e) { // FIXME
Log::detail()
<< "l.CHdecompose: exception" << std::endl
// << e.what() << std::endl // FIXME
<< "lambda=" << lambda << std::endl
<< "l" << std::endl << l
<< std::endl;
return;
}
step = negativeGradient;
l.CHsubstitute(step);
normStepSquared = normSquared(step);
normStep = sqrt(normStepSquared);
}
}
// computation of step is complete, convert to NICE::Vector
Vector stepLimun(step);
// minimal change stopping condition
if (changeIsMinimal(stepLimun, problem.position())) {
Log::debug() << "SecondOrderTrustRegion stopped: change is minimal "
<< iteration << std::endl;
break;
}
if (previousStepSuccessful) {
normOldPosition = problem.position().normL2();
}
// set new region parameters (to be verified later)
problem.applyStep(stepLimun);
// compute reduction rate
const double newError = problem.objective();
//Log::debug() << "newError: " << newError << std::endl;
const double errorReduction = newError - previousError;
const double psi = problem.gradientCached().scalarProduct(stepLimun)
+ 0.5 * productVMV(step, hessian, step);
double rho;
if (std::fabs(psi) <= epsilonRho
&& std::fabs(errorReduction) <= epsilonRho) {
rho = 1.0;
} else {
rho = errorReduction / psi;
}
// NOTE psi and errorReduction checks added to the algorithm
// described in Ferid Bajramovic's Diplomarbeit
if (rho < eta1 || psi >= 0.0 || errorReduction > 0.0) {
previousStepSuccessful = false;
problem.unapplyStep(stepLimun);
delta = alpha2 * normStep;
} else {
previousStepSuccessful = true;
previousError = newError;
if (rho >= eta2) {
const double newDelta = alpha1 * normStep;
if (newDelta > delta) {
delta = newDelta;
}
} // else: don't change delta
}
// delta stopping condition
if (delta < epsilonDelta * normOldPosition) {
Log::debug() << "SecondOrderTrustRegion stopped: delta too small "
<< iteration << std::endl;
break;
}
}
#else // no linal
fthrow(Exception,
"SecondOrderTrustRegion needs LinAl. Please recompile with LinAl");
#endif
}
AlignmentDB::AlignmentDB(string fastaFileName, string s, int kmerSize, float gapOpen, float gapExtend, float match, float misMatch, int tid, bool writeShortcut){ // This assumes that the template database is in fasta format, may
try { // need to alter this in the future?
m = MothurOut::getInstance();
current = CurrentFile::getInstance();
longest = 0;
method = s;
bool needToGenerate = true;
threadID = tid;
Utils util;
long start = time(NULL);
m->mothurOut("\nReading in the " + fastaFileName + " template sequences...\t"); cout.flush();
//bool aligned = false;
int tempLength = 0;
ifstream fastaFile;
util.openInputFile(fastaFileName, fastaFile);
while (!fastaFile.eof()) {
Sequence temp(fastaFile); util.gobble(fastaFile);
if (m->getControl_pressed()) { templateSequences.clear(); break; }
if (temp.getName() != "") {
templateSequences.push_back(temp);
//save longest base
if (temp.getUnaligned().length() >= longest) { longest = ((int)temp.getUnaligned().length()+1); }
if (tempLength != 0) {
if (tempLength != temp.getAligned().length()) { m->mothurOut("[ERROR]: template is not aligned, aborting.\n"); m->setControl_pressed(true); }
}else { tempLength = (int)temp.getAligned().length(); }
}
}
fastaFile.close();
numSeqs = (int)templateSequences.size();
//all of this is elsewhere already!
m->mothurOut("DONE.\n");
cout.flush();
m->mothurOut("It took " + toString(time(NULL) - start) + " to read " + toString(templateSequences.size()) + " sequences.\n");
//in case you delete the seqs and then ask for them
emptySequence = Sequence();
emptySequence.setName("no_match");
emptySequence.setUnaligned("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
emptySequence.setAligned("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
string kmerDBName;
if(method == "kmer") {
search = new KmerDB(fastaFileName, kmerSize);
kmerDBName = fastaFileName.substr(0,fastaFileName.find_last_of(".")+1) + char('0'+ kmerSize) + "mer";
ifstream kmerFileTest(kmerDBName.c_str());
if(kmerFileTest){
string line = util.getline(kmerFileTest);
bool GoodFile = util.checkReleaseVersion(line, current->getVersion()); kmerFileTest.close();
int shortcutTimeStamp = util.getTimeStamp(kmerDBName);
int referenceTimeStamp = util.getTimeStamp(fastaFileName);
//if the shortcut file is older then the reference file, remake shortcut file
if (shortcutTimeStamp < referenceTimeStamp) { GoodFile = false; }
if (GoodFile) { needToGenerate = false; }
}
}
else if(method == "suffix") { search = new SuffixDB(numSeqs); }
else if(method == "blast") { search = new BlastDB(fastaFileName.substr(0,fastaFileName.find_last_of(".")+1), gapOpen, gapExtend, match, misMatch, "", threadID); }
else {
method = "kmer";
m->mothurOut(method + " is not a valid search option. I will run the command using kmer, ksize=8.\n");
search = new KmerDB(fastaFileName, 8);
}
if (!m->getControl_pressed()) {
if (needToGenerate) {
//add sequences to search
for (int i = 0; i < templateSequences.size(); i++) {
search->addSequence(templateSequences[i]);
if (m->getControl_pressed()) { templateSequences.clear(); break; }
}
if (m->getControl_pressed()) { templateSequences.clear(); }
if ((method != "kmer") || ((method == "kmer") && (writeShortcut))) { search->generateDB(); }
}else if ((method == "kmer") && (!needToGenerate)) {
ifstream kmerFileTest(kmerDBName.c_str());
search->readKmerDB(kmerFileTest);
}
search->setNumSeqs(numSeqs);
}
}
catch(exception& e) {
m->errorOut(e, "AlignmentDB", "AlignmentDB");
exit(1);
}
}
TestCase& TestCase::operator = ( TestCase const& other ) {
TestCase temp( other );
swap( temp );
return *this;
}
void MatrixStack::MultMatrix(const Matrix4Df& matrixRHS)
{
Matrix4Df temp(matrixRHS * m_stack.top());
PopMatrix();
m_stack.push(temp);
}
inline Derived operator--(int)
{
Derived temp(*this);
--_id;
return temp;
}
inline Derived operator++(int)
{
Derived temp(*this);
++_id;
return temp;
}
Vector4D<double> Vector4D<double>::Normalized()
{
Vector4D<double> temp(*this);
temp.Normalize();
return temp;
}
//------------------------------------------------------------
VIREO_EXPORT TypeRef TypeManager_FindType(TypeManagerRef typeManager, const char* typeName)
{
SubString temp(typeName);
return typeManager->FindType(&temp);
}
Vector4D<double> Vector4D<double>::Inverted()
{
Vector4D<double> temp(*this);
temp.Invert();
return temp;
}
SymmetricSchurDecomposition::SymmetricSchurDecomposition(const Matrix & s)
: diagonal_(s.rows()), eigenVectors_(s.rows(), s.columns(), 0.0) {
QL_REQUIRE(s.rows() > 0 && s.columns() > 0, "null matrix given");
QL_REQUIRE(s.rows()==s.columns(), "input matrix must be square");
Size size = s.rows();
for (Size q=0; q<size; q++) {
diagonal_[q] = s[q][q];
eigenVectors_[q][q] = 1.0;
}
Matrix ss = s;
std::vector<Real> tmpDiag(diagonal_.begin(), diagonal_.end());
std::vector<Real> tmpAccumulate(size, 0.0);
Real threshold, epsPrec = 1e-15;
bool keeplooping = true;
Size maxIterations = 100, ite = 1;
do {
//main loop
Real sum = 0;
for (Size a=0; a<size-1; a++) {
for (Size b=a+1; b<size; b++) {
sum += std::fabs(ss[a][b]);
}
}
if (sum==0) {
keeplooping = false;
} else {
/* To speed up computation a threshold is introduced to
make sure it is worthy to perform the Jacobi rotation
*/
if (ite<5) threshold = 0.2*sum/(size*size);
else threshold = 0.0;
Size j, k, l;
for (j=0; j<size-1; j++) {
for (k=j+1; k<size; k++) {
Real sine, rho, cosin, heig, tang, beta;
Real smll = std::fabs(ss[j][k]);
if(ite> 5 &&
smll<epsPrec*std::fabs(diagonal_[j]) &&
smll<epsPrec*std::fabs(diagonal_[k])) {
ss[j][k] = 0;
} else if (std::fabs(ss[j][k])>threshold) {
heig = diagonal_[k]-diagonal_[j];
if (smll<epsPrec*std::fabs(heig)) {
tang = ss[j][k]/heig;
} else {
beta = 0.5*heig/ss[j][k];
tang = 1.0/(std::fabs(beta)+
std::sqrt(1+beta*beta));
if (beta<0)
tang = -tang;
}
cosin = 1/std::sqrt(1+tang*tang);
sine = tang*cosin;
rho = sine/(1+cosin);
heig = tang*ss[j][k];
tmpAccumulate[j] -= heig;
tmpAccumulate[k] += heig;
diagonal_[j] -= heig;
diagonal_[k] += heig;
ss[j][k] = 0.0;
for (l=0; l+1<=j; l++)
jacobiRotate_(ss, rho, sine, l, j, l, k);
for (l=j+1; l<=k-1; l++)
jacobiRotate_(ss, rho, sine, j, l, l, k);
for (l=k+1; l<size; l++)
jacobiRotate_(ss, rho, sine, j, l, k, l);
for (l=0; l<size; l++)
jacobiRotate_(eigenVectors_,
rho, sine, l, j, l, k);
}
}
}
for (k=0; k<size; k++) {
tmpDiag[k] += tmpAccumulate[k];
diagonal_[k] = tmpDiag[k];
tmpAccumulate[k] = 0.0;
}
}
} while (++ite<=maxIterations && keeplooping);
QL_ENSURE(ite<=maxIterations,
"Too many iterations (" << maxIterations << ") reached");
// sort (eigenvalues, eigenvectors)
std::vector<std::pair<Real, std::vector<Real> > > temp(size);
std::vector<Real> eigenVector(size);
Size row, col;
for (col=0; col<size; col++) {
std::copy(eigenVectors_.column_begin(col),
eigenVectors_.column_end(col), eigenVector.begin());
temp[col] = std::make_pair(diagonal_[col], eigenVector);
}
std::sort(temp.begin(), temp.end(),
std::greater<std::pair<Real, std::vector<Real> > >());
Real maxEv = temp[0].first;
for (col=0; col<size; col++) {
// check for round-off errors
diagonal_[col] =
(std::fabs(temp[col].first/maxEv)<1e-16 ? 0.0 :
temp[col].first);
Real sign = 1.0;
if (temp[col].second[0]<0.0)
sign = -1.0;
for (row=0; row<size; row++) {
eigenVectors_[row][col] = sign * temp[col].second[row];
}
}
}
void trecruit::refresh_tooltip(twindow& window)
{
int idx_in_resistances;
std::stringstream text;
tstacked_widget* stacked = find_widget<tstacked_widget>(&window, "middle_top_part", false, true);
stacked->set_dirty(true);
stacked = find_widget<tstacked_widget>(&window, "right_part", false, true);
stacked->set_dirty(true);
if (checked_heros_.empty()) {
// It is necessary set all relative tips to empty.
tcontrol* control = find_widget<tcontrol>(&window, "master_png", false, true);
control->set_label("");
tlabel* label = find_widget<tlabel>(&window, "master_name", false, true);
label->set_label("");
// leadership
label = find_widget<tlabel>(&window, "tip_leadership", false, true);
label->set_label("");
// force
label = find_widget<tlabel>(&window, "tip_force", false, true);
label->set_label("");
// intellect
label = find_widget<tlabel>(&window, "tip_intellect", false, true);
label->set_label("");
// politics
label = find_widget<tlabel>(&window, "tip_politics", false, true);
label->set_label("");
// charm
label = find_widget<tlabel>(&window, "tip_charm", false, true);
label->set_label("");
// hp
label = find_widget<tlabel>(&window, "tip_hp", false, true);
label->set_label("");
// xp
label = find_widget<tlabel>(&window, "tip_xp", false, true);
label->set_label("");
// movement
label = find_widget<tlabel>(&window, "tip_movement", false, true);
label->set_label("");
// arm
label = find_widget<tlabel>(&window, "tip_arm", false, true);
label->set_label("");
// adaptability
label = find_widget<tlabel>(&window, "tip_adaptability", false, true);
label->set_label("");
// abilities
label = find_widget<tlabel>(&window, "tip_abilities", false, true);
label->set_label("");
// feature
label = find_widget<tlabel>(&window, "tip_feature", false, true);
label->set_label("");
// attack
label = find_widget<tlabel>(&window, "tip_attack", false, true);
label->set_label("");
// resistance
for (idx_in_resistances = 0; idx_in_resistances < 7; idx_in_resistances ++) {
text.str("");
text << "tip_resistance" << idx_in_resistances;
label = find_widget<tlabel>(&window, text.str(), false, true);
label->set_label("");
}
return;
}
const unit_type* t = unit_types_[type_index_];
std::vector<const hero*> v;
int index = 0;
for (std::set<int>::const_iterator itor = checked_heros_.begin(); itor != checked_heros_.end(); ++ itor, index ++) {
if (index == 0) {
v.push_back(fresh_heros_[*itor]);
} else if (index == 1) {
v.push_back(fresh_heros_[*itor]);
} else if (index == 2) {
v.push_back(fresh_heros_[*itor]);
}
}
type_heros_pair pair(t, v);
unit temp(units_, heros_, pair, city_.cityno(), false);
std::stringstream str;
// refresh to gui
tcontrol* control = find_widget<tcontrol>(&window, "master_png", false, true);
control->set_label(temp.master().image());
tlabel* label = find_widget<tlabel>(&window, "master_name", false, true);
label->set_label(temp.master().name());
control = find_widget<tcontrol>(&window, "second_png", false, true);
label = find_widget<tlabel>(&window, "second_name", false, true);
if (temp.second().valid()) {
control->set_label(temp.second().image());
label->set_label(temp.second().name());
} else {
control->set_label("");
label->set_label("");
}
control = find_widget<tcontrol>(&window, "third_png", false, true);
label = find_widget<tlabel>(&window, "third_name", false, true);
if (temp.third().valid()) {
control->set_label(temp.third().image());
label->set_label(temp.third().name());
} else {
control->set_label("");
label->set_label("");
}
// leadership
label = find_widget<tlabel>(&window, "tip_leadership", false, true);
label->set_label(lexical_cast<std::string>(temp.leadership_));
// force
label = find_widget<tlabel>(&window, "tip_force", false, true);
label->set_label(lexical_cast<std::string>(temp.force_));
// intellect
label = find_widget<tlabel>(&window, "tip_intellect", false, true);
label->set_label(lexical_cast<std::string>(temp.intellect_));
// politics
label = find_widget<tlabel>(&window, "tip_politics", false, true);
label->set_label(lexical_cast<std::string>(temp.politics_));
// charm
label = find_widget<tlabel>(&window, "tip_charm", false, true);
label->set_label(lexical_cast<std::string>(temp.charm_));
// hp
label = find_widget<tlabel>(&window, "tip_hp", false, true);
label->set_label(lexical_cast<std::string>(temp.max_hitpoints()));
// xp
label = find_widget<tlabel>(&window, "tip_xp", false, true);
label->set_label(lexical_cast<std::string>(temp.max_experience()));
// movement
label = find_widget<tlabel>(&window, "tip_movement", false, true);
label->set_label(lexical_cast<std::string>(temp.total_movement()));
// arm
label = find_widget<tlabel>(&window, "tip_arm", false, true);
str << temp.type_name() << "(Lv" << temp.level() << ")";
label->set_label(str.str());
// adaptability
str.str("");
label = find_widget<tlabel>(&window, "tip_adaptability", false, true);
str << hero::arms_str(temp.arms()) << "(" << hero::adaptability_str2(ftofxp12(temp.adaptability_[temp.arms()])) << ")";
label->set_label(str.str());
// abilities
str.str("");
std::vector<std::string> abilities_tt;
abilities_tt = temp.ability_tooltips(true);
if (!abilities_tt.empty()) {
std::vector<t_string> abilities;
for (std::vector<std::string>::const_iterator a = abilities_tt.begin(); a != abilities_tt.end(); a += 2) {
abilities.push_back(*a);
}
for (std::vector<t_string>::const_iterator a = abilities.begin(); a != abilities.end(); a++) {
if (a != abilities.begin()) {
if (a - abilities.begin() != 2) {
str << ", ";
} else {
str << "\n";
}
}
str << (*a);
}
}
label = find_widget<tlabel>(&window, "tip_abilities", false, true);
label->set_label(str.str());
// feature
str.str("");
index = 0;
for (int i = 0; i < HEROS_MAX_FEATURE; i ++) {
if (unit_feature_val2(temp, i) == hero_feature_single_result) {
if (index > 0) {
if (index != 2) {
str << ", ";
} else {
str << "\n";
}
}
index ++;
str << temp.master().feature_str(i);
}
}
label = find_widget<tlabel>(&window, "tip_feature", false, true);
label->set_label(str.str());
// attack
str.str("");
std::vector<attack_type>* attacks_ptr = const_cast<std::vector<attack_type>*>(&temp.attacks());
for (std::vector<attack_type>::const_iterator at_it = attacks_ptr->begin(); at_it != attacks_ptr->end(); ++at_it) {
// see generate_report() in generate_report.cpp
str << at_it->name() << " (" << dgettext("wesnoth", at_it->type().c_str()) << ")\n";
std::string accuracy = at_it->accuracy_parry_description();
if(accuracy.empty() == false) {
accuracy += " ";
}
str << " " << at_it->damage() << "-" << at_it->num_attacks()
<< " " << accuracy << "- " << dgettext("wesnoth", at_it->range().c_str());
std::string special = at_it->weapon_specials(true);
if (!special.empty()) {
str << "(" << special << ")";
}
str << "\n";
}
label = find_widget<tlabel>(&window, "tip_attack", false, true);
label->set_label(str.str());
// resistance
std::set<std::string> resistances_table;
utils::string_map resistances = temp.get_base_resistances();
bool att_def_diff = false;
const map_location& loc = temp.get_location();
idx_in_resistances = 0;
for (utils::string_map::iterator resist = resistances.begin(); resist != resistances.end(); ++resist, idx_in_resistances ++) {
// str << gettext(resist->first.c_str()) << ": ";
str.str("");
if (loc.valid()) {
// Some units have different resistances when
// attacking or defending.
int res_att = 100 - temp.resistance_against(resist->first, true, loc);
int res_def = 100 - temp.resistance_against(resist->first, false, loc);
if (res_att == res_def) {
str << res_def;
} else {
str << res_att << "% / " << res_def; // (Att / Def)
att_def_diff = true;
}
} else {
str << 100 - lexical_cast_default<int>(resist->second.c_str());
}
str << "%";
text.str("");
text << "tip_resistance" << idx_in_resistances;
label = find_widget<tlabel>(&window, text.str(), false, true);
label->set_label(str.str());
}
}
int main(int narg,char **arg)
{
init_latpars();
//read ensemble list, meson masses and meson name
FILE *an_input_file=open_file("analysis_pars","r");
char meson_name[1024];
read_formatted_from_file_expecting((char*)&include_a4,an_input_file,"%d","include_a4");
read_formatted_from_file_expecting((char*)&include_380,an_input_file,"%d","include_380");
read_formatted_from_file_expecting((char*)&include_ml_term,an_input_file,"%d","include_ml_term");
read_formatted_from_file_expecting((char*)&nens,an_input_file,"%d","nens");
read_formatted_from_file_expecting(meson_name,an_input_file,"%s","meson_name");
lmass=new double[nens];
ibeta=new int[nens];
F=bvec(nens,nboot,njack);
ofstream bare_data_table("bare_data_table");
for(int iens=0;iens<nens;iens++)
{
char path[1024];
read_formatted_from_file((char*)&(ibeta[iens]),an_input_file,"%d","ibeta");
read_formatted_from_file((char*)&(lmass[iens]),an_input_file,"%lg","lmass");
read_formatted_from_file(path,an_input_file,"%s","path");
jack temp(njack);
temp.load(combine("../%s/%s",path,meson_name).c_str());
//write the bare data table
bare_data_table<<path<<" "<<smart_print(temp)<<endl;
//load iboot
int iboot_jack[100];
load_iboot(iboot_jack,path);
boot_from_jack(F.data[iens],temp,iboot_jack);
}
fclose(an_input_file);
//define ml and ref ml
ml=bvec(nens,nboot,njack);
for(int iens=0;iens<nens;iens++)
{
int b=ibeta[iens],r=ref_ml_beta[b];
//define ml
cout<<iens<<" "<<b<<" "<<lmass[iens]<<endl;
ml[iens]=lmass[iens]/lat[b]/Zp[b];
//set the lighter mass
if(r==-1||fabs(ml[r].med()-0.050)>fabs(ml[iens].med()-0.050)) ref_ml_beta[b]=iens;
}
cout<<"---"<<endl;
for(int ib=0;ib<nbeta;ib++) if(ref_ml_beta[ib]!=-1) cout<<"Ref "<<ib<<" = "<<ref_ml_beta[ib]<<", "<<ml[ref_ml_beta[ib]]<<" MeV"<<endl;
cout<<"---"<<endl;
//perform the fit
boot A(nboot,njack),B(nboot,njack),C(nboot,njack),D(nboot,njack);
fit(A,B,C,D,ml,F);
//chiral extrapolation
bvec F_chir(nbeta,nboot,njack);
boot F_chir_cont(nboot,njack);
bvec F_estr_ml(nbeta,nboot,njack);
for(int iboot=0;iboot<nboot+1;iboot++)
{
F_chir_cont.data[iboot]=fun_fit_F(A[iboot],B[iboot],C[iboot],D[iboot],ml_phys[iboot],0);
for(int ib=0;ib<nbeta;ib++)
{
int r=ref_ml_beta[ib];
F_chir[ib].data[iboot]=fun_fit_F(A[iboot],B[iboot],C[iboot],D[iboot],ml_phys[iboot],lat[ib][iboot]);
if(r!=-1)
F_estr_ml.data[ib].data[iboot]=F[r][iboot]*fun_fit_F(A[nboot],B[nboot],C[nboot],D[nboot],ml_phys[nboot],0)/fun_fit_F(A[nboot],B[nboot],C[nboot],D[nboot],ml[r][nboot],0);
}
}
//chiral and continuum
cout<<"F = "<<F_chir_cont<<endl;
cout<<endl;
par_res_fit_F=bvec(4,nboot,njack);
par_res_fit_F.data[0]=A;
par_res_fit_F.data[1]=B;
par_res_fit_F.data[2]=C;
par_res_fit_F.data[3]=D;
const char tag_ml[1024]="m\\sl\\N\\SMS,2GeV\\N (GeV)";
const char tag_a2[1024]="a\\S2\\N (fm)";
double lat_med_fm[4]={lat[0].med()*hc,lat[1].med()*hc,lat[2].med()*hc,lat[3].med()*hc};
plot_funz_ml("F_funz_ml.xmg",meson_name,tag_ml,meson_name,ml,F,par_res_fit_F,ml_phys.med(),fun_fit_F,F_chir_cont);
plot_funz_a2("F_funz_a2.xmg",meson_name,tag_a2,meson_name,lat_med_fm,F_estr_ml,par_res_fit_F,fun_fit_F,F_chir_cont);
F_chir_cont.write_to_binfile("results");
return 0;
}
void swap(T& a, T& b)
{
T temp(a);
a = b;
b = temp;
}
Rational Rational::operator --(int i)
{
Rational temp(*this);
this->operator--();
return temp;
}
void GradeBook::addCourse(int CRN)
{
Course temp(CRN);
list.insert(temp);
} // addCourse()
Rational operator -(Rational const &l, Rational const & r)
{
Rational temp(l);
temp-=r;
return temp;
}
string fp(double value) {
string temp;
temp.reserve(fp(0, value));
fp(temp(), value);
return temp;
}
Vector4D<float> Vector4D<float>::Normalized()
{
Vector4D<float> temp(*this);
temp.Normalize();
return temp;
}
vector<int> LefseCommand::runWilcoxon(vector<SharedRAbundVector*>& lookup, DesignMap& designMap, vector<int> bins) {
try {
vector<int> significantOtuLabels;
//if it exists and meets the following requirements run Wilcoxon
/*
1. Subclass members all belong to same main class
2. Number of groups in each subclass is the same
3. anything else??
*/
vector<string> subclasses;
map<string, string> subclass2Class;
map<string, int> subclassCounts;
map<string, vector<int> > subClass2GroupIndex; //maps subclass name to vector of indexes in lookup from that subclass. old -> 1,2,3 means groups in location 1,2,3 of lookup are from old. Saves time below.
bool error = false;
for (int j = 0; j < lookup.size(); j++) {
string group = lookup[j]->getGroup();
string treatment = designMap.get(group, mclass); //get value for this group in this category
string thisSub = designMap.get(group, subclass);
map<string, string>::iterator it = subclass2Class.find(thisSub);
if (it == subclass2Class.end()) {
subclass2Class[thisSub] = treatment;
subclassCounts[thisSub] = 1;
vector<int> temp; temp.push_back(j);
subClass2GroupIndex[thisSub] = temp;
}
else {
subclassCounts[thisSub]++;
subClass2GroupIndex[thisSub].push_back(j);
if (it->second != treatment) {
error = true;
m->mothurOut("[ERROR]: subclass " + thisSub + " has members in " + it->second + " and " + treatment + ". Subclass members must be from the same class. Ignoring wilcoxon.\n");
}
}
}
if (error) { return significantOtuLabels; }
else { //check counts to make sure subclasses are the same size
set<int> counts;
for (map<string, int>::iterator it = subclassCounts.begin(); it != subclassCounts.end(); it++) { counts.insert(it->second); }
if (counts.size() > 1) { m->mothurOut("[ERROR]: subclasses must be the same size. Ignoring wilcoxon.\n");
return significantOtuLabels; }
}
int numBins = lookup[0]->getNumBins();
vector<compGroup> comp;
//find comparisons and fill comp
map<string, int>::iterator itB;
for(map<string, int>::iterator it=subclassCounts.begin();it!=subclassCounts.end();it++){
itB = it;itB++;
for(itB;itB!=subclassCounts.end();itB++){
compGroup temp(it->first,itB->first);
comp.push_back(temp);
}
}
int numComp = comp.size();
if (numComp < 2) { m->mothurOut("[ERROR]: Need at least 2 subclasses, Ignoring Wilcoxon.\n");
return significantOtuLabels; }
map<string, string> variables;
variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(sharedfile));
variables["[distance]"] = lookup[0]->getLabel();
string outputFileName = getOutputFileName("wilcoxon",variables);
ofstream out;
m->openOutputFile(outputFileName, out);
outputNames.push_back(outputFileName); outputTypes["wilcoxon"].push_back(outputFileName);
out << "OTULabel\tComparision\tWilcoxon\tPvalue\n";
LinearAlgebra linear;
for (int i = 0; i < numBins; i++) {
if (m->control_pressed) { break; }
if (m->inUsersGroups(i, bins)) { //flagged in Kruskal Wallis
bool sig = false;
//for each subclass comparision
for (int j = 0; j < numComp; j++) {
//fill x and y with this comparisons data
vector<double> x; vector<double> y;
//fill x and y
vector<int> xIndexes = subClass2GroupIndex[comp[j].group1]; //indexes in lookup for this subclass
for (int k = 0; k < xIndexes.size(); k++) { x.push_back(lookup[xIndexes[k]]->getAbundance(i)); }
vector<int> yIndexes = subClass2GroupIndex[comp[j].group2]; //indexes in lookup for this subclass
for (int k = 0; k < yIndexes.size(); k++) { y.push_back(lookup[yIndexes[k]]->getAbundance(i)); }
double pValue = 0.0;
double H = linear.calcWilcoxon(x, y, pValue);
//output H and signifigance
out << m->currentBinLabels[i] << '\t' << comp[j].getCombo() << '\t' << H << '\t' << pValue << endl;
//set sig - not sure how yet
}
if (sig) { significantOtuLabels.push_back(i); }
}
}
out.close();
return significantOtuLabels;
}
catch(exception& e) {
m->errorOut(e, "LefseCommand", "runWilcoxon");
exit(1);
}
}
Vector4D<float> Vector4D<float>::Inverted()
{
Vector4D<float> temp(*this);
temp.Invert();
return temp;
}
double cv::kmeans( InputArray _data, int K,
InputOutputArray _bestLabels,
TermCriteria criteria, int attempts,
int flags, OutputArray _centers )
{
const int SPP_TRIALS = 3;
Mat data0 = _data.getMat();
bool isrow = data0.rows == 1;
int N = isrow ? data0.cols : data0.rows;
int dims = (isrow ? 1 : data0.cols)*data0.channels();
int type = data0.depth();
attempts = std::max(attempts, 1);
CV_Assert( data0.dims <= 2 && type == CV_32F && K > 0 );
CV_Assert( N >= K );
Mat data(N, dims, CV_32F, data0.ptr(), isrow ? dims * sizeof(float) : static_cast<size_t>(data0.step));
_bestLabels.create(N, 1, CV_32S, -1, true);
Mat _labels, best_labels = _bestLabels.getMat();
if( flags & CV_KMEANS_USE_INITIAL_LABELS )
{
CV_Assert( (best_labels.cols == 1 || best_labels.rows == 1) &&
best_labels.cols*best_labels.rows == N &&
best_labels.type() == CV_32S &&
best_labels.isContinuous());
best_labels.copyTo(_labels);
}
else
{
if( !((best_labels.cols == 1 || best_labels.rows == 1) &&
best_labels.cols*best_labels.rows == N &&
best_labels.type() == CV_32S &&
best_labels.isContinuous()))
best_labels.create(N, 1, CV_32S);
_labels.create(best_labels.size(), best_labels.type());
}
int* labels = _labels.ptr<int>();
Mat centers(K, dims, type), old_centers(K, dims, type), temp(1, dims, type);
std::vector<int> counters(K);
std::vector<Vec2f> _box(dims);
Vec2f* box = &_box[0];
double best_compactness = DBL_MAX, compactness = 0;
RNG& rng = theRNG();
int a, iter, i, j, k;
if( criteria.type & TermCriteria::EPS )
criteria.epsilon = std::max(criteria.epsilon, 0.);
else
criteria.epsilon = FLT_EPSILON;
criteria.epsilon *= criteria.epsilon;
if( criteria.type & TermCriteria::COUNT )
criteria.maxCount = std::min(std::max(criteria.maxCount, 2), 100);
else
criteria.maxCount = 100;
if( K == 1 )
{
attempts = 1;
criteria.maxCount = 2;
}
const float* sample = data.ptr<float>(0);
for( j = 0; j < dims; j++ )
box[j] = Vec2f(sample[j], sample[j]);
for( i = 1; i < N; i++ )
{
sample = data.ptr<float>(i);
for( j = 0; j < dims; j++ )
{
float v = sample[j];
box[j][0] = std::min(box[j][0], v);
box[j][1] = std::max(box[j][1], v);
}
}
for( a = 0; a < attempts; a++ )
{
double max_center_shift = DBL_MAX;
for( iter = 0;; )
{
swap(centers, old_centers);
if( iter == 0 && (a > 0 || !(flags & KMEANS_USE_INITIAL_LABELS)) )
{
if( flags & KMEANS_PP_CENTERS )
generateCentersPP(data, centers, K, rng, SPP_TRIALS);
else
{
for( k = 0; k < K; k++ )
generateRandomCenter(_box, centers.ptr<float>(k), rng);
}
}
else
{
if( iter == 0 && a == 0 && (flags & KMEANS_USE_INITIAL_LABELS) )
{
for( i = 0; i < N; i++ )
CV_Assert( (unsigned)labels[i] < (unsigned)K );
}
// compute centers
centers = Scalar(0);
for( k = 0; k < K; k++ )
counters[k] = 0;
for( i = 0; i < N; i++ )
{
sample = data.ptr<float>(i);
k = labels[i];
float* center = centers.ptr<float>(k);
j=0;
#if CV_ENABLE_UNROLLED
for(; j <= dims - 4; j += 4 )
{
float t0 = center[j] + sample[j];
float t1 = center[j+1] + sample[j+1];
center[j] = t0;
center[j+1] = t1;
t0 = center[j+2] + sample[j+2];
t1 = center[j+3] + sample[j+3];
center[j+2] = t0;
center[j+3] = t1;
}
#endif
for( ; j < dims; j++ )
center[j] += sample[j];
counters[k]++;
}
if( iter > 0 )
max_center_shift = 0;
for( k = 0; k < K; k++ )
{
if( counters[k] != 0 )
continue;
// if some cluster appeared to be empty then:
// 1. find the biggest cluster
// 2. find the farthest from the center point in the biggest cluster
// 3. exclude the farthest point from the biggest cluster and form a new 1-point cluster.
int max_k = 0;
for( int k1 = 1; k1 < K; k1++ )
{
if( counters[max_k] < counters[k1] )
max_k = k1;
}
double max_dist = 0;
int farthest_i = -1;
float* new_center = centers.ptr<float>(k);
float* old_center = centers.ptr<float>(max_k);
float* _old_center = temp.ptr<float>(); // normalized
float scale = 1.f/counters[max_k];
for( j = 0; j < dims; j++ )
_old_center[j] = old_center[j]*scale;
for( i = 0; i < N; i++ )
{
if( labels[i] != max_k )
continue;
sample = data.ptr<float>(i);
double dist = normL2Sqr(sample, _old_center, dims);
if( max_dist <= dist )
{
max_dist = dist;
farthest_i = i;
}
}
counters[max_k]--;
counters[k]++;
labels[farthest_i] = k;
sample = data.ptr<float>(farthest_i);
for( j = 0; j < dims; j++ )
{
old_center[j] -= sample[j];
new_center[j] += sample[j];
}
}
for( k = 0; k < K; k++ )
{
float* center = centers.ptr<float>(k);
CV_Assert( counters[k] != 0 );
float scale = 1.f/counters[k];
for( j = 0; j < dims; j++ )
center[j] *= scale;
if( iter > 0 )
{
double dist = 0;
const float* old_center = old_centers.ptr<float>(k);
for( j = 0; j < dims; j++ )
{
double t = center[j] - old_center[j];
dist += t*t;
}
max_center_shift = std::max(max_center_shift, dist);
}
}
}
if( ++iter == MAX(criteria.maxCount, 2) || max_center_shift <= criteria.epsilon )
break;
// assign labels
Mat dists(1, N, CV_64F);
double* dist = dists.ptr<double>(0);
parallel_for_(Range(0, N),
KMeansDistanceComputer(dist, labels, data, centers));
compactness = 0;
for( i = 0; i < N; i++ )
{
compactness += dist[i];
}
}
if( compactness < best_compactness )
{
best_compactness = compactness;
if( _centers.needed() )
centers.copyTo(_centers);
_labels.copyTo(best_labels);
}
}
return best_compactness;
}
rmat_iterator operator++(int)
{
rmat_iterator temp(*this);
++(*this);
return temp;
}