pyfmtools 0.81__tar.gz → 5.2__tar.gz

{pyfmtools-0.81 → pyfmtools-5.2}/MANIFEST.in

@@ -4,6 +4,7 @@ recursive-include dist *.whl
 recursive-include src *.h
 recursive-include src *.c
 recursive-include src *.cpp
+recursive-include src *.inc
 recursive-include src *.py
 recursive-include tests *.py
 

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

@@ -1,14 +1,13 @@
 Metadata-Version: 2.1
 Name: pyfmtools
-Version: 0.81
+Version: 5.2
 Summary: Library for handling and fitting fuzzy measures
-Home-page: UNKNOWN
+Home-page: 
 Author: Gleb Beliakov, Norbert Henseler
 Author-email: gleb.beliakov@deakin.edu.au, norbert.henseler@deakin.edu.au
-License: UNKNOWN
-Platform: UNKNOWN
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: cffi>=1.0.0
 
 # 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.
@@ -153,4 +152,3 @@ To unit test type:
 ```python
 $ test/test_no_wrapper.py
 ```
-

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

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

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

@@ -5,6 +5,7 @@ ffibuilder = FFI()
 PATH = os.path.dirname(__file__)
 
 ffibuilder.cdef(r"""
+    extern "Python" int(py_user_defined_measurecheck)(int*, double *);
     typedef unsigned long long int_64;
     struct  fm_env {
 	int n;
@@ -15,7 +16,7 @@ ffibuilder.cdef(r"""
 	double* card2bit;
 	double* factorials;};
     struct  fm_env_sparse { 
-	int xx[40];};
+	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);
     void py_ConvertCard2Bit(double* dest, double* src,  struct fm_env* env);
