[Python-es] numpy.absolute

[Rolando Paz]

Hola a todos.

El siguiente codigo me funciona bien cuando utilizo archivos que contienen datos positivos:

import numpy as np

import matplotlib.pyplot as plt

import argparse

parser = argparse.ArgumentParser(description="Script that plots the bram's data obtained from the IBOB.")

parser.add_argument('-b','--bram', help="Name of BRAM that will be processed")

parser.add_argument('-f','--fre', help="Test frequency signal in MHz. Example: $python plot_bram.py -b bram_file -f 33 (33MHz)")

args = parser.parse_args()

freq = args.fre

open_bram = open(args.bram, 'r')

bram = open_bram.readlines()

cols = np.loadtxt(bram, dtype=str)

x = cols[:,2]

y = cols[:,8]

max_x = np.argmax(y)

#Regla de 3 para determinar el valor del numero de canales teorico

ancho_de_banda_MHz = 100

canales = 1024

test_signal = int(freq)

dato_teorico = (test_signal*canales)/ancho_de_banda_MHz

plt.rc('font', size=9.2)

plt.subplot(1,1,1)

plt.plot(x,y)

plt.title('Autocorrelation \nTest Frequency Signal= %iMHz, Channels of the Maximum Value= %i, Theoretical Channel Value= %i'%(int(freq),max_x,dato_teorico))

plt.ylabel('Power (arbitrary units)')

plt.grid()

plt.xlabel('Channels')

plt.xlim(0,1024)

plt.show()

Sin embargo algunos archivos contienen datos negativos, que debo cambiar a absolutos.

Yo intente esto:

y = np.absolute(y)

Pero me surge este error:

$ python plot_bram.py -b bram_ac_real -f 50

Traceback (most recent call last):

  File "plot_bram.py", line 37, in <module>

    plt.plot(x,np.absolute(y))

TypeError: Not implemented for this type

Que opinan?

Saludos

Rolando Paz

[Daπid]

On 20 Dec 2015 05:16, "Rolando Paz" <flx...@gmail.com> wrote:
> open_bram = open(args.bram, 'r')
> bram = open_bram.readlines()
>
> cols = np.loadtxt(bram, dtype=str)

A np.loadtxt le puedes pasar el nombre de archivo directamente, así que esas tres líneas se colapsan en :

cols = np.loadtxt(args.bram)

Si necesitas especificar el dtype, usa np.float64, ahora tienes un array de strings. La transformada de Fourier te funciona porque lo primero que hace es convertir el input a uno de los sabores de float que entiende.

/David

[Rolando Paz]

Hola David

Gracias.

Acabo de deducir que uno de mis problemas es el tipo de dato que estoy tratando de graficar.

Los valores validos se ven asi:

0006286334

El valor que me da problemas es este:

00-4834129

El error es este:

ValueError: invalid literal for float(): 00-4834129

Entiendo que lo que necesito hacer es cambiar el valor de 00-4834129 a este -4834129.

Tienes idea de como poder hacerlo?

saludos

_______________________________________________
Python-es mailing list
Pyth...@python.org
https://mail.python.org/mailman/listinfo/python-es
FAQ: http://python-es-faq.wikidot.com/

[monoBOT]

puedes modificarlo al vuelo pasandolo a string y volviendolo a pasar a float tras la transformación

si x = 00-4834129

str_x = str(x).replace('00-', '')

x = float(str_x)

en una sola linea

x = float(str(x).replace('00-', ''))

--

monoBOT

Visite mi sitio(Visit my site): monobotsoft.es/blog/

[Flavio Danesse]

x = 00-4834129

x = float(x.split("-")[-1])

[Rolando Paz]

Gracias por los consejos, sin embargo aun no logro resolver el problema.

El archivo de datos "bram_ac_real" tiene este formato:

0x01FA / 00506 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000

0x01FB / 00507 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000

0x01FC / 00508 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000

