no need for separate struct

3 files changed, 32 insertions, 41 deletions

diff --git a/pyisda/credit_index.pxd b/pyisda/credit_index.pxd
index 961130d..0cf8cf8 100644
--- a/pyisda/credit_index.pxd
+++ b/pyisda/credit_index.pxd
@@ -1,6 +1,6 @@
 from legs cimport TContingentLeg, TFeeLeg
 from date cimport TDate
-from curve cimport TCurve, TRatePt, shared_ptr, Carray
+from curve cimport TCurve, TRatePt, shared_ptr
 from libcpp.vector cimport vector
 from libcpp.unordered_map cimport unordered_map
 from libcpp.string cimport string
@@ -11,7 +11,7 @@ cdef class CurveList:
     cdef vector[double] T
     cdef vector[shared_ptr[TCurve]] curves
     cdef unordered_map[string, size_t] tickers
-    cdef vector[Carray] recovery_rates
+    cdef vector[shared_ptr[double]] recovery_rates
 
 cdef class CreditIndex(CurveList):
     cdef TDate start_date
diff --git a/pyisda/curve.pxd b/pyisda/curve.pxd
index 6432d40..daec974 100644
--- a/pyisda/curve.pxd
+++ b/pyisda/curve.pxd
@@ -197,13 +197,9 @@ cdef class Curve:
 cdef class YieldCurve(Curve):
     cdef vector[TDate] dates
 
-ctypedef struct Carray:
-    shared_ptr[double] data
-    size_t size
-
 cdef class SpreadCurve(Curve):
     cdef string ticker
-    cdef Carray recovery_rates
+    cdef shared_ptr[double] recovery_rates
 
 cdef fArray_to_list(TRatePt* fArray, int fNumItems)
 
diff --git a/pyisda/curve.pyx b/pyisda/curve.pyx
index 26b3c79..e852d3d 100644
--- a/pyisda/curve.pyx
+++ b/pyisda/curve.pyx
@@ -530,10 +530,11 @@ cdef class SpreadCurve(Curve):
             raise ValueError("Didn't init the survival curve properly")
         else:
             self._thisptr = make_shared(curve)
-            self.recovery_rates.size = recovery_rates.shape[0] * sizeof(double)
-            self.recovery_rates.data = shared_ptr[double](<double*>malloc(self.recovery_rates.size),
-                                                          double_free)
-            memcpy(<void*>self.recovery_rates.data.get(), &recovery_rates[0], self.recovery_rates.size)
+            self.recovery_rates = shared_ptr[double](
+                <double*>malloc(curve.fNumItems * sizeof(double)),
+                double_free)
+            memcpy(<void*>self.recovery_rates.get(), &recovery_rates[0],
+                   curve.fNumItems * sizeof(double))
             if ticker:
                 self.ticker = ticker.encode()
 
@@ -546,7 +547,7 @@ cdef class SpreadCurve(Curve):
             TCurve* curve = self._thisptr.get()
             size_t size = TCurve_size(curve.fNumItems)
             size_t buf_size = size + sizeof(size_t) + self.ticker.length() + \
-                              sizeof(size_t) + self.recovery_rates.size
+                              curve.fNumItems * sizeof(double)
             unsigned char* buf = <unsigned char*>malloc(buf_size)
             unsigned char* cursor = buf + size
         serialize(curve, buf)
@@ -554,10 +555,8 @@ cdef class SpreadCurve(Curve):
         memcpy(cursor, &size, sizeof(size_t))
         cursor += sizeof(size_t)
         cursor += self.ticker.copy(<char*>cursor, size, 0)
-        size = self.recovery_rates.size
-        memcpy(cursor, &size, sizeof(size_t))
-        cursor += sizeof(size_t)
-        memcpy(cursor, self.recovery_rates.data.get(), self.recovery_rates.size)
+        size = self._thisptr.get().fNumItems * sizeof(double)
+        memcpy(cursor, self.recovery_rates.get(), size)
         return <bytes>buf[:buf_size]
 
     @cython.initializedcheck(False)
@@ -566,8 +565,7 @@ cdef class SpreadCurve(Curve):
         cdef:
             TCurve* curve = <TCurve*>malloc(sizeof(TCurve))
             unsigned char* cursor = state
-            size_t ticker_length
-            np.npy_intp size
+            size_t ticker_length, size
             double* temp
         cursor = deserialize(cursor, curve)
         self._thisptr = make_shared(curve)
@@ -575,21 +573,18 @@ cdef class SpreadCurve(Curve):
         cursor += sizeof(size_t)
         self.ticker = string(<char*>cursor, ticker_length)
         cursor += ticker_length
