int main(int argc, string argv[])
{
stream istr, ostr;
real eps2, tnow;
int nforce, nbody, i;
bodyptr btab = NULL;
string intags[MaxBodyFields];
initparam(argv, defv);
layout_body(bodytags, Precision, NDIM);
istr = stropen(getparam("in"), "r");
get_history(istr);
ostr = stropen(getparam("out"), "w");
put_history(ostr);
eps2 = rsqr(getdparam("eps"));
nforce = -1; /* use nforce as flag... */
while (get_snap(istr, &btab, &nbody, &tnow, intags, FALSE)) {
if (nforce == -1 && ! set_member(intags, MassTag))
error("%s: Mass data missing from 1st snapshot\n", getargv0());
if (! set_member(intags, PosTag))
error("%s: %s data missing\n", getargv0(), PosTag);
if (nforce == -1)
nforce = (strnull(getparam("nforce")) ?
nbody : MIN(getiparam("nforce"), nbody));
for (i = 0; i < nforce; i++)
sum1force(btab, nbody, i, eps2);
put_snap(ostr, &btab, &nforce, &tnow, bodytags);
}
return (0);
}
mxArray * FT_set_Set(const set_type S)
{
mxArray * tmp;
double * r;
int i, j;
int num;
if (S) {
num = (int)(S[0]);
j = 0;
for (i = 1; i <= num; i++) {
if (set_member(i,S)) {
j++;
}
}
tmp = mxCreateDoubleMatrix(1, j, mxREAL);
r = mxGetPr(tmp);
j = 0;
for (i = 1; i <= num; i++) {
if (set_member(i,S)) {
r[j++] = i;
}
}
return tmp;
}
return 0;
}
int main(int argc, string argv[])
{
stream istr, ostr;
string itags[MaxBodyFields];
initparam(argv, defv);
new_field(&LinkField, IntType, LinkTag); /* use int's worth of space */
new_field(&LinkField + 1, NULL, NULL);
layout_body(bodytags, Precision, NDIM);
istr = stropen(getparam("in"), "r");
get_history(istr);
if (! get_snap(istr, &btab, &nbody, &tnow, itags, TRUE))
error("%s: snapshot input failed\n", getargv0());
if (! set_member(itags, PosTag))
error("%s: %s data missing\n", getargv0(), PosTag);
if (getbparam("subkey") && ! set_member(itags, KeyTag))
error("%s: %s data missing\n", getargv0(), KeyTag);
findobj(getdparam("bcrit"), getiparam("nmin"), getbparam("subkey"));
ostr = stropen(getparam("out"), "w");
put_history(ostr);
put_snap(ostr, &btab, &nbody, &tnow,
set_union(itags, set_cons(KeyTag, NULL)));
strclose(ostr);
return (0);
}
void snapstack(bodyptr btab, bodyptr bt1, int nb1, bodyptr bt2, int nb2,
string *tags)
{
vector deltar, deltav;
bodyptr bp;
int i;
setvect(deltar, burststring(getparam("deltar"), ", "));
setvect(deltav, burststring(getparam("deltav"), ", "));
for (i = 0; i < nb1; i++) {
bp = NthBody(btab, i);
memcpy(bp, NthBody(bt1, i), SizeofBody);
if (set_member(tags, PosTag)) {
ADDMULVS(Pos(bp), deltar, 0.5);
}
if (set_member(tags, VelTag)) {
ADDMULVS(Vel(bp), deltav, 0.5);
}
}
for (i = 0; i < nb2; i++) {
bp = NthBody(btab, i + nb1);
memcpy(bp, NthBody(bt2, i), SizeofBody);
if (set_member(tags, PosTag)) {
ADDMULVS(Pos(bp), deltar, -0.5);
}
if (set_member(tags, VelTag)) {
ADDMULVS(Vel(bp), deltav, -0.5);
}
}
}
int main(int argc, string argv[])
{
stream istr, ostr;
bodyptr btab = NULL;
int nbody;
real tnow;
string intags[MaxBodyFields];
gsprof *gsp;
initparam(argv, defv);
layout_body(bodyfields, Precision, NDIM);
istr = stropen(getparam("in"), "r");
get_history(istr);
if (! get_snap(istr, &btab, &nbody, &tnow, intags, FALSE))
error("%s: snapshot input failed\n", getargv0());
if (! set_member(intags, PosTag))
error("%s: position data missing\n", getargv0());
if (! set_member(intags, MassTag))
error("%s: mass data missing\n", getargv0());
gsp = snapgsp(btab, nbody, getiparam("npoint"),
getdparam("alpha"), getdparam("beta"));
if (! strnull(getparam("out"))) {
ostr = stropen(getparam("out"), "w");
put_history(ostr);
put_gsprof(ostr, gsp);
strclose(ostr);
}
return (0);
}
int main(int argc, string argv[])
{
string prog, coords, itags[MaxBodyFields], otags[MaxBodyFields];
stream xstr, ostr;
bodyptr btab = NULL, bp;
int nbody;
real tnow;
vector cmpos, cmvel, cmacc;
initparam(argv, defv);
exprs[0] = getparam("weight");
prog = mktemp((string) copxstr("/tmp/sm_XXXXXX", sizeof(char)));
buildmap(prog, names, exprs, types, NULL, Precision, NDIM, TRUE);
xstr = execmap(prog);
if (get_tag_ok(xstr, "History"))
skip_item(xstr);
get_history(xstr);
ostr = stropen(getparam("out"), "w");
put_history(ostr);
coords = getparam("coords");
new_field(&WeightField, RealType, "Weight");
new_field(&WeightField + 1, NULL, NULL);
while (get_snap(xstr, &btab, &nbody, &tnow, itags, TRUE, NULL)) {
if (scanopt(coords, PosTag) && set_member(itags, PosTag)) {
snapcmpos(cmpos, btab, nbody, WeightField.offset);
for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) {
SUBV(Pos(bp), Pos(bp), cmpos);
}
eprintf("[%s: centroid position: %f,%f,%f]\n", getprog(),
cmpos[0], cmpos[1], cmpos[2]);
}
if (scanopt(coords, VelTag) && set_member(itags, VelTag)) {
snapcmvel(cmvel, btab, nbody, WeightField.offset);
for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) {
SUBV(Vel(bp), Vel(bp), cmvel);
}
eprintf("[%s: centroid velocity: %f,%f,%f]\n", getprog(),
cmvel[0], cmvel[1], cmvel[2]);
}
if (scanopt(coords, AccTag) && set_member(itags, AccTag)) {
snapcmacc(cmacc, btab, nbody, WeightField.offset);
for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) {
SUBV(Acc(bp), Acc(bp), cmacc);
}
eprintf("[%s: cen. acceleration: %f,%f,%f]\n", getprog(),
cmacc[0], cmacc[1], cmacc[2]);
}
del_tag(otags, itags, "Weight");
put_snap(ostr, &btab, &nbody, &tnow, otags);
}
strclose(ostr);
if (unlink(prog) != 0)
error("%s: can't unlink %s\n", getprog(), prog);
return (0);
}
void rotate(snapshot *snap, string *tags, string *vecs, char axis,
real thetax, real thetay, real thetaz)
{
matrix rmat;
bodyptr bp;
switch (tolower(axis)) {
case 'x':
xmatrix(rmat, thetax);
break;
case 'y':
ymatrix(rmat, thetay);
break;
case 'z':
zmatrix(rmat, thetaz);
break;
default:
error("%s: unknown axis %c\n", getargv0(), axis);
}
if (set_member(tags, PosTag) && set_member(vecs, PosTag))
for_all_bodies(bp, *snap)
rotatevec(Pos(bp), rmat);
if (set_member(tags, VelTag) && set_member(vecs, VelTag))
for_all_bodies(bp, *snap)
rotatevec(Vel(bp), rmat);
if (set_member(tags, AccTag) && set_member(vecs, AccTag))
for_all_bodies(bp, *snap)
rotatevec(Acc(bp), rmat);
if (set_member(tags, AuxVecTag) && set_member(vecs, AuxVecTag))
for_all_bodies(bp, *snap)
rotatevec(AuxVec(bp), rmat);
}
void readsphr(string name)
{
stream instr;
real tsnap;
string infields[MaxBodyFields];
instr = stropen(name, "r");
get_history(instr);
if (! get_snap(instr, &spheroid, &nspheroid, &tsnap, infields, FALSE))
error("readsphr in %s: no data in input file\n", getargv0());
strclose(instr);
if (! (set_member(infields, MassTag) && set_member(infields, PosTag)))
error("readsphr in %s: required data missing\n", getargv0());
}
mxArray * ZH_set_Vlist(const dd_SetFamilyPtr Inc, const dd_SetFamilyPtr Adj)
{
mxArray *A, *row;
double *r;
dd_bigrange i, j; /* unsigned long int */
dd_bigrange cur;
set_type s, adj;
int count, total;
int num;
if(Inc){
num = (int) Inc->famsize;
A = mxCreateCellMatrix(num,1);
for (i=0;i<Inc->famsize;i++){
set_initialize(&s, Inc->set[i][0]);
set_copy(s, Inc->set[i]);
count=0;
if (set_card(s)>0) {
/*get the first element in the set*/
for (j=1;j<=s[0];j++){
if (set_member(j,s)) break;
}
cur = j;
total = set_card(s);
row = mxCreateDoubleMatrix(1,total,mxREAL);
r = mxGetPr(row);
while (count <= total){
/* write to the output */
set_delelem(s, cur);
r[count++]=(double)cur;
/* find its neighbor in list */
adj = Adj->set[cur-1];
for (j=1; j<=s[0]; j++){
if ((set_member(j,adj)==1 )&&(set_member(j,s)==1)) {
break;
}
}
if (j<=s[0])
cur = j;
else
break;
}
mxSetCell(A, i, row);
}
}
return A;
}
return 0;
}
void implicit_linear(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[])
{
dd_MatrixPtr H;
dd_rowset rows;
dd_ErrorType err;
if (nrhs == 1 && nlhs <= 2 && mxIsStruct(prhs[0])) {
H = FT_get_H_MatrixPtr(prhs[0]);
dd_set_global_constants(); /* First, this must be called. */
rows = dd_ImplicitLinearityRows(H, &err);
if (err == dd_NoError) {
int total, element, i;
double* pr;
total = set_card(rows);
plhs[0] = mxCreateDoubleMatrix(total, 1, mxREAL);
pr = mxGetPr(plhs[0]);
for (i=1, element=0; i<=rows[0]; i++){
if (set_member(i, rows)) {
pr[element++] = (double)i;
}
}
} else {
dd_WriteErrorMessages(stdout,err);
mexErrMsgTxt("CDD returned an error, see above(!) for details");
}
dd_FreeMatrix(H);
set_free(rows);
return;
} else {
mexErrMsgTxt("hull expects a V input struct and produces an H output struct");
}
}
mxArray * FT_set_SetFamilyPtr(const dd_SetFamilyPtr F)
{
mxArray * A, * tmp;
double * r;
int i, j, k;
int num;
if (F) {
num = (int)(F->famsize);
A = mxCreateCellMatrix(num, 1);
for (i=0; i<(int)(F->famsize); i++) {
num = (int)set_card(F->set[i]);
tmp = mxCreateDoubleMatrix(1, num, mxREAL);
r = mxGetPr(tmp);
k = 0;
for (j = 1; j <= *(F->set[i]); j++) {
if (set_member(j,F->set[i]))
r[k++] = j;
}
mxSetCell(A, i, tmp);
}
return A;
}
return 0;
}
/*折扣计算，并打印小票信息
*@parm: member 商品条形码信息
*@parm: c 库存商品集合
*@parm: c1 总计金额
*@parm: c2 节省金额*/
void settle_discount_print(const void *member, void *c, float *c1, float *c2)
{
struct product_detail *product;
struct sales_products *sales;
unsigned int count; //购买的商品数量
float money; //小记金额
float rate; //折扣率
float price; //单价
float save_money; //节省金额
count = money = save_money = 0;
sales = (struct sales_products *)member;
product = (struct product_detail *)set_member((struct set_t *)c, sales);
count = sales->sum;
price = product->unit_price;
money = (count * price) * DISCOUNT_RATE;
save_money = (count * price) - money;
assert(product && sales);
printf("名称:%s,",product->name);
printf("数量:%u",count);
printf("%s,",product->unit);
printf("单价:%.2f(元),",price);
printf("小记:%.2f(元)", money);
printf("节省%.2f(元)\n",save_money);
(*c1) += money; //更新消费总计
(*c2) += save_money; //更新节省总结
}
int main(int argc, string argv[])
{
string *datafields, *bodyfields, times, ifmt, rfmt;
stream istr;
bodyptr btab = NULL;
int nbody;
real tnow;
string intags[MaxBodyFields];
initparam(argv, defv);
istr = stropen(getparam("in"), "r");
get_history(istr);
datafields = burststring(getparam("fields"), ", ");
if (set_member(datafields, TimeTag))
bodyfields = set_diff(datafields, set_cons(TimeTag, NULL));
else
bodyfields = datafields;
layout_body(bodyfields, Precision, NDIM);
times = getparam("times");
ifmt = getparam("ifmt");
rfmt = getparam("rfmt");
print_header(datafields, getparam("hfmt"), getparam("keyhead"),
burststring(getparam("auxhead"), ", "));
while (get_snap_t(istr, &btab, &nbody, &tnow, intags, FALSE, times)) {
if (! set_subset(intags, bodyfields))
error("%s: one or more required fields not found\n", getargv0());
print_data(btab, nbody, tnow, datafields, ifmt, rfmt);
skip_history(istr);
}
return (0);
}
base_manager::base_manager()
{
scoped_istream stream = istream_file(get_prefs_file(), true);
read(prefs, *stream);
if (member().empty()) {
std::stringstream strstr;
std::map<int, int> member;
member.insert(std::make_pair(172, 5));
member.insert(std::make_pair(176, 6));
member.insert(std::make_pair(244, 7));
member.insert(std::make_pair(279, 8));
member.insert(std::make_pair(103, 8));
member.insert(std::make_pair(106, 9));
member.insert(std::make_pair(120, 9));
member.insert(std::make_pair(381, 9));
for (std::map<int ,int>::const_iterator it = member.begin(); it != member.end(); ++ it) {
if (it != member.begin()) {
strstr << ", ";
}
strstr << ((it->second << 16) | it->first);
}
set_member(strstr.str());
}
}
void ddf_DDMain(ddf_ConePtr cone)
{
ddf_rowrange hh, itemp, otemp;
ddf_boolean locallog=ddf_log; /* if ddf_log=ddf_FALSE, no log will be written. */
if (cone->d<=0){
cone->Iteration=cone->m;
cone->FeasibleRayCount=0;
cone->CompStatus=ddf_AllFound;
goto _L99;
}
if (locallog) {
fprintf(stderr,"(Initially added rows ) = ");
set_fwrite(stderr,cone->InitialHalfspaces);
}
while (cone->Iteration <= cone->m) {
ddf_SelectNextHalfspace(cone, cone->WeaklyAddedHalfspaces, &hh);
if (set_member(hh,cone->NonequalitySet)){ /* Skip the row hh */
if (ddf_debug) {
fprintf(stderr,"*The row # %3ld should be inactive and thus skipped.\n", hh);
}
set_addelem(cone->WeaklyAddedHalfspaces, hh);
} else {
if (cone->PreOrderedRun)
ddf_AddNewHalfspace2(cone, hh);
else{
ddf_AddNewHalfspace1(cone, hh);
}
set_addelem(cone->AddedHalfspaces, hh);
set_addelem(cone->WeaklyAddedHalfspaces, hh);
}
if (!cone->PreOrderedRun){
for (itemp=1; cone->OrderVector[itemp]!=hh; itemp++);
otemp=cone->OrderVector[cone->Iteration];
cone->OrderVector[cone->Iteration]=hh;
/* store the dynamic ordering in ordervec */
cone->OrderVector[itemp]=otemp;
/* store the dynamic ordering in ordervec */
}
if (locallog){
fprintf(stderr,"(Iter, Row, #Total, #Curr, #Feas)= %5ld %5ld %9ld %6ld %6ld\n",
cone->Iteration, hh, cone->TotalRayCount, cone->RayCount,
cone->FeasibleRayCount);
}
if (cone->CompStatus==ddf_AllFound||cone->CompStatus==ddf_RegionEmpty) {
set_addelem(cone->AddedHalfspaces, hh);
goto _L99;
}
(cone->Iteration)++;
}
_L99:;
if (cone->d<=0 || cone->newcol[1]==0){ /* fixing the number of output */
cone->parent->n=cone->LinearityDim + cone->FeasibleRayCount -1;
cone->parent->ldim=cone->LinearityDim - 1;
} else {
cone->parent->n=cone->LinearityDim + cone->FeasibleRayCount;
cone->parent->ldim=cone->LinearityDim;
}
void dd_MLWriteSet(set_type S)
{
long j;
MLPutFunction(stdlink,"List",set_card(S));
for (j=1; j <= S[0]; j++) {
if (set_member(j, S)) MLPutLongInteger(stdlink, j);
}
}
bool init()
{
V_ = FromEigen(v);
dd_ErrorType error = dd_NoError;
/*dd_rowset redset,impl_linset;
dd_rowindex newpos;
dd_MatrixCanonicalize(&V_, &impl_linset, &redset, &newpos, &error);
if(error != dd_NoError)
{
std::cout << ("can not reduce matrix") << std::endl;
}
fprintf(stdout, "\nRedundant rows: ");
set_fwrite(stdout, redset);
fprintf(stdout, "\n");
set_free(redset);
set_free(impl_linset);
free(newpos);
error = dd_NoError;*/
H_= dd_DDMatrix2Poly(V_, &error);
if(error != dd_NoError)
{
if(dd_debug)
std::cout << ("numerical instability in cddlib. ill formed polytope") << std::endl;
}
else
{
init_= true;
b_A = dd_CopyInequalities(H_);
// get equalities and add them as complementary inequality constraints
long elem;
std::vector<long> eq_rows;
for(elem=1;elem<=(long)(b_A->linset[0]);++elem)
{
if (set_member(elem,b_A->linset))
eq_rows.push_back(elem);
}
int rowsize = (int)b_A->rowsize;
A = matrix_t (rowsize + eq_rows.size(), (int)b_A->colsize-1);
b = vector_t (rowsize + eq_rows.size());
for(int i=0; i < rowsize; ++i)
{
b(i) = (value_type)(*(b_A->matrix[i][0]));
for(int j=1; j < b_A->colsize; ++j)
{
A(i, j-1) = -(value_type)(*(b_A->matrix[i][j]));
}
}
int i = 0;
for(std::vector<long int>::const_iterator cit = eq_rows.begin();
cit != eq_rows.end(); ++cit, ++i)
{
b(rowsize + i) = -b((int)(*cit));
A(rowsize + i) = -A((int)(*cit));
}
}
return init_;
}
static void
hippo_block_group_member_dispose(GObject *object)
{
HippoBlockGroupMember *block_group_member = HIPPO_BLOCK_GROUP_MEMBER(object);
set_group(block_group_member, NULL);
set_member(block_group_member, NULL);
G_OBJECT_CLASS(hippo_block_group_member_parent_class)->dispose(object);
}
x3ds_instance::x3ds_instance(player* player, x3ds_definition* def, character* parent, int id) :
character(player, parent, id),
m_def(def),
m_current_frame(0.0f),
m_play_state(PLAY)
{
assert(m_def != NULL);
// take the first camera
m_camera = m_def->m_file->cameras;
set_member("mapMaterial", as_map_material);
set_member("play", as_3d_play);
set_member("stop", as_3d_stop);
// set_member("gotoAndStop", &as_3d_goto_and_stop);
// set_member("gotoAndPlay", &as_3d_goto_and_play);
// set_member("nextFrame", &as_3d_next_frame);
// set_member("prevFrame", &as_3d_prev_frame);
}
struct pkguinf *pkguinf_restore(tn_alloc *na, tn_buf_it *it, const char *lang)
{
struct pkguinf *pkgu;
char *key = NULL, *val;
size_t len = 0;
pkgu = pkguinf_new(na);
if (lang && strcmp(lang, "C") == 0) {
while ((key = n_buf_it_getz(it, &len))) {
if (len > 1)
return NULL;
if (*key == PKGUINF_TAG_ENDCMN)
break;
val = n_buf_it_getz(it, &len);
switch (*key) {
case PKGUINF_LICENSE:
set_member(pkgu, &pkgu->license, val, len);
break;
case PKGUINF_URL:
set_member(pkgu, &pkgu->url, val, len);
break;
case PKGUINF_VENDOR:
set_member(pkgu, &pkgu->vendor, val, len);
break;
case PKGUINF_BUILDHOST:
set_member(pkgu, &pkgu->buildhost, val, len);
break;
case PKGUINF_DISTRO:
set_member(pkgu, &pkgu->distro, val, len);
break;
case PKGUINF_LEGACY_SOURCERPM:
set_member(pkgu, &pkgu->legacy_sourcerpm, val, len);
break;
case PKGUINF_CHANGELOG:
set_member(pkgu, &pkgu->changelog, val, len);
break;
default:
/* skip unknown tag */
;
}
}
}
n_assert(lang);
pkguinf_restore_i18n(pkgu, it, lang);
return pkgu;
}
/* Returns first item in s. s must be non-empty. */
static long set_first(const set_type s)
{
long elem;
for (elem = 1; elem <= s[0]; elem++) {
if (set_member(elem, s)) {
return elem;
}
}
assert(0); /* empty set */
}
void inputdata(void)
{
stream instr;
string intags[MaxBodyFields];
bodyptr p;
bodytab = NULL; // request new input data
instr = stropen(infile, "r"); // open input stream
get_history(instr); // read file history data
if (! get_snap(instr, &bodytab, &nbody, &tnow, intags, FALSE))
error("%s.inputdata: no data in input file\n", getprog());
strclose(instr); // close input stream
if (! set_member(intags, MassTag) || ! set_member(intags, PosTag) ||
! set_member(intags, VelTag))
error("%s.inputdata: essential data missing\n", getprog());
if (scanopt(options, "reset-time")) // reset starting time?
tnow = 0.0;
for (p = bodytab; p < bodytab+nbody; p++) // loop over new bodies
Type(p) = BODY; // initializing body type
}
void set_write(set_type set)
{
long elem;
for (elem=1;elem<=set[0];elem++)
{
if (set_member(elem,set))
printf("%ld ",elem);
}
printf("\n");
}
void set_fwrite_compl(FILE *f,set_type set)
{
long elem;
for (elem=1;elem<=set[0];elem++)
{
if (!set_member(elem,set))
fprintf(f,"%ld ",elem);
}
fprintf(f,"\n");
}
int main(int argc, string argv[])
{
stream istr, ostr;
string times, *produce, itags[MaxBodyFields], atags[MaxBodyFields];
bodyptr btab = NULL;
int nbody, ntag, i;
real tsnap;
bool expand;
initparam(argv, defv);
istr = stropen(getparam("in"), "r");
get_history(istr);
times = getparam("times");
expand = streq(getparam("produce"), "*");
if (! expand) {
produce = burststring(getparam("produce"), ", ");
layout_body(produce, Precision, NDIM);
}
atags[ntag = 0] = NULL;
while (get_snap_t(istr, &btab, &nbody, &tsnap, itags, expand, times)) {
for (i = 0; itags[i] != NULL; i++)
if (! set_member(atags, itags[i])) {
atags[ntag++] = itags[i];
atags[ntag] = NULL;
}
get_history(istr);
}
if (! expand) {
for (i = 0; produce[i] != 0; i++)
if (! set_member(atags, produce[i]))
error("%s: field %s missing\n", getargv0(), produce[i]);
} else
produce = atags;
ostr = stropen(getparam("out"), "w");
put_history(ostr);
put_snap(ostr, &btab, &nbody, &tsnap, produce);
strclose(ostr);
return (0);
}
void dd_MLWriteSetFamily(dd_SetFamilyPtr F)
{
long i,j;
if (F!=NULL){
MLPutFunction(stdlink,"List",F->famsize);
for (i=0; i < F->famsize; i++) {
MLPutFunction(stdlink,"List",set_card(F->set[i]));
for (j=1; j <= F->setsize; j++) {
if (set_member(j, F->set[i])) MLPutLongInteger(stdlink, j);
}
}
}
}
bool as_sharedobject::get_member(const tu_stringi& name, as_value* val)
{
if( as_object::get_member( name, val ) )
{
return true;
}
as_object * object = new as_object( get_player() );
set_member( name, object );
val->set_as_object( object );
return true;
}
bool getdata(void)
{
static bool firstcall = TRUE;
string intags[MaxBodyFields];
bodyptr bp;
get_history(instr);
if (! get_snap(instr, &btab, &nbody, &tnow, intags, FALSE,
getparam("times")))
return (FALSE);
if (firstcall && ! set_member(intags, bodytags[0]))
error("%s: required %s data missing\n", getargv0(), bodytags[0]);
if (firstcall && ! set_member(intags, bodytags[1]))
if (streq(bodytags[1], KeyTag)) {
eprintf("[%s: using default point color]\n", getargv0());
for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp))
Key(bp) = pcolor;
} else
error("%s: required %s data missing\n", getargv0(), bodytags[1]);
if (firstcall && bodytags[2] != NULL && ! set_member(intags, bodytags[2]))
error("%s: required %s data missing\n", getargv0(), bodytags[2]);
firstcall = FALSE;
return (TRUE);
}
mxArray * FT_set_H_MatrixPtr(const dd_MatrixPtr M)
{
mxArray * P;
mxArray * tmpa;
mxArray * tmpb;
mxArray * tmpl;
int i, j;
double * a;
double * b;
double * l;
int k=0;
dd_rowrange ii;
if ((M !=NULL) &&
(M->representation == dd_Inequality)) {
const char *f[] = {"A", "B", "lin"};
int dims[] = {1};
P = mxCreateStructArray(1, dims, 3, f);
if (set_card(M->linset)) {
tmpl = mxCreateDoubleMatrix(1, set_card(M->linset), mxREAL);
l = mxGetPr(tmpl);
for (ii=1; ii<=M->rowsize; ii++) {
if (set_member(ii, M->linset)) {
l[k] = (int)ii;
k ++;
}
}
mxSetField(P, 0, "lin", tmpl);
}
tmpb = mxCreateDoubleMatrix(M->rowsize, 1, mxREAL);
b = mxGetPr(tmpb);
tmpa = mxCreateDoubleMatrix(M->rowsize, M->colsize - 1, mxREAL);
a = mxGetPr(tmpa);
for (i = 0 ; i < (int)(M->rowsize); i++) {
b[i] = dd_get_d(M->matrix[i][0]);
for (j = 0; j < (int)(M->colsize) - 1; j++) {
a[i + j * (int)(M->rowsize)] = - dd_get_d(M->matrix[i][j + 1]);
}
}
mxSetField(P, 0, "A", tmpa);
mxSetField(P, 0, "B", tmpb);
return P;
}
return 0;
}
static ZMatrix getConstraints(dd_MatrixPtr A, bool returnEquations)
{
int rowsize=A->rowsize;
int n=A->colsize-1;
ZMatrix ret(0,n);
for(int i=0;i<rowsize;i++)
{
bool isEquation=set_member(i+1,A->linset);
if(isEquation==returnEquations)
{
QVector v(n);
for(int j=0;j<n;j++)v[j]=Rational(A->matrix[i][j+1]);
ret.appendRow(QToZVectorPrimitive(v));
}
}
return ret;
}
