Ciao a tutti,
Sto cercando un modo robusto per definire se un intervallo impostato da utente sia divisibile un numero intero di volte per un terzo valore.

(estremi dell'intervallo e valori tutti float)

Per il momento pensavo a qualcosa del genere:

import numpy as np

def foo(sx, dx, val):
	delta = abs(sx - dx)
	delta += np.spacing(delta) # eps calc
	return np.isclose(delta%val, 0., rtol=1e-05, atol=1e-11)

Cosa ne pensate?

Se l'intervallo diventa molto grande l'eps può diventare anche maggiore di atol.

Sarebbe meglio un eps costante piuttosto che calcolato?

Avete in mente qualcosa di meglio?

Grazie a tutti per l'aiuto

Salve a tutti,

dovrei creare una tabella di distribuzione per la quale ad ogni funzione corrispondono differenti alias, per capirci una cosa del genere:

dictio={'a': miafunzione1,
        0: miafunzione1,
        'prima_func': miafunzione1,

        'b': miafunzione2,
        ...}

esiste un modo più agevole?


ho visto che alcuni utilizzano due dict, uno dei quali contenenti solo i differenti alias, del tipo:

alias={'a':0,
       0:0,
       'prima_func':0,
       ...}

dictio={0: miafunzione1,
        ...}

dictio[alias[<key>]]

qual'è il reale vantaggio di una soluzione di questo tipo? grazie a tutti in anticipo

Ciao!
Se ho capito bene quello che hai è un segnale campionato a una certa frequenza di acquisizione.

Ovviamente senza sapere nulla della tua materia (e non essendo di certo un esperto di analisi dei segnali) ne i parametri di acquisizione (tipo frequenza d' acquisizione e tempo di acquisizione) posso solo darti qualche spunto di ragionamento..

Così a scatola chiusa se quello che cerchi è un valore rms opterei per il calcolo di rms e crest factor su finestre viaggianti. Usa un valore di crest factor soglia (come potrebbe essere 5 o 4..) per capire se il tempo della finestra viaggiante sia adatto. Ricorda che il crest factor è un parametro che potremmo vedere come indicatore di Spike presenti nel segnale.

Se quella che cerchi è l'ampiezza del picco ricorda che il segnale è campionato.. Premettendo che la frequenza di campionamento sia adatta allo scopo penserei a una funzione di pre-trigger in modo da riuscire a isolare i picchi dopodiché potresti trovarti il massimo dell'array che isola un solo picco. In base a questo ragionamento potresti buttare giù un algoritmo in modo da ciclarlo su tutto l array, però la natura aleatoria del fenomeno (lo è?) potrebbe darti problemi.

La libreria numpy ha tutto quello che ti serve per fare questo.

In attesa della risposta di quale esperto spero ti sia utile,

Ciao ciao

ciao RicPol ! in realtà ti leggo sempre con molto interesse e ho seguito quasi nella totalità quello che mi hai consigliato quindi sono contento che mi hai risposto .

Sul pattern state era uscito dopo qualche ricerca online dove qualcuno lo consigliava per strutturare casi in cui ci fossero differenti switch ma non avendo capito il nesso (non avendo mai nemmeno avuto occasione di utilizzarlo..) ho chiesto.

Al momento stavo operando con un dizionario che presentava come chiavi delle tuple di lunghezza 3 (es. (None,None,None)) e come valori delle funzioni specifiche (come una sorta di tabella di switch non saprei come chiamarla)... ma come dici tu sicuramente mi sto complicando la vita e non vedo un modo più semplice.

Quello che vorrei ottenere è una funzione relativamente elastica che si comporta in modo differente a seconda degli input. Ti allego un esempio per capirci:

def func(l: list, a=None, b=None, c=None):
    if a is None and b is None and c is None:
        a = 0.
        c = 1.
        b = a + (len(l) -1)*c
    elif a is not None and b is None and c is None:
        c = 1.
        b = a + (len(l) -1)*c
    elif a is None and b is not None and c is None:
        c = 1.
        a = b - (len(l) -1)*c
    elif a is None and b is None and c is not None:
        a = 0.
        b = a + (len(l) -1)*c 
   
    (. . .)
    
    return a,b,c

la def così è totalmente inutile ma il concetto è il medesimo, in sostanza c'è un legame tra le 3 variabili a,b,c ovvero sono legate dalla lunghezza della lista in ingresso, ma non riesco a trovare uno modo per metterlo giù in modo più compatto.

ciao a tutti,

il mio problema è relativo ad una funzione che deve cambiare il suo comportamento a seconda di 3 parametri di input (mettiamo a,b,c). I parametri possono essere None o non None, e ad ogni combinazione di questi 3 parametri è associato un comportamento differente della funzione.

Conoscete un modo di avere questo effetto senza usare quella enorme file di costrutti if elif else? leggevo di un design pattern chiamato state ma so se può fare al caso mio.


grazie a tutti in anticipo!

Nessuno??

Ciao a tutti,
Come da titolo volevo sapere se conoscete qualche funzione numpy (o non) per il confronto di numeri float.

Conosco al momento la funzione isclose di math e numpy ma è valida solo per l uguaglianza. Mi servirebbe anche per >= <= > e <... Nel caso posso sempre comporre operatori logici con isclose ma se c è qualcosa già implementato... Inoltre chiedevo anche cosa solitamente preferite tra tolleranza assoluta e relativa.

Grazie mille in anticipo!


--- Ultima modifica di Bibo90 in data 2019-03-13 13:50:13 ---

si l'ho trovato proprio controllando il sorgente.... però ho domandato proprio perchè non mi è chiarissimo com' è utilizzato... in ogni modo farò qualche prova proprio solo per capire come funziona



Penso inoltre di aver capito come rendono possibile importare solo tramite numpy. le funzioni presenti dei differenti moduli (più o meno annidati) nel package.. in pratica definiscono le variabili __all__ nel modulo delle funzioni che si vuole portare alla root e tramite i file __init__ e degli import * portano le funzioni a livello radice.



Direi che è semplice ed efficace e tra l'altro... mi permetterebbe di togliere quella struttura del codice che se ti ricordi RicPol non ti piaceva ... e tutto risulterebbe più pulito (quindi senza architetture più "strane") e ben distribuito nei vari moduli.



--- Ultima modifica di Bibo90 in data 2019-03-12 17:35:22 ---

be dunque in questo senso... non ha mai senso effettuare una sottoclasse di np.ndarray xD... in quanto gli array numpy non sono di sicuro una classe astratta e tantomeno pensata in questa logica per effettuarne una sottoclasse... ma dunque perchè documentare così bene su come effettuarne una sottoclasse?


Per il momento sto provando entrambe le versioni comunqe e sono tutt'ora indeciso... da un lato con una sottoclasse dovrei scrivere meno codice perchè utilizzerei molte funzioni già dell'array numpy... dall'altro molte di queste non mi servono e/o potrebbero anche creare dei conflitti (ad esempio trattando solo array 1d funzioni come reshape creerebbero degli oggetti che non hanno praticamente senso).

mi spiego meglio, nel mio caso per mera comodità stò suddividendo le differenti funzioni in diversi moduli.


Tuttavia vorrei che tutte queste funzioni siano utilizzabili come appartenenti al modulo radice.

Mi spiego meglio con un esempio relativamente a Numpy;

dopo avere importato numpy come np, se vogliamo creare un array unitario possiamo utilizzare la funzione np.ones... però ones in realtà non apprtiene a numpy.py ma a matlib.py all'interno del package numpy... com'è possibile ottenere questo effetto?

in modo analogo (ma presumibilmente questa cosa è ottenuta in modo differente dal caso precedente ed utilizzando @set_module) se vogliamo creare un matrix possiamo utilizzare np.matrix e non np.matrixlib.defmatrix.matrix ( :confused...

Nel mio caso in modo analogo a livello di utilizzo vorrei che queste funzioni appartenenti tutte alla stessa famigliola di funzioni siano utilizzabili come se fossero tutte presenti nel modulo principale.