pyfmtools 5.3.8__tar.gz → 5.4.0__tar.gz

{pyfmtools-5.3.8/src/pyfmtools.egg-info → pyfmtools-5.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pyfmtools
-Version: 5.3.8
+Version: 5.4.0
 Summary: Library for handling and fitting fuzzy measures
 Home-page: 
 Author: Gleb Beliakov, Norbert Henseler
@@ -8,6 +8,13 @@ Author-email: gleb.beliakov@deakin.edu.au, norbert.henseler@deakin.edu.au
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: cffi>=1.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 # Pyfmtools    
 Pyfmtools provides various tools for handling fuzzy measures, calculating various indices, Choquet and Sugeno integrals, as well as fitting fuzzy measures to empirical data. This package is designed for Python , but it also includes the C++ source files and a user manual.

{pyfmtools-5.3.8 → pyfmtools-5.4.0}/setup.py

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

{pyfmtools-5.3.8 → pyfmtools-5.4.0}/src/buildPyfmtools.py

@@ -19,7 +19,16 @@ ffibuilder.cdef(r"""
 	int xx[44];};
     double py_min_subset(double* x, int n, int_64 S);
     double py_max_subset(double* x, int n, int_64 S);
+     int py_IsSubset( int_64 A, int_64 B);
+	 int py_IsInSet( int_64 A, int B);
+	 int py_Setunion( int_64 A, int_64 B);
+	 int py_Setintersection( int_64 A, int_64 B);
+	 int py_Setdiff( int_64 A, int_64 B);
+	 int_64 py_AddToSet( int_64 A, int i);
+	 int_64 py_RemoveFromSet( int_64 A, int i);
+	 int py_Cardinality( int_64 A);
     void py_ConvertCard2Bit(double* dest, double* src,  struct fm_env* env);
+    void py_ConvertBit2Card(double* dest, double* src, struct fm_env* env);
     double py_min_subsetC(double* x, int n, int_64 S, struct fm_env* env);
     double py_max_subsetNegC(double* x, int n, int_64 S, struct fm_env* env);
     int py_SizeArraykinteractive(int n, int k, struct fm_env* env);
@@ -46,13 +55,14 @@ ffibuilder.cdef(r"""
     void py_FuzzyMeasureFitKtolerant(int datanum, int additive, struct fm_env* env, double* v, double* dataset);
     void py_FuzzyMeasureFitLPKmaxitive(int datanum, int additive, struct fm_env* env, double* v, double* dataset);
     void py_FuzzyMeasureFitLPKinteractive(int datanum, int additive, struct fm_env* env, double* v, double* dataset, double* K);
+    void py_FuzzyMeasureFitLPKinteractiveLP(int datanum, int additive, struct fm_env* env, double* v, double* dataset, double* K, double* R);
     void py_FuzzyMeasureFitLPKinteractiveMaxChains(int datanum, int additive, struct fm_env* env, double* v, double* dataset, double* K);
     void py_FuzzyMeasureFitLPKinteractiveAutoK(int datanum, int additive, struct fm_env* env, double* v, double* dataset, double* K, int* maxiters);
     void py_FuzzyMeasureFitLPKinteractiveMarginal(int datanum, int additive, struct fm_env* env, double* v, double* dataset, double* K, int submod);
     void py_FuzzyMeasureFitLPKinteractiveMarginalMaxChain(int datanum, int additive, struct fm_env* env, double* v, double* dataset, double* K, int* maxiters, int submod);
     void py_FuzzyMeasureFitLP(int datanum, int additive, struct fm_env* env, double* v, double* dataset, int * options, double* indexlow, double* indexhihg, int* option1, double* orness);
     void py_FuzzyMeasureFitLPMob(int datanum, int additive, struct fm_env* env, double* v, double* dataset, int * options, double* indexlow, double* indexhihg, int* option1, double* orness);
-    void py_fittingOWA(int datanum, struct fm_env* env, double* v, double* dataset);
+    void py_fittingOWA(int datanum, struct fm_env* env, double* v, double* dataset, int ensureon);
     void py_fittingWAM(int datanum, struct fm_env* env, double* v, double* dataset);
     void py_Interaction(double* Mob, double* v, struct fm_env* env);
     void py_InteractionB(double* Mob, double* v, struct fm_env* env);
@@ -149,6 +159,10 @@ ffibuilder.cdef(r"""
  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, double* weights, int_64* vv, struct fm_env* env);
  int py_generate_fm_minimals(int num, int n, int markov, double ratio, double* weights, double* vv, struct fm_env* env);
+   void py_CCM2FM(double* v, double* B, struct fm_env* env);
+ void py_FM2CCM(double* v, double* B, struct fm_env* env);
+ void py_CCM2Mob(double* v, double* B, struct fm_env* env);
+ void py_Mob2CCM(double* v, double* B, 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.3.8 → pyfmtools-5.4.0}/src/fmrandomsort.inc

@@ -115,7 +115,7 @@ LIBDLL_API int generate_fm_sorting01(int_64 num, int n, int markov, int option,
 		  values[0] = 0;	values[m - 1] = 1;
 		  // this is unbalanced
 
-		  for (int_64 i = 1; i < m - 1; i++) values[i] = values[i] * p + (1 - p) * bal[bit2card[i]];
+		  for (int_64 i = 1; i < m - 1; i++) values[i] = values[i] * p + (1 - p) * bal[i];
 
 		  }
 		values[0] = 0;	values[m - 1] = 1; // empty set and N

{pyfmtools-5.3.8 → pyfmtools-5.4.0}/src/fuzzymeasurefit.cpp

@@ -507,6 +507,8 @@ int	FuzzyMeasureFitLPsymmetric(int n,  int K, double *v, double* XYData, int opt
   // next equality constraint = add to 1
   double wei=K; // this constraint is taken with that weight, to ensure it is actually satisfied 
   if(wei<1) wei=1;
+  
+  if(options==2) wei=0; // no add to one constraint
   // despite roundoff errors 
   row[0]=wei; rowno[0]=0; k=1;
   for(i=0;i<RowsC1+n;i++) {

{pyfmtools-5.3.8 → pyfmtools-5.4.0}/src/fuzzymeasurefit.h

@@ -208,3 +208,5 @@ LIBDLL_API int FuzzyMeasureFit2additive(int n, int datanum, int length,
 	
 LIBDLL_API 	int	LinearFunctionFitLP(int n,  int K, double *v, double* XYData, int options);
 	
+LIBDLL_API  int	FuzzyMeasureFitLPKinteractiveLP(int n, int_64 m, int K, int Kadd, double *v, double* XYData, int options,
+	double* indexlow, double* indexhigh, int option1, double* orness, double KConst, double Rconst);

{pyfmtools-5.3.8 → pyfmtools-5.4.0}/src/fuzzymeasurefit3.cpp

@@ -2259,3 +2259,289 @@ LIBDLL_API int FuzzyMeasureFit2additive(int n, int datanum, int length,
 
 
 
+
+// new 5.4, involves K, R in LP
+int	FuzzyMeasureFitLPKinteractiveLP(int n, int_64 m, int K, int Kadd, double *v, double* XYData, int options,
+	double* indexlow, double* indexhigh, int option1, double* orness, double KConst, double Rconst)
+
+	// in standard representation
+	// K for data, Kadd for k-interactive f.m.
+	// KConst the bound on the constant K for k-interactive fm
+	// uses free Kconst and Rconst if they are specified as negatives
+
+{
+
+	int counter = 0;
+	unsigned int i, j, k,  res;
+	int result;
+	int_64 A, B, C;
+	lprec		*MyLP;
+	unsigned int RowsR, RowsC, RowsC1;
+
+	if (Kadd >= n) {
+		Kadd = n - 1; KConst = Rconst;
+	}
+	if (Kadd == n - 1) KConst = Rconst;
+
+	RowsC1 = (cardpos[Kadd] - n - 1); //how many non-singletons   ///Check this mu(0)=0. Also fewer variables as all are positive
+	RowsR = K * 2; RowsC = n + RowsC1;  /// removed *2
+	unsigned int RowsC2 = (cardpos[Kadd - 1]); // position of the second last cardinality
+	unsigned int ExtraRows=2; 
+
+	MyLP = make_lp(RowsR + RowsC + ExtraRows, 0);
+	MyLP->do_presolve = FALSE;
+	set_verbose(MyLP, 0);
+	unsigned int itemp = RowsC + 2 + 1 + ExtraRows; // just the max number of entries per column
+
+	double *row;
+	int	 *rowno;
+	row = new double[itemp];
+	rowno = new int[itemp];
+	int* ind=new int[n];
+
+	// int re;
+
+	// the first K columns
+	rowno[0] = 0;
+	double factor = 1.0 / (n - Kadd - 1);
+	
+	for (k = 0; k<(unsigned int)K; k++) {
+		//rowno[0] is the obj. function
+		row[0] = XYData[k*(n + 1) + n];//y[k]; //
+		rowno[0] = 0;
+		
+		myiota(ind, ind + n, 0);  // found in <numeric>
+		sort(ind, ind + n, compare_indirect_index <double*>(&(XYData[k*(n + 1)]))); // decreasing order now
+
+		double coefK=0;
+		for (i = 0; i < (unsigned int)(n - Kadd - 1); i++) {
+			coefK += ((&(XYData[k*(n + 1)]))[ind[n-i-1]]); 
+		}
+		double coefR=coefK*factor;
+		coefK =-coefK*factor;
+		coefK += ((&(XYData[k*(n + 1)]))[ind[Kadd]]);
+
+		//todo not to include 0
+
+		rowno[1] = k + 1;  // 1-based
+		rowno[2] = k + 1 + K;
+		row[1] = -1;
+		row[2] = 1;
+		// now the vales of h_A
+
+		itemp = 0;
+		for (i = 0; i<(unsigned int)n; i++) {// singletons
+			row[2 + itemp + 1] = maxf(0, XYData[k*(n + 1) + i] - max_subset_complement(&(XYData[k*(n + 1)]), n, card2bit[i + 1]));
+			rowno[2 + itemp + 1] = RowsR + i + 1;
+			if (row[2 + itemp + 1] != 0) {
+				counter++; itemp++;
+			}
+		}
+
+
+		//todo: do I need zeroes?
+
+		for (i = 0; i<RowsC1; i++) {
+			row[2 + itemp  + 1] = maxf(0, min_subset(&(XYData[k*(n + 1)]), n, card2bit[i + 1 + n]) - max_subset_complement(&(XYData[k*(n + 1)]), n, card2bit[i + 1 + n]));      /// new function g_A, need max_subset_complement, also need to move 1s to the RHS with y
+			rowno[2 + itemp  + 1] = RowsR + n + i + 1;  // was +n in the index
+
+			if (row[2 + itemp  + 1] != 0) { counter++; itemp++; }
+			//			row[2+i +n + RowsC1+1]= - row[2+i +n+1] ;
+			//			rowno[2+i+n + RowsC1+1] = RowsR + n + i +1  + RowsC1;
+		}
+		
+		// add K and R
+		rowno[2 + itemp  + 1] = RowsR + n + RowsC1 + 1;  // was +n in the index
+		row[2 + itemp  + 1] =coefK;
+		itemp++;
+		
+		rowno[2 + itemp  + 1] = RowsR + n + RowsC1+1 + 1;  // was +n in the index
+		row[2 + itemp  + 1] =coefR;
+		itemp++;		
+
+		add_columnex(MyLP, itemp+3, row, rowno);
+
+		// now repeat everything, just change the sign
+		for (i = 0; i<itemp+3; i++) row[i] = -row[i];
+
+		add_columnex(MyLP, itemp+3, row, rowno);
+		
+	}
+
+	/// I do not need this as m(N)=1
+
+	// now monotonicity constraints for all |A|>2
+
+
+	for (A = n + 1; A <= RowsC; A++){   ///check if we need <=
+		//	cout<<"start subset  "<< A<<endl;
+		C = card2bit[A];
+		for (i = 0; i<(unsigned int)n; i++) if (IsInSet(C, i)) { ///check if inequality is reverse	
+			row[0] = 0; rowno[0] = 0;
+			k = 1;
+			row[k] = 1;
+			rowno[k] = int( A + RowsR);
+			k++;
+			B = C;
+			RemoveFromSet(&B, i);
+			row[k] = -1;
+			rowno[k] = int(bit2card[B] + RowsR);
+			k++;
+			add_columnex(MyLP, k, row, rowno);
+
+			counter += k;
+		}
+
+	} // A 
+
+
+	for (A = RowsC2; A <= RowsC; A++){   ///check if we need <=1 ????????????????	
+	// constraint K-m(A)>0
+		row[0] = 0.0; rowno[0] = 0;  // Kconst
+		//row[0] = 0;
+		k = 1;
+		row[k] = -1;
+		rowno[k] = int(A + RowsR);
+		k++;
+		row[k] = 1;   // Kconst
+		rowno[k] = int(RowsR + n + RowsC1 + 1);
+		k++;
+		
+		add_columnex(MyLP, k, row, rowno);
+
+		counter += k;
+	} // i 
+
+	//} // subsets
+
+	// add interaction indices if needed
+
+	/// no orness or other options
+	
+	// if Rconst and Kconst given, assign their values
+	
+	
+	// K<R
+		k=3;
+		row[0] = 0.0; rowno[0] = 0;  // Kconst
+		row[1]=-1; rowno[1]=RowsR + n + RowsC1 + 1;
+		row[2]=1; rowno[2]=RowsR + n + RowsC1 + 2;
+		add_columnex(MyLP, k, row, rowno);
+		counter += k;
+
+	
+	if(KConst>0)
+	{
+		k=2;
+		row[0] = KConst; rowno[0] = 0;  // Kconst
+		row[1]=1; rowno[1]=RowsR + n + RowsC1 + 1;
+		add_columnex(MyLP, k, row, rowno);
+		counter += k;
+		row[0] = -KConst; 
+		row[1]=-1;
+		add_columnex(MyLP, k, row, rowno);
+		counter += k;	
+	}
+	
+	if(Rconst>0)
+	{
+		k=2;
+		row[0] = Rconst; rowno[0] = 0;  // Kconst
+		row[1]=1; rowno[1]=RowsR + n + RowsC1 + 2;
+		add_columnex(MyLP, k, row, rowno);
+		counter += k;
+		row[0] = -Rconst; 
+		row[1]=-1;
+		add_columnex(MyLP, k, row, rowno);
+		counter += k;	
+	}
+
+	int RR = get_Nrows(MyLP);
+	int CC = get_Ncolumns(MyLP);
+	for (i = 1; i <= (unsigned int)RR; i++) {
+		set_rh(MyLP, i, 0);
+		set_constr_type(MyLP, i, LE);
+
+	}
+//	for (i = 1; i <= (unsigned int)CC; i++) {
+//		set_bounds(MyLP, i, 0.0, 1.0);
+//	}
+
+
+	for (i = 1; i <= RowsR   ; i++) {
+		set_rh(MyLP, i, 1.0); 
+	}
+//	for (i = RowsR + RowsC2; i <= RR; i++) {
+//		set_rh(MyLP, i, KConst);
+//	}
+
+	set_maxim(MyLP); // well, we always do that
+
+
+
+	double *sol = (double*)malloc(sizeof(double)*(1 + RR + CC + ExtraRows));
+
+//	cout << n <<"\t"<<K <<"\t"<<Kadd<<"\t"<< RR << "\t" << CC << "\t"<<counter<<endl;
+
+		 write_lp(MyLP, "model.lp");
+//		cout<<"finished building LP "<< RR<< " " <<CC<<endl;
+		set_outputfile(MyLP, "log.txt");
+
+		print_lp(MyLP);
+
+	//  set_verbose(MyLP,5);
+	//  set_outputstream(MyLP, stdout);
+	//  print_lp(MyLP);
+	/// change recovery from the output...
+
+	res = solve(MyLP);
+	double minval=10e10;
+
+	if (res == OPTIMAL) {
+		//		temp=0;
+		get_dual_solution(MyLP, sol);
+		print_solution(MyLP, 1);
+		minval = get_objective(MyLP);  // minimum
+
+//	   for (i = 0; i < RR + 1 ; i++) cout << sol[i] << endl;
+//		cout<<" min value "<<minval<<" "<<res<<endl;
+
+		v[0] = 0;// always !!
+		for (i = 1; i <= (unsigned int)n; i++)
+		{
+			v[i] = sol[i + RowsR]; // singletons
+		}
+		for (i = 0; i<RowsC1; i++)
+		{
+			v[i + n + 1] = sol[n + RowsR + 1 + i]; ////- sol[n+RowsR+1 + RowsC1+i]; // other subsets
+			k++;
+		}
+		k = n + RowsC1+1;
+		
+		double RC, KC;
+		KC=sol[RowsR + n + RowsC1 + 1];
+		RC=sol[RowsR + n + RowsC1 + 2];
+
+		for (int_64 ii = k; ii < m; ii++){
+			j = card[card2bit[ii]];
+			if (Kadd<n - 1)
+				v[ii] = KC + (j - Kadd - 1.0)*(RC - KC) / (n - Kadd - 1);
+			else v[ii] = KC;
+
+		}
+
+		result = 1;
+	} // no optimal
+	else result = 0;
+
+	// just to cheat the compiler
+	minval = minval + 1;
+	delete[] row;
+	delete[] rowno;
+	delete[] ind;
+
+
+	free(sol);
+	delete_lp(MyLP);
+	return result;
+}

{pyfmtools-5.3.8 → pyfmtools-5.4.0}/src/fuzzymeasuretools.cpp

@@ -230,7 +230,7 @@ int_64 RemoveHighestBit(int_64 a, int K) {
 
 
 
-inline int Cardinality(int_64 A) { return bitweight(A); }
+ int Cardinality(int_64 A) { return bitweight(A); }
 
 
 unsigned int     ShowValue(int_64 s) {
@@ -613,6 +613,70 @@ void Zeta(double* Mob, double* v, int n, int_64 m)
                 v[i]=s;
         }
 }
+void FM2CCM(double* v, double* ccm, int n, int_64 m)
+{
+		int_64 i;
+		int_64 id;
+        double s;
+        for(i=0;i<m;i++) {
+                s=0;
+				
+                for(id=i;id < m;id++) if(IsSubset(id,i)) { // supersets
+					int r=1;
+					if(IsOdd(Cardinality(id)-Cardinality(i))) r=-1;
+                        s += r* v[id] ;
+                }
+                ccm[i]=s;
+        }	
+}
+
+void CCM2FM(double* ccm, double* v, int n, int_64 m)
+{
+		int_64 i;
+		int_64 id;
+        double s;
+        for(i=0;i<m;i++) {
+                s=0;
+                for(id=i;id < m;id++) if(IsSubset(id,i)) { // supersets
+                        s += ccm[id] ;
+                }
+                v[i]=s;
+        }
+}
+
+void Mob2CCM(double* Mob, double* ccm, int n, int_64 m)
+{
+		int_64 i;
+		int_64 id;
+        double s;
+        for(i=0;i<m;i++) {
+                s=0;
+				int r=1;
+				if(IsOdd(n-Cardinality(i))) r=-1;
+				int_64 NI=Setdiff(m-1,i);
+                for(id=NI;id < m;id++) if(IsSubset(id,NI)) { // supersets
+                        s += Mob[id] ;
+                }
+                ccm[i]=r*s;
+        }	
+}
+
+void CCM2Mob(double* ccm, double* Mob, int n, int_64 m)
+{
+		int_64 i;
+		int_64 id;
+        double s;
+        for(i=0;i<m;i++) {
+                s=0;
+				int r=1;
+				if(IsOdd(1+Cardinality(i)) )r=-1;
+                for(id=1;id < m;id++) if(Setintersection(id,i)>0) { // set intersection no null
+                        s += ccm[id] ;
+                }
+                Mob[i]=r*s;
+        }
+}
+
 
 
 void Shapley(double* v, double* x, int n, int_64 m)
@@ -1352,11 +1416,23 @@ void dualMobKadd( myfloat* src, myfloat* dest, int m, int length, int k)
 
 }
 
-// todo: for k-additive, should follow dualMobKadd process with right coefficients
-void Shapley2addMob(double* v, double* x, int n)
-// calculates the array x of Shapley values for 2 additive fm in compact representation (cardinality based)
+
+void Banzhaf2addMob(double* v, double* x, int n)
+// calculates the array x of Banzhaf indices for 2 additive fm in compact representation (cardinality based)
 {
-	// the formula is singleton + all pairs/2
+	
+	for (int i = 0;i < n; i++) 
+		x[i]= v[i];  // singleton
+	
+	int start=n;
+	for (int i = 0;i < n; i++) 
+		for (int j = i+1;j < n;j++){
+			x[i]  +=  v[start] *0.5;
+			x[j] += v[start] *0.5 ;
+			start++;
+		}
+/*		
+	// the formula is singleton + all pairs/3
 	for (int i = 0;i < n; i++) {
 		x[i] = v[i];  // singleton
 
@@ -1364,8 +1440,8 @@ void Shapley2addMob(double* v, double* x, int n)
 		start += (i - 1); if (start < n) start = n; // special case i==0
 		if (i > 0) step = n - 1;
 		for (int j = 1;j < n;j++) {
-			x[i] += v[start] * 0.5;  // pair
-//			cout << start << " ";
+			x[i] += v[start] *0.5;  // pair
+			//				cout << start << " ";
 			if (row < i) {
 				step -= 1;  row++; if (row == i) start++;
 			}// row not reached
@@ -1375,12 +1451,18 @@ void Shapley2addMob(double* v, double* x, int n)
 			start += step;
 		}
 	}
+	*/
 }
 
-void Banzhaf2addMob(double* v, double* x, int n)
-// calculates the array x of Banzhaf indices for 2 additive fm in compact representation (cardinality based)
+
+
+// todo: for k-additive, should follow dualMobKadd process with right coefficients
+void Shapley2addMob(double* v, double* x, int n)
+// calculates the array x of Shapley values for 2 additive fm in compact representation (cardinality based)
 {
-	// the formula is singleton + all pairs/3
+	Banzhaf2addMob(v,x,n); // they are the same
+	return;
+	// the formula is singleton + all pairs/2
 	for (int i = 0;i < n; i++) {
 		x[i] = v[i];  // singleton
 
@@ -1388,8 +1470,8 @@ void Banzhaf2addMob(double* v, double* x, int n)
 		start += (i - 1); if (start < n) start = n; // special case i==0
 		if (i > 0) step = n - 1;
 		for (int j = 1;j < n;j++) {
-			x[i] += v[start] *0.5;  // pair
-			//				cout << start << " ";
+			x[i] += v[start] * 0.5;  // pair
+//			cout << start << " ";
 			if (row < i) {
 				step -= 1;  row++; if (row == i) start++;
 			}// row not reached
@@ -1402,11 +1484,21 @@ void Banzhaf2addMob(double* v, double* x, int n)
 }
 
 
+
 double Choquet2add(double*x, double* Mob, int n)
 /* This is a calculation of the Choquet integral from the Moebius transform for 2-additive capacities.
 */
 {
 	double val = 0;
+	for (int i = 0;i < n; i++) 
+		val+= Mob[i]*x[i];  // singleton
+	int start=n;
+	for (int i = 0;i < n; i++) 
+		for (int j = i+1;j < n;j++){
+			val  +=  Mob[start] * minf(x[i], x[j]);
+			start++;
+		}
+/*	
 	// the formula is singleton + all pairs/2
 	for (int i = 0;i < n; i++) {
 		val+= Mob[i]*x[i];  // singleton
@@ -1426,6 +1518,7 @@ double Choquet2add(double*x, double* Mob, int n)
 			start += step;
 		}
 	}
+	*/
 	return val;
 }
 /* ====================== Sparse FM in Mobius representation ==================================*/

{pyfmtools-5.3.8 → pyfmtools-5.4.0}/src/fuzzymeasuretools.h

@@ -187,7 +187,7 @@ LIBDLL_API inline int TopElement(int_64 a) {
 	// return true is a= 11111...
 	return (bitweight(a + 1) == 1);
 }
-
+LIBDLL_API int Cardinality(int_64 A) ;
 
 
 #include "fmrandom.h"
@@ -381,6 +381,10 @@ LIBDLL_API int generate_fm_2additive_convex_sparse(int n, struct SparseFM* cap);
 /* this is actually a total monotone, Belief measure */
 LIBDLL_API int generate_fm_kadditive_convex_sparse(int n, int k, int nonzero, struct SparseFM* cap);
 
+LIBDLL_API void FM2CCM(double* v, double* ccm, int n, int_64 m);
+LIBDLL_API void CCM2FM(double* ccm, double* v, int n, int_64 m);
+LIBDLL_API void Mob2CCM(double* Mob, double* ccm, int n, int_64 m);
+LIBDLL_API void CCM2Mob(double* ccm, double* Mob, int n, int_64 m);
 
 
 #endif

{pyfmtools-5.3.8 → pyfmtools-5.4.0/src/pyfmtools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pyfmtools
-Version: 5.3.8
+Version: 5.4.0
 Summary: Library for handling and fitting fuzzy measures
 Home-page: 
 Author: Gleb Beliakov, Norbert Henseler
@@ -8,6 +8,13 @@ Author-email: gleb.beliakov@deakin.edu.au, norbert.henseler@deakin.edu.au
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: cffi>=1.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 # Pyfmtools    
 Pyfmtools provides various tools for handling fuzzy measures, calculating various indices, Choquet and Sugeno integrals, as well as fitting fuzzy measures to empirical data. This package is designed for Python , but it also includes the C++ source files and a user manual.