Stack Overflow en español

4:39 AM

Egun on

5:35 AM

Lindo Lunes!

Vuelven todos al chat!

Hola, @Trauma

Pikoh

6:31 AM

Buenos dias

Nicolas Oñate

7:28 AM

buenos días

phpMyGuel

7:40 AM

Buenos días ^^

8:16 AM

A las güenas :-)

Asco de Lunes :-(

9:01 AM

Güenas

9:11 AM

@Trauma los lunes son lo peor

@PaperBirdMaster No te haces una idea :'-(

@Trauma Sí me hago a la idea

@CandidMoe y esto? es.stackoverflow.com/questions/490611/…

9:24 AM

@PaperBirdMaster Quizás esto? es.stackoverflow.com/questions/490611/…

@abulafia Nope. Aunque llames a pow con enteros, los transformará a double (si se usa la versión C, no así con la versión C++) y dado que operar con coma flotante tiene errores de redondeo puede suceder que en algunos casos pow(5, 2) de un número diferente a 25.0. El caso es que yo no he conseguido reproducir ese error ni en gcc ni en clang ni en msvc, pero por poder, puede suceder.

@PaperBirdMaster Pero 5.0*5.0 siempre dará 25.0

la única forma en que pow(5,2) puede dar algo diferente de 25 por errores de redondeo es que lo esté haciendo con logaritmos, como traté de explicar en el comentario

yo no digo que no haga la conversión a float cuando pasas un entero

de hecho, creo que es por eso, porque está trabajando con floats, por lo que usa logaritmos

digo que si hubiera hecho la multiplicación no habría habido ese error

por otro lado, ya que la especificación de float y de double siguen un estándar (IEEE754) independiente de la implementación del compilador, no veo como 5.0*5.0 podría salir diferente resultado "según el compilador". La única forma en que puede salir diferente resultado es según cómo esté implementado pow

De hecho.... mira esto que curioso (es python pero creo que nos ilumina igualmente):

>>> from math import log, exp
>>> exp(2.0*log(5.0))
24.999999999999996
>>> 5.0*5.0
25.0

9:51 AM

@abulafia El cómo está hecho pow internamente es dependiente de implementación, puede hacerlo por logaritmo o puede hacerlo por magia negra o puede hacerlo con una instrucción específica de 8086. Sea como sea, hay números que no son expresables en coma flotante (aunque creo que todos los enteros lo son, no soy experto) y su representación interna es una aproximación, y según como le de al código por imprimir el número pues saldrá una u otra cosa.

Es bastante común que en coma flotante A + A != 2A.

Que sí, que sí.. que cómo funciona la coma flotante lo tengo claro. Lo que se está hablando aquí es que no hay ninguna implementación posible en la que 5.0*5.0 != 25.0 porque el 5.0 es representable de forma exacta, el algoritmo para multiplicar es parte del estándar, y el 25.0 también es representable de forma exacta

Y bueno, ya sabemos que A^2 es A*A que a la vez sabemos que una multiplicación es sólo una repetición de sumas.

y que puede haber casos en que A+A != 2A también de acuerdo, pero no si A=5.0

y que A*A puede salir distinto de A^2. también de acuerdo, pero no en el caso particular de A=5.0

A ver, experto no soy, y te digo que he sido completamente incapaz de reproducir el error, pero entiendo que conceptualmente puede pasar con cualquier número porque en el fondo pow es dependiente de implementación.

asi que si pow(5, 2) no sale 25.0 es porque no está haciendo 5.0*5.0

eso era simplemente lo que estaba tratando de decir

9:54 AM

@abulafia Podría poder ser posible que lo estuviera haciendo... y podría poder ser posible que no: implementation defined.

vale, anda, como quieras

@abulafia O_o no es como quiera yo, es como es... y lo que es: ni idea de cómo lo hace.

que no estoy discutiendo aqui como lo hace o lo deja de hacer. Solo estoy enunciando un hecho incontrovertible (y es la última vez que lo repito, y ya lo dejo). Si pow(5,2) saca algo distinto de 25, es porque no ha hecho 5*5. Ya está. "podría ser posible que sí", dices tú? pues no es posible digo yo

XD

y de hecho si lo que hace es usar logaritmos, sí que sale 24.9999999996, por tanto es altamente probables (y muy lógico) que sea eso lo que esté haciendo. Y darle más vueltas es ganas de marear la perdiz

9:56 AM

Esto es ver 2 portaaviones en pleno conflicto atacando con todo su arsenal.

@abulafia Y yo te digo que no tengo información para decir que estés en lo cierto ni que no lo estés, para empezar no he podido reproducir el error y para acabar el cómo lo haga internamente puede dar resultados extraños aún siendo una multplicación de números enteros en formato de coma flotante porque la coma flotante es rara.

@abulafia ¿ Y si fuera pow( 5.0, 2.0 ) ?

@Trauma Ese es precisamente el tema y el meollo

A ver, que yo acabo de llegar y no se de que va el tema

debido a que el 2 se convierte en 2.0, la implementación de pow muy probablemente estará usando logaritmos

es eso lo que usa? no se sabe, como dice paperbirdmaster

puede que esté haciendo en realidad 5*5. imposible digo yo. En ese caso saldría 25

y sí que puedo hablar con cierta autoridad sobre el tema. me estudié bastante a fondo el IEEE-754 años ha

y 5.0*5.0 sale siempre 25.0 en cualquier implementación que cumpla el estándar

como de hecho lo cumplen los propios procesadores hardware

9:59 AM

@abulafia Ahí ya no lo tengo tan claro

transformar de un literal 5.0 a su representación binaria no está definido en ningún lado, depende de la implementación

no estoy hablando de eso

Pues toy perdido. Me callo mejor xD

estoy hablando de que tengas ya un dato de tipo float o double (me da igual) que represente al 5

y lo multipliques por sí mismo

saldrá 25

Entonces ahí me superas en sapiencia, yo el IEEE ni lo he mirado. Lo que sí que me he encontrado es comportamientos extraños de coma flotante en casos claros:

1) leer X de un archivo y que X sea diferente al literal X en código.
2) sumar A + B y que sea diferente al literal que representa esa suma.
3) A*B != B*A sea verdadero...
4) etc...

