protected void SetViewer()
{
foreach (CMacro cm in k_model.macros)
{
AMD.AddMacro(cm);
}
}
/// <summary>
/// Symbolic ordering and analysis for QR.
/// </summary>
private void SymbolicAnalysis(ColumnOrdering order, CompressedColumnStorage <double> A)
{
int m = A.RowCount;
int n = A.ColumnCount;
var sym = this.symFactor = new SymbolicFactorization();
// Fill-reducing ordering
sym.q = AMD.Generate(A, order);
var C = order > 0 ? Permute(A, null, sym.q) : SymbolicColumnStorage.Create(A);
// etree of C'*C, where C=A(:,q)
sym.parent = GraphHelper.EliminationTree(m, n, C.ColumnPointers, C.RowIndices, true);
int[] post = GraphHelper.TreePostorder(sym.parent, n);
sym.cp = GraphHelper.ColumnCounts(C, sym.parent, post, true); // col counts chol(C'*C)
bool ok = C != null && sym.parent != null && sym.cp != null && CountV(C);
if (ok)
{
sym.unz = 0;
for (int k = 0; k < n; k++)
{
sym.unz += sym.cp[k];
}
}
}
/// <summary>
/// 查詢兌換紀錄
/// </summary>
/// <param name="Model">AMD</param>
/// <param name="SDate">日期開始區間</param>
/// <param name="EDate">日期結束區間</param>
/// <returns></returns>
public ActionResult Query(AMD Model, DateTime?SDate, DateTime?EDate)
{
try
{
using (SqlConnection dbConn = new SqlConnection(_DBConn))
{
string strSQL = "SELECT * FROM AMD WHERE ID > 0 AND Type=@Type";
if (!string.IsNullOrWhiteSpace(Model.UName))
{
strSQL += " AND UName LIKE N'%'+@UName+'%'";
}
if (!string.IsNullOrWhiteSpace(Model.UPhone))
{
strSQL += " AND UPhone=@UPhone";
}
if (!string.IsNullOrWhiteSpace(Model.UEmail))
{
strSQL += " AND UEmail=@UEmail";
}
if (!string.IsNullOrWhiteSpace(Model.UInvoice))
{
strSQL += " AND UInvoice=@UInvoice";
}
if (!string.IsNullOrWhiteSpace(Model.UCPUType))
{
strSQL += " AND UCPUType=@UCPUType";
}
if (!string.IsNullOrWhiteSpace(Model.UBuyStore))
{
strSQL += " AND UBuyStore=@UBuyStore";
}
if (!string.IsNullOrWhiteSpace(Model.USeagate))
{
strSQL += " AND USeagate=@USeagate";
}
if (!string.IsNullOrWhiteSpace(Model.UTForce))
{
strSQL += " AND UTForce=@UTForce";
}
if (Model.CState != null)
{
strSQL += " AND CState=@CState";
}
if (SDate != null)
{
strSQL += $" AND InsertDateTime>='{SDate.Value.ToString("yyyy/MM/dd 00:00:00")}'";
}
if (EDate != null)
{
strSQL += $" AND InsertDateTime<'{EDate.Value.AddDays(1).ToString("yyyy/MM/dd 00:00:00")}'";
}
return(Json(dbConn.Query <AMD>(strSQL, Model).ToList(), JsonRequestBehavior.AllowGet));
}
}
catch
{
return(Json(new List <AMD>(), JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// Ordering and symbolic analysis for a Cholesky factorization
/// </summary>
/// <param name="order">Column ordering.</param>
/// <param name="A">Matrix to factorize.</param>
private void SymbolicAnalysis(ColumnOrdering order, CompressedColumnStorage <double> A)
{
int n = A.ColumnCount;
var sym = this.symFactor = new SymbolicFactorization();
// P = amd(A+A') or natural
var p = AMD.Generate(A, order);
// Find inverse permutation.
sym.pinv = Permutation.Invert(p);
// C = spones(triu(A(P,P)))
var C = PermuteSym(A, sym.pinv, false);
// Find etree of C.
sym.parent = GraphHelper.EliminationTree(n, n, C.ColumnPointers, C.RowIndices, false);
// Postorder the etree.
var post = GraphHelper.TreePostorder(sym.parent, n);
// Find column counts of chol(C)
var c = GraphHelper.ColumnCounts(SymbolicColumnStorage.Create(C, false), sym.parent, post, false);
sym.cp = new int[n + 1];
// Find column pointers for L
sym.unz = sym.lnz = Helper.CumulativeSum(sym.cp, c, n);
}
/// <summary>
/// See <see cref="IReorderingAlgorithm.FindPermutation(SparsityPatternSymmetric)"/>
/// </summary>
/// <remarks>The returned permutation is new-to-old.</remarks>
public (int[] permutation, bool oldToNew) FindPermutation(SparsityPatternSymmetric pattern)
{
int order = pattern.Order;
(int[] cscRowIndices, int[] cscColOffsets) = pattern.BuildSymmetricCSCArrays(true); //TODO: perhaps sorting is not needed here.
var dummyCscValues = new double[cscRowIndices.Length]; //TODO: too expensive
var matrixCSparse = new SparseMatrix(order, order, dummyCscValues, cscRowIndices, cscColOffsets);
int[] permutation = AMD.Generate <double>(matrixCSparse, ColumnOrdering.MinimumDegreeAtPlusA);
// It is possible that CSparse.NET AMD algorithm returns more entries than the matrix order (so far I have found 1
// extra). In that case, make sure the first ones are valid and return only them.
if (permutation.Length > order)
{
for (int i = order; i < permutation.Length; ++i)
{
if (permutation[i] < pattern.Order)
{
throw new Exception(
"Something went wrong during AMD. The permutation vector has more entries than the matrix order.");
}
}
var permutationCorrected = new int[order];
Array.Copy(permutation, permutationCorrected, order);
return(permutationCorrected, false);
}
else
{
return(permutation, false);
}
}
public override string ToString()
{
r = (AMD)base.Tag;
Binding myBinding = new Binding("initialSilence");
myBinding.Mode = BindingMode.TwoWay;
myBinding.Source = r;
txtsilence.SetBinding(TextBox.TextProperty, myBinding);
Binding myBinding2 = new Binding("greeting");
myBinding2.Mode = BindingMode.TwoWay;
myBinding2.Source = r;
txtgreeting.SetBinding(TextBox.TextProperty, myBinding2);
Binding myBinding3 = new Binding("afterGreetingSilence");
myBinding3.Mode = BindingMode.TwoWay;
myBinding3.Source = r;
txtafter.SetBinding(TextBox.TextProperty, myBinding3);
Binding myBinding4 = new Binding("totalAnalysisTime");
myBinding4.Mode = BindingMode.TwoWay;
myBinding4.Source = r;
txtanalisis.SetBinding(TextBox.TextProperty, myBinding4);
Binding myBinding5 = new Binding("minWordLength");
myBinding5.Mode = BindingMode.TwoWay;
myBinding5.Source = r;
txtmin.SetBinding(TextBox.TextProperty, myBinding5);
Binding myBinding6 = new Binding("betweenWordsSilence");
myBinding6.Mode = BindingMode.TwoWay;
myBinding6.Source = r;
txtbet.SetBinding(TextBox.TextProperty, myBinding6);
Binding myBinding7 = new Binding("maxNumberOfWords");
myBinding7.Mode = BindingMode.TwoWay;
myBinding7.Source = r;
txtmax.SetBinding(TextBox.TextProperty, myBinding7);
Binding myBinding8 = new Binding("silenceThreshold");
myBinding8.Mode = BindingMode.TwoWay;
myBinding8.Source = r;
txtsil.SetBinding(TextBox.TextProperty, myBinding8);
Binding descbinding = new Binding("Description");
descbinding.Mode = BindingMode.TwoWay;
descbinding.Source = r;
txtdesc.SetBinding(TextBox.TextProperty, descbinding);
return(base.ToString());
}
/// <summary>
/// Symbolic ordering and analysis for LU.
/// </summary>
/// <param name="order"></param>
/// <param name="A"></param>
private void SymbolicAnalysis(ColumnOrdering order, CompressedColumnStorage <double> A)
{
var sym = this.symFactor = new SymbolicFactorization();
// Fill-reducing ordering
sym.q = AMD.Generate(A, order);
// Guess nnz(L) and nnz(U)
sym.unz = sym.lnz = 4 * (A.ColumnPointers[n]) + n;
}
/// <summary>
/// Creates a sparse Cholesky factorization.
/// </summary>
/// <param name="A">Column-compressed matrix, symmetric positive definite.</param>
/// <param name="order">Ordering method to use (natural or A+A').</param>
/// <param name="progress">Report progress (range from 0.0 to 1.0).</param>
public static SparseCholesky Create(CompressedColumnStorage <Complex> A, ColumnOrdering order,
IProgress <double> progress)
{
if ((int)order > 1)
{
throw new ArgumentException(Resources.InvalidColumnOrdering, "order");
}
return(Create(A, AMD.Generate(A, order), progress));
}
private void AddMacro(object sender, EventArgs e)
{
CMacro cm = new CMacro("");
MaCrt cf = new MaCrt(cm, this);
if (cf.ShowDialog() != DialogResult.OK)
{
return;
}
k_model.macros.Add(cm);
AMD.AddMacro(cm);
}
public override string ToString()
{
r = (AMD)base.Tag;
Binding myBinding = new Binding("initialSilence");
myBinding.Mode = BindingMode.TwoWay;
myBinding.Source = r;
txtsilence.SetBinding(TextBox.TextProperty, myBinding);
Binding myBinding2 = new Binding("greeting");
myBinding2.Mode = BindingMode.TwoWay;
myBinding2.Source = r;
txtgreeting.SetBinding(TextBox.TextProperty, myBinding2);
Binding myBinding3 = new Binding("afterGreetingSilence");
myBinding3.Mode = BindingMode.TwoWay;
myBinding3.Source = r;
txtafter.SetBinding(TextBox.TextProperty, myBinding3);
Binding myBinding4 = new Binding("totalAnalysisTime");
myBinding4.Mode = BindingMode.TwoWay;
myBinding4.Source = r;
txtanalisis.SetBinding(TextBox.TextProperty, myBinding4);
Binding myBinding5 = new Binding("minWordLength");
myBinding5.Mode = BindingMode.TwoWay;
myBinding5.Source = r;
txtmin.SetBinding(TextBox.TextProperty, myBinding5);
Binding myBinding6 = new Binding("betweenWordsSilence");
myBinding6.Mode = BindingMode.TwoWay;
myBinding6.Source = r;
txtbet.SetBinding(TextBox.TextProperty, myBinding6);
Binding myBinding7 = new Binding("maxNumberOfWords");
myBinding7.Mode = BindingMode.TwoWay;
myBinding7.Source = r;
txtmax.SetBinding(TextBox.TextProperty, myBinding7);
Binding myBinding8 = new Binding("silenceThreshold");
myBinding8.Mode = BindingMode.TwoWay;
myBinding8.Source = r;
txtsil.SetBinding(TextBox.TextProperty, myBinding8);
Binding descbinding = new Binding("Description");
descbinding.Mode = BindingMode.TwoWay;
descbinding.Source = r;
txtdesc.SetBinding(TextBox.TextProperty, descbinding);
return base.ToString();
}
public ActionResult Query(AMD Model)
{
try
{
using (SqlConnection dbConn = new SqlConnection(_DBConn))
{
string strSQL = "SELECT TOP 1 * FROM AMD WHERE ID>0 AND Type=@Type AND UName=@UName AND UPhone=@UPhone ORDER BY ID DESC";
return(Json(dbConn.QueryFirstOrDefault <AMD>(strSQL, Model), JsonRequestBehavior.AllowGet));
}
}
catch
{
return(Json(new List <AMD>(), JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// 審核
/// </summary>
/// <param name="Model">AMD</param>
/// <returns></returns>
public ActionResult Verify(AMD Model)
{
try
{
using (SqlConnection dbConn = new SqlConnection(_DBConn))
{
string strSQL = "UPDATE AMD SET CState=@CState,CReason=@CReason,CAnotherReason=@CAnotherReason WHERE ID=@ID";
dbConn.Open();
using (SqlTransaction trade = dbConn.BeginTransaction())
{
dbConn.Execute(strSQL, Model, transaction: trade);
trade.Commit();
}
return(Json(true, JsonRequestBehavior.AllowGet));
}
}
catch
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
}
/// <summary>
/// Creates a sparse QR factorization.
/// </summary>
/// <param name="A">Column-compressed matrix, symmetric positive definite.</param>
/// <param name="order">Ordering method to use (natural or A+A').</param>
public static SparseQR Create(CompressedColumnStorage <double> A, ColumnOrdering order,
IProgress progress)
{
Check.NotNull(A, "A");
int m = A.RowCount;
int n = A.ColumnCount;
var C = new SparseQR(m, n);
if (m >= n)
{
var p = AMD.Generate(A, order);
// Ordering and symbolic analysis
C.SymbolicAnalysis(A, p, order == ColumnOrdering.Natural);
// Numeric QR factorization
C.Factorize(A, progress);
}
else
{
// Ax=b is underdetermined
var AT = A.Transpose();
var p = AMD.Generate(AT, order);
// Ordering and symbolic analysis
C.SymbolicAnalysis(AT, p, order == ColumnOrdering.Natural);
// Numeric QR factorization of A'
C.Factorize(AT, progress);
}
return(C);
}
public partial void BlendEquationSeparateIndexed([Flow(FlowDirection.In)] uint buf, [Flow(FlowDirection.In)] BlendEquationModeEXT modeRGB, [Flow(FlowDirection.In)] AMD modeAlpha);
public partial void BlendEquationIndexed([Flow(FlowDirection.In)] uint buf, [Flow(FlowDirection.In)] AMD mode);
public abstract void SetMultisample([Flow(FlowDirection.In)] AMD pname, [Flow(FlowDirection.In)] uint index, [Count(Count = 2), Flow(FlowDirection.In)] Span <float> val);
public abstract unsafe void SetMultisample([Flow(FlowDirection.In)] AMD pname, [Flow(FlowDirection.In)] uint index, [Count(Count = 2), Flow(FlowDirection.In)] float *val);
public abstract void TessellationMode([Flow(FlowDirection.In)] AMD mode);
public unsafe partial void GetPerfMonitorCounterInfo([Flow(FlowDirection.In)] uint group, [Flow(FlowDirection.In)] uint counter, [Flow(FlowDirection.In)] AMD pname, [Count(Computed = "pname"), Flow(FlowDirection.Out)] void *data);
/// <summary>
/// Ordering and symbolic analysis for a LDL' factorization.
/// </summary>
/// <param name="order">Column ordering.</param>
/// <param name="A">Matrix to factorize.</param>
private void SymbolicAnalysis(ColumnOrdering order, CompressedColumnStorage <double> A)
{
int n = A.ColumnCount;
var sym = this.S = new SymbolicFactorization();
var ap = A.ColumnPointers;
var ai = A.RowIndices;
// P = amd(A+A') or natural
var P = AMD.Generate(A, order);
var Pinv = Permutation.Invert(P);
// Output: column pointers and elimination tree.
var lp = new int[n + 1];
var parent = new int[n];
// Workspace
var lnz = new int[n];
var flag = new int[n];
int i, k, p, kk, p2;
for (k = 0; k < n; k++)
{
// L(k,:) pattern: all nodes reachable in etree from nz in A(0:k-1,k)
parent[k] = -1; // parent of k is not yet known
flag[k] = k; // mark node k as visited
lnz[k] = 0; // count of nonzeros in column k of L
kk = (P != null) ? (P[k]) : (k); // kth original, or permuted, column
p2 = ap[kk + 1];
for (p = ap[kk]; p < p2; p++)
{
// A(i,k) is nonzero (original or permuted A)
i = (Pinv != null) ? (Pinv[ai[p]]) : (ai[p]);
if (i < k)
{
// follow path from i to root of etree, stop at flagged node
for (; flag[i] != k; i = parent[i])
{
// find parent of i if not yet determined
if (parent[i] == -1)
{
parent[i] = k;
}
lnz[i]++; // L(k,i) is nonzero
flag[i] = k; // mark i as visited
}
}
}
}
// construct Lp index array from Lnz column counts
lp[0] = 0;
for (k = 0; k < n; k++)
{
lp[k + 1] = lp[k] + lnz[k];
}
sym.parent = parent;
sym.cp = lp;
sym.q = P;
sym.pinv = Pinv;
}
public partial void QueryObjectParameter([Flow(FlowDirection.In)] QueryTarget target, [Flow(FlowDirection.In)] uint id, [Flow(FlowDirection.In)] AMD pname, [Flow(FlowDirection.In)] OcclusionQueryEventMaskAMD param);
public partial void QueryObjectParameter([Flow(FlowDirection.In)] QueryTarget target, [Flow(FlowDirection.In)] uint id, [Flow(FlowDirection.In)] AMD pname, [Flow(FlowDirection.In)] uint param);
public partial void BlendFuncIndexed([Flow(FlowDirection.In)] uint buf, [Flow(FlowDirection.In)] AMD src, [Flow(FlowDirection.In)] AMD dst);
public partial void BlendFuncSeparateIndexed([Flow(FlowDirection.In)] uint buf, [Flow(FlowDirection.In)] BlendingFactor srcRGB, [Flow(FlowDirection.In)] BlendingFactor dstRGB, [Flow(FlowDirection.In)] BlendingFactor srcAlpha, [Flow(FlowDirection.In)] AMD dstAlpha);
public static unsafe void GetPerfMonitorCounterInfo <T0>(this AmdPerformanceMonitor thisApi, [Flow(FlowDirection.In)] uint group, [Flow(FlowDirection.In)] uint counter, [Flow(FlowDirection.In)] AMD pname, [Count(Computed = "pname"), Flow(FlowDirection.Out)] Span <T0> data) where T0 : unmanaged
{
// SpanOverloader
thisApi.GetPerfMonitorCounterInfo(group, counter, pname, out data.GetPinnableReference());
}
public partial void GetPerfMonitorCounterData([Flow(FlowDirection.In)] uint monitor, [Flow(FlowDirection.In)] AMD pname, [Flow(FlowDirection.In)] uint dataSize, [Count(Parameter = "dataSize"), Flow(FlowDirection.Out)] out uint data, [Count(Count = 1), Flow(FlowDirection.Out)] out int bytesWritten);
public partial void VertexAttribParameter([Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] AMD pname, [Flow(FlowDirection.In)] int param);
public partial void GetPerfMonitorCounterInfo <T0>([Flow(FlowDirection.In)] uint group, [Flow(FlowDirection.In)] uint counter, [Flow(FlowDirection.In)] AMD pname, [Count(Computed = "pname"), Flow(FlowDirection.Out)] out T0 data) where T0 : unmanaged;
/// <summary>
/// Creates a LU factorization.
/// </summary>
/// <param name="A">Column-compressed matrix, must be square.</param>
/// <param name="order">Ordering method to use (natural or A+A').</param>
/// <param name="tol">Partial pivoting tolerance (form 0.0 to 1.0).</param>
/// <param name="progress">Report progress (range from 0.0 to 1.0).</param>
public static SparseLU Create(CompressedColumnStorage <Complex> A, ColumnOrdering order,
double tol, IProgress <double> progress)
{
return(Create(A, AMD.Generate(A, order), tol, progress));
}
public partial void RenderbufferStorageMultisampleAdvance([Flow(FlowDirection.In)] RenderbufferTarget target, [Flow(FlowDirection.In)] uint samples, [Flow(FlowDirection.In)] uint storageSamples, [Flow(FlowDirection.In)] AMD internalformat, [Flow(FlowDirection.In)] uint width, [Flow(FlowDirection.In)] uint height);
public static unsafe void GetPerfMonitorCounterData(this AmdPerformanceMonitor thisApi, [Flow(FlowDirection.In)] uint monitor, [Flow(FlowDirection.In)] AMD pname, [Flow(FlowDirection.In)] uint dataSize, [Count(Parameter = "dataSize"), Flow(FlowDirection.Out)] Span <uint> data, [Count(Count = 1), Flow(FlowDirection.Out)] Span <int> bytesWritten)
{
// SpanOverloader
thisApi.GetPerfMonitorCounterData(monitor, pname, dataSize, out data.GetPinnableReference(), out bytesWritten.GetPinnableReference());
}
