Changeset 33662 for trunk/Ohana/src/opihi/lib.shell/VectorOps.c

Timestamp:

Apr 1, 2012, 3:24:39 PM (14 years ago)

Author:

eugene

Message:

support for parallel dvo in mextract, avextract, avmerge, gstar, gcat; remove some if-def-ed out code already moved to libdvo; list -vectors and -buffers options (store names of vectors and buffers in lists); list -copy give error if missing source; catlist, hosts & remote functions to support parallel dvos; skyregion -save option; new skycoverage modes (-min-ubercal; -min-dmag-sys; -min-mcal; -max-mcal); gstar output formatting cleanups; add more average info to gstar output; functions for spectral similarity analysis; coords returns nans for projections off the sphere; fix cumulative function; add name:type option to opihi/read function (eg read a:float 2 b:time 3 c:int 4); line -frac option; vtype function to get vector types; threshold function; write -fits option; code for unfinished mtype function (matching vtype)

File:

• trunk/Ohana/src/opihi/lib.shell/VectorOps.c (modified) (7 diffs)

trunk/Ohana/src/opihi/lib.shell/VectorOps.c

@@ -15 +15 @@
 
 // this function is NOT thread protected : it is only used in startup and/or shutdown
+void FreeVectorArray (Vector **vec, int Nvec) {
+
+  int i;
+
+  if (!vec) return;
+  for (i = 0; i < Nvec; i++) {
+    if (!vec[i]) continue;
+    if (vec[i]->elements.Int) {
+      free (vec[i]->elements.Int);
+    }
+    free (vec[i]);
+  }
+  free (vec);
+}
+
+// this function is NOT thread protected : it is only used in startup and/or shutdown
 void FreeVectors () {
-
-  int i;
-
-  for (i = 0; i < Nvectors; i++) {
-    if (vectors[i][0].elements.Int) {
-      free (vectors[i][0].elements.Int);
-    }
-    free (vectors[i]);
-  }
-  free (vectors);
+  FreeVectorArray (vectors, Nvectors);
 }
 
@@ -93 +100 @@
 }
   
