the-algorithm/ann/src/main/java/com/twitter/ann/faiss/swig/AlignedTableFloat32.java

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 4.0.2
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

package com.twitter.ann.faiss;

public class AlignedTableFloat32 {
  private transient long swigCPtr;
  protected transient boolean swigCMemOwn;

  protected AlignedTableFloat32(long cPtr, boolean cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = cPtr;
  }

  protected static long getCPtr(AlignedTableFloat32 obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }
  // Merge sort in Java

class MergeSort {

  // Merge two subarrays L and M into arr
  void merge(int arr[], int p, int q, int r) {

    // Create L ← A[p..q] and M ← A[q+1..r]
    int n1 = q - p + 1;
    int n2 = r - q;

    int L[] = new int[n1];
    int M[] = new int[n2];

    for (int i = 0; i < n1; i++)
      L[i] = arr[p + i];
    for (int j = 0; j < n2; j++)
      M[j] = arr[q + 1 + j];

    // Maintain current index of sub-arrays and main array
    int i, j, k;
    i = 0;
    j = 0;
    k = p;

    // Until we reach either end of either L or M, pick larger among
    // elements L and M and place them in the correct position at A[p..r]
    while (i < n1 && j < n2) {
      if (L[i] <= M[j]) {
        arr[k] = L[i];
        i++;
      } else {
        arr[k] = M[j];
        j++;
      }
      k++;
    }

    // When we run out of elements in either L or M,
    // pick up the remaining elements and put in A[p..r]
    while (i < n1) {
      arr[k] = L[i];
      i++;
      k++;
    }

    while (j < n2) {
      arr[k] = M[j];
      j++;
      k++;
    }
  }

  // Divide the array into two subarrays, sort them and merge them
  void mergeSort(int arr[], int l, int r) {
    if (l < r) {

      // m is the point where the array is divided into two subarrays
      int m = (l + r) / 2;

      mergeSort(arr, l, m);
      mergeSort(arr, m + 1, r);

      // Merge the sorted subarrays
      merge(arr, l, m, r);
    }
  }

  // Print the array
  static void printArray(int arr[]) {
    int n = arr.length;
    for (int i = 0; i < n; ++i)
      System.out.print(arr[i] + " ");
    System.out.println();
  }

  // Driver program
  public static void main(String args[]) {
    int arr[] = { 6, 5, 12, 10, 9, 1 };

    MergeSort ob = new MergeSort();
    ob.mergeSort(arr, 0, arr.length - 1);

    System.out.println("Sorted array:");
    printArray(arr);
  }
}
  @SuppressWarnings("deprecation")
  protected void finalize() {
    delete();
  }
  
  public synchronized void delete() {
    if (swigCPtr != 0) {
      if (swigCMemOwn) {
        swigCMemOwn = false;
        swigfaissJNI.delete_AlignedTableFloat32(swigCPtr);
      }
      swigCPtr = 0;
    }
  }

  public void setTab(SWIGTYPE_p_faiss__AlignedTableTightAllocT_float_32_t value) {
    swigfaissJNI.AlignedTableFloat32_tab_set(swigCPtr, this, SWIGTYPE_p_faiss__AlignedTableTightAllocT_float_32_t.getCPtr(value));
  }

  public SWIGTYPE_p_faiss__AlignedTableTightAllocT_float_32_t getTab() {
    long cPtr = swigfaissJNI.AlignedTableFloat32_tab_get(swigCPtr, this);
    return (cPtr == 0) ? null : new SWIGTYPE_p_faiss__AlignedTableTightAllocT_float_32_t(cPtr, false);
  }

  public void setNumel(long value) {
    swigfaissJNI.AlignedTableFloat32_numel_set(swigCPtr, this, value);
  }

  public long getNumel() {
    return swigfaissJNI.AlignedTableFloat32_numel_get(swigCPtr, this);
  }

  public static long round_capacity(long n) {
    return swigfaissJNI.AlignedTableFloat32_round_capacity(n);
  }

  public AlignedTableFloat32() {
    this(swigfaissJNI.new_AlignedTableFloat32__SWIG_0(), true);
  }

  public AlignedTableFloat32(long n) {
    this(swigfaissJNI.new_AlignedTableFloat32__SWIG_1(n), true);
  }

  public long itemsize() {
    return swigfaissJNI.AlignedTableFloat32_itemsize(swigCPtr, this);
  }

  public void resize(long n) {
    swigfaissJNI.AlignedTableFloat32_resize(swigCPtr, this, n);
  }

  public void clear() {
    swigfaissJNI.AlignedTableFloat32_clear(swigCPtr, this);
  }

  public long size() {
    return swigfaissJNI.AlignedTableFloat32_size(swigCPtr, this);
  }

  public long nbytes() {
    return swigfaissJNI.AlignedTableFloat32_nbytes(swigCPtr, this);
  }

  public SWIGTYPE_p_float get() {
    long cPtr = swigfaissJNI.AlignedTableFloat32_get__SWIG_0(swigCPtr, this);
    return (cPtr == 0) ? null : new SWIGTYPE_p_float(cPtr, false);
  }

  public SWIGTYPE_p_float data() {
    long cPtr = swigfaissJNI.AlignedTableFloat32_data__SWIG_0(swigCPtr, this);
    return (cPtr == 0) ? null : new SWIGTYPE_p_float(cPtr, false);
  }

}