iOS Charting Documentation - SciChart iOS Charts SDK v3.x

ISCIListUtilProvider

@protocol ISCIListUtilProvider

Defines interface with SciListUtil methods.

  • Finds the maximum value of the array in specified bounds.

    Declaration

    Objective-C

    - (char)maxChar:(const char *)array
         startIndex:(NSInteger)startIndex
           endIndex:(NSInteger)endIndex;

    Swift

    func maxChar(_ array: UnsafePointer<Int8>!, start startIndex: Int, end endIndex: Int) -> Int8

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The maximum value of array.

  • Finds the minimum value of the array in specified bounds.

    Declaration

    Objective-C

    - (char)minChar:(const char *)array
         startIndex:(NSInteger)startIndex
           endIndex:(NSInteger)endIndex;

    Swift

    func minChar(_ array: UnsafePointer<Int8>!, start startIndex: Int, end endIndex: Int) -> Int8

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The minimum value of array.

  • Finds the minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxChar:(const char *)array
            startIndex:(NSInteger)startIndex
              endIndex:(NSInteger)endIndex
                 range:(id<ISCIRange>)range;

    Swift

    func minMaxChar(_ array: UnsafePointer<Int8>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Finds the positive minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxCharPositive:(const char *)array
                    startIndex:(NSInteger)startIndex
                      endIndex:(NSInteger)endIndex
                         range:(id<ISCIRange>)range;

    Swift

    func minMaxCharPositive(_ array: UnsafePointer<Int8>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Copies elements of the srcArray at specified indices to the dstArray.

    Declaration

    Objective-C

    - (void)getCharValues:(const char *)srcArray
            srcArrayCount:(NSInteger)srcArrayCount
                baseIndex:(NSInteger)baseIndex
                 dstArray:(double *)dstArray
                  indices:(const int *)indices
                    count:(NSInteger)count;

    Swift

    func getCharValues(_ srcArray: UnsafePointer<Int8>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, indices: UnsafePointer<Int32>!, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Copies batch elements of the srcArray to the dstArray.

    Declaration

    Objective-C

    - (void)getCharValues:(const char *)srcArray
            srcArrayCount:(NSInteger)srcArrayCount
                baseIndex:(NSInteger)baseIndex
                 dstArray:(double *)dstArray
               startIndex:(NSInteger)startIndex
                    count:(NSInteger)count;

    Swift

    func getCharValues(_ srcArray: UnsafePointer<Int8>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, start startIndex: Int, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Finds the index of the item in the array according to desired SCISearchMode.

    Declaration

    Objective-C

    - (NSInteger)findIndexInCharArray:(const char *)array
                           startIndex:(NSInteger)startIndex
                                count:(NSInteger)count
                             isSorted:(BOOL)isSorted
                                value:(char)value
                           searchMode:(SCISearchMode)searchMode;

    Swift

    func findIndex(inCharArray array: UnsafePointer<Int8>!, start startIndex: Int, count: Int, isSorted: Bool, value: Int8, searchMode: SCISearchMode) -> Int

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    count

    The amount of items to search in.

    isSorted

    If true will use fast binary search.

    value

    The value to search.

    searchMode

    The search mode options.

    Return Value

    The index of value, or -1 if not found.

  • Checks whether the array is sorted ascending in specified range.

    Declaration

    Objective-C

    - (BOOL)isCharArraySortedAscending:(const char *)array
                            startIndex:(NSInteger)startIndex
                                 count:(NSInteger)count;

    Swift

    func isCharArraySortedAscending(_ array: UnsafePointer<Int8>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to check.

    startIndex

    The start index of sequences to check.

    count

    The amount of point in sequence to check.

    Return Value

    True if items in sequence is sorted in ascending order.

  • Checks whether data in the array region is evenly spaced and calculated space between data if it true.

    Declaration

    Objective-C

    - (double)calculateIsCharArrayEvenlySpaced:(const char *)array
                                    startIndex:(NSInteger)startIndex
                                         count:(NSInteger)count
                                       epsilon:(double)epsilon;

    Swift

    func calculateIsCharArrayEvenlySpaced(_ array: UnsafePointer<Int8>!, start startIndex: Int, count: Int, epsilon: Double) -> Double

    Parameters

    array

    The array to process.

    startIndex

    The start index index of sequence to process.

    count

    The size of data sequence to processs.

    epsilon

    The epsilon value.

    Return Value

    If data is evenly spaced returns positive value with calculated space, otherwise returns negative value.

  • Checks wheter data in array region contains NaN values

    Declaration

    Objective-C

    - (BOOL)containsNaNCharArray:(const char *)array
                      startIndex:(NSInteger)startIndex
                           count:(NSInteger)count;

    Swift

    func containsNaNCharArray(_ array: UnsafePointer<Int8>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to use

    startIndex

    The start index of sequence to process

    count

    The size of data sequence to process

    Return Value

    If data sequence contains NaN value returns true, otherwise returns false

  • Finds the maximum value of the array in specified bounds.

    Declaration

    Objective-C

    - (short)maxShort:(const short *)array
           startIndex:(NSInteger)startIndex
             endIndex:(NSInteger)endIndex;

    Swift

    func maxShort(_ array: UnsafePointer<Int16>!, start startIndex: Int, end endIndex: Int) -> Int16

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The maximum value of array.

  • Finds the minimum value of the array in specified bounds.

    Declaration

    Objective-C

    - (short)minShort:(const short *)array
           startIndex:(NSInteger)startIndex
             endIndex:(NSInteger)endIndex;

    Swift

    func minShort(_ array: UnsafePointer<Int16>!, start startIndex: Int, end endIndex: Int) -> Int16

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The minimum value of array.

  • Finds the minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxShort:(const short *)array
             startIndex:(NSInteger)startIndex
               endIndex:(NSInteger)endIndex
                  range:(id<ISCIRange>)range;

    Swift

    func minMaxShort(_ array: UnsafePointer<Int16>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Finds the positive minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxShortPositive:(const short *)array
                     startIndex:(NSInteger)startIndex
                       endIndex:(NSInteger)endIndex
                          range:(id<ISCIRange>)range;

    Swift

    func minMaxShortPositive(_ array: UnsafePointer<Int16>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Copies elements of the srcArray at specified indices to the dstArray.

    Declaration

    Objective-C

    - (void)getShortValues:(const short *)srcArray
             srcArrayCount:(NSInteger)srcArrayCount
                 baseIndex:(NSInteger)baseIndex
                  dstArray:(double *)dstArray
                   indices:(const int *)indices
                     count:(NSInteger)count;

    Swift

    func getShortValues(_ srcArray: UnsafePointer<Int16>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, indices: UnsafePointer<Int32>!, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Copies batch elements of the srcArray to the dstArray.

    Declaration

    Objective-C

    - (void)getShortValues:(const short *)srcArray
             srcArrayCount:(NSInteger)srcArrayCount
                 baseIndex:(NSInteger)baseIndex
                  dstArray:(double *)dstArray
                startIndex:(NSInteger)startIndex
                     count:(NSInteger)count;

    Swift

    func getShortValues(_ srcArray: UnsafePointer<Int16>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, start startIndex: Int, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Finds the index of the item in the array according to desired SCISearchMode.

    Declaration

    Objective-C

    - (NSInteger)findIndexInShortArray:(const short *)array
                            startIndex:(NSInteger)startIndex
                                 count:(NSInteger)count
                              isSorted:(BOOL)isSorted
                                 value:(short)value
                            searchMode:(SCISearchMode)searchMode;

    Swift

    func findIndex(inShortArray array: UnsafePointer<Int16>!, start startIndex: Int, count: Int, isSorted: Bool, value: Int16, searchMode: SCISearchMode) -> Int

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    count

    The amount of items to search in.

    isSorted

    If true will use fast binary search.

    value

    The value to search.

    searchMode

    The search mode options.

    Return Value

    The index of value, or -1 if not found.

  • Checks whether the array is sorted ascending in specified range.

    Declaration

    Objective-C

    - (BOOL)isShortArraySortedAscending:(const short *)array
                             startIndex:(NSInteger)startIndex
                                  count:(NSInteger)count;

    Swift

    func isShortArraySortedAscending(_ array: UnsafePointer<Int16>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to check.

    startIndex

    The start index of sequences to check.

    count

    The amount of point in sequence to check.

    Return Value

    True if items in sequence is sorted in ascending order.

  • Checks whether data in the array region is evenly spaced and calculated space between data if it true.

    Declaration

    Objective-C

    - (double)calculateIsShortArrayEvenlySpaced:(const short *)array
                                     startIndex:(NSInteger)startIndex
                                          count:(NSInteger)count
                                        epsilon:(double)epsilon;

    Swift

    func calculateIsShortArrayEvenlySpaced(_ array: UnsafePointer<Int16>!, start startIndex: Int, count: Int, epsilon: Double) -> Double

    Parameters

    array

    The array to process.

    startIndex

    The start index index of sequence to process.

    count

    The size of data sequence to processs.

    epsilon

    The epsilon value.

    Return Value

    If data is evenly spaced returns positive value with calculated space, otherwise returns negative value.

  • Checks wheter data in array region contains NaN values

    Declaration

    Objective-C

    - (BOOL)containsNaNShortArray:(const short *)array
                       startIndex:(NSInteger)startIndex
                            count:(NSInteger)count;

    Swift

    func containsNaNShortArray(_ array: UnsafePointer<Int16>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to use

    startIndex

    The start index of sequence to process

    count

    The size of data sequence to process

    Return Value

    If data sequence contains NaN value returns true, otherwise returns false

  • Finds the maximum value of the array in specified bounds.

    Declaration

    Objective-C

    - (int)maxInt:(const int *)array
        startIndex:(NSInteger)startIndex
          endIndex:(NSInteger)endIndex;

    Swift

    func maxInt(_ array: UnsafePointer<Int32>!, start startIndex: Int, end endIndex: Int) -> Int32

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The maximum value of array.

  • Finds the minimum value of the array in specified bounds.

    Declaration

    Objective-C

    - (int)minInt:(const int *)array
        startIndex:(NSInteger)startIndex
          endIndex:(NSInteger)endIndex;

    Swift

    func minInt(_ array: UnsafePointer<Int32>!, start startIndex: Int, end endIndex: Int) -> Int32

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The minimum value of array.

  • Finds the minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxInt:(const int *)array
           startIndex:(NSInteger)startIndex
             endIndex:(NSInteger)endIndex
                range:(id<ISCIRange>)range;

    Swift

    func minMaxInt(_ array: UnsafePointer<Int32>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Finds the positive minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxIntPositive:(const int *)array
                   startIndex:(NSInteger)startIndex
                     endIndex:(NSInteger)endIndex
                        range:(id<ISCIRange>)range;

    Swift

    func minMaxIntPositive(_ array: UnsafePointer<Int32>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Copies elements of the srcArray at specified indices to the dstArray.

    Declaration

    Objective-C

    - (void)getIntValues:(const int *)srcArray
           srcArrayCount:(NSInteger)srcArrayCount
               baseIndex:(NSInteger)baseIndex
                dstArray:(double *)dstArray
                 indices:(const int *)indices
                   count:(NSInteger)count;

    Swift

    func getIntValues(_ srcArray: UnsafePointer<Int32>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, indices: UnsafePointer<Int32>!, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Copies batch elements of the srcArray to the dstArray.

    Declaration

    Objective-C

    - (void)getIntValues:(const int *)srcArray
           srcArrayCount:(NSInteger)srcArrayCount
               baseIndex:(NSInteger)baseIndex
                dstArray:(double *)dstArray
              startIndex:(NSInteger)startIndex
                   count:(NSInteger)count;

    Swift

    func getIntValues(_ srcArray: UnsafePointer<Int32>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, start startIndex: Int, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Finds the index of the item in the array according to desired SCISearchMode.

    Declaration

    Objective-C

    - (NSInteger)findIndexInIntArray:(const int *)array
                          startIndex:(NSInteger)startIndex
                               count:(NSInteger)count
                            isSorted:(BOOL)isSorted
                               value:(int)value
                          searchMode:(SCISearchMode)searchMode;

    Swift

    func findIndex(inIntArray array: UnsafePointer<Int32>!, start startIndex: Int, count: Int, isSorted: Bool, value: Int32, searchMode: SCISearchMode) -> Int

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    count

    The amount of items to search in.

    isSorted

    If true will use fast binary search.

    value

    The value to search.

    searchMode

    The search mode options.

    Return Value

    The index of value, or -1 if not found.

  • Checks whether the array is sorted ascending in specified range.

    Declaration

    Objective-C

    - (BOOL)isIntArraySortedAscending:(const int *)array
                           startIndex:(NSInteger)startIndex
                                count:(NSInteger)count;

    Swift

    func isIntArraySortedAscending(_ array: UnsafePointer<Int32>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to check.

    startIndex

    The start index of sequences to check.

    count

    The amount of point in sequence to check.

    Return Value

    True if items in sequence is sorted in ascending order.

  • Checks whether data in the array region is evenly spaced and calculated space between data if it true.

    Declaration

    Objective-C

    - (double)calculateIsIntArrayEvenlySpaced:(const int *)array
                                   startIndex:(NSInteger)startIndex
                                        count:(NSInteger)count
                                      epsilon:(double)epsilon;

    Swift

    func calculateIsIntArrayEvenlySpaced(_ array: UnsafePointer<Int32>!, start startIndex: Int, count: Int, epsilon: Double) -> Double

    Parameters

    array

    The array to process.

    startIndex

    The start index index of sequence to process.

    count

    The size of data sequence to processs.

    epsilon

    The epsilon value.

    Return Value

    If data is evenly spaced returns positive value with calculated space, otherwise returns negative value.

  • Checks wheter data in array region contains NaN values

    Declaration

    Objective-C

    - (BOOL)containsNaNIntArray:(const int *)array
                     startIndex:(NSInteger)startIndex
                          count:(NSInteger)count;

    Swift

    func containsNaNIntArray(_ array: UnsafePointer<Int32>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to use

    startIndex

    The start index of sequence to process

    count

    The size of data sequence to process

    Return Value

    If data sequence contains NaN value returns true, otherwise returns false

  • Finds the maximum value of the array in specified bounds.

    Declaration

    Objective-C

    - (long long)maxLong:(const long long *)array
              startIndex:(NSInteger)startIndex
                endIndex:(NSInteger)endIndex;

    Swift

    func maxLong(_ array: UnsafePointer<Int64>!, start startIndex: Int, end endIndex: Int) -> Int64

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The maximum value of array.

  • Finds the minimum value of the array in specified bounds.

    Declaration

    Objective-C

    - (long long)minLong:(const long long *)array
              startIndex:(NSInteger)startIndex
                endIndex:(NSInteger)endIndex;

    Swift

    func minLong(_ array: UnsafePointer<Int64>!, start startIndex: Int, end endIndex: Int) -> Int64

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The minimum value of array.

  • Finds the minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxLong:(const long long *)array
            startIndex:(NSInteger)startIndex
              endIndex:(NSInteger)endIndex
                 range:(id<ISCIRange>)range;

    Swift

    func minMaxLong(_ array: UnsafePointer<Int64>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Finds the positive minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxLongPositive:(const long long *)array
                    startIndex:(NSInteger)startIndex
                      endIndex:(NSInteger)endIndex
                         range:(id<ISCIRange>)range;

    Swift

    func minMaxLongPositive(_ array: UnsafePointer<Int64>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Copies elements of the srcArray at specified indices to the dstArray.

    Declaration

    Objective-C

    - (void)getLongValues:(const long long *)srcArray
            srcArrayCount:(NSInteger)srcArrayCount
                baseIndex:(NSInteger)baseIndex
                 dstArray:(double *)dstArray
                  indices:(const int *)indices
                    count:(NSInteger)count;

    Swift

    func getLongValues(_ srcArray: UnsafePointer<Int64>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, indices: UnsafePointer<Int32>!, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Copies batch elements of the srcArray to the dstArray.

    Declaration

    Objective-C

    - (void)getLongValues:(const long long *)srcArray
            srcArrayCount:(NSInteger)srcArrayCount
                baseIndex:(NSInteger)baseIndex
                 dstArray:(double *)dstArray
               startIndex:(NSInteger)startIndex
                    count:(NSInteger)count;

    Swift

    func getLongValues(_ srcArray: UnsafePointer<Int64>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, start startIndex: Int, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Finds the index of the item in the array according to desired SCISearchMode.

    Declaration

    Objective-C

    - (NSInteger)findIndexInLongArray:(const long long *)array
                           startIndex:(NSInteger)startIndex
                                count:(NSInteger)count
                             isSorted:(BOOL)isSorted
                                value:(long long)value
                           searchMode:(SCISearchMode)searchMode;

    Swift

    func findIndex(inLongArray array: UnsafePointer<Int64>!, start startIndex: Int, count: Int, isSorted: Bool, value: Int64, searchMode: SCISearchMode) -> Int

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    count

    The amount of items to search in.

    isSorted

    If true will use fast binary search.

    value

    The value to search.

    searchMode

    The search mode options.

    Return Value

    The index of value, or -1 if not found.

  • Checks whether the array is sorted ascending in specified range.

    Declaration

    Objective-C

    - (BOOL)isLongArraySortedAscending:(const long long *)array
                            startIndex:(NSInteger)startIndex
                                 count:(NSInteger)count;

    Swift

    func isLongArraySortedAscending(_ array: UnsafePointer<Int64>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to check.

    startIndex

    The start index of sequences to check.

    count

    The amount of point in sequence to check.

    Return Value

    True if items in sequence is sorted in ascending order.

  • Checks whether data in the array region is evenly spaced and calculated space between data if it true.

    Declaration

    Objective-C

    - (double)calculateIsLongArrayEvenlySpaced:(const long long *)array
                                    startIndex:(NSInteger)startIndex
                                         count:(NSInteger)count
                                       epsilon:(double)epsilon;

    Swift

    func calculateIsLongArrayEvenlySpaced(_ array: UnsafePointer<Int64>!, start startIndex: Int, count: Int, epsilon: Double) -> Double

    Parameters

    array

    The array to process.

    startIndex

    The start index index of sequence to process.

    count

    The size of data sequence to processs.

    epsilon

    The epsilon value.

    Return Value

    If data is evenly spaced returns positive value with calculated space, otherwise returns negative value.

  • Checks wheter data in array region contains NaN values

    Declaration

    Objective-C

    - (BOOL)containsNaNLongArray:(const long long *)array
                      startIndex:(NSInteger)startIndex
                           count:(NSInteger)count;

    Swift

    func containsNaNLongArray(_ array: UnsafePointer<Int64>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to use

    startIndex

    The start index of sequence to process

    count

    The size of data sequence to process

    Return Value

    If data sequence contains NaN value returns true, otherwise returns false

  • Finds the maximum value of the array in specified bounds.

    Declaration

    Objective-C

    - (float)maxFloat:(const float *)array
           startIndex:(NSInteger)startIndex
             endIndex:(NSInteger)endIndex;

    Swift

    func maxFloat(_ array: UnsafePointer<Float>!, start startIndex: Int, end endIndex: Int) -> Float

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The maximum value of array.

  • Finds the minimum value of the array in specified bounds.

    Declaration

    Objective-C

    - (float)minFloat:(const float *)array
           startIndex:(NSInteger)startIndex
             endIndex:(NSInteger)endIndex;

    Swift

    func minFloat(_ array: UnsafePointer<Float>!, start startIndex: Int, end endIndex: Int) -> Float

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The minimum value of array.

  • Finds the minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxFloat:(const float *)array
             startIndex:(NSInteger)startIndex
               endIndex:(NSInteger)endIndex
                  range:(id<ISCIRange>)range;

    Swift

    func minMaxFloat(_ array: UnsafePointer<Float>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Finds the positive minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxFloatPositive:(const float *)array
                     startIndex:(NSInteger)startIndex
                       endIndex:(NSInteger)endIndex
                          range:(id<ISCIRange>)range;

    Swift

    func minMaxFloatPositive(_ array: UnsafePointer<Float>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Copies elements of the srcArray at specified indices to the dstArray.

    Declaration

    Objective-C

    - (void)getFloatValues:(const float *)srcArray
             srcArrayCount:(NSInteger)srcArrayCount
                 baseIndex:(NSInteger)baseIndex
                  dstArray:(double *)dstArray
                   indices:(const int *)indices
                     count:(NSInteger)count;

    Swift

    func getFloatValues(_ srcArray: UnsafePointer<Float>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, indices: UnsafePointer<Int32>!, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Copies batch elements of the srcArray to the dstArray.

    Declaration

    Objective-C

    - (void)getFloatValues:(const float *)srcArray
             srcArrayCount:(NSInteger)srcArrayCount
                 baseIndex:(NSInteger)baseIndex
                  dstArray:(double *)dstArray
                startIndex:(NSInteger)startIndex
                     count:(NSInteger)count;

    Swift

    func getFloatValues(_ srcArray: UnsafePointer<Float>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, start startIndex: Int, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Finds the index of the item in the array according to desired SCISearchMode.

    Declaration

    Objective-C

    - (NSInteger)findIndexInFloatArray:(const float *)array
                            startIndex:(NSInteger)startIndex
                                 count:(NSInteger)count
                              isSorted:(BOOL)isSorted
                                 value:(float)value
                            searchMode:(SCISearchMode)searchMode;

    Swift

    func findIndex(inFloatArray array: UnsafePointer<Float>!, start startIndex: Int, count: Int, isSorted: Bool, value: Float, searchMode: SCISearchMode) -> Int

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    count

    The amount of items to search in.

    isSorted

    If true will use fast binary search.

    value

    The value to search.

    searchMode

    The search mode options.

    Return Value

    The index of value, or -1 if not found.

  • Checks whether the array is sorted ascending in specified range.

    Declaration

    Objective-C

    - (BOOL)isFloatArraySortedAscending:(const float *)array
                             startIndex:(NSInteger)startIndex
                                  count:(NSInteger)count;

    Swift

    func isFloatArraySortedAscending(_ array: UnsafePointer<Float>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to check.

    startIndex

    The start index of sequences to check.

    count

    The amount of point in sequence to check.

    Return Value

    True if items in sequence is sorted in ascending order.

  • Checks whether data in the array region is evenly spaced and calculated space between data if it true.

    Declaration

    Objective-C

    - (double)calculateIsFloatArrayEvenlySpaced:(const float *)array
                                     startIndex:(NSInteger)startIndex
                                          count:(NSInteger)count
                                        epsilon:(double)epsilon;

    Swift

    func calculateIsFloatArrayEvenlySpaced(_ array: UnsafePointer<Float>!, start startIndex: Int, count: Int, epsilon: Double) -> Double

    Parameters

    array

    The array to process.

    startIndex

    The start index index of sequence to process.

    count

    The size of data sequence to processs.

    epsilon

    The epsilon value.

    Return Value

    If data is evenly spaced returns positive value with calculated space, otherwise returns negative value.

  • Checks wheter data in array region contains NaN values

    Declaration

    Objective-C

    - (BOOL)containsNaNFloatArray:(const float *)array
                       startIndex:(NSInteger)startIndex
                            count:(NSInteger)count;

    Swift

    func containsNaNFloatArray(_ array: UnsafePointer<Float>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to use

    startIndex

    The start index of sequence to process

    count

    The size of data sequence to process

    Return Value

    If data sequence contains NaN value returns true, otherwise returns false

  • Finds the maximum value of the array in specified bounds.

    Declaration

    Objective-C

    - (double)maxDouble:(const double *)array
             startIndex:(NSInteger)startIndex
               endIndex:(NSInteger)endIndex;

    Swift

    func maxDouble(_ array: UnsafePointer<Double>!, start startIndex: Int, end endIndex: Int) -> Double

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The maximum value of array.

  • Finds the minimum value of the array in specified bounds.

    Declaration

    Objective-C

    - (double)minDouble:(const double *)array
             startIndex:(NSInteger)startIndex
               endIndex:(NSInteger)endIndex;

    Swift

    func minDouble(_ array: UnsafePointer<Double>!, start startIndex: Int, end endIndex: Int) -> Double

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    Return Value

    The minimum value of array.

  • Finds the minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxDouble:(const double *)array
              startIndex:(NSInteger)startIndex
                endIndex:(NSInteger)endIndex
                   range:(id<ISCIRange>)range;

    Swift

    func minMaxDouble(_ array: UnsafePointer<Double>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Finds the positive minimum and maximum of the array in specified bounds.

    Declaration

    Objective-C

    - (void)minMaxDoublePositive:(const double *)array
                      startIndex:(NSInteger)startIndex
                        endIndex:(NSInteger)endIndex
                           range:(id<ISCIRange>)range;

    Swift

    func minMaxDoublePositive(_ array: UnsafePointer<Double>!, start startIndex: Int, end endIndex: Int, range: ISCIRange!)

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    endIndex

    The startIndex to end search at.

    range

    The range which holds the result of search.

  • Copies elements of the srcArray at specified indices to the dstArray.

    Declaration

    Objective-C

    - (void)getDoubleValues:(const double *)srcArray
              srcArrayCount:(NSInteger)srcArrayCount
                  baseIndex:(NSInteger)baseIndex
                   dstArray:(double *)dstArray
                    indices:(const int *)indices
                      count:(NSInteger)count;

    Swift

    func getDoubleValues(_ srcArray: UnsafePointer<Double>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, indices: UnsafePointer<Int32>!, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Copies batch elements of the srcArray to the dstArray.

    Declaration

    Objective-C

    - (void)getDoubleValues:(const double *)srcArray
              srcArrayCount:(NSInteger)srcArrayCount
                  baseIndex:(NSInteger)baseIndex
                   dstArray:(double *)dstArray
                 startIndex:(NSInteger)startIndex
                      count:(NSInteger)count;

    Swift

    func getDoubleValues(_ srcArray: UnsafePointer<Double>!, srcArrayCount: Int, baseIndex: Int, dstArray: UnsafeMutablePointer<Double>!, start startIndex: Int, count: Int)

    Parameters

    srcArray

    The source array to copy from.

    baseIndex

    The baseIndex which is used in {@link FifoBufferFactory}. Otherwise it’s {@link FifoBufferFactory#NORMALIZED_BASE_INDEX}.

  • Finds the index of the item in the array according to desired SCISearchMode.

    Declaration

    Objective-C

    - (NSInteger)findIndexInDoubleArray:(const double *)array
                             startIndex:(NSInteger)startIndex
                                  count:(NSInteger)count
                               isSorted:(BOOL)isSorted
                                  value:(double)value
                             searchMode:(SCISearchMode)searchMode;

    Swift

    func findIndex(inDoubleArray array: UnsafePointer<Double>!, start startIndex: Int, count: Int, isSorted: Bool, value: Double, searchMode: SCISearchMode) -> Int

    Parameters

    array

    The array to search.

    startIndex

    The startIndex to start search from.

    count

    The amount of items to search in.

    isSorted

    If true will use fast binary search.

    value

    The value to search.

    searchMode

    The search mode options.

    Return Value

    The index of value, or -1 if not found.

  • Checks whether the array is sorted ascending in specified range.

    Declaration

    Objective-C

    - (BOOL)isDoubleArraySortedAscending:(const double *)array
                              startIndex:(NSInteger)startIndex
                                   count:(NSInteger)count;

    Swift

    func isDoubleArraySortedAscending(_ array: UnsafePointer<Double>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to check.

    startIndex

    The start index of sequences to check.

    count

    The amount of point in sequence to check.

    Return Value

    True if items in sequence is sorted in ascending order.

  • Checks whether data in the array region is evenly spaced and calculated space between data if it true.

    Declaration

    Objective-C

    - (double)calculateIsDoubleArrayEvenlySpaced:(const double *)array
                                      startIndex:(NSInteger)startIndex
                                           count:(NSInteger)count
                                         epsilon:(double)epsilon;

    Swift

    func calculateIsDoubleArrayEvenlySpaced(_ array: UnsafePointer<Double>!, start startIndex: Int, count: Int, epsilon: Double) -> Double

    Parameters

    array

    The array to process.

    startIndex

    The start index index of sequence to process.

    count

    The size of data sequence to processs.

    epsilon

    The epsilon value.

    Return Value

    If data is evenly spaced returns positive value with calculated space, otherwise returns negative value.

  • Checks wheter data in array region contains NaN values

    Declaration

    Objective-C

    - (BOOL)containsNaNDoubleArray:(const double *)array
                        startIndex:(NSInteger)startIndex
                             count:(NSInteger)count;

    Swift

    func containsNaNDoubleArray(_ array: UnsafePointer<Double>!, start startIndex: Int, count: Int) -> Bool

    Parameters

    array

    The array to use

    startIndex

    The start index of sequence to process

    count

    The size of data sequence to process

    Return Value

    If data sequence contains NaN value returns true, otherwise returns false