Date(int dd,int mm,int yy) {
d=dd;
m=mm;
y=yy;
wd=-1;
standardise();
}
Date(int dd,int mm,int yy,int ww) {
d=dd;
m=mm;
y=yy;
wd=ww;
standardise();
}
Date(String s) {
// Note: this function should update to better code in finddate() later
d=-1;
m=-1;
y=-1;
wd=-1;
List<String> ws=Ssplit(s,Salphanumeric());
// First, look for a month
// Find month
int f=ws.satisfy(&isamonth);
if (f>0) {
// Find adjacent numbers
int side=-1;
List<int> nums;
for (int side=-1;side<=1;side+=2) // Search left side first
for (int d=1;d<=2;d++) { // Search two words each side
int c=f+side*d;
// Collect max 2 numbers
if (c>0 && c<=ws.len && nums.len<2) {
int x;
if (sscanf(ws.num(c),"%i",&x)>0)
nums.add(x);
}
}
m=whichmonth(ws.num(f));
if (nums.len>=1) {
// Assume first number found is the day
int p=nums.num(1);
if (p>=1 && p<=31)
d=p;
else
y=p;
}
if (nums.len>=2) {
int p=nums.num(2);
// If year not yet found (second number depends on first)
if (y==-1)
y=p;
else
if (p>=1 && p<=31)
d=p;
}
}
// Otherwise, look for a pattern ../../..
standardise();
}
DISTRIBUTION_gaussianh::DISTRIBUTION_gaussianh(const double & a,
const datamatrix & b, MCMCoptions * o, const datamatrix & r,
const datamatrix & w)
: DISTRIBUTION(o,r,w)
{
nrcat = response.cols(); //neu
family = "Gaussian with heteroscedastic errors";
standardise();
scale(0,0) = 1;
scaleexisting = false;
constant_iwlsweights=true;
// für den Fall des Mittelwertschätzers wäre dies falsch
// für den Fall des Varianzschätzers ist dies richtig
}
/*
ssmtp() -- send the message (exactly one) from stdin to the mailhub SMTP port
*/
int ssmtp(char *argv[])
{
char b[(BUF_SZ + 2)], *buf = b+1, *p, *q;
#ifdef MD5AUTH
char challenge[(BUF_SZ + 1)];
#endif
struct passwd *pw;
int i, sock;
uid_t uid;
bool_t minus_v_save, leadingdot, linestart = True;
int timeout = 0;
int bufsize = sizeof(b)-1;
b[0] = '.';
outbytes = 0;
ht = &headers;
uid = getuid();
if((pw = getpwuid(uid)) == (struct passwd *)NULL) {
die("Could not find password entry for UID %d", uid);
}
get_arpadate(arpadate);
if(read_config() == False) {
log_event(LOG_INFO, "%s not found", config_file);
}
if((p = strtok(pw->pw_gecos, ";,"))) {
if((gecos = strdup(p)) == (char *)NULL) {
die("ssmtp() -- strdup() failed");
}
}
revaliases(pw);
/* revaliases() may have defined this */
if(uad == (char *)NULL) {
uad = append_domain(pw->pw_name);
}
rt = &rcpt_list;
header_parse(stdin);
#if 1
/* With FromLineOverride=YES set, try to recover sane MAIL FROM address */
uad = append_domain(uad);
#endif
from = from_format(uad, override_from);
/* Now to the delivery of the message */
(void)signal(SIGALRM, (void(*)())handler); /* Catch SIGALRM */
(void)alarm((unsigned) MAXWAIT); /* Set initial timer */
if(setjmp(TimeoutJmpBuf) != 0) {
/* Then the timer has gone off and we bail out */
die("Connection lost in middle of processing");
}
if((sock = smtp_open(mailhost, port)) == -1) {
die("Cannot open %s:%d", mailhost, port);
}
else if (use_starttls == False) /* no initial response after STARTTLS */
{
if(smtp_okay(sock, buf) == False)
die("Invalid response SMTP server");
}
/* If user supplied username and password, then try ELHO */
if(auth_user) {
outbytes += smtp_write(sock, "EHLO %s", hostname);
}
else {
outbytes += smtp_write(sock, "HELO %s", hostname);
}
(void)alarm((unsigned) MEDWAIT);
if(smtp_okay(sock, buf) == False) {
die("%s (%s)", buf, hostname);
}
/* Try to log in if username was supplied */
if(auth_user) {
#ifdef MD5AUTH
if(auth_pass == (char *)NULL) {
auth_pass = strdup("");
}
if(auth_method && strcasecmp(auth_method, "cram-md5") == 0) {
outbytes += smtp_write(sock, "AUTH CRAM-MD5");
(void)alarm((unsigned) MEDWAIT);
if(smtp_read(sock, buf) != 3) {
die("Server rejected AUTH CRAM-MD5 (%s)", buf);
}
strncpy(challenge, strchr(buf,' ') + 1, sizeof(challenge));
memset(buf, 0, bufsize);
crammd5(challenge, auth_user, auth_pass, buf);
}
else {
#endif
memset(buf, 0, bufsize);
to64frombits(buf, auth_user, strlen(auth_user));
if (use_oldauth) {
outbytes += smtp_write(sock, "AUTH LOGIN %s", buf);
}
else {
outbytes += smtp_write(sock, "AUTH LOGIN");
(void)alarm((unsigned) MEDWAIT);
if(smtp_read(sock, buf) != 3) {
die("Server didn't like our AUTH LOGIN (%s)", buf);
}
/* we assume server asked us for Username */
memset(buf, 0, bufsize);
to64frombits(buf, auth_user, strlen(auth_user));
outbytes += smtp_write(sock, buf);
}
(void)alarm((unsigned) MEDWAIT);
if(smtp_read(sock, buf) != 3) {
die("Server didn't accept AUTH LOGIN (%s)", buf);
}
memset(buf, 0, bufsize);
to64frombits(buf, auth_pass, strlen(auth_pass));
#ifdef MD5AUTH
}
#endif
/* We do NOT want the password output to STDERR
* even base64 encoded.*/
minus_v_save = minus_v;
minus_v = False;
outbytes += smtp_write(sock, "%s", buf);
minus_v = minus_v_save;
(void)alarm((unsigned) MEDWAIT);
if(smtp_okay(sock, buf) == False) {
die("Authorization failed (%s)", buf);
}
}
/* Send "MAIL FROM:" line */
outbytes += smtp_write(sock, "MAIL FROM:<%s>", uad);
(void)alarm((unsigned) MEDWAIT);
if(smtp_okay(sock, buf) == 0) {
die("%s", buf);
}
/* Send all the To: adresses */
/* Either we're using the -t option, or we're using the arguments */
if(minus_t) {
if(rcpt_list.next == (rcpt_t *)NULL) {
die("No recipients specified although -t option used");
}
rt = &rcpt_list;
while(rt->next) {
p = rcpt_remap(rt->string);
outbytes += smtp_write(sock, "RCPT TO:<%s>", p);
(void)alarm((unsigned)MEDWAIT);
if(smtp_okay(sock, buf) == 0) {
die("RCPT TO:<%s> (%s)", p, buf);
}
rt = rt->next;
}
}
else {
for(i = 1; (argv[i] != NULL); i++) {
p = strtok(argv[i], ",");
while(p) {
/* RFC822 Address -> "foo@bar" */
q = rcpt_remap(addr_parse(p));
outbytes += smtp_write(sock, "RCPT TO:<%s>", q);
(void)alarm((unsigned) MEDWAIT);
if(smtp_okay(sock, buf) == 0) {
die("RCPT TO:<%s> (%s)", q, buf);
}
p = strtok(NULL, ",");
}
}
}
/* Send DATA */
outbytes += smtp_write(sock, "DATA");
(void)alarm((unsigned) MEDWAIT);
if(smtp_read(sock, buf) != 3) {
/* Oops, we were expecting "354 send your data" */
die("%s", buf);
}
outbytes += smtp_write(sock,
"Received: by %s (sSMTP sendmail emulation); %s", hostname, arpadate);
if(have_from == False) {
outbytes += smtp_write(sock, "From: %s", from);
}
if(have_date == False) {
outbytes += smtp_write(sock, "Date: %s", arpadate);
}
#ifdef HASTO_OPTION
if(have_to == False) {
outbytes += smtp_write(sock, "To: postmaster");
}
#endif
ht = &headers;
while(ht->next) {
outbytes += smtp_write(sock, "%s", ht->string);
ht = ht->next;
}
(void)alarm((unsigned) MEDWAIT);
/* End of headers, start body */
outbytes += smtp_write(sock, "");
/*prevent blocking on pipes, we really shouldnt be using
stdio functions like fgets in the first place */
fcntl(STDIN_FILENO,F_SETFL,O_NONBLOCK);
while(!feof(stdin)) {
if (!fgets(buf, bufsize, stdin)) {
/* if nothing was received, then no transmission
* over smtp should be done */
sleep(1);
/* don't hang forever when reading from stdin */
if (++timeout >= MEDWAIT) {
log_event(LOG_ERR, "killed: timeout on stdin while reading body -- message saved to dead.letter.");
die("Timeout on stdin while reading body");
}
continue;
}
/* Trim off \n, double leading .'s */
leadingdot = standardise(buf, &linestart);
if (linestart || feof(stdin)) {
linestart = True;
outbytes += smtp_write(sock, "%s", leadingdot ? b : buf);
} else {
if (log_level > 0) {
log_event(LOG_INFO, "Sent a very long line in chunks");
}
if (leadingdot) {
outbytes += fd_puts(sock, b, sizeof(b));
} else {
outbytes += fd_puts(sock, buf, bufsize);
}
}
(void)alarm((unsigned) MEDWAIT);
}
if(!linestart) {
smtp_write(sock, "");
}
/* End of body */
outbytes += smtp_write(sock, ".");
(void)alarm((unsigned) MAXWAIT);
if(smtp_okay(sock, buf) == 0) {
die("%s", buf);
}
/* Close connection */
(void)signal(SIGALRM, SIG_IGN);
outbytes += smtp_write(sock, "QUIT");
(void)smtp_okay(sock, buf);
(void)close(sock);
log_event(LOG_INFO, "Sent mail for %s (%s) uid=%d username=%s outbytes=%d",
from_strip(uad), buf, uid, pw->pw_name, outbytes);
return(0);
}
void LinearModel::fitLM()
{
if (par::verbose)
{
for (int i=0; i<nind; i++)
{
cout << "VO " << i << "\t"
<< Y[i] << "\t";
for (int j=0; j<np; j++)
cout << X[i][j] << "\t";
cout << "\n";
}
}
// cout << "LM VIEW\n";
// display(Y);
// display(X);
// cout << "---\n";
coef.resize(np);
sizeMatrix(S,np,np);
if ( np==0 || nind==0 || ! all_valid )
{
return;
}
setVariance();
if ( par::standard_beta )
standardise();
sig.resize(nind, sqrt(1.0/sqrt((double)nind)) );
w.resize(np);
sizeMatrix(u,nind,np);
sizeMatrix(v,np,np);
// Perform "svdfit(C,Y,sig,b,u,v,w,chisq,function)"
int i,j;
const double TOL=1.0e-13;
double wmax,tmp,thresh,sum;
vector_t b(nind),afunc(np);
for (i=0;i<nind;i++) {
afunc = X[i];
tmp=1.0/sig[i];
for (j=0;j<np;j++)
u[i][j]=afunc[j]*tmp;
b[i]=Y[i]*tmp;
}
bool flag = svdcmp(u,w,v);
if ( ! flag )
{
all_valid = false;
return;
}
wmax=0.0;
for (j=0;j<np;j++)
if (w[j] > wmax) wmax=w[j];
thresh=TOL*wmax;
for (j=0;j<np;j++)
if (w[j] < thresh) w[j]=0.0;
svbksb(u,w,v,b,coef);
chisq=0.0;
for (i=0;i<nind;i++) {
afunc=X[i];
sum=0.0;
for (j=0;j<np;j++) sum += coef[j]*afunc[j];
chisq += (tmp=(Y[i]-sum)/sig[i],tmp*tmp);
}
/////////////////////////////////////////
// Obtain covariance matrix of estimates
// Robust cluster variance estimator
// V_cluster = (X'X)^-1 * \sum_{j=1}^{n_C} u_{j}' * u_j * (X'X)^-1
// where u_j = \sum_j cluster e_i * x_i
// Above, e_i is the residual for the ith observation and x_i is a
// row vector of predictors including the constant.
// For simplicity, I omitted the multipliers (which are close to 1)
// from the formulas for Vrob and Vclusters.
// The formula for the clustered estimator is simply that of the
// robust (unclustered) estimator with the individual ei*s replaced
// by their sums over each cluster.
// http://www.stata.com/support/faqs/stat/cluster.html
// SEE http://aje.oxfordjournals.org/cgi/content/full/kwm223v1#APP1
// Williams, R. L. 2000. A note on robust variance estimation for
// cluster-correlated data. Biometrics 56: 64
// t ( y - yhat X ) %*% ( y - yhat) / nind - np
// = variance of residuals
// j <- ( t( y- m %*% t(b) ) %*% ( y - m %*% t(b) ) ) / ( N - p )
// print( sqrt(kronecker( solve( t(m) %*% m ) , j ) ))
////////////////////////////////////////////////
// OLS variance estimator = s^2 * ( X'X )^-1
// where s^2 = (1/(N-k)) \sum_i=1^N e_i^2
// 1. Calcuate S = (X'X)^-1
matrix_t Xt;
sizeMatrix(Xt, np, nind);
for (int i=0; i<nind; i++)
for (int j=0; j<np; j++)
Xt[j][i] = X[i][j];
matrix_t S0;
multMatrix(Xt,X,S0);
flag = true;
S0 = svd_inverse(S0,flag);
if ( ! flag )
{
all_valid = false;
return;
}
if (par::verbose)
{
cout << "beta...\n";
display(coef);
cout << "Sigma(S0b)\n";
display(S0);
cout << "\n";
}
////////////////////////
// Calculate s^2 (sigma)
if (!cluster)
{
double sigma= 0.0;
for (int i=0; i<nind; i++)
{
double partial = 0.0;
for (int j=0; j<np; j++)
partial += coef[j] * X[i][j];
partial -= Y[i];
sigma += partial * partial;
}
sigma /= nind-np;
for (int i=0; i<np; i++)
for (int j=0; j<np; j++)
S[i][j] = S0[i][j] * sigma;
}
///////////////////////////
// Robust-cluster variance
if (cluster)
{
vector<vector_t> sc(nc);
for (int i=0; i<nc; i++)
sc[i].resize(np,0);
for (int i=0; i<nind; i++)
{
double partial = 0.0;
for (int j=0; j<np; j++)
partial += coef[j] * X[i][j];
partial -= Y[i];
for (int j=0; j<np; j++)
sc[clst[i]][j] += partial * X[i][j];
}
matrix_t meat;
sizeMatrix(meat, np, np);
for (int k=0; k<nc; k++)
{
for (int i=0; i<np; i++)
for (int j=0; j<np; j++)
meat[i][j] += sc[k][i] * sc[k][j];
}
matrix_t tmp1;
multMatrix( S0 , meat, tmp1);
multMatrix( tmp1 , S0, S);
}
if (par::verbose)
{
cout << "coefficients:\n";
display(coef);
cout << "var-cov matrix:\n";
display(S);
cout << "\n";
}
}
