C++

abs

Recherche :

Mot : Pseudo : Filtrer
Page : 1 2 Page Suivante Page Précédente Bas de page
Auteur	Sujet : abs

d_imane

Bonjour à tous,
:pt1cable: Coment faire pour calculer la valeur absolue de deux float?
Merci

Publicité

Aldarek

Un cast non?

Taz

bisounours-codeur

std::abs

d_imane

float(abs(a-b)) me rend un entier,moi je cherche à garder les float et calculer leur valeurs absolue
j'ai pas compris ta réponse Taz

fra0

::fabs(a-b);

Elmoricq

Modérateur

d_imane a écrit :

j'ai pas compris ta réponse Taz

Ben c'est pourtant simple ?
std::abs() fait ce que tu souhaites.

d_imane

That's it, Thanks fra0.

Taz

bisounours-codeur

Code :

#include <cmath>
#include <iostream>
int main()
{
std::cout << std::abs(1.0f - 3.14f) << '\n';
}

fabs c'est le truc C parce que y a pas de surcharge. utilise std::abs sur n'importe quoi et ça ira.

d_imane

maintenant c'est beaucoup plus clair, je retiens ta proposition, merci

d_imane

but...il m'as sotie un message d'erreur

Code :

float Region::ValRealSubdivision(float mediane,float *x, int dimx)
{ float *t,min;
t=new float[dimx];
for(int i=0;i<dimx;i++)
//t[i]=fabs(x[i]-mediane);
t[i]=std::abs(x[i]-mediane);
min=t[0];
for(i=0;i<dimx;i++)
if(t[i]<min) min=t[i];
return (min+mediane);
}

error C2039: 'abs' : is not a member of 'std'

Publicité

skelter

#include <cmath>
ya une fuite dans ta fonction

d_imane

si si j'ai utilisé

Code :

#include<cmath>
#include<iostream>
float Region::ValRealSubdivision(float mediane,float *x, int dimx)
{ float *t,min;
t=new float[dimx];
for(int i=0;i<dimx;i++)
//t[i]=fabs(x[i]-mediane);
t[i]=std::abs(x[i]-mediane);
min=t[0];
for(i=0;i<dimx;i++)
if(t[i]<min) min=t[i];
return (min+mediane);
}

fra0

je parie que tu utilises ~~Borland~~ VC

Message édité par fra0 le 13-06-2005 à 16:30:09

Taz

bisounours-codeur

très simplement, tu peux encore améliorer :

Code :

#include <algorithm>
#include <cmath>
#include <vector>
class Region
{
public:
static float ValRealSubdivision(float mediane, float *x, size_t dimx);
};
float Region::ValRealSubdivision(float mediane, float *x, size_t dimx)
{
std::vector<float> t(dimx);
for(size_t i = 0; i < dimx; ++i)
t[i] = std::abs(x[i] - mediane);
return mediane + *std::min_element(t.begin(), t.end());
}

fra0

quand ça marchera,
tu pourras même tout faire en évitant le stockage temporaire
et avec deux fois moins d'itérations.

d_imane

j'ai utliliser exactement ta fct Taz, et j'ai tjs le meme message d'erreur:'abs' : is not a member of 'std'
j'ulilise la biblio

Code :

#include "stdafx.h"
#include "base.h"
//#include "coder.h"
#include "Region.h"
#include<cstdio>
#include<cmath>
#include <windows.h>
#include<iostream>
#include<ctime>
#include<conio.h>
#include<cstring>
#include<stdlib.h>
#include <fstream>
#include <algorithm>
#include <vector>
using namespace std;

Taz

bisounours-codeur

Code :

#include <algorithm>
#include <cmath>
#include <vector>
#include <iterator>
class Region
{
class ValRealSubdivisionIterator : public std::iterator<std::input_iterator_tag, float>
{
const float *x;
float mediane;
public:
ValRealSubdivisionIterator(const float *px, float pmediane = float())
: x(px), mediane(pmediane)
{ }
ValRealSubdivisionIterator& operator++()
{
this->x++;
return *this;
}
ValRealSubdivisionIterator operator++(int)
{
const ValRealSubdivisionIterator last(*this);
++*this;
return last;
}
float operator*() const
{
return std::abs(*this->x - this->mediane);
}
bool operator==(const ValRealSubdivisionIterator &other) const
{
return this->x == other.x;
}
bool operator!=(const ValRealSubdivisionIterator &other) const
{
return not (*this == other);
}
};
public:
static float ValRealSubdivision(float mediane, float *x, size_t dimx);
static float ValRealSubdivision2(float mediane, const float *x, size_t dimx);
};
float Region::ValRealSubdivision(float mediane, float *x, size_t dimx)
{
std::vector<float> t(dimx);
for(size_t i = 0; i < dimx; ++i)
t[i] = std::abs(x[i] - mediane);
return mediane + *std::min_element(t.begin(), t.end());
}
float Region::ValRealSubdivision2(float mediane, const float *x, size_t dimx)
{
ValRealSubdivisionIterator first(x, mediane), last(x + dimx);
return mediane + *std::min_element(first, last);
}