+// Assign the given Vector to the internal array of vectors by name
+int AssignVector (Vector *vec, char *name, int mode, int verbose) {
+
+  int i;
+
+  if (name == NULL) goto error;
+  if (ISNUM(name[0])) goto error;
+  if (IsBuffer(name)) goto error;
+
+  for (i = 0; (i < Nvectors) && (strcmp(vectors[i][0].name, name)); i++);
+  /* is a new vector */
+  if (i == Nvectors) { 
+    if (mode == OLDVECTOR) goto error;
+    pthread_mutex_lock (&mutex);
+    Nvectors ++;
+    REALLOCATE (vectors, Vector *, Nvectors);
+    vectors[i] = vec;
+    pthread_mutex_unlock (&mutex);
+    return TRUE;
+  } 
+  /* is an old vector */
+  if (mode == NEWVECTOR) goto error;
+  if (vectors[i]) {
+    if (vectors[i][0].elements.Ptr) free (vectors[i][0].elements.Ptr);
+    free (vectors[i]);
+  }
+  vectors[i] = vec;
+  return TRUE;
+
+ error:
+  if (verbose) gprint (GP_ERR, "invalid vector %s\n", name);
+  return FALSE;
+}
+  
 /* delete by pointer */
 int DeleteVector (Vector *vec) {
@@ -148 +189 @@
   if (in[0].elements.Ptr) {
     if (in[0].type == OPIHI_FLT) {
-      ALLOCATE (out[0].elements.Flt, opihi_flt, out[0].Nelements);
+      ALLOCATE (out[0].elements.Flt, opihi_flt, MAX(1,out[0].Nelements));
       memcpy (out[0].elements.Flt, in[0].elements.Flt, out[0].Nelements*sizeof(opihi_flt));
       out[0].type = OPIHI_FLT;
     } else {
-      ALLOCATE (out[0].elements.Int, opihi_int, out[0].Nelements);
+      ALLOCATE (out[0].elements.Int, opihi_int, MAX(1,out[0].Nelements));
       memcpy (out[0].elements.Int, in[0].elements.Int, out[0].Nelements*sizeof(opihi_int));
       out[0].type = OPIHI_INT;
@@ -164 +205 @@
   out[0].Nelements = in[0].Nelements;
   if (type == OPIHI_FLT) {
-    ALLOCATE (out[0].elements.Flt, opihi_flt, out[0].Nelements);
+    ALLOCATE (out[0].elements.Flt, opihi_flt, MAX(1,out[0].Nelements));
     out[0].type = OPIHI_FLT;
   } else {
-    ALLOCATE (out[0].elements.Int, opihi_int, out[0].Nelements);
+    ALLOCATE (out[0].elements.Int, opihi_int, MAX(1,out[0].Nelements));
     out[0].type = OPIHI_INT;
   }
@@ -173 +214 @@
 }
 
-// ResetVector (vecx, OPIHI_FLT, MAX (Npts, 1));
 int ResetVector (Vector *vec, char type, int Nelements) {
 
-  vec[0].Nelements = Nelements;
+  // a vector can only have >= 0 elements
+  vec[0].Nelements = MAX(Nelements,0);
   if (type == OPIHI_FLT) {
     REALLOCATE (vec[0].elements.Flt, opihi_flt, MAX(1, Nelements));
@@ -190 +231 @@
 int SetVector (Vector *vec, char type, int Nelements) {
 
-  vec[0].Nelements = Nelements;
+  vec[0].Nelements = MAX(Nelements,0);
   if (type == OPIHI_FLT) {
-    ALLOCATE (vec[0].elements.Flt, opihi_flt, Nelements);
+    ALLOCATE (vec[0].elements.Flt, opihi_flt, MAX(1,Nelements));
     vec[0].type = OPIHI_FLT;
   } else {
-    ALLOCATE (vec[0].elements.Int, opihi_int, Nelements);
+    ALLOCATE (vec[0].elements.Int, opihi_int, MAX(1,Nelements));
     vec[0].type = OPIHI_INT;
   }
@@ -287 +328 @@
   return (TRUE);
 }
+
+int ListVectorsToList (char *name) {
+
+  int i;
+  char line[1024];
+
+  for (i = 0; i < Nvectors; i++) {
+    sprintf (line, "%s:%d", name, i);
+    set_str_variable (line, vectors[i][0].name);
+  }
+  sprintf (line, "%s:n", name);
+  set_int_variable (line, Nvectors);
+  return (Nvectors);
+}
+
+// Take two arrays of vectors and merge equal named vectors.
+// Output is a single array in (vec), with vectors lengths of len(vec) + len(invec)
+// For ease, require that the order of the names match & number of vectors match
+Vector **MergeVectors (Vector **vec, int *Nvec, Vector **invec, int Ninvec) {
+
+  int i, j;
+
+  if (vec == NULL) {
+    *Nvec = Ninvec;
+    return invec;
+  }
+
+  myAssert (*Nvec == Ninvec, "programming error (1) %d vs %d", *Nvec, Ninvec);
+
+  for (i = 0; i < Ninvec; i++) {
+    myAssert (!strcmp(vec[i]->name, invec[i]->name), "programming error (2) %s vs %s", vec[i]->name, invec[i]->name);
+    myAssert (vec[i]->type == invec[i]->type, "programming error (3), %d vs %d", vec[i]->type, invec[i]->type);
+
+    int N = vec[i]->Nelements;
+    if (vec[i]->type == OPIHI_FLT) {
+      REALLOCATE (vec[i]->elements.Flt, opihi_flt, vec[i]->Nelements + invec[i]->Nelements);
+      for (j = 0; j < invec[i]->Nelements; j++) {
+        vec[i]->elements.Flt[N+j] = invec[i]->elements.Flt[j];
+      }
+    } else {
+      REALLOCATE (vec[i]->elements.Int, opihi_int, vec[i]->Nelements + invec[i]->Nelements);
+      for (j = 0; j < invec[i]->Nelements; j++) {
+        vec[i]->elements.Int[N+j] = invec[i]->elements.Int[j];
+      }
+    }
+    vec[i]->Nelements += invec[i]->Nelements;
+  }
+  return vec;
+}
+
+// Take two arrays of vectors and merge equal named vectors, where the last vector
+// specifies the element in the output vector.  All input vectors must have a max sequence
+// value of Nelements.  Output is a single array in (vec), with vector lengths of
+// Nelements for ease, require that the order of the names match & number of vectors match
+Vector **MergeVectorsByIndex (Vector **vec, int *Nvec, Vector **invec, int Ninvec, int Nelements) {
+
+  int i, j;
+
+  // on first call, allocate a new vector, excluding the index
+  int newArray = FALSE;
+  if (vec == NULL) {
+    ALLOCATE (vec, Vector *, Ninvec - 1);
+    *Nvec = Ninvec - 1;
+    newArray = TRUE;
+  } 
+
+  myAssert (*Nvec == Ninvec - 1, "programming error (1)");
+
+  // find the index vector
+  int idx = Ninvec - 1;
+  myAssert (!strcmp(invec[idx]->name, "index"), "failed to find index vector");
   
+  for (i = 0; i < Ninvec - 1; i++) {
+    // on first call, create the output vector
+    if (newArray) {
+      vec[i] = InitVector();
+      strcpy (vec[i]->name, invec[i]->name);
+      ResetVector (vec[i], invec[i]->type, Nelements);
+      for (j = 0; j < Nelements; j++) {
+        if (vec[i][0].type == OPIHI_FLT) {
+          vec[i][0].elements.Flt[j] = NAN;
+        } else {
+          vec[i][0].elements.Int[j] = 0; // or NAN_INT?
+        }
+      }
+    }
+
+    myAssert (!strcmp(vec[i]->name, invec[i]->name), "programming error (2)");
+    myAssert (vec[i]->type == invec[i]->type, "programming error (2)");
+
+    // copy vector elements from input to output, matching location
+    if (vec[i]->type == OPIHI_FLT) {
+      for (j = 0; j < invec[i]->Nelements; j++) {
+        int seq = invec[idx]->elements.Int[j];
+        vec[i]->elements.Flt[seq] = invec[i]->elements.Flt[j];
+      }
+    } else {
+      for (j = 0; j < invec[i]->Nelements; j++) {
+        int seq = invec[idx]->elements.Int[j];
+        vec[i]->elements.Int[seq] = invec[i]->elements.Int[j];
+      }
+    }
+  }
+  return vec;
+}
+