void NR::svdfit(Vec_I_DP &x, Vec_I_DP &y, Vec_I_DP &sig, Vec_O_DP &a,
Mat_O_DP &u, Mat_O_DP &v, Vec_O_DP &w, DP &chisq,
void funcs(const DP, Vec_O_DP &))
{
int i,j;
const DP TOL=1.0e-13;
DP wmax,tmp,thresh,sum;
int ndata=x.size();
int ma=a.size();
Vec_DP b(ndata),afunc(ma);
for (i=0;i<ndata;i++) {
funcs(x[i],afunc);
tmp=1.0/sig[i];
for (j=0;j<ma;j++) u[i][j]=afunc[j]*tmp;
b[i]=y[i]*tmp;
}
svdcmp(u,w,v);
wmax=0.0;
for (j=0;j<ma;j++)
if (w[j] > wmax) wmax=w[j];
thresh=TOL*wmax;
for (j=0;j<ma;j++)
if (w[j] < thresh) w[j]=0.0;
svbksb(u,w,v,b,a);
chisq=0.0;
for (i=0;i<ndata;i++) {
funcs(x[i],afunc);
sum=0.0;
for (j=0;j<ma;j++) sum += a[j]*afunc[j];
chisq += (tmp=(y[i]-sum)/sig[i],tmp*tmp);
}
}
void NR::mrqcof(Vec_I_DP &x, Vec_I_DP &y, Vec_I_DP &sig, Vec_I_DP &a,
Vec_I_BOOL &ia, Mat_O_DP &alpha, Vec_O_DP &beta, DP &chisq,
void funcs(const DP, Vec_I_DP &,DP &, Vec_O_DP &))
{
int i,j,k,l,m,mfit=0;
DP ymod,wt,sig2i,dy;
int ndata=x.size();
int ma=a.size();
Vec_DP dyda(ma);
for (j=0;j<ma;j++)
if (ia[j]) mfit++;
for (j=0;j<mfit;j++) {
for (k=0;k<=j;k++) alpha[j][k]=0.0;
beta[j]=0.0;
}
chisq=0.0;
for (i=0;i<ndata;i++) {
funcs(x[i],a,ymod,dyda);
sig2i=1.0/(sig[i]*sig[i]);
dy=y[i]-ymod;
for (j=0,l=0;l<ma;l++) {
if (ia[l]) {
wt=dyda[l]*sig2i;
for (k=0,m=0;m<l+1;m++)
if (ia[m]) alpha[j][k++] += wt*dyda[m];
beta[j++] += dy*wt;
}
}
chisq += dy*dy*sig2i;
}
for (j=1;j<mfit;j++)
for (k=0;k<j;k++) alpha[k][j]=alpha[j][k];
}
int main(void) {
int n;
scanf("%d", &n);
funcs(n, n);
printf("+1\n");
return 0;
}
int main(void)
{
long idum=(-911);
int i,j,*ia;
float chisq,*a,*x,*y,*sig,**covar;
ia=ivector(1,NTERM);
a=vector(1,NTERM);
x=vector(1,NPT);
y=vector(1,NPT);
sig=vector(1,NPT);
covar=matrix(1,NTERM,1,NTERM);
for (i=1;i<=NPT;i++) {
x[i]=0.1*i;
funcs(x[i],a,NTERM);
y[i]=0.0;
for (j=1;j<=NTERM;j++) y[i] += j*a[j];
y[i] += SPREAD*gasdev(&idum);
sig[i]=SPREAD;
}
for (i=1;i<=NTERM;i++) ia[i]=1;
lfit(x,y,sig,NPT,a,ia,NTERM,covar,&chisq,funcs);
printf("\n%11s %21s\n","parameter","uncertainty");
for (i=1;i<=NTERM;i++)
printf(" a[%1d] = %8.6f %12.6f\n",
i,a[i],sqrt(covar[i][i]));
printf("chi-squared = %12f\n",chisq);
printf("full covariance matrix\n");
for (i=1;i<=NTERM;i++) {
for (j=1;j<=NTERM;j++) printf("%12f",covar[i][j]);
printf("\n");
}
printf("\npress RETURN to continue...\n");
(void) getchar();
/* Now check results of restricting fit parameters */
for (i=2;i<=NTERM;i+=2) ia[i]=0;
lfit(x,y,sig,NPT,a,ia,NTERM,covar,&chisq,funcs);
printf("\n%11s %21s\n","parameter","uncertainty");
for (i=1;i<=NTERM;i++)
printf(" a[%1d] = %8.6f %12.6f\n",
i,a[i],sqrt(covar[i][i]));
printf("chi-squared = %12f\n",chisq);
printf("full covariance matrix\n");
for (i=1;i<=NTERM;i++) {
for (j=1;j<=NTERM;j++) printf("%12f",covar[i][j]);
printf("\n");
}
printf("\n");
free_matrix(covar,1,NTERM,1,NTERM);
free_vector(sig,1,NPT);
free_vector(y,1,NPT);
free_vector(x,1,NPT);
free_vector(a,1,NTERM);
free_ivector(ia,1,NTERM);
return 0;
}
std::string Unit::toString() const {
std::ostringstream ss;
prettyPrint(ss);
for (PreClassPtrVec::const_iterator it = m_preClasses.begin();
it != m_preClasses.end(); ++it) {
(*it).get()->prettyPrint(ss);
}
for (FuncRange fr(funcs()); !fr.empty();) {
fr.popFront()->prettyPrint(ss);
}
return ss.str();
}
int funcs(int i, int n) {
if (i <= 1) {
funca(1, 1);
return 1;
} else {
printf("(");
int d = funcs(i-1, n) + (n-i+1);
printf("+%d)", d);
funca(1, i);
return 1;
}
}
void Unit::prettyPrint(std::ostream &out, size_t startOffset,
size_t stopOffset) const {
std::map<Offset,const Func*> funcMap;
for (FuncRange fr(funcs()); !fr.empty();) {
const Func* f = fr.popFront();
funcMap[f->base()] = f;
}
for (PreClassPtrVec::const_iterator it = m_preClasses.begin();
it != m_preClasses.end(); ++it) {
Func* const* methods = (*it)->methods();
size_t const numMethods = (*it)->numMethods();
for (size_t i = 0; i < numMethods; ++i) {
funcMap[methods[i]->base()] = methods[i];
}
}
std::map<Offset,const Func*>::const_iterator funcIt =
funcMap.lower_bound(startOffset);
const uchar* it = &m_bc[startOffset];
int prevLineNum = -1;
MetaHandle metaHand;
while (it < &m_bc[stopOffset]) {
ASSERT(funcIt == funcMap.end() || funcIt->first >= offsetOf(it));
if (funcIt != funcMap.end() && funcIt->first == offsetOf(it)) {
out.put('\n');
funcIt->second->prettyPrint(out);
++funcIt;
}
int lineNum = getLineNumber(offsetOf(it));
if (lineNum != prevLineNum) {
out << " // line " << lineNum << std::endl;
prevLineNum = lineNum;
}
out << " " << std::setw(4) << (it - m_bc) << ": ";
out << instrToString((Opcode*)it, (Unit*)this);
if (metaHand.findMeta(this, offsetOf(it))) {
out << " #";
Unit::MetaInfo info;
while (metaHand.nextArg(info)) {
int arg = info.m_arg & ~MetaInfo::VectorArg;
const char *argKind = info.m_arg & MetaInfo::VectorArg ? "M" : "";
switch (info.m_kind) {
case Unit::MetaInfo::DataType:
out << " i" << argKind << arg << ":t=" << (int)info.m_data;
break;
case Unit::MetaInfo::String: {
const StringData* sd = this->lookupLitstrId(info.m_data);
out << " i" << argKind << arg << ":s=" <<
std::string(sd->data(), sd->size());
break;
}
case Unit::MetaInfo::Class: {
const StringData* sd = this->lookupLitstrId(info.m_data);
out << " i" << argKind << arg << ":c=" << sd->data();
break;
}
case Unit::MetaInfo::NopOut:
out << " Nop";
break;
case Unit::MetaInfo::GuardedThis:
out << " GuardedThis";
break;
case Unit::MetaInfo::None:
ASSERT(false);
break;
}
}
}
out << std::endl;
it += instrLen((Opcode*)it);
}
}
void QOpenGLTextureGlyphCache::resizeTextureData(int width, int height)
{
QOpenGLContext *ctx = QOpenGLContext::currentContext();
if (ctx == 0) {
qWarning("QOpenGLTextureGlyphCache::resizeTextureData: Called with no context");
return;
}
int oldWidth = m_textureResource->m_width;
int oldHeight = m_textureResource->m_height;
// Make the lower glyph texture size 16 x 16.
if (width < 16)
width = 16;
if (height < 16)
height = 16;
GLuint oldTexture = m_textureResource->m_texture;
createTextureData(width, height);
if (ctx->d_func()->workaround_brokenFBOReadBack) {
QImageTextureGlyphCache::resizeTextureData(width, height);
Q_ASSERT(image().depth() == 8);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, oldHeight, GL_ALPHA, GL_UNSIGNED_BYTE, image().constBits());
glDeleteTextures(1, &oldTexture);
return;
}
// ### the QTextureGlyphCache API needs to be reworked to allow
// ### resizeTextureData to fail
QOpenGLFunctions funcs(ctx);
funcs.glBindFramebuffer(GL_FRAMEBUFFER, m_textureResource->m_fbo);
GLuint tmp_texture;
glGenTextures(1, &tmp_texture);
glBindTexture(GL_TEXTURE_2D, tmp_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, oldWidth, oldHeight, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
m_filterMode = Nearest;
glBindTexture(GL_TEXTURE_2D, 0);
funcs.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, tmp_texture, 0);
funcs.glActiveTexture(GL_TEXTURE0 + QT_IMAGE_TEXTURE_UNIT);
glBindTexture(GL_TEXTURE_2D, oldTexture);
if (pex != 0)
pex->transferMode(BrushDrawingMode);
glDisable(GL_STENCIL_TEST);
glDisable(GL_DEPTH_TEST);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
glViewport(0, 0, oldWidth, oldHeight);
QOpenGLShaderProgram *blitProgram = 0;
if (pex == 0) {
if (m_blitProgram == 0) {
m_blitProgram = new QOpenGLShaderProgram(ctx);
{
QString source;
source.append(QLatin1String(qopenglslMainWithTexCoordsVertexShader));
source.append(QLatin1String(qopenglslUntransformedPositionVertexShader));
QOpenGLShader *vertexShader = new QOpenGLShader(QOpenGLShader::Vertex, m_blitProgram);
vertexShader->compileSourceCode(source);
m_blitProgram->addShader(vertexShader);
}
{
QString source;
source.append(QLatin1String(qopenglslMainFragmentShader));
source.append(QLatin1String(qopenglslImageSrcFragmentShader));
QOpenGLShader *fragmentShader = new QOpenGLShader(QOpenGLShader::Fragment, m_blitProgram);
fragmentShader->compileSourceCode(source);
m_blitProgram->addShader(fragmentShader);
}
m_blitProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR);
m_blitProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR);
m_blitProgram->link();
}
funcs.glVertexAttribPointer(QT_VERTEX_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, m_vertexCoordinateArray);
funcs.glVertexAttribPointer(QT_TEXTURE_COORDS_ATTR, 2, GL_FLOAT, GL_FALSE, 0, m_textureCoordinateArray);
m_blitProgram->bind();
m_blitProgram->enableAttributeArray(int(QT_VERTEX_COORDS_ATTR));
m_blitProgram->enableAttributeArray(int(QT_TEXTURE_COORDS_ATTR));
m_blitProgram->disableAttributeArray(int(QT_OPACITY_ATTR));
blitProgram = m_blitProgram;
} else {
pex->setVertexAttributePointer(QT_VERTEX_COORDS_ATTR, m_vertexCoordinateArray);
pex->setVertexAttributePointer(QT_TEXTURE_COORDS_ATTR, m_textureCoordinateArray);
pex->shaderManager->useBlitProgram();
blitProgram = pex->shaderManager->blitProgram();
}
blitProgram->setUniformValue("imageTexture", QT_IMAGE_TEXTURE_UNIT);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glBindTexture(GL_TEXTURE_2D, m_textureResource->m_texture);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, oldWidth, oldHeight);
funcs.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, 0);
glDeleteTextures(1, &tmp_texture);
glDeleteTextures(1, &oldTexture);
funcs.glBindFramebuffer(GL_FRAMEBUFFER, ctx->d_func()->current_fbo);
if (pex != 0) {
glViewport(0, 0, pex->width, pex->height);
pex->updateClipScissorTest();
} else {
m_blitProgram->disableAttributeArray(int(QT_VERTEX_COORDS_ATTR));
m_blitProgram->disableAttributeArray(int(QT_TEXTURE_COORDS_ATTR));
}
}
bool DebugInterface::parseExpression(PostfixExpression& exp, u64& dest)
{
MipsExpressionFunctions funcs(this);
return parsePostfixExpression(exp,&funcs,dest);
}
bool DebugInterface::initExpression(const char* exp, PostfixExpression& dest)
{
MipsExpressionFunctions funcs(this);
return initPostfixExpression(exp,&funcs,dest);
}
