Updated the usage of CIT calling

Author: MarkDana

docs/source/independence_tests_index/chisq.rst

@@ -5,14 +5,29 @@ Chi-Square test
 
 Perform an independence test on discrete variables using Chi-Square test.
 
-(We have updated the independence test class and the usage example hasn't been updated yet. For new class, please refer to `TestCIT.py <https://github.com/cmu-phil/causal-learn/blob/main/tests/TestCIT.py>`_ or `TestCIT_KCI.py <https://github.com/cmu-phil/causal-learn/blob/main/tests/TestCIT_KCI.py>`_.)
-
 Usage
 --------
 .. code-block:: python
 
+    from causallearn.utils.cit import CIT
+    chisq_obj = CIT(data, "chisq") # construct a CIT instance with data and method name
+    pValue = chisq_obj(X, Y, S)
+
+Please be kindly informed that we have refactored the independence tests from functions to classes since the release `v0.1.2.8 <https://github.com/cmu-phil/causal-learn/releases/tag/0.1.2.8>`_. Speed gain and a more flexible parameters specification are enabled.
+
+For users, you may need to adjust your codes accordingly. Specifically, if you are
+
++ running a constraint-based algorithm from end to end: then you don't need to change anything. Old codes are still compatible. For example,
+.. code-block:: python
+
+    from causallearn.search.ConstraintBased.PC import pc
     from causallearn.utils.cit import chisq
-    p = chisq(data, X, Y, conditioning_set)
+    cg = pc(data, 0.05, chisq)
+
++ explicitly calculating the p-value of a test: then you need to declare the :code:`chisq_obj` and then call it as above, instead of using :code:`chisq(data, X, Y, condition_set)` as before. Note that now :code:`causallearn.utils.cit.chisq` is a string :code:`"chisq"`, instead of a function.
+
+Please see `CIT.py <https://github.com/cmu-phil/causal-learn/blob/main/causallearn/utils/cit.py>`_
+for more details on the implementation of the (conditional) independent tests.
 
 
 Parameters

docs/source/independence_tests_index/fisherz.rst

@@ -5,15 +5,31 @@ Fisher-z test
 
 Perform an independence test using Fisher-z's test [1]_. This test is optimal for linear-Gaussian data.
 
-(We have updated the independence test class and the usage example hasn't been updated yet. For new class, please refer to `TestCIT.py <https://github.com/cmu-phil/causal-learn/blob/main/tests/TestCIT.py>`_ or `TestCIT_KCI.py <https://github.com/cmu-phil/causal-learn/blob/main/tests/TestCIT_KCI.py>`_.)
-
 
 Usage
 --------
 .. code-block:: python
 
+    from causallearn.utils.cit import CIT
+    fisherz_obj = CIT(data, "fisherz") # construct a CIT instance with data and method name
+    pValue = fisherz_obj(X, Y, S)
+
+Please be kindly informed that we have refactored the independence tests from functions to classes since the release `v0.1.2.8 <https://github.com/cmu-phil/causal-learn/releases/tag/0.1.2.8>`_. Speed gain and a more flexible parameters specification are enabled.
+
+For users, you may need to adjust your codes accordingly. Specifically,
+
++ If you are running a constraint-based algorithm from end to end: then you don't need to change anything. Old codes are still compatible. For example,
+.. code-block:: python
+
+    from causallearn.search.ConstraintBased.PC import pc
     from causallearn.utils.cit import fisherz
-    p = fisherz(data, X, Y, condition_set, correlation_matrix)
+    cg = pc(data, 0.05, fisherz)
+
++ If you are explicitly calculating the p-value of a test: then you need to declare the :code:`fisherz_obj` and then call it as above, instead of using :code:`fisherz(data, X, Y, condition_set)` as before. Note that now :code:`causallearn.utils.cit.fisherz` is a string :code:`"fisherz"`, instead of a function.
+
+
+Please see `CIT.py <https://github.com/cmu-phil/causal-learn/blob/main/causallearn/utils/cit.py>`_
+for more details on the implementation of the (conditional) independent tests.
 
 Parameters
 ------------

docs/source/independence_tests_index/gsq.rst

@@ -5,15 +5,29 @@ G-Square test
 
 Perform an independence test using G-Square test [1]_. This test is based on the log likelihood ratio test.
 
-(We have updated the independence test class and the usage example hasn't been updated yet. For new class, please refer to `TestCIT.py <https://github.com/cmu-phil/causal-learn/blob/main/tests/TestCIT.py>`_ or `TestCIT_KCI.py <https://github.com/cmu-phil/causal-learn/blob/main/tests/TestCIT_KCI.py>`_.)
-
-
 Usage
 --------
 .. code-block:: python
 
+    from causallearn.utils.cit import CIT
+    gsq_obj = CIT(data, "gsq") # construct a CIT instance with data and method name
+    pValue = gsq_obj(X, Y, S)
+
+Please be kindly informed that we have refactored the independence tests from functions to classes since the release `v0.1.2.8 <https://github.com/cmu-phil/causal-learn/releases/tag/0.1.2.8>`_. Speed gain and a more flexible parameters specification are enabled.
+
+For users, you may need to adjust your codes accordingly. Specifically, if you are
+
++ running a constraint-based algorithm from end to end: then you don't need to change anything. Old codes are still compatible. For example,
+.. code-block:: python
+
+    from causallearn.search.ConstraintBased.PC import pc
     from causallearn.utils.cit import gsq
-    p = gsq(data, X, Y, conditioning_set)
+    cg = pc(data, 0.05, gsq)
+
++ explicitly calculating the p-value of a test: then you need to declare the :code:`gsq_obj` and then call it as above, instead of using :code:`gsq(data, X, Y, condition_set)` as before. Note that now :code:`causallearn.utils.cit.gsq` is a string :code:`"gsq"`, instead of a function.
+
+Please see `CIT.py <https://github.com/cmu-phil/causal-learn/blob/main/causallearn/utils/cit.py>`_
+for more details on the implementation of the (conditional) independent tests.
 
 Parameters
 -------------

docs/source/independence_tests_index/kci.rst

@@ -7,15 +7,39 @@ Kernel-based conditional independence (KCI) test and independence test [1]_.
 To test if x and y are conditionally or unconditionally independent on Z. For unconditional independence tests,
 Z is set to the empty set.
 
-(We have updated the independence test class and the usage example hasn't been updated yet. For new class, please refer to `TestCIT.py <https://github.com/cmu-phil/causal-learn/blob/main/tests/TestCIT.py>`_ or `TestCIT_KCI.py <https://github.com/cmu-phil/causal-learn/blob/main/tests/TestCIT_KCI.py>`_.)
-
-
 Usage
 --------
 .. code-block:: python
 
+    from causallearn.utils.cit import CIT
+    kci_obj = CIT(data, "kci") # construct a CIT instance with data and method name
+    pValue = kci_obj(X, Y, S)
+
+The above code runs KCI with the default parameters. Or instead if you would like to specify some parameters of KCI, you may do it by e.g.,
+
+.. code-block:: python
+
+    kci_obj = CIT(data, "kci", kernelZ='Polynomial', approx=False, est_width='median', ...)
+
+See `KCI.py <https://github.com/cmu-phil/causal-learn/blob/main/causallearn/utils/KCI/KCI.py>`_
+for more details on the parameters options of the KCI tests.
+
+
+Please be kindly informed that we have refactored the independence tests from functions to classes since the release `v0.1.2.8 <https://github.com/cmu-phil/causal-learn/releases/tag/0.1.2.8>`_. Speed gain and a more flexible parameters specification are enabled.
+
+For users, you may need to adjust your codes accordingly. Specifically, if you are
+
++ running a constraint-based algorithm from end to end: then you don't need to change anything. Old codes are still compatible. For example,
+.. code-block:: python
+
+    from causallearn.search.ConstraintBased.PC import pc
     from causallearn.utils.cit import kci
-    p = kci(data, X, Y, condition_set, kernelX, kernelY, kernelZ, est_width, polyd, kwidthx, kwidthy, kwidthz)
+    cg = pc(data, 0.05, kci)
+
++ explicitly calculating the p-value of a test: then you need to declare the :code:`kci_obj` and then call it as above, instead of using :code:`kci(data, X, Y, condition_set)` as before. Note that now :code:`causallearn.utils.cit.kci` is a string :code:`"kci"`, instead of a function.
+
+Please see `CIT.py <https://github.com/cmu-phil/causal-learn/blob/main/causallearn/utils/cit.py>`_
+for more details on the implementation of the (conditional) independent tests.
 
 Parameters
 -------------

docs/source/independence_tests_index/mvfisherz.rst

@@ -6,15 +6,29 @@ Missing-value Fisher-z test
 Perform a testwise-deletion Fisher-z independence test to data sets with missing values.
 With testwise-deletion, the test makes use of all data points that do not have missing values for the variables involved in the test.
 
-(We have updated the independence test class and the usage example hasn't been updated yet. For new class, please refer to `TestCIT.py <https://github.com/cmu-phil/causal-learn/blob/main/tests/TestCIT.py>`_ or `TestCIT_KCI.py <https://github.com/cmu-phil/causal-learn/blob/main/tests/TestCIT_KCI.py>`_.)
-
-
 Usage
 --------
 .. code-block:: python
 
+    from causallearn.utils.cit import CIT
+    mv_fisherz_obj = CIT(data_with_missingness, "mv_fisherz") # construct a CIT instance with data and method name
+    pValue = mv_fisherz_obj(X, Y, S)
+
+Please be kindly informed that we have refactored the independence tests from functions to classes since the release `v0.1.2.8 <https://github.com/cmu-phil/causal-learn/releases/tag/0.1.2.8>`_. Speed gain and a more flexible parameters specification are enabled.
+
+For users, you may need to adjust your codes accordingly. Specifically, if you are
+
++ running a constraint-based algorithm from end to end: then you don't need to change anything. Old codes are still compatible. For example,
+.. code-block:: python
+
+    from causallearn.search.ConstraintBased.PC import pc
     from causallearn.utils.cit import mv_fisherz
-    p = mv_fisherz(mvdata, X, Y, condition_set)
+    cg = pc(data_with_missingness, 0.05, mv_fisherz)
+
++ explicitly calculating the p-value of a test: then you need to declare the :code:`mv_fisherz_obj` and then call it as above, instead of using :code:`mv_fisherz(data, X, Y, condition_set)` as before. Note that now :code:`causallearn.utils.cit.mv_fisherz` is a string :code:`"mv_fisherz"`, instead of a function.
+
+Please see `CIT.py <https://github.com/cmu-phil/causal-learn/blob/main/causallearn/utils/cit.py>`_
+for more details on the implementation of the (conditional) independent tests.
 
 
 Parameters