chore: resolve merge conflict

Author: bobleesj

doc/source/api/diffpy.utils.rst

@@ -28,6 +28,14 @@ diffpy.utils.transforms module
     :undoc-members:
     :show-inheritance:
 
+diffpy.utils.validators module
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. automodule:: diffpy.utils.validators
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
 diffpy.utils.tools module
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 

doc/source/examples/diffraction_objects_example.rst

@@ -129,14 +129,14 @@ For convenience, you can also apply an offset to the scaled new diffraction obje
 DiffractionObject convenience functions
 ---------------------------------------
 
-1) create a copy of a diffraction object using the ``copy`` method
+1. create a copy of a diffraction object using the ``copy`` method
    when you want to preserve the original data while working with a modified version.
 
 .. code-block:: python
 
     copy_of_calculated = calculated.copy()
 
-2) test the equality of two diffraction objects.  For example,
+2. test the equality of two diffraction objects.  For example,
 
 .. code-block:: python
 
@@ -145,15 +145,38 @@ DiffractionObject convenience functions
 
 will return ``True``.
 
-3) make arithmetic operations on the intensities of diffraction objects. e.g.,
+3. make arithmetic operations on the intensities of diffraction objects.
+For example, you can do scalar operations on a single diffraction object,
+which will modify the intensity values (``yarrays``) without affecting other properties:
 
 .. code-block:: python
 
-    doubled_object = 2 * diff_object1     # Double the intensities
-    sum_object = diff_object1 + diff_object2    # Sum the intensities
-    subtract_scaled = diff_object1 - 5 * diff_object2   # subtract 5 * obj2 from obj 1
+    increased_intensity = diff_object1 + 5      # Increases the intensities by 5
+    decreased_intensity = diff_object1 - 1      # Decreases the intensities by 1
+    doubled_object = 2 * diff_object1           # Double the intensities
+    reduced_intensity = diff_object1 / 2        # Halves the intensities
 
-4) get the value of the DiffractionObject at a given point in one of the xarrays
+You can also do binary operations between two diffraction objects, as long as they are on the same ``q/tth/d-array``.
+The operation will apply to the intensity values, while other properties
+(such as ``xarrays``, ``xtype``, and ``metadata``) will be inherited
+from the left-hand side diffraction object (``diff_object1``).
+For example:
+
+.. code-block:: python
+
+    sum_object = diff_object1 + diff_object2            # Sum the intensities
+    subtract_scaled = diff_object1 - 5 * diff_object2   # Subtract 5 * obj2 from obj 1
+    multiplied_object = diff_object1 * diff_object2     # Multiply the intensities
+    divided_object = diff_object1 / diff_object2        # Divide the intensities
+
+You cannot perform operations between diffraction objects and incompatible types.
+For example, attempting to add a diffraction object and a string will raise an error:
+
+.. code-block:: python
+
+    diff_object1 + "string_value"       # This will raise an error
+
+4. get the value of the DiffractionObject at a given point in one of the xarrays
 
 .. code-block:: python
 
@@ -170,7 +193,7 @@ you can find its closest index for ``q=0.25`` by typing either of the following:
     index = do.get_array_index(0.25) # no xtype passed, defaults to do._input_xtype, or in this example, q
     index = do.get_array_index(0.25, xtype="q") # explicitly choose an xtype to specify a value
 
-5) The ``dump`` function saves the diffraction data and relevant information to an xy format file with headers
+5. The ``dump`` function saves the diffraction data and relevant information to an xy format file with headers
 (widely used chi format used, for example, by Fit2D and diffpy.  These files can be read by ``LoadData()``
 in ``diffpy.utils.parsers``).
 

news/docs-do.rst

@@ -0,0 +1,23 @@
+**Added:**
+
+* no news added: adding documentation for diffraction object operation examples
+
+**Changed:**
+
+* <news item>
+
+**Deprecated:**
+
+* <news item>
+
+**Removed:**
+
+* <news item>
+
+**Fixed:**
+
+* <news item>
+
+**Security:**
+
+* <news item>

news/is-float.rst

@@ -0,0 +1,23 @@
+**Added:**
+
+* <news item>
+
+**Changed:**
+
+* Rename the `isfloat` function to `is_number`, and move it to the `diffpy/utils/utilsvalidators.py` directory
+
+**Deprecated:**
+
+* <news item>
+
+**Removed:**
+
+* <news item>
+
+**Fixed:**
+
+* <news item>
+
+**Security:**
+
+* <news item>

news/no-news.rst

@@ -0,0 +1,23 @@
+**Added:**
+
+* No news added: just making sure the previous add, mul, div, and sub tests are working as expected.
+
+**Changed:**
+
+* <news item>
+
+**Deprecated:**
+
+* <news item>
+
+**Removed:**
+
+* <news item>
+
+**Fixed:**
+
+* <news item>
+
+**Security:**
+
+* <news item>

src/diffpy/utils/diffraction_objects.py

