public static void RowCopy <T>(Narray <T> values, int i, int j) { for (int k = 0; k < values.Dim(1); k++) { values[i, k] = values[j, k]; } }
public static void RowPermute <T>(Narray <T> data, Narray <int> permutation) { CHECK_ARG(data.Dim(0) == permutation.Length(), "data.Dim(0) == permutation.Length()"); Narray <bool> finished = new Narray <bool>(data.Dim(0)); finished.Fill(false); for (int start = 0; start < finished.Length(); start++) { if (finished[start]) { continue; } int index = start; Narray <T> value = new Narray <T>(); RowCopy(value, data, index); for ( ; ;) { int next = permutation[index]; if (next == start) { break; } RowCopy(data, index, next); index = next; CHECK_ARG(!finished[index], "!finished[index]"); finished[index] = true; index = next; } RowCopy(data, index, value); finished[index] = true; } }
public static int RowArgMin <T>(Narray <T> values, int i) { if (values.Dim(1) < 1) { return(-1); } int mj = 0; T mv = values[i, 0]; for (int j = 1; j < values.Dim(1); j++) { T value = values[i, j]; if (value.Equals(mv)) { continue; } if (Convert.ToDouble(value) > Convert.ToDouble(mv)) { continue; } mv = value; mj = j; } return(mj); }
public static void RowCopy <T>(Narray <T> a, Narray <T> b, int i) { a.Resize(b.Dim(1)); for (int k = 0; k < b.Dim(1); k++) { a[k] = b[i, k]; } }
public static void RowCopy <T>(Narray <T> a, int i, Narray <T> b) { CHECK_ARG(a.Dim(1) == b.Length(), "a.Dim(1) == b.Length()"); for (int k = 0; k < a.Dim(1); k++) { a[i, k] = b[k]; } }
public static void RowGet <T, S>(Narray <T> outv, Narray <S> data, int row) { outv.Resize(data.Dim(1)); for (int i = 0; i < outv.Length(); i++) { outv[i] = (T)Convert.ChangeType(data[row, i], typeof(T)); } }
/// <summary> /// Reverse an array /// </summary> public static void Reverse <T>(Narray <T> outa, Narray <T> ina) { outa.Clear(); for (int i = ina.Length() - 1; i >= 0; i--) { outa.Push(ina[i]); } }
/// <summary> /// Quicksort an array, generating a permutation of the indexes. /// </summary> public static void Quicksort <T>(Narray <int> outindex, Narray <T> values) { outindex.Resize(values.Length()); for (int i = 0; i < values.Length(); i++) { outindex[i] = i; } Quicksort(outindex, values, 0, outindex.Length()); }
/// <summary> /// Copy the elements of the source array into the destination array, /// resizing if necessary. /// </summary> public void Copy <S>(Narray <S> src) { this.Resize(src.Dim(0), src.Dim(1), src.Dim(2), src.Dim(3)); index_t n = this.Length1d(); for (index_t i = 0; i < n; i++) { this.UnsafePut1d(i, src.UnsafeAt1d(i)); } }
/// <summary> /// Swap the contents of the two arrays. /// </summary> public void Swap(Narray <T> src) { swap_ <T[]>(ref this.data, ref src.data); for (int i = 0; i < 5; i++) { swap_(ref this.dims[i], ref src.dims[i]); } swap_(ref this.total, ref src.total); swap_(ref this.allocated, ref src.allocated); }
public static int first_index_of <T>(Narray <T> a, T target) { for (int i = 0; i < a.Length(); i++) { if (a[i].Equals(target)) { return(i); } } return(-1); }
public static bool contains_only <T, U, V>(Narray <T> a, U value1, V value2) { for (int i = 0; i < a.Length1d(); i++) { if (!a.At1d(i).Equals(value1) && !a.At1d(i).Equals(value2)) { return(false); } } return(true); }
public static double Sum <T>(Narray <T> data) { double result = 0.0; int n = data.Length1d(); for (int i = 0; i < n; i++) { result += Convert.ToDouble(data.At1d(i)); } return(result); }
public static void RowPut <T, S>(Narray <T> data, int row, Narray <S> v) { if (!(v.Length() == data.Dim(1))) { throw new Exception("CHECK: v.Length() == data.Dim(1)"); } for (int i = 0; i < v.Length(); i++) { data[row, i] = (T)Convert.ChangeType(v[i], typeof(T)); } }
public static int first_index_of(Narray <int> a, int target) { for (int i = 0; i < a.Length(); i++) { if (a[i] == target) { return(i); } } return(-1); }
/// <summary> /// Take the data held by the src array and put it into the dest array. /// The src array is made empty in the proceess. This is an O(1) operation. /// </summary> public void Move(Narray <T> src) { this.data = src.data; for (int i = 0; i < 5; i++) { this.dims[i] = src.dims[i]; } this.total = src.total; this.allocated = src.allocated; src.Dealloc(); }
public void Append <S>(Narray <S> src) { check_rank1(); Reserve(src.Length()); for (index_t i = 0; i < src.Length(); i++) { var value = src.UnsafeAt1d(i); data[dims[0]] = (T)Convert.ChangeType(value, typeof(T)); dims[0] += 1; total = dims[0]; } }
/// <summary> /// Copy the elements of the source array into the destination array, /// resizing if necessary. /// </summary> public void Append(Narray <T> src) { check_rank1(); Reserve(src.Length()); for (index_t i = 0; i < src.Length(); i++) { //Push(src.unsafe_at1d(i)); data[dims[0]] = src.UnsafeAt1d(i); dims[0] += 1; total = dims[0]; } }
public static void Shuffle <T>(Narray <T> values) { Floatarray temp = new Floatarray(values.Length()); Intarray index = new Intarray(); for (int i = 0; i < temp.Length(); i++) { temp.UnsafePut1d(i, DRandomizer.Default.drand()); } Quicksort(index, temp); Permute(values, index); }
/// <summary> /// Original name: randomly_permute /// </summary> public static void RandomlyPermute <T>(Narray <T> v) { int n = v.Length(); for (int i = 0; i < n - 1; i++) { int target = DRandomizer.Default.nrand() % (n - i) + i; T temp = v[target]; v[target] = v[i]; v[i] = temp; } }
public static float Fractile(Narray <float> a, double f) { Floatarray temp = new Floatarray(); if (!(f >= 0 && f <= 1)) { throw new Exception("CHECK: f >= 0 && f <= 1"); } temp.Copy(a); temp.Reshape(temp.Length1d()); Quicksort(temp); return(temp[(int)(f * temp.Length())]); }
public StdInput(Narray <float> floatarray) { alloc_(floatarray.Dim(1), floatarray.Dim(0)); int yput; for (int y = 0; y < Height; y++) { yput = Height - y - 1; for (int x = 0; x < Width; x++) { Put(yput, x, Convert.ToByte(floatarray[x, y] * 255)); } } }
public StdInput(Narray <byte> bytearray) { alloc_(bytearray.Dim(1), bytearray.Dim(0)); int yput; for (int y = 0; y < Height; y++) { yput = Height - y - 1; for (int x = 0; x < Width; x++) { Put(yput, x, bytearray[x, y]); } } }
public static T Bat <T>(Narray <T> a, int i, int j, T value) { unchecked { if ((uint)(i) >= (uint)(a.Dim(0))) { return(value); } if ((uint)(j) >= (uint)(a.Dim(1))) { return(value); } } return(a.UnsafeAt(i, j)); }
/// <summary> /// Check whether two narrays have the same rank and sizes. /// </summary> public bool SameDims <S>(Narray <S> b) { if (this.Rank() != b.Rank()) { return(false); } for (int i = 0; i < this.Rank(); i++) { if (this.Dim(i) != b.Dim(i)) { return(false); } } return(true); }
public static void RowPush <T>(Narray <T> table, Narray <T> data) { if (table.Length1d() == 0) { table.Copy(data); table.Reshape(1, table.Length()); return; } CHECK_ARG(table.Dim(1) == data.Length(), "table.Dim(1) == data.Length()"); table.Reserve(table.Length1d() + data.Length()); table.SetDims(table.Dim(0) + 1, table.Dim(1), 0, 0); int irow = table.Dim(0) - 1; for (int k = 0; k < table.Dim(1); k++) { table[irow, k] = data.UnsafeAt1d(k); } }
/// <summary> /// Find unique elements. /// </summary> public static void Uniq <T>(Narray <T> values) { if (values.Length() == 0) { return; } Quicksort(values); int j = 1; for (int i = 1; i < values.Length(); i++) { if (values[i].Equals(values[j - 1])) { continue; } values[j++] = values[i]; } values.Truncate(j); }
public static float Median(Narray <int> a) { Narray <int> s = new Narray <int>(); s.Copy(a); s.Reshape(s.Length1d()); Quicksort(s); int n = s.Length(); if (n == 0) { return(0); } if ((n % 2) > 0) { return(s[n / 2]); } else { return((s[n / 2 - 1] + s[n / 2]) / 2.0f); } }
/// <summary> /// Permute the elements of an array given a permutation. /// </summary> public static void Permute <T>(Narray <T> data, Narray <int> permutation) { if (!data.SameDims(permutation)) { throw new Exception("CHECK_ARG: data.SameDims(permutation)"); } Narray <bool> finished = new Narray <bool>(data.Length()); finished.Fill(false); for (int start = 0; start < finished.Length(); start++) { if (finished[start]) { continue; } int index = start; T value = data[index]; for ( ; ;) { int next = permutation[index]; if (next == start) { break; } data[index] = data[next]; index = next; //CHECK_ARG(!finished[index] && "not a permutation"); if (finished[index]) { throw new Exception("CHECK_ARG: !finished[index]"); } finished[index] = true; index = next; } data[index] = value; finished[index] = true; } }
/// <summary> /// Check whether two narrays are equal (mostly for testing). /// </summary> public bool Equal(Narray <T> b) { if (this.Rank() != b.Rank()) { return(false); } for (int i = 0; i < this.Rank(); i++) { if (this.Dim(i) != b.Dim(i)) { return(false); } } index_t n = this.Length1d(); for (index_t i = 0; i < n; i++) { if (!this.UnsafeAt1d(i).Equals(b.UnsafeAt1d(i))) { return(false); } } return(true); }