Skip to content

Commit 417c581

Browse files
author
Jason Ramapuram
committed
forgot to push the actual index changes
1 parent 67c3f98 commit 417c581

File tree

1 file changed

+132
-72
lines changed

1 file changed

+132
-72
lines changed

‎src/index.rs‎

Lines changed: 132 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ use defines::AfError;
55
use dim4::Dim4;
66
use seq::Seq;
77
use defines::Aftype;
8-
use self::libc::{uint8_t, c_void, c_int, c_uint, c_longlong};
8+
use self::libc::{c_int, c_uint, c_longlong};
99

1010
type MutAfArray = *mut self::libc::c_longlong;
1111
type MutAfSeq = *mut Seq;
@@ -39,7 +39,7 @@ pub struct Index {
3939

4040
impl Index {
4141
#[allow(unused_mut)]
42-
pub fn new<T>(arr: Option<Array>, seq: Option<Seq>, is_batch: bool) -> Result<Index, AfError> {
42+
pub fn new(arr: Option<Array>, seq: Option<Seq>, is_batch: bool) -> Result<Index, AfError> {
4343
unsafe {
4444
let mut err_val: c_int = 0;
4545
let mut temp: i64 = 0;
@@ -63,97 +63,157 @@ impl Index {
6363
}
6464
}
6565

66-
pub fn index(&self, input: Array, seqs: &[Seq]) -> Result<Array, AfError> {
67-
unsafe {
68-
let mut temp: i64 = 0;
69-
let err_val = af_index(&mut temp as MutAfArray
70-
, input.get() as AfArray, seqs.len() as u32
71-
, seqs.as_ptr() as *const SeqT);
72-
match err_val {
73-
0 => Ok(Array::from(temp)),
74-
_ => Err(AfError::from(err_val)),
75-
}
76-
}
66+
pub fn get(&self) -> i64 {
67+
self.handle
7768
}
7869

79-
pub fn lookup(&self, input: Array, indices: Array, seq_dim: i32) -> Result<Array, AfError> {
70+
pub fn is_seq(&self) -> bool{
71+
self.is_seq
72+
}
73+
74+
pub fn is_batch(&self) -> bool{
75+
self.is_batch
76+
}
77+
}
78+
79+
impl Drop for Index {
80+
fn drop(&mut self) {
8081
unsafe {
81-
let mut temp: i64 = 0;
82-
let err_val = af_lookup(&mut temp as MutAfArray
83-
, input.get() as AfArray
84-
, indices.get() as AfArray
85-
, seq_dim as c_uint);
86-
match err_val {
87-
0 => Ok(Array::from(temp)),
88-
_ => Err(AfError::from(err_val)),
82+
let ret_val = af_release_index(self.handle as MutAfIndex);
83+
match ret_val {
84+
0 => (),
85+
_ => panic!("Failed to destruct Index: {}", ret_val),
8986
}
9087
}
9188
}
89+
}
9290

93-
pub fn assign_seq(&self, lhs: Array, ndims: usize, seq_dim: i32, seqs: &[Seq], rhs: Array) -> Result<Array, AfError> {
94-
unsafe{
95-
let mut temp: i64 = 0;
96-
let err_val = af_assign_seq(&mut temp as MutAfArray
97-
, lhs.get() as AfArray
98-
, ndims as c_uint, seqs.as_ptr() as *const IndexT
99-
, rhs.get() as AfArray);
100-
match err_val {
101-
0 => Ok(Array::from(temp)),
102-
_ => Err(AfError::from(err_val)),
103-
}
91+
pub fn index(input: &Array, seqs: &[Seq]) -> Result<Array, AfError> {
92+
unsafe {
93+
let mut temp: i64 = 0;
94+
let err_val = af_index(&mut temp as MutAfArray
95+
, input.get() as AfArray, seqs.len() as u32
96+
, seqs.as_ptr() as *const SeqT);
97+
match err_val {
98+
0 => Ok(Array::from(temp)),
99+
_ => Err(AfError::from(err_val)),
104100
}
105101
}
102+
}
106103

107-
pub fn index_gen(&self, input: Array, ndims: Dim4, indices: &[Index]) -> Result<Array, AfError> {
108-
unsafe{
109-
let mut temp: i64 = 0;
110-
let err_val = af_index_gen(&mut temp as MutAfArray
111-
, input.get() as AfArray
112-
, ndims.get().as_ptr() as DimT
113-
, indices.as_ptr() as *const IndexT);
114-
match err_val {
115-
0 => Ok(Array::from(temp)),
116-
_ => Err(AfError::from(err_val)),
117-
}
118-
}
104+
pub fn row(input: &Array, row_num: u64) -> Result<Array, AfError> {
105+
let dims_err = input.dims();
106+
let mut dims = [0, 0, 0, 0];
107+
match dims_err {
108+
Ok(dim) => dims = dim.get().clone(),
109+
Err(e) => panic!("Error unwrapping dims in row(): {}", e),
119110
}
120111

121-
pub fn assign_gen(&self, lhs: Array, ndims: Dim4, indices: &[Index], rhs: Array) -> Result<Array, AfError> {
122-
unsafe{
123-
let mut temp: i64 = 0;
124-
let err_val = af_assign_gen(&mut temp as MutAfArray
125-
, lhs.get() as AfArray
126-
, ndims.get().as_ptr() as DimT
127-
, indices.as_ptr() as *const IndexT
128-
, rhs.get() as AfArray);
129-
match err_val {
130-
0 => Ok(Array::from(temp)),
131-
_ => Err(AfError::from(err_val)),
132-
}
133-
}
112+
let array_end = dims[0] as f64 * dims[1] as f64 * dims[2] as f64 * dims[3] as f64;
113+
let row_begin: f64 = dims[1] as f64 * row_num as f64;
114+
assert!(row_begin <= array_end - dims[1] as f64);
115+
116+
let row_end: f64 = row_begin + dims[1] as f64 - 1.0;
117+
assert!(row_end <= array_end);
118+
119+
let index = Index::new(None, Some(Seq::new(row_begin, row_end, 1.0)), false);
120+
println!("origin size {} x {} x {} x {}", dims[0], dims[1], dims[2], dims[3]);
121+
println!("passed index gen from {} to {}", row_begin, row_end);
122+
123+
match index {
124+
Ok(i) => { println!("index raw handle: {}", i.get()); index_gen(input, Dim4::new(&[1, 1, 1, 1]), &[i])},
125+
Err(e) => Err(AfError::from(e)),
134126
}
127+
}
135128

136-
pub fn get(&self) -> i64 {
137-
self.handle
129+
pub fn col(input: &Array, col_num: u64) -> Result<Array, AfError> {
130+
let dims_err = input.dims();
131+
let mut dims = [0, 0, 0, 0];
132+
match dims_err {
133+
Ok(dim) => dims = dim.get().clone(),
134+
Err(e) => panic!("Error unwrapping dims in col(): {}", e),
138135
}
139136

140-
pub fn is_seq(&self) -> bool{
141-
self.is_seq
137+
let input_type_err = input.get_type();
138+
let mut input_type = Aftype::F32;
139+
match input_type_err {
140+
Ok(t) => input_type = t,
141+
Err(e) => panic!("Error unwrapping type in col(): {}", e),
142142
}
143143

144-
pub fn is_batch(&self) -> bool{
145-
self.is_seq
144+
let mut indices = vec![col_num];
145+
for i in 0..dims[0]-1 {
146+
let last_element = indices[indices.len() - 1];
147+
indices.push(last_element + dims[0]);
148+
}
149+
150+
let index_array = Array::new(Dim4::new(&dims), &indices, input_type);
151+
match index_array {
152+
Ok(a) => {
153+
let index = Index::new(Some(a), None, false);
154+
match index {
155+
Ok(i) => index_gen(input, Dim4::new(&[1, 1, 1, 1]), &[i]),
156+
Err(e) => Err(AfError::from(e)),
157+
}
158+
},
159+
Err(e) => Err(AfError::from(e)),
146160
}
147161
}
148162

149-
impl Drop for Index {
150-
fn drop(&mut self) {
151-
unsafe {
152-
let ret_val = af_release_index(self.handle as MutAfIndex);
153-
match ret_val {
154-
0 => (),
155-
_ => panic!("Failed to destruct Index: {}", ret_val),
156-
}
163+
pub fn lookup(input: &Array, indices: &Array, seq_dim: i32) -> Result<Array, AfError> {
164+
unsafe {
165+
let mut temp: i64 = 0;
166+
let err_val = af_lookup(&mut temp as MutAfArray
167+
, input.get() as AfArray
168+
, indices.get() as AfArray
169+
, seq_dim as c_uint);
170+
match err_val {
171+
0 => Ok(Array::from(temp)),
172+
_ => Err(AfError::from(err_val)),
173+
}
174+
}
175+
}
176+
177+
178+
pub fn assign_seq(lhs: &Array, ndims: usize, seqs: &[Seq], rhs: &Array) -> Result<Array, AfError> {
179+
unsafe{
180+
let mut temp: i64 = 0;
181+
let err_val = af_assign_seq(&mut temp as MutAfArray
182+
, lhs.get() as AfArray
183+
, ndims as c_uint, seqs.as_ptr() as *const IndexT
184+
, rhs.get() as AfArray);
185+
match err_val {
186+
0 => Ok(Array::from(temp)),
187+
_ => Err(AfError::from(err_val)),
188+
}
189+
}
190+
}
191+
192+
pub fn index_gen(input: &Array, ndims: Dim4, indices: &[Index]) -> Result<Array, AfError> {
193+
unsafe{
194+
let mut temp: i64 = 0;
195+
let err_val = af_index_gen(&mut temp as MutAfArray
196+
, input.get() as AfArray
197+
, ndims.get().as_ptr() as DimT
198+
, indices.as_ptr() as *const IndexT);
199+
match err_val {
200+
0 => Ok(Array::from(temp)),
201+
_ => Err(AfError::from(err_val)),
202+
}
203+
}
204+
}
205+
206+
pub fn assign_gen(lhs: &Array, ndims: Dim4, indices: &[Index], rhs: &Array) -> Result<Array, AfError> {
207+
unsafe{
208+
let mut temp: i64 = 0;
209+
let err_val = af_assign_gen(&mut temp as MutAfArray
210+
, lhs.get() as AfArray
211+
, ndims.get().as_ptr() as DimT
212+
, indices.as_ptr() as *const IndexT
213+
, rhs.get() as AfArray);
214+
match err_val {
215+
0 => Ok(Array::from(temp)),
216+
_ => Err(AfError::from(err_val)),
157217
}
158218
}
159219
}

0 commit comments

Comments
 (0)