Programação orientada a objeto vs baseada em vetor

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!

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?

Projete objetos maiores. Um Pixelobjeto não tem espaço para respirar para um loop paralelo ou transformações de imagem da GPU ou algo assim. E Imagedesde que ele não precise atravessar a barreira de um Pixelobjeto pequenino para acessar os dados.

Essa é uma daquelas áreas em que é impossível dar respostas definitivas, porque se trata de uma troca. Como você descobriu, nem o OO, nem o vetor são sempre superiores, mas tudo depende de como o software será usado.

Você pode tentar combinar o melhor de ambos e criar um Volatilityobjeto e um VolatilitySeriesobjeto, onde o segundo representa conceitualmente objetos da Série of Volatility, mas usa internamente um método de armazenamento que é muito mais adequado para vetorizar os cálculos (uma estrutura de matrizes) . Então você só precisa educar seus usuários que o uso VolatilitySeriesé muito preferível Series(Volatility).