0x01FD / 00509 -> 0xFFB63CAF / 0b11111111101101100011110010101111 / 00-4834129

0x01FE / 00510 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000

0x01FF / 00511 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000

0x0200 / 00512 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000

En donde los primeros dos numero es la representación hex y decimal del ID de cada linea.

El tercer, cuarto y quinto numero es la representación hex, binario y decimal de los datos obtenidos, respectivamente.

Yo entiendo que el valor negativo surge de esto: 

FFB63CAF = 11111111101101100011110010101111 = 4290133167

En donde:

4290133167 - 2^32 = -4834129

De forma general el código "plot_bram.py" hace esto:

cols = np.loadtxt(args.bram, dtype=str, usecols=[2,8])

x = cols[:,0]

y = cols[:,1]

plt.plot(x,y)

plt.show()

en donde "y" es un objeto numpy.ndarray 

Los errores que surgen son estos 

numpy.ndarray object has no attribute split

numpy.ndarray object has no attribute replace

Lo que entiendo que necesito es encontrar una función que elimine todos los ceros a la izquierda del signo menos.

Agradeceré cualquier corrección u opinión.

Saludos

Rolando Paz 

[Juan Luis Cano]

On 2015-12-29 18:20, Rolando Paz wrote:

Lo que entiendo que necesito es encontrar una función que elimine todos los ceros a la izquierda del signo menos.

Tal vez puedes probar con

>>> "00-4834129".lstrip("0")
'-4834129'

https://docs.python.org/3/library/stdtypes.html#str.lstrip

Juan Luis

[Rolando Paz]

Mira lo que surge:

$ python plot_bram.py -b bram_ac_real -f 50

Traceback (most recent call last):

  File "plot_bram.py", line 27, in <module>

    y = y.lstrip("0")

AttributeError: 'numpy.ndarray' object has no attribute 'lstrip'

Codigo:

cols = np.loadtxt(args.bram, dtype=str, usecols=[2,8])

x = cols[:,0]

y = cols[:,1]

max_x = np.argmax(y)

y = y.lstrip("0")

plt.plot(x,y)

plt.show()

[Yamila Moreno Suárez]

Rolando, el error te indica que tienes un tipo "ndarray" y que los ndarray no tienen "lstrip".

lstrip es un método de strings (cadenas de texto), como la que ves en el ejemplo que te dio Juanlu.

Siguiendo con los consejos que te han dado en correos anteriores, lo que tendrías que hacer es (1)pasar el valor de tu ndarray (que si no me equivoco es 00-48....) a string, (2)aplicarle la modificación y (3)después volver a pasarlo al tipo que necesites.

en varios pasos:

y = str(y)

y = y.lstrip("0")

y = float(y)

en un solo paso:

y = float(str(y).lstrip("0"))

suerte :)

--

Yamila  Moreno Suárez
http://dendarii.es

http://moduslaborandi.net

[Rolando Paz]

Gracias por todos los consejos.

Hice esto:

cols = np.loadtxt(args.bram, dtype=str, usecols=[2,8])

x = cols[:,0]

y = cols[:,1]

max_x = np.argmax(y)

y = float(str(y).lstrip("0"))

plt.plot(x,y)

plt.show()

El nuevo error es este:

$ python plot_bram.py -b bram_ac_real_test -f 50

Traceback (most recent call last):

  File "plot_bram.py", line 27, in <module>

    y = float(str(y).lstrip("0"))

ValueError: could not convert string to float: ['0000000000' '0000000000' '0000000000' '00-4834129' '0000000000'

 '0000000000' '0000000000' '0000000000']

Entiendo que este es el contenido del arreglo "y":

['0000000000' '0000000000' '0000000000' '00-4834129' '0000000000'

 '0000000000' '0000000000' '0000000000']

Esta representación esta correcta?

[Yamila Moreno Suárez]

Rolando, un par de cositas:

Si y tiene el valor que nos pasas, entonces tu código tiene que ser algo como:

y = float(str(y[0]).lstrip("0"))

