public void Calculator_Should_Calculate_Test1()
{
var calculator = new Calculator();
var result = calculator.Calculate("(5+3)*4");
result.Should().Be(32);
}
public void Calculator_Should_Calculate_Test4()
{
var calculator = new Calculator();
var result = calculator.Calculate("5+5*2-1");
result.Should().Be(14);
}
public void Calculator_Should_Calculate_Test2()
{
var calculator = new Calculator();
var result = calculator.Calculate("(5+3)*(4-1)");
result.Should().Be(24);
}
public void AddNegative4and10()
{
Calculator calc = new Calculator();
int result = calc.Add(-4, 10);
Assert.AreEqual(6, result);
}
public void AddNegative4andnegative10()
{
Calculator calc = new Calculator(); //ARRANGE
int result = calc.Add(-4, -10); //ACT
Assert.AreEqual(-14, result); //assert
}
public void Add4and10()
{
Calculator calc = new Calculator();
int result = calc.Add(4, 10);
Assert.AreEqual(14, result);
}
public void Add5and8()
{
Calculator calc = new Calculator();
int result = calc.Add(5, 3);
Assert.AreEqual(8, result);
}
public void Happy_day_Nth_op_builds_on_previous()
{
var sut = new Calculator();
sut.Calculate(2, "+");
var result = sut.Calculate(3, "+");
Assert.AreEqual(5, result);
}
public int Calculator_GetNumber(string roman)
{
int number = 0;
var calculator = new Calculator();
calculator.GetNumber(roman, ref number);
return number;
}
protected void CalculateButton_Click(object sender, EventArgs e)
{
if (ValueBox1.Text.Length > 0 && ValueBox2.Text.Length > 0)
{
double result = 0;
double value1 = Convert.ToDouble(ValueBox1.Text);
double value2 = Convert.ToDouble(ValueBox2.Text);
Calculator myCalculator = new Calculator();
switch (OperatorList.SelectedValue)
{
case "+":
result = myCalculator.Add(value1, value2);
break;
case "-":
result = myCalculator.Subtract(value1, value2);
break;
case "*":
result = myCalculator.Multiply(value1, value2);
break;
case "/":
result = myCalculator.Divide(value1, value2);
break;
}
ResultLabel.Text = result.ToString();
}
else
{
ResultLabel.Text = string.Empty;
}
}
public void Division_by_zero_does_not_affect_calculator_state()
{
var sut = new Calculator();
sut.Calculate(8, "/");
Assert.Throws<DivideByZeroException>(() => sut.Calculate(0, "="));
Assert.AreEqual(4, sut.Calculate(2, "="));
}
public void OnePlusOneIsTwo()
{
var calc = new Calculator();
var two = calc.Add(1, 1);
Assert.AreEqual(2, two);
}
public void TenMinusFiveIsFive()
{
var calc = new Calculator();
var five = calc.Subtract(10, 5);
Assert.AreEqual(5, five);
}
public void ShouldErrorWhenNumberTooBig()
{
var sut = new Calculator();
Assert.That(() => sut.Divide(200, 2),
Throws.TypeOf<ArgumentOutOfRangeException>());
}
public void ShouldAdd()
{
var sut = new Calculator();
var result = sut.Add(1, 2);
Assert.Equal(3, result);
}
public void WhenCreateCalculatorAndAddSomeOperatorWecanUseIt()
{
var parser = new Mock<Parser>();
parser.Protected().Setup<OperatorCollection>("DefaultConfiguration").Returns(new OperatorCollection());
var calculator = new Calculator(parser.Object, x => x.Add(Operator.Create<FakeOperation>("+", Priority.Low)));//var calculator = new Calculator(_parser).Configure(x => x.Add(op));
Assert.IsTrue(calculator.Operators.Count() > 0);
}
public void Add_OneNumber_ReturnNumber()
{
var numberString = "1";
var calculator = new Calculator();
int result = calculator.Add(numberString);
Assert.AreEqual(1, result);
}
public void Add_TwoNumbers_ReturnSum()
{
var numberString = "1,2";
var calculator = new Calculator();
int result = calculator.Add(numberString);
Assert.AreEqual(3, result);
}
public void Add_NumbersAndHandleValidNewLine_ReturnSum()
{
var numberString = "1\n2";
var calculator = new Calculator();
int result = calculator.Add(numberString);
Assert.AreEqual(3, result);
}
public void ShouldErrorWhenDivideByZero_ExplicitExceptionType()
{
var sut = new Calculator();
Assert.That(() => sut.Divide(99, 0),
Throws.TypeOf<DivideByZeroException>());
}
protected void CalculateButton_Click(object sender, EventArgs e)
{
if (ValueBox1.Text.Length > 0 && ValueBox2.Text.Length > 0)
{
double result = 0;
double value1 = Convert.ToDouble(ValueBox1.Text);
double value2 = Convert.ToDouble(ValueBox2.Text);
Calculator myCalculator = new Calculator();
Trace.Write(string.Format("Performing the calculation with the {0} operator", OperatorList.SelectedValue));
switch (OperatorList.SelectedValue)
{
case "+":
result = myCalculator.Add(value1, value2);
break;
case "-":
result = myCalculator.Subtract(value1, value2);
break;
case "*":
result = myCalculator.Multiply(value1, value2);
break;
case "/":
result = myCalculator.Divide(value1, value2);
break;
}
ResultLabel.Text = result.ToString();
}
else
{
ResultLabel.Text = string.Empty;
Trace.Warn("Custom Category", "TextBox controls are empty; time to add Validation controls?");
}
}
public void Add_NumbersAndHandleInvalidNewLine_ThrowsInvalidException()
{
var numberString = "1,\n";
var calculator = new Calculator();
calculator.Add(numberString);
Assert.Fail();
}
public void Start()
{
plsh = GetComponent<playerShooting>();
rb = GetComponent<Rigidbody>();
col = GetComponent<SphereCollider>();
calculator = GameObject.FindGameObjectWithTag("scripts").GetComponent<Calculator>();
sightConstant = calculator.getSightConstant();
fieldofViewAngle = calculator.getFieldOfView();
sensitivity = calculator.getSensitivity();
rotateToTargetSpeed = calculator.getRotateSpeed();
index = calculator.addBot(this);
targets = calculator.getTargets(index);
col.radius= (float)sightConstant;
shootFlag = false;
playerInSight = false;
moveBool = new bool[calculator.getMasterBoolLength()];
bestPoint = transform.position;
bestPoints = new Vector3[moveBool.Length];
bestPointsSV = new float[moveBool.Length];
team = GetComponent<TeamMember>().teamID;
teamFinder();
if (team == 1)
{
goal = new Vector3(-37f, -30f, 28f);
}
else if(team == 2)
{
goal = new Vector3(64f, -30f, -43f);
}
}
public void Press1_Then_PressPlus_Should_Set_PreviousValue_To_1()
{
var calc = new Calculator();
calc.Press1();
calc.PressPlus();
Assert.AreEqual(1, calc.PreviousValue);
}
public void PressBackspace_Should_Set_DisplayValue_To_0_If_DisplayValue_Less_Then_10()
{
var calc = new Calculator();
calc.Press1();
calc.PressBackspace();
Assert.AreEqual(0, calc.DisplayValue);
}
public CalculatorReplLoop()
{
Calculator = new Calculator();
InputService = new ConsoleInputService();
OutputService = new ConsoleOutputService();
ParsingService = new InputParserService();
}
public void Press1_Should_Set_Display_Value_To_DisplayValue_Multiply_10_Plus_1()
{
var calc = new Calculator();
calc.Press9();
calc.Press1();
Assert.AreEqual(91, calc.DisplayValue);
}
public string Calculate(double number, char operator)
{
Calculator calculator = new Calculator();
if(!storedNum)
{
storedNum = number;
}
if(storedOperator!='')
{
switch(storedOperator)
{
case '+':
storedNum = calculator.Add(storedNum, number);
break;
default:
//Suitable error for case not found
break;
}
storedOperator
}
else
{
storedOperator = operator;
}
}
public void IfExpressionIsNullOrEmptyThrowException()
{
var parser = new Mock<IParser>().Object;
var expression = String.Empty;
var calculator = new Calculator(parser);
calculator.Calculate(expression);
}
private static void Calculate(string s)
{
var calculator = new Calculator(UI);
calculator.Add(s);
CalculateNextValue(calculator);
}
public static void Main()
{
int i = Calculator.Add(3, 5);
Console.WriteLine("3 + 5 =" + i);
}
public ActionResult Solve(Calculator viewModel)
{
viewModel.Solve();
return(View("Calculator", viewModel));
}
public void SetUp()
{
_calculator = new Calculator();
}
public void Init()
{
this.op1 = 4;
this.op2 = 2;
this.calculator = new Calculator();
}
public void Init()
{
this.calc = new Calculator();
}
static void Main(string[] args)
{
int firstNumber, secondNumber;
int sub;
double sum, mult, dev;
String check;
bool useLibrary, useConsole;
useConsole = Convert.ToBoolean(ConfigurationManager.AppSettings["UseConsole"]);
if (useConsole == true)
{
Console.WriteLine("Enter two numbers for calculating.");
Console.WriteLine("Enter first number: ");
check = Console.ReadLine();
while (!int.TryParse(check, out firstNumber))
{
Console.WriteLine("You entered wrong type of data. You should enter the integer number. Try again:");
check = Console.ReadLine();
}
Console.WriteLine("Enter second number: ");
check = Console.ReadLine();
while (!int.TryParse(check, out secondNumber))
{
Console.WriteLine("You entered wrong type of data. You should enter the integer number. Try again:");
check = Console.ReadLine();
}
}
else
{
check = Data.FirstNumber;
while (!int.TryParse(check, out firstNumber))
{
Console.WriteLine("You have wrong type of data in resours file. You should enter the integer number.");
Environment.Exit(-1);
}
check = Data.SecondNumber;
while (!int.TryParse(check, out secondNumber))
{
Console.WriteLine("You have wrong type of data in resours file. You should enter the integer number.");
Environment.Exit(-1);
}
Console.WriteLine($"You have two numbers for calculating in resours file. That is : a = {firstNumber} and b = {secondNumber}.");
}
useLibrary = Convert.ToBoolean(ConfigurationManager.AppSettings["UseLibrary"]);
if (useLibrary == true)
{
Calculator calc = new Calculator();
sum = calc.Addition(firstNumber, secondNumber);
sub = calc.Subtraction(firstNumber, secondNumber);
mult = calc.Multiplication(firstNumber, secondNumber);
dev = calc.Division(firstNumber, secondNumber);
Console.WriteLine($"Sum: {sum}, difference: {sub}, product: {mult}, quotient: {dev} ");
}
else
{
sum = Addition(firstNumber, secondNumber);
sub = Subtraction(firstNumber, secondNumber);
mult = Multiplication(firstNumber, secondNumber);
dev = Division(firstNumber, secondNumber);
Console.WriteLine($"Sum: {sum}, difference: {sub}, product: {mult}, quotient: {dev} ");
}
Console.WriteLine("Press any key to exit...");
Console.ReadLine();
}
public void SetUp()
{
calc = new Calculator(new ListStack());
}
public void TestSqrtCleanup()
{
TestSqrt.calc = null;
}
public void Setup()
{
uut_ = new Calculator();
}
public void TestCalculate_WrongTerm_ZeroResult()
{
var calculator = new Calculator();
calculator.Calculate("25.5 + ");
}
public ActionResult Calculate(Calculator calculator)
{
calculator.Result = CalculateResult(calculator);
return(RedirectToAction("Index", calculator));
}
public void TestSqrtInitialize()
{
TestSqrt.calc = new Calculator();
}
public void Sum_MAX_and_1_Result_OverflowException()
{
Calculator calc = new Calculator();
Assert.Throws <OverflowException>(() => calc.Sum(int.MaxValue, 1));
}
public ActionResult Index(Calculator calculator)
{
return(View(calculator));
}
private void UpdateEnemyFleetInstant(bool isPractice = false)
{
BattleManager bm = KCDatabase.Instance.Battle;
BattleData bd = bm.StartsFromDayBattle ? (BattleData)bm.BattleDay : (BattleData)bm.BattleNight;
int[] enemies = bd.Initial.EnemyMembers;
int[][] slots = bd.Initial.EnemySlots;
int[] levels = bd.Initial.EnemyLevels;
int[][] parameters = bd.Initial.EnemyParameters;
int[] hps = bd.Initial.MaxHPs;
_enemyFleetCandidate = null;
_enemyFleetCandidateIndex = -1;
if (!bm.IsPractice)
{
var efcurrent = EnemyFleetRecord.EnemyFleetElement.CreateFromCurrentState();
var efrecord = RecordManager.Instance.EnemyFleet[efcurrent.FleetID];
if (efrecord != null)
{
TextEnemyFleetName.Text = efrecord.FleetName;
}
TextEventDetail.Text = "敵艦隊ID: " + efcurrent.FleetID.ToString("x8");
ToolTipInfo.SetToolTip(TextEventDetail, null);
}
TextFormation.Text = Constants.GetFormationShort((int)bd.Searching.FormationEnemy);
//TextFormation.ImageIndex = (int)ResourceManager.IconContent.BattleFormationEnemyLineAhead + bd.Searching.FormationEnemy - 1;
TextFormation.Visible = true;
{
int air = Calculator.GetAirSuperiority(enemies, slots);
TextAirSuperiority.Text = isPractice ?
air.ToString() + " ～ " + Calculator.GetAirSuperiorityAtMaxLevel(enemies, slots).ToString() :
air.ToString();
ToolTipInfo.SetToolTip(TextAirSuperiority, GetAirSuperiorityString(isPractice ? 0 : air));
TextAirSuperiority.Visible = true;
}
TableEnemyMember.SuspendLayout();
for (int i = 0; i < ControlMembers.Length; i++)
{
int shipID = enemies[i];
ControlMembers[i].Update(shipID, shipID != -1 ? slots[i] : null);
if (shipID != -1)
{
ControlMembers[i].UpdateEquipmentToolTip(shipID, slots[i], levels[i], hps[i + 6], parameters[i][0], parameters[i][1], parameters[i][2], parameters[i][3]);
}
}
TableEnemyMember.ResumeLayout();
TableEnemyMember.Visible = true;
PanelEnemyFleet.Visible = true;
PanelEnemyCandidate.Visible = false;
BasePanel.Visible = true; //checkme
}
public Dictionary <int, List <int> > CalculatePlayersScore(Dictionary <int, Dictionary <Player, TextBox[]> > allPlayersChoice, Dictionary <int, List <Label> > playersResults)
{
Calculator calculator = new Calculator();
return(calculator.CalculateScore(allPlayersChoice));
}
public static ReportData GetCalculatedReportData(UnitReport[] onlyRecentUnitReports,
UnitReport[] allUnitReports,
ZoneReport[] onlyRecentZoneReports = null,
ZoneReport[] allZoneReports = null,
StateReport[] onlyRecentStateReports = null,
StateReport[] allStateReports = null,
CentralReport[] onlyRecentCentralReports = null,
CentralReport[] allCentralReports = null
)
{
if (onlyRecentUnitReports == null)
{
onlyRecentUnitReports = new UnitReport[0];
}
if (onlyRecentZoneReports == null)
{
onlyRecentZoneReports = new ZoneReport[0];
}
if (onlyRecentStateReports == null)
{
onlyRecentStateReports = new StateReport[0];
}
if (onlyRecentCentralReports == null)
{
onlyRecentCentralReports = new CentralReport[0];
}
if (allUnitReports == null)
{
allUnitReports = new UnitReport[0];
}
if (allZoneReports == null)
{
allZoneReports = new ZoneReport[0];
}
if (allStateReports == null)
{
allStateReports = new StateReport[0];
}
if (allCentralReports == null)
{
allCentralReports = new CentralReport[0];
}
return(Calculator.GetCalculatedReportData(onlyRecentUnitReports.Select(o =>
{
ReportData r = o;
return r;
}).ToArray(),
allUnitReports.Select(o =>
{
ReportData r = o;
return r;
}).ToArray(),
onlyRecentZoneReports.Select(o =>
{
ReportData r = o;
return r;
}).ToArray(),
allZoneReports.Select(o =>
{
ReportData r = o;
return r;
}).ToArray(),
onlyRecentStateReports.Select(o =>
{
ReportData r = o;
return r;
}).ToArray(),
allStateReports.Select(o =>
{
ReportData r = o;
return r;
}).ToArray(),
onlyRecentCentralReports.Select(o =>
{
ReportData r = o;
return r;
}).ToArray(),
allCentralReports.Select(o =>
{
ReportData r = o;
return r;
}).ToArray()));
}
/// <summary>
/// Create <see cref="Secret{TNumber}"/> from a0 coefficient
/// </summary>
/// <typeparam name="TNumber"></typeparam>
/// <param name="coefficient">a0 coefficient</param>
/// <returns>A <see cref="Secret{TNumber}"/></returns>
internal static Secret <TNumber> FromCoefficient <TNumber>(Calculator <TNumber> coefficient) =>
new Secret <TNumber>(coefficient.ByteRepresentation.Take(coefficient.ByteCount - MarkByteCount).ToArray());
public void OneTimeSetUp()
{
Sut = new Calculator();
}
public SpecFlowFeature1Steps(Calculator calculator)
{
this._calculator = calculator;
}
public void TestMultiplyDoubleByInt()
{
Assert.Equal(21.9, Calculator.Calculate(multiply, 4.38, 5));
}
public void Setup()
{
_uut = new Calculator();
}
public void TestMultiplyInts(double expected, int value1, int value2)
{
Assert.Equal(expected, Calculator.Calculate(multiply, value1, value2));
}
public void TestMultiplyIntByDouble()
{
Assert.Equal(21.9, Calculator.Calculate(multiply, 5, 4.38));
}
public void SubtractDivide()
{
var c = Calculator.Divide(4, 2);
Assert.AreEqual(2, c);
}
public void TestMultiplyDoubles(double expected, double value1, double value2)
{
Assert.Equal(expected, Calculator.Calculate(multiply, value1, value2));
}
/// <summary>
/// Computes the reverse transformation.
/// </summary>
/// <param name="coordinate">The coordinate.</param>
/// <returns>The transformed coordinate.</returns>
protected override GeoCoordinate ComputeReverse(Coordinate coordinate)
{
// source: EPSG Guidance Note number 7, part 2, page 67
Double phi = Math.Sqrt(Calculator.Square(coordinate.X - _falseEasting) + Calculator.Square(coordinate.Y - _falseNorthing));
Double t = phi * Math.Sqrt(Math.Pow(1 + _ellipsoid.Eccentricity, 1 + _ellipsoid.Eccentricity) * Math.Pow(1 - _ellipsoid.Eccentricity, 1 - _ellipsoid.Eccentricity)) / (2 * _ellipsoid.SemiMajorAxis.BaseValue * _scaleFactorAtNaturalOrigin);
Double ksi = 0, longitude = 0, latitude;
switch (_operationAspect)
{
case OperationAspect.NorthPolar:
ksi = Constants.PI / 2 - 2 * Math.Atan(t);
if (coordinate.X == _falseEasting)
{
longitude = _longitudeOfOrigin;
}
else
{
longitude = _longitudeOfOrigin + Math.Atan2(coordinate.X - _falseEasting, _falseNorthing - coordinate.Y);
}
break;
case OperationAspect.SouthPolar:
ksi = 2 * Math.Atan(t) - Constants.PI / 2;
if (coordinate.X == _falseEasting)
{
longitude = _longitudeOfOrigin;
}
else
{
longitude = _longitudeOfOrigin + Math.Atan2(coordinate.X - _falseEasting, coordinate.Y - _falseNorthing);
}
break;
}
latitude = ksi +
(_ellipsoid.EccentricitySquare / 2 + 5 * Calculator.Pow(_ellipsoid.Eccentricity, 4) / 24 + Calculator.Pow(_ellipsoid.Eccentricity, 6) / 12 + 13 * Calculator.Pow(_ellipsoid.Eccentricity, 8) / 360) * Math.Sin(2 * ksi) +
(7 * Calculator.Pow(_ellipsoid.Eccentricity, 4) / 48 + 29 * Calculator.Pow(_ellipsoid.Eccentricity, 6) / 240 + 811 * Calculator.Pow(_ellipsoid.Eccentricity, 8) / 11520) * Math.Sin(4 * ksi) +
(7 * Calculator.Pow(_ellipsoid.Eccentricity, 6) / 120 + 81 * Calculator.Pow(_ellipsoid.Eccentricity, 8) / 1120) * Math.Sin(6 * ksi) +
(4279 * Calculator.Pow(_ellipsoid.Eccentricity, 8) / 161280) * Math.Sin(8 * ksi);
return(new GeoCoordinate(latitude, longitude));
}
private void showFormSettings()
{
Calculator calculator = new Calculator();
const int FORMSETTNGSIZEHEIGHT = 300;
const int FORMSETTNGSIZEWIDTH = 500;
Form prompt = new Form();
prompt.FormBorderStyle = FormBorderStyle.Fixed3D;
prompt.Width = FORMSETTNGSIZEWIDTH;
prompt.Height = FORMSETTNGSIZEHEIGHT;
prompt.Text = "Paramètres";
prompt.Icon = new Icon("..\\..\\Images\\Icons\\main.ico");
Label labelGobanSize = new Label()
{
Left = 50, Top = 23, Text = "Taille du Goban", Width = 100
};
NumericUpDown inputGobanSize = new NumericUpDown()
{
Left = 250, Top = 20, Width = 200
};
inputGobanSize.Maximum = generalSettings.MaxCase;
inputGobanSize.Minimum = generalSettings.MinCase;
inputGobanSize.Value = userSettings.GobanSize;
inputGobanSize.ValueChanged += (sender, e) => { userSettings.GobanSize = (byte)inputGobanSize.Value; };
prompt.Controls.Add(labelGobanSize);
prompt.Controls.Add(inputGobanSize);
Label labelTimeForPlayer = new Label()
{
Left = 50, Top = 73, Text = "Temps par joueur"
};
Label labelTimeHours = new Label()
{
Left = 300, Top = 73, Text = "h", Width = 20
};
Label labelTimeMinutes = new Label()
{
Left = 370, Top = 73, Text = "min", Width = 30
};
Label labelTimeSeconds = new Label()
{
Left = 450, Top = 73, Text = "s", Width = 30
};
NumericUpDown inputTimeHours = new NumericUpDown()
{
Left = 250, Top = 70, Width = 50
};
inputTimeHours.Maximum = 99;
inputTimeHours.Minimum = 0;
inputTimeHours.Value = calculator.getHours(userSettings.MaxTimeForPlayer);
NumericUpDown inputTimeMinutes = new NumericUpDown()
{
Left = 320, Top = 70, Width = 50
};
inputTimeMinutes.Maximum = 99;
inputTimeMinutes.Minimum = 0;
inputTimeMinutes.Value = calculator.getMinutes(userSettings.MaxTimeForPlayer);
NumericUpDown inputTimeSeconds = new NumericUpDown()
{
Left = 400, Top = 70, Width = 50
};
inputTimeSeconds.Maximum = 99;
inputTimeSeconds.Minimum = 0;
inputTimeSeconds.Value = calculator.getSeconds(userSettings.MaxTimeForPlayer);
inputTimeHours.ValueChanged += (sender, e) => { calculateMaxTimeForPlayer((int)inputTimeHours.Value, (int)inputTimeMinutes.Value, (int)inputTimeSeconds.Value); };
inputTimeMinutes.ValueChanged += (sender, e) => { calculateMaxTimeForPlayer((int)inputTimeHours.Value, (int)inputTimeMinutes.Value, (int)inputTimeSeconds.Value); };
inputTimeSeconds.ValueChanged += (sender, e) => { calculateMaxTimeForPlayer((int)inputTimeHours.Value, (int)inputTimeMinutes.Value, (int)inputTimeSeconds.Value); };
prompt.Controls.Add(labelTimeForPlayer);
prompt.Controls.Add(labelTimeHours);
prompt.Controls.Add(labelTimeMinutes);
prompt.Controls.Add(labelTimeSeconds);
prompt.Controls.Add(inputTimeHours);
prompt.Controls.Add(inputTimeMinutes);
prompt.Controls.Add(inputTimeSeconds);
Button terminated = new Button()
{
Text = "Terminé", Left = FORMSETTNGSIZEWIDTH - 150, Width = 100, Top = FORMSETTNGSIZEHEIGHT - 100
};
terminated.Click += (sender, e) => { prompt.Close(); };
prompt.Controls.Add(terminated);
prompt.ShowDialog();
}
private readonly Double _scaleFactorAtNaturalOrigin; // projection constants
#endregion
#region Constructors
/// <summary>
/// Initializes a new instance of the <see cref="PolarStereographicAProjection" /> class.
/// </summary>
/// <param name="identifier">The identifier of the operation.</param>
/// <param name="name">The name of the operation.</param>
/// <param name="parameters">The parameters of the operation.</param>
/// <param name="ellipsoid">The ellipsoid.</param>
/// <param name="areaOfUse">The area of use where the operation is applicable.</param>
/// <exception cref="System.ArgumentNullException">
/// The identifier is null.
/// or
/// The method is null.
/// or
/// The defined operation method requires parameters.
/// or
/// The ellipsoid is null.
/// or
/// The area of use is null.
/// </exception>
/// <exception cref="System.ArgumentException">
/// The parameters do not contain a required parameter value.
/// or
/// The parameter is not an angular value as required by the method.
/// or
/// The parameter is not a length value as required by the method.
/// or
/// The parameter is not a double precision floating-point number as required by the method.
/// or
/// The parameter does not have the same measurement unit as the ellipsoid.
/// </exception>
public PolarStereographicBProjection(String identifier, String name, Dictionary <CoordinateOperationParameter, Object> parameters, Ellipsoid ellipsoid, AreaOfUse areaOfUse)
: base(identifier, name, CoordinateOperationMethods.PolarStereographicBProjection, parameters, ellipsoid, areaOfUse)
{
_latitudeOfStandardParallel = ((Angle)_parameters[CoordinateOperationParameters.LatitudeOfStandardParallel]).BaseValue;
_longitudeOfOrigin = ((Angle)_parameters[CoordinateOperationParameters.LongitudeOfOrigin]).BaseValue;
_falseEasting = ((Length)_parameters[CoordinateOperationParameters.FalseEasting]).Value;
_falseNorthing = ((Length)_parameters[CoordinateOperationParameters.FalseNorthing]).Value;
_operationAspect = (_latitudeOfStandardParallel >= 0) ? OperationAspect.NorthPolar : OperationAspect.SouthPolar;
// source: EPSG Guidance Note number 7, part 2, page 65
Double mF, tF;
mF = Math.Cos(_latitudeOfStandardParallel) / Math.Sqrt(1 - Ellipsoid.EccentricitySquare * Calculator.Sin2(_latitudeOfStandardParallel));
if (_operationAspect == OperationAspect.NorthPolar)
{
tF = Math.Tan(Numerics.Constants.PI / 4 - _latitudeOfStandardParallel / 2) / Math.Pow((1 + Ellipsoid.Eccentricity * Math.Sin(_latitudeOfStandardParallel)) / (1 - Ellipsoid.Eccentricity * Math.Sin(_latitudeOfStandardParallel)), Ellipsoid.Eccentricity / 2);
}
else
{
tF = Math.Tan(Numerics.Constants.PI / 4 + _latitudeOfStandardParallel / 2) / Math.Pow((1 + Ellipsoid.Eccentricity * Math.Sin(_latitudeOfStandardParallel)) / (1 - Ellipsoid.Eccentricity * Math.Sin(_latitudeOfStandardParallel)), Ellipsoid.Eccentricity / 2);
}
_scaleFactorAtNaturalOrigin = mF * (Math.Sqrt(Math.Pow(1 + Ellipsoid.Eccentricity, 1 + Ellipsoid.Eccentricity) * Math.Pow(1 - Ellipsoid.Eccentricity, 1 - Ellipsoid.Eccentricity))) / (2 * tF);
}
public void MultiplyTest()
{
var c = Calculator.Multiply(3, 2);
Assert.AreEqual(6, c);
}
