static void
combiner_intr(void *arg)
{
struct combiner_softc *sc;
void (*ih) (void *);
void *ih_user;
int enabled;
int intrs;
int shift;
int cirq;
int grp;
int i,n;
sc = arg;
intrs = READ4(sc, CIPSR);
for (grp = 0; grp < 32; grp++) {
if (intrs & (1 << grp)) {
n = (grp / 4);
shift = (grp % 4) * 8;
cirq = READ4(sc, ISTR(n));
for (i = 0; i < 8; i++) {
if (cirq & (1 << (i + shift))) {
ih = intr_map[grp][i].ih;
ih_user = intr_map[grp][i].ih_user;
enabled = intr_map[grp][i].enabled;
if (enabled && (ih != NULL)) {
ih(ih_user);
}
}
}
}
}
}
void ApproximateValueManager::Initialize( ros::NodeHandle& ph )
{
ros::NodeHandle ih( ph.resolveName( "input_streams" ) );
BroadcastMultiReceiver::Ptr rx = std::make_shared<BroadcastMultiReceiver>();
rx->Initialize( ih );
Initialize( rx, ph );
}
int main(int argc, char* argv[])
{
if (argc != 3)
{
std::cout << "not enough arguments" << std::endl;
return 1;
}
Connection con;
con.openPort(atoi(argv[1]));
std::vector<unsigned char> ATCommand;
std::vector<unsigned char> empty;
int connectionDescriptor = con.getConnectionDescriptor();
bool b = true;
InputHandler ih(connectionDescriptor, &b);
ATCommand.push_back(argv[2][0]);
ATCommand.push_back(argv[2][1]);
con.sendPacket( APIFrames::ATCommand(ATCommand, empty));
char input;
while(true)
{
input = ih.readByte(connectionDescriptor);
//if(input != 0X0) printf("%X", input);
}
std::cout << "end" << std::endl;
con.closeConnection();
return 0;
}
bool Esbot::
Initialize(npm::RobotServer &server)
{
if ( !npm::RobotClient::Initialize(server))
return false;
m_cheat = server.CreateCheatSheet();
shared_ptr<Hull> hull(CreateHull());
for(HullIterator ih(*hull); ih.IsValid(); ih.Increment())
server.AddLine(Line(ih.GetX0(), ih.GetY0(), ih.GetX1(), ih.GetY1()));
const_cast<double &>(m_radius) = hull->CalculateRadius();
robox_parameters params; // make configurable... should we just subclass npm::Robox?
m_front = server.DefineLidar(Frame(params.front_mount_x,
params.front_mount_y,
params.front_mount_theta),
params.front_nscans,
params.front_rhomax,
params.front_phi0,
params.front_phirange,
params.front_channel)->GetScanner();
m_rear = server.DefineLidar(Frame(params.rear_mount_x,
params.rear_mount_y,
params.rear_mount_theta),
params.rear_nscans,
params.rear_rhomax,
params.rear_phi0,
params.rear_phirange,
params.rear_channel)->GetScanner();
m_drive = server.DefineDiffDrive(params.model_wheelbase, params.model_wheelradius);
const RobotModel::Parameters modelParms(CreateRobotParameters(params));
m_robotModel.reset(new RobotModel(modelParms, hull));
m_motionController.reset(new MotionController(m_robotModel, m_hal));
m_odometry.reset(new Odometry(m_hal));
m_multiscanner.reset(new Multiscanner(m_hal));
m_dynamicWindow.reset(new LegacyDynamicWindow(params.dwa_dimension,
params.dwa_grid_width,
params.dwa_grid_height,
params.dwa_grid_resolution,
m_robotModel,
params.dwa_alpha_distance,
params.dwa_alpha_heading,
params.dwa_alpha_speed,
true));
m_multiscanner->Add(m_front);
m_multiscanner->Add(m_rear);
CreateGfxStuff(server, name);
return true;
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Network n;
QThread inputHandleThread;
InputHandle ih(&n);
ih.moveToThread(&inputHandleThread);
QObject::connect(&inputHandleThread, SIGNAL(started()), &ih, SLOT(start()));
inputHandleThread.start();
int ret = a.exec();
inputHandleThread.quit();
inputHandleThread.wait();
return ret;
}
static void
ext_intr(void *arg)
{
struct pad_softc *sc;
void (*ih) (void *);
void *ih_user;
int ngpio;
int found;
int reg;
int i,j;
int n,k;
sc = arg;
n = 0;
for (i = 0; sc->gpio_map[i].ngpio != -1; i++) {
found = 0;
ngpio = sc->gpio_map[i].ngpio;
if (sc->gpio_map[i].pend == 0) {
n += ngpio;
continue;
}
reg = READ4(sc, sc->gpio_map[i].port, sc->gpio_map[i].pend);
for (j = 0; j < ngpio; j++) {
if (reg & (1 << j)) {
found = 1;
k = (n + j);
if (intr_map[k].enabled == 1) {
ih = intr_map[k].ih;
ih_user = intr_map[k].ih_user;
ih(ih_user);
}
}
}
if (found) {
/* ACK */
WRITE4(sc, sc->gpio_map[i].port, sc->gpio_map[i].pend, reg);
}
n += ngpio;
}
}
void addPerformance(const Int_t it)
{
if(!narr[it]){
narr[it] = (TObjArray*)arr->Clone(); narr[it]->SetOwner();
gDirectory->ls();
return;
}
TObject *oo(NULL);
TH1 *h1(NULL), *H1(NULL);
THnSparse *h(NULL), *H(NULL);
Int_t nplots(plots[it]->GetEntries());
TString sname;
for(Int_t ih(0); ih<nplots; ih++){
sname= ((TObjString*)(*plots[it])[ih])->String();
if(!mc && sname.EndsWith("MC")) continue;
if(!(oo = (TObject*)arr->FindObject(sname.Data()))) {
Warning("addPerformance", "Missing %s from \"%s\"", sname.Data(), file->GetName());
continue;
}
if(strstr(oo->IsA()->GetName(), "THnSparse")){
h = dynamic_cast<THnSparse*>(oo);
if(!(H = (THnSparse*)narr[it]->FindObject(sname.Data()))) {
Error("addPerformance", "Missing %s from Merging.", sname.Data());
return;
}
H->Add(h);
if(kWrite) printf(" -> %s[%d]\n", sname.Data(), (Int_t)H->GetEntries());
} else if(strstr(oo->IsA()->GetName(), "TH")){
h1 = dynamic_cast<TH1*>(oo);
if(!(H1 = (TH1*)narr[it]->FindObject(sname.Data()))) {
Error("addPerformance", "Missing %s. from Merging.", sname.Data());
return;
}
H1->Add(h1);
if(kWrite) printf(" -> %s[%d]\n", sname.Data(), (Int_t)H1->GetEntries());
} else{
Warning("addPerformance", "Object %s. from \"%s\" of unknown class %s", sname.Data(), file->GetName(), oo->IsA()->GetName());
continue;
}
}
if(kWrite){
narr[it]->Write(taskName[it], /*TObject::kOverwrite|*/TObject::kSingleKey);
narr[it]->Delete(); delete narr[it]; narr[it] = NULL;
}
}
void ImpactEmitterAsset::initializeAssetNameTable()
{
/* initialize the exlosion, iofx, and ios asset names to resID tables */
NxParameterized::Handle eventSetHandle(*mParams);
int numSets;
mParams->getParameterHandle("eventSetList", eventSetHandle);
PX_ASSERT(eventSetHandle.isValid());
mParams->getArraySize(eventSetHandle, numSets);
for (int i = 0; i < numSets; i++)
{
NxParameterized::Handle ih(*mParams);
NxParameterized::Interface* eventPtr = 0;
eventSetHandle.getChildHandle(i, ih);
PX_ASSERT(ih.isValid());
mParams->getParamRef(ih, eventPtr);
PX_ASSERT(eventPtr);
ApexSimpleString tmpClassName(eventPtr->className());
if (tmpClassName == "ImpactExplosionEvent")
{
#if NX_SDK_VERSION_MAJOR == 2
ImpactExplosionEvent* paramPtr = (ImpactExplosionEvent*)eventPtr;
mExplosionAssetTracker.addAssetName(paramPtr->parameters().explosionAssetName->name(), false);
#elif NX_SDK_VERSION_MAJOR == 3
APEX_DEBUG_WARNING("Invalid asset. ImpactExplosionEvent is not supported under PhysX 3.");
PX_ALWAYS_ASSERT();
#endif
}
else if (tmpClassName == "ImpactObjectEvent")
{
ImpactObjectEvent* paramPtr = (ImpactObjectEvent*)eventPtr;
mIofxAssetTracker.addAssetName(paramPtr->parameters().iofxAssetName->name(), false);
mIosAssetTracker.addAssetName(paramPtr->parameters().iosAssetName->className(),
paramPtr->parameters().iosAssetName->name());
}
}
}
static Handle getGcInfoBuilder(GCMemoryManager *gcManager,TRAPS) {
Klass* k = Management::sun_management_GarbageCollectorImpl_klass(CHECK_NH);
instanceKlassHandle gcMBeanKlass (THREAD, k);
instanceOop i = gcManager->get_memory_manager_instance(THREAD);
instanceHandle ih(THREAD, i);
JavaValue result(T_OBJECT);
JavaCallArguments args(ih);
JavaCalls::call_virtual(&result,
gcMBeanKlass,
vmSymbols::getGcInfoBuilder_name(),
vmSymbols::getGcInfoBuilder_signature(),
&args,
CHECK_NH);
return Handle(THREAD,(oop)result.get_jobject());
}
vector sq::transform(vector& v)
{ vector v1(4);
v1.el(0) = iw() * (v.el(0) - minx) / dx;
v1.el(1) = ih() * (v.el(1) - miny) / dy;
return(v1);
}
void PZStability::check() {
Timer tfull;
// Estimate runtime
{
// Test value
arma::vec x0(count_params());
x0.zeros();
if(x0.n_elem)
x0(0)=0.1;
if(x0.n_elem>=2)
x0(1)=-0.1;
Timer t;
eval(x0,GHMODE);
double dt=t.get();
// Total time is
double ttot=2*x0.n_elem*(x0.n_elem+1)*dt;
fprintf(stderr,"\nComputing the Hessian will take approximately %s\n",t.parse(ttot).c_str());
fflush(stderr);
}
// Get gradient
Timer t;
arma::vec g(gradient());
printf("Gradient norm is %e (%s)\n",arma::norm(g,2),t.elapsed().c_str()); fflush(stdout);
if(cancheck && oocheck) {
size_t nov=count_ov_params(oa,va);
if(!restr)
nov+=count_ov_params(ob,vb);
double ovnorm=arma::norm(g.subvec(0,nov-1),2);
double oonorm=arma::norm(g.subvec(nov,g.n_elem-1),2);
printf("OV norm %e, OO norm %e.\n",ovnorm,oonorm);
}
t.set();
// Evaluate Hessian
arma::mat h(hessian());
printf("Hessian evaluated (%s)\n",t.elapsed().c_str()); fflush(stdout);
t.set();
// Helpers
arma::mat hvec;
arma::vec hval;
if(cancheck && oocheck) {
// Amount of parameters
size_t nov=count_ov_params(oa,va);
if(!restr)
nov+=count_ov_params(ob,vb);
// Stability of canonical orbitals
arma::mat hcan(h.submat(0,0,nov-1,nov-1));
eig_sym_ordered(hval,hvec,hcan);
printf("\nOV Hessian diagonalized (%s)\n",t.elapsed().c_str()); fflush(stdout);
hval.t().print("Canonical orbital stability");
// Stability of optimal orbitals
arma::mat hopt(h.submat(nov-1,nov-1,h.n_rows-1,h.n_cols-1));
eig_sym_ordered(hval,hvec,hopt);
printf("\nOO Hessian diagonalized (%s)\n",t.elapsed().c_str()); fflush(stdout);
hval.t().print("Optimal orbital stability");
}
if(cplx) {
// Collect real and imaginary parts of Hessian.
arma::uvec rp, ip;
real_imag_idx(rp,ip);
arma::mat rh(rp.n_elem,rp.n_elem);
for(size_t i=0;i<rp.n_elem;i++)
for(size_t j=0;j<rp.n_elem;j++)
rh(i,j)=h(rp(i),rp(j));
arma::mat ih(ip.n_elem,ip.n_elem);
for(size_t i=0;i<ip.n_elem;i++)
for(size_t j=0;j<ip.n_elem;j++)
ih(i,j)=h(ip(i),ip(j));
eig_sym_ordered(hval,hvec,rh);
printf("\nReal part of Hessian diagonalized (%s)\n",t.elapsed().c_str()); fflush(stdout);
hval.t().print("Real orbital stability");
eig_sym_ordered(hval,hvec,ih);
printf("\nImaginary part of Hessian diagonalized (%s)\n",t.elapsed().c_str()); fflush(stdout);
hval.t().print("Imaginary orbital stability");
}
// Total stability
eig_sym_ordered(hval,hvec,h);
printf("\nFull Hessian diagonalized (%s)\n",t.elapsed().c_str()); fflush(stdout);
hval.t().print("Orbital stability");
fprintf(stderr,"Check completed in %s.\n",tfull.elapsed().c_str());
}
void MagnetGeneratorPlugin::generateMagnet()
{
bt::TorrentInterface* tor = getGUI()->getTorrentActivity()->getCurrentTorrent();
if (!tor)
return;
QUrl dn(tor->getStats().torrent_name);
SHA1Hash ih(tor->getInfoHash());
QString uri("magnet:?xt=urn:btih:");
uri.append(ih.toString());
if (MagnetGeneratorPluginSettings::dn())
{
uri.append("&dn=");
uri.append(QUrl::toPercentEncoding(dn.toString(), "{}", NULL));
}
if ((MagnetGeneratorPluginSettings::customtracker() && MagnetGeneratorPluginSettings::tr().length() > 0) && !MagnetGeneratorPluginSettings::torrenttracker())
{
uri.append("&tr=");
QUrl tr(MagnetGeneratorPluginSettings::tr());
uri.append(QUrl::toPercentEncoding(tr.toString(), "{}", NULL));
}
if (MagnetGeneratorPluginSettings::torrenttracker())
{
QList<bt::TrackerInterface*> trackers = tor->getTrackersList()->getTrackers();
if (!trackers.isEmpty())
{
Tracker* trk = (Tracker*)trackers.first();
QUrl tr(trk->trackerURL());
uri.append("&tr=");
uri.append(QUrl::toPercentEncoding(tr.toString(), "{}", NULL));
}
}
addToClipboard(uri);
if (MagnetGeneratorPluginSettings::popup())
showPopup();
}
