Fixed compilation errors on Windows

libraries/hilbert/include/hilbert.h

-/* C header file for Hilbert curve functions */
-#if !defined(_hilbert_h_)
-#define _hilbert_h_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef _MSC_VER
-/* define the bitmask_t type as an integer of sufficient size */
-typedef unsigned long long bitmask_t;
-/* define the halfmask_t type as an integer of 1/2 the size of bitmask_t */
-typedef unsigned int halfmask_t;
-#else
-#include <stdint.h>
-/* define the bitmask_t type as an integer of sufficient size */
-typedef uint64_t bitmask_t;
-/* define the halfmask_t type as an integer of 1/2 the size of bitmask_t */
-typedef uint32_t halfmask_t;
-#endif
-
-/*****************************************************************
- * hilbert_i2c
- *
- * Convert an index into a Hilbert curve to a set of coordinates.
- * Inputs:
- *  nDims:      Number of coordinate axes.
- *  nBits:      Number of bits per axis.
- *  index:      The index, contains nDims*nBits bits (so nDims*nBits must be <= 8*sizeof(bitmask_t)).
- * Outputs:
- *  coord:      The list of nDims coordinates, each with nBits bits.
- * Assumptions:
- *      nDims*nBits <= (sizeof index) * (bits_per_byte)
- */
-
-void hilbert_i2c(unsigned nDims, unsigned nBits, bitmask_t index, bitmask_t coord[]);
-
-/*****************************************************************
- * hilbert_c2i
- *
- * Convert coordinates of a point on a Hilbert curve to its index.
- * Inputs:
- *  nDims:      Number of coordinates.
- *  nBits:      Number of bits/coordinate.
- *  coord:      Array of n nBits-bit coordinates.
- * Outputs:
- *  index:      Output index value.  nDims*nBits bits.
- * Assumptions:
- *      nDims*nBits <= (sizeof bitmask_t) * (bits_per_byte)
- */
-
-bitmask_t hilbert_c2i(unsigned nDims, unsigned nBits, bitmask_t const coord[]);
-
-/*****************************************************************
- * hilbert_cmp, hilbert_ieee_cmp
- *
- * Determine which of two points lies further along the Hilbert curve
- * Inputs:
- *  nDims:      Number of coordinates.
- *  nBytes:     Number of bytes of storage/coordinate (hilbert_cmp only)
- *  nBits:      Number of bits/coordinate. (hilbert_cmp only)
- *  coord1:     Array of nDims nBytes-byte coordinates (or doubles for ieee_cmp).
- *  coord2:     Array of nDims nBytes-byte coordinates (or doubles for ieee_cmp).
- * Return value:
- *      -1, 0, or 1 according to whether
-           coord1<coord2, coord1==coord2, coord1>coord2
- * Assumptions:
- *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
- */
-
-int hilbert_cmp(unsigned nDims, unsigned nBytes, unsigned nBits, void const* coord1, void const* coord2);
-int hilbert_ieee_cmp(unsigned nDims, double const* coord1, double const* coord2);
-
-/*****************************************************************
- * hilbert_box_vtx
- *
- * Determine the first or last vertex of a box to lie on a Hilbert curve
- * Inputs:
- *  nDims:      Number of coordinates.
- *  nBytes:     Number of bytes/coordinate.
- *  nBits:      Number of bits/coordinate. (hilbert_cmp only)
- *  findMin:    Is it the least vertex sought?
- *  coord1:     Array of nDims nBytes-byte coordinates - one corner of box
- *  coord2:     Array of nDims nBytes-byte coordinates - opposite corner
- * Output:
- *      c1 and c2 modified to refer to selected corner
- *      value returned is log2 of size of largest power-of-two-aligned box that
- *      contains the selected corner and no other corners
- * Assumptions:
- *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
- */
-unsigned
-hilbert_box_vtx(unsigned nDims, unsigned nBytes, unsigned nBits,
-		int findMin, void* c1, void* c2);
-unsigned
-hilbert_ieee_box_vtx(unsigned nDims,
-		     int findMin, double* c1, double* c2);
-
-/*****************************************************************
- * hilbert_box_pt
- *
- * Determine the first or last point of a box to lie on a Hilbert curve
- * Inputs:
- *  nDims:      Number of coordinates.
- *  nBytes:     Number of bytes/coordinate.
- *  nBits:      Number of bits/coordinate.
- *  findMin:    Is it the least vertex sought?
- *  coord1:     Array of nDims nBytes-byte coordinates - one corner of box
- *  coord2:     Array of nDims nBytes-byte coordinates - opposite corner
- * Output:
- *      c1 and c2 modified to refer to least point
- * Assumptions:
- *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
- */
-unsigned
-hilbert_box_pt(unsigned nDims, unsigned nBytes, unsigned nBits,
-	       int findMin, void* coord1, void* coord2);
-unsigned
-hilbert_ieee_box_pt(unsigned nDims,
-		    int findMin, double* c1, double* c2);
-
-/*****************************************************************
- * hilbert_nextinbox
- *
- * Determine the first point of a box after a given point to lie on a Hilbert curve
- * Inputs:
- *  nDims:      Number of coordinates.
- *  nBytes:     Number of bytes/coordinate.
- *  nBits:      Number of bits/coordinate.
- *  findPrev:   Is the previous point sought?
- *  coord1:     Array of nDims nBytes-byte coordinates - one corner of box
- *  coord2:     Array of nDims nBytes-byte coordinates - opposite corner
- *  point:      Array of nDims nBytes-byte coordinates - lower bound on point returned
- *
- * Output:
-      if returns 1:
- *      c1 and c2 modified to refer to least point after "point" in box
-      else returns 0:
-        arguments unchanged; "point" is beyond the last point of the box
- * Assumptions:
- *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
- */
-int
-hilbert_nextinbox(unsigned nDims, unsigned nBytes, unsigned nBits,
-		  int findPrev, void* coord1, void* coord2,
-		  void const* point);
-
-/*****************************************************************
- * hilbert_incr
- *
- * Advance from one point to its successor on a Hilbert curve
- * Inputs:
- *  nDims:      Number of coordinates.
- *  nBits:      Number of bits/coordinate.
- *  coord:      Array of nDims nBits-bit coordinates.
- * Output:
- *  coord:      Next point on Hilbert curve
- * Assumptions:
- *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
- */
-
-void
-hilbert_incr(unsigned nDims, unsigned nBits, bitmask_t coord[]);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _hilbert_h_ */
+/* C header file for Hilbert curve functions */
+#if !defined(_hilbert_h_)
+#define _hilbert_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _MSC_VER
+/* define the bitmask_t type as an integer of sufficient size */
+typedef unsigned long long bitmask_t;
+/* define the halfmask_t type as an integer of 1/2 the size of bitmask_t */
+typedef unsigned int halfmask_t;
+#if defined(OPENMM_BUILDING_SHARED_LIBRARY)
+    #define WINDOWS_EXPORT __declspec(dllexport)
+#endif
+#else
+#include <stdint.h>
+/* define the bitmask_t type as an integer of sufficient size */
+typedef uint64_t bitmask_t;
+/* define the halfmask_t type as an integer of 1/2 the size of bitmask_t */
+typedef uint32_t halfmask_t;
+#define WINDOWS_EXPORT
+#endif
+
+/*****************************************************************
+ * hilbert_i2c
+ *
+ * Convert an index into a Hilbert curve to a set of coordinates.
+ * Inputs:
+ *  nDims:      Number of coordinate axes.
+ *  nBits:      Number of bits per axis.
+ *  index:      The index, contains nDims*nBits bits (so nDims*nBits must be <= 8*sizeof(bitmask_t)).
+ * Outputs:
+ *  coord:      The list of nDims coordinates, each with nBits bits.
+ * Assumptions:
+ *      nDims*nBits <= (sizeof index) * (bits_per_byte)
+ */
+
+void WINDOWS_EXPORT hilbert_i2c(unsigned nDims, unsigned nBits, bitmask_t index, bitmask_t coord[]);
+
+/*****************************************************************
+ * hilbert_c2i
+ *
+ * Convert coordinates of a point on a Hilbert curve to its index.
+ * Inputs:
+ *  nDims:      Number of coordinates.
+ *  nBits:      Number of bits/coordinate.
+ *  coord:      Array of n nBits-bit coordinates.
+ * Outputs:
+ *  index:      Output index value.  nDims*nBits bits.
+ * Assumptions:
+ *      nDims*nBits <= (sizeof bitmask_t) * (bits_per_byte)
+ */
+
+bitmask_t WINDOWS_EXPORT hilbert_c2i(unsigned nDims, unsigned nBits, bitmask_t const coord[]);
+
+/*****************************************************************
+ * hilbert_cmp, hilbert_ieee_cmp
+ *
+ * Determine which of two points lies further along the Hilbert curve
+ * Inputs:
+ *  nDims:      Number of coordinates.
+ *  nBytes:     Number of bytes of storage/coordinate (hilbert_cmp only)
+ *  nBits:      Number of bits/coordinate. (hilbert_cmp only)
+ *  coord1:     Array of nDims nBytes-byte coordinates (or doubles for ieee_cmp).
+ *  coord2:     Array of nDims nBytes-byte coordinates (or doubles for ieee_cmp).
+ * Return value:
+ *      -1, 0, or 1 according to whether
+           coord1<coord2, coord1==coord2, coord1>coord2
+ * Assumptions:
+ *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
+ */
+
+int WINDOWS_EXPORT hilbert_cmp(unsigned nDims, unsigned nBytes, unsigned nBits, void const* coord1, void const* coord2);
+int WINDOWS_EXPORT hilbert_ieee_cmp(unsigned nDims, double const* coord1, double const* coord2);
+
+/*****************************************************************
+ * hilbert_box_vtx
+ *
+ * Determine the first or last vertex of a box to lie on a Hilbert curve
+ * Inputs:
+ *  nDims:      Number of coordinates.
+ *  nBytes:     Number of bytes/coordinate.
+ *  nBits:      Number of bits/coordinate. (hilbert_cmp only)
+ *  findMin:    Is it the least vertex sought?
+ *  coord1:     Array of nDims nBytes-byte coordinates - one corner of box
+ *  coord2:     Array of nDims nBytes-byte coordinates - opposite corner
+ * Output:
+ *      c1 and c2 modified to refer to selected corner
+ *      value returned is log2 of size of largest power-of-two-aligned box that
+ *      contains the selected corner and no other corners
+ * Assumptions:
+ *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
+ */
+unsigned WINDOWS_EXPORT
+hilbert_box_vtx(unsigned nDims, unsigned nBytes, unsigned nBits,
+		int findMin, void* c1, void* c2);
+unsigned WINDOWS_EXPORT
+hilbert_ieee_box_vtx(unsigned nDims,
+		     int findMin, double* c1, double* c2);
+
+/*****************************************************************
+ * hilbert_box_pt
+ *
+ * Determine the first or last point of a box to lie on a Hilbert curve
+ * Inputs:
+ *  nDims:      Number of coordinates.
+ *  nBytes:     Number of bytes/coordinate.
+ *  nBits:      Number of bits/coordinate.
+ *  findMin:    Is it the least vertex sought?
+ *  coord1:     Array of nDims nBytes-byte coordinates - one corner of box
+ *  coord2:     Array of nDims nBytes-byte coordinates - opposite corner
+ * Output:
+ *      c1 and c2 modified to refer to least point
+ * Assumptions:
+ *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
+ */
+unsigned WINDOWS_EXPORT
+hilbert_box_pt(unsigned nDims, unsigned nBytes, unsigned nBits,
+	       int findMin, void* coord1, void* coord2);
+unsigned WINDOWS_EXPORT
+hilbert_ieee_box_pt(unsigned nDims,
+		    int findMin, double* c1, double* c2);
+
+/*****************************************************************
+ * hilbert_nextinbox
+ *
+ * Determine the first point of a box after a given point to lie on a Hilbert curve
+ * Inputs:
+ *  nDims:      Number of coordinates.
+ *  nBytes:     Number of bytes/coordinate.
+ *  nBits:      Number of bits/coordinate.
+ *  findPrev:   Is the previous point sought?
+ *  coord1:     Array of nDims nBytes-byte coordinates - one corner of box
+ *  coord2:     Array of nDims nBytes-byte coordinates - opposite corner
+ *  point:      Array of nDims nBytes-byte coordinates - lower bound on point returned
+ *
+ * Output:
+      if returns 1:
+ *      c1 and c2 modified to refer to least point after "point" in box
+      else returns 0:
+        arguments unchanged; "point" is beyond the last point of the box
+ * Assumptions:
+ *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
+ */
+int WINDOWS_EXPORT
+hilbert_nextinbox(unsigned nDims, unsigned nBytes, unsigned nBits,
+		  int findPrev, void* coord1, void* coord2,
+		  void const* point);
+
+/*****************************************************************
+ * hilbert_incr
+ *
+ * Advance from one point to its successor on a Hilbert curve
+ * Inputs:
+ *  nDims:      Number of coordinates.
+ *  nBits:      Number of bits/coordinate.
+ *  coord:      Array of nDims nBits-bit coordinates.
+ * Output:
+ *  coord:      Next point on Hilbert curve
+ * Assumptions:
+ *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
+ */
+
+void WINDOWS_EXPORT
+hilbert_incr(unsigned nDims, unsigned nBits, bitmask_t coord[]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _hilbert_h_ */

libraries/hilbert/src/hilbert.cpp

@@ -135,7 +135,7 @@ bitTranspose(unsigned nDims, unsigned nBits, bitmask_t inCoords)
  * Assumptions:
  *      nDims*nBits <= (sizeof index) * (bits_per_byte)
  */
-void
+void WINDOWS_EXPORT
 hilbert_i2c(unsigned nDims, unsigned nBits, bitmask_t index, bitmask_t coord[])
 {
   if (nDims > 1)
@@ -193,7 +193,7 @@ hilbert_i2c(unsigned nDims, unsigned nBits, bitmask_t index, bitmask_t coord[])
  * Assumptions:
  *      nDims*nBits <= (sizeof bitmask_t) * (bits_per_byte)
  */
-bitmask_t
+bitmask_t WINDOWS_EXPORT
 hilbert_c2i(unsigned nDims, unsigned nBits, bitmask_t const coord[])
 {
   if (nDims > 1)
@@ -562,7 +562,7 @@ hilbert_cmp_work(unsigned nDims, unsigned nBytes, unsigned nBits,
   return 0;
 }
 
-int
+int WINDOWS_EXPORT
 hilbert_cmp(unsigned nDims, unsigned nBytes, unsigned nBits,
 	    void const* c1, void const* c2)
 {
@@ -573,7 +573,7 @@ hilbert_cmp(unsigned nDims, unsigned nBytes, unsigned nBits,
 			  0, bits, bits, getIntBits);
 }
 
-int
+int WINDOWS_EXPORT
 hilbert_ieee_cmp(unsigned nDims, double const* c1, double const* c2)
 {
   unsigned rotation, max;
@@ -673,7 +673,7 @@ hilbert_box_vtx_work(unsigned nDims, unsigned nBytes, unsigned nBits,
   return y;
 }
 
-unsigned
+unsigned WINDOWS_EXPORT
 hilbert_box_vtx(unsigned nDims, unsigned nBytes, unsigned nBits,
 		int findMin, void* c1, void* c2)
 {
@@ -684,7 +684,7 @@ hilbert_box_vtx(unsigned nDims, unsigned nBytes, unsigned nBits,
 			      0, bits, bits, getIntBits);
 }
 
-unsigned
+unsigned WINDOWS_EXPORT
 hilbert_ieee_box_vtx(unsigned nDims,
 		     int findMin, double* c1, double* c2)
 {
@@ -722,7 +722,7 @@ hilbert_ieee_box_vtx(unsigned nDims,
  * Assumptions:
  *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
  */
-unsigned
+unsigned WINDOWS_EXPORT
 hilbert_box_pt_work(unsigned nDims, unsigned nBytes, unsigned nBits,
 		    int findMin,
 		    unsigned max, unsigned y,
@@ -783,7 +783,7 @@ hilbert_box_pt_work(unsigned nDims, unsigned nBytes, unsigned nBits,
   return smearSum;
 }
 
-unsigned
+unsigned WINDOWS_EXPORT
 hilbert_box_pt(unsigned nDims, unsigned nBytes, unsigned nBits,
 		int findMin, void* c1, void* c2)
 {
@@ -795,7 +795,7 @@ hilbert_box_pt(unsigned nDims, unsigned nBytes, unsigned nBits,
 			     getIntBits, propogateIntBits);
 }
 
-unsigned
+unsigned WINDOWS_EXPORT
 hilbert_ieee_box_pt(unsigned nDims,
 		    int findMin, double* c1, double* c2)
 {
@@ -851,7 +851,7 @@ hilbert_ieee_box_pt(unsigned nDims,
  * Assumptions:
  *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
  */
-int
+int WINDOWS_EXPORT
 hilbert_nextinbox(unsigned nDims, unsigned nBytes, unsigned nBits,
 		  int findPrev, void* c1V, void* c2V, void const* ptV)
 {
@@ -1045,7 +1045,7 @@ hilbert_nextinbox(unsigned nDims, unsigned nBytes, unsigned nBits,
  *      nBits <= (sizeof bitmask_t) * (bits_per_byte)
  */
 
-void
+void WINDOWS_EXPORT
 hilbert_incr(unsigned nDims, unsigned nBits, bitmask_t coord[])
 {
   bitmask_t const one = 1;

platforms/opencl/tests/TestOpenCLCheckpoints.cpp

@@ -63,7 +63,7 @@ void compareStates(State& s1, State& s2) {
         ASSERT_EQUAL_VEC(b1, b2, TOL);
         ASSERT_EQUAL_VEC(c1, c2, TOL);
         for (map<string, double>::const_iterator iter = s1.getParameters().begin(); iter != s1.getParameters().end(); ++iter)
-            ASSERT_EQUAL(iter->second, s2.getParameters().at(iter->first));
+            ASSERT_EQUAL(iter->second, (*s2.getParameters().find(iter->first)).second);
     }
 }
 

platforms/reference/tests/TestReferenceCheckpoints.cpp

@@ -63,7 +63,7 @@ void compareStates(State& s1, State& s2) {
         ASSERT_EQUAL_VEC(b1, b2, TOL);
         ASSERT_EQUAL_VEC(c1, c2, TOL);
         for (map<string, double>::const_iterator iter = s1.getParameters().begin(); iter != s1.getParameters().end(); ++iter)
-            ASSERT_EQUAL(iter->second, s2.getParameters().at(iter->first));
+            ASSERT_EQUAL(iter->second, (*s2.getParameters().find(iter->first)).second);
     }
 }