//! Called by the engine when the vertex and/or pixel shader constants for an
//! material renderer should be set.
void COpenGLParallaxMapRenderer::OnSetConstants(IMaterialRendererServices* services, s32 userData)
{
video::IVideoDriver* driver = services->getVideoDriver();
// set transposed world matrix
const core::matrix4& tWorld = driver->getTransform(video::ETS_WORLD).getTransposed();
services->setVertexShaderConstant(tWorld.pointer(), 0, 4);
// The viewpoint is at (0., 0., 0.) in eye space.
// Turning this into a vector [0 0 0 1] and multiply it by
// the inverse of the view matrix, the resulting vector is the
// object space location of the camera.
f32 floats[4] = {0.0f,0.0f,0.0f,1.0f};
core::matrix4 minv(driver->getTransform(video::ETS_VIEW));
minv.makeInverse();
minv.multiplyWith1x4Matrix(floats);
services->setVertexShaderConstant(floats, 16, 1);
// set transposed worldViewProj matrix
core::matrix4 worldViewProj(driver->getTransform(video::ETS_PROJECTION));
worldViewProj *= driver->getTransform(video::ETS_VIEW);
worldViewProj *= driver->getTransform(video::ETS_WORLD);
core::matrix4 tr(worldViewProj.getTransposed());
services->setVertexShaderConstant(tr.pointer(), 8, 4);
// here we fetch the fixed function lights from the driver
// and set them as constants
u32 cnt = driver->getDynamicLightCount();
for (u32 i=0; i<2; ++i)
{
video::SLight light;
if (i<cnt)
light = driver->getDynamicLight(i);
else
{
light.DiffuseColor.set(0,0,0); // make light dark
light.Radius = 1.0f;
}
light.DiffuseColor.a = 1.0f/(light.Radius*light.Radius); // set attenuation
services->setVertexShaderConstant(
reinterpret_cast<const f32*>(&light.Position), 12+(i*2), 1);
services->setVertexShaderConstant(
reinterpret_cast<const f32*>(&light.DiffuseColor), 13+(i*2), 1);
}
// set scale factor
f32 factor = 0.02f; // default value
if (CurrentScale != 0.0f)
factor = CurrentScale;
f32 c6[] = {factor, factor, factor, factor};
services->setPixelShaderConstant(c6, 0, 1);
}
int main()
{
ull i,x,s,m;
ull f41[10];
f41[0] =1;
for(i=1;i<=9;i++)
f41[i] = f41[i-1]*41;
fact[0] = fact2[0] = 1;
for(i=1;i<=max;i++)
fact[i] = ( ( ( fact[i-1] * (4*i-2) ) % mod4 ) * minv(i,mod4) ) % mod4;
for(i=1;i<=2*max;i++)
{
x = i;
while(!(x%41))
x/=41;
fact2[i] = (fact2[i-1]*x)%mod6;
}
ncr[0] = 1;
for(i=1;i<=max;i++)
{
s = minv(fact2[i],mod6);
s = (s*s)%mod6;
x = (fact2[2*i]*s)%mod6;
m = pow_fact(2*i) - 2*pow_fact(i);
x = (x*f41[m])%mod6;
ncr[i] = crt(fact[i],x);
}
return 0;
}
// hungarian method : bipartite min-weighted matching
// O(n^3) or O(m*n^2)
// http://e-maxx.ru/algo/assignment_hungary
// mat[1][1] ~ mat[n][m]
// matched[i] : matched column of row i
int hungarian(vector<int>& matched) {
vector<int> u(n + 1), v(m + 1), p(m + 1), way(m + 1), minv(m + 1);
vector<char> used(m + 1);
for (int i = 1; i <= n; ++i) {
p[0] = i;
int j0 = 0;
fill(minv.begin(), minv.end(), INF);
fill(used.begin(), used.end(), false);
do {
used[j0] = true;
int i0 = p[j0], delta = INF, j1;
for (int j = 1; j <= m; ++j) {
if (!used[j]) {
int cur = mat[i0][j] - u[i0] - v[j];
if (cur < minv[j]) minv[j] = cur, way[j] = j0;
if (minv[j] < delta) delta = minv[j], j1 = j;
}
}
for (int j = 0; j <= m; ++j) {
if (used[j])
u[p[j]] += delta, v[j] -= delta;
else
minv[j] -= delta;
}
j0 = j1;
} while (p[j0] != 0);
do {
int j1 = way[j0];
p[j0] = p[j1];
j0 = j1;
} while (j0);
}
for (int j = 1; j <= m; ++j) matched[p[j]] = j;
return -v[0];
}
void gen_fact_inv()
{
ll i;
fact[0] = 1,inv[0]=1,inv[2]=0;
for(i=1;i<=max;i++)
{
fact[i] = (fact[i-1]*i)%mod;
inv[i] = minv(fact[i],mod);
inv2[i] = minv(i,mod);
}
}
// Center mesh around origin.
// Fit mesh in box from (-1, -1, -1) to (1, 1, 1)
void Mesh::Normalize()
{
float min[3], max[3], Scale;
setMinMax(min, max);
Vec3 minv(min);
Vec3 maxv(max);
Vec3 dimv = maxv - minv;
if (dimv.x >= dimv.y && dimv.x >= dimv.z) Scale = 2.0f/dimv.x;
else if (dimv.y >= dimv.x && dimv.y >= dimv.z) Scale = 2.0f/dimv.y;
else Scale = 2.0f/dimv.z;
Vec3 transv = minv + maxv;
transv *= 0.5f;
for (unsigned int i = 0; i < _vlist.size(); ++i)
{
_vlist[i].getXYZ() -= transv;
_vlist[i].getXYZ() *= Scale;
}
}
int main()
{
ull i=0,j;
a[i] = 1;
for(i=1;i<=mod;i++)
{
ull x = i;
for(j=0;j<4;j++)
while(!(x%val[j]))
x /= val[j];
a[i] = (a[i-1] * x)%mod;
}
int t;
scanf("%d",&t);
while(t--)
{
ull n,r;
scanf("%lld%lld",&n,&r);
int i,s1[4]={0},s2[4]={0},check = 0;
for(i=0;i<4;i++)
{
s1[i] = power(n,val[i]);
s2[i] = power(r,val[i]) + power(n-r,val[i]);
if(s1[i]-s2[i] < count[i])
check = 1;
}
if(check)
{
ull b[5]={0},c[5]={0};
ull x = num_to_base(n,b,mod);
ull x1 = num_to_base(r,c,mod);
ull ans = 1;
for(i=0;i<=x;i++)
{
ans = ( a[b[i]] * minv(a[c[i]],mod) )%mod;
ans = (ans * minv(a[b[i]-c[i]],mod) )%mod;
}
for(i=0;i<4;i++)
ans = ( ans * power2(val[i],s1[i]-s2[i]) )%mod;
printf("%lld\n",ans);
}
else
printf("0\n");
}
return 0;
}
//---------------------------------------------------------------------------
TMatrix TMatrix::operator!() const // обращение матрицы
{
if (sizeV != sizeH)
throw Exception("Попытка обратить неквадратную матрицу!");
TMatrix Result(*this);
minv (Result.mat, sizeV);
return Result;
}
int main()
{
ull i,t,n,x;
a[1] = 1;
for(i=2;i<=max;i++)
x=i-1,a[i] = (((a[i-1]*(4*x+2))%mod)*minv(x,mod))%mod;
for(scanf("%lld",&t);t--;scanf("%lld",&n),printf("%lld\n",a[n]));
return 0;
}
Transform Translate(const Vector &delta) {
Matrix4x4 m(1, 0, 0, delta.x,
0, 1, 0, delta.y,
0, 0, 1, delta.z,
0, 0, 0, 1);
Matrix4x4 minv(1, 0, 0, -delta.x,
0, 1, 0, -delta.y,
0, 0, 1, -delta.z,
0, 0, 0, 1);
return Transform(m, minv);
}
Transform Scale(float x, float y, float z) {
Matrix4x4 m(x, 0, 0, 0,
0, y, 0, 0,
0, 0, z, 0,
0, 0, 0, 1);
Matrix4x4 minv(1.f/x, 0, 0, 0,
0, 1.f/y, 0, 0,
0, 0, 1.f/z, 0,
0, 0, 0, 1);
return Transform(m, minv);
}
// test driver
main(int , char **)
{
// output precision
cout.precision(6);
cout.setf(ios::showpoint);
// define matrix and initialize elements
int nrows = 3;
int ncols = 3;
int idata = 0;
int ir = 0;
Matrix<double> m(nrows, ncols);
for ( ; ir < nrows; ir++)
{
for (int ic = 0; ic < ncols; ic++)
{
m(ir, ic) = data[idata++];
}
}
cout << "TEST MATRIX IS ... " << endl;
cout << m << endl;
Matrix<double> msave(m);
// initialize inhomogeneous part.
Vector<double> y(nrows);
for (ir = 0; ir < nrows; ir++)
{
y[ir] = data[idata++];
}
cout << "TEST Y-VECTOR IS ... " << endl;
cout << y << endl << endl;
// get LUP decomposition
Vector<int> pv(nrows);
double determinant;
MustBeTrue(GaussianLUP_Pivot(m, pv, 0.0, determinant) == OK);
// get solution using LUP results
Vector<double> x(nrows);
MustBeTrue(SolveUsingGaussianLUP_Pivot(m, x, y, pv, 0.0) == OK);
cout << "SOLUTION X IS ... " << x << endl << endl;
// get inverse using LUP results
Matrix<double> minv(nrows, ncols);
MustBeTrue(GetInverseUsingGaussianLUP_Pivot(m, minv, pv, 0.0) == OK)
cout << "INVERSE OF M IS ... " << endl << endl;
cout << minv << endl;
cout << "M*MINV IS ... " << endl;
cout << msave*minv << endl << endl;
return(0);
}
Transform Transform::Scale(float p_x, float p_y, float p_z){
Matrix4x4 m(p_x, 0, 0, 0,
0, p_y, 0, 0,
0, 0, p_z, 0,
0, 0, 0, 1);
Matrix4x4 minv(1.0f/p_x, 0, 0, 0,
0, 1.0f/p_y, 0, 0,
0, 0, 1.0f/p_z, 0,
0, 0, 0, 1);
return Transform(m, minv);
}
int main()
{
ull i,x,s,m;
ull f41[10];
f41[0] = 1;
for(i=1;i<=9;i++)
f41[i] = f41[i-1]*41;
fact[0] = fact2[0] = 1;
for(i=1;i<=max+5;i++)
fact[i] = ( ( ( fact[i-1] * (4*i-2) ) % mod4 ) * minv(i,mod4) ) % mod4;
for(i=1;i<=2*max+5;i++)
{
x = i;
while(!(x%41))
x/=41;
fact2[i] = (fact2[i-1]*x)%mod6;
}
int t,a,b,n=79981;
for(a=0;a<100;a++)
for(b=0;b<100;b++)
{
s = minv(fact2[n],mod6);
s = (s*s)%mod6;
x = (fact2[2*n]*s)%mod6;
m = pow_fact(2*n) - 2*pow_fact(n);
x = x*f41[m];
ull y = crt(fact[n],x%mod6);
if(n==0)
y = 1;
if (y==0)
y = mod3;
ull y1 = power(b,y,mod2);
if(b==0)
y1 = 0;
ull z = power(a,y1,mod1);
printf("%lld\n",z);
}
return 0;
}
Transform translate(float x, float y, float z) {
Matrix4x4 m(
1, 0, 0, x,
0, 1, 0, y,
0, 0, 1, z,
0, 0, 0, 1);
Matrix4x4 minv(
1, 0, 0, -x,
0, 1, 0, -y,
0, 0, 1, -z,
0, 0, 0, 1
);
return Transform(m, minv);
}
function ent_setminmax(ENTITY *ent)
{
VECTOR pos;
vec_set(&ent->max_x, vector(-9999999, -9999999, -9999999));
vec_set(&ent->min_x, vector(9999999, 9999999, 9999999));
int i;
CONTACT c;
for(i = 1; i <= ent_status(ent, 0); i++)
{
VECTOR pos;
ent_getvertex(ent, &c, i);
pos.x = c.v->x;
pos.y = c.v->z;
pos.z = c.v->y;
//vec_mul(&pos, &ent->scale_x);
ent->max_x = maxv(pos.x, ent->max_x);
ent->max_y = maxv(pos.y, ent->max_y);
ent->max_z = maxv(pos.z, ent->max_z);
ent->min_x = minv(pos.x, ent->min_x);
ent->min_y = minv(pos.y, ent->min_y);
ent->min_z = minv(pos.z, ent->min_z);
}
}
Transform Transform::Translate(const Vector3& p_delta){
Matrix4x4 m(1, 0, 0, p_delta.x,
0, 1, 0, p_delta.y,
0, 0, 1, p_delta.z,
0, 0, 0, 1
);
Matrix4x4 minv(1, 0, 0, -p_delta.x,
0, 1, 0, -p_delta.y,
0, 0, 1, -p_delta.z,
0, 0, 0, 1
);
return Transform(m, minv);
}
//! renvoie la transformation associee au changement d'echelle (v, v, v).
Transform Scale( float v )
{
Matrix4x4 m(
v, 0, 0, 0,
0, v, 0, 0,
0, 0, v, 0,
0, 0, 0, 1 );
Matrix4x4 minv(
1.f / v, 0, 0, 0,
0, 1.f / v, 0, 0,
0, 0, 1.f / v, 0,
0, 0, 0, 1 );
return Transform( m, minv );
}
autoSound Sound_and_MixingMatrix_unmix (Sound me, MixingMatrix thee) {
try {
if (my ny != thy numberOfRows) {
Melder_throw (U"The MixingMatrix and the Sound must have the same number of channels.");
}
autoNUMmatrix<double> minv (1, thy numberOfColumns, 1, thy numberOfRows);
NUMpseudoInverse (thy data, thy numberOfRows, thy numberOfColumns, minv.peek(), 0);
autoSound him = Sound_create (thy numberOfColumns, my xmin, my xmax, my nx, my dx, my x1);
for (long i = 1; i <= thy numberOfColumns; i++) {
for (long j = 1; j <= my nx; j++) {
double s = 0;
for (long k = 1; k <= my ny; k++) {
s += minv[i][k] * my z[k][j];
}
his z[i][j] = s;
}
}
return him;
} catch (MelderError) {
Melder_throw (me, U": not unmixed.");
}
}
void OccluderComponent::setVertices(const Vec3* begin, U count, U stride)
{
ANKI_ASSERT(begin);
ANKI_ASSERT(count > 0 && (count % 3) == 0);
ANKI_ASSERT(stride >= sizeof(Vec3));
m_begin = begin;
m_count = count;
m_stride = stride;
Vec3 minv(MAX_F32), maxv(MIN_F32);
while(count--)
{
const Vec3& v = *reinterpret_cast<const Vec3*>(reinterpret_cast<const U8*>(begin) + stride * count);
for(U i = 0; i < 3; ++i)
{
minv[i] = min(minv[i], v[i]);
maxv[i] = max(maxv[i], v[i]);
}
}
m_aabb.setMin(minv.xyz0());
m_aabb.setMax(maxv.xyz0());
}
function dialog_say(int dialog)
{
if(dialogEntries[dialog].initialized == NULL) return;
proc_kill(4);
var soundID = -1;
if(dialogEntries[dialog].sound != NULL)
{
soundID = snd_play(dialogEntries[dialog].sound, 100, 0);
}
set(dialogText, SHOW);
(dialogText->pstring)[0] = dialogEntries[dialog].text;
dialogText->alpha = 0;
var timer = 32;
while(timer > 0 || snd_playing(soundID))
{
dialogText->pos_x = 0.5 * screen_size.x;
dialogText->pos_y = screen_size.y - 64;
if(timer > 8)
{
dialogText->alpha = minv(100, dialogText->alpha + 12 * time_step);
}
else
{
dialogText->alpha = maxv(0, dialogText->alpha - 12 * time_step);
}
if(!snd_playing(soundID))
timer -= time_step;
wait(1);
}
reset(dialogText, SHOW);
dialogText->alpha = 0;
}
//---------------------------------------------------------------------------
long double TMatrix::Inverse()
{
if (sizeV != sizeH)
throw Exception("Попытка обратить неквадратную матрицу!");
return minv (mat, sizeV);
}
GraphData * ProcWave2Data(QString fname)
{
SPTK_SETTINGS * sptk_settings = SettingsDialog::getSPTKsettings();
QFile file(fname);
file.open(QIODevice::ReadOnly);
WaveFile * waveFile = waveOpenHFile(file.handle());
qDebug() << "waveOpenFile" << LOG_DATA;
int size = littleEndianBytesToUInt32(waveFile->dataChunk->chunkDataSize);
qDebug() << "chunkDataSize" << LOG_DATA;
short int bits = littleEndianBytesToUInt16(waveFile->formatChunk->significantBitsPerSample);
qDebug() << "significantBitsPerSample" << LOG_DATA;
vector wave = sptk_v2v(waveFile->dataChunk->waveformData, size, bits);
qDebug() << "wave" << LOG_DATA;
vector frame = sptk_frame(wave, sptk_settings->frame);
qDebug() << "frame" << LOG_DATA;
vector intensive = vector_intensive(frame, sptk_settings->frame->leng, sptk_settings->frame->shift);
qDebug() << "intensive" << LOG_DATA;
vector window = sptk_window(frame, sptk_settings->window);
qDebug() << "window" << LOG_DATA;
vector lpc = sptk_lpc(frame, sptk_settings->lpc);
qDebug() << "lpc" << LOG_DATA;
vector spec = sptk_spec(lpc, sptk_settings->spec);
qDebug() << "spec " << maxv(spec) << LOG_DATA;
vector spec_proc;
if (sptk_settings->spec->proc == 0){
spec_proc = vector_pow_log(spec, sptk_settings->spec->factor, sptk_settings->spec->min);
qDebug() << "spec_log" << LOG_DATA;
} else if (sptk_settings->spec->proc == 1){
spec_proc = vector_pow_exp(spec, sptk_settings->spec->factor, sptk_settings->spec->min);
qDebug() << "spec_exp" << LOG_DATA;
}
qDebug() << "spec_proc " << maxv(spec_proc) << LOG_DATA;
vector pitch = processZeros(sptk_pitch_spec(wave, sptk_settings->pitch, intensive.x));
qDebug() << "pitch" << LOG_DATA;
vector mask = getFileMask(waveFile, wave, pitch.x);
qDebug() << "mask" << LOG_DATA;
vector pitch_cutted = processZeros(vector_cut_by_mask(pitch, mask));
qDebug() << "pitch_cutted" << LOG_DATA;
double pitch_min = getv(pitch_cutted, minv(pitch_cutted));
double pitch_max = getv(pitch_cutted, maxv(pitch_cutted));
vector intensive_cutted = vector_cut_by_mask(intensive, mask);
qDebug() << "intensive_cutted" << LOG_DATA;
vector inverted_mask = vector_invert_mask(mask);
qDebug() << "inverted_mask" << LOG_DATA;
vector pitch_interpolate = vector_interpolate_by_mask(
pitch_cutted,
inverted_mask,
0,
sptk_settings->plotF0->interpolation_type
);
qDebug() << "pitch_interpolate" << LOG_DATA;
vector intensive_interpolate = vector_interpolate_by_mask(
intensive_cutted,
inverted_mask,
0,
sptk_settings->plotEnergy->interpolation_type
);
qDebug() << "intensive_interpolate" << LOG_DATA;
vector pitch_mid = vector_smooth_mid(pitch_interpolate, sptk_settings->plotF0->frame);
qDebug() << "pitch_mid" << LOG_DATA;
vector intensive_mid = vector_smooth_lin(intensive_interpolate, sptk_settings->plotEnergy->frame);
qDebug() << "intensive_mid" << LOG_DATA;
vector norm_wave = normalizev(wave, 0.0, 1.0);
MaskData md_p = getLabelsFromFile(waveFile, MARK_PRE_NUCLEUS);
MaskData md_n = getLabelsFromFile(waveFile, MARK_NUCLEUS);
MaskData md_t = getLabelsFromFile(waveFile, MARK_POST_NUCLEUS);
vector p_mask = readMaskFromFile(waveFile, wave.x, MARK_PRE_NUCLEUS);
qDebug() << "p_mask" << LOG_DATA;
vector n_mask = readMaskFromFile(waveFile, wave.x, MARK_NUCLEUS);
qDebug() << "n_mask" << LOG_DATA;
vector t_mask = readMaskFromFile(waveFile, wave.x, MARK_POST_NUCLEUS);
qDebug() << "t_mask" << LOG_DATA;
vector p_wave = zero_to_nan(vector_cut_by_mask(norm_wave, p_mask));
qDebug() << "p_mask" << LOG_DATA;
vector n_wave = zero_to_nan(vector_cut_by_mask(norm_wave, n_mask));
qDebug() << "n_mask" << LOG_DATA;
vector t_wave = zero_to_nan(vector_cut_by_mask(norm_wave, t_mask));
qDebug() << "t_mask" << LOG_DATA;
vector pnt_mask = onesv(norm_wave.x);
for (int i=0; i<p_mask.x && i<n_mask.x && i<t_mask.x && i<norm_wave.x; i++) {
if (getv(p_mask, i) == 1 || getv(n_mask, i) == 1 || getv(t_mask, i) == 1)
{
setv(pnt_mask, i, 0);
} else {
setv(pnt_mask, i, 1);
}
}
vector display_wave = zero_to_nan(vector_cut_by_mask(norm_wave, pnt_mask));
freev(frame);
freev(window);
freev(lpc);
freev(pitch_cutted);
freev(intensive_cutted);
freev(inverted_mask);
freev(pitch_interpolate);
freev(intensive_interpolate);
freev(wave);
qDebug() << "freev" << LOG_DATA;
file.close();
waveCloseFile(waveFile);
qDebug() << "waveCloseFile" << LOG_DATA;
GraphData * data = new GraphData();
data->d_full_wave = norm_wave;
data->d_wave = display_wave;
data->d_p_wave = p_wave;
data->d_n_wave = n_wave;
data->d_t_wave = t_wave;
data->d_pitch_original = pitch;
data->d_pitch = pitch_mid;
data->pitch_max = pitch_max;
data->pitch_min = pitch_min;
data->d_intensive_original = intensive;
data->d_intensive = intensive_mid;
data->d_spec_proc = spec_proc;
data->d_spec = spec;
data->d_mask = mask;
data->p_mask = p_mask;
data->n_mask = n_mask;
data->t_mask = t_mask;
data->pnt_mask = pnt_mask;
data->md_p = md_p;
data->md_t = md_t;
data->md_n = md_n;
return data;
}
// Scale object boundings to [-5,5]
void DXFRenderer::NormalizeEntities()
{
// calculate current min and max boundings of object
DXFVector minv(10e20f, 10e20f, 10e20f);
DXFVector maxv(-10e20f, -10e20f, -10e20f);
for (DXFEntityList::compatibility_iterator node = m_entities.GetFirst(); node; node = node->GetNext())
{
DXFEntity *p = node->GetData();
if (p->type == DXFEntity::Line)
{
DXFLine *line = (DXFLine *)p;
const DXFVector *v[2] = { &line->v0, &line->v1 };
for (int i = 0; i < 2; ++i)
{
minv.x = mymin(v[i]->x, minv.x);
minv.y = mymin(v[i]->y, minv.y);
minv.z = mymin(v[i]->z, minv.z);
maxv.x = mymax(v[i]->x, maxv.x);
maxv.y = mymax(v[i]->y, maxv.y);
maxv.z = mymax(v[i]->z, maxv.z);
}
} else if (p->type == DXFEntity::Face)
{
DXFFace *face = (DXFFace *)p;
const DXFVector *v[4] = { &face->v0, &face->v1, &face->v2, &face->v3 };
for (int i = 0; i < 4; ++i)
{
minv.x = mymin(v[i]->x, minv.x);
minv.y = mymin(v[i]->y, minv.y);
minv.z = mymin(v[i]->z, minv.z);
maxv.x = mymax(v[i]->x, maxv.x);
maxv.y = mymax(v[i]->y, maxv.y);
maxv.z = mymax(v[i]->z, maxv.z);
}
}
}
// rescale object down to [-5,5]
DXFVector span(maxv.x - minv.x, maxv.y - minv.y, maxv.z - minv.z);
float factor = mymin(mymin(10.0f / span.x, 10.0f / span.y), 10.0f / span.z);
for (DXFEntityList::compatibility_iterator node2 = m_entities.GetFirst(); node2; node2 = node2->GetNext())
{
DXFEntity *p = node2->GetData();
if (p->type == DXFEntity::Line)
{
DXFLine *line = (DXFLine *)p;
DXFVector *v[2] = { &line->v0, &line->v1 };
for (int i = 0; i < 2; ++i)
{
v[i]->x -= minv.x + span.x/2; v[i]->x *= factor;
v[i]->y -= minv.y + span.y/2; v[i]->y *= factor;
v[i]->z -= minv.z + span.z/2; v[i]->z *= factor;
}
} else if (p->type == DXFEntity::Face)
{
DXFFace *face = (DXFFace *)p;
DXFVector *v[4] = { &face->v0, &face->v1, &face->v2, &face->v3 };
for (int i = 0; i < 4; ++i)
{
v[i]->x -= minv.x + span.x/2; v[i]->x *= factor;
v[i]->y -= minv.y + span.y/2; v[i]->y *= factor;
v[i]->z -= minv.z + span.z/2; v[i]->z *= factor;
}
}
}
}
void Cost::minv(uchar* _data,cv::Mat& _minIndex,cv::Mat& _minValue){
minv((float*)_data, _minIndex, _minValue);
}
int longest_palindrome_sub_string(char *str,unsigned int *lps,unsigned int *idx)
{
if(!lps || !idx) {
return 1;
}
unsigned int _len = strlen(str);
if(_len == 0) {
*lps = *idx = 0;
return 0;
}
int len = _len * 2 + 1;
char *s = (char*)malloc(len);
if(!s) {
return 1;
}
unsigned int *p = (unsigned int*)malloc(sizeof(unsigned int)*len);
if(!p) {
free(s);
return 1;
}
memset(p,0,sizeof(unsigned int)*len);
int i;
for(i=0;i<_len;i++) {
s[2*i] = '#';
s[2*i+1] = str[i];
}
s[len-1] = '#';
for(i=0;i<len;i++) {
printf("%c ",s[i]);
}
printf("\n");
unsigned int id = 0;
unsigned int mx = 0;
for(i=0;i<len;i++) {
p[i] = mx>i?minv(p[2*id-i],mx-i):1;
unsigned int lidx = i - p[i];
unsigned int ridx = i + p[i];
while(lidx >= 0 && ridx < len && s[lidx] == s[ridx]) {
p[i]++;
lidx = i - p[i];
ridx = i + p[i];
}
if(i+p[i] > mx) {
mx = i + p[i];
id = i;
}
}
unsigned int _idx = 0;
unsigned int _lps = 0;
for(i=0;i<len;i++) {
if(p[i] > _lps) {
_lps = p[i];
_idx = i;
}
printf("%d ",p[i]);
}
printf("\n");
*lps = _lps - 1;
*idx = (_idx-_lps)/2 + 1;
free(s);
free(p);
return 0;
}
void max_control ()
{
maxLimit = maxv ( minLimit, maxLimit );
nSlider = minv ( maxLimit, nSlider );
}
int matrixSelfInv(Mat m) {
if(minv(m.m, m.row, m.row) == NULL) {
return 1;
}
return 0;
}
/**
\brief Invert (in place) a general real matrix A -> Inv(A).
\param a = array containing the input matrix A. This is converted to the inverse matrix.
\param n = dimension of the system (i.e. A is n x n )
\return: 0 -> normal exit, 1 -> singular input matrix
*/
int G_math_minv(double **a,int n)
{
return minv(a[0], n);
}
/*! \brief
* Function that does the analysis for a single frame.
*
* It is called once for each frame.
*/
static int analyze_frame(t_topology *top, t_trxframe *fr, t_pbc *pbc,
int nr, gmx_ana_selection_t *sel[], void *data)
{
t_analysisdata *d = (t_analysisdata *)data;
t_electrostatics dat;
/* Print the current frame number to the xvg file */
if (d->fp) {
fprintf(d->fp, "%10i ", d->framen);
}
/* Index the pqr file to the frame number */
std::string pqrname(d->pqr);
pqrname = pqrname.substr(0,pqrname.size()-4);
std::stringstream pqr;
pqr << pqrname << d->framen << ".pqr";
FILE *pqrout;
if ( d->dopqr ) {
pqrout = ffopen(pqr.str().c_str(), "w");
if ( pqrout == NULL ) {
gmx_fatal(FARGS, "\nFailed to open output file, '%s'\n",pqrout);
}
}
/* Get the bond vector and bond midpoint */
rvec bondvector, midpoint;
rvec_sub(fr->x[d->a2],fr->x[d->a1],bondvector);
double bondlength = pow( iprod(bondvector,bondvector), 0.5);
for (int i=0; i<3; i++){
midpoint[i] = fr->x[d->a1][i] + 0.5 * bondvector[i];
}
/*
* Defined axes based on the nitrile bond vector
* The z-axis is the bond axis
* The y-axis is from solving y0 = -(z1*y1+z2*y2)/z0, where (y1,y2)=(z2,-z0), then normalizing
* The x-axis is the cross product of the y-axis with the z-axis
*/
double zvec[3] = { bondvector[0] / bondlength, bondvector[1] / bondlength, bondvector[2] / bondlength };
double yvec[3] = { 1, 1, 1 };
if (zvec[0] != 0 ) {
yvec[0] = -(zvec[1]*yvec[1]+zvec[2]*yvec[2]) / zvec[0] ; }
else if (zvec[1] != 0 ) {
yvec[1] = -(zvec[0]*yvec[0]+zvec[2]*yvec[2]) / zvec[1] ; }
else if (zvec[2] != 0 ) {
yvec[2] = -(zvec[0]*yvec[0]+zvec[1]*yvec[1]) / zvec[2] ; }
else {
std::cerr << "\nERROR! Bond length is 0! This cannoy be correct!\n";
std::cerr << "BondVEC: " << bondvector[0] << " " << bondvector[1] << " " << bondvector[2] << std::endl;
std::cerr << "ZVEC: " << zvec[0] << " " << zvec[1] << " " << zvec[2] << std::endl;
}
/* Normalize */
double ylen = pow(dot(yvec,yvec),0.5);
for (int i=0; i<3;i++) {
yvec[i] = yvec[i]/ylen;
}
double xvec[3];
cross(yvec,zvec,xvec);
double xlen = pow(dot(xvec,xvec),0.5);
for (int i=0; i<3;i++) {
xvec[i] = xvec[i]/xlen;
}
/* Find the points that are Cho group-sites for calculating the potential */
std::vector<std::vector<double> > each_point;
int nsites = 0;
if (d->site_ndx.size() > 0) {
/*
* There are 8 sites from -a1, 8 sites from -a2, 1 site along the bond vector
* and 1 site for each atom in site_ndx
*/
nsites = d->site_ndx.size() + 17;
int n = 0;
each_point = std::vector<std::vector<double> > (nsites, std::vector<double> (3,0));
//std::vector<std::vector<double> > each_point(nsites,std::vector<double> (3,0));
/* Assign coordinates for the atoms in site_ndx */
for (int i=0; i<(int)d->site_ndx.size(); i++) {
for (int j=0; j<3; j++) {
each_point[n][j] = fr->x[d->site_ndx[i]][j];
}
n++;
}
/* Assign coordinate for the site along the bond vector */
for (int i=0; i<3; i++) {
each_point[n][i] = fr->x[d->a2][i] + bondvector[i] / bondlength * d->ring_dist;
}
n++;
/* 8 points around -a1 */
ring_points( fr->x[d->a1], &xvec[0], &yvec[0], &zvec[0], d->ring_dist, each_point,n);
/* 8 points around -a2 */
ring_points( fr->x[d->a2], &xvec[0], &yvec[0], &zvec[0], d->ring_dist, each_point,n);
std::vector<double> minv(3,10);
std::vector<double> maxv(3,-10);
}
/* Find the dummy atom points */
/* midpoint xyz vectors */
double pzcomp[3], nzcomp[3], pycomp[3], nycomp[3], pxcomp[3], nxcomp[3];
/* -a1 xyz vectors */
double pzcomp1[3], nzcomp1[3], pycomp1[3], nycomp1[3], pxcomp1[3], nxcomp1[3];
/* -a2 xyz vectors */
double pzcomp2[3], nzcomp2[3], pycomp2[3], nycomp2[3], pxcomp2[3], nxcomp2[3];
for (int i=0; i<3; i++) {
/* midpoint xyz vectors */
pzcomp[i] = midpoint[i] + zvec[i] * d->delta;
nzcomp[i] = midpoint[i] - zvec[i] * d->delta;
pycomp[i] = midpoint[i] + yvec[i] * d->delta;
nycomp[i] = midpoint[i] - yvec[i] * d->delta;
pxcomp[i] = midpoint[i] + xvec[i] * d->delta;
nxcomp[i] = midpoint[i] - xvec[i] * d->delta;
/* -a1 xyz vectors */
pzcomp1[i] = fr->x[d->a1][i] + zvec[i] * d->delta;
nzcomp1[i] = fr->x[d->a1][i] - zvec[i] * d->delta;
pycomp1[i] = fr->x[d->a1][i] + yvec[i] * d->delta;
nycomp1[i] = fr->x[d->a1][i] - yvec[i] * d->delta;
pxcomp1[i] = fr->x[d->a1][i] + xvec[i] * d->delta;
nxcomp1[i] = fr->x[d->a1][i] - xvec[i] * d->delta;
/* -a2 xyz vectors */
pzcomp2[i] = fr->x[d->a2][i] + zvec[i] * d->delta;
nzcomp2[i] = fr->x[d->a2][i] - zvec[i] * d->delta;
pycomp2[i] = fr->x[d->a2][i] + yvec[i] * d->delta;
nycomp2[i] = fr->x[d->a2][i] - yvec[i] * d->delta;
pxcomp2[i] = fr->x[d->a2][i] + xvec[i] * d->delta;
nxcomp2[i] = fr->x[d->a2][i] - xvec[i] * d->delta;
}
/* Write all the dummy atoms to the pqr file */
if ( d->dopqr ) {
write_dummy_atom( pqrout, nzcomp, "MIDz" );
write_dummy_atom( pqrout, pzcomp, "MIDz" );
write_dummy_atom( pqrout, nycomp, "MIDy" );
write_dummy_atom( pqrout, pycomp, "MIDy" );
write_dummy_atom( pqrout, nxcomp, "MIDx" );
write_dummy_atom( pqrout, pxcomp, "MIDx" );
write_dummy_atom( pqrout, nzcomp1, (std::string)*top->atoms.atomname[d->a1]+"z" );
write_dummy_atom( pqrout, pzcomp1, (std::string)*top->atoms.atomname[d->a1]+"z" );
write_dummy_atom( pqrout, nycomp1, (std::string)*top->atoms.atomname[d->a1]+"y" );
write_dummy_atom( pqrout, pycomp1, (std::string)*top->atoms.atomname[d->a1]+"y" );
write_dummy_atom( pqrout, nxcomp1, (std::string)*top->atoms.atomname[d->a1]+"x" );
write_dummy_atom( pqrout, pxcomp1, (std::string)*top->atoms.atomname[d->a1]+"x" );
write_dummy_atom( pqrout, nzcomp2, (std::string)*top->atoms.atomname[d->a2]+"z" );
write_dummy_atom( pqrout, pzcomp2, (std::string)*top->atoms.atomname[d->a2]+"z" );
write_dummy_atom( pqrout, nycomp2, (std::string)*top->atoms.atomname[d->a2]+"y" );
write_dummy_atom( pqrout, pycomp2, (std::string)*top->atoms.atomname[d->a2]+"y" );
write_dummy_atom( pqrout, nxcomp2, (std::string)*top->atoms.atomname[d->a2]+"x" );
write_dummy_atom( pqrout, pxcomp2, (std::string)*top->atoms.atomname[d->a2]+"x" );
if (d->site_ndx.size() > 0) {
for (int i=0; i<nsites; i++) {
std::stringstream key;
key << "p" << i;
write_dummy_atom( pqrout, &each_point[i][0], key.str());
}
}
}
/* Initialize all the electrostatics, since they are the result of summing parts */
int nexclude = d->exclude_ndx.size();
dat.field_proj_total = 0.0f;
dat.field_proj_each_exclude = std::vector<double> (nexclude,0.0f);
dat.field_each_exclude = std::vector<std::vector<double> > (nexclude, std::vector<double> (3,0));
dat.field_proj_exclude = 0.0f;
for (int i=0; i<3; i++){
dat.field_exclude[i] = 0.0f;
dat.field_mid[i] = 0.0f;
dat.field_a1[i] = 0.0f;
dat.field_a2[i] = 0.0f;
}
dat.protein_site = std::vector<double> (nsites, 0.0f);
dat.water_site = std::vector<double> (nsites, 0.0f);
int g = 0;
int nresidues = top->atoms.atom[sel[g]->g->index[sel[g]->p.nr]].resind;
std::vector<float> field_per_residue (nresidues,0.0f);
int nwater=0;
/* Loop through everything */
for (int g = 0; g < nr; ++g) { // for each group
if (g > 1) {
fprintf(stderr,"\nWarning: More than 1 group was specified. Cowardly ignoring all additional groups\n");
break;
}
for (int i = 0; i < sel[g]->p.nr; ++i) { // for each atom in the group
int atom_ndx = sel[g]->g->index[i]; // how we get to the atom index
/* Get .dat parameters and write the atom to the .pqr file */
int resid = top->atoms.atom[atom_ndx].resind;
double charge = top->atoms.atom[atom_ndx].q;
char *atomname = *top->atoms.atomname[atom_ndx];
char *resname = *top->atoms.resinfo[resid].name;
double radius = -1;
int namber = d->amber.size();
for (int j=0; j<namber; j++) {
if (d->bVerbose) {
fprintf(stderr, "\nTrying to match: %s %s to %s (%d/%d)", resname, *top->atoms.atomtype[atom_ndx], d->amber[j].ambername, j, namber);
}
if ( strncmp(*top->atoms.atomtype[atom_ndx], d->amber[j].ambername, strlen(*top->atoms.atomtype[atom_ndx])+1) == 0 ) {
radius = d->amber[j].radius;
if (d->bVerbose) {
fprintf(stderr,"\nMatched %s on %s to %s! (%d/%d)",resname, *top->atoms.atomtype[atom_ndx], d->amber[j].ambername, j, namber);
}
break;
}
}
if (radius < 0) {
fprintf(stderr,"\nError: Frame %d, could not match %s %s %s %i\n",d->framen, atomname, resname, *top->atoms.atomtype[atom_ndx],i+1);
std::exit(1);
}
if ( d->dopqr ) {
fprintf(pqrout,"ATOM %6i %4s %4s %5i %11.3f %7.3f %7.3f %7.4f %7.3f\n",atom_ndx+1,atomname,resname,resid+1,fr->x[atom_ndx][XX]*10,fr->x[atom_ndx][YY]*10,fr->x[atom_ndx][ZZ]*10,charge,radius);
}
/* Do the field calculations now */
bool keepAtom = true;
std::vector<double> anatom (3,0.0f);
calculate_field(midpoint, atom_ndx, *top, *fr, &anatom[0], 1);
for (int j=0; j<nexclude; j++) {
if (atom_ndx == d->exclude_ndx[j]) {
keepAtom = false;
break;
}
}
if (keepAtom) {
field_per_residue[resid] += d->rpdie * project_field(bondvector,&anatom[0]);
}
for (int j=0; j<3; j++) {
dat.field_mid[j] += anatom[j];
}
/* Get the field due to each excluded atom */
keepAtom = true;
for (int j=0; j<nexclude ; j++) {
if (atom_ndx == d->exclude_ndx[j]) {
calculate_field(midpoint, d->exclude_ndx[j], *top, *fr, &dat.field_each_exclude[j][0], 1);
keepAtom = false;
break;
}
}
if (keepAtom) {
calculate_field(midpoint, atom_ndx, *top, *fr, dat.field_exclude, 1);
calculate_field(fr->x[d->a1], atom_ndx, *top, *fr, dat.field_a1, 1);
calculate_field(fr->x[d->a2], atom_ndx, *top, *fr, dat.field_a2, 1);
}
//d->field_per_residue[resid] += d->rpdie * project_field(
/* Do the potential calculations now */
/* We want to exclude atoms at the sites */
/* We are also going to exclude atoms in the exclude group */
if ((int)d->site_ndx.size() > 0) {
if (keepAtom) {
for (int j=0; j<(int)d->site_ndx.size(); j++) {
if (atom_ndx == d->site_ndx[j] ) {
keepAtom = false;
break;
}
}
}
if (keepAtom) {
if (strncmp("SOL", resname, sizeof(resname)+1) == 0 ||
strncmp("HOH", resname, sizeof(resname)+1) == 0 ) {
for (int j=0; j<nsites; j++) {
double r = calculate_r( &each_point[j][0], atom_ndx, *top, *fr);
dat.water_site[j] += calculate_potential( r, atom_ndx, *top, *fr);
}
nwater++;
}
else {
for (int j=0; j<nsites; j++) {
double r = calculate_r( &each_point[j][0], atom_ndx, *top, *fr);
dat.protein_site[j] += calculate_potential( r, atom_ndx, *top, *fr);
}
}
}
}
}
}
/* Write all output to xvg file */
if (d->fp) {
fprintf(d->fp, "%.6e ", d->rpdie * project_field(bondvector, dat.field_mid));
for (int i=0; i<nexclude; i++) {
fprintf(d->fp, "%.6e ", d->rpdie * project_field(bondvector, &dat.field_each_exclude[i][0]));
}
fprintf(d->fp, "%.6e ", d->rpdie * project_field(bondvector, dat.field_exclude));
fprintf(d->fp, "%.6e ", d->rpdie * project_field(xvec,dat.field_exclude));
fprintf(d->fp, "%.6e ", d->rpdie * project_field(yvec,dat.field_exclude));
fprintf(d->fp, "%.6e ", d->rpdie * project_field(zvec,dat.field_exclude));
fprintf(d->fp, "%.6e ", d->rpdie * project_field(xvec,dat.field_a1));
fprintf(d->fp, "%.6e ", d->rpdie * project_field(yvec,dat.field_a1));
fprintf(d->fp, "%.6e ", d->rpdie * project_field(zvec,dat.field_a1));
fprintf(d->fp, "%.6e ", d->rpdie * project_field(xvec,dat.field_a2));
fprintf(d->fp, "%.6e ", d->rpdie * project_field(yvec,dat.field_a2));
fprintf(d->fp, "%.6e ", d->rpdie * project_field(zvec,dat.field_a2));
if ((int)d->site_ndx.size() > 0) {
for (int i=0; i<nsites; i++) {
fprintf(d->fp, "%.6e %.6e ", d->rpdie * dat.protein_site[i], d->rpdie * dat.water_site[i]);
}
}
fprintf(d->fp, "\n");
}
/* close the pqr file */
if ( d->dopqr ) {
fclose(pqrout);
}
/* Print the current frame number to the xvg file */
if (d->fpr) {
fprintf(d->fpr, "%10i ", d->framen);
for (int i=0;i<nresidues;i++) {
fprintf(d->fpr,"%12.6e ",field_per_residue[i]);
}
fprintf(d->fpr,"\n");
}
/* increment the frame number */
d->framen++;
/* We need to return 0 to tell that everything went OK */
return 0;
}
// from mSelfInv.c
int selfInv(ARMat *m) {
if (minv(m->m, m->row, m->row) == NULL)
return -1;
return 0;
}
