public void CanConvertArrayToSparseVector() { var array = new[] { new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1) }; var vector = new SparseVector(array); Assert.IsInstanceOf(typeof(SparseVector), vector); CollectionAssert.AreEqual(array, array); }
public void CanConvertArrayToSparseVector() { var array = new[] { 0.0, 1.0, 2.0, 3.0, 4.0 }; var vector = new SparseVector(array); Assert.IsInstanceOf(typeof(SparseVector), vector); CollectionAssert.AreEqual(array, array); }
public void CanConvertSparseVectorToArray() { var vector = new SparseVector(Data); var array = vector.ToArray(); Assert.IsInstanceOf(typeof(double[]), array); CollectionAssert.AreEqual(vector, array); }
public double Compute(SparseVector x, SparseVector z) { double temp; temp = ((SparseVector)(x - z)).Magnitude; return Math.Exp(-sigma * (temp * temp)); }
public ExampleSet GetProof(SparseVector x) { ExampleSet res = new ExampleSet(); List<ExampleDistancePair> list = new List<ExampleDistancePair>(); foreach (Example e in m_t_set.Examples) { list.Add(new ExampleDistancePair(e, SparseVector.Distance(x, e.X))); } list.Sort(); int[] votes = new int[m_catnum]; for (int i = 0; i < votes.Length; i++) { votes[i] = 0; } for (int i = 0; i < this.m_k; i++) { ExampleDistancePair pair = list[i]; res.AddExample(pair.Example); } return res; }
//-- VMP ------------------------------------------------------------------------------------------- /// <summary> /// Evidence message for VMP /// </summary> /// <param name="sample">Incoming message from 'sample'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="probsTrue">Incoming message from 'probsTrue'. Must be a proper distribution. If any element is uniform, the result will be uniform.</param> /// <param name="MeanLog">Buffer 'MeanLog'.</param> /// <param name="MeanLogOneMinus">Buffer 'MeanLogOneMinus'.</param> /// <returns>Average of the factor's log-value across the given argument distributions</returns> /// <remarks><para> /// The formula for the result is <c>sum_(sample,probsTrue) p(sample,probsTrue) log(factor(sample,probsTrue))</c>. /// Adding up these values across all factors and variables gives the log-evidence estimate for VMP. /// </para></remarks> /// <exception cref="ImproperMessageException"><paramref name="sample"/> is not a proper distribution</exception> /// <exception cref="ImproperMessageException"><paramref name="probsTrue"/> is not a proper distribution</exception> public static double AverageLogFactor([Proper] SparseBernoulliListBase sample, [Proper] SparseBetaList probsTrue, SparseVector MeanLog, SparseVector MeanLogOneMinus) { //var MeanLogOneMinus = probsTrue.GetMeanLogOneMinus(); var p = sample.GetProbTrueVector(); var res = p * MeanLog + (1 - p) * MeanLogOneMinus; return res.Sum(); }
/// <summary> /// Adds each element of vec to corresponding element of addTo vector /// addTo vector is being changed in place /// </summary> public static void AddInPlace(SparseVector<double> addTo, SparseVector<double> vec) { foreach (var vecIdx in vec.InnerIdx) { var num = addTo.TryGet(vecIdx, 0.0); addTo[vecIdx] = num + vec[vecIdx]; } }
public void CanCallUnaryNegationOperatorOnSparseVector() { var vector = new SparseVector(_data); var other = -vector; for (var i = 0; i < _data.Length; i++) { Assert.AreEqual(-_data[i], other[i]); } }
public static SparseVector<double> Multiply(double scalar, SparseVector<double> vector) { var newVector = vector.DeepClone(); for (int i = 0; i < newVector.InnerDat.Count; i++ ) { newVector.SetDirect(i, newVector.InnerDat[i] * scalar); } return newVector; }
public void AddRowTestAddsRowWithGivenVector() { SparseVector v = new SparseVector(TestMatrix.Columns); v[2] = 5.1f; TestMatrix.AddRow(v); float expected = 5.1f; Assert.AreEqual(expected, TestMatrix[3, 2]); }
/// <summary> /// Creates a new instance of the Vector class. /// </summary> /// <param name="data">The array to create this vector from.</param> /// <returns>The new <c>Vector</c>.</returns> protected override Vector<double> CreateVector(IList<double> data) { var vector = new SparseVector(data.Count); for (var index = 0; index < data.Count; index++) { vector[index] = data[index]; } return vector; }
public void ConstructorThrowsArgumentNullExceptionIfNullArgumentPassed() { // arrange // act var sv = new SparseVector<double>(null); // assert Assert.Fail("SparseVector ctor must throw ArgumentNullException if null argument passed."); }
/// <summary> /// Divides each element of dividee with corresponding element of divisor in place /// Dividee is being changed /// </summary> public static void DivideInPlace(SparseVector<double> dividee, SparseVector<double> divisor) { foreach (var divIdx in divisor.InnerIdx) { var num = dividee.TryGet(divIdx, 0.0); if (num < Double.Epsilon) continue; dividee[divIdx] = num/divisor[divIdx]; } }
public void CanCreateSparseVectorFromArray() { var data = new double[Data.Length]; Array.Copy(Data, data, Data.Length); var vector = new SparseVector(data); for (var i = 0; i < data.Length; i++) { Assert.AreEqual(data[i], vector[i]); } }
public void AddColumnTestAddsColumnWithGivenValue() { SparseVector expected = new SparseVector(TestMatrix.Rows); expected[0] = 5.0f; expected[1] = 5.0f; expected[2] = 5.0f; TestMatrix.AddColumn(5.0f); Assert.IsTrue(expected.ApproximatelyEqual( TestMatrix.ColumnVector(TestMatrix.Columns - 1))); }
public Binary_SVM_SMO(int n) { this.m_NonBound = new List<int>(); this.m_rand = new Random(); this.m_weight = new SparseVector(n); // foamliu, 2008/12/29, default values this.m_c = Constants.SVM_C; this.m_eta = Constants.SVM_Eta; this.m_tolerance = Constants.SVM_Tolerance; this.m_epsilon = Constants.SVM_Epsilon; }
public void CanAddTwoSparseVectorsUsingOperator() { var vector = new SparseVector(Data); var other = new SparseVector(Data); var result = vector + other; for (var i = 0; i < Data.Length; i++) { AssertHelpers.AreEqual(Data[i], vector[i]); AssertHelpers.AreEqual(Data[i], other[i]); AssertHelpers.AreEqual(Data[i] * 2.0f, result[i]); } }
public void CanAddTwoSparseVectorsUsingOperator() { var vector = new SparseVector(_data); var other = new SparseVector(_data); var result = vector + other; for (var i = 0; i < _data.Length; i++) { Assert.AreEqual(_data[i], vector[i], "Making sure the original vector wasn't modified."); Assert.AreEqual(_data[i], other[i], "Making sure the original vector wasn't modified."); Assert.AreEqual(_data[i] * 2.0, result[i]); } }
public void CanAddTwoSparseVectorsUsingOperator() { var vector = new SparseVector(Data); var other = new SparseVector(Data); var result = vector + other; CollectionAssert.AreEqual(Data, vector, "Making sure the original vector wasn't modified."); CollectionAssert.AreEqual(Data, other, "Making sure the original vector wasn't modified."); for (var i = 0; i < Data.Length; i++) { Assert.AreEqual(Data[i] * 2.0f, result[i]); } }
public void IndexedPropertyGetAccessorReturnsWhatWasSavedThroughConstructor() { // arrange var originalVector = SparseVectorHelper.GenerateRandomVector(1000, 0.7, () => SparseVectorHelper.RandomInInterval(-100, 100, 2)); // act var sv = new SparseVector<double>(originalVector); // assert foreach (var element in originalVector) { Assert.AreEqual(element.Value, sv[element.Key]); } }
public static SparseVector<double> Add(SparseVector<double> v1, SparseVector<double> v2) { var newVector = new SparseVector<double>(); var v1LastI = v1.Count > 0 ? v1.Last.Idx : 0; var v2LastI = v2.Count > 0 ? v2.Last.Idx : 0; var limit = Math.Max(v1LastI, v2LastI); for (int i = 0; i < limit; i++) { var sum = v1.TryGet(i, 0.0) + v2.TryGet(i, 0.0); if (sum > Double.Epsilon) newVector[i] = sum; } return newVector; }
public void Test() { int l = 30; int k = 10; double ratioSeparable = 0; int numSeparable = 0; ExampleSet set = new ExampleSet(); for (int d = 10; d < 50; d=d+10) { numSeparable = 0; for (int n = 0; n < k; n++) { set.Examples.Clear(); for (int i = 0; i < l; i++) { SparseVector x = new SparseVector(d); for (int j = 0; j < d; j++) { x[j] = m_rand.NextDouble(); } Category c = GetRandCategory(); Example e = new Example(c); e.X = x; set.AddExample(e); } SimpleLLM llm = new SimpleLLM(set, d); //Logging.Info(string.Format("IsLinearSeparable: {0}", llm.IsLinearSeparable())); //System.Console.WriteLine(string.Format("IsLinearSeparable: {0}", llm.IsLinearSeparable())); if (llm.IsLinearSeparable()) { numSeparable++; } } ratioSeparable = 1.0 * numSeparable / k; System.Console.WriteLine(string.Format("d: {0}, l: {1}, Separable ratio: {2}", d, l, ratioSeparable)); } }
public static SparseVector<double> GenerateSparseVector(int columns, double density, Func<double> randomGenerator) { if (density < 0 || density > 1) { throw new ArgumentOutOfRangeException("rowDensity"); } var rowDensity = columns * density; var nonZeroElementsInRow = Poisson(rowDensity); var result = new SparseVector<double>(); for (var j = 0; j < nonZeroElementsInRow; j++) { result[Random.Next(0, columns)] = randomGenerator(); } return result; }
private SparseVector m_weight; // weight vector #endregion Fields #region Constructors public Binary_SVM_SMO(ClassificationProblem problem) { this.m_problem = problem; this.m_t_set = this.m_problem.TrainingSet; // this.m_problem.RetrieveVocabulary(out this.m_voc); this.m_l = m_t_set.Examples.Count; this.m_alpha = new double[m_l]; this.m_error = new double[m_l]; this.m_kernel = new LinearKernel(); this.m_NonBound = new List<int>(); this.m_rand = new Random(); this.m_weight = new SparseVector(problem.Dimension); // foamliu, 2009/01/12, default values this.m_c = Constants.SVM_C; this.m_eta = Constants.SVM_Eta; this.m_tolerance = Constants.SVM_Tolerance; this.m_epsilon = Constants.SVM_Epsilon; }
public static void Main() { Vector vector = new SparseVector(10); for (int i = 0; i < vector.Count; i++) { vector[i] = i % 2 * i; } //The Vector enumerator also returns a KeyValuePair with the key being the //element's position in the Vector and the value being the element's value. //For sparse matrices, the enumerator only returns non-zero values. //The code below will return: //Position: 1, Value: 1 //Position: 3, Value: 3 //Position: 5, Value: 5 //Position: 7, Value: 7 //Position: 9, Value: 9 foreach (KeyValuePair<int, double> element in vector.GetIndexedEnumerator()) { Console.WriteLine("Position: {0}, Value: {1}", element.Key, element.Value); } }
private static void BuildExample(TextExample example, Vocabulary voc, int exampleCount) { int dimension = voc.Count; SparseVector vector = new SparseVector(dimension); foreach (string word in example.Tokens.Keys) { int pos = voc.GetWordPosition(word); if (pos == Constants.KEY_NOT_FOUND) continue; // phi i(x) = tfi log(idfi) /k // tfi: number of occurences of the term i in the document x // idfi: the ratio between the total number of documents and the // number of documents containing the term // k: normalisation constant ensuring that ||phi|| = 1 double phi = example.Tokens[word] * Math.Log(exampleCount / voc.WordExampleOccurMap[word]); vector.Components.Add(pos, phi); } vector.Normalize(); example.X = vector; }
public void CanCreateSparseVectorFromAnotherSparseVector() { var vector = new SparseVector(Data); var other = new SparseVector(vector); Assert.AreNotSame(vector, other); for (var i = 0; i < Data.Length; i++) { Assert.AreEqual(vector[i], other[i]); } }
/// <summary> /// Initialize a new MultiPathGenerator with constant drifts and variances. /// </summary> /// <summary> /// Initialize a new MultiPathGenerator which samples at explicitly specified times. /// </summary> /// <remarks> /// The initial time is assumed to be zero and must /// <b>not</b> be included in the passed SparseVector. /// </remarks> /// <param name="generator"></param> /// <param name="drifts"> /// A <see cref="SparseVector"/> of constant drifts - one for each single asset. /// </param> /// <param name="covariance"> /// A covariance <see cref="Matrix"/> which encapsulates the relations between /// the diffusion components of the single assets. /// </param> /// <param name="times"> /// A <see cref="SparseVector"/> of explicitly specified times at which the /// path will be sampled. /// The initial time is assumed to be zero and must /// <b>not</b> be included in the passed SparseVector. /// </param> public MultiPathGenerator(IContinuousRng generator, SparseVector drifts, Matrix covariance, SparseVector times) : base(drifts, times) { InitializeGenerator(generator, covariance); }
/// <summary> /// foamliu, 2009/05/14, 补上这个方法. /// </summary> /// <param name="x">要分类的向量</param> /// <param name="iResult">分类结果: +1 或者 -1</param> public override int Predict(SparseVector x) { double confidence; return(this.Predict(x, out confidence)); }
static void Main(string[] args) { // Get the stop words and stemmer for English. IStemmer stemmer; Set <string> .ReadOnly stopWords; TextMiningUtils.GetLanguageTools(Language.English, out stopWords, out stemmer); // Create a tokenizer. UnicodeTokenizer tokenizer = new UnicodeTokenizer(); tokenizer.MinTokenLen = 2; // Each token must be at least 2 // characters long. tokenizer.Filter = TokenizerFilter.AlphaStrict; // Tokens // can consist of alphabetic characters only. // Load a document corpus from a file. Each line in the file // represents one document. string[] docs = File.ReadAllLines("..\\..\\Data\\YahooFinance.txt"); // Create a bag-of-words space. BowSpace bowSpc = new BowSpace(); bowSpc.Tokenizer = tokenizer; // Assign the tokenizer. bowSpc.StopWords = stopWords; // Assign the stop words. bowSpc.Stemmer = stemmer; // Assign the stemmer. bowSpc.MinWordFreq = 3; // A term must appear at least 3 // times in the corpus for it to be part of the // vocabulary. bowSpc.MaxNGramLen = 3; // Terms consisting of at most 3 // consecutive words will be considered. bowSpc.WordWeightType = WordWeightType.TfIdf; // Set the // weighting scheme for the bag-of-words vectors to // TF-IDF. bowSpc.NormalizeVectors = true; // The TF-IDF vectors will // be normalized. bowSpc.CutLowWeightsPerc = 0.2; // The terms with the lowest // weights, summing up to 20% of the overall weight sum, // will be removed from each TF-IDF vector. bowSpc.Initialize(docs); // Initialize the BOW space. // Compute 100 clusters of documents. KMeansFast kMeans = new KMeansFast(100); // Set k to 100. kMeans.Trials = 3; // Perform 3 repetitions. Take the best // result. kMeans.Eps = 0.001; // Stop iterating when the partition // quality increases for less than 0.001. ClusteringResult cr = kMeans.Cluster(bowSpc); // Execute. // Extract the top 5 terms with the highest TF-IDF weights // from each of the clusters' centroids and output the // number of documents (companies) in each cluster. foreach (Cluster cl in cr.Roots) { SparseVector <double> .ReadOnly centroid = cl.ComputeCentroid(bowSpc, CentroidType.NrmL2); Console.Write(bowSpc.GetKeywordsStr(centroid, 5)); Console.WriteLine(" ({0} companies)", cl.Items.Count); } // Output the documents that are contained in the first // cluster. foreach (int docIdx in cr.Roots[0].Items) { Console.WriteLine(docs[docIdx]); } }
/// <summary> /// Creates a vector from an array. /// </summary> /// <param name="data">The array to create this vector from.</param> /// <returns>The new vector. </returns> protected override Vector <float> CreateVector(float[] data) { return(SparseVector.OfEnumerable(data)); }
public double Compute(SparseVector x, SparseVector z) { return(Math.Pow(scale * SparseVector.DotProduct(x, z) + offset, degree)); }
public abstract int Predict(SparseVector x);
// *** ISimilarity<SparseVector<double>> interface implementation *** public double GetSimilarity(SparseVector <double> a, SparseVector <double> b) { return(GetSimilarity(new SparseVector <double> .ReadOnly(a), new SparseVector <double> .ReadOnly(b))); }
public double[] Solve(double[] x0, double[,] a, double[] b, double[] measurability, double[] tolerance, double[] lower, double[] upper) { // Проверка аргументов на null _ = x0 ?? throw new ArgumentNullException(nameof(x0)); _ = a ?? throw new ArgumentNullException(nameof(a)); _ = b ?? throw new ArgumentNullException(nameof(b)); _ = measurability ?? throw new ArgumentNullException(nameof(measurability)); _ = tolerance ?? throw new ArgumentNullException(nameof(tolerance)); _ = lower ?? throw new ArgumentNullException(nameof(lower)); _ = upper ?? throw new ArgumentNullException(nameof(upper)); //Проверка аргументов на размерности if (x0.Length == 0) { throw new ArgumentException(nameof(x0)); } if (a.GetLength(1) != x0.Length) { throw new ArgumentException("Array length by dimension 1 is not equal to X0 length.", nameof(a)); } if (b.Length != a.GetLength(0)) { throw new ArgumentException("Array length is not equal to A length by 0 dimension.", nameof(b)); } if (measurability.Length != x0.Length) { throw new ArgumentException("Array length is not equal to X0 length.", nameof(measurability)); } if (tolerance.Length != x0.Length) { throw new ArgumentException("Array length is not equal to X0 length.", nameof(tolerance)); } if (lower.Length != x0.Length) { throw new ArgumentException("Array length is not equal to X0 length.", nameof(lower)); } if (upper.Length != x0.Length) { throw new ArgumentException("Array length is not equal to X0 length.", nameof(upper)); } var stopWatch = new Stopwatch(); stopWatch.Start(); var i = SparseMatrix.OfDiagonalArray(measurability); var w = SparseMatrix.OfDiagonalVector(1 / SparseVector.OfEnumerable(tolerance).PointwisePower(2)); var h = i * w; var d = -(h * SparseVector.OfEnumerable(x0)); var func = new QuadraticObjectiveFunction(h.ToArray(), d.ToArray()); var constraints = new List <LinearConstraint>(); Time = stopWatch.Elapsed; //Нижние и верхние границы for (var j = 0; j < x0.Length; j++) { constraints.Add(new LinearConstraint(1) { VariablesAtIndices = new[] { j }, ShouldBe = ConstraintType.GreaterThanOrEqualTo, Value = lower[j] }); constraints.Add(new LinearConstraint(1) { VariablesAtIndices = new[] { j }, ShouldBe = ConstraintType.LesserThanOrEqualTo, Value = upper[j] }); } //Ограничения для решения задачи баланса for (var j = 0; j < b.Length; j++) { var notNullElements = Array.FindAll(a.GetRow(j), x => Math.Abs(x) > 0.0000001); var notNullElementsIndexes = new List <int>(); for (var k = 0; k < x0.Length; k++) { if (Math.Abs(a[j, k]) > 0.0000001) { notNullElementsIndexes.Add(k); } } constraints.Add(new LinearConstraint(notNullElements.Length) { VariablesAtIndices = notNullElementsIndexes.ToArray(), CombinedAs = notNullElements, ShouldBe = ConstraintType.EqualTo, Value = b[j] }); } var solver = new GoldfarbIdnani(func, constraints); if (!solver.Minimize()) { throw new ApplicationException("Failed to solve balance task."); } stopWatch.Stop(); TimeAll = stopWatch.Elapsed; DisbalanceOriginal = a.Dot(x0).Subtract(b).Euclidean(); Disbalance = a.Dot(solver.Solution).Subtract(b).Euclidean(); return(solver.Solution); }
public ClusteringResult Cluster(IExampleCollection <LblT, SparseVector <double> .ReadOnly> dataset) { Utils.ThrowException(dataset == null ? new ArgumentNullException("dataset") : null); Utils.ThrowException(dataset.Count < m_k ? new ArgumentValueException("dataset") : null); ClusteringResult clustering = null; ClusteringResult best_clustering = null; double global_best_clust_qual = 0; for (int trial = 1; trial <= m_trials; trial++) { Utils.VerboseLine("*** CLUSTERING TRIAL {0} OF {1} ***", trial, m_trials); ArrayList <SparseVector <double> .ReadOnly> centroids = null; clustering = new ClusteringResult(); for (int i = 0; i < m_k; i++) { clustering.Roots.Add(new Cluster()); } // select seed items double min_sim = double.MaxValue; ArrayList <int> tmp = new ArrayList <int>(dataset.Count); for (int i = 0; i < dataset.Count; i++) { tmp.Add(i); } for (int k = 0; k < 3; k++) { ArrayList <SparseVector <double> .ReadOnly> seeds = new ArrayList <SparseVector <double> .ReadOnly>(m_k); tmp.Shuffle(m_rnd); for (int i = 0; i < m_k; i++) { seeds.Add(ModelUtils.ComputeCentroid(new SparseVector <double> .ReadOnly[] { dataset[tmp[i]].Example }, m_centroid_type)); } // assess quality of seed items double sim_avg = 0; foreach (SparseVector <double> .ReadOnly seed_1 in seeds) { foreach (SparseVector <double> .ReadOnly seed_2 in seeds) { if (seed_1 != seed_2) { sim_avg += m_similarity.GetSimilarity(seed_1, seed_2); } } } sim_avg /= (double)(m_k * m_k - m_k); //Console.WriteLine(sim_avg); if (sim_avg < min_sim) { min_sim = sim_avg; centroids = seeds; } } // main loop int iter = 0; double best_clust_qual = 0; double clust_qual; while (true) { iter++; clust_qual = 0; // assign items to clusters foreach (Cluster cluster in clustering.Roots) { cluster.Items.Clear(); } for (int i = 0; i < dataset.Count; i++) { SparseVector <double> .ReadOnly example = dataset[i].Example; double max_sim = double.MinValue; ArrayList <int> candidates = new ArrayList <int>(); for (int j = 0; j < m_k; j++) { SparseVector <double> .ReadOnly centroid = centroids[j]; double sim = m_similarity.GetSimilarity(example, centroid); if (sim > max_sim) { max_sim = sim; candidates.Clear(); candidates.Add(j); } else if (sim == max_sim) { candidates.Add(j); } } if (candidates.Count > 1) { candidates.Shuffle(m_rnd); } if (candidates.Count > 0) // *** is this always true? { clustering.Roots[candidates[0]].Items.Add(new Pair <double, int>(1, i)); clust_qual += max_sim; } } clust_qual /= (double)dataset.Count; Utils.VerboseLine("*** Iteration {0} ***", iter); Utils.VerboseLine("Quality: {0:0.0000}", clust_qual); // check if done if (iter > 1 && clust_qual - best_clust_qual <= m_eps) { break; } best_clust_qual = clust_qual; // compute new centroids for (int i = 0; i < m_k; i++) { centroids[i] = clustering.Roots[i].ComputeCentroid(dataset, m_centroid_type); } } if (trial == 1 || clust_qual > global_best_clust_qual) { global_best_clust_qual = clust_qual; best_clustering = clustering; } } return(best_clustering); }
/// <summary> /// foamliu, 2009/05/14, 补上这个方法. /// </summary> /// <param name="x"></param> /// <param name="confidence"></param> public override int Predict(SparseVector x, out double confidence) { confidence = 1.0; return(this.Predict(x)); }
public State() { SparseData = new SparseVector(); }
/// <summary> /// Creates a vector from an array. /// </summary> /// <param name="data">The array to create this vector from.</param> /// <returns>The new vector. </returns> protected override Vector <Complex> CreateVector(Complex[] data) { return(SparseVector.OfEnumerable(data)); }
public SimpleLLM(ExampleSet t_set, int d) { this.m_t_set = t_set; this.m_l = t_set.Examples.Count; this.m_weight = new SparseVector(d); }
public static ulong GetSimHash64(SparseVector<double>.ReadOnly vec, ArrayList<Word>.ReadOnly vocabulary, double eps) { // TODO: check parameters double[] v = new double[64]; Array.Clear(v, 0, 64); foreach (IdxDat<double> item in vec) { Word word = vocabulary[item.Idx]; double weight = item.Dat; ulong hashCode = word.GetHashCode64(); for (int i = 0; i < 64; i++) { if ((hashCode & (1UL << i)) > 0) { v[i] += weight; } else { v[i] -= weight; } } } ulong fp = 0; for (int i = 0; i < 64; i++) { if (v[i] >= eps) { fp |= (1UL << i); } } return fp; }
private void Replicate(SparseVector <double> vector, out SparseVector <double> vector1, out SparseVector <double> vector2) { int featureIdx = BowSpace.Words.Count; vector1 = vector.Clone(); vector1.InnerIdx.Add(featureIdx); vector1.InnerDat.Add(H1); vector2 = vector.Clone(); vector2.InnerIdx.Add(featureIdx); vector2.InnerDat.Add(H2); ModelUtils.TryNrmVecL2(vector1); ModelUtils.TryNrmVecL2(vector2); }
/// <summary> /// Gets a vector of P(true) values. /// </summary> /// <returns></returns> public void SetProbTrueVector(SparseVector probTrueVector) { LogOddsVector.SetToFunction(probTrueVector, MMath.Logit); }
public void ParseIfMissingClosingParenThrowsFormatException() { Assert.Throws <FormatException>(() => SparseVector.Parse("(1")); Assert.Throws <FormatException>(() => SparseVector.Parse("[1")); }
public double Compute(SparseVector x, SparseVector z) { return(Math.Tanh(scale * SparseVector.DotProduct(x, z) + offset)); }
public Vector2D[] ComputeLayout(LayoutSettings settings) { UnlabeledDataset <SparseVector <double> > dataset = new UnlabeledDataset <SparseVector <double> >(mDataset); // clustering mLogger.Info("ComputeLayout", "Clustering ..."); KMeansFast kMeans = new KMeansFast(mKClust); kMeans.Eps = mKMeansEps; kMeans.Random = mRandom; kMeans.Trials = 1; ClusteringResult clustering = kMeans.Cluster(mDataset); // throws ArgumentValueException // determine reference instances UnlabeledDataset <SparseVector <double> > dsRefInst = new UnlabeledDataset <SparseVector <double> >(); foreach (Cluster cluster in clustering.Roots) { SparseVector <double> centroid = cluster.Items.Count > 0 ? cluster.ComputeCentroid(mDataset, CentroidType.NrmL2) : new SparseVector <double>(); dsRefInst.Add(centroid); // dataset of reference instances dataset.Add(centroid); // add centroids to the main dataset } // position reference instances mLogger.Info("ComputeLayout", "Positioning reference instances ..."); SparseMatrix <double> simMtx = ModelUtils.GetDotProductSimilarity(dsRefInst, mSimThresh, /*fullMatrix=*/ false); StressMajorizationLayout sm = new StressMajorizationLayout(dsRefInst.Count, new DistFunc(simMtx)); sm.Random = mRandom; Vector2D[] centrPos = sm.ComputeLayout(); // k-NN mLogger.Info("ComputeLayout", "Computing similarities ..."); simMtx = ModelUtils.GetDotProductSimilarity(dataset, mSimThresh, /*fullMatrix=*/ true); mLogger.Info("ComputeLayout", "Constructing system of linear equations ..."); LabeledDataset <double, SparseVector <double> > lsqrDs = new LabeledDataset <double, SparseVector <double> >(); foreach (IdxDat <SparseVector <double> > simMtxRow in simMtx) { if (simMtxRow.Dat.Count <= 1) { mLogger.Warn("ComputeLayout", "Instance #{0} has no neighborhood.", simMtxRow.Idx); } ArrayList <KeyDat <double, int> > knn = new ArrayList <KeyDat <double, int> >(simMtxRow.Dat.Count); foreach (IdxDat <double> item in simMtxRow.Dat) { if (item.Idx != simMtxRow.Idx) { knn.Add(new KeyDat <double, int>(item.Dat, item.Idx)); } } knn.Sort(DescSort <KeyDat <double, int> > .Instance); int count = Math.Min(knn.Count, mKNN); SparseVector <double> eq = new SparseVector <double>(); double wgt = 1.0 / (double)count; for (int i = 0; i < count; i++) { eq.InnerIdx.Add(knn[i].Dat); eq.InnerDat.Add(-wgt); } eq.InnerIdx.Sort(); // *** sort only indices eq[simMtxRow.Idx] = 1; lsqrDs.Add(0, eq); } Vector2D[] layout = new Vector2D[dataset.Count - mKClust]; for (int i = dataset.Count - mKClust, j = 0; i < dataset.Count; i++, j++) { SparseVector <double> eq = new SparseVector <double>(new IdxDat <double>[] { new IdxDat <double>(i, 1) }); lsqrDs.Add(centrPos[j].X, eq); } LSqrModel lsqr = new LSqrModel(); lsqr.Train(lsqrDs); for (int i = 0; i < layout.Length; i++) { layout[i].X = lsqr.Solution[i]; } for (int i = lsqrDs.Count - mKClust, j = 0; i < lsqrDs.Count; i++, j++) { lsqrDs[i].Label = centrPos[j].Y; } lsqr.Train(lsqrDs); for (int i = 0; i < layout.Length; i++) { layout[i].Y = lsqr.Solution[i]; } return(settings == null ? layout : settings.AdjustLayout(layout)); }
public abstract int Predict(SparseVector x, out double confidence);
//gamma is second level parameter public static Cluster run(Cluster histClus, Network curNet, double alpha, double gamma, double lambda, Dictionary <int, double> betaVec, int typeNum) { Cluster curClus = new Cluster(typeNum); //clustering for each type double log_alpha = Math.Log(alpha); SparseVector logPriorPropVec = new SparseVector(); if (histClus.clusterList.Count != 0) { foreach (KeyValuePair <int, double> kvp in histClus.clusterSizeVec.vector) { logPriorPropVec[kvp.Key] = Math.Log(kvp.Value); //log (lambda* pi_k) } } /*****************************/ //background 2: uniform background /*********************************************/ Dictionary <int, HashSet <int> > attributeDict = new Dictionary <int, HashSet <int> >(); for (int type = 0; type < typeNum; type++) { attributeDict[type] = new HashSet <int>(); attributeDict[type].UnionWith(histClus.attriClusMatList[type].getKeys()); attributeDict[type].UnionWith(curNet.entityList[type].IDHT.Keys); } /*********************************************/ //foreach object in curNet, adjust their cluster membership, until converge double epsi = double.MaxValue; double EPSI = 0.0001; int INITITER = 0; HashSet <int> candidateClus = new HashSet <int>(); //initial clusters are historical clusters. It should be commented if do not need prior clusters if (histClus.clusterList.Count != 0) { candidateClus.UnionWith(histClus.clusterList); } int iter = 0; int objSize = curNet.network.tensor.Count; /******* control types that will be used **************/ HashSet <int> subTypeSet = new HashSet <int> (); subTypeSet.Add(0); //C subTypeSet.Add(1); //A subTypeSet.Add(2); //T /********* calculate the p(oi) under H, and under each possible priors beforehand*/ //SparseMatrix obj_priorTable_Mat = new SparseMatrix(); Dictionary <int, int> obj_priorDict = new Dictionary <int, int> (); if (histClus.clusterList.Count != 0) { foreach (int objID in curNet.network.tensor.Keys) { SparseVector clusProbVec = new SparseVector(); double log_prob_in_newclus = 0; SparseMatrix typeIDMat = curNet.network.tensor[objID]; //prior clusters foreach (int clusID in histClus.clusterList) { //double clusSize = /*histClus.clusterSizeVec[clusID] + */curClus.clusterSizeVec[clusID]; double clusSize = histClus.clusterSizeVec[clusID]; double log_prob_in_clus = 0; for (int type = 0; type < typeNum; type++) { if (!subTypeSet.Contains(type)) { continue; } SparseVector IDCountVec = typeIDMat.getRow(type); if (IDCountVec == null) { continue; } double typeProb = 1; double curObjTotalCount = IDCountVec.getSum(); double histClus_total_count = histClus.clusTypeCountMat[clusID, type]; //double curClus_total_Count = curClus.clusTypeCountMat[clusID, type]; double curClus_total_Count = 0; int i = 1;// record total current count foreach (KeyValuePair <int, double> kvp in IDCountVec.vector) { int ID = kvp.Key; double count = kvp.Value; //if (!attributeDict[type].ContainsKey(ID)) //{ // Console.WriteLine("Type {0} ID {1}is not in dictionary", type, ID); //} double hist_item_count = histClus.clusAttriMatList[type][clusID, ID]; //double cur_item_count = curClus.clusAttriMatList[type][clusID, ID]; double cur_item_count = 0; for (int itemCount = 1; itemCount <= count; itemCount++) { //background 1: //typeProb *= /*Math.Log*/((attributeDict[type][ID] * betaVec[type] + hist_item_count + cur_item_count + count - itemCount) // / (typeCount[type] * betaVec[type] + histClus_total_count + curClus_total_Count + curObjTotalCount - i)); //logTypeProb -= Math.Log(attributeDict[type].Count * betaVec[type] + histClus_total_count + curClus_total_Count + curObjTotalCount - i); //background 2: typeProb *= /*Math.Log*/ ((1 * betaVec[type] + hist_item_count + cur_item_count + count - itemCount) / (attributeDict[type].Count * betaVec[type] + histClus_total_count + curClus_total_Count + curObjTotalCount - i)); i++; } } log_prob_in_clus += Math.Log(typeProb); } clusProbVec[clusID] = log_prob_in_clus; } //unseen clusters for (int type = 0; type < typeNum; type++) { if (!subTypeSet.Contains(type)) { continue; } SparseVector IDCountVec = typeIDMat.getRow(type); if (IDCountVec == null) { continue; } double typeProb = 1; double curObjTotalCount = IDCountVec.getSum(); int i = 1; foreach (KeyValuePair <int, double> kvp in IDCountVec.vector) { int ID = kvp.Key; double count = kvp.Value; for (int itemCount = 1; itemCount <= count; itemCount++) { //background 1: //typeProb *= /*Math.Log*/((attributeDict[type][ID] * betaVec[type] + count - itemCount) / (typeCount[type] * betaVec[type] + curObjTotalCount - i)); //logTypeProb -= Math.Log(attributeDict[type].Count * betaVec[type] + curObjTotalCount - i); //background 2: typeProb *= /*Math.Log*/ ((1 * betaVec[type] + count - itemCount) / (attributeDict[type].Count * betaVec[type] + curObjTotalCount - i)); i++; } } log_prob_in_newclus += Math.Log(typeProb); } clusProbVec[-1] = log_prob_in_newclus + log_alpha; int curPrior = clusProbVec.getMax_Pos().Key; obj_priorDict.Add(objID, curPrior); } } ////handle middle results of tables //int MAXTableID = 0; //start from 1 //Dictionary<int, Cluster> groupTableDict = new Dictionary<int,Cluster> ();//record tables for each group //Dictionary<int, int> tableClusterDict = new Dictionary<int, int>();// record cluster for each table; //foreach (int priorID in obj_priorDict) //{ // Cluster TableList = new Cluster(); // groupTableDict.Add(priorID, TableList); //} SparseMatrix groupClusSizeMat = new SparseMatrix(); foreach (int priorID in obj_priorDict.Keys) { SparseVector vec = new SparseVector(); groupClusSizeMat.setRow(priorID, vec); } SparseVector betaCoeffVec = new SparseVector(); //first level component coefficient, non-normalized betaCoeffVec[-1] = alpha; //betaCoeffVec[-1] = 1; //alpha logn (every one has alpha) while (epsi > EPSI && iter < 1000) { int handledObjNum = 0; int clusChangedNum = 0; DateTime curTime = DateTime.Now; //randomize the network curNet.network.randomize(objSize); //if (histClus.clusterList.Count != 0) { //foreach (int objID in curNet.network.tensor.Keys) //{ // int priorID = obj_priorDict[objID]; // SparseMatrix typeIDMat = curNet.network.tensor[objID]; // //1. assign tables // int tID = getTableID(typeIDMat, histClus, curClus, groupTableDict[priorGroup].clusterSizeVec, gamma); // //2. assign clusters to tables // if (tID == -1) // a new table // { // int kID = getClusterID_new(typeIDMat,candidateClus, histClus, curClus, curClus.clusterSizeVec, alpha); // // change the clusters for all the objects in the table if needed // //... // } // else // a existing table // { // SparseMatrix tableTypeIDMat = new SparseMatrix(); // int kID = getClusterID(tableTypeIDMat, candidateClus, histClus, curClus, curClus.clusterSizeVec, alpha); // //change the clusters for all the objects in the table if needed // //... // } //} foreach (int objID in curNet.network.tensor.Keys) { //calculate the probability it belongs to each cluster SparseVector clusProbVec = new SparseVector(); int newClusID = Cluster.MAXClusID; SparseMatrix typeIDMat = curNet.network.tensor[objID]; int priorGroup = -1; if (obj_priorDict.ContainsKey(objID)) { priorGroup = obj_priorDict[objID]; } //existing clusters foreach (int clusID in candidateClus) { //double clusSize = /*histClus.clusterSizeVec[clusID] + */curClus.clusterSizeVec[clusID]; //double clusSize = histClus.clusterSizeVec[clusID] + curClus.clusterSizeVec[clusID]; double clusSize = histClus.clusterSizeVec[clusID] + groupClusSizeMat[priorGroup, clusID] + gamma * betaCoeffVec[clusID] / betaCoeffVec.getSum();//groupClusSize could be zero, that's why we need HDP, or priors for the size double log_prob_in_clus = 0; for (int type = 0; type < typeNum; type++) { if (!subTypeSet.Contains(type)) { continue; } SparseVector IDCountVec = typeIDMat.getRow(type); if (IDCountVec == null) { continue; } double typeProb = 1; double curObjTotalCount = IDCountVec.getSum(); double histClus_total_count = histClus.clusTypeCountMat[clusID, type]; double curClus_total_Count = curClus.clusTypeCountMat[clusID, type]; int i = 1;// record total current count foreach (KeyValuePair <int, double> kvp in IDCountVec.vector) { int ID = kvp.Key; double count = kvp.Value; //if (!attributeDict[type].ContainsKey(ID)) //{ // Console.WriteLine("Type {0} ID {1}is not in dictionary", type, ID); //} double hist_item_count = histClus.clusAttriMatList[type][clusID, ID]; double cur_item_count = curClus.clusAttriMatList[type][clusID, ID]; for (int itemCount = 1; itemCount <= count; itemCount++) { if (curClus.objectClusMat[objID, clusID] == 1)//clusID contains objID, needs to remove it { //background 1: //typeProb *= /*Math.Log*/((attributeDict[type][ID] * betaVec[type] + hist_item_count + cur_item_count /*- count + count*/ - itemCount) // / (typeCount[type] * betaVec[type] + histClus_total_count + curClus_total_Count /*- curObjTotalCount + curObjTotalCount*/ - i)); //logTypeProb -= Math.Log(attributeDict[type].Count * betaVec[type] + histClus_total_count + curClus_total_Count - curClus_total_Count + curObjTotalCount - i); //background 2: typeProb *= /*Math.Log*/ ((1 * betaVec[type] + hist_item_count + cur_item_count /*- count + count*/ - itemCount) / (attributeDict[type].Count * betaVec[type] + histClus_total_count + curClus_total_Count /*+ curObjTotalCount - curObjTotalCount*/ - i)); } else { //background 1: //typeProb *= /*Math.Log*/((attributeDict[type][ID] * betaVec[type] + hist_item_count + cur_item_count + count - itemCount) // / (typeCount[type] * betaVec[type] + histClus_total_count + curClus_total_Count + curObjTotalCount - i)); //logTypeProb -= Math.Log(attributeDict[type].Count * betaVec[type] + histClus_total_count + curClus_total_Count + curObjTotalCount - i); //background 2: typeProb *= /*Math.Log*/ ((1 * betaVec[type] + hist_item_count + cur_item_count + count - itemCount) / (attributeDict[type].Count * betaVec[type] + histClus_total_count + curClus_total_Count + curObjTotalCount - i)); } i++; } } log_prob_in_clus += Math.Log(typeProb); } if (iter < INITITER) { clusProbVec[clusID] = log_prob_in_clus; } else { double tempClusSize = clusSize; if (curClus.objectClusMat[objID, clusID] == 1) //clusID { tempClusSize = tempClusSize - 1; } //if (tempClusSize == 0) //{ // clusProbVec[clusID] = log_prob_in_clus + log_alpha; //} //else { clusProbVec[clusID] = log_prob_in_clus + Math.Log(tempClusSize); } } } //new cluster, only calculate if current objID is not the only object in its cluster and with no history int oldClusID = -1; bool needsNewCluster = true; SparseVector assignVec = curClus.objectClusMat.getRow(objID); if (assignVec != null) { if (assignVec.vector.Count != 0) { oldClusID = assignVec.getMax_Pos().Key; } if (oldClusID != -1 && curClus.clusterSizeVec[oldClusID] == 1) { needsNewCluster = false; } if (histClus.clusterList.Contains(oldClusID)) { needsNewCluster = true; } } if (needsNewCluster) { double log_prob_in_newclus = 0; for (int type = 0; type < typeNum; type++) { if (!subTypeSet.Contains(type)) { continue; } SparseVector IDCountVec = typeIDMat.getRow(type); if (IDCountVec == null) { continue; } double typeProb = 1; double curObjTotalCount = IDCountVec.getSum(); int i = 1; foreach (KeyValuePair <int, double> kvp in IDCountVec.vector) { int ID = kvp.Key; double count = kvp.Value; for (int itemCount = 1; itemCount <= count; itemCount++) { //background 2: typeProb *= /*Math.Log*/ ((1 * betaVec[type] + count - itemCount) / (attributeDict[type].Count * betaVec[type] + curObjTotalCount - i)); i++; } } log_prob_in_newclus += Math.Log(typeProb); } if (iter < INITITER) { clusProbVec[newClusID] = log_prob_in_newclus; } else { clusProbVec[newClusID] = log_prob_in_newclus + Math.Log(gamma * (betaCoeffVec[-1] / betaCoeffVec.getSum())); } } //pick the cluster with the largest logprob KeyValuePair <int, double> maxClusLogP = clusProbVec.getMax_Pos(); if (oldClusID != maxClusLogP.Key) { clusChangedNum++; //code for test if (epsi < 0.0001) { Console.WriteLine("\tObj {0} from {1} to {2}", objID, oldClusID, maxClusLogP.Key); } } curClus.assignCluster(objID, typeIDMat, oldClusID, maxClusLogP.Key); handledObjNum++; //update candidateClus if (oldClusID != -1 && !curClus.clusterList.Contains(oldClusID)) { //candidateClus.Remove(oldClusID); // This sentence was originally here. // groupClusSizeMat[priorGroup, oldClusID]--; //betaCoeffVec[oldClusID] = 0; } if (maxClusLogP.Key == newClusID)//assign to a new cluster { candidateClus.Add(newClusID); Console.WriteLine("maxClus = {0}, objects handled = {1}", newClusID, handledObjNum); Cluster.MAXClusID++; } if (maxClusLogP.Key != oldClusID) { // We move the sentence here. groupClusSizeMat[priorGroup, oldClusID]--; groupClusSizeMat[priorGroup, maxClusLogP.Key]++; betaCoeffVec[maxClusLogP.Key] = Math.Log(curClus.clusterSizeVec[maxClusLogP.Key] + 1); } } } TimeSpan timeSpan = DateTime.Now - curTime; epsi = (double)clusChangedNum / objSize; Console.WriteLine("Iteration {0}: cluster number = {1}, epsi = {2}, execution time = {3}", ++iter, curClus.clusterList.Count, epsi, timeSpan); } curClus.clusterPriorMat = groupClusSizeMat.getTranspose(); return(curClus); }
/// <summary> /// Creates a vector from an array. /// </summary> /// <param name="data">The array to create this vector from.</param> /// <returns>The new vector. </returns> protected override Vector <double> CreateVector(double[] data) { return(SparseVector.OfEnumerable(data)); }
public VCInfo(int total_varcount) { total_varcount_ = total_varcount; tempmultstorage = new ThreadLocal <Vector <double> >(() => SparseVector.Create(total_varcount, 0.0)); }
static void Main(string[] args) { // create SparseVector Console.WriteLine("Create SparseVector ..."); SparseVector <string> vec = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(1, "a"), new IdxDat <string>(3, "b"), new IdxDat <string>(4, "c"), new IdxDat <string>(6, "d") }); Console.WriteLine(vec); // add more items Console.WriteLine("Add more items ..."); // ... at the end vec.Add("E"); vec.AddRange(new string[] { "F", "G" }); // ... at specific places vec.AddRange(new IdxDat <string>[] { new IdxDat <string>(2, "AB"), new IdxDat <string>(10, "H") }); vec[11] = "i"; Console.WriteLine(vec); // get items Console.WriteLine("Get items ..."); Console.WriteLine(vec[1]); Console.WriteLine(vec.TryGet(2, "missing")); Console.WriteLine(vec.TryGet(5, "missing")); // set items Console.WriteLine("Set items ..."); vec[2] = "ab"; vec[10] = "h"; Console.WriteLine(vec); // check for items Console.WriteLine("Check for items ..."); Console.WriteLine(vec.ContainsAt(2)); Console.WriteLine(vec.ContainsAt(5)); // get first and last non-empty index Console.WriteLine("Get first and last non-empty index ..."); Console.WriteLine(vec.FirstNonEmptyIndex); Console.WriteLine(vec.LastNonEmptyIndex); // get first and last item Console.WriteLine("Get first and last item ..."); Console.WriteLine(vec.First); Console.WriteLine(vec.Last); // create another SparseVector Console.WriteLine("Create another SparseVector ..."); SparseVector <string> vec2 = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(0, "!"), new IdxDat <string>(2, "@"), new IdxDat <string>(3, "#"), new IdxDat <string>(5, "$") }); Console.WriteLine(vec2); // concatenate Console.WriteLine("Concatenate ..."); vec.Append(vec2, vec.LastNonEmptyIndex + 1); Console.WriteLine(vec); vec2.Append(vec, vec2.LastNonEmptyIndex + 1); Console.WriteLine(vec2); // get number of items Console.WriteLine("Get number of items ..."); Console.WriteLine(vec.Count); // remove item Console.WriteLine("Remove item ..."); vec.RemoveAt(2); Console.WriteLine(vec); // directly access to items Console.WriteLine("Directly access to items ..."); int idx = vec.GetDirectIdx(3); Console.WriteLine(idx); vec.SetDirect(idx, "bbb"); Console.WriteLine(vec); Console.WriteLine(vec.GetIdxDirect(idx)); Console.WriteLine(vec.GetDatDirect(idx)); Console.WriteLine(vec.GetDirect(idx)); vec.RemoveDirect(idx); Console.WriteLine(vec); // perform unary operation Console.WriteLine("Perform unary operation ..."); vec.PerformUnaryOperation(delegate(string item) { return(item.ToUpper()); }); Console.WriteLine(vec); // merge Console.WriteLine("Merge ..."); vec.Merge(vec2, delegate(string a, string b) { return(string.Format("{0}+{1}", a, b)); }); Console.WriteLine(vec); // purge Console.WriteLine("Purge items ..."); vec.PurgeAt(1); Console.WriteLine(vec); vec.PurgeAt(1); Console.WriteLine(vec); Console.WriteLine(); // *** SparseMatrix *** Console.WriteLine("*** SparseMatrix ***"); Console.WriteLine(); // create SparseMatrix Console.WriteLine("Create SparseMatrix ..."); SparseMatrix <string> matrix = new SparseMatrix <string>(); matrix[0] = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(1, "a"), new IdxDat <string>(3, "b"), new IdxDat <string>(4, "c") }); matrix[2] = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(2, "d"), new IdxDat <string>(4, "e"), new IdxDat <string>(5, "f") }); matrix[3] = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(0, "g"), new IdxDat <string>(3, "h"), new IdxDat <string>(5, "i") }); matrix[4] = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(1, "j"), new IdxDat <string>(2, "k"), new IdxDat <string>(4, "l") }); Console.WriteLine(matrix.ToString("E")); // get rows Console.WriteLine("Get rows ..."); Console.WriteLine(matrix[0]); Console.WriteLine(matrix[3]); // set rows Console.WriteLine("Set rows ..."); matrix[1] = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(0, "j"), new IdxDat <string>(3, "k") }); matrix[2] = null; matrix[4] = null; Console.WriteLine(matrix.ToString("E")); // count rows Console.WriteLine("Count rows ..."); Console.WriteLine("{0} != {1}", matrix.GetRowCount(), matrix.GetLastNonEmptyRowIdx() + 1); // trim rows Console.WriteLine("Trim rows ..."); matrix.TrimRows(); Console.WriteLine(matrix.ToString("E")); // add more items Console.WriteLine("Add more items ..."); matrix[0].Add("*"); matrix[3].AddRange(new IdxDat <string>[] { new IdxDat <string>(1, "!"), new IdxDat <string>(2, "?"), new IdxDat <string>(4, "&") }); matrix[2] = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(2, "d"), new IdxDat <string>(4, "e"), new IdxDat <string>(5, "f") }); Console.WriteLine(matrix.ToString("E")); // get items Console.WriteLine("Get items ..."); Console.WriteLine(matrix[0, 1]); Console.WriteLine(matrix[2, 2]); Console.WriteLine(matrix[2][4]); Console.WriteLine(matrix.TryGet(2, 4, "missing")); Console.WriteLine(matrix.TryGet(2, 6, "missing")); // set items Console.WriteLine("Set items ..."); matrix[0, 1] = "l"; matrix[2, 3] = "m"; matrix[3][4] = "n"; Console.WriteLine(matrix.ToString("E")); // check for items Console.WriteLine("Check for items ..."); Console.WriteLine(matrix.ContainsAt(0, 1)); Console.WriteLine(matrix.ContainsAt(1, 1)); Console.WriteLine(matrix.Contains("c")); Console.WriteLine(matrix.Contains("C")); int rowIdx = -1, colIdx = -1; matrix.IndexOf("c", ref rowIdx, ref colIdx); Console.WriteLine("{0}, {1}", rowIdx, colIdx); // check for rows and columns Console.WriteLine("Check for rows and columns ..."); Console.WriteLine(matrix.ContainsColAt(0)); Console.WriteLine(matrix.ContainsColAt(100)); Console.WriteLine(matrix.ContainsRowAt(0)); Console.WriteLine(matrix.ContainsRowAt(100)); // get first and last non-empty row and column index Console.WriteLine("Get first and last non-empty row and column index ..."); Console.WriteLine(matrix.GetFirstNonEmptyRowIdx()); Console.WriteLine(matrix.GetLastNonEmptyRowIdx()); Console.WriteLine(matrix.GetFirstNonEmptyColIdx()); Console.WriteLine(matrix.GetLastNonEmptyColIdx()); // get first and last item in row Console.WriteLine("Get first and last item in row ..."); Console.WriteLine(matrix[0].First); Console.WriteLine(matrix[3].Last); // create another SparseMatrix Console.WriteLine("Create another SparseMatrix ..."); SparseMatrix <string> matrix2 = new SparseMatrix <string>(); matrix2[0] = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(0, "A"), new IdxDat <string>(2, "B"), new IdxDat <string>(3, "C") }); matrix2[2] = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(1, "D"), new IdxDat <string>(3, "E") }); matrix2[3] = new SparseVector <string>(new IdxDat <string>[] { new IdxDat <string>(0, "G"), new IdxDat <string>(1, "H"), new IdxDat <string>(2, "I") }); Console.WriteLine(matrix2.ToString("E")); // concatenate Console.WriteLine("Concatenate ..."); matrix.AppendCols(matrix2, matrix.GetLastNonEmptyColIdx() + 1); Console.WriteLine(matrix.ToString("E")); // remove items Console.WriteLine("Remove items ..."); matrix.RemoveAt(0, 1); matrix.RemoveAt(3, 5); Console.WriteLine(matrix.ToString("E")); // directly access to items Console.WriteLine("Directly access to items ..."); idx = matrix[0].GetDirectIdx(4); Console.WriteLine(idx); Console.WriteLine(matrix[0].GetDirect(idx)); matrix[0].SetDirect(idx, "C"); Console.WriteLine(matrix[1].GetDirect(0)); matrix[1].RemoveDirect(0); Console.WriteLine(matrix.ToString("E")); // get properties Console.WriteLine("Get properties ..."); Console.WriteLine("{0:0.00}%", matrix.GetSparseness(matrix.GetLastNonEmptyRowIdx() + 1, matrix.GetLastNonEmptyColIdx() + 1) * 100.0); Console.WriteLine(matrix.IsSymmetric()); Console.WriteLine(matrix.ContainsDiagonalElement()); Console.WriteLine(matrix.CountValues()); // perform unary operation Console.WriteLine("Perform unary operation ..."); matrix.PerformUnaryOperation(delegate(string item) { return(item.ToUpper()); }); Console.WriteLine(matrix.ToString("E")); // merge Console.WriteLine("Merge ..."); matrix.Merge(matrix2, delegate(string a, string b) { return(string.Format("{0}+{1}", a, b)); }); Console.WriteLine(matrix.ToString("E")); // clear row and column Console.WriteLine("Clear row and column ..."); matrix.RemoveRowAt(2); matrix.RemoveColAt(1); Console.WriteLine(matrix.ToString("E")); // purge row and column Console.WriteLine("Purge row and column ..."); matrix.PurgeRowAt(2); matrix.PurgeColAt(1); Console.WriteLine(matrix.ToString("E")); // get column copy Console.WriteLine("Get column copy ..."); Console.WriteLine(matrix.GetColCopy(0)); // transpose Console.WriteLine("Transpose ..."); Console.WriteLine(matrix.GetTransposedCopy().ToString("E")); // set diagonal Console.WriteLine("Set diagonal ..."); matrix.SetDiagonal(matrix.GetLastNonEmptyColIdx() + 1, "X"); Console.WriteLine(matrix.ToString("E")); // make symmetric Console.WriteLine("Make symmetric ..."); matrix.Symmetrize(delegate(string a, string b) { return(string.Format("{0}+{1}", a, b)); }); Console.WriteLine(matrix.ToString("E")); }
private LPSTerm() { coefficients_ = SparseVector.Create(vcinfo_.total_varcount_, 0.0); intercept_ = 0.0; }
public void CanPointwiseMultiplySparseVector() { var zeroArray = new[] { 0.0, 1.0, 0.0, 1.0, 0.0 }; var vector1 = new SparseVector(Data); var vector2 = new SparseVector(zeroArray); var result = new SparseVector(vector1.Count); vector1.PointwiseMultiply(vector2, result); for (var i = 0; i < vector1.Count; i++) { Assert.AreEqual(Data[i] * zeroArray[i], result[i]); } Assert.AreEqual(2, result.NonZerosCount); }
public void Sparsify() { coefficients_ = SparseVector.OfVector(coefficients_); }
public double SVMOutput(SparseVector x) { return(Calculate_F(x)); }
public Vector <double> CreateVector(int capacity) { return(SparseVector.Create(capacity, 0.0)); }
public double Compute(SparseVector x, SparseVector z) { return(SparseVector.DotProduct(x, z)); }
private double[][] GetKernel(int rmvFeatIdx) { int numSv = SvmLightLib.GetSupportVectorCount(mModelId); // initialize matrix double[][] kernel = new double[numSv][]; // compute linear kernel SparseMatrix <double> m = new SparseMatrix <double>(); for (int i = 0; i < numSv; i++) { SparseVector <double> sv = GetSupportVector(i); m[i] = sv; } if (rmvFeatIdx >= 0) { m.RemoveColAt(rmvFeatIdx); } SparseMatrix <double> mTr = m.GetTransposedCopy(); for (int i = 0; i < numSv; i++) { double[] innerProd = ModelUtils.GetDotProductSimilarity(mTr, numSv, m[i]); kernel[i] = innerProd; } // compute non-linear kernel switch (mKernelType) { case SvmLightKernelType.Polynomial: for (int row = 0; row < kernel.Length; row++) { for (int col = 0; col < kernel.Length; col++) { kernel[row][col] = Math.Pow(mKernelParamS * kernel[row][col] + mKernelParamC, mKernelParamD); } } break; case SvmLightKernelType.RadialBasisFunction: double[] diag = new double[kernel.Length]; for (int i = 0; i < kernel.Length; i++) { diag[i] = kernel[i][i]; } // save diagonal for (int row = 0; row < kernel.Length; row++) { for (int col = 0; col < kernel.Length; col++) { kernel[row][col] = Math.Exp(-mKernelParamGamma * (diag[row] + diag[col] - 2.0 * kernel[row][col])); } } break; case SvmLightKernelType.Sigmoid: for (int row = 0; row < kernel.Length; row++) { for (int col = 0; col < kernel.Length; col++) { kernel[row][col] = Math.Tanh(mKernelParamS * kernel[row][col] + mKernelParamC); } } break; } return(kernel); }
public double[] Simulate(double t, double[] values) { SimulationState st = new SimulationState { VX = values[3], VY = values[4], VZ = values[5], Phi = values[6], Theta = values[7], PhiDot = values[8], ThetaDot = values[9], GammaDot = values[10], Gamma = values[11], }; //double CLo, CLa, CDo, CDa, CMo, CMa; //double CL_data, CD_data, CM_data; double[] CRr_rad = new[] { -0.0873, -0.0698, -0.0524, -0.0349, -0.0175, 0.0000, 0.0175, 0.0349, 0.0524, 0.0698, 0.0873, 0.1047, 0.1222, 0.1396, 0.1571, 0.1745, 0.1920, 0.2094, 0.2269, 0.2443, 0.2618, 0.5236 }; double[] CRr_AdvR = new[] { 2, 1.04, 0.69, 0.35, 0.17, 0 }; double[,] CRr_data = new [, ] { { -0.0172, -0.0192, -0.018, -0.0192, -0.018, -0.0172, -0.0172, -0.0168, -0.0188, -0.0164, -0.0136, -0.01, -0.0104, -0.0108, -0.0084, -0.008, -0.008, -0.006, -0.0048, -0.0064, -0.008, -0.003 }, { -0.0112, -0.0132, -0.012, -0.0132, -0.012, -0.0112, -0.0112, -0.0108, -0.0128, -0.0104, -0.0096, -0.0068, -0.0072, -0.0076, -0.0052, -0.0048, -0.0048, -0.0028, -0.0032, -0.0048, -0.0064, -0.003 }, { -0.0056, -0.0064, -0.0064, -0.0068, -0.0064, -0.0064, -0.0052, -0.0064, -0.0028, -0.0028, -0.004, -0.002, -0.004, -0.002, -0.0016, 0, 0, 0, 0, -0.002, -0.0048, -0.003 }, { -0.0012, -0.0016, -0.0004, -0.0028, -0.0016, -0.0016, -0.0004, 0.0004, 0.0004, 0.0008, 0.0004, 0.0008, 0.0012, 0.0008, 0.002, 0.0028, 0.0032, 0.0024, 0.0028, 0.0004, -0.0012, -0.003 }, { -0.0012, -0.0012, -0.0016, -0.0016, -0.0012, -0.0004, 0.0004, 0.0008, 0.0008, 0.0016, 0.0004, 0.002, 0.0004, 0.0016, 0.002, 0.002, 0.002, 0.0012, 0.0012, 0, -0.0012, -0.003 }, { -0.0012, -0.0012, -0.0004, -0.0008, -0.0008, -0.0008, 0.0004, 0.0004, 0.0004, 0.0008, 0.0004, 0.0008, -0.0004, 0, 0, 0.0004, 0, 0, 0.0004, -0.002, -0.0012, -0.003 } }; const double CMq = -0.005; const double CRp = -0.0055; const double CNr = 0.0000071; double diameter = 2 * Math.Sqrt(Area / Math.PI); // Rotation matrix: http://s-mat-pcs.oulu.fi/~mpa/matreng/eem1_3-7.htm // y // ------------------> x ^ // |\ | // | \ | // | \ | // | \ theta = pitch | gamma = yaw // | | // v --------------------> x // z // z // ^ // | // | // | // | phi = roll // | // ------------------> y // // 3D homogenous transformation matrix // // g = gamma = yaw // t = theta = pitch // p = phi = roll // // http://en.wikipedia.org/wiki/Rotation_matrix // http://www.gregslabaugh.name/publications/euler.pdf // -- -- // | cos(g)*cos(t), cos(g)*sin(t)*sin(p)-sin(g)*cos(p), cos(g)*sin(t)*cos(p)+sin(g)*sin(p) | // | | // T = | sin(g)*cos(t), sin(g)*sin(t)*sin(p)-cos(g)*cos(p), sin(g)*sin(t)*cos(p)+cos(g)*sin(p) | // | | // | -sin(t) , cos(t)*sin(p) , cos(t)*cos(p) | // -- -- // // With g = yaw = 0 and sin(t) = -sin(t) since z is positive downward // // -- -- // | cos(t) , sin(t)*sin(p) , sin(t)*cos(p) | // | | // T = | 0 , cos(p) , sin(p) | // | | // | -sin(t) , cos(t)*sin(p) , cos(t)*cos(p) | // -- -- Matrix <double> transformation = new SparseMatrix(new [, ] { { st.CosTheta, st.SinTheta * st.SinPhi, -st.SinTheta * st.CosPhi }, { 0, st.CosPhi, st.SinPhi }, { st.SinTheta, -st.CosTheta * st.SinPhi, st.CosTheta * st.CosPhi } }); // Eigenvector & eigenvalue // -- // | x1 // X = | x2 // | x3 // -- // // -- // | a11, a12, a13 // A = | a21, a22, a23 // | a31, a32, a33 // -- // // // Usually, the multiplication of a vector x by a square matrix A changes both the magnitude and the direction // of the vector upon which it acts; but in the special case where it changes only the scale (magnitude) of the // vector and leaves the direction unchanged, or switches the vector to the opposite direction, then that vector // is called an eigenvector of that matrix (the term "eigenvector" is meaningless except in relation to some // particular matrix). When multiplied by a matrix, each eigenvector of that matrix changes its magnitude by a // factor, called the eigenvalue corresponding to that eigenvector. // // // See local frame vs global frame: // Evd evd = new UserEvd(transformation); //Matrix<double> eigenVectors = evd.EigenVectors(); Vector <Complex> temp = evd.EigenValues(); Vector <double> eigenValues = new SparseVector(3); eigenValues[0] = temp[0].Real; eigenValues[1] = temp[1].Real; eigenValues[1] = temp[1].Real; //eigenValues.Norm // // If you have Theta and Phi = 0 you have a transformation matrix like this: // // | 1, 0, 0 | // | 0, 1, 0 | // | 0, 0, 1 | // // So each row represents the rotated X, Y or Z axis expressed as N-Frame coordinates. In this case, // there is no rotation so you have the axis (1,0,0), (0,1,0), (0,0,1). // For example, the first row represents the X Axis after the rotation. Since the rotation is 0, // the X axis is a vector (1,0,0) in the N-Frame. // // // // //SparseVector c1 = new SparseVector(transformation.Row(0)); //SparseVector c2 = new SparseVector(transformation.Row(1)); SparseVector c3 = new SparseVector(transformation.Row(2)); SparseVector velocity = new SparseVector(new [] { st.VX, st.VY, st.VZ }); double velocityMagnitude = velocity.Norm(2); double velocityC3 = velocity.DotProduct(c3); Vector <double> vp = velocity.Subtract(c3.Multiply(velocityC3)); double vpMagnitude = vp.Norm(2); double alpha = Math.Atan(velocityC3 / vp.Norm(2)); double adp = Area * Rho * velocityMagnitude * velocityMagnitude / 2; Vector <double> unitVelocity = velocity.Divide(velocityMagnitude); Vector <double> unitVp = vp.Divide(vpMagnitude); //c3. Vector <double> unitLat = ConvertVector(Vector3D.CrossProduct(ConvertVector(c3), ConvertVector(unitVp))); Matrix <double> omegaD_N_inC = new SparseMatrix(new [, ] { { st.PhiDot *st.CosTheta, st.ThetaDot, st.PhiDot *st.SinTheta + st.GammaDot } }); // expressed in c1,c2,c3 Vector <double> omegaD_N_inN = transformation.Transpose().Multiply(omegaD_N_inC.Transpose()).Column(0); // expressed in c1,c2,c3 double omegaVp = omegaD_N_inN.DotProduct(unitVp); double omegaLat = omegaD_N_inN.DotProduct(unitLat); double omegaSpin = omegaD_N_inN.DotProduct(c3); double aDvR = diameter * omegaSpin / 2 / vpMagnitude; LinearSplineInterpolation interpolation = new LinearSplineInterpolation(m_xCL, m_yCL); double CL = interpolation.Interpolate(alpha); interpolation = new LinearSplineInterpolation(m_xCD, m_yCD); double CD = interpolation.Interpolate(alpha); interpolation = new LinearSplineInterpolation(m_xCM, m_yCM); double CM = interpolation.Interpolate(alpha); alglib.spline2d.spline2dinterpolant interpolant = new alglib.spline2d.spline2dinterpolant(); alglib.spline2d.spline2dbuildbilinear(CRr_rad, CRr_AdvR, CRr_data, 6, 22, interpolant); double CRr = alglib.spline2d.spline2dcalc(interpolant, alpha, aDvR); Vector <double> mvp = unitVp.Multiply(adp * diameter * (CRr * diameter * omegaSpin / 2 / velocityMagnitude + CRp * omegaVp)); // Roll moment, expressed in N double lift = CL * adp; double drag = CD * adp; Vector <double> unitLift = -ConvertVector(Vector3D.CrossProduct(ConvertVector(unitVelocity), ConvertVector(unitLat))); Vector <double> unitDrag = -unitVelocity; Vector <double> forceAerodynamic = unitLift.Multiply(lift).Add(unitDrag.Multiply(drag)); Vector <double> gravityForceN = new SparseVector(new[] { 0, 0, m * g }); Vector <double> force = forceAerodynamic.Add(gravityForceN); Vector <double> mLat = unitLat.Multiply(adp * diameter * (CM + CMq * omegaLat)); Vector <double> mSpin = new SparseVector(new [] { 0, 0, CNr * omegaSpin }); // TODO: Check if missing element Vector <double> mvpInC = transformation.Multiply(mvp); Vector <double> mLatInC = transformation.Multiply(mLat); Vector <double> moment = mvpInC.Add(mLatInC).Add(mSpin); Vector <double> acceleration = force.Divide(m); double[] result = new double[12]; result[0] = velocity[0]; result[1] = velocity[1]; result[2] = velocity[2]; result[3] = acceleration[0]; result[4] = acceleration[1]; result[5] = acceleration[2]; result[6] = -st.PhiDot; result[7] = st.ThetaDot; result[8] = (moment[0] + Id * st.ThetaDot * st.PhiDot * st.SinTheta - Ia * st.ThetaDot * (st.PhiDot * st.SinTheta + st.GammaDot) + Id * st.ThetaDot * st.PhiDot * st.SinTheta) / Id / st.CosTheta; result[9] = (moment[1] + Ia * st.PhiDot * st.CosTheta * (st.PhiDot * st.SinTheta + st.GammaDot) - Id * st.PhiDot * st.PhiDot * st.CosTheta * st.SinTheta) / Id; result[10] = (moment[2] - Ia * (result[9] * st.SinTheta + st.ThetaDot * st.PhiDot * st.CosTheta)) / Ia; result[11] = result[10]; return(result); }