internal void AddVector(ITraits vec)
{
Bad_Good += vec.Bad_Good;
False_Honest += vec.False_Honest;
Timid_Powerful += vec.Timid_Powerful;
/*if (Traits == Trait.All)
* {
* Trait newTraits = Trait.None;
* if (Bad_Good.Number != 0)
* newTraits |= Trait.Bad_Good;
* if (False_Honest.Number != 0)
* newTraits |= Trait.False_Honest;
* if (Timid_Powerful.Number != 0)
* newTraits |= Trait.Timid_Powerful;
* }
* else if (Traits == Trait.None)
* {
* if (vec.Bad_Good != 0)
* Traits |= Trait.Bad_Good;
* if (vec.False_Honest != 0)
* Traits |= Trait.False_Honest;
* if (vec.Timid_Powerful != 0)
* Traits |= Trait.Timid_Powerful;
* }
* else
* {
* if ()
* }*/
}
public ScoringDialogTask(IDialogTask inner, IComparer <Score> comparer, ITraits <Score> traits, params IScorable <Score>[] scorables)
: base(inner)
{
SetField.NotNull(out this.comparer, nameof(comparer), comparer);
SetField.NotNull(out this.traits, nameof(traits), traits);
SetField.NotNull(out this.scorables, nameof(scorables), scorables);
}
public static YieldTermStructure factory <Interpolator>(this ITraits <YieldTermStructure> self,
int settlementDays,
Calendar calendar,
DayCounter dayCounter,
List <Handle <Quote> > jumps = null,
List <Date> jumpDates = null,
Interpolator interpolator = default(Interpolator))
where Interpolator : class, IInterpolationFactory, new()
{
if (self.GetType().Equals(typeof(Discount)))
{
return(new InterpolatedDiscountCurve <Interpolator>(settlementDays, calendar, dayCounter, jumps, jumpDates, interpolator));
}
else if (self.GetType().Equals(typeof(ZeroYield)))
{
return(new InterpolatedZeroCurve <Interpolator>(settlementDays, calendar, dayCounter, jumps, jumpDates, interpolator));
}
else if (self.GetType().Equals(typeof(ForwardRate)))
{
return(new InterpolatedForwardCurve <Interpolator>(settlementDays, calendar, dayCounter, jumps, jumpDates, interpolator));
}
else
{
return(null);
}
}
public static YieldTermStructure factory <Interpolator>(this ITraits <YieldTermStructure> self,
List <Date> dates,
List <double> discounts,
DayCounter dayCounter,
Calendar calendar,
Interpolator interpolator)
where Interpolator : class, IInterpolationFactory, new()
{
if (self.GetType().Equals(typeof(Discount)))
{
return(new InterpolatedDiscountCurve <Interpolator>(dates, discounts, dayCounter, calendar, interpolator));
}
else if (self.GetType().Equals(typeof(ZeroYield)))
{
return(new InterpolatedZeroCurve <Interpolator>(dates, discounts, dayCounter, calendar, interpolator));
}
else if (self.GetType().Equals(typeof(ForwardRate)))
{
return(new InterpolatedForwardCurve <Interpolator>(dates, discounts, dayCounter, calendar, interpolator));
}
else
{
return(null);
}
}
public static DefaultProbabilityTermStructure factory <Interpolator>(this ITraits <DefaultProbabilityTermStructure> self,
int settlementDays,
Calendar calendar,
DayCounter dayCounter,
List <Handle <Quote> > jumps = null,
List <Date> jumpDates = null,
Interpolator interpolator = default(Interpolator))
where Interpolator : class, IInterpolationFactory, new()
{
if (self.GetType().Equals(typeof(SurvivalProbability)))
{
return(new InterpolatedSurvivalProbabilityCurve <Interpolator>(settlementDays, calendar, dayCounter, jumps, jumpDates, interpolator));
}
else if (self.GetType().Equals(typeof(HazardRate)))
{
return(new InterpolatedHazardRateCurve <Interpolator>(settlementDays, calendar, dayCounter, jumps, jumpDates, interpolator));
}
else if (self.GetType().Equals(typeof(DefaultDensity)))
{
return(new InterpolatedDefaultDensityCurve <Interpolator>(settlementDays, calendar, dayCounter, jumps, jumpDates, interpolator));
}
else
{
return(null);
}
}
public DialogRouter(
IDialogStack stack,
IEnumerable <IScorable <IActivity, double> > fromActivity,
IEnumerable <IScorable <IResolver, double> > fromResolver,
Func <IActivity, IResolver> makeResolver,
ITraits <double> traits,
IComparer <double> comparer)
: base(MakeDelegate(stack, fromActivity, fromResolver, makeResolver, traits, comparer))
{
}
public static YoYInflationTermStructure factory <Interpolator>(this ITraits <YoYInflationTermStructure> self,
Date referenceDate, Calendar calendar, DayCounter dayCounter, Period lag,
Frequency frequency, bool indexIsInterpolated, double baseZeroRate,
Handle <YieldTermStructure> yTS,
Interpolator interpolator = default(Interpolator))
where Interpolator : class, IInterpolationFactory, new()
{
return(new InterpolatedYoYInflationCurve <Interpolator>(referenceDate, calendar, dayCounter, lag, frequency,
indexIsInterpolated, baseZeroRate, yTS, interpolator));
}
public static IScorable <IActivity, double> MakeDelegate(
IDialogStack stack,
IEnumerable <IScorable <IActivity, double> > fromActivity,
IEnumerable <IScorable <IResolver, double> > fromResolver,
Func <IActivity, IResolver> makeResolver,
ITraits <double> traits,
IComparer <double> comparer)
{
// since the stack of scorables changes over time, this should be lazy
var relevant = EnumerateRelevant(stack, fromActivity, fromResolver, makeResolver);
var significant = relevant.Select(s => s.WhereScore((_, score) => comparer.Compare(score, traits.Minimum) >= 0));
var scorable = new TraitsScorable <IActivity, double>(traits, comparer, significant);
return(scorable);
}
public static DefaultProbabilityTermStructure factory <Interpolator>(this ITraits <DefaultProbabilityTermStructure> self,
List <Date> dates,
List <double> densities,
DayCounter dayCounter,
Interpolator interpolator)
where Interpolator : class, IInterpolationFactory, new()
{
if (self.GetType().Equals(typeof(HazardRate)))
{
return(new InterpolatedHazardRateCurve <Interpolator>(dates, densities, dayCounter, interpolator));
}
else if (self.GetType().Equals(typeof(DefaultDensity)))
{
return(new InterpolatedDefaultDensityCurve <Interpolator>(dates, densities, dayCounter, interpolator));
}
else
{
return(null);
}
}
public static YieldTermStructure factory <Interpolator>(this ITraits <YieldTermStructure> self,
List <Date> dates,
List <double> discounts,
DayCounter dayCounter,
List <Handle <Quote> > jumps,
List <Date> jumpDates,
Interpolator interpolator = default(Interpolator))
where Interpolator : class, IInterpolationFactory, new()
{
if (self.GetType().Equals(typeof(Discount)))
{
return(new InterpolatedDiscountCurve <Interpolator>(dates, discounts, dayCounter, jumps, jumpDates, interpolator));
}
else if (self.GetType().Equals(typeof(ForwardRate)))
{
return(new InterpolatedForwardCurve <Interpolator>(dates, discounts, dayCounter, jumps, jumpDates, interpolator));
}
else
{
return(null);
}
}
public TraitsScorable(ITraits <Score> traits, IComparer <Score> comparer, IEnumerable <IScorable <Item, Score> > scorables)
: base(null, comparer, scorables)
{
SetField.NotNull(out this.traits, nameof(traits), traits);
}
/// <summary>
/// Construct the QnA Scorable.
/// </summary>
public QnAMakerScorable(IQnAService service, IBotToUser botToUser, ITraits <double> traits)
{
SetField.NotNull(out this.service, nameof(service), service);
SetField.NotNull(out this.botToUser, nameof(botToUser), botToUser);
SetField.NotNull(out this.traits, nameof(traits), traits);
}
public static bool Access <T>(this ITraits traits, out T trait) where T : Trait
{
return((trait = traits.GetTrait <T>()) != null);
}
public CompositeScorable(IComparer <Score> comparer, ITraits <Score> traits, IEnumerable <IScorable <Score> > scorables)
{
SetField.NotNull(out this.comparer, nameof(comparer), comparer);
SetField.NotNull(out this.traits, nameof(traits), traits);
SetField.NotNull(out this.scorables, nameof(scorables), scorables);
}
public CompositeScorable(IComparer <Score> comparer, ITraits <Score> traits, params IScorable <Score>[] scorables)
: this(comparer, traits, (IEnumerable <IScorable <Score> >)scorables)
{
}
public static bool HasTrait <T>(this ITraits traits) where T : Trait
{
return(traits.GetTrait <T>() != null);
}
/// <summary>
/// Construct the QnA Scorable.
/// </summary>
public QnAMakerScorable(QnAMakerServiceScorable inner, ITraits <double> traits)
{
SetField.NotNull(out this.inner, nameof(inner), inner);
SetField.NotNull(out this.traits, nameof(traits), traits);
}
public ScoringDialogTask(IPostToBot inner, IDialogStack stack, IComparer <Score> comparer, ITraits <Score> traits, params IScorable <Score>[] scorables)
{
SetField.NotNull(out this.inner, nameof(inner), inner);
SetField.NotNull(out this.stack, nameof(stack), stack);
SetField.NotNull(out this.comparer, nameof(comparer), comparer);
SetField.NotNull(out this.traits, nameof(traits), traits);
SetField.NotNull(out this.scorables, nameof(scorables), scorables);
}
