Add files using upload-large-folder tool

.gitattributes

@@ -732,3 +732,9 @@ mplug_owl2/x86_64-conda-linux-gnu/bin/ld filter=lfs diff=lfs merge=lfs -text
 mplug_owl2/x86_64-conda_cos7-linux-gnu/bin/ld filter=lfs diff=lfs merge=lfs -text
 llava_video/bin/python filter=lfs diff=lfs merge=lfs -text
 openflamingo/lib/python3.10/site-packages/transformers/models/speecht5/__pycache__/modeling_speecht5.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+phi4/bin/xzcat filter=lfs diff=lfs merge=lfs -text
+phi4/bin/xz filter=lfs diff=lfs merge=lfs -text
+phi4/bin/lzma filter=lfs diff=lfs merge=lfs -text
+phi4/bin/bunzip2 filter=lfs diff=lfs merge=lfs -text
+phi4/bin/x86_64-conda_cos7-linux-gnu-ld filter=lfs diff=lfs merge=lfs -text
+phi4/bin/unxz filter=lfs diff=lfs merge=lfs -text

mplug_owl2/include/openssl/bnerr.h

@@ -0,0 +1,47 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_BNERR_H
+# define OPENSSL_BNERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * BN reason codes.
+ */
+# define BN_R_ARG2_LT_ARG3                                100
+# define BN_R_BAD_RECIPROCAL                              101
+# define BN_R_BIGNUM_TOO_LONG                             114
+# define BN_R_BITS_TOO_SMALL                              118
+# define BN_R_CALLED_WITH_EVEN_MODULUS                    102
+# define BN_R_DIV_BY_ZERO                                 103
+# define BN_R_ENCODING_ERROR                              104
+# define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA                105
+# define BN_R_INPUT_NOT_REDUCED                           110
+# define BN_R_INVALID_LENGTH                              106
+# define BN_R_INVALID_RANGE                               115
+# define BN_R_INVALID_SHIFT                               119
+# define BN_R_NOT_A_SQUARE                                111
+# define BN_R_NOT_INITIALIZED                             107
+# define BN_R_NO_INVERSE                                  108
+# define BN_R_NO_PRIME_CANDIDATE                          121
+# define BN_R_NO_SOLUTION                                 116
+# define BN_R_NO_SUITABLE_DIGEST                          120
+# define BN_R_PRIVATE_KEY_TOO_LARGE                       117
+# define BN_R_P_IS_NOT_PRIME                              112
+# define BN_R_TOO_MANY_ITERATIONS                         113
+# define BN_R_TOO_MANY_TEMPORARY_VARIABLES                109
+
+#endif

mplug_owl2/include/openssl/httperr.h

@@ -0,0 +1,55 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_HTTPERR_H
+# define OPENSSL_HTTPERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * HTTP reason codes.
+ */
+# define HTTP_R_ASN1_LEN_EXCEEDS_MAX_RESP_LEN             108
+# define HTTP_R_CONNECT_FAILURE                           100
+# define HTTP_R_ERROR_PARSING_ASN1_LENGTH                 109
+# define HTTP_R_ERROR_PARSING_CONTENT_LENGTH              119
+# define HTTP_R_ERROR_PARSING_URL                         101
+# define HTTP_R_ERROR_RECEIVING                           103
+# define HTTP_R_ERROR_SENDING                             102
+# define HTTP_R_FAILED_READING_DATA                       128
+# define HTTP_R_HEADER_PARSE_ERROR                        126
+# define HTTP_R_INCONSISTENT_CONTENT_LENGTH               120
+# define HTTP_R_INVALID_PORT_NUMBER                       123
+# define HTTP_R_INVALID_URL_PATH                          125
+# define HTTP_R_INVALID_URL_SCHEME                        124
+# define HTTP_R_MAX_RESP_LEN_EXCEEDED                     117
+# define HTTP_R_MISSING_ASN1_ENCODING                     110
+# define HTTP_R_MISSING_CONTENT_TYPE                      121
+# define HTTP_R_MISSING_REDIRECT_LOCATION                 111
+# define HTTP_R_RECEIVED_ERROR                            105
+# define HTTP_R_RECEIVED_WRONG_HTTP_VERSION               106
+# define HTTP_R_REDIRECTION_FROM_HTTPS_TO_HTTP            112
+# define HTTP_R_REDIRECTION_NOT_ENABLED                   116
+# define HTTP_R_RESPONSE_LINE_TOO_LONG                    113
+# define HTTP_R_RESPONSE_PARSE_ERROR                      104
+# define HTTP_R_RETRY_TIMEOUT                             129
+# define HTTP_R_SERVER_CANCELED_CONNECTION                127
+# define HTTP_R_SOCK_NOT_SUPPORTED                        122
+# define HTTP_R_STATUS_CODE_UNSUPPORTED                   114
+# define HTTP_R_TLS_NOT_ENABLED                           107
+# define HTTP_R_TOO_MANY_REDIRECTIONS                     115
+# define HTTP_R_UNEXPECTED_CONTENT_TYPE                   118
+
+#endif

mplug_owl2/include/openssl/opensslv.h

@@ -0,0 +1,114 @@
+/*
+ * WARNING: do not edit!
+ * Generated by Makefile from include/openssl/opensslv.h.in
+ *
+ * Copyright 1999-2020 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_OPENSSLV_H
+# define OPENSSL_OPENSSLV_H
+# pragma once
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+/*
+ * SECTION 1: VERSION DATA.  These will change for each release
+ */
+
+/*
+ * Base version macros
+ *
+ * These macros express version number MAJOR.MINOR.PATCH exactly
+ */
+# define OPENSSL_VERSION_MAJOR  3
+# define OPENSSL_VERSION_MINOR  0
+# define OPENSSL_VERSION_PATCH  16
+
+/*
+ * Additional version information
+ *
+ * These are also part of the new version scheme, but aren't part
+ * of the version number itself.
+ */
+
+/* Could be: #define OPENSSL_VERSION_PRE_RELEASE "-alpha.1" */
+# define OPENSSL_VERSION_PRE_RELEASE ""
+/* Could be: #define OPENSSL_VERSION_BUILD_METADATA "+fips" */
+/* Could be: #define OPENSSL_VERSION_BUILD_METADATA "+vendor.1" */
+# define OPENSSL_VERSION_BUILD_METADATA ""
+
+/*
+ * Note: The OpenSSL Project will never define OPENSSL_VERSION_BUILD_METADATA
+ * to be anything but the empty string.  Its use is entirely reserved for
+ * others
+ */
+
+/*
+ * Shared library version
+ *
+ * This is strictly to express ABI version, which may or may not
+ * be related to the API version expressed with the macros above.
+ * This is defined in free form.
+ */
+# define OPENSSL_SHLIB_VERSION 3
+
+/*
+ * SECTION 2: USEFUL MACROS
+ */
+
+/* For checking general API compatibility when preprocessing */
+# define OPENSSL_VERSION_PREREQ(maj,min)                                \
+    ((OPENSSL_VERSION_MAJOR << 16) + OPENSSL_VERSION_MINOR >= ((maj) << 16) + (min))
+
+/*
+ * Macros to get the version in easily digested string form, both the short
+ * "MAJOR.MINOR.PATCH" variant (where MAJOR, MINOR and PATCH are replaced
+ * with the values from the corresponding OPENSSL_VERSION_ macros) and the
+ * longer variant with OPENSSL_VERSION_PRE_RELEASE_STR and
+ * OPENSSL_VERSION_BUILD_METADATA_STR appended.
+ */
+# define OPENSSL_VERSION_STR "3.0.16"
+# define OPENSSL_FULL_VERSION_STR "3.0.16"
+
+/*
+ * SECTION 3: ADDITIONAL METADATA
+ *
+ * These strings are defined separately to allow them to be parsable.
+ */
+# define OPENSSL_RELEASE_DATE "11 Feb 2025"
+
+/*
+ * SECTION 4: BACKWARD COMPATIBILITY
+ */
+
+# define OPENSSL_VERSION_TEXT "OpenSSL 3.0.16 11 Feb 2025"
+
+/* Synthesize OPENSSL_VERSION_NUMBER with the layout 0xMNN00PPSL */
+# ifdef OPENSSL_VERSION_PRE_RELEASE
+#  define _OPENSSL_VERSION_PRE_RELEASE 0x0L
+# else
+#  define _OPENSSL_VERSION_PRE_RELEASE 0xfL
+# endif
+# define OPENSSL_VERSION_NUMBER          \
+    ( (OPENSSL_VERSION_MAJOR<<28)        \
+      |(OPENSSL_VERSION_MINOR<<20)       \
+      |(OPENSSL_VERSION_PATCH<<4)        \
+      |_OPENSSL_VERSION_PRE_RELEASE )
+
+# ifdef  __cplusplus
+}
+# endif
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_OPENSSLV_H
+# endif
+
+#endif                          /* OPENSSL_OPENSSLV_H */

mplug_owl2/include/openssl/proverr.h

@@ -0,0 +1,148 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_PROVERR_H
+# define OPENSSL_PROVERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * PROV reason codes.
+ */
+# define PROV_R_ADDITIONAL_INPUT_TOO_LONG                 184
+# define PROV_R_ALGORITHM_MISMATCH                        173
+# define PROV_R_ALREADY_INSTANTIATED                      185
+# define PROV_R_BAD_DECRYPT                               100
+# define PROV_R_BAD_ENCODING                              141
+# define PROV_R_BAD_LENGTH                                142
+# define PROV_R_BAD_TLS_CLIENT_VERSION                    161
+# define PROV_R_BN_ERROR                                  160
+# define PROV_R_CIPHER_OPERATION_FAILED                   102
+# define PROV_R_DERIVATION_FUNCTION_INIT_FAILED           205
+# define PROV_R_DIGEST_NOT_ALLOWED                        174
+# define PROV_R_ENTROPY_SOURCE_STRENGTH_TOO_WEAK          186
+# define PROV_R_ERROR_INSTANTIATING_DRBG                  188
+# define PROV_R_ERROR_RETRIEVING_ENTROPY                  189
+# define PROV_R_ERROR_RETRIEVING_NONCE                    190
+# define PROV_R_FAILED_DURING_DERIVATION                  164
+# define PROV_R_FAILED_TO_CREATE_LOCK                     180
+# define PROV_R_FAILED_TO_DECRYPT                         162
+# define PROV_R_FAILED_TO_GENERATE_KEY                    121
+# define PROV_R_FAILED_TO_GET_PARAMETER                   103
+# define PROV_R_FAILED_TO_SET_PARAMETER                   104
+# define PROV_R_FAILED_TO_SIGN                            175
+# define PROV_R_FIPS_MODULE_CONDITIONAL_ERROR             227
+# define PROV_R_FIPS_MODULE_ENTERING_ERROR_STATE          224
+# define PROV_R_FIPS_MODULE_IN_ERROR_STATE                225
+# define PROV_R_GENERATE_ERROR                            191
+# define PROV_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE       165
+# define PROV_R_INDICATOR_INTEGRITY_FAILURE               210
+# define PROV_R_INSUFFICIENT_DRBG_STRENGTH                181
+# define PROV_R_INVALID_AAD                               108
+# define PROV_R_INVALID_CONFIG_DATA                       211
+# define PROV_R_INVALID_CONSTANT_LENGTH                   157
+# define PROV_R_INVALID_CURVE                             176
+# define PROV_R_INVALID_CUSTOM_LENGTH                     111
+# define PROV_R_INVALID_DATA                              115
+# define PROV_R_INVALID_DIGEST                            122
+# define PROV_R_INVALID_DIGEST_LENGTH                     166
+# define PROV_R_INVALID_DIGEST_SIZE                       218
+# define PROV_R_INVALID_INPUT_LENGTH                      230
+# define PROV_R_INVALID_ITERATION_COUNT                   123
+# define PROV_R_INVALID_IV_LENGTH                         109
+# define PROV_R_INVALID_KEY                               158
+# define PROV_R_INVALID_KEY_LENGTH                        105
+# define PROV_R_INVALID_MAC                               151
+# define PROV_R_INVALID_MGF1_MD                           167
+# define PROV_R_INVALID_MODE                              125
+# define PROV_R_INVALID_OUTPUT_LENGTH                     217
+# define PROV_R_INVALID_PADDING_MODE                      168
+# define PROV_R_INVALID_PUBINFO                           198
+# define PROV_R_INVALID_SALT_LENGTH                       112
+# define PROV_R_INVALID_SEED_LENGTH                       154
+# define PROV_R_INVALID_SIGNATURE_SIZE                    179
+# define PROV_R_INVALID_STATE                             212
+# define PROV_R_INVALID_TAG                               110
+# define PROV_R_INVALID_TAG_LENGTH                        118
+# define PROV_R_INVALID_UKM_LENGTH                        200
+# define PROV_R_INVALID_X931_DIGEST                       170
+# define PROV_R_IN_ERROR_STATE                            192
+# define PROV_R_KEY_SETUP_FAILED                          101
+# define PROV_R_KEY_SIZE_TOO_SMALL                        171
+# define PROV_R_LENGTH_TOO_LARGE                          202
+# define PROV_R_MISMATCHING_DOMAIN_PARAMETERS             203
+# define PROV_R_MISSING_CEK_ALG                           144
+# define PROV_R_MISSING_CIPHER                            155
+# define PROV_R_MISSING_CONFIG_DATA                       213
+# define PROV_R_MISSING_CONSTANT                          156
+# define PROV_R_MISSING_KEY                               128
+# define PROV_R_MISSING_MAC                               150
+# define PROV_R_MISSING_MESSAGE_DIGEST                    129
+# define PROV_R_MISSING_OID                               209
+# define PROV_R_MISSING_PASS                              130
+# define PROV_R_MISSING_SALT                              131
+# define PROV_R_MISSING_SECRET                            132
+# define PROV_R_MISSING_SEED                              140
+# define PROV_R_MISSING_SESSION_ID                        133
+# define PROV_R_MISSING_TYPE                              134
+# define PROV_R_MISSING_XCGHASH                           135
+# define PROV_R_MODULE_INTEGRITY_FAILURE                  214
+# define PROV_R_NOT_A_PRIVATE_KEY                         221
+# define PROV_R_NOT_A_PUBLIC_KEY                          220
+# define PROV_R_NOT_INSTANTIATED                          193
+# define PROV_R_NOT_PARAMETERS                            226
+# define PROV_R_NOT_SUPPORTED                             136
+# define PROV_R_NOT_XOF_OR_INVALID_LENGTH                 113
+# define PROV_R_NO_KEY_SET                                114
+# define PROV_R_NO_PARAMETERS_SET                         177
+# define PROV_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE  178
+# define PROV_R_OUTPUT_BUFFER_TOO_SMALL                   106
+# define PROV_R_PARENT_CANNOT_GENERATE_RANDOM_NUMBERS     228
+# define PROV_R_PARENT_CANNOT_SUPPLY_ENTROPY_SEED         187
+# define PROV_R_PARENT_LOCKING_NOT_ENABLED                182
+# define PROV_R_PARENT_STRENGTH_TOO_WEAK                  194
+# define PROV_R_PATH_MUST_BE_ABSOLUTE                     219
+# define PROV_R_PERSONALISATION_STRING_TOO_LONG           195
+# define PROV_R_PSS_SALTLEN_TOO_SMALL                     172
+# define PROV_R_REQUEST_TOO_LARGE_FOR_DRBG                196
+# define PROV_R_REQUIRE_CTR_MODE_CIPHER                   206
+# define PROV_R_RESEED_ERROR                              197
+# define PROV_R_SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES     222
+# define PROV_R_SEED_SOURCES_MUST_NOT_HAVE_A_PARENT       229
+# define PROV_R_SELF_TEST_KAT_FAILURE                     215
+# define PROV_R_SELF_TEST_POST_FAILURE                    216
+# define PROV_R_TAG_NOT_NEEDED                            120
+# define PROV_R_TAG_NOT_SET                               119
+# define PROV_R_TOO_MANY_RECORDS                          126
+# define PROV_R_UNABLE_TO_FIND_CIPHERS                    207
+# define PROV_R_UNABLE_TO_GET_PARENT_STRENGTH             199
+# define PROV_R_UNABLE_TO_GET_PASSPHRASE                  159
+# define PROV_R_UNABLE_TO_INITIALISE_CIPHERS              208
+# define PROV_R_UNABLE_TO_LOAD_SHA256                     147
+# define PROV_R_UNABLE_TO_LOCK_PARENT                     201
+# define PROV_R_UNABLE_TO_RESEED                          204
+# define PROV_R_UNSUPPORTED_CEK_ALG                       145
+# define PROV_R_UNSUPPORTED_KEY_SIZE                      153
+# define PROV_R_UNSUPPORTED_MAC_TYPE                      137
+# define PROV_R_UNSUPPORTED_NUMBER_OF_ROUNDS              152
+# define PROV_R_URI_AUTHORITY_UNSUPPORTED                 223
+# define PROV_R_VALUE_ERROR                               138
+# define PROV_R_WRONG_FINAL_BLOCK_LENGTH                  107
+# define PROV_R_WRONG_OUTPUT_BUFFER_SIZE                  139
+# define PROV_R_XOF_DIGESTS_NOT_ALLOWED                   183
+# define PROV_R_XTS_DATA_UNIT_IS_TOO_LARGE                148
+# define PROV_R_XTS_DUPLICATED_KEYS                       149
+
+#endif

mplug_owl2/include/openssl/srp.h

