Sto lavorando con particolari classi di matrici che ammettono operazioni veloci senza ricorrere a una densa algebra lineare. Per mantenere la gerarchia semplice, attualmente sto facendo la seguente (molto semplificata):
class Matrix:
def mvm() # matrix-vector multiplication
def is_square()
def is_psd()
def is_symm()
def eigenvalue_bound()
class Diag(Matrix):
# represents a diagonal matrix with main diagonal v
# requires O(n) memory and time for all Matrix operations
# where n is the size of v
def __init__(self, v)
class Circulant(Matrix):
# represents a circulant matrix with top row v
# requires O(n lg n) memory and time for all Matrix operations
# where n is the size of v
def __init__(self, v)
class Kronecker(Matrix):
# represents the Kronecker product of two matrices A and B
# requires O(memory(A) + memory(B)) memory for sparse storage
# instead of the dense version, of size O(memory(A) * memory(B))
# Similarly, a Matrix operation taking op(A) and op(B) time
# can be done in O(size(A) * op(B) + size(B) * op(A)).
def __init__(self, A, B)
class Composition(Matrix):
# represents the composition product of two matrices A and B, AB
# requires O(memory(A) + memory(B)) memory
# might save time if op(A) + op(B) < op(AB)
def __init__(self, A, B)
Come puoi vedere, mi preoccupo di molte proprietà delle matrici: semideterminity positive, simmetria, informazioni sugli autovalori. Queste proprietà sono disponibili solo se la matrice soddisfa determinate proprietà matematiche e esse traducono non banalmente tra le matrici.
Ci sono altre matrici e proprietà che sto considerando, ma si spera che questo abbia successo: i metodi che vorrei chiamare su un'istanza di ognuno di questi sono strongmente dipendenti dal contesto in cui vengono create le matrici.
Ho adottato la "semplice" soluzione per far sì che la base contenga l'unione di tutte le proprietà che potrei desiderare, quindi eseguo vari controlli di integrità runtime se un metodo viene chiamato in un determinato contesto.
All'altra estremità dello spettro, questa potrebbe essere una soluzione per l'ereditarietà multipla e i mixin, ma ciò comporterebbe un numero combinatorio di sottoclassi da gestire! Qual è l'approccio migliore qui?
Per chiarimenti: queste matrici sono immutable . Per coerenza, attenersi a python . Un'altra caratteristica importante è che sotto diversi vincoli, la rappresentazione in memoria differisce tra ogni sottotipo. In altre parole, sto solo trattando queste matrici come operatori lineari.