pour faire joli

fra0

std::not ?

Taz

bisounours-codeur

non, not le mot clef

fra0

ok (...)

Code :

// pr le fun,
float Region::ValRealSubdivision3(float mediane, const float *x, size_t dimx)
{
std::priority_queue<float, std::deque<float>, std::greater<float> > pq;
while(dimx--) pq.push(mediane+std::abs(x[dimx]-mediane));
return pq.top();
}

Taz

bisounours-codeur

c'est très très lent ton truc : tu maintiens un ordre pour rien.

edit : et tu as un recopies inutile. Seul avantage par rapport à la méthode initiale : ça ne fuit pas

Message cité 1 fois
Message édité par Taz le 13-06-2005 à 18:58:58

fra0

mais qu'il est lourd celui là....
c'est pour le fun j'ai dit.

la solution la plus efficace est évidente

skelter

pour le fun aussi , histoire d'user le pauvre valarray

Code :

float Region::ValRealSubdivision3(float mediane, const float *x, size_t dimx)
{
std::valarray<float> t(x, dimx);
t -= mediane;
return mediane + t.min();
}

edit: c'est quand meme une meilleur soltution ?

Message édité par skelter le 13-06-2005 à 19:12:09

fra0

c toujours bon les solutions en 3 lignes

pour info, dans le files de priorité*, c'est le popage des éléments qui est lent plutôt que leur pushage (facteur 3 avec un vector, 10 avec une deque (dans des tailles cahemissables))

Taz

bisounours-codeur

Code :

float Region::ValRealSubdivision3(float mediane, const float *x, size_t dimx)
{
float min;
min = x[0];
for(size_t i = 1; i < dimx; ++i)
{
const float v = std::abs(x[i] - mediane);
if(v < min)
min = v;
}
return mediane + min;
}

quant à ton histoire de pop plus lent que push, elle ne veut rien dire, vu que ça dépend très largement de l'implémentation.

edit : avec un tas, on a d'ailleurs o(log(n)) en insertion et suppression
edit2 : encore heureux que top() est o(1)

Message édité par Taz le 13-06-2005 à 19:31:14

Kyle_Katarn

Fais une macro qui fait (fVal<0.0f)?-fVal:fVal

Taz

bisounours-codeur

non mais là c'est plus rigolo

chrisbk

Kyle_Katarn a écrit :

Fais une macro qui fait (fVal<0.0f)?-fVal:fVal

[:pingouino]

fra0

Taz a écrit :

quant à ton histoire de pop plus lent que push, elle ne veut rien dire, vu que ça dépend très largement de l'implémentation.

teste avant d'être trop péremptoire....

quand à ton dernier code j'ai bien peur qu'il soir complètement faux.

Taz

bisounours-codeur

je comprends pas de quoi tu parles : vu que tu fais n push() et 1 top(), et que top() est o(1), tu te mouilles pas trop en disant que c'est les push() qui prennent du temps.

après on s'en fout que ça soit juste ou pas, c'est son algo après tout.

fra0

justement,
je suis peut être pas très clair,
mais (chez moi, sur ma machine....)
aussi bizarre que cela puisse paraître
ce sont les pop qui prennent du temps

Taz

bisounours-codeur

mais tu ne fais pas de pop()

fra0

donc la méthode "fun" est efficace
cqfd

Taz

bisounours-codeur

ben non.

utilisation mémoire : n
complexité : n x log(n)

alors que l'opération est clairement o(n). C'est la pire des solutions proposées ici.

fra0

:pt1cable:

que fais ton ValRealSubdivision3 quand x[0]==-1e9f ?

Taz

bisounours-codeur

je vois pas le problème

fra0

d'après ton code :
v : n'est jamais (strictement) négatif
si x[0] est négatif,
v<min : est toujours faux,

ta boucle ne sert à rien.

pour *x==-1e9f, ton code renvoit mediane - 1 millard quelles que soient les valeurs du tableau (et y'a un autre petit problème)

edit 'f','t','a'

Message édité par fra0 le 14-06-2005 à 13:42:12

Taz

bisounours-codeur

encore une fois on s'en bat de son algo à la con, je sais pas ce que tu cherches à prouver.

xtremdev

Je choisi la formule offensive

Si on revenait au pb de départ ??? Calculer une valeur absolue d'un type float

Question à 15 et un mars : "Quelle est la différence entre -3.14f et 3.14f ?"
Alors...

Réponse : le bit de poid fort.

Comme une variable de type float est codée sur 4 octets, on peut donc créer sa propre fonction fabs qui remet à zéro ce bit.

Code :