iOS & macOS Charting Documentation - SciChart iOS & macOS Charts SDK v4.x

ISCIListUtilProvider

@protocol ISCIListUtilProvider

Defines interface with SciListUtil methods.

< --- ISCIListUtilProvider methods for Char --- >

  • 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<CChar>!, start startIndex: Int, end endIndex: Int) -> CChar

    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<CChar>!, start startIndex: Int, end endIndex: Int) -> CChar

    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<CChar>!, 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<CChar>!, 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<CChar>!, 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<CChar>!, 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<CChar>!, start startIndex: Int, count: Int, isSorted: Bool, value: CChar, 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<CChar>!, 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<CChar>!, 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<CChar>!, 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

< --- ISCIListUtilProvider methods for Short --- >

  • 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

< --- ISCIListUtilProvider methods for Int --- >

  • 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

< --- ISCIListUtilProvider methods for Long --- >

  • 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

< --- ISCIListUtilProvider methods for Float --- >

  • 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

< --- ISCIListUtilProvider methods for Double --- >

  • 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

© 2024 SciChart. All rights reserved. (Last updated: 2024-06-12)

Generated by jazzy ♪♫ v0.14.4, a Realm project.