-        memcpy(&size, cursor, sizeof(size_t))
-        self.recovery_rates.size = size
-        self.recovery_rates.data = shared_ptr[double](<double*>malloc(self.recovery_rates.size),
-                                                      double_free)
-        cursor += sizeof(size_t)
-        memcpy(self.recovery_rates.data.get(), cursor, size)
+        size = curve.fNumItems * sizeof(double)
+        self.recovery_rates = shared_ptr[double](<double*>malloc(size),
+                                                 double_free)
+        memcpy(self.recovery_rates.get(), cursor, size)
 
     def __deepcopy__(self, dict memo):
         cdef SpreadCurve sc = SpreadCurve.__new__(SpreadCurve)
+        cdef size_t size = self._thisptr.get().fNumItems * sizeof(double)
         sc._thisptr = make_shared(JpmcdsCopyCurve(self._thisptr.get()))
         sc.ticker = self.ticker
-        sc.recovery_rates.data = shared_ptr[double](<double*>malloc(self.recovery_rates.size),
-                                                    double_free)
-        memcpy(sc.recovery_rates.data.get(), self.recovery_rates.data.get(), self.recovery_rates.size)
-        sc.recovery_rates.size = self.recovery_rates.size
+        sc.recovery_rates= shared_ptr[double](<double*>malloc(size), double_free)
+        memcpy(sc.recovery_rates.get(), self.recovery_rates.get(), size)
         memo[id(self)] = sc
         return sc
 
@@ -613,25 +608,23 @@ cdef class SpreadCurve(Curve):
         memcpy(&ticker_length, cursor, sizeof(size_t))
         cursor += sizeof(size_t)
         instance.ticker = string(<char*>cursor, ticker_length)
-        memcpy(&size, cursor, sizeof(size_t))
-        instance.recovery_rates.size = size
-        instance.recovery_rates.data = shared_ptr[double](<double*>malloc(size), double_free)
-        cursor += sizeof(size_t)
-        memcpy(instance.recovery_rates.data.get(), cursor, size)
+        size = curve.fNumItems * sizeof(double)
+        instance.recovery_rates = shared_ptr[double](
+            <double*>malloc(size), double_free)
+        memcpy(instance.recovery_rates.get(), cursor, size)
         return instance
 
     def __hash__(self):
         cdef:
             TCurve* curve = self._thisptr.get()
             size_t size = TCurve_size(curve.fNumItems)
-            size_t buf_size = size + sizeof(size_t) + self.ticker.length()
+            size_t buf_size = size + sizeof(size_t) + self.ticker.length() + \
+                              curve.fNumItems * sizeof(double)
             unsigned char* buf = <unsigned char*>malloc(buf_size)
             unsigned char* cursor = buf + size
         serialize(curve, buf)
-        size = self.ticker.length()
-        memcpy(cursor, &size, sizeof(size_t))
-        cursor += sizeof(size_t)
-        self.ticker.copy(<char*>cursor, size, 0)
+        cursor += self.ticker.copy(<char*>cursor, self.ticker.length(), 0)
+        memcpy(cursor, self.recovery_rates.get(), curve.fNumItems * sizeof(double))
         cdef uint64_t r = Hash64(<char*>buf, buf_size)
         free(buf)
         return r
@@ -691,6 +684,8 @@ cdef class SpreadCurve(Curve):
             curve_tweaked = JpmcdsCopyCurve(self._thisptr.get())
             sc._thisptr = make_shared(curve_tweaked)
             sc.ticker = self.ticker
+            # memcpy(sc.recovery_rates.get(), self.recovery_rates.get(),
+            #        self._thisptr.get().fNumItems * sizeof(double))
             sc.recovery_rates = self.recovery_rates
         else:
             sc = self
@@ -758,10 +753,10 @@ cdef class SpreadCurve(Curve):
 
     @property
     def recovery_rates(self):
-        cdef np.npy_intp* shape = <np.npy_intp*>&self.recovery_rates.size
+        cdef np.npy_intp shape = <np.npy_intp>self._thisptr.get().fNumItems
         cdef np.ndarray[np.float64_t] out = \
-            np.PyArray_SimpleNewFromData(1, shape, np.NPY_DOUBLE,
-                                         self.recovery_rates.data.get())
+            np.PyArray_SimpleNewFromData(1, &shape, np.NPY_DOUBLE,
+                                         self.recovery_rates.get())
         return out
 
 @cython.boundscheck(False)