working on it ...

Filters

Explore Public Snippets

Sort by

Found 25k snippets matching: where

    public by Geometry  1480  0  4  0

    Checks whether a number is in the range where we expect the robust arithmetic to work

    // Checks whether a number is in the range where we expect the robust arithmetic to work // - exponents between -142 and 201. (According to S. p.3)
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    // Checks whether a number is in the range where we expect the robust arithmetic to work
    // - exponents between -142 and 201. (According to S. p.3)
    public static bool IsInRange(this double d)
    {
        double dabs = Math.Abs(d);
        return dabs >= 1e-142 && dabs < 1e202;
    }

    public by Geometry  1337  0  6  0

    OneHot: Creates a matrix of one-hot vectors, where all values at each row are zero except for the indicated <paramref name="indices"/>, which is set to one.

    Creates a matrix of one-hot vectors, where all values at each row are zero except for the indicated , which is set to one. The rows's dimension which will be marked as one. The matrix where the one-hot should be marked. A matrix containing one-hot vectors where only a single position is one and the others are zero.
    /// <summary>
            ///   Creates a matrix of one-hot vectors, where all values at each row are 
            ///   zero except for the indicated <paramref name="indices"/>, which is set to one.
            /// </summary>
            /// 
            /// <param name="indices">The rows's dimension which will be marked as one.</param>
            /// <param name="result">The matrix where the one-hot should be marked.</param>
            /// 
            /// <returns>A matrix containing one-hot vectors where only a single position
            /// is one and the others are zero.</returns>
            /// 
    #if NET45
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
    #endif
            public static double[,] OneHot(int[] indices, double[,] result)
            {
                for (int i = 0; i < indices.Length; i++)
                    result[i, indices[i]] = 1;
                return result;
            }

    public by cghersi  2181  2  6  1

    Where you can find the logs and temporary stuff from IntelliJ on Windows7

    This is the location where the plugins can safely write some stuff
    C:\Users\<your user>\AppData\Local\Temp\<pluginName>

    public by Geometry  963  0  5  0

    KHot: Creates a matrix of k-hot vectors, where all values at each row are zero except for the ones in the positions where <paramref name="mask"/> are true, which are set to one.

    Creates a matrix of k-hot vectors, where all values at each row are zero except for the ones in the positions where are true, which are set to one. The data type for the matrix. The boolean mask determining where ones will be placed. A matrix containing one-hot vectors where only a single position is one and the others are
    /// <summary>
            ///   Creates a matrix of k-hot vectors, where all values at each row are 
            ///   zero except for the ones in the positions where <paramref name="mask"/>
            ///   are true, which are set to one.
            /// </summary>
            /// 
            /// <typeparam name="T">The data type for the matrix.</typeparam>
            /// 
            /// <param name="mask">The boolean mask determining where ones will be placed.</param>
            /// 
            /// <returns>A matrix containing one-hot vectors where only a single position
            ///   is one and the others are zero.</returns>
            /// 
    #if NET45
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
    #endif
            public static T[][] KHot<T>(bool[][] mask)
            {
                return KHot<T>(mask, Jagged.CreateAs<bool, T>(mask));
            }

    public by Geometry  943  0  5  0

    OneHot: Creates a matrix of one-hot vectors, where all values at each row are zero except for the indicated <paramref name="indices"/>, which is set to one.

    Creates a matrix of one-hot vectors, where all values at each row are zero except for the indicated , which is set to one. The data type for the matrix. The rows's dimension which will be marked as one. A matrix containing one-hot vectors where only a single position is one and the others are zero.
    /// <summary>
            ///   Creates a matrix of one-hot vectors, where all values at each row are 
            ///   zero except for the indicated <paramref name="indices"/>, which is set to one.
            /// </summary>
            /// 
            /// <typeparam name="T">The data type for the matrix.</typeparam>
            /// 
            /// <param name="indices">The rows's dimension which will be marked as one.</param>
            /// 
            /// <returns>A matrix containing one-hot vectors where only a single position
            /// is one and the others are zero.</returns>
            /// 
    #if NET45
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
    #endif
            public static T[][] OneHot<T>(int[] indices)
            {
                return OneHot<T>(indices, indices.DistinctCount());
            }

    public by Geometry  897  0  5  0

    KHot: Creates a matrix of k-hot vectors, where all values at each row are zero except for the indicated <paramref name="indices"/>, which are set to one.

    Creates a matrix of k-hot vectors, where all values at each row are zero except for the indicated , which are set to one. The data type for the matrix. The rows's dimension which will be marked as one. The size (length) of the vectors (columns of the matrix). A matrix containing k-hot vectors where only elements at the indicated
    /// <summary>
            ///   Creates a matrix of k-hot vectors, where all values at each row are 
            ///   zero except for the indicated <paramref name="indices"/>, which are set to one.
            /// </summary>
            /// 
            /// <typeparam name="T">The data type for the matrix.</typeparam>
            /// 
            /// <param name="indices">The rows's dimension which will be marked as one.</param>
            /// <param name="columns">The size (length) of the vectors (columns of the matrix).</param>
            /// 
            /// <returns>A matrix containing k-hot vectors where only elements at the indicated 
            ///   <paramref name="indices"/> are set to one and the others are zero.</returns>
            /// 
    #if NET45
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
    #endif
            public static T[][] KHot<T>(int[][] indices, int columns)
            {
                return KHot<T>(indices, Jagged.Create<T>(indices.Length, columns));
            }

    public by Geometry  859  0  5  0

    Centering: Creates a centering matrix of size <c>N x N</c> in the form <c>(I - 1N)</c> where <c>1N</c> is a matrix with all elements equal to <c>1 / N</c>.

    Creates a centering matrix of size N x N in the form (I - 1N) where 1N is a matrix with all elements equal to 1 / N.
    /// <summary>
    ///   Creates a centering matrix of size <c>N x N</c> in the
    ///   form <c>(I - 1N)</c> where <c>1N</c> is a matrix with 
    ///   all elements equal to <c>1 / N</c>.
    /// </summary>
    /// 
    public static double[,] Centering(int size)
    {
        if (size < 0)
        {
            throw new ArgumentOutOfRangeException("size", size,
                "The size of the centering matrix must be a positive integer.");
        }
    
        double[,] C = Matrix.Square(size, -1.0 / size);
    
        for (int i = 0; i < size; i++)
            C[i, i] = 1.0 - 1.0 / size;
    
        return C;
    }

    public by Geometry  733  0  5  0

    OneHot: Creates a matrix of one-hot vectors, where all values at each row are zero except for the ones in the positions where <paramref name="mask"/> are true, which are set to one.

    Creates a matrix of one-hot vectors, where all values at each row are zero except for the ones in the positions where are true, which are set to one. The data type for the matrix. The boolean mask determining where ones will be placed. A matrix containing one-hot vectors where only a single position is one and the others ar
    /// <summary>
            ///   Creates a matrix of one-hot vectors, where all values at each row are 
            ///   zero except for the ones in the positions where <paramref name="mask"/>
            ///   are true, which are set to one.
            /// </summary>
            /// 
            /// <typeparam name="T">The data type for the matrix.</typeparam>
            /// 
            /// <param name="mask">The boolean mask determining where ones will be placed.</param>
            /// 
            /// <returns>A matrix containing one-hot vectors where only a single position
            ///   is one and the others are zero.</returns>
            /// 
    #if NET45
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
    #endif
            public static T[][] OneHot<T>(bool[] mask)
            {
                return OneHot<T>(mask, Jagged.Create<T>(mask.Length, 2));
            }

    public by Geometry  640  0  5  0

    KHot: Creates a matrix of k-hot vectors, where all values at each row are zero except for the indicated <paramref name="indices"/>, which are set to one.

    Creates a matrix of k-hot vectors, where all values at each row are zero except for the indicated , which are set to one. The rows's dimension which will be marked as one. The matrix where the one-hot should be marked. A matrix containing k-hot vectors where only elements at the indicated are set to one and the others are zero.
    /// <summary>
            ///   Creates a matrix of k-hot vectors, where all values at each row are 
            ///   zero except for the indicated <paramref name="indices"/>, which are set to one.
            /// </summary>
            /// 
            /// <param name="indices">The rows's dimension which will be marked as one.</param>
            /// <param name="result">The matrix where the one-hot should be marked.</param>
            /// 
            /// <returns>A matrix containing k-hot vectors where only elements at the indicated 
            ///   <paramref name="indices"/> are set to one and the others are zero.</returns>
            /// 
    #if NET45
            [MethodImpl(MethodImplOptions.AggressiveInlining)]
    #endif
            public static double[,] KHot(int[][] indices, double[,] result)
            {
                for (int i = 0; i < indices.Length; i++)
                    for (int j = 0; j < indices[i].Length; j++)
                        result[i, indices[i][j]] = 1;
                return result;
            }

    public by marksimon232  2477  0  7  2

    Swift Collections: Classes vs. Structs - where to use which?

    A small distinction in behavior drives the architectural possibilities at play here: structs are value types and classes are reference types.
    Why you should consider using Structs instead of Classes when writing Swift?
    
    Instances of value types are copied whenever they’re assigned or used as a 
    function argument. Numbers, strings, arrays, dictionaries, enums, tuples, and 
    structs are value types. For example:
    
    var a = "Hello"
    var b = a
    b.extend(", world")
    println("a: \(a); b: \(b)") // a: Hello; b: Hello, world
    
    Instances of reference types (chiefly: classes, functions) can have multiple 
    owners. When assigning a reference to a new variable or passing it to a 
    function, those locations all point to the same instance. This is the behavior
    you’re used to with objects. For instance:
    
    var a = UIView()
    var b = a
    b.alpha = 0.5
    println("a: \(a.alpha); b: \(b.alpha)") // a: 0.5; b: 0.5
    
    The distinction between these two categories seems small, but the choice 
    between values and references can have huge ramifications for your system’s
    architecture.
    
    
    • Public Snippets
    • Channels Snippets