@@ -14,9 +14,10 @@
 XQUANTITIES = ANGLEQUANTITIES + DQUANTITIES + QQUANTITIES
 XUNITS = ["degrees", "radians", "rad", "deg", "inv_angs", "inv_nm", "nm-1", "A-1"]
 
-y_grid_length_mismatch_emsg = (
-    "The two objects have different y-array lengths. "
-    "Please ensure the length of the y-value during initialization is identical."
+x_values_not_equal_emsg = (
+    "The two objects have different values in x arrays (my_do.all_arrays[:, [1, 2, 3]]). "
+    "Please ensure the x values of the two objects are identical by re-instantiating "
+    "the DiffractionObject with the correct x value inputs."
 )
 
 invalid_add_type_emsg = (
@@ -301,7 +302,9 @@ def _check_operation_compatibility(self, other):
             raise TypeError(invalid_add_type_emsg)
         if isinstance(other, DiffractionObject):
             if self.all_arrays.shape != other.all_arrays.shape:
-                raise ValueError(y_grid_length_mismatch_emsg)
+                raise ValueError(x_values_not_equal_emsg)
+            if not np.allclose(self.all_arrays[:, [1, 2, 3]], other.all_arrays[:, [1, 2, 3]]):
+                raise ValueError(x_values_not_equal_emsg)
 
     @property
     def all_arrays(self):

src/diffpy/utils/parsers/loaddata.py

@@ -17,6 +17,8 @@
 
 import numpy
 
+from diffpy.utils import validators
+
 
 def loadData(filename, minrows=10, headers=False, hdel="=", hignore=None, **kwargs):
     """Find and load data from a text file.
@@ -139,7 +141,7 @@ def countcolumnsvalues(line):
                     name = hpair[0]
                     value = hpair[1]
                     # check if data value should be stored as float
-                    if isfloat(hpair[1]):
+                    if validators.is_number(hpair[1]):
                         value = float(hpair[1])
                     hdata.update({name: value})
             # continue search for the start of datablock
@@ -331,16 +333,3 @@ def _findDataBlocks(self):
             self.headers.append(header)
             self.datasets.append(data)
         return
-
-
-# End of class TextDataLoader
-
-
-def isfloat(s):
-    """True if s is convertible to float."""
-    try:
-        float(s)
-        return True
-    except ValueError:
-        pass
-    return False

src/diffpy/utils/validators.py

@@ -0,0 +1,47 @@
+def is_number(string):
+    """Check if the provided string can be converted to a float.
+
+    Since integers can be converted to floats, this function will return True for integers as well.
+    Hence, we can use this function to check if a string is a number.
+
+    Parameters
+    ----------
+    string : str
+        The string to evaluate for numeric conversion.
+
+    Returns
+    -------
+    bool
+        The boolean whether `string` can be successfully converted to float.
+
+    Examples
+    --------
+    >>> is_number("3.14")
+    True
+
+    >>> is_number("-1.23")
+    True
+
+    >>> is_number("007")
+    True
+
+    >>> is_number("five")
+    False
+
+    >>> is_number("3.14.15")
+    False
+
+    >>> is_number("NaN")
+    True
+
+    >>> is_number("Infinity")
+    True
+
+    >>> is_number("Inf")
+    True
+    """
+    try:
+        float(string)
+        return True
+    except ValueError:
+        return False

tests/conftest.py

@@ -81,8 +81,9 @@ def invalid_add_type_error_msg():
 
 
 @pytest.fixture
-def y_grid_size_mismatch_error_msg():
+def x_values_not_equal_error_msg():
     return (
-        "The two objects have different y-array lengths. "
-        "Please ensure the length of the y-value during initialization is identical."
+        "The two objects have different values in x arrays (my_do.all_arrays[:, [1, 2, 3]]). "
+        "Please ensure the x values of the two objects are identical by re-instantiating "
+        "the DiffractionObject with the correct x value inputs."
     )

tests/test_diffraction_objects.py

@@ -780,28 +780,28 @@ def test_scalar_operations(operation, starting_yarray, scalar_value, expected_ya
 
 
 @pytest.mark.parametrize(
-    "operation, " "expected_do_1_all_arrays_with_y_modified, " "expected_do_2_all_arrays_with_y_modified",
+    "operation, expected_do_1_all_arrays_with_y_modified, expected_do_2_all_arrays_with_y_modified",
     [
         # Test addition, subtraction, multiplication, and division of two DO objects
         (  # Test addition of two DO objects, expect combined yarray values
             "add",
             np.array([[2.0, 0.51763809, 30.0, 12.13818192], [4.0, 1.0, 60.0, 6.28318531]]),
-            np.array([[2.0, 6.28318531, 100.70777771, 1], [4.0, 3.14159265, 45.28748053, 2.0]]),
+            np.array([[2.0, 0.51763809, 30.0, 12.13818192], [4.0, 1.0, 60.0, 6.28318531]]),
         ),
         (  # Test subtraction of two DO objects, expect differences in yarray values
             "sub",
             np.array([[0.0, 0.51763809, 30.0, 12.13818192], [0.0, 1.0, 60.0, 6.28318531]]),
-            np.array([[0.0, 6.28318531, 100.70777771, 1], [0.0, 3.14159265, 45.28748053, 2.0]]),
+            np.array([[0.0, 0.51763809, 30.0, 12.13818192], [0.0, 1.0, 60.0, 6.28318531]]),
         ),
         (  # Test multiplication of two DO objects, expect multiplication in yarray values
             "mul",
             np.array([[1.0, 0.51763809, 30.0, 12.13818192], [4.0, 1.0, 60.0, 6.28318531]]),
-            np.array([[1.0, 6.28318531, 100.70777771, 1], [4.0, 3.14159265, 45.28748053, 2.0]]),
+            np.array([[1.0, 0.51763809, 30.0, 12.13818192], [4.0, 1.0, 60.0, 6.28318531]]),
         ),
         (  # Test division of two DO objects, expect division in yarray values
             "div",
             np.array([[1.0, 0.51763809, 30.0, 12.13818192], [1.0, 1.0, 60.0, 6.28318531]]),
-            np.array([[1.0, 6.28318531, 100.70777771, 1], [1.0, 3.14159265, 45.28748053, 2.0]]),
+            np.array([[1.0, 0.51763809, 30.0, 12.13818192], [1.0, 1.0, 60.0, 6.28318531]]),
         ),
     ],
 )
@@ -810,15 +810,14 @@ def test_binary_operator_on_do(
     expected_do_1_all_arrays_with_y_modified,
     expected_do_2_all_arrays_with_y_modified,
     do_minimal_tth,
-    do_minimal_d,
 ):
     do_1 = do_minimal_tth
-    do_2 = do_minimal_d
+    do_2 = do_minimal_tth
     assert np.allclose(
         do_1.all_arrays, np.array([[1.0, 0.51763809, 30.0, 12.13818192], [2.0, 1.0, 60.0, 6.28318531]])
     )
     assert np.allclose(
-        do_2.all_arrays, np.array([[1.0, 6.28318531, 100.70777771, 1], [2.0, 3.14159265, 45.28748053, 2.0]])
+        do_2.all_arrays, np.array([[1.0, 0.51763809, 30.0, 12.13818192], [2.0, 1.0, 60.0, 6.28318531]])
     )
 
     if operation == "add":
@@ -856,13 +855,31 @@ def test_operator_invalid_type(do_minimal_tth, invalid_add_type_error_msg):
 
 
 @pytest.mark.parametrize("operation", ["add", "sub", "mul", "div"])
-def test_operator_invalid_yarray_length(operation, do_minimal, do_minimal_tth, y_grid_size_mismatch_error_msg):
-    # Add two DO objects with different yarray lengths, expect ValueError
+def test_operator_invalid_xarray_values_not_equal(
+    operation, do_minimal_tth, do_minimal_d, x_values_not_equal_error_msg
+):
+    # Add two DO objects with different xarray values but equal in shape, expect ValueError
+    do_1 = do_minimal_tth
+    do_2 = do_minimal_d
+    with pytest.raises(ValueError, match=re.escape(x_values_not_equal_error_msg)):
+        if operation == "add":
+            do_1 + do_2
+        elif operation == "sub":
+            do_1 - do_2
+        elif operation == "mul":
+            do_1 * do_2
+        elif operation == "div":
+            do_1 / do_2
+
+
+@pytest.mark.parametrize("operation", ["add", "sub", "mul", "div"])
+def test_operator_invalid_xarray_shape_not_equal(
+    operation, do_minimal, do_minimal_tth, x_values_not_equal_error_msg
+):
+    # Add two DO objects with different xarrays shape, expect ValueError
     do_1 = do_minimal
     do_2 = do_minimal_tth
-    assert len(do_1.all_arrays[:, 0]) == 0
-    assert len(do_2.all_arrays[:, 0]) == 2
-    with pytest.raises(ValueError, match=re.escape(y_grid_size_mismatch_error_msg)):
+    with pytest.raises(ValueError, match=re.escape(x_values_not_equal_error_msg)):
         if operation == "add":
             do_1 + do_2
         elif operation == "sub":

tests/test_validators.py

@@ -0,0 +1,27 @@
+import pytest
+
+from diffpy.utils.validators import is_number
+
+
+@pytest.mark.parametrize(
+    "input,expected",
+    [
+        ("3.14", True),  # Standard float
+        ("2", True),  # Integer
+        ("-100", True),  # Negative integer
+        ("-3.14", True),  # Negative float
+        ("0", True),  # Zero
+        ("4.5e-1", True),  # Scientific notation
+        ("abc", False),  # Non-numeric string
+        ("", False),  # Empty string
+        ("3.14.15", False),  # Multiple dots
+        ("2+3", False),  # Arithmetic expression
+        ("NaN", True),  # Not a Number (special float value)
+        ("Infinity", True),  # Positive infinity
+        ("-Infinity", True),  # Negative infinity
+        ("Inf", True),  # Positive infinity
+        ("-Inf", True),  # Negative infinity
+    ],
+)
+def test_is_number(input, expected):
+    assert is_number(input) == expected