Estou dividido entre o design orientado a objetos e o vetor. Adoro as habilidades, a estrutura e a segurança que os objetos dão a toda a arquitetura. Mas, ao mesmo tempo, a velocidade é muito importante para mim, e ter variáveis flutuantes simples em uma matriz realmente ajuda em bibliotecas / linguagens baseadas em vetores como Matlab ou numpy em Python.
Aqui está um pedaço de código que escrevi para ilustrar meu ponto
Problema: Adicionando números de volatilidade do Tow. Se xey são dois números de volatilidade, a soma da volatilidade é (x ^ 2 + y ^ 2) ^ 0,5 (assumindo certas condições matemáticas, mas isso não é importante aqui).
Quero executar essa operação muito rapidamente e, ao mesmo tempo, preciso garantir que as pessoas não adicionem apenas a volatilidade da maneira errada (x + y). Ambos são importantes.
O design baseado em OO seria algo como isto:
from datetime import datetime
from pandas import *
class Volatility:
def __init__(self,value):
self.value = value
def __str__(self):
return "Volatility: "+ str(self.value)
def __add__(self,other):
return Volatility(pow(self.value*self.value + other.value*other.value, 0.5))
(Além disso: para quem é novo no Python, __add__
é apenas uma função que substitui o +
operador)
Digamos que eu adicione duas listas de valores de volatilidade
n = 1000000
vs1 = Series(map(lambda x: Volatility(2*x-1.0), range(0,n)))
vs2 = Series(map(lambda x: Volatility(2*x+1.0), range(0,n)))
(Além disso: Novamente, uma série em Python é uma espécie de lista com um índice) Agora, quero adicionar as duas:
t1 = datetime.now()
vs3 = vs1 + vs2
t2 = datetime.now()
print t2-t1
Apenas a adição é executada em 3,8 segundos na minha máquina, os resultados que eu forneci não incluem o tempo de inicialização do objeto, é apenas o código de adição que foi cronometrado. Se eu executar a mesma coisa usando matrizes numpy:
nv1 = Series(map(lambda x: 2.0*x-1.0, range(0,n)))
nv2 = Series(map(lambda x: 2.0*x+1.0, range(0,n)))
t3 = datetime.now()
nv3 = numpy.sqrt((nv1*nv1+nv2*nv2))
t4 = datetime.now()
print t4-t3
É executado em 0,03 segundos. Isso é mais de 100 vezes mais rápido!
Como você pode ver, o modo POO me dá muita segurança para que as pessoas não adicionem Volatilidade da maneira errada, mas o método vetorial é tão rápido demais! Existe um design no qual eu possa obter os dois? Tenho certeza de que muitos de vocês já escolheram opções de design semelhantes. Como vocês resolveram isso?
A escolha do idioma aqui é imaterial. Sei que muitos de vocês recomendariam o uso de C ++ ou Java, e o código pode ser executado mais rapidamente do que as linguagens baseadas em vetores. Mas esse não é o ponto. Preciso usar o Python, porque tenho várias bibliotecas não disponíveis em outros idiomas. Essa é a minha restrição. Eu preciso otimizar dentro dele.
E eu sei que muitas pessoas sugeririam paralelização, gpgpu etc. Mas quero maximizar primeiro o desempenho de núcleo único e, em seguida, paralelizar as duas versões do código.
Desde já, obrigado!