path: root/pyisda/curve.pyx

from cython.operator import dereference as deref, preincrement as preinc
from libc.math cimport log1p, log, exp, isnan
from .date cimport (JpmcdsStringToDateInterval, pydate_to_TDate, dcc, TMonthDayYear,
                   JpmcdsDateIntervalToFreq, JpmcdsDateFwdThenAdjust, TDate_to_pydate,
                   JpmcdsDateFromBusDaysOffset, JpmcdsStringToDayCountConv, ACT_360,
                   BadDay, FOLLOW, MODIFIED, NONE)
from .date import dcc_tostring
from .date cimport _previous_twentieth, _roll_date
from .cdsone cimport JpmcdsStringToStubMethod
from .legs cimport (JpmcdsCdsContingentLegMake, JpmcdsCdsFeeLegMake,
                   JpmcdsContingentLegPV, JpmcdsFeeLegPV, FeeLegAI, JpmcdsFeeLegFree)

cimport cython
cimport numpy as np
import numpy as np
np.import_array()
import pandas as pd
from cpython cimport Py_buffer
from cpython.bytes cimport PyBytes_GET_SIZE

cdef extern from "Python.h":
    int PyMemoryView_Check(object)
    Py_buffer *PyMemoryView_GET_BUFFER(object)

cdef extern from "numpy/arrayobject.h":
    void PyArray_ENABLEFLAGS(np.ndarray arr, int flags)
    int PyArray_CheckExact(object)
    void* PyArray_DATA(object)
    int PyArray_TYPE(object)
    np.npy_intp PyArray_Size(object)

cdef extern from "lz4.h" nogil:
    int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity)
    int LZ4_decompress_safe(const char* src, char* dst, int compressedSize, int dstCapacity)
    int LZ4_compressBound(int inputSize)

cdef int SUCCESS = 0

cdef inline void double_free(double* ptr) nogil:
    free(ptr)


cdef double survival_prob(const TCurve* curve, TDate start_date, TDate maturity_date, double eps) nogil:
    cdef:
        double lambda1, lambda2
        double t1, t2, u
    if start_date == curve.fBaseDate:
        lambda2 = JpmcdsZeroRate(curve, maturity_date)
        t2 = (maturity_date - curve.fBaseDate) / 365.
        if eps != 0.:
            lambda2 *= (1 + eps)
        return exp(-lambda2 * t2)
    else:
        lambda1 = JpmcdsZeroRate(curve, start_date)
        lambda2 = JpmcdsZeroRate(curve, maturity_date)
        t1 = start_date - curve.fBaseDate
        t2 = maturity_date - curve.fBaseDate
        u = (lambda1 * t1 - lambda2 * t2) / 365.
        if eps != 0.:
            u *= (1 + eps)
        return exp(u)

