public void SetVolumeDensity(float volume, float density)
{
autoCalculate = CalculateType.Mass;
transform.localScale = Vector3.one * Mathf.Pow(volume, 1f / 3f);
this.density = density;
}
static double Calculate(double A, double B,
CalculateType type = CalculateType.Add, bool PrintResult = false)
{
string calculatetype = "";
double result = 0.0;
switch (type)
{
case CalculateType.Add:
result = (A + B);
break;
case CalculateType.Sub:
result = (A - B);
break;
case CalculateType.Mul:
result = (A * B);
break;
case CalculateType.Div:
result = (A / B);
break;
}
if (PrintResult)
{
Console.WriteLine(calculatetype + "결과: " + result);
}
return(result);
}
/// <summary>
/// 計算処理を行う
/// </summary>
/// <param name="calculateType">計算種別</param>
/// <param name="values">計算対象の値</param>
/// <returns>計算結果</returns>
/// <exception cref="ApplicationException">業務エラー発生時に例外を発生させる。</exception>
public Task <float> CalculateAsync(CalculateType calculateType, params float[] values)
{
if (!this.HasCorrectParameterCount(calculateType, values))
{
throw new ArgumentException("引数の数が正しくありません。");
}
// 計算処理を行うインスタンス生成
var calculator = this.CreateCalculator(calculateType, values);
if (calculator == null)
{
throw new NotImplementedException(calculateType.ToString() + "の処理は実装されていません。");
}
string errorMessage;
if (calculator.Validate(out errorMessage))
{
// 処理キャンセル時に必要なオブジェクトを保持しておく
this.tokenSource = new CancellationTokenSource();
this.tokenSource.Token.ThrowIfCancellationRequested();
// 非同期で計算処理実行
// 既定ではオーバーフロー時に例外は発生しないので(unchecked)考慮しない
this.calcultionTask = Task.Run(() => calculator.Calculate(), this.tokenSource.Token);
}
else
{
this.calcultionTask = Task.FromException <float>(new ApplicationException(errorMessage));
}
return(this.calcultionTask);
}
public void SetMassDensity(float mass, float density)
{
autoCalculate = CalculateType.Volume;
rigidbody = GetComponent <Rigidbody>();
this.rigidbody.mass = mass;
this.density = density;
}
public void SetMatrix3x3(apMatrix3x3 matrix4x4, CalculateType calculateType, bool isWeighted, float weight)
{
_valueType = UnitValueType.Matrix3x3;
_val_Matrix3x3 = matrix4x4;
_calculateType = calculateType;
_isWeighted = isWeighted;
_weight = weight;
}
public void SetMassVolume(float mass, float volume)
{
autoCalculate = CalculateType.Density;
rigidbody = GetComponent <Rigidbody>();
rigidbody.mass = mass;
transform.localScale = Vector3.one * Mathf.Pow(volume, 1f / 3f);
}
private int totalValueOfArray(int[] param, CalculateType hesaplamaTipi)
{
int result = 0;
foreach (int item in param)
{
result += Convert.ToInt32(Math.Pow(item, (int)hesaplamaTipi));
}
return(result);
}
/* private void DisplayLocalizationResult(TagInfo tagInfo)
* {
* // tbxDisplay.AppendText("Round " + tagInfo.TotalTagCount + ": " + tagInfo.EPC + " (" + SARParameter.PredictedX + "," + SARParameter.PredictedY+ ","+SARParameter.PredictedZ+ ")" + "\r\n");
* this.BeginInvoke(method: new Action(() =>
* {
* tbxDisplay.SelectionStart = tbxDisplay.Text.Length;
* tbxDisplay.ScrollToCaret();
* }));
* }*/
/// <summary>
/// Clear all components created by this form before inventroring
/// </summary>
public void Clear()
{
tbxDisplay.Clear();
string algorithmType = tssbtnAlgorithms.Text.Trim();
CalculateType calculateType = getTypeByStr(algorithmType);
ICalculateService iCalculateService = ServiceManager.getCalculateService(calculateType);
iCalculateService.clearAll();
ServiceManager.closeService(iCalculateService);
}
internal void CalculateRiskData(DateTime baseTime, CalculateType calculateType, IQuotePolicyProvider quotePolicyProvider)
{
this.InitializeSubFunds();
this.CalculateSubFunds(baseTime, calculateType, quotePolicyProvider);
this.CalculateSumFund();
foreach (var eachFund in _funds.Values)
{
FundDataPool.Default.Add(eachFund);
}
_funds.Clear();
}
public bool ContainsTaskId(string taskId, CalculateType calculateType)
{
try
{
return(client.UseService <IRpcTaskExcute>(typeof(IRpcTaskExcute).Namespace).ContainsTaskId(taskId, calculateType));
}
catch (Exception ex)
{
Logger.Log.Error(true, "ContainsTaskId:", ex);
return(false);
}
}
public string[] GetAllTaskId(CalculateType calculateType)
{
try
{
return(client.UseService <IRpcTaskExcute>(typeof(IRpcTaskExcute).Namespace).GetAllTaskId(calculateType));
}
catch (Exception ex)
{
Logger.Log.Error(true, "ContainsTaskId:", ex);
return(null);
}
}
private CalculateType getTypeByStr(string calculateTypeStr)
{
string[] calTypeStrArray = new string[] { "Origin SAR", "Tagoram-AH", "Tagoram-DAH", "MobiTagbot" };
CalculateType[] calTypes = new CalculateType[] { CalculateType.ORIGIN_SAR };
for (int i = 0; i < calTypeStrArray.Length; ++i)
{
if (calculateTypeStr.Equals(calTypeStrArray[i]))
{
return(calTypes[i]);
}
}
return(CalculateType.NOT_EXIST);
}
/**
* 根据算法的枚举获得算法的远程代理对象
*/
public static ICalculateService getCalculateService(CalculateType calculateType)
{
string className = getStringValue(calculateType);
if (className == null)
{
return(null);
}
Type type = Type.GetType(className);
object obj = Activator.CreateInstance(type);
return((ICalculateService)obj);
}
public static Texture2D GetTexture(SceneRaycastInfo sceneInfo, CalculateType calType, int minRange = -1, int maxRange = -1,
int generateLayerMask = -1)
{
var width = sceneInfo.Width;
var height = sceneInfo.Height;
var tex = CreateTexture2D(width, height);
var pixels = SceneJobUtility.CalculateGenerateTexture(sceneInfo, calType, minRange, maxRange, generateLayerMask, NoneColor, HitColor, GenerateColor);
tex.SetPixels32(pixels);
tex.Apply();
return(tex);
}
internal void CalculateRiskData(DateTime baseTime, CalculateType calculateType, IQuotePolicyProvider quotePolicyProvider)
{
try
{
_riskDataCalculator.CalculateRiskData(baseTime, calculateType, quotePolicyProvider);
}
catch (TradePolicyDetailNotFountException tradePolicyDetailNotFountException)
{
Logger.ErrorFormat("instrumentId={0}, tradePolicyId={1}, accountId={2},error={3}", tradePolicyDetailNotFountException.InstrumentId, tradePolicyDetailNotFountException.TradePolicyId, _account.Id, tradePolicyDetailNotFountException);
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
public void SetMatrixWrap(apMatrix matrixWrap, CalculateType calculateType, bool isWeighted, float weight)
{
_valueType = UnitValueType.MatrixWrap;
if (_val_MatrixWrap == null)
{
_val_MatrixWrap = new apMatrix(matrixWrap); //<<복사를 하자
}
else
{
_val_MatrixWrap.SetMatrix(matrixWrap);
}
_calculateType = calculateType;
_isWeighted = isWeighted;
_weight = weight;
}
public void SetPosition(Vector2[] vertPositions, CalculateType calculateType, bool isWeighted, float weight)
{
_valueType = UnitValueType.VertPos;
if (_val_VertPos == null || _val_VertPos.Length != vertPositions.Length)
{
_val_VertPos = new Vector2[vertPositions.Length];
}
for (int i = 0; i < vertPositions.Length; i++)
{
_val_VertPos[i] = vertPositions[i];
}
_calculateType = calculateType;
_isWeighted = isWeighted;
_weight = weight;
}
private void CalculateSubFunds(DateTime baseTime, CalculateType calculateType, IQuotePolicyProvider quotePolicyProvider)
{
if (_instrumentManager.Count > 0)
{
foreach (var instrument in _instrumentManager.Instruments)
{
if (instrument.GetTransactions().Count == 0)
{
continue;
}
instrument.Calculate(baseTime, calculateType, instrument.GetQuotation(quotePolicyProvider));
FundData fund = this.GetOrCreateFund(instrument.CurrencyId);
fund.Add(instrument.RiskRawData, null);
}
}
}
//从队列中去除一个TagPos
public void SAR(TagPos tagPos)
{
TagInfo tagInfo = tagPos.tagInfo;
string algorithmType = tssbtnAlgorithms.Text.Trim();
CalculateType calculateType = getTypeByStr(algorithmType);
ICalculateService iCalculateService = ServiceManager.getCalculateService(calculateType);
if (!SARParameter.epcSet.Contains(tagInfo.EPC))
{
iCalculateService.init(tagInfo.EPC, SARParameter.confParam);
SARParameter.epcSet.Add(tagInfo.EPC);
}
Tuple <double, double, double> position = tagPos.pos;
iCalculateService.calculate(tagInfo.EPC, position.Item1, position.Item2, position.Item3, tagInfo.Frequency, tagInfo.AcutalPhaseInRadian);
ServiceManager.closeService(iCalculateService);
}
public static CalculatorBase Create(CalculateType type)
{
switch (type)
{
case CalculateType.Heavy:
return(new CalculatorHeavy());
case CalculateType.Regular:
return(new CalculatorRegular());
case CalculateType.Specialized:
return(new CalculatorSpecialized());
default:
throw new Exception("The type does not supported !");
}
}
private double calculateAverage(int[] paramArray, CalculateType calculateType)
{
double result = 0;
if (calculateType == CalculateType.Arithmetic)
{
result = arithmeticAverage(paramArr: paramArray);
}
else if (calculateType == CalculateType.Geometric)
{
result = geometricAverage(paramArr: paramArray);
}
else if (calculateType == CalculateType.Harmonic)
{
result = harmonicAverage(paramArr: paramArray);
}
return(result);
}
public override void Calculate(DateTime baseTime, CalculateType calculateType, Quotation quotation)
{
base.Calculate(baseTime, calculateType, quotation);
if (calculateType != CalculateType.CheckRiskForQuotation)
{
foreach (var eachTran in _owner.GetTransactions())
{
foreach (var eachOrder in eachTran.Orders)
{
if (eachTran.Phase == iExchange.Common.TransactionPhase.Executed)
{
PhysicalOrder physicalOrder = (PhysicalOrder)eachOrder;
_riskData.TotalPaidAmount += physicalOrder.CalculatePaidAmount();
}
}
}
}
}
public void CheckRisk(DateTime baseTime, CalculateType calculateType, IQuotePolicyProvider quotePolicyProvider = null)
{
try
{
if (this.IsFreeOfRiskCheck)
{
return;
}
this.CalculateRiskData(baseTime, calculateType, quotePolicyProvider ?? _account);
_account.AcceptChanges();
this.ExecutePendingConfirmLimitOrders(baseTime);
this.CheckAlertLevelAndCut(baseTime);
RiskChecker.Default.Add(_account.Id, baseTime);
_account.SaveAndBroadcastChanges();
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
public void SAR(TagInfo tagInfo)
{
Tuple <double, double, double> position;
if (SARParameter.Trajectory.TryDequeue(out position))
{
string algorithmType = tssbtnAlgorithms.Text.Trim();
CalculateType calculateType = getTypeByStr(algorithmType);
ICalculateService iCalculateService = ServiceManager.getCalculateService(calculateType);
if (!SARParameter.epcSet.Contains(tagInfo.EPC))
{
iCalculateService.init(tagInfo.EPC, SARParameter.confParam);
SARParameter.epcSet.Add(tagInfo.EPC);
}
CalculateServiceClient client = (CalculateServiceClient)iCalculateService;
iCalculateService.calculate(tagInfo.EPC, position.Item1, position.Item2, position.Item3, tagInfo.Frequency, tagInfo.AcutalPhaseInRadian);
ServiceManager.closeService(iCalculateService);
//DisplayLocalizationResult(tagInfo);
}
}
public string[] GetAllTaskId(CalculateType calculateType)
{
string[] taskIds = null;
try
{
if (calculateType == CalculateType.Aggregate)
{
taskIds = TaskManager.GetAllWindowId();
}
else if (calculateType == CalculateType.Expression)
{
taskIds = TaskManager.GetAllExpressionId();
}
return(taskIds);
}
catch (Exception ex)
{
Logger.Log.Error(true, "执行GetAllTaskId出错", ex);
return(taskIds);
}
}
public ViewResult Pkm(int?id)
{
PokemonDetailViewModel ViewModel = new PokemonDetailViewModel();
ViewModel.Pokemon = repository.Pokemons.Where(p => p.PokemonID == id).Single();
var pokemonAbility = (from ability in repository.Abilities
join pkmAbility in repository.PokemonAbilities on ability.AbilityID equals pkmAbility.AbilityID
where pkmAbility.PokemonID == id
select ability);
ViewModel.Abilities = pokemonAbility;
ViewModel.Type1 = repository.Pokemons.Where(p => p.PokemonID == id).Select(p => p.Type1).Single();
var type1id = ViewModel.Type1.TypeID;
int?type2id;
ViewModel.Type2 = repository.Pokemons.Where(p => p.PokemonID == id).Select(p => p.Type2).Single();
if (ViewModel.Type2 is null)
{
type2id = null;
}
else
{
type2id = ViewModel.Type2.TypeID;
}
var query1 = repository.Pokemons.Where(p => p.PokemonID == (id - 1));
var query2 = repository.Pokemons.Where(p => p.PokemonID == (id + 1));
ViewModel.PrevPokemon = query1.Any() ? query1.Single().Name : null;
ViewModel.NextPokemon = query2.Any() ? query2.Single().Name : null;
float[] TypesDamageMultiplierList = CalculateType.CalculateTypes(type1id, type2id);
ViewModel.Weaknesses = CalculateType.FindWeaknesses(TypesDamageMultiplierList);
ViewModel.Resists = CalculateType.FindResists(TypesDamageMultiplierList);
ViewModel.Immunes = CalculateType.FindImmunes(TypesDamageMultiplierList);
return(View(ViewModel));
}
public CalculateContext(string name, string desc, DateTime leftTime, DateTime rightTime, CalculateType calculateType, ICalculateInpute inpute, ICalculateOutput output, ICalculate calculateOperator)
{
Name = name;
Desc = desc;
LeftTime = leftTime;
RightTime = rightTime;
CalculateType = calculateType;
CalculateInpute = inpute;
CalculateOutput = output;
CalculateOperator = calculateOperator;
IExecutionEnvironment env = ExecutionEnvironment.GetExecutionEnvironment(null);
if (env == null)
{
Sinks = new List <SinkFunction>();
}
else
{
Sinks = new List <SinkFunction>(((ExecutionEnvironment)env).Sinks);
}
}
public bool ContainsTaskId(string taskId, CalculateType calculateType)
{
bool containsFlag = false;
try
{
if (calculateType == CalculateType.Aggregate)
{
containsFlag = TaskManager.ContainsWindow(taskId);
}
else if (calculateType == CalculateType.Expression)
{
containsFlag = TaskManager.ContainsExpression(taskId);
}
return(containsFlag);
}
catch (Exception ex)
{
Logger.Log.Error(true, "执行ContainsTaskId出错", ex);
return(containsFlag);
}
}
private bool HasCorrectParameterCount(CalculateType calculateType, params float[] values)
{
int count = 0;
switch (calculateType)
{
case CalculateType.Addition:
case CalculateType.Subtraction:
case CalculateType.Multiplication:
case CalculateType.Division:
case CalculateType.Power:
count = 2;
break;
case CalculateType.Sine:
case CalculateType.Cosine:
count = 1;
break;
}
return(values.Length == count);
}
public virtual void Calculate(DateTime baseTime, CalculateType calculateType, Quotation quotation)
{
if (_owner.ExecutedAndHasPositionOrders.Count == 0)
{
_riskData.Clear();
return;
}
_riskData.ClearFloatingPL();
NecessaryAndQuantity necessaryAndQuantity = new NecessaryAndQuantity();
this.CalculateFloatPL(ref necessaryAndQuantity, quotation);
if (calculateType != CalculateType.CheckRiskForQuotation || necessaryAndQuantity.needCalculateNecessary)
{
_riskData.ClearNecessary();
this.CalculateNecessary(ref necessaryAndQuantity, baseTime);
}
if (this.ShouldCalculateLockOrderTradePLFloat(_owner.Owner.Setting(), necessaryAndQuantity.buyQuantitySum, necessaryAndQuantity.sellQuantitySum))
{
_riskData.LockOrderTradePLFloat = this.CalculateLockOrderTradePLFloat(necessaryAndQuantity.buyQuantitySum, necessaryAndQuantity.sellQuantitySum);
}
_riskData.RiskCredit = this.CalculateRiskCredit();
}
public Status[] CalculateWorkbook(string sessionId, CalculateType calculateType) {
object[] results = this.Invoke("CalculateWorkbook", new object[] {
sessionId,
calculateType});
return ((Status[])(results[0]));
}
/// <remarks/>
public void CalculateWorkbookAsync(string sessionId, CalculateType calculateType, object userState) {
if ((this.CalculateWorkbookOperationCompleted == null)) {
this.CalculateWorkbookOperationCompleted = new System.Threading.SendOrPostCallback(this.OnCalculateWorkbookOperationCompleted);
}
this.InvokeAsync("CalculateWorkbook", new object[] {
sessionId,
calculateType}, this.CalculateWorkbookOperationCompleted, userState);
}
/// <remarks/>
public void CalculateWorkbookAsync(string sessionId, CalculateType calculateType) {
this.CalculateWorkbookAsync(sessionId, calculateType, null);
}
