ScaleAP/data.hpp at main · LazyShion/ScaleAP · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#ifndef DATA_H
#define DATA_H

#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cassert>

#include "util.hpp"

using namespace std;

class Data{
private:
  // ---------------------
  // Members
  // ---------------------

  unsigned int N; // # of data objects
  unsigned int size; // size of sim_vector
  vector<double> sim_vector; // vector of similarities

public:
  // ---------------------
  // Members
  // ---------------------

  vector<double> delta_sim_vector; // vector of delta similarities
  vector<unsigned int> min_index; // vector of min similarity index

  // ---------------------
  // Constructor
  // ---------------------

  Data();
  Data(char *simfile, double pref);

  // ---------------------
  // Functions
  // ---------------------

  void read_sim_vector(char *simfile);
  void init(double pref);

  // ---------------------
  // Inlines
  // ---------------------

  // Return # of data objects
  inline unsigned int get_N(){
    return N;
  }

  // Return size
  inline unsigned int get_size(){
    return size;
  }

  // Return a similarity from i to j
  inline double
  sim(unsigned int i, unsigned int j){
    //assert(i >=0 && i < N);
    //assert(j >=0 && j < N);
    return sim_vector[N*i + j];
  }

  // Return a maximum similarity of object i except for sim(i,j)
  inline double
  max_sim(unsigned int i, unsigned int j){
    //assert(i >=0 && i < N);
    //assert(j >=0 && j < N);

    vector<double>::iterator it = sim_vector.begin()+(N*i);

    if(j==0){
      return *max_element(it+1, it+N);
    }else if(j == N-1){
      return *max_element(it, it+N-1);
    }else{
      return max(*max_element(it, it+j), *max_element(it+j+1, it+N));
    }
  }

  // Return an index of minimum similarity of object i except for sim(i,i)
  inline vector<double>::iterator
  min_sim_index(unsigned int i){
    //assert(i >=0 && i < N);
    vector<double>::iterator it = sim_vector.begin()+(N*i);

    if(i==0){
      return min_element(it+1, it+N);
    }else if(i == N-1){
      return min_element(it, it+N-1);
    }else{
      vector<double>::iterator min1 = min_element(it, it+i);
      vector<double>::iterator min2 = min_element(it+i+1, it+N);
      if(*min1 < *min2){
	return min1;
      }else{
	return min2;
      }
    }
  }

  // Return an index of maximum similarity of object i
  inline unsigned int
  max_sim_index(unsigned int i){
    return (max_element(sim_vector.begin()+N*i, sim_vector.begin()+N*(i+1)) - sim_vector.begin())%N;
  }

};

#endif //DATA_H