int main(int argc, char *argv[]) {
// poczatkowo pusta lista
struct Lista* MojaLista=NULL;
struct Lista* MojaLista1=NULL;
struct Lista* MojaLista2=NULL;
int i;
for(i=1;i<11;i++) MojaLista=dodaj(MojaLista,i,i);
for(i=11;i<21;i++) MojaLista1=dodaj(MojaLista1,i,i);
for(i=21;i<31;i++) MojaLista2=dodaj(MojaLista2,i,i);
printf("wypelniamy wszystkie 3 listy i wyswietlamy\n");
printf("lista1\n");
wyswietl(MojaLista);
printf("lista2\n");
wyswietl(MojaLista1);
printf("lista3\n");
wyswietl(MojaLista2);
printf("szukamy jakas wartosc w liscie\n");
szukaj(MojaLista,1.0,1.0);
szukaj(MojaLista,12,14);
printf("usuwamy jakas wartosc w liscie\n");
MojaLista=usun(MojaLista,1,1);
MojaLista=usun(MojaLista,10,10);
MojaLista=usun(MojaLista,5,5);
printf("scalamy liste 2 i 3 z zapisem w 1 oraz kasowaniem list\n");
MojaLista=scal(MojaLista,MojaLista1,MojaLista2);
MojaLista1=kasuj(MojaLista1);
MojaLista2=kasuj(MojaLista2);
wyswietl(MojaLista);
wyswietl(MojaLista1);
wyswietl(MojaLista2);
return 0;
}
Pt3dr cMEPCoCentrik::ComputeBase()
{
Pt3dr aBest(0,0,0);
double aScoreMin = 1e20;
for (int aK1=0 ; aK1<int(mVPlanBase.size()); aK1++)
{
Pt3dr aCdtBase = mVPlanBase[aK1];
double aScore = 0;
for (int aK2=0 ; aK2<int(mVPlanBase.size()); aK2++)
{
Pt3dr aP2 = mVPlanBase[aK2];
if (scal(aP2,aCdtBase) < 0) aP2 = -aP2;
double aDist = euclid(aP2-aCdtBase);
aDist = CoutAttenueTetaMax(aDist,0.3);
aScore += aDist;
}
if (aScore < aScoreMin)
{
aScoreMin = aScore;
aBest = aCdtBase;
}
}
return aBest;
}
void cASAMG::ComputeIncidAngle3D()
{
cRawNuage aRN = mStdN->GetRaw();
Pt2di aP0;
Im2D_Bits<1> aMasqTmp = ImMarqueurCC(mSz);
TIm2DBits<1> aTMasqTmp(aMasqTmp);
for (aP0.x=0 ; aP0.x<mSz.x ; aP0.x++)
{
for (aP0.y=0 ; aP0.y<mSz.y ; aP0.y++)
{
double Angle = 1.5;
if (mTMasqN.get(aP0))
{
cCalcPlanEuclid aCalcPl(CCDist(),aRN);
int aNb = OneZC(aP0,CCV4(),aTMasqTmp,1,0,mTMasqN,1,aCalcPl);
ResetMarqueur(aTMasqTmp,aCalcPl.mVPts);
if (aNb >= SeuimNbPtsCCDist())
{
cElPlan3D aPlan(aCalcPl.mVP3,0);
// ElSeg3D aSeg(aC0,mStdN->GetPt(aP0));
ElSeg3D aSeg = mStdN->FaisceauFromIndex(Pt2dr(aP0));
double aScal = scal(aPlan.Norm(),aSeg.TgNormee());
if (aScal<0) aScal = - aScal;
Angle = acos(ElMin(1.0,ElMax(-1.0,aScal)));
}
}
mTIncid.oset(aP0,ElMin(255,ElMax(0,round_ni(Angle*DynAng()))));
}
}
}
Pt3dr cElN3D_EpipGen<Type,TBase>::Loc_IndexAndProf2Euclid(const Pt2dr & anI,const double & anInvProf) const
{
if (mProfIsZ)
{
// std::cout << anInvProf << " " << anI << " " << this->mCam->F2AndZtoR3(anI,anInvProf) << "\n";
return this->mCam->F2AndZtoR3(anI,anInvProf);
}
double aProf = CorZInv(anInvProf);
if (mIsSpherik)
{
return mCS->ImEtProfSpherik2Terrain(anI,aProf);
}
ElSeg3D aSeg = this->mCam->F2toRayonR3(anI) ;
Pt3dr aRay =aSeg.Tgt();
Pt3dr aC = aSeg.P0();
return aC
+ aRay * (aProf/scal(aRay,mDirPl));
}
template <class T> INT get_best_intexe(const ElFifo<T> & fp,bool EnvConv)
{
if (! fp.circ())
return 0;
if (fp.nb() < 4)
return 0;
INT delta = EnvConv ? 1 : std::min(5,(fp.nb()-2)/2);
REAL min_cos = 10.0;
INT best_index = 0;
std::vector<INT> aVOk;
std::vector<INT> aVPrec;
std::vector<INT> aVSucc;
for(INT aK=0 ; aK<INT(fp.size()) ; aK++)
{
aVOk.push_back(EnvConv ? 0 : 1);
aVPrec.push_back(aK-delta);
aVSucc.push_back(aK+delta);
}
if (EnvConv)
{
ElFilo<Pt2dr> aFLP;
for(INT aK=0 ; aK<INT(fp.size()) ; aK++)
aFLP.pushlast(fp[aK]);
ElFifo<INT> Ind;
env_conv(Ind,aFLP,true);
for (INT aK=0 ; aK<Ind.nb() ; aK++)
{
aVOk[Ind[aK]] = 1;
aVPrec[Ind[aK]] = Ind[(aK-1+Ind.nb())%Ind.nb()];
aVSucc[Ind[aK]] = Ind[(aK+1)%Ind.nb()];
}
}
for (INT k =0 ; k<fp.nb() ; k++)
{
if (aVOk[k])
{
T u1 = fp[k]-fp[aVPrec[k]];
T u2 = fp[aVSucc[k]]-fp[k];
double d1 = euclid(u1);
double d2 = euclid(u2);
if (d1 && d2)
{
double cosin = scal(u1,u2) / (d1*d2);
if (cosin < min_cos)
{
min_cos = cosin;
best_index = k;
}
}
}
}
return best_index ;
}
int scal( //
const TYPE& sa, //[in]
ArrayListV<TYPE>& asx //[in,out]
) {
int n = asx.size();
TYPE* sx = asx.getPointer();
return scal(n, sa, sx, 1);
}
static Pt3dr PInBCoord(const Pt3dr & aBase,const ElMatrix<double> & aRot,const Pt3dr & aPA)
{
// mDirOr1A (vunit(mBase^mDir1A)),
Pt3dr aRes = aRot.transpose() * (aBase+aPA);
std::cout << "PInBCoord " << scal(aBase^aPA,aRot*aRes) << "\n";
return aRes;
}
/* elementary row operation: scale a row by some factor */
void el_scale(size_t n, num *equation, size_t r, num c)
{
if (!c) {
fprintf(stderr, "multiplying a row by 0 is disallowed\n");
abort();
}
scal(n + 1, c, equation + r * (n + 1));
}
double cLiaisORPO::Residu()
{
SetOrCam();
if (! mProfCalc)
{
mProfCalc = true;
SetProf();
}
// ElRotation3D aC1toM = mCam1.Orientation().inv();
// ElRotation3D aMtoC2 = mCam2.Orientation();
ElRotation3D aC1toC2 = mCam2.Orient() * mCam1.Orient().inv();
Pt3dr aBaseInC2 = aC1toC2.ImAff(Pt3dr(0,0,0));
ElMatrix<double> aMat = aC1toC2.Mat() ;
Pt3dr aC0,aC1,aC2;
aMat.GetCol(0,aC0);
aMat.GetCol(1,aC1);
aMat.GetCol(2,aC2);
double sDist=0.0;
int aK = 0;
for (ElPackHomologue::const_iterator itP =mPack.begin() ; itP!=mPack.end(); itP++)
{
double aPds = itP->Pds();
double aLambda = mProfs.at(aK);
Pt2dr aPIm1 = itP->P1();
Pt3dr aRay1 = aC0 * aPIm1.x + aC1 * aPIm1.y + aC2;
Pt3dr aPTerA = aBaseInC2 + aRay1 * (aLambda *0.99);
Pt3dr aPTerB = aBaseInC2 + aRay1 * (aLambda *1.01);
Pt2dr aProjA(aPTerA.x/aPTerA.z,aPTerA.y/aPTerA.z);
Pt2dr aProjB(aPTerB.x/aPTerB.z,aPTerB.y/aPTerB.z);
Pt2dr aVAB (aProjB.y-aProjA.y,aProjA.x-aProjB.x);
double aD2 = ElAbs(scal(aVAB,aProjA-itP->P2()) / euclid(aVAB));
sDist += aPds*aD2;
aK++;
}
if (DEBUG_POWEL)
{
std::cout << sDist/mPack.size() << "\n"; // getchar();
}
return sDist * mPPL->Pds().Val();
}
void ScreenCapSetting::on_pushButton_applyOptions_clicked()
{
QString bits(ui.comboBox_bits->currentText().split(" ")[0]);
QString scal(ui.comboBox_scaling->currentText().split(" ")[0]);
QString refresh(ui.comboBox_refresh->currentText().split(" ")[0]);
emit ApplyOptions(bits, scal, refresh);
close();
}
Transform SWPhysics::toSWTransform(btTransform& o) {
Transform ret;
Vector3f trans(o.getOrigin().getX(), o.getOrigin().getY(), o.getOrigin().getZ());
Vector3f rot(o.getRotation().getX(), o.getRotation().getY(), o.getOrigin().getZ());
Vector3f scal(1);
ret.setTranslate(trans);
ret.setRotate(rot);
ret.setScale(scal);
return ret;
}
ElMatrix<double> cOriFromBundle::CalculRot(const cOFB_Sol1S1T & aSol,bool Show)
{
// R [mDir1B ...] = [mV1 ...]
ElMatrix<double> aMatB = MatFromCol(mDir1B,mDir2B,mDir3B);
ElMatrix<double> aMatBinA = MatFromCol(aSol.mV1,aSol.mV2,aSol.mV3);
ElMatrix<double> aMat = aMatBinA * gaussj(aMatB);
// std::cout << mDir1B << mDir2B << mDir3B << "\n";
// std::cout << aSol.mV1 << aSol.mV2 << aSol.mV3 << "\n";
// std::cout << "xxxxxxxxxxxx\n";
/*
for (int anY=0 ; anY<3 ; anY++)
{
for (int anX=0 ; anX<3 ; anX++)
{
std::cout << aMat(anX,anY) << " ";
}
std::cout << "\n";
}
*/
// getchar();
ElMatrix<double> aR = NearestRotation(aMat);
// std::cout << "yyyyyyyyyyyyyy\n";
if (Show)
{
std::cout << "DET " << aR.Det() -1.0 << " Eucl " << ElMatrix<double>(3,true).L2(aR*aR.transpose())<< "\n";
std::cout << " SCAL " << scal(mBase^mDir1A,aR*mDir1B) << " "
<< scal(mBase^mDir2A,aR*mDir2B) << " "
<< scal(mBase^mDir3A,aR*mDir3B) << "\n";
}
return aR;
}
bool seg_prim_inside
(
const SegComp & s,
Pt2dr pt,
SegComp::ModePrim mode
)
{
switch(mode)
{
case SegComp::droite :
return true;
case SegComp::demi_droite :
return (scal(pt-s.p0(),s.tangente()) > 0) ;
default :
return (scal(pt-s.p0(),s.tangente()) <s.length())
&& (scal(pt-s.p0(),s.tangente()) > 0) ;
}
}
void bi::var(const M1 X, const V1 mu, V2 sigma) {
/* pre-conditions */
BI_ASSERT(X.size2() == mu.size());
BI_ASSERT(sigma.size() == mu.size());
const int N = X.size1();
typename sim_temp_matrix<M1>::type Z(X.size2(), X.size1());
Z = X;
sub_rows(Z, mu);
dot_columns(Z, sigma);
scal(1.0/(N - 1.0), sigma);
}
cOriFromBundle::cOriFromBundle
(
Pt3dr aBase,
Pt3dr aDir1A,
Pt3dr aDir2A,
Pt3dr aDir3A,
Pt3dr aDir1B,
Pt3dr aDir2B,
Pt3dr aDir3B
) :
mBase (vunit(aBase)) ,
mDir1A (vunit(aDir1A)),
mDir2A (vunit(aDir2A)),
mDir3A (vunit(aDir3A)),
mDirOr1A (vunit(mBase^mDir1A)),
mDirOr2A (vunit(mBase^mDir2A)),
mDirOr3A (vunit(mBase^mDir3A)),
mDir1B (vunit(aDir1B)),
mDir2B (vunit(aDir2B)),
mDir3B (vunit(aDir3B)),
mSc12 (scal(mDir1B,mDir2B)),
mZB (vunit(mDir1B^mDir2B)),
mYB (vunit(mZB^mDir1B)),
mSc3X (scal(mDir3B,mDir1B)),
mSc3Y (scal(mDir3B,mYB)),
mSc3Z (scal(mDir3B,mZB)),
mX12 (vunit(mDirOr1A^mDirOr2A)),
mY1 (vunit(mDirOr1A^mX12)),
mZ1 (mX12 ^ mY1),
mY2 (vunit(mDirOr2A^mX12)),
mCosY2 (scal(mY2,mY1)),
mSinY2 (scal(mY2,mZ1))
{
}
void cLiaisORPO::SetProf()
{
mProfs.clear();
Pt3dr aC1 = mCam1.PseudoOpticalCenter();
for(ElPackHomologue::iterator itP=mPack.begin();itP!=mPack.end();itP++)
{
Pt3dr aPTer = mCam1.PseudoInter(itP->P1(),mCam2,itP->P2());
mProfs.push_back
(
scal(aPTer-aC1,mCam1.F2toDirRayonR3(itP->P1()))
);
}
}
int main(void)
{
char a[]="jeden";
char b[]="dwa";
char *wynik;
wynik = scal(a, b);
printf("%s+%s=%s\n", a, b, wynik);
free(wynik);
return 0;
}
int main(int ac, char **av)
{
if (debut(ac, av[1]) == 0 && atoi(av[1]) > 0 && (av[2][0] >= 49 && av[2][0] <= 57))
{
srand(time(NULL));
int a = atoi(av[2]);
int b = rand()%(9+10)-9;
int tabA[a], tabB[a] , tabAB[a], tabMult[a];
printf("Vecteur A:\t");
nbrAlea(a, tabA);
affiche(tabA, a);
printf("\n");
if (atoi(av[1]) != 2)
{
printf("Vecteur B:\t");
nbrAlea(a, tabB);
affiche(tabB, a);
printf("\n");
}
if (atoi(av[1]) == 1)
{
printf("Vecteur A+B:\t");
somme(a, tabA, tabB, tabAB);
affiche(tabAB, a);
}
else if (atoi(av[1]) == 2)
{
printf(" B: %d\nVecteur A*B:\t", b);
multi(a, tabA, tabMult, b);
affiche(tabMult, a);
}
else if (atoi(av[1]) == 3)
{
printf("Produit Scalaire AB:\t");
printf("%d", scal(a, tabA, tabB));
}
else if (atoi(av[1]) == 4)
{
printf("Norme Euclidienne A.B:\t");
somme(a, tabA, tabB, tabAB);
printf("%.3f", sqrt(norme(a, tabAB)));
}
printf("\n");
}
else
printf("Veuillez entrer en argument un nombre compris entre 1 et 4 suivi du nombre de coordonnee que vous voulez \n");
return (0);
}
bool RosenbrockDaeDefinition::numericalJacVec(const Vec& v, Vec& Jv)
{
bool evalError=false;
real delFac=1.0e-5;
value(evalError);//sets Fcurrent
if (evalError)
return evalError;
else
{
//cek del = -delFac*v;
del = v;
scal(-delFac,del);
//end cek
correctArgument(del);//sets Flast to Fcurrent --
//remember correction is -del = delFac*v
value(evalError);
while (evalError)
{
std::cerr<<"cutting back on del in numerical jac vec"<<std::endl;
unCorrect();//sets Flast to Fcurrent
delFac*=0.1;
//cek del = -delFac*v;
del = v;
scal(-delFac,del);
//end cek
correctArgument(del);
value(evalError);//sets Fcurrent
}
//cek Jv = (Fcurrent - Flast)/delFac;
Jv = Fcurrent;
axpy(-1.0,Flast,Jv);
scal(delFac,Jv);
//end cek
unCorrect();
}
return evalError;
}
REAL IntersecSegCercle(const SegComp &aSeg,Pt2dr & Q0,Pt2dr & Q1)
{
Pt2dr T = aSeg.tangente();
Pt2dr p0 = aSeg.p0();
REAL a = square_euclid(T);
REAL b = 2 * scal(T,p0);
REAL c = square_euclid(p0) - 1;
REAL delta = ElSquare(b) - 4 * a * c;
REAL SqDelta = sqrt(ElMax(0.0,delta));
Q0 = p0 + T*((-b-SqDelta)/(2*a));
Q1 = p0 + T*((-b+SqDelta)/(2*a));
return delta;
}
//Calcule et stocke l'angle entre Dir et Triangle (appartenant a TriIdx)
void cMesh::setTrianglesAttribute(int img_idx, Pt3dr Dir, vector <unsigned int> const &aTriIdx)
{
for (unsigned int aK=0; aK < aTriIdx.size(); aK++)
{
cTriangle *aTri = getTriangle(aTriIdx[aK]);
Pt3dr aNormale = aTri->getNormale(true);
double cosAngle = scal(Dir, aNormale) / euclid(Dir);
vector <double> vAttr;
vAttr.push_back(cosAngle);
aTri->setAttributes(img_idx, vAttr);
}
}
void
scal(const Kokkos::View< RT,RL,RD,RM,Kokkos::Impl::ViewMPVectorContiguous >& r,
const typename Kokkos::View< XT,XL,XD,XM,Kokkos::Impl::ViewMPVectorContiguous >::non_const_value_type& a,
const Kokkos::View< XT,XL,XD,XM,Kokkos::Impl::ViewMPVectorContiguous >& x)
{
typedef Kokkos::Impl::ViewMPVectorContiguous S;
typedef Kokkos::View< XT,XL,XD,XM,S > XVector;
typedef Kokkos::View< RT,RL,RD,RM,S > RVector;
if (!Sacado::is_constant(a)) {
Kokkos::Impl::raise_error("scal not implemented for non-constant a");
}
typename XVector::flat_array_type x_flat = x;
typename RVector::flat_array_type r_flat = r;
scal( r_flat, a.coeff(0), x_flat );
}
Pt2di second_freeman_approx(Pt2di u, bool conx_8,Pt2di u1)
{
Pt2di u2;
if(u1^u)
{
u2 = best_4_approx(u - u1 * scal(u,u1)); // first suppose not 4 cone xity
if (conx_8) // eventually correct if 8 conne xity
u2 = u1+u2;
}
// if u is horizontal or vertical (wich is equivalent to u colinear to u1)
// the previous line mail fail (because take best_4_approx of (0,0) may give
// u1). So simply set :
else
u2 = u1;
return u2;
}
typename std::enable_if<
Kokkos::is_view_mp_vector< Kokkos::View<RD,RP...> >::value &&
Kokkos::is_view_mp_vector< Kokkos::View<XD,XP...> >::value >::type
scal(const Kokkos::View<RD,RP...>& r,
const typename Kokkos::View<XD,XP...>::non_const_value_type& a,
const Kokkos::View<XD,XP...>& x)
{
typedef Kokkos::View<RD,RP...> RVector;
typedef Kokkos::View<XD,XP...> XVector;
if (!Sacado::is_constant(a)) {
Kokkos::Impl::raise_error("scal not implemented for non-constant a");
}
typename Kokkos::FlatArrayType<XVector>::type x_flat = x;
typename Kokkos::FlatArrayType<RVector>::type r_flat = r;
scal( r_flat, a.coeff(0), x_flat );
}
void L2SysSurResol::GSSR_Add_EqInterPlan3D(const Pt3dr& aDirOrtho,const Pt3dr& aP0,double aPds)
{
static std::vector<int> aVInd;
if (aVInd.empty())
{
aVInd.push_back(0);
aVInd.push_back(1);
aVInd.push_back(2);
}
double aCoeff[3];
// Pt3dr aD = vunit(aDirOrtho);
// std::cout << euclid(aDirOrtho) << "\n";
aCoeff[0] = aDirOrtho.x;
aCoeff[1] = aDirOrtho.y;
aCoeff[2] = aDirOrtho.z;
//GSSR_AddNewEquation(aPds,aCoeff,scal(aDirOrtho,aP0),0);
L2SysSurResol::V_GSSR_AddNewEquation_Indexe(0,0,0,aVInd,aPds,&(aCoeff[0]),scal(aDirOrtho,aP0));
}
template <class Type,class TBase> cElN3D_EpipGen<Type,TBase>::cElN3D_EpipGen
(
const std::string & aDir,
const cXML_ParamNuage3DMaille & aNuage,
Fonc_Num aFMasq,
Fonc_Num aFProf,
bool aProfIsZ,
bool WithEmptyData,
bool Dequant
) :
cElNuage3DMaille_FromImProf<Type,TBase>(aDir,aNuage,aFMasq,aFProf,WithEmptyData,Dequant),
mProfIsZ (aProfIsZ)
{
mCentre = this->mCam->OrigineProf();
mDirPl = this->Params().DirFaisceaux();
mZIsInv = this->Params().ZIsInverse();
mIsSpherik = this->Params().IsSpherik().Val();
mCS = (mIsSpherik ? this->mCam->CS() : 0);
mProfC = scal(mDirPl,mCentre);
}
void A2L::fillScalarsInfo(QVector< QSharedPointer<ECUScalar> > &scalars) const {
for ( ptrdiff_t i=0; i<m_scalarsInfo.size(); i++ ) {
QSharedPointer<ECUScalar> scal(new ECUScalar());
const ptrdiff_t compuMethodInd = findCompuMethod(m_scalarsInfo[i][6]);
if ( m_compumethodsInfo[compuMethodInd][2] == "RAT_FUNC" ) {
scal->setType(VARTYPE_SCALAR_NUM);
scal->setCoefficients(getCoeff(compuMethodInd));
}
else if ( m_compumethodsInfo[compuMethodInd][2] == "TAB_VERB" ) {
scal->setType(VARTYPE_SCALAR_VTAB);
const ptrdiff_t compuVTabInd = findCompuVTab(m_compumethodsInfo[compuMethodInd][5].split(' ').last());
scal->setVTable(getVTab(compuVTabInd));
}
scal->setName(m_scalarsInfo[i][0]);
scal->setShortDescription(delQuotes(m_scalarsInfo[i][1]));
scal->setAddress(m_scalarsInfo[i][3].split("x").last());
scal->setNumType(m_scalarsInfo[i][4].split('_').last());
scal->setRangeSoft(m_scalarsInfo[i][5].toDouble());
scal->setMinValueSoft(m_scalarsInfo[i][7].toDouble());
scal->setMaxValueSoft(m_scalarsInfo[i][8].toDouble());
scal->setPrecision(delQuotes(m_scalarsInfo[i][9].split('.').last()).toInt());
QVector<double> v = getHardLimints(m_scalarsInfo[i][10]);
scal->setMinValueHard(v[0]);
scal->setMaxValueHard(v[1]);
scal->setReadOnly(isReadOnly(i));
scal->setDimension("[" + delQuotes(m_compumethodsInfo[compuMethodInd][4]) + "]");
scalars.push_back(scal);
}
}
void cEqPlanInconnuFormel::GenCode(const cMatr_Etat_PhgrF & aME)
{
Pt3d<Fonc_Num> aPInc = mEqP3I->PF();
Pt3d<Fonc_Num> aPBary = aME.Mat() * Pt3d<Fonc_Num>(aPInc.x,aPInc.y,1.0);
Pt3d<Fonc_Num> aPZ
(
mTri->S1().ValsIncAsScal(),
mTri->S2().ValsIncAsScal(),
mTri->S3().ValsIncAsScal()
);
std::vector<Fonc_Num> aVEcart;
aVEcart.push_back(aPInc.z - scal(aPZ,aPBary));
cElCompileFN::DoEverything
(
"CodeGenere/photogram/", // Directory ou est localise le code genere
mNameType, // donne les noms de fichier .cpp et .h ainsi que les nom de classe
aVEcart, // expressions formelles
mLInterv // intervalle de reference
);
}
void calcDepthRange(mat4 const& pr, mat4 const& mv,
aabb const& bbox, float& minval, float& maxval)
{
vec3 center = vec4( mv * vec4(bbox.center(), 1.0f) ).xyz();
vec3 min = vec4( mv * vec4(bbox.min, 1.0f) ).xyz();
vec3 max = vec4( mv * vec4(bbox.max, 1.0f) ).xyz();
float radius = length(max - min) * 0.5f;
// Depth buffer of ibrPlanes
vec3 scal(center);
scal = normalize(scal) * radius;
min = center - scal;
max = center + scal;
vec4 min4 = pr * vec4(min, 1.f);
vec4 max4 = pr * vec4(max, 1.f);
min = min4.xyz() / min4.w;
max = max4.xyz() / max4.w;
minval = (min.z+1.f) * 0.5f;
maxval = (max.z+1.f) * 0.5f;
}
int main(int argc, char** argv)
{
std::vector<std::chrono::duration<double, std::milli>> duration_vector_1, duration_vector_2;
bool run_ref = false, run_tiramisu = false;
const char* env_ref = std::getenv("RUN_REF");
if (env_ref != NULL && env_ref[0] == '1')
run_ref = true;
const char* env_tiramisu = std::getenv("RUN_TIRAMISU");
if (env_tiramisu != NULL && env_tiramisu[0] == '1')
run_tiramisu = true;
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
double alpha = 2.5;
Halide::Buffer<int> SIZES(1);
SIZES(0) = nrow;
Halide::Buffer<double> b_alpha(1);
b_alpha(0) = alpha;
Halide::Buffer<double> b_X(nrow), b_X_ref(nrow);
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
{
for (int i = 0; i < NB_TESTS; ++i)
{
init_buffer(b_X_ref, (double)1);
auto start = std::chrono::high_resolution_clock::now();
if (run_ref)
scal_ref(nrow, alpha, b_X_ref.data());
auto end = std::chrono::high_resolution_clock::now();
duration_vector_1.push_back(end - start);
}
}
{
for (int i = 0; i < NB_TESTS; ++i)
{
init_buffer(b_X, (double)1);
auto start = std::chrono::high_resolution_clock::now();
if (run_tiramisu)
scal(SIZES.raw_buffer(), b_alpha.raw_buffer(), b_X.raw_buffer());
auto end = std::chrono::high_resolution_clock::now();
duration_vector_2.push_back(end - start);
}
}
print_time("performance_cpu.csv", "scal",
{"Ref", "Tiramisu"},
{median(duration_vector_1), median(duration_vector_2)});
if (CHECK_CORRECTNESS && run_ref && run_tiramisu)
compare_buffers("scal", b_X_ref, b_X);
if (PRINT_OUTPUT)
{
std::cout << "Tiramisu " << std::endl;
print_buffer(b_X);
std::cout << "Reference " << std::endl;
print_buffer(b_X_ref);
}
return 0;
}
