diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 47762116..bac1be67 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -3,9 +3,9 @@ updates: - package-ecosystem: "pip" directory: "/" schedule: - interval: "weekly" + interval: "monthly" - package-ecosystem: "github-actions" directory: "/" schedule: - interval: "weekly" + interval: "monthly" diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index 287684e1..bfa2dd9f 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -11,8 +11,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - # Python 3.11 is blocked by the following issue: https://github.com/h5py/h5py/issues/2146 - python-version: ["3.8", "3.9", "3.10"] + python-version: ["3.8", "3.9", "3.10", "3.11"] steps: - uses: actions/checkout@v4 diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index dbb9869a..3ee06753 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -17,7 +17,7 @@ repos: - id: black # linter - repo: https://github.com/PyCQA/flake8 - rev: 7.0.0 + rev: 7.1.0 hooks: - id: flake8 exclude: ^docs/ diff --git a/docs/changelog.md b/docs/changelog.md index 14b269d6..16e17a8f 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -1,5 +1,9 @@ # Change Log +## v0.3.5 (18 Jun. 2024) + +- Make compatible with NumPy 2.0.0 + ## v0.3.3 (11 Jan. 2023) - Improve comparison between linear subspaces [[#53]](https://github.com/spglib/spgrep/pull/53) - Use Grassmann distance to measure linear subspaces: {func}`spgrep.utils.grassmann_distance` diff --git a/docs/development/development.md b/docs/development/development.md index 71457575..97aba82e 100644 --- a/docs/development/development.md +++ b/docs/development/development.md @@ -48,8 +48,7 @@ vim docs/changelog.md # Push with tag git tag -git push origin main -git push origin --tags +git push origin ``` ## Subpages diff --git a/docs/examples/lattice_vibration.ipynb b/docs/examples/lattice_vibration.ipynb index 543c6ecf..a9fa121a 100644 --- a/docs/examples/lattice_vibration.ipynb +++ b/docs/examples/lattice_vibration.ipynb @@ -23,14 +23,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "spgrep==0.3.4.dev12+g7a90fec.d20230402\n" + "spgrep==0.3.4.dev177+gd763494\n" ] } ], @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -105,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -154,7 +154,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -188,7 +188,7 @@ " perm_i = permutations[i]\n", " shifts[i] = positions @ Ri.T + vi[None, :] - positions[perm_i]\n", "\n", - " perm_rep = np.zeros((little_order, num_atoms, num_atoms), dtype=np.complex_)\n", + " perm_rep = np.zeros((little_order, num_atoms, num_atoms), dtype=np.complex128)\n", " for i, Ri in enumerate(little_rotations):\n", " for kappa in range(num_atoms):\n", " kappa2 = permutations[i, kappa]\n", @@ -199,7 +199,7 @@ " # Rotation matrix in cartesian (order, 3, 3)\n", " A = np.transpose(lattice) # column-wise lattice vectors\n", " Ainv = np.linalg.inv(A)\n", - " rotation_rep = np.array([A @ r @ Ainv for r in little_rotations], dtype=np.complex_)\n", + " rotation_rep = np.array([A @ r @ Ainv for r in little_rotations], dtype=np.complex128)\n", "\n", " rep = np.einsum(\"ipq,iab->ipaqb\", perm_rep, rotation_rep, optimize=\"greedy\")\n", " return rep.reshape(-1, num_atoms * 3, num_atoms * 3)\n", @@ -220,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -229,7 +229,7 @@ "(16, 15, 15)" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -240,12 +240,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -280,7 +280,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -293,12 +293,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -324,7 +324,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -345,7 +345,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -399,7 +399,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.10" + "version": "3.11.9" }, "orig_nbformat": 4, "vscode": { diff --git a/docs/examples/symmetry_adapted_tensor.ipynb b/docs/examples/symmetry_adapted_tensor.ipynb index c409a222..f558a05a 100644 --- a/docs/examples/symmetry_adapted_tensor.ipynb +++ b/docs/examples/symmetry_adapted_tensor.ipynb @@ -26,7 +26,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "spgrep==0.3.2.dev5+ga44d231\n" + "spgrep==0.3.4.dev177+gd763494\n" ] } ], @@ -153,7 +153,7 @@ " [0, 0, 0],\n", " [0, 0, 0],\n", " ],\n", - " dtype=np.float_,\n", + " dtype=np.float64,\n", " ),\n", " np.array(\n", " [\n", @@ -161,7 +161,7 @@ " [0, 1, 0],\n", " [0, 0, 0],\n", " ],\n", - " dtype=np.float_,\n", + " dtype=np.float64,\n", " ),\n", " np.array(\n", " [\n", @@ -169,7 +169,7 @@ " [0, 0, 0],\n", " [0, 0, 1],\n", " ],\n", - " dtype=np.float_,\n", + " dtype=np.float64,\n", " ),\n", " np.array(\n", " [\n", @@ -177,7 +177,7 @@ " [0, 0, 1],\n", " [0, 1, 0],\n", " ],\n", - " dtype=np.float_,\n", + " dtype=np.float64,\n", " )\n", " / np.sqrt(2),\n", " np.array(\n", @@ -186,7 +186,7 @@ " [0, 0, 0],\n", " [1, 0, 0],\n", " ],\n", - " dtype=np.float_,\n", + " dtype=np.float64,\n", " )\n", " / np.sqrt(2),\n", " np.array(\n", @@ -195,7 +195,7 @@ " [1, 0, 0],\n", " [0, 0, 0],\n", " ],\n", - " dtype=np.float_,\n", + " dtype=np.float64,\n", " )\n", " / np.sqrt(2),\n", " ]\n", @@ -237,9 +237,9 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABVUAAAHNCAYAAAAe4JuCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAacUlEQVR4nO3dQY4T19fG4VNWD5HMPCOkXoCzAnev3HgF8QKQ2AItMXZ9g44D+X8Icupe+tYpP48UqSe+NvnZRfHGCtM8zwEAAAAAwH+zG/0CAAAAAAAqMaoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgISHXgdN0/RXRHyIiK8R8anXufwnjxHxLiI+z/P859JDNByqS8MIHQfSsD4N69OwPg23wb1pfT6L9WlYn4b1aVjfTxtO8zx3eZZpmr5ExL7LYSz1Ms/z+6UP1nAVmhpG6LgCGtanYX0a1qfhNrg3rc9nsT4N69OwPg3r+2HDbt9Ujde1fL+PiMPSE47Hbi/mnlwul3h5eYl4bdBCw0E6Nrydsd/v93E4HJadcD63vYI7fB9oWN9vaRiup29Jw/pcS7eh+72phm/O9bQ+Devze2J9Gtb3q4Y9R9VPEfHHISI+Lj3hdOr1Wu7K0/NznF8/HK1fAddwkI4Nb2f8cTgc4uPSHrvG/93yHb4PNKzvtzQM19O3pGF9rqXb0P3eVMM353pan4b1+T2xPg3r+1VDf1EVAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEh46H7i8RhxOi177K5x471e2x7PKw234Xxe3kOHddCwPtfT+jSsz7W0Pg23wfW0Pg3rcz2tT8NV8U1VAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABIeRr+Af7le2x6/a9iIW5+bVxqux/EYcTqNeW4d+9Dwvrme1qfhOriW1qchrqf1abgOrqf1abgqvqkKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAICEh9EvoKvrdfljd437cstz842G2zDy36X3QR8a1tfw72HaTU1PPV/npsfzNw3rG3g98h7oRMNt8GeM+jSsz58v6tPw//FNVQAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASHka/gNW4Xtsev2vcp1ufHw03YtpNTY+fdRhOw/rm69z0+Pb3QNvzo+EmNN6XuJaugIbb0NjB9XQFNKzPn9Xr22hD31QFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACABKMqAAAAAECCURUAAAAAIOFh9AvYjOu17fE7+/ZwGq7CfJ2HPv+0m4Y+/xZoSPN7wPV0OA1XoPW+pJFraQcaEu3XUx3H03AFBl9P3dd0sNGG3hkAAAAAAAlGVQAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEh46HjWY0TE5XKJp+fnjsfyK5dvPz42HqXhIJdvP7Y2/OcMHd/a5faDhmVdbj9oWNTl248aFnX59qOGpV1uP7g3Lety+8FnsazL7QcNy7rcftCwqMu3HzUs6vLtxx82nOZ57vJE0zR9iYh9l8NY6mWe5/dLH6zhKjQ1jNBxBTSsT8P6NKxPw21wb1qfz2J9GtanYX0a1vfDhj2/qfo5Ij5ExNeI+NTxXH7tMSLexWuDFhqO06thhI6jaFifhvVpWJ+G2+DetD6fxfo0rE/D+jSs76cNu31TFQAAAADgHviLqgAAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQ89Dpomqa/IuJDRHyNiE+9zuU/eYyIdxHxeZ7nP5ceouFQXRpG6DiQhvVpWJ+G9Wm4De5N6/NZrE/D+jSsT8P6ftpwmue5y7NM0/QlIvZdDmOpl3me3y99sIar0NQwQscV0LA+DevTsD4Nt8G9aX0+i/VpWJ+G9WlY3w8bdvumaryu5ft9RByWnnA8dnsx9+RyucTLy0vEa4MWGg7SseHtjP1+v4/D4bDshPO57RXc4ftAw/pW17BVy3ugaH8Nv6Ph7QwNB+h+b6rhm/NZ/E7Rjhp+R8PbGRq+MQ2/s9GGPUfVTxHxxyEiPi494XTq9VruytPzc5xf39ytXwHXcJCODW9n/HE4HOLj0h67xv/d8h2+DzSsb3UNW7W8B4r21/A7Gt7O0HCA7vemGr45n8XvFO2o4Xc0vJ2h4RvT8DsbbegvqgIAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACQ/dTzweI06nZY/dNW6812vb43ml4Tacz8t76LAOGtY3sqH3QB8a3jf3NfVpuB6up/VpeN9cT+vTsDvfVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAg4WH0C/iX67Xt8buGjbj1uXml4XocjxGn05jn1rEPDetradjSIEKHXjSs73xe3kKDddBwG1xP69OwPtfT+jRcFd9UBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAwsPoF9DV9br4odNuanrq+To3PZ6/abgNDR1beR90ouF4AxsMt9vIf/PVcB2Ox4jTafSrKKf1WtyVhousqmEr19P6NFwH19NFVnU91XCR39VwRZ9uAAAAAID1M6oCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDhYfQLWIv5OrcdsGvcp6/Xtsej4UZMu6np8c3vA5ppuAGjr4dLH//8HHE+tz33VmhI43tgbngPPMnYh4arMPy+xvW0mYaMeg+4lvaz1oa+qQoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAwsPoF7AZ12vTw6fd1OmFsJiGqzBf57EvYOe/NbXScAMar4fNDVqfHw03oPW+YtZgOA23ofW+pv19MPi+agM03IDG+xLX0xXYaEN/8gQAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQMJDx7MeIyIul0s8PT93PJZfu9x+eGw8SMNhLrcfWhv+c4aOb+vy7UcNi7p8+1HD0Rb+O7tcLrcfNRxNw+GeBv6SO3bUcBCfxfVY+j7QcD00XIFBv2YNO1ppw2me5y5PNE3Tl4jYdzmMpV7meX6/9MEarkJTwwgdV0DD+jSsT8P6NNwG96b1+SzWp2F9GtanYX0/bNjzm6qfI+JDRHyNiE8dz+XXHiPiXbw2aKHhOL0aRug4iob1aVifhvVpuA3uTevzWaxPw/o0rE/D+n7asNs3VQEAAAAA7oG/qAoAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACAhIdeB03T9FdEfIiIrxHxqde5/CePEfEuIj7P8/zn0kM0HKpLwwgdB9KwPg3r07A+DbfBvWl9Pov1aVifhvVpWN9PG07zPHd5lmmavkTEvsthLPUyz/P7pQ/WcBWaGkbouAIa1qdhfRrWp+E2uDetz2exPg3r07A+Dev7YcNu31SN17V8v9/v43A4dDw24Xxe/tjjsd/reGOXyyVeXl4iXhu00HCQjg1vZ+j4xjT8joa3MzR8Yxp+R8PbGRoO4N70bxretHds6RBRusVSGtb3WxpGxGHpCXfYoJWG9f2qYc9R9VNE/HE4HOLj6dTx2IRdw/8idtRr7uDp+TnOr79JtX4FXMNBOja8naHjG9PwOxreztDwjWn4HQ1vZ2g4gHvTv2l4096xpUNE6RZLaVjfb2kYER+XnnCHDVppWN+vGvqLqgAAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAwkP3E8/niN3CrfZ6bXvu1sfzSkOW9r/RcTwN18H1tD4N75traX0abkNrh5b3gfdAHxquw/EYcTqNeW4N+9BwVXxTFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAICEh+4nHo8Rp9Oyx+4aN97rte3xvNJwG87n5T10WAcN63M9rU/D+lxL69NwG0Z29D7oQ8P75r6mPg27801VAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkPIx+Af9yvY5+BcNMu2n0S+hDw/U4HiNOp9Gvop7div5bk4bLrKlhC9fT+jRcB9fSZdZ0LdVwmTU1jLjfjq0d1vR7iYbLrKlhi4G/jtb7ivk6d3olxWnY3cp+pwUAAAAAWDejKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEh5Gv4DV2DXuy9dr08Pn67z4sU/PEedz09Nvg4ZEjHsfPIvYjYbDTbup6fEt18OWx7uWfqMh7e+Bhvsi19MuNNyIxj9jNN8X0U7D4VrvS1q1Xo/ZbkOfbgAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASHka/gNW4XpsePu2mpsfP17np8YSGW7Fr/G89je8DOtCwvObrmffAcBrW576kPg03YvT1cOnjn58jzue2594KDWl8D8wLGz5J2M9KG/qmKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEh46nvUYEXG5XOLp+bnjsffhqeFf2eVyuf342PgyNGywkob/nHG3HQf9mjXsSEMW/jvTcEU0HK7lvqSVe9M+NtLwnzPutaP7mg3QEPc19f2mhtM8z8te0P8eNE1fImLf5TCWepnn+f3SB2u4Ck0NI3RcAQ3r07A+DevTcBvcm9bns1ifhvVpWJ+G9f2wYc9vqn6OiA8R8TUiPnU8l197jIh38dqghYbj9GoYoeMoGtanYX0a1qfhNrg3rc9nsT4N69OwPg3r+2nDbt9UBQAAAAC4B/6iKgAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASHnodNE3TXxHxISK+RsSnXufynzxGxLuI+DzP859LD9FwqC4NI3QcSMP6NKxPw/o03Ab3pvX5LNanYX0a1qdhfT9tOM3z3OVZpmn6EhH7Loex1Ms8z++XPljDVWhqGKHjCmhYn4b1aVifhtvg3rQ+n8X6NKxPw/o0rO+HDbt9UzVe1/L9fr+Pw+Gw7ITzue0VHI9tjy/qcrnEy8tLxGuDFhoO0rHh7Yz9PiIOS0+40w4tNKzvtzR0PX1TGtbnWroN3e9NQ8O35npan4b1+T2xPg3r+1XDnqPqp4j443A4xMfTadkJu8b/xevS5y3u6fk5zq+/SbV+BVzDQTo2vJ3xxyEiPi494U47tNCwvt/S0PX0TWlYn2vpNnS/Nw0N35rraX0a1uf3xPo0rO9XDf1FVQAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJDwMPoF/Mv12vb4XcNG3PrcvNJwPY7HiNNpzHPr2IeG9831tD4N18G1tD4NcT2tT8N1cD2tT8NV8U1VAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABIeup94PkfsFm6112vbc7c+nlcasrT/jY7jabgOrqf1aXjfXEvr03A9XE/r0/C+uZ7Wp2F3vqkKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAICEh+4nHo8Rp1P3Y9du2k1Nj5+vc6dX0oGGi6yqYavrddxz7xr/W8/I174mGq6D6+kiq7qearjIqhq2cC2tT8P1uNPr6abeBxous6aGLQb+OtyXdKJhd76pCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACABKMqAAAAAECCURUAAAAAIMGoCgAAAACQYFQFAAAAAEgwqgIAAAAAJBhVAQAAAAASjKoAAAAAAAlGVQAAAACABKMqAAAAAEDCw+gXsBXzdW47YGffHk3Dlbhehz79tJuGPv8maHj3Wq+nGo6n4QoMvpa6r+lAQyKa3weupyug4XDNf1Zv5XrabKsNvTMAAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCqAgAAAAAkGFUBAAAAABKMqgAAAAAACUZVAAAAAIAEoyoAAAAAQIJRFQAAAAAgwagKAAAAAJBgVAUAAAAASDCq/m3aTU3/NLtel/9zPLY//wZoSET7+2C+zov+kbAfDVdgt2v7p5GGHWhI63vAfc14Gq7C6D9juJ6205Dm94Br6XBrbWhUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAwkPHsx4jIi6XSzw9P3c8toangb/ky+Vy+/Gx8SgNB+nY8J8z7rVjq6XvAw3XQ8MVGPRr1rAjDWn4d+bedCXW0fCfM+6146g/Y2jYj4b480V9v6vhNM/zspP/96Bp+hIR+y6HsdTLPM/vlz5Yw1Voahih4wpoWJ+G9WlYn4bb4N60Pp/F+jSsT8P6NKzvhw17flP1c0R8iIivEfGp47n82mNEvIvXBi00HKdXwwgdR9GwPg3r07A+DbfBvWl9Pov1aVifhvVpWN9PG3b7pioAAAAAwD3wF1UBAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABIMKoCAAAAACQYVQEAAAAAEoyqAAAAAAAJRlUAAAAAgASjKgAAAABAglEVAAAAACDBqAoAAAAAkGBUBQAAAABI+D/alo/QkWfwCwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -312,9 +312,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -388,7 +388,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.11.9" }, "orig_nbformat": 4, "vscode": { diff --git a/examples/lattice_vibration.py b/examples/lattice_vibration.py index 8dbcd750..57fe89d1 100644 --- a/examples/lattice_vibration.py +++ b/examples/lattice_vibration.py @@ -37,7 +37,7 @@ def get_displacements_representation( perm_i = permutations[i] shifts[i] = positions @ Ri.T + vi[None, :] - positions[perm_i] - perm_rep = np.zeros((little_order, num_atoms, num_atoms), dtype=np.complex_) + perm_rep = np.zeros((little_order, num_atoms, num_atoms), dtype=np.complex128) for i, Ri in enumerate(little_rotations): for kappa in range(num_atoms): kappa2 = permutations[i, kappa] @@ -48,7 +48,7 @@ def get_displacements_representation( # Rotation matrix in cartesian (order, 3, 3) A = np.transpose(lattice) # column-wise lattice vectors Ainv = np.linalg.inv(A) - rotation_rep = np.array([A @ r @ Ainv for r in little_rotations], dtype=np.complex_) + rotation_rep = np.array([A @ r @ Ainv for r in little_rotations], dtype=np.complex128) rep = np.einsum("ipq,iab->ipaqb", perm_rep, rotation_rep, optimize="greedy") return rep.reshape(-1, num_atoms * 3, num_atoms * 3) diff --git a/setup.py b/setup.py index dbb350bc..af1dd970 100644 --- a/setup.py +++ b/setup.py @@ -23,8 +23,8 @@ # What packages are optional? EXTRAS = { "dev": [ - "pytest==8.2.2", - "pytest-cov==5.0.0", + "pytest", + "pytest-cov", "pre-commit", "black", "mypy", @@ -32,7 +32,7 @@ "pyupgrade", "pydocstyle", "nbqa", - "phonopy==2.24.2", + "phonopy", # Jupyter notebook "notebook", "matplotlib", @@ -93,6 +93,7 @@ "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", "Topic :: Scientific/Engineering :: Mathematics", "Topic :: Scientific/Engineering :: Physics", ], diff --git a/src/spgrep/corep.py b/src/spgrep/corep.py index b0fbafcb..359e19ec 100644 --- a/src/spgrep/corep.py +++ b/src/spgrep/corep.py @@ -186,14 +186,14 @@ def enumerate_spinor_small_corepresentations( if indicator == 1: # Unitary matrix s.t. irrep @ U = conj_irrep @ U U = get_intertwiner(irrep, conj_irrep, atol, max_num_random_generations) - corep = np.zeros((order, dim, dim), dtype=np.complex_) + corep = np.zeros((order, dim, dim), dtype=np.complex128) corep[xsg_indices] = irrep corep[a0u] = ( np.conj(factor_system[a0_idx, xsg_indices])[:, None, None] * U[None, :, :] @ irrep ) elif indicator == -1: U = get_intertwiner(irrep, conj_irrep, atol, max_num_random_generations) - corep = np.zeros((order, 2 * dim, 2 * dim), dtype=np.complex_) + corep = np.zeros((order, 2 * dim, 2 * dim), dtype=np.complex128) # [ [irrep, 0], # [0, conj_irrep]] @@ -202,7 +202,7 @@ def enumerate_spinor_small_corepresentations( # [ [0, -U], # [U, 0] ] - corep_a0 = np.zeros((2 * dim, 2 * dim), dtype=np.complex_) + corep_a0 = np.zeros((2 * dim, 2 * dim), dtype=np.complex128) corep_a0[:dim, dim:] = -U corep_a0[dim:, :dim] = U @@ -212,7 +212,7 @@ def enumerate_spinor_small_corepresentations( @ corep[xsg_indices] ) elif indicator == 0: - corep = np.zeros((order, 2 * dim, 2 * dim), dtype=np.complex_) + corep = np.zeros((order, 2 * dim, 2 * dim), dtype=np.complex128) # [ [irrep, 0], # [0, conj_irrep]] @@ -221,11 +221,11 @@ def enumerate_spinor_small_corepresentations( # [ [0, omega(a0, a0) irrep[a0 * a0]], # [1, 0] ] - corep_a0 = np.zeros((2 * dim, 2 * dim), dtype=np.complex_) + corep_a0 = np.zeros((2 * dim, 2 * dim), dtype=np.complex128) corep_a0[:dim, dim:] = ( factor_system[a0_idx, a0_idx] * irrep[xsg_indices_mapping[table[a0_idx, a0_idx]]] ) - corep_a0[dim:, :dim] = np.eye(dim, dtype=np.complex_) + corep_a0[dim:, :dim] = np.eye(dim, dtype=np.complex128) corep[a0u] = ( np.conj(factor_system[a0_idx, xsg_indices])[:, None, None] @@ -277,12 +277,12 @@ def get_corep_spinor_factor_system( [0, -1], [1, 0], ], - dtype=np.complex_, + dtype=np.complex128, ) # Assign a unitary or anti-unitary operator for each magnetic operation order = len(rotations) - unitary_rotations = np.zeros((order, 2, 2), dtype=np.complex_) + unitary_rotations = np.zeros((order, 2, 2), dtype=np.complex128) anti_linear = np.zeros((order,), dtype=np.bool_) for i, (rotation, time_reversal) in enumerate(zip(rotations, time_reversals)): unitary_rotation = get_spinor_unitary_rotation(lattice, rotation) @@ -297,7 +297,7 @@ def get_corep_spinor_factor_system( # Factor system for spinor co-rep table = get_cayley_table(rotations, time_reversals) - corep_spinor_factor_system = np.zeros((order, order), dtype=np.complex_) + corep_spinor_factor_system = np.zeros((order, order), dtype=np.complex128) for i, (ui, ai) in enumerate(zip(unitary_rotations, anti_linear)): for j, uj in enumerate(unitary_rotations): if ai: diff --git a/src/spgrep/group.py b/src/spgrep/group.py index 67e82ff5..e2077371 100644 --- a/src/spgrep/group.py +++ b/src/spgrep/group.py @@ -131,7 +131,7 @@ def get_factor_system_from_little_group( # Never take modulus! residuals[i] = rotation.T @ kpoint - kpoint - factor_system = np.zeros((n, n), dtype=np.complex_) + factor_system = np.zeros((n, n), dtype=np.complex128) for i, residual in enumerate(residuals): for j, translation in enumerate(little_translations): factor_system[i, j] = np.exp(-2j * np.pi * np.dot(residual, translation)) diff --git a/src/spgrep/irreps.py b/src/spgrep/irreps.py index 1aae7d90..d17f80b1 100644 --- a/src/spgrep/irreps.py +++ b/src/spgrep/irreps.py @@ -177,7 +177,7 @@ def enumerate_unitary_irreps( """ order = rotations.shape[0] if factor_system is None: - factor_system = np.ones((order, order), dtype=np.complex_) + factor_system = np.ones((order, order), dtype=np.complex128) if method == "Neto": table = get_cayley_table(rotations) @@ -264,10 +264,10 @@ def enumerate_unitary_irreps_from_regular_representation( # For (m, i), reg[m, i, :] has only one nonzero entry. # To reduce computational time, suppress reg to only nonzero elements - reg_nonzero = np.zeros((n, n), dtype=np.complex_) + reg_nonzero = np.zeros((n, n), dtype=np.complex128) lookup = np.zeros((n, n), dtype=int) for m, i in product(range(n), repeat=2): - idx = np.nonzero(reg[m, i, :])[0] + idx = np.nonzero(reg[m, i, :])[0].item() reg_nonzero[m, i] = reg[m, i, idx] lookup[m, i] = idx @@ -277,7 +277,7 @@ def enumerate_unitary_irreps_from_regular_representation( hermite_random = rng.random((n, n)) + rng.random((n, n)) * 1j hermite_random += np.conj(hermite_random.T) - hermite_random_reordered = np.zeros((n, n, n), dtype=np.complex_) + hermite_random_reordered = np.zeros((n, n, n), dtype=np.complex128) meshi, meshj = np.meshgrid(range(n), range(n)) # hermite_random_reordered[m, i, j] = hermite_random[lookup[m, i], lookup[m, j]] for m in range(n): @@ -434,7 +434,7 @@ def enumerate_unitary_irreps_from_solvable_group_chain( """ identity = get_identity_index(table) group = [identity] # int -> GroupIdx - irreps = [np.ones((1, 1, 1), dtype=np.complex_)] + irreps = [np.ones((1, 1, 1), dtype=np.complex128)] # Extend subgroups from identity to whole for r in solvable_chain_generators[::-1]: @@ -504,13 +504,13 @@ def enumerate_unitary_irreps_from_solvable_group_chain( omegaq = omega * np.exp(2j * np.pi * q / p) delta_r = intertwiner / omegaq # Rep. matrix for r delta_rm = [ - np.eye(intertwiner.shape[0], dtype=np.complex_) + np.eye(intertwiner.shape[0], dtype=np.complex128) ] # delta_rm[m] is rep. matrix for r^m for m in range(1, p): # D(r^m) = D(r) @ D(r^{m-1}) / mu(r, r^{m-1}) delta_rm.append(delta_r @ delta_rm[m - 1] / factor_system[r, rm[m - 1]]) - next_irrep = np.zeros((len(group), dim, dim), dtype=np.complex_) + next_irrep = np.zeros((len(group), dim, dim), dtype=np.complex128) for m in range(p): for s in subgroup: idx = table[rm[m], s] @@ -522,7 +522,7 @@ def enumerate_unitary_irreps_from_solvable_group_chain( next_sub_irreps.append(next_irrep) else: # Mutually inequivalent - next_irrep = np.zeros((len(group), dim * p, dim * p), dtype=np.complex_) + next_irrep = np.zeros((len(group), dim * p, dim * p), dtype=np.complex128) for m in range(p): for s in subgroup: idx = table[rm[m], s] @@ -613,7 +613,7 @@ def get_physically_irrep( real_irrep = np.real(np.einsum("il,klm,mj->kij", T, irrep, np.conj(T), optimize="greedy")) elif indicator in [-1, 0]: - real_irrep = np.empty((order, 2 * dim, 2 * dim), dtype=np.float_) + real_irrep = np.empty((order, 2 * dim, 2 * dim), dtype=np.float64) # [ [Re D(g), Im D(g)] # [-Im D(g), Re D(g)] ] real_irrep[:, :dim, :dim] = np.real(irrep) diff --git a/src/spgrep/representation.py b/src/spgrep/representation.py index 63e1ce19..cbf97656 100644 --- a/src/spgrep/representation.py +++ b/src/spgrep/representation.py @@ -59,7 +59,7 @@ def get_projective_regular_representation( n = len(rotations) table = get_cayley_table(rotations) - reg = np.zeros((n, n, n), dtype=np.complex_) + reg = np.zeros((n, n, n), dtype=np.complex128) for k, j in product(range(n), repeat=2): reg[k, table[k, j], j] = factor_system[k, j] @@ -120,7 +120,7 @@ def get_character(representation: NDArrayComplex) -> NDArrayComplex: ------- character: array, (order, ) """ - character = np.einsum("ijj->i", representation, optimize="greedy").astype(np.complex_) + character = np.einsum("ijj->i", representation, optimize="greedy").astype(np.complex128) return character @@ -251,7 +251,7 @@ def is_representation( """Return true if given matrix function is a (projective) representation with given factor system.""" order = rep.shape[0] if factor_system is None: - factor_system = np.ones((order, order), dtype=np.complex_) + factor_system = np.ones((order, order), dtype=np.complex128) for i, ri in enumerate(rep): for j, rj in enumerate(rep): @@ -302,7 +302,7 @@ def check_spacegroup_representation( """Check definition of representation. This function works for primitive and conventional cell.""" order = len(little_rotations) if spinor_factor_system is None: - spinor_factor_system = np.ones((order, order), dtype=np.complex_) + spinor_factor_system = np.ones((order, order), dtype=np.complex128) little_rotations_int = [ndarray2d_to_integer_tuple(rotation) for rotation in little_rotations] diff --git a/src/spgrep/spinor.py b/src/spgrep/spinor.py index 6948a7b6..7144c1cf 100644 --- a/src/spgrep/spinor.py +++ b/src/spgrep/spinor.py @@ -125,13 +125,13 @@ def get_spinor_factor_system( order = len(rotations) # Assign a SU(2) rotation for each O(3) operation - unitary_rotations = np.zeros((order, 2, 2), dtype=np.complex_) + unitary_rotations = np.zeros((order, 2, 2), dtype=np.complex128) for i, rotation in enumerate(rotations): unitary_rotations[i] = get_spinor_unitary_rotation(lattice, rotation) # Factor system from spin table = get_cayley_table(rotations) - spinor_factor_system = np.zeros((order, order), dtype=np.complex_) + spinor_factor_system = np.zeros((order, order), dtype=np.complex128) for (i, ui), (j, uj) in product(enumerate(unitary_rotations), repeat=2): # si @ sj = sk in O(3) k = table[i, j] diff --git a/src/spgrep/utils.py b/src/spgrep/utils.py index 8fe16ca7..38ac2196 100644 --- a/src/spgrep/utils.py +++ b/src/spgrep/utils.py @@ -11,8 +11,8 @@ NDArrayBool: TypeAlias = NDArray[np.bool_] NDArrayInt: TypeAlias = NDArray[np.int_] -NDArrayFloat: TypeAlias = NDArray[np.float_] -NDArrayComplex: TypeAlias = NDArray[np.complex_] +NDArrayFloat: TypeAlias = NDArray[np.float64] +NDArrayComplex: TypeAlias = NDArray[np.complex128] def is_integer_array(array: NDArrayFloat, rtol: float = 1e-5, atol: float = 1e-8) -> bool: @@ -54,7 +54,7 @@ def is_prime(n: int) -> bool: return True -def nroot(z: np.complex_, n: int) -> np.complex_: +def nroot(z: np.complex128, n: int) -> np.complex128: """Return `n`-th power root of `z` with the minimum angle.""" root = z ** (1 / n) r = np.absolute(root) diff --git a/tests/test_corep.py b/tests/test_corep.py index 93a120bc..f1c7977b 100644 --- a/tests/test_corep.py +++ b/tests/test_corep.py @@ -57,7 +57,7 @@ def test_corep_spinor_factor_system(request, symmetry_and_lattice): for unitary_rotation in unitary_rotations: assert np.allclose( unitary_rotation @ np.conj(unitary_rotation).T, - np.eye(2, dtype=np.complex_), + np.eye(2, dtype=np.complex128), ) # Cocycle condition diff --git a/tests/test_pir.py b/tests/test_pir.py index 0da1dc18..e5b361e3 100644 --- a/tests/test_pir.py +++ b/tests/test_pir.py @@ -57,7 +57,7 @@ def check_spacegroup_pir( m12 = phase * rep[idx] else: half_dim = rep.shape[1] // 2 - rep_additional = np.zeros((2 * half_dim, 2 * half_dim), dtype=np.complex_) + rep_additional = np.zeros((2 * half_dim, 2 * half_dim), dtype=np.complex128) # [ [ cos(kt), -sin(kt) ], # [ sin(kt), cos(kt) ] ] rep_additional[:half_dim, :half_dim] = np.cos( diff --git a/tests/test_spinor.py b/tests/test_spinor.py index 5cbd6c16..27f1d96d 100644 --- a/tests/test_spinor.py +++ b/tests/test_spinor.py @@ -48,7 +48,7 @@ def test_spinor_factor_system_symmorphic(C3v, hexagonal_lattice): for unitary_rotation in unitary_rotations: assert np.allclose( unitary_rotation @ np.conj(unitary_rotation).T, - np.eye(2, dtype=np.complex_), + np.eye(2, dtype=np.complex128), ) # Check factor system @@ -129,7 +129,7 @@ def test_get_spacegroup_spinor_irreps_from_primitive_symmetry(kpoint, shape_expe for unitary_rotation in little_unitary_rotations: assert np.allclose( unitary_rotation @ np.conj(unitary_rotation).T, - np.eye(2, dtype=np.complex_), + np.eye(2, dtype=np.complex128), ) # Check as representation @@ -159,7 +159,7 @@ def test_get_crystallographic_pointgroup_spinor_irreps_from_symmetry(Oh): for unitary_rotation in unitary_rotations: assert np.allclose( unitary_rotation @ np.conj(unitary_rotation).T, - np.eye(2, dtype=np.complex_), + np.eye(2, dtype=np.complex128), ) # Check as representation diff --git a/tests/test_tensor.py b/tests/test_tensor.py index d317c85a..2a0715b9 100644 --- a/tests/test_tensor.py +++ b/tests/test_tensor.py @@ -18,7 +18,7 @@ def get_standard_basis() -> list[np.ndarray]: [0, 0, 0], [0, 0, 0], ], - dtype=np.float_, + dtype=np.float64, ), np.array( [ @@ -26,7 +26,7 @@ def get_standard_basis() -> list[np.ndarray]: [0, 1, 0], [0, 0, 0], ], - dtype=np.float_, + dtype=np.float64, ), np.array( [ @@ -34,7 +34,7 @@ def get_standard_basis() -> list[np.ndarray]: [0, 0, 0], [0, 0, 1], ], - dtype=np.float_, + dtype=np.float64, ), np.array( [ @@ -42,7 +42,7 @@ def get_standard_basis() -> list[np.ndarray]: [0, 0, 1], [0, 1, 0], ], - dtype=np.float_, + dtype=np.float64, ) / np.sqrt(2), np.array( @@ -51,7 +51,7 @@ def get_standard_basis() -> list[np.ndarray]: [0, 0, 0], [1, 0, 0], ], - dtype=np.float_, + dtype=np.float64, ) / np.sqrt(2), np.array( @@ -60,7 +60,7 @@ def get_standard_basis() -> list[np.ndarray]: [1, 0, 0], [0, 0, 0], ], - dtype=np.float_, + dtype=np.float64, ) / np.sqrt(2), ]