cdef class Curve(object):

    def __getstate__(self):
        cdef:
            size_t curve_size = self.size()
            unsigned char* buf = <unsigned char*>malloc(curve_size * sizeof(unsigned char))
        serialize(get_TCurve(self), buf)
        cdef bytes r = buf[:curve_size]
        free(buf)
        return r

    def __setstate__(self, bytes state):
        cdef:
            TCurve* curve = <TCurve*>malloc(sizeof(TCurve))
            unsigned char* cursor = state
        deserialize(cursor, curve)
        self._thisptr.reset(curve, JpmcdsFreeTCurve)

    cdef size_t size(self) nogil:
        return TCurve_size(get_TCurve(self))

    @classmethod
    def from_bytes(cls, object state):
        cdef:
            Curve instance = Curve.__new__(Curve)
            TCurve* curve = <TCurve*>malloc(sizeof(TCurve))
            Py_buffer* py_buf
            unsigned char* cursor
        if PyMemoryView_Check(state):
            py_buf = PyMemoryView_GET_BUFFER(state)
            cursor = <unsigned char*>py_buf.buf
        else:
            cursor = <bytes?>state
        deserialize(cursor, curve)
        instance._thisptr.reset(curve, JpmcdsFreeTCurve)
        return instance

    def __hash__(self):
        cdef:
            const TCurve* curve = get_TCurve(self)
            size_t curve_size = self.size()
            unsigned char* buf = <unsigned char*>malloc(curve_size * sizeof(unsigned char))
        serialize(curve, buf)
        cdef uint64_t r = Hash64(<char*>buf, curve_size)
        free(buf)
        return r

    def inspect(self):
        """ method to inspect the content of the C struct

        Returns
        -------
        dict
           contains `base_date`, `basis`, `day_count_counvention` and `data`
        """
        cdef const TCurve* curve = get_TCurve(self)
        return {'base_date': self.base_date,
                'basis': curve.fBasis,
                'day_count_convention': dcc_tostring(curve.fDayCountConv),
                'data': fArray_to_list(curve.fArray, curve.fNumItems)}

    @cython.boundscheck(False)
    @cython.cdivision(True)
    def to_series(self, bint forward=True):
        cdef const TCurve* curve = get_TCurve(self)
        cdef np.npy_intp n = curve.fNumItems
        cdef np.ndarray[np.float64_t,ndim=1] h = np.PyArray_EMPTY(1, &n, np.NPY_DOUBLE, 0)
        cdef np.ndarray[np.int64_t,ndim=1] d = np.PyArray_EMPTY(1, &n, np.NPY_INT64, 0)
        cdef size_t i
        cdef TRatePt* it = curve.fArray
        cdef double t1, h1, t2, h2
        t1 = 0
        h1 = 0
        cdef int base_date = curve.fBaseDate
        if forward:
            for i in range(n):
                h2 = it[i].fRate
                t2 = (it[i].fDate - base_date)/365.
                h[i] = (h2 * t2 - h1 * t1) / (t2 - t1)
                d[i] = it[i].fDate - 134774
                h1 = h2
                t1 = t2
        else:
             for i in range(n):
                h[i] = it[i].fRate
                d[i] = it[i].fDate - 134774
        if isinstance(self, YieldCurve):
            name = 'forward_rates'
        elif isinstance(self, SpreadCurve):
            name = (<SpreadCurve>self).name.get().ticker
            if name == "":
                name = "hazard_rates"
        return pd.Series(h, index=d.view('M8[D]'), name=name)

    def __iter__(self):
        cdef:
            size_t i = 0
            TRatePt* it = get_TCurve(self).fArray
        for i in range(get_TCurve(self).fNumItems):
            yield (TDate_to_pydate(it[i].fDate), it[i].fRate)

    def __len__(self):
        return get_TCurve(self).fNumItems

    def __deepcopy__(self, dict memo):
        cdef Curve sc = Curve.__new__(Curve)
        sc._thisptr.reset(JpmcdsCopyCurve(get_TCurve(self)),
                          JpmcdsFreeTCurve)
        memo[id(self)] = sc
        return sc

    @property
    @cython.cdivision(True)
    def forward_hazard_rates(self):
        cdef double t1, h1, t2, h2
        cdef const TCurve* curve = get_TCurve(self)
        cdef np.npy_intp shape = curve.fNumItems
        t1 = 0
        h1 = 0

        cdef double* data = <double*>malloc(shape * sizeof(double))
        cdef size_t i
        if <Basis>curve.fBasis == Basis.CONTINUOUS:
            for i in range(shape):
                h2 = curve.fArray[i].fRate
                t2 = (curve.fArray[i].fDate - curve.fBaseDate)/365.
                data[i] = (h2 * t2 - h1 * t1) / (t2 - t1)
                h1 = h2
                t1 = t2
        elif <Basis>curve.fBasis == Basis.ANNUAL_BASIS:
            for i in range(shape):
                h2 = log1p(curve.fArray[i].fRate)
                t2 = (curve.fArray[i].fDate - curve.fBaseDate)/365.
                data[i] = (h2 * t2 - h1 * t1) / (t2 - t1)
                h1 = h2
                t1 = t2
        else:
            raise ValueError("Can only convert CONTINUOUS and ANNUAL_BASIS")

        cdef np.ndarray[np.float64_t] out = \
            np.PyArray_SimpleNewFromData(1, &shape, np.NPY_DOUBLE, data)
        PyArray_ENABLEFLAGS(out, np.NPY_OWNDATA)
        return out

    @property
    def base_date(self):
        return TDate_to_pydate(get_TCurve(self).fBaseDate)

    def __forward_zero_price(self, d2, d1=None):
        """ computes the forward zero price at a given date.

        Parameters
        ----------
        date : :class:`datetime.date`

        Returns
        -------
        float
        """
        cdef const TCurve* curve = get_TCurve(self)
        if d1 is None:
            return JpmcdsForwardZeroPrice(curve, curve.fBaseDate,
                                          pydate_to_TDate(d2))
        else:
            return JpmcdsForwardZeroPrice(curve, pydate_to_TDate(d1),
                                          pydate_to_TDate(d2))

