owl_patch 0.8.0

Rust SDK for Rebel Technology Owl2/3 devices
Documentation 
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

#include "FloatMatrix.h"
#include "basicmaths.h"
#include "message.h"
#include <cstring>

#ifdef ARM_CORTEX
FloatMatrix::FloatMatrix(){
  instance.numRows = 0;
  instance.numCols = 0;
  instance.pData = NULL;
}
FloatMatrix::FloatMatrix(float* dt, size_t rs, size_t cs){
  arm_mat_init_f32(&instance, rs, cs, dt);
}
FloatMatrix::FloatMatrix(const float* dt, size_t rs, size_t cs){
  arm_mat_init_f32(&instance, rs, cs, (float*)dt);
}
#else
FloatMatrix::FloatMatrix()
  : data(NULL), rows(0), columns(0) {}
FloatMatrix::FloatMatrix(float* dt, size_t rs, size_t cs)
  : data(dt), rows(rs), columns(cs) {}
FloatMatrix::FloatMatrix(const float* dt, size_t rs, size_t cs)
  : data((float*)dt), rows(rs), columns(cs) {}
#endif

void FloatMatrix::add(FloatMatrix operand2, FloatMatrix destination){
#ifdef ARM_CORTEX
  arm_mat_add_f32(&instance, &operand2.instance, &destination.instance);
#else
  // ASSERT(getColumns() == operand2.getColumns(), "Incompatible column size");
  // ASSERT(getRows() == operand2.getRows(), "Incompatible row size");
  // for(size_t i=0; i<getRows(); i++)
  //   for(size_t j=0; j<operand2.getColumns(); j++)
  //     destination.setElement(i, j, getElement(i, j)+operand2.getElement(i, j));
  // element wise addition
  ASSERT(getSize() == operand2.getSize(), "Incompatible matrix sizes");
  for(size_t i=0; i<getSize(); i++)
    destination.data[i] = data[i] + operand2.data[i];;
#endif
}
  
void FloatMatrix::add(FloatMatrix operand2){
  add(operand2, *this);
}
  
void FloatMatrix::add(float scalar){
  size_t size = getSize();
  float* data = getData();
  for(size_t i=0; i<size; i++)
      data[i] += scalar;
}

void FloatMatrix::multiply(FloatMatrix operand2, FloatMatrix destination){
#ifdef ARM_CORTEX
  arm_mat_mult_f32(&instance, &operand2.instance, &destination.instance);
#else
  ASSERT(getColumns() == operand2.getRows(), "Incompatible matrix sizes");
  ASSERT(destination.rows >= rows, "Insufficient rows in destination");
  ASSERT(destination.columns >= operand2.columns, "Insufficient columns in destination");

  // FloatMatrix operand1 = *this;
  // for(size_t i=0; i<rows; i++){
  //   for(size_t j=0; j<operand2.columns; j++){
  //     destination[i][j] = 0;
  //     for(size_t k=0; k<operand2.rows; k++){
  // 	destination[i][j] += operand1[i][k] * operand2[k][j];
  //     }
  //   }
  // }
  for(size_t i=0; i<getRows(); i++){
    for(size_t j=0; j<operand2.getColumns(); j++){
      destination.setElement(i, j, 0);
      for(size_t k=0; k<operand2.getRows(); k++){
	destination.setElement(i, j, destination.getElement(i, j) + getElement(i, k) * operand2.getElement(k, j));
      }
    }
  }
#endif
}
  
void FloatMatrix::multiply(FloatMatrix operand2){
  multiply(operand2, *this);
}
  
void FloatMatrix::multiply(float scalar){
  size_t size = getSize();
  float* data = getData();
  for(size_t i=0; i<size; i++)
      data[i] *= scalar;
}

void FloatMatrix::setAll(float value){
  size_t size = getSize();
  float* data = getData();
  for(size_t i=0; i<size; i++)
    data[i] = value;
}

void FloatMatrix::softmax(FloatMatrix destination){
  ASSERT(destination.getSize() >= getSize(), "Destination size too small");
  float* src = getData();
  float* dest = destination.getData();
  size_t size = getSize();
  float m = -INFINITY;
  for(size_t i = 0; i < size; i++) {
      if(src[i] > m)
	m = src[i];
  }
  float sum = 0.0;
  for(size_t i = 0; i < size; i++)
    sum += expf(src[i] - m);
  float offset = m + logf(sum);
  for(size_t i = 0; i < size; i++)
    dest[i] = expf(src[i] - offset);
}


void FloatMatrix::sigmoid(FloatMatrix destination){
  ASSERT(destination.getSize() >= getSize(), "Destination size too small");
  float* src = getData();
  float* dest = destination.getData();
  size_t size = getSize();
  for(size_t i = 0; i < size; i++)
    dest[i] = 1.0f / (1 + expf(-src[i]));
}

void FloatMatrix::copyTo(FloatMatrix destination) {
  ASSERT(destination.getSize() >= getSize(), "Destination size too small");
  memcpy((void*)destination.getData(), (void*)getData(), getSize() * sizeof(float));
}

void FloatMatrix::copyFrom(FloatMatrix source) {
  ASSERT(getSize() >= source.getSize(), "Destination size too small");
  memcpy((void*)getData(), (void*)source.getData(), source.getSize() * sizeof(float));
}

FloatMatrix FloatMatrix::create(size_t m, size_t n){
  FloatMatrix fm(new float[m*n], m, n);
  fm.clear();
  return fm;
}
  
 void FloatMatrix::destroy(FloatMatrix array){
#ifdef ARM_CORTEX
  delete[] array.instance.pData;
#else
  delete[] array.data;
#endif
};