public InterestRate EquivalentRate(IDayCounter dc, Compounding c, Frequency f, DateTimeOffset d1, DateTimeOffset d2)
{
var t1 = _dc.YearFraction(d1, d2);
var t2 = dc.YearFraction(d1, d2);
var compoundFactor = CompoundFactor(t1);
return ImpliedRate(dc, compoundFactor, c, f, t2);
}
public FetchConfigurationForCustomCommand(IntegrationAction action, IntegrationType type, Frequency frequency, string customDay)
{
Type = type;
Action = action;
Frequency = frequency;
CustomDay = customDay;
}
public FlatForward(Date referenceDate, double forward, DayCounter dayCounter, Compounding compounding, Frequency frequency)
: base(referenceDate, new Calendar(), dayCounter)
{
forward_ = new SimpleQuote(forward);
compounding_ = compounding;
frequency_ = frequency;
}
public static InterestRate ImpliedRate(IDayCounter dc, double compoundFactor, Compounding c, Frequency f, double time)
{
double r;
if (Helper.Equals(compoundFactor, 1.0))
{
r = 0.0;
}
else
{
switch (c)
{
case Compounding.Simple:
r = (compoundFactor - 1.0)/time;
break;
case Compounding.Compounded:
r = (Math.Pow(compoundFactor, 1.0 / ((double)f * time)) - 1.0) * (double)f;
break;
case Compounding.Continuous:
r = Math.Log(compoundFactor)/time;
break;
default:
throw new NotImplementedException($"Unknown Compounding {c}");
}
}
return new InterestRate(dc, r, c, f);
}
//! utility function giving the inflation period for a given date
public static KeyValuePair<Date, Date> inflationPeriod(Date d, Frequency frequency) {
Month month = (Month)d.Month;
int year = d.Year;
Month startMonth;
Month endMonth;
switch (frequency) {
case Frequency.Annual:
startMonth = Month.January;
endMonth = Month.December;
break;
case Frequency.Semiannual:
startMonth = (Month)(6 * ((int)month - 1) / 6 + 1);
endMonth = (Month)(startMonth + 5);
break;
case Frequency.Quarterly:
startMonth = (Month)(3 * ((int)month - 1) / 3 + 1);
endMonth = (Month)(startMonth + 2);
break;
case Frequency.Monthly:
startMonth = endMonth = month;
break;
default:
throw new ApplicationException("Frequency not handled: " + frequency);
}
Date startDate = new Date(1, startMonth, year);
Date endDate = Date.endOfMonth(new Date(1, endMonth, year));
return new KeyValuePair<Date, Date>(startDate, endDate);
}
public InterestRate(IDayCounter dc, double r, Compounding c, Frequency f)
{
_dc = dc;
_r = r;
_c = c;
_f = f;
}
//! fixed-rate bond
/*! \ingroup instruments
\test calculations are tested by checking results against
cached values.
*/
//! simple annual compounding coupon rates
public FixedRateBond(int settlementDays, double faceAmount, Schedule schedule,List<double> coupons,
DayCounter accrualDayCounter, BusinessDayConvention paymentConvention = BusinessDayConvention.Following,
double redemption = 100, Date issueDate = null,Calendar paymentCalendar = null,
Period exCouponPeriod = null,
Calendar exCouponCalendar = null,
BusinessDayConvention exCouponConvention = BusinessDayConvention.Unadjusted,
bool exCouponEndOfMonth = false)
: base(settlementDays, paymentCalendar == null ? schedule.calendar() : paymentCalendar,
issueDate)
{
frequency_ = schedule.tenor().frequency();
dayCounter_ = accrualDayCounter;
maturityDate_ = schedule.endDate();
cashflows_ = new FixedRateLeg(schedule)
.withCouponRates(coupons, accrualDayCounter)
.withExCouponPeriod(exCouponPeriod,
exCouponCalendar,
exCouponConvention,
exCouponEndOfMonth)
.withPaymentCalendar(calendar_)
.withNotionals(faceAmount)
.withPaymentAdjustment(paymentConvention);
addRedemptionsToCashflows(new List<double>() { redemption });
if (cashflows().Count == 0)
throw new ApplicationException("bond with no cashflows!");
if (redemptions_.Count != 1)
throw new ApplicationException("multiple redemptions created");
}
private IPwmDevice GetRealDevice()
{
PwmFrequency = new Frequency(60);
DeviceAddress = 0x40;
try
{
Log.Info("Creating pins");
var sdaPin = SdaPin.ToProcessor();
var sclPin = SclPin.ToProcessor();
Log.Info("Creating i2cDriver");
_i2cDriver = new I2cDriver(sdaPin, sclPin);
}
catch (Exception e)
{
Log.Error("Failed to initialise i2c driver. Did you forget sudo?", e);
}
Log.Info("Creating real device...");
var device = new Pca9685Connection(_i2cDriver.Connect(DeviceAddress));
Log.Info("Setting frequency...");
device.SetPwmUpdateRate(PwmFrequency); // # Set frequency to 60 Hz
IsConnected = true;
return device;
}
public AmortizingFixedRateBond(
int settlementDays,
Calendar calendar,
double faceAmount,
Date startDate,
Period bondTenor,
Frequency sinkingFrequency,
double coupon,
DayCounter accrualDayCounter,
BusinessDayConvention paymentConvention = BusinessDayConvention.Following,
Date issueDate = null)
:base(settlementDays, calendar, issueDate)
{
frequency_ = sinkingFrequency;
dayCounter_ = accrualDayCounter;
Utils.QL_REQUIRE( bondTenor.length() > 0,() =>
"bond tenor must be positive. "
+ bondTenor + " is not allowed." );
maturityDate_ = startDate + bondTenor;
maturityDate_ = startDate + bondTenor;
schedule_ = sinkingSchedule(startDate, bondTenor, sinkingFrequency, calendar);
cashflows_ = new FixedRateLeg(schedule_)
.withCouponRates(coupon, accrualDayCounter)
.withNotionals(sinkingNotionals(bondTenor, sinkingFrequency, coupon, faceAmount))
.withPaymentAdjustment(paymentConvention).value();
addRedemptionsToCashflows();
}
public AmortizingFixedRateBond(
int settlementDays,
List<double> notionals,
Schedule schedule,
List<double> coupons,
DayCounter accrualDayCounter,
BusinessDayConvention paymentConvention = BusinessDayConvention.Following,
Date issueDate = null)
:base(settlementDays, schedule.calendar(), issueDate)
{
frequency_ = schedule.tenor().frequency();
dayCounter_ = accrualDayCounter;
schedule_ = schedule;
maturityDate_ = schedule.endDate();
cashflows_ = new FixedRateLeg(schedule)
.withCouponRates(coupons, accrualDayCounter)
.withNotionals(notionals)
.withPaymentAdjustment(paymentConvention).value();
addRedemptionsToCashflows();
if ( cashflows().empty())
throw new ApplicationException("bond with no cashflows!");
}
internal UserPreferenceBuilder()
{
userId = Constants.USER_InValidId;
portalId = Constants.PORTAL_ValidPortalId;
messagesEmailFrequency = Frequency.Instant;
notificationsEmailFrequency = Frequency.Hourly;
}
public void VerifyAllEnums()
{
var acceleration = new Acceleration(1, AccelerationUnit.BaseUnit);
var angle = new Angle(1, AngleUnit.BaseUnit);
var angularAcceleration = new AngularAcceleration(1, AngularAccelerationUnit.BaseUnit);
var area = new Area(1, AreaUnit.BaseUnit);
var density = new MassDensity(1, MassDensityUnit.BaseUnit);
var electricCurrent = new ElectricCurrent(1, ElectricCurrentUnit.BaseUnit);
var electricResistance = new ElectricResistance(1, ElectricResistanceUnit.BaseUnit);
var electricVoltage = new ElectricPotential(1, ElectricPotentialUnit.BaseUnit);
var energy = new Energy(1, EnergyUnit.BaseUnit);
var force = new Force(1, ForceUnit.BaseUnit);
var frequency = new Frequency(1, FrequencyUnit.BaseUnit);
var jerk = new Jerk(1, JerkUnit.BaseUnit);
var length = new Length(1, LengthUnit.BaseUnit);
var mass = new Mass(1, MassUnit.BaseUnit);
var massFlowRate = new MassFlowRate(1, MassFlowRateUnit.BaseUnit);
var momentum = new Momentum(1, MomentumUnit.BaseUnit);
var numeric = new Numeric(1, NumericUnit.BaseUnit);
var power = new Power(1, PowerUnit.BaseUnit);
var pressure = new Pressure(1, PressureUnit.BaseUnit);
var speed = new Speed(1, SpeedUnit.BaseUnit);
var temperature = new Temperature(1, TemperatureUnit.BaseUnit);
var time = new Time(1, TimeUnit.BaseUnit);
var torque = new Torque(1, TorqueUnit.BaseUnit);
var volume = new Volume(1, VolumeUnit.BaseUnit);
var volumetricFlowRate = new VolumetricFlowRate(1, VolumetricFlowRateUnit.BaseUnit);
}
public SwapRateHelper(double rate, Period tenor, Calendar calendar,
Frequency fixedFrequency, BusinessDayConvention fixedConvention, DayCounter fixedDayCount,
IborIndex iborIndex)
: this(rate, tenor, calendar, fixedFrequency, fixedConvention, fixedDayCount, iborIndex,
new Handle<Quote>(), new Period(0, TimeUnit.Days))
{
}
public Result(Age a, Sex s, Profession p, Education e, YesNo cit,
List<Technology> tech, Frequency pub, Frequency home,
NumPass single, List<PassType> passType, Frequency pChange,
YesNo sharePass,YesNo pSecure, YesNo passHome,YesNo pMobile,
YesNo hWifiPass, YesNo hWifiFire, YesNo hVirusSoftware, YesNo softUpdate,
SecureLevel sLevel, SharePersonalInfo postPersonal, Frequency pWifi)
{
m_age = a;
m_sex = s;
m_profession = p;
m_education = e;
m_usCitizen = cit;
m_technologyList = tech;
m_publicComputer = pub;
m_homeComputer = home;
m_singlePass = single;
m_passType = passType;
m_passChangeFreq = pChange;
m_sharePassword = sharePass;
m_passSecure = pSecure;
m_passHomePC = passHome;
m_passForMobile = pMobile;
m_homeWifiPass = hWifiPass;
m_homeWifiFirewall = hWifiFire;
m_homeVirusSoftware = hVirusSoftware;
m_softwareUpdates = softUpdate;
m_securityLevel = sLevel;
m_postPersonalInfo = postPersonal;
m_publicWifi = pWifi;
}
public Magazine(string name, Frequency issueFrequency, DateTime issueDate, int circulation)
{
_name = name;
_issueFrequency = issueFrequency;
_issueDate = issueDate;
_circulation = circulation;
_articles = new List<Article>();
}
public FetchConfigurationForClientCommand(IntegrationAction action, IntegrationType type, Frequency frequency, Guid contractId, Guid packageId)
{
Type = type;
Action = action;
Frequency = frequency;
ContractId = contractId;
PackageId = packageId;
}
public Magazine()
{
_name = "Junior Technician";
_issueFrequency = Frequency.Monthly;
_issueDate = DateTime.Today;
_circulation = 128394;
_articles = new List<Article>();
}
public void OpAddition()
{
var frequency1 = new Frequency(1, FrequencyUnit.Hertz);
var frequency2 = new Frequency(1, FrequencyUnit.CyclePerSecond);
var expected = new Frequency(2, FrequencyUnit.Hertz);
(frequency1 + frequency2).ShouldEqual(expected);
(frequency2 + frequency1).ShouldEqual(expected);
}
public void Frequency_ToUnit_Then_ResultShouldBeExpected(double value, double expected)
{
var testee = new Frequency(4, x => x.Mega.Hertz);
var result = testee.ToUnit(x => x.Hertz);
result.Should().Be(4000000, "Hz", UnitFormat.Default);
}
public static AmortizingFixedRateBond makeAmortizingFixedBond( Date startDate,
Period bondLength,
DayCounter dCounter,
Frequency payFrequency,
double amount,
double rate)
{
return makeAmortizingFixedBond(startDate, bondLength, dCounter, payFrequency, amount, rate, new TARGET());
}
public FlatForward(Date referenceDate, Quote forward, DayCounter dayCounter, Compounding compounding, Frequency frequency)
: base(referenceDate, new Calendar(), dayCounter)
{
forward_ = forward;
compounding_ = compounding;
frequency_ = frequency;
forward_.registerWith(update);
}
static YieldTermStructure flatRate(Date today,
double forward,
DayCounter dc,
Compounding compounding,
Frequency frequency)
{
return new FlatForward(today, forward, dc, compounding, frequency);
//FlatForward flatRate = new FlatForward(settlementDate, r.rate(), r.dayCounter(), r.compounding(), r.frequency());
}
public YieldFinder(double faceAmount, List<CashFlow> cashflows, double dirtyPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency, Date settlement)
{
_faceAmount = faceAmount;
_cashflows = cashflows;
_dirtyPrice = dirtyPrice;
_compounding = compounding;
_dayCounter = dayCounter;
_frequency = frequency;
_settlement = settlement;
}
public void OpInverseEquals()
{
var frequency1 = new Frequency(1, FrequencyUnit.Hertz);
var frequency2 = new Frequency(1, FrequencyUnit.CyclePerSecond);
var frequency3 = new Frequency(2, FrequencyUnit.CyclePerSecond);
(frequency1 != frequency2).ShouldBeFalse();
(frequency2 != frequency1).ShouldBeFalse();
(frequency1 != frequency3).ShouldBeTrue();
(frequency3 != frequency1).ShouldBeTrue();
}
public void OpGreaterThanOrEqual()
{
var frequency1 = new Frequency(1, FrequencyUnit.Hertz);
var frequency2 = new Frequency(1, FrequencyUnit.CyclePerSecond);
var frequency3 = new Frequency(2, FrequencyUnit.CyclePerSecond);
(frequency1 >= frequency3).ShouldBeFalse();
(frequency3 >= frequency1).ShouldBeTrue();
(frequency1 >= frequency2).ShouldBeTrue();
(frequency2 >= frequency1).ShouldBeTrue();
}
public void OpDivision()
{
var frequency1 = new Frequency(2, FrequencyUnit.Hertz);
var frequency2 = new Frequency(2, FrequencyUnit.CyclePerSecond);
(frequency1 / frequency2).ShouldBeWithinEpsilonOf(1);
(frequency2 / frequency1).ShouldBeWithinEpsilonOf(1);
(frequency1 / 2).ShouldEqual(new Frequency(1, FrequencyUnit.Hertz));
(frequency2 / 2).ShouldEqual(new Frequency(1, FrequencyUnit.CyclePerSecond));
}
public InterestRateData(double _r, Compounding _comp, Frequency _freq, double _t, Compounding _comp2, Frequency _freq2, double _expected, int _precision)
{
r = _r;
comp = _comp;
freq = _freq;
t = _t;
comp2 = _comp2;
freq2 = _freq2;
expected = _expected;
precision = _precision;
}
public static Plan WithPremium(this Plan plan, PremiumType premiumType = PremiumType.Individual, Frequency frequency = Frequency.Biweekly, decimal? cost = null)
{
plan.Premiums.Add(new Premium
{
Cost = cost ?? RandomData.DollarAmount,
Frequency = frequency,
Type = premiumType
});
return plan;
}
public static int GetMultipler(Frequency frequency)
{
switch(frequency)
{
case Frequency.Biweekly:
return 26;
case Frequency.Monthly:
return 12;
default:
throw new ApplicationException("Unknown frequency");
}
}
/// <summary>
/// Ported but wasn't used in original? Ported from https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code/blob/master/Adafruit_PWM_Servo_Driver/Servo_Example.py
/// Not entirely sure what the result is meant to mean.
/// </summary>
private static int CalculatePulse(Frequency frequency, int pulse)
{
const int microSeconds = 1000000; // # 1,000,000 us per second
var pulseLengthMicroSeconds = microSeconds/(int)frequency.Hertz; // # 60 Hz
log.Info(m => m("{0} uSecs per period", pulseLengthMicroSeconds));
var microSecondsPerBit = pulseLengthMicroSeconds/4096; // # 12 bits of resolution
log.Info(m => m("{0} uSecs per bit", microSecondsPerBit));
return (pulse*1000)/pulseLengthMicroSeconds;
}
public bool Update(long transactionId, DateTime start, DateTime end, string description, decimal amount, string notes, Frequency period)
{
if (string.IsNullOrWhiteSpace(description) || amount < 0.01m)
{
return(false);
}
notes ??= string.Empty;
if (start > end)
{
var temp = start;
start = end;
end = temp;
}
var transaction = _repository.FindById <IRecurringTransaction>(transactionId);
var user = _currentUserProvider.CurrentUser;
if (transaction == null || transaction.UserId != user.Id)
{
return(false);
}
var clearChildren = transaction.Start != start || transaction.Recurrence != period;
var trimBounds = transaction.End != end && !clearChildren;
transaction.Start = start;
transaction.End = end;
transaction.Recurrence = period;
transaction.Description = description;
transaction.Amount = amount;
transaction.Notes = notes;
if (!_repository.Update(transaction))
{
return(false);
}
var children = _repository
.UserFiltered <ITransaction>(user)
.Where(t => t.ParentId == transactionId)
.ToList();
if (clearChildren)
{
return(_repository.DeleteRange(children));
}
if (trimBounds)
{
var invalidChildren = children.Where(t => t.Date > end);
if (!_repository.DeleteRange(invalidChildren))
{
return(false);
}
children = children.Where(t => t.Date <= end).ToList();
}
foreach (var child in children)
{
child.Description = description;
child.Amount = amount;
}
return(_repository.UpdateRange(children));
}
/// <inheritdoc cref="Frequency.FromGigahertz(double)"/> public static Frequency Gigahertz(this float value) => Frequency.FromGigahertz(value);
/// <inheritdoc cref="Frequency.FromHertz(double?)"/> public static Frequency?Hertz(this long?value) => Frequency.FromHertz(value);
/// <inheritdoc cref="Frequency.FromHertz(double?)"/> public static Frequency?Hertz(this float?value) => Frequency.FromHertz(value);
/// <inheritdoc cref="Frequency.FromKilohertz(double?)"/> public static Frequency?Kilohertz(this double?value) => Frequency.FromKilohertz(value);
/// <inheritdoc cref="Frequency.FromTerahertz(double?)"/> public static Frequency?Terahertz(this decimal?value) => Frequency.FromTerahertz(value == null ? (double?)null : Convert.ToDouble(value.Value));
public static double yield(Bond bond, double cleanPrice, DayCounter dayCounter, Compounding compounding, Frequency frequency,
Date settlementDate = null, double accuracy = 1.0e-10, int maxIterations = 100, double guess = 0.05)
{
if (settlementDate == null)
{
settlementDate = bond.settlementDate();
}
Utils.QL_REQUIRE(BondFunctions.isTradable(bond, settlementDate),
"non tradable at " + settlementDate +
" (maturity being " + bond.maturityDate() + ")");
double dirtyPrice = cleanPrice + bond.accruedAmount(settlementDate);
dirtyPrice /= 100.0 / bond.notional(settlementDate);
return(CashFlows.yield(bond.cashflows(), dirtyPrice,
dayCounter, compounding, frequency,
false, settlementDate, settlementDate,
accuracy, maxIterations, guess));
}
public static double bps(Bond bond, double yield, DayCounter dayCounter, Compounding compounding, Frequency frequency,
Date settlementDate = null)
{
return(bps(bond, new InterestRate(yield, dayCounter, compounding, frequency), settlementDate));
}
/// <inheritdoc cref="Frequency.FromCyclesPerMinute(double?)"/> public static Frequency?CyclesPerMinute(this double?value) => Frequency.FromCyclesPerMinute(value);
/// <inheritdoc cref="Frequency.FromCyclesPerHour(double)"/> public static Frequency CyclesPerHour(this double value) => Frequency.FromCyclesPerHour(value);
/// <inheritdoc cref="Frequency.FromCyclesPerHour(double?)"/> public static Frequency?CyclesPerHour(this decimal?value) => Frequency.FromCyclesPerHour(value == null ? (double?)null : Convert.ToDouble(value.Value));
public void EqualsReturnsFalseOnTypeMismatch()
{
Frequency hertz = Frequency.FromHertz(1);
Assert.IsFalse(hertz.Equals(new object()));
}
/// <inheritdoc cref="Frequency.FromCyclesPerHour(double)"/> public static Frequency CyclesPerHour(this decimal value) => Frequency.FromCyclesPerHour(Convert.ToDouble(value));
/// <inheritdoc cref="Frequency.FromTerahertz(double)"/> public static Frequency Terahertz(this decimal value) => Frequency.FromTerahertz(Convert.ToDouble(value));
/// <inheritdoc cref="Frequency.FromKilohertz(double)"/> public static Frequency Kilohertz(this long value) => Frequency.FromKilohertz(value);
/// <inheritdoc cref="Frequency.FromTerahertz(double?)"/> public static Frequency?Terahertz(this float?value) => Frequency.FromTerahertz(value);
/// <inheritdoc cref="Frequency.FromHertz(double?)"/> public static Frequency?Hertz(this double?value) => Frequency.FromHertz(value);
/// <inheritdoc cref="Frequency.FromTerahertz(double?)"/> public static Frequency?Terahertz(this double?value) => Frequency.FromTerahertz(value);
/// <inheritdoc cref="Frequency.FromHertz(double)"/> public static Frequency Hertz(this int value) => Frequency.FromHertz(value);
/// <inheritdoc cref="Frequency.FromTerahertz(double)"/> public static Frequency Terahertz(this long value) => Frequency.FromTerahertz(value);
/// <inheritdoc cref="Frequency.FromGigahertz(double)"/> public static Frequency Gigahertz(this double value) => Frequency.FromGigahertz(value);
/// <inheritdoc cref="Frequency.FromMegahertz(double?)"/> public static Frequency?Megahertz(this float?value) => Frequency.FromMegahertz(value);
/// <inheritdoc cref="Frequency.FromGigahertz(double?)"/> public static Frequency?Gigahertz(this long?value) => Frequency.FromGigahertz(value);
/// <inheritdoc cref="Frequency.FromMegahertz(double?)"/> public static Frequency?Megahertz(this double?value) => Frequency.FromMegahertz(value);
public IRecurringTransaction Add(DateTime start, DateTime end, string description, decimal amount, string notes, Frequency period)
{
if (string.IsNullOrWhiteSpace(description) || amount < 0.01m)
{
return(null);
}
notes ??= string.Empty;
if (start > end)
{
var temp = start;
start = end;
end = temp;
}
var user = _currentUserProvider.CurrentUser;
var transaction = _entityFactory.NewRecurringTransaction;
transaction.Start = start;
transaction.End = end;
transaction.Recurrence = period;
transaction.Description = description;
transaction.Amount = amount;
transaction.UserId = user.Id;
transaction.User = user;
transaction.Notes = notes;
return(_repository.Add(transaction));
}
/// <inheritdoc cref="Frequency.FromMegahertz(double)"/> public static Frequency Megahertz(this long value) => Frequency.FromMegahertz(value);
public void EqualsReturnsFalseOnNull()
{
Frequency hertz = Frequency.FromHertz(1);
Assert.IsFalse(hertz.Equals(null));
}
/// <inheritdoc cref="Frequency.FromKilohertz(double?)"/> public static Frequency?Kilohertz(this float?value) => Frequency.FromKilohertz(value);
/// <inheritdoc cref="Frequency.FromCyclesPerMinute(double)"/> public static Frequency CyclesPerMinute(this long value) => Frequency.FromCyclesPerMinute(value);
/// <inheritdoc cref="Frequency.FromCyclesPerHour(double?)"/> public static Frequency?CyclesPerHour(this float?value) => Frequency.FromCyclesPerHour(value);