¡ojo! en lstrip la "l" significa "left", así que solo te quita los ceros de la izquierda. ¿así te sirve?

Por otro lado, te doy un par de pistas para que tú mismo hagas debugging del programa:

1) usa print, sí tal cual. Añade en tu programa líneas con:

print(" VALOR DE Y ANTES DE TAL O CUAL TRANSFORMACION ", y)

2) usa pdb. Si en cualquier línea de tu programa pones "import pdb; pdb.set_trace()", al lanzar la ejecución se parará en ese punto, y te dará un intérprete de python con las variables de tu programa, de forma que puedes investigar qué valor tiene en un punto concreto.

El problema que estás teniendo tiene mucho de "afinar" el resultado como te guste, o como lo necesites según el caso, y para eso, es muy recomendable que estés constantemente evaluando qué valores tienen las variables y probando las transformaciones que necesites.

¡¡mucho ánimo!!

yami

[Rolando Paz]

Hola Yamila

Muchas gracias por tu correo.

Lo que necesito es corregir cualquier valor negativo que tenga ceros a la izquierda. 

Algunos ejemplos:

00000000-1

000000-355

0000-54623

0000000-56

0-98756874

El valor negativo depende de la potencia en dBm de la senial analógica que le ingrese a la tarjeta que estoy usando.

Al colocar el print para observar el contenido de "y", observo esto:

['0000000000' '0000000000' '0000000000' '00-4834129' '0000000000'

 '0000000000' '0000000000' '0000000000']

Veo cadenas separadas por un espacio en blanco.

cols = np.loadtxt(args.bram, dtype=str, usecols=[2,8])

x = cols[:,0]

y = cols[:,1]

print 'este es el contenido de y =',y

y = float(str(y[0]).lstrip("0"))

El error que surge es este:

Traceback (most recent call last):

  File "plot_bram.py", line 28, in <module>

    y = float(str(y[0]).lstrip("0"))

ValueError: could not convert string to float:

Seguire intentando... :-)

[Kiko]

Hola, Rolando.

Entiendo que estás trabajando en Python3.

np.loadtxt produce un error que no está resuelto desde hace mucho tiempo (ver [1] y [2], por ejemplo). Parece que se resolverá en numpy 1.11 incluyendo un keyword encoding [3].

Este error lleva a muchos problemas al leer ficheros de strings con np.loadtxt (sobretodo en python3 y numpy).

Por otro lado, estás intentando aplicar métodos de str a numpy arrays. Esto no es posible y te devuelve los errores que estás viendo.

A continuación dejo un código comentado que debería funcionar:

##########################################
## Importamos librerías
##########################################
import io

import numpy as np
import matplotlib.pyplot as plt

##########################################
##########################################



##########################################
## Todo esto es para simular un fichero
##########################################
raw_data = """0x01FA / 00506 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000

0x01FB / 00507 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000
0x01FC / 00508 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000
0x01FD / 00509 -> 0xFFB63CAF / 0b11111111101101100011110010101111 / 00-4834129
0x01FE / 00510 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000
0x01FF / 00511 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000
0x0200 / 00512 -> 0x00000000 / 0b00000000000000000000000000000000 / 0000000000"""

file_sim = io.StringIO(raw_data)
##########################################
##########################################


##########################################
## Leemos los datos, fíjate en el dtype
## Si usamos 'dtype = str' se rompe todo y
## nos convierte el string regular de python3 b'kkkkkk' en un string literal "b'kkkkkk'" ¿?¿?¿?

## para tu caso debes cambiar file_sim por la ruta a tu fichero.

##########################################
cols = np.loadtxt(file_sim, dtype = bytes, usecols = [2, 8])
##########################################
##########################################

##########################################
## Asignamos x e y,
## Ahora, x e y son numpy arrays de una dimensión con elementos como bytes,
## un numpy array no tiene el método split u otros típicos de strings,
## Para poder transformar los bytes dentro del array a un integer, por ejemplo,

