private void SaveV_Click(object sender, EventArgs e) { try { AX.Enabled = false; AY.Enabled = false; AZ.Enabled = false; BX.Enabled = false; BY.Enabled = false; BZ.Enabled = false; Point p1 = new Point(Int32.Parse(AX.Text), Int32.Parse(AY.Text), Int32.Parse(AZ.Text)); Point p2 = new Point(Int32.Parse(BX.Text), Int32.Parse(BY.Text), Int32.Parse(BZ.Text)); Vectors vectros = new Vectors(p1, p2); Calculate.AppendText(vectros.Calculate()); Scalar.AppendText(p1.ScalarV(p2) + ";"); Collinearity.AppendText(vectros.IsCollinearity()); } catch (Exception exc) { MessageBox.Show(exc.Message); AX.Clear(); AY.Clear(); AZ.Clear(); BX.Clear(); BY.Clear(); BZ.Clear(); } }
private void Start() { Attack(); Knife knife = new Knife(); AX ax = new AX(); SetWeapon(knife); Attack(); SetWeapon(ax); Attack(); }
private void Reset_Click(object sender, EventArgs e) { AX.Clear(); AY.Clear(); AZ.Clear(); BX.Clear(); BY.Clear(); BZ.Clear(); Calculate.Clear(); Scalar.Clear(); Collinearity.Clear(); AX.Enabled = true; AY.Enabled = true; AZ.Enabled = true; BX.Enabled = true; BY.Enabled = true; BZ.Enabled = true; }
private void StatesGrid_PullSelected(DataRowView g) { this.QueGrid.SelectionChanged -= QueGrid_SelectionChanged; int j = QueGrid.Items.Count; try { using (SqlConnection MomCon = new SqlConnection(MomConStr)) { string h = g.Row.ItemArray[1].ToString(); int JoyStickAssignment = int.Parse(g.Row.ItemArray[3].ToString()); if (JoyStickAssignment != -1) { this.Dispatcher.Invoke(() => SelectedQueTextBox.Text = h); Thread.Sleep(1); this.Dispatcher.Invoke(() => PopulateJoystickSelections(!(bool)QueMode, JoyStickAssignment - 1, SelectedQueTextBox.Text)); } using (SqlCommand cmd = new SqlCommand("momsql..PullAxisTargets", MomCon)) { cmd.Parameters.AddWithValue("@QueName", h); cmd.CommandType = CommandType.StoredProcedure; MomCon.Open(); cmd.ExecuteNonQuery(); MomCon.Close(); } foreach (AxisControl AX in axControl) { this.Dispatcher.Invoke(() => AX.PullSelection()); this.Dispatcher.Invoke(() => AX.queControl = (bool)this.QueMode); this.Dispatcher.Invoke(() => AX.SelectedQue = SelectedQueTextBox.Text); } } } catch { } finally { this.QueGrid.SelectionChanged += QueGrid_SelectionChanged; } }
private void StatesGridTimer_tick(object myObject, EventArgs e) { // UpdateSQL.Refresh(); int x = 0; foreach (AxisControl AX in axControl) { if (AX == null) { return; } AX.queControl = (bool)QueMode; if (!(bool)QueMode && AX.AssignedJoyStick != -1) { if (qControl[AX.AssignedJoyStick].QueName != AX.AxisNameTextBox.Text) { qControl[AX.AssignedJoyStick].QueName = AX.AxisNameTextBox.Text; } } if (UpdateSQL.ADT != null && UpdateSQL.ADT.Rows.Count > x) { if (!AX.HasKeyBoardFocus) { AX.DataContext = UpdateSQL.ADT.Rows[x]; AX.UpdateLayout(); AX.AxisNumber = (int)UpdateSQL.ADT.Rows[x].ItemArray[1]; } else { Debug.Print("EAT SHIT"); } } x++; } Task k = Task.Run(() => UpdateSQL.Refresh()); }
public bool Run() { while (PC < program.Count) { if (debug) { this.ShowProgram(); this.ShowHeap(); this.ShowStack(); } switch (program[PC]) { case (int)IS.NOP: ++PC; break; case (int)IS.IMOV: ++PC; AX = program[PC]; ++PC; break; case (int)IS.PUSH: datStack.Set(SP++, AX); ++PC; break; case (int)IS.IPUSH: ++PC; datStack.Set(SP++, program[PC]); ++PC; break; case (int)IS.TOP: AX = datStack[SP - 1]; ++PC; break; case (int)IS.POP: --SP; ++PC; break; case (int)IS.LFS: AX = datStack[SP - 1 + datStack[SP - 1]]; ++PC; break; case (int)IS.STS: datStack.Set(SP - 1 + datStack[SP - 1], AX); ++PC; break; case (int)IS.LFH: AX = datHeap.Get(datStack[SP - 1]); ++PC; break; case (int)IS.STH: datHeap.Set(datStack[SP - 1], AX); ++PC; break; case (int)IS.JMP: ++PC; PC = program[PC]; break; case (int)IS.JZ: ++PC; PC = AX == 0 ? program[PC] : PC + 1; break; case (int)IS.JNZ: ++PC; PC = AX != 0 ? program[PC] : PC + 1; break; case (int)IS.CALL: ++PC; datStack.Set(SP++, PC + 1); PC = program[PC]; break; case (int)IS.CALLS: ++PC; int addr = datStack[--SP]; datStack.Set(SP++, PC); PC = addr; break; case (int)IS.RET: PC = datStack[--SP]; break; case (int)IS.ADD: datStack[SP - 1] = datStack[SP - 1] + AX; ++PC; break; case (int)IS.SUB: datStack[SP - 1] = datStack[SP - 1] - AX; ++PC; break; case (int)IS.NEG: datStack.Set(SP++, -AX); ++PC; break; case (int)IS.MUL: datStack[SP - 1] = datStack[SP - 1] * AX; ++PC; break; case (int)IS.DIV: datStack[SP - 1] = datStack[SP - 1] / AX; ++PC; break; case (int)IS.MOD: datStack[SP - 1] = datStack[SP - 1] % AX; ++PC; break; case (int)IS.POW: datStack[SP - 1] = LuaVMHelper.Pow(datStack[SP - 1], AX); ++PC; break; case (int)IS.AND: datStack[SP - 1] = (datStack[SP - 1] != 0 && AX != 0) ? 1 : 0; ++PC; break; case (int)IS.OR: datStack[SP - 1] = (datStack[SP - 1] != 0 || AX != 0) ? 1 : 0; ++PC; break; case (int)IS.NOT: datStack.Set(SP, (AX != 0) ? 0 : 1); ++SP; ++PC; break; case (int)IS.EQ: datStack[SP - 1] = (datStack[SP - 1] == AX) ? 1 : 0;; ++PC; break; case (int)IS.NEQ: datStack[SP - 1] = (datStack[SP - 1] != AX) ? 1 : 0;; ++PC; break; case (int)IS.LT: datStack[SP - 1] = (datStack[SP - 1] < AX) ? 1 : 0;; ++PC; break; case (int)IS.LE: datStack[SP - 1] = (datStack[SP - 1] <= AX) ? 1 : 0;; ++PC; break; case (int)IS.GT: datStack[SP - 1] = (datStack[SP - 1] > AX) ? 1 : 0;; ++PC; break; case (int)IS.GE: datStack[SP - 1] = (datStack[SP - 1] >= AX) ? 1 : 0;; ++PC; break; case (int)IS.STRSUB: strStack.Add(strStack[AX].Substring(datStack[SP - 2], datStack[SP - 1])); SP -= 2; AX = strStack.Count - 1; ++PC; break; case (int)IS.STRCON: strStack[AX] = strStack[AX] + strStack[datStack[--SP]]; ++PC; break; case (int)IS.STRLEN: AX = strStack[AX].Length; ++PC; break; case (int)IS.STRCPY: strStack.Add(strStack[AX]); AX = strStack.Count - 1; ++PC; break; case (int)IS.STRADD: strStack[AX] += (char)datStack[--SP]; ++PC; break; case (int)IS.STRCMP: AX = LuaVMHelper.StrCmp(strStack[datStack[--SP]], strStack[AX]); ++PC; break; case (int)IS.STRFMT: strStack.Add(AX.ToString()); AX = strStack.Count - 1; ++PC; break; case (int)IS.PRINT: Console.WriteLine(strStack[AX]); ++PC; break; } if (debug) { Console.ReadKey(); } } return(true); }
/* Generate the action table and its associates: ** ** yy_action[] A single table containing all actions. ** yy_lookahead[] A table containing the lookahead for each entry in ** yy_action. Used to detect hash collisions. ** yy_shift_ofst[] For each state, the offset into yy_action for ** shifting terminals. ** yy_reduce_ofst[] For each state, the offset into yy_action for ** shifting non-terminals after a reduce. ** yy_default[] Default action for each state. */ public static EmitterActionTable Make(Context ctx, out int maxTokenOffset, out int minTokenOffset, out int maxNonTerminalOffset, out int minNonTerminalOffset) { /* Compute the actions on all states and count them up */ var ax = new AX[ctx.States * 2]; for (var i = 0; i < ctx.States; i++) { var state = ctx.Sorted[i]; ax[i * 2] = new AX { State = state, Token = true, Actions = state.TokenActions }; ax[i * 2 + 1] = new AX { State = state, Token = false, Actions = state.NonTerminalActions }; } maxTokenOffset = minTokenOffset = 0; maxNonTerminalOffset = minNonTerminalOffset = 0; /* Compute the action table. In order to try to keep the size of the action table to a minimum, the heuristic of placing the largest action sets first is used. */ for (var i = 0; i < ctx.States * 2; i++) { ax[i].iOrder = i; } Array.Sort(ax, _keyComparer); var actionTable = new EmitterActionTable(); for (var i = 0; i < ctx.States * 2 && ax[i].Actions > 0; i++) { var state = ax[i].State; if (ax[i].Token) { foreach (var action in state.Actions) { if (action.Symbol.ID >= ctx.Terminals) { continue; } var actionID = action.ComputeID(ctx); if (actionID < 0) { continue; } actionTable.Action(action.Symbol.ID, actionID); } state.TokenOffset = actionTable.Insert(); if (state.TokenOffset < minTokenOffset) { minTokenOffset = state.TokenOffset; } if (state.TokenOffset > maxTokenOffset) { maxTokenOffset = state.TokenOffset; } } else { foreach (var action in state.Actions) { if (action.Symbol.ID < ctx.Terminals) { continue; } if (action.Symbol.ID == ctx.Symbols.Length - 1) { continue; } var actionID = action.ComputeID(ctx); if (actionID < 0) { continue; } actionTable.Action(action.Symbol.ID, actionID); } state.NonTerminalOffset = actionTable.Insert(); if (state.NonTerminalOffset < minNonTerminalOffset) { minNonTerminalOffset = state.NonTerminalOffset; } if (state.NonTerminalOffset > maxNonTerminalOffset) { maxNonTerminalOffset = state.NonTerminalOffset; } } } ax = null; return(actionTable); }
public static void mgmres(double[] a, int[] ia, int[] ja, ref double[] x, double[] rhs, int n, int nz_num, int itr_max, int mr, double tol_abs, double tol_rel) //****************************************************************************80 // // Purpose: // // MGMRES applies the restarted GMRES iteration to a linear system. // // Discussion: // // The linear system A*X=B is solved iteratively. // // The matrix A is assumed to be sparse. To save on storage, only // the nonzero entries of A are stored. For instance, the K-th nonzero // entry in the matrix is stored by: // // A(K) = value of entry, // IA(K) = row of entry, // JA(K) = column of entry. // // The "matrices" H and V are treated as one-dimensional vectors // which store the matrix data in row major form. // // This requires that references to H[I][J] be replaced by references // to H[I+J*(MR+1)] and references to V[I][J] by V[I+J*N]. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 13 July 2007 // // Author: // // Original C version by Lili Ju. // C++ version by John Burkardt. // // Reference: // // Richard Barrett, Michael Berry, Tony Chan, James Demmel, // June Donato, Jack Dongarra, Victor Eijkhout, Roidan Pozo, // Charles Romine, Henk van der Vorst, // Templates for the Solution of Linear Systems: // Building Blocks for Iterative Methods, // SIAM, 1994, // ISBN: 0898714710, // LC: QA297.8.T45. // // Tim Kelley, // Iterative Methods for Linear and Nonlinear Equations, // SIAM, 2004, // ISBN: 0898713528, // LC: QA297.8.K45. // // Yousef Saad, // Iterative Methods for Sparse Linear Systems, // Second Edition, // SIAM, 2003, // ISBN: 0898715342, // LC: QA188.S17. // // Parameters: // // Input, double A[NZ_NUM], the matrix values. // // Input, int IA[NZ_NUM], JA[NZ_NUM], the row and column indices // of the matrix values. // // Input/output, double X[N]; on input, an approximation to // the solution. On output, an improved approximation. // // Input, double RHS[N], the right hand side of the linear system. // // Input, int N, the order of the linear system. // // Input, int NZ_NUM, the number of nonzero matrix values. // // Input, int ITR_MAX, the maximum number of (outer) iterations to take. // // Input, int MR, the maximum number of (inner) iterations to take. // MR must be less than N. // // Input, double TOL_ABS, an absolue tolerance applied to the // current residual. // // Input, double TOL_REL, a relative tolerance comparing the // current residual to the initial residual. // { const double delta = 1.0e-03; int itr; int k_copy = 0; double rho = 0; double rho_tol = 0; const bool verbose = true; double[] c = new double[mr]; double[] g = new double[mr + 1]; double[] h = new double[(mr + 1) * mr]; double[] r = new double[n]; double[] s = new double[mr]; double[] v = new double[n * (mr + 1)]; double[] y = new double[mr + 1]; int itr_used = 0; if (n < mr) { Console.WriteLine(""); Console.WriteLine("MGMRES - Fatal error!"); Console.WriteLine(" N < MR."); Console.WriteLine(" N = " + n + ""); Console.WriteLine(" MR = " + mr + ""); return; } for (itr = 1; itr <= itr_max; itr++) { AX.ax(a, ia, ja, x, ref r, n, nz_num); int i; for (i = 0; i < n; i++) { r[i] = rhs[i] - r[i]; } rho = Math.Sqrt(typeMethods.r8vec_dot_product(n, r, r)); switch (verbose) { case true: Console.WriteLine(" ITR = " + itr + " Residual = " + rho + ""); break; } rho_tol = itr switch { 1 => rho * tol_rel, _ => rho_tol }; for (i = 0; i < n; i++) { v[i + 0 * n] = r[i] / rho; } g[0] = rho; for (i = 1; i <= mr; i++) { g[i] = 0.0; } int j; for (i = 0; i < mr + 1; i++) { for (j = 0; j < mr; j++) { h[i + j * (mr + 1)] = 0.0; } } int k; for (k = 1; k <= mr; k++) { k_copy = k; AX.ax(a, ia, ja, v, ref v, n, nz_num, xIndex: +(k - 1) * n, wIndex: +k * n); double av = Math.Sqrt(typeMethods.r8vec_dot_product(n, v, v, a1Index: +k * n, a2Index: +k * n)); for (j = 1; j <= k; j++) { h[j - 1 + (k - 1) * (mr + 1)] = typeMethods.r8vec_dot_product(n, v, v, a1Index: +k * n, a2Index: +(j - 1) * n); for (i = 0; i < n; i++) { v[i + k * n] -= h[j - 1 + (k - 1) * (mr + 1)] * v[i + (j - 1) * n]; } } h[k + (k - 1) * (mr + 1)] = Math.Sqrt(typeMethods.r8vec_dot_product(n, v, v, a1Index: +k * n, a2Index: +k * n)); if (Math.Abs(av + delta * h[k + (k - 1) * (mr + 1)] - av) <= double.Epsilon) { for (j = 1; j <= k; j++) { double htmp = typeMethods.r8vec_dot_product(n, v, v, a1Index: +k * n, a2Index: +(j - 1) * n); h[j - 1 + (k - 1) * (mr + 1)] += htmp; for (i = 0; i < n; i++) { v[i + k * n] -= htmp * v[i + (j - 1) * n]; } } h[k + (k - 1) * (mr + 1)] = Math.Sqrt(typeMethods.r8vec_dot_product(n, v, v, a1Index: +k * n, a2Index: +k * n)); } if (h[k + (k - 1) * (mr + 1)] != 0.0) { for (i = 0; i < n; i++) { v[i + k * n] /= h[k + (k - 1) * (mr + 1)]; } } switch (k) { case > 1: { for (i = 1; i <= k + 1; i++) { y[i - 1] = h[i - 1 + (k - 1) * (mr + 1)]; } for (j = 1; j <= k - 1; j++) { Helpers.mult_givens(c[j - 1], s[j - 1], j - 1, ref y); } for (i = 1; i <= k + 1; i++) { h[i - 1 + (k - 1) * (mr + 1)] = y[i - 1]; } break; } } double mu = Math.Sqrt(Math.Pow(h[k - 1 + (k - 1) * (mr + 1)], 2) + Math.Pow(h[k + (k - 1) * (mr + 1)], 2)); c[k - 1] = h[k - 1 + (k - 1) * (mr + 1)] / mu; s[k - 1] = -h[k + (k - 1) * (mr + 1)] / mu; h[k - 1 + (k - 1) * (mr + 1)] = c[k - 1] * h[k - 1 + (k - 1) * (mr + 1)] - s[k - 1] * h[k + (k - 1) * (mr + 1)]; h[k + (k - 1) * (mr + 1)] = 0; Helpers.mult_givens(c[k - 1], s[k - 1], k - 1, ref g); rho = Math.Abs(g[k]); itr_used += 1; switch (verbose) { case true: Console.WriteLine(" K = " + k + " Residual = " + rho + ""); break; } if (rho <= rho_tol && rho <= tol_abs) { break; } } k = k_copy - 1; y[k] = g[k] / h[k + k * (mr + 1)]; for (i = k; 1 <= i; i--) { y[i - 1] = g[i - 1]; for (j = i + 1; j <= k + 1; j++) { y[i - 1] -= h[i - 1 + (j - 1) * (mr + 1)] * y[j - 1]; } y[i - 1] /= h[i - 1 + (i - 1) * (mr + 1)]; } for (i = 1; i <= n; i++) { for (j = 1; j <= k + 1; j++) { x[i - 1] += v[i - 1 + (j - 1) * n] * y[j - 1]; } } if (rho <= rho_tol && rho <= tol_abs) { break; } } switch (verbose) { case true: Console.WriteLine(""); Console.WriteLine("MGMRES"); Console.WriteLine(" Number of iterations = " + itr_used + ""); Console.WriteLine(" Final residual = " + rho + ""); break; } }
public static void ConflictResolution(FuzzyModel fm, float preserveThr, float ratioThr) { List <FuzzyEdge> toRemove = new List <FuzzyEdge>(); foreach (FuzzyEdge AB in fm.GetEdges()) { FuzzyEdge BA = fm.GetEdge(AB.GetToNode(), AB.GetFromNode()); float relAB = 0; float relBA = 0; if (BA != null) { if (AB.Equals(BA)) { toRemove.Add(AB); } if (toRemove.Contains(AB) || toRemove.Contains(BA)) { continue; } FuzzyNode A = AB.GetFromNode(); FuzzyNode B = AB.GetToNode(); // compute relative significance of edge A->B float sigAB = AB.GetFrequencySignificance(); float sigAX = 0; foreach (FuzzyEdge AX in A.GetOutEdges()) { sigAX += AX.GetFrequencySignificance(); } float sigXB = 0; foreach (FuzzyEdge XB in B.GetInEdges()) { sigXB += XB.GetFrequencySignificance(); } relAB = (0.5F * (sigAB / sigAX)) + (0.5F * (sigAB / sigXB)); Console.WriteLine("{0}, Relative significance: {1}", AB.ToString(), relAB); // compute relative significance of edge B->A float sigBA = BA.GetFrequencySignificance(); float sigBX = 0; foreach (FuzzyEdge BX in B.GetOutEdges()) { sigBX += BX.GetFrequencySignificance(); } float sigXA = 0; foreach (FuzzyEdge XA in A.GetInEdges()) { sigXA += XA.GetFrequencySignificance(); } relBA = (0.5F * (sigBA / sigBX)) + (0.5F * (sigBA / sigXA)); Console.WriteLine("{0}, Relative significance: {1}", BA.ToString(), relBA); // Decide preservation if (relAB < preserveThr || relBA < preserveThr) { float ofsAB = Math.Abs(relAB - relBA); if (ofsAB < ratioThr) { toRemove.Add(AB); toRemove.Add(BA); } else { if (relAB > relBA) { toRemove.Add(BA); } else { toRemove.Add(AB); } } } } } foreach (FuzzyEdge fe in toRemove) { fm.RemoveEdge(fe); } }
get => new Vector2(AX, AY);
public ActionResult CCenterList() { int userId = (int)Session[CDictionary.SK_LOGINED_USER_ID]; var w = ( from o in db.OrderList where o.cId == userId join p in db.Product on o.pId equals p.pId select new CartVM { totalPrice = ((decimal)(o.oQty * p.pPrice)) }); if (db.OrderList.FirstOrDefault(o => o.cId == userId) != null) { Session[CDictionary.TK_Cart_TOTALPRICE] = w.Sum(p => p.totalPrice).ToString("0.##"); } else { Session[CDictionary.TK_Cart_TOTALPRICE] = 0; } var user = (from c in db.Customer join a in db.Admin on c.cId equals a.cId into AX join cp in db.Company on c.CPId equals cp.CPId into AY from x in AX.DefaultIfEmpty() from y in AY.DefaultIfEmpty() where c.cId == userId select new vMemberCenterVM { firstName = c.cFName, lastName = c.cLName, email = c.cEmail, phoneNumber = c.cPhone, avatar = c.cAvatar, point = c.cPoint, birthday = c.cBD, companyId = c.CPId, companyAdd = y.CPAdd, companyBranch = y.CPBranch, companyName = y.CPName, aId = x.aId, adminDepartment = x.aDepartment, tp = w.Sum(p => p.totalPrice).ToString(), // tax=( w.Sum(p => p.totalPrice)*(decimal)0.12).ToString("0.##") }).FirstOrDefault(); // Session[CDictionary.TK_Cart_TOTALPRICE] = x.Sum(a=>a.totalPrice).ToString(); // Session[CDictionary.TK_Cart_TOTALPRICE] = w.Select(a => a.totalPrice).ToString(); if (Session[CDictionary.SK_LOGINED_USER_ID] != null && Session[CDictionary.SK_LOGINED_ADMIN_ID] != null) { Session[CDictionary.SK_LOGINED_ADMIN_ID] = user.aId; } return(View(user)); }