void QrRegSuf::refresh_qr(const std::vector<Ptr<RegressionData> > &raw_data) const {
if(current) return;
int n = raw_data.size(); // number of observations
if(n==0){
current=false;
return;}
Ptr<RegressionData> rdp = DAT(raw_data[0]);
uint dim_beta = rdp->xdim();
Matrix X(n, dim_beta);
Vector y(n);
sumsqy=0.0;
for(int i = 0; i<n; ++i){
rdp = DAT(raw_data[i]);
y[i] = rdp->y();
const Vector & x(rdp->x());
X.set_row(i,x);
// X(i,0)=1.0; // this stuff is no longer needed b/c the intercept is explicit
// int k=0;
// for(int j=x.lo(); j<=x.hi(); ++j) X(i,++k) = x[j];
sumsqy += y[i]*y[i];
}
qr.decompose(X);
X = qr.getQ();
Qty = y*X;
current=true;
x_column_sums_ = ColSums(X);
}
void on_surface_changed(int width, int height)
{
Message* m = MESSAGE(Message::MSG_RESIZE);
m->AddData(DAT(width));
m->AddData(DAT(height));
gCore->SendMessage(m);
}
static int
pcf8583_attach(struct i2c_adapter *adap, int addr, unsigned short flags,
int kind)
{
struct i2c_client *c;
unsigned char buf[1], ad[1] = { 0 };
struct i2c_msg msgs[2] = {
{ addr, 0, 1, ad },
{ addr, I2C_M_RD, 1, buf }
};
c = kmalloc(sizeof(*c), GFP_KERNEL);
if (!c)
return -ENOMEM;
strcpy(c->dev.name, "PCF8583");
c->id = pcf8583_driver.id;
c->flags = 0;
c->addr = addr;
c->adapter = adap;
c->driver = &pcf8583_driver;
c->dev.driver_data = NULL;
if (i2c_transfer(c->adapter, msgs, 2) == 2)
DAT(c) = buf[0];
return i2c_attach_client(c);
}
double MVTR::pdf(dPtr dp, bool logscale)const{
Ptr<DataType> d = DAT(dp);
const Vec &y(d->y());
const Vec &X(d->x());
double ans = dmvt(y, X*Beta(), Siginv(), nu(), ldsi(), true);
return logscale ? ans : exp(ans);
}
static int
ds1307_get_ctrl(struct i2c_client *client, unsigned char *ctrl)
{
*ctrl = DAT(client);
return 0;
}
double MM::pdf(Ptr<Data> dp, bool logscale)const{
check_logp();
uint i = DAT(dp)->value();
if(i >=size()){
string msg = "too large a value passed to MultinomialModel::pdf";
throw_exception<std::runtime_error>(msg);
}
return logscale ? logp_[i] : pi(i);
}
void update(const Ptr<Data> &dp) override {
Ptr<DataPointType> d = DAT_1(dp);
if (!!d) {
Update(*d);
return;
}
Ptr<DataSeriesType> ds = DAT(dp);
if (!!ds) {
update_series(*ds);
return;
}
report_error(
"TimeSeriesSfustatDetails::update failed due to "
"unknown type");
}
static int
ds1307_set_ctrl(struct i2c_client *client, unsigned char *cinfo)
{
unsigned char buf[2];
int ret;
buf[0] = 7; /* control register address on DS1307 */
buf[1] = *cinfo;
/* save the control reg info in the client data field so that get_ctrl
* function doesn't have to do an I2C transfer to get it.
*/
DAT(client) = buf[1];
ret = i2c_master_send(client, (char *)buf, 2);
return ret;
}
static int
ds1307_attach(struct i2c_adapter *adap, int addr, unsigned short flags,int kind)
{
struct i2c_client *c;
unsigned char buf[1], ad[1] = { 7 };
struct i2c_msg msgs[2] = {
{ addr , 0, 1, ad },
{ addr , I2C_M_RD, 1, buf }
};
int ret;
c = (struct i2c_client *)kmalloc(sizeof(*c), GFP_KERNEL);
if (!c)
return -ENOMEM;
strcpy(c->name, "DS1307");
c->id = ds1307_driver.id;
c->flags = 0;
c->addr = addr;
c->adapter = adap;
c->driver = &ds1307_driver;
c->data = NULL;
ret = i2c_transfer(c->adapter, msgs, 2);
if ( ret == 2 )
{
DAT(c) = buf[0];
}
else
printk ("ds1307_attach(): i2c_transfer() returned %d.\n",ret);
ds1307_i2c_client = c;
ds1307_enable_clock( 1);
return i2c_attach_client(c);
}
static int
pcf8583_attach(struct i2c_adapter *adap, int addr, int kind)
{
struct i2c_client *c;
unsigned char buf[1], ad[1] = { 0 };
struct i2c_msg msgs[2] = {
{ addr, 0, 1, ad },
{ addr, I2C_M_RD, 1, buf }
};
c = kmalloc(sizeof(*c), GFP_KERNEL);
if (!c)
return -ENOMEM;
memset(c, 0, sizeof(*c));
c->addr = addr;
c->adapter = adap;
c->driver = &pcf8583_driver;
if (i2c_transfer(c->adapter, msgs, 2) == 2)
DAT(c) = buf[0];
return i2c_attach_client(c);
}
double BLM::pdf(dPtr dp, bool logscale) const{
return pdf(DAT(dp), logscale);}
double MLB::pdf(const Data * dp, bool logscale)const{
double ans = logp(*DAT(dp));
return logscale ? ans : exp(ans);
}
double ZIGM::pdf(const Ptr<Data> &dp, bool logscale) const {
double ans = logp(DAT(dp)->value());
return logscale ? ans : exp(ans);
}
void ZIGM::add_data(const Ptr<Data> &dp) {
if (dp->missing()) return;
Ptr<DoubleData> d = DAT(dp);
double y = d->value();
add_data_raw(y);
}
double IndependentMvnModel::pdf(const Data* dp, bool logscale)const{
double ans = Logp(DAT(dp)->value(), g_, h_, 0);
return logscale ? ans : exp(ans);
}
void GaussianBartModel::add_data(Ptr<Data> dp) {
add_data(DAT(dp));
}
void ASSR::add_data(Ptr<Data> dp) {
add_data(DAT(dp));
}
void MVT::add_data(const Ptr<Data> &dp) {
Ptr<VectorData> d = DAT(dp);
add_data(d);
}
void ZIGM::add_mixture_data(Ptr<Data> dp, double prob){
if(dp->missing()) return;
double y = DAT(dp)->value();
add_mixture_data_raw(y, prob);
}
double WeightedMvnModel::pdf(Ptr<Data> dp, bool logscale)const{
return pdf(DAT(dp), logscale); }
void PoissonModel::add_mixture_data(Ptr<Data> dp, double prob){
double y = DAT(dp)->value();
suf()->add_mixture_data(y, prob);
}
double PoissonModel::pdf(const Data * dp, bool logscale) const{
return dpois(DAT(dp)->value(), lam(), logscale); }
double LRM::pdf(dPtr dp, bool logscale) const{
Ptr<BRD> d = DAT(dp);
double ans= logp(d->y(), d->x());
return logscale ? ans : exp(ans);
}
double MGXS::pdf(Ptr<Data> dp, bool logscale)const{
Ptr<GlmCoefs> d(DAT(dp));
double ans = logp(d->Beta());
return logscale ? ans : exp(ans);
}
double LRM::pdf(const Data * dp, bool logscale) const{
const BRD * d = DAT(dp);
double ans= logp(d->y(), d->x());
return logscale ? ans : exp(ans);
}
void DirichletModel::add_mixture_data(const Ptr<Data> &dp, double prob) {
suf()->add_mixture_data(DAT(dp)->value(), prob);
}
double ExponentialModel::pdf(const Data *dp, bool logscale) const {
double ans = logp(DAT(dp)->value());
return logscale ? ans : exp(ans);
}
//----------------------------------------------------------------------
void PoissonBartModel::add_data(Ptr<Data> dp) {
add_data(DAT(dp));
}
void ExponentialModel::add_mixture_data(const Ptr<Data> &dp, double prob) {
double y = DAT(dp)->value();
suf()->add_mixture_data(y, prob);
}
double DM::pdf(const Data *dp, bool logscale) const {
return pdf(DAT(dp)->value(), logscale);
}