cdef fArray_to_list(TRatePt* fArray, int fNumItems):
    cdef size_t i
    cdef list l = []
    for i in range(fNumItems):
        l.append((TDate_to_pydate(fArray[i].fDate), fArray[i].fRate))
    return l

cdef class YieldCurve(Curve):
    """ Initialize a yield curve from a list of zero coupon rates

    Parameters
    ----------
    types : str
        string containing only the letters 'M' (for Money Market ) and
        'S' (for swaps) to describe the type of quotes
    periods : list of str
        Describe the maturity of each instrument (Example: ['3M', '2Y'])
    rates: array.array
        Array of double containing the quotes
    mm_dcc : str
        Day count convention for the money market instrument.
    fixed_swap_period : str
        Period of the fixed leg of the swap.
    float_swap_period : str
        Period of the floating leg of the swap.
    fixed_swap_dcc : str
        Day count convention for the fixed leg of the swap.
    float_swap_dcc : str
        Day count convention for the floating leg of the swap.
    bad_day_conv : int
        Business day convention.


    .. warning:: Instruments need to be sorted by tenor!

    """
    def __init__(self, date, str types,
                 list periods, double[:] rates,
                 str mm_dcc, str fixed_swap_period, str float_swap_period,
                 str fixed_swap_dcc, str float_swap_dcc, BadDay bad_day_conv):

        cdef:
           double fixed_freq
           double float_freq
           TDateInterval ivl
           char* routine = 'zerocurve'
           TDate value_date = pydate_to_TDate(date)

        self.dates = vector[TDate](len(periods))


        cdef TDate settle_date
        if JpmcdsDateFromBusDaysOffset(value_date, 2, "None", &settle_date) != SUCCESS:
            raise ValueError

        cdef:
            TDateInterval tmp
            long period_adjust
            size_t i
            char* period_bytes

        for i, p in enumerate(periods):
            period_bytes = p
            if JpmcdsStringToDateInterval(period_bytes, routine, &tmp) != SUCCESS:
                raise ValueError
            if types[i] == 'M':
                period_adjust = MODIFIED
            else:
                period_adjust = NONE
            if JpmcdsDateFwdThenAdjust(settle_date, &tmp, period_adjust,
                                       "None", &self.dates[i]) != SUCCESS:
                raise ValueError('Invalid interval')

        cdef char* fixed_bytes = fixed_swap_period
        cdef char* float_bytes = float_swap_period
        cdef char* types_bytes = types

        if JpmcdsStringToDateInterval(<char*>fixed_bytes, routine, &ivl) != SUCCESS:
            raise ValueError
        if JpmcdsDateIntervalToFreq(&ivl, &fixed_freq) != SUCCESS:
            raise ValueError
        if JpmcdsStringToDateInterval(float_bytes, routine, &ivl) != SUCCESS:
            raise ValueError
        if JpmcdsDateIntervalToFreq(&ivl, &float_freq) != SUCCESS:
            raise ValueError

        self._thisptr.reset(JpmcdsBuildIRZeroCurve(
            value_date, types_bytes, self.dates.data(),
            &rates[0], self.dates.size(), dcc(mm_dcc), <long> fixed_freq,
            <long> float_freq, dcc(fixed_swap_dcc), dcc(float_swap_dcc),
            bad_day_conv, b"None"
        ), JpmcdsFreeTCurve)

    cdef size_t size(self) nogil:
        return Curve.size(self) + sizeof(size_t) + sizeof(TDate) * self.dates.size()

    def __getstate__(self):
        cdef:
            const TCurve* curve = get_TCurve(self)
            size_t buf_size = self.size()
            unsigned char* buf = <unsigned char*>malloc(buf_size)
            unsigned char* cursor = serialize(curve, buf)

        serialize_vector(self.dates, cursor)
        cdef bytes r = buf[:buf_size]
        free(buf)
        return r

    def __setstate__(self, bytes state):
        cdef:
            TCurve* curve = <TCurve*>malloc(sizeof(TCurve))
            const unsigned char* cursor = state
            size_t num_instr

        cursor = deserialize(cursor, curve)
        self._thisptr.reset(curve, JpmcdsFreeTCurve)
        memcpy(&num_instr, cursor, sizeof(size_t))
        cursor += sizeof(size_t)
        self.dates = vector[TDate](num_instr)
        memcpy(self.dates.data(), cursor, num_instr * sizeof(TDate))

    def __deepcopy__(self, dict memo):
        cdef YieldCurve yc = YieldCurve.__new__(YieldCurve)
        yc._thisptr.reset(JpmcdsCopyCurve(get_TCurve(self)), JpmcdsFreeTCurve)
        yc.dates = vector[TDate](self.dates)
        memo[id(self)] = yc
        return yc

    @classmethod
    def from_bytes(cls, object state):
        cdef:
            YieldCurve instance = YieldCurve.__new__(YieldCurve)
            TCurve* curve = <TCurve*>malloc(sizeof(TCurve))
            size_t num_instr
            Py_buffer* py_buf
            const unsigned char* cursor

        if PyMemoryView_Check(state):
            py_buf = PyMemoryView_GET_BUFFER(state)
            cursor = <unsigned char*>py_buf.buf
        else:
            cursor = <bytes?>state


        cursor = deserialize(cursor, curve)
        instance._thisptr.reset(curve, JpmcdsFreeTCurve)
        memcpy(&num_instr, cursor, sizeof(size_t))
        cursor += sizeof(size_t)
        instance.dates = vector[TDate](num_instr)
        memcpy(instance.dates.data(), cursor, num_instr * sizeof(TDate))
        return instance

    def __hash__(self):
        cdef:
            const TCurve* curve = get_TCurve(self)
            size_t buf_size = self.size()
            size_t size
            unsigned char* buf = <unsigned char*>malloc(buf_size)
            unsigned char* cursor = serialize(curve, buf)

        size = self.dates.size()
        memcpy(cursor, &size, sizeof(size_t))
        cursor += sizeof(size_t)
        memcpy(cursor, self.dates.data(), sizeof(TDate) * size)
        cdef uint64_t r = Hash64(<char*>buf, buf_size)
        free(buf)
        return r

    @classmethod
    def from_discount_factors(cls, base_date, list dates, double[:] dfs, str day_count_conv):
        """ build a yield curve from a list of discount factors """
        cdef TDate base_date_c = pydate_to_TDate(base_date)
        cdef YieldCurve yc = YieldCurve.__new__(YieldCurve)
        yc.dates = vector[TDate](len(dates))
        cdef size_t i
        cdef double* rates = <double*>malloc(sizeof(double) * yc.dates.size())
        for i, d in enumerate(dates):
            yc.dates[i] = pydate_to_TDate(d)
            JpmcdsDiscountToRateYearFrac(dfs[i], <double>(yc.dates[i]-base_date_c)/365.,
                                         <double>1, &rates[i])

        yc._thisptr.reset(
            JpmcdsMakeTCurve(base_date_c, yc.dates.data(), rates, dfs.shape[0],
                             <double>1, dcc(day_count_conv)), JpmcdsFreeTCurve)
        return yc

    discount_factor = Curve.__forward_zero_price

    @property
    def dates(self):
        """ returns the list of instrument dates

        """
        return [TDate_to_pydate(d) for d in self.dates]

    def expected_forward_curve(self, forward_date):
        """ returns the expected forward curve """
        cdef TDate forward_date_c = pydate_to_TDate(forward_date)
        cdef YieldCurve yc = YieldCurve.__new__(YieldCurve)
        cdef size_t i = 0
        while self.dates[i] < forward_date_c:
            i += 1
        yc.dates = vector[TDate](self.dates.size() - i)
        cdef double* rates = <double*>malloc(sizeof(double) * yc.dates.size())
        cdef size_t k
        cdef double df
        for k in range(yc.dates.size()):
            yc.dates[k] = self.dates[i]
            df = JpmcdsForwardZeroPrice(self._thisptr.get(), forward_date_c, self.dates[i])
            JpmcdsDiscountToRateYearFrac(
                df, <double>(self.dates[i] - forward_date_c)/365.,
                <double>1, &rates[k])
            i += 1
        yc._thisptr.reset(JpmcdsMakeTCurve(
            forward_date_c, yc.dates.data(), rates, yc.dates.size(),
            <double>1, self._thisptr.get().fDayCountConv), JpmcdsFreeTCurve)
        return yc

