static float Dot_prod (const float x1, const char x2,
const float y1, const char y2,
const float z1, const char z2,
const float t1, const char t2)
{
return (Prod (x1, x2) + Prod (y1, y2) + Prod (z1, z2) + Prod (t1, t2));
}
void LayerFull::WeightGrads(Layer *prev_layer, GradInd gradind) {
if (gradind == GradInd::First) {
Prod(deriv_mat_, true, prev_layer->activ_mat_, false, filters_.der());
filters_.der() *= (lr_coef_ / dims_[0]);
} else if (gradind == GradInd::Second) {
Prod(deriv_mat_, true, prev_layer->activ_mat_, false, filters_.der2());
filters_.der2() *= (lr_coef_ / dims_[0]);
}
}
template<> RotMatrix<3>& RotMatrix<3>::fromQuaternion(const Quaternion& q,
const bool not_flip)
{
CoordType xx, yy, zz, xy, xz, yz;
const Vector<3> &vref = q.vector();
xx = vref[0] * vref[0];
xy = vref[0] * vref[1];
xz = vref[0] * vref[2];
yy = vref[1] * vref[1];
yz = vref[1] * vref[2];
zz = vref[2] * vref[2];
Vector<3> wvec = vref * q.scalar();
m_elem[0][0] = 1 - 2 * (yy + zz);
m_elem[1][1] = 1 - 2 * (xx + zz);
m_elem[2][2] = 1 - 2 * (xx + yy);
m_elem[0][1] = 2 * (xy + wvec[2]);
m_elem[0][2] = 2 * (xz - wvec[1]);
m_elem[1][0] = 2 * (xy - wvec[2]);
m_elem[1][2] = 2 * (yz + wvec[0]);
m_elem[2][0] = 2 * (xz + wvec[1]);
m_elem[2][1] = 2 * (yz - wvec[0]);
m_flip = !not_flip;
m_age = q.age();
if(!not_flip)
*this = Prod(*this, RotMatrix<3>().mirror(0));
m_valid = true;
return *this;
}
void PrelucrareArbore(struct TNod *lel){
char * a=lel->info;
lel->rez = (double*)malloc(sizeof(double));
if(strcmp(a,"+")==0){
Add(lel->st,lel->dr,lel);
}else if(strcmp(a,"-")==0){
Sub(lel->st,lel->dr,lel);
}else if(strcmp(a,"*")==0){
Mult(lel->st, lel->dr,lel);
}else if(strcmp(a,"/")==0){
Divi(lel->st, lel->dr,lel);
}else if(strcmp(a,"sum")==0){
Sum(lel);
//printf("PrelArb %lf\n",*(lel->rez));
}else if(strcmp(a,"prod")==0){
Prod(lel);
}else if(strcmp(a,"sqrt")==0){
SqrtCalc(lel->st,lel->dr,lel);
}else if(strcmp(a,"pow")==0){
PowCalc(lel->st, lel->dr,lel);
}else{
*(lel->rez) = (double)atoi(a);
//printf("ATOI %lf\n",*(lel->rez));
}
}
inline OpenSMOKEVector<T, IndexPolicy>& OpenSMOKEVector<T, IndexPolicy>::operator /=(T const& rval)
{
if (rval==0)
ErrorMessage("operator/=(T const& rval) Division by zero");
Prod(dimensions_ , 1./rval, vector_+this->index_);
return *this;
}
VColor TwoField::operator () (MPoint point) const
{
DCoord P=Prod(point-a,b);
if( P<=0 ) return va;
if( P>=D ) return vb;
return Linear(va,vb,d(uDCoord(P)),d);
}
void LayerFull::Backward(Layer *prev_layer) {
StartTimer();
prev_layer->deriv_mat_.resize(prev_layer->batchsize_, prev_layer->length_);
Prod(deriv_mat_, false, weights_.get(), false, prev_layer->deriv_mat_);
if (prev_layer->type_ == "f") {
LayerFull *layerfull = static_cast<LayerFull*>(prev_layer);
if (layerfull->dropout_ > 0) {
layerfull->deriv_mat_ *= layerfull->dropmat_;
}
}
prev_layer->deriv_mat_.Validate();
MeasureTime("Backwards Full Layer",4);
}
void LayerFull::Forward(Layer *prev_layer, int passnum) {
StartTimer();
batchsize_ = prev_layer->batchsize_;
if (passnum == 3) {
Swap(activ_mat_, first_mat_);
}
activ_mat_.resize(batchsize_, length_);
Prod(prev_layer->activ_mat_, false, weights_.get(), true, activ_mat_);
if (passnum == 0 || passnum == 1) {
activ_mat_.AddVect(biases_.get(), 1);
}
if (dropout_ > 0) { // dropout
if (passnum == 1) {
dropmat_.resize(batchsize_, length_);
dropmat_.rand();
dropmat_.CondAssign(dropmat_, false, dropout_, 0);
dropmat_.CondAssign(dropmat_, true, 0, 1);
activ_mat_ *= dropmat_;
} else if (passnum == 3) {
activ_mat_ *= dropmat_;
} else if (passnum == 0) {
activ_mat_ *= (1 - dropout_);
}
}
activ_mat_.Validate();
/*
if (print == 1) {
mexPrintMsg("FULL");
Mat m;
m.attach(activ_mat_);
mexPrintMsg("s1", m.size1());
mexPrintMsg("s2", m.size2());
mexPrintMsg("totalsum", m.sum());
Mat versum = Sum(m, 1);
for (int i = 0; i < 5; ++i) {
mexPrintMsg("versum", versum(0, i));
}
Mat horsum = Sum(m, 2);
for (int i = 0; i < 5; ++i) {
mexPrintMsg("horsum", horsum(i, 0));
}
for (int i = 0; i < 5; ++i) {
mexPrintMsg("Horizontal", m(0, i));
}
for (int i = 0; i < 5; ++i) {
mexPrintMsg("Vertical", m(i, 0));
}
}*/
MeasureTime("Forwards Full Layer",3);
}
TwoField::TwoField(MPoint a_,VColor va_,MPoint b_,VColor vb_)
: a(a_),
va(va_),
b(b_),
vb(vb_)
{
b-=a;
D=Prod(b,b);
IntGuard( D>0 );
d.init(uDCoord(D));
}
bool Quaternion::fromRotMatrix(const RotMatrix<3>& m)
{
RotMatrix<3> m_tmp;
bool not_flip = !m.parity();
m_valid = m.isValid();
m_vec.setValid(m.isValid());
if(!not_flip)
m_tmp = Prod(m, RotMatrix<3>().mirrorX());
const RotMatrix<3> &m_ref = not_flip ? m : m_tmp;
CoordType s;
const int nxt[3] = {1, 2, 0};
CoordType tr = m_ref.trace();
// check the diagonal
if (tr > 0.0) {
s = std::sqrt(tr + 1.0f);
m_w = (s / 2.0f);
s = (0.5f / s);
m_vec[0] = -(m_ref.elem(2, 1) - m_ref.elem(1, 2)) * s;
m_vec[1] = -(m_ref.elem(0, 2) - m_ref.elem(2, 0)) * s;
m_vec[2] = -(m_ref.elem(1, 0) - m_ref.elem(0, 1)) * s;
} else {
// diagonal is negative
int i = 0;
if (m_ref.elem(1, 1) > m_ref.elem(0, 0)) i = 1;
if (m_ref.elem(2, 2) > m_ref.elem(i, i)) i = 2;
int j = nxt[i], k = nxt[j];
s = std::sqrt (1.0f + m_ref.elem(i, i) - m_ref.elem(j, j) - m_ref.elem(k, k));
m_vec[i] = -(s * 0.5f);
assert("sqrt() returns positive" && s > 0.0);
s = (0.5f / s);
m_w = (m_ref.elem(k, j) - m_ref.elem(j, k)) * s;
m_vec[j] = -(m_ref.elem(i, j) + m_ref.elem(j, i)) * s;
m_vec[k] = -(m_ref.elem(i, k) + m_ref.elem(k, i)) * s;
}
m_age = m.age();
return not_flip;
}
void LayerFull::CalcWeights(Layer *prev_layer, int passnum) {
StartTimer();
if (passnum < 2) return;
Mat weights_der;
if (passnum == 2) {
weights_der.attach(weights_.der());
} else if (passnum == 3) {
weights_der.attach(weights_.der2());
}
Prod(deriv_mat_, true, prev_layer->activ_mat_, false, weights_der);
if (passnum == 2) {
Mean(deriv_mat_, biases_.der(), 1);
biases_.der() *= bias_coef_;
biases_.der().Validate();
}
weights_der /= (ftype) batchsize_;
weights_der.Validate();
MeasureTime("CalcWeights Full Layer",5);
}
void Prod(const Mat &a, bool a_tr, const Mat &b, bool b_tr, Mat &c) {
Mat m; // empty mask matrix;
Prod(a, a_tr, b, b_tr, m, c);
}
void LayerFull::TransformBackward(Layer *prev_layer) {
Prod(deriv_mat_, false, filters_.get(), false, prev_layer->deriv_mat_);
prev_layer->deriv_mat_.Validate();
}
void LayerFull::TransformForward(Layer *prev_layer, PassNum passnum) {
Prod(prev_layer->activ_mat_, false, filters_.get(), true, activ_mat_);
activ_mat_.Validate();
}
EXPORT void g_verbose_fprint_state(
FILE *file,
const char *name,
Locstate state)
{
bool bin_out;
int i, dim;
float p, c, S, v[SMAXD], speed;
static char vname[3][3] = { "vx", "vy", "vz"};
static char mname[3][3] = { "mx", "my", "mz"};
if (name == NULL)
name = "";
(void) fprintf(file,"\n%s:\n",name);
(void) fprintf(file,"address %p\n",state);
if (state == NULL || is_obstacle_state(state))
{
(void) fprintf(file,"(OBSTACLE STATE)\n\n");
return;
}
dim = Params(state)->dim;
p = pressure(state);
c = sound_speed(state);
S = entropy(state);
(void) fprintf(file,"%-24s = %-"FFMT" %-24s = %-"FFMT"\n",
"density",Dens(state),
"specific internal energy",
specific_internal_energy(state));
(void) fprintf(file,"%-24s = %-"FFMT" %-24s = %-"FFMT"\n","pressure",p,
"sound speed",c);
(void) fprintf(file,"%-24s = %-"FFMT" %-24s = %-"FFMT"\n","temperature",
temperature(state),"specific entropy",S);
speed = 0.0;
for (i = 0; i < dim; i++)
{
v[i] = vel(i,state); speed += sqr(v[i]);
(void) fprintf(file,"%-24s = %-"FFMT" %-24s = %-"FFMT"\n",
mname[i],mom(i,state),vname[i],v[i]);
}
speed = sqrt(speed);
(void) fprintf(file,"%-24s = %-"FFMT"","total energy",energy(state));
if (c > 0. && Dens(state) > 0.)
(void) fprintf(file," %-24s = %-"FFMT"\n","Mach number",speed / c);
else
(void) fprintf(file,"\n");
#if defined(TWOD)
if (dim == 2)
(void) fprintf(file,"%-24s = %-"FFMT"\n","velocity angle",
degrees(angle(v[0],v[1])));
#endif /* defined(TWOD) */
fprint_state_type(file,"State type = ",state_type(state));
(void) fprintf(file,"Params state = %llu\n",
gas_param_number(Params(state)));
bin_out = is_binary_output();
set_binary_output(NO);
if (debugging("prt_params"))
fprint_Gas_param(file,Params(state));
else
(void) fprintf(file,"Gas_param = %llu\n",
gas_param_number(Params(state)));
set_binary_output(bin_out);
//if(p< -2000 || p>10000)
//{
// printf("#huge pressure\n");
// clean_up(0);
//}
#if !defined(COMBUSTION_CODE)
(void) fprintf(file,"\n");
#else /* !defined(COMBUSTION_CODE) */
if (Composition_type(state) == PURE_NON_REACTIVE)
{
(void) fprintf(file,"\n");
return;
}
(void) fprintf(file,"%-24s = %-12s %-24s = %-"FFMT"\n","burned",
Burned(state) ? "BURNED" : "UNBURNED",
"q",Params(state)->q);
(void) fprintf(file,"%-24s = %-"FFMT"\n","t_crit",
Params(state)->critical_temperature);
if (Composition_type(state) == PTFLAME)
{
(void) fprintf(file,"\n");
return;
}
(void) fprintf(file,"%-24s = %-"FFMT"\n","product density",Prod(state));
(void) fprintf(file,"%-24s = %-"FFMT"\n",
"reaction progress",React(state));
if (Composition_type(state) == ZND)
{
(void) fprintf(file,"\n");
return;
}
(void) fprintf(file,"%-24s = %-"FFMT"\n","rho1",Dens1(state));
#endif /* !defined(COMBUSTION_CODE) */
(void) fprintf(file,"%-24s = %-24s %-24s = %-"FFMT"\n\n","gamma_set",
Local_gamma_set(state)?"YES" : "NO","local_gamma",
Local_gamma(state));
if(g_composition_type() == MULTI_COMP_NON_REACTIVE)
{
if(Params(state) != NULL &&
Params(state)->n_comps != 1)
{
for(i = 0; i < Params(state)->n_comps; i++)
(void) fprintf(file,"partial density[%2d] = %"FFMT"\n",
i,pdens(state)[i]);
(void) fprintf(file,"\n");
/* TMP the following print is for the debuging display purpose */
for(i = 0; i < Params(state)->n_comps; i++)
(void) fprintf(file,"[%d]Mass fraction = %-"FFMT"\n",
i, pdens(state)[i]/Dens(state));
(void) fprintf(file,"\n");
}
}
} /*end g_verbose_fprint_state*/
EXPORT void g_fprint_state(
FILE *file,
Locstate state)
{
int dim;
if (is_obstacle_state(state))
{
(void) fprintf(file,"state %p (OBSTACLE STATE)\n\n",state);
return;
}
if (current_interface())
dim = current_interface()->dim;
else
dim = Params(state)->dim;
g_fprint_raw_state(file,state,dim);
#if !defined(COMBUSTION_CODE)
(void) fprintf(file,"\n");
#else /* !defined(COMBUSTION_CODE) */
if (Composition_type(state) == PURE_NON_REACTIVE)
{
(void) fprintf(file,"\n");
return;
}
(void) fprintf(file,"burned = %s q = %"FFMT" t_crit = %"FFMT"\n",
Burned(state)? "BURNED" : "UNBURNED",
Params(state)->q,
Params(state)->critical_temperature);
if ((Composition_type(state) == PTFLAME) ||
(Composition_type(state) == THINFLAME))
{
(void) fprintf(file,"\n");
return;
}
(void) fprintf(file,"product density = %"FFMT"\n",Prod(state));
if (Composition_type(state) == ZND)
{
(void) fprintf(file,"\n");
return;
}
(void) fprintf(file," rho1 = %"FFMT"\n\n",Dens1(state));
#endif /* !defined(COMBUSTION_CODE) */
(void) fprintf(file,"%-24s = %-24s %-24s = %-"FFMT"\n\n","gamma_set",
Local_gamma_set(state)?"YES" : "NO","local_gamma",
Local_gamma(state));
if(g_composition_type() == MULTI_COMP_NON_REACTIVE)
{
if(Params(state) != NULL &&
Params(state)->n_comps != 1)
{
int i;
for(i = 0; i < Params(state)->n_comps; i++)
(void) fprintf(file,"partial density[%2d] = %"FFMT"\n",
i,pdens(state)[i]);
(void) fprintf(file,"\n");
}
}
} /*end g_fprint_state*/
inline OpenSMOKEVector<T, IndexPolicy>& OpenSMOKEVector<T, IndexPolicy>::operator *=(T const& rval)
{
Prod(dimensions_ , rval, vector_+this->index_);
return *this;
}
inline const
Prod operator*(const float c, const E& v) {return Prod(c,v);}
GFA::Tuple GFA::Tuple::operator*(const Scalar &rhs) const
{
Tuple temp;
Prod(temp, rhs);
return temp;
}
