int main(int argc, char *argv[])
{
int a, b, terminator, index;
double c;
char *p;
if (argc < 6)
goto bad_input;
a = strtol(argv[1], &p, 10);
if (*p != '\0') goto bad_input;
b = strtol(argv[2], &p, 10);
if (*p != '\0') goto bad_input;
c = strtod(argv[3], &p);
if (*p != '\0') goto bad_input;
terminator = strtol(argv[4], &p, 10);
if (*p != '\0') goto bad_input;
index = strtol(argv[5], &p, 10);
if (*p != '\0') {
bad_input:
std::cerr << "BAD INPUT\n";
return -1;
}
W1 w1 = W1(a, b, c, terminator);
w1.molecule.mmp(std::cout, index);
return 0;
}
//calculate ES energy between pDNA
FLOAT pdna::pDNA_esenergy(proteinPDB p, matrix Wp, bdna *b) {
FLOAT E = 0.0;
FLOAT kap = 0.329*sqrt(ion);
FLOAT r,x,y,z;
FLOAT q1, q2;
matrix W1 = identity(4);
//translate the positions of the protein
FLOAT *pex = new FLOAT[p.neatoms];
FLOAT *pey = new FLOAT[p.neatoms];
FLOAT *pez = new FLOAT[p.neatoms];
for (int i = 0; i < p.neatoms; i++) {
pex[i] = Wp(1,4)+p.ex[i]*Wp(1,1)+p.ey[i]*Wp(1,2)+p.ez[i]*Wp(1,3);
pey[i] = Wp(2,4)+p.ex[i]*Wp(2,1)+p.ey[i]*Wp(2,2)+p.ez[i]*Wp(2,3);
pez[i] = Wp(3,4)+p.ex[i]*Wp(3,1)+p.ey[i]*Wp(3,2)+p.ez[i]*Wp(3,3);
}
for (int i = 0; i < b->nsteps-1; i++) {
FLOAT X1 = W1(1,4);
FLOAT Y1 = W1(2,4);
FLOAT Z1 = W1(3,4);
q1 = -0.25; //DNA screened charge
W1 = W1 * calculateW(v[i]);
for (int j = 0; j < p.neatoms; j++) {
x = X1-pex[j];
y = Y1-pey[j];
z = Z1-pez[j];
q2 = p.e[j];
r = sqrt(x*x+y*y+z*z);
E += q1*q2*exp(-kap*r)/r;
}
}
E *= coeff;
return E;
delete [] pex; delete [] pey; delete [] pez;
}
MeshCurvature<Real>::MeshCurvature (int numVertices,
const Vector3<Real>* vertices, int numTriangles, const int* indices)
{
mNumVertices = numVertices;
mVertices = vertices;
mNumTriangles = numTriangles;
mIndices = indices;
// Compute normal vectors.
mNormals = new1<Vector3<Real> >(mNumVertices);
memset(mNormals, 0, mNumVertices*sizeof(Vector3<Real>));
int i, v0, v1, v2;
for (i = 0; i < mNumTriangles; ++i)
{
// Get vertex indices.
v0 = *indices++;
v1 = *indices++;
v2 = *indices++;
// Compute the normal (length provides a weighted sum).
Vector3<Real> edge1 = mVertices[v1] - mVertices[v0];
Vector3<Real> edge2 = mVertices[v2] - mVertices[v0];
Vector3<Real> normal = edge1.Cross(edge2);
mNormals[v0] += normal;
mNormals[v1] += normal;
mNormals[v2] += normal;
}
for (i = 0; i < mNumVertices; ++i)
{
mNormals[i].Normalize();
}
// Compute the matrix of normal derivatives.
Matrix3<Real>* DNormal = new1<Matrix3<Real> >(mNumVertices);
Matrix3<Real>* WWTrn = new1<Matrix3<Real> >(mNumVertices);
Matrix3<Real>* DWTrn = new1<Matrix3<Real> >(mNumVertices);
bool* DWTrnZero = new1<bool>(mNumVertices);
memset(WWTrn, 0, mNumVertices*sizeof(Matrix3<Real>));
memset(DWTrn, 0, mNumVertices*sizeof(Matrix3<Real>));
memset(DWTrnZero, 0, mNumVertices*sizeof(bool));
int row, col;
indices = mIndices;
for (i = 0; i < mNumTriangles; ++i)
{
// Get vertex indices.
int V[3];
V[0] = *indices++;
V[1] = *indices++;
V[2] = *indices++;
for (int j = 0; j < 3; j++)
{
v0 = V[j];
v1 = V[(j+1)%3];
v2 = V[(j+2)%3];
// Compute edge from V0 to V1, project to tangent plane of vertex,
// and compute difference of adjacent normals.
Vector3<Real> E = mVertices[v1] - mVertices[v0];
Vector3<Real> W = E - (E.Dot(mNormals[v0]))*mNormals[v0];
Vector3<Real> D = mNormals[v1] - mNormals[v0];
for (row = 0; row < 3; ++row)
{
for (col = 0; col < 3; ++col)
{
WWTrn[v0][row][col] += W[row]*W[col];
DWTrn[v0][row][col] += D[row]*W[col];
}
}
// Compute edge from V0 to V2, project to tangent plane of vertex,
// and compute difference of adjacent normals.
E = mVertices[v2] - mVertices[v0];
W = E - (E.Dot(mNormals[v0]))*mNormals[v0];
D = mNormals[v2] - mNormals[v0];
for (row = 0; row < 3; ++row)
{
for (col = 0; col < 3; ++col)
{
WWTrn[v0][row][col] += W[row]*W[col];
DWTrn[v0][row][col] += D[row]*W[col];
}
}
}
}
// Add in N*N^T to W*W^T for numerical stability. In theory 0*0^T gets
// added to D*W^T, but of course no update is needed in the
// implementation. Compute the matrix of normal derivatives.
for (i = 0; i < mNumVertices; ++i)
{
for (row = 0; row < 3; ++row)
{
for (col = 0; col < 3; ++col)
{
WWTrn[i][row][col] = ((Real)0.5)*WWTrn[i][row][col] +
mNormals[i][row]*mNormals[i][col];
DWTrn[i][row][col] *= (Real)0.5;
}
}
// Compute the max-abs entry of D*W^T. If this entry is (nearly)
// zero, flag the DNormal matrix as singular.
Real maxAbs = (Real)0;
for (row = 0; row < 3; ++row)
{
for (col = 0; col < 3; ++col)
{
Real absEntry = Math<Real>::FAbs(DWTrn[i][row][col]);
if (absEntry > maxAbs)
{
maxAbs = absEntry;
}
}
}
if (maxAbs < (Real)1e-07)
{
DWTrnZero[i] = true;
}
DNormal[i] = DWTrn[i]*WWTrn[i].Inverse();
}
delete1(WWTrn);
delete1(DWTrn);
// If N is a unit-length normal at a vertex, let U and V be unit-length
// tangents so that {U, V, N} is an orthonormal set. Define the matrix
// J = [U | V], a 3-by-2 matrix whose columns are U and V. Define J^T
// to be the transpose of J, a 2-by-3 matrix. Let dN/dX denote the
// matrix of first-order derivatives of the normal vector field. The
// shape matrix is
// S = (J^T * J)^{-1} * J^T * dN/dX * J = J^T * dN/dX * J
// where the superscript of -1 denotes the inverse. (The formula allows
// for J built from non-perpendicular vectors.) The matrix S is 2-by-2.
// The principal curvatures are the eigenvalues of S. If k is a principal
// curvature and W is the 2-by-1 eigenvector corresponding to it, then
// S*W = k*W (by definition). The corresponding 3-by-1 tangent vector at
// the vertex is called the principal direction for k, and is J*W.
mMinCurvatures = new1<Real>(mNumVertices);
mMaxCurvatures = new1<Real>(mNumVertices);
mMinDirections = new1<Vector3<Real> >(mNumVertices);
mMaxDirections = new1<Vector3<Real> >(mNumVertices);
for (i = 0; i < mNumVertices; ++i)
{
// Compute U and V given N.
Vector3<Real> U, V;
Vector3<Real>::GenerateComplementBasis(U, V, mNormals[i]);
if (DWTrnZero[i])
{
// At a locally planar point.
mMinCurvatures[i] = (Real)0;
mMaxCurvatures[i] = (Real)0;
mMinDirections[i] = U;
mMaxDirections[i] = V;
continue;
}
// Compute S = J^T * dN/dX * J. In theory S is symmetric, but
// because we have estimated dN/dX, we must slightly adjust our
// calculations to make sure S is symmetric.
Real s01 = U.Dot(DNormal[i]*V);
Real s10 = V.Dot(DNormal[i]*U);
Real sAvr = ((Real)0.5)*(s01 + s10);
Matrix2<Real> S
(
U.Dot(DNormal[i]*U), sAvr,
sAvr, V.Dot(DNormal[i]*V)
);
// Compute the eigenvalues of S (min and max curvatures).
Real trace = S[0][0] + S[1][1];
Real det = S[0][0]*S[1][1] - S[0][1]*S[1][0];
Real discr = trace*trace - ((Real)4.0)*det;
Real rootDiscr = Math<Real>::Sqrt(Math<Real>::FAbs(discr));
mMinCurvatures[i] = ((Real)0.5)*(trace - rootDiscr);
mMaxCurvatures[i] = ((Real)0.5)*(trace + rootDiscr);
// Compute the eigenvectors of S.
Vector2<Real> W0(S[0][1], mMinCurvatures[i] - S[0][0]);
Vector2<Real> W1(mMinCurvatures[i] - S[1][1], S[1][0]);
if (W0.SquaredLength() >= W1.SquaredLength())
{
W0.Normalize();
mMinDirections[i] = W0.X()*U + W0.Y()*V;
}
else
{
W1.Normalize();
mMinDirections[i] = W1.X()*U + W1.Y()*V;
}
W0 = Vector2<Real>(S[0][1], mMaxCurvatures[i] - S[0][0]);
W1 = Vector2<Real>(mMaxCurvatures[i] - S[1][1], S[1][0]);
if (W0.SquaredLength() >= W1.SquaredLength())
{
W0.Normalize();
mMaxDirections[i] = W0.X()*U + W0.Y()*V;
}
else
{
W1.Normalize();
mMaxDirections[i] = W1.X()*U + W1.Y()*V;
}
}
delete1(DWTrnZero);
delete1(DNormal);
}
/// Adaptive Weights disparity computation.
///
/// The dissimilarity is computed putting adaptive weights on the raw cost.
/// \param im1,im2 the two color images
/// \param dMin,dMax disparity range
/// \param param raw cost computation parameters
/// \param disp1 output disparity map from image 1 to image 2
/// \param disp2 output disparity map from image 2 to image 1
void disparityAW(Image im1, Image im2,
int dMin, int dMax, const ParamDisparity& param,
Image& disp1, Image& disp2) {
const int width=im1.width(), height=im1.height();
const int r = param.radius;
#ifdef COMB_LEFT // Disparity range
const int nd = 1; // Do not compute useless weights in target image
#else
const int nd = dMax-dMin+1;
#endif
// Tabulated proximity weights (color distance)
const int maxL1 = im1.channels()*255; // Maximum L1 distance between colors
float* distC = new float[maxL1+1];
float e2=exp(-1/(im1.channels()*param.gammaCol));
distC[0]=1.0f;
for(int x=1; x<=maxL1; x++)
distC[x] = e2*distC[x-1]; // distC[x] = exp(-x/(c*gamma))
// Tabulated proximity weights (spatial distance)
const int dim=2*r+1; // window dimension
float *distP = new float[dim*dim], *d=distP;
for(int y=-r; y<=r; y++)
for(int x=-r; x<=r; x++)
*d++ = exp(-2.0f*sqrt((float)(x*x+y*y))/param.gammaPos);
Image* cost = costVolume(im1, im2, dMin, dMax, param);
// Images of dissimilarity 1->2 and 2->1
Image E1(width,height), E2(width,height);
std::fill_n(&E1(0,0), width*height, std::numeric_limits<float>::max());
std::fill_n(&E2(0,0), width*height, std::numeric_limits<float>::max());
#ifdef _OPENMP
#pragma omp parallel for
#endif
for(int y=0; y<height; y++) {
// Weight window in reference image
Image W1(dim,dim);
// Weight windows in target image for each disparity (useless for
// COMB_LEFT, but better to have readable code than multiplying #ifdef)
Image* weights2 = new Image[nd];
for(int d=0; d<nd; d++) {
weights2[d] = Image(dim,dim);
if(d+1<nd) // Support for dMax computed later
support(im2, d,y, r, distC, weights2[d]);
}
for(int x=0; x<width; x++) {
// Reference window weights
support(im1, x,y, r, distC, W1);
#ifndef COMB_LEFT // Weight window at disparity dMax in target image
support(im2, x+dMax,y, r, distC, weights2[(x+dMax-dMin)%nd]);
#endif
for(int d=dMin; d<=dMax; d++) {
if(0<=x+d && x+d<width) {
const Image& e = cost[d-dMin]; // Raw cost for disp. d
const Image& W2 = weights2[(x+d-dMin)%nd];
float E = costCombined(x, x+d, y, r, W1, W2, distP, e);
if(E1(x,y) > E) {
E1(x,y) = E;
disp1(x,y) = static_cast<float>(d);
}
if(E2(x+d,y) > E) {
E2(x+d,y) = E;
disp2(x+d,y)= -static_cast<float>(d);
}
}
}
}
delete [] weights2;
}
delete [] cost;
delete [] distC;
delete [] distP;
}
bool
ICBinaryArith_Int32::Compiler::generateStubCode(MacroAssembler& masm)
{
// Guard that R0 is an integer and R1 is an integer.
Label failure;
masm.branchTestInt32(Assembler::NotEqual, R0, &failure);
masm.branchTestInt32(Assembler::NotEqual, R1, &failure);
// Add R0 and R1. Don't need to explicitly unbox, just use R2.
Register Rscratch = R2_;
ARMRegister Wscratch = ARMRegister(Rscratch, 32);
#ifdef MERGE
// DIV and MOD need an extra non-volatile ValueOperand to hold R0.
AllocatableGeneralRegisterSet savedRegs(availableGeneralRegs(2));
savedRegs.set() = GeneralRegisterSet::Intersect(GeneralRegisterSet::NonVolatile(), savedRegs);
#endif
// get some more ARM-y names for the registers
ARMRegister W0(R0_, 32);
ARMRegister X0(R0_, 64);
ARMRegister W1(R1_, 32);
ARMRegister X1(R1_, 64);
ARMRegister WTemp(ExtractTemp0, 32);
ARMRegister XTemp(ExtractTemp0, 64);
Label maybeNegZero, revertRegister;
switch(op_) {
case JSOP_ADD:
masm.Adds(WTemp, W0, Operand(W1));
// Just jump to failure on overflow. R0 and R1 are preserved, so we can
// just jump to the next stub.
masm.j(Assembler::Overflow, &failure);
// Box the result and return. We know R0 already contains the
// integer tag, so we just need to move the payload into place.
masm.movePayload(ExtractTemp0, R0_);
break;
case JSOP_SUB:
masm.Subs(WTemp, W0, Operand(W1));
masm.j(Assembler::Overflow, &failure);
masm.movePayload(ExtractTemp0, R0_);
break;
case JSOP_MUL:
masm.mul32(R0.valueReg(), R1.valueReg(), Rscratch, &failure, &maybeNegZero);
masm.movePayload(Rscratch, R0_);
break;
case JSOP_DIV:
case JSOP_MOD: {
// Check for INT_MIN / -1, it results in a double.
Label check2;
masm.Cmp(W0, Operand(INT_MIN));
masm.B(&check2, Assembler::NotEqual);
masm.Cmp(W1, Operand(-1));
masm.j(Assembler::Equal, &failure);
masm.bind(&check2);
Label no_fail;
// Check for both division by zero and 0 / X with X < 0 (results in -0).
masm.Cmp(W1, Operand(0));
// If x > 0, then it can't be bad.
masm.B(&no_fail, Assembler::GreaterThan);
// if x == 0, then ignore any comparison, and force
// it to fail, if x < 0 (the only other case)
// then do the comparison, and fail if y == 0
masm.Ccmp(W0, Operand(0), vixl::ZFlag, Assembler::NotEqual);
masm.B(&failure, Assembler::Equal);
masm.bind(&no_fail);
masm.Sdiv(Wscratch, W0, W1);
// Start calculating the remainder, x - (x / y) * y.
masm.mul(WTemp, W1, Wscratch);
if (op_ == JSOP_DIV) {
// Result is a double if the remainder != 0, which happens
// when (x/y)*y != x.
masm.branch32(Assembler::NotEqual, R0.valueReg(), ExtractTemp0, &revertRegister);
masm.movePayload(Rscratch, R0_);
} else {
// Calculate the actual mod. Set the condition code, so we can see if it is non-zero.
masm.Subs(WTemp, W0, WTemp);
// If X % Y == 0 and X < 0, the result is -0.
masm.Ccmp(W0, Operand(0), vixl::NoFlag, Assembler::Equal);
masm.branch(Assembler::LessThan, &revertRegister);
masm.movePayload(ExtractTemp0, R0_);
}
break;
}
// ORR, EOR, AND can trivially be coerced int
// working without affecting the tag of the dest..
case JSOP_BITOR:
masm.Orr(X0, X0, Operand(X1));
break;
case JSOP_BITXOR:
masm.Eor(X0, X0, Operand(W1, vixl::UXTW));
break;
case JSOP_BITAND:
masm.And(X0, X0, Operand(X1));
break;
// LSH, RSH and URSH can not.
case JSOP_LSH:
// ARM will happily try to shift by more than 0x1f.
masm.Lsl(Wscratch, W0, W1);
masm.movePayload(Rscratch, R0.valueReg());
break;
case JSOP_RSH:
masm.Asr(Wscratch, W0, W1);
masm.movePayload(Rscratch, R0.valueReg());
break;
case JSOP_URSH:
masm.Lsr(Wscratch, W0, W1);
if (allowDouble_) {
Label toUint;
// Testing for negative is equivalent to testing bit 31
masm.Tbnz(Wscratch, 31, &toUint);
// Move result and box for return.
masm.movePayload(Rscratch, R0_);
EmitReturnFromIC(masm);
masm.bind(&toUint);
masm.convertUInt32ToDouble(Rscratch, ScratchDoubleReg);
masm.boxDouble(ScratchDoubleReg, R0, ScratchDoubleReg);
} else {
// Testing for negative is equivalent to testing bit 31
masm.Tbnz(Wscratch, 31, &failure);
// Move result for return.
masm.movePayload(Rscratch, R0_);
}
break;
default:
MOZ_CRASH("Unhandled op for BinaryArith_Int32.");
}
EmitReturnFromIC(masm);
switch (op_) {
case JSOP_MUL:
masm.bind(&maybeNegZero);
// Result is -0 if exactly one of lhs or rhs is negative.
masm.Cmn(W0, W1);
masm.j(Assembler::Signed, &failure);
// Result is +0, so use the zero register.
masm.movePayload(rzr, R0_);
EmitReturnFromIC(masm);
break;
case JSOP_DIV:
case JSOP_MOD:
masm.bind(&revertRegister);
break;
default:
break;
}
// Failure case - jump to next stub.
masm.bind(&failure);
EmitStubGuardFailure(masm);
return true;
}
virtual void paintGL()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
int xOffset = -70;
int yOffset = -50;
int zoom = -200;
glTranslatef(xOffset, yOffset, zoom);
glColor3f(0.0f, 0.0f, 0.0f);
glLineWidth(5.0);
float scale = 1.0;
if(showFilters)
{
Eigen::MatrixXd W1 = sae.getInputWeights();
Eigen::MatrixXd W2 = sae.getOutputWeights();
double mi = sae.getInputWeights().minCoeff();
double ma = sae.getInputWeights().maxCoeff();
double range = ma - mi;
for(int row = 0, filter = 0; row < neuronRows; row++)
{
for(int col = 0; col < neuronCols; col++, filter++)
{
glBegin(GL_QUADS);
for(int yIdx = 0; yIdx < 28; yIdx++)
{
for(int xIdx = 0; xIdx < 28; xIdx++)
{
int h = (filter + offset) / 2;
bool in = (filter + offset) % 2 == 0;
int idx = yIdx * 28 + xIdx;
float c = ((in ? W1(h, idx) : W2(idx, h)) - mi) / range;
float x = xIdx * scale + col * 29.0f * scale - 30.0f;
float y = (28.0f - yIdx) * scale - row * scale * 29.0f + 90.0f;
glColor3f(c, c, c);
glVertex2f(x, y);
glVertex2f(x + scale, y);
glVertex2f(x + scale, y + scale);
glVertex2f(x, y + scale);
}
}
glEnd();
}
}
}
else
{
for(int row = 0; row < neuronRows; row++)
{
for(int col = 0; col < neuronCols; col++)
{
Eigen::VectorXd out = sae.reconstruct(dataSet.getInstance(offset + row*neuronCols+col));
glBegin(GL_QUADS);
for(int yIdx = 0; yIdx < 28; yIdx++)
{
for(int xIdx = 0; xIdx < 28; xIdx++)
{
int idx = yIdx * 28 + xIdx;
float c = out(idx);
float x = xIdx * scale + col * 29.0f * scale - 30.0f;
float y = (28.0f - yIdx) * scale - row * scale * 29.0f + 90.0f;
glColor3f(c, c, c);
glVertex2f(x, y);
glVertex2f(x + scale, y);
glVertex2f(x + scale, y + scale);
glVertex2f(x, y + scale);
}
}
glEnd();
}
}
}
glColor3f(0.0f, 0.0f, 0.0f);
renderText(10, 35, "MNIST data set", QFont("Helvetica", 20));
glFlush();
}
