pyfmtools 5.2__tar.gz → 5.3__tar.gz

{pyfmtools-5.2/src/pyfmtools.egg-info → pyfmtools-5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyfmtools
-Version: 5.2
+Version: 5.3
 Summary: Library for handling and fitting fuzzy measures
 Home-page: 
 Author: Gleb Beliakov, Norbert Henseler

{pyfmtools-5.2 → pyfmtools-5.3}/setup.py

@@ -10,7 +10,7 @@ with open("README.md", "r") as fh:
 
 setup( 
     name="pyfmtools",
-    version="5.2",
+    version="5.3",
     description="Library for handling and fitting fuzzy measures",
     long_description=open('README.md').read(),
     long_description_content_type="text/markdown",

{pyfmtools-5.2 → pyfmtools-5.3}/src/buildPyfmtools.py

@@ -147,6 +147,8 @@ ffibuilder.cdef(r"""
  int py_generate_fm_kinteractivedualconvex(int num, int n, int kint, int markov, int option, double step,  double * vv, struct fm_env* env, void* extrachecks);
  int py_generate_fm_kinteractivedualconcave(int num, int n, int kint, int markov, int option, double step,  double * vv, struct fm_env* env, void* extrachecks);
  int py_generate_fm_2additive_randomwalk2(int num, int n, int markov, int option, double step,  double * vv, void* extrachecks);
+ int py_generate_fm_minimals_le(int num, int n, int markov, double ratio, int_64* vv, struct fm_env* env);
+ int py_generate_fm_minimals(int num, int n, int markov, double ratio, double* vv, struct fm_env* env);
     """, override=True)
 
 pyfmtools_src=['src/colamd.c','src/lp_lib.c','src/lp_params.c','src/lp_simplex.c','src/lusolio.c','src/commonlib.c','src/lp_LUSOL.c','src/lp_presolve.c','src/lpslink56.c','src/mmio.c',

{pyfmtools-5.2 → pyfmtools-5.3}/src/fmrandom.h

@@ -181,3 +181,6 @@ LIBDLL_API  int CheckMonMob2additive2(double* Mob, int n, int length, double* te
 
 LIBDLL_API void ConvertCoMob2Kinter(double* mu, double* Mob, int n, int_64 m, int kadd, int len, int fullmu);
 LIBDLL_API double ChoquetCoMobKInter(double* x, double* Mob, int n, int_64 m, int kadd, int length);
+
+LIBDLL_API int generate_fm_minimals(int_64 num, int n, int ratio, int markov, double* vv);
+LIBDLL_API int generate_fm_minimals_le(int_64 num, int n, int ratio, int markov, int_64* vv);

{pyfmtools-5.2 → pyfmtools-5.3}/src/fmrandomsort.inc

@@ -1229,11 +1229,11 @@ LIBDLL_API int generate_fm_belief(int_64 num, int n, int kadd, int_64* length,
 
 	vector<double> v1(*length);
 	for (int_64 k = 0; k < num; k++) {
-		GenerateBeliefMob(n, *length, v1); // in Mobius! with no 0
+		GenerateBeliefMob(n, *length-1, v1); // in Mobius! with no 0
 		
 		vv[0+ (*length)*k] = 0;
 
-		for (int i = 0; i < *length; i++)
+		for (int i = 0; i < *length-1; i++)
 			vv[i + 1 + (*length) * k] = v1[i]; // last one?
 	}
 	return 1;
@@ -1942,3 +1942,212 @@ LIBDLL_API int generate_fm_2additive_randomwalk2(int_64 num, int n, int markov,
 }
 
 
+
+
+// version 5.3
+
+uniform_real_distribution<double> uni0(0.0, 1.0);
+double randone() { return uni0(rng); }
+
+void DoMarkovChain0(vector<int_64>& v, int k)
+{
+#ifndef NO_R
+	unif_R_class<int> uni(3, (int)v.size() - 2);
+#else	
+	uniform_int_distribution<int> uni(3, (int)v.size() - 2); // guaranteed unbiased
+#endif
+	for (int j = 0; j < k; j++)
+	{
+		{
+			int pos = uni(rng);
+			if (!IsSubset(v[pos + 1], v[pos]))  //was preceedsaP(v[pos] , v[pos+1], r)
+			{
+				std::swap(v[pos], v[pos + 1]);
+			}
+		}
+	}
+}
+void Balanced_LE(int_64 num, int n, int_64 m, int markov, int_64* LE)
+{
+	// random shuffles for each cardinality
+	vector<int> perm;
+	vector<int_64> LEtemp(m);
+
+	for (int_64 k = 0; k < num; k++) {
+		for (int_64 ii = 0; ii < m; ++ii) LEtemp[ii] = card2bit[ii]; // do not place outside loop, Markov scrambles everything
+
+		for (int i = 1; i < n; i++) {
+			std::shuffle(LEtemp.begin() + cardpos[i - 1], LEtemp.begin() + cardpos[i], rng);
+		}
+
+		DoMarkovChain0(LEtemp, markov);
+
+		for (int_64 ii = 0; ii < m; ii++)  LE[k * m + ii] = LEtemp[ii];
+
+	}
+}
+
+
+
+void PutIntoMinimals(vector<int_64>& minimals, vector<int_64>& freespaces, int_64 C, int pos, int& first)
+{
+	if (first) { minimals[pos] = C; first = 0; }
+	else if (freespaces.size() > 0) {
+		minimals[freespaces.back()] = C; freespaces.pop_back();
+	}
+	else minimals.push_back(C); // no free spots left in the existing array
+}
+
+
+void Minimals_fast(int_64 num, int n, int_64 m, int_64* LE, int* weights)
+{
+	// just generate LEs, make FM outside
+
+	vector<int_64> pool(m);
+	vector<int_64> minimals;
+	vector<int_64> freespaces;
+	vector<int_64> current(m);
+
+	int maxweight = 1;
+	if (weights != NULL) for (int i = 0; i < n; i++) if (maxweight < weights[i]) maxweight = weights[i];
+
+	for (int_64 Num = 0; Num < num; Num++) {
+		minimals.clear();
+		freespaces.clear();
+		iota(pool.begin(), pool.end(), 0);
+
+		// start
+		current[0] = 0;
+		current[1] = 1; current[2] = 2;
+		minimals.push_back(3); minimals.push_back(4); // always starting point
+		for (int_64 B = 1; B <= 2; B++)
+			for (int i = 0; i < n; i++) {
+				int_64 C = B;  AddToSet(&C, i);
+				if (B != C && pool[C] != 0) { // already added or B==C (means i was in B already)
+					RemoveFromSet(&(pool[C]), i);  // i indicate a predecessor of C
+				}
+			}
+
+		if (weights != NULL); // dependent on cardinalities
+	   //
+		int_64 pos, k = 3;
+		// main loop
+		while (k < m - 1) { // ensure that minimals is not empty
+			// select random minimal
+		repeat0:
+			pos = randone() * minimals.size();
+			if (pos >= minimals.size()) pos--;
+
+			int_64 B = minimals[pos];
+			//			
+						// here we ensure that B is not empty (when a minimal was removed, its space could be left empty), we simply take the next
+		repeat:
+			while (B == 0 && pos < minimals.size()) {
+				B = minimals[pos]; if (B == 0) pos++;
+			}
+			if (B == 0) // no luck finding a valid minimal
+			{
+				pos = 0; B = minimals[pos]; goto repeat;
+			}
+
+
+			// process weights
+			if (weights != NULL)
+				if (randone() * maxweight > weights[card[B]])// discard
+					goto repeat0;
+
+			minimals[pos] = 0;
+			int first = 1;
+			current[k] = B;  k++;
+
+			for (int i = 0; i < n; i++) {
+				// check successrs
+				int_64 C = B;  AddToSet(&C, i);
+				if (B != C && pool[C] != 0) { // already added or B==C (means i was in B already)
+					RemoveFromSet(&(pool[C]), i);  // i indicate a predecessor of C
+
+					if (pool[C] == 0) {// can be added to minimals
+						PutIntoMinimals(minimals, freespaces, C, pos, first);
+						pool[C] = 0xFFFFFFFFFFFFFFFF; // so it is not added to minimals again
+						// add weight
+
+					}// pool==0
+				}// decrease pool[C]
+			} // for i
+			if (bit2card[B] < n) {// singleton, add next singleton
+				PutIntoMinimals(minimals, freespaces, card2bit[bit2card[B] + 1], pos, first);
+				//pool[C] = 0xFFFFFFFFFFFFFFFF; // so it is not added to minimals again// no need, singletons are increasing
+			}
+			if (first) // none replaced pos
+				freespaces.push_back(pos);
+		} // while
+
+		current[m - 1] = m - 1;
+		memcpy(&(LE[Num * m]), current.data(), m * sizeof(int_64));
+	}
+
+}
+
+void Minimals_fastreshuffle(int_64 num, int n, int_64 m, int markov, int_64* LE, int* weights)
+{
+	Minimals_fast(num, n, m, LE, weights);
+
+	vector<int> perm;
+	for (int ii = 0; ii < n; ++ii) perm.push_back(ii);
+	vector<int_64> cardbitswapped;
+	for (int_64 ii = 0; ii < m; ++ii) cardbitswapped.push_back(ii);
+	vector<int_64> LEtemp(m);
+
+	for (int_64 i = 0; i < num; i++)
+	{
+		std::shuffle(perm.begin(), perm.end(), rng);
+
+		for (int_64 ii = 0; ii < m; ++ii) cardbitswapped[ii] = swapbits(ii, perm, n); // initialise
+		memcpy(LEtemp.data(), &(LE[i * m]), m * sizeof(int_64));
+		DoMarkovChain0(LEtemp, markov);
+
+		for (int_64 ii = 0; ii < m; ii++)  LE[i * m + ii] = cardbitswapped[LEtemp[ii]];
+	}
+}
+
+LIBDLL_API int generate_fm_minimals_le(int_64 num, int n, int ratio, int markov, int_64* vv)
+{
+	int_64 m = 1ULL << n;
+
+	int_64 num1 = num * ratio;
+	int_64 num2 = num - num1;
+
+	Minimals_fastreshuffle(num1, n, m, markov, vv, NULL);
+	Balanced_LE(num2, n, m, markov,  &(vv[m * num1]));
+	return 1;
+}
+
+void random_coefficientsup(int n, vector<double>& c)
+//Generates a vector of n random real numbers 0=X1<=X2<=...<=Xn=1
+{
+#ifndef NO_R
+	unif_R_class<double> dis(0.0, 1.0);
+#else
+	uniform_real_distribution<> dis(0.0, 1.0);
+#endif
+	for (int i = 0; i < n; i++)
+		c[i] = (double)dis(rng);
+
+	sort(c.begin(), c.end(), less<double>());
+	c[0] = 0; c[n - 1] = 1;
+}
+
+LIBDLL_API int generate_fm_minimals(int_64 num, int n, int ratio, int markov, double* vv)
+{
+	int_64 m = 1ULL << n;
+	vector<int_64> LE(m*num);
+	vector<myfloat> v(m);
+	generate_fm_minimals_le(num, n, ratio, markov, LE.data());
+
+	for (int_64 k = 0; k < num; k++) {
+		random_coefficientsup(m, v);
+		for (int_64 i = 0; i < m; i++) vv[m * k + LE[m * k + i]] = v[  i ];
+	}
+
+	return 1;
+}

{pyfmtools-5.2 → pyfmtools-5.3/src/pyfmtools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyfmtools
-Version: 5.2
+Version: 5.3
 Summary: Library for handling and fitting fuzzy measures
 Home-page: 
 Author: Gleb Beliakov, Norbert Henseler

{pyfmtools-5.2 → pyfmtools-5.3}/src/pyfmtools.py

@@ -197,6 +197,12 @@ def create_float_zeros_as_CFFI_double( n):
     px = ffi.cast( "double *", x.ctypes.data)
     return x, px
 
+    # use numpy to create an float array with n zeros and cast to CFFI 
+def create_zeros_as_CFFI_uint64( n):
+    x = np.zeros( int(n), dtype=np.uint64)
+    px = ffi.cast( "unsigned long long int *", x.ctypes.data)
+    return x, px
+
 
 # version of the function using np.ascontiguousarray() 
 def convert_py_float_to_cffi_cont( x):
@@ -1532,5 +1538,26 @@ def FuzzyMeasureFit2Additive(datanum, n, options, indexlow, indexhihg, option1,
     return pout_vnp
 
 
+def generate_fm_minimals( num, n , markov, ratio,  env):
+    trace( "int generate_fm_minimals( num, n , markov, ratio,  env)")
+    try:
+        length = pow(2,n)
+        pout_vvnp, pout_vv = create_float_zeros_as_CFFI_double( num * length)
 
+        fm.py_generate_fm_minimals(num, n, markov, ratio,  pout_vv, env)
+        return  pout_vvnp
+        
+    except ValueError:
+        raise
 
+def generate_fm_minimals_le( num, n , markov, ratio,  env):
+    trace( "int generate_fm_minimals_le( num, n , markov, ratio,  env)")
+    try:
+        length = pow(2,n)
+        pout_vvnp, pout_vv = create_zeros_as_CFFI_uint64( num * length)
+        # these are int_64
+        fm.py_generate_fm_minimals_le(num, n, markov, ratio,  pout_vv, env)
+        return  pout_vvnp
+        
+    except ValueError:
+        raise

{pyfmtools-5.2 → pyfmtools-5.3}/src/wrapperpy.cpp

@@ -158,6 +158,11 @@ void releaseVectorWrapper( std::vector<T,  std::allocator<T> > volatile &targetV
 #endif
 
 #else
+	
+#if ( _MSC_VER>1)
+#include <crtversion.h>
+#endif
+#if (_VC_CRT_MAJOR_VERSION<13)
 
 template <class T>
 void wrapArrayInVector( T *sourceArray, size_t arraySize, std::vector<T,  std::allocator<T> > volatile &targetVector ) {
@@ -173,6 +178,23 @@ void releaseVectorWrapper( std::vector<T,  std::allocator<T> > volatile &targetV
         (typename std::_Vector_base<T, std::allocator<T> >::_Vector_impl *)((void *) &targetVector);
   vectorPtr->_M_start = vectorPtr->_M_finish = vectorPtr->_M_end_of_storage = NULL;
 }
+#else
+	// just copy
+template <class T>
+void wrapArrayInVector( T *sourceArray, size_t arraySize, std::vector<T,  std::allocator<T> > volatile &targetVector ) {
+  typename std::vector<T, std::allocator<T> > *vectorPtr =
+    (typename std::vector<T, std::allocator<T> > *)((void *) &targetVector);
+	
+	vectorPtr->assign(sourceArray, sourceArray+ arraySize);
+}
+template <class T>
+void releaseVectorWrapper( std::vector<T,  std::allocator<T> > volatile &targetVector )
+{
+	// do nothing 
+	return ;
+}
+#endif
+
 #endif
 
 #endif
@@ -2194,6 +2216,32 @@ int* Rcard, int* Rcardpos, double* Rbit2card, double* Rcard2bit, double* Rfactor
 	 int_64 num1=*num;		
 	 *out= generate_fm_balanced(num1, *n,  vv);
  }
+ void generate_fm_minimals_Call(int* num, int* n, int* markov, double* ratio, double* vv, int* out,
+	 int* m, int* Rcard, int* Rcardpos, double* Rbit2card, double* Rcard2bit, double* Rfactorials)
+ {
+	 //int_64 mm = (int_64)*m;
+	 card = Rcard;
+	 cardpos = Rcardpos;
+	 bit2card = (int_64*)Rbit2card;
+	 card2bit = (int_64*)Rcard2bit;
+	 m_factorials = Rfactorials;
+
+	 int_64 num1 = *num;
+	 *out = generate_fm_minimals(num1, *n, *ratio, *markov, vv);
+ }
+ void generate_fm_minimals_le_Call(int* num, int* n, int* markov, double* ratio, int_64* vv, int* out,
+	 int* m, int* Rcard, int* Rcardpos, double* Rbit2card, double* Rcard2bit, double* Rfactorials)
+ {
+	 //int_64 mm = (int_64)*m;
+	 card = Rcard;
+	 cardpos = Rcardpos;
+	 bit2card = (int_64*)Rbit2card;
+	 card2bit = (int_64*)Rcard2bit;
+	 m_factorials = Rfactorials;
+
+	 int_64 num1 = *num;
+	 *out = generate_fm_minimals_le(num1, *n, *ratio, *markov, vv);
+ }
 
 
 // 2 additive
@@ -2375,6 +2423,20 @@ LIBEXP int py_generate_fm_balanced(int num, int n,  double * vv, struct fm_env*
 	return out;
 }
 
+LIBEXP int py_generate_fm_minimals_le(int num, int n, int markov, double ratio, int_64* vv, struct fm_env* env)
+{
+	int out; //length, or not needed?
+	generate_fm_minimals_le_Call(&num, &n, &markov, &ratio, vv, &out, &(env->m), env->card, env->cardpos, env->bit2card, env->card2bit, env->factorials);
+	return out;
+}
+LIBEXP int py_generate_fm_minimals(int num, int n, int markov, double ratio, double* vv, struct fm_env* env)
+{
+	int out; //length, or not needed?
+	generate_fm_minimals_Call(&num, &n, &markov, &ratio, vv, &out, &(env->m), env->card, env->cardpos, env->bit2card, env->card2bit, env->factorials);
+	return out;
+}
+
+
 LIBEXP int py_generate_fm_2additive(int num, int n,  double * vv)
 {
 	int out; //length, or not needed?

{pyfmtools-5.2 → pyfmtools-5.3}/src/wrapperpy.h

@@ -396,6 +396,10 @@ LIBEXP int py_generate_fm_kinteractivedualconcave(int num, int n, int kint, int
 
 LIBEXP int py_generate_fm_2additive_randomwalk2(int num, int n, int markov, int option, double step,  double * vv, void* extrachecks);
 
+LIBEXP int py_generate_fm_minimals_le(int num, int n, int markov, double ratio, int_64* vv, struct fm_env* env);
+
+LIBEXP int py_generate_fm_minimals(int num, int n, int markov, double ratio, double* vv, struct fm_env* env);
+
 
 
 #ifdef __cplusplus

{pyfmtools-5.2 → pyfmtools-5.3}/tests/test_wrapper.py

@@ -1079,6 +1079,16 @@ check=fm.CheckMonotonicityMob(Mob, len, env)
 print(Mob)
 print(check)
 
+step=0.001
+Fn=None
+Option=0
+ret_code, v, len = fm.generate_fm_randomwalk(1, 3, 3, 1000, Option, step, env, Fn)
+print("Random walk")
+print(v)
+
+
+
+
 
 #fm.CheckConvexityMonMob(Mob, len, env)
 #env=fm.fm_init(3)
@@ -1113,7 +1123,7 @@ print(Mob)
 print(ret_code)
 print(len)
 
-
+fm.fm_free(env)
 
 
 #fm.ConvertCoMob2KinterCall(n, kadd, len, Mob, fullmu, env)
@@ -1178,3 +1188,24 @@ v = fm.FuzzyMeasureFit2Additive(num, 3, options, indexlow, indexhigh, option1, o
 print(v)
 
 fm.fm_free(env)
+
+
+n=4
+env=fm.fm_init(n)
+num=3
+v= fm.generate_fm_minimals(num, n, 100, 0.35, env)
+print(v)
+
+num=3
+le= fm.generate_fm_minimals_le(num, n, 100, 0.35, env)
+print(le)
+
+
+step=0.001
+Fn=None
+Option=0
+ret_code, v, len = fm.generate_fm_randomwalk(2, n, n, 1000, Option, step, env, Fn)
+print("Random walk")
+print(v)
+
+fm.fm_free(env)