@@ -0,0 +1,285 @@
+/*
+ * WARNING: do not edit!
+ * Generated by Makefile from include/openssl/srp.h.in
+ *
+ * Copyright 2004-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright (c) 2004, EdelKey Project. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ *
+ * Originally written by Christophe Renou and Peter Sylvester,
+ * for the EdelKey project.
+ */
+
+
+
+#ifndef OPENSSL_SRP_H
+# define OPENSSL_SRP_H
+# pragma once
+
+# include <openssl/macros.h>
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+#  define HEADER_SRP_H
+# endif
+
+#include <openssl/opensslconf.h>
+
+#ifndef OPENSSL_NO_SRP
+# include <stdio.h>
+# include <string.h>
+# include <openssl/safestack.h>
+# include <openssl/bn.h>
+# include <openssl/crypto.h>
+
+# ifdef  __cplusplus
+extern "C" {
+# endif
+
+# ifndef OPENSSL_NO_DEPRECATED_3_0
+
+typedef struct SRP_gN_cache_st {
+    char *b64_bn;
+    BIGNUM *bn;
+} SRP_gN_cache;
+SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN_cache, SRP_gN_cache, SRP_gN_cache)
+#define sk_SRP_gN_cache_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_value(sk, idx) ((SRP_gN_cache *)OPENSSL_sk_value(ossl_check_const_SRP_gN_cache_sk_type(sk), (idx)))
+#define sk_SRP_gN_cache_new(cmp) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new(ossl_check_SRP_gN_cache_compfunc_type(cmp)))
+#define sk_SRP_gN_cache_new_null() ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new_null())
+#define sk_SRP_gN_cache_new_reserve(cmp, n) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_new_reserve(ossl_check_SRP_gN_cache_compfunc_type(cmp), (n)))
+#define sk_SRP_gN_cache_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_gN_cache_sk_type(sk), (n))
+#define sk_SRP_gN_cache_free(sk) OPENSSL_sk_free(ossl_check_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_delete(sk, i) ((SRP_gN_cache *)OPENSSL_sk_delete(ossl_check_SRP_gN_cache_sk_type(sk), (i)))
+#define sk_SRP_gN_cache_delete_ptr(sk, ptr) ((SRP_gN_cache *)OPENSSL_sk_delete_ptr(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr)))
+#define sk_SRP_gN_cache_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_pop(sk) ((SRP_gN_cache *)OPENSSL_sk_pop(ossl_check_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_shift(sk) ((SRP_gN_cache *)OPENSSL_sk_shift(ossl_check_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_gN_cache_sk_type(sk),ossl_check_SRP_gN_cache_freefunc_type(freefunc))
+#define sk_SRP_gN_cache_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr), (idx))
+#define sk_SRP_gN_cache_set(sk, idx, ptr) ((SRP_gN_cache *)OPENSSL_sk_set(ossl_check_SRP_gN_cache_sk_type(sk), (idx), ossl_check_SRP_gN_cache_type(ptr)))
+#define sk_SRP_gN_cache_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr))
+#define sk_SRP_gN_cache_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr), pnum)
+#define sk_SRP_gN_cache_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_gN_cache_sk_type(sk))
+#define sk_SRP_gN_cache_dup(sk) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_dup(ossl_check_const_SRP_gN_cache_sk_type(sk)))
+#define sk_SRP_gN_cache_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_copyfunc_type(copyfunc), ossl_check_SRP_gN_cache_freefunc_type(freefunc)))
+#define sk_SRP_gN_cache_set_cmp_func(sk, cmp) ((sk_SRP_gN_cache_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_compfunc_type(cmp)))
+
+
+
+typedef struct SRP_user_pwd_st {
+    /* Owned by us. */
+    char *id;
+    BIGNUM *s;
+    BIGNUM *v;
+    /* Not owned by us. */
+    const BIGNUM *g;
+    const BIGNUM *N;
+    /* Owned by us. */
+    char *info;
+} SRP_user_pwd;
+SKM_DEFINE_STACK_OF_INTERNAL(SRP_user_pwd, SRP_user_pwd, SRP_user_pwd)
+#define sk_SRP_user_pwd_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_value(sk, idx) ((SRP_user_pwd *)OPENSSL_sk_value(ossl_check_const_SRP_user_pwd_sk_type(sk), (idx)))
+#define sk_SRP_user_pwd_new(cmp) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new(ossl_check_SRP_user_pwd_compfunc_type(cmp)))
+#define sk_SRP_user_pwd_new_null() ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new_null())
+#define sk_SRP_user_pwd_new_reserve(cmp, n) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_new_reserve(ossl_check_SRP_user_pwd_compfunc_type(cmp), (n)))
+#define sk_SRP_user_pwd_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_user_pwd_sk_type(sk), (n))
+#define sk_SRP_user_pwd_free(sk) OPENSSL_sk_free(ossl_check_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_delete(sk, i) ((SRP_user_pwd *)OPENSSL_sk_delete(ossl_check_SRP_user_pwd_sk_type(sk), (i)))
+#define sk_SRP_user_pwd_delete_ptr(sk, ptr) ((SRP_user_pwd *)OPENSSL_sk_delete_ptr(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr)))
+#define sk_SRP_user_pwd_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_pop(sk) ((SRP_user_pwd *)OPENSSL_sk_pop(ossl_check_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_shift(sk) ((SRP_user_pwd *)OPENSSL_sk_shift(ossl_check_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_user_pwd_sk_type(sk),ossl_check_SRP_user_pwd_freefunc_type(freefunc))
+#define sk_SRP_user_pwd_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr), (idx))
+#define sk_SRP_user_pwd_set(sk, idx, ptr) ((SRP_user_pwd *)OPENSSL_sk_set(ossl_check_SRP_user_pwd_sk_type(sk), (idx), ossl_check_SRP_user_pwd_type(ptr)))
+#define sk_SRP_user_pwd_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr))
+#define sk_SRP_user_pwd_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr), pnum)
+#define sk_SRP_user_pwd_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_user_pwd_sk_type(sk))
+#define sk_SRP_user_pwd_dup(sk) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_dup(ossl_check_const_SRP_user_pwd_sk_type(sk)))
+#define sk_SRP_user_pwd_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_copyfunc_type(copyfunc), ossl_check_SRP_user_pwd_freefunc_type(freefunc)))
+#define sk_SRP_user_pwd_set_cmp_func(sk, cmp) ((sk_SRP_user_pwd_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_compfunc_type(cmp)))
+
+
+OSSL_DEPRECATEDIN_3_0
+SRP_user_pwd *SRP_user_pwd_new(void);
+OSSL_DEPRECATEDIN_3_0
+void SRP_user_pwd_free(SRP_user_pwd *user_pwd);
+
+OSSL_DEPRECATEDIN_3_0
+void SRP_user_pwd_set_gN(SRP_user_pwd *user_pwd, const BIGNUM *g,
+                         const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+int SRP_user_pwd_set1_ids(SRP_user_pwd *user_pwd, const char *id,
+                          const char *info);
+OSSL_DEPRECATEDIN_3_0
+int SRP_user_pwd_set0_sv(SRP_user_pwd *user_pwd, BIGNUM *s, BIGNUM *v);
+
+typedef struct SRP_VBASE_st {
+    STACK_OF(SRP_user_pwd) *users_pwd;
+    STACK_OF(SRP_gN_cache) *gN_cache;
+/* to simulate a user */
+    char *seed_key;
+    const BIGNUM *default_g;
+    const BIGNUM *default_N;
+} SRP_VBASE;
+
+/*
+ * Internal structure storing N and g pair
+ */
+typedef struct SRP_gN_st {
+    char *id;
+    const BIGNUM *g;
+    const BIGNUM *N;
+} SRP_gN;
+SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN, SRP_gN, SRP_gN)
+#define sk_SRP_gN_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_value(sk, idx) ((SRP_gN *)OPENSSL_sk_value(ossl_check_const_SRP_gN_sk_type(sk), (idx)))
+#define sk_SRP_gN_new(cmp) ((STACK_OF(SRP_gN) *)OPENSSL_sk_new(ossl_check_SRP_gN_compfunc_type(cmp)))
+#define sk_SRP_gN_new_null() ((STACK_OF(SRP_gN) *)OPENSSL_sk_new_null())
+#define sk_SRP_gN_new_reserve(cmp, n) ((STACK_OF(SRP_gN) *)OPENSSL_sk_new_reserve(ossl_check_SRP_gN_compfunc_type(cmp), (n)))
+#define sk_SRP_gN_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_gN_sk_type(sk), (n))
+#define sk_SRP_gN_free(sk) OPENSSL_sk_free(ossl_check_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_delete(sk, i) ((SRP_gN *)OPENSSL_sk_delete(ossl_check_SRP_gN_sk_type(sk), (i)))
+#define sk_SRP_gN_delete_ptr(sk, ptr) ((SRP_gN *)OPENSSL_sk_delete_ptr(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr)))
+#define sk_SRP_gN_push(sk, ptr) OPENSSL_sk_push(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_pop(sk) ((SRP_gN *)OPENSSL_sk_pop(ossl_check_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_shift(sk) ((SRP_gN *)OPENSSL_sk_shift(ossl_check_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_SRP_gN_sk_type(sk),ossl_check_SRP_gN_freefunc_type(freefunc))
+#define sk_SRP_gN_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr), (idx))
+#define sk_SRP_gN_set(sk, idx, ptr) ((SRP_gN *)OPENSSL_sk_set(ossl_check_SRP_gN_sk_type(sk), (idx), ossl_check_SRP_gN_type(ptr)))
+#define sk_SRP_gN_find(sk, ptr) OPENSSL_sk_find(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr))
+#define sk_SRP_gN_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr), pnum)
+#define sk_SRP_gN_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_gN_sk_type(sk))
+#define sk_SRP_gN_dup(sk) ((STACK_OF(SRP_gN) *)OPENSSL_sk_dup(ossl_check_const_SRP_gN_sk_type(sk)))
+#define sk_SRP_gN_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_sk_type(sk), ossl_check_SRP_gN_copyfunc_type(copyfunc), ossl_check_SRP_gN_freefunc_type(freefunc)))
+#define sk_SRP_gN_set_cmp_func(sk, cmp) ((sk_SRP_gN_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_compfunc_type(cmp)))
+
+
+
+OSSL_DEPRECATEDIN_3_0
+SRP_VBASE *SRP_VBASE_new(char *seed_key);
+OSSL_DEPRECATEDIN_3_0
+void SRP_VBASE_free(SRP_VBASE *vb);
+OSSL_DEPRECATEDIN_3_0
+int SRP_VBASE_init(SRP_VBASE *vb, char *verifier_file);
+
+OSSL_DEPRECATEDIN_3_0
+int SRP_VBASE_add0_user(SRP_VBASE *vb, SRP_user_pwd *user_pwd);
+
+/* NOTE: unlike in SRP_VBASE_get_by_user, caller owns the returned pointer.*/
+OSSL_DEPRECATEDIN_3_0
+SRP_user_pwd *SRP_VBASE_get1_by_user(SRP_VBASE *vb, char *username);
+
+OSSL_DEPRECATEDIN_3_0
+char *SRP_create_verifier_ex(const char *user, const char *pass, char **salt,
+                             char **verifier, const char *N, const char *g,
+                             OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+char *SRP_create_verifier(const char *user, const char *pass, char **salt,
+                          char **verifier, const char *N, const char *g);
+OSSL_DEPRECATEDIN_3_0
+int SRP_create_verifier_BN_ex(const char *user, const char *pass, BIGNUM **salt,
+                              BIGNUM **verifier, const BIGNUM *N,
+                              const BIGNUM *g, OSSL_LIB_CTX *libctx,
+                              const char *propq);
+OSSL_DEPRECATEDIN_3_0
+int SRP_create_verifier_BN(const char *user, const char *pass, BIGNUM **salt,
+                           BIGNUM **verifier, const BIGNUM *N,
+                           const BIGNUM *g);
+
+#  define SRP_NO_ERROR 0
+#  define SRP_ERR_VBASE_INCOMPLETE_FILE 1
+#  define SRP_ERR_VBASE_BN_LIB 2
+#  define SRP_ERR_OPEN_FILE 3
+#  define SRP_ERR_MEMORY 4
+
+#  define DB_srptype      0
+#  define DB_srpverifier  1
+#  define DB_srpsalt      2
+#  define DB_srpid        3
+#  define DB_srpgN        4
+#  define DB_srpinfo      5
+#  undef  DB_NUMBER
+#  define DB_NUMBER       6
+
+#  define DB_SRP_INDEX    'I'
+#  define DB_SRP_VALID    'V'
+#  define DB_SRP_REVOKED  'R'
+#  define DB_SRP_MODIF    'v'
+
+/* see srp.c */
+OSSL_DEPRECATEDIN_3_0
+char *SRP_check_known_gN_param(const BIGNUM *g, const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+SRP_gN *SRP_get_default_gN(const char *id);
+
+/* server side .... */
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_server_key(const BIGNUM *A, const BIGNUM *v, const BIGNUM *u,
+                            const BIGNUM *b, const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_B_ex(const BIGNUM *b, const BIGNUM *N, const BIGNUM *g,
+                      const BIGNUM *v, OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_B(const BIGNUM *b, const BIGNUM *N, const BIGNUM *g,
+                   const BIGNUM *v);
+
+OSSL_DEPRECATEDIN_3_0
+int SRP_Verify_A_mod_N(const BIGNUM *A, const BIGNUM *N);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_u_ex(const BIGNUM *A, const BIGNUM *B, const BIGNUM *N,
+                      OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_u(const BIGNUM *A, const BIGNUM *B, const BIGNUM *N);
+
+/* client side .... */
+
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_x_ex(const BIGNUM *s, const char *user, const char *pass,
+                      OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_x(const BIGNUM *s, const char *user, const char *pass);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_A(const BIGNUM *a, const BIGNUM *N, const BIGNUM *g);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_client_key_ex(const BIGNUM *N, const BIGNUM *B, const BIGNUM *g,
+                            const BIGNUM *x, const BIGNUM *a, const BIGNUM *u,
+                            OSSL_LIB_CTX *libctx, const char *propq);
+OSSL_DEPRECATEDIN_3_0
+BIGNUM *SRP_Calc_client_key(const BIGNUM *N, const BIGNUM *B, const BIGNUM *g,
+                            const BIGNUM *x, const BIGNUM *a, const BIGNUM *u);
+OSSL_DEPRECATEDIN_3_0
+int SRP_Verify_B_mod_N(const BIGNUM *B, const BIGNUM *N);
+
+#  define SRP_MINIMAL_N 1024
+
+# endif /* OPENSSL_NO_DEPRECATED_3_0 */
+
+/* This method ignores the configured seed and fails for an unknown user. */
+# ifndef OPENSSL_NO_DEPRECATED_1_1_0
+OSSL_DEPRECATEDIN_1_1_0
+SRP_user_pwd *SRP_VBASE_get_by_user(SRP_VBASE *vb, char *username);
+# endif
+
+# ifdef  __cplusplus
+}
+# endif
+# endif
+
+#endif

openflamingo/lib/python3.10/site-packages/sympy/functions/combinatorial/__init__.py

@@ -0,0 +1 @@
+# Stub __init__.py for sympy.functions.combinatorial

openflamingo/lib/python3.10/site-packages/sympy/functions/combinatorial/tests/test_comb_factorials.py

@@ -0,0 +1,653 @@
+from sympy.concrete.products import Product
+from sympy.core.function import expand_func
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core import EulerGamma
+from sympy.core.numbers import (Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (ff, rf, binomial, factorial, factorial2)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.gamma_functions import (gamma, polygamma)
+from sympy.polys.polytools import Poly
+from sympy.series.order import O
+from sympy.simplify.simplify import simplify
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.functions.combinatorial.factorials import subfactorial
+from sympy.functions.special.gamma_functions import uppergamma
+from sympy.testing.pytest import XFAIL, raises, slow
+
+#Solves and Fixes Issue #10388 - This is the updated test for the same solved issue
+
+def test_rf_eval_apply():
+    x, y = symbols('x,y')
+    n, k = symbols('n k', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+
+    assert rf(nan, y) is nan
+    assert rf(x, nan) is nan
+
+    assert unchanged(rf, x, y)
+
+    assert rf(oo, 0) == 1
+    assert rf(-oo, 0) == 1
+
+    assert rf(oo, 6) is oo
+    assert rf(-oo, 7) is -oo
+    assert rf(-oo, 6) is oo
+
+    assert rf(oo, -6) is oo
+    assert rf(-oo, -7) is oo
+
+    assert rf(-1, pi) == 0
+    assert rf(-5, 1 + I) == 0
+
+    assert unchanged(rf, -3, k)
+    assert unchanged(rf, x, Symbol('k', integer=False))
+    assert rf(-3, Symbol('k', integer=False)) == 0
+    assert rf(Symbol('x', negative=True, integer=True), Symbol('k', integer=False)) == 0
+
+    assert rf(x, 0) == 1
+    assert rf(x, 1) == x
+    assert rf(x, 2) == x*(x + 1)
+    assert rf(x, 3) == x*(x + 1)*(x + 2)
+    assert rf(x, 5) == x*(x + 1)*(x + 2)*(x + 3)*(x + 4)
+
+    assert rf(x, -1) == 1/(x - 1)
+    assert rf(x, -2) == 1/((x - 1)*(x - 2))
+    assert rf(x, -3) == 1/((x - 1)*(x - 2)*(x - 3))
+
+    assert rf(1, 100) == factorial(100)
+
+    assert rf(x**2 + 3*x, 2) == (x**2 + 3*x)*(x**2 + 3*x + 1)
+    assert isinstance(rf(x**2 + 3*x, 2), Mul)
+    assert rf(x**3 + x, -2) == 1/((x**3 + x - 1)*(x**3 + x - 2))
+
+    assert rf(Poly(x**2 + 3*x, x), 2) == Poly(x**4 + 8*x**3 + 19*x**2 + 12*x, x)
+    assert isinstance(rf(Poly(x**2 + 3*x, x), 2), Poly)
+    raises(ValueError, lambda: rf(Poly(x**2 + 3*x, x, y), 2))
+    assert rf(Poly(x**3 + x, x), -2) == 1/(x**6 - 9*x**5 + 35*x**4 - 75*x**3 + 94*x**2 - 66*x + 20)
+    raises(ValueError, lambda: rf(Poly(x**3 + x, x, y), -2))
+
+    assert rf(x, m).is_integer is None
+    assert rf(n, k).is_integer is None
+    assert rf(n, m).is_integer is True
+    assert rf(n, k + pi).is_integer is False
+    assert rf(n, m + pi).is_integer is False
+    assert rf(pi, m).is_integer is False
+
+    def check(x, k, o, n):
+        a, b = Dummy(), Dummy()
+        r = lambda x, k: o(a, b).rewrite(n).subs({a:x,b:k})
+        for i in range(-5,5):
+          for j in range(-5,5):
+              assert o(i, j) == r(i, j), (o, n, i, j)
+    check(x, k, rf, ff)
+    check(x, k, rf, binomial)
+    check(n, k, rf, factorial)
+    check(x, y, rf, factorial)
+    check(x, y, rf, binomial)
+
+    assert rf(x, k).rewrite(ff) == ff(x + k - 1, k)
+    assert rf(x, k).rewrite(gamma) == Piecewise(
+        (gamma(k + x)/gamma(x), x > 0),
+        ((-1)**k*gamma(1 - x)/gamma(-k - x + 1), True))
+    assert rf(5, k).rewrite(gamma) == gamma(k + 5)/24
+    assert rf(x, k).rewrite(binomial) == factorial(k)*binomial(x + k - 1, k)
+    assert rf(n, k).rewrite(factorial) == Piecewise(
+        (factorial(k + n - 1)/factorial(n - 1), n > 0),
+        ((-1)**k*factorial(-n)/factorial(-k - n), True))
+    assert rf(5, k).rewrite(factorial) == factorial(k + 4)/24
+    assert rf(x, y).rewrite(factorial) == rf(x, y)
+    assert rf(x, y).rewrite(binomial) == rf(x, y)
+
+    import random
+    from mpmath import rf as mpmath_rf
+    for i in range(100):
+        x = -500 + 500 * random.random()
+        k = -500 + 500 * random.random()
+        assert (abs(mpmath_rf(x, k) - rf(x, k)) < 10**(-15))
+
+
+def test_ff_eval_apply():
+    x, y = symbols('x,y')
+    n, k = symbols('n k', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+
+    assert ff(nan, y) is nan
+    assert ff(x, nan) is nan
+
+    assert unchanged(ff, x, y)
+
+    assert ff(oo, 0) == 1
+    assert ff(-oo, 0) == 1
+
+    assert ff(oo, 6) is oo
+    assert ff(-oo, 7) is -oo
+    assert ff(-oo, 6) is oo
+
+    assert ff(oo, -6) is oo
+    assert ff(-oo, -7) is oo
+
+    assert ff(x, 0) == 1
+    assert ff(x, 1) == x
+    assert ff(x, 2) == x*(x - 1)
+    assert ff(x, 3) == x*(x - 1)*(x - 2)
+    assert ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4)
+
+    assert ff(x, -1) == 1/(x + 1)
+    assert ff(x, -2) == 1/((x + 1)*(x + 2))
+    assert ff(x, -3) == 1/((x + 1)*(x + 2)*(x + 3))
+
+    assert ff(100, 100) == factorial(100)
+
+    assert ff(2*x**2 - 5*x, 2) == (2*x**2  - 5*x)*(2*x**2 - 5*x - 1)
+    assert isinstance(ff(2*x**2 - 5*x, 2), Mul)
+    assert ff(x**2 + 3*x, -2) == 1/((x**2 + 3*x + 1)*(x**2 + 3*x + 2))
+
+    assert ff(Poly(2*x**2 - 5*x, x), 2) == Poly(4*x**4 - 28*x**3 + 59*x**2 - 35*x, x)
+    assert isinstance(ff(Poly(2*x**2 - 5*x, x), 2), Poly)
+    raises(ValueError, lambda: ff(Poly(2*x**2 - 5*x, x, y), 2))
+    assert ff(Poly(x**2 + 3*x, x), -2) == 1/(x**4 + 12*x**3 + 49*x**2 + 78*x + 40)
+    raises(ValueError, lambda: ff(Poly(x**2 + 3*x, x, y), -2))
+
+
+    assert ff(x, m).is_integer is None
+    assert ff(n, k).is_integer is None
+    assert ff(n, m).is_integer is True
+    assert ff(n, k + pi).is_integer is False
+    assert ff(n, m + pi).is_integer is False
+    assert ff(pi, m).is_integer is False
+
+    assert isinstance(ff(x, x), ff)
+    assert ff(n, n) == factorial(n)
+
+    def check(x, k, o, n):
+        a, b = Dummy(), Dummy()
+        r = lambda x, k: o(a, b).rewrite(n).subs({a:x,b:k})
+        for i in range(-5,5):
+          for j in range(-5,5):
+              assert o(i, j) == r(i, j), (o, n)
+    check(x, k, ff, rf)
+    check(x, k, ff, gamma)
+    check(n, k, ff, factorial)
+    check(x, k, ff, binomial)
+    check(x, y, ff, factorial)
+    check(x, y, ff, binomial)
+
+    assert ff(x, k).rewrite(rf) == rf(x - k + 1, k)
+    assert ff(x, k).rewrite(gamma) == Piecewise(
+        (gamma(x + 1)/gamma(-k + x + 1), x >= 0),
+        ((-1)**k*gamma(k - x)/gamma(-x), True))
+    assert ff(5, k).rewrite(gamma) == 120/gamma(6 - k)
+    assert ff(n, k).rewrite(factorial) == Piecewise(
+        (factorial(n)/factorial(-k + n), n >= 0),
+        ((-1)**k*factorial(k - n - 1)/factorial(-n - 1), True))
+    assert ff(5, k).rewrite(factorial) == 120/factorial(5 - k)
+    assert ff(x, k).rewrite(binomial) == factorial(k) * binomial(x, k)
+    assert ff(x, y).rewrite(factorial) == ff(x, y)
+    assert ff(x, y).rewrite(binomial) == ff(x, y)
+
+    import random
+    from mpmath import ff as mpmath_ff
+    for i in range(100):
+        x = -500 + 500 * random.random()
+        k = -500 + 500 * random.random()
+        a = mpmath_ff(x, k)
+        b = ff(x, k)
+        assert (abs(a - b) < abs(a) * 10**(-15))
+
+
+def test_rf_ff_eval_hiprec():
+    maple = Float('6.9109401292234329956525265438452')
+    us = ff(18, Rational(2, 3)).evalf(32)
+    assert abs(us - maple)/us < 1e-31
+
+    maple = Float('6.8261540131125511557924466355367')
+    us = rf(18, Rational(2, 3)).evalf(32)
+    assert abs(us - maple)/us < 1e-31
+
+    maple = Float('34.007346127440197150854651814225')
+    us = rf(Float('4.4', 32), Float('2.2', 32));
+    assert abs(us - maple)/us < 1e-31
+
+
+def test_rf_lambdify_mpmath():
+    from sympy.utilities.lambdify import lambdify
+    x, y = symbols('x,y')
+    f = lambdify((x,y), rf(x, y), 'mpmath')
+    maple = Float('34.007346127440197')
+    us = f(4.4, 2.2)
+    assert abs(us - maple)/us < 1e-15
+
+
+def test_factorial():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+    r = Symbol('r', integer=False)
+    s = Symbol('s', integer=False, negative=True)
+    t = Symbol('t', nonnegative=True)
+    u = Symbol('u', noninteger=True)
+
+    assert factorial(-2) is zoo
+    assert factorial(0) == 1
+    assert factorial(7) == 5040
+    assert factorial(19) == 121645100408832000
+    assert factorial(31) == 8222838654177922817725562880000000
+    assert factorial(n).func == factorial
+    assert factorial(2*n).func == factorial
+
+    assert factorial(x).is_integer is None
+    assert factorial(n).is_integer is None
+    assert factorial(k).is_integer
+    assert factorial(r).is_integer is None
+
+    assert factorial(n).is_positive is None
+    assert factorial(k).is_positive
+
+    assert factorial(x).is_real is None
+    assert factorial(n).is_real is None
+    assert factorial(k).is_real is True
+    assert factorial(r).is_real is None
+    assert factorial(s).is_real is True
+    assert factorial(t).is_real is True
+    assert factorial(u).is_real is True
+
+    assert factorial(x).is_composite is None
+    assert factorial(n).is_composite is None
+    assert factorial(k).is_composite is None
+    assert factorial(k + 3).is_composite is True
+    assert factorial(r).is_composite is None
+    assert factorial(s).is_composite is None
+    assert factorial(t).is_composite is None
+    assert factorial(u).is_composite is None
+
+    assert factorial(oo) is oo
+
+
+def test_factorial_Mod():
+    pr = Symbol('pr', prime=True)
+    p, q = 10**9 + 9, 10**9 + 33 # prime modulo
+    r, s = 10**7 + 5, 33333333 # composite modulo
+    assert Mod(factorial(pr - 1), pr) == pr - 1
+    assert Mod(factorial(pr - 1), -pr) == -1
+    assert Mod(factorial(r - 1, evaluate=False), r) == 0
+    assert Mod(factorial(s - 1, evaluate=False), s) == 0
+    assert Mod(factorial(p - 1, evaluate=False), p) == p - 1
+    assert Mod(factorial(q - 1, evaluate=False), q) == q - 1
+    assert Mod(factorial(p - 50, evaluate=False), p) == 854928834
+    assert Mod(factorial(q - 1800, evaluate=False), q) == 905504050
+    assert Mod(factorial(153, evaluate=False), r) == Mod(factorial(153), r)
+    assert Mod(factorial(255, evaluate=False), s) == Mod(factorial(255), s)
+    assert Mod(factorial(4, evaluate=False), 3) == S.Zero
+    assert Mod(factorial(5, evaluate=False), 6) == S.Zero
+
+
+def test_factorial_diff():
+    n = Symbol('n', integer=True)
+
+    assert factorial(n).diff(n) == \
+        gamma(1 + n)*polygamma(0, 1 + n)
+    assert factorial(n**2).diff(n) == \
+        2*n*gamma(1 + n**2)*polygamma(0, 1 + n**2)
+    raises(ArgumentIndexError, lambda: factorial(n**2).fdiff(2))
+
+
+def test_factorial_series():
+    n = Symbol('n', integer=True)
+
+    assert factorial(n).series(n, 0, 3) == \
+        1 - n*EulerGamma + n**2*(EulerGamma**2/2 + pi**2/12) + O(n**3)
+
+
+def test_factorial_rewrite():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+
+    assert factorial(n).rewrite(gamma) == gamma(n + 1)
+    _i = Dummy('i')
+    assert factorial(k).rewrite(Product).dummy_eq(Product(_i, (_i, 1, k)))
+    assert factorial(n).rewrite(Product) == factorial(n)
+
+
+def test_factorial2():
+    n = Symbol('n', integer=True)
+
+    assert factorial2(-1) == 1
+    assert factorial2(0) == 1
+    assert factorial2(7) == 105
+    assert factorial2(8) == 384
+
+    # The following is exhaustive
+    tt = Symbol('tt', integer=True, nonnegative=True)
+    tte = Symbol('tte', even=True, nonnegative=True)
+    tpe = Symbol('tpe', even=True, positive=True)
+    tto = Symbol('tto', odd=True, nonnegative=True)
+    tf = Symbol('tf', integer=True, nonnegative=False)
+    tfe = Symbol('tfe', even=True, nonnegative=False)
+    tfo = Symbol('tfo', odd=True, nonnegative=False)
+    ft = Symbol('ft', integer=False, nonnegative=True)
+    ff = Symbol('ff', integer=False, nonnegative=False)
+    fn = Symbol('fn', integer=False)
+    nt = Symbol('nt', nonnegative=True)
+    nf = Symbol('nf', nonnegative=False)
+    nn = Symbol('nn')
+    z = Symbol('z', zero=True)
+    #Solves and Fixes Issue #10388 - This is the updated test for the same solved issue
+    raises(ValueError, lambda: factorial2(oo))
+    raises(ValueError, lambda: factorial2(Rational(5, 2)))
+    raises(ValueError, lambda: factorial2(-4))
+    assert factorial2(n).is_integer is None
+    assert factorial2(tt - 1).is_integer
+    assert factorial2(tte - 1).is_integer
+    assert factorial2(tpe - 3).is_integer
+    assert factorial2(tto - 4).is_integer
+    assert factorial2(tto - 2).is_integer
+    assert factorial2(tf).is_integer is None
+    assert factorial2(tfe).is_integer is None
+    assert factorial2(tfo).is_integer is None
+    assert factorial2(ft).is_integer is None
+    assert factorial2(ff).is_integer is None
+    assert factorial2(fn).is_integer is None
+    assert factorial2(nt).is_integer is None
+    assert factorial2(nf).is_integer is None
+    assert factorial2(nn).is_integer is None
+
+    assert factorial2(n).is_positive is None
+    assert factorial2(tt - 1).is_positive is True
+    assert factorial2(tte - 1).is_positive is True
+    assert factorial2(tpe - 3).is_positive is True
+    assert factorial2(tpe - 1).is_positive is True
+    assert factorial2(tto - 2).is_positive is True
+    assert factorial2(tto - 1).is_positive is True
+    assert factorial2(tf).is_positive is None
+    assert factorial2(tfe).is_positive is None
+    assert factorial2(tfo).is_positive is None
+    assert factorial2(ft).is_positive is None
+    assert factorial2(ff).is_positive is None
+    assert factorial2(fn).is_positive is None
+    assert factorial2(nt).is_positive is None
+    assert factorial2(nf).is_positive is None
+    assert factorial2(nn).is_positive is None
+
+    assert factorial2(tt).is_even is None
+    assert factorial2(tt).is_odd is None
+    assert factorial2(tte).is_even is None
+    assert factorial2(tte).is_odd is None
+    assert factorial2(tte + 2).is_even is True
+    assert factorial2(tpe).is_even is True
+    assert factorial2(tpe).is_odd is False
+    assert factorial2(tto).is_odd is True
+    assert factorial2(tf).is_even is None
+    assert factorial2(tf).is_odd is None
+    assert factorial2(tfe).is_even is None
+    assert factorial2(tfe).is_odd is None
+    assert factorial2(tfo).is_even is False
+    assert factorial2(tfo).is_odd is None
+    assert factorial2(z).is_even is False
+    assert factorial2(z).is_odd is True
+
+
+def test_factorial2_rewrite():
+    n = Symbol('n', integer=True)
+    assert factorial2(n).rewrite(gamma) == \
+        2**(n/2)*Piecewise((1, Eq(Mod(n, 2), 0)), (sqrt(2)/sqrt(pi), Eq(Mod(n, 2), 1)))*gamma(n/2 + 1)
+    assert factorial2(2*n).rewrite(gamma) == 2**n*gamma(n + 1)
+    assert factorial2(2*n + 1).rewrite(gamma) == \
+        sqrt(2)*2**(n + S.Half)*gamma(n + Rational(3, 2))/sqrt(pi)
+
+
+def test_binomial():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    nz = Symbol('nz', integer=True, nonzero=True)
+    k = Symbol('k', integer=True)
+    kp = Symbol('kp', integer=True, positive=True)
+    kn = Symbol('kn', integer=True, negative=True)
+    u = Symbol('u', negative=True)
+    v = Symbol('v', nonnegative=True)
+    p = Symbol('p', positive=True)
+    z = Symbol('z', zero=True)
+    nt = Symbol('nt', integer=False)
+    kt = Symbol('kt', integer=False)
+    a = Symbol('a', integer=True, nonnegative=True)
+    b = Symbol('b', integer=True, nonnegative=True)
+
+    assert binomial(0, 0) == 1
+    assert binomial(1, 1) == 1
+    assert binomial(10, 10) == 1
+    assert binomial(n, z) == 1
+    assert binomial(1, 2) == 0
+    assert binomial(-1, 2) == 1
+    assert binomial(1, -1) == 0
+    assert binomial(-1, 1) == -1
+    assert binomial(-1, -1) == 0
+    assert binomial(S.Half, S.Half) == 1
+    assert binomial(-10, 1) == -10
+    assert binomial(-10, 7) == -11440
+    assert binomial(n, -1) == 0 # holds for all integers (negative, zero, positive)
+    assert binomial(kp, -1) == 0
+    assert binomial(nz, 0) == 1
+    assert expand_func(binomial(n, 1)) == n
+    assert expand_func(binomial(n, 2)) == n*(n - 1)/2
+    assert expand_func(binomial(n, n - 2)) == n*(n - 1)/2
+    assert expand_func(binomial(n, n - 1)) == n
+    assert binomial(n, 3).func == binomial
+    assert binomial(n, 3).expand(func=True) ==  n**3/6 - n**2/2 + n/3
+    assert expand_func(binomial(n, 3)) ==  n*(n - 2)*(n - 1)/6
+    assert binomial(n, n).func == binomial # e.g. (-1, -1) == 0, (2, 2) == 1
+    assert binomial(n, n + 1).func == binomial  # e.g. (-1, 0) == 1
+    assert binomial(kp, kp + 1) == 0
+    assert binomial(kn, kn) == 0 # issue #14529
+    assert binomial(n, u).func == binomial
+    assert binomial(kp, u).func == binomial
+    assert binomial(n, p).func == binomial
+    assert binomial(n, k).func == binomial
+    assert binomial(n, n + p).func == binomial
+    assert binomial(kp, kp + p).func == binomial
+
+    assert expand_func(binomial(n, n - 3)) == n*(n - 2)*(n - 1)/6
+
+    assert binomial(n, k).is_integer
+    assert binomial(nt, k).is_integer is None
+    assert binomial(x, nt).is_integer is False
+
+    assert binomial(gamma(25), 6) == 79232165267303928292058750056084441948572511312165380965440075720159859792344339983120618959044048198214221915637090855535036339620413440000
+    assert binomial(1324, 47) == 906266255662694632984994480774946083064699457235920708992926525848438478406790323869952
+    assert binomial(1735, 43) == 190910140420204130794758005450919715396159959034348676124678207874195064798202216379800
+    assert binomial(2512, 53) == 213894469313832631145798303740098720367984955243020898718979538096223399813295457822575338958939834177325304000
+    assert binomial(3383, 52) == 27922807788818096863529701501764372757272890613101645521813434902890007725667814813832027795881839396839287659777235
+    assert binomial(4321, 51) == 124595639629264868916081001263541480185227731958274383287107643816863897851139048158022599533438936036467601690983780576
+
+    assert binomial(a, b).is_nonnegative is True
+    assert binomial(-1, 2, evaluate=False).is_nonnegative is True
+    assert binomial(10, 5, evaluate=False).is_nonnegative is True
+    assert binomial(10, -3, evaluate=False).is_nonnegative is True
+    assert binomial(-10, -3, evaluate=False).is_nonnegative is True
+    assert binomial(-10, 2, evaluate=False).is_nonnegative is True
+    assert binomial(-10, 1, evaluate=False).is_nonnegative is False
+    assert binomial(-10, 7, evaluate=False).is_nonnegative is False
+
+    # issue #14625
+    for _ in (pi, -pi, nt, v, a):
+        assert binomial(_, _) == 1
+        assert binomial(_, _ - 1) == _
+    assert isinstance(binomial(u, u), binomial)
+    assert isinstance(binomial(u, u - 1), binomial)
+    assert isinstance(binomial(x, x), binomial)
+    assert isinstance(binomial(x, x - 1), binomial)
+
+    #issue #18802
+    assert expand_func(binomial(x + 1, x)) == x + 1
+    assert expand_func(binomial(x, x - 1)) == x
+    assert expand_func(binomial(x + 1, x - 1)) == x*(x + 1)/2
+    assert expand_func(binomial(x**2 + 1, x**2)) == x**2 + 1
+
+    # issue #13980 and #13981
+    assert binomial(-7, -5) == 0
+    assert binomial(-23, -12) == 0
+    assert binomial(Rational(13, 2), -10) == 0
+    assert binomial(-49, -51) == 0
+
+    assert binomial(19, Rational(-7, 2)) == S(-68719476736)/(911337863661225*pi)
+    assert binomial(0, Rational(3, 2)) == S(-2)/(3*pi)
+    assert binomial(-3, Rational(-7, 2)) is zoo
+    assert binomial(kn, kt) is zoo
+
+    assert binomial(nt, kt).func == binomial
+    assert binomial(nt, Rational(15, 6)) == 8*gamma(nt + 1)/(15*sqrt(pi)*gamma(nt - Rational(3, 2)))
+    assert binomial(Rational(20, 3), Rational(-10, 8)) == gamma(Rational(23, 3))/(gamma(Rational(-1, 4))*gamma(Rational(107, 12)))
+    assert binomial(Rational(19, 2), Rational(-7, 2)) == Rational(-1615, 8388608)
+    assert binomial(Rational(-13, 5), Rational(-7, 8)) == gamma(Rational(-8, 5))/(gamma(Rational(-29, 40))*gamma(Rational(1, 8)))
+    assert binomial(Rational(-19, 8), Rational(-13, 5)) == gamma(Rational(-11, 8))/(gamma(Rational(-8, 5))*gamma(Rational(49, 40)))
+
+    # binomial for complexes
+    assert binomial(I, Rational(-89, 8)) == gamma(1 + I)/(gamma(Rational(-81, 8))*gamma(Rational(97, 8) + I))
+    assert binomial(I, 2*I) == gamma(1 + I)/(gamma(1 - I)*gamma(1 + 2*I))
+    assert binomial(-7, I) is zoo
+    assert binomial(Rational(-7, 6), I) == gamma(Rational(-1, 6))/(gamma(Rational(-1, 6) - I)*gamma(1 + I))
+    assert binomial((1+2*I), (1+3*I)) == gamma(2 + 2*I)/(gamma(1 - I)*gamma(2 + 3*I))
+    assert binomial(I, 5) == Rational(1, 3) - I/S(12)
+    assert binomial((2*I + 3), 7) == -13*I/S(63)
+    assert isinstance(binomial(I, n), binomial)
+    assert expand_func(binomial(3, 2, evaluate=False)) == 3
+    assert expand_func(binomial(n, 0, evaluate=False)) == 1
+    assert expand_func(binomial(n, -2, evaluate=False)) == 0
+    assert expand_func(binomial(n, k)) == binomial(n, k)
+
+
+def test_binomial_Mod():
+    p, q = 10**5 + 3, 10**9 + 33 # prime modulo
+    r = 10**7 + 5 # composite modulo
+
+    # A few tests to get coverage
+    # Lucas Theorem
+    assert Mod(binomial(156675, 4433, evaluate=False), p) == Mod(binomial(156675, 4433), p)
+
+    # factorial Mod
+    assert Mod(binomial(1234, 432, evaluate=False), q) == Mod(binomial(1234, 432), q)
+
+    # binomial factorize
+    assert Mod(binomial(253, 113, evaluate=False), r) == Mod(binomial(253, 113), r)
+
+    # using Granville's generalisation of Lucas' Theorem
+    assert Mod(binomial(10**18, 10**12, evaluate=False), p*p) == 3744312326
+
+
+@slow
+def test_binomial_Mod_slow():
+    p, q = 10**5 + 3, 10**9 + 33 # prime modulo
+    r, s = 10**7 + 5, 33333333 # composite modulo
+
+    n, k, m = symbols('n k m')
+    assert (binomial(n, k) % q).subs({n: s, k: p}) == Mod(binomial(s, p), q)
+    assert (binomial(n, k) % m).subs({n: 8, k: 5, m: 13}) == 4
+    assert (binomial(9, k) % 7).subs(k, 2) == 1
+
+    # Lucas Theorem
+    assert Mod(binomial(123456, 43253, evaluate=False), p) == Mod(binomial(123456, 43253), p)
+    assert Mod(binomial(-178911, 237, evaluate=False), p) == Mod(-binomial(178911 + 237 - 1, 237), p)
+    assert Mod(binomial(-178911, 238, evaluate=False), p) == Mod(binomial(178911 + 238 - 1, 238), p)
+
+    # factorial Mod
+    assert Mod(binomial(9734, 451, evaluate=False), q) == Mod(binomial(9734, 451), q)
+    assert Mod(binomial(-10733, 4459, evaluate=False), q) == Mod(binomial(-10733, 4459), q)
+    assert Mod(binomial(-15733, 4458, evaluate=False), q) == Mod(binomial(-15733, 4458), q)
+    assert Mod(binomial(23, -38, evaluate=False), q) is S.Zero
+    assert Mod(binomial(23, 38, evaluate=False), q) is S.Zero
+
+    # binomial factorize
+    assert Mod(binomial(753, 119, evaluate=False), r) == Mod(binomial(753, 119), r)
+    assert Mod(binomial(3781, 948, evaluate=False), s) == Mod(binomial(3781, 948), s)
+    assert Mod(binomial(25773, 1793, evaluate=False), s) == Mod(binomial(25773, 1793), s)
+    assert Mod(binomial(-753, 118, evaluate=False), r) == Mod(binomial(-753, 118), r)
+    assert Mod(binomial(-25773, 1793, evaluate=False), s) == Mod(binomial(-25773, 1793), s)
+
+
+def test_binomial_diff():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True)
+
+    assert binomial(n, k).diff(n) == \
+        (-polygamma(0, 1 + n - k) + polygamma(0, 1 + n))*binomial(n, k)
+    assert binomial(n**2, k**3).diff(n) == \
+        2*n*(-polygamma(
+            0, 1 + n**2 - k**3) + polygamma(0, 1 + n**2))*binomial(n**2, k**3)
+
+    assert binomial(n, k).diff(k) == \
+        (-polygamma(0, 1 + k) + polygamma(0, 1 + n - k))*binomial(n, k)
+    assert binomial(n**2, k**3).diff(k) == \
+        3*k**2*(-polygamma(
+            0, 1 + k**3) + polygamma(0, 1 + n**2 - k**3))*binomial(n**2, k**3)
+    raises(ArgumentIndexError, lambda: binomial(n, k).fdiff(3))
+
+
+def test_binomial_rewrite():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True)
+    x = Symbol('x')
+
+    assert binomial(n, k).rewrite(
+        factorial) == factorial(n)/(factorial(k)*factorial(n - k))
+    assert binomial(
+        n, k).rewrite(gamma) == gamma(n + 1)/(gamma(k + 1)*gamma(n - k + 1))
+    assert binomial(n, k).rewrite(ff) == ff(n, k) / factorial(k)
+    assert binomial(n, x).rewrite(ff) == binomial(n, x)
+
+
+@XFAIL
+def test_factorial_simplify_fail():
+    # simplify(factorial(x + 1).diff(x) - ((x + 1)*factorial(x)).diff(x))) == 0
+    from sympy.abc import x
+    assert simplify(x*polygamma(0, x + 1) - x*polygamma(0, x + 2) +
+                    polygamma(0, x + 1) - polygamma(0, x + 2) + 1) == 0
+
+
+def test_subfactorial():
+    assert all(subfactorial(i) == ans for i, ans in enumerate(
+        [1, 0, 1, 2, 9, 44, 265, 1854, 14833, 133496]))
+    assert subfactorial(oo) is oo
+    assert subfactorial(nan) is nan
+    assert subfactorial(23) == 9510425471055777937262
+    assert unchanged(subfactorial, 2.2)
+
+    x = Symbol('x')
+    assert subfactorial(x).rewrite(uppergamma) == uppergamma(x + 1, -1)/S.Exp1
+
+    tt = Symbol('tt', integer=True, nonnegative=True)
+    tf = Symbol('tf', integer=True, nonnegative=False)
+    tn = Symbol('tf', integer=True)
+    ft = Symbol('ft', integer=False, nonnegative=True)
+    ff = Symbol('ff', integer=False, nonnegative=False)
+    fn = Symbol('ff', integer=False)
+    nt = Symbol('nt', nonnegative=True)
+    nf = Symbol('nf', nonnegative=False)
+    nn = Symbol('nf')
+    te = Symbol('te', even=True, nonnegative=True)
+    to = Symbol('to', odd=True, nonnegative=True)
+    assert subfactorial(tt).is_integer
+    assert subfactorial(tf).is_integer is None
+    assert subfactorial(tn).is_integer is None
+    assert subfactorial(ft).is_integer is None
+    assert subfactorial(ff).is_integer is None
+    assert subfactorial(fn).is_integer is None
+    assert subfactorial(nt).is_integer is None
+    assert subfactorial(nf).is_integer is None
+    assert subfactorial(nn).is_integer is None
+    assert subfactorial(tt).is_nonnegative
+    assert subfactorial(tf).is_nonnegative is None
+    assert subfactorial(tn).is_nonnegative is None
+    assert subfactorial(ft).is_nonnegative is None
+    assert subfactorial(ff).is_nonnegative is None
+    assert subfactorial(fn).is_nonnegative is None
+    assert subfactorial(nt).is_nonnegative is None
+    assert subfactorial(nf).is_nonnegative is None
+    assert subfactorial(nn).is_nonnegative is None
+    assert subfactorial(tt).is_even is None
+    assert subfactorial(tt).is_odd is None
+    assert subfactorial(te).is_odd is True
+    assert subfactorial(to).is_even is True

openflamingo/lib/python3.10/site-packages/sympy/functions/combinatorial/tests/test_comb_numbers.py

@@ -0,0 +1,1241 @@
+import string
+
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.function import (diff, expand_func)
+from sympy.core import (EulerGamma, TribonacciConstant)
+from sympy.core.numbers import (Float, I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.numbers import carmichael
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.integers import floor
+from sympy.polys.polytools import cancel
+from sympy.series.limits import limit, Limit
+from sympy.series.order import O
+from sympy.functions import (
+    bernoulli, harmonic, bell, fibonacci, tribonacci, lucas, euler, catalan,
+    genocchi, andre, partition, divisor_sigma, udivisor_sigma, legendre_symbol,
+    jacobi_symbol, kronecker_symbol, mobius,
+    primenu, primeomega, totient, reduced_totient, primepi,
+    motzkin, binomial, gamma, sqrt, cbrt, hyper, log, digamma,
+    trigamma, polygamma, factorial, sin, cos, cot, polylog, zeta, dirichlet_eta)
+from sympy.functions.combinatorial.numbers import _nT
+from sympy.ntheory.factor_ import factorint
+
+from sympy.core.expr import unchanged
+from sympy.core.numbers import GoldenRatio, Integer
+
+from sympy.testing.pytest import raises, nocache_fail, warns_deprecated_sympy
+from sympy.abc import x
+
+
+def test_carmichael():
+    with warns_deprecated_sympy():
+        assert carmichael.is_prime(2821) == False
+
+
+def test_bernoulli():
+    assert bernoulli(0) == 1
+    assert bernoulli(1) == Rational(1, 2)
+    assert bernoulli(2) == Rational(1, 6)
+    assert bernoulli(3) == 0
+    assert bernoulli(4) == Rational(-1, 30)
+    assert bernoulli(5) == 0
+    assert bernoulli(6) == Rational(1, 42)
+    assert bernoulli(7) == 0
+    assert bernoulli(8) == Rational(-1, 30)
+    assert bernoulli(10) == Rational(5, 66)
+    assert bernoulli(1000001) == 0
+
+    assert bernoulli(0, x) == 1
+    assert bernoulli(1, x) == x - S.Half
+    assert bernoulli(2, x) == x**2 - x + Rational(1, 6)
+    assert bernoulli(3, x) == x**3 - (3*x**2)/2 + x/2
+
+    # Should be fast; computed with mpmath
+    b = bernoulli(1000)
+    assert b.p % 10**10 == 7950421099
+    assert b.q == 342999030
+
+    b = bernoulli(10**6, evaluate=False).evalf()
+    assert str(b) == '-2.23799235765713e+4767529'
+
+    # Issue #8527
+    l = Symbol('l', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+    n = Symbol('n', integer=True, positive=True)
+    assert isinstance(bernoulli(2 * l + 1), bernoulli)
+    assert isinstance(bernoulli(2 * m + 1), bernoulli)
+    assert bernoulli(2 * n + 1) == 0
+
+    assert bernoulli(x, 1) == bernoulli(x)
+
+    assert str(bernoulli(0.0, 2.3).evalf(n=10)) == '1.000000000'
+    assert str(bernoulli(1.0).evalf(n=10)) == '0.5000000000'
+    assert str(bernoulli(1.2).evalf(n=10)) == '0.4195995367'
+    assert str(bernoulli(1.2, 0.8).evalf(n=10)) == '0.2144830348'
+    assert str(bernoulli(1.2, -0.8).evalf(n=10)) == '-1.158865646 - 0.6745558744*I'
+    assert str(bernoulli(3.0, 1j).evalf(n=10)) == '1.5 - 0.5*I'
+    assert str(bernoulli(I).evalf(n=10)) == '0.9268485643 - 0.5821580598*I'
+    assert str(bernoulli(I, I).evalf(n=10)) == '0.1267792071 + 0.01947413152*I'
+    assert bernoulli(x).evalf() == bernoulli(x)
+
+
+def test_bernoulli_rewrite():
+    from sympy.functions.elementary.piecewise import Piecewise
+    n = Symbol('n', integer=True, nonnegative=True)
+
+    assert bernoulli(-1).rewrite(zeta) == pi**2/6
+    assert bernoulli(-2).rewrite(zeta) == 2*zeta(3)
+    assert not bernoulli(n, -3).rewrite(zeta).has(harmonic)
+    assert bernoulli(-4, x).rewrite(zeta) == 4*zeta(5, x)
+    assert isinstance(bernoulli(n, x).rewrite(zeta), Piecewise)
+    assert bernoulli(n+1, x).rewrite(zeta) == -(n+1) * zeta(-n, x)
+
+
+def test_fibonacci():
+    assert [fibonacci(n) for n in range(-3, 5)] == [2, -1, 1, 0, 1, 1, 2, 3]
+    assert fibonacci(100) == 354224848179261915075
+    assert [lucas(n) for n in range(-3, 5)] == [-4, 3, -1, 2, 1, 3, 4, 7]
+    assert lucas(100) == 792070839848372253127
+
+    assert fibonacci(1, x) == 1
+    assert fibonacci(2, x) == x
+    assert fibonacci(3, x) == x**2 + 1
+    assert fibonacci(4, x) == x**3 + 2*x
+
+    # issue #8800
+    n = Dummy('n')
+    assert fibonacci(n).limit(n, S.Infinity) is S.Infinity
+    assert lucas(n).limit(n, S.Infinity) is S.Infinity
+
+    assert fibonacci(n).rewrite(sqrt) == \
+        2**(-n)*sqrt(5)*((1 + sqrt(5))**n - (-sqrt(5) + 1)**n) / 5
+    assert fibonacci(n).rewrite(sqrt).subs(n, 10).expand() == fibonacci(10)
+    assert fibonacci(n).rewrite(GoldenRatio).subs(n,10).evalf() == \
+        Float(fibonacci(10))
+    assert lucas(n).rewrite(sqrt) == \
+        (fibonacci(n-1).rewrite(sqrt) + fibonacci(n+1).rewrite(sqrt)).simplify()
+    assert lucas(n).rewrite(sqrt).subs(n, 10).expand() == lucas(10)
+    raises(ValueError, lambda: fibonacci(-3, x))
+
+
+def test_tribonacci():
+    assert [tribonacci(n) for n in range(8)] == [0, 1, 1, 2, 4, 7, 13, 24]
+    assert tribonacci(100) == 98079530178586034536500564
+
+    assert tribonacci(0, x) == 0
+    assert tribonacci(1, x) == 1
+    assert tribonacci(2, x) == x**2
+    assert tribonacci(3, x) == x**4 + x
+    assert tribonacci(4, x) == x**6 + 2*x**3 + 1
+    assert tribonacci(5, x) == x**8 + 3*x**5 + 3*x**2
+
+    n = Dummy('n')
+    assert tribonacci(n).limit(n, S.Infinity) is S.Infinity
+
+    w = (-1 + S.ImaginaryUnit * sqrt(3)) / 2
+    a = (1 + cbrt(19 + 3*sqrt(33)) + cbrt(19 - 3*sqrt(33))) / 3
+    b = (1 + w*cbrt(19 + 3*sqrt(33)) + w**2*cbrt(19 - 3*sqrt(33))) / 3
+    c = (1 + w**2*cbrt(19 + 3*sqrt(33)) + w*cbrt(19 - 3*sqrt(33))) / 3
+    assert tribonacci(n).rewrite(sqrt) == \
+      (a**(n + 1)/((a - b)*(a - c))
+      + b**(n + 1)/((b - a)*(b - c))
+      + c**(n + 1)/((c - a)*(c - b)))
+    assert tribonacci(n).rewrite(sqrt).subs(n, 4).simplify() == tribonacci(4)
+    assert tribonacci(n).rewrite(GoldenRatio).subs(n,10).evalf() == \
+        Float(tribonacci(10))
+    assert tribonacci(n).rewrite(TribonacciConstant) == floor(
+            3*TribonacciConstant**n*(102*sqrt(33) + 586)**Rational(1, 3)/
+            (-2*(102*sqrt(33) + 586)**Rational(1, 3) + 4 + (102*sqrt(33)
+            + 586)**Rational(2, 3)) + S.Half)
+    raises(ValueError, lambda: tribonacci(-1, x))
+
+
+@nocache_fail
+def test_bell():
+    assert [bell(n) for n in range(8)] == [1, 1, 2, 5, 15, 52, 203, 877]
+
+    assert bell(0, x) == 1
+    assert bell(1, x) == x
+    assert bell(2, x) == x**2 + x
+    assert bell(5, x) == x**5 + 10*x**4 + 25*x**3 + 15*x**2 + x
+    assert bell(oo) is S.Infinity
+    raises(ValueError, lambda: bell(oo, x))
+
+    raises(ValueError, lambda: bell(-1))
+    raises(ValueError, lambda: bell(S.Half))
+
+    X = symbols('x:6')
+    # X = (x0, x1, .. x5)
+    # at the same time: X[1] = x1, X[2] = x2 for standard readablity.
+    # but we must supply zero-based indexed object X[1:] = (x1, .. x5)
+
+    assert bell(6, 2, X[1:]) == 6*X[5]*X[1] + 15*X[4]*X[2] + 10*X[3]**2
+    assert bell(
+        6, 3, X[1:]) == 15*X[4]*X[1]**2 + 60*X[3]*X[2]*X[1] + 15*X[2]**3
+
+    X = (1, 10, 100, 1000, 10000)
+    assert bell(6, 2, X) == (6 + 15 + 10)*10000
+
+    X = (1, 2, 3, 3, 5)
+    assert bell(6, 2, X) == 6*5 + 15*3*2 + 10*3**2
+
+    X = (1, 2, 3, 5)
+    assert bell(6, 3, X) == 15*5 + 60*3*2 + 15*2**3
+
+    # Dobinski's formula
+    n = Symbol('n', integer=True, nonnegative=True)
+    # For large numbers, this is too slow
+    # For nonintegers, there are significant precision errors
+    for i in [0, 2, 3, 7, 13, 42, 55]:
+        # Running without the cache this is either very slow or goes into an
+        # infinite loop.
+        assert bell(i).evalf() == bell(n).rewrite(Sum).evalf(subs={n: i})
+
+    m = Symbol("m")
+    assert bell(m).rewrite(Sum) == bell(m)
+    assert bell(n, m).rewrite(Sum) == bell(n, m)
+    # issue 9184
+    n = Dummy('n')
+    assert bell(n).limit(n, S.Infinity) is S.Infinity
+
+
+def test_harmonic():
+    n = Symbol("n")
+    m = Symbol("m")
+
+    assert harmonic(n, 0) == n
+    assert harmonic(n).evalf() == harmonic(n)
+    assert harmonic(n, 1) == harmonic(n)
+    assert harmonic(1, n) == 1
+
+    assert harmonic(0, 1) == 0
+    assert harmonic(1, 1) == 1
+    assert harmonic(2, 1) == Rational(3, 2)
+    assert harmonic(3, 1) == Rational(11, 6)
+    assert harmonic(4, 1) == Rational(25, 12)
+    assert harmonic(0, 2) == 0
+    assert harmonic(1, 2) == 1
+    assert harmonic(2, 2) == Rational(5, 4)
+    assert harmonic(3, 2) == Rational(49, 36)
+    assert harmonic(4, 2) == Rational(205, 144)
+    assert harmonic(0, 3) == 0
+    assert harmonic(1, 3) == 1
+    assert harmonic(2, 3) == Rational(9, 8)
+    assert harmonic(3, 3) == Rational(251, 216)
+    assert harmonic(4, 3) == Rational(2035, 1728)
+
+    assert harmonic(oo, -1) is S.NaN
+    assert harmonic(oo, 0) is oo
+    assert harmonic(oo, S.Half) is oo
+    assert harmonic(oo, 1) is oo
+    assert harmonic(oo, 2) == (pi**2)/6
+    assert harmonic(oo, 3) == zeta(3)
+    assert harmonic(oo, Dummy(negative=True)) is S.NaN
+    ip = Dummy(integer=True, positive=True)
+    if (1/ip <= 1) is True:  #---------------------------------+
+        assert None, 'delete this if-block and the next line' #|
+    ip = Dummy(even=True, positive=True)  #--------------------+
+    assert harmonic(oo, 1/ip) is oo
+    assert harmonic(oo, 1 + ip) is zeta(1 + ip)
+
+    assert harmonic(0, m) == 0
+    assert harmonic(-1, -1) == 0
+    assert harmonic(-1, 0) == -1
+    assert harmonic(-1, 1) is S.ComplexInfinity
+    assert harmonic(-1, 2) is S.NaN
+    assert harmonic(-3, -2) == -5
+    assert harmonic(-3, -3) == 9
+
+
+def test_harmonic_rational():
+    ne = S(6)
+    no = S(5)
+    pe = S(8)
+    po = S(9)
+    qe = S(10)
+    qo = S(13)
+
+    Heee = harmonic(ne + pe/qe)
+    Aeee = (-log(10) + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + pi*sqrt(2*sqrt(5)/5 + 1)/2 + Rational(13944145, 4720968))
+
+    Heeo = harmonic(ne + pe/qo)
+    Aeeo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(4, 13)) + 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(32, 13))
+             + 2*log(sin(pi*Rational(5, 13)))*cos(pi*Rational(80, 13)) - 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(5, 13))
+             - 2*log(sin(pi*Rational(4, 13)))*cos(pi/13) + pi*cot(pi*Rational(5, 13))/2 - 2*log(sin(pi/13))*cos(pi*Rational(3, 13))
+             + Rational(2422020029, 702257080))
+
+    Heoe = harmonic(ne + po/qe)
+    Aeoe = (-log(20) + 2*(Rational(1, 4) + sqrt(5)/4)*log(Rational(-1, 4) + sqrt(5)/4)
+             + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 + Rational(1, 4))*log(Rational(1, 4) + sqrt(5)/4)
+             + Rational(11818877030, 4286604231) + pi*sqrt(2*sqrt(5) + 5)/2)
+
+    Heoo = harmonic(ne + po/qo)
+    Aeoo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(54, 13)) + 2*log(sin(pi*Rational(4, 13)))*cos(pi*Rational(6, 13))
+             + 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(108, 13)) - 2*log(sin(pi*Rational(5, 13)))*cos(pi/13)
+             - 2*log(sin(pi/13))*cos(pi*Rational(5, 13)) + pi*cot(pi*Rational(4, 13))/2
+             - 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(3, 13)) + Rational(11669332571, 3628714320))
+
+    Hoee = harmonic(no + pe/qe)
+    Aoee = (-log(10) + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + pi*sqrt(2*sqrt(5)/5 + 1)/2 + Rational(779405, 277704))
+
+    Hoeo = harmonic(no + pe/qo)
+    Aoeo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(4, 13)) + 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(32, 13))
+             + 2*log(sin(pi*Rational(5, 13)))*cos(pi*Rational(80, 13)) - 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(5, 13))
+             - 2*log(sin(pi*Rational(4, 13)))*cos(pi/13) + pi*cot(pi*Rational(5, 13))/2
+             - 2*log(sin(pi/13))*cos(pi*Rational(3, 13)) + Rational(53857323, 16331560))
+
+    Hooe = harmonic(no + po/qe)
+    Aooe = (-log(20) + 2*(Rational(1, 4) + sqrt(5)/4)*log(Rational(-1, 4) + sqrt(5)/4)
+             + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 + Rational(1, 4))*log(Rational(1, 4) + sqrt(5)/4)
+             + Rational(486853480, 186374097) + pi*sqrt(2*sqrt(5) + 5)/2)
+
+    Hooo = harmonic(no + po/qo)
+    Aooo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(54, 13)) + 2*log(sin(pi*Rational(4, 13)))*cos(pi*Rational(6, 13))
+             + 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(108, 13)) - 2*log(sin(pi*Rational(5, 13)))*cos(pi/13)
+             - 2*log(sin(pi/13))*cos(pi*Rational(5, 13)) + pi*cot(pi*Rational(4, 13))/2
+             - 2*log(sin(pi*Rational(2, 13)))*cos(3*pi/13) + Rational(383693479, 125128080))
+
+    H = [Heee, Heeo, Heoe, Heoo, Hoee, Hoeo, Hooe, Hooo]
+    A = [Aeee, Aeeo, Aeoe, Aeoo, Aoee, Aoeo, Aooe, Aooo]
+    for h, a in zip(H, A):
+        e = expand_func(h).doit()
+        assert cancel(e/a) == 1
+        assert abs(h.n() - a.n()) < 1e-12
+
+
+def test_harmonic_evalf():
+    assert str(harmonic(1.5).evalf(n=10)) == '1.280372306'
+    assert str(harmonic(1.5, 2).evalf(n=10)) == '1.154576311'  # issue 7443
+    assert str(harmonic(4.0, -3).evalf(n=10)) == '100.0000000'
+    assert str(harmonic(7.0, 1.0).evalf(n=10)) == '2.592857143'
+    assert str(harmonic(1, pi).evalf(n=10)) == '1.000000000'
+    assert str(harmonic(2, pi).evalf(n=10)) == '1.113314732'
+    assert str(harmonic(1000.0, pi).evalf(n=10)) == '1.176241563'
+    assert str(harmonic(I).evalf(n=10)) == '0.6718659855 + 1.076674047*I'
+    assert str(harmonic(I, I).evalf(n=10)) == '-0.3970915266 + 1.9629689*I'
+
+    assert harmonic(-1.0, 1).evalf() is S.NaN
+    assert harmonic(-2.0, 2.0).evalf() is S.NaN
+
+def test_harmonic_rewrite():
+    from sympy.functions.elementary.piecewise import Piecewise
+    n = Symbol("n")
+    m = Symbol("m", integer=True, positive=True)
+    x1 = Symbol("x1", positive=True)
+    x2 = Symbol("x2", negative=True)
+
+    assert harmonic(n).rewrite(digamma) == polygamma(0, n + 1) + EulerGamma
+    assert harmonic(n).rewrite(trigamma) == polygamma(0, n + 1) + EulerGamma
+    assert harmonic(n).rewrite(polygamma) == polygamma(0, n + 1) + EulerGamma
+
+    assert harmonic(n,3).rewrite(polygamma) == polygamma(2, n + 1)/2 - polygamma(2, 1)/2
+    assert isinstance(harmonic(n,m).rewrite(polygamma), Piecewise)
+
+    assert expand_func(harmonic(n+4)) == harmonic(n) + 1/(n + 4) + 1/(n + 3) + 1/(n + 2) + 1/(n + 1)
+    assert expand_func(harmonic(n-4)) == harmonic(n) - 1/(n - 1) - 1/(n - 2) - 1/(n - 3) - 1/n
+
+    assert harmonic(n, m).rewrite("tractable") == harmonic(n, m).rewrite(polygamma)
+    assert harmonic(n, x1).rewrite("tractable") == harmonic(n, x1)
+    assert harmonic(n, x1 + 1).rewrite("tractable") == zeta(x1 + 1) - zeta(x1 + 1, n + 1)
+    assert harmonic(n, x2).rewrite("tractable") == zeta(x2) - zeta(x2, n + 1)
+
+    _k = Dummy("k")
+    assert harmonic(n).rewrite(Sum).dummy_eq(Sum(1/_k, (_k, 1, n)))
+    assert harmonic(n, m).rewrite(Sum).dummy_eq(Sum(_k**(-m), (_k, 1, n)))
+
+
+def test_harmonic_calculus():
+    y = Symbol("y", positive=True)
+    z = Symbol("z", negative=True)
+    assert harmonic(x, 1).limit(x, 0) == 0
+    assert harmonic(x, y).limit(x, 0) == 0
+    assert harmonic(x, 1).series(x, y, 2) == \
+            harmonic(y) + (x - y)*zeta(2, y + 1) + O((x - y)**2, (x, y))
+    assert limit(harmonic(x, y), x, oo) == harmonic(oo, y)
+    assert limit(harmonic(x, y + 1), x, oo) == zeta(y + 1)
+    assert limit(harmonic(x, y - 1), x, oo) == harmonic(oo, y - 1)
+    assert limit(harmonic(x, z), x, oo) == Limit(harmonic(x, z), x, oo, dir='-')
+    assert limit(harmonic(x, z + 1), x, oo) == oo
+    assert limit(harmonic(x, z + 2), x, oo) == harmonic(oo, z + 2)
+    assert limit(harmonic(x, z - 1), x, oo) == Limit(harmonic(x, z - 1), x, oo, dir='-')
+
+
+def test_euler():
+    assert euler(0) == 1
+    assert euler(1) == 0
+    assert euler(2) == -1
+    assert euler(3) == 0
+    assert euler(4) == 5
+    assert euler(6) == -61
+    assert euler(8) == 1385
+
+    assert euler(20, evaluate=False) != 370371188237525
+
+    n = Symbol('n', integer=True)
+    assert euler(n) != -1
+    assert euler(n).subs(n, 2) == -1
+
+    assert euler(-1) == S.Pi / 2
+    assert euler(-1, 1) == 2*log(2)
+    assert euler(-2).evalf() == (2*S.Catalan).evalf()
+    assert euler(-3).evalf() == (S.Pi**3 / 16).evalf()
+    assert str(euler(2.3).evalf(n=10)) == '-1.052850274'
+    assert str(euler(1.2, 3.4).evalf(n=10)) == '3.575613489'
+    assert str(euler(I).evalf(n=10)) == '1.248446443 - 0.7675445124*I'
+    assert str(euler(I, I).evalf(n=10)) == '0.04812930469 + 0.01052411008*I'
+
+    assert euler(20).evalf() == 370371188237525.0
+    assert euler(20, evaluate=False).evalf() == 370371188237525.0
+
+    assert euler(n).rewrite(Sum) == euler(n)
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert euler(2*n + 1).rewrite(Sum) == 0
+    _j = Dummy('j')
+    _k = Dummy('k')
+    assert euler(2*n).rewrite(Sum).dummy_eq(
+            I*Sum((-1)**_j*2**(-_k)*I**(-_k)*(-2*_j + _k)**(2*n + 1)*
+                  binomial(_k, _j)/_k, (_j, 0, _k), (_k, 1, 2*n + 1)))
+
+
+def test_euler_odd():
+    n = Symbol('n', odd=True, positive=True)
+    assert euler(n) == 0
+    n = Symbol('n', odd=True)
+    assert euler(n) != 0
+
+
+def test_euler_polynomials():
+    assert euler(0, x) == 1
+    assert euler(1, x) == x - S.Half
+    assert euler(2, x) == x**2 - x
+    assert euler(3, x) == x**3 - (3*x**2)/2 + Rational(1, 4)
+    m = Symbol('m')
+    assert isinstance(euler(m, x), euler)
+    from sympy.core.numbers import Float
+    A = Float('-0.46237208575048694923364757452876131e8')  # from Maple
+    B = euler(19, S.Pi).evalf(32)
+    assert abs((A - B)/A) < 1e-31
+
+
+def test_euler_polynomial_rewrite():
+    m = Symbol('m')
+    A = euler(m, x).rewrite('Sum');
+    assert A.subs({m:3, x:5}).doit() == euler(3, 5)
+
+
+def test_catalan():
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True, positive=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+    p = Symbol('p', nonnegative=True)
+
+    catalans = [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786]
+    for i, c in enumerate(catalans):
+        assert catalan(i) == c
+        assert catalan(n).rewrite(factorial).subs(n, i) == c
+        assert catalan(n).rewrite(Product).subs(n, i).doit() == c
+
+    assert unchanged(catalan, x)
+    assert catalan(2*x).rewrite(binomial) == binomial(4*x, 2*x)/(2*x + 1)
+    assert catalan(S.Half).rewrite(gamma) == 8/(3*pi)
+    assert catalan(S.Half).rewrite(factorial).rewrite(gamma) ==\
+        8 / (3 * pi)
+    assert catalan(3*x).rewrite(gamma) == 4**(
+        3*x)*gamma(3*x + S.Half)/(sqrt(pi)*gamma(3*x + 2))
+    assert catalan(x).rewrite(hyper) == hyper((-x + 1, -x), (2,), 1)
+
+    assert catalan(n).rewrite(factorial) == factorial(2*n) / (factorial(n + 1)
+                                                              * factorial(n))
+    assert isinstance(catalan(n).rewrite(Product), catalan)
+    assert isinstance(catalan(m).rewrite(Product), Product)
+
+    assert diff(catalan(x), x) == (polygamma(
+        0, x + S.Half) - polygamma(0, x + 2) + log(4))*catalan(x)
+
+    assert catalan(x).evalf() == catalan(x)
+    c = catalan(S.Half).evalf()
+    assert str(c) == '0.848826363156775'
+    c = catalan(I).evalf(3)
+    assert str((re(c), im(c))) == '(0.398, -0.0209)'
+
+    # Assumptions
+    assert catalan(p).is_positive is True
+    assert catalan(k).is_integer is True
+    assert catalan(m+3).is_composite is True
+
+
+def test_genocchi():
+    genocchis = [0, -1, -1, 0, 1, 0, -3, 0, 17]
+    for n, g in enumerate(genocchis):
+        assert genocchi(n) == g
+
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True, positive=True)
+    assert unchanged(genocchi, m)
+    assert genocchi(2*n + 1) == 0
+    gn = 2 * (1 - 2**n) * bernoulli(n)
+    assert genocchi(n).rewrite(bernoulli).factor() == gn.factor()
+    gnx = 2 * (bernoulli(n, x) - 2**n * bernoulli(n, (x+1) / 2))
+    assert genocchi(n, x).rewrite(bernoulli).factor() == gnx.factor()
+    assert genocchi(2 * n).is_odd
+    assert genocchi(2 * n).is_even is False
+    assert genocchi(2 * n + 1).is_even
+    assert genocchi(n).is_integer
+    assert genocchi(4 * n).is_positive
+    # these are the only 2 prime Genocchi numbers
+    assert genocchi(6, evaluate=False).is_prime == S(-3).is_prime
+    assert genocchi(8, evaluate=False).is_prime
+    assert genocchi(4 * n + 2).is_negative
+    assert genocchi(4 * n + 1).is_negative is False
+    assert genocchi(4 * n - 2).is_negative
+
+    g0 = genocchi(0, evaluate=False)
+    assert g0.is_positive is False
+    assert g0.is_negative is False
+    assert g0.is_even is True
+    assert g0.is_odd is False
+
+    assert genocchi(0, x) == 0
+    assert genocchi(1, x) == -1
+    assert genocchi(2, x) == 1 - 2*x
+    assert genocchi(3, x) == 3*x - 3*x**2
+    assert genocchi(4, x) == -1 + 6*x**2 - 4*x**3
+    y = Symbol("y")
+    assert genocchi(5, (x+y)**100) == -5*(x+y)**400 + 10*(x+y)**300 - 5*(x+y)**100
+
+    assert str(genocchi(5.0, 4.0).evalf(n=10)) == '-660.0000000'
+    assert str(genocchi(Rational(5, 4)).evalf(n=10)) == '-1.104286457'
+    assert str(genocchi(-2).evalf(n=10)) == '3.606170709'
+    assert str(genocchi(1.3, 3.7).evalf(n=10)) == '-1.847375373'
+    assert str(genocchi(I, 1.0).evalf(n=10)) == '-0.3161917278 - 1.45311955*I'
+
+    n = Symbol('n')
+    assert genocchi(n, x).rewrite(dirichlet_eta) == -2*n * dirichlet_eta(1-n, x)
+
+
+def test_andre():
+    nums = [1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521]
+    for n, a in enumerate(nums):
+        assert andre(n) == a
+    assert andre(S.Infinity) == S.Infinity
+    assert andre(-1) == -log(2)
+    assert andre(-2) == -2*S.Catalan
+    assert andre(-3) == 3*zeta(3)/16
+    assert andre(-5) == -15*zeta(5)/256
+    # In fact andre(-2*n) is related to the Dirichlet *beta* function
+    # at 2*n, but SymPy doesn't implement that (or general L-functions)
+    assert unchanged(andre, -4)
+
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert unchanged(andre, n)
+    assert andre(n).is_integer is True
+    assert andre(n).is_positive is True
+
+    assert str(andre(10, evaluate=False).evalf(n=10)) == '50521.00000'
+    assert str(andre(-1, evaluate=False).evalf(n=10)) == '-0.6931471806'
+    assert str(andre(-2, evaluate=False).evalf(n=10)) == '-1.831931188'
+    assert str(andre(-4, evaluate=False).evalf(n=10)) == '1.977889103'
+    assert str(andre(I, evaluate=False).evalf(n=10)) == '2.378417833 + 0.6343322845*I'
+
+    assert andre(x).rewrite(polylog) == \
+            (-I)**(x+1) * polylog(-x, I) + I**(x+1) * polylog(-x, -I)
+    assert andre(x).rewrite(zeta) == \
+            2 * gamma(x+1) / (2*pi)**(x+1) * \
+            (zeta(x+1, Rational(1,4)) - cos(pi*x) * zeta(x+1, Rational(3,4)))
+
+
+@nocache_fail
+def test_partition():
+    partition_nums = [1, 1, 2, 3, 5, 7, 11, 15, 22]
+    for n, p in enumerate(partition_nums):
+        assert partition(n) == p
+
+    x = Symbol('x')
+    y = Symbol('y', real=True)
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True, negative=True)
+    p = Symbol('p', integer=True, nonnegative=True)
+    assert partition(m).is_integer
+    assert not partition(m).is_negative
+    assert partition(m).is_nonnegative
+    assert partition(n).is_zero
+    assert partition(p).is_positive
+    assert partition(x).subs(x, 7) == 15
+    assert partition(y).subs(y, 8) == 22
+    raises(TypeError, lambda: partition(Rational(5, 4)))
+
+
+def test_divisor_sigma():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: divisor_sigma(m))
+    raises(TypeError, lambda: divisor_sigma(4.5))
+    raises(TypeError, lambda: divisor_sigma(1, m))
+    raises(TypeError, lambda: divisor_sigma(1, 4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: divisor_sigma(m))
+    raises(ValueError, lambda: divisor_sigma(0))
+    m = Symbol('m', negative=True)
+    raises(ValueError, lambda: divisor_sigma(1, m))
+    raises(ValueError, lambda: divisor_sigma(1, -1))
+
+    # special case
+    p = Symbol('p', prime=True)
+    k = Symbol('k', integer=True)
+    assert divisor_sigma(p, 1) == p + 1
+    assert divisor_sigma(p, k) == p**k + 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert divisor_sigma(n).is_integer is True
+    assert divisor_sigma(n).is_positive is True
+
+    # symbolic
+    k = Symbol('k', integer=True, zero=False)
+    assert divisor_sigma(4, k) == 2**(2*k) + 2**k + 1
+    assert divisor_sigma(6, k) == (2**k + 1) * (3**k + 1)
+
+    # Integer
+    assert divisor_sigma(23450) == 50592
+    assert divisor_sigma(23450, 0) == 24
+    assert divisor_sigma(23450, 1) == 50592
+    assert divisor_sigma(23450, 2) == 730747500
+    assert divisor_sigma(23450, 3) == 14666785333344
+
+
+def test_udivisor_sigma():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: udivisor_sigma(m))
+    raises(TypeError, lambda: udivisor_sigma(4.5))
+    raises(TypeError, lambda: udivisor_sigma(1, m))
+    raises(TypeError, lambda: udivisor_sigma(1, 4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: udivisor_sigma(m))
+    raises(ValueError, lambda: udivisor_sigma(0))
+    m = Symbol('m', negative=True)
+    raises(ValueError, lambda: udivisor_sigma(1, m))
+    raises(ValueError, lambda: udivisor_sigma(1, -1))
+
+    # special case
+    p = Symbol('p', prime=True)
+    k = Symbol('k', integer=True)
+    assert udivisor_sigma(p, 1) == p + 1
+    assert udivisor_sigma(p, k) == p**k + 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert udivisor_sigma(n).is_integer is True
+    assert udivisor_sigma(n).is_positive is True
+
+    # Integer
+    A034444 = [1, 2, 2, 2, 2, 4, 2, 2, 2, 4, 2, 4, 2, 4, 4, 2, 2, 4, 2, 4,
+               4, 4, 2, 4, 2, 4, 2, 4, 2, 8, 2, 2, 4, 4, 4, 4, 2, 4, 4, 4,
+               2, 8, 2, 4, 4, 4, 2, 4, 2, 4, 4, 4, 2, 4, 4, 4, 4, 4, 2, 8]
+    for n, val in enumerate(A034444, 1):
+        assert udivisor_sigma(n, 0) == val
+    A034448 = [1, 3, 4, 5, 6, 12, 8, 9, 10, 18, 12, 20, 14, 24, 24, 17, 18,
+               30, 20, 30, 32, 36, 24, 36, 26, 42, 28, 40, 30, 72, 32, 33,
+               48, 54, 48, 50, 38, 60, 56, 54, 42, 96, 44, 60, 60, 72, 48]
+    for n, val in enumerate(A034448, 1):
+        assert udivisor_sigma(n, 1) == val
+    A034676 = [1, 5, 10, 17, 26, 50, 50, 65, 82, 130, 122, 170, 170, 250,
+               260, 257, 290, 410, 362, 442, 500, 610, 530, 650, 626, 850,
+               730, 850, 842, 1300, 962, 1025, 1220, 1450, 1300, 1394, 1370]
+    for n, val in enumerate(A034676, 1):
+        assert udivisor_sigma(n, 2) == val
+
+
+def test_legendre_symbol():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: legendre_symbol(m, 3))
+    raises(TypeError, lambda: legendre_symbol(4.5, 3))
+    raises(TypeError, lambda: legendre_symbol(1, m))
+    raises(TypeError, lambda: legendre_symbol(1, 4.5))
+    m = Symbol('m', prime=False)
+    raises(ValueError, lambda: legendre_symbol(1, m))
+    raises(ValueError, lambda: legendre_symbol(1, 6))
+    m = Symbol('m', odd=False)
+    raises(ValueError, lambda: legendre_symbol(1, m))
+    raises(ValueError, lambda: legendre_symbol(1, 2))
+
+    # special case
+    p = Symbol('p', prime=True)
+    k = Symbol('k', integer=True)
+    assert legendre_symbol(p*k, p) == 0
+    assert legendre_symbol(1, p) == 1
+
+    # property
+    n = Symbol('n')
+    m = Symbol('m')
+    assert legendre_symbol(m, n).is_integer is True
+    assert legendre_symbol(m, n).is_prime is False
+
+    # Integer
+    assert legendre_symbol(5, 11) == 1
+    assert legendre_symbol(25, 41) == 1
+    assert legendre_symbol(67, 101) == -1
+    assert legendre_symbol(0, 13) == 0
+    assert legendre_symbol(9, 3) == 0
+
+
+def test_jacobi_symbol():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: jacobi_symbol(m, 3))
+    raises(TypeError, lambda: jacobi_symbol(4.5, 3))
+    raises(TypeError, lambda: jacobi_symbol(1, m))
+    raises(TypeError, lambda: jacobi_symbol(1, 4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: jacobi_symbol(1, m))
+    raises(ValueError, lambda: jacobi_symbol(1, -6))
+    m = Symbol('m', odd=False)
+    raises(ValueError, lambda: jacobi_symbol(1, m))
+    raises(ValueError, lambda: jacobi_symbol(1, 2))
+
+    # special case
+    p = Symbol('p', integer=True)
+    k = Symbol('k', integer=True)
+    assert jacobi_symbol(p*k, p) == 0
+    assert jacobi_symbol(1, p) == 1
+    assert jacobi_symbol(1, 1) == 1
+    assert jacobi_symbol(0, 1) == 1
+
+    # property
+    n = Symbol('n')
+    m = Symbol('m')
+    assert jacobi_symbol(m, n).is_integer is True
+    assert jacobi_symbol(m, n).is_prime is False
+
+    # Integer
+    assert jacobi_symbol(25, 41) == 1
+    assert jacobi_symbol(-23, 83) == -1
+    assert jacobi_symbol(3, 9) == 0
+    assert jacobi_symbol(42, 97) == -1
+    assert jacobi_symbol(3, 5) == -1
+    assert jacobi_symbol(7, 9) == 1
+    assert jacobi_symbol(0, 3) == 0
+    assert jacobi_symbol(0, 1) == 1
+    assert jacobi_symbol(2, 1) == 1
+    assert jacobi_symbol(1, 3) == 1
+
+
+def test_kronecker_symbol():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: kronecker_symbol(m, 3))
+    raises(TypeError, lambda: kronecker_symbol(4.5, 3))
+    raises(TypeError, lambda: kronecker_symbol(1, m))
+    raises(TypeError, lambda: kronecker_symbol(1, 4.5))
+
+    # special case
+    p = Symbol('p', integer=True)
+    assert kronecker_symbol(1, p) == 1
+    assert kronecker_symbol(1, 1) == 1
+    assert kronecker_symbol(0, 1) == 1
+
+    # property
+    n = Symbol('n')
+    m = Symbol('m')
+    assert kronecker_symbol(m, n).is_integer is True
+    assert kronecker_symbol(m, n).is_prime is False
+
+    # Integer
+    for n in range(3, 10, 2):
+        for a in range(-n, n):
+            val = kronecker_symbol(a, n)
+            assert val == jacobi_symbol(a, n)
+            minus = kronecker_symbol(a, -n)
+            if a < 0:
+                assert -minus == val
+            else:
+                assert minus == val
+            even = kronecker_symbol(a, 2 * n)
+            if a % 2 == 0:
+                assert even == 0
+            elif a % 8 in [1, 7]:
+                assert even == val
+            else:
+                assert -even == val
+    assert kronecker_symbol(1, 0) == kronecker_symbol(-1, 0) == 1
+    assert kronecker_symbol(0, 0) == 0
+
+
+def test_mobius():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: mobius(m))
+    raises(TypeError, lambda: mobius(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: mobius(m))
+    raises(ValueError, lambda: mobius(-3))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert mobius(p) == -1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert mobius(n).is_integer is True
+    assert mobius(n).is_prime is False
+
+    # symbolic
+    n = Symbol('n', integer=True, positive=True)
+    k = Symbol('k', integer=True, positive=True)
+    assert mobius(n**2) == 0
+    assert mobius(4*n) == 0
+    assert isinstance(mobius(n**k), mobius)
+    assert mobius(n**(k+1)) == 0
+    assert isinstance(mobius(3**k), mobius)
+    assert mobius(3**(k+1)) == 0
+    m = Symbol('m')
+    assert isinstance(mobius(4*m), mobius)
+
+    # Integer
+    assert mobius(13*7) == 1
+    assert mobius(1) == 1
+    assert mobius(13*7*5) == -1
+    assert mobius(13**2) == 0
+    A008683 = [1, -1, -1, 0, -1, 1, -1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1, 0,
+               -1, 0, 1, 1, -1, 0, 0, 1, 0, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1,
+               1, 1, 0, -1, -1, -1, 0, 0, 1, -1, 0, 0, 0, 1, 0, -1, 0, 1, 0]
+    for n, val in enumerate(A008683, 1):
+        assert mobius(n) == val
+
+
+def test_primenu():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: primenu(m))
+    raises(TypeError, lambda: primenu(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: primenu(m))
+    raises(ValueError, lambda: primenu(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert primenu(p) == 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert primenu(n).is_integer is True
+    assert primenu(n).is_nonnegative is True
+
+    # Integer
+    assert primenu(7*13) == 2
+    assert primenu(2*17*19) == 3
+    assert primenu(2**3 * 17 * 19**2) == 3
+    A001221 = [0, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 2, 1, 2, 2, 1, 1, 2,
+               1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 1, 2, 2, 2, 2]
+    for n, val in enumerate(A001221, 1):
+        assert primenu(n) == val
+
+
+def test_primeomega():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: primeomega(m))
+    raises(TypeError, lambda: primeomega(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: primeomega(m))
+    raises(ValueError, lambda: primeomega(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert primeomega(p) == 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert primeomega(n).is_integer is True
+    assert primeomega(n).is_nonnegative is True
+
+    # Integer
+    assert primeomega(7*13) == 2
+    assert primeomega(2*17*19) == 3
+    assert primeomega(2**3 * 17 * 19**2) == 6
+    A001222 = [0, 1, 1, 2, 1, 2, 1, 3, 2, 2, 1, 3, 1, 2, 2, 4, 1, 3,
+               1, 3, 2, 2, 1, 4, 2, 2, 3, 3, 1, 3, 1, 5, 2, 2, 2, 4]
+    for n, val in enumerate(A001222, 1):
+        assert primeomega(n) == val
+
+
+def test_totient():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: totient(m))
+    raises(TypeError, lambda: totient(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: totient(m))
+    raises(ValueError, lambda: totient(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert totient(p) == p - 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert totient(n).is_integer is True
+    assert totient(n).is_positive is True
+
+    # Integer
+    assert totient(7*13) == totient(factorint(7*13)) == (7-1)*(13-1)
+    assert totient(2*17*19) == totient(factorint(2*17*19)) == (17-1)*(19-1)
+    assert totient(2**3 * 17 * 19**2) == totient({2: 3, 17: 1, 19: 2}) == 2**2 * (17-1) * 19*(19-1)
+    A000010 = [1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16,
+               6, 18, 8, 12, 10, 22, 8, 20, 12, 18, 12, 28, 8, 30, 16,
+               20, 16, 24, 12, 36, 18, 24, 16, 40, 12, 42, 20, 24, 22]
+    for n, val in enumerate(A000010, 1):
+        assert totient(n) == val
+
+
+def test_reduced_totient():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: reduced_totient(m))
+    raises(TypeError, lambda: reduced_totient(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: reduced_totient(m))
+    raises(ValueError, lambda: reduced_totient(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert reduced_totient(p) == p - 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert reduced_totient(n).is_integer is True
+    assert reduced_totient(n).is_positive is True
+
+    # Integer
+    assert reduced_totient(7*13) == reduced_totient(factorint(7*13)) == 12
+    assert reduced_totient(2*17*19) == reduced_totient(factorint(2*17*19)) == 144
+    assert reduced_totient(2**2 * 11) == reduced_totient({2: 2, 11: 1}) == 10
+    assert reduced_totient(2**3 * 17 * 19**2) == reduced_totient({2: 3, 17: 1, 19: 2}) == 2736
+    A002322 = [1, 1, 2, 2, 4, 2, 6, 2, 6, 4, 10, 2, 12, 6, 4, 4, 16, 6,
+               18, 4, 6, 10, 22, 2, 20, 12, 18, 6, 28, 4, 30, 8, 10, 16,
+               12, 6, 36, 18, 12, 4, 40, 6, 42, 10, 12, 22, 46, 4, 42]
+    for n, val in enumerate(A002322, 1):
+        assert reduced_totient(n) == val
+
+
+def test_primepi():
+    # error
+    z = Symbol('z', real=False)
+    raises(TypeError, lambda: primepi(z))
+    raises(TypeError, lambda: primepi(I))
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert primepi(n).is_integer is True
+    assert primepi(n).is_nonnegative is True
+
+    # infinity
+    assert primepi(oo) == oo
+    assert primepi(-oo) == 0
+
+    # symbol
+    x = Symbol('x')
+    assert isinstance(primepi(x), primepi)
+
+    # Integer
+    assert primepi(0) == 0
+    A000720 = [0, 1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 8,
+               8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 11, 11, 11, 11, 11, 11,
+               12, 12, 12, 12, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15]
+    for n, val in enumerate(A000720, 1):
+        assert primepi(n) == primepi(n + 0.5) == val
+
+
+def test__nT():
+       assert [_nT(i, j) for i in range(5) for j in range(i + 2)] == [
+    1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 2, 1, 1, 0]
+       check = [_nT(10, i) for i in range(11)]
+       assert check == [0, 1, 5, 8, 9, 7, 5, 3, 2, 1, 1]
+       assert all(type(i) is int for i in check)
+       assert _nT(10, 5) == 7
+       assert _nT(100, 98) == 2
+       assert _nT(100, 100) == 1
+       assert _nT(10, 3) == 8
+
+
+def test_nC_nP_nT():
+    from sympy.utilities.iterables import (
+        multiset_permutations, multiset_combinations, multiset_partitions,
+        partitions, subsets, permutations)
+    from sympy.functions.combinatorial.numbers import (
+        nP, nC, nT, stirling, _stirling1, _stirling2, _multiset_histogram, _AOP_product)
+
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.core.random import choice
+
+    c = string.ascii_lowercase
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(8):
+                check = nP(s, i)
+                tot += check
+                assert len(list(multiset_permutations(s, i))) == check
+                if u:
+                    assert nP(len(s), i) == check
+            assert nP(s) == tot
+        except AssertionError:
+            print(s, i, 'failed perm test')
+            raise ValueError()
+
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(8):
+                check = nC(s, i)
+                tot += check
+                assert len(list(multiset_combinations(s, i))) == check
+                if u:
+                    assert nC(len(s), i) == check
+            assert nC(s) == tot
+            if u:
+                assert nC(len(s)) == tot
+        except AssertionError:
+            print(s, i, 'failed combo test')
+            raise ValueError()
+
+    for i in range(1, 10):
+        tot = 0
+        for j in range(1, i + 2):
+            check = nT(i, j)
+            assert check.is_Integer
+            tot += check
+            assert sum(1 for p in partitions(i, j, size=True) if p[0] == j) == check
+        assert nT(i) == tot
+
+    for i in range(1, 10):
+        tot = 0
+        for j in range(1, i + 2):
+            check = nT(range(i), j)
+            tot += check
+            assert len(list(multiset_partitions(list(range(i)), j))) == check
+        assert nT(range(i)) == tot
+
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(1, 8):
+                check = nT(s, i)
+                tot += check
+                assert len(list(multiset_partitions(s, i))) == check
+                if u:
+                    assert nT(range(len(s)), i) == check
+            if u:
+                assert nT(range(len(s))) == tot
+            assert nT(s) == tot
+        except AssertionError:
+            print(s, i, 'failed partition test')
+            raise ValueError()
+
+    # tests for Stirling numbers of the first kind that are not tested in the
+    # above
+    assert [stirling(9, i, kind=1) for i in range(11)] == [
+        0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1, 0]
+    perms = list(permutations(range(4)))
+    assert [sum(1 for p in perms if Permutation(p).cycles == i)
+            for i in range(5)] == [0, 6, 11, 6, 1] == [
+            stirling(4, i, kind=1) for i in range(5)]
+    # http://oeis.org/A008275
+    assert [stirling(n, k, signed=1)
+        for n in range(10) for k in range(1, n + 1)] == [
+            1, -1,
+            1, 2, -3,
+            1, -6, 11, -6,
+            1, 24, -50, 35, -10,
+            1, -120, 274, -225, 85, -15,
+            1, 720, -1764, 1624, -735, 175, -21,
+            1, -5040, 13068, -13132, 6769, -1960, 322, -28,
+            1, 40320, -109584, 118124, -67284, 22449, -4536, 546, -36, 1]
+    # https://en.wikipedia.org/wiki/Stirling_numbers_of_the_first_kind
+    assert  [stirling(n, k, kind=1)
+        for n in range(10) for k in range(n+1)] == [
+            1,
+            0, 1,
+            0, 1, 1,
+            0, 2, 3, 1,
+            0, 6, 11, 6, 1,
+            0, 24, 50, 35, 10, 1,
+            0, 120, 274, 225, 85, 15, 1,
+            0, 720, 1764, 1624, 735, 175, 21, 1,
+            0, 5040, 13068, 13132, 6769, 1960, 322, 28, 1,
+            0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1]
+    # https://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind
+    assert [stirling(n, k, kind=2)
+        for n in range(10) for k in range(n+1)] == [
+            1,
+            0, 1,
+            0, 1, 1,
+            0, 1, 3, 1,
+            0, 1, 7, 6, 1,
+            0, 1, 15, 25, 10, 1,
+            0, 1, 31, 90, 65, 15, 1,
+            0, 1, 63, 301, 350, 140, 21, 1,
+            0, 1, 127, 966, 1701, 1050, 266, 28, 1,
+            0, 1, 255, 3025, 7770, 6951, 2646, 462, 36, 1]
+    assert stirling(3, 4, kind=1) == stirling(3, 4, kind=1) == 0
+    raises(ValueError, lambda: stirling(-2, 2))
+
+    # Assertion that the return type is SymPy Integer.
+    assert isinstance(_stirling1(6, 3), Integer)
+    assert isinstance(_stirling2(6, 3), Integer)
+
+    def delta(p):
+        if len(p) == 1:
+            return oo
+        return min(abs(i[0] - i[1]) for i in subsets(p, 2))
+    parts = multiset_partitions(range(5), 3)
+    d = 2
+    assert (sum(1 for p in parts if all(delta(i) >= d for i in p)) ==
+            stirling(5, 3, d=d) == 7)
+
+    # other coverage tests
+    assert nC('abb', 2) == nC('aab', 2) == 2
+    assert nP(3, 3, replacement=True) == nP('aabc', 3, replacement=True) == 27
+    assert nP(3, 4) == 0
+    assert nP('aabc', 5) == 0
+    assert nC(4, 2, replacement=True) == nC('abcdd', 2, replacement=True) == \
+        len(list(multiset_combinations('aabbccdd', 2))) == 10
+    assert nC('abcdd') == sum(nC('abcdd', i) for i in range(6)) == 24
+    assert nC(list('abcdd'), 4) == 4
+    assert nT('aaaa') == nT(4) == len(list(partitions(4))) == 5
+    assert nT('aaab') == len(list(multiset_partitions('aaab'))) == 7
+    assert nC('aabb'*3, 3) == 4  # aaa, bbb, abb, baa
+    assert dict(_AOP_product((4,1,1,1))) == {
+        0: 1, 1: 4, 2: 7, 3: 8, 4: 8, 5: 7, 6: 4, 7: 1}
+    # the following was the first t that showed a problem in a previous form of
+    # the function, so it's not as random as it may appear
+    t = (3, 9, 4, 6, 6, 5, 5, 2, 10, 4)
+    assert sum(_AOP_product(t)[i] for i in range(55)) == 58212000
+    raises(ValueError, lambda: _multiset_histogram({1:'a'}))
+
+
+def test_PR_14617():
+    from sympy.functions.combinatorial.numbers import nT
+    for n in (0, []):
+        for k in (-1, 0, 1):
+            if k == 0:
+                assert nT(n, k) == 1
+            else:
+                assert nT(n, k) == 0
+
+
+def test_issue_8496():
+    n = Symbol("n")
+    k = Symbol("k")
+
+    raises(TypeError, lambda: catalan(n, k))
+
+
+def test_issue_8601():
+    n = Symbol('n', integer=True, negative=True)
+
+    assert catalan(n - 1) is S.Zero
+    assert catalan(Rational(-1, 2)) is S.ComplexInfinity
+    assert catalan(-S.One) == Rational(-1, 2)
+    c1 = catalan(-5.6).evalf()
+    assert str(c1) == '6.93334070531408e-5'
+    c2 = catalan(-35.4).evalf()
+    assert str(c2) == '-4.14189164517449e-24'
+
+
+def test_motzkin():
+    assert motzkin.is_motzkin(4) == True
+    assert motzkin.is_motzkin(9) == True
+    assert motzkin.is_motzkin(10) == False
+    assert motzkin.find_motzkin_numbers_in_range(10,200) == [21, 51, 127]
+    assert motzkin.find_motzkin_numbers_in_range(10,400) == [21, 51, 127, 323]
+    assert motzkin.find_motzkin_numbers_in_range(10,1600) == [21, 51, 127, 323, 835]
+    assert motzkin.find_first_n_motzkins(5) == [1, 1, 2, 4, 9]
+    assert motzkin.find_first_n_motzkins(7) == [1, 1, 2, 4, 9, 21, 51]
+    assert motzkin.find_first_n_motzkins(10) == [1, 1, 2, 4, 9, 21, 51, 127, 323, 835]
+    raises(ValueError, lambda: motzkin.eval(77.58))
+    raises(ValueError, lambda: motzkin.eval(-8))
+    raises(ValueError, lambda: motzkin.find_motzkin_numbers_in_range(-2,7))
+    raises(ValueError, lambda: motzkin.find_motzkin_numbers_in_range(13,7))
+    raises(ValueError, lambda: motzkin.find_first_n_motzkins(112.8))
+
+
+def test_nD_derangements():
+    from sympy.utilities.iterables import (partitions, multiset,
+        multiset_derangements, multiset_permutations)
+    from sympy.functions.combinatorial.numbers import nD
+
+    got = []
+    for i in partitions(8, k=4):
+        s = []
+        it = 0
+        for k, v in i.items():
+            for i in range(v):
+                s.extend([it]*k)
+                it += 1
+        ms = multiset(s)
+        c1 = sum(1 for i in multiset_permutations(s) if
+            all(i != j for i, j in zip(i, s)))
+        assert c1 == nD(ms) == nD(ms, 0) == nD(ms, 1)
+        v = [tuple(i) for i in multiset_derangements(s)]
+        c2 = len(v)
+        assert c2 == len(set(v))
+        assert c1 == c2
+        got.append(c1)
+    assert got == [1, 4, 6, 12, 24, 24, 61, 126, 315, 780, 297, 772,
+        2033, 5430, 14833]
+
+    assert nD('1112233456', brute=True) == nD('1112233456') == 16356
+    assert nD('') == nD([]) == nD({}) == 0
+    assert nD({1: 0}) == 0
+    raises(ValueError, lambda: nD({1: -1}))
+    assert nD('112') == 0
+    assert nD(i='112') == 0
+    assert [nD(n=i) for i in range(6)] == [0, 0, 1, 2, 9, 44]
+    assert nD((i for i in range(4))) == nD('0123') == 9
+    assert nD(m=(i for i in range(4))) == 3
+    assert nD(m={0: 1, 1: 1, 2: 1, 3: 1}) == 3
+    assert nD(m=[0, 1, 2, 3]) == 3
+    raises(TypeError, lambda: nD(m=0))
+    raises(TypeError, lambda: nD(-1))
+    assert nD({-1: 1, -2: 1}) == 1
+    assert nD(m={0: 3}) == 0
+    raises(ValueError, lambda: nD(i='123', n=3))
+    raises(ValueError, lambda: nD(i='123', m=(1,2)))
+    raises(ValueError, lambda: nD(n=0, m=(1,2)))
+    raises(ValueError, lambda: nD({1: -1}))
+    raises(ValueError, lambda: nD(m={-1: 1, 2: 1}))
+    raises(ValueError, lambda: nD(m={1: -1, 2: 1}))
+    raises(ValueError, lambda: nD(m=[-1, 2]))
+    raises(TypeError, lambda: nD({1: x}))
+    raises(TypeError, lambda: nD(m={1: x}))
+    raises(TypeError, lambda: nD(m={x: 1}))
+
+
+def test_deprecated_ntheory_symbolic_functions():
+    from sympy.testing.pytest import warns_deprecated_sympy
+
+    with warns_deprecated_sympy():
+        assert not carmichael.is_carmichael(3)
+    with warns_deprecated_sympy():
+        assert carmichael.find_carmichael_numbers_in_range(10, 20) == []
+    with warns_deprecated_sympy():
+        assert carmichael.find_first_n_carmichaels(1)

openflamingo/lib/python3.10/site-packages/sympy/functions/special/benchmarks/bench_special.py

@@ -0,0 +1,8 @@
+from sympy.core.symbol import symbols
+from sympy.functions.special.spherical_harmonics import Ynm
+
+x, y = symbols('x,y')
+
+
+def timeit_Ynm_xy():
+    Ynm(1, 1, x, y)

openflamingo/lib/python3.10/site-packages/sympy/matrices/eigen.py

@@ -0,0 +1,1346 @@
+from types import FunctionType
+from collections import Counter
+
+from mpmath import mp, workprec
+from mpmath.libmp.libmpf import prec_to_dps
+
+from sympy.core.sorting import default_sort_key
+from sympy.core.evalf import DEFAULT_MAXPREC, PrecisionExhausted
+from sympy.core.logic import fuzzy_and, fuzzy_or
+from sympy.core.numbers import Float
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys import roots, CRootOf, ZZ, QQ, EX
+from sympy.polys.matrices import DomainMatrix
+from sympy.polys.matrices.eigen import dom_eigenvects, dom_eigenvects_to_sympy
+from sympy.polys.polytools import gcd
+
+from .exceptions import MatrixError, NonSquareMatrixError
+from .determinant import _find_reasonable_pivot
+
+from .utilities import _iszero, _simplify
+
+
+__doctest_requires__ = {
+    ('_is_indefinite',
+     '_is_negative_definite',
+     '_is_negative_semidefinite',
+     '_is_positive_definite',
+     '_is_positive_semidefinite'): ['matplotlib'],
+}
+
+
+def _eigenvals_eigenvects_mpmath(M):
+    norm2 = lambda v: mp.sqrt(sum(i**2 for i in v))
+
+    v1 = None
+    prec = max(x._prec for x in M.atoms(Float))
+    eps = 2**-prec
+
+    while prec < DEFAULT_MAXPREC:
+        with workprec(prec):
+            A = mp.matrix(M.evalf(n=prec_to_dps(prec)))
+            E, ER = mp.eig(A)
+            v2 = norm2([i for e in E for i in (mp.re(e), mp.im(e))])
+            if v1 is not None and mp.fabs(v1 - v2) < eps:
+                return E, ER
+            v1 = v2
+        prec *= 2
+
+    # we get here because the next step would have taken us
+    # past MAXPREC or because we never took a step; in case
+    # of the latter, we refuse to send back a solution since
+    # it would not have been verified; we also resist taking
+    # a small step to arrive exactly at MAXPREC since then
+    # the two calculations might be artificially close.
+    raise PrecisionExhausted
+
+
+def _eigenvals_mpmath(M, multiple=False):
+    """Compute eigenvalues using mpmath"""
+    E, _ = _eigenvals_eigenvects_mpmath(M)
+    result = [_sympify(x) for x in E]
+    if multiple:
+        return result
+    return dict(Counter(result))
+
+
+def _eigenvects_mpmath(M):
+    E, ER = _eigenvals_eigenvects_mpmath(M)
+    result = []
+    for i in range(M.rows):
+        eigenval = _sympify(E[i])
+        eigenvect = _sympify(ER[:, i])
+        result.append((eigenval, 1, [eigenvect]))
+
+    return result
+
+
+# This function is a candidate for caching if it gets implemented for matrices.
+def _eigenvals(
+    M, error_when_incomplete=True, *, simplify=False, multiple=False,
+    rational=False, **flags):
+    r"""Compute eigenvalues of the matrix.
+
+    Parameters
+    ==========
+
+    error_when_incomplete : bool, optional
+        If it is set to ``True``, it will raise an error if not all
+        eigenvalues are computed. This is caused by ``roots`` not returning
+        a full list of eigenvalues.
+
+    simplify : bool or function, optional
+        If it is set to ``True``, it attempts to return the most
+        simplified form of expressions returned by applying default
+        simplification method in every routine.
+
+        If it is set to ``False``, it will skip simplification in this
+        particular routine to save computation resources.
+
+        If a function is passed to, it will attempt to apply
+        the particular function as simplification method.
+
+    rational : bool, optional
+        If it is set to ``True``, every floating point numbers would be
+        replaced with rationals before computation. It can solve some
+        issues of ``roots`` routine not working well with floats.
+
+    multiple : bool, optional
+        If it is set to ``True``, the result will be in the form of a
+        list.
+
+        If it is set to ``False``, the result will be in the form of a
+        dictionary.
+
+    Returns
+    =======
+
+    eigs : list or dict
+        Eigenvalues of a matrix. The return format would be specified by
+        the key ``multiple``.
+
+    Raises
+    ======
+
+    MatrixError
+        If not enough roots had got computed.
+
+    NonSquareMatrixError
+        If attempted to compute eigenvalues from a non-square matrix.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix(3, 3, [0, 1, 1, 1, 0, 0, 1, 1, 1])
+    >>> M.eigenvals()
+    {-1: 1, 0: 1, 2: 1}
+
+    See Also
+    ========
+
+    MatrixBase.charpoly
+    eigenvects
+
+    Notes
+    =====
+
+    Eigenvalues of a matrix $A$ can be computed by solving a matrix
+    equation $\det(A - \lambda I) = 0$
+
+    It's not always possible to return radical solutions for
+    eigenvalues for matrices larger than $4, 4$ shape due to
+    Abel-Ruffini theorem.
+
+    If there is no radical solution is found for the eigenvalue,
+    it may return eigenvalues in the form of
+    :class:`sympy.polys.rootoftools.ComplexRootOf`.
+    """
+    if not M:
+        if multiple:
+            return []
+        return {}
+
+    if not M.is_square:
+        raise NonSquareMatrixError("{} must be a square matrix.".format(M))
+
+    if M._rep.domain not in (ZZ, QQ):
+        # Skip this check for ZZ/QQ because it can be slow
+        if all(x.is_number for x in M) and M.has(Float):
+            return _eigenvals_mpmath(M, multiple=multiple)
+
+    if rational:
+        from sympy.simplify import nsimplify
+        M = M.applyfunc(
+            lambda x: nsimplify(x, rational=True) if x.has(Float) else x)
+
+    if multiple:
+        return _eigenvals_list(
+            M, error_when_incomplete=error_when_incomplete, simplify=simplify,
+            **flags)
+    return _eigenvals_dict(
+        M, error_when_incomplete=error_when_incomplete, simplify=simplify,
+        **flags)
+
+
+eigenvals_error_message = \
+"It is not always possible to express the eigenvalues of a matrix " + \
+"of size 5x5 or higher in radicals. " + \
+"We have CRootOf, but domains other than the rationals are not " + \
+"currently supported. " + \
+"If there are no symbols in the matrix, " + \
+"it should still be possible to compute numeric approximations " + \
+"of the eigenvalues using " + \
+"M.evalf().eigenvals() or M.charpoly().nroots()."
+
+
+def _eigenvals_list(
+    M, error_when_incomplete=True, simplify=False, **flags):
+    iblocks = M.strongly_connected_components()
+    all_eigs = []
+    is_dom = M._rep.domain in (ZZ, QQ)
+    for b in iblocks:
+
+        # Fast path for a 1x1 block:
+        if is_dom and len(b) == 1:
+            index = b[0]
+            val = M[index, index]
+            all_eigs.append(val)
+            continue
+
+        block = M[b, b]
+
+        if isinstance(simplify, FunctionType):
+            charpoly = block.charpoly(simplify=simplify)
+        else:
+            charpoly = block.charpoly()
+
+        eigs = roots(charpoly, multiple=True, **flags)
+
+        if len(eigs) != block.rows:
+            try:
+                eigs = charpoly.all_roots(multiple=True)
+            except NotImplementedError:
+                if error_when_incomplete:
+                    raise MatrixError(eigenvals_error_message)
+                else:
+                    eigs = []
+
+        all_eigs += eigs
+
+    if not simplify:
+        return all_eigs
+    if not isinstance(simplify, FunctionType):
+        simplify = _simplify
+    return [simplify(value) for value in all_eigs]
+
+
+def _eigenvals_dict(
+    M, error_when_incomplete=True, simplify=False, **flags):
+    iblocks = M.strongly_connected_components()
+    all_eigs = {}
+    is_dom = M._rep.domain in (ZZ, QQ)
+    for b in iblocks:
+
+        # Fast path for a 1x1 block:
+        if is_dom and len(b) == 1:
+            index = b[0]
+            val = M[index, index]
+            all_eigs[val] = all_eigs.get(val, 0) + 1
+            continue
+
+        block = M[b, b]
+
+        if isinstance(simplify, FunctionType):
+            charpoly = block.charpoly(simplify=simplify)
+        else:
+            charpoly = block.charpoly()
+
+        eigs = roots(charpoly, multiple=False, **flags)
+
+        if sum(eigs.values()) != block.rows:
+            try:
+                eigs = dict(charpoly.all_roots(multiple=False))
+            except NotImplementedError:
+                if error_when_incomplete:
+                    raise MatrixError(eigenvals_error_message)
+                else:
+                    eigs = {}
+
+        for k, v in eigs.items():
+            if k in all_eigs:
+                all_eigs[k] += v
+            else:
+                all_eigs[k] = v
+
+    if not simplify:
+        return all_eigs
+    if not isinstance(simplify, FunctionType):
+        simplify = _simplify
+    return {simplify(key): value for key, value in all_eigs.items()}
+
+
+def _eigenspace(M, eigenval, iszerofunc=_iszero, simplify=False):
+    """Get a basis for the eigenspace for a particular eigenvalue"""
+    m   = M - M.eye(M.rows) * eigenval
+    ret = m.nullspace(iszerofunc=iszerofunc)
+
+    # The nullspace for a real eigenvalue should be non-trivial.
+    # If we didn't find an eigenvector, try once more a little harder
+    if len(ret) == 0 and simplify:
+        ret = m.nullspace(iszerofunc=iszerofunc, simplify=True)
+    if len(ret) == 0:
+        raise NotImplementedError(
+            "Can't evaluate eigenvector for eigenvalue {}".format(eigenval))
+    return ret
+
+
+def _eigenvects_DOM(M, **kwargs):
+    DOM = DomainMatrix.from_Matrix(M, field=True, extension=True)
+    DOM = DOM.to_dense()
+
+    if DOM.domain != EX:
+        rational, algebraic = dom_eigenvects(DOM)
+        eigenvects = dom_eigenvects_to_sympy(
+            rational, algebraic, M.__class__, **kwargs)
+        eigenvects = sorted(eigenvects, key=lambda x: default_sort_key(x[0]))
+
+        return eigenvects
+    return None
+
+
+def _eigenvects_sympy(M, iszerofunc, simplify=True, **flags):
+    eigenvals = M.eigenvals(rational=False, **flags)
+
+    # Make sure that we have all roots in radical form
+    for x in eigenvals:
+        if x.has(CRootOf):
+            raise MatrixError(
+                "Eigenvector computation is not implemented if the matrix have "
+                "eigenvalues in CRootOf form")
+
+    eigenvals = sorted(eigenvals.items(), key=default_sort_key)
+    ret = []
+    for val, mult in eigenvals:
+        vects = _eigenspace(M, val, iszerofunc=iszerofunc, simplify=simplify)
+        ret.append((val, mult, vects))
+    return ret
+
+
+# This functions is a candidate for caching if it gets implemented for matrices.
+def _eigenvects(M, error_when_incomplete=True, iszerofunc=_iszero, *, chop=False, **flags):
+    """Compute eigenvectors of the matrix.
+
+    Parameters
+    ==========
+
+    error_when_incomplete : bool, optional
+        Raise an error when not all eigenvalues are computed. This is
+        caused by ``roots`` not returning a full list of eigenvalues.
+
+    iszerofunc : function, optional
+        Specifies a zero testing function to be used in ``rref``.
+
+        Default value is ``_iszero``, which uses SymPy's naive and fast
+        default assumption handler.
+
+        It can also accept any user-specified zero testing function, if it
+        is formatted as a function which accepts a single symbolic argument
+        and returns ``True`` if it is tested as zero and ``False`` if it
+        is tested as non-zero, and ``None`` if it is undecidable.
+
+    simplify : bool or function, optional
+        If ``True``, ``as_content_primitive()`` will be used to tidy up
+        normalization artifacts.
+
+        It will also be used by the ``nullspace`` routine.
+
+    chop : bool or positive number, optional
+        If the matrix contains any Floats, they will be changed to Rationals
+        for computation purposes, but the answers will be returned after
+        being evaluated with evalf. The ``chop`` flag is passed to ``evalf``.
+        When ``chop=True`` a default precision will be used; a number will
+        be interpreted as the desired level of precision.
+
+    Returns
+    =======
+
+    ret : [(eigenval, multiplicity, eigenspace), ...]
+        A ragged list containing tuples of data obtained by ``eigenvals``
+        and ``nullspace``.
+
+        ``eigenspace`` is a list containing the ``eigenvector`` for each
+        eigenvalue.
+
+        ``eigenvector`` is a vector in the form of a ``Matrix``. e.g.
+        a vector of length 3 is returned as ``Matrix([a_1, a_2, a_3])``.
+
+    Raises
+    ======
+
+    NotImplementedError
+        If failed to compute nullspace.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix(3, 3, [0, 1, 1, 1, 0, 0, 1, 1, 1])
+    >>> M.eigenvects()
+    [(-1, 1, [Matrix([
+    [-1],
+    [ 1],
+    [ 0]])]), (0, 1, [Matrix([
+    [ 0],
+    [-1],
+    [ 1]])]), (2, 1, [Matrix([
+    [2/3],
+    [1/3],
+    [  1]])])]
+
+    See Also
+    ========
+
+    eigenvals
+    MatrixBase.nullspace
+    """
+    simplify = flags.get('simplify', True)
+    primitive = flags.get('simplify', False)
+    flags.pop('simplify', None)  # remove this if it's there
+    flags.pop('multiple', None)  # remove this if it's there
+
+    if not isinstance(simplify, FunctionType):
+        simpfunc = _simplify if simplify else lambda x: x
+
+    has_floats = M.has(Float)
+    if has_floats:
+        if all(x.is_number for x in M):
+            return _eigenvects_mpmath(M)
+        from sympy.simplify import nsimplify
+        M = M.applyfunc(lambda x: nsimplify(x, rational=True))
+
+    ret = _eigenvects_DOM(M)
+    if ret is None:
+        ret = _eigenvects_sympy(M, iszerofunc, simplify=simplify, **flags)
+
+    if primitive:
+        # if the primitive flag is set, get rid of any common
+        # integer denominators
+        def denom_clean(l):
+            return [(v / gcd(list(v))).applyfunc(simpfunc) for v in l]
+
+        ret = [(val, mult, denom_clean(es)) for val, mult, es in ret]
+
+    if has_floats:
+        # if we had floats to start with, turn the eigenvectors to floats
+        ret = [(val.evalf(chop=chop), mult, [v.evalf(chop=chop) for v in es])
+                for val, mult, es in ret]
+
+    return ret
+
+
+def _is_diagonalizable_with_eigen(M, reals_only=False):
+    """See _is_diagonalizable. This function returns the bool along with the
+    eigenvectors to avoid calculating them again in functions like
+    ``diagonalize``."""
+
+    if not M.is_square:
+        return False, []
+
+    eigenvecs = M.eigenvects(simplify=True)
+
+    for val, mult, basis in eigenvecs:
+        if reals_only and not val.is_real: # if we have a complex eigenvalue
+            return False, eigenvecs
+
+        if mult != len(basis): # if the geometric multiplicity doesn't equal the algebraic
+            return False, eigenvecs
+
+    return True, eigenvecs
+
+def _is_diagonalizable(M, reals_only=False, **kwargs):
+    """Returns ``True`` if a matrix is diagonalizable.
+
+    Parameters
+    ==========
+
+    reals_only : bool, optional
+        If ``True``, it tests whether the matrix can be diagonalized
+        to contain only real numbers on the diagonal.
+
+
+        If ``False``, it tests whether the matrix can be diagonalized
+        at all, even with numbers that may not be real.
+
+    Examples
+    ========
+
+    Example of a diagonalizable matrix:
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[1, 2, 0], [0, 3, 0], [2, -4, 2]])
+    >>> M.is_diagonalizable()
+    True
+
+    Example of a non-diagonalizable matrix:
+
+    >>> M = Matrix([[0, 1], [0, 0]])
+    >>> M.is_diagonalizable()
+    False
+
+    Example of a matrix that is diagonalized in terms of non-real entries:
+
+    >>> M = Matrix([[0, 1], [-1, 0]])
+    >>> M.is_diagonalizable(reals_only=False)
+    True
+    >>> M.is_diagonalizable(reals_only=True)
+    False
+
+    See Also
+    ========
+
+    sympy.matrices.matrixbase.MatrixBase.is_diagonal
+    diagonalize
+    """
+    if not M.is_square:
+        return False
+
+    if all(e.is_real for e in M) and M.is_symmetric():
+        return True
+
+    if all(e.is_complex for e in M) and M.is_hermitian:
+        return True
+
+    return _is_diagonalizable_with_eigen(M, reals_only=reals_only)[0]
+
+
+#G&VL, Matrix Computations, Algo 5.4.2
+def _householder_vector(x):
+    if not x.cols == 1:
+        raise ValueError("Input must be a column matrix")
+    v = x.copy()
+    v_plus = x.copy()
+    v_minus = x.copy()
+    q = x[0, 0] / abs(x[0, 0])
+    norm_x = x.norm()
+    v_plus[0, 0] = x[0, 0] + q * norm_x
+    v_minus[0, 0] = x[0, 0] - q * norm_x
+    if x[1:, 0].norm() == 0:
+        bet = 0
+        v[0, 0] = 1
+    else:
+        if v_plus.norm() <= v_minus.norm():
+            v = v_plus
+        else:
+            v = v_minus
+        v = v / v[0]
+        bet = 2 / (v.norm() ** 2)
+    return v, bet
+
+
+def _bidiagonal_decmp_hholder(M):
+    m = M.rows
+    n = M.cols
+    A = M.as_mutable()
+    U, V = A.eye(m), A.eye(n)
+    for i in range(min(m, n)):
+        v, bet = _householder_vector(A[i:, i])
+        hh_mat = A.eye(m - i) - bet * v * v.H
+        A[i:, i:] = hh_mat * A[i:, i:]
+        temp = A.eye(m)
+        temp[i:, i:] = hh_mat
+        U = U * temp
+        if i + 1 <= n - 2:
+            v, bet = _householder_vector(A[i, i+1:].T)
+            hh_mat = A.eye(n - i - 1) - bet * v * v.H
+            A[i:, i+1:] = A[i:, i+1:] * hh_mat
+            temp = A.eye(n)
+            temp[i+1:, i+1:] = hh_mat
+            V = temp * V
+    return U, A, V
+
+
+def _eval_bidiag_hholder(M):
+    m = M.rows
+    n = M.cols
+    A = M.as_mutable()
+    for i in range(min(m, n)):
+        v, bet = _householder_vector(A[i:, i])
+        hh_mat = A.eye(m-i) - bet * v * v.H
+        A[i:, i:] = hh_mat * A[i:, i:]
+        if i + 1 <= n - 2:
+            v, bet = _householder_vector(A[i, i+1:].T)
+            hh_mat = A.eye(n - i - 1) - bet * v * v.H
+            A[i:, i+1:] = A[i:, i+1:] * hh_mat
+    return A
+
+
+def _bidiagonal_decomposition(M, upper=True):
+    """
+    Returns $(U,B,V.H)$ for
+
+    $$A = UBV^{H}$$
+
+    where $A$ is the input matrix, and $B$ is its Bidiagonalized form
+
+    Note: Bidiagonal Computation can hang for symbolic matrices.
+
+    Parameters
+    ==========
+
+    upper : bool. Whether to do upper bidiagnalization or lower.
+                True for upper and False for lower.
+
+    References
+    ==========
+
+    .. [1] Algorithm 5.4.2, Matrix computations by Golub and Van Loan, 4th edition
+    .. [2] Complex Matrix Bidiagonalization, https://github.com/vslobody/Householder-Bidiagonalization
+
+    """
+
+    if not isinstance(upper, bool):
+        raise ValueError("upper must be a boolean")
+
+    if upper:
+        return _bidiagonal_decmp_hholder(M)
+
+    X = _bidiagonal_decmp_hholder(M.H)
+    return X[2].H, X[1].H, X[0].H
+
+
+def _bidiagonalize(M, upper=True):
+    """
+    Returns $B$, the Bidiagonalized form of the input matrix.
+
+    Note: Bidiagonal Computation can hang for symbolic matrices.
+
+    Parameters
+    ==========
+
+    upper : bool. Whether to do upper bidiagnalization or lower.
+                True for upper and False for lower.
+
+    References
+    ==========
+
+    .. [1] Algorithm 5.4.2, Matrix computations by Golub and Van Loan, 4th edition
+    .. [2] Complex Matrix Bidiagonalization : https://github.com/vslobody/Householder-Bidiagonalization
+
+    """
+
+    if not isinstance(upper, bool):
+        raise ValueError("upper must be a boolean")
+
+    if upper:
+        return _eval_bidiag_hholder(M)
+    return _eval_bidiag_hholder(M.H).H
+
+
+def _diagonalize(M, reals_only=False, sort=False, normalize=False):
+    """
+    Return (P, D), where D is diagonal and
+
+        D = P^-1 * M * P
+
+    where M is current matrix.
+
+    Parameters
+    ==========
+
+    reals_only : bool. Whether to throw an error if complex numbers are need
+                    to diagonalize. (Default: False)
+
+    sort : bool. Sort the eigenvalues along the diagonal. (Default: False)
+
+    normalize : bool. If True, normalize the columns of P. (Default: False)
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix(3, 3, [1, 2, 0, 0, 3, 0, 2, -4, 2])
+    >>> M
+    Matrix([
+    [1,  2, 0],
+    [0,  3, 0],
+    [2, -4, 2]])
+    >>> (P, D) = M.diagonalize()
+    >>> D
+    Matrix([
+    [1, 0, 0],
+    [0, 2, 0],
+    [0, 0, 3]])
+    >>> P
+    Matrix([
+    [-1, 0, -1],
+    [ 0, 0, -1],
+    [ 2, 1,  2]])
+    >>> P.inv() * M * P
+    Matrix([
+    [1, 0, 0],
+    [0, 2, 0],
+    [0, 0, 3]])
+
+    See Also
+    ========
+
+    sympy.matrices.matrixbase.MatrixBase.is_diagonal
+    is_diagonalizable
+    """
+
+    if not M.is_square:
+        raise NonSquareMatrixError()
+
+    is_diagonalizable, eigenvecs = _is_diagonalizable_with_eigen(M,
+                reals_only=reals_only)
+
+    if not is_diagonalizable:
+        raise MatrixError("Matrix is not diagonalizable")
+
+    if sort:
+        eigenvecs = sorted(eigenvecs, key=default_sort_key)
+
+    p_cols, diag = [], []
+
+    for val, mult, basis in eigenvecs:
+        diag   += [val] * mult
+        p_cols += basis
+
+    if normalize:
+        p_cols = [v / v.norm() for v in p_cols]
+
+    return M.hstack(*p_cols), M.diag(*diag)
+
+
+def _fuzzy_positive_definite(M):
+    positive_diagonals = M._has_positive_diagonals()
+    if positive_diagonals is False:
+        return False
+
+    if positive_diagonals and M.is_strongly_diagonally_dominant:
+        return True
+
+    return None
+
+
+def _fuzzy_positive_semidefinite(M):
+    nonnegative_diagonals = M._has_nonnegative_diagonals()
+    if nonnegative_diagonals is False:
+        return False
+
+    if nonnegative_diagonals and M.is_weakly_diagonally_dominant:
+        return True
+
+    return None
+
+
+def _is_positive_definite(M):
+    if not M.is_hermitian:
+        if not M.is_square:
+            return False
+        M = M + M.H
+
+    fuzzy = _fuzzy_positive_definite(M)
+    if fuzzy is not None:
+        return fuzzy
+
+    return _is_positive_definite_GE(M)
+
+
+def _is_positive_semidefinite(M):
+    if not M.is_hermitian:
+        if not M.is_square:
+            return False
+        M = M + M.H
+
+    fuzzy = _fuzzy_positive_semidefinite(M)
+    if fuzzy is not None:
+        return fuzzy
+
+    return _is_positive_semidefinite_cholesky(M)
+
+
+def _is_negative_definite(M):
+    return _is_positive_definite(-M)
+
+
+def _is_negative_semidefinite(M):
+    return _is_positive_semidefinite(-M)
+
+
+def _is_indefinite(M):
+    if M.is_hermitian:
+        eigen = M.eigenvals()
+        args1        = [x.is_positive for x in eigen.keys()]
+        any_positive = fuzzy_or(args1)
+        args2        = [x.is_negative for x in eigen.keys()]
+        any_negative = fuzzy_or(args2)
+
+        return fuzzy_and([any_positive, any_negative])
+
+    elif M.is_square:
+        return (M + M.H).is_indefinite
+
+    return False
+
+
+def _is_positive_definite_GE(M):
+    """A division-free gaussian elimination method for testing
+    positive-definiteness."""
+    M = M.as_mutable()
+    size = M.rows
+
+    for i in range(size):
+        is_positive = M[i, i].is_positive
+        if is_positive is not True:
+            return is_positive
+        for j in range(i+1, size):
+            M[j, i+1:] = M[i, i] * M[j, i+1:] - M[j, i] * M[i, i+1:]
+    return True
+
+
+def _is_positive_semidefinite_cholesky(M):
+    """Uses Cholesky factorization with complete pivoting
+
+    References
+    ==========
+
+    .. [1] http://eprints.ma.man.ac.uk/1199/1/covered/MIMS_ep2008_116.pdf
+
+    .. [2] https://www.value-at-risk.net/cholesky-factorization/
+    """
+    M = M.as_mutable()
+    for k in range(M.rows):
+        diags = [M[i, i] for i in range(k, M.rows)]
+        pivot, pivot_val, nonzero, _ = _find_reasonable_pivot(diags)
+
+        if nonzero:
+            return None
+
+        if pivot is None:
+            for i in range(k+1, M.rows):
+                for j in range(k, M.cols):
+                    iszero = M[i, j].is_zero
+                    if iszero is None:
+                        return None
+                    elif iszero is False:
+                        return False
+            return True
+
+        if M[k, k].is_negative or pivot_val.is_negative:
+            return False
+        elif not (M[k, k].is_nonnegative and pivot_val.is_nonnegative):
+            return None
+
+        if pivot > 0:
+            M.col_swap(k, k+pivot)
+            M.row_swap(k, k+pivot)
+
+        M[k, k] = sqrt(M[k, k])
+        M[k, k+1:] /= M[k, k]
+        M[k+1:, k+1:] -= M[k, k+1:].H * M[k, k+1:]
+
+    return M[-1, -1].is_nonnegative
+
+
+_doc_positive_definite = \
+    r"""Finds out the definiteness of a matrix.
+
+    Explanation
+    ===========
+
+    A square real matrix $A$ is:
+
+    - A positive definite matrix if $x^T A x > 0$
+      for all non-zero real vectors $x$.
+    - A positive semidefinite matrix if $x^T A x \geq 0$
+      for all non-zero real vectors $x$.
+    - A negative definite matrix if $x^T A x < 0$
+      for all non-zero real vectors $x$.
+    - A negative semidefinite matrix if $x^T A x \leq 0$
+      for all non-zero real vectors $x$.
+    - An indefinite matrix if there exists non-zero real vectors
+      $x, y$ with $x^T A x > 0 > y^T A y$.
+
+    A square complex matrix $A$ is:
+
+    - A positive definite matrix if $\text{re}(x^H A x) > 0$
+      for all non-zero complex vectors $x$.
+    - A positive semidefinite matrix if $\text{re}(x^H A x) \geq 0$
+      for all non-zero complex vectors $x$.
+    - A negative definite matrix if $\text{re}(x^H A x) < 0$
+      for all non-zero complex vectors $x$.
+    - A negative semidefinite matrix if $\text{re}(x^H A x) \leq 0$
+      for all non-zero complex vectors $x$.
+    - An indefinite matrix if there exists non-zero complex vectors
+      $x, y$ with $\text{re}(x^H A x) > 0 > \text{re}(y^H A y)$.
+
+    A matrix need not be symmetric or hermitian to be positive definite.
+
+    - A real non-symmetric matrix is positive definite if and only if
+      $\frac{A + A^T}{2}$ is positive definite.
+    - A complex non-hermitian matrix is positive definite if and only if
+      $\frac{A + A^H}{2}$ is positive definite.
+
+    And this extension can apply for all the definitions above.
+
+    However, for complex cases, you can restrict the definition of
+    $\text{re}(x^H A x) > 0$ to $x^H A x > 0$ and require the matrix
+    to be hermitian.
+    But we do not present this restriction for computation because you
+    can check ``M.is_hermitian`` independently with this and use
+    the same procedure.
+
+    Examples
+    ========
+
+    An example of symmetric positive definite matrix:
+
+    .. plot::
+        :context: reset
+        :format: doctest
+        :include-source: True
+
+        >>> from sympy import Matrix, symbols
+        >>> from sympy.plotting import plot3d
+        >>> a, b = symbols('a b')
+        >>> x = Matrix([a, b])
+
+        >>> A = Matrix([[1, 0], [0, 1]])
+        >>> A.is_positive_definite
+        True
+        >>> A.is_positive_semidefinite
+        True
+
+        >>> p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1))
+
+    An example of symmetric positive semidefinite matrix:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> A = Matrix([[1, -1], [-1, 1]])
+        >>> A.is_positive_definite
+        False
+        >>> A.is_positive_semidefinite
+        True
+
+        >>> p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1))
+
+    An example of symmetric negative definite matrix:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> A = Matrix([[-1, 0], [0, -1]])
+        >>> A.is_negative_definite
+        True
+        >>> A.is_negative_semidefinite
+        True
+        >>> A.is_indefinite
+        False
+
+        >>> p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1))
+
+    An example of symmetric indefinite matrix:
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> A = Matrix([[1, 2], [2, -1]])
+        >>> A.is_indefinite
+        True
+
+        >>> p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1))
+
+    An example of non-symmetric positive definite matrix.
+
+    .. plot::
+        :context: close-figs
+        :format: doctest
+        :include-source: True
+
+        >>> A = Matrix([[1, 2], [-2, 1]])
+        >>> A.is_positive_definite
+        True
+        >>> A.is_positive_semidefinite
+        True
+
+        >>> p = plot3d((x.T*A*x)[0, 0], (a, -1, 1), (b, -1, 1))
+
+    Notes
+    =====
+
+    Although some people trivialize the definition of positive definite
+    matrices only for symmetric or hermitian matrices, this restriction
+    is not correct because it does not classify all instances of
+    positive definite matrices from the definition $x^T A x > 0$ or
+    $\text{re}(x^H A x) > 0$.
+
+    For instance, ``Matrix([[1, 2], [-2, 1]])`` presented in
+    the example above is an example of real positive definite matrix
+    that is not symmetric.
+
+    However, since the following formula holds true;
+
+    .. math::
+        \text{re}(x^H A x) > 0 \iff
+        \text{re}(x^H \frac{A + A^H}{2} x) > 0
+
+    We can classify all positive definite matrices that may or may not
+    be symmetric or hermitian by transforming the matrix to
+    $\frac{A + A^T}{2}$ or $\frac{A + A^H}{2}$
+    (which is guaranteed to be always real symmetric or complex
+    hermitian) and we can defer most of the studies to symmetric or
+    hermitian positive definite matrices.
+
+    But it is a different problem for the existence of Cholesky
+    decomposition. Because even though a non symmetric or a non
+    hermitian matrix can be positive definite, Cholesky or LDL
+    decomposition does not exist because the decompositions require the
+    matrix to be symmetric or hermitian.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Definiteness_of_a_matrix#Eigenvalues
+
+    .. [2] https://mathworld.wolfram.com/PositiveDefiniteMatrix.html
+
+    .. [3] Johnson, C. R. "Positive Definite Matrices." Amer.
+        Math. Monthly 77, 259-264 1970.
+    """
+
+_is_positive_definite.__doc__     = _doc_positive_definite
+_is_positive_semidefinite.__doc__ = _doc_positive_definite
+_is_negative_definite.__doc__     = _doc_positive_definite
+_is_negative_semidefinite.__doc__ = _doc_positive_definite
+_is_indefinite.__doc__            = _doc_positive_definite
+
+
+def _jordan_form(M, calc_transform=True, *, chop=False):
+    """Return $(P, J)$ where $J$ is a Jordan block
+    matrix and $P$ is a matrix such that $M = P J P^{-1}$
+
+    Parameters
+    ==========
+
+    calc_transform : bool
+        If ``False``, then only $J$ is returned.
+
+    chop : bool
+        All matrices are converted to exact types when computing
+        eigenvalues and eigenvectors.  As a result, there may be
+        approximation errors.  If ``chop==True``, these errors
+        will be truncated.
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[ 6,  5, -2, -3], [-3, -1,  3,  3], [ 2,  1, -2, -3], [-1,  1,  5,  5]])
+    >>> P, J = M.jordan_form()
+    >>> J
+    Matrix([
+    [2, 1, 0, 0],
+    [0, 2, 0, 0],
+    [0, 0, 2, 1],
+    [0, 0, 0, 2]])
+
+    See Also
+    ========
+
+    jordan_block
+    """
+
+    if not M.is_square:
+        raise NonSquareMatrixError("Only square matrices have Jordan forms")
+
+    mat        = M
+    has_floats = M.has(Float)
+
+    if has_floats:
+        try:
+            max_prec = max(term._prec for term in M.values() if isinstance(term, Float))
+        except ValueError:
+            # if no term in the matrix is explicitly a Float calling max()
+            # will throw a error so setting max_prec to default value of 53
+            max_prec = 53
+
+        # setting minimum max_dps to 15 to prevent loss of precision in
+        # matrix containing non evaluated expressions
+        max_dps = max(prec_to_dps(max_prec), 15)
+
+    def restore_floats(*args):
+        """If ``has_floats`` is `True`, cast all ``args`` as
+        matrices of floats."""
+
+        if has_floats:
+            args = [m.evalf(n=max_dps, chop=chop) for m in args]
+        if len(args) == 1:
+            return args[0]
+
+        return args
+
+    # cache calculations for some speedup
+    mat_cache = {}
+
+    def eig_mat(val, pow):
+        """Cache computations of ``(M - val*I)**pow`` for quick
+        retrieval"""
+
+        if (val, pow) in mat_cache:
+            return mat_cache[(val, pow)]
+
+        if (val, pow - 1) in mat_cache:
+            mat_cache[(val, pow)] = mat_cache[(val, pow - 1)].multiply(
+                    mat_cache[(val, 1)], dotprodsimp=None)
+        else:
+            mat_cache[(val, pow)] = (mat - val*M.eye(M.rows)).pow(pow)
+
+        return mat_cache[(val, pow)]
+
+    # helper functions
+    def nullity_chain(val, algebraic_multiplicity):
+        """Calculate the sequence  [0, nullity(E), nullity(E**2), ...]
+        until it is constant where ``E = M - val*I``"""
+
+        # mat.rank() is faster than computing the null space,
+        # so use the rank-nullity theorem
+        cols    = M.cols
+        ret     = [0]
+        nullity = cols - eig_mat(val, 1).rank()
+        i       = 2
+
+        while nullity != ret[-1]:
+            ret.append(nullity)
+
+            if nullity == algebraic_multiplicity:
+                break
+
+            nullity  = cols - eig_mat(val, i).rank()
+            i       += 1
+
+            # Due to issues like #7146 and #15872, SymPy sometimes
+            # gives the wrong rank. In this case, raise an error
+            # instead of returning an incorrect matrix
+            if nullity < ret[-1] or nullity > algebraic_multiplicity:
+                raise MatrixError(
+                    "SymPy had encountered an inconsistent "
+                    "result while computing Jordan block: "
+                    "{}".format(M))
+
+        return ret
+
+    def blocks_from_nullity_chain(d):
+        """Return a list of the size of each Jordan block.
+        If d_n is the nullity of E**n, then the number
+        of Jordan blocks of size n is
+
+            2*d_n - d_(n-1) - d_(n+1)"""
+
+        # d[0] is always the number of columns, so skip past it
+        mid = [2*d[n] - d[n - 1] - d[n + 1] for n in range(1, len(d) - 1)]
+        # d is assumed to plateau with "d[ len(d) ] == d[-1]", so
+        # 2*d_n - d_(n-1) - d_(n+1) == d_n - d_(n-1)
+        end = [d[-1] - d[-2]] if len(d) > 1 else [d[0]]
+
+        return mid + end
+
+    def pick_vec(small_basis, big_basis):
+        """Picks a vector from big_basis that isn't in
+        the subspace spanned by small_basis"""
+
+        if len(small_basis) == 0:
+            return big_basis[0]
+
+        for v in big_basis:
+            _, pivots = M.hstack(*(small_basis + [v])).echelon_form(
+                    with_pivots=True)
+
+            if pivots[-1] == len(small_basis):
+                return v
+
+    # roots doesn't like Floats, so replace them with Rationals
+    if has_floats:
+        from sympy.simplify import nsimplify
+        mat = mat.applyfunc(lambda x: nsimplify(x, rational=True))
+
+    # first calculate the jordan block structure
+    eigs = mat.eigenvals()
+
+    # Make sure that we have all roots in radical form
+    for x in eigs:
+        if x.has(CRootOf):
+            raise MatrixError(
+                "Jordan normal form is not implemented if the matrix have "
+                "eigenvalues in CRootOf form")
+
+    # most matrices have distinct eigenvalues
+    # and so are diagonalizable.  In this case, don't
+    # do extra work!
+    if len(eigs.keys()) == mat.cols:
+        blocks     = sorted(eigs.keys(), key=default_sort_key)
+        jordan_mat = mat.diag(*blocks)
+
+        if not calc_transform:
+            return restore_floats(jordan_mat)
+
+        jordan_basis = [eig_mat(eig, 1).nullspace()[0]
+                for eig in blocks]
+        basis_mat    = mat.hstack(*jordan_basis)
+
+        return restore_floats(basis_mat, jordan_mat)
+
+    block_structure = []
+
+    for eig in sorted(eigs.keys(), key=default_sort_key):
+        algebraic_multiplicity = eigs[eig]
+        chain = nullity_chain(eig, algebraic_multiplicity)
+        block_sizes = blocks_from_nullity_chain(chain)
+
+        # if block_sizes =       = [a, b, c, ...], then the number of
+        # Jordan blocks of size 1 is a, of size 2 is b, etc.
+        # create an array that has (eig, block_size) with one
+        # entry for each block
+        size_nums = [(i+1, num) for i, num in enumerate(block_sizes)]
+
+        # we expect larger Jordan blocks to come earlier
+        size_nums.reverse()
+
+        block_structure.extend(
+            [(eig, size) for size, num in size_nums for _ in range(num)])
+
+    jordan_form_size = sum(size for eig, size in block_structure)
+
+    if jordan_form_size != M.rows:
+        raise MatrixError(
+            "SymPy had encountered an inconsistent result while "
+            "computing Jordan block. : {}".format(M))
+
+    blocks     = (mat.jordan_block(size=size, eigenvalue=eig) for eig, size in block_structure)
+    jordan_mat = mat.diag(*blocks)
+
+    if not calc_transform:
+        return restore_floats(jordan_mat)
+
+    # For each generalized eigenspace, calculate a basis.
+    # We start by looking for a vector in null( (A - eig*I)**n )
+    # which isn't in null( (A - eig*I)**(n-1) ) where n is
+    # the size of the Jordan block
+    #
+    # Ideally we'd just loop through block_structure and
+    # compute each generalized eigenspace.  However, this
+    # causes a lot of unneeded computation.  Instead, we
+    # go through the eigenvalues separately, since we know
+    # their generalized eigenspaces must have bases that
+    # are linearly independent.
+    jordan_basis = []
+
+    for eig in sorted(eigs.keys(), key=default_sort_key):
+        eig_basis = []
+
+        for block_eig, size in block_structure:
+            if block_eig != eig:
+                continue
+
+            null_big   = (eig_mat(eig, size)).nullspace()
+            null_small = (eig_mat(eig, size - 1)).nullspace()
+
+            # we want to pick something that is in the big basis
+            # and not the small, but also something that is independent
+            # of any other generalized eigenvectors from a different
+            # generalized eigenspace sharing the same eigenvalue.
+            vec      = pick_vec(null_small + eig_basis, null_big)
+            new_vecs = [eig_mat(eig, i).multiply(vec, dotprodsimp=None)
+                    for i in range(size)]
+
+            eig_basis.extend(new_vecs)
+            jordan_basis.extend(reversed(new_vecs))
+
+    basis_mat = mat.hstack(*jordan_basis)
+
+    return restore_floats(basis_mat, jordan_mat)
+
+
+def _left_eigenvects(M, **flags):
+    """Returns left eigenvectors and eigenvalues.
+
+    This function returns the list of triples (eigenval, multiplicity,
+    basis) for the left eigenvectors. Options are the same as for
+    eigenvects(), i.e. the ``**flags`` arguments gets passed directly to
+    eigenvects().
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix
+    >>> M = Matrix([[0, 1, 1], [1, 0, 0], [1, 1, 1]])
+    >>> M.eigenvects()
+    [(-1, 1, [Matrix([
+    [-1],
+    [ 1],
+    [ 0]])]), (0, 1, [Matrix([
+    [ 0],
+    [-1],
+    [ 1]])]), (2, 1, [Matrix([
+    [2/3],
+    [1/3],
+    [  1]])])]
+    >>> M.left_eigenvects()
+    [(-1, 1, [Matrix([[-2, 1, 1]])]), (0, 1, [Matrix([[-1, -1, 1]])]), (2,
+    1, [Matrix([[1, 1, 1]])])]
+
+    """
+
+    eigs = M.transpose().eigenvects(**flags)
+
+    return [(val, mult, [l.transpose() for l in basis]) for val, mult, basis in eigs]
+
+
+def _singular_values(M):
+    """Compute the singular values of a Matrix
+
+    Examples
+    ========
+
+    >>> from sympy import Matrix, Symbol
+    >>> x = Symbol('x', real=True)
+    >>> M = Matrix([[0, 1, 0], [0, x, 0], [-1, 0, 0]])
+    >>> M.singular_values()
+    [sqrt(x**2 + 1), 1, 0]
+
+    See Also
+    ========
+
+    condition_number
+    """
+
+    if M.rows >= M.cols:
+        valmultpairs = M.H.multiply(M).eigenvals()
+    else:
+        valmultpairs = M.multiply(M.H).eigenvals()
+
+    # Expands result from eigenvals into a simple list
+    vals = []
+
+    for k, v in valmultpairs.items():
+        vals += [sqrt(k)] * v  # dangerous! same k in several spots!
+
+    # Pad with zeros if singular values are computed in reverse way,
+    # to give consistent format.
+    if len(vals) < M.cols:
+        vals += [M.zero] * (M.cols - len(vals))
+
+    # sort them in descending order
+    vals.sort(reverse=True, key=default_sort_key)
+
+    return vals

openflamingo/lib/python3.10/site-packages/sympy/matrices/tests/test_commonmatrix.py

@@ -0,0 +1,1266 @@
+#
+# Code for testing deprecated matrix classes. New test code should not be added
+# here. Instead, add it to test_matrixbase.py.
+#
+# This entire test module and the corresponding sympy/matrices/common.py
+# module will be removed in a future release.
+#
+from sympy.testing.pytest import raises, XFAIL, warns_deprecated_sympy
+
+from sympy.assumptions import Q
+from sympy.core.expr import Expr
+from sympy.core.add import Add
+from sympy.core.function import Function
+from sympy.core.kind import NumberKind, UndefinedKind
+from sympy.core.numbers import I, Integer, oo, pi, Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, symbols
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.matrices.exceptions import ShapeError, NonSquareMatrixError
+from sympy.matrices.kind import MatrixKind
+from sympy.matrices.common import (
+    _MinimalMatrix, _CastableMatrix, MatrixShaping, MatrixProperties,
+    MatrixOperations, MatrixArithmetic, MatrixSpecial)
+from sympy.matrices.matrices import MatrixCalculus
+from sympy.matrices import (Matrix, diag, eye,
+    matrix_multiply_elementwise, ones, zeros, SparseMatrix, banded,
+    MutableDenseMatrix, MutableSparseMatrix, ImmutableDenseMatrix,
+    ImmutableSparseMatrix)
+from sympy.polys.polytools import Poly
+from sympy.utilities.iterables import flatten
+from sympy.tensor.array.dense_ndim_array import ImmutableDenseNDimArray as Array
+
+from sympy.abc import x, y, z
+
+
+def test_matrix_deprecated_isinstance():
+
+    # Test that e.g. isinstance(M, MatrixCommon) still gives True when M is a
+    # Matrix for each of the deprecated matrix classes.
+
+    from sympy.matrices.common import (
+        MatrixRequired,
+        MatrixShaping,
+        MatrixSpecial,
+        MatrixProperties,
+        MatrixOperations,
+        MatrixArithmetic,
+        MatrixCommon
+    )
+    from sympy.matrices.matrices import (
+        MatrixDeterminant,
+        MatrixReductions,
+        MatrixSubspaces,
+        MatrixEigen,
+        MatrixCalculus,
+        MatrixDeprecated
+    )
+    from sympy import (
+        Matrix,
+        ImmutableMatrix,
+        SparseMatrix,
+        ImmutableSparseMatrix
+    )
+    all_mixins = (
+        MatrixRequired,
+        MatrixShaping,
+        MatrixSpecial,
+        MatrixProperties,
+        MatrixOperations,
+        MatrixArithmetic,
+        MatrixCommon,
+        MatrixDeterminant,
+        MatrixReductions,
+        MatrixSubspaces,
+        MatrixEigen,
+        MatrixCalculus,
+        MatrixDeprecated
+    )
+    all_matrices = (
+        Matrix,
+        ImmutableMatrix,
+        SparseMatrix,
+        ImmutableSparseMatrix
+    )
+
+    Ms = [M([[1, 2], [3, 4]]) for M in all_matrices]
+    t = ()
+
+    for mixin in all_mixins:
+        for M in Ms:
+            with warns_deprecated_sympy():
+                assert isinstance(M, mixin) is True
+        with warns_deprecated_sympy():
+            assert isinstance(t, mixin) is False
+
+
+# classes to test the deprecated matrix classes. We use warns_deprecated_sympy
+# to suppress the deprecation warnings because subclassing the deprecated
+# classes causes a warning to be raised.
+
+with warns_deprecated_sympy():
+    class ShapingOnlyMatrix(_MinimalMatrix, _CastableMatrix, MatrixShaping):
+        pass
+
+
+def eye_Shaping(n):
+    return ShapingOnlyMatrix(n, n, lambda i, j: int(i == j))
+
+
+def zeros_Shaping(n):
+    return ShapingOnlyMatrix(n, n, lambda i, j: 0)
+
+
+with warns_deprecated_sympy():
+    class PropertiesOnlyMatrix(_MinimalMatrix, _CastableMatrix, MatrixProperties):
+        pass
+
+
+def eye_Properties(n):
+    return PropertiesOnlyMatrix(n, n, lambda i, j: int(i == j))
+
+
+def zeros_Properties(n):
+    return PropertiesOnlyMatrix(n, n, lambda i, j: 0)
+
+
+with warns_deprecated_sympy():
+    class OperationsOnlyMatrix(_MinimalMatrix, _CastableMatrix, MatrixOperations):
+        pass
+
+
+def eye_Operations(n):
+    return OperationsOnlyMatrix(n, n, lambda i, j: int(i == j))
+
+
+def zeros_Operations(n):
+    return OperationsOnlyMatrix(n, n, lambda i, j: 0)
+
+
+with warns_deprecated_sympy():
+    class ArithmeticOnlyMatrix(_MinimalMatrix, _CastableMatrix, MatrixArithmetic):
+        pass
+
+
+def eye_Arithmetic(n):
+    return ArithmeticOnlyMatrix(n, n, lambda i, j: int(i == j))
+
+
+def zeros_Arithmetic(n):
+    return ArithmeticOnlyMatrix(n, n, lambda i, j: 0)
+
+
+with warns_deprecated_sympy():
+    class SpecialOnlyMatrix(_MinimalMatrix, _CastableMatrix, MatrixSpecial):
+        pass
+
+
+with warns_deprecated_sympy():
+    class CalculusOnlyMatrix(_MinimalMatrix, _CastableMatrix, MatrixCalculus):
+        pass
+
+
+def test__MinimalMatrix():
+    x = _MinimalMatrix(2, 3, [1, 2, 3, 4, 5, 6])
+    assert x.rows == 2
+    assert x.cols == 3
+    assert x[2] == 3
+    assert x[1, 1] == 5
+    assert list(x) == [1, 2, 3, 4, 5, 6]
+    assert list(x[1, :]) == [4, 5, 6]
+    assert list(x[:, 1]) == [2, 5]
+    assert list(x[:, :]) == list(x)
+    assert x[:, :] == x
+    assert _MinimalMatrix(x) == x
+    assert _MinimalMatrix([[1, 2, 3], [4, 5, 6]]) == x
+    assert _MinimalMatrix(([1, 2, 3], [4, 5, 6])) == x
+    assert _MinimalMatrix([(1, 2, 3), (4, 5, 6)]) == x
+    assert _MinimalMatrix(((1, 2, 3), (4, 5, 6))) == x
+    assert not (_MinimalMatrix([[1, 2], [3, 4], [5, 6]]) == x)
+
+
+def test_kind():
+    assert Matrix([[1, 2], [3, 4]]).kind == MatrixKind(NumberKind)
+    assert Matrix([[0, 0], [0, 0]]).kind == MatrixKind(NumberKind)
+    assert Matrix(0, 0, []).kind == MatrixKind(NumberKind)
+    assert Matrix([[x]]).kind == MatrixKind(NumberKind)
+    assert Matrix([[1, Matrix([[1]])]]).kind == MatrixKind(UndefinedKind)
+    assert SparseMatrix([[1]]).kind == MatrixKind(NumberKind)
+    assert SparseMatrix([[1, Matrix([[1]])]]).kind == MatrixKind(UndefinedKind)
+
+
+# ShapingOnlyMatrix tests
+def test_vec():
+    m = ShapingOnlyMatrix(2, 2, [1, 3, 2, 4])
+    m_vec = m.vec()
+    assert m_vec.cols == 1
+    for i in range(4):
+        assert m_vec[i] == i + 1
+
+
+def test_todok():
+    a, b, c, d = symbols('a:d')
+    m1 = MutableDenseMatrix([[a, b], [c, d]])
+    m2 = ImmutableDenseMatrix([[a, b], [c, d]])
+    m3 = MutableSparseMatrix([[a, b], [c, d]])
+    m4 = ImmutableSparseMatrix([[a, b], [c, d]])
+    assert m1.todok() == m2.todok() == m3.todok() == m4.todok() == \
+        {(0, 0): a, (0, 1): b, (1, 0): c, (1, 1): d}
+
+
+def test_tolist():
+    lst = [[S.One, S.Half, x*y, S.Zero], [x, y, z, x**2], [y, -S.One, z*x, 3]]
+    flat_lst = [S.One, S.Half, x*y, S.Zero, x, y, z, x**2, y, -S.One, z*x, 3]
+    m = ShapingOnlyMatrix(3, 4, flat_lst)
+    assert m.tolist() == lst
+
+def test_todod():
+    m = ShapingOnlyMatrix(3, 2, [[S.One, 0], [0, S.Half], [x, 0]])
+    dict = {0: {0: S.One}, 1: {1: S.Half}, 2: {0: x}}
+    assert m.todod() == dict
+
+def test_row_col_del():
+    e = ShapingOnlyMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
+    raises(IndexError, lambda: e.row_del(5))
+    raises(IndexError, lambda: e.row_del(-5))
+    raises(IndexError, lambda: e.col_del(5))
+    raises(IndexError, lambda: e.col_del(-5))
+
+    assert e.row_del(2) == e.row_del(-1) == Matrix([[1, 2, 3], [4, 5, 6]])
+    assert e.col_del(2) == e.col_del(-1) == Matrix([[1, 2], [4, 5], [7, 8]])
+
+    assert e.row_del(1) == e.row_del(-2) == Matrix([[1, 2, 3], [7, 8, 9]])
+    assert e.col_del(1) == e.col_del(-2) == Matrix([[1, 3], [4, 6], [7, 9]])
+
+
+def test_get_diag_blocks1():
+    a = Matrix([[1, 2], [2, 3]])
+    b = Matrix([[3, x], [y, 3]])
+    c = Matrix([[3, x, 3], [y, 3, z], [x, y, z]])
+    assert a.get_diag_blocks() == [a]
+    assert b.get_diag_blocks() == [b]
+    assert c.get_diag_blocks() == [c]
+
+
+def test_get_diag_blocks2():
+    a = Matrix([[1, 2], [2, 3]])
+    b = Matrix([[3, x], [y, 3]])
+    c = Matrix([[3, x, 3], [y, 3, z], [x, y, z]])
+    A, B, C, D = diag(a, b, b), diag(a, b, c), diag(a, c, b), diag(c, c, b)
+    A = ShapingOnlyMatrix(A.rows, A.cols, A)
+    B = ShapingOnlyMatrix(B.rows, B.cols, B)
+    C = ShapingOnlyMatrix(C.rows, C.cols, C)
+    D = ShapingOnlyMatrix(D.rows, D.cols, D)
+
+    assert A.get_diag_blocks() == [a, b, b]
+    assert B.get_diag_blocks() == [a, b, c]
+    assert C.get_diag_blocks() == [a, c, b]
+    assert D.get_diag_blocks() == [c, c, b]
+
+
+def test_shape():
+    m = ShapingOnlyMatrix(1, 2, [0, 0])
+    assert m.shape == (1, 2)
+
+
+def test_reshape():
+    m0 = eye_Shaping(3)
+    assert m0.reshape(1, 9) == Matrix(1, 9, (1, 0, 0, 0, 1, 0, 0, 0, 1))
+    m1 = ShapingOnlyMatrix(3, 4, lambda i, j: i + j)
+    assert m1.reshape(
+        4, 3) == Matrix(((0, 1, 2), (3, 1, 2), (3, 4, 2), (3, 4, 5)))
+    assert m1.reshape(2, 6) == Matrix(((0, 1, 2, 3, 1, 2), (3, 4, 2, 3, 4, 5)))
+
+
+def test_row_col():
+    m = ShapingOnlyMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
+    assert m.row(0) == Matrix(1, 3, [1, 2, 3])
+    assert m.col(0) == Matrix(3, 1, [1, 4, 7])
+
+
+def test_row_join():
+    assert eye_Shaping(3).row_join(Matrix([7, 7, 7])) == \
+           Matrix([[1, 0, 0, 7],
+                   [0, 1, 0, 7],
+                   [0, 0, 1, 7]])
+
+
+def test_col_join():
+    assert eye_Shaping(3).col_join(Matrix([[7, 7, 7]])) == \
+           Matrix([[1, 0, 0],
+                   [0, 1, 0],
+                   [0, 0, 1],
+                   [7, 7, 7]])
+
+
+def test_row_insert():
+    r4 = Matrix([[4, 4, 4]])
+    for i in range(-4, 5):
+        l = [1, 0, 0]
+        l.insert(i, 4)
+        assert flatten(eye_Shaping(3).row_insert(i, r4).col(0).tolist()) == l
+
+
+def test_col_insert():
+    c4 = Matrix([4, 4, 4])
+    for i in range(-4, 5):
+        l = [0, 0, 0]
+        l.insert(i, 4)
+        assert flatten(zeros_Shaping(3).col_insert(i, c4).row(0).tolist()) == l
+    # issue 13643
+    assert eye_Shaping(6).col_insert(3, Matrix([[2, 2], [2, 2], [2, 2], [2, 2], [2, 2], [2, 2]])) == \
+           Matrix([[1, 0, 0, 2, 2, 0, 0, 0],
+                   [0, 1, 0, 2, 2, 0, 0, 0],
+                   [0, 0, 1, 2, 2, 0, 0, 0],
+                   [0, 0, 0, 2, 2, 1, 0, 0],
+                   [0, 0, 0, 2, 2, 0, 1, 0],
+                   [0, 0, 0, 2, 2, 0, 0, 1]])
+
+
+def test_extract():
+    m = ShapingOnlyMatrix(4, 3, lambda i, j: i*3 + j)
+    assert m.extract([0, 1, 3], [0, 1]) == Matrix(3, 2, [0, 1, 3, 4, 9, 10])
+    assert m.extract([0, 3], [0, 0, 2]) == Matrix(2, 3, [0, 0, 2, 9, 9, 11])
+    assert m.extract(range(4), range(3)) == m
+    raises(IndexError, lambda: m.extract([4], [0]))
+    raises(IndexError, lambda: m.extract([0], [3]))
+
+
+def test_hstack():
+    m = ShapingOnlyMatrix(4, 3, lambda i, j: i*3 + j)
+    m2 = ShapingOnlyMatrix(3, 4, lambda i, j: i*3 + j)
+    assert m == m.hstack(m)
+    assert m.hstack(m, m, m) == ShapingOnlyMatrix.hstack(m, m, m) == Matrix([
+                [0,  1,  2, 0,  1,  2, 0,  1,  2],
+                [3,  4,  5, 3,  4,  5, 3,  4,  5],
+                [6,  7,  8, 6,  7,  8, 6,  7,  8],
+                [9, 10, 11, 9, 10, 11, 9, 10, 11]])
+    raises(ShapeError, lambda: m.hstack(m, m2))
+    assert Matrix.hstack() == Matrix()
+
+    # test regression #12938
+    M1 = Matrix.zeros(0, 0)
+    M2 = Matrix.zeros(0, 1)
+    M3 = Matrix.zeros(0, 2)
+    M4 = Matrix.zeros(0, 3)
+    m = ShapingOnlyMatrix.hstack(M1, M2, M3, M4)
+    assert m.rows == 0 and m.cols == 6
+
+
+def test_vstack():
+    m = ShapingOnlyMatrix(4, 3, lambda i, j: i*3 + j)
+    m2 = ShapingOnlyMatrix(3, 4, lambda i, j: i*3 + j)
+    assert m == m.vstack(m)
+    assert m.vstack(m, m, m) == ShapingOnlyMatrix.vstack(m, m, m) == Matrix([
+                                [0,  1,  2],
+                                [3,  4,  5],
+                                [6,  7,  8],
+                                [9, 10, 11],
+                                [0,  1,  2],
+                                [3,  4,  5],
+                                [6,  7,  8],
+                                [9, 10, 11],
+                                [0,  1,  2],
+                                [3,  4,  5],
+                                [6,  7,  8],
+                                [9, 10, 11]])
+    raises(ShapeError, lambda: m.vstack(m, m2))
+    assert Matrix.vstack() == Matrix()
+
+
+# PropertiesOnlyMatrix tests
+def test_atoms():
+    m = PropertiesOnlyMatrix(2, 2, [1, 2, x, 1 - 1/x])
+    assert m.atoms() == {S.One, S(2), S.NegativeOne, x}
+    assert m.atoms(Symbol) == {x}
+
+
+def test_free_symbols():
+    assert PropertiesOnlyMatrix([[x], [0]]).free_symbols == {x}
+
+
+def test_has():
+    A = PropertiesOnlyMatrix(((x, y), (2, 3)))
+    assert A.has(x)
+    assert not A.has(z)
+    assert A.has(Symbol)
+
+    A = PropertiesOnlyMatrix(((2, y), (2, 3)))
+    assert not A.has(x)
+
+
+def test_is_anti_symmetric():
+    x = symbols('x')
+    assert PropertiesOnlyMatrix(2, 1, [1, 2]).is_anti_symmetric() is False
+    m = PropertiesOnlyMatrix(3, 3, [0, x**2 + 2*x + 1, y, -(x + 1)**2, 0, x*y, -y, -x*y, 0])
+    assert m.is_anti_symmetric() is True
+    assert m.is_anti_symmetric(simplify=False) is False
+    assert m.is_anti_symmetric(simplify=lambda x: x) is False
+
+    m = PropertiesOnlyMatrix(3, 3, [x.expand() for x in m])
+    assert m.is_anti_symmetric(simplify=False) is True
+    m = PropertiesOnlyMatrix(3, 3, [x.expand() for x in [S.One] + list(m)[1:]])
+    assert m.is_anti_symmetric() is False
+
+
+def test_diagonal_symmetrical():
+    m = PropertiesOnlyMatrix(2, 2, [0, 1, 1, 0])
+    assert not m.is_diagonal()
+    assert m.is_symmetric()
+    assert m.is_symmetric(simplify=False)
+
+    m = PropertiesOnlyMatrix(2, 2, [1, 0, 0, 1])
+    assert m.is_diagonal()
+
+    m = PropertiesOnlyMatrix(3, 3, diag(1, 2, 3))
+    assert m.is_diagonal()
+    assert m.is_symmetric()
+
+    m = PropertiesOnlyMatrix(3, 3, [1, 0, 0, 0, 2, 0, 0, 0, 3])
+    assert m == diag(1, 2, 3)
+
+    m = PropertiesOnlyMatrix(2, 3, zeros(2, 3))
+    assert not m.is_symmetric()
+    assert m.is_diagonal()
+
+    m = PropertiesOnlyMatrix(((5, 0), (0, 6), (0, 0)))
+    assert m.is_diagonal()
+
+    m = PropertiesOnlyMatrix(((5, 0, 0), (0, 6, 0)))
+    assert m.is_diagonal()
+
+    m = Matrix(3, 3, [1, x**2 + 2*x + 1, y, (x + 1)**2, 2, 0, y, 0, 3])
+    assert m.is_symmetric()
+    assert not m.is_symmetric(simplify=False)
+    assert m.expand().is_symmetric(simplify=False)
+
+
+def test_is_hermitian():
+    a = PropertiesOnlyMatrix([[1, I], [-I, 1]])
+    assert a.is_hermitian
+    a = PropertiesOnlyMatrix([[2*I, I], [-I, 1]])
+    assert a.is_hermitian is False
+    a = PropertiesOnlyMatrix([[x, I], [-I, 1]])
+    assert a.is_hermitian is None
+    a = PropertiesOnlyMatrix([[x, 1], [-I, 1]])
+    assert a.is_hermitian is False
+
+
+def test_is_Identity():
+    assert eye_Properties(3).is_Identity
+    assert not PropertiesOnlyMatrix(zeros(3)).is_Identity
+    assert not PropertiesOnlyMatrix(ones(3)).is_Identity
+    # issue 6242
+    assert not PropertiesOnlyMatrix([[1, 0, 0]]).is_Identity
+
+
+def test_is_symbolic():
+    a = PropertiesOnlyMatrix([[x, x], [x, x]])
+    assert a.is_symbolic() is True
+    a = PropertiesOnlyMatrix([[1, 2, 3, 4], [5, 6, 7, 8]])
+    assert a.is_symbolic() is False
+    a = PropertiesOnlyMatrix([[1, 2, 3, 4], [5, 6, x, 8]])
+    assert a.is_symbolic() is True
+    a = PropertiesOnlyMatrix([[1, x, 3]])
+    assert a.is_symbolic() is True
+    a = PropertiesOnlyMatrix([[1, 2, 3]])
+    assert a.is_symbolic() is False
+    a = PropertiesOnlyMatrix([[1], [x], [3]])
+    assert a.is_symbolic() is True
+    a = PropertiesOnlyMatrix([[1], [2], [3]])
+    assert a.is_symbolic() is False
+
+
+def test_is_upper():
+    a = PropertiesOnlyMatrix([[1, 2, 3]])
+    assert a.is_upper is True
+    a = PropertiesOnlyMatrix([[1], [2], [3]])
+    assert a.is_upper is False
+
+
+def test_is_lower():
+    a = PropertiesOnlyMatrix([[1, 2, 3]])
+    assert a.is_lower is False
+    a = PropertiesOnlyMatrix([[1], [2], [3]])
+    assert a.is_lower is True
+
+
+def test_is_square():
+    m = PropertiesOnlyMatrix([[1], [1]])
+    m2 = PropertiesOnlyMatrix([[2, 2], [2, 2]])
+    assert not m.is_square
+    assert m2.is_square
+
+
+def test_is_symmetric():
+    m = PropertiesOnlyMatrix(2, 2, [0, 1, 1, 0])
+    assert m.is_symmetric()
+    m = PropertiesOnlyMatrix(2, 2, [0, 1, 0, 1])
+    assert not m.is_symmetric()
+
+
+def test_is_hessenberg():
+    A = PropertiesOnlyMatrix([[3, 4, 1], [2, 4, 5], [0, 1, 2]])
+    assert A.is_upper_hessenberg
+    A = PropertiesOnlyMatrix(3, 3, [3, 2, 0, 4, 4, 1, 1, 5, 2])
+    assert A.is_lower_hessenberg
+    A = PropertiesOnlyMatrix(3, 3, [3, 2, -1, 4, 4, 1, 1, 5, 2])
+    assert A.is_lower_hessenberg is False
+    assert A.is_upper_hessenberg is False
+
+    A = PropertiesOnlyMatrix([[3, 4, 1], [2, 4, 5], [3, 1, 2]])
+    assert not A.is_upper_hessenberg
+
+
+def test_is_zero():
+    assert PropertiesOnlyMatrix(0, 0, []).is_zero_matrix
+    assert PropertiesOnlyMatrix([[0, 0], [0, 0]]).is_zero_matrix
+    assert PropertiesOnlyMatrix(zeros(3, 4)).is_zero_matrix
+    assert not PropertiesOnlyMatrix(eye(3)).is_zero_matrix
+    assert PropertiesOnlyMatrix([[x, 0], [0, 0]]).is_zero_matrix == None
+    assert PropertiesOnlyMatrix([[x, 1], [0, 0]]).is_zero_matrix == False
+    a = Symbol('a', nonzero=True)
+    assert PropertiesOnlyMatrix([[a, 0], [0, 0]]).is_zero_matrix == False
+
+
+def test_values():
+    assert set(PropertiesOnlyMatrix(2, 2, [0, 1, 2, 3]
+        ).values()) == {1, 2, 3}
+    x = Symbol('x', real=True)
+    assert set(PropertiesOnlyMatrix(2, 2, [x, 0, 0, 1]
+        ).values()) == {x, 1}
+
+
+# OperationsOnlyMatrix tests
+def test_applyfunc():
+    m0 = OperationsOnlyMatrix(eye(3))
+    assert m0.applyfunc(lambda x: 2*x) == eye(3)*2
+    assert m0.applyfunc(lambda x: 0) == zeros(3)
+    assert m0.applyfunc(lambda x: 1) == ones(3)
+
+
+def test_adjoint():
+    dat = [[0, I], [1, 0]]
+    ans = OperationsOnlyMatrix([[0, 1], [-I, 0]])
+    assert ans.adjoint() == Matrix(dat)
+
+
+def test_as_real_imag():
+    m1 = OperationsOnlyMatrix(2, 2, [1, 2, 3, 4])
+    m3 = OperationsOnlyMatrix(2, 2,
+        [1 + S.ImaginaryUnit, 2 + 2*S.ImaginaryUnit,
+        3 + 3*S.ImaginaryUnit, 4 + 4*S.ImaginaryUnit])
+
+    a, b = m3.as_real_imag()
+    assert a == m1
+    assert b == m1
+
+
+def test_conjugate():
+    M = OperationsOnlyMatrix([[0, I, 5],
+                [1, 2, 0]])
+
+    assert M.T == Matrix([[0, 1],
+                          [I, 2],
+                          [5, 0]])
+
+    assert M.C == Matrix([[0, -I, 5],
+                          [1,  2, 0]])
+    assert M.C == M.conjugate()
+
+    assert M.H == M.T.C
+    assert M.H == Matrix([[ 0, 1],
+                          [-I, 2],
+                          [ 5, 0]])
+
+
+def test_doit():
+    a = OperationsOnlyMatrix([[Add(x, x, evaluate=False)]])
+    assert a[0] != 2*x
+    assert a.doit() == Matrix([[2*x]])
+
+
+def test_evalf():
+    a = OperationsOnlyMatrix(2, 1, [sqrt(5), 6])
+    assert all(a.evalf()[i] == a[i].evalf() for i in range(2))
+    assert all(a.evalf(2)[i] == a[i].evalf(2) for i in range(2))
+    assert all(a.n(2)[i] == a[i].n(2) for i in range(2))
+
+
+def test_expand():
+    m0 = OperationsOnlyMatrix([[x*(x + y), 2], [((x + y)*y)*x, x*(y + x*(x + y))]])
+    # Test if expand() returns a matrix
+    m1 = m0.expand()
+    assert m1 == Matrix(
+        [[x*y + x**2, 2], [x*y**2 + y*x**2, x*y + y*x**2 + x**3]])
+
+    a = Symbol('a', real=True)
+
+    assert OperationsOnlyMatrix(1, 1, [exp(I*a)]).expand(complex=True) == \
+           Matrix([cos(a) + I*sin(a)])
+
+
+def test_refine():
+    m0 = OperationsOnlyMatrix([[Abs(x)**2, sqrt(x**2)],
+                 [sqrt(x**2)*Abs(y)**2, sqrt(y**2)*Abs(x)**2]])
+    m1 = m0.refine(Q.real(x) & Q.real(y))
+    assert m1 == Matrix([[x**2, Abs(x)], [y**2*Abs(x), x**2*Abs(y)]])
+
+    m1 = m0.refine(Q.positive(x) & Q.positive(y))
+    assert m1 == Matrix([[x**2, x], [x*y**2, x**2*y]])
+
+    m1 = m0.refine(Q.negative(x) & Q.negative(y))
+    assert m1 == Matrix([[x**2, -x], [-x*y**2, -x**2*y]])
+
+
+def test_replace():
+    F, G = symbols('F, G', cls=Function)
+    K = OperationsOnlyMatrix(2, 2, lambda i, j: G(i+j))
+    M = OperationsOnlyMatrix(2, 2, lambda i, j: F(i+j))
+    N = M.replace(F, G)
+    assert N == K
+
+
+def test_replace_map():
+    F, G = symbols('F, G', cls=Function)
+    K = OperationsOnlyMatrix(2, 2, [(G(0), {F(0): G(0)}), (G(1), {F(1): G(1)}), (G(1), {F(1) \
+                                                                              : G(1)}), (G(2), {F(2): G(2)})])
+    M = OperationsOnlyMatrix(2, 2, lambda i, j: F(i+j))
+    N = M.replace(F, G, True)
+    assert N == K
+
+
+def test_rot90():
+    A = Matrix([[1, 2], [3, 4]])
+    assert A == A.rot90(0) == A.rot90(4)
+    assert A.rot90(2) == A.rot90(-2) == A.rot90(6) == Matrix(((4, 3), (2, 1)))
+    assert A.rot90(3) == A.rot90(-1) == A.rot90(7) == Matrix(((2, 4), (1, 3)))
+    assert A.rot90() == A.rot90(-7) == A.rot90(-3) == Matrix(((3, 1), (4, 2)))
+
+def test_simplify():
+    n = Symbol('n')
+    f = Function('f')
+
+    M = OperationsOnlyMatrix([[            1/x + 1/y,                 (x + x*y) / x  ],
+                [ (f(x) + y*f(x))/f(x), 2 * (1/n - cos(n * pi)/n) / pi ]])
+    assert M.simplify() == Matrix([[ (x + y)/(x * y),                        1 + y ],
+                        [           1 + y, 2*((1 - 1*cos(pi*n))/(pi*n)) ]])
+    eq = (1 + x)**2
+    M = OperationsOnlyMatrix([[eq]])
+    assert M.simplify() == Matrix([[eq]])
+    assert M.simplify(ratio=oo) == Matrix([[eq.simplify(ratio=oo)]])
+
+    # https://github.com/sympy/sympy/issues/19353
+    m = Matrix([[30, 2], [3, 4]])
+    assert (1/(m.trace())).simplify() == Rational(1, 34)
+
+
+def test_subs():
+    assert OperationsOnlyMatrix([[1, x], [x, 4]]).subs(x, 5) == Matrix([[1, 5], [5, 4]])
+    assert OperationsOnlyMatrix([[x, 2], [x + y, 4]]).subs([[x, -1], [y, -2]]) == \
+           Matrix([[-1, 2], [-3, 4]])
+    assert OperationsOnlyMatrix([[x, 2], [x + y, 4]]).subs([(x, -1), (y, -2)]) == \
+           Matrix([[-1, 2], [-3, 4]])
+    assert OperationsOnlyMatrix([[x, 2], [x + y, 4]]).subs({x: -1, y: -2}) == \
+           Matrix([[-1, 2], [-3, 4]])
+    assert OperationsOnlyMatrix([[x*y]]).subs({x: y - 1, y: x - 1}, simultaneous=True) == \
+           Matrix([[(x - 1)*(y - 1)]])
+
+
+def test_trace():
+    M = OperationsOnlyMatrix([[1, 0, 0],
+                [0, 5, 0],
+                [0, 0, 8]])
+    assert M.trace() == 14
+
+
+def test_xreplace():
+    assert OperationsOnlyMatrix([[1, x], [x, 4]]).xreplace({x: 5}) == \
+           Matrix([[1, 5], [5, 4]])
+    assert OperationsOnlyMatrix([[x, 2], [x + y, 4]]).xreplace({x: -1, y: -2}) == \
+           Matrix([[-1, 2], [-3, 4]])
+
+
+def test_permute():
+    a = OperationsOnlyMatrix(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
+
+    raises(IndexError, lambda: a.permute([[0, 5]]))
+    raises(ValueError, lambda: a.permute(Symbol('x')))
+    b = a.permute_rows([[0, 2], [0, 1]])
+    assert a.permute([[0, 2], [0, 1]]) == b == Matrix([
+                                            [5,  6,  7,  8],
+                                            [9, 10, 11, 12],
+                                            [1,  2,  3,  4]])
+
+    b = a.permute_cols([[0, 2], [0, 1]])
+    assert a.permute([[0, 2], [0, 1]], orientation='cols') == b ==\
+                            Matrix([
+                            [ 2,  3, 1,  4],
+                            [ 6,  7, 5,  8],
+                            [10, 11, 9, 12]])
+
+    b = a.permute_cols([[0, 2], [0, 1]], direction='backward')
+    assert a.permute([[0, 2], [0, 1]], orientation='cols', direction='backward') == b ==\
+                            Matrix([
+                            [ 3, 1,  2,  4],
+                            [ 7, 5,  6,  8],
+                            [11, 9, 10, 12]])
+
+    assert a.permute([1, 2, 0, 3]) == Matrix([
+                                            [5,  6,  7,  8],
+                                            [9, 10, 11, 12],
+                                            [1,  2,  3,  4]])
+
+    from sympy.combinatorics import Permutation
+    assert a.permute(Permutation([1, 2, 0, 3])) == Matrix([
+                                            [5,  6,  7,  8],
+                                            [9, 10, 11, 12],
+                                            [1,  2,  3,  4]])
+
+def test_upper_triangular():
+
+    A = OperationsOnlyMatrix([
+                [1, 1, 1, 1],
+                [1, 1, 1, 1],
+                [1, 1, 1, 1],
+                [1, 1, 1, 1]
+            ])
+
+    R = A.upper_triangular(2)
+    assert R == OperationsOnlyMatrix([
+                        [0, 0, 1, 1],
+                        [0, 0, 0, 1],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0]
+                    ])
+
+    R = A.upper_triangular(-2)
+    assert R == OperationsOnlyMatrix([
+                        [1, 1, 1, 1],
+                        [1, 1, 1, 1],
+                        [1, 1, 1, 1],
+                        [0, 1, 1, 1]
+                    ])
+
+    R = A.upper_triangular()
+    assert R == OperationsOnlyMatrix([
+                        [1, 1, 1, 1],
+                        [0, 1, 1, 1],
+                        [0, 0, 1, 1],
+                        [0, 0, 0, 1]
+                    ])
+
+def test_lower_triangular():
+    A = OperationsOnlyMatrix([
+                        [1, 1, 1, 1],
+                        [1, 1, 1, 1],
+                        [1, 1, 1, 1],
+                        [1, 1, 1, 1]
+                    ])
+
+    L = A.lower_triangular()
+    assert L == ArithmeticOnlyMatrix([
+                        [1, 0, 0, 0],
+                        [1, 1, 0, 0],
+                        [1, 1, 1, 0],
+                        [1, 1, 1, 1]])
+
+    L = A.lower_triangular(2)
+    assert L == ArithmeticOnlyMatrix([
+                        [1, 1, 1, 0],
+                        [1, 1, 1, 1],
+                        [1, 1, 1, 1],
+                        [1, 1, 1, 1]
+                    ])
+
+    L = A.lower_triangular(-2)
+    assert L == ArithmeticOnlyMatrix([
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [1, 0, 0, 0],
+                        [1, 1, 0, 0]
+                    ])
+
+
+# ArithmeticOnlyMatrix tests
+def test_abs():
+    m = ArithmeticOnlyMatrix([[1, -2], [x, y]])
+    assert abs(m) == ArithmeticOnlyMatrix([[1, 2], [Abs(x), Abs(y)]])
+
+
+def test_add():
+    m = ArithmeticOnlyMatrix([[1, 2, 3], [x, y, x], [2*y, -50, z*x]])
+    assert m + m == ArithmeticOnlyMatrix([[2, 4, 6], [2*x, 2*y, 2*x], [4*y, -100, 2*z*x]])
+    n = ArithmeticOnlyMatrix(1, 2, [1, 2])
+    raises(ShapeError, lambda: m + n)
+
+
+def test_multiplication():
+    a = ArithmeticOnlyMatrix((
+        (1, 2),
+        (3, 1),
+        (0, 6),
+    ))
+
+    b = ArithmeticOnlyMatrix((
+        (1, 2),
+        (3, 0),
+    ))
+
+    raises(ShapeError, lambda: b*a)
+    raises(TypeError, lambda: a*{})
+
+    c = a*b
+    assert c[0, 0] == 7
+    assert c[0, 1] == 2
+    assert c[1, 0] == 6
+    assert c[1, 1] == 6
+    assert c[2, 0] == 18
+    assert c[2, 1] == 0
+
+    try:
+        eval('c = a @ b')
+    except SyntaxError:
+        pass
+    else:
+        assert c[0, 0] == 7
+        assert c[0, 1] == 2
+        assert c[1, 0] == 6
+        assert c[1, 1] == 6
+        assert c[2, 0] == 18
+        assert c[2, 1] == 0
+
+    h = a.multiply_elementwise(c)
+    assert h == matrix_multiply_elementwise(a, c)
+    assert h[0, 0] == 7
+    assert h[0, 1] == 4
+    assert h[1, 0] == 18
+    assert h[1, 1] == 6
+    assert h[2, 0] == 0
+    assert h[2, 1] == 0
+    raises(ShapeError, lambda: a.multiply_elementwise(b))
+
+    c = b * Symbol("x")
+    assert isinstance(c, ArithmeticOnlyMatrix)
+    assert c[0, 0] == x
+    assert c[0, 1] == 2*x
+    assert c[1, 0] == 3*x
+    assert c[1, 1] == 0
+
+    c2 = x * b
+    assert c == c2
+
+    c = 5 * b
+    assert isinstance(c, ArithmeticOnlyMatrix)
+    assert c[0, 0] == 5
+    assert c[0, 1] == 2*5
+    assert c[1, 0] == 3*5
+    assert c[1, 1] == 0
+
+    try:
+        eval('c = 5 @ b')
+    except SyntaxError:
+        pass
+    else:
+        assert isinstance(c, ArithmeticOnlyMatrix)
+        assert c[0, 0] == 5
+        assert c[0, 1] == 2*5
+        assert c[1, 0] == 3*5
+        assert c[1, 1] == 0
+
+    # https://github.com/sympy/sympy/issues/22353
+    A = Matrix(ones(3, 1))
+    _h = -Rational(1, 2)
+    B = Matrix([_h, _h, _h])
+    assert A.multiply_elementwise(B) == Matrix([
+        [_h],
+        [_h],
+        [_h]])
+
+
+def test_matmul():
+    a = Matrix([[1, 2], [3, 4]])
+
+    assert a.__matmul__(2) == NotImplemented
+
+    assert a.__rmatmul__(2) == NotImplemented
+
+    #This is done this way because @ is only supported in Python 3.5+
+    #To check 2@a case
+    try:
+        eval('2 @ a')
+    except SyntaxError:
+        pass
+    except TypeError:  #TypeError is raised in case of NotImplemented is returned
+        pass
+
+    #Check a@2 case
+    try:
+        eval('a @ 2')
+    except SyntaxError:
+        pass
+    except TypeError:  #TypeError is raised in case of NotImplemented is returned
+        pass
+
+
+def test_non_matmul():
+    """
+    Test that if explicitly specified as non-matrix, mul reverts
+    to scalar multiplication.
+    """
+    class foo(Expr):
+        is_Matrix=False
+        is_MatrixLike=False
+        shape = (1, 1)
+
+    A = Matrix([[1, 2], [3, 4]])
+    b = foo()
+    assert b*A == Matrix([[b, 2*b], [3*b, 4*b]])
+    assert A*b == Matrix([[b, 2*b], [3*b, 4*b]])
+
+
+def test_power():
+    raises(NonSquareMatrixError, lambda: Matrix((1, 2))**2)
+
+    A = ArithmeticOnlyMatrix([[2, 3], [4, 5]])
+    assert (A**5)[:] == (6140, 8097, 10796, 14237)
+    A = ArithmeticOnlyMatrix([[2, 1, 3], [4, 2, 4], [6, 12, 1]])
+    assert (A**3)[:] == (290, 262, 251, 448, 440, 368, 702, 954, 433)
+    assert A**0 == eye(3)
+    assert A**1 == A
+    assert (ArithmeticOnlyMatrix([[2]]) ** 100)[0, 0] == 2**100
+    assert ArithmeticOnlyMatrix([[1, 2], [3, 4]])**Integer(2) == ArithmeticOnlyMatrix([[7, 10], [15, 22]])
+    A = Matrix([[1,2],[4,5]])
+    assert A.pow(20, method='cayley') == A.pow(20, method='multiply')
+
+def test_neg():
+    n = ArithmeticOnlyMatrix(1, 2, [1, 2])
+    assert -n == ArithmeticOnlyMatrix(1, 2, [-1, -2])
+
+
+def test_sub():
+    n = ArithmeticOnlyMatrix(1, 2, [1, 2])
+    assert n - n == ArithmeticOnlyMatrix(1, 2, [0, 0])
+
+
+def test_div():
+    n = ArithmeticOnlyMatrix(1, 2, [1, 2])
+    assert n/2 == ArithmeticOnlyMatrix(1, 2, [S.Half, S(2)/2])
+
+# SpecialOnlyMatrix tests
+def test_eye():
+    assert list(SpecialOnlyMatrix.eye(2, 2)) == [1, 0, 0, 1]
+    assert list(SpecialOnlyMatrix.eye(2)) == [1, 0, 0, 1]
+    assert type(SpecialOnlyMatrix.eye(2)) == SpecialOnlyMatrix
+    assert type(SpecialOnlyMatrix.eye(2, cls=Matrix)) == Matrix
+
+
+def test_ones():
+    assert list(SpecialOnlyMatrix.ones(2, 2)) == [1, 1, 1, 1]
+    assert list(SpecialOnlyMatrix.ones(2)) == [1, 1, 1, 1]
+    assert SpecialOnlyMatrix.ones(2, 3) == Matrix([[1, 1, 1], [1, 1, 1]])
+    assert type(SpecialOnlyMatrix.ones(2)) == SpecialOnlyMatrix
+    assert type(SpecialOnlyMatrix.ones(2, cls=Matrix)) == Matrix
+
+
+def test_zeros():
+    assert list(SpecialOnlyMatrix.zeros(2, 2)) == [0, 0, 0, 0]
+    assert list(SpecialOnlyMatrix.zeros(2)) == [0, 0, 0, 0]
+    assert SpecialOnlyMatrix.zeros(2, 3) == Matrix([[0, 0, 0], [0, 0, 0]])
+    assert type(SpecialOnlyMatrix.zeros(2)) == SpecialOnlyMatrix
+    assert type(SpecialOnlyMatrix.zeros(2, cls=Matrix)) == Matrix
+
+
+def test_diag_make():
+    diag = SpecialOnlyMatrix.diag
+    a = Matrix([[1, 2], [2, 3]])
+    b = Matrix([[3, x], [y, 3]])
+    c = Matrix([[3, x, 3], [y, 3, z], [x, y, z]])
+    assert diag(a, b, b) == Matrix([
+        [1, 2, 0, 0, 0, 0],
+        [2, 3, 0, 0, 0, 0],
+        [0, 0, 3, x, 0, 0],
+        [0, 0, y, 3, 0, 0],
+        [0, 0, 0, 0, 3, x],
+        [0, 0, 0, 0, y, 3],
+    ])
+    assert diag(a, b, c) == Matrix([
+        [1, 2, 0, 0, 0, 0, 0],
+        [2, 3, 0, 0, 0, 0, 0],
+        [0, 0, 3, x, 0, 0, 0],
+        [0, 0, y, 3, 0, 0, 0],
+        [0, 0, 0, 0, 3, x, 3],
+        [0, 0, 0, 0, y, 3, z],
+        [0, 0, 0, 0, x, y, z],
+    ])
+    assert diag(a, c, b) == Matrix([
+        [1, 2, 0, 0, 0, 0, 0],
+        [2, 3, 0, 0, 0, 0, 0],
+        [0, 0, 3, x, 3, 0, 0],
+        [0, 0, y, 3, z, 0, 0],
+        [0, 0, x, y, z, 0, 0],
+        [0, 0, 0, 0, 0, 3, x],
+        [0, 0, 0, 0, 0, y, 3],
+    ])
+    a = Matrix([x, y, z])
+    b = Matrix([[1, 2], [3, 4]])
+    c = Matrix([[5, 6]])
+    # this "wandering diagonal" is what makes this
+    # a block diagonal where each block is independent
+    # of the others
+    assert diag(a, 7, b, c) == Matrix([
+        [x, 0, 0, 0, 0, 0],
+        [y, 0, 0, 0, 0, 0],
+        [z, 0, 0, 0, 0, 0],
+        [0, 7, 0, 0, 0, 0],
+        [0, 0, 1, 2, 0, 0],
+        [0, 0, 3, 4, 0, 0],
+        [0, 0, 0, 0, 5, 6]])
+    raises(ValueError, lambda: diag(a, 7, b, c, rows=5))
+    assert diag(1) == Matrix([[1]])
+    assert diag(1, rows=2) == Matrix([[1, 0], [0, 0]])
+    assert diag(1, cols=2) == Matrix([[1, 0], [0, 0]])
+    assert diag(1, rows=3, cols=2) == Matrix([[1, 0], [0, 0], [0, 0]])
+    assert diag(*[2, 3]) == Matrix([
+        [2, 0],
+        [0, 3]])
+    assert diag(Matrix([2, 3])) == Matrix([
+        [2],
+        [3]])
+    assert diag([1, [2, 3], 4], unpack=False) == \
+            diag([[1], [2, 3], [4]], unpack=False) == Matrix([
+        [1, 0],
+        [2, 3],
+        [4, 0]])
+    assert type(diag(1)) == SpecialOnlyMatrix
+    assert type(diag(1, cls=Matrix)) == Matrix
+    assert Matrix.diag([1, 2, 3]) == Matrix.diag(1, 2, 3)
+    assert Matrix.diag([1, 2, 3], unpack=False).shape == (3, 1)
+    assert Matrix.diag([[1, 2, 3]]).shape == (3, 1)
+    assert Matrix.diag([[1, 2, 3]], unpack=False).shape == (1, 3)
+    assert Matrix.diag([[[1, 2, 3]]]).shape == (1, 3)
+    # kerning can be used to move the starting point
+    assert Matrix.diag(ones(0, 2), 1, 2) == Matrix([
+        [0, 0, 1, 0],
+        [0, 0, 0, 2]])
+    assert Matrix.diag(ones(2, 0), 1, 2) == Matrix([
+        [0, 0],
+        [0, 0],
+        [1, 0],
+        [0, 2]])
+
+
+def test_diagonal():
+    m = Matrix(3, 3, range(9))
+    d = m.diagonal()
+    assert d == m.diagonal(0)
+    assert tuple(d) == (0, 4, 8)
+    assert tuple(m.diagonal(1)) == (1, 5)
+    assert tuple(m.diagonal(-1)) == (3, 7)
+    assert tuple(m.diagonal(2)) == (2,)
+    assert type(m.diagonal()) == type(m)
+    s = SparseMatrix(3, 3, {(1, 1): 1})
+    assert type(s.diagonal()) == type(s)
+    assert type(m) != type(s)
+    raises(ValueError, lambda: m.diagonal(3))
+    raises(ValueError, lambda: m.diagonal(-3))
+    raises(ValueError, lambda: m.diagonal(pi))
+    M = ones(2, 3)
+    assert banded({i: list(M.diagonal(i))
+        for i in range(1-M.rows, M.cols)}) == M
+
+
+def test_jordan_block():
+    assert SpecialOnlyMatrix.jordan_block(3, 2) == SpecialOnlyMatrix.jordan_block(3, eigenvalue=2) \
+            == SpecialOnlyMatrix.jordan_block(size=3, eigenvalue=2) \
+            == SpecialOnlyMatrix.jordan_block(3, 2, band='upper') \
+            == SpecialOnlyMatrix.jordan_block(
+                size=3, eigenval=2, eigenvalue=2) \
+            == Matrix([
+                [2, 1, 0],
+                [0, 2, 1],
+                [0, 0, 2]])
+
+    assert SpecialOnlyMatrix.jordan_block(3, 2, band='lower') == Matrix([
+                    [2, 0, 0],
+                    [1, 2, 0],
+                    [0, 1, 2]])
+    # missing eigenvalue
+    raises(ValueError, lambda: SpecialOnlyMatrix.jordan_block(2))
+    # non-integral size
+    raises(ValueError, lambda: SpecialOnlyMatrix.jordan_block(3.5, 2))
+    # size not specified
+    raises(ValueError, lambda: SpecialOnlyMatrix.jordan_block(eigenvalue=2))
+    # inconsistent eigenvalue
+    raises(ValueError,
+    lambda: SpecialOnlyMatrix.jordan_block(
+        eigenvalue=2, eigenval=4))
+
+    # Using alias keyword
+    assert SpecialOnlyMatrix.jordan_block(size=3, eigenvalue=2) == \
+        SpecialOnlyMatrix.jordan_block(size=3, eigenval=2)
+
+
+def test_orthogonalize():
+    m = Matrix([[1, 2], [3, 4]])
+    assert m.orthogonalize(Matrix([[2], [1]])) == [Matrix([[2], [1]])]
+    assert m.orthogonalize(Matrix([[2], [1]]), normalize=True) == \
+        [Matrix([[2*sqrt(5)/5], [sqrt(5)/5]])]
+    assert m.orthogonalize(Matrix([[1], [2]]), Matrix([[-1], [4]])) == \
+        [Matrix([[1], [2]]), Matrix([[Rational(-12, 5)], [Rational(6, 5)]])]
+    assert m.orthogonalize(Matrix([[0], [0]]), Matrix([[-1], [4]])) == \
+        [Matrix([[-1], [4]])]
+    assert m.orthogonalize(Matrix([[0], [0]])) == []
+
+    n = Matrix([[9, 1, 9], [3, 6, 10], [8, 5, 2]])
+    vecs = [Matrix([[-5], [1]]), Matrix([[-5], [2]]), Matrix([[-5], [-2]])]
+    assert n.orthogonalize(*vecs) == \
+        [Matrix([[-5], [1]]), Matrix([[Rational(5, 26)], [Rational(25, 26)]])]
+
+    vecs = [Matrix([0, 0, 0]), Matrix([1, 2, 3]), Matrix([1, 4, 5])]
+    raises(ValueError, lambda: Matrix.orthogonalize(*vecs, rankcheck=True))
+
+    vecs = [Matrix([1, 2, 3]), Matrix([4, 5, 6]), Matrix([7, 8, 9])]
+    raises(ValueError, lambda: Matrix.orthogonalize(*vecs, rankcheck=True))
+
+def test_wilkinson():
+
+    wminus, wplus = Matrix.wilkinson(1)
+    assert wminus == Matrix([
+                                [-1, 1, 0],
+                                [1, 0, 1],
+                                [0, 1, 1]])
+    assert wplus == Matrix([
+                            [1, 1, 0],
+                            [1, 0, 1],
+                            [0, 1, 1]])
+
+    wminus, wplus = Matrix.wilkinson(3)
+    assert wminus == Matrix([
+                                [-3,  1,  0, 0, 0, 0, 0],
+                                [1, -2,  1, 0, 0, 0, 0],
+                                [0,  1, -1, 1, 0, 0, 0],
+                                [0,  0,  1, 0, 1, 0, 0],
+                                [0,  0,  0, 1, 1, 1, 0],
+                                [0,  0,  0, 0, 1, 2, 1],
+
+      [0,  0,  0, 0, 0, 1, 3]])
+
+    assert wplus == Matrix([
+                            [3, 1, 0, 0, 0, 0, 0],
+                            [1, 2, 1, 0, 0, 0, 0],
+                            [0, 1, 1, 1, 0, 0, 0],
+                            [0, 0, 1, 0, 1, 0, 0],
+                            [0, 0, 0, 1, 1, 1, 0],
+                            [0, 0, 0, 0, 1, 2, 1],
+                            [0, 0, 0, 0, 0, 1, 3]])
+
+
+# CalculusOnlyMatrix tests
+@XFAIL
+def test_diff():
+    x, y = symbols('x y')
+    m = CalculusOnlyMatrix(2, 1, [x, y])
+    # TODO: currently not working as ``_MinimalMatrix`` cannot be sympified:
+    assert m.diff(x) == Matrix(2, 1, [1, 0])
+
+
+def test_integrate():
+    x, y = symbols('x y')
+    m = CalculusOnlyMatrix(2, 1, [x, y])
+    assert m.integrate(x) == Matrix(2, 1, [x**2/2, y*x])
+
+
+def test_jacobian2():
+    rho, phi = symbols("rho,phi")
+    X = CalculusOnlyMatrix(3, 1, [rho*cos(phi), rho*sin(phi), rho**2])
+    Y = CalculusOnlyMatrix(2, 1, [rho, phi])
+    J = Matrix([
+        [cos(phi), -rho*sin(phi)],
+        [sin(phi),  rho*cos(phi)],
+        [   2*rho,             0],
+    ])
+    assert X.jacobian(Y) == J
+
+    m = CalculusOnlyMatrix(2, 2, [1, 2, 3, 4])
+    m2 = CalculusOnlyMatrix(4, 1, [1, 2, 3, 4])
+    raises(TypeError, lambda: m.jacobian(Matrix([1, 2])))
+    raises(TypeError, lambda: m2.jacobian(m))
+
+
+def test_limit():
+    x, y = symbols('x y')
+    m = CalculusOnlyMatrix(2, 1, [1/x, y])
+    assert m.limit(x, 5) == Matrix(2, 1, [Rational(1, 5), y])
+
+
+def test_issue_13774():
+    M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    v = [1, 1, 1]
+    raises(TypeError, lambda: M*v)
+    raises(TypeError, lambda: v*M)
+
+def test_companion():
+    x = Symbol('x')
+    y = Symbol('y')
+    raises(ValueError, lambda: Matrix.companion(1))
+    raises(ValueError, lambda: Matrix.companion(Poly([1], x)))
+    raises(ValueError, lambda: Matrix.companion(Poly([2, 1], x)))
+    raises(ValueError, lambda: Matrix.companion(Poly(x*y, [x, y])))
+
+    c0, c1, c2 = symbols('c0:3')
+    assert Matrix.companion(Poly([1, c0], x)) == Matrix([-c0])
+    assert Matrix.companion(Poly([1, c1, c0], x)) == \
+        Matrix([[0, -c0], [1, -c1]])
+    assert Matrix.companion(Poly([1, c2, c1, c0], x)) == \
+        Matrix([[0, 0, -c0], [1, 0, -c1], [0, 1, -c2]])
+
+def test_issue_10589():
+    x, y, z = symbols("x, y z")
+    M1 = Matrix([x, y, z])
+    M1 = M1.subs(zip([x, y, z], [1, 2, 3]))
+    assert M1 == Matrix([[1], [2], [3]])
+
+    M2 = Matrix([[x, x, x, x, x], [x, x, x, x, x], [x, x, x, x, x]])
+    M2 = M2.subs(zip([x], [1]))
+    assert M2 == Matrix([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]])
+
+def test_rmul_pr19860():
+    class Foo(ImmutableDenseMatrix):
+        _op_priority = MutableDenseMatrix._op_priority + 0.01
+
+    a = Matrix(2, 2, [1, 2, 3, 4])
+    b = Foo(2, 2, [1, 2, 3, 4])
+
+    # This would throw a RecursionError: maximum recursion depth
+    # since b always has higher priority even after a.as_mutable()
+    c = a*b
+
+    assert isinstance(c, Foo)
+    assert c == Matrix([[7, 10], [15, 22]])
+
+
+def test_issue_18956():
+    A = Array([[1, 2], [3, 4]])
+    B = Matrix([[1,2],[3,4]])
+    raises(TypeError, lambda: B + A)
+    raises(TypeError, lambda: A + B)
+
+
+def test__eq__():
+    class My(object):
+        def __iter__(self):
+            yield 1
+            yield 2
+            return
+        def __getitem__(self, i):
+            return list(self)[i]
+    a = Matrix(2, 1, [1, 2])
+    assert a != My()
+    class My_sympy(My):
+        def _sympy_(self):
+            return Matrix(self)
+    assert a == My_sympy()

openflamingo/lib/python3.10/site-packages/sympy/matrices/tests/test_determinant.py

@@ -0,0 +1,280 @@
+import random
+import pytest
+from sympy.core.numbers import I
+from sympy.core.numbers import Rational
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys.polytools import Poly
+from sympy.matrices import Matrix, eye, ones
+from sympy.abc import x, y, z
+from sympy.testing.pytest import raises
+from sympy.matrices.exceptions import NonSquareMatrixError
+from sympy.functions.combinatorial.factorials import factorial, subfactorial
+
+
+@pytest.mark.parametrize("method", [
+    # Evaluating these directly because they are never reached via M.det()
+    Matrix._eval_det_bareiss, Matrix._eval_det_berkowitz,
+    Matrix._eval_det_bird, Matrix._eval_det_laplace, Matrix._eval_det_lu
+])
+@pytest.mark.parametrize("M, sol", [
+    (Matrix(), 1),
+    (Matrix([[0]]), 0),
+    (Matrix([[5]]), 5),
+])
+def test_eval_determinant(method, M, sol):
+    assert method(M) == sol
+
+
+@pytest.mark.parametrize("method", [
+    "domain-ge", "bareiss", "berkowitz", "bird", "laplace", "lu"])
+@pytest.mark.parametrize("M, sol", [
+    (Matrix(( (-3,  2),
+              ( 8, -5) )), -1),
+    (Matrix(( (x,   1),
+              (y, 2*y) )), 2*x*y - y),
+    (Matrix(( (1, 1, 1),
+              (1, 2, 3),
+              (1, 3, 6) )), 1),
+    (Matrix(( ( 3, -2,  0, 5),
+              (-2,  1, -2, 2),
+              ( 0, -2,  5, 0),
+              ( 5,  0,  3, 4) )), -289),
+    (Matrix(( ( 1,  2,  3,  4),
+              ( 5,  6,  7,  8),
+              ( 9, 10, 11, 12),
+              (13, 14, 15, 16) )), 0),
+    (Matrix(( (3, 2, 0, 0, 0),
+              (0, 3, 2, 0, 0),
+              (0, 0, 3, 2, 0),
+              (0, 0, 0, 3, 2),
+              (2, 0, 0, 0, 3) )), 275),
+    (Matrix(( ( 3,  0,  0, 0),
+              (-2,  1,  0, 0),
+              ( 0, -2,  5, 0),
+              ( 5,  0,  3, 4) )), 60),
+    (Matrix(( ( 1,  0,  0,  0),
+              ( 5,  0,  0,  0),
+              ( 9, 10, 11, 0),
+              (13, 14, 15, 16) )), 0),
+    (Matrix(( (3, 2, 0, 0, 0),
+              (0, 3, 2, 0, 0),
+              (0, 0, 3, 2, 0),
+              (0, 0, 0, 3, 2),
+              (0, 0, 0, 0, 3) )), 243),
+    (Matrix(( (1, 0,  1,  2, 12),
+              (2, 0,  1,  1,  4),
+              (2, 1,  1, -1,  3),
+              (3, 2, -1,  1,  8),
+              (1, 1,  1,  0,  6) )), -55),
+    (Matrix(( (-5,  2,  3,  4,  5),
+              ( 1, -4,  3,  4,  5),
+              ( 1,  2, -3,  4,  5),
+              ( 1,  2,  3, -2,  5),
+              ( 1,  2,  3,  4, -1) )), 11664),
+    (Matrix(( ( 2,  7, -1, 3, 2),
+              ( 0,  0,  1, 0, 1),
+              (-2,  0,  7, 0, 2),
+              (-3, -2,  4, 5, 3),
+              ( 1,  0,  0, 0, 1) )), 123),
+    (Matrix(( (x, y, z),
+              (1, 0, 0),
+              (y, z, x) )), z**2 - x*y),
+])
+def test_determinant(method, M, sol):
+    assert M.det(method=method) == sol
+
+
+def test_issue_13835():
+    a = symbols('a')
+    M = lambda n: Matrix([[i + a*j for i in range(n)]
+                          for j in range(n)])
+    assert M(5).det() == 0
+    assert M(6).det() == 0
+    assert M(7).det() == 0
+
+
+def test_issue_14517():
+    M = Matrix([
+        [   0, 10*I,    10*I,       0],
+        [10*I,    0,       0,    10*I],
+        [10*I,    0, 5 + 2*I,    10*I],
+        [   0, 10*I,    10*I, 5 + 2*I]])
+    ev = M.eigenvals()
+    # test one random eigenvalue, the computation is a little slow
+    test_ev = random.choice(list(ev.keys()))
+    assert (M - test_ev*eye(4)).det() == 0
+
+
+@pytest.mark.parametrize("method", [
+    "bareis", "det_lu", "det_LU", "Bareis", "BAREISS", "BERKOWITZ", "LU"])
+@pytest.mark.parametrize("M, sol", [
+    (Matrix(( ( 3, -2,  0, 5),
+              (-2,  1, -2, 2),
+              ( 0, -2,  5, 0),
+              ( 5,  0,  3, 4) )), -289),
+    (Matrix(( (-5,  2,  3,  4,  5),
+              ( 1, -4,  3,  4,  5),
+              ( 1,  2, -3,  4,  5),
+              ( 1,  2,  3, -2,  5),
+              ( 1,  2,  3,  4, -1) )), 11664),
+])
+def test_legacy_det(method, M, sol):
+    # Minimal support for legacy keys for 'method' in det()
+    # Partially copied from test_determinant()
+    assert M.det(method=method) == sol
+
+
+def eye_Determinant(n):
+    return Matrix(n, n, lambda i, j: int(i == j))
+
+def zeros_Determinant(n):
+    return Matrix(n, n, lambda i, j: 0)
+
+def test_det():
+    a = Matrix(2, 3, [1, 2, 3, 4, 5, 6])
+    raises(NonSquareMatrixError, lambda: a.det())
+
+    z = zeros_Determinant(2)
+    ey = eye_Determinant(2)
+    assert z.det() == 0
+    assert ey.det() == 1
+
+    x = Symbol('x')
+    a = Matrix(0, 0, [])
+    b = Matrix(1, 1, [5])
+    c = Matrix(2, 2, [1, 2, 3, 4])
+    d = Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 8])
+    e = Matrix(4, 4,
+        [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14])
+    from sympy.abc import i, j, k, l, m, n
+    f = Matrix(3, 3, [i, l, m, 0, j, n, 0, 0, k])
+    g = Matrix(3, 3, [i, 0, 0, l, j, 0, m, n, k])
+    h = Matrix(3, 3, [x**3, 0, 0, i, x**-1, 0, j, k, x**-2])
+    # the method keyword for `det` doesn't kick in until 4x4 matrices,
+    # so there is no need to test all methods on smaller ones
+
+    assert a.det() == 1
+    assert b.det() == 5
+    assert c.det() == -2
+    assert d.det() == 3
+    assert e.det() == 4*x - 24
+    assert e.det(method="domain-ge") == 4*x - 24
+    assert e.det(method='bareiss') == 4*x - 24
+    assert e.det(method='berkowitz') == 4*x - 24
+    assert f.det() == i*j*k
+    assert g.det() == i*j*k
+    assert h.det() == 1
+    raises(ValueError, lambda: e.det(iszerofunc="test"))
+
+def test_permanent():
+    M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    assert M.per() == 450
+    for i in range(1, 12):
+        assert ones(i, i).per() == ones(i, i).T.per() == factorial(i)
+        assert (ones(i, i)-eye(i)).per() == (ones(i, i)-eye(i)).T.per() == subfactorial(i)
+
+    a1, a2, a3, a4, a5 = symbols('a_1 a_2 a_3 a_4 a_5')
+    M = Matrix([a1, a2, a3, a4, a5])
+    assert M.per() == M.T.per() == a1 + a2 + a3 + a4 + a5
+
+def test_adjugate():
+    x = Symbol('x')
+    e = Matrix(4, 4,
+        [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14])
+
+    adj = Matrix([
+        [   4,         -8,         4,         0],
+        [  76, -14*x - 68,  14*x - 8, -4*x + 24],
+        [-122, 17*x + 142, -21*x + 4,  8*x - 48],
+        [  48,  -4*x - 72,       8*x, -4*x + 24]])
+    assert e.adjugate() == adj
+    assert e.adjugate(method='bareiss') == adj
+    assert e.adjugate(method='berkowitz') == adj
+    assert e.adjugate(method='bird') == adj
+    assert e.adjugate(method='laplace') == adj
+
+    a = Matrix(2, 3, [1, 2, 3, 4, 5, 6])
+    raises(NonSquareMatrixError, lambda: a.adjugate())
+
+def test_util():
+    R = Rational
+
+    v1 = Matrix(1, 3, [1, 2, 3])
+    v2 = Matrix(1, 3, [3, 4, 5])
+    assert v1.norm() == sqrt(14)
+    assert v1.project(v2) == Matrix(1, 3, [R(39)/25, R(52)/25, R(13)/5])
+    assert Matrix.zeros(1, 2) == Matrix(1, 2, [0, 0])
+    assert ones(1, 2) == Matrix(1, 2, [1, 1])
+    assert v1.copy() == v1
+    # cofactor
+    assert eye(3) == eye(3).cofactor_matrix()
+    test = Matrix([[1, 3, 2], [2, 6, 3], [2, 3, 6]])
+    assert test.cofactor_matrix() == \
+        Matrix([[27, -6, -6], [-12, 2, 3], [-3, 1, 0]])
+    test = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    assert test.cofactor_matrix() == \
+        Matrix([[-3, 6, -3], [6, -12, 6], [-3, 6, -3]])
+
+def test_cofactor_and_minors():
+    x = Symbol('x')
+    e = Matrix(4, 4,
+        [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14])
+
+    m = Matrix([
+        [ x,  1,  3],
+        [ 2,  9, 11],
+        [12, 13, 14]])
+    cm = Matrix([
+        [ 4,         76,       -122,        48],
+        [-8, -14*x - 68, 17*x + 142, -4*x - 72],
+        [ 4,   14*x - 8,  -21*x + 4,       8*x],
+        [ 0,  -4*x + 24,   8*x - 48, -4*x + 24]])
+    sub = Matrix([
+            [x, 1,  2],
+            [4, 5,  6],
+            [2, 9, 10]])
+
+    assert e.minor_submatrix(1, 2) == m
+    assert e.minor_submatrix(-1, -1) == sub
+    assert e.minor(1, 2) == -17*x - 142
+    assert e.cofactor(1, 2) == 17*x + 142
+    assert e.cofactor_matrix() == cm
+    assert e.cofactor_matrix(method="bareiss") == cm
+    assert e.cofactor_matrix(method="berkowitz") == cm
+    assert e.cofactor_matrix(method="bird") == cm
+    assert e.cofactor_matrix(method="laplace") == cm
+
+    raises(ValueError, lambda: e.cofactor(4, 5))
+    raises(ValueError, lambda: e.minor(4, 5))
+    raises(ValueError, lambda: e.minor_submatrix(4, 5))
+
+    a = Matrix(2, 3, [1, 2, 3, 4, 5, 6])
+    assert a.minor_submatrix(0, 0) == Matrix([[5, 6]])
+
+    raises(ValueError, lambda:
+        Matrix(0, 0, []).minor_submatrix(0, 0))
+    raises(NonSquareMatrixError, lambda: a.cofactor(0, 0))
+    raises(NonSquareMatrixError, lambda: a.minor(0, 0))
+    raises(NonSquareMatrixError, lambda: a.cofactor_matrix())
+
+def test_charpoly():
+    x, y = Symbol('x'), Symbol('y')
+    z, t = Symbol('z'), Symbol('t')
+
+    from sympy.abc import a,b,c
+
+    m = Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+    assert eye_Determinant(3).charpoly(x) == Poly((x - 1)**3, x)
+    assert eye_Determinant(3).charpoly(y) == Poly((y - 1)**3, y)
+    assert m.charpoly() == Poly(x**3 - 15*x**2 - 18*x, x)
+    raises(NonSquareMatrixError, lambda: Matrix([[1], [2]]).charpoly())
+    n = Matrix(4, 4, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    assert n.charpoly() == Poly(x**4, x)
+
+    n = Matrix(4, 4, [45, 0, 0, 0, 0, 23, 0, 0, 0, 0, 87, 0, 0, 0, 0, 12])
+    assert n.charpoly() == Poly(x**4 - 167*x**3 + 8811*x**2 - 173457*x + 1080540, x)
+
+    n = Matrix(3, 3, [x, 0, 0, a, y, 0, b, c, z])
+    assert n.charpoly() == Poly(t**3 - (x+y+z)*t**2 + t*(x*y+y*z+x*z) - x*y*z, t)

openflamingo/lib/python3.10/site-packages/sympy/matrices/tests/test_domains.py

@@ -0,0 +1,113 @@
+# Test Matrix/DomainMatrix interaction.
+
+
+from sympy import GF, ZZ, QQ, EXRAW
+from sympy.polys.matrices import DomainMatrix, DM
+
+from sympy import (
+    Matrix,
+    MutableMatrix,
+    ImmutableMatrix,
+    SparseMatrix,
+    MutableDenseMatrix,
+    ImmutableDenseMatrix,
+    MutableSparseMatrix,
+    ImmutableSparseMatrix,
+)
+from sympy import symbols, S, sqrt
+
+from sympy.testing.pytest import raises
+
+
+x, y = symbols('x y')
+
+
+MATRIX_TYPES = (
+    Matrix,
+    MutableMatrix,
+    ImmutableMatrix,
+    SparseMatrix,
+    MutableDenseMatrix,
+    ImmutableDenseMatrix,
+    MutableSparseMatrix,
+    ImmutableSparseMatrix,
+)
+IMMUTABLE = (
+    ImmutableMatrix,
+    ImmutableDenseMatrix,
+    ImmutableSparseMatrix,
+)
+
+
+def DMs(items, domain):
+    return DM(items, domain).to_sparse()
+
+
+def test_Matrix_rep_domain():
+
+    for Mat in MATRIX_TYPES:
+
+        M = Mat([[1, 2], [3, 4]])
+        assert M._rep == DMs([[1, 2], [3, 4]], ZZ)
+        assert (M / 2)._rep == DMs([[(1,2), 1], [(3,2), 2]], QQ)
+        if not isinstance(M, IMMUTABLE):
+            M[0, 0] = x
+            assert M._rep == DMs([[x, 2], [3, 4]], EXRAW)
+
+        M = Mat([[S(1)/2, 2], [3, 4]])
+        assert M._rep == DMs([[(1,2), 2], [3, 4]], QQ)
+        if not isinstance(M, IMMUTABLE):
+            M[0, 0] = x
+            assert M._rep == DMs([[x, 2], [3, 4]], EXRAW)
+
+        dM = DMs([[1, 2], [3, 4]], ZZ)
+        assert Mat._fromrep(dM)._rep == dM
+
+    # XXX: This is not intended. Perhaps it should be coerced to EXRAW?
+    # The private _fromrep method is never called like this but perhaps it
+    # should be guarded.
+    #
+    # It is not clear how to integrate domains other than ZZ, QQ and EXRAW with
+    # the rest of Matrix or if the public type for this needs to be something
+    # different from Matrix somehow.
+    K = QQ.algebraic_field(sqrt(2))
+    dM = DM([[1, 2], [3, 4]], K)
+    assert Mat._fromrep(dM)._rep.domain == K
+
+
+def test_Matrix_to_DM():
+
+    M = Matrix([[1, 2], [3, 4]])
+    assert M.to_DM() == DMs([[1, 2], [3, 4]], ZZ)
+    assert M.to_DM() is not M._rep
+    assert M.to_DM(field=True) == DMs([[1, 2], [3, 4]], QQ)
+    assert M.to_DM(domain=QQ) == DMs([[1, 2], [3, 4]], QQ)
+    assert M.to_DM(domain=QQ[x]) == DMs([[1, 2], [3, 4]], QQ[x])
+    assert M.to_DM(domain=GF(3)) == DMs([[1, 2], [0, 1]], GF(3))
+
+    M = Matrix([[1, 2], [3, 4]])
+    M[0, 0] = x
+    assert M._rep.domain == EXRAW
+    M[0, 0] = 1
+    assert M.to_DM() == DMs([[1, 2], [3, 4]], ZZ)
+
+    M = Matrix([[S(1)/2, 2], [3, 4]])
+    assert M.to_DM() == DMs([[QQ(1,2), 2], [3, 4]], QQ)
+
+    M = Matrix([[x, 2], [3, 4]])
+    assert M.to_DM() == DMs([[x, 2], [3, 4]], ZZ[x])
+    assert M.to_DM(field=True) == DMs([[x, 2], [3, 4]], ZZ.frac_field(x))
+
+    M = Matrix([[1/x, 2], [3, 4]])
+    assert M.to_DM() == DMs([[1/x, 2], [3, 4]], ZZ.frac_field(x))
+
+    M = Matrix([[1, sqrt(2)], [3, 4]])
+    K = QQ.algebraic_field(sqrt(2))
+    sqrt2 = K.from_sympy(sqrt(2)) # XXX: Maybe K(sqrt(2)) should work
+    M_K = DomainMatrix([[K(1), sqrt2], [K(3), K(4)]], (2, 2), K)
+    assert M.to_DM() == DMs([[1, sqrt(2)], [3, 4]], EXRAW)
+    assert M.to_DM(extension=True) == M_K.to_sparse()
+
+    # Options cannot be used with the domain parameter
+    M = Matrix([[1, 2], [3, 4]])
+    raises(TypeError, lambda: M.to_DM(domain=QQ, field=True))

openflamingo/lib/python3.10/site-packages/sympy/matrices/tests/test_interactions.py

@@ -0,0 +1,77 @@
+"""
+We have a few different kind of Matrices
+Matrix, ImmutableMatrix, MatrixExpr
+
+Here we test the extent to which they cooperate
+"""
+
+from sympy.core.symbol import symbols
+from sympy.matrices import (Matrix, MatrixSymbol, eye, Identity,
+        ImmutableMatrix)
+from sympy.matrices.expressions import MatrixExpr, MatAdd
+from sympy.matrices.matrixbase import classof
+from sympy.testing.pytest import raises
+
+SM = MatrixSymbol('X', 3, 3)
+SV = MatrixSymbol('v', 3, 1)
+MM = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+IM = ImmutableMatrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+meye = eye(3)
+imeye = ImmutableMatrix(eye(3))
+ideye = Identity(3)
+a, b, c = symbols('a,b,c')
+
+
+def test_IM_MM():
+    assert isinstance(MM + IM, ImmutableMatrix)
+    assert isinstance(IM + MM, ImmutableMatrix)
+    assert isinstance(2*IM + MM, ImmutableMatrix)
+    assert MM.equals(IM)
+
+
+def test_ME_MM():
+    assert isinstance(Identity(3) + MM, MatrixExpr)
+    assert isinstance(SM + MM, MatAdd)
+    assert isinstance(MM + SM, MatAdd)
+    assert (Identity(3) + MM)[1, 1] == 6
+
+
+def test_equality():
+    a, b, c = Identity(3), eye(3), ImmutableMatrix(eye(3))
+    for x in [a, b, c]:
+        for y in [a, b, c]:
+            assert x.equals(y)
+
+
+def test_matrix_symbol_MM():
+    X = MatrixSymbol('X', 3, 3)
+    Y = eye(3) + X
+    assert Y[1, 1] == 1 + X[1, 1]
+
+
+def test_matrix_symbol_vector_matrix_multiplication():
+    A = MM * SV
+    B = IM * SV
+    assert A == B
+    C = (SV.T * MM.T).T
+    assert B == C
+    D = (SV.T * IM.T).T
+    assert C == D
+
+
+def test_indexing_interactions():
+    assert (a * IM)[1, 1] == 5*a
+    assert (SM + IM)[1, 1] == SM[1, 1] + IM[1, 1]
+    assert (SM * IM)[1, 1] == SM[1, 0]*IM[0, 1] + SM[1, 1]*IM[1, 1] + \
+        SM[1, 2]*IM[2, 1]
+
+
+def test_classof():
+    A = Matrix(3, 3, range(9))
+    B = ImmutableMatrix(3, 3, range(9))
+    C = MatrixSymbol('C', 3, 3)
+    assert classof(A, A) == Matrix
+    assert classof(B, B) == ImmutableMatrix
+    assert classof(A, B) == ImmutableMatrix
+    assert classof(B, A) == ImmutableMatrix
+    raises(TypeError, lambda: classof(A, C))

openflamingo/lib/python3.10/site-packages/sympy/matrices/tests/test_reductions.py

@@ -0,0 +1,351 @@
+from sympy.core.numbers import I
+from sympy.core.symbol import symbols
+from sympy.testing.pytest import raises
+from sympy.matrices import Matrix, zeros, eye
+from sympy.core.symbol import Symbol
+from sympy.core.numbers import Rational
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.simplify.simplify import simplify
+from sympy.abc import x
+
+
+# Matrix tests
+def test_row_op():
+    e = eye(3)
+
+    raises(ValueError, lambda: e.elementary_row_op("abc"))
+    raises(ValueError, lambda: e.elementary_row_op())
+    raises(ValueError, lambda: e.elementary_row_op('n->kn', row=5, k=5))
+    raises(ValueError, lambda: e.elementary_row_op('n->kn', row=-5, k=5))
+    raises(ValueError, lambda: e.elementary_row_op('n<->m', row1=1, row2=5))
+    raises(ValueError, lambda: e.elementary_row_op('n<->m', row1=5, row2=1))
+    raises(ValueError, lambda: e.elementary_row_op('n<->m', row1=-5, row2=1))
+    raises(ValueError, lambda: e.elementary_row_op('n<->m', row1=1, row2=-5))
+    raises(ValueError, lambda: e.elementary_row_op('n->n+km', row1=1, row2=5, k=5))
+    raises(ValueError, lambda: e.elementary_row_op('n->n+km', row1=5, row2=1, k=5))
+    raises(ValueError, lambda: e.elementary_row_op('n->n+km', row1=-5, row2=1, k=5))
+    raises(ValueError, lambda: e.elementary_row_op('n->n+km', row1=1, row2=-5, k=5))
+    raises(ValueError, lambda: e.elementary_row_op('n->n+km', row1=1, row2=1, k=5))
+
+    # test various ways to set arguments
+    assert e.elementary_row_op("n->kn", 0, 5) == Matrix([[5, 0, 0], [0, 1, 0], [0, 0, 1]])
+    assert e.elementary_row_op("n->kn", 1, 5) == Matrix([[1, 0, 0], [0, 5, 0], [0, 0, 1]])
+    assert e.elementary_row_op("n->kn", row=1, k=5) == Matrix([[1, 0, 0], [0, 5, 0], [0, 0, 1]])
+    assert e.elementary_row_op("n->kn", row1=1, k=5) == Matrix([[1, 0, 0], [0, 5, 0], [0, 0, 1]])
+    assert e.elementary_row_op("n<->m", 0, 1) == Matrix([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
+    assert e.elementary_row_op("n<->m", row1=0, row2=1) == Matrix([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
+    assert e.elementary_row_op("n<->m", row=0, row2=1) == Matrix([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
+    assert e.elementary_row_op("n->n+km", 0, 5, 1) == Matrix([[1, 5, 0], [0, 1, 0], [0, 0, 1]])
+    assert e.elementary_row_op("n->n+km", row=0, k=5, row2=1) == Matrix([[1, 5, 0], [0, 1, 0], [0, 0, 1]])
+    assert e.elementary_row_op("n->n+km", row1=0, k=5, row2=1) == Matrix([[1, 5, 0], [0, 1, 0], [0, 0, 1]])
+
+    # make sure the matrix doesn't change size
+    a = Matrix(2, 3, [0]*6)
+    assert a.elementary_row_op("n->kn", 1, 5) == Matrix(2, 3, [0]*6)
+    assert a.elementary_row_op("n<->m", 0, 1) == Matrix(2, 3, [0]*6)
+    assert a.elementary_row_op("n->n+km", 0, 5, 1) == Matrix(2, 3, [0]*6)
+
+
+def test_col_op():
+    e = eye(3)
+
+    raises(ValueError, lambda: e.elementary_col_op("abc"))
+    raises(ValueError, lambda: e.elementary_col_op())
+    raises(ValueError, lambda: e.elementary_col_op('n->kn', col=5, k=5))
+    raises(ValueError, lambda: e.elementary_col_op('n->kn', col=-5, k=5))
+    raises(ValueError, lambda: e.elementary_col_op('n<->m', col1=1, col2=5))
+    raises(ValueError, lambda: e.elementary_col_op('n<->m', col1=5, col2=1))
+    raises(ValueError, lambda: e.elementary_col_op('n<->m', col1=-5, col2=1))
+    raises(ValueError, lambda: e.elementary_col_op('n<->m', col1=1, col2=-5))
+    raises(ValueError, lambda: e.elementary_col_op('n->n+km', col1=1, col2=5, k=5))
+    raises(ValueError, lambda: e.elementary_col_op('n->n+km', col1=5, col2=1, k=5))
+    raises(ValueError, lambda: e.elementary_col_op('n->n+km', col1=-5, col2=1, k=5))
+    raises(ValueError, lambda: e.elementary_col_op('n->n+km', col1=1, col2=-5, k=5))
+    raises(ValueError, lambda: e.elementary_col_op('n->n+km', col1=1, col2=1, k=5))
+
+    # test various ways to set arguments
+    assert e.elementary_col_op("n->kn", 0, 5) == Matrix([[5, 0, 0], [0, 1, 0], [0, 0, 1]])
+    assert e.elementary_col_op("n->kn", 1, 5) == Matrix([[1, 0, 0], [0, 5, 0], [0, 0, 1]])
+    assert e.elementary_col_op("n->kn", col=1, k=5) == Matrix([[1, 0, 0], [0, 5, 0], [0, 0, 1]])
+    assert e.elementary_col_op("n->kn", col1=1, k=5) == Matrix([[1, 0, 0], [0, 5, 0], [0, 0, 1]])
+    assert e.elementary_col_op("n<->m", 0, 1) == Matrix([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
+    assert e.elementary_col_op("n<->m", col1=0, col2=1) == Matrix([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
+    assert e.elementary_col_op("n<->m", col=0, col2=1) == Matrix([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
+    assert e.elementary_col_op("n->n+km", 0, 5, 1) == Matrix([[1, 0, 0], [5, 1, 0], [0, 0, 1]])
+    assert e.elementary_col_op("n->n+km", col=0, k=5, col2=1) == Matrix([[1, 0, 0], [5, 1, 0], [0, 0, 1]])
+    assert e.elementary_col_op("n->n+km", col1=0, k=5, col2=1) == Matrix([[1, 0, 0], [5, 1, 0], [0, 0, 1]])
+
+    # make sure the matrix doesn't change size
+    a = Matrix(2, 3, [0]*6)
+    assert a.elementary_col_op("n->kn", 1, 5) == Matrix(2, 3, [0]*6)
+    assert a.elementary_col_op("n<->m", 0, 1) == Matrix(2, 3, [0]*6)
+    assert a.elementary_col_op("n->n+km", 0, 5, 1) == Matrix(2, 3, [0]*6)
+
+
+def test_is_echelon():
+    zro = zeros(3)
+    ident = eye(3)
+
+    assert zro.is_echelon
+    assert ident.is_echelon
+
+    a = Matrix(0, 0, [])
+    assert a.is_echelon
+
+    a = Matrix(2, 3, [3, 2, 1, 0, 0, 6])
+    assert a.is_echelon
+
+    a = Matrix(2, 3, [0, 0, 6, 3, 2, 1])
+    assert not a.is_echelon
+
+    x = Symbol('x')
+    a = Matrix(3, 1, [x, 0, 0])
+    assert a.is_echelon
+
+    a = Matrix(3, 1, [x, x, 0])
+    assert not a.is_echelon
+
+    a = Matrix(3, 3, [0, 0, 0, 1, 2, 3, 0, 0, 0])
+    assert not a.is_echelon
+
+
+def test_echelon_form():
+    # echelon form is not unique, but the result
+    # must be row-equivalent to the original matrix
+    # and it must be in echelon form.
+
+    a = zeros(3)
+    e = eye(3)
+
+    # we can assume the zero matrix and the identity matrix shouldn't change
+    assert a.echelon_form() == a
+    assert e.echelon_form() == e
+
+    a = Matrix(0, 0, [])
+    assert a.echelon_form() == a
+
+    a = Matrix(1, 1, [5])
+    assert a.echelon_form() == a
+
+    # now we get to the real tests
+
+    def verify_row_null_space(mat, rows, nulls):
+        for v in nulls:
+            assert all(t.is_zero for t in a_echelon*v)
+        for v in rows:
+            if not all(t.is_zero for t in v):
+                assert not all(t.is_zero for t in a_echelon*v.transpose())
+
+    a = Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
+    nulls = [Matrix([
+                     [ 1],
+                     [-2],
+                     [ 1]])]
+    rows = [a[i, :] for i in range(a.rows)]
+    a_echelon = a.echelon_form()
+    assert a_echelon.is_echelon
+    verify_row_null_space(a, rows, nulls)
+
+
+    a = Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 8])
+    nulls = []
+    rows = [a[i, :] for i in range(a.rows)]
+    a_echelon = a.echelon_form()
+    assert a_echelon.is_echelon
+    verify_row_null_space(a, rows, nulls)
+
+    a = Matrix(3, 3, [2, 1, 3, 0, 0, 0, 2, 1, 3])
+    nulls = [Matrix([
+             [Rational(-1, 2)],
+             [   1],
+             [   0]]),
+             Matrix([
+             [Rational(-3, 2)],
+             [   0],
+             [   1]])]
+    rows = [a[i, :] for i in range(a.rows)]
+    a_echelon = a.echelon_form()
+    assert a_echelon.is_echelon
+    verify_row_null_space(a, rows, nulls)
+
+    # this one requires a row swap
+    a = Matrix(3, 3, [2, 1, 3, 0, 0, 0, 1, 1, 3])
+    nulls = [Matrix([
+             [   0],
+             [  -3],
+             [   1]])]
+    rows = [a[i, :] for i in range(a.rows)]
+    a_echelon = a.echelon_form()
+    assert a_echelon.is_echelon
+    verify_row_null_space(a, rows, nulls)
+
+    a = Matrix(3, 3, [0, 3, 3, 0, 2, 2, 0, 1, 1])
+    nulls = [Matrix([
+             [1],
+             [0],
+             [0]]),
+             Matrix([
+             [ 0],
+             [-1],
+             [ 1]])]
+    rows = [a[i, :] for i in range(a.rows)]
+    a_echelon = a.echelon_form()
+    assert a_echelon.is_echelon
+    verify_row_null_space(a, rows, nulls)
+
+    a = Matrix(2, 3, [2, 2, 3, 3, 3, 0])
+    nulls = [Matrix([
+             [-1],
+             [1],
+             [0]])]
+    rows = [a[i, :] for i in range(a.rows)]
+    a_echelon = a.echelon_form()
+    assert a_echelon.is_echelon
+    verify_row_null_space(a, rows, nulls)
+
+
+def test_rref():
+    e = Matrix(0, 0, [])
+    assert e.rref(pivots=False) == e
+
+    e = Matrix(1, 1, [1])
+    a = Matrix(1, 1, [5])
+    assert e.rref(pivots=False) == a.rref(pivots=False) == e
+
+    a = Matrix(3, 1, [1, 2, 3])
+    assert a.rref(pivots=False) == Matrix([[1], [0], [0]])
+
+    a = Matrix(1, 3, [1, 2, 3])
+    assert a.rref(pivots=False) == Matrix([[1, 2, 3]])
+
+    a = Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
+    assert a.rref(pivots=False) == Matrix([
+                                     [1, 0, -1],
+                                     [0, 1,  2],
+                                     [0, 0,  0]])
+
+    a = Matrix(3, 3, [1, 2, 3, 1, 2, 3, 1, 2, 3])
+    b = Matrix(3, 3, [1, 2, 3, 0, 0, 0, 0, 0, 0])
+    c = Matrix(3, 3, [0, 0, 0, 1, 2, 3, 0, 0, 0])
+    d = Matrix(3, 3, [0, 0, 0, 0, 0, 0, 1, 2, 3])
+    assert a.rref(pivots=False) == \
+            b.rref(pivots=False) == \
+            c.rref(pivots=False) == \
+            d.rref(pivots=False) == b
+
+    e = eye(3)
+    z = zeros(3)
+    assert e.rref(pivots=False) == e
+    assert z.rref(pivots=False) == z
+
+    a = Matrix([
+            [ 0, 0,  1,  2,  2, -5,  3],
+            [-1, 5,  2,  2,  1, -7,  5],
+            [ 0, 0, -2, -3, -3,  8, -5],
+            [-1, 5,  0, -1, -2,  1,  0]])
+    mat, pivot_offsets = a.rref()
+    assert mat == Matrix([
+                     [1, -5, 0, 0, 1,  1, -1],
+                     [0,  0, 1, 0, 0, -1,  1],
+                     [0,  0, 0, 1, 1, -2,  1],
+                     [0,  0, 0, 0, 0,  0,  0]])
+    assert pivot_offsets == (0, 2, 3)
+
+    a = Matrix([[Rational(1, 19),  Rational(1, 5),    2,    3],
+                        [   4,    5,    6,    7],
+                        [   8,    9,   10,   11],
+                        [  12,   13,   14,   15]])
+    assert a.rref(pivots=False) == Matrix([
+                                         [1, 0, 0, Rational(-76, 157)],
+                                         [0, 1, 0,  Rational(-5, 157)],
+                                         [0, 0, 1, Rational(238, 157)],
+                                         [0, 0, 0,       0]])
+
+    x = Symbol('x')
+    a = Matrix(2, 3, [x, 1, 1, sqrt(x), x, 1])
+    for i, j in zip(a.rref(pivots=False),
+            [1, 0, sqrt(x)*(-x + 1)/(-x**Rational(5, 2) + x),
+                0, 1, 1/(sqrt(x) + x + 1)]):
+        assert simplify(i - j).is_zero
+
+
+def test_rref_rhs():
+    a, b, c, d = symbols('a b c d')
+    A = Matrix([[0, 0], [0, 0], [1, 2], [3, 4]])
+    B = Matrix([a, b, c, d])
+    assert A.rref_rhs(B) == (Matrix([
+    [1, 0],
+    [0, 1],
+    [0, 0],
+    [0, 0]]), Matrix([
+    [   -2*c + d],
+    [3*c/2 - d/2],
+    [          a],
+    [          b]]))
+
+
+def test_issue_17827():
+    C = Matrix([
+        [3, 4, -1, 1],
+        [9, 12, -3, 3],
+        [0, 2, 1, 3],
+        [2, 3, 0, -2],
+        [0, 3, 3, -5],
+        [8, 15, 0, 6]
+    ])
+    # Tests for row/col within valid range
+    D = C.elementary_row_op('n<->m', row1=2, row2=5)
+    E = C.elementary_row_op('n->n+km', row1=5, row2=3, k=-4)
+    F = C.elementary_row_op('n->kn', row=5, k=2)
+    assert(D[5, :] == Matrix([[0, 2, 1, 3]]))
+    assert(E[5, :] == Matrix([[0, 3, 0, 14]]))
+    assert(F[5, :] == Matrix([[16, 30, 0, 12]]))
+    # Tests for row/col out of range
+    raises(ValueError, lambda: C.elementary_row_op('n<->m', row1=2, row2=6))
+    raises(ValueError, lambda: C.elementary_row_op('n->kn', row=7, k=2))
+    raises(ValueError, lambda: C.elementary_row_op('n->n+km', row1=-1, row2=5, k=2))
+
+def test_rank():
+    m = Matrix([[1, 2], [x, 1 - 1/x]])
+    assert m.rank() == 2
+    n = Matrix(3, 3, range(1, 10))
+    assert n.rank() == 2
+    p = zeros(3)
+    assert p.rank() == 0
+
+def test_issue_11434():
+    ax, ay, bx, by, cx, cy, dx, dy, ex, ey, t0, t1 = \
+        symbols('a_x a_y b_x b_y c_x c_y d_x d_y e_x e_y t_0 t_1')
+    M = Matrix([[ax, ay, ax*t0, ay*t0, 0],
+                [bx, by, bx*t0, by*t0, 0],
+                [cx, cy, cx*t0, cy*t0, 1],
+                [dx, dy, dx*t0, dy*t0, 1],
+                [ex, ey, 2*ex*t1 - ex*t0, 2*ey*t1 - ey*t0, 0]])
+    assert M.rank() == 4
+
+def test_rank_regression_from_so():
+    # see:
+    # https://stackoverflow.com/questions/19072700/why-does-sympy-give-me-the-wrong-answer-when-i-row-reduce-a-symbolic-matrix
+
+    nu, lamb = symbols('nu, lambda')
+    A = Matrix([[-3*nu,         1,                  0,  0],
+                [ 3*nu, -2*nu - 1,                  2,  0],
+                [    0,      2*nu, (-1*nu) - lamb - 2,  3],
+                [    0,         0,          nu + lamb, -3]])
+    expected_reduced = Matrix([[1, 0, 0, 1/(nu**2*(-lamb - nu))],
+                               [0, 1, 0,    3/(nu*(-lamb - nu))],
+                               [0, 0, 1,         3/(-lamb - nu)],
+                               [0, 0, 0,                      0]])
+    expected_pivots = (0, 1, 2)
+
+    reduced, pivots = A.rref()
+
+    assert simplify(expected_reduced - reduced) == zeros(*A.shape)
+    assert pivots == expected_pivots
+
+def test_issue_15872():
+    A = Matrix([[1, 1, 1, 0], [-2, -1, 0, -1], [0, 0, -1, -1], [0, 0, 2, 1]])
+    B = A - Matrix.eye(4) * I
+    assert B.rank() == 3
+    assert (B**2).rank() == 2
+    assert (B**3).rank() == 2

openflamingo/lib/python3.10/site-packages/sympy/matrices/tests/test_repmatrix.py

@@ -0,0 +1,49 @@
+from sympy.testing.pytest import raises
+from sympy.matrices.exceptions import NonSquareMatrixError, NonInvertibleMatrixError
+
+from sympy import Matrix, Rational
+
+
+def test_lll():
+    A = Matrix([[1, 0, 0, 0, -20160],
+                [0, 1, 0, 0, 33768],
+                [0, 0, 1, 0, 39578],
+                [0, 0, 0, 1, 47757]])
+    L = Matrix([[ 10, -3,  -2,  8,  -4],
+                [  3, -9,   8,  1, -11],
+                [ -3, 13,  -9, -3,  -9],
+                [-12, -7, -11,  9,  -1]])
+    T = Matrix([[ 10, -3,  -2,  8],
+                [  3, -9,   8,  1],
+                [ -3, 13,  -9, -3],
+                [-12, -7, -11,  9]])
+    assert A.lll() == L
+    assert A.lll_transform() == (L, T)
+    assert T * A == L
+
+
+def test_matrix_inv_mod():
+    A = Matrix(2, 1, [1, 0])
+    raises(NonSquareMatrixError, lambda: A.inv_mod(2))
+    A = Matrix(2, 2, [1, 0, 0, 0])
+    raises(NonInvertibleMatrixError, lambda: A.inv_mod(2))
+    A = Matrix(2, 2, [1, 2, 3, 4])
+    Ai = Matrix(2, 2, [1, 1, 0, 1])
+    assert A.inv_mod(3) == Ai
+    A = Matrix(2, 2, [1, 0, 0, 1])
+    assert A.inv_mod(2) == A
+    A = Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])
+    raises(NonInvertibleMatrixError, lambda: A.inv_mod(5))
+    A = Matrix(3, 3, [5, 1, 3, 2, 6, 0, 2, 1, 1])
+    Ai = Matrix(3, 3, [6, 8, 0, 1, 5, 6, 5, 6, 4])
+    assert A.inv_mod(9) == Ai
+    A = Matrix(3, 3, [1, 6, -3, 4, 1, -5, 3, -5, 5])
+    Ai = Matrix(3, 3, [4, 3, 3, 1, 2, 5, 1, 5, 1])
+    assert A.inv_mod(6) == Ai
+    A = Matrix(3, 3, [1, 6, 1, 4, 1, 5, 3, 2, 5])
+    Ai = Matrix(3, 3, [6, 0, 3, 6, 6, 4, 1, 6, 1])
+    assert A.inv_mod(7) == Ai
+    A = Matrix([[1, 2], [3, Rational(3,4)]])
+    raises(ValueError, lambda: A.inv_mod(2))
+    A = Matrix([[1, 2], [3, 4]])
+    raises(TypeError, lambda: A.inv_mod(Rational(1, 2)))

openflamingo/lib/python3.10/site-packages/sympy/matrices/tests/test_solvers.py

@@ -0,0 +1,601 @@
+import pytest
+from sympy.core.function import expand_mul
+from sympy.core.numbers import (I, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.simplify.simplify import simplify
+from sympy.matrices.exceptions import (ShapeError, NonSquareMatrixError)
+from sympy.matrices import (
+    ImmutableMatrix, Matrix, eye, ones, ImmutableDenseMatrix, dotprodsimp)
+from sympy.matrices.determinant import _det_laplace
+from sympy.testing.pytest import raises
+from sympy.matrices.exceptions import NonInvertibleMatrixError
+from sympy.polys.matrices.exceptions import DMShapeError
+from sympy.solvers.solveset import linsolve
+from sympy.abc import x, y
+
+def test_issue_17247_expression_blowup_29():
+    M = Matrix(S('''[
+        [             -3/4,       45/32 - 37*I/16,                   0,                     0],
+        [-149/64 + 49*I/32, -177/128 - 1369*I/128,                   0, -2063/256 + 541*I/128],
+        [                0,         9/4 + 55*I/16, 2473/256 + 137*I/64,                     0],
+        [                0,                     0,                   0, -177/128 - 1369*I/128]]'''))
+    with dotprodsimp(True):
+        assert M.gauss_jordan_solve(ones(4, 1)) == (Matrix(S('''[
+            [                          -32549314808672/3306971225785 - 17397006745216*I/3306971225785],
+            [                               67439348256/3306971225785 - 9167503335872*I/3306971225785],
+            [-15091965363354518272/21217636514687010905 + 16890163109293858304*I/21217636514687010905],
+            [                                                          -11328/952745 + 87616*I/952745]]''')), Matrix(0, 1, []))
+
+def test_issue_17247_expression_blowup_30():
+    M = Matrix(S('''[
+        [             -3/4,       45/32 - 37*I/16,                   0,                     0],
+        [-149/64 + 49*I/32, -177/128 - 1369*I/128,                   0, -2063/256 + 541*I/128],
+        [                0,         9/4 + 55*I/16, 2473/256 + 137*I/64,                     0],
+        [                0,                     0,                   0, -177/128 - 1369*I/128]]'''))
+    with dotprodsimp(True):
+        assert M.cholesky_solve(ones(4, 1)) == Matrix(S('''[
+            [                          -32549314808672/3306971225785 - 17397006745216*I/3306971225785],
+            [                               67439348256/3306971225785 - 9167503335872*I/3306971225785],
+            [-15091965363354518272/21217636514687010905 + 16890163109293858304*I/21217636514687010905],
+            [                                                          -11328/952745 + 87616*I/952745]]'''))
+
+# @XFAIL # This calculation hangs with dotprodsimp.
+# def test_issue_17247_expression_blowup_31():
+#     M = Matrix([
+#         [x + 1, 1 - x,     0,     0],
+#         [1 - x, x + 1,     0, x + 1],
+#         [    0, 1 - x, x + 1,     0],
+#         [    0,     0,     0, x + 1]])
+#     with dotprodsimp(True):
+#         assert M.LDLsolve(ones(4, 1)) == Matrix([
+#             [(x + 1)/(4*x)],
+#             [(x - 1)/(4*x)],
+#             [(x + 1)/(4*x)],
+#             [    1/(x + 1)]])
+
+
+def test_LUsolve_iszerofunc():
+    # taken from https://github.com/sympy/sympy/issues/24679
+
+    M = Matrix([[(x + 1)**2 - (x**2 + 2*x + 1), x], [x, 0]])
+    b = Matrix([1, 1])
+    is_zero_func = lambda e: False if e._random() else True
+
+    x_exp = Matrix([1/x, (1-(-x**2 - 2*x + (x+1)**2 - 1)/x)/x])
+
+    assert (x_exp - M.LUsolve(b, iszerofunc=is_zero_func)) == Matrix([0, 0])
+
+
+def test_issue_17247_expression_blowup_32():
+    M = Matrix([
+        [x + 1, 1 - x,     0,     0],
+        [1 - x, x + 1,     0, x + 1],
+        [    0, 1 - x, x + 1,     0],
+        [    0,     0,     0, x + 1]])
+    with dotprodsimp(True):
+        assert M.LUsolve(ones(4, 1)) == Matrix([
+            [(x + 1)/(4*x)],
+            [(x - 1)/(4*x)],
+            [(x + 1)/(4*x)],
+            [    1/(x + 1)]])
+
+def test_LUsolve():
+    A = Matrix([[2, 3, 5],
+                [3, 6, 2],
+                [8, 3, 6]])
+    x = Matrix(3, 1, [3, 7, 5])
+    b = A*x
+    soln = A.LUsolve(b)
+    assert soln == x
+    A = Matrix([[0, -1, 2],
+                [5, 10, 7],
+                [8,  3, 4]])
+    x = Matrix(3, 1, [-1, 2, 5])
+    b = A*x
+    soln = A.LUsolve(b)
+    assert soln == x
+    A = Matrix([[2, 1], [1, 0], [1, 0]])   # issue 14548
+    b = Matrix([3, 1, 1])
+    assert A.LUsolve(b) == Matrix([1, 1])
+    b = Matrix([3, 1, 2])                  # inconsistent
+    raises(ValueError, lambda: A.LUsolve(b))
+    A = Matrix([[0, -1, 2],
+                [5, 10, 7],
+                [8,  3, 4],
+                [2, 3, 5],
+                [3, 6, 2],
+                [8, 3, 6]])
+    x = Matrix([2, 1, -4])
+    b = A*x
+    soln = A.LUsolve(b)
+    assert soln == x
+    A = Matrix([[0, -1, 2], [5, 10, 7]])  # underdetermined
+    x = Matrix([-1, 2, 0])
+    b = A*x
+    raises(NotImplementedError, lambda: A.LUsolve(b))
+
+    A = Matrix(4, 4, lambda i, j: 1/(i+j+1) if i != 3 else 0)
+    b = Matrix.zeros(4, 1)
+    raises(NonInvertibleMatrixError, lambda: A.LUsolve(b))
+
+
+def test_QRsolve():
+    A = Matrix([[2, 3, 5],
+                [3, 6, 2],
+                [8, 3, 6]])
+    x = Matrix(3, 1, [3, 7, 5])
+    b = A*x
+    soln = A.QRsolve(b)
+    assert soln == x
+    x = Matrix([[1, 2], [3, 4], [5, 6]])
+    b = A*x
+    soln = A.QRsolve(b)
+    assert soln == x
+
+    A = Matrix([[0, -1, 2],
+                [5, 10, 7],
+                [8,  3, 4]])
+    x = Matrix(3, 1, [-1, 2, 5])
+    b = A*x
+    soln = A.QRsolve(b)
+    assert soln == x
+    x = Matrix([[7, 8], [9, 10], [11, 12]])
+    b = A*x
+    soln = A.QRsolve(b)
+    assert soln == x
+
+def test_errors():
+    raises(ShapeError, lambda: Matrix([1]).LUsolve(Matrix([[1, 2], [3, 4]])))
+
+def test_cholesky_solve():
+    A = Matrix([[2, 3, 5],
+                [3, 6, 2],
+                [8, 3, 6]])
+    x = Matrix(3, 1, [3, 7, 5])
+    b = A*x
+    soln = A.cholesky_solve(b)
+    assert soln == x
+    A = Matrix([[0, -1, 2],
+                [5, 10, 7],
+                [8,  3, 4]])
+    x = Matrix(3, 1, [-1, 2, 5])
+    b = A*x
+    soln = A.cholesky_solve(b)
+    assert soln == x
+    A = Matrix(((1, 5), (5, 1)))
+    x = Matrix((4, -3))
+    b = A*x
+    soln = A.cholesky_solve(b)
+    assert soln == x
+    A = Matrix(((9, 3*I), (-3*I, 5)))
+    x = Matrix((-2, 1))
+    b = A*x
+    soln = A.cholesky_solve(b)
+    assert expand_mul(soln) == x
+    A = Matrix(((9*I, 3), (-3 + I, 5)))
+    x = Matrix((2 + 3*I, -1))
+    b = A*x
+    soln = A.cholesky_solve(b)
+    assert expand_mul(soln) == x
+    a00, a01, a11, b0, b1 = symbols('a00, a01, a11, b0, b1')
+    A = Matrix(((a00, a01), (a01, a11)))
+    b = Matrix((b0, b1))
+    x = A.cholesky_solve(b)
+    assert simplify(A*x) == b
+
+
+def test_LDLsolve():
+    A = Matrix([[2, 3, 5],
+                [3, 6, 2],
+                [8, 3, 6]])
+    x = Matrix(3, 1, [3, 7, 5])
+    b = A*x
+    soln = A.LDLsolve(b)
+    assert soln == x
+
+    A = Matrix([[0, -1, 2],
+                [5, 10, 7],
+                [8,  3, 4]])
+    x = Matrix(3, 1, [-1, 2, 5])
+    b = A*x
+    soln = A.LDLsolve(b)
+    assert soln == x
+
+    A = Matrix(((9, 3*I), (-3*I, 5)))
+    x = Matrix((-2, 1))
+    b = A*x
+    soln = A.LDLsolve(b)
+    assert expand_mul(soln) == x
+
+    A = Matrix(((9*I, 3), (-3 + I, 5)))
+    x = Matrix((2 + 3*I, -1))
+    b = A*x
+    soln = A.LDLsolve(b)
+    assert expand_mul(soln) == x
+
+    A = Matrix(((9, 3), (3, 9)))
+    x = Matrix((1, 1))
+    b = A * x
+    soln = A.LDLsolve(b)
+    assert expand_mul(soln) == x
+
+    A = Matrix([[-5, -3, -4], [-3, -7, 7]])
+    x = Matrix([[8], [7], [-2]])
+    b = A * x
+    raises(NotImplementedError, lambda: A.LDLsolve(b))
+
+
+def test_lower_triangular_solve():
+
+    raises(NonSquareMatrixError,
+        lambda: Matrix([1, 0]).lower_triangular_solve(Matrix([0, 1])))
+    raises(ShapeError,
+        lambda: Matrix([[1, 0], [0, 1]]).lower_triangular_solve(Matrix([1])))
+    raises(ValueError,
+        lambda: Matrix([[2, 1], [1, 2]]).lower_triangular_solve(
+            Matrix([[1, 0], [0, 1]])))
+
+    A = Matrix([[1, 0], [0, 1]])
+    B = Matrix([[x, y], [y, x]])
+    C = Matrix([[4, 8], [2, 9]])
+
+    assert A.lower_triangular_solve(B) == B
+    assert A.lower_triangular_solve(C) == C
+
+
+def test_upper_triangular_solve():
+
+    raises(NonSquareMatrixError,
+        lambda: Matrix([1, 0]).upper_triangular_solve(Matrix([0, 1])))
+    raises(ShapeError,
+        lambda: Matrix([[1, 0], [0, 1]]).upper_triangular_solve(Matrix([1])))
+    raises(TypeError,
+        lambda: Matrix([[2, 1], [1, 2]]).upper_triangular_solve(
+            Matrix([[1, 0], [0, 1]])))
+
+    A = Matrix([[1, 0], [0, 1]])
+    B = Matrix([[x, y], [y, x]])
+    C = Matrix([[2, 4], [3, 8]])
+
+    assert A.upper_triangular_solve(B) == B
+    assert A.upper_triangular_solve(C) == C
+
+
+def test_diagonal_solve():
+    raises(TypeError, lambda: Matrix([1, 1]).diagonal_solve(Matrix([1])))
+    A = Matrix([[1, 0], [0, 1]])*2
+    B = Matrix([[x, y], [y, x]])
+    assert A.diagonal_solve(B) == B/2
+
+    A = Matrix([[1, 0], [1, 2]])
+    raises(TypeError, lambda: A.diagonal_solve(B))
+
+def test_pinv_solve():
+    # Fully determined system (unique result, identical to other solvers).
+    A = Matrix([[1, 5], [7, 9]])
+    B = Matrix([12, 13])
+    assert A.pinv_solve(B) == A.cholesky_solve(B)
+    assert A.pinv_solve(B) == A.LDLsolve(B)
+    assert A.pinv_solve(B) == Matrix([sympify('-43/26'), sympify('71/26')])
+    assert A * A.pinv() * B == B
+    # Fully determined, with two-dimensional B matrix.
+    B = Matrix([[12, 13, 14], [15, 16, 17]])
+    assert A.pinv_solve(B) == A.cholesky_solve(B)
+    assert A.pinv_solve(B) == A.LDLsolve(B)
+    assert A.pinv_solve(B) == Matrix([[-33, -37, -41], [69, 75, 81]]) / 26
+    assert A * A.pinv() * B == B
+    # Underdetermined system (infinite results).
+    A = Matrix([[1, 0, 1], [0, 1, 1]])
+    B = Matrix([5, 7])
+    solution = A.pinv_solve(B)
+    w = {}
+    for s in solution.atoms(Symbol):
+        # Extract dummy symbols used in the solution.
+        w[s.name] = s
+    assert solution == Matrix([[w['w0_0']/3 + w['w1_0']/3 - w['w2_0']/3 + 1],
+                               [w['w0_0']/3 + w['w1_0']/3 - w['w2_0']/3 + 3],
+                               [-w['w0_0']/3 - w['w1_0']/3 + w['w2_0']/3 + 4]])
+    assert A * A.pinv() * B == B
+    # Overdetermined system (least squares results).
+    A = Matrix([[1, 0], [0, 0], [0, 1]])
+    B = Matrix([3, 2, 1])
+    assert A.pinv_solve(B) == Matrix([3, 1])
+    # Proof the solution is not exact.
+    assert A * A.pinv() * B != B
+
+def test_pinv_rank_deficient():
+    # Test the four properties of the pseudoinverse for various matrices.
+    As = [Matrix([[1, 1, 1], [2, 2, 2]]),
+          Matrix([[1, 0], [0, 0]]),
+          Matrix([[1, 2], [2, 4], [3, 6]])]
+
+    for A in As:
+        A_pinv = A.pinv(method="RD")
+        AAp = A * A_pinv
+        ApA = A_pinv * A
+        assert simplify(AAp * A) == A
+        assert simplify(ApA * A_pinv) == A_pinv
+        assert AAp.H == AAp
+        assert ApA.H == ApA
+
+    for A in As:
+        A_pinv = A.pinv(method="ED")
+        AAp = A * A_pinv
+        ApA = A_pinv * A
+        assert simplify(AAp * A) == A
+        assert simplify(ApA * A_pinv) == A_pinv
+        assert AAp.H == AAp
+        assert ApA.H == ApA
+
+    # Test solving with rank-deficient matrices.
+    A = Matrix([[1, 0], [0, 0]])
+    # Exact, non-unique solution.
+    B = Matrix([3, 0])
+    solution = A.pinv_solve(B)
+    w1 = solution.atoms(Symbol).pop()
+    assert w1.name == 'w1_0'
+    assert solution == Matrix([3, w1])
+    assert A * A.pinv() * B == B
+    # Least squares, non-unique solution.
+    B = Matrix([3, 1])
+    solution = A.pinv_solve(B)
+    w1 = solution.atoms(Symbol).pop()
+    assert w1.name == 'w1_0'
+    assert solution == Matrix([3, w1])
+    assert A * A.pinv() * B != B
+
+def test_gauss_jordan_solve():
+
+    # Square, full rank, unique solution
+    A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 10]])
+    b = Matrix([3, 6, 9])
+    sol, params = A.gauss_jordan_solve(b)
+    assert sol == Matrix([[-1], [2], [0]])
+    assert params == Matrix(0, 1, [])
+
+    # Square, full rank, unique solution, B has more columns than rows
+    A = eye(3)
+    B = Matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
+    sol, params = A.gauss_jordan_solve(B)
+    assert sol == B
+    assert params == Matrix(0, 4, [])
+
+    # Square, reduced rank, parametrized solution
+    A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    b = Matrix([3, 6, 9])
+    sol, params, freevar = A.gauss_jordan_solve(b, freevar=True)
+    w = {}
+    for s in sol.atoms(Symbol):
+        # Extract dummy symbols used in the solution.
+        w[s.name] = s
+    assert sol == Matrix([[w['tau0'] - 1], [-2*w['tau0'] + 2], [w['tau0']]])
+    assert params == Matrix([[w['tau0']]])
+    assert freevar == [2]
+
+    # Square, reduced rank, parametrized solution, B has two columns
+    A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    B = Matrix([[3, 4], [6, 8], [9, 12]])
+    sol, params, freevar = A.gauss_jordan_solve(B, freevar=True)
+    w = {}
+    for s in sol.atoms(Symbol):
+        # Extract dummy symbols used in the solution.
+        w[s.name] = s
+    assert sol == Matrix([[w['tau0'] - 1, w['tau1'] - Rational(4, 3)],
+                          [-2*w['tau0'] + 2, -2*w['tau1'] + Rational(8, 3)],
+                          [w['tau0'], w['tau1']],])
+    assert params == Matrix([[w['tau0'], w['tau1']]])
+    assert freevar == [2]
+
+    # Square, reduced rank, parametrized solution
+    A = Matrix([[1, 2, 3], [2, 4, 6], [3, 6, 9]])
+    b = Matrix([0, 0, 0])
+    sol, params = A.gauss_jordan_solve(b)
+    w = {}
+    for s in sol.atoms(Symbol):
+        w[s.name] = s
+    assert sol == Matrix([[-2*w['tau0'] - 3*w['tau1']],
+                         [w['tau0']], [w['tau1']]])
+    assert params == Matrix([[w['tau0']], [w['tau1']]])
+
+    # Square, reduced rank, parametrized solution
+    A = Matrix([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
+    b = Matrix([0, 0, 0])
+    sol, params = A.gauss_jordan_solve(b)
+    w = {}
+    for s in sol.atoms(Symbol):
+        w[s.name] = s
+    assert sol == Matrix([[w['tau0']], [w['tau1']], [w['tau2']]])
+    assert params == Matrix([[w['tau0']], [w['tau1']], [w['tau2']]])
+
+    # Square, reduced rank, no solution
+    A = Matrix([[1, 2, 3], [2, 4, 6], [3, 6, 9]])
+    b = Matrix([0, 0, 1])
+    raises(ValueError, lambda: A.gauss_jordan_solve(b))
+
+    # Rectangular, tall, full rank, unique solution
+    A = Matrix([[1, 5, 3], [2, 1, 6], [1, 7, 9], [1, 4, 3]])
+    b = Matrix([0, 0, 1, 0])
+    sol, params = A.gauss_jordan_solve(b)
+    assert sol == Matrix([[Rational(-1, 2)], [0], [Rational(1, 6)]])
+    assert params == Matrix(0, 1, [])
+
+    # Rectangular, tall, full rank, unique solution, B has less columns than rows
+    A = Matrix([[1, 5, 3], [2, 1, 6], [1, 7, 9], [1, 4, 3]])
+    B = Matrix([[0,0], [0, 0], [1, 2], [0, 0]])
+    sol, params = A.gauss_jordan_solve(B)
+    assert sol == Matrix([[Rational(-1, 2), Rational(-2, 2)], [0, 0], [Rational(1, 6), Rational(2, 6)]])
+    assert params == Matrix(0, 2, [])
+
+    # Rectangular, tall, full rank, no solution
+    A = Matrix([[1, 5, 3], [2, 1, 6], [1, 7, 9], [1, 4, 3]])
+    b = Matrix([0, 0, 0, 1])
+    raises(ValueError, lambda: A.gauss_jordan_solve(b))
+
+    # Rectangular, tall, full rank, no solution, B has two columns (2nd has no solution)
+    A = Matrix([[1, 5, 3], [2, 1, 6], [1, 7, 9], [1, 4, 3]])
+    B = Matrix([[0,0], [0, 0], [1, 0], [0, 1]])
+    raises(ValueError, lambda: A.gauss_jordan_solve(B))
+
+    # Rectangular, tall, full rank, no solution, B has two columns (1st has no solution)
+    A = Matrix([[1, 5, 3], [2, 1, 6], [1, 7, 9], [1, 4, 3]])
+    B = Matrix([[0,0], [0, 0], [0, 1], [1, 0]])
+    raises(ValueError, lambda: A.gauss_jordan_solve(B))
+
+    # Rectangular, tall, reduced rank, parametrized solution
+    A = Matrix([[1, 5, 3], [2, 10, 6], [3, 15, 9], [1, 4, 3]])
+    b = Matrix([0, 0, 0, 1])
+    sol, params = A.gauss_jordan_solve(b)
+    w = {}
+    for s in sol.atoms(Symbol):
+        w[s.name] = s
+    assert sol == Matrix([[-3*w['tau0'] + 5], [-1], [w['tau0']]])
+    assert params == Matrix([[w['tau0']]])
+
+    # Rectangular, tall, reduced rank, no solution
+    A = Matrix([[1, 5, 3], [2, 10, 6], [3, 15, 9], [1, 4, 3]])
+    b = Matrix([0, 0, 1, 1])
+    raises(ValueError, lambda: A.gauss_jordan_solve(b))
+
+    # Rectangular, wide, full rank, parametrized solution
+    A = Matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 1, 12]])
+    b = Matrix([1, 1, 1])
+    sol, params = A.gauss_jordan_solve(b)
+    w = {}
+    for s in sol.atoms(Symbol):
+        w[s.name] = s
+    assert sol == Matrix([[2*w['tau0'] - 1], [-3*w['tau0'] + 1], [0],
+                         [w['tau0']]])
+    assert params == Matrix([[w['tau0']]])
+
+    # Rectangular, wide, reduced rank, parametrized solution
+    A = Matrix([[1, 2, 3, 4], [5, 6, 7, 8], [2, 4, 6, 8]])
+    b = Matrix([0, 1, 0])
+    sol, params = A.gauss_jordan_solve(b)
+    w = {}
+    for s in sol.atoms(Symbol):
+        w[s.name] = s
+    assert sol == Matrix([[w['tau0'] + 2*w['tau1'] + S.Half],
+                         [-2*w['tau0'] - 3*w['tau1'] - Rational(1, 4)],
+                         [w['tau0']], [w['tau1']]])
+    assert params == Matrix([[w['tau0']], [w['tau1']]])
+    # watch out for clashing symbols
+    x0, x1, x2, _x0 = symbols('_tau0 _tau1 _tau2 tau1')
+    M = Matrix([[0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, _x0]])
+    A = M[:, :-1]
+    b = M[:, -1:]
+    sol, params = A.gauss_jordan_solve(b)
+    assert params == Matrix(3, 1, [x0, x1, x2])
+    assert sol == Matrix(5, 1, [x0, 0, x1, _x0, x2])
+
+    # Rectangular, wide, reduced rank, no solution
+    A = Matrix([[1, 2, 3, 4], [5, 6, 7, 8], [2, 4, 6, 8]])
+    b = Matrix([1, 1, 1])
+    raises(ValueError, lambda: A.gauss_jordan_solve(b))
+
+    # Test for immutable matrix
+    A = ImmutableMatrix([[1, 0], [0, 1]])
+    B = ImmutableMatrix([1, 2])
+    sol, params = A.gauss_jordan_solve(B)
+    assert sol == ImmutableMatrix([1, 2])
+    assert params == ImmutableMatrix(0, 1, [])
+    assert sol.__class__ == ImmutableDenseMatrix
+    assert params.__class__ == ImmutableDenseMatrix
+
+    # Test placement of free variables
+    A = Matrix([[1, 0, 0, 0], [0, 0, 0, 1]])
+    b = Matrix([1, 1])
+    sol, params = A.gauss_jordan_solve(b)
+    w = {}
+    for s in sol.atoms(Symbol):
+        w[s.name] = s
+    assert sol == Matrix([[1], [w['tau0']], [w['tau1']], [1]])
+    assert params == Matrix([[w['tau0']], [w['tau1']]])
+
+
+def test_linsolve_underdetermined_AND_gauss_jordan_solve():
+    #Test placement of free variables as per issue 19815
+    A = Matrix([[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+                [0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
+                [0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0],
+                [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
+                [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1]])
+    B  = Matrix([1, 2, 1, 1, 1, 1, 1, 2])
+    sol, params = A.gauss_jordan_solve(B)
+    w = {}
+    for s in sol.atoms(Symbol):
+        w[s.name] = s
+    assert params == Matrix([[w['tau0']], [w['tau1']], [w['tau2']],
+                             [w['tau3']], [w['tau4']], [w['tau5']]])
+    assert sol == Matrix([[1 - 1*w['tau2']],
+                          [w['tau2']],
+                          [1 - 1*w['tau0'] + w['tau1']],
+                          [w['tau0']],
+                          [w['tau3'] + w['tau4']],
+                          [-1*w['tau3'] - 1*w['tau4'] - 1*w['tau1']],
+                          [1 - 1*w['tau2']],
+                          [w['tau1']],
+                          [w['tau2']],
+                          [w['tau3']],
+                          [w['tau4']],
+                          [1 - 1*w['tau5']],
+                          [w['tau5']],
+                          [1]])
+
+    from sympy.abc import j,f
+    # https://github.com/sympy/sympy/issues/20046
+    A = Matrix([
+    [1,  1, 1,  1, 1,  1, 1,  1,  1],
+    [0, -1, 0, -1, 0, -1, 0, -1, -j],
+    [0,  0, 0,  0, 1,  1, 1,  1,  f]
+    ])
+
+    sol_1=Matrix(list(linsolve(A))[0])
+
+    tau0, tau1, tau2, tau3, tau4 = symbols('tau:5')
+
+    assert sol_1 == Matrix([[-f - j - tau0 + tau2 + tau4 + 1],
+                          [j - tau1 - tau2 - tau4],
+                          [tau0],
+                          [tau1],
+                          [f - tau2 - tau3 - tau4],
+                          [tau2],
+                          [tau3],
+                          [tau4]])
+
+    # https://github.com/sympy/sympy/issues/19815
+    sol_2 = A[:, : -1 ] * sol_1 - A[:, -1 ]
+    assert sol_2 == Matrix([[0], [0], [0]])
+
+
+@pytest.mark.parametrize("det_method", ["bird", "laplace"])
+@pytest.mark.parametrize("M, rhs", [
+    (Matrix([[2, 3, 5], [3, 6, 2], [8, 3, 6]]), Matrix(3, 1, [3, 7, 5])),
+    (Matrix([[2, 3, 5], [3, 6, 2], [8, 3, 6]]),
+     Matrix([[1, 2], [3, 4], [5, 6]])),
+    (Matrix(2, 2, symbols("a:4")), Matrix(2, 1, symbols("b:2"))),
+])
+def test_cramer_solve(det_method, M, rhs):
+    assert simplify(M.cramer_solve(rhs, det_method=det_method) - M.LUsolve(rhs)
+                    ) == Matrix.zeros(M.rows, rhs.cols)
+
+
+@pytest.mark.parametrize("det_method, error", [
+    ("bird", DMShapeError), (_det_laplace, NonSquareMatrixError)])
+def test_cramer_solve_errors(det_method, error):
+    # Non-square matrix
+    A = Matrix([[0, -1, 2], [5, 10, 7]])
+    b = Matrix([-2, 15])
+    raises(error, lambda: A.cramer_solve(b, det_method=det_method))
+
+
+def test_solve():
+    A = Matrix([[1,2], [2,4]])
+    b = Matrix([[3], [4]])
+    raises(ValueError, lambda: A.solve(b)) #no solution
+    b = Matrix([[ 4], [8]])
+    raises(ValueError, lambda: A.solve(b)) #infinite solution

openflamingo/lib/python3.10/site-packages/sympy/matrices/tests/test_sparsetools.py

@@ -0,0 +1,132 @@
+from sympy.matrices.sparsetools import _doktocsr, _csrtodok, banded
+from sympy.matrices.dense import (Matrix, eye, ones, zeros)
+from sympy.matrices import SparseMatrix
+from sympy.testing.pytest import raises
+
+
+def test_doktocsr():
+    a = SparseMatrix([[1, 2, 0, 0], [0, 3, 9, 0], [0, 1, 4, 0]])
+    b = SparseMatrix(4, 6, [10, 20, 0, 0, 0, 0, 0, 30, 0, 40, 0, 0, 0, 0, 50,
+        60, 70, 0, 0, 0, 0, 0, 0, 80])
+    c = SparseMatrix(4, 4, [0, 0, 0, 0, 0, 12, 0, 2, 15, 0, 12, 0, 0, 0, 0, 4])
+    d = SparseMatrix(10, 10, {(1, 1): 12, (3, 5): 7, (7, 8): 12})
+    e = SparseMatrix([[0, 0, 0], [1, 0, 2], [3, 0, 0]])
+    f = SparseMatrix(7, 8, {(2, 3): 5, (4, 5):12})
+    assert _doktocsr(a) == [[1, 2, 3, 9, 1, 4], [0, 1, 1, 2, 1, 2],
+        [0, 2, 4, 6], [3, 4]]
+    assert _doktocsr(b) == [[10, 20, 30, 40, 50, 60, 70, 80],
+        [0, 1, 1, 3, 2, 3, 4, 5], [0, 2, 4, 7, 8], [4, 6]]
+    assert _doktocsr(c) == [[12, 2, 15, 12, 4], [1, 3, 0, 2, 3],
+        [0, 0, 2, 4, 5], [4, 4]]
+    assert _doktocsr(d) == [[12, 7, 12], [1, 5, 8],
+        [0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3], [10, 10]]
+    assert _doktocsr(e) == [[1, 2, 3], [0, 2, 0], [0, 0, 2, 3], [3, 3]]
+    assert _doktocsr(f) == [[5, 12], [3, 5], [0, 0, 0, 1, 1, 2, 2, 2], [7, 8]]
+
+
+def test_csrtodok():
+    h = [[5, 7, 5], [2, 1, 3], [0, 1, 1, 3], [3, 4]]
+    g = [[12, 5, 4], [2, 4, 2], [0, 1, 2, 3], [3, 7]]
+    i = [[1, 3, 12], [0, 2, 4], [0, 2, 3], [2, 5]]
+    j = [[11, 15, 12, 15], [2, 4, 1, 2], [0, 1, 1, 2, 3, 4], [5, 8]]
+    k = [[1, 3], [2, 1], [0, 1, 1, 2], [3, 3]]
+    m = _csrtodok(h)
+    assert isinstance(m, SparseMatrix)
+    assert m == SparseMatrix(3, 4,
+        {(0, 2): 5, (2, 1): 7, (2, 3): 5})
+    assert _csrtodok(g) == SparseMatrix(3, 7,
+        {(0, 2): 12, (1, 4): 5, (2, 2): 4})
+    assert _csrtodok(i) == SparseMatrix([[1, 0, 3, 0, 0], [0, 0, 0, 0, 12]])
+    assert _csrtodok(j) == SparseMatrix(5, 8,
+        {(0, 2): 11, (2, 4): 15, (3, 1): 12, (4, 2): 15})
+    assert _csrtodok(k) == SparseMatrix(3, 3, {(0, 2): 1, (2, 1): 3})
+
+
+def test_banded():
+    raises(TypeError, lambda: banded())
+    raises(TypeError, lambda: banded(1))
+    raises(TypeError, lambda: banded(1, 2))
+    raises(TypeError, lambda: banded(1, 2, 3))
+    raises(TypeError, lambda: banded(1, 2, 3, 4))
+    raises(ValueError, lambda: banded({0: (1, 2)}, rows=1))
+    raises(ValueError, lambda: banded({0: (1, 2)}, cols=1))
+    raises(ValueError, lambda: banded(1, {0: (1, 2)}))
+    raises(ValueError, lambda: banded(2, 1, {0: (1, 2)}))
+    raises(ValueError, lambda: banded(1, 2, {0: (1, 2)}))
+
+    assert isinstance(banded(2, 4, {}), SparseMatrix)
+    assert banded(2, 4, {}) == zeros(2, 4)
+    assert banded({0: 0, 1: 0}) == zeros(0)
+    assert banded({0: Matrix([1, 2])}) == Matrix([1, 2])
+    assert banded({1: [1, 2, 3, 0], -1: [4, 5, 6]}) == \
+        banded({1: (1, 2, 3), -1: (4, 5, 6)}) == \
+        Matrix([
+        [0, 1, 0, 0],
+        [4, 0, 2, 0],
+        [0, 5, 0, 3],
+        [0, 0, 6, 0]])
+    assert banded(3, 4, {-1: 1, 0: 2, 1: 3}) == \
+        Matrix([
+        [2, 3, 0, 0],
+        [1, 2, 3, 0],
+        [0, 1, 2, 3]])
+    s = lambda d: (1 + d)**2
+    assert banded(5, {0: s, 2: s}) == \
+        Matrix([
+        [1, 0, 1,  0,  0],
+        [0, 4, 0,  4,  0],
+        [0, 0, 9,  0,  9],
+        [0, 0, 0, 16,  0],
+        [0, 0, 0,  0, 25]])
+    assert banded(2, {0: 1}) == \
+        Matrix([
+        [1, 0],
+        [0, 1]])
+    assert banded(2, 3, {0: 1}) == \
+        Matrix([
+        [1, 0, 0],
+        [0, 1, 0]])
+    vert = Matrix([1, 2, 3])
+    assert banded({0: vert}, cols=3) == \
+        Matrix([
+        [1, 0, 0],
+        [2, 1, 0],
+        [3, 2, 1],
+        [0, 3, 2],
+        [0, 0, 3]])
+    assert banded(4, {0: ones(2)}) == \
+        Matrix([
+        [1, 1, 0, 0],
+        [1, 1, 0, 0],
+        [0, 0, 1, 1],
+        [0, 0, 1, 1]])
+    raises(ValueError, lambda: banded({0: 2, 1: ones(2)}, rows=5))
+    assert banded({0: 2, 2: (ones(2),)*3}) == \
+        Matrix([
+        [2, 0, 1, 1, 0, 0, 0, 0],
+        [0, 2, 1, 1, 0, 0, 0, 0],
+        [0, 0, 2, 0, 1, 1, 0, 0],
+        [0, 0, 0, 2, 1, 1, 0, 0],
+        [0, 0, 0, 0, 2, 0, 1, 1],
+        [0, 0, 0, 0, 0, 2, 1, 1]])
+    raises(ValueError, lambda: banded({0: (2,)*5, 1: (ones(2),)*3}))
+    u2 = Matrix([[1, 1], [0, 1]])
+    assert banded({0: (2,)*5, 1: (u2,)*3}) == \
+        Matrix([
+        [2, 1, 1, 0, 0, 0, 0],
+        [0, 2, 1, 0, 0, 0, 0],
+        [0, 0, 2, 1, 1, 0, 0],
+        [0, 0, 0, 2, 1, 0, 0],
+        [0, 0, 0, 0, 2, 1, 1],
+        [0, 0, 0, 0, 0, 0, 1]])
+    assert banded({0:(0, ones(2)), 2: 2}) == \
+        Matrix([
+        [0, 0, 2],
+        [0, 1, 1],
+        [0, 1, 1]])
+    raises(ValueError, lambda: banded({0: (0, ones(2)), 1: 2}))
+    assert banded({0: 1}, cols=3) == banded({0: 1}, rows=3) == eye(3)
+    assert banded({1: 1}, rows=3) == Matrix([
+        [0, 1, 0],
+        [0, 0, 1],
+        [0, 0, 0]])

phi4/bin/bunzip2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a514cce807cb1656a3bcd59794401e7d63c9554267e9acc77097a406092a8ed
+size 299464

phi4/bin/lzma

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07d32f3060c130f5192e1441831d7fce2f9c4a9612b347a0181296419bc04856
+size 108336

phi4/bin/unxz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07d32f3060c130f5192e1441831d7fce2f9c4a9612b347a0181296419bc04856
+size 108336

phi4/bin/x86_64-conda_cos7-linux-gnu-ld

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aaaab6b3200c6f71e5f2970b01a074c958d5af546e5f43c011192307f69d9cac
+size 2195376

phi4/bin/xz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07d32f3060c130f5192e1441831d7fce2f9c4a9612b347a0181296419bc04856
+size 108336

phi4/bin/xzcat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07d32f3060c130f5192e1441831d7fce2f9c4a9612b347a0181296419bc04856
+size 108336

phi4/compiler_compat/README

@@ -0,0 +1,2 @@
+Files in this folder are to enhance backwards compatibility of anaconda software with older compilers.
+See: https://github.com/conda/conda/issues/6030 for more information.

phi4/conda-meta/libuuid-1.41.5-h5eee18b_0.json

@@ -0,0 +1,81 @@
+{
+  "build": "h5eee18b_0",
+  "build_number": 0,
+  "channel": "https://repo.anaconda.com/pkgs/main",
+  "constrains": [],
+  "depends": [
+    "libgcc-ng >=11.2.0"
+  ],
+  "extracted_package_dir": "/opt/conda/pkgs/libuuid-1.41.5-h5eee18b_0",
+  "files": [
+    "include/uuid/uuid.h",
+    "lib/libuuid.a",
+    "lib/libuuid.so",
+    "lib/libuuid.so.1",
+    "lib/libuuid.so.1.3.0",
+    "lib/pkgconfig/uuid.pc"
+  ],
+  "fn": "libuuid-1.41.5-h5eee18b_0.conda",
+  "license": "BSD-3-Clause",
+  "link": {
+    "source": "/opt/conda/pkgs/libuuid-1.41.5-h5eee18b_0",
+    "type": 1
+  },
+  "md5": "4a6a2354414c9080327274aa514e5299",
+  "name": "libuuid",
+  "package_tarball_full_path": "/opt/conda/pkgs/libuuid-1.41.5-h5eee18b_0.conda",
+  "paths_data": {
+    "paths": [
+      {
+        "_path": "include/uuid/uuid.h",
+        "path_type": "hardlink",
+        "sha256": "926b9441cae3c113950827ef438cb0b07657f6ec1d2fe5f3ba557662ddbb526b",
+        "sha256_in_prefix": "926b9441cae3c113950827ef438cb0b07657f6ec1d2fe5f3ba557662ddbb526b",
+        "size_in_bytes": 3910
+      },
+      {
+        "_path": "lib/libuuid.a",
+        "path_type": "hardlink",
+        "sha256": "d16861859d7ad6a76c11296ef77000e95f64d75330ce6365f679c1c88c0ecabd",
+        "sha256_in_prefix": "d16861859d7ad6a76c11296ef77000e95f64d75330ce6365f679c1c88c0ecabd",
+        "size_in_bytes": 53390
+      },
+      {
+        "_path": "lib/libuuid.so",
+        "path_type": "softlink",
+        "sha256": "b42fa6cf1dcaca6b84e8155c4649d6bad561eaca2e8fa9473db178dbaa4aec53",
+        "size_in_bytes": 35944
+      },
+      {
+        "_path": "lib/libuuid.so.1",
+        "path_type": "softlink",
+        "sha256": "b42fa6cf1dcaca6b84e8155c4649d6bad561eaca2e8fa9473db178dbaa4aec53",
+        "size_in_bytes": 35944
+      },
+      {
+        "_path": "lib/libuuid.so.1.3.0",
+        "path_type": "hardlink",
+        "sha256": "b42fa6cf1dcaca6b84e8155c4649d6bad561eaca2e8fa9473db178dbaa4aec53",
+        "sha256_in_prefix": "b42fa6cf1dcaca6b84e8155c4649d6bad561eaca2e8fa9473db178dbaa4aec53",
+        "size_in_bytes": 35944
+      },
+      {
+        "_path": "lib/pkgconfig/uuid.pc",
+        "file_mode": "text",
+        "path_type": "hardlink",
+        "prefix_placeholder": "/croot/libuuid_1668082679328/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold",
+        "sha256": "ad771b4cb15ca6fcc526199ebbc1c4ff31e1cf96f01fb4710b14462327ebbef1",
+        "sha256_in_prefix": "e27debe8eb6ff313bb5f980796b5d0230e6dba1820b4dfe9c049bd3b086dc9ab",
+        "size_in_bytes": 1208
+      }
+    ],
+    "paths_version": 1
+  },
+  "requested_spec": "None",
+  "sha256": "2a401aafabac51b7736cfe12d2ab205d29052640ea8183253c9d0a8e7ed0d49a",
+  "size": 28110,
+  "subdir": "linux-64",
+  "timestamp": 1668082729000,
+  "url": "https://repo.anaconda.com/pkgs/main/linux-64/libuuid-1.41.5-h5eee18b_0.conda",
+  "version": "1.41.5"
+}