@@ -59,7 +60,7 @@ ffibuilder.cdef(r"""
     void py_InteractionBMob(double* Mob, double* v, struct fm_env* env);
     void py_BipartitionShapleyIndex(double* v, double* w, struct fm_env* env);
     void py_BipartitionBanzhafIndex(double* v, double* w, struct fm_env* env);
-    void py_BNonadditivityIndexMob(double* Mob, double* w, struct fm_env* env);
+    void py_NonadditivityIndexMob(double* Mob, double* w, struct fm_env* env);
     void py_NonadditivityIndex(double* v, double* w, struct fm_env* env);
 	void py_NonmodularityIndex(double* v, double* w, struct fm_env* env);
 	void py_NonmodularityIndexMob(double* Mob, double* w, struct fm_env* env);	
@@ -96,6 +97,7 @@ ffibuilder.cdef(r"""
 	void py_Banzhaf2addMob(double* v, double* x, int n);
     double py_Choquet2addMob(double*x, double* Mob, int n);
 	int py_fm_arraysize(int n, int kint, struct fm_env* env);
+    int py_fm_arraysize_kadd(int n, int kint, struct fm_env* env);
 	int py_generate_fm_tsort(int num, int n, int kint, int markov, int option, double K, double * vv, struct fm_env* env);
 	int py_generate_fmconvex_tsort(int num, int n, int kint, int markov, int option, double K, double * vv, struct fm_env* env);
 	int py_generate_fm_minplus(int num, int n, int kint, int markov, int option, double K, double * vv, struct fm_env* env);
@@ -127,15 +129,34 @@ ffibuilder.cdef(r"""
     int   py_generate_fm_2additive_convex_sparse(int n, struct fm_env_sparse* env);
     int   py_generate_fm_kadditive_convex_sparse(int n, int k, int nonzero, struct fm_env_sparse* env);
     void py_Nonmodularityindex_sparse(double* w, int n, struct fm_env_sparse* env);
+     void py_generate_fm_sorting(int num, int n, int markov, int option, double * vv, struct fm_env* env);
+ int py_CheckMonotonicitySortMerge(double * vv, double* indices, struct fm_env* env);
+ int py_CheckMonotonicitySortInsert(double * vv, double* indices, struct fm_env* env);
+ int py_CheckMonotonicitySimple(double * vv,struct fm_env* env);
+ void py_GenerateAntibuoyant( double * vv, struct fm_env* env);
+ int py_generate_fm_belief(int num, int n, int kadd, double * vv, struct fm_env* env);
+ int py_generate_fm_balanced(int num, int n,  double * vv, struct fm_env* env);
+ int py_generate_fm_2additive(int num, int n,  double * vv);
+ int py_CheckMonMob2additive2(double * vv, int n, int length, double* temp);
+ int py_CheckMonotonicityMob(double * vv, int len, struct fm_env* env);
+ int py_CheckConvexityMonMob(double * vv, int len, struct fm_env* env);
+ void py_ConvertCoMob2KinterCall(int n, int kint, int len, double* mu, double * vv, int fullmu, struct fm_env* env);
+ double py_ChoquetCoMobKInter(double* x, double* Mob, int kadd, int len, struct fm_env* env);
+ void py_fitting2additive(int datanum, int n, int len,  double* v, double* dataset, int  options, double* indexlow, double* indexhi, int option1, double* orness);
+ int py_generate_fm_randomwalk(int num, int n, int kint, int markov, int option, double step,  double * vv, struct fm_env* env, void* extrachecks);
+ 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);
     """, 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',
 	'src/ini.c','src/lp_matrix.c','src/lp_price.c','src/lp_SOS.c','src/myblas.c','src/isfixedvar.c','src/lp_MDO.c','src/lp_pricePSE.c','src/lp_utils.c','src/sparselib.c',
-	'src/lp_crash.c','src/lp_mipbb.c','src/lp_report.c','src/lp_wlp.c','src/yacc_read.c','src/lp_Hash.c','src/lp_MPS.c','src/lp_scale.c','src/lusol.c',
+	'src/lp_crash.c','src/lp_mipbb.c','src/lp_report.c','src/lp_wlp.c','src/yacc_read.c','src/lp_Hash.c','src/lp_MPS.c','src/lp_scale.c','src/lusol.c','src/gbrealloc.c',
 	'src/fmrandom.cpp','src/fuzzymeasurefit.cpp','src/wrapperpy.cpp','src/fuzzymeasurefit3.cpp','src/fuzzymeasuretools.cpp']
 
 ffibuilder.set_source("_pyfmtools",r""" #include "wrapperpy.h" """,  
     sources=pyfmtools_src,
+            extra_compile_args=[],
     include_dirs=[PATH],
     )
     

{pyfmtools-0.81 → pyfmtools-5.2}/src/colamd.h

@@ -207,6 +207,7 @@ typedef struct Colamd_Row_struct
 #endif
 */
 
+
 #ifndef __BORLANDC__
 
   #ifdef __cplusplus
@@ -277,10 +278,10 @@ void symamd_report
     int stats [COLAMD_STATS]
 ) ;
 
-#endif /* COLAMD_H */
+
 
 
 #ifdef __cplusplus
 }
 #endif
-
+#endif /* COLAMD_H */

{pyfmtools-0.81 → pyfmtools-5.2}/src/commonlib.c

