InterestRate YieldTermStructure::zeroRate(const Date& d,
                                           const DayCounter& dayCounter,
                                           Compounding comp,
                                           Frequency freq,
                                           bool extrapolate) const {
     if (d==referenceDate()) {
         Real compound = 1.0/discount(dt, extrapolate);
         // t has been calculated with a possibly different daycounter
         // but the difference should not matter for very small times
         return InterestRate::impliedRate(compound,
                                          dayCounter, comp, freq,
                                          dt);
     }
     Real compound = 1.0/discount(d, extrapolate);
     return InterestRate::impliedRate(compound,
                                      dayCounter, comp, freq,
                                      referenceDate(), d);
 }
 InterestRate YieldTermStructure::forwardRate(Time t1,
                                              Time t2,
                                              Compounding comp,
                                              Frequency freq,
                                              bool extrapolate) const {
     Real compound;
     if (t2==t1) {
         checkRange(t1, extrapolate);
         t1 = std::max(t1 - dt/2.0, 0.0);
         t2 = t1 + dt;
         compound = discount(t1, true)/discount(t2, true);
     } else {
         QL_REQUIRE(t2>t1, "t2 (" << t2 << ") < t1 (" << t2 << ")");
         compound = discount(t1, extrapolate)/discount(t2, extrapolate);
     }
     return InterestRate::impliedRate(compound,
                                      dayCounter(), comp, freq,
                                      t2-t1);
 }
 InterestRate YieldTermStructure::zeroRate(Time t,
                                           Compounding comp,
                                           Frequency freq,
                                           bool extrapolate) const {
     if (t==0.0) t = dt;
     Real compound = 1.0/discount(t, extrapolate);
     return InterestRate::impliedRate(compound,
                                      dayCounter(), comp, freq,
                                      t);
 }
int main()
{
    float price=42.99;

    printf("The item costs %.2f\n", price);
    discount(&price);
    printf("With the discount, thats %.2f\n",price);

    return(0);
}
Beispiel #5
0
int main()
{
    float price=42.99;
    float *p;
    p=&price;

    printf("The item costs $%.2f\n",price);
    discount(p);
    printf("With the discount, that's $%.2f\n",price);
    return(0);
}
 InterestRate YieldTermStructure::forwardRate(const Date& d1,
                                              const Date& d2,
                                              const DayCounter& dayCounter,
                                              Compounding comp,
                                              Frequency freq,
                                              bool extrapolate) const {
     if (d1==d2) {
         checkRange(d1, extrapolate);
         Time t1 = std::max(timeFromReference(d1) - dt/2.0, 0.0);
         Time t2 = t1 + dt;
         Real compound =
             discount(t1, true)/discount(t2, true);
         // times have been calculated with a possibly different daycounter
         // but the difference should not matter for very small times
         return InterestRate::impliedRate(compound,
                                          dayCounter, comp, freq,
                                          dt);
     }
     QL_REQUIRE(d1 < d2,  d1 << " later than " << d2);
     Real compound = discount(d1, extrapolate)/discount(d2, extrapolate);
     return InterestRate::impliedRate(compound,
                                      dayCounter, comp, freq,
                                      d1, d2);
 }