@cython.cdivision(True)
cdef void tweak_curve(const TCurve* sc, TCurve* sc_tweaked, double epsilon,
                      unsigned long mask) nogil:
    ## We want to tweak in the forward space, so we convert the hazard rates
    ## into forward rates and then back
    cdef double h1, h2, t1, t2, c
    h1 = t1 = c = 0
    cdef size_t i

    if mask == 0 or epsilon == 0.:
        return
    else:
        for i in range(sc.fNumItems):
            h2 = sc.fArray[i].fRate
            t2 = (sc.fArray[i].fDate - sc.fBaseDate) / 365.
            c += (h2 * t2 - h1 * t1) * (1 + epsilon * ((mask >> i) & 1))
            sc_tweaked.fArray[i].fRate = c / t2
            h1 = h2
            t1 = t2

cdef class SpreadCurve(Curve):
    """
    Initialize a SpreadCurve from a list of spreads and maturity.

    Parameters
    ----------
    today : :class:`datetime.date`
    yc : :class:`~pyisda.curve.YieldCurve`
    start_date : :class:`datetime.date`
    step_in_date : :class:`datetime.date`
    cash_settle_date: :class:`datetime.date`
    end_dates : list of :class:`datetime.date`
    coupon_rates : :class:`array.array` of double
    upfront_rates : double[:]
    recovery_rates : double[:]
    pay_accrued_on_default : bool, optional
        Default to True

    """
    @cython.boundscheck(False)
    @cython.wraparound(False)
    @cython.initializedcheck(False)
    def __init__(self, today, YieldCurve yc not None, start_date, step_in_date,
                 cash_settle_date, end_dates,
                 const double[:] coupon_rates, const double[:] upfront_rates,
                 const double[:] recovery_rates, bint pay_accrued_on_default=True,
                 str ticker="", Seniority seniority=Senior,
                 DocClause doc_clause=XR14,
                 bint fill_curve=True, defaulted=None):

        cdef TDate today_c = pydate_to_TDate(today)
        cdef TDate step_in_date_c
        cdef TDate cash_settle_date_c
        cdef TDate start_date_c
        cdef string ticker_cpp = ticker
        cdef TRatePt* ptr = NULL

        if start_date is None:
            start_date_c = _previous_twentieth(today_c, True)
            if start_date_c == -1:
                raise ValueError("incorrect today's date: " + today)
        else:
            start_date_c = pydate_to_TDate(start_date)
        if step_in_date is None:
            step_in_date_c = today_c + 1
        else:
            step_in_date_c = pydate_to_TDate(step_in_date)
        if cash_settle_date is None:
            JpmcdsDateFromBusDaysOffset(today_c, 3, "None", &cash_settle_date_c)
        else:
            cash_settle_date_c = pydate_to_TDate(cash_settle_date)

        cdef int n_dates
        cdef TDate* end_dates_c = NULL
        cdef double* tenors_c = NULL
        cdef TCurve* curve = NULL
        cdef TCurve* new_curve = NULL
        cdef unsigned int includes = 0
        cdef size_t i
        cdef bint freeup = False

        if cash_settle_date_c < get_TCurve(yc).fBaseDate:
            raise ValueError("cash_settle_date: {0} is anterior to yc's base_date: {1}".
                             format(cash_settle_date, yc.base_date))
        if defaulted is None:
            self.defaulted = -1
        else:
            self.defaulted = pydate_to_TDate(defaulted)
            # bloomberg reuses company_id for companies that defaulted in the past
            # like American Airlines for instance
            if today_c - self.defaulted > 120:
                self.defaulted = -1

        if isinstance(end_dates, list):
            n_dates = len(end_dates)
            end_dates_c = <TDate*>malloc(n_dates * sizeof(TDate))
            freeup = True
            i = 0
            for d in end_dates:
                end_dates_c[i] = pydate_to_TDate(d)
                if not isnan(upfront_rates[i]):
                    includes |= 1 << i
                i += 1
        elif PyArray_CheckExact(end_dates):
            n_dates = PyArray_Size(end_dates)
            if PyArray_TYPE(end_dates) == np.NPY_INT64:
                end_dates_c = <TDate*>PyArray_DATA(end_dates)
            elif PyArray_TYPE(end_dates) == np.NPY_DOUBLE:
                end_dates_c = <TDate*>malloc(n_dates * sizeof(TDate))
                tenors_c = <double*>PyArray_DATA(end_dates)
                freeup = True
                _roll_date(today_c, tenors_c, n_dates, end_dates_c)
            for i in range(upfront_rates.shape[0]):
                if not isnan(upfront_rates[i]):
                    includes |= 1 << i
        else:
            raise ValueError("end_dates need to be a list of dates, "
                             "or an array of tenors or TDates")

        cdef TStubMethod stub_type
        with nogil:
            stub_type.stubAtEnd = False
            stub_type.longStub = False
            if self.defaulted == -1:
                curve = JpmcdsCleanSpreadCurve(today_c,
                                               get_TCurve(yc),
                                               start_date_c,
                                               step_in_date_c,
                                               cash_settle_date_c,
                                               n_dates,
                                               end_dates_c,
                                               &coupon_rates[0],
                                               &upfront_rates[0],
                                               includes,
                                               &recovery_rates[0],
                                               pay_accrued_on_default,
                                               NULL,
                                               ACT_360,
                                               &stub_type,
                                               MODIFIED,
                                               b'NONE')
            else:
                curve = <TCurve*>malloc(sizeof(TCurve))
                curve.fNumItems = n_dates
                curve.fArray = <TRatePt*>malloc(n_dates * sizeof(TRatePt))
                curve.fBaseDate = today_c
                curve.fBasis = <double>CONTINUOUS
                curve.fDayCountConv = ACT_360
                ptr = curve.fArray
                for i in range(n_dates):
                    ptr.fDate = end_dates_c[i]
                    ptr.fRate = JPMCDS_MAX_RATE
                    preinc(ptr)

            if curve is not NULL:
                if fill_curve and curve.fNumItems != n_dates:
                    new_curve = _fill_curve(curve, end_dates_c, n_dates)
                    JpmcdsFreeTCurve(curve)
                    curve = new_curve
                if freeup:
                    free(end_dates_c)
                self._thisptr.reset(curve, JpmcdsFreeTCurve)
                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))

                self.name = make_shared[CurveName](ticker_cpp,
                                                   <CurveName.Seniority>seniority,
                                                   <CurveName.DocClause>doc_clause)

        if curve is NULL:
            if freeup:
                free(end_dates_c)
            raise ValueError("Didn't init the survival curve properly")


    survival_probability = Curve.__forward_zero_price

    cdef size_t size(self) nogil:
        cdef const TCurve* curve = get_TCurve(self)
        return Curve.size(self) + curve.fNumItems * sizeof(double) + \
            sizeof(TDate) + self.name.get().size()

    def __getstate__(self):
        return self.as_buffer(False)

    cpdef bytes as_buffer(self, bint compressed):
        cdef:
            const TCurve* curve = get_TCurve(self)
            size_t size_recovery = curve.fNumItems * sizeof(double)
            size_t buf_size = TCurve_size(curve) + size_recovery + sizeof(TDate) + \
                self.name.get().size()
            char* buf = <char*>malloc(buf_size)
            unsigned char* cursor = serialize(curve, <unsigned char*>buf)
            int dst_capacity, compressed_size
            char* dst
            bytes r
        memcpy(cursor, self.recovery_rates.get(), size_recovery)
        cursor += size_recovery
        memcpy(cursor, &self.defaulted, sizeof(TDate))
        cursor += sizeof(TDate)
        self.name.get().serialize(cursor)

        if compressed:
            dst_capacity = LZ4_compressBound(buf_size)
            dst = <char*>malloc(dst_capacity)
            compressed_size = LZ4_compress_default(buf, dst, buf_size, dst_capacity)
            r = dst[:compressed_size]
            free(dst)
        else:
            r = buf[:buf_size]

        free(buf)
        return r

    def __setstate__(self, bytes state):
        cdef:
            TCurve* curve = <TCurve*>malloc(sizeof(TCurve))
            const unsigned char* cursor = state
            size_t recovery_size
            double* recovery_rates

        cursor = deserialize(cursor, curve)
        self._thisptr.reset(curve, JpmcdsFreeTCurve)
        recovery_size = curve.fNumItems * sizeof(double)
        recovery_rates = <double*>malloc(recovery_size)
        memcpy(recovery_rates, cursor, recovery_size)
        cursor += recovery_size
        self.recovery_rates.reset(recovery_rates, double_free)
        memcpy(&self.defaulted, cursor, sizeof(TDate))
        cursor += sizeof(TDate)
        self.name = make_shared[CurveName](cursor)

    def __deepcopy__(self, dict memo):
        cdef SpreadCurve sc = SpreadCurve.__new__(SpreadCurve)
        cdef const TCurve* curve = get_TCurve(self)
        cdef size_t recovery_size = curve.fNumItems * sizeof(double)
        sc._thisptr.reset(JpmcdsCopyCurve(curve), JpmcdsFreeTCurve)
        sc.name = make_shared[CurveName](deref(self.name))
        sc.recovery_rates = shared_ptr[double](<double*>malloc(recovery_size), double_free)
        memcpy(sc.recovery_rates.get(), self.recovery_rates.get(), recovery_size)
        sc.defaulted = self.defaulted
        memo[id(self)] = sc
        return sc

    @property
    def defaulted(self):
        return self.defaulted != -1

    @property
    def default_date(self):
        if self.defaulted != -1:
            return TDate_to_pydate(self.defaulted)

    @classmethod
    def from_bytes(cls, object state, bint compressed=False):
        cdef:
            SpreadCurve instance = SpreadCurve.__new__(SpreadCurve)
            const unsigned char* cursor
            const char* src
            char* dst
            TCurve* curve = <TCurve*>malloc(sizeof(TCurve))
            size_t size
            Py_buffer* py_buf


        if PyMemoryView_Check(state):
            py_buf = PyMemoryView_GET_BUFFER(state)
            src = <char*>py_buf.buf
            size = py_buf.len
        else:
            src = <bytes?>state
            size = PyBytes_GET_SIZE(state)
        with nogil:
            if compressed:
                dst = <char*>malloc(500)
                if LZ4_decompress_safe(src, dst, size, 500) < 0:
                    free(dst)
                    raise MemoryError("something went wrong")
                else:
                    cursor = <unsigned char*>dst
            else:
                cursor = <unsigned char*>src
            cursor = deserialize(cursor, curve)
            size = curve.fNumItems * sizeof(double)
            instance.recovery_rates = shared_ptr[double](<double*>malloc(size),
                                                         double_free)

            instance._thisptr.reset(curve, JpmcdsFreeTCurve)
            memcpy(instance.recovery_rates.get(), cursor, size)
            cursor += size
            memcpy(&instance.defaulted, cursor, sizeof(TDate))
            cursor += sizeof(TDate)
            instance.name = make_shared[CurveName](cursor)
            if compressed:
                free(dst)

        return instance

    def __hash__(self):
        # same code as __getstate__
        cdef:
            const TCurve* curve = get_TCurve(self)
            size_t buf_size = self.size()
            size_t size_recovery = curve.fNumItems * sizeof(double)
            unsigned char* buf = <unsigned char*>malloc(buf_size)
            unsigned char* cursor = serialize(curve, buf)
        memcpy(cursor, self.recovery_rates.get(), size_recovery)
        cursor += size_recovery
        memcpy(cursor, &self.defaulted, sizeof(TDate))
        cursor += sizeof(TDate)
        self.name.get().serialize(cursor)
        cdef uint64_t r = Hash64(<char*>buf, buf_size)
        free(buf)
        return r

    @classmethod
    def from_flat_hazard(cls, base_date, double rate, Basis basis=CONTINUOUS,
                         str day_count_conv='Actual/365F', double recov=0.4,
                         str ticker="", Seniority sen=Senior,
                         DocClause doc=XR14):
        """
        Alternative constructor for flat hazard rate Curve.

        Parameters
        ----------
        base_date : datetime.date
            Starting date of the curve
        rate : float
            Flat hazard rate.
        basis : int, optional
            Default to :data:`CONTINUOUS`
        day_count_conv : str, optional
            Default to 'Actual/365F'

        """
        cdef TDate base_date_c = pydate_to_TDate(base_date)
        cdef SpreadCurve sc = SpreadCurve.__new__(SpreadCurve)
        cdef TDate max_date = 200000 # can go higher but this should be more than enough
        cdef string ticker_cpp = ticker
        cdef double* recovery_rates

        sc._thisptr.reset(JpmcdsMakeTCurve(base_date_c, &max_date, &rate, 1,
                                           <double>basis, dcc(day_count_conv)),
                          JpmcdsFreeTCurve)
        recovery_rates = <double*>malloc(sizeof(double))
        recovery_rates[0] = recov
        sc.recovery_rates.reset(recovery_rates, double_free)
        sc.name = make_shared[CurveName](ticker_cpp, <CurveName.Seniority>(sen),
                                         <CurveName.DocClause>(doc))
        return sc

    @cython.boundscheck(False)
    def tweak_curve(self, double epsilon, bint multiplicative=True,
                    unsigned long mask=-1, bint inplace=False):
        """
        Tweak the survival curve in place.

        Parameters
        ----------
        epsilon : double
           tweaking factor (either additive or multiplicative)
        multiplicative : bool, optional
           do we scale by 1+epsilon or add epsilon (default multiplicative).
        mask : bitmask
           Default is tweak everything, otherwise only tweak values
           in the mask.
        """
        cdef:
            const TCurve* curve_orig = get_TCurve(self)
            TCurve* curve_tweaked
            SpreadCurve sc
            int num_items = curve_orig.fNumItems
            double* recovery_rates

        if not inplace:
            sc = SpreadCurve.__new__(SpreadCurve)
            curve_tweaked = JpmcdsCopyCurve(curve_orig)
            sc._thisptr.reset(curve_tweaked, JpmcdsFreeTCurve)
            sc.name = make_shared[CurveName](deref(self.name))
            recovery_rates = <double*>malloc(sizeof(double) * num_items)
            sc.recovery_rates.reset(recovery_rates, double_free)
            memcpy(sc.recovery_rates.get(), self.recovery_rates.get(),
                   num_items * sizeof(double))
        else:
            sc = self
            curve_tweaked = <TCurve*>curve_orig

        if mask != 0:
            tweak_curve(curve_orig, curve_tweaked, epsilon, mask)
        return sc

    @cython.boundscheck(False)
    def par_spread(self, today, step_in_date, start_date, end_dates,
                   const double[:] recovery_rates, YieldCurve yc not None,
                   bint pay_accrued_on_default=True):
        """
        Parameters
        ----------
        recovery_rates : should be same length as end_dates
        """
        cdef TDate today_c = pydate_to_TDate(today)
        cdef TDate step_in_date_c = pydate_to_TDate(step_in_date)
        cdef TDate start_date_c = pydate_to_TDate(start_date)
        cdef int n_dates = len(end_dates)
        cdef TDate* end_dates_c = <TDate*>malloc(n_dates * sizeof(TDate))
        cdef size_t i
        for i, d in enumerate(end_dates):
            end_dates_c[i] = pydate_to_TDate(d)
        cdef double* par_spreads

        cdef TStubMethod stub_type
        if JpmcdsStringToStubMethod(b"f/s", &stub_type) != 0:
            free(end_dates_c)
            raise ValueError("can't convert stub")

        cdef int result
        with nogil:
            par_spreads = <double*>malloc(n_dates * sizeof(double))
            result = JpmcdsCdsParSpreads(today_c,
                                         step_in_date_c,
                                         start_date_c,
                                         n_dates,
                                         end_dates_c,
                                         pay_accrued_on_default,
                                         NULL,
                                         &stub_type,
                                         ACT_360,
                                         MODIFIED,
                                         b'NONE',
                                         get_TCurve(yc),
                                         get_TCurve(self),
                                         &recovery_rates[0],
                                         par_spreads)
            free(end_dates_c)
        cdef list r = []
        if result != SUCCESS:
            free(par_spreads)
            raise ValueError("can't compute par spread")
        else:
            for i in range(n_dates):
                r.append(par_spreads[i])
            free(par_spreads)
            return r

    @property
    def recovery_rates(self):
        cdef np.npy_intp shape = get_TCurve(self).fNumItems
        cdef np.ndarray[np.float64_t] out = \
            np.PyArray_SimpleNewFromData(1, &shape, np.NPY_DOUBLE,
                                         self.recovery_rates.get())
        return out

    @property
    def ticker(self):
        return self.name.get().ticker

    @property
    def full_ticker(self):
        return self.name.get().full_ticker()

    @property
    def seniority(self):
        return Seniority(<int>self.name.get().seniority)

    @property
    def doc_clause(self):
        return DocClause(<int>self.name.get().doc_clause)


@cython.cdivision(True)
@cython.boundscheck(False)
cdef TCurve* _fill_curve(const TCurve* sc, const TDate* end_dates, int n_dates) nogil:
    cdef:
        size_t i
        TDate base_date = sc.fBaseDate
        double t
        TCurve* curve = JpmcdsNewTCurve(base_date, n_dates, <double>CONTINUOUS, 2)
        TRatePt* it = curve.fArray

    for i in range(n_dates):
        t = (end_dates[i] - base_date)/365.
        it[i].fDate = end_dates[i]
        it[i].fRate = -JpmcdsLogForwardZeroPrice(sc, base_date, end_dates[i]) / t
    return curve