Other Languages - data structur

detail definition
Q :-sparse metrics.

In the subfield of numerical analysis, a sparse matrix is a matrix populated primarily with zeros . 
Conceptually, sparsity corresponds to systems which are loosely coupled. Consider a line of balls connected by springs from one to the next; this is a sparse system. By contrast, if the same line of balls had springs connecting each ball to all other balls, the system would be represented by a dense matrix. The concept of sparsity is useful in combinatorics and application areas such as network theory, which have a low density of significant data or connections.
Huge sparse matrices often appear in science or engineering when solving partial differential equations.
When storing and manipulating sparse matrices on a computer, it is beneficial and often necessary to use specialized algorithms and data structures that take advantage of the sparse structure of the matrix. Operations using standard dense matrix structures and algorithms are slow and consume large amounts of memory when applied to large sparse matrices. Sparse data is by nature easily compressed, and this compression almost always results in significantly less computer data storage usage. Indeed, some very large sparse matrices are infeasible to manipulate with the standard dense algorithms.

The native data structure for a matrix is a two-dimensional array. Each entry in the array represents an element ai,j of the matrix and can be accessed by the two indices i and j. For an m×n matrix, enough memory to store at least (m×n) entries to represent the matrix is needed.
Substantial memory requirement reductions can be realized by storing only the non-zero entries. Depending on the number and distribution of the non-zero entries, different data structures can be used and yield huge savings in memory when compared to a native approach.
Formats can be divided into two groups: (1) those that support efficient modification, and (2) those that support efficient matrix operations. The efficient modification group includes DOK, LIL, and COO and is typically used to construct the matrix. Once the matrix is constructed, it is typically converted to a format, such as CSR or CSC, which is more efficient for matrix operations.

A sparse matrix is a matrix that allows special techniques to take advantage of the large number of zero elements. This definition helps to define "how many" zeros a matrix needs in order to be "sparse." The answer is that it depends on what the structure of the matrix is, and what you want to do with it. For example, a randomly generated sparse  matrix with  entries scattered randomly throughout the matrix is not sparse in the sense of Wilkinson (for direct methods) since it takes  time to factorize (with high probability and for large enough ; Gilbert et al. 1992).

If a matrix A is stored in ordinary (dense) format, then the command S = sparse(A) creates a copy of the matrix stored in sparse format. For example:

>> A = [0 0 1;1 0 2;0 -3 0]
A =
     0     0     1
     1     0     2
     0    -3     0
>> S = sparse(A)
S =
   (2,1)        1
   (3,2)       -3
   (1,3)        1
   (2,3)        2
>> whos
  Name      Size         Bytes  Class

  A         3x3             72  double array
  S         3x3             64  sparse array

Grand total is 13 elements using 136 bytes

Unfortunately, this form of the sparse command is not particularly useful, since if A is large, it can be very time-consuming to first create it in dense format. The command S = sparse(m,n) creates an zero matrix in sparse format. Entries can then be added one-by-one:

Hello Hafiz,

A good operational definition is that a matrix is sparse if it contains enough zero entries to be worth taking advantage of them to reduce both the storage and work required in solving a linear system. Ideally, we would like to store and operate on only the nonzero entries of the matrix, but such a policy is not necessarily a clear win in either storage or work. The difficulty is that sparse data structures include more overhead (to store indices as well as numerical values of nonzero matrix entries) than the simple arrays used for dense matrices, and arithmetic operations on the data stored in them usually cannot be performed as rapidly either (due to indirect addressing of operands). There is therefore a tradeoff in memory requirements between sparse and dense representations and a tradeoff in performance between the algorithms that use them.

Hi,

Sparse Matrix
    
A sparse matrix is a matrix that allows special techniques to take advantage of the large number of zero elements. This definition helps to define "how many" zeros a matrix needs in order to be "sparse." The answer is that it depends on what the structure of the matrix is, and what you want to do with it. For example, a randomly generated sparse n×n matrix with cn entries scattered randomly throughout the matrix is not sparse in the sense of Wilkinson (for direct methods) since it takes O(n^3) time to factorize (with high probability and for large enough)

Sparse Matrix - Example

A selection of articles related to Sparse Matrix - Example:

A computer printer is a computer peripheral device that produces a hard copy (permanent human-readable text and/or graphics, usually on paper) from data stored in a computer connected to it. The world's first computer printer was a 19th-century mechanically driven apparatus invented by Charles Babbage for his Difference Engine. Computer printer - Printing mode

The naive data structure for a matrix is a two dimensional array. Each entry in the array represents an element ai,j of the matrix and can be accessed by the two indices i and j. For a n×m matrix we need at least (n*m) / 8 bytes to represent the matrix when assuming 1 bit for each entry

Follow this example , here you will get create, read, update example in XML file.

Creating a XML document

To create a XML document

using System.Xml.Linq; .. #region CreateCustomerXMLfile public static void CreateCustomerXMLfile(string filename) {   XElement connections =    new XElement("Customers",    new XElement("Customer",   new XElement("Id", "0")   new XElement("Name", "default")));   connections.Save(filename); } #endregion

To call the function and create the XML file in c:\temp\customer.xml CreateCustomerXMLfile("c:\\temp\\customer.xml");

Add a record to the Customer XML document

To add a record to the customer xml document we create the following function

#region AddCustomerToXMLfile public static string AddCustomerToXMLfile(string XMLfile, string Id, string Name) {   XDocument XMLDoc = XDocument.Load(XMLfile);   XElement root = XMLDoc.Root;   root.Add(new XElement("Customer",   new XElement("Id", Id),   new XElement("Name", Name)));   XMLDoc.Save(XMLfile);   return Id; } #endregion

Call the function a new record will be created with id 1 name Mark AddCustomerToXMLfile("c:\\temp\\Customer.xml","1","Mark");

Update a record in a XML document

First we create a customer class

#region Customer Class public class Customer { public string ID; public string NAME; } #endregion

Next we create the function to update the specific record we will call this function UpdateCustomerInXMLfile. The function wil try to find the Id in the XML document and update it with the Name parameter.

#region UpdateCustomerInXMLfile string UpdateCustomerInXMLfile(string XMLfile, string Id, string Name) { Customer customer = new Customer(); XDocument XMLDoc = XDocument.Load(XMLfile); IEnumerable<XElement> elem_list = from elem in XMLDoc.Descendants("Customer")                            where elem.Element("Id").Value == customer.ID                            select elem; XElement[] elem_array = elem_list.ToArray(); foreach (XElement elem in elem_array) {   elem.Element("Id").Value = customer.ID.ToString();    elem.Element("Name").Value = customer.NAME.ToString(); } return Id; } #endregion

Now we are ready to call the update function

UpdateCustomerInXMLfile( "c:\\temp\\Customer.xml", "1", "Johny");

The name "Mark" will have changed in  the XML document to "Johny"

TRy this and let me know.