/*
	ANT_EVALUATION_INTENT_AWARE_NORMALISED_DISCOUNTED_CUMULATIVE_GAIN::EVALUATE()
	-----------------------------------------------------------------------------
*/
double ANT_evaluation_intent_aware_normalised_discounted_cumulative_gain::evaluate(ANT_search_engine *search_engine, long topic, long *valid, long subtopic)
{
#if 1
double score, precision;
double *dcg, *subtopicGain;
long long i, current_subtopic;
ANT_relevant_topic *got_topic, key_topic;
ANT_relevant_subtopic *got;
ANT_relevant_document key, *relevance_data;
ANT_search_engine_result_iterator iterator;

key_topic.topic = topic;

got_topic = (ANT_relevant_topic *)bsearch(&key_topic, relevant_topic_list, (size_t)relevant_topic_list_length, sizeof(*relevant_topic_list), ANT_relevant_topic::compare);

if (got_topic == NULL)
	{
	printf("Didn't find %ld in qrels... no judgements?\n", topic);
	*valid = false;
	
	return 0;
	}

*valid = true;

dcg = new double[(size_t)precision_point];
subtopicGain = new double[(size_t)got_topic->number_of_subtopics];

for (i = 0; i < precision_point; i++)
	dcg[i] = 0;

for (i = 0; i < got_topic->number_of_subtopics; i++)
	subtopicGain[i] = 1;

key.topic = topic;
#ifdef FILENAME_INDEX
for (i = 0, key.docid = iterator.first(search_engine); key.docid != NULL && i < precision_point; key.docid = iterator.next(), i++)
#else
for (i = 0, key.docid = iterator.first(search_engine); key.docid >= 0 && i < precision_point; key.docid = iterator.next(), i++)
#endif
	{
	score = 0;
	for (current_subtopic = 0; current_subtopic < got_topic->number_of_subtopics; current_subtopic++)
		{
		key.subtopic = got_topic->subtopic_list[current_subtopic].subtopic;

		if ((got = setup(key.topic, key.subtopic)) == NULL)
			continue;

		if ((relevance_data = (ANT_relevant_document *)bsearch(&key, got->document_list, (size_t)got->number_of_documents, sizeof(*got->document_list), ANT_relevant_document::compare)) != NULL)
			if (relevance_data->relevant_characters > 0)
				{
				score += subtopicGain[current_subtopic];
				subtopicGain[current_subtopic] *= 1 - alpha;
				}
		}
	dcg[i] = score * discount(i);
	}

for (i = 1; i < precision_point; i++)
	dcg[i] += dcg[i - 1];

precision = dcg[precision_point - 1];

delete [] subtopicGain;
delete [] dcg;

return precision / ideal_gains[got_topic - relevant_topic_list];

#else
double precision = 0;
long long current_subtopic;
ANT_relevant_topic *got_topic, key_topic;

key_topic.topic = topic;

got_topic = (ANT_relevant_topic *)bsearch(&key_topic, relevant_topic_list, (size_t)relevant_topic_list_length, sizeof(*relevant_topic_list), ANT_relevant_topic::compare);

for (current_subtopic = 0; current_subtopic < got_topic->number_of_subtopics; current_subtopic++)
	precision += ANT_evaluation_discounted_cumulative_gain::evaluate(search_engine, topic, (long)got_topic->subtopic_list[current_subtopic].subtopic);

printf("%f / %f\n", precision, ideal_gains[got_topic - relevant_topic_list]);
return precision / ideal_gains[got_topic - relevant_topic_list];
#endif

#pragma ANT_PRAGMA_UNUSED_PARAMETER
}
/*
	ANT_EVALUATION_INTENT_AWARE_NORMALISED_DISCOUNTED_CUMULATIVE_GAIN::SET_LISTS()
	------------------------------------------------------------------------------
	Calculates a greedy approximation for the best ordering, where the best ordering maximizes
	the gain across all subtopics. The actual solution to this is NP-hard (references in [1]).

	[1] Clarke, C.L.A et. al. A comparative analysis of cascade measures for novelty and diversity. WSDM'11

	Here we misappropriate the best_entry_point value to store whether the assessment has been used or not.
	Can do this because TREC, which doesn't have bep does diversity, and INEX which has bep doesn't.
*/
void ANT_evaluation_intent_aware_normalised_discounted_cumulative_gain::set_lists(ANT_relevant_topic *relevant_topic_list, long long relevant_topic_list_length)
{
#ifdef FILENAME_INDEX
	char *examine_docid, *best_docid = NULL;
#else
	long long examine_docid, best_docid = -1;
#endif
ANT_relevant_topic *got_top;
ANT_relevant_document *current_doc, *first_doc;
long long topic, subtopic, total_documents, relevant_documents, position;
double max_score, current_score = 0;
double *subtopicGain = NULL;
long long this_subtopic_position;

ANT_evaluation::set_lists(relevant_topic_list, relevant_topic_list_length);

ideal_gains = new double[(size_t)relevant_topic_list_length];
for (topic = 0; topic < relevant_topic_list_length; topic++)
	{
	ideal_gains[topic] = 0;
	got_top = relevant_topic_list + topic;
	relevant_documents = total_documents = 0;

	delete [] subtopicGain;
	subtopicGain = new double[(size_t)got_top->number_of_subtopics];

	for (subtopic = 0; subtopic < got_top->number_of_subtopics; subtopic++)
		{
		subtopicGain[subtopic] = 1;
		total_documents += got_top->subtopic_list[subtopic].number_of_documents;
		relevant_documents += got_top->subtopic_list[subtopic].number_of_relevant_documents;
		}

	first_doc = got_top->subtopic_list[0].document_list;

	/*
		We need to try each document for each position in the ideal ordering
	*/
	for (position = 0; position < relevant_documents && position < precision_point; position++)
		{
#ifdef FILENAME_INDEX
		examine_docid = NULL;
#else
		examine_docid = -1;
#endif
		max_score = 0;
		current_doc = first_doc;

		while (current_doc->topic == got_top->topic)
			{
			/*
				If we haven't set the document to examine, then find the first one that hasn't been used
				otherwise find the next judgement for the document
			*/
#ifdef FILENAME_INDEX
			if (examine_docid == NULL)
#else
			if (examine_docid == -1)
#endif
				{
				while (current_doc->topic == got_top->topic && current_doc->best_entry_point != UNUSED)
					current_doc++;

				/*
					If we didn't find a new document to consider then we are done for this ranking position
				*/
				if (current_doc->topic == got_top->topic)
					examine_docid = current_doc->docid;
				else
					break;
				}
			else
#ifdef FILENAME_INDEX
				while (current_doc->topic == got_top->topic && strcmp(current_doc->docid, examine_docid) != 0)
#else
				while (current_doc->topic == got_top->topic && current_doc->docid != examine_docid)
#endif
					current_doc++;

			/*
				If we found an assessment, add it's contribution to this documents score, and mark it examined.
			*/
#ifdef FILENAME_INDEX
			if (current_doc->topic == got_top->topic && strcmp(current_doc->docid, examine_docid) == 0)
#else
			if (current_doc->topic == got_top->topic && current_doc->docid == examine_docid)
#endif
				{
				this_subtopic_position = got_top->subtopic_list[0].subtopic - current_doc->subtopic;
				if (current_doc->relevant_characters > 0)
					current_score += subtopicGain[this_subtopic_position];
				current_doc->best_entry_point = EXAMINED;
				}
			current_doc++;

			/*
				If we've reached the end of the document list, then we should check if this document
				is the best we've encountered so far for this position
			*/
			if (current_doc->topic != got_top->topic && current_doc->docid >= 0)
				{
				if (current_score > max_score)
					{
					max_score = current_score;
					best_docid = examine_docid;
					}

				/*
					Reset for the next document
				*/
				current_doc = first_doc;
#ifdef FILENAME_INDEX
				examine_docid = NULL;
#else
				examine_docid = -1;
#endif
				current_score = 0;
				}
			}

		/*
			Now we've found the best document for this position, then mark those assessments for that
			document as used, and reset the others
		*/
		for (current_doc = first_doc; current_doc->topic == got_top->topic; current_doc++)
#ifdef FILENAME_INDEX
			if (strcmp(current_doc->docid, best_docid) == 0)
#else
			if (current_doc->docid == best_docid)
#endif
				{
				this_subtopic_position = got_top->subtopic_list[0].subtopic - current_doc->subtopic;
				// modify the subtopic gains now we've selected the document we're going to put in this position
				if (current_doc->relevant_characters > 0)
					subtopicGain[this_subtopic_position] *= (1.0 - alpha);
				current_doc->best_entry_point = USED;
				}
			else if (current_doc->best_entry_point == EXAMINED)
				current_doc->best_entry_point = UNUSED;

		/*
			If the maximum score is 0, then we found no more relevant documents, this can happen if 
			some documents are relevant for more than one subtopics. If this happens our gain can't
			get bigger to stop bothering
		*/
		if (max_score == 0)
			break;

		ideal_gains[topic] += max_score * discount(position);
		}
	/*
		Reset the flag for whether the document has been used, so that we can do multiple
		evaluations that need to use this flag
	*/
	for (current_doc = first_doc; current_doc->topic == got_top->topic; current_doc++)
		current_doc->best_entry_point = UNUSED;
	}
}
 Real LiborForwardModel::discountBond(Time, Time maturity, Array) const {
     return discount(maturity);
 }
