path: root/pyisda/curve.pyx

from libc.stdlib cimport malloc, free, calloc
from libc.math cimport log1p, log
from libcpp.vector cimport vector
from libcpp.string cimport string
from date cimport (JpmcdsStringToDateInterval, pydate_to_TDate, dcc,
                   JpmcdsDateIntervalToFreq, JpmcdsDateFwdThenAdjust, TDate_to_pydate,
                   JpmcdsDateFromBusDaysOffset, JpmcdsStringToDayCountConv, ACT_360)
from date import dcc_tostring
from cdsone cimport JpmcdsStringToStubMethod, TStubMethod
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

cdef extern from "numpy/arrayobject.h":
    void PyArray_ENABLEFLAGS(np.ndarray arr, int flags)

cdef int SUCCESS = 0

cpdef public enum BadDay:
    FOLLOW = <long>'F'
    PREVIOUS = <long>'P'
    NONE = <long>'N'
    MODIFIED = <long>'M'

cdef inline shared_ptr[TCurve] make_shared(TCurve* ptr) nogil:
    return shared_ptr[TCurve](ptr, JpmcdsFreeTCurve)

cdef class Curve(object):

    def __getstate__(self):
        cdef:
            TCurve* curve = self._thisptr.get()
            size_t curve_size = TCurve_size(curve.fNumItems)
            unsigned char* buf = <unsigned char*>malloc(curve_size * sizeof(unsigned char))
        serialize(curve, buf)
        return <bytes>buf[:curve_size]

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

    @classmethod
    def from_bytes(cls, bytes state):
        cdef:
            Curve instance = Curve.__new__(Curve)
            unsigned char* cursor = state
            TCurve* curve = <TCurve*>malloc(sizeof(TCurve))
        deserialize(cursor, curve)
        instance._thisptr = make_shared(curve)
        return instance

    def __hash__(self):
        cdef:
            TCurve* curve = self._thisptr.get()
            size_t curve_size = TCurve_size(curve.fNumItems)
            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`
        """

        return {'base_date': self.base_date,
                'basis': self._thisptr.get().fBasis,
                'day_count_convention': dcc_tostring(self._thisptr.get().fDayCountConv),
                'data': fArray_to_list(self._thisptr.get().fArray, self._thisptr.get().fNumItems)}

    @cython.boundscheck(False)
    @cython.cdivision(True)
    def to_series(self, bint forward=True):
        cdef np.npy_intp n = self._thisptr.get().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 = self._thisptr.get().fArray
        cdef double t1, h1, t2, h2
        t1 = 0
        h1 = 0
        cdef int base_date = self._thisptr.get().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
        return pd.Series(h, index=d.view('M8[D]'), name=self.ticker \
                         if self.ticker else 'hazard_rates')

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

    def __len__(self):
        return self._thisptr.get().fNumItems

    def __deepcopy__(self, memo):
        cdef Curve sc = Curve.__new__(Curve)
        sc._thisptr = make_shared(JpmcdsCopyCurve(self._thisptr.get()))
        return sc

    @property
    @cython.cdivision(True)
    def forward_hazard_rates(self):
        cdef double t1, h1, t2, h2
        cdef np.npy_intp shape = self._thisptr.get().fNumItems
        t1 = 0
        h1 = 0
        cdef TCurve* curve = self._thisptr.get()
        cdef double* data = <double*>malloc(curve.fNumItems * sizeof(double))
        cdef size_t i
        if <Basis>curve.fBasis == Basis.CONTINUOUS:
            for i in range(curve.fNumItems):
                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(curve.fNumItems):
                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(self._thisptr.get().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
        """
        if not self._thisptr:
            raise ValueError('curve is empty')
        cdef TDate start_date
        if d1 is None:
            start_date = self._thisptr.get().fBaseDate
            return JpmcdsForwardZeroPrice(self._thisptr.get(), start_date,
                                          pydate_to_TDate(d2))
        else:
            return JpmcdsForwardZeroPrice(self._thisptr.get(), 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

        for i, p in enumerate(periods):
            period_bytes = p.encode('utf-8')
            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 bytes fixed_bytes = fixed_swap_period.encode('utf-8')
        cdef bytes float_bytes = float_swap_period.encode('utf-8')
        cdef bytes types_bytes = types.encode('utf-8')

        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 = make_shared(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"
        ))

    def __getstate__(self):
        cdef:
            TCurve* curve = self._thisptr.get()
            size_t size = TCurve_size(curve.fNumItems)
            size_t buf_size = size + sizeof(size_t) + sizeof(TDate) * self.dates.size()
            unsigned char* buf = <unsigned char*>malloc(buf_size)
            unsigned char* cursor = buf + size
        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)
        return <bytes>buf[:buf_size]

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

        cursor = deserialize(cursor, curve)
        self._thisptr = make_shared(curve)
        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))

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

        cursor = deserialize(cursor, curve)
        instance._thisptr = make_shared(curve)
        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:
            TCurve* curve = self._thisptr.get()
            size_t size = TCurve_size(curve.fNumItems)
            size_t buf_size = size + sizeof(size_t) + sizeof(TDate) * self.dates.size()
            unsigned char* buf = <unsigned char*>malloc(buf_size)
            unsigned char* cursor = buf + size
        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 = make_shared(
            JpmcdsMakeTCurve(base_date_c, yc.dates.data(), rates, dfs.shape[0],
                             <double>1, dcc(day_count_conv)))
        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 = make_shared(JpmcdsMakeTCurve(
            forward_date_c, yc.dates.data(), rates, yc.dates.size(),
            <double>1, self._thisptr.get().fDayCountConv))
        return yc

@cython.cdivision(True)
cdef void tweak_curve(TCurve* sc, TCurve* sc_tweaked, double epsilon,
                      vector[double]& h, const vector[double]& T, 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
    h1 = t1 = 0
    cdef size_t i
    for i in range(T.size()):
        h2 = sc.fArray[i].fRate
        t2 = T[i]
        h[i] = (h2 * t2 - h1 * t1) / (t2 - t1)
        if mask == 0 or (mask >> i) & 1:
            h[i] *= (1 + epsilon)
        h1 = h2
        t1 = t2

    t1 = 0
    cdef double c = 0
    for i in range(T.size()):
        c += (T[i] - t1) * h[i]
        sc_tweaked.fArray[i].fRate = c / T[i]
        t1 = T[i]

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
    recovery_rate : float
    pay_accrued_on_default : bool, optional
        Default to True

    """
    @cython.boundscheck(False)
    @cython.wraparound(False)
    @cython.initializedcheck(False)
    def __init__(self, today, YieldCurve yc, start_date, step_in_date,
                 cash_settle_date, end_dates,
                 double[:] coupon_rates, double[:] upfront_rates,
                 double[:] recovery_rates, bint pay_accrued_on_default=True,
                 str ticker=None):

        cdef TDate today_c = pydate_to_TDate(today)
        cdef TDate step_in_date_c = pydate_to_TDate(step_in_date)
        cdef TDate cash_settle_date_c = pydate_to_TDate(cash_settle_date)
        cdef TDate start_date_c = pydate_to_TDate(start_date)
        cdef int n_dates = len(end_dates)
        cdef TDate* end_dates_c = NULL
        cdef TDate[:] end_dates_view
        cdef TCurve* curve = NULL
        cdef unsigned int includes = 0
        cdef size_t i
        if cash_settle_date_c < yc._thisptr.get().fBaseDate:
            raise ValueError("cash_settle_date: {0} is anterior to yc's base_date: {1}".
                             format(cash_settle_date, yc.base_date))

        if isinstance(end_dates, list):
            end_dates_c = <TDate*>malloc(n_dates * sizeof(TDate))
            end_dates_view = <TDate[:n_dates]>end_dates_c
            for i, d in enumerate(end_dates):
                end_dates_view[i] = pydate_to_TDate(d)
                if upfront_rates[i] == upfront_rates[i]:
                    includes |= 1 << i
        else:
            end_dates_view = memoryview(end_dates)
            for i in range(n_dates):
                if upfront_rates[i] == upfront_rates[i]:
                    includes |= 1 << i

        cdef TStubMethod stub_type
        if JpmcdsStringToStubMethod(b"f/s", &stub_type) != 0:
            raise ValueError("can't convert stub")
        with nogil:
            curve = JpmcdsCleanSpreadCurve(today_c,
                                           yc._thisptr.get(),
                                           start_date_c,
                                           step_in_date_c,
                                           cash_settle_date_c,
                                           n_dates,
                                           &end_dates_view[0],
                                           &coupon_rates[0],
                                           &upfront_rates[0],
                                           includes,
                                           &recovery_rates[0],
                                           pay_accrued_on_default,
                                           NULL,
                                           ACT_360,
                                           &stub_type,
                                           <long>'M',
                                           b'NONE')
            if end_dates_c:
                free(end_dates_c)
        if curve == NULL:
            raise ValueError("Didn't init the survival curve properly")
        else:
            self._thisptr = make_shared(curve)
            if ticker:
                self.ticker = ticker.encode()

    survival_probability = Curve.__forward_zero_price

    def __getstate__(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()
            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)
        return <bytes>buf[:buf_size]

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

        cursor = deserialize(cursor, curve)
        self._thisptr = make_shared(curve)
        memcpy(&ticker_length, cursor, sizeof(size_t))
        cursor += sizeof(size_t)
        self.ticker = string(<char*>cursor, ticker_length)

    @classmethod
    def from_bytes(cls, bytes state):
        cdef:
            SpreadCurve instance = SpreadCurve.__new__(SpreadCurve)
            unsigned char* cursor = state
            TCurve* curve = <TCurve*>malloc(sizeof(TCurve))
            size_t ticker_length

        cursor = deserialize(cursor, curve)
        instance._thisptr = make_shared(curve)
        memcpy(&ticker_length, cursor, sizeof(size_t))
        cursor += sizeof(size_t)
        instance.ticker = string(<char*>cursor, ticker_length)
        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()
            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)
        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'):
        """
        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

        sc._thisptr = make_shared(JpmcdsMakeTCurve(base_date_c, &max_date, &rate, 1,
                                                   <double>basis, dcc(day_count_conv)))
        return sc

    @cython.boundscheck(False)
    def tweak_curve(self, double epsilon, bint multiplicative=True,
                    unsigned long mask=0, 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 : array of bool or None
           If None (default), tweak everything, otherwise only tweak values
           in the mask.
        """
        cdef:
            TCurve* curve_tweaked
            SpreadCurve sc
            int num_items = self._thisptr.get().fNumItems
            vector[double] h
            vector[double] T
            size_t i

        if not inplace:
            sc = SpreadCurve.__new__(SpreadCurve)
            curve_tweaked = JpmcdsCopyCurve(self._thisptr.get())
            sc._thisptr = make_shared(curve_tweaked)
            sc.ticker = self.ticker
        else:
            sc = self
            curve_tweaked = self._thisptr.get()

        h = vector[double](num_items)
        T = vector[double](num_items)
        for i in range(num_items):
            T[i] = (curve_tweaked.fArray[i].fDate - curve_tweaked.fBaseDate) / 365.

        if mask != 0:
            tweak_curve(self._thisptr.get(), curve_tweaked, epsilon, h, T, mask)
        return sc

    @cython.boundscheck(False)
    def par_spread(self, today, step_in_date, start_date, end_dates,
                   double[:] recovery_rates, YieldCurve yc, bint pay_accrued_on_default):
        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,
                                         <long>'M',
                                         b'NONE',
                                         yc._thisptr.get(),
                                         self._thisptr.get(),
                                         &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 ticker(self):
        return self.ticker.decode()

@cython.boundscheck(False)
@cython.wraparound(False)
@cython.initializedcheck(False)
@cython.cdivision(True)
def fill_curve(SpreadCurve sc, TDate[:] end_dates):

    cdef size_t n_dates = end_dates.shape[0]
    cdef size_t i
    cdef TDate base_date = sc._thisptr.get().fBaseDate
    cdef double t
    cdef TCurve* curve = JpmcdsNewTCurve(sc._thisptr.get().fBaseDate,
                                         n_dates,
                                         5000.,
                                         2)
    cdef 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 = -log(JpmcdsForwardZeroPrice(sc._thisptr.get(), base_date,
                                                  end_dates[i])) / t

    cdef SpreadCurve sc_new = SpreadCurve.__new__(SpreadCurve)
    sc_new._thisptr = make_shared(curve)
    sc_new.ticker = sc.ticker
    return sc_new