a ver, te puedo poner la representación binaria IEEE del 5 y del 25... pero qué mas da

10:00 AM

@abulafia ... supongo, no lo se. Pero también supongo que pow( ) no hará directamente X * 2

@PaperBirdMaster Sí, todas esas cosas son "normales" y bien sabidas salvo por programadores noveles

@Trauma Efectivamente, ese es mi punto. Si hiciera X*Y, daría 25

pero como da 24.99999996 es que hace otra cosa

y logaritmos es lo más plausible

Para contexto puedes ver esta pregunta y mi respuesta es.stackoverflow.com/questions/490611/…

Nada, que no se de que va esto y tengo cosas que hacer. Yo a lo mio :-)

@PaperBirdMaster Decía, que todo eso puede pasar, depende de con qué números estés operando

Los primeros Lunes son mu malos

10:02 AM

pero si el número es el 5, entonces te apuesto lo que quieras a que 5*5 sale 25 y no hay errores de redondeo

y ya que esto es así, se deduce que pow(5,2) no ha hecho 5*5

vaya, ya lo repetí otra vez y dije que no lo repetía más :-)

@abulafia Y estoy seguro de que ganarías la apuesta. Pero el problema es que vete tú a saber lo que hace pow en la implementación del autor de aquella pregunta. Lo que sí te digo es que en clang, gcc y msvc el comportamiento NO ES el que describe.

Vale, cosa que nunca discutí. Lo que digo es que, sea lo que sea lo que está haciendo pow(5,2), no es 5*5. Y todo esto venía a raíz del comentario de Candid, que se extrañaba precisamente de ese hecho, de cómo puede ser que 5*5 dé algo diferente a 25 y le respondiste "cosas de trabajar en coma flotante"

y entonces salté yo para aclarar que eso no es un problema de coma flotante, ya que 5*5 sale siempre 25. Es un problema de que ese pow() está haciendo otra cosa

y que esa cosa con toda probabilidad son logaritmos (pero esto ya si que es una mera elucubración, que encaja bien con los hechos, sí, pero indemostrable)

No tiene mayor importancia, solo que me da rabia que no se me entienda :-)

@abulafia Bueno, en realidad quería decir: "Es una mierda trabajar con cabeceras C en código C++, si la gente hiciera lo que debe hacer y los profesores enseñaran como deben enseñar y las cosas funcionaran como deben funcionar, la operación trivial de multiplicar dos enteros debería estar perfectamente definida, pero no lo está porque la gente se empeña en programar mal"...

pero no tenía suficiente café entonces para responder y no creo que ese fuera el contenido adecuado en la caja de comentarios de esa pregunta.

xD

Q: std::vector to string with custom delimiter

11:50 AM

@PaperBirdMaster tú que tienes mas tiros pegados que yo

		std::vector<std::pair<std::string,type::PartitionId>> partitionInfo;
		{
			std::map< type::PartitionId, std::string > niceTraces;

			query::Partitions query;
			partitionInfo = query.execute( );

			for( const auto &item : partitionInfo ) {
				auto &text = niceTraces[item.second];

				if( !text.empty( ) ) {
					text += ", ";
				}

				text += item.first;
			}

			LOG_INFO( ) << "Obtained partitions and their devices:";
			for( const auto &info : niceTraces ) {
				LOG_INFO( ) << std::setfill( '0' ) << std::setw( 3 ) << info.first << ": [ " << info.second << " ]";

El if( !text.empty( ) ) { ese que hay ahí en medio

¿ Como lo podría quitar ?

Es solo para separar las distintas cosas con una coma (,) si no es la primera

text es un std::string &

Pikoh

38

I would like to copy the contents of a vector to one long string with a custom delimiter. So far, I've tried: // .h string getLabeledPointsString(const string delimiter=","); // .cpp string Gesture::getLabeledPointsString(const string delimiter) { vector<int> x = getLabeledPoints(); stri...

c++ string vector

@Pikoh joé, veo que estás atento O-O jejeje

Voy a ver, pero lo mio no es un vector. Aunque seguramente sea aplicable

@PaperBirdMaster Los enteros son representables exactamente en punto flotante. Algunos decimales son representables (0.2 por ejemplo), otros no (0.1 por ejemplo)

Pikoh

@Trauma estoy a punto de salir a comer y pasé por aqui

@Pikoh Pues las pillas al vuelo :-O

11:57 AM

Lo que todo programador debe saber sobre punto flotante: docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html