@@ -347,8 +347,8 @@ int CMP_CALLMODEL compareREAL(const void *current, const void *candidate)
    where interchanges are reflected in a caller-initialized integer "tags" list. */
 void hpsort(void *attributes, int count, int offset, int recsize, MYBOOL descending, findCompare_func findCompare)
 {
-  register int  i, j, k, ir, order;
-  register char *hold, *base;
+   int  i, j, k, ir, order;
+   char *hold, *base;
   char          *save;
 
   if(count < 2)
@@ -409,8 +409,8 @@ void hpsortex(void *attributes, int count, int offset, int recsize, MYBOOL desce
     return;
   }
   else {
-    register int  i, j, k, ir, order;
-    register char *hold, *base;
+     int  i, j, k, ir, order;
+     char *hold, *base;
     char          *save;
     int           savetag;
 
@@ -515,7 +515,7 @@ void QS_delete(UNIONTYPE QSORTrec a[], int ipos, int epos)
 }
 int QS_sort(UNIONTYPE QSORTrec a[], int l, int r, findCompare_func findCompare)
 {
-  register int i, j, nmove = 0;
+   int i, j, nmove = 0;
   UNIONTYPE QSORTrec v;
 
   /* Perform the a fast QuickSort */

{pyfmtools-0.81 → pyfmtools-5.2}/src/commonlib.h

@@ -38,6 +38,10 @@
 #endif
 
 
+
+
+
+
 /* ************************************************************************ */
 /* Define sizes of standard number types                                    */
 /* ************************************************************************ */

{pyfmtools-0.81 → pyfmtools-5.2}/src/fmrandom.cpp

@@ -18,8 +18,14 @@ using namespace std;
 
 
 
+#ifndef NO_R
+unif_R_class<double> distribution(0.0, 1.0);
+#else
+std::uniform_real_distribution<> distribution(0.0, 1.0);
+#endif
+
+
 
-std::uniform_real_distribution<double> distribution(0.0, 1.0);
 
 
 
@@ -27,13 +33,14 @@ random_device rd;
 mt19937 rng(rd());    // random-number engine used (Mersenne-Twister in this case)
 
 
-
+/*
 template <class T> struct prec : binary_function <T, T, bool> {
 	bool operator() (const T& x, const T& y) const { return x < y; }
 };
 template <class T> struct succ : binary_function <T, T, bool> {
 	bool operator() (const T& x, const T& y) const { return x < y; }
 };
+*/
 // These definitions can be changed to support other data types. They sin in the .h file
 
 //typedef uint16_t myint;
@@ -413,6 +420,15 @@ int fm_arraysize_kadd(int n,  int k)
 	return r;
 }
 
+
+int fm_arraysize_2add(int n)
+{
+	// calculates the number of parameers needed in cardinal representation for 2-additive capacity
+	// no 0 included !!!
+	return (int)(choose(2, n)) + n;
+}
+
+
 myfloat fm_delta(int m, int kint, myfloat K)
 {  // delta is the fixed marginal contribution in the k-interactive fuzzy measures
 //	if (m == (kint + 1)) return (myfloat)(1.0 - K);
@@ -654,7 +670,7 @@ int generate_fm_tsort(int_64 num, int m, int kint, int markov, int option, myflo
 	std::vector<BYTE> decodedData1;
 
 
-	int NN = 0;
+    int NN=0;
 	myint i, j1, j;
 	double Wei, WeiS, p, u;
 	Edge E;
@@ -834,7 +850,7 @@ int generate_fmconvexconcave_tsort(int_64 num, int m, int kint, int markov, int
 	string s5, s6;
 	std::vector<BYTE> decodedData1;
 	
-	int NN = 0;
+    int NN=0;
 	myint i, j1, j;
 	double Wei, WeiS, p, u;
 	Edge E;
@@ -1041,3 +1057,9 @@ void export_maximal_chains(int n, int_64 m,  double * v, double * mc)
 		std::next_permutation(temp.begin(), temp.end());
 	}
 }
+
+
+
+
+
+#include "fmrandomsort.inc"

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

@@ -53,7 +53,7 @@ The generate_fm_minplus is based on the minimalsPlus method, which
 which is also published in their paper
 
 "Minimals plus: An improved algorithm for the random generation of linear extensions of partially ordered sets." Information
-Sciences, 501:50�67, 2019.
+Sciences, 501:50-67, 2019.
 
 The code can be optimised by not using the matrix representation of the poset, relying on the relation preceeds.Not attempted here due to lack of time.
 
@@ -100,6 +100,15 @@ gleb@deakin.edu.au
 //#include "fuzzymeasuretools.h"
 
 
+typedef struct {
+	double val;
+	int_64 ind;
+} dobint;
+
+typedef struct {
+	double val;
+	int_64 ind;
+} doblongint;
 
 
 
@@ -109,6 +118,9 @@ LIBDLL_API int fm_arraysize(int n, int_64 m, int kint);
 LIBDLL_API int fm_arraysize_kadd(int n, int k);
 // same for k-additive in cardinality ordering
 
+LIBDLL_API int fm_arraysize_2add(int n); 
+// same for 2-additive and without 0
+
 // generate fuzzy measures randomly using topological sort
 LIBDLL_API int generate_fm_tsort(int_64 num, int n, int kint, int markov, int option, myfloat K, myfloat * vv);
 
@@ -128,3 +140,44 @@ LIBDLL_API int generate_fm_2additive_convex_withsomeindependent(int_64 num, int
 // as above, but resets randomly some interactions to 0
 
 LIBDLL_API void export_maximal_chains(int n, int_64 m, double * v, double * mc);
+
+LIBDLL_API int generate_fm_sorting01(int_64 num, int n, int markov, int option, double* vv);
+
+LIBDLL_API int generate_fm_randomwalk(int_64 num, int n, int kadd, int markov, int option, double step , double* vv, int* len, void* extrachecks);
+
+	//	option==0 normal, 1 convex, 2 antibuoyant, 3 kadditive  ,   4 belief,  5 kadditive convex , 
+//option =0x0100 standars slower mon/convexiy check, 0x1000 or 0x0010 - avoid belief meaures to start walk 
+//on the borders of the simplex
+
+
+
+LIBDLL_API int CheckMonotonicitySortMerge(double* v, int_64* indices, int_64 m, int n);
+LIBDLL_API int CheckMonotonicitySortInsert(double* v, int_64* indices, int_64 m, int n);
+LIBDLL_API int CheckMonotonicitySimple(double* v, int_64 m, int n);
+
+
+LIBDLL_API int CheckConvexitySortMerge(vector<doblongint>& v, vector<int_64>& indices, int_64 m, int n, int_64 M, int conv );
+LIBDLL_API int CheckConvexitySortInsert(vector<doblongint>& v, vector<int_64>& indices, int_64 m, int n, int_64 M, int conv );
+LIBDLL_API  int GenerateAntibuoyant(int n, int_64 m, double* out); // lambda
+LIBDLL_API int generate_fm_simple_randomwalk(int_64 num, int n, int markov, int option, double noise, double* vv, int* len, void* extrachecks);
+LIBDLL_API int generate_fm_convex_randomwalk(int_64 num, int n, int markov, int option, double noise, double* vv, int* len, void* extrachecks);
+
+
+LIBDLL_API int CheckMonotonicityMob(double* Mob, int n, int_64 m, int_64 len);
+LIBDLL_API int CheckConvexityMonMob(double* Mob, int n, int_64 m, int_64 len);
+
+//LIBDLL_API int generate_fm_kadditive_randomwalk(int_64 num, int n, int kadd, int markov, int option, double noise, double* vv, void* extrachecks);
+//LIBDLL_API int generate_fm_kadditiveconvex_randomwalk(int_64 num, int n, int kadd, int markov, int option, double noise, double* vv, void* extrachecks);
+LIBDLL_API int generate_fm_belief(int_64 num, int n, int kadd, int_64* length, double* vv);
+LIBDLL_API int generate_fm_balanced(int_64 num, int n, double* vv);
+
+LIBDLL_API int generate_fm_kinteractivedualconvex(int_64 num, int n, int kadd, int markov, int_64* length, double noise, double* vv, void* extrachecks);
+LIBDLL_API int generate_fm_kinteractivedualconcave(int_64 num, int n, int kadd, int markov, int_64* length, double noise, double* vv, void* extrachecks);
+
+// 2 additive
+LIBDLL_API int generate_fm_2additive(int_64 num, int n, int option, myfloat* vv);
+LIBDLL_API int generate_fm_2additive_randomwalk2(int_64 num, int n, int markov, int option, double noise, double* vv, void* extrachecks);
+LIBDLL_API  int CheckMonMob2additive2(double* Mob, int n, int length, double* temp);
+
+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);