## primero hemos de decodificar el byte a str y sobre el str aplicar el método lstrip

## habría que iterar sobre los elementos del array,

## Hago un bucle forr para que se entienda lo que hace, se podría hacer en una sola línea,

## cada elemento del array sí que tiene el método split ya que AHORA son strings
##########################################
x = cols[:,0].astype(int)
y = cols[:,1]
y_modificado = np.empty_like(y)
for i, elem in enumerate(y):
    elem = elem.decode() # pasamos de byte a str
    if '-' in elem:
        y_modificado[i] = elem.lstrip('0')
    else:
        y_modificado[i] = elem

y_modificado = y_modificado.astype(float)
##########################################
##########################################


plt.plot(x,y_modificado)
plt.show()

Si no se entiende algo a o te falla seguirmos iterando.

[1] https://github.com/numpy/numpy/issues/2715
[2] https://github.com/numpy/numpy/issues/4600
[3] https://github.com/numpy/numpy/pull/4208

[monoBOT]

de entrada te digo que no conozco numpy ... pero en python casi todas las clases (bien hechas) tienen un metodo __str__ que permite visualizar el objeto como string, en tu casi ese metodo ha de existir ya que tu print arroja una representación el objeto.

Seguro que hay formas muchisimas veces mas eficientes de obtener el "numero" de cada posición directamente para ello tienes que estudiarte la documentación. No obstante puedes hacer lo siguiente:

si Y es tu objeto

y.__str__() 

es la representación en string de tu objeto

y.__str__()[.split(' ') 

es tu objeto convertido en lista de strings tomando el espacio como separador.

y.__str__()[.split(' ')[3] 

es el cuarto objeto de la lista, que sería el  '00-4834129'

y.__str__()[.split(' ')[3].replace("'", "")

como tiene ' las tenemos que borrar para que no tengamos problemas mas adelante

y.__str__()[.split(' ')[3].lstrip['0']

quitamos los 0 a la izquierda

 

y.__str__()[.split(' ')[3].lstrip['0'].replace('-')

le quitamos el signo - si lo tiene

int(y.__str__()[.split(' ')[3].lstrip['0'].replace('-'))

por último tenemos el valor entero de la representación en string

[Álvaro Glez.]

Puedes aplicar np.char.lstrip  directamente a la fila/s   y/o   columa/s   donde tienes el problema

http://docs.scipy.org/doc/numpy-1.7.0/reference/generated/numpy.core.defchararray.lstrip.html#numpy.core.defchararray.lstrip

y después cambiar el tipo del array

Un ejemplo:

>>> a = np.array(['00-20', '00-3','000'])
>>> a
array(['00-20', '00-3', '000'],
      dtype='<U5')
>>> a[:2] = np.char.lstrip(a[:2], '0')
>>> a
array(['-20', '-3', '000'],
      dtype='<U5')

Si lo aplicas a todo el array ,además, pasas de tener "000" a "" y no creo que sea lo que quieres.

Un saludo


PD: Di con ello porque me parecia extraño que no hubiese nada de eso en numpy y hubo suerte así era.

---

From: yami...@gmail.com
Date: Tue, 29 Dec 2015 20:05:17 +0100
To: pyth...@python.org
Subject: Re: [Python-es] numpy.absolute

[Pedro Jorge De Los Santos]

Rolando,

Puedes probar con lo siguiente:

y = np.array([float(y[k].split("-")[-1]) for k in range(len(y))])

Y lo mismo con el array "x"...

En este caso, no necesitarás utilizar np.absolute porque el método split "elimina" el signo negativo.

Saludos.

[Rolando Paz]

Hola de nuevo a todos....

Con la ayuda de ustedes logre graficar los datos...

Adjunto las imágenes...

Tengo la opción de representar el dato con el numero negativo o con su valor absoluto.

Agradezco de nuevo a todos...  :-)

Muchos saludos y  FELIZ AÑO NUEVO 2016!!!