/*
	ANT_EVALUATION_DISCOUNTED_CUMULATIVE_GAIN::EVALUATE()
	-----------------------------------------------------
*/
double ANT_evaluation_discounted_cumulative_gain::evaluate(ANT_search_engine *search_engine, long topic, long *valid, long subtopic)
{
ANT_search_engine_result_iterator iterator;
ANT_relevant_subtopic *got;
ANT_relevant_document key, *relevance_data;
double discounted_cumulative_gain = 0;
long long current;

if ((got = setup(topic, subtopic)) == NULL)
	{
	*valid = false;
	return 0;
	}
*valid = true;

key.topic = topic;
key.subtopic = subtopic;
current = 0;

#ifdef FILENAME_INDEX
for (key.docid = iterator.first(search_engine); key.docid != NULL && current < precision_point; key.docid = iterator.next(), current++)
#else
for (key.docid = iterator.first(search_engine); key.docid >= 0 && current < precision_point; key.docid = iterator.next(), current++)
#endif
	if ((relevance_data = (ANT_relevant_document *)bsearch(&key, got->document_list, (size_t)got->number_of_documents, sizeof(*got->document_list), ANT_relevant_document::compare)) != NULL)
		if (relevance_data->relevant_characters != 0)
			discounted_cumulative_gain += gain(relevance_data->relevant_characters, current) * discount(current);

return discounted_cumulative_gain;
}
Beispiel #11
0
	double MurexCurve::discount(Date maturity) {
		return discount(dc_.yearFraction(refDate_,maturity));
	}