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); }