h&"!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""############################################################################################################################################################################################################################################################################################################################################################################################################$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''''((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))*******************+++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,---------------------------------------------------------------------------............................................................................////////0000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!7!8!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!9!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:!:":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":":";";";";";";";";";";";";";";";";";";";";";";";";";";";";";";";";";";#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;#;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$;$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<$<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<%<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&<&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&=&='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='='=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(=(>(>(>(>(>(>(>(>(>(>(>(>(>(>(>(>(>(>(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?(?)?)?)?)?)?)?)?)?)?)?)@)@)@)@)@)@)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)A)B)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C)C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*C*D*D*D*D*D*D*D*D*D*D*D*D*D*D*D*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E*E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+E+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+F+G+G+G+G+G+G+G+G+G+G+G+G+G+G+G+G+G+G+H+H+H+H+H+H+H+I+I+I+I+I+I+I+I+I+I+I+I+I+I+I+I+I+I+I+I+I+I+I+J+J+J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,J,K,L,L,L,L,L,L,L,L,L,L,L,L,L,L,L,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,M,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-N-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O-O.O.O.O.O.P.Q.Q.Q.Q.Q.Q.Q.Q.Q.Q.Q.Q.Q.Q.Q.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.R.S.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.T.U.U/U/U/U/U/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/V/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W/W0W0W0W0W0W0W0W0W0W0W0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0X0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y0Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Y1Z1Z1Z1Z1Z1[1[1[1[1[1[1[1[1[1[1[1[1[1[1[1\1\1\1\1\1\1\1\1\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3]3^3^3^3^3^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4^4_4_4_4_4_4_4_4_4_4_4_4_4_4_4_4_4_4_4_4_4_4_4_4`4`4`4`4`4`4`4a4a4a4a4a4a4a4a4a4a4a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b5b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6b6c6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d6d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7d7e7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f8f8f8f8f8f8f8f8g8g8g8g8g8g8g8g8g8g8g8g8g8g8g8g8g8h8h8h8h8h8h8h8h8h8h8h8h8h8h8h8h8h8i8i8i8i8i8i8i8i8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j8j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9j9k9k9k9k9k9k9k9k9k9k9k9k9k9k9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9l9m9m9m9m9m9m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:m:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n:n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n;n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<n<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o<o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=o=p=p=p=p=p=p=p=p=p=p=p=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=q=r=r=r=r=r=r=r=r=r=r=r=r=r=r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r>r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?r?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s?s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@s@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@tAtAuAuAuAuAuAuAuAuAuAuAuAuAuAuAuAuAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAvAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwAwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBwBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxBxByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByByBzBzBzBzBzBzBzCzCzCzCzC{C{C{C{C{C{C{C{C{C{C{C{C{C{C{C{C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C|C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}C}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}D}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E}E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~E~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~F~FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKLLLL Safe-Inferred )*1#Flint2 Return type for fpwrap functionsFlint2 arb_fpwrap_cdouble_modular_delta res tau flags Flint2!arb_fpwrap_cdouble_modular_lambda res tau flags Flint2arb_fpwrap_cdouble_modular_j res tau flags Flint2arb_fpwrap_cdouble_dedekind_eta res tau flags Flint2!arb_fpwrap_cdouble_jacobi_theta_4 res z tau flags Jacobi theta functions.Flint2!arb_fpwrap_cdouble_jacobi_theta_3 res z tau flags Flint2!arb_fpwrap_cdouble_jacobi_theta_2 res z tau flags Flint2!arb_fpwrap_cdouble_jacobi_theta_1 res z tau flags Flint2!arb_fpwrap_cdouble_elliptic_sigma res z tau flags Weierstrass elliptic functions. Flint2 arb_fpwrap_cdouble_elliptic_zeta res z tau flags Flint2!arb_fpwrap_cdouble_elliptic_inv_p res z tau flags Flint2#arb_fpwrap_cdouble_elliptic_p_prime res z tau flags Flint2arb_fpwrap_cdouble_elliptic_p res z tau flags Flint2arb_fpwrap_cdouble_elliptic_rj res x y z w option flags %Carlson symmetric elliptic integrals.Flint2arb_fpwrap_cdouble_elliptic_rg res x y z option flags Flint2arb_fpwrap_cdouble_elliptic_rf res x y z option flags Flint2"arb_fpwrap_cdouble_elliptic_pi_inc res n phi m pi flags +Complete and incomplete elliptic integrals.Flint2!arb_fpwrap_cdouble_elliptic_e_inc res phi m pi flags Flint2arb_fpwrap_cdouble_elliptic_f res phi m pi flags Flint2arb_fpwrap_cdouble_elliptic_pi res n m flags Flint2arb_fpwrap_cdouble_elliptic_e res m flags Flint2arb_fpwrap_cdouble_elliptic_k res m flags Flint2arb_fpwrap_cdouble_agm res x y flags Arithmetic-geometric mean.Flint2arb_fpwrap_double_agm res x y flags Flint2arb_fpwrap_cdouble_hypgeom_pfq res a p b q z  regularized flags Flint2arb_fpwrap_double_hypgeom_pfq res a p b q z  regularized flags Flint2arb_fpwrap_cdouble_hypgeom_2f1 res a b c x  regularized flags Flint2arb_fpwrap_double_hypgeom_2f1 res a b c x  regularized flags Flint2arb_fpwrap_cdouble_hypgeom_u res a b x flags Flint2arb_fpwrap_double_hypgeom_u res a b x flags !Flint2arb_fpwrap_cdouble_hypgeom_1f1 res a b x  regularized flags "Flint2arb_fpwrap_double_hypgeom_1f1 res a b x  regularized flags #Flint2arb_fpwrap_cdouble_hypgeom_0f1 res a x  regularized flags $Flint2arb_fpwrap_double_hypgeom_0f1 res a x  regularized flags %Flint2arb_fpwrap_cdouble_spherical_y res n m x1 x2 flags &Flint2arb_fpwrap_double_legendre_root res1 res2 n k flags Sets res1 to the index k! root of the Legendre polynomial P_n(x), and simultaneously sets res2< to the corresponding weight for Gauss-Legendre quadrature.'Flint2arb_fpwrap_cdouble_legendre_q res n m x type flags (Flint2arb_fpwrap_double_legendre_q res n m x type flags )Flint2arb_fpwrap_cdouble_legendre_p res n m x type flags *Flint2arb_fpwrap_double_legendre_p res n m x type flags +Flint2arb_fpwrap_cdouble_hermite_h res n x flags ,Flint2arb_fpwrap_double_hermite_h res n x flags -Flint2arb_fpwrap_cdouble_laguerre_l res n m x flags .Flint2arb_fpwrap_double_laguerre_l res n m x flags /Flint2arb_fpwrap_cdouble_gegenbauer_c res n m x flags 0Flint2arb_fpwrap_double_gegenbauer_c res n m x flags 1Flint2arb_fpwrap_cdouble_jacobi_p res n a b x flags 2Flint2arb_fpwrap_double_jacobi_p res n a b x flags 3Flint2arb_fpwrap_cdouble_chebyshev_u res n x flags 4Flint2arb_fpwrap_double_chebyshev_u res n x flags 5Flint2arb_fpwrap_cdouble_chebyshev_t res n x flags 6Flint2arb_fpwrap_double_chebyshev_t res n x flags 7Flint2arb_fpwrap_cdouble_coulomb_hneg res l eta x flags 8Flint2arb_fpwrap_cdouble_coulomb_hpos res l eta x flags 9Flint2arb_fpwrap_cdouble_coulomb_g res l eta x flags :Flint2arb_fpwrap_double_coulomb_g res l eta x flags ;Flint2arb_fpwrap_cdouble_coulomb_f res l eta x flags <Flint2arb_fpwrap_double_coulomb_f res l eta x flags =Flint2$arb_fpwrap_double_airy_bi_prime_zero res n flags >Flint2arb_fpwrap_double_airy_bi_zero res n flags ?Flint2$arb_fpwrap_double_airy_ai_prime_zero res n flags @Flint2arb_fpwrap_double_airy_ai_zero res n flags AFlint2 arb_fpwrap_cdouble_airy_bi_prime res x flags BFlint2arb_fpwrap_double_airy_bi_prime res x flags CFlint2arb_fpwrap_cdouble_airy_bi res x flags DFlint2arb_fpwrap_double_airy_bi res x flags EFlint2 arb_fpwrap_cdouble_airy_ai_prime res x flags FFlint2arb_fpwrap_double_airy_ai_prime res x flags GFlint2arb_fpwrap_cdouble_airy_ai res x flags HFlint2arb_fpwrap_double_airy_ai res x flags IFlint2"arb_fpwrap_cdouble_bessel_k_scaled res nu x flags JFlint2!arb_fpwrap_double_bessel_k_scaled res nu x flags KFlint2arb_fpwrap_cdouble_bessel_k res nu x flags LFlint2arb_fpwrap_double_bessel_k res nu x flags MFlint2arb_fpwrap_cdouble_bessel_i res nu x flags NFlint2arb_fpwrap_double_bessel_i res nu x flags OFlint2arb_fpwrap_cdouble_bessel_y res nu x flags PFlint2arb_fpwrap_double_bessel_y res nu x flags QFlint2arb_fpwrap_cdouble_bessel_j res nu x flags RFlint2arb_fpwrap_double_bessel_j res nu x flags SFlint2arb_fpwrap_cdouble_dilog res x flags TFlint2arb_fpwrap_double_dilog res x flags UFlint2arb_fpwrap_cdouble_log_integral res x offset flags VFlint2arb_fpwrap_double_log_integral res x offset flags WFlint2 arb_fpwrap_cdouble_cosh_integral res x flags XFlint2arb_fpwrap_double_cosh_integral res x flags YFlint2 arb_fpwrap_cdouble_sinh_integral res x flags ZFlint2arb_fpwrap_double_sinh_integral res x flags [Flint2arb_fpwrap_cdouble_cos_integral res x flags \Flint2arb_fpwrap_double_cos_integral res x flags ]Flint2arb_fpwrap_cdouble_sin_integral res x flags ^Flint2arb_fpwrap_double_sin_integral res x flags _Flint2"arb_fpwrap_cdouble_exp_integral_ei res x flags `Flint2!arb_fpwrap_double_exp_integral_ei res x flags aFlint2!arb_fpwrap_cdouble_exp_integral_e res s z flags bFlint2 arb_fpwrap_double_exp_integral_e res s z flags cFlint2arb_fpwrap_cdouble_beta_lower res a b z  regularized flags dFlint2arb_fpwrap_double_beta_lower res a b z  regularized flags eFlint2arb_fpwrap_cdouble_gamma_lower res s z  regularized flags fFlint2arb_fpwrap_double_gamma_lower res s z  regularized flags gFlint2arb_fpwrap_cdouble_gamma_upper res s z  regularized flags hFlint2arb_fpwrap_double_gamma_upper res s z  regularized flags iFlint2arb_fpwrap_cdouble_fresnel_c res x  normalized flags jFlint2arb_fpwrap_double_fresnel_c res x  normalized flags kFlint2arb_fpwrap_cdouble_fresnel_s res x  normalized flags lFlint2arb_fpwrap_double_fresnel_s res x  normalized flags mFlint2arb_fpwrap_double_erfcinv res x flags nFlint2arb_fpwrap_double_erfinv res x flags oFlint2arb_fpwrap_cdouble_erfi res x flags pFlint2arb_fpwrap_double_erfi res x flags qFlint2arb_fpwrap_cdouble_erfc res x flags rFlint2arb_fpwrap_double_erfc res x flags sFlint2arb_fpwrap_cdouble_erf res x flags tFlint2arb_fpwrap_double_erf res x flags uFlint2arb_fpwrap_cdouble_zeta_zero res n flags vFlint2arb_fpwrap_cdouble_hardy_z res z flags wFlint2arb_fpwrap_cdouble_hardy_theta res z flags xFlint2arb_fpwrap_cdouble_riemann_xi res s flags yFlint2 arb_fpwrap_cdouble_dirichlet_eta res s flags zFlint2arb_fpwrap_cdouble_polylog res s z flags Polylogarithm.{Flint2arb_fpwrap_double_polylog res s z flags |Flint2arb_fpwrap_cdouble_polygamma res s z flags Polygamma function.}Flint2arb_fpwrap_double_polygamma res s z flags ~Flint2arb_fpwrap_cdouble_log_barnes_g res x flags Logarithmic Barnes G-function.Flint2arb_fpwrap_double_log_barnes_g res x flags Flint2arb_fpwrap_cdouble_barnes_g res x flags Barnes G-function.Flint2arb_fpwrap_double_barnes_g res x flags Flint2arb_fpwrap_cdouble_lerch_phi res z s a flags Lerch transcendent.Flint2arb_fpwrap_double_lerch_phi res z s a flags Flint2arb_fpwrap_cdouble_hurwitz_zeta res s z flags Hurwitz zeta function.Flint2arb_fpwrap_double_hurwitz_zeta res s z flags Flint2arb_fpwrap_cdouble_zeta res x flags Riemann zeta function.Flint2arb_fpwrap_double_zeta res x flags Flint2arb_fpwrap_cdouble_digamma res x flags Digamma function.Flint2arb_fpwrap_double_digamma res x flags Flint2arb_fpwrap_cdouble_lgamma res x flags Log-gamma function.Flint2arb_fpwrap_double_lgamma res x flags Flint2arb_fpwrap_cdouble_rgamma res x flags Reciprocal gamma function.Flint2arb_fpwrap_double_rgamma res x flags Flint2arb_fpwrap_cdouble_gamma res x flags Gamma function.Flint2arb_fpwrap_double_gamma res x flags Flint2arb_fpwrap_cdouble_rising res x n flags Rising factorial.Flint2arb_fpwrap_double_rising res x n flags Flint2arb_fpwrap_cdouble_lambertw res x branch flags Flint2arb_fpwrap_double_lambertw res x branch flags Flint2arb_fpwrap_cdouble_atanh res x flags Flint2arb_fpwrap_double_atanh res x flags Flint2arb_fpwrap_cdouble_acosh res x flags Flint2arb_fpwrap_double_acosh res x flags Flint2arb_fpwrap_cdouble_asinh res x flags Flint2arb_fpwrap_double_asinh res x flags Flint2arb_fpwrap_double_atan2 res x1 x2 flags Flint2arb_fpwrap_cdouble_atan res x flags Flint2arb_fpwrap_double_atan res x flags Flint2arb_fpwrap_cdouble_acos res x flags Flint2arb_fpwrap_double_acos res x flags Flint2arb_fpwrap_cdouble_asin res x flags Flint2arb_fpwrap_double_asin res x flags Flint2arb_fpwrap_cdouble_sinc_pi res x flags Flint2arb_fpwrap_double_sinc_pi res x flags Flint2arb_fpwrap_cdouble_cot_pi res x flags Flint2arb_fpwrap_double_cot_pi res x flags Flint2arb_fpwrap_cdouble_tan_pi res x flags Flint2arb_fpwrap_double_tan_pi res x flags Flint2arb_fpwrap_cdouble_cos_pi res x flags Flint2arb_fpwrap_double_cos_pi res x flags Flint2arb_fpwrap_cdouble_sin_pi res x flags Flint2arb_fpwrap_double_sin_pi res x flags Flint2arb_fpwrap_cdouble_sinc res x flags Flint2arb_fpwrap_double_sinc res x flags Flint2arb_fpwrap_cdouble_csc res x flags Flint2arb_fpwrap_double_csc res x flags Flint2arb_fpwrap_cdouble_sec res x flags Flint2arb_fpwrap_double_sec res x flags Flint2arb_fpwrap_cdouble_cot res x flags Flint2arb_fpwrap_double_cot res x flags Flint2arb_fpwrap_cdouble_tan res x flags Flint2arb_fpwrap_double_tan res x flags Flint2arb_fpwrap_cdouble_cos res x flags Flint2arb_fpwrap_double_cos res x flags Flint2arb_fpwrap_cdouble_sin res x flags Flint2arb_fpwrap_double_sin res x flags Flint2arb_fpwrap_cdouble_cbrt res x flags Flint2arb_fpwrap_double_cbrt res x flags Flint2arb_fpwrap_cdouble_rsqrt res x flags Flint2arb_fpwrap_double_rsqrt res x flags Flint2arb_fpwrap_cdouble_sqrt res x flags Flint2arb_fpwrap_double_sqrt res x flags Flint2arb_fpwrap_cdouble_pow res x y flags Flint2arb_fpwrap_double_pow res x y flags Flint2arb_fpwrap_cdouble_log1p res x flags Flint2arb_fpwrap_double_log1p res x flags Flint2arb_fpwrap_cdouble_log res x flags Flint2arb_fpwrap_double_log res x flags Flint2arb_fpwrap_cdouble_expm1 res x flags Flint2arb_fpwrap_double_expm1 res x flags Flint2arb_fpwrap_cdouble_exp res x flags Flint2arb_fpwrap_double_exp res x flags Flint2Indicates an accurate result. (Up to inevitable underflow or overflow in the final conversion to a floating-point result; see above.)$This flag has the numerical value 0.Flint2Indicates failure (unable to achieve to target accuracy, possibly because of a singularity). The output is set to NaN.This flag has the numerical value 1. Functions take a flags parameter specifying optional rounding and termination behavior. This can be set to 0 to use defaults.Flint2For complex output, compute both real and imaginary parts to full relative accuracy. By default (if this flag is not set), complex results are computed to at least 53-bit accuracy as a whole, but if either the real or imaginary part is much smaller than the other, that part can have a large relative error. Setting this flag can result in slower evaluation or failure to converge in some cases.$This flag has the numerical value 1.Flint2Guarantees correct rounding. By default (if this flag is not set), real results are accurate up to the rounding of the last bit, but the last bit is not guaranteed to be rounded optimally. Setting this flag can result in slower evaluation or failure to converge in some cases. Correct rounding automatically applies to both real and imaginary parts of complex numbers, so it is unnecessary to set both this flag and FPWRAP_ACCURATE_PARTS.$This flag has the numerical value 2.Flint2Multiplied by an integer, specifies the maximum working precision to use before giving up. With n * FPWRAP_WORK_LIMIT added to flags, levels of precision will be used. The default is equivalent to , which for double means trying with a working precision of 64, 128, 256, 512, 1024, 2048, 4096, 8192 bits. With flags = 2 * FPWRAP_WORK_LIMIT, we only try 64 and 128 bits, and with flags = 16 * FPWRAP_WORK_LIMIT we go up to 2097152 bits.(This flag has the numerical value 65536.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred )*1  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!   Safe-Inferred )*1Flint2fexpr_builtin_lookup sReturns the internal index used to encode the builtin symbol with name s in expressions. If s is not the name of a builtin symbol, returns -1Flint2fexpr_builtin_name nReturns a pointer for a string giving the name of the builtin symbol with index nFlint2fexpr_builtin_length&Returns the number of builtin symbols. Safe-Inferred )*1U Safe-Inferred )*1 Safe-Inferred )*1( Flint2flint_reset_num_workers  num_workers After a call to flint_set_num_workers this function must be called to set the number of workers that may be started by the current thread back to its original value.Flint2flint_set_num_workers  num_workers Restricts the number of worker threads that can be started by the current thread to  num_workers/. This function can be called from any thread.5Assumes that the Flint thread pool is already set up.The function returns the old number of worker threads that can be started.The function can only be used to reduce the number of workers that can be started from a thread. It cannot be used to increase the number. If a higher number is passed, the function has no effect.The number of workers must be restored to the original value by a call to flint_reset_num_workers3 before the thread is returned to the thread pool."The main use of this function and flint_reset_num_workers is to cheaply and temporarily restrict the number of workers that can be started, e.g. by a function that one wishes to call from a thread, and cheaply restore the number of workers to its original value before exiting the current thread.Flint2flint_get_num_threads When called at the global level, this function returns one more than the number of worker threads in the Flint thread pool, i.e. it counts the workers in the thread pool plus one more for the master thread.In general, this function returns one more than the number of additional worker threads that can be started by the current thread.Use thread_pool_wake. to set this number for a given worker thread.Flint2flint_set_num_threads  num_threads Set up a thread pool of num_threads - 1 worker threads (in addition to the master thread) and set the maximum number of worker threads the master thread can start to num_threads - 1.This function may only be called globally from the master thread. It can also be called at a global level to change the size of the thread pool, but an exception is raised if the thread pool is in use (threads have been woken but not given back). The function cannot be called from inside worker threads.Flint2flint_randclear state Free all memory allocated by flint_rand_init.Flint2flint_randinit state  Initialize a  flint_rand_t.Flint2flint_rand_free state /Frees a random state object as allocated using flint_rand_alloc.Flint2flint_rand_alloc  Allocates a  flint_rand_t* object to be used like a heap-allocated  flint_rand_t= in external libraries. The random state is not initialised.Flint2 flint_calloc num size  Allocate num objects of size, bytes each, and zero the allocated memory.Flint2 flint_realloc ptr size 5Reallocate an area of memory previously allocated by  flint_malloc,  flint_realloc, or  flint_calloc.Flint2 flint_malloc size  Allocate size bytes of memory. Safe-Inferred )*1).Flint2+Data structure containing the CMpfr pointer  Safe-Inferred )*1*Flint23Data structure containing the CGmpRandstate pointerFlint2*Data structure containing the CMpf pointerFlint2*Data structure containing the CMpq pointerFlint2*Data structure containing the CMpz pointerFlint2)Data structure containing the CMp pointer Safe-Inferred )*1+ Safe-Inferred )*1+3 Safe-Inferred )*1 1Flint2fft_convolution_precache ii jj depth limbs trunc t1 t2 s1 tt As per fft_convolution except that it is assumed  fft_precache has been called on jj> with the same parameters. This will then run faster than if fft_convolution had been run with the original jj.Flint2 fft_precache jj depth limbs trunc t1 t2 s1 Precompute the FFT of jj= for use with precache functions. The parameters are as for fft_convolution.Flint2fft_convolution ii jj depth limbs trunc t1 t2 s1 tt Perform an FFT convolution of ii with jj, both of length 4*n where  n = 2^depth . Assume that all but the first trunc( coefficients of the output (placed in ii.) are zero. Each coefficient is taken modulo  B^limbs + 1. The temporary spaces t1, t2 and s1 must have  limbs + 1 limbs of space and tt must have  2*(limbs + 1) of free space.Flint2flint_mpn_mul_fft_main r1 i1 n1 i2 n2 .The main integer multiplication routine. Sets  (r1, n1 + n2) to (i1, n1) times (i2, n2) . We require  n1 >= n2 > 0.Flint2mul_mfa_truncate_sqrt2 r1 i1 n1 i2 n2 depth w As for mul_truncate_sqrt2 except that the cache friendly matrix Fourier algorithm is used.If  n = 2^depth then we require nw* to be at least 64. Here we also require w to be 2^i for some i \geq 0.Flint2mul_truncate_sqrt2 r1 i1 n1 i2 n2 depth w Integer multiplication using the radix 2 truncated sqrt2 transforms.Set  (r1, n1 + n2) to the product of (i1, n1) by (i2, n2). This is achieved through an FFT convolution of length at most  2^(depth + 2) with coefficients of size nw bits where  n = 2^depth. We require  depth >= 6>. The input data is broken into chunks of data not exceeding (nw - (depth + 1))/2 bits. If breaking the first integer into chunks of this size results in j1: coefficients and breaking the second integer results in j2 chunks then j1 + j2 - 1 <= 2^(depth + 2).If  n = 2^depth then we require nw to be at least 64.Flint2fft_mulmod_2expp1 r i1 i2 n w tt As per _fft_mulmod_2expp1 but with a tuned cutoff below which more classical methods are used for the convolution. The temporary space is required to fit n*w + FLINT_BITS% bits. There are no restrictions on n , but if limbs = n*w/FLINT_BITS then if limbs exceeds FFT_MULMOD_2EXPP1_CUTOFF the function fft_adjust_limbs must be called to increase the number of limbs to an appropriate value.Flint2fft_adjust_limbs limbs Given a number of limbs, returns a new number of limbs (no more than the next power of 2) which will work with the Nussbaumer code. It is only necessary to make this adjustment if  limbs > FFT_MULMOD_2EXPP1_CUTOFF.Flint2_fft_mulmod_2expp1 r1 i1 i2 r_limbs depth w  Multiply i1 by i2 modulo  B^r_limbs + 1 where r_limbs = nw/FLINT_BITS with  n = 2^depth. Uses the negacyclic FFT convolution CRT'd with a 1 limb naive convolution. We require that depth and w( have been selected as per the wrapper fft_mulmod_2expp1 below.Flint2fft_naive_convolution_1 r ii jj m +Performs a naive negacyclic convolution of ii with jj, both of length m , and sets r to the result. This is essentially multiplication of polynomials modulo x^m + 1.Flint2ifft_negacyclic ii n w t1 t2 temp As per  ifft_radix2 except that it performs a sqrt2 negacyclic inverse transform of length 2n. This is the same as the radix 2 inverse transform except that the i5-th coefficient of the output is finally divided by  \sqrt{2}^{iw}. We require nw to be at least 64 and the two temporary space pointers to point to blocks of size n*w + FLINT_BITS bits.Flint2fft_negacyclic ii n w t1 t2 temp As per  fft_radix2 except that it performs a sqrt2 negacyclic transform of length 2n=. This is the same as the radix 2 transform except that the i5-th coefficient of the input is first multiplied by  \sqrt{2}^{iw}. We require nw to be at least 64 and the two temporary space pointers to point to blocks of size n*w + FLINT_BITS bits.Flint2ifft_mfa_truncate_sqrt2_outer ii n w t1 t2 temp n1 trunc The outer layers of ifft_mfa_truncate_sqrt2 combined with normalisation.Flint2fft_mfa_truncate_sqrt2_inner ii jj n w t1 t2 temp n1 trunc tt The inner layers of fft_mfa_truncate_sqrt2 and ifft_mfa_truncate_sqrt2 combined with pointwise mults.Flint2fft_mfa_truncate_sqrt2_outer ii n w t1 t2 temp n1 trunc Just the outer layers of fft_mfa_truncate_sqrt2.Flint2ifft_mfa_truncate_sqrt2 ii n w t1 t2 temp n1 trunc This is as per the ifft_truncate_sqrt2 function except that the matrix Fourier algorithm is used for the left and right IFFTs. The total transform length is 4n where  n = 2^depth8 so that the left and right transforms are both length 2n . We require  trunc > 2*n and that trunc is divisible by 2*n1.We set n1* to a power of 2 about the square root of n.As per the matrix fourier FFT the sqrt2 layer is folded into the final column IFFTs for better cache locality and the extra twiddles that occur in the matrix Fourier algorithm are combined with the butterflied performed at the first layer of the final column transforms. We require nw to be at least 64 and the three temporary space pointers to point to blocks of size n*w + FLINT_BITS bits.Flint2fft_mfa_truncate_sqrt2 ii n w t1 t2 temp n1 trunc This is as per the fft_truncate_sqrt2 function except that the matrix Fourier algorithm is used for the left and right FFTs. The total transform length is 4n where  n = 2^depth8 so that the left and right transforms are both length 2n . We require  trunc > 2*n and that trunc is divisible by 2*n1 (explained below). The coefficients are produced in an order different from fft_truncate_sqrt2.The matrix Fourier algorithm, which is applied to each transform of length 2n, works as follows. We set n1+ to a power of 2 about the square root of n*. The data is then thought of as a set of n2 rows each with n1 columns (so that  n1*n2 = 2n). The length 2n transform is then computed using a whole pile of short transforms. These comprise n1 column transforms of length n26 followed by some twiddles by roots of unity (namely z^rc where r is the row and c) the column within the data) followed by n2 row transforms of length n1. Along the way the data needs to be rearranged due to the fact that the short transforms output the data in binary reversed order compared with what is needed.The matrix Fourier algorithm provides better cache locality by decomposing the long length 2n transforms into many transforms of about the square root of the original length.=For better cache locality the sqrt2 layer of the full length 4n transform is folded in with the column FFTs performed as part of the first matrix Fourier algorithm on the left half of the data.The second half of the data requires a truncated version of the matrix Fourier algorithm. This is achieved by truncating to an exact multiple of the row length so that the row transforms are full length. Moreover, the column transforms will then be truncated transforms and their truncated length needs to be a multiple of 2. This explains the condition on trunc given above.To improve performance, the extra twiddles by roots of unity are combined with the butterflies performed at the last layer of the column transforms. We require nw to be at least 64 and the three temporary space pointers to point to blocks of size n*w + FLINT_BITS bits.Flint2ifft_truncate1_twiddle ii is n w t1 t2 ws r c rs trunc As per ifft_radix2_twiddle0 except that the transform is truncated as per ifft_truncate1.Flint2fft_truncate1_twiddle ii is n w t1 t2 ws r c rs trunc As per fft_radix2_twiddle0 except that the transform is truncated as per  fft_truncate1.Flint2ifft_radix2_twiddle ii is n w t1 t2 ws r c rs As for  ifft_radix2, except that the coefficients are spaced by is in the array ii and an additional twist by z^(-c*i)' is applied to each coefficient where i starts at r and increases by rs6 as one moves from one coefficient to the next. Here z# corresponds to multiplication by 2^ws.Flint2fft_radix2_twiddle ii is n w t1 t2 ws r c rs As for  fft_radix2, except that the coefficients are spaced by is in the array ii and an additional twist by z^c*i' is applied to each coefficient where i starts at r and increases by rs6 as one moves from one coefficient to the next. Here z# corresponds to multiplication by 2^ws.Flint2ifft_butterfly_twiddle u v s t limbs b1 b2 Set u = s/2^b1 + t/2^b1), v = s/2^b1 - t/2^b1 modulo  B^limbs + 1. This is used to compute "u = 2^(-ws*tw1)*s + 2^(-ws*tw2)*t), "v = 2^(-ws*tw1)*s + 2^(-ws*tw2)*t) in the matrix Fourier algorithm, i.e. effectively computing an ordinary butterfly with additional twiddles by z1^(-rc) for row r and column c9 of the matrix of coefficients. Aliasing is not allowed.Flint2fft_butterfly_twiddle u v s t limbs b1 b2 Set u = 2^b1*(s + t), v = 2^b2*(s - t) modulo  B^limbs + 1. This is used to compute u = 2^(ws*tw1)*(s + t), v = 2^(w+ws*tw2)*(s - t) in the matrix Fourier algorithm, i.e. effectively computing an ordinary butterfly with additional twiddles by z1^rc for row r and column c8 of the matrix of coefficients. Aliasing is not allowed.Flint2ifft_truncate_sqrt2 ii n w t1 t2 temp trunc As per  ifft_truncate except that the transform is twice the usual length, i.e. length 4n instead of 2n. This is achieved by making use of twiddles by powers of a square root of 2, not powers of 2 in the final layer of the transform. We require nw to be at least 64 and the three temporary space pointers to point to blocks of size n*w + FLINT_BITS bits.Flint2fft_truncate_sqrt2 ii n w t1 t2 temp trunc As per  fft_truncate except that the transform is twice the usual length, i.e. length 4n rather than 2n. This is achieved by making use of twiddles by powers of a square root of 2, not powers of 2 in the first layer of the transform. We require nw to be at least 64 and the three temporary space pointers to point to blocks of size n*w + FLINT_BITS bits.Flint2ifft_butterfly_sqrt2 s t i1 i2 i limbs w temp Let  w = 2k + 1,  i = 2j + 1. Set s = i1 + z1^i*i2, t = i1 - z1^i*i2 modulo  B^limbs + 1 where z1^2 = exp(-Pi*I/n) corresponds to division by 2^w . Requires  0 \leq i < 2n where nw = limbs*FLINT_BITS.Here z1 corresponds to division by 2^k then division by (2^(3nw/4) - 2^(nw/4)) . We see z1^i corresponds to division by (2^(3nw/4) - 2^(nw/4))*2^(j+ik)# which is the same as division by  2^(j+ik + 1) then multiplication by (2^(3nw/4) - 2^(nw/4)).Of course, division by  2^(j+ik + 1)# is the same as multiplication by 2^(2*wn - j - ik - 1). The exponent is positive as i \leq 2\cdot n, j < n, k < w/2.We first multiply by 2^(2*wn - j - ik - 1 + wn/4)! then multiply by an additional 2^(nw/2) and subtract.Flint2fft_butterfly_sqrt2 s t i1 i2 i limbs w temp Let  w = 2k + 1,  i = 2j + 1. Set  s = i1 + i2, t = z1^i*(i1 - i2) modulo  B^limbs + 1 where z1^2 = exp(Pi*I/n)# corresponds to multiplication by 2^w . Requires  0 \leq i < 2n where nw = limbs*FLINT_BITS.Here z1" corresponds to multiplication by 2^k then multiplication by (2^(3nw/4) - 2^(nw/4)) . We see z1^i# corresponds to multiplication by (2^(3nw/4) - 2^(nw/4))*2^(j+ik).We first multiply by 2^(j + ik + wn/4)! then multiply by an additional 2^(nw/2) and subtract.Flint2ifft_truncate1 ii n w t1 t2 trunc Computes the first trunc coefficients of the radix 2 inverse transform assuming the first trunc coefficients are given and that the remaining coefficients have been set to the value they would have if an inverse transform had already been applied with full data.!The algorithm is the same as for  ifft_truncate$ except that the coefficients from trunc onwards after the inverse transform are not inferred to be zero but the supplied values.Flint2 ifft_truncate ii n w t1 t2 trunc As for  ifft_radix2 except that the output is assumed to have zeros from coefficient trunc onwards and only the first trunc coefficients of the input are specified. The remaining coefficients need to exist as the extra space is needed, but their value is irrelevant. The value of trunc must be divisible by 2.Although the implementation does not require it, we assume for simplicity that trunc is greater than n. The algorithm begins by computing the inverse transform of the first n coefficients of the input array. The unspecified coefficients of the second half of the array are then written: coefficient  trunc + i( is computed as a twist of coefficient i by a root of unity. The values of these coefficients are then equal to what they would have been if the inverse transform of the right hand side of the input array had been computed with full data from the start. The function ifft_truncate1 is then called on the entire right half of the input array with this auxiliary data filled in. Finally a single layer of the IFFT is completed on all the coefficients up to trunc being careful to note that this involves doubling the coefficients from  trunc - n up to n.Flint2 ifft_radix2 ii n w t1 t2 &The radix 2 DIF IFFT works as follows:Input: [i0, i1, ..., i(m-1)], for m = 2n a power of 2. Output: @[r0, r1, ..., r(m-1)] = IFFT[i0, i1, ..., i(m-1)]@. Algorithm: \bullet- Recursively compute @[s0, s1, ...., s(m/2-1)] = IFFT[i0, i2, ..., i(m-2)]@\bullet4 Recursively compute @[t(m/2), t(m/2+1), ..., t(m-1)] = IFFT[i1, i3, ..., i(m-1)]@\bullet Let @[r0, r1, ..., r(m/2-1)] == [s0+z1^0*t0, s1+z1^1*t1, ..., s(m/2-1)+z1^(m/2-1)*t(m/2-1)] where 0z1 = exp(-2*Pi*I/m)@ corresponds to division by 2^w.\bullet$ Let @[r(m/2), r(m/2+1), ..., r(m-1)] >= [s0-z1^0*t0, s1-z1^1*t1, ..., s(m/2-1)-z1^(m/2-1)*t(m/2-1)]@The parameters are as follows: \bullet 2*n& is the length of the input and outputarrays\bullet w is such that 2^w is an 2n-th root of unity in the ring \mathbf{Z}/p\mathbf{Z} that we are working in, i.e. p = 2^{wn} + 1 (here n is divisible by GMP_LIMB_BITS)\bullet ii is the array of inputs (each input is an array of limbs of length wn/GMP_LIMB_BITS + 1 (the extra limbs being a "carry limb"). Outputs are written in-place. We require nw to be at least 64 and the two temporary space pointers to point to blocks of size n*w + FLINT_BITS bits.Flint2 fft_truncate1 ii n w t1 t2 trunc As for  fft_radix2 except that only the first trunc coefficients of the output are computed. The transform still needs all 2n% input coefficients to be specified.Flint2 fft_truncate ii n w t1 t2 trunc As for  fft_radix2 except that only the first trunc coefficients of the output are computed and the input is regarded as having (implied) zero coefficients from coefficient trunc onwards. The coefficients must exist as the algorithm needs to use this extra space, but their value is irrelevant. The value of trunc must be divisible by 2.Flint2 fft_radix2 ii n w t1 t2 %The radix 2 DIF FFT works as follows:Input: [i0, i1, ..., i(m-1)], for m = 2n a power of 2.Output: [r0, r1, ..., r(m-1)] = FFT[i0, i1, ..., i(m-1)]. Algorithm:\bullet Recursively compute [r0, r2, r4, ...., r(m-2)] 3= FFT[i0+i(m/2), i1+i(m/2+1), ..., i(m/2-1)+i(m-1)] \bullet Let [t0, t1, ..., t(m/2-1)] 0= [i0-i(m/2), i1-i(m/2+1), ..., i(m/2-1)-i(m-1)] \bullet Let [u0, u1, ..., u(m/2-1)] .= [z1^0*t0, z1^1*t1, ..., z1^(m/2-1)*t(m/2-1)] where z1 = exp(2*Pi*I/m)# corresponds to multiplication by 2^w. \bullet Recursively compute [r1, r3, ..., r(m-1)] = FFT[u0, u1, ..., u(m/2-1)]The parameters are as follows:\bullet 2*n- is the length of the input and output arrays \bullet w is such that 2^w is an 2n-th root of unity in the ring \mathbf{Z}/p\mathbf{Z} that we are working in, i.e. p = 2^{wn} + 1 (here n is divisible by GMP_LIMB_BITS)\bullet ii) is the array of inputs (each input is anarray of limbs of length wn/GMP_LIMB_BITS + 1 (the extra limbs being a "carry limb"). Outputs are written in-place. We require nw to be at least 64 and the two temporary space pointers to point to blocks of size n*w + FLINT_BITS bits.Flint2ifft_butterfly s t i1 i2 i limbs w Set s = i1 + z1^i*i2, t = i1 - z1^i*i2 modulo  B^limbs + 1 where z1 = exp(-Pi*I/n) corresponds to division by 2^w . Requires  0 \leq i < 2n where nw = limbs*FLINT_BITS.Flint2 fft_butterfly s t i1 i2 i limbs w Set  s = i1 + i2, t = z1^i*(i1 - i2) modulo  B^limbs + 1 where z1 = exp(Pi*I/n)" corresponds to multiplication by 2^w . Requires  0 \leq i < n where nw = limbs*FLINT_BITS.Flint2butterfly_rshB t u i1 i2 limbs x y We are given two integers i1 and i2 modulo  B^limbs + 13 which are not necessarily normalised. We compute t = (i1 + i2)/B^x and u = (i1 - i2)/B^y modulo p. Aliasing between inputs and outputs is not permitted. We require x and y to be less than limbs and nonnegative.Flint2butterfly_lshB t u i1 i2 limbs x y We are given two integers i1 and i2 modulo  B^limbs + 13 which are not necessarily normalised. We compute t = (i1 + i2)*B^x and u = (i1 - i2)*B^y modulo p. Aliasing between inputs and outputs is not permitted. We require x and y to be less than limbs and nonnegative.Flint2fft_adjust_sqrt2 r i1 i limbs w temp Set r to i1 times z^i modulo  B^limbs + 1 where z# corresponds to multiplication by  \sqrt{2}^w. This can be thought of as part of a butterfly operation. We require 0 \leq i < 2\cdot n and odd where nw = limbs*FLINT_BITS.Flint2 fft_adjust r i1 i limbs w Set r to i1 times z^i modulo  B^limbs + 1 where z# corresponds to multiplication by 2^w. This can be thought of as part of a butterfly operation. We require  0 \leq i < n where nw = limbs*FLINT_BITS. Aliasing is not supported.Flint2mpn_div_2expmod_2expp1 t i1 limbs d Given i1 a signed integer of  limbs + 12 limbs in two's complement format reduced modulo  B^limbs + 1 up to some overflow, compute  t = i1/2^d modulo p. The result will not necessarily be fully reduced. The number of bits d$ must be nonnegative and less than  FLINT_BITS. Aliasing is permitted.Flint2mpn_mul_2expmod_2expp1 t i1 limbs d Given i1 a signed integer of  limbs + 12 limbs in two's complement format reduced modulo  B^limbs + 1 up to some overflow, compute  t = i1*2^d modulo p. The result will not necessarily be fully reduced. The number of bits d$ must be nonnegative and less than  FLINT_BITS. Aliasing is permitted.Flint2mpn_normmod_2expp1 t limbs Given t a signed integer of  limbs + 1+ limbs in two's complement format, reduce t to the corresponding value modulo the generalised Fermat number  B^limbs + 1, where B = 2^FLINT_BITS.Flint2mpn_addmod_2expp1_1 r limbs c Adds the signed limb c" to the generalised Fermat number r modulo  B^limbs + 1. The compiler should be able to inline this for the case that there is no overflow from the first limb.Flint2mpn_negmod_2expp1 z a limbs Set z& to the negation of the Fermat number a modulo  B^limbs + 1 . The input a is expected to be fully reduced, and the output is fully reduced. Aliasing is permitted.Flint2 fermat_to_mpz m i limbs Convert the Fermat number  (i, limbs) modulo  B^limbs + 1 to an mpz_t m . Assumes m has been initialised. This function is used only in test code.Flint2fft_combine_bits res poly length bits  output_limbs  total_limbs Evaluate the polynomial poly of the given length at 2^bits$ and add the result to the integer (res, total_limbs) throwing away any bits that exceed the given number of limbs. The polynomial coefficients are assumed to have at least  output_limbs limbs each, however any additional limbs are ignored. If the integer is initially zero the result will just be the evaluation of the polynomial.Flint2fft_combine_limbs res poly length  coeff_limbs  output_limbs  total_limbs Evaluate the polynomial poly of the given length at  B^coeff_limbs , where B = 2^FLINT_BITS%, and add the result to the integer (res, total_limbs) throwing away any bits that exceed the given number of limbs. The polynomial coefficients are assumed to have at least  output_limbs6 limbs each, however any additional limbs are ignored.If the integer is initially zero the result will just be the evaluation of the polynomial.Flint2fft_split_bits poly limbs  total_limbs bits  output_limbs Split an integer (limbs, total_limbs)+ into coefficients of the given number of bits" and store as the coefficients of poly& which are assumed to have space for output_limbs + 1 limbs per coefficient. The coefficients of the polynomial do not need to be zeroed before calling this function, however the number of coefficients written is returned by the function and any coefficients beyond this point are not touched.Flint2fft_split_limbs poly limbs  total_limbs  coeff_limbs  output_limbs Split an integer (limbs, total_limbs) into coefficients of length  coeff_limbs( limbs and store as the coefficients of poly& which are assumed to have space for output_limbs + 1 limbs per coefficient. The coefficients of the polynomial do not need to be zeroed before calling this function, however the number of coefficients written is returned by the function and any coefficients beyond this point are not touched.1 Safe-Inferred )*111 Safe-Inferred )*1# Safe-Inferred )*1D## Safe-Inferred )*1 Safe-Inferred )*1z Safe-Inferred )*1'Flint2dirichlet_char_lower chi_H H chi_G G If chi_G is a character of G which factors through H, sets chi_H& to the corresponding restriction in H.This requires c(\chi_G)\mid q_H\mid q_G, where  c(\chi_G) is the conductor of \chi_G and q_G, q_H are the moduli of G and H.Flint2dirichlet_char_lift chi_G G chi_H H If H is a subgroup of G, computes the character in G corresponding to chi_H in H.Flint2dirichlet_char_pow c G a n Take the power of a character.Flint2dirichlet_char_mul chi12 G chi1 chi2 *Multiply two characters of the same group G.Flint2dirichlet_chi_vec_order v G chi order nv $Compute the list of exponent values v[k] for  0\leq k < nv, as exponents modulo order5, which is assumed to be a multiple of the order of chi.Flint2dirichlet_chi_vec v G chi nv $Compute the list of exponent values v[k] for  0\leq k < nv, as exponents modulo G->expo.Flint2 dirichlet_chi G chi n Compute the value \chi(n) as the exponent modulo G->expo.Flint2dirichlet_pairing_char G chi psi 6Compute the value of the Dirichlet pairing on numbers m and n, as exponent modulo G->expo.The char variant takes as input two characters, so that no discrete logarithm is computed.The returned value is the numerator of the actual value exponent mod the group exponent G->expo.Flint2dirichlet_char_is_primitive G chi  Returns 1 if chi, is primitive (iff its conductor is exactly q).Flint2dirichlet_char_is_real G chi  Returns 1 if chi' is a real character (iff it has order \leq 2).Flint2dirichlet_order_char G x Returns the order of \chi_q(a,\cdot) which is the order of a\bmod q.Flint2dirichlet_parity_char G x  Returns the parity \lambda in \{0,1\} of \chi_q(a,\cdot) , such that \chi_q(a,-1)=(-1)^\lambda.Flint2dirichlet_conductor_char G x  Returns the  conductor of \chi_q(a,\cdot), that is the smallest r dividing q such \chi_q(a,\cdot)% can be obtained as a character mod r.Flint2dirichlet_char_is_principal G chi  Returns 1 if chi is the principal character mod q.Flint2dirichlet_char_eq_deep G x y  Return 1 if x equals y.The second version checks every byte of the representation and is intended for testing only.Flint2dirichlet_char_index x G j Sets x to the character whose log has lexicographic index j.Flint2dirichlet_index_char G x 'Returns the lexicographic index of the log of x as an integer in 0\dots \varphi(q).Flint2dirichlet_char_next_primitive x G Same as dirichlet_char_next0, but jumps to the next primitive character of G.Flint2dirichlet_char_next x G Sets x to the next character in G) according to lexicographic ordering of log.>The return value is the index of the last updated exponent of x, or -1& if the last element has been reached.3This function allows to iterate on all elements of G looping on their log5. Note that it produces elements in seemingly random number order.3The following template can be used for such a loop: dirichlet_char_one(chi, G); do { /* use character chi */ } while (dirichlet_char_next(chi, G) >= 0);Flint2dirichlet_char_set x G y Sets x to the element y.Flint2dirichlet_char_first_primitive x G Sets x% to the first primitive character of G , having log  [1,\dots 1], or [0, 1, \dots 1] if 8\mid q.Flint2dirichlet_char_one x G Sets x to the principal character in G , having log  [0,\dots 0].Flint2_dirichlet_char_exp x G  Computes and returns the number m corresponding to exponents in x%. This function is for internal use.Flint2dirichlet_char_exp G x Returns the number m corresponding to exponents in x.Flint2dirichlet_char_log x G m Sets x to the character of number m1, computing its log using discrete logarithm in G.Flint2dirichlet_char_clear chi Clears chi.Flint2dirichlet_char_init chi G  Initializes chi to an element of the group G0 and sets its value to the principal character.Flint2dirichlet_group_dlog_clear G num #Clear discrete logarithm tables in G. When discrete logarithm tables are shared with subgroups, those subgroups must be cleared before clearing the tables.Flint2dirichlet_group_dlog_precompute G num Precompute decomposition and tables for discrete log computations in G&, so as to minimize the complexity of num calls to discrete logarithms.If num2 gets very large, the entire group may be indexed.Flint2dirichlet_group_num_primitive G ,Returns the number of primitive elements in G.Flint2dirichlet_group_size G "Returns the number of elements in G, i.e.  \varphi(q).Flint2dirichlet_group_clear G Clears G. Remark this function does not0 clear the discrete logarithm tables stored in G* (which may be shared with another group).Flint2dirichlet_subgroup_init H G h  Given an already computed group G mod q, initialize its subgroup H defined mod h\mid q1. Precomputed discrete log tables are inherited.Flint2dirichlet_group_init G q  Initializes G* to the group of Dirichlet characters mod q.2This method computes a canonical decomposition of G/ in terms of cyclic groups, which are the mod p^e subgroups for p^e\|q, plus the specific generator described by Conrey for each subgroup.In particular G contains: the number num of componentsthe generators the exponent expo of the groupIt does not automatically precompute lookup tables of discrete logarithms or numerical roots of unity, and can therefore safely be called even with large q.8For implementation reasons, the largest prime factor of q must not exceed 10^{16}. This restriction could be removed in the future. The function returns 1 on success and 0 if a factor is too large.Flint2Use DirichletGroup in f.Flint2Apply f to new DirichletGroup.Flint2Use DirichletChar in f.Flint2Apply f to new DirichletChar.Flint2dirichlet_char_print G chi :Prints the array of exponents representing this character.6  Safe-Inferred )*166 Safe-Inferred )*1Flint2$nmod_discrete_log_pohlig_hellman_run L y Return the logarithm of y. with respect to the internally stored base. y& is expected to be reduced modulo the p=. The function is undefined if the logarithm does not exist.Flint2/nmod_discrete_log_pohlig_hellman_primitive_root L "Return the internally stored base.Flint21nmod_discrete_log_pohlig_hellman_precompute_prime L p  Configure L for discrete logarithms modulo p3 to an internally chosen base. It is assumed that p is prime. The return is an estimate on the number of multiplications needed for one run.Flint2&nmod_discrete_log_pohlig_hellman_clear L Free any space used by L.Flint2%nmod_discrete_log_pohlig_hellman_init L  Initialize L. Upon initialization L is not ready for computation.Flint2 nmod_pow_ui a e mod Returns a^e modulo mod.n . No assumptions are made about mod.n. It is assumed that a is already reduced modulo mod.n.Flint2nmod_div a b mod Returns ab^{-1} modulo mod.n. The inverse of b* is assumed to exist. It is assumed that a is already reduced modulo mod.n.Flint2nmod_inv a mod Returns a^{-1} modulo mod.n". The inverse is assumed to exist.Flint2_nmod_mul_fullword a b mod Returns ab modulo mod.n. Requires that mod.n is exactly  FLINT_BITS large. It is assumed that a and b are already reduced modulo mod.n.Flint2nmod_mul a b mod Returns ab modulo mod.n . No assumptions are made about mod.n. It is assumed that a and b are already reduced modulo mod.n.Flint2nmod_neg a mod Returns -a modulo mod.n. It is assumed that a is already reduced modulo mod.n/, but no assumptions are made about the latter.Flint2nmod_sub a b mod Returns a - b modulo mod.n . No assumptions are made about mod.n. It is assumed that a and b are already reduced modulo mod.n.Flint2 _nmod_sub a b mod Returns a - b modulo mod.n. It is assumed that mod is no more than FLINT_BITS - 1 bits. It is assumed that a and b are already reduced modulo mod.n.Flint2nmod_add a b mod Returns a + b modulo mod.n . No assumptions are made about mod.n. It is assumed that a and b are already reduced modulo mod.n.Flint2 _nmod_add a b mod Returns a + b modulo mod.n. It is assumed that mod is no more than FLINT_BITS - 1 bits. It is assumed that a and b are already reduced modulo mod.n.Flint2 nmod_init mod n Initialises the given nmod_t structure for reduction modulo n with a precomputed inverse.Flint2 Create a new  structureFlint2Use  structure  Safe-Inferred )*1d Safe-Inferred )*1Flint2dlog_vec_sieve v nv a va mod na order Compute the discrete logarithms of the first few prime numbers, then use them as a factor base to obtain the logarithms of larger primes by sieving techniques.In the the present implementation, the full index-calculus method is not implemented.Flint2dlog_vec_sieve_add v nv a va mod na order Flint2dlog_vec_eratos_add v nv a va mod na order 7Compute discrete logarithms of prime numbers less than nv% and propagate to composite numbers.Flint2dlog_vec_eratos v nv a va mod na order Flint2dlog_vec_loop_add v nv a va mod na order  Perform a complete loop of size na on powers of a to fill the logarithm values, discarding powers outside the bounds of v3. This requires no discrete logarithm computation.Flint2 dlog_vec_loop v nv a va mod na order Flint2 dlog_vec_add v nv a va mod na order $Same parameters as before, but adds \log(k,a)\times v_a to v[k] and reduce modulo order) instead of replacing the value. Indices k such that v[k] equals  DLOG_NONE are ignored.Flint2dlog_vec v nv a va mod na order Sets v[k] to  \log(k,a) times value va for  0\leq k < nv , where a has order na. va should be 1 for usual log computation.Flint2dlog_vec_set_not_found v nv mod  Sets values v[k] to  DLOG_NONE for all k not coprime to mod.Flint2 dlog_vec_fill v nv x  Sets values v[k] to x for all k less than nv.Flint2dlog_precomp_small_init pre a mod n num %Make a complete lookup table of size n. If mod= is small, this is done using an element-indexed array (see  dlog_table_t9), otherwise with a sorted array allowing binary search.Flint2dlog_precomp_pe_init pre a mod p e pe num  Assume that a has primepower order pe p^e.Flint2dlog_precomp_p_init pre a mod p num  Assume that a has prime order p.Flint2dlog_precomp_modpe_init pre a p e pe num  Assume that a( generates the group of residues modulo pe equal p^e for prime p.Flint2dlog_precomp_clear pre Clears t.Flint2 dlog_precomp pre b Return \log(b) for the group described in pre.Flint2dlog_precomp_n_init pre a mod n num Precompute data for num? discrete logarithms evaluations in the subgroup generated by a modulo mod, where a is known to have order n.Flint2 dlog_once b a mod n Return x such that b = a^x in  (\mathbb Z/mod \mathbb Z)^\times, where a is known to have order n.  Safe-Inferred )*1y Safe-Inferred )*1)  Safe-Inferred )*1ՋNone )*1Flint2Data structure containing  CFmpzFactor pointerFlint2Data structure containing  CFmpzMultiCRT pointerFlint2Data structure containing  CFmpzCombTemp pointerFlint2Data structure containing  CFmpzComb pointerFlint2Data structure containing the CFmpz pointerFlint2Integer (opaque pointer)LFlint2 nmod_pow_fmpz a e mod Returns a^e modulo mod.n . No assumptions are made about mod.n. It is assumed that a is already reduced modulo mod.n and that e is not negative.Flint2fmpz_factor_divisor_sigma res k fac Sets res to  \sigma_k(n), the sum of (k`th powers of all divisors of :math:`n). The factor version takes a precomputed factorisation of n.Flint2fmpz_factor_moebius_mu fac Computes the Moebius function \mu(n), which is defined as  \mu(n) = 0 if n2 has a prime factor of multiplicity greater than 1,  \mu(n) = -1 if n3 has an odd number of distinct prime factors, and  \mu(n) = 1 if n? has an even number of distinct prime factors. By convention,  \mu(0) = 0;. The factor version takes a precomputed factorisation of n.Flint2fmpz_factor_euler_phi res fac Sets res to the Euler totient function \phi(n), counting the number of positive integers less than or equal to n that are coprime to n:. The factor version takes a precomputed factorisation of n.Flint2fmpz_primorial res n Sets res to n primorial or n \#:, the product of all prime numbers less than or equal to n.Flint2fmpz_nextprime res n proved (Finds the next prime number larger than n.If proved is nonzero, then the integer returned is guaranteed to actually be prime. Otherwise if n fits in FLINT_BITS - 3 bits  n_nextprime$ is called, and if not then the GMP  mpz_nextprime function is called. Up to an including GMP 6.1.2 this used Miller-Rabin iterations, and thereafter uses a BPSW test.Flint2%fmpz_divisor_in_residue_class_lenstra fac n r s $If there exists a proper divisor of n which is  r \pmod{s} for  0 < r < s < n, this function returns 1 and sets fac4 to such a divisor. Otherwise the function returns 0 and the value of fac is undefined. We require \gcd(r, s) = 1.This is efficient if s^3 > n.Flint2fmpz_lucas_chain_VtoU Um Um1 Vm Vm1 A B Dinv n Given V_m, V_{m + 1} \pmod{n} compute U_m, U_{m + 1} \pmod{n}. Aliasing of V_m and U_m and aliasing of  V_{m + 1} and  U_{m + 1}, is permitted. No other aliasing is allowed.Flint2fmpz_lucas_chain_mul Ukm Ukm1 Um Um1 A B k n Given U_m, U_{m + 1} \pmod{n} compute U_{km}, U_{km + 1} \pmod{n}. Aliasing of U_{km} and U_m and aliasing of  U_{km + 1} and  U_{m + 1}, is permitted. No other aliasing is allowed.Flint2fmpz_lucas_chain_add Umn Umn1 Um Um1 Un Un1 A B n Given U_m, U_{m + 1} \pmod{n} and U_n, U_{n + 1} \pmod{n} compute !U_{m + n}, U_{m + n + 1} \pmod{n}. Aliasing of  U_{m + n} with U_m or U_n and aliasing of  U_{m + n + 1} with  U_{m + 1} or  U_{n + 1}- is permitted. No other aliasing is allowed.Flint2fmpz_lucas_chain_double U2m U2m1 Um Um1 A B n Given U_m, U_{m + 1} \pmod{n} compute U_{2m}, U_{2m + 1} \pmod{n}. Aliasing of U_{2m} and U_m and aliasing of  U_{2m + 1} and  U_{m + 1}, is permitted. No other aliasing is allowed.Flint2fmpz_lucas_chain_full Vm Vm1 A B m n Given V_0 = 2, V_1 = A compute V_m, V_{m + 1} \pmod{n} from the recurrences &V_j = AV_{j - 1} - BV_{j - 2} \pmod{n}.;This is computed efficiently using double and add formulas.No aliasing is permitted.Flint2fmpz_lucas_chain Vm Vm1 A m n Given V_0 = 2, V_1 = A compute V_m, V_{m + 1} \pmod{n} from the recurrences %V_j = AV_{j - 1} - V_{j - 2} \pmod{n}.#This is computed efficiently using V_{2j} = V_j^2 - 2 \pmod{n} and &V_{2j + 1} = V_jV_{j + 1} - A \pmod{n}.No aliasing is permitted.Flint2 fmpz_is_prime n Attempts to prove n prime. If n( is proven prime, the function returns 1. If n0 is definitely composite, the function returns 0.This function calls  n_is_prime for n" that fits in a single word. For n larger than one word, it tests divisibility by a few small primes and whether n: is a perfect square to rule out trivial composites. For n up to about 81 bits, it then uses a strong probable prime test (Miller-Rabin test) with the first 13 primes as witnesses. This has been shown to prove primality  [SorWeb2016]. For larger n, it does a single base-2 strong probable prime test to eliminate most composite numbers. If n passes, it does a combination of Pocklington, Morrison and Brillhart, Lehmer, Selfridge tests. If any of these tests fails to give a proof, it falls back to performing an APRCL test.6The APRCL test could theoretically fail to prove that n is prime or composite. In that case, the program aborts. This is not expected to occur in practice.Flint2_fmpz_np1_trial_factors n pp1 num_pp1 limit Trial factors n + 1 up to the given limit (approximately) and stores the factors in an array pp1 whose length is written out to num_pp1. One can use  \log(n) + 2 as a bound on the number of factors which might be produced (and hence on the length of the array that needs to be supplied).Flint2fmpz_is_prime_morrison F R n pp1 num_pp1 Applies the Morrison p + 1. primality test. The test computes a product F of primes which divide n + 1.!The function then returns either 0 if n( is definitely composite or it returns 1 if all factors of n are \pm 1 \pmod{F}. Also in that case, R is set to  (n + 1)/F.N.B: a return value of 1 only proves n prime if F > \sqrt{n} + 1.2The function does not compute which primes divide n + 1/. Instead, these must be supplied as an array pp1 of length num_pp1. It does not matter how many prime factors are supplied, but the more that are supplied, the larger F will be.There is a balance between the amount of time spent looking for factors of n + 16 and the usefulness of the output (F may be as low as 2 in some cases).-A reasonable heuristic seems to be to choose limit to be some small multiple of  \log^3(n)/10 (e.g. 1, 2, 5 or 10) depending on how long one is prepared to wait, then to trial factor up to the limit. (See _fmpz_np1_trial_factors.) Requires n to be odd and non-square.Flint2_fmpz_nm1_trial_factors n pm1 num_pm1 limit Trial factors n - 1 up to the given limit (approximately) and stores the factors in an array pm1 whose length is written out to num_pm1. One can use  \log(n) + 2 as a bound on the number of factors which might be produced (and hence on the length of the array that needs to be supplied).Flint2fmpz_is_prime_pocklington F R n pm1 num_pm1 Applies the Pocklington primality test. The test computes a product F of prime powers which divide n - 1.!The function then returns either 0 if n( is definitely composite or it returns 1 if all factors of n are  1 \pmod{F}. Also in that case, R is set to  (n - 1)/F.N.B: a return value of 1 only proves n prime if F \ge \sqrt{n}.2The function does not compute which primes divide n - 1/. Instead, these must be supplied as an array pm1 of length num_pm1. It does not matter how many prime factors are supplied, but the more that are supplied, the larger F will be.There is a balance between the amount of time spent looking for factors of n - 16 and the usefulness of the output (F may be as low as 2 in some cases).-A reasonable heuristic seems to be to choose limit to be some small multiple of  \log^3(n)/10 (e.g. 1, 2, 5 or 10) depending on how long one is prepared to wait, then to trial factor up to the limit. (See _fmpz_nm1_trial_factors.) Requires n to be odd.Flint2fmpz_is_prime_pseudosquare n Return 0 is n is composite. If n# is too large (greater than about 94/ bits) the function fails silently and returns -1, otherwise, if n6 is proven prime by the pseudosquares method, return 1. Tests if n' is a prime according to [Theorem 2.7]  [LukPatWil1996].We first factor N' using trial division up to some limit B. In fact, the number of primes used in the trial factoring is at most FLINT_PSEUDOSQUARES_CUTOFF.Next we compute N/B and find the next pseudosquare L_p1 above this value, using a static table as per  $https://oeis.org/A002189/b002189.txt.As noted in the text, if p is prime then Step 3 will pass. This test rejects many composites, and so by this time we suspect that p is prime. If N is 3 or 7 modulo 8, we are done, and N is prime.We now run a probable prime test, for which no known counterexamples are known, to reject any composites. We then proceed to prove N. prime by executing Step 4. In the case that N is 1 modulo 83, if Step 4 fails, we extend the number of primes p_i at Step 3 and hope to find one which passes Step 4. We take the test one past the largest p! for which we have pseudosquares L_p5 tabulated, as this already corresponds to the next L_p which is bigger than 2^{64}6 and hence larger than any prime we might be testing.5As explained in the text, Condition 4 cannot fail if N is prime.The possibility exists that the probable prime test declares a composite prime. However in that case an error is printed, as that would be of independent interest.Flint2fmpz_is_probabprime p Performs some trial division and then some probabilistic primality tests. If p/ is definitely composite, the function returns 0, otherwise it is declared probably prime, i.e. prime for most practical purposes, and the function returns 1;. The chance of declaring a composite prime is very small.Subsequent calls to the same function do not increase the probability of the number being prime.Flint2fmpz_is_probabprime_BPSW n Perform a Baillie-PSW probable prime test with parameters chosen by Selfridge's method A as per  [BaiWag1980].Return 1 if n- is a Lucas probable prime, otherwise return 0.There are no known composites passed as prime by this test, though infinitely many probably exist. The test will declare no primes composite.Flint2fmpz_is_probabprime_lucas n Performs a Lucas probable prime test with parameters chosen by Selfridge's method A as per  [BaiWag1980].Return 1 if n- is a Lucas probable prime, otherwise return 0. This function declares some composites probably prime, but no primes composite.Flint2fmpz_is_strong_probabprime n a Returns 1 if n$ is a strong probable prime to base a, otherwise it returns 0.Flint2fmpz_multi_CRT_clear P Free all space used by CRT.Flint2fmpz_multi_CRT output moduli values len Perform the same operation as fmpz_multi_CRT_precomp while internally constructing and destroying the precomputed data. All of the remarks in fmpz_multi_CRT_precompute apply.Flint2fmpz_multi_CRT_precomp output P inputs Set output to an integer of smallest absolute value that is congruent to  values + i modulo the  moduli + i in fmpz_crt_precompute.Flint2fmpz_multi_CRT_precompute CRT moduli len  Configure CRT& for repeated Chinese remaindering of moduli. The number of moduli, len", should be positive. A return of 0< indicates that the compilation failed and future calls to fmpz_crt_precomp/ will leave the output undefined. A return of 1 indicates that the compilation was successful, which occurs if and only if either (1) len == 1 and  modulus + 0" is nonzero, or (2) no modulus is 0,1,-1/ and all moduli are pairwise relatively prime.Flint2fmpz_multi_CRT_init CRT  Initialize CRT for Chinese remaindering.Flint2fmpz_comb_temp_clear temp Clears temporary space temp9 used by multimodular and CRT functions using the given comb structure.Flint2fmpz_comb_clear comb Clears the given comb) structure, releasing any memory it uses.Flint2fmpz_comb_temp_init temp comb Creates temporary space to be used by multimodular and CRT functions based on an initialised comb structure.Flint2fmpz_comb_init comb primes  num_primes Initialises a comb structure for multimodular reduction and recombination. The array primes is assumed to contain  num_primes primes each of FLINT_BITS - 1 bits. Modular reductions and recombinations will be done modulo this list of primes. The primes array must not be free 'd until the comb structure is no longer required and must be cleared by the user.Flint2fmpz_multi_CRT_ui output residues comb ctemp sign This function takes a set of residues modulo the list of primes contained in the comb structure and reconstructs a multiprecision integer modulo the product of the primes which has these residues modulo the corresponding primes.If N' is the product of all the primes then out# is normalised to be in the range [0, N) if sign = 0 and the range [-(N-1)/2, N/2] if sign = 1. The array temp/ is temporary space which must be provided by fmpz_comb_temp_init and cleared by fmpz_comb_temp_clear.Flint2fmpz_multi_mod_ui out in comb temp #Reduces the multiprecision integer in* modulo each of the primes stored in the comb structure. The array out will be filled with the residues modulo these primes. The structure temp/ is temporary space which must be provided by fmpz_comb_temp_init and cleared by fmpz_comb_temp_clear.Flint2fmpz_CRT out r1 m1 r2 m2 sign )Use the Chinese Remainder Theorem to set out to the unique value  0 \le x < M (if sign = 0) or -M/2 < x \le M/2 (if sign = 1) congruent to r_1 modulo m_1 and r_2 modulo m_2, where where M = m_1 \times m_2.It is assumed that m_1 and m_2% are positive integers greater than 1 and coprime. If sign = 0, it is assumed that 0 \le r_1 < m_1 and 0 \le r_2 < m_2!. Otherwise, it is assumed that -m_1 \le r_1 < m_1 and 0 \le r_2 < m_2.Flint2 fmpz_CRT_ui out r1 m1 r2 m2 sign Uses the Chinese Remainder Theorem to compute the unique integer  0 \le x < M (if sign = 0) or -M/2 < x \le M/2 (if sign = 1) congruent to r_1 modulo m_1 and r_2 modulo m_2, where where M = m_1 \times m_2 . The result x is stored in out.It is assumed that m_1 and m_2% are positive integers greater than 1 and coprime. If sign = 0, it is assumed that 0 \le r_1 < m_1 and 0 \le r_2 < m_2!. Otherwise, it is assumed that -m_1 \le r_1 < m_1 and 0 \le r_2 < m_2.Flint2 fmpz_popcnt a Returns the number of '1' bits in the given Z (aka Hamming weight or population count). The return value is undefined if the input is negative.Flint2fmpz_xor r a b Sets r# to the bit-wise logical exclusive or of a and b.Flint2fmpz_or r a b Sets r% to the bit-wise logical (inclusive) or of a and b.Flint2fmpz_and r a b Sets r to the bit-wise logical and of a and b.Flint2 fmpz_combit f i Complements the i th bit in f.Flint2 fmpz_clrbit f i  Sets the i th bit in f to zero.Flint2fmpz_complement r f  The variable r" is set to the ones-complement of f.Flint2fmpz_bit_unpack_unsigned coeff arr shift bits :A bit field of the given number of bits is extracted from arr, starting after shift bits, and placed into coeff. The value of shift is expected to be less than  FLINT_BITS.Flint2fmpz_bit_unpack coeff arr shift bits negate borrow :A bit field of the given number of bits is extracted from arr, starting after shift bits, and placed into coeff. An optional borrow of 1 may be added to the coefficient. If the result is negative, a borrow of 1% is returned. Finally, the resulting coeff may be negated by setting the negate parameter to -1. The value of shift is expected to be less than  FLINT_BITS.Flint2 fmpz_bit_pack arr shift bits coeff negate borrow ,Shifts the given coefficient to the left by shift% bits and adds it to the integer in arr( in a field of the given number of bits: 8shift bits -------------- X X X C C C C 0 0 0 0 0 0 0An optional borrow of 1 can be subtracted from coeff before it is packed. If coeff is negative after the borrow, then a borrow will be returned by the function. The value of shift is assumed to be less than  FLINT_BITS. All but the first shift bits of arr2 are assumed to be zero on entry to the function. The value of coeff may also be optionally (and notionally) negated before it is used, by setting the negate parameter to -1.Flint2fmpz_divides_mod_list xstart xstride xlength a b n Set xstart, xstride, and xlength( so that the solution set for x modulo n in  a x = b mod n is exactly *\{xstart + xstride i | 0 \le i < xlength\}. This function essentially gives a list of possibilities for the fraction a/b modulo n&. The outputs may not be aliased, and n should be positive.Flint2fmpz_kronecker a n Computes the Kronecker symbol \left(\frac{a}{n}\right) for any a and any n.Flint2 fmpz_jacobi a n Computes the Jacobi symbol \left(\frac{a}{n}\right) for any a and odd positive n.Flint2 fmpz_negmod f g h Sets f to  -g \pmod{h} , assuming g is reduced modulo h.Flint2 fmpz_invmod f g h Sets f to the inverse of g modulo h. The value of h may not be 0 otherwise an exception results. If the inverse exists the return value will be non-zero, otherwise the return value will be 0 and the value of f undefined. As a special case, we consider any number invertible modulo  h = \pm 1, with inverse 0.Flint2 fmpz_remove rop op f %Remove all occurrences of the factor f > 1 from the integer op and sets rop to the resulting integer.If op is zero, sets rop to op and returns 0. Returns an abort/ signal if any of the assumptions are violated.Flint2 _fmpz_remove x f finv Removes all factors f from x and returns the number of such. Assumes that x is non-zero, that f > 1 and that finv is the precomputed double inverse of f whenever f is a small integer and 0 otherwise.Does not support aliasing.Flint2fmpz_xgcd_partial co2 co1 r2 r1 L This function is an implementation of Lehmer extended GCD with early termination, as used in the qfb module. It terminates early when remainders fall below the specified bound. The initial values r1 and r2 are treated as successive remainders in the Euclidean algorithm and are replaced with the last two remainders computed. The values co1 and co26 are the last two cofactors and satisfy the identity co2*r1 - co1*r2 == +/- r2_orig upon termination, where r2_orig is the starting value of r2 supplied, and r1 and r2 are the final values.Aliasing of inputs is not allowed. Similarly aliasing of inputs and outputs is not allowed.Flint2fmpz_xgcd_canonical_bezout d a b f g Computes the extended GCD \mathrm{xgcd}(f, g) = (d, a, b) such that the solution is the canonical solution to Bzout's identity. We define the canonical solution to satisfy one of the following if one of the given conditions apply:\begin{aligned} \operatorname{xgcd}(\pm g, g) &= \bigl(|g|, 0, \operatorname{sgn}(g)\bigr)\\ \operatorname{xgcd}(f, 0) &= \bigl(|f|, \operatorname{sgn}(f), 0\bigr)\\ \operatorname{xgcd}(0, g) &= \bigl(|g|, 0, \operatorname{sgn}(g)\bigr)\\ \operatorname{xgcd}(f, \mp 1) &= (1, 0, \mp 1)\\ \operatorname{xgcd}(\mp 1, g) &= (1, \mp 1, 0)\quad g \neq 0, \pm 1\\ \operatorname{xgcd}(\mp 2 d, g) &= \bigl(d, {\textstyle\frac{d - |g|}{\mp 2 d}}, \operatorname{sgn}(g)\bigr)\\ \operatorname{xgcd}(f, \mp 2 d) &= \bigl(d, \operatorname{sgn}(f), {\textstyle\frac{d - |g|}{\mp 2 d}}\bigr). \end{aligned} If the pair (f, g)9 does not satisfy any of these conditions, the solution  (d, a, b) will satisfy the following:` |a| < \Bigl| \frac{g}{2 d} \Bigr|, \qquad |b| < \Bigl| \frac{f}{2 d} \Bigr|.4Assumes that there is no aliasing among the outputs.Flint2 fmpz_xgcd d a b f g Computes the extended GCD of f and g, i.e. the values a and b such that  af + bg = d, where d = \gcd(f, g). Here a will be the same as calling  fmpz_gcdinv when f < g (or vice versa for b when g < f).=To obtain the canonical solution to Bzout's identity, call fmpz_xgcd_canonical_bezout instead. This is also faster.4Assumes that there is no aliasing among the outputs.Flint2 fmpz_gcdinv d a f g Given integers f, g with  0 \leq f < g(, computes the greatest common divisor d = \gcd(f, g) and the modular inverse a = f^{-1} \pmod{g} , whenever f \neq 0. Assumes that d and a are not aliased.Flint2fmpz_lcm f g h Sets f! to the least common multiple of g and h4. The result is always nonnegative, even if one of g and h is negative.Flint2 fmpz_gcd3 f a b c Sets f# to the greatest common divisor of a, b and c!. This is equivalent to calling fmpz_gcd twice, but may be faster.Flint2fmpz_gcd f g h Sets f# to the greatest common divisor of g and h1. The result is always positive, even if one of g and h is negative.Flint2fmpz_mul_si_tdiv_q_2exp f g x exp Sets f to the product g and x divided by 2^exp, rounding down towards zero.Flint2fmpz_mul_tdiv_q_2exp f g h exp Sets f to the product g and h divided by 2^exp, rounding down towards zero.Flint2fmpz_rfac_uiui r x k Sets r to the rising factorial x (x+1) (x+2) \cdots (x+k-1).Flint2 fmpz_rfac_ui r x k Sets r to the rising factorial x (x+1) (x+2) \cdots (x+k-1).Flint2 _fmpz_rfac_ui r x a b Sets r to the rising factorial $(x+a) (x+a+1) (x+a+2) \cdots (x+b-1) . Assumes b > a.Flint2 fmpz_bin_uiui f n k Sets f to the binomial coefficient  {n \choose k}.Flint2 fmpz_fib_ui f n Sets f to the Fibonacci number F_n where n is an ulong.Flint2 fmpz_fac_ui f n Sets f to the factorial n! where n is an ulong.Flint2fmpz_is_perfect_power root f If f is a perfect power r^k set root to r and return k, otherwise return 0 . Note that -1, 0, 1 are all considered perfect powers. No guarantee is made about r or k8 being the smallest possible value. Negative values of f are permitted.Flint2 fmpz_root r f n Set r to the integer part of the n -th root of f. Requires that n > 0 and that if n is even then f be non-negative, otherwise an exception is raised. The function returns 1# if the root was exact, otherwise 0.Flint2fmpz_is_square f Returns nonzero if f( is a perfect square and zero otherwise.Flint2 fmpz_sqrtrem f r g Sets f+ to the integer part of the square root of g, where g* is assumed to be non-negative, and sets r, to the remainder, that is, the difference g - f^2. If g is negative, an exception is raised. The behaviour is undefined if f and r are aliases.Flint2 fmpz_sqrt f g Sets f+ to the integer part of the square root of g, where g$ is assumed to be non-negative. If g& is negative, an exception is raised.Flint2 fmpz_sqrtmod b a p If p is prime, set b to a square root of a modulo p if a is a quadratic residue modulo p and return 1, otherwise return 0.If p8 is not prime the return value is with high probability 0, indicating that p is not prime, or a is not a square modulo p. If p& is not prime and the return value is 1, the value of b is meaningless.Flint2 fmpz_dlog x Returns a double precision approximation of the natural logarithm of x.The accuracy depends on the implementation of the floating-point logarithm provided by the C standard library. The result can typically be expected to have a relative error no greater than 1-2 bits.Flint2 fmpz_flog x b Returns \lfloor\log_b x\rfloor. Assumes that x \geq 1 and b \geq 2/ and that the return value fits into a signed slong.Flint2 fmpz_clog x b Returns \lceil\log_b x\rceil. Assumes that x \geq 1 and b \geq 2/ and that the return value fits into a signed slong.Flint2 fmpz_powm f g e m Sets f to  g^e \bmod{m}. If e = 0, sets f to 1. Assumes that m \neq 0 , raises an abort signal otherwise.Flint2 fmpz_pow_fmpz f g x Sets f to g^x . Defines 0^0 = 1 . Return 1 for success and 0* for failure. The function throws only if x is negative.Flint2 fmpz_pow_ui f g x Sets f to g^x . Defines 0^0 = 1.Flint2fmpz_fdiv_qr_preinvn f s g h hinv As per  fmpz_fdiv_qr", but takes a precomputed inverse hinv of h constructed using  fmpz_preinvn."This function will be faster than fmpz_fdiv_qr_preinvn when the number of limbs of h is at least PREINVN_CUTOFF.Flint2fmpz_preinvn_clear inv Clean up the resources used by a precomputed inverse created with the fmpz_preinvn_init function.Flint2fmpz_preinvn_init inv f Compute a precomputed inverse inv of f for use in the preinvn functions listed below.Flint2 fmpz_smod f g h Sets f to the signed remainder y \equiv g \bmod h satisfying ,-\lvert h \rvert/2 < y \leq \lvert h\rvert/2.Flint2 fmpz_mod_ui f g h Sets f to the remainder of g divided by h such that the remainder is positive and also returns this value. Raises an exception if h is zero.Flint2fmpz_mod f g h Sets f to the remainder of g divided by h4 such that the remainder is positive. Assumes that h is not zero.Flint2 fmpz_divides q g h Returns 1 if there is an integer q with f = q g and sets q$ to the quotient. Otherwise returns 0 and sets q to 0.Flint2fmpz_divisible_si f g Returns 1 if there is an integer q with f = q g and 0 if there is none.Flint2fmpz_divexact2_uiui f g x y Sets f to the quotient of g and h = x \times y, assuming that the division is exact, i.e.(g) is a multiple of h. If x or y is 0 an exception is raised.Flint2fmpz_divexact_ui f g h Sets f to the quotient of g and h, assuming that the division is exact, i.e.(g) is a multiple of h. If h is 0 an exception is raised.Flint2 fmpz_tdiv_ui g h (Returns the absolute value remainder of g divided by h:, following the convention of rounding as seen above. If h! is zero an exception is raised.Flint2fmpz_tdiv_r_2exp s g exp Sets f to the quotient of g by h and/or s to the remainder. For the 2exp functions,  g = 2^exp.  If :math:`h is 0 an exception is raised.&Rounding is made in the following way:fdiv( rounds the quotient via floor rounding.cdiv' rounds the quotient via ceil rounding.tdiv rounds the quotient via truncation, i.e. rounding towards zero.ndiv rounds the quotient such that the remainder has the smallest absolute value. In case of ties, it rounds the quotient towards zero.Flint2 fmpz_fmms f a b c d Sets f to a \times b - c \times d.Flint2 fmpz_fmma f a b c d Sets f to a \times b + c \times d.Flint2 fmpz_submul f g h Sets f to f - g \times h.Flint2 fmpz_addmul f g h Sets f to f + g \times h.Flint2 fmpz_one_2exp f e Sets f to 2^e.Flint2 fmpz_mul_2exp f g e Sets f to  g \times 2^e.Note: Assumes that e + FLINT_BITS does not overflow.Flint2fmpz_mul2_uiui f g x y Sets f to g \times x \times y where x and y are of type ulong.Flint2fmpz_mul f g h Sets f to  g \times h.Flint2fmpz_sub f g h Sets f to g - h.Flint2fmpz_add f g h Sets f to g + h.Flint2fmpz_abs f1 f2 Sets f_1 to the absolute value of f_2.Flint2fmpz_neg f1 f2 Sets f_1 to -f_2.Flint2 fmpz_is_odd f Returns whether the integer f is odd.Flint2 fmpz_is_even f Returns whether the integer f is even.Flint2 fmpz_is_pm1 f Returns 1 if f2 is equal to one or minus one, otherwise returns 0.Flint2 fmpz_is_one f Returns 1 if f$ is equal to one, otherwise returns 0.Flint2 fmpz_is_zero f Returns 1 if f is 0, otherwise returns 0.Flint2 fmpz_equal_si f g Returns 1 if f is equal to g, otherwise returns 0.Flint2 fmpz_cmp2abs f g Returns a negative value if  \lvert f\rvert < \lvert 2g\rvert, positive value if !\lvert 2g\rvert < \lvert f \rvert, otherwise returns 0.Flint2 fmpz_cmpabs f g Returns a negative value if \lvert f\rvert < \lvert g\rvert, positive value if  \lvert g\rvert < \lvert f \rvert, otherwise returns 0.Flint2 fmpz_cmp_si f g Returns a negative value if f < g, positive value if g < f, otherwise returns 0.Flint2fmpz_abs_ubound_ui_2exp exp x bits  For nonzero x, returns a mantissa m with exactly bits bits and sets exp to an exponent e , such that  |x| \le m 2^e,. The number of bits must be between 1 and  FLINT_BITS inclusive. The mantissa is either correctly rounded or one unit too large (possibly meaning that the exponent is one too large, if the mantissa is a power of two).Flint2fmpz_abs_lbound_ui_2exp exp x bits  For nonzero x, returns a mantissa m with exactly bits bits and sets exp to an exponent e , such that  |x| \ge m 2^e,. The number of bits must be between 1 and  FLINT_BITS inclusive. The mantissa is guaranteed to be correctly rounded.Flint2 fmpz_tstbit f i Test bit index i of f and return 0 or 1, accordingly.Flint2 fmpz_setbit f i Sets bit index i of f.Flint2 fmpz_fits_si f Returns whether the value of f fits into a slong.Flint2fmpz_abs_fits_ui f &Returns whether the absolute value of f fits into an ulong.Flint2fmpz_one f Sets f to one.Flint2 fmpz_zero f Sets f to zero.Flint2fmpz_set f g Sets f to the same value as g.Flint2 fmpz_swap f g Efficiently swaps f and g. No data is copied.Flint2 fmpz_val2 f :Returns the exponent of the largest power of two dividing f, or equivalently the number of trailing zeros in the binary expansion of f. If f is zero then 0 is returned.Flint2fmpz_sgn f Returns -1 if the sign of f is negative, +1' if it is positive, otherwise returns 0.Flint2 fmpz_size f Returns the number of limbs required to store the absolute value of f. If f is zero then 0 is returned.Flint2 fmpz_bits f Returns the number of bits required to store the absolute value of f. If f is 0 then 0 is returned.Flint2fmpz_sizeinbase f b *Returns the size of the absolute value of f in base b+, measured in numbers of digits. The base b can be between 2 and 62 , inclusive. Flint2 fmpz_out_raw fout x Writes the value x to file. The value is written in raw binary format. The integer is written in portable format, with 4 bytes of size information, and that many bytes of limbs. Both the size and the limbs are written in decreasing significance order (i.e., in big-endian).The output can be read with  fmpz_inp_raw.In case of success, return a positive number, indicating number of bytes written. In case of failure, return 0.'The output of this can also be read by  mpz_inp_raw/ from GMP >= 2, Since this function calls the  mpz_inp_raw function in library gmp. Flint2 fmpz_fprint file x Prints the value x to file, without a carriage return(CR). The value is printed as either 0, the decimal digits of a positive integer, or a minus sign followed by the digits of a negative integer.In case of success, returns a positive number. In case of failure, returns a non-positive number.=This convention is adopted in light of the return values of  flint_printf from the standard library and  mpz_out_str from MPIR. Flint2 fmpz_inp_raw x fin /Reads a multiprecision integer from the stream file,. The format is raw binary format write by  fmpz_out_raw.In case of success, return a positive number, indicating number of bytes read. In case of failure 0.This function calls the  mpz_inp_raw function in library gmp. So that it can read the raw data written by  mpz_inp_raw directly. Flint2 fmpz_fread file f /Reads a multiprecision integer from the stream file. The format is an optional minus sign, followed by one or more digits. The first digit should be non-zero unless it is the only digit.In case of success, returns a positive number. In case of failure, returns a non-positive number.. This will give a signed two's complement representation of in (assuming in doesn't overflow the array). Flint2fmpz_get_ui_array out n in &Assuming that the nonnegative integer in! can be represented in the form .out[0] + out[1]*X + ... + out[n - 1]*X^(n - 1) , where X = 2^{FLINT\_BITS}%, sets the corresponding elements of out+ so that this is true. It is assumed that n > 0. Flint2fmpz_set_signed_ui_array out in n Sets out to the integer represented in in[0], ..., in[n - 1], as a signed two's complement integer with n * FLINT_BITS bits. It is assumed that n > 0&. The function operates as a call to fmpz_set_ui_array+ followed by a symmetric remainder modulo 2^(n*FLINT\_BITS). Flint2fmpz_set_ui_array out in n Sets out to the nonnegative integer ,in[0] + in[1]*X + ... + in[n - 1]*X^(n - 1) where X = 2^FLINT_BITS. It is assumed that n > 0. Flint2fmpz_set_signed_uiuiui f hi mid lo Sets f to lo, plus mid shifted to the left by  FLINT_BITS, plus hi shifted to the left by  2*FLINT_BITS> bits, interpreted as a signed two's complement integer with 3 * FLINT_BITS bits. Flint2fmpz_set_signed_uiui f hi lo Sets f to lo, plus hi shifted to the left by  FLINT_BITS9, interpreted as a signed two's complement integer with 2 * FLINT_BITS bits. Flint2 fmpz_neg_uiui f hi lo Sets f to lo, plus hi shifted to the left by  FLINT_BITS, and then negates f. Flint2 fmpz_set_uiui f hi lo Sets f to lo, plus hi shifted to the left by  FLINT_BITS. Flint2 fmpz_neg_ui f val Sets f to the given ulong value, and then negates f. Flint2fmpz_set_d_2exp f d exp Sets f to the nearest integer to  d 2^{exp}. Flint2 fmpz_set_d f c Sets f to the double c., rounding down towards zero if the value of c, is fractional. The outcome is undefined if c* is infinite, not-a-number, or subnormal. Flint2 fmpz_set_ui f val Sets f to the given ulong value. Flint2 fmpz_set_si f val Sets f to the given slong value. Flint2 fmpz_get_str str b f Returns the representation of f in base b, which can vary between 2 and 62 , inclusive.If str is NULL, the result string is allocated by the function. Otherwise, it is up to the caller to ensure that the allocated block of memory is sufficiently large. Flint2 fmpz_get_mpn n n_in  Sets the mp_ptr n to the same value as n_{in}4. Returned integer is number of limbs allocated to n, minimum number of limbs required to hold the value stored in n_{in}. Flint2 fmpz_get_mpz x f  Sets the mpz_t x to the same value as f. Flint2fmpz_get_d_2exp exp f Returns f as a normalized double along with a 2 -exponent exp , i.e.if r is the return value then  f = r 2^{exp}, to within 1 ULP. Flint2 fmpz_get_mpfr x f rnd Sets the value of x from f&, rounded toward the given direction rnd. Flint2 fmpz_get_mpf x f Sets the value of the mpf_t x to the value of f. Flint2 fmpz_set_mpf f x Sets f to the mpf_t x., rounding down towards zero if the value of x is fractional. Flint2 fmpz_get_d f Returns f as a double , rounding down towards zero if f= cannot be represented exactly. The outcome is undefined if f6 is too large to fit in the normal range of a double. Flint2 fmpz_get_nmod f mod Returns f \mod n. Flint2 fmpz_get_uiui hi low f If f consists of two limbs, then *hi and *low/ are set to the high and low limbs, otherwise *low is set to the low limb and *hi is set to 0. Flint2 fmpz_get_ui f Returns f as an ulong. The result is undefined if f does not fit into an ulong or is negative. Flint2 fmpz_get_si f Returns f as a slong. The result is undefined if f does not fit into a slong. Flint2fmpz_randprime f state bits proved >Generates a random prime number with the given number of bits.The generation is performed by choosing a random number and then finding the next largest prime, and therefore does not quite give a uniform distribution over the set of primes with that many bits.Random number generation is performed using the standard Flint random number generator, which is not suitable for cryptographic use.If proved is nonzero, then the integer returned is guaranteed to actually be prime. Flint2fmpz_randtest_mod_signed f state m (Generates a random integer in the range  (-m/2, m/2], with an increased probability of generating values close to the endpoints or close to zero. Flint2fmpz_randtest_mod f state m (Generates a random integer in the range 0 to m - 1 inclusive, with an increased probability of generating values close to the endpoints. Flint2 fmpz_randm f state m (Generates a random integer in the range 0 to m - 1 inclusive. Flint2fmpz_randtest_not_zero f state bits As per  fmpz_randtest, but the result will not be 0. If bits is set to 0, an exception will result. Flint2fmpz_randtest_unsigned f state bits Generates a random unsigned integer whose value has a number of bits which is random from 0 up to bits inclusive. Flint2 fmpz_randtest f state bits Generates a random signed integer whose absolute value has a number of bits which is random from 0 up to bits inclusive. Flint2 fmpz_randbits f state bits Generates a random signed integer whose absolute value has precisely the given number of bits. Flint2fmpz_init_set_si f g  Initialises f and sets it to the value of g. Flint2 fmpz_clear f Clears the given fmpz_t, releasing any memory associated with it, either back to the stack or the OS, depending on whether the reentrant or non-reentrant version of FLINT is built. Flint2 fmpz_init2 f limbs Initialises the given fmpz_t. to have space for the given number of limbs.If limbs is zero then a small fmpz_t is allocated, i.e.just a slong. The value is also set to zero. It is not necessary to call this function except to save time. A call to  fmpz_init will do just fine. Flint2 fmpz_init f A small fmpz_t is initialised, i.e.just a slong. The value is set to zero. Flint2_fmpz_demote_val f if f represents an mpz_t and its value will fit in an slong, preserve the value in f which we make to represent an slong, and clear the mpz_t. Flint2 _fmpz_demote f if f represents an mpz_t clear it and make f just represent an slong. Flint2_fmpz_promote_val f if f doesn't represent an mpz_t&, initialise one and associate it to f, but preserve the value of f.1This function is for internal use. The resulting fmpz will be backed by an mpz_t$ that can be passed to GMP, but the fmpz will be in an inconsistent state with respect to the other Flint fmpz functions such as  fmpz_is_zero, etc. Flint2 _fmpz_promote f if f doesn't represent an mpz_t&, initialise one and associate it to f. Flint2 _fmpz_cleanup 7this function does nothing in the reentrant version of fmpz. Flint2_fmpz_cleanup_mpz_content 7this function does nothing in the reentrant version of fmpz. Flint2 _fmpz_new_mpz initialises a new mpz_t< and returns a pointer to it. This is only used internally. Flint2newFmpz Create a new . Flint2withFmpz x fApply f to x. Flint2 withNewFmpz fApply f to a new . Flint2 fmpz_print x Prints the value x to stdout, without a carriage return(CR). The value is printed as either 0, the decimal digits of a positive integer, or a minus sign followed by the digits of a negative integer.In case of success, returns a positive number. In case of failure, returns a non-positive number.=This convention is adopted in light of the return values of  flint_printf from the standard library and  mpz_out_str from MPIR.   Safe-Inferred )*1       Safe-Inferred )*1E Flint2fmpzi_gcd_euclidean res x y Computes the GCD of x and y'. The result is in canonical unit form.The  euclidean version is a straightforward implementation of Euclid's algorithm. The euclidean_improved version is optimized by performing approximate divisions. The binary version uses a (1+i)-ary analog of the binary GCD algorithm for integers  [Wei2000]. The shortest version finds the GCD as the shortest vector in a lattice. The default version chooses an algorithm automatically. Flint2fmpzi_remove_one_plus_i res x Divide x' exactly by the largest possible power (1+i)^k and return the exponent k. Flint2fmpzi_divrem_approx q r x y -Computes a quotient and remainder satisfying  x = q y + r with  N(r) < N(y), with an implementation-defined, non-canonical choice of remainder. Flint2 fmpzi_divrem q r x y -Computes a quotient and remainder satisfying  x = q y + r with N(r) \le N(y)/2;, with a canonical choice of remainder when breaking ties. Flint2fmpzi_divexact q x y Sets q to the quotient of x and y', assuming that the division is exact. Flint2Create  . Flint2Create  . Flint2Use  Flint2Use real part of  Flint2Use imaginary part of  Flint2Use new  )  Safe-Inferred )*1) )  Safe-Inferred )*1   Safe-Inferred )*19 Flint2_mpoly_heap_pop1 heap heap_len maskhi As per _mpoly_heap_pop1 except that N = 1, and maskhi = cmpmask[0]. Flint2_mpoly_heap_pop heap heap_len N maskhi masklo *Pop the head of the heap. It is cast to a void *>. A pointer to the current heap length must be passed in via heap_len. This will be updated by the function. Note that the index 0 position in the heap is not used, so the length is always one greater than the number of elements. The maskhi and masklo values are zero except for degrevlex ordering, where they are as per the monomial comparison operations above. Flint2_mpoly_heap_insert1 heap exp x heap_len maskhi As per _mpoly_heap_insert except that N = 1, and maskhi = cmpmask[0]. Flint2_mpoly_heap_insert heap exp x heap_len N cmpmask  Given a heap, insert a new node x corresponding to the given exponent into the heap. Heap elements are ordered by the exponent (exp, N), with the largest element at the head of the heap. A pointer to the current heap length must be passed in via heap_len. This will be updated by the function. Note that the index 0 position in the heap is not used, so the length is always one greater than the number of elements. Flint2mpoly_main_variable_terms1 i1 n1 exp1 l1 len1 k num bits #Given an array of exponent vectors  (exp1, len1), each exponent vector taking one word of space, with each exponent being packed into the given number of bits, compute l1 starting offsets i1 and lengths n1 (which may be zero) to break the exponents into chunks. Each chunk consists of exponents have the same degree in the main variable. The index of the main variable is given by k. The variables are indexed from the variable of least significance, starting from 0 . The value l15 should be the degree in the main variable, plus one. Flint2mpoly_unpack_monomials_tight e1 e2 len mults num extra bits #Given an array of exponent vectors e2 of length len packed using a factorial numbering scheme, unpack the monomials into an array e1 of exponent vectors in standard packed format, where each field has the given number of bits. The "bases" for the factorial numbering scheme are given as an array of integers mults, the first entry of which corresponds to the field of least significance in each exponent vector.&The number of multipliers is given by num-. The code only considers least significant num fields of each exponent vectors and ignores the rest. The number of ignored fields should be passed in extras. Flint2mpoly_pack_monomials_tight exp1 exp2 len mults num extra bits 3Given an array of possibly packed exponent vectors exp2 of length len, where each field of each exponent vector is packed into the given number of bits, return the corresponding array of monomial vectors packed using a factorial numbering scheme. The "bases" for the factorial numbering scheme are given as an array of integers mults, the first entry of which corresponds to the field of least significance in each input exponent vector. Obviously the maximum exponent to be packed must be less than the corresponding base in mults.&The number of multipliers is given by num-. The code only considers least significant num fields of each exponent vectors and ignores the rest. The number of ignored fields should be passed in extras. Flint2mpoly_repack_monomials exps1 bits1 exps2 bits2 len mctx Convert an array of length len of exponents exps2 packed using bits bits2 into an array exps1 using bits bits1. No checking is done to ensure that the result fits into bits bits1. Flint2mpoly_unpack_vec_fmpz exp1 exp2 bits nfields len Unpacks vector exp2 of bit count bits into exp1*. The number of fields in each vector is nfields/ and the total number of vectors to unpack is len. Flint2mpoly_unpack_vec_ui exp1 exp2 bits nfields len Unpacks vector exp2 of bit count bits into exp1*. The number of fields in each vector is nfields/ and the total number of vectors to unpack is len. Flint2mpoly_pack_vec_fmpz exp1 exp2 bits nfields len Packs a vector exp2" into {exp1} using a bit count of bits. No checking is done to ensure that the vector actually fits into bits/ bits. The number of fields in each vector is nfields/ and the total number of vectors to unpack is len. Flint2mpoly_pack_vec_ui exp1 exp2 bits nfields len Packs a vector exp2" into {exp1} using a bit count of bits. No checking is done to ensure that the vector actually fits into bits/ bits. The number of fields in each vector is nfields/ and the total number of vectors to unpack is len. Flint2mpoly_set_monomial_pfmpz exp1 exp2 bits mctx Convert the user monomial exp2 to packed format using bits. Flint2mpoly_set_monomial_ffmpz exp1 exp2 bits mctx Convert the user monomial exp2 to packed format using bits. Flint2mpoly_set_monomial_ui exp1 exp2 bits mctx Convert the user monomial exp2 to packed format using bits. Flint2mpoly_get_monomial_pfmpz exps  poly_exps bits mctx Convert the packed exponent  poly_exps of bit count bits, to a monomial from the user's perspective. Flint2mpoly_get_monomial_ffmpz exps  poly_exps bits mctx Convert the packed exponent  poly_exps of bit count bits, to a monomial from the user's perspective. Flint2mpoly_get_monomial_ui exps  poly_exps bits mctx Convert the packed exponent  poly_exps of bit count bits to a monomial from the user's perspective. The exponents are assumed to fit a ulong. Flint2mpoly_term_exp_fits_si exps bits n mctx ;Return whether every entry of the exponent vector of index n in exps fits into a slong. Flint2mpoly_term_exp_fits_ui exps bits n mctx ;Return whether every entry of the exponent vector of index n in exps fits into a ulong. Flint2mpoly_search_monomials e_ind e e_score t1 t2 t3 lower upper a a_len b b_len N cmpmask Given packed exponent vectors a and b, compute a packed exponent e9 such that the number of monomials in the cross product a X b! that are less than or equal to e is between lower and upper. This number is stored in e_store. If no such monomial exists, one is chosen so that the number of monomials is as close as possible. This function assumes that 11 is the smallest monomial and needs three arrays t1, t2, and t3 of the size as a for workspace. The parameter e_ind is set to one of t1, t2, and t3. and gives the locations of the monomials in a X b. Flint2mpoly_monomial_exists index  poly_exps exp len N cmpmask *Returns true if the given exponent vector exp* exists in the array of exponent vectors (poly_exps, len), otherwise, returns false. If the exponent vector is found, its index into the array of exponent vectors is returned. Otherwise, index is set to the index where this exponent could be inserted to preserve the ordering. The index can be in the range [0, len]. Flint2mpoly_max_degrees_tight max_exp exps len prods num Return an array of num integers corresponding to the maximum degrees of the exponents in the array of exponent vectors  (exps, len), assuming that the exponent are packed in a factorial representation. The array  (prods, num) should consist of 1, b_1, b_1\times b_2, \ldots , where the b_i are the bases of the factorial number representation. The results are stored in the array max_exp, with the entry corresponding to the most significant base of the factorial representation first in the array. Flint2mpoly_max_fields_fmpz  max_fields  poly_exps len bits mctx 8Compute the field-wise maximum of packed exponents from  poly_exps of length len and unpack the result into  max_fields. Flint2mpoly_max_fields_ui_sp  max_fields  poly_exps len bits mctx 8Compute the field-wise maximum of packed exponents from  poly_exps of length len and unpack the result into  max_fields+. The maximums are assumed to fit a ulong. Flint2mpoly_exp_bits_required_pfmpz user_exp mctx -Returns the number of bits required to store user_exp in packed format. The returned number of bits includes space for a zeroed signed bit. Flint2mpoly_exp_bits_required_ffmpz user_exp mctx -Returns the number of bits required to store user_exp in packed format. The returned number of bits includes space for a zeroed signed bit. Flint2mpoly_exp_bits_required_ui user_exp mctx -Returns the number of bits required to store user_exp in packed format. The returned number of bits includes space for a zeroed signed bit. Flint2mpoly_monomial_divides_tight e1 e2 prods num Return 1 if the monomial e2 divides the monomial e1, where the monomials are stored using factorial representation. The array  (prods, num) should consist of 1, b_1, b_1\times b_2, \ldots , where the b_i6 are the bases of the factorial number representation. Flint2mpoly_monomial_divides1 exp_ptr exp2 exp3 mask As per mpoly_monomial_divides with N = 1. Flint2mpoly_monomial_divides_mp exp_ptr exp2 exp3 N bits Return 1 if the monomial  (exp3, N) divides  (exp2, N) . If so set  (exp_ptr, N)) to the quotient monomial. Assumes that bits >= FLINT_BITS. Flint2mpoly_monomial_divides exp_ptr exp2 exp3 N mask Return 1 if the monomial  (exp3, N) divides  (exp2, N) . If so set  (exp_ptr, N) to the quotient monomial. The mask is a word with the high bit of each bit field set to 1. Assumes that bits <= FLINT_BITS. Flint2mpoly_monomial_cmp exp2 exp3 N cmpmask Return 1 if  (exp2, N) is greater than, 0 if it is equal to and -1 if it is less than  (exp3, N). Flint2mpoly_monomial_gt exp2 exp3 N cmpmask  Return 1 if  (exp2, N) is greater than  (exp3, N). Flint2mpoly_monomial_lt exp2 exp3 N cmpmask  Return 1 if  (exp2, N) is less than  (exp3, N). Flint2mpoly_get_cmpmask cmpmask N bits mctx  Get the mask  (cmpmask, N) for comparisons. bits should be set to the number of bits in the exponents to be compared. Any function that compares monomials should use this comparison mask. Flint2mpoly_monomial_equal exp2 exp3 N Return 1 if the monomials  (exp2, N) and  (exp3, N) are equal. Flint2mpoly_monomial_is_zero exp N  Return 1 if (exp, N) is zero. Flint2mpoly_monomial_mul_ui exp2 exp3 N c Set the words of  (exp2, N) to the words of  (exp3, N) multiplied by c. Flint2mpoly_monomial_swap exp2 exp3 N Swap the words in  (exp2, N) and  (exp3, N). Flint2mpoly_monomial_set exp2 exp3 N Set the monomial  (exp2, N) to  (exp3, N). Flint2mpoly_monomial_overflows1 exp mask As per mpoly_monomial_overflows with N = 1. Flint2mpoly_monomial_overflows_mp exp_ptr N bits 7Return true if any of the fields of the given monomial  (exp_ptr, N) has overflowed. Assumes that bits >= FLINT_BITS. Flint2mpoly_monomial_overflows exp2 N mask 7Return true if any of the fields of the given monomial  (exp2, N)' has overflowed (or is negative). The mask is a word with the high bit of each field set to 1. In other words, the function returns 1 if any word of exp2 has any of the nonzero bits in mask set. Assumes that bits <= FLINT_BITS. Flint2mpoly_monomial_sub_mp exp_ptr exp2 exp3 N Set  (exp_ptr, N)$ to the difference of the monomials  (exp2, N) and  (exp3, N). Flint2mpoly_monomial_sub exp_ptr exp2 exp3 N Set  (exp_ptr, N)$ to the difference of the monomials  (exp2, N) and  (exp3, N) , assuming bits <= FLINT_BITS Flint2mpoly_monomial_add_mp exp_ptr exp2 exp3 N Set  (exp_ptr, N) to the sum of the monomials  (exp2, N) and  (exp3, N). Flint2mpoly_monomial_add exp_ptr exp2 exp3 N Set  (exp_ptr, N) to the sum of the monomials  (exp2, N) and  (exp3, N) , assuming bits <= FLINT_BITS Flint2mpoly_ordering_print ord Print a string (either "lex", "deglex" or "degrevlex") to standard output, corresponding to the given ordering. Flint2mpoly_ordering_isrev ord Return 1 if the given ordering is a reverse ordering (currently only degrevlex). Flint2mpoly_ordering_isdeg ord Return 1 if the given ordering is a degree ordering (deglex or degrevlex). Flint2mpoly_ctx_init_rand mctx state  max_nvars ;Initialize a context with a random choice for the ordering. Flint2mpoly_ordering_randtest state 0Return a random ordering. The possibilities are ORD_LEX,  ORD_DEGLEX and  ORD_DEGREVLEX. Flint2mpoly_ctx_clear mctx ,Clean up any space used by a context object. Flint2mpoly_ctx_init ctx nvars ord Initialize a context for specified number of variables and ordering. Flint2 Create a new   structure. Flint2 Use a new   structure.  Safe-Inferred )*1p  Safe-Inferred )*1R# Flint2&nmod_mpoly_divrem_ideal_monagan_pearce q r poly2 poly3 len ctx This function is as per  nmod_mpoly_divrem_monagan_pearce7 except that it takes an array of divisor polynomials poly33, and it returns an array of quotient polynomials q. The number of divisor (and hence quotient) polynomials, is given by len%. The function computes polynomials  q_i = q[i] such that poly2 is &r + \sum_{i=0}^{\mbox{len - 1}} q_ib_i, where b_i = poly3[i]. Flint2 nmod_mpoly_divrem_monagan_pearce q r poly2 poly3 ctx Set polyq and polyr" to the quotient and remainder of poly2 divided by poly3, (with remainder coefficients reduced modulo the leading coefficient of poly3). Implements "Polynomial division using dynamic arrays, heaps and packed exponents" by Michael Monagan and Roman Pearce. Flint2nmod_mpoly_div_monagan_pearce polyq poly2 poly3 ctx Set polyq to the quotient of poly2 by poly3, discarding the remainder (with notional remainder coefficients reduced modulo the leading coefficient of poly3). Implements "Polynomial division using dynamic arrays, heaps and packed exponents" by Michael Monagan and Roman Pearce. This function is exceptionally efficient if the division is known to be exact. Flint2nmod_mpoly_pow_rmul A B k ctx Set A to B raised to the k*-th power using repeated multiplications. Flint2!nmod_mpoly_univar_swap_term_coeff c A i ctx Set (resp. swap) c7 to (resp. with) the coefficient of the term of index i of A. Flint2 nmod_mpoly_univar_get_term_coeff c A i ctx Flint2!nmod_mpoly_univar_get_term_exp_si A i ctx )Return the exponent of the term of index i of A. Flint2nmod_mpoly_univar_length A ctx Return the number of terms in A# with respect to the main variable. Flint2 nmod_mpoly_univar_degree_fits_si A ctx Return 1 if the degree of A, with respect to the main variable fits an slong. Otherwise, return 0. Flint2nmod_mpoly_from_univar A B var ctx Set A to the normal form of B& by putting in the variable of index var4. This function is undefined if the coefficients of B" depend on the variable of index var. Flint2nmod_mpoly_to_univar A B var ctx Set A to a univariate form of B' by pulling out the variable of index var. The coefficients of A" will still belong to the content ctx/ but will not depend on the variable of index var. Flint2nmod_mpoly_univar_swap A B ctx Swap A and B. Flint2nmod_mpoly_univar_clear A ctx Clear A. Flint2nmod_mpoly_univar_init A ctx  Initialize A. Flint2nmod_mpoly_quadratic_root Q A B ctx If Q^2+AQ=B has a solution, set Q to a solution and return 1, otherwise return 0. Flint2nmod_mpoly_is_square A ctx Return 1 if A' is a perfect square, otherwise return 0. Flint2nmod_mpoly_sqrt Q A ctx If Q^2=A has a solution, set Q to a solution and return 1, otherwise return 0 and set Q to zero. Flint2nmod_mpoly_discriminant D A var ctx  Try to set D to the discriminant of A( with respect to the variable of index var. Flint2nmod_mpoly_resultant R A B var ctx  Try to set R to the resultant of A and B( with respect to the variable of index var. Flint2nmod_mpoly_gcd_zippel G A B ctx  Try to set G to the GCD of A and B using various algorithms. Flint2nmod_mpoly_gcd_hensel G A B ctx Flint2nmod_mpoly_gcd_brown G A B ctx Flint2nmod_mpoly_gcd_cofactors G Abar Bbar A B ctx Do the operation of nmod_mpoly_gcd and also compute  Abar = A/G and  Bbar = B/G if successful. Flint2nmod_mpoly_gcd G A B ctx  Try to set G to the monic GCD of A and B. The GCD of zero and zero is defined to be zero. If the return is 17 the function was successful. Otherwise the return is 0 and G is left untouched. Flint2nmod_mpoly_content_vars g A vars  vars_length ctx Set g# to the GCD of the coefficients of A/ when viewed as a polynomial in the variables vars . Return 1 for success and 0 for failure. Upon success, g' will be independent of the variables vars. Flint2nmod_mpoly_term_content M A ctx Set M to the GCD of the terms of A. If A is zero, M will be zero. Otherwise, M) will be a monomial with coefficient one. Flint2 nmod_mpoly_divides_heap_threaded Q A B ctx Do the operation of nmod_mpoly_divides using a heap and multiple threads. This function should only be called once global_thread_pool has been initialized. Flint2!nmod_mpoly_divides_monagan_pearce Q A B ctx Do the operation of nmod_mpoly_divides: using the algorithm of Michael Monagan and Roman Pearce. Flint2nmod_mpoly_divides_dense Q A B ctx Try to do the operation of nmod_mpoly_divides0 using univariate arithmetic. If the return is -1, the operation was unsuccessful. Otherwise, it was successful and the return is 0 or 1. Flint2nmod_mpoly_divrem_ideal Q R A B len ctx This function is as per nmod_mpoly_divrem7 except that it takes an array of divisor polynomials B2 and it returns an array of quotient polynomials Q. The number of divisor (and hence quotient) polynomials, is given by len. Flint2nmod_mpoly_divrem Q R A B ctx Set Q and R" to the quotient and remainder of A divided by B. Flint2nmod_mpoly_div Q A B ctx Set Q to the quotient of A by B, discarding the remainder. Flint2nmod_mpoly_divides Q A B ctx If A is divisible by B, set Q# to the exact quotient and return 1. Otherwise, set Q to zero and return 0. Note that the function nmod_mpoly_div; below may be faster if the quotient is known to be exact. Flint2nmod_mpoly_pow_ui A B k ctx Set A to B raised to the k-th power. Return 1 for success and 0 for failure. Flint2nmod_mpoly_pow_fmpz A B k ctx Set A to B raised to the k-th power. Return 1 for success and 0 for failure. Flint2nmod_mpoly_mul_dense A B C ctx  Try to set A to  B \times C0 using univariate arithmetic. If the return is 0, the operation was unsuccessful. Otherwise, it was successful and the return is 1. Flint2nmod_mpoly_mul_array_threaded A B C ctx  Try to set A to  B \times C using arrays. If the return is 0, the operation was unsuccessful. Otherwise, it was successful, and the return is 1+. The first version always uses one thread. Flint2nmod_mpoly_mul_array A B C ctx Flint2nmod_mpoly_mul_heap_threaded A B C ctx Set A to  B \times C using Johnson's heap-based method. The first version always uses one thread. Flint2nmod_mpoly_mul_johnson A B C ctx Flint2nmod_mpoly_mul A B C ctx Set A to  B \times C. Flint2!nmod_mpoly_compose_nmod_mpoly_gen A B c ctxB ctxAC Set A to the evaluation of B where the variable of index i in ctxB& is replaced by the variable of index c[i] in ctxAC. The length of the array C is the number of variables in ctxB . If any c[i], is negative, the corresponding variable of B6 is replaced by zero. Otherwise, it is expected that c[i]* is less than the number of variables in ctxAC. Flint2nmod_mpoly_compose_nmod_mpoly A B C ctxB ctxAC Set A to the evaluation of B where the variables are replaced by the corresponding elements of the array C. Both A and the elements of C have context object ctxAC, while B has context object ctxB. Neither of A and B3 is allowed to alias any other polynomial. Return 1 for success and 0 for failure. The main method attempts to perform the calculation using matrices and chooses heuristically between the  geobucket and horner methods if needed. Flint2$nmod_mpoly_compose_nmod_mpoly_horner A B C ctxB ctxAC Flint2'nmod_mpoly_compose_nmod_mpoly_geobucket A B C ctxB ctxAC Flint2nmod_mpoly_compose_nmod_poly A B C ctx Set A to the evaluation of B where the variables are replaced by the corresponding elements of the array C. The context object of B is ctxB . Return 1 for success and 0 for failure. Flint2nmod_mpoly_evaluate_one_ui A B var val ctx Set A to the evaluation of B where the variable of index var is replaced by val. Flint2nmod_mpoly_evaluate_all_ui A vals ctx Return the evaluation of A where the variables are replaced by the corresponding elements of the array vals. Flint2nmod_mpoly_derivative A B var ctx Set A to the derivative of B( with respect to the variable of index var. Flint2nmod_mpoly_make_monic A B ctx Set A to B' divided by the leading coefficient of B. This throws if B6 is zero or the leading coefficient is not invertible. Flint2nmod_mpoly_scalar_mul_ui A B c ctx Set A to  B \times c. Flint2nmod_mpoly_neg A B ctx Set A to -B. Flint2nmod_mpoly_sub A B C ctx Set A to B - C. Flint2nmod_mpoly_add A B C ctx Set A to B + C. Flint2nmod_mpoly_sub_ui A B c ctx Set A to B - c. Flint2nmod_mpoly_add_ui A B c ctx Set A to B + c. Flint2nmod_mpoly_randtest_bits A state length exp_bits ctx /Generate a random polynomial with length up to length and exponents whose packed form does not exceed the given bit count. Flint2nmod_mpoly_randtest_bounds A state length  exp_bounds ctx /Generate a random polynomial with length up to length and exponents in the range [0, exp_bounds[i] - 1]*. The exponents of the variable of index i are generated by calls to n_randint(state, exp_bounds[i]). Flint2nmod_mpoly_randtest_bound A state length  exp_bound ctx /Generate a random polynomial with length up to length and exponents in the range [0, exp_bound - 1]<. The exponents of each variable are generated by calls to n_randint(state, exp_bound). Flint2nmod_mpoly_reverse A B ctx Set A to the reversal of B. Flint2nmod_mpoly_combine_like_terms A ctx Combine adjacent like terms in A: and delete terms with coefficient zero. If the terms of A were sorted to begin with, the result will be in canonical form. This function runs in linear time in the bit size of A. Flint2nmod_mpoly_sort_terms A ctx Sort the terms of A: into the canonical ordering dictated by the ordering in ctx. This function simply reorders the terms: It does not combine like terms, nor does it delete terms with coefficient zero. This function runs in linear time in the bit size of A. Flint2nmod_mpoly_push_term_ui_ui A c exp ctx Append a term to A with coefficient c and exponent vector exp/. This function runs in constant average time. Flint2nmod_mpoly_push_term_ui_fmpz A c exp ctx Flint2nmod_mpoly_get_term_monomial M A i ctx Set M& to the monomial of the term of index i in A. The coefficient of M will be one. Flint2nmod_mpoly_get_term M A i ctx Set M to the term of index i in A. Flint2nmod_mpoly_set_term_exp_ui A i exp ctx &Set the exponent of the term of index i to exp. Flint2nmod_mpoly_set_term_exp_fmpz A i exp ctx Flint2nmod_mpoly_get_term_var_exp_si A i var ctx $Return the exponent of the variable var of the term of index i<. This function throws if the exponent does not fit into a ulong (resp. slong). Flint2nmod_mpoly_get_term_var_exp_ui A i var ctx Flint2nmod_mpoly_get_term_exp_si exp A i ctx Set exp- to the exponent vector of the term of index i. The _ui (resp. _si2) version throws if any entry does not fit into a ulong (resp. slong). Flint2nmod_mpoly_get_term_exp_ui exp A i ctx Flint2nmod_mpoly_get_term_exp_fmpz exp A i ctx Flint2nmod_mpoly_term_exp_fits_ui A i ctx Return 1= if all entries of the exponent vector of the term of index i fit into an slong (resp. a ulong). Otherwise, return 0. Flint2nmod_mpoly_term_exp_fits_si A i ctx Flint2nmod_mpoly_set_term_coeff_ui A i c ctx )Set the coefficient of the term of index i to c. Flint2nmod_mpoly_get_term_coeff_ui A i ctx ,Return the coefficient of the term of index i. Flint2nmod_mpoly_resize A  new_length ctx Set the length of A to  new_length. Terms are either deleted from the end, or new zero terms are appended. Flint2nmod_mpoly_length A ctx Return the number of terms in A. If the polynomial is in canonical form, this will be the number of nonzero coefficients. Flint2nmod_mpoly_is_canonical A ctx Return 1 if A) is in canonical form. Otherwise, return 0. To be in canonical form, all of the terms must have nonzero coefficients, and the terms must be sorted from greatest to least. Flint2nmod_mpoly_term_coeff_ref A i ctx /Return a reference to the coefficient of index i of A. Flint2nmod_mpoly_cmp A B ctx Return 1 (resp. -1, or 0) if A# is after (resp. before, same as) B in some arbitrary but fixed total ordering of the polynomials. This ordering agrees with the usual ordering of monomials when A and B are both monomials. Flint2nmod_mpoly_get_coeff_vars_ui C A vars exps length ctx Set C to the coefficient of A# with respect to the variables in vars( with powers in the corresponding array exps. Both vars and exps point to array of length length. It is assumed that 0 < length \le nvars(A) and that the variables in vars are distinct. Flint2nmod_mpoly_set_coeff_ui_ui A c exp ctx 2Set the coefficient of the monomial with exponent exp to c. Flint2nmod_mpoly_set_coeff_ui_fmpz A c exp ctx Flint2nmod_mpoly_get_coeff_ui_ui A exp ctx 5Return the coefficient of the monomial with exponent exp. Flint2nmod_mpoly_get_coeff_ui_fmpz A exp ctx Flint2 nmod_mpoly_set_coeff_ui_monomial A c M ctx Assuming that M is a monomial, set the coefficient of the corresponding monomial in A to c. This function throws if M is not a monomial. Flint2 nmod_mpoly_get_coeff_ui_monomial A M ctx Assuming that M is a monomial, return the coefficient of the corresponding monomial in A. This function throws if M is not a monomial. Flint2nmod_mpoly_used_vars used A ctx For each variable index i, set used[i]& to nonzero if the variable of index i appears in A and to zero otherwise. Flint2nmod_mpoly_total_degree_si A ctx Either return or set tdeg to the total degree of A. If A- is zero, the total degree is defined to be -1. Flint2nmod_mpoly_total_degree_fmpz tdeg A ctx Flint2nmod_mpoly_total_degree_fits_si A ctx Return 1 if the total degree of A fits into an slong, otherwise return 0. Flint2nmod_mpoly_degree_si A var ctx Either return or set deg to the degree of A( with respect to the variable of index var. If A' is zero, the degree is defined to be -1. Flint2nmod_mpoly_degree_fmpz deg A var ctx Flint2nmod_mpoly_degrees_si degs A ctx Set degs to the degrees of A# with respect to each variable. If A" is zero, all degrees are set to -1. Flint2nmod_mpoly_degrees_fmpz degs A ctx Flint2nmod_mpoly_degrees_fit_si A ctx Return 1 if the degrees of A, with respect to each variable fit into an slong, otherwise return 0. Flint2nmod_mpoly_is_one A ctx Return 1 if A is the constant 1, else return 0. Flint2nmod_mpoly_is_zero A ctx Return 1 if A is the constant 0, else return 0. Flint2nmod_mpoly_equal_ui A c ctx Return 1 if A is equal to the constant c, else return 0. Flint2nmod_mpoly_one A ctx Set A to the constant 1. Flint2nmod_mpoly_zero A ctx Set A to the constant 0. Flint2nmod_mpoly_set_ui A c ctx Set A to the constant c. Flint2nmod_mpoly_get_ui A ctx Assuming that A? is a constant, return this constant. This function throws if A is not a constant. Flint2nmod_mpoly_is_ui A ctx Return 1 if A is a constant, else return 0. Flint2nmod_mpoly_swap A B ctx Efficiently swap A and B. Flint2nmod_mpoly_equal A B ctx Return 1 if A is equal to B, else return 0. Flint2nmod_mpoly_set A B ctx Set A to B. Flint2nmod_mpoly_is_gen A var ctx If  var \ge 0 , return 1 if A is equal to the var!-th generator, otherwise return 0. If var < 0 , return 1 if the polynomial is equal to any generator, otherwise return 0. Flint2nmod_mpoly_gen A var ctx Set A to the variable of index var, where var = 0 corresponds to the variable with the most significance with respect to the ordering. Flint2nmod_mpoly_set_str_pretty A str x ctx Set A1 to the polynomial in the null-terminates string str given an array x! of variable strings. If parsing str fails, A is set to zero, and -1 is returned. Otherwise, 0 is returned. The operations +, -, *, and /9 are permitted along with integers and the variables in x. The character ^ must be immediately followed by the (integer) exponent. If any division is not exact, parsing fails. Flint2nmod_mpoly_fprint_pretty file A x ctx Print a string representing A to file. Flint2nmod_mpoly_get_str_pretty A x ctx Return a string, which the user is responsible for cleaning up, representing A%, given an array of variable strings x. Flint2nmod_mpoly_clear A ctx  Release any space allocated for A. Flint2nmod_mpoly_realloc A alloc ctx  Reallocate A to have space for alloc terms. Assumes the current length of the polynomial is not greater than alloc. Flint2nmod_mpoly_fit_length A len ctx  Ensure that A has space for at least len terms. Flint2nmod_mpoly_init3 A alloc bits ctx  Initialise A for use with the given an initialised context object. Its value is set to zero. It is allocated with space for alloc terms and bits bits for the exponents. Flint2nmod_mpoly_init2 A alloc ctx  Initialise A for use with the given an initialised context object. Its value is set to zero. It is allocated with space for alloc terms and at least MPOLY_MIN_BITS bits for the exponent widths. Flint2nmod_mpoly_init A ctx  Initialise A for use with the given an initialised context object. Its value is set to zero. Flint2nmod_mpoly_ctx_clear ctx Release any space allocated by ctx. Flint2nmod_mpoly_ctx_modulus ctx 2Return the modulus used to initialize the context. Flint2nmod_mpoly_ctx_ord ctx 3Return the ordering used to initialize the context. Flint2nmod_mpoly_ctx_nvars ctx >Return the number of variables used to initialize the context. Flint2nmod_mpoly_ctx_init ctx nvars ord n Initialise a context object for a polynomial ring with the given number of variables and the given ordering. It will have coefficients modulo n . Setting n = 0 will give undefined behavior. The possibilities for the ordering are ORD_LEX,  ORD_DEGLEX and  ORD_DEGREVLEX. Flint2 Create a new  LFlint2 Create a new L Flint2 Create a new  Flint2Use a  Flint2nmod_mpoly_print_pretty A x ctx Print a string representing A to stdout.  Safe-Inferred )*1Sz   Safe-Inferred )*1\ Flint2nmod_mpoly_factor f A ctx Set f to a factorization of A! where the bases are irreducible. Flint2nmod_mpoly_factor_squarefree f A ctx Set f to a factorization of A where the bases are primitive and pairwise relatively prime. If the product of all irreducible factors with a given exponent is desired, it is recommended to call nmod_mpoly_factor_sort8 and then multiply the bases with the desired exponent. Flint2nmod_mpoly_factor_sort f ctx Sort the product of f$ first by exponent and then by base. Flint2nmod_mpoly_factor_get_exp_si f i ctx )Return the exponent of the term of index i in A. It is assumed to fit an slong. Flint2nmod_mpoly_factor_swap_base p f i ctx Set (resp. swap) B/ to (resp. with) the base of the term of index i in A. Flint2nmod_mpoly_factor_get_base p f i ctx Flint2!nmod_mpoly_factor_get_constant_ui f ctx Return the constant of f. Flint2nmod_mpoly_factor_length f ctx $Return the length of the product in f. Flint2nmod_mpoly_factor_swap f g ctx Efficiently swap f and g. Flint2nmod_mpoly_factor_clear f ctx Clear f. Flint2nmod_mpoly_factor_init f ctx  Initialise f.  Safe-Inferred )*1\   Safe-Inferred )*1]   Safe-Inferred )*1]y   Safe-Inferred )*1 Flint2fq_nmod_bit_unpack rop f bit_size ctx  Unpacks into rop; the element with coefficients packed into fields of size bit_size as represented by the integer f. Flint2fq_nmod_bit_pack f op bit_size ctx Packs op into bitfields of size bit_size, writing the result to f. Flint2fq_nmod_is_primitive op ctx Returns whether op is primitive, i.e., whether it is a generator of the multiplicative group of ctx. Flint2fq_nmod_multiplicative_order ord op ctx Computes the order of op/ as an element of the multiplicative group of ctx. Returns 0 if op! is 0, otherwise it returns 1 if op is a generator of the multiplicative group, and -1 if it is not.This function can also be used to check primitivity of a generator of a finite field whose defining polynomial is not primitive. Flint2fq_nmod_frobenius rop op e ctx Evaluates the homomorphism \Sigma^e at op. Recall that \mathbf{F}_q / \mathbf{F}_p is Galois with Galois group \langle \sigma \rangle, which is also isomorphic to \mathbf{Z}/d\mathbf{Z} , where 8\sigma \in \operatorname{Gal}(\mathbf{F}_q/\mathbf{F}_p) is the Frobenius element \sigma \colon x \mapsto x^p. Flint2_fq_nmod_frobenius rop op len e ctx Sets  (rop, 2d-1) to the image of  (op, len) under the Frobenius operator raised to the e-th power, assuming that neither op nor e are zero. Flint2 fq_nmod_norm rop op ctx Computes the norm of op.For an element a \in \mathbf{F}_q, multiplication by a defines a  \mathbf{F}_p-linear map on  \mathbf{F}_q. We define the norm of a2 as the determinant of this map. Equivalently, if \Sigma generates /\operatorname{Gal}(\mathbf{F}_q / \mathbf{F}_p) then the trace of a is equal to \prod_{i=0}^{d-1} \Sigma^i (a) , where +d = \text{dim}_{\mathbf{F}_p}(\mathbf{F}_q).8Algorithm selection is automatic depending on the input. Flint2 _fq_nmod_norm rop op len ctx Sets rop% to the norm of the non-zero element  (op, len) in \mathbf{F}_{q}. Flint2 fq_nmod_trace rop op ctx Sets rop to the trace of op.For an element a \in \mathbf{F}_q, multiplication by a defines a  \mathbf{F}_p-linear map on  \mathbf{F}_q. We define the trace of a, as the trace of this map. Equivalently, if \Sigma generates /\operatorname{Gal}(\mathbf{F}_q / \mathbf{F}_p) then the trace of a is equal to \sum_{i=0}^{d-1} \Sigma^i (a), where (d = log_{p} q). Flint2_fq_nmod_trace rop op len ctx Sets rop& to the trace of the non-zero element  (op, len) in \mathbf{F}_{q}. Flint2 fq_nmod_cmp a b ctx Return 1 (resp. -1, or 0) if a# is after (resp. before, same as) b< in some arbitrary but fixed total ordering of the elements. Flint2fq_nmod_is_invertible_f f op ctx Returns whether op. is an invertible element. If it is not, then f$ is set to a factor of the modulus. Flint2fq_nmod_is_invertible op ctx Returns whether op is an invertible element. Flint2 fq_nmod_equal op1 op2 ctx Returns whether op1 and op2 are equal. Flint2fq_nmod_is_one op ctx Returns whether op is equal to one. Flint2fq_nmod_is_zero op ctx Returns whether op is equal to zero. Flint2fq_nmod_set_nmod_mat a col ctx Convert a column vector col of length  degree(ctx) to an element of ctx. Flint2fq_nmod_get_nmod_mat col a ctx Convert a to a column vector of length  degree(ctx). Flint2fq_nmod_set_nmod_poly a b ctx Set a to the element in ctx with representative b$. The representatives are taken in  (\mathbb{Z}/p\mathbb{Z})[x]/h(x) where h(x) is the defining polynomial in ctx. Flint2fq_nmod_get_nmod_poly a b ctx Set a to a representative of b in ctx$. The representatives are taken in  (\mathbb{Z}/p\mathbb{Z})[x]/h(x) where h(x) is the defining polynomial in ctx. Flint2fq_nmod_get_fmpz rop op ctx If op$ has a lift to the integers, return 1 and set rop to the lift in [0,p). Otherwise, return 0 and leave rop undefined. Flint2 fq_nmod_gen rop ctx Sets rop to a generator for the finite field. There is no guarantee this is a multiplicative generator of the finite field. Flint2 fq_nmod_one rop ctx Sets rop& to one, reduced in the given context. Flint2 fq_nmod_zero rop ctx Sets rop to zero. Flint2 fq_nmod_swap op1 op2 ctx Swaps the two elements op1 and op2. Flint2fq_nmod_set_fmpz rop x ctx Sets rop to x, considered as an element of  \mathbf{F}_p. Flint2fq_nmod_set_ui rop x ctx Sets rop to x, considered as an element of  \mathbf{F}_p. Flint2fq_nmod_set_si rop x ctx Sets rop to x, considered as an element of  \mathbf{F}_p. Flint2 fq_nmod_set rop op ctx Sets rop to op. Flint2fq_nmod_rand_not_zero rop state ctx 4Generates a high quality non-zero random element of  \mathbf{F}_q. Flint2 fq_nmod_rand rop state ctx +Generates a high quality random element of  \mathbf{F}_q. Flint2fq_nmod_randtest_dense rop state ctx Generates a random element of  \mathbf{F}_q= which has an underlying polynomial with dense coefficients. Flint2fq_nmod_randtest_not_zero rop state ctx 'Generates a random non-zero element of  \mathbf{F}_q. Flint2fq_nmod_randtest rop state ctx Generates a random element of  \mathbf{F}_q. Flint2fq_nmod_get_str_pretty op ctx /Returns a pretty representation of the element op# using the null-terminated string x as the variable name. Flint2fq_nmod_get_str op ctx =Returns the plain FLINT string representation of the element op. Flint2fq_nmod_fprint file op ctx Prints a representation of op to file.5For further details on the representation used, see nmod_poly_fprint(). Flint2fq_nmod_fprint_pretty file op ctx "Prints a pretty representation of op to file.In case of success, returns a positive value. In case of failure, returns a non-positive value. Flint2fq_nmod_is_square op ctx Return 1 if op is a square. Flint2fq_nmod_pth_root rop op1 ctx Sets rop to a p^{\textrm{th}} root of op10. Currently, this computes the root by raising op1 to p^{d-1} where d! is the degree of the extension. Flint2 fq_nmod_sqrt rop op1 ctx Sets rop to the square root of op1 if it is a square, and return 1, otherwise return 0. Flint2fq_nmod_pow_ui rop op e ctx Sets rop to op raised to the power e.Currently assumes that e \geq 0.Note that for any input op, rop is set to 1 whenever e = 0. Flint2 fq_nmod_pow rop op e ctx Sets rop to op raised to the power e.Currently assumes that e \geq 0.Note that for any input op, rop is set to 1 whenever e = 0. Flint2 _fq_nmod_pow rop op len e ctx Sets  (rop, 2*d-1) to (op,len) raised to the power e, reduced modulo f(X), the modulus of ctx. Assumes that e \geq 0 and that len is positive and at most d.Although we require that rop provides space for 2d - 12 coefficients, the output will be reduced modulo f(X)#, which is a polynomial of degree d.Does not support aliasing. Flint2fq_nmod_gcdinv f inv op ctx Sets inv to be the inverse of op modulo the modulus of ctx. If op is not invertible, then f is set to a factor of the modulus; otherwise, it is set to one. Flint2 fq_nmod_inv rop op ctx Sets rop( to the inverse of the non-zero element op. Flint2 _fq_nmod_inv rop op len ctx Sets (rop, d)( to the inverse of the non-zero element  (op, len). Flint2 fq_nmod_sqr rop op ctx Sets rop to the square of op,, reducing the output in the given context. Flint2fq_nmod_mul_ui rop op x ctx Sets rop to the product of op and x,, reducing the output in the given context. Flint2fq_nmod_mul_si rop op x ctx Sets rop to the product of op and x,, reducing the output in the given context. Flint2fq_nmod_mul_fmpz rop op x ctx Sets rop to the product of op and x,, reducing the output in the given context. Flint2 fq_nmod_mul rop op1 op2 ctx Sets rop to the product of op1 and op2,, reducing the output in the given context. Flint2 fq_nmod_neg rop op ctx Sets rop to the negative of op. Flint2fq_nmod_sub_one rop op1 ctx Sets rop to the difference of op1 and 1. Flint2 fq_nmod_sub rop op1 op2 ctx Sets rop to the difference of op1 and op2. Flint2 fq_nmod_add rop op1 op2 ctx Sets rop to the sum of op1 and op2. Flint2fq_nmod_reduce rop ctx Reduces the polynomial rop as an element of \mathbf{F}_p[X] / (f(X)). Flint2_fq_nmod_reduce r lenR ctx Reduces  (R, lenR) modulo the polynomial f given by the modulus of ctx2. Does either sparse or dense reduction based on ctx->sparse_modulus. Flint2_fq_nmod_dense_reduce R lenR ctx Reduces  (R, lenR) modulo the polynomial f given by the modulus of ctx using Newton division. Flint2_fq_nmod_sparse_reduce R lenR ctx Reduces  (R, lenR) modulo the polynomial f given by the modulus of ctx. Flint2 fq_nmod_clear rop ctx Clears the element rop. Flint2 fq_nmod_init2 rop ctx  Initialises rop8 with at least enough space for it to be an element of ctx and sets it to 0. Flint2 fq_nmod_init rop ctx Initialises the element rop, setting its value to 0,. Currently, the behaviour is identical to  fq_nmod_init2, as it also ensures rop. has enough space for it to be an element of ctx!, this may change in the future. Flint2fq_nmod_ctx_randtest_reducible ctx  Initializes ctx to a random extension of a word-sized prime field. The modulus may or may not be irreducible. Assumes that fq_nmod_ctx_init has not been called on ctx already. Flint2fq_nmod_ctx_randtest ctx  Initializes ctx) to a random finite field. Assumes that fq_nmod_ctx_init has not been called on ctx already. Flint2fq_nmod_ctx_fprint file ctx "Prints the context information to file>. Returns 1 for a success and a negative number for an error.LFlint2fq_nmod_ctx_get_str ctx ;Return a string representation of the context information. Flint2fq_nmod_ctx_order f ctx Sets f$ to be the size of the finite field. Flint2fq_nmod_ctx_degree ctx +Returns the degree of the field extension ![\mathbf{F}_{q} : \mathbf{F}_{p}], which is equal to  \log_{p} q. Flint2fq_nmod_ctx_modulus ctx 0Returns a pointer to the modulus in the context. Flint2fq_nmod_ctx_clear ctx Clears all memory that has been allocated as part of the context. Flint2fq_nmod_ctx_init_modulus ctx modulus var "Initialises the context for given modulus with name var for the generator. Assumes that modulus$ is an irreducible polynomial over \mathbf{F}_{p}.Assumes that the string var5 is a null-terminated string of length at least one. Flint2fq_nmod_ctx_init_conway ctx p d var "Initialises the context for prime p and extension degree d , with name var= for the generator using a Conway polynomial for the modulus. Assumes that p is a prime.Assumes that the string var5 is a null-terminated string of length at least one. Flint2_fq_nmod_ctx_init_conway ctx p d var -Attempts to initialise the context for prime p and extension degree d , with name var> for the generator using a Conway polynomial for the modulus.Returns 1 if the Conway polynomial is in the database for the given size and the initialization is successful; otherwise, returns 0. Assumes that p is a prime.Assumes that the string var5 is a null-terminated string of length at least one. Flint2fq_nmod_ctx_init ctx p d var "Initialises the context for prime p and extension degree d , with name var for the generator. By default, it will try use a Conway polynomial; if one is not available, a random irreducible polynomial will be used. Assumes that p is a prime.Assumes that the string var5 is a null-terminated string of length at least one.LFlint2fq_nmod_ctx_prime ctx Returns a pointer to the prime p in the context. foreign import ccall "fq_nmod.h fq_nmod_ctx_prime" Flint2fq_nmod_ctx_print ctx "Prints the context information to stdout. Flint2fq_nmod_print_pretty op ctx "Prints a pretty representation of op to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value. Flint2 fq_nmod_print op ctx Prints a representation of op to stdout.4For further details on the representation used, see nmod_poly_print().  Safe-Inferred )*1  Safe-Inferred )*1׻= Flint2_fmpz_vec_dot_ptr res vec1 vec2 offset len Sets res to the dot product of len values at vec1 and the len values vec2[i] + offset for 0 \leq i < len. Flint2 _fmpz_vec_dot res vec1 vec2 len2 Sets res to the dot product of  (vec1, len2) and  (vec2, len2). Flint2 _fmpz_vec_lcm res vec len Sets res= to the nonnegative least common multiple of the entries in vec. The least common multiple is zero if any entry in the vector is zero. The least common multiple of a length zero vector is defined to be one. Flint2_fmpz_vec_content_chained res vec len input Sets res to the non-negative content of input and the entries in vec. This is useful for calculating the common content of several vectors. Flint2_fmpz_vec_content res vec len Sets res/ to the non-negative content of the entries in vec. The content of a zero vector, including the case when the length is zero, is defined to be zero. Flint2_fmpz_vec_scalar_smod_fmpz res vec len p Reduces all entries in  (vec, len) modulo p > 0), choosing the unique representative in  (-p/2, p/2]. Flint2_fmpz_vec_scalar_mod_fmpz res vec len p Reduces all entries in  (vec, len) modulo p > 0. Flint2_fmpz_vec_prod res vec len Sets res" to the product of the entries in  (vec, len). Aliasing of res with the entries in vec) is not permitted. Uses binary splitting. Flint2 _fmpz_vec_sum res vec len Sets res to the sum of the entries in  (vec, len). Aliasing of res with the entries in vec is not permitted. Flint2_fmpz_vec_scalar_submul_si_2exp vec1 vec2 len2 c e  Subtracts  (vec2, len2) times  c \times 2^e from  (vec1, len2) , where c is a slong. Flint2_fmpz_vec_scalar_submul_si vec1 vec2 len2 c  Subtracts  (vec2, len2) times c from  (vec1, len2), where c is a slong. Flint2_fmpz_vec_scalar_submul_fmpz vec1 vec2 len2 x  Subtracts  (vec2, len2) times c from  (vec1, len2), where c is a fmpz_t. Flint2_fmpz_vec_scalar_addmul_si_2exp vec1 vec2 len2 c exp Adds  (vec2, len2) times  c * 2^exp to  (vec1, len2), where c is a slong. Flint2_fmpz_vec_scalar_addmul_fmpz vec1 vec2 len2 c Adds  (vec2, len2) times c to  (vec1, len2). Flint2_fmpz_vec_scalar_tdiv_q_2exp vec1 vec2 len2 exp Sets  (vec1, len2) to  (vec2, len2) divided by 2^exp, rounding down towards zero whenever the division is not exact. Flint2_fmpz_vec_scalar_tdiv_q_ui vec1 vec2 len2 c Sets  (vec1, len2) to  (vec2, len2) divided by c<, rounding towards zero whenever the division is not exact. Flint2_fmpz_vec_scalar_tdiv_q_si vec1 vec2 len2 c Sets  (vec1, len2) to  (vec2, len2) divided by c<, rounding towards zero whenever the division is not exact. Flint2_fmpz_vec_scalar_tdiv_q_fmpz vec1 vec2 len2 c Sets  (vec1, len2) to  (vec2, len2) divided by c<, rounding towards zero whenever the division is not exact. Flint2_fmpz_vec_scalar_fdiv_r_2exp vec1 vec2 len2 exp Sets  (vec1, len2) to the remainder of  (vec2, len2) divided by 2^exp, rounding down the quotient towards minus infinity whenever the division is not exact. Flint2_fmpz_vec_scalar_fdiv_q_2exp vec1 vec2 len2 exp Sets  (vec1, len2) to  (vec2, len2) divided by 2^exp, rounding down towards minus infinity whenever the division is not exact. Flint2_fmpz_vec_scalar_fdiv_q_ui vec1 vec2 len2 c Sets  (vec1, len2) to  (vec2, len2) divided by c, rounding down towards minus infinity whenever the division is not exact. Flint2_fmpz_vec_scalar_fdiv_q_si vec1 vec2 len2 c Sets  (vec1, len2) to  (vec2, len2) divided by c, rounding down towards minus infinity whenever the division is not exact. Flint2_fmpz_vec_scalar_fdiv_q_fmpz vec1 vec2 len2 c Sets  (vec1, len2) to  (vec2, len2) divided by c, rounding down towards minus infinity whenever the division is not exact. Flint2_fmpz_vec_scalar_divexact_ui vec1 vec2 len2 c Sets  (vec1, len2) to  (vec2, len2) divided by x, where the division is assumed to be exact for every entry in vec2. Flint2_fmpz_vec_scalar_divexact_si vec1 vec2 len2 c Sets  (vec1, len2) to  (vec2, len2) divided by x, where the division is assumed to be exact for every entry in vec2. Flint2_fmpz_vec_scalar_divexact_fmpz vec1 vec2 len2 x Sets  (vec1, len2) to  (vec2, len2) divided by x, where the division is assumed to be exact for every entry in vec2. Flint2_fmpz_vec_scalar_mul_2exp vec1 vec2 len2 exp Sets  (vec1, len2) to  (vec2, len2) multiplied by 2^exp. Flint2_fmpz_vec_scalar_mul_ui vec1 vec2 len2 c Sets  (vec1, len2) to  (vec2, len2) multiplied by c, where c is an ulong. Flint2_fmpz_vec_scalar_mul_si vec1 vec2 len2 c Sets  (vec1, len2) to  (vec2, len2) multiplied by c, where c is a slong. Flint2_fmpz_vec_scalar_mul_fmpz vec1 vec2 len2 x Sets  (vec1, len2) to  (vec2, len2) multiplied by c, where c is an fmpz_t. Flint2 _fmpz_vec_sub res vec1 vec2 len2 Sets  (res, len2) to  (vec1, len2) minus  (vec2, len2). Flint2 _fmpz_vec_add res vec1 vec2 len2 Sets  (res, len2) to the sum of  (vec1, len2) and  (vec2, len2). Flint2_fmpz_vec_sort vec len Sorts the coefficients of vec in ascending order. Flint2_fmpz_vec_max_inplace vec1 vec2 len Sets vec1 to the pointwise maximum of vec1 and vec2. Flint2 _fmpz_vec_max vec1 vec2 vec3 len Sets vec1 to the pointwise maximum of vec2 and vec3. Flint2_fmpz_vec_is_zero vec len Returns 1 if  (vec, len) is zero, and 0 otherwise. Flint2_fmpz_vec_equal vec1 vec2 len 5Compares two vectors of the given length and returns 1' if they are equal, otherwise returns 0. Flint2_fmpz_vec_scalar_abs vec1 vec2 len2 'Takes the absolute value of entries in  (vec2, len2) and places the result into vec1. Flint2 _fmpz_vec_neg vec1 vec2 len2 Negates  (vec2, len2) and places it into vec1. Flint2_fmpz_vec_zero vec len Zeros the entries of  (vec, len). Flint2_fmpz_vec_swap vec1 vec2 len2 Swaps the integers in  (vec1, len2) and  (vec2, len2). Flint2 _fmpz_vec_set vec1 vec2 len2 Makes a copy of  (vec2, len2) into vec1. Flint2_fmpz_vec_get_d_vec_2exp appv vec len Export the array of len! entries starting at the pointer vec to an array of doubles appv, each entry of which is notionally multiplied by a single returned exponent to give the original entry. The returned exponent is set to be the maximum exponent of all the original entries so that all the doubles in appv& have a maximum absolute value of 1.0. Flint2_fmpz_vec_set_fft coeffs_m length coeffs_f limbs sign Convert an fft vector coeffs_f/ of fully reduced Fermat numbers of the given length to a vector of fmpz's. Each is assumed to be the given number of limbs in length with an additional limb for overflow. If the output coefficients are to be signed then set sign%, otherwise clear it. The resulting fmpzs will be in the range [-n,n]& in the signed case and in the range [0,2n] in the unsigned case where n = 2^(FLINT_BITS*limbs - 1). Flint2_fmpz_vec_get_fft coeffs_f coeffs_m l length Convert the vector of coeffs coeffs_m to an fft vector coeffs_f of the given length with l= limbs per coefficient with an additional limb for overflow. Flint2_fmpz_vec_set_nmod_vec res poly len mod Set the coefficients of  (res, len)2 to the symmetric modulus of the coefficients of  (poly, len), i.e. convert the given coefficients modulo the given modulus n7 to their signed integer representatives in the range  [-n/2, n/2). Flint2_fmpz_vec_get_nmod_vec res poly len mod Reduce the coefficients of  (poly, len)# modulo the given modulus and set  (res, len) to the result. Flint2_fmpz_vec_fprint file vec len 0Prints the vector of given length to the stream file. The format is the length followed by two spaces, then a space separated list of coefficients. If the length is zero, only 0 is printed.In case of success, returns a positive value. In case of failure, returns a non-positive value. Flint2_fmpz_vec_read vec len Reads a vector from stdin and stores it at *vec.For further details, see _fmpz_vec_fread(). Flint2_fmpz_vec_fread file vec len Reads a vector from the stream file and stores it at *vec2. The format is the same as the output format of _fmpz_vec_fprint();, followed by either any character or the end of the file.The interpretation of the various input arguments depends on whether or not *vec is NULL:If  *vec == NULL, the value of *len: on input is ignored. Once the length has been read from file, *len is set to that value and a vector of this length is allocated at *vec . Finally, *len coefficients are read from the input stream. In case of a file or parsing error, clears the vector and sets *vec and *len to NULL and 0, respectively.Otherwise, if  *vec != NULL, it is assumed that  (*vec, *len) is a properly initialised vector. If the length on the input stream does not match *len, a parsing error is raised. Attempts to read the right number of coefficients from the input stream. In case of a file or parsing error, leaves the vector  (*vec, *len) in its current state.In case of success, returns a positive value. In case of failure, returns a non-positive value. Flint2_fmpz_vec_height_index vec len Returns the index of an entry of maximum absolute value in the vector. The the length must be at least 1. Flint2_fmpz_vec_height height vec len Computes the height of  (vec, len), defined as the largest of the absolute values the coefficients. Equivalently, this gives the infinity norm of the vector. If len is zero, the height is 0. Flint2_fmpz_vec_max_limbs vec len Returns the maximum number of limbs needed to store the absolute value of any entry in  (vec, len)(. If all entries are zero, returns zero. Flint2_fmpz_vec_sum_max_bits sumabs maxabs vec len Sets sumabs to the bit count of the sum of the absolute values of the elements of vec. Sets maxabs to the bit count of the maximum of the absolute values of the elements of vec. Flint2_fmpz_vec_max_bits_ref vec len If b is the maximum number of bits of the absolute value of any coefficient of vec, then if any coefficient of vec is negative, -b is returned, else b< is returned. This is a slower reference implementation of _fmpz_vec_max_bits. Flint2_fmpz_vec_max_bits vec len If b is the maximum number of bits of the absolute value of any coefficient of vec, then if any coefficient of vec is negative, -b is returned, else b is returned. Flint2_fmpz_vec_randtest_unsigned f state len bits Sets the entries of a vector of the given length to random unsigned integers with up to the given number of bits per entry. Flint2_fmpz_vec_randtest f state len bits Sets the entries of a vector of the given length to random integers with up to the given number of bits per entry. Flint2_fmpz_vec_clear vec len Clears the entries of  (vec, len)$ and frees the space allocated for vec. Flint2_fmpz_vec_init len !Returns an initialised vector of fmpz's of given length. Flint2_fmpz_vec_print vec len %Prints the vector of given length to stdout.For further details, see _fmpz_vec_fprint().  Safe-Inferred )*1؀  Safe-Inferred )*1 Flint2fmpz_next_smooth_prime a b Either return 1 and set a* to a smooth prime strictly greater than b , or return 0 and set a to 0. The smooth primes returned by this function currently have no prime factor of a-1 greater than 23%, but this should not be relied upon. Flint2(fmpz_mod_discrete_log_pohlig_hellman_run x L y Set x to the logarithm of y. with respect to the internally stored base. y& is expected to be reduced modulo the p=. The function is undefined if the logarithm does not exist. Flint23fmpz_mod_discrete_log_pohlig_hellman_primitive_root L "Return the internally stored base. Flint25fmpz_mod_discrete_log_pohlig_hellman_precompute_prime L p  Configure L for discrete logarithms modulo p3 to an internally chosen base. It is assumed that p is prime. The return is an estimate on the number of multiplications needed for one run. Flint2*fmpz_mod_discrete_log_pohlig_hellman_clear L Free any space used by L. Flint2)fmpz_mod_discrete_log_pohlig_hellman_init L  Initialize L. Upon initialization L is not ready for computation. Flint2fmpz_mod_pow_fmpz a b e ctx  Try to set a to b^e modulo n. If e < 0 and b is not invertible modulo n, the return is 0. Otherwise, the return is 1. Flint2fmpz_mod_pow_ui a b e ctx Set a to b^e modulo n. Flint2fmpz_mod_divides a b c ctx If a*c = b \mod n has a solution for a return 1 and set a& to such a solution. Otherwise return 0 and leave a undefined. Flint2 fmpz_mod_inv a b ctx Set a to b^{-1} modulo n. This function expects that b is invertible modulo n and throws if this not the case. Invertibility maybe tested with func:fmpz_mod_pow_fmpz or func:fmpz_mod_divides. Flint2 fmpz_mod_mul a b c ctx Set a to b*c modulo n. Flint2 fmpz_mod_neg a b ctx Set a to -b modulo n. Flint2fmpz_mod_fmpz_sub a b c ctx Set a to b-c modulo n where only c is assumed to be canonical. Flint2fmpz_mod_sub_fmpz a b c ctx Set a to b-c modulo n where only b is assumed to be canonical. Flint2 fmpz_mod_sub a b c ctx Set a to b-c modulo n. Flint2fmpz_mod_add_fmpz a b c ctx Set a to b+c modulo n where only b is assumed to be canonical. Flint2 fmpz_mod_add a b c ctx Set a to b+c modulo n. Flint2fmpz_mod_is_one a ctx Return 1 if a is 1 modulo n and return 0 otherwise. Flint2fmpz_mod_is_canonical a ctx Return 1 if a is in the canonical range [0,n) and 0 otherwise. Flint2fmpz_mod_set_fmpz a b ctx Set a to b$ after reduction modulo the modulus. Flint2fmpz_mod_ctx_set_modulus ctx n  Reconfigure ctx for arithmetic modulo n. Flint2fmpz_mod_ctx_clear ctx Free any memory used by ctx. Flint2fmpz_mod_ctx_init ctx n  Initialise ctx for arithmetic modulo n$, which is expected to be positive.  Safe-Inferred )*1   Safe-Inferred )*1 Flint2_fmpz_mod_vec_mul A B C len ctx Set (A, len)! the pointwise multiplication of (B, len) and (C, len). Flint2_fmpz_mod_vec_dot_rev d A B len ctx Set d to the dot product of (A, len)! with the reverse of the vector (B, len). Flint2_fmpz_mod_vec_dot d A B len ctx Set d to the dot product of (A, len) with (B, len). Flint2!_fmpz_mod_vec_scalar_div_fmpz_mod A B len c ctx Set (A, len) to  (B, len)/c assuming c is nonzero. Flint2$_fmpz_mod_vec_scalar_addmul_fmpz_mod A B len c ctx Set (A, len) to (A, len) + (B, len)*c. Flint2!_fmpz_mod_vec_scalar_mul_fmpz_mod A B len c ctx Set (A, len) to  (B, len)*c. Flint2_fmpz_mod_vec_sub a b c n ctx +Set (A, len) to :math:(B, len) - (C, len)`. Flint2_fmpz_mod_vec_add a b c n ctx +Set (A, len) to :math:(B, len) + (C, len)`. Flint2_fmpz_mod_vec_neg A B len ctx Set (A, len) to  -(B, len). Flint2_fmpz_mod_vec_set_fmpz_vec A B len ctx Set the  fmpz_mod_vec (A, len) to the fmpz_vec (B, len)4 after reduction of each entry modulo the modulus..  Safe-Inferred )*1  Safe-Inferred )*1! Flint2fmpz_factor_ecm f curves B1 B2 state n_in 6Outer wrapper function for the ECM algorithm. In case f/ can fit in a single unsigned word, a call to  n_factor_ecm is made.The function calls stage I and II, and the precomputations (builds  prime_array for stage I,  GCD_table and  prime_table for stage II).f is set as the factor if found. curves. is the number of random curves being tried. B1, B2. are the two bounds or stage I and stage II. n is the number being factored.!If a factor is found in stage I, 11 is returned. If a factor is found in stage II, 2? is returned. If a factor is found while selecting the curve, -1 is returned. Otherwise 0 is returned. Flint2fmpz_factor_ecm_stage_II f B1 B2 P n ecm_inf -Stage II implementation of the ECM algorithm.f is set as the factor if found. B1, B2 are the two bounds. P+ is the primorial (approximately equal to  \sqrt{B2}). n is the number being factored.If the factor is found, number of words required to store the factor is returned, otherwise 0. Flint2fmpz_factor_ecm_stage_I f  prime_array num B1 n ecm_inf ,Stage I implementation of the ECM algorithm.f is set as the factor if found. num is number of prime numbers \le the bound B1.  prime_array is an array of first B1 primes. n is the number being factored.If the factor is found, number of words required to store the factor is returned, otherwise 0. Flint2fmpz_factor_ecm_select_curve f sigma n ecm_inf 7Selects a random elliptic curve given a random integer sigma, according to Suyama's parameterization. If the factor is found while selecting the curve, the number of limbs required to store the factor is returned, otherwise 0.It could be possible that the selected curve is unsuitable for further computations, in such a case, -1 is returned.Also selects the initial point x_0, and the value of  (a + 2)/4 , where a is a curve parameter. Sets z_0 as 1. All these are stored in the ecm_t struct.The curve selected is of Montgomery form, the points selected satisfy the curve and are projective coordinates. Flint2%fmpz_factor_ecm_mul_montgomery_ladder x z x0 z0 k n ecm_inf Montgomery ladder algorithm for scalar multiplication of elliptic points.Sets the point (x : z) to  k(x_0 : z_0) modulo n.ecm_inf is used just to use temporary mp_ptr's in the structure. Valid only for points expressed in Montgomery projective coordinates. Flint2fmpz_factor_ecm_add x z x1 z1 x2 z2 x0 z0 n ecm_inf Sets the point (x : z) to the sum of  (x_1 : z_1) and  (x_2 : z_2) modulo n, given the difference  (x_0 : z_0) according to the formula` \begin{aligned} x = 4z_0(x_1x_2 - z_1z_2)^2 \mod n, \\ z = 4x_0(x_2z_1 - x_1z_2)^2 \mod n. \end{aligned}ecm_inf is used just to use temporary mp_ptr's in the structure. This group addition is valid only for points expressed in Montgomery projective coordinates. Flint2fmpz_factor_ecm_double x z x0 z0 n ecm_inf Sets the point (x : z) to two times  (x_0 : z_0) modulo n according to the formula` -x = (x_0 + z_0)^2 \cdot (x_0 - z_0)^2 \mod n,` z = 4 x_0 z_0 \left((x_0 - z_0)^2 + 4a_{24}x_0z_0\right) \mod n.ecm_inf is used just to use temporary mp_ptr's in the structure. This group doubling is valid only for points expressed in Montgomery projective coordinates. Flint2fmpz_factor_ecm_submod x a b n n_size Sets x to (a - b) % n:. This is not a normal subtract mod function, it assumes n% is normalized (highest bit set) and b and c are reduced modulo n."Used for arithmetic operations in fmpz_factor_ecm. Flint2fmpz_factor_ecm_addmod a b c n n_size Sets a to (b + c) % n5. This is not a normal add mod function, it assumes n% is normalized (highest bit set) and b and c are reduced modulo n."Used for arithmetic operations in fmpz_factor_ecm. Flint2fmpz_factor_ecm_clear ecm_inf  Clears the ecm_t struct. Flint2fmpz_factor_ecm_init ecm_inf sz Initializes the ecm_t struct. This is needed in some functions and carries data between subsequent calls. Flint2fmpz_factor_pollard_brent factor state n  max_tries  max_iters Pollard Rho algorithm for integer factorization. Assumes that the n is not prime. factor is set as the factor if found. It is not assured that the factor found will be prime. Does not compute the complete factorization, just one factor. Returns the number of limbs of factor if factorization is successful (non trivial factor is found), else returns 0. max_iters is the number of iterations tried in process of finding the cycle. If the algorithm fails to find a non trivial factor in one call, it tries again (this time with a different set of random values). This process is repeated a maximum of  max_tries times.The algorithm used is a modification of the original Pollard Rho algorithm, suggested by Richard Brent. It can be found in the paper available at 5https://maths-people.anu.edu.au/~brent/pd/rpb051i.pdf Flint2 fmpz_factor_pollard_brent_single p_factor n_in yi ai  max_iters Pollard Rho algorithm for integer factorization. Assumes that the n is not prime. factor is set as the factor if found. Takes as input the initial value y%, to start polynomial evaluation and a, the constant of the polynomial used. It is not assured that the factor found will be prime. Does not compute the complete factorization, just one factor. Returns the number of limbs of factor if factorization is successful (non trivial factor is found), else returns 0. max_iters is the number of iterations tried in process of finding the cycle. If the algorithm fails to find a non trivial factor in one call, it tries again (this time with a different set of random values). Flint2fmpz_factor_pp1 factor n B1 B2_sqrt c Use Williams' p + 1 method to factor n%, using a prime bound in stage 1 of B19 and a prime limit in stage 2 of at least the square of B2_sqrt-. If a factor is found, the function returns 1 and factor is set to the factor that is found. Otherwise, the function returns 0. The value c' should be a random value greater than 2=. Successive calls to the function with different values of c$ give additional chances to factor n with roughly exponentially decaying probability of finding a factor which has been missed (if p+1 or p-1& is not smooth for any prime factors p of n+ then the function will not ever succeed). Flint2fmpz_factor_expand_iterative n factor 1Evaluates an integer in factored form back to an fmpz_t.This currently exponentiates the bases separately and multiplies them together one by one, although much more efficient algorithms exist. Flint2fmpz_factor_refine res f Attempts to improve a partial factorization of an integer by "refining" the factorization f# to a more complete factorization res+ whose bases are pairwise relatively prime.This function does not require its input to be in canonical form, nor does it guarantee that the resulting factorization will be canonical. Flint2fmpz_factor_trial factor n  num_primes Factors n- into prime factors using trial division. If n- is zero or negative, the sign field of the factor! object will be set accordingly.The algorithm uses the given number of primes, which must be in the range  [0, 3512]. An exception is raised if a number outside this range is passed.The function returns 1 if n/ is completely factored, otherwise it returns 0.The final entry in the factor struct is set to the cofactor after removing prime factors, if this is not 1. Flint2fmpz_factor_trial_range factor n start  num_primes Factors n- into prime factors using trial division. If n- is zero or negative, the sign field of the factor! object will be set accordingly.7The algorithm starts with the given start index in the  flint_primes table and uses at most  num_primes primes from that point.The function returns 1 if n/ is completely factored, otherwise it returns 0. Flint2fmpz_factor_si factor n Like  fmpz_factor, but takes a machine integer n as input. Flint2fmpz_factor_smooth factor n bits proved Factors n into prime numbers up to approximately the given number of bits and possibly one additional cofactor, which may or may not be prime.If the number is definitely factored fully, the return value is 1, otherwise the final factor (which may have exponent greater than 11) is composite and needs to be factored further.If the number has a factor of around the given number of bits, there is at least a two-thirds chance of finding it. Smaller factors should be found with a much higher probability.The amount of time spent factoring can be controlled by lowering or increasing bits0. However, the quadratic sieve may be faster if bits9 is set to more than one third of the number of bits of n.(The function uses trial factoring up to  bits = 15, followed by a primality test and a perfect power test to check if the factorisation is complete. If bits is at least 16, it proceeds to use the elliptic curve method to look for larger factors.7The behavior of primality testing is determined by the proved parameter:If proved is set to 1 the function will prove all factors prime (other than the last factor, if the return value is 0).If proved is set to 0, the function will only check that factors are probable primes.If proved is set to -1, the function will not test primality after performing trial division. A perfect power test is still performed.As an exception to the rules stated above, this function will call n_factor internally if n or the remainder after trial division is smaller than one word, guaranteeing a complete factorisation. Flint2 fmpz_factor factor n Factors n into prime numbers. If n- is zero or negative, the sign field of the factor object will be set accordingly. Flint2_fmpz_factor_append factor p exp Append a factor p to the given exponent to the  fmpz_factor_t structure factor. Flint2_fmpz_factor_append_ui factor p exp Append a factor p to the given exponent to the  fmpz_factor_t structure factor. Flint2fmpz_factor_fprint factorPrint factorization to file Flint2fmpz_factor_get_str factor*Get string representation of factorization Flint2fmpz_factor_clear factor  Clears an  fmpz_factor_t structure. Flint2fmpz_factor_init factor Initialises an  fmpz_factor_t structure. Flint2fmpz_factor_print factorPrint factorization"  Safe-Inferred )*1"!" "  Safe-Inferred )*1- Flint2*Data structure containing the CArb pointer Flint2string options Flint2*Data structure containing the CArb pointer Flint2 Arf rounding Flint2*Data structure containing the CArb pointer Flint2*Data structure containing the CMag pointer Flint2Specifies that the result of an operation should be rounded to the nearest representable number in the direction towards zero. Flint2Specifies that the result of an operation should be rounded to the nearest representable number in the direction away from zero. Flint2Specifies that the result of an operation should be rounded to the nearest representable number in the direction towards minus infinity. Flint2Specifies that the result of an operation should be rounded to the nearest representable number in the direction towards plus infinity. Flint2Specifies that the result of an operation should be rounded to the nearest representable number, rounding to even if there is a tie between two values. Flint2If passed as the precision parameter to a function, indicates that no rounding is to be performed. Warning: use of this value is unsafe in general. It must only be passed as input under the following two conditions:The operation in question can inherently be viewed as an exact operation in \mathbb{Z}[\tfrac{1}{2}] for all possible inputs, provided that the precision is large enough. Examples include addition, multiplication, conversion from integer types to arbitrary-precision floating-point types, and evaluation of some integer-valued functions.The exact result of the operation will certainly fit in memory. Note that, for example, adding two numbers whose exponents are far apart can easily produce an exact result that is far too large to store in memory.The typical use case is to work with small integer values, double precision constants, and the like. It is also useful when writing test code. If in doubt, simply try with some convenient high precision instead of using this special value, and check that the result is exact. Flint2Default print option Flint2If  arb_str_more is added to flags, more (possibly incorrect) digits may be printed Flint2If arb_str_no_radius is added to flags, the radius is not included in the output if at least 1 digit of the midpoint can be printed. Flint2By adding a multiple m of arb_str_condense to flags, strings of more than three times m consecutive digits are condensed, only printing the leading and trailing m digits along with brackets indicating the number of digits omitted (useful when computing values to extremely high precision).  Safe-Inferred )*1.K   Safe-Inferred )*198 Flint2arb_hypgeom_infsum P Q hyp tol prec  Computes P, Q such that  P / Q = \sum_{k=0}^{\infty} T(k) where T(k) is defined by hyp3, using binary splitting and working precision of prec bits. The number of terms is chosen automatically to bound the truncation error by at most 2^{-\mathrm{tol}}. The bound for the truncation error is included in the output as part of P. Flint2arb_hypgeom_sum P Q hyp n prec  Computes P, Q such that P / Q = \sum_{k=0}^{n-1} T(k) where T(k) is defined by hyp5, using binary splitting and a working precision of prec bits. Flint2hypgeom_precompute hyp Precomputes the bounds data C, D, K and an upper bound for T(K). Flint2 hypgeom_bound error r C D K TK z prec 6Computes a truncation parameter sufficient to achieve prec bits of absolute accuracy, according to the strategy described above. The input consists of r, C, D, K, precomputed bound for T(K), and \tilde z = z (a_p / b_q), such that for k > K., the hypergeometric term ratio is bounded by` 0\frac{\tilde z}{k^r} \frac{k(k-D)}{(k-C)(k-2D)}.%Given this information, we compute a  \varepsilon and an integer n such that \left| \sum_{k=n}^{\infty} T(k) \right| \le \varepsilon \le 2^{-\mathrm{prec}}. The output variable error is set to the value of  \varepsilon, and n is returned. Flint2hypgeom_estimate_terms z r d )Computes an approximation of the largest n such that |z|^n/(n!)^r = 2^{-d}, giving a first-order estimate of the number of terms needed to approximate the sum of a hypergeometric series of weight r \ge 0 and argument z to an absolute precision of d \ge 0 bits. If r = 03, the direct solution of the equation is given by #n = (\log(1-z) - d \log 2) / \log z. If r > 0 , using \log n! \approx n \log n - n? gives an equation that can be solved in terms of the Lambert W -function as n = (d \log 2) / (r\,W\!(t)) where t = (d \log 2) / (e r z^{1/r}).The evaluation is done using double precision arithmetic. The function aborts if the computed value of n+ is greater than or equal to LONG_MAX / 2. Flint2 hypgeom_clear hyp Flint2 hypgeom_init hyp  Safe-Inferred )*19  Safe-Inferred )*1: Flint2An Acf structure consists of a pair of arf_struct:s. An acf_t is defined as an array of length one of type acf_struct, permitting an acf_t to be passed by reference. Flint2%An CArb consists of a pair of Arb:s.   Safe-Inferred )*1;K   Safe-Inferred )*1@4 Flint2Triple-valued logic Flint2calcium_write_acb out z digits flags Writes the Arb number z to out , showing digits1 digits and with the display style specified by flags (ARB_STR_NO_RADIUS, etc.). Flint2calcium_write_arb out z digits flags Flint2calcium_write_fmpz out x Writes the integer x to out. Flint2calcium_write_si out x Flint2calcium_version  0. For large n, this function implements a subquadratic algorithm. The convergents are given by a chain product of 2 by 2 matrices. This product is split in half recursively to balance the size of the coefficients.Flint2fmpq_get_cfrac c rem x n Generates up to n8 terms of the (simple) continued fraction expansion of x), writing the coefficients to the vector c and the remainder r to the rem* variable. The return value is the number k* of generated terms. The output satisfiesx = c_0 + \cfrac{1}{c_1 + \cfrac{1}{c_2 + \cfrac{1}{ \ddots + \cfrac{1}{c_{k-1} + r }}}} ]If r; is zero, the continued fraction expansion is complete. If r is nonzero, 1/r* can be passed back as input to generate c_k, c_{k+1}, \ldots . Calls to fmpq_get_cfrac can therefore be chained to generate the continued fraction incrementally, extracting any desired number of coefficients at a time.In general, a rational number has exactly two continued fraction expansions. By convention, we generate the shorter one. The longer expansion can be obtained by replacing the last coefficient a_{k-1} by the pair of coefficients a_{k-1} - 1, 1. =The behaviour of this function in corner cases is as follows:- if x is infinite (anything over 0), rem) will be zero and the return is k=0 regardless of n. [else (if x is finite),]if n <= 0, rem will be 1/x5 (allowing for infinite in the case x=0) and the return is k=0 else (if n > 0), rem0 will finite and the return is  0 < k \le n.7Essentially, if this function is called with canonical x and n > 0, then rem will be canonical. Therefore, applications relying on canonical fmpq_t&'s should not call this function with n <= 0.Flint2fmpq_simplest_between x l r Set x1 to the simplest fraction in the closed interval [l, r]?. The underscore version makes the additional assumption that l \le r. The endpoints l and r do not need to be reduced, but their denominators do need to be positive. x will be always be returned in canonical form. A canonical fraction a_1/b_1 is defined to be simpler than a_2/b_2 iff b_1 2 , a residue  0 \le a < m, and positive N, D satisfying 2ND < m-, this function attempts to find a fraction n/d with 0 \le |n| \le N and  0 < d \le D such that  \gcd(n,d) = 1 and n \equiv ad \pmod m. If a solution exists, then it is also unique. The function returns 1 if successful, and 0 to indicate that no solution exists.Flint2_fmpq_mod_fmpz res num den mod Sets the integer res to the residue a of x = n/d =  (num, den) modulo the positive integer m = mod, defined as the  0 \le a < m satisfying n \equiv a d \pmod m . If such an a; exists, 1 will be returned, otherwise 0 will be returned.Flint2_fmpq_mul_small rnum rden p1 q1 p2 q2 Sets  (rnum, rden) to the product of (p1, q1) and (p2, q2). Assumes that (p1, q1) and (p2, q2)8 are in canonical form and that all inputs are between  COEFF_MIN and  COEFF_MAX.Flint2_fmpq_add_small rnum rden p1 q1 p2 q2 Sets  (rnum, rden) to the sum of (p1, q1) and (p2, q2). Assumes that (p1, q1) and (p2, q2)8 are in canonical form and that all inputs are between  COEFF_MIN and  COEFF_MAX.Flint2_fmpq_gcd_cofactors gnum gden abar bbar anum aden bnum bden Set g to \operatorname{gcd}(a,b) as per fmpq_gcd and also compute \overline{a} = a/g and \overline{b} = b/g . Unlike fmpq_gcd*, this function requires canonical inputs.Flint2fmpq_gcd res op1 op2 Set res to the gcd of op1 and op2. See the low level function  _fmpq_gcd for our definition of gcd.Flint2 _fmpq_gcd rnum rden p q r s Set  (rnum, rden) to the gcd of (p, q) and (r, s) which we define to be the canonicalisation of gcd`(ps, qr)/(qs). (This is apparently Euclid's original definition and is stable under scaling of numerator and denominator. It also agrees with the gcd on the integers. Note that it does not agree with gcd as defined in fmpq_poly`.) This definition agrees with the result as output by Sage and Pari/GP.Flint2 fmpq_div_2exp res x exp Sets res to x divided by 2^exp.Flint2 fmpq_mul_2exp res x exp Sets res to x multiplied by 2^exp.Flint2 fmpq_div_fmpz res op x Sets res( to the quotient of the rational number op and the integer x.Flint2 fmpq_mul_fmpz res op x Sets res' to the product of the rational number op and the integer x.Flint2 fmpq_pow_fmpz a b e Set res to op! raised to the power~`e`. Return 1 for success and 0 for failure.Flint2 _fmpq_pow_si rnum rden opnum opden e Sets res to op) raised to the power~`e`, where~`e` is a slong. If e is 0 and op is 0, then res will be set to 1.Flint2fmpq_inv dest src Sets dest to 1 / src9. The result is placed in canonical form, assuming that src is already in canonical form.Flint2 _fmpq_addmul rnum rden op1num op1den op2num op2den Sets  (rnum, rden)' to the canonical form of the fraction  (rnum, rden) + (op1num, op1den) * (op2num, op2den) or  (rnum, rden) - (op1num, op1den) * (op2num, op2den) respectively. Aliasing between any combination of the variables is allowed, whilst no numerator is aliased with a denominator.Flint2 fmpq_addmul res op1 op2 Sets res to res + op1 * op2 or res - op1 * op2 respectively, placing the result in canonical form. Aliasing between any combination of the variables is allowed.Flint2 fmpq_mul_ui res op1 c Sets res to the product of op1 and the integer c.Flint2 _fmpq_mul_ui rnum rden p q r Sets  (rnum, rden) to the product of (p, q) and the integer r.LFlint2 fmpq_mul_si res op1 c Sets res to the product of op1 and the integer c.Flint2 _fmpq_mul_si rnum rden p q r Sets  (rnum, rden) to the product of (p, q) and the integer r.Flint2 fmpq_add_si res op1 c Sets res8 to the sum or difference respectively, of the fraction op1 and the integer c.Flint2 _fmpq_add_si rnum rden p q r Sets  (rnum, rden) to the canonical form of the sum or difference respectively of the fractions represented by (p, q) and (r, 1)3. Numerators may not be aliased with denominators.Flint2 _fmpq_add rnum rden op1num op1den op2num op2den Sets  (rnum, rden) to the canonical form of the sum, difference, product or quotient respectively of the fractions represented by (op1num, op1den) and (op2num, op2den). Aliasing between any combination of the variables is allowed, whilst no numerator is aliased with a denominator.Flint2fmpq_add res op1 op2 Sets res respectively to  op1 + op2,  op1 - op2,  op1 * op2, or  op1 / op2. Assumes that the inputs are in canonical form, and produces output in canonical form. Division by zero results in an error. Aliasing between any combination of the variables is allowed.Flint2_fmpq_randbits num den state bits Does the same thing as  fmpq_randbits9, but for numerator and denominator given explicitly as fmpz_t variables. Aliasing of num and den is not allowed.Flint2 fmpq_randbits res state bits Sets res to a random value, with numerator and denominator both having exactly bits- bits before canonicalisation, and then puts res in canonical form. Note that as a result of the canonicalisation, the resulting numerator and denominator can be slightly smaller than bits bits.Flint2fmpq_randtest_not_zero res state bits As per  fmpq_randtest, but the result will not be 0. If bits is set to 0, an exception will result.Flint2_fmpq_randtest num den state bits Does the same thing as  fmpq_randtest9, but for numerator and denominator given explicitly as fmpz_t variables. Aliasing of num and den is not allowed.Flint2 fmpq_randtest res state bits Sets res to a random value, with numerator and denominator having up to bits bits. The fraction will be in canonical form. This function has an increased probability of generating special values which are likely to trigger corner cases.Flint2 _fmpq_print num den Does the same thing as  fmpq_print9, but for numerator and denominator given explicitly as fmpz_t variables.In case of success, returns a positive number. In case of failure, returns a non-positive number.Flint2 _fmpq_fprint file num den Does the same thing as  fmpq_fprint9, but for numerator and denominator given explicitly as fmpz_t variables.In case of success, returns a positive number. In case of failure, returns a non-positive number.Flint2 fmpq_fprint file x Prints x as a fraction to the stream file. The numerator and denominator are printed verbatim as integers, with a forward slash (/) printed in between.In case of success, returns a positive number. In case of failure, returns a non-positive number.Flint2fmpq_clear_readonly f Clears the readonly fmpq_t f.Flint2fmpq_init_set_readonly f z Sets the uninitialised fmpq_t f( to a readonly version of the rational z.Note that the value of z; is assumed to remain constant throughout the lifetime of f.The fmpq_t f, has to be cleared by calling the function fmpq_clear_readonly.5The suggested use of the two functions is as follows: mpq_t z; ... { fmpq_t f; fmpq_init_set_readonly(f, z); foo(..., f); fmpq_clear_readonly(f); }Flint2flint_mpq_clear_readonly z Clears the readonly mpq_t z.Flint2flint_mpq_init_set_readonly z f Sets the uninitialised mpq_t z to the value of the readonly fmpq_t f.Note that it is assumed that f) does not change during the lifetime of z. The rational z! has to be cleared by a call to flint_mpq_clear_readonly.5The suggested use of the two functions is as follows: fmpq_t f; ... { mpq_t z; flint_mpq_init_set_readonly(z, f); foo(..., z); flint_mpq_clear_readonly(z); }This provides a convenient function for user code, only requiring to work with the types fmpq_t and mpq_t.Flint2 _fmpq_get_str str b num den $Prints the string representation of x in base  b \in [2, 36] to a suitable buffer.If str is not NULL<, this is used as the buffer and also the return value. If str is NULL, allocates sufficient space and returns a pointer to the string.Flint2 fmpq_get_mpfr dest src rnd Sets the MPFR variable dest to the value of src, rounded to the nearest representable binary floating-point value in direction rnd. Returns the sign of the rounding, according to MPFR conventions.Flint2 fmpq_get_mpq dest src Sets the value of destFlint2 fmpq_get_d f Returns f as a double, rounding towards zero if f cannot be represented exactly. The return is system dependent if f( is too large or too small to fit in a double.Flint2fmpq_init_set_mpz_frac_readonly z p q  Assuming z is an fmpz_t8 which will not be cleaned up, this temporarily copies p and q' into the numerator and denominator of z7 for read only operations only. The user must not run  fmpq_clear on z.Flint2 fmpq_set_str dest s base Sets the value of dest( to the value represented in the string s in base base.7Returns 0 if no error occurs. Otherwise returns -1 and dest is set to zero.Flint2 fmpq_set_mpq dest src Sets the value of dest to that of the mpq_t variable src.Flint2 _fmpq_set_ui rnum rden p q Sets  (rnum, rden)' to the canonical form of the fraction p / q. rnum and rden may not be aliased.Flint2 fmpq_set_ui res p q Sets res' to the canonical form of the fraction p / q.Flint2 _fmpq_set_si rnum rden p q Sets  (rnum, rden)' to the canonical form of the fraction p / q. rnum and rden may not be aliased.Flint2 fmpq_set_si res p q Sets res' to the canonical form of the fraction p / q.Flint2fmpq_get_mpz_frac a b c Sets a, b% to the numerator and denominator of c respectively.Flint2fmpq_set_fmpz_frac res p q Sets res' to the canonical form of the fraction p / q. This is equivalent to assigning the numerator and denominator separately and calling fmpq_canonicalise.Flint2fmpq_height_bits x ,Returns the number of bits in the height of x.Flint2 fmpq_height height x Sets height to the height of x, defined as the larger of the absolute values of the numerator and denominator of x.Flint2 fmpq_equal_si x y Returns 1 if x = y, otherwise returns 0.Flint2 fmpq_equal_ui x y Returns 1 if x = y, otherwise returns 0.Flint2 fmpq_cmp_si x y Returns negative if x < y , zero if x = y, and positive if x > y.Flint2fmpq_cmp x y Returns negative if x < y , zero if x = y, and positive if x > y.Flint2fmpq_sgn x (Returns the sign of the rational number x.Flint2 fmpq_equal x y Returns nonzero if x and y. are equal, and zero otherwise. Assumes that x and y are both in canonical form.Flint2 fmpq_is_pm1 res Returns nonzero if res has value \pm{1} and zero otherwise.Flint2 fmpq_is_one res Returns nonzero if res has value 1, and returns zero otherwise.Flint2 fmpq_is_zero res Returns nonzero if res) has value 0, and returns zero otherwise.Flint2fmpq_one res Sets the value of res to 1.Flint2 fmpq_zero res Sets the value of res to 0.Flint2fmpq_abs dest src Sets dest to the absolute value of src.Flint2fmpq_neg dest src Sets dest to the additive inverse of src.Flint2 fmpq_swap op1 op2 Swaps the two rational numbers op1 and op2.Flint2fmpq_set dest src Sets dest to a copy of src#. No canonicalisation is performed.Flint2_fmpq_is_canonical num den Does the same thing as fmpq_is_canonical9, but for numerator and denominator given explicitly as fmpz_t variables.Flint2fmpq_is_canonical x Returns nonzero if fmpq_t) x is in canonical form (as produced by fmpq_canonicalise), and zero otherwise.Flint2_fmpq_canonicalise num den Does the same thing as fmpq_canonicalise9, but for numerator and denominator given explicitly as fmpz_t variables. Aliasing of num and den is not allowed.Flint2fmpq_canonicalise res Puts res in canonical form: the numerator and denominator are reduced to lowest terms, and the denominator is made positive. If the numerator is zero, the denominator is set to one.If the denominator is zero, the outcome of calling this function is undefined, regardless of the value of the numerator.Flint2 fmpq_clear x  Clears the fmpq_t variable x=. To use the variable again, it must be re-initialised with  fmpq_init.Flint2 fmpq_init x Initialises the fmpq_t variable x for use. Its value is set to 0.Flint2newFmpq Construct a .Flint2withFmpq x fExecute f with x.Flint2 withNewFmpq f Execture f with a new .Flint2 withFmpqNum x fExecute f on the numerator of x.Flint2 withFmpqDen x fExecute f on the denominator of x.Flint2 fmpq_print x Prints x as a fraction. The numerator and denominator are printed verbatim as integers, with a forward slash (/) printed in between.In case of success, returns a positive number. In case of failure, returns a non-positive number.  Safe-Inferred )*1Ǡ Safe-Inferred )*1&Flint2 padic_debug op Prints debug information about op to the stream stdout, in the format  "(u v N)".Flint2 _padic_print u v ctx (Prints the string representation of the p -adic number op to the stream stdout..In the current implementation, always returns 1.Flint2 _padic_fprint file u v ctx (Prints the string representation of the p -adic number op to the stream file..In the current implementation, always returns 1.Flint2 padic_get_str str op ctx )Returns the string representation of the p -adic number op4 according to the printing mode set in the context.If str is NULL then a new block of memory is allocated and a pointer to this is returned. Otherwise, it is assumed that the string str is large enough to hold the representation and it is also the return value.Flint2 padic_val_fac rop op p Sets rop to the p$-adic valuation of the factorial of op, assuming that op is non-negative.Flint2padic_val_fac_ui n p  Computes the p-adic valuation of n!.Note that since n fits into an ulong , so does \operatorname{ord}_p(n!) since /\operatorname{ord}_p(n!) \leq (n - 1) / (p - 1).Flint2padic_val_fac_ui_2 n  Computes the 2-adic valuation of n!.Note that since n fits into an ulong , so does \operatorname{ord}_2(n!) since 7\operatorname{ord}_2(n!) \leq (n - 1) / (p - 1) = n - 1.Flint2padic_teichmuller rop op ctx &Computes the Teichm"uller lift of the p -adic unit op.If op is a p-adic integer divisible by p, sets rop to zero, which satisfies  t^p - t = 0 , although it is clearly not a (p-1)-st root of unity.If op# has negative valuation, raises an abort signal.Flint2_padic_teichmuller rop op p N &Computes the Teichm"uller lift of the p -adic unit op, assuming that N \geq 1.Supports aliasing between rop and op.Flint2padic_log_balanced rop op ctx Returns whether the p+-adic logarithm function converges at the p -adic number op, and if so sets rop to its value.Flint2padic_log_satoh rop op ctx Returns whether the p+-adic logarithm function converges at the p -adic number op, and if so sets rop to its value.Uses an algorithm based on a result of Satoh, Skjernaa and Taguchi that /\operatorname{ord}_p\bigl(a^{p^k} - 1\bigr) > k, which implies that` \log(a) \equiv p^{-k} \Bigl( \log\bigl(a^{p^k}\bigr) \pmod{p^{N+k}} \Bigr) \pmod{p^N}.Flint2padic_log_rectangular rop op ctx Returns whether the p+-adic logarithm function converges at the p -adic number op, and if so sets rop to its value.Uses a rectangular splitting algorithm to evaluate the series expression of \log(x) \bmod{p^N}.Flint2 padic_log rop op ctx Returns whether the p+-adic logarithm function converges at the p -adic number op, and if so sets rop to its value.The p7-adic logarithm function is defined by the usual series` <\log_p(x) = \sum_{i=1}^{\infty} (-1)^{i-1} \frac{(x-1)^i}{i}but this only converges when \operatorname{ord}_p(x - 1) is at least 2 or 1 when p = 2 or p > 2, respectively.Flint2 _padic_log z y v p N Computes` 5z = - \sum_{i = 1}^{\infty} \frac{y^i}{i} \pmod{p^N},reduced modulo p^N.*Note that this can be used to compute the p!-adic logarithm via the equation` \begin{aligned} \log(x) & = \sum_{i=1}^{\infty} (-1)^{i-1} \frac{(x-1)^i}{i} \\ & = - \sum_{i=1}^{\infty} \frac{(1-x)^i}{i}. \end{aligned} Assumes that  y = 1 - x is non-zero and that v = \operatorname{ord}_p(y) is at least 1 when p is odd and at least 2 when p = 2 so that the series converges. Assumes that v < N, and hence in particular N \geq 2."Does not support aliasing between y and z.Flint2_padic_log_bound v N p Returns b such that for all i \geq b we have` $i v - \operatorname{ord}_p(i) \geq Nwhere v \geq 1. Assumes that  1 \leq v < N or  2 \leq v < N when p is odd or p = 2, respectively, and also that  N < 2^{f-2} where f is  FLINT_BITS.Flint2padic_exp_balanced y x ctx Returns whether the p--adic exponential function converges at the p -adic number x, and if so sets y to its value.:Uses a balanced approach, balancing the size of chunks of x with the valuation and hence the rate of convergence, which results in a quasi-linear algorithm in N , for fixed p.Flint2padic_exp_rectangular y x ctx Returns whether the p--adic exponential function converges at the p -adic number x, and if so sets y to its value.Uses a rectangular splitting algorithm to evaluate the series expression of \exp(x) \bmod{p^N}.Flint2 padic_exp y x ctx Returns whether the p--adic exponential function converges at the p -adic number x, and if so sets y to its value.The p9-adic exponential function is defined by the usual series` 0\exp_p(x) = \sum_{i = 0}^{\infty} \frac{x^i}{i!}#but this only converges only when %\operatorname{ord}_p(x) > 1 / (p - 1). For elements x \in \mathbf{Q}_p, this means that \operatorname{ord}_p(x) \geq 1 when p \geq 3 and \operatorname{ord}_2(x) \geq 2 when p = 2.Flint2_padic_exp_rectangular rop u v p N Sets rop to the p#-exponential function evaluated at  x = p^v u, reduced modulo p^N. Assumes that x \neq 0, that \operatorname{ord}_p(x) < N and that \exp(x) converges, that is, that \operatorname{ord}_p(x) is at least 2 or 1 depending on whether the prime p is 2 or odd.Supports aliasing between rop and u.Flint2_padic_exp_bound v N p Returns an integer i such that for all j \geq i we have %\operatorname{ord}_p(x^j / j!) \geq N , where \operatorname{ord}_p(x) = v.When p! is a word-sized prime, returns 5\left\lceil \frac{(p-1)N - 1}{(p-1)v - 1}\right\rceil. Otherwise, returns \lceil N/v\rceil. Assumes that v < N . Moreover, v has to be at least 2 or 1, depending on whether p is 2 or odd.Flint2 padic_pow_si rop op e ctx Sets rop to op raised to the power e$, which is defined as one whenever e = 0.)Assumes that some computations involving e and the valuation of op do not overflow in the slong range.Note that if the input  x = p^v u is defined modulo p^N then x^e = p^{ev} u^e is defined modulo p^{N + (e - 1) v}%, which is a precision loss in case v < 0.Flint2 padic_sqrt rop op ctx Returns whether op is a p)-adic square. If this is the case, sets rop5 to one of the square roots; otherwise, the value of rop is undefined.We have the following theorem:Let u \in \mathbf{Z}^{\times}. Then u is a square if and only if  u \bmod p is a square in \mathbf{Z} / p \mathbf{Z}, for p > 2, or if  u \bmod 8 is a square in \mathbf{Z} / 8 \mathbf{Z}, for p = 2.Flint2 padic_inv rop op ctx Computes the inverse of op modulo p^N. Suppose that op is given as  x = u p^v . Raises an abort signal if v < -N%. Otherwise, computes the inverse of u modulo p^{N+v}.:This function employs Hensel lifting of an inverse modulo p.Flint2 _padic_inv rop op p N Sets rop to the inverse of op modulo p^N, assuming that op is a unit and N \geq 1.In the current implementation, allows aliasing, but this might change in future versions.Flint2_padic_inv_precomp rop op S Sets rop to the inverse of op modulo p^N, assuming that op is a unit and N \geq 1.In the current implementation, allows aliasing, but this might change in future versions.Uses some data S& precomputed by calling the function _padic_inv_precompute(. Note that this object is not declared const and in fact it carries a field providing temporary work space. This allows repeated calls of this function to avoid repeated memory allocations, as used e.g. by the function  padic_log.Flint2_padic_inv_clear S Frees the memory used by S.Flint2_padic_inv_precompute S p N 9Pre-computes some data and allocates temporary space for p&-adic inversion using Hensel lifting.Flint2 padic_div rop op1 op2 ctx Sets rop to the quotient of op1 and op2.Flint2 padic_shift rop op v ctx Sets rop to the product of op and p^v.Flint2 padic_mul rop op1 op2 ctx Sets rop to the product of op1 and op2.Flint2 padic_neg rop op ctx Sets rop to the additive inverse of op.Flint2 padic_sub rop op1 op2 ctx Sets rop to the difference of op1 and op2.Flint2 padic_add rop op1 op2 ctx Sets rop to the sum of op1 and op2.Flint2_padic_lifts_pows pow a n p Given an array a as computed above, this function computes the corresponding powers of p , that is, pow[i] is equal to p^{a_i}.Flint2_padic_lifts_exps n N Given a positive integer N define the sequence a_0 = N, a_1 = \lceil a_0/2\rceil, \dotsc, a_{n-1} = \lceil a_{n-2}/2\rceil = 1. Then n = \lceil\log_2 N\rceil + 1.This function sets n% and allocates and returns the array a.Flint2 padic_equal op1 op2 Returns whether op1 and op2 are equal, that is, whether  u_1 = u_2 and  v_1 = v_2.Flint2 padic_is_one op Returns whether op# is equal to one, that is, whether u = 1 and v = 0.Flint2 padic_is_zero op Returns whether op is equal to zero.Flint2 padic_one rop  Sets the p -adic number rop* to one, reduced modulo the precision of rop.Flint2 padic_zero rop  Sets the p -adic number rop to zero.Flint2 padic_swap op1 op2 Swaps the two p-adic numbers op1 and op2.Note that this includes swapping the precisions. In particular, this operation is not equivalent to swapping op1 and op2 using  padic_set and an auxiliary variable whenever the precisions of the two elements are different.Flint2 padic_get_mpq rop op ctx Sets the MPIR rational rop to the value of op.Flint2 padic_get_mpz rop op ctx Sets the MPIR integer rop to the p-adic integer op.If op is not a p-adic integer, raises an abort signal.Flint2padic_get_fmpq rop op ctx Sets the rational rop to the p -adic number op.Flint2padic_get_fmpz rop op ctx Sets the integer rop to the exact p-adic integer op.If op is not a p-adic integer, raises an abort signal.Flint2 padic_set_mpq rop op ctx Sets rop to the MPIR rational op.Flint2 padic_set_mpz rop op ctx  Sets the p -adic number rop to the MPIR integer op.Flint2padic_set_fmpq rop op ctx Sets rop to the rational op.Flint2padic_set_fmpz rop op ctx  Sets the p -adic number rop to the integer op.Flint2 padic_set_ui rop op ctx  Sets the p -adic number rop to the ulong integer op.Flint2 padic_set_si rop op ctx  Sets the p -adic number rop to the slong integer op.Flint2 padic_set rop op ctx Sets rop to the p -adic number op.Flint2padic_randtest_int rop state ctx Sets rop to a random p-adic integer modulo p^N.Note that whenever N \leq 0, rop is set to zero.Flint2padic_randtest_not_zero rop state ctx Sets rop to a random non-zero p-adic number modulo p^N;, where the range of the valuation is as for the function padic_randtest.Flint2padic_randtest rop state ctx Sets rop to a random p-adic number modulo p^N with valuation in the range [- \lceil N/10\rceil, N),  - \lceil -N/10\rceil, N), or [-10, 0) as N* is positive, negative or zero, whenever rop is non-zero.Flint2 padic_reduce rop ctx Ensures that the p -adic number rop is reduced.Flint2 _padic_reduce rop ctx Given a p -adic number rop' in canonical form, reduces it modulo p^N.Flint2_padic_canonicalise rop ctx  Brings the p -adic number rop into canonical form.$That is to say, ensures that either  u = v = 0 or  p \nmid u+. There is no reduction modulo a power of p.Flint2 padic_clear rop Clears all memory used by the p -adic number rop.Flint2 padic_init2 rop N Initialises the p -adic number rop with precision N.Flint2 padic_init rop Initialises the p(-adic number with the precision set to PADIC_DEFAULT_PREC, which is defined as 20.Flint2_padic_ctx_pow_ui rop e ctx Sets rop to p^e# as efficiently as possible, where rop% is expected to be an uninitialised fmpz_t.If the return value is non-zero, it is the responsibility of the caller to clear the returned integer.Flint2padic_ctx_clear ctx Clears all memory that has been allocated as part of the context.Flint2padic_ctx_init ctx p min max mode Initialises the context ctx with the given data. Assumes that p is a prime. This is not verified but the subsequent behaviour is undefined if p is a composite number. Assumes that min and max are non-negative and that min is at most max , raising an abort signal otherwise.)Assumes that the printing mode is one of  PADIC_TERSE,  PADIC_SERIES, or PADIC_VAL_UNIT. Using the example  x = 7^{-1} 12 in  \mathbf{Q}_7, these behave as follows:In  padic_terseE mode, a p-adic number is printed in the same way as a rational number, e.g. 12/7.In  padic_series mode, a p.-adic number is printed digit by digit, e.g.  5*7^-1 + 1.In padic_val_unit mode, a p-adic number is printed showing the valuation and unit parts separately, e.g. 12*7^-1.Flint2Create a new p-adic.Flint2 Use p-adic.Flint2Apply f to new p-adic.Flint2!Create p-adic context with prime p, precomputed powers p^{min} to p^{max} and  mode.Flint2Use p-adic context.Flint2Use new p-adic ctxFlint2 padic_unit op Returns the unit part of the p-adic number as a FLINT integer, which can be used as an operand for the fmpz functions.Flint2 padic_get_val op "Returns the valuation part of the p -adic number.Flint2padic_get_prec op Returns the precision of the p -adic number.Flint2 padic_print op ctx (Prints the string representation of the p -adic number op to the stream stdout..In the current implementation, always returns 1.! Safe-Inferred )*1 Safe-Inferred )*1 Flint2_nmod_vec_dot_ptr vec1 vec2 offset len mod nlimbs Returns the dot product of (vec1, len) and the values at vec2[i][offset]. The nlimbs parameter should be 0, 1, 2 or 3, specifying the number of limbs needed to represent the unreduced result.Flint2_nmod_vec_dot_rev vec1 vec2 len mod nlimbs  The same as  _nmod_vec_dot, but reverses vec2.Flint2 _nmod_vec_dot vec1 vec2 len mod nlimbs Returns the dot product of (vec1, len) and (vec2, len). The nlimbs parameter should be 0, 1, 2 or 3, specifying the number of limbs needed to represent the unreduced result.Flint2_nmod_vec_dot_bound_limbs len mod Returns the number of limbs (0, 1, 2 or 3) needed to represent the unreduced dot product of two vectors of length len having entries modulo mod.n, assuming that len is nonnegative and that mod.n is nonzero. The computed bound is tight. In other words, this function returns the precise limb size of len times (mod.n - 1) ^ 2.Flint2_nmod_vec_scalar_addmul_nmod res vec len c mod Adds  (vec, len) times c to the vector  (res, len). The element c and all elements of vec are assumed to be less than mod.n.Flint2_nmod_vec_scalar_mul_nmod_shoup res vec len c mod Sets  (res, len) to  (vec, len) multiplied by c using n_mulmod_shoup. mod.n should be less than 2^{\mathtt{FLINT\_BITS} - 1}. c and all elements of vec should be less than mod.n.Flint2_nmod_vec_scalar_mul_nmod res vec len c mod Sets  (res, len) to  (vec, len) multiplied by c. The element c and all elements of vec are assumed to be less than mod.n.Flint2 _nmod_vec_neg res vec len mod Sets  (res, len) to the negation of  (vec, len).Flint2 _nmod_vec_sub res vec1 vec2 len mod Sets  (res, len) to the difference of  (vec1, len) and  (vec2, len).Flint2 _nmod_vec_add res vec1 vec2 len mod Sets  (res, len) to the sum of  (vec1, len) and  (vec2, len).Flint2_nmod_vec_equal vec vec2 len Returns~`1` if  (vec, len) is equal to  (vec2, len), otherwise returns~`0`.Flint2_nmod_vec_max_bits vec len >Returns the maximum number of bits of any entry in the vector.Flint2_nmod_vec_reduce res vec len mod Reduces the entries of  (vec, len) modulo mod.n and set res to the result.Flint2_nmod_vec_swap a b length Swaps the vectors a and b of length n# by actually swapping the entries.Flint2_nmod_vec_zero vec len +Zeros the given vector of the given length.Flint2 _nmod_vec_set res vec len Copies len entries from the vector vec to res.Flint2_nmod_vec_randtest vec state len mod Sets vec to a random vector of the given length with entries reduced modulo mod.n.Flint2_nmod_vec_clear vec *Frees the memory used by the given vector.Flint2_nmod_vec_init len Returns a vector of the given length. The entries are not necessarily zero." Safe-Inferred )*1!K Safe-Inferred )*11LFlint2Data structure containing the CFmpzPolyMulPrecache pointerLFlint2Data structure containing the CFmpzPolyFactor pointerLFlint2Data structure containing the CFmpzPolyPowersPrecomp pointerFlint2fmpz_poly_CLD_bound res f n Compute a bound on the n coefficient of fg'/g where g is any factor of f.Flint2fmpz_poly_theta_qexp f r n Sets f to the q-expansion to length n3 of the Jacobi theta function raised to the power r, i.e. \vartheta(q)^r where 0\vartheta(q) = 1 + 2 \sum_{k=1}^{\infty} q^{k^2}.'This function uses sparse formulas for r = 1, 2 and otherwise reduces to those cases using power series arithmetic.Flint2_fmpz_poly_theta_qexp f r len Flint2fmpz_poly_eta_qexp f r n Sets f to the q-expansion to length n; of the Dedekind eta function (without the leading factor q^{1/24}) raised to the power r, i.e. 8(q^{-1/24} \eta(q))^r = \prod_{k=1}^{\infty} (1 - q^k)^r.In particular, r = -1: gives the generating function of the partition function p(k), and r = 24 gives, after multiplication by q, the modular discriminant  \Delta(q)- which generates the Ramanujan tau function \tau(k).'This function uses sparse formulas for r = 1, 2, 3, 4, 6 and otherwise reduces to one of those cases using power series arithmetic.Flint2_fmpz_poly_eta_qexp f r len Flint2fmpz_poly_fibonacci poly n Sets poly to the n-th Fibonacci polynomial. The coefficients are calculated using a hypergeometric recurrence.Flint2_fmpz_poly_fibonacci coeffs n Sets coeffs! to the coefficient array of the n-th Fibonacci polynomial. The coefficients are calculated using a hypergeometric recurrence.Flint2fmpz_poly_hermite_he poly n Sets poly to the Hermite polynomial He_n(x), defined by ;He_n(x) = 2^{-\tfrac{n}{2}}H_n\left(\frac{x}{\sqrt2}\right), for n\ge0. The coefficients are calculated using a hypergeometric recurrence.Flint2_fmpz_poly_hermite_he coeffs n Sets coeffs5 to the coefficient array of the Hermite polynomial He_n(x), defined by ;He_n(x) = 2^{-\tfrac{n}{2}}H_n\left(\frac{x}{\sqrt2}\right), for n\ge0. The coefficients are calculated using a hypergeometric recurrence. The length of the array will be n+1.Flint2fmpz_poly_hermite_h poly n Sets poly to the Hermite polynomial H_n(x), defined by H'_n(x) = 2nH_{n-1}(x), for n\ge0. The coefficients are calculated using a hypergeometric recurrence.Flint2_fmpz_poly_hermite_h coeffs n Sets coeffs5 to the coefficient array of the Hermite polynomial H_n(x) , defined by H'_n(x) = 2nH_{n-1}(x), for n\ge0. The coefficients are calculated using a hypergeometric recurrence. The length of the array will be n+1.Flint2fmpz_poly_legendre_pt poly n Sets poly$ to the shifted Legendre polynomial \tilde{P_n}(x), defined by \tilde{P_n}(x) = P_n(2x-1), for n\ge0. The coefficients are calculated using a hypergeometric recurrence. See  fmpq_poly for the Legendre polynomials.Flint2_fmpz_poly_legendre_pt coeffs n Sets coeffs> to the coefficient array of the shifted Legendre polynomial \tilde{P_n}(x), defined by \tilde{P_n}(x) = P_n(2x-1), for n\ge0. The coefficients are calculated using a hypergeometric recurrence. The length of the array will be n+1. See  fmpq_poly for the Legendre polynomials.Flint2fmpz_poly_chebyshev_u poly n Sets poly/ to the Chebyshev polynomial of the first kind U_n(x), defined by (n+1) U_n(x) = T'_{n+1}(x), for n\ge0. The coefficients are calculated using a hypergeometric recurrence.Flint2_fmpz_poly_chebyshev_u coeffs n Flint2fmpz_poly_chebyshev_t poly n Sets poly/ to the Chebyshev polynomial of the first kind T_n(x), defined by T_n(x) = \cos(n \cos^{-1}(x)), for n\ge0. The coefficients are calculated using a hypergeometric recurrence.Flint2_fmpz_poly_chebyshev_t coeffs n Flint2fmpz_poly_swinnerton_dyer poly n Sets poly# to the Swinnerton-Dyer polynomial S_n&, defined as the integer polynomial S_n = \prod (x \pm \sqrt{2} \pm \sqrt{3} \pm \sqrt{5} \pm \ldots \pm \sqrt{p_n}) where p_n denotes the n-th prime number and all combinations of signs are taken. This polynomial has degree 2^n and is irreducible over the integers (it is the minimal polynomial of \sqrt{2} + \ldots + \sqrt{p_n}).Flint2_fmpz_poly_swinnerton_dyer coeffs n Flint2fmpz_poly_cos_minpoly poly n Sets poly to the minimal polynomial of 2 \cos(2 \pi / n). For suitable choice of n(, this gives the minimal polynomial of  2 \cos(a \pi) or  2 \sin(a \pi) for any rational a.The cosine is multiplied by a factor two since this gives a monic polynomial with integer coefficients. One can obtain the minimal polynomial for \cos(2 \pi / n) by making the substitution  x \to x / 2.For n > 2", the degree of the polynomial is \varphi(n) / 2. For n = 1, 2, the degree is 1. For n = 08, we define the output to be the constant polynomial 1.See  [WaktinsZeitlin1993].Flint2_fmpz_poly_cos_minpoly coeffs n Flint2fmpz_poly_is_cyclotomic poly If poly/ is a cyclotomic polynomial, returns the index n$ of this cyclotomic polynomial. If poly, is not a cyclotomic polynomial, returns 0.Flint2_fmpz_poly_is_cyclotomic poly len Flint2fmpz_poly_cyclotomic poly n Sets poly to the n'-th cyclotomic polynomial, defined as %\Phi_n(x) = \prod_{\omega} (x-\omega) where \omega runs over all the n-th primitive roots of unity. We factor n into n = qs where q is squarefree, and compute  \Phi_q(x). Then \Phi_n(x) = \Phi_q(x^s).Flint2_fmpz_poly_cyclotomic a n factors  num_factors phi Sets a0 to the lower half of the cyclotomic polynomial  \Phi_n(x) , given n \ge 3 which must be squarefree.4A precomputed array containing the prime factors of n must be provided, as well as the value of the Euler totient function \phi(n) as phi. If n1 is even, 2 must be the first factor in the list.The degree of  \Phi_n(x) is exactly \phi(n). Only the low (\phi(n) + 1) / 2 coefficients are written; the high coefficients can be obtained afterwards by copying the low coefficients in reverse order, since  \Phi_n(x) is a palindrome for n \ne 1.We use the sparse power series algorithm described as Algorithm 4  [ArnoldMonagan2011](. The algorithm is based on the identity` -\Phi_n(x) = \prod_{d|n} (x^d - 1)^{\mu(n/d)}.Treating the polynomial as a power series, the multiplications and divisions can be done very cheaply using repeated additions and subtractions. The complexity is O(2^k \phi(n)) where k$ is the number of prime factors in n. To improve efficiency for small n, we treat the fmpz coefficients as machine integers when there is no risk of overflow. The following bounds are given in Table 6 of  [ArnoldMonagan2011]:For  n < 10163195!, the largest coefficient in any  \Phi_n(x)8 has 27 bits, so machine arithmetic is safe on 32 bits.For  n < 169828113!, the largest coefficient in any  \Phi_n(x)8 has 60 bits, so machine arithmetic is safe on 64 bits.%Further, the coefficients are always \pm 1 or 0 if there are exactly two prime factors, so in this case machine arithmetic can be used as well.Finally, we handle two special cases: if there is exactly one prime factor n = p, then *\Phi_n(x) = 1 + x + x^2 + \ldots + x^{n-1} , and if n = 2m , we use \Phi_n(x) = \Phi_m(-x) to fall back to the case when n is odd.Flint2fmpz_poly_num_real_roots pol >Returns the number of real roots of the squarefree polynomial pol.+The polynomial is assumed to be squarefree.Flint2_fmpz_poly_num_real_roots pol len ?Returns the number of real roots of the squarefree polynomial  (pol, len).+The polynomial is assumed to be squarefree.Flint2fmpz_poly_num_real_roots_sturm pol >Returns the number of real roots of the squarefree polynomial pol using Sturm sequence.+The polynomial is assumed to be squarefree.Flint2_fmpz_poly_num_real_roots_sturm n_neg n_pos pol len Sets n_neg and n_pos to the number of negative and positive roots of the polynomial  (pol, len) using Sturm sequence. The Sturm sequence is computed via subresultant remainders obtained by repeated call to the function _fmpz_poly_pseudo_rem_cohen.The polynomial is assumed to be squarefree, of degree larger than 1 and with non-zero constant coefficient.Flint2fmpz_poly_bound_roots bound poly Computes a nonnegative integer bound9 that bounds the absolute value of all complex roots of poly. Uses Fujiwara's bound` 2 \max \left( \left|\frac{a_{n-1}}{a_n}\right|, \left|\frac{a_{n-2}}{a_n}\right|^{\frac{1}{2}}, \dotsc, \left|\frac{a_1}{a_n}\right|^{\frac{1}{n-1}}, \left|\frac{a_0}{2a_n}\right|^{\frac{1}{n}} \right)-where the coefficients of the polynomial are a_0, \ldots, a_n.Flint2_fmpz_poly_bound_roots bound poly len Flint2 fmpz_poly_product_roots_fmpq_vec poly xs n Sets poly, to the polynomial which is the product of 7(q_0 x - p_0)(q_1 x - p_1) \cdots (q_{n-1} x - p_{n-1}) , the roots p_i/q_i being given by xs.Flint2!_fmpz_poly_product_roots_fmpq_vec poly xs n Sets  (poly, n + 1) to the product of 7(q_0 x - p_0)(q_1 x - p_1) \cdots (q_{n-1} x - p_{n-1}) , the roots p_i/q_i being given by xs.Flint2 fmpz_poly_product_roots_fmpz_vec poly xs n Sets poly2 to the monic polynomial which is the product of '(x - x_0)(x - x_1) \cdots (x - x_{n-1}) , the roots x_i being given by xs.Flint2!_fmpz_poly_product_roots_fmpz_vec poly xs n Sets  (poly, n + 1)2 to the monic polynomial which is the product of '(x - x_0)(x - x_1) \cdots (x - x_{n-1}) , the roots x_i being given by xs.0Aliasing of the input and output is not allowed.Flint2fmpz_poly_CRT_ui res poly1 m poly2 sign Given poly1 with coefficients modulo m and poly2 with modulus n, sets res" to the CRT reconstruction modulo mn with coefficients satisfying -mn/2 \le c < mn/2 (if sign = 1) or  0 \le c < mn (if sign = 0).Flint2_fmpz_poly_CRT_ui res poly1 len1 m1 poly2 len2 m2 m2inv sign This function is identical to _fmpz_poly_CRT_ui_precomp&, apart from automatically computing m_1m_2 and c. It also aborts if c cannot be computed.Flint2_fmpz_poly_CRT_ui_precomp res poly1 len1 m1 poly2 len2 m2 m2inv m1m2 c sign Sets the coefficients in res# to the CRT reconstruction modulo m_1m_2 of the residues  (poly1, len1) and  (poly2, len2) which are images modulo m_1 and m_2 respectively. The caller must supply the precomputed product of the input moduli as m_1m_2, the inverse of m_1 modulo m_2 as c", and the precomputed inverse of m_2 (in the form computed by n_preinvert_limb) as m2inv.If sign = 0, residues 0 \le r < m_1 m_2 are computed, while if sign = 1, residues -m_1 m_2/2 \le r < m_1 m_2/2 are computed.Coefficients of res" are written up to the maximum of len1 and len2.Flint2 fmpz_poly_set_nmod_poly_unsigned A Amod Sets the coefficients of A to the residues in Amod, normalised to the interval  0 \le r < m where m is the modulus.Flint2fmpz_poly_set_nmod_poly A Amod Sets the coefficients of A to the residues in Amod, normalised to the interval -m/2 \le r < m/2 where m is the modulus.Flint2fmpz_poly_get_nmod_poly Amod A Sets the coefficients of Amod to the coefficients in A, reduced by the modulus of Amod.Flint2fmpz_poly_fread_pretty file poly x !Reads a polynomial from the file file and sets poly! to this polynomial. The string *x8 is set to the variable name that is used in the input.Returns a positive value, equal to the number of characters read from the file, in case of success. Returns a non-positive value in case of failure, which could either be a read error or the indicator of a malformed input.Flint2fmpz_poly_fread file poly #Reads a polynomial from the stream file, storing the result in poly.In case of success, returns a positive number. In case of failure, returns a non-positive value.Flint2fmpz_poly_read_pretty poly x )Reads a polynomial in pretty format from stdin.=For further details, see the documentation for the function fmpz_poly_fread_pretty.Flint2fmpz_poly_read poly Reads a polynomial from stdin, storing the result in poly.In case of success, returns a positive number. In case of failure, returns a non-positive value.Flint2fmpz_poly_fprint_pretty file poly x $Prints the pretty representation of poly to the stream file, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2_fmpz_poly_fprint_pretty file poly len x $Prints the pretty representation of  (poly, len) to the stream file, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2fmpz_poly_fprint file poly $Prints the polynomial to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2_fmpz_poly_fprint file poly len Prints the polynomial  (poly, len) to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2fmpz_poly_print_pretty poly x $Prints the pretty representation of poly to stdout, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2_fmpz_poly_print_pretty poly len x $Prints the pretty representation of  (poly, len) to stdout, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2fmpz_poly_print poly Prints the polynomial to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2_fmpz_poly_print poly len Prints the polynomial  (poly, len) to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2fmpz_poly_hensel_lift_once  lifted_fac f  local_fac N !This function does a Hensel lift.!It lifts local factors stored in  local_fac of f to p^N , where N \geq 2'. The lifted factors will be stored in  lifted_fac. This lift cannot be restarted. This function is a convenience function intended for end users. The product of local factors must be squarefree.Flint2_fmpz_poly_hensel_continue_lift  lifted_fac link v w f prev curr N p -This function restarts a stopped Hensel lift.It lifts from curr to N. It also requires prev (to lift the cofactors) given as the return value of the function _fmpz_poly_hensel_start_lift or the function _fmpz_poly_hensel_continue_lift.. The current lifted factors are supplied in  lifted_fac. and upon return are updated there. As usual link, v, and w# describe the current Hensel tree, r% is the number of local factors and p is the small prime modulo whose power we are lifting to. It is required that curr be at least 1 and that N > curr."Currently, supports the case when prev and curr are equal.Flint2_fmpz_poly_hensel_start_lift  lifted_fac link v w f  local_fac N )This function takes the local factors in  local_fac1 and Hensel lifts them until they are known mod p^N, where N \geq 1.?These lifted factors will be stored (in the same ordering) in  lifted_fac. It is assumed that link, v, and w are initialized arrays of  fmpz_poly_t's with at least 2*r - 2 entries and that r \geq 2. This is done outside of this function so that you can keep them for restarting Hensel lifting later. The product of local factors must be squarefree.The return value is an exponent which must be passed to the function _fmpz_poly_hensel_continue_lift as prev_exp) if the Hensel lifting is to be resumed."Currently, supports the case when N = 1 for convenience, although it is preferable in this case to simply iterate over the local factors and convert them to polynomials over  \mathbf{Z}.Flint2fmpz_poly_hensel_lift_tree link v w f r p e0 e1 inv  Computes  p_0 = p^{e_0} and p_1 = p^{e_1 - e_0} for a small prime p and  P = p^{e_1}.If we aim to lift to p^b then f is the polynomial whose factors we wish to lift, made monic mod p^b . As usual,  (link, v, w) is an initialised tree.)This starts the recursion on lifting the  product tree for lifting from p^{e_0} to p^{e_1}. The value of inv- corresponds to that given for the function $fmpz_poly_hensel_lift_tree_recursive . We set r$ to the number of local factors of f. In terms of the notation, above  P = p^{e_1},  p_0 = p^{e_0} and p_1 = p^{e_1-e_0}. Assumes that f is monic. Assumes that 1 < p_1 \leq p_0 , that is, 0 < e_1 \leq e_0.Flint2$fmpz_poly_hensel_lift_tree_recursive link v w f j inv p0 p1 Takes a current Hensel tree  (link, v, w) and a pair (j,j+1)5 of entries in the tree and lifts the tree from mod p_0 to mod  P = p_0 p_1, where 1 < p_1 \leq p_0.Set inv to -1 if restarting Hensel lifting, 0 if stopping and 1 otherwise.Here f = g h is the polynomial whose factors we are trying to lift. We will have that v[j] is the product of  v[link[j]] and v[link[j] + 1] as described above.Does support aliasing of f+ with one of the polynomials in the lists v and w. But the polynomials in these two lists are not allowed to be aliases of each other.Flint2"fmpz_poly_hensel_lift_only_inverse Aout Bout G H a b p p1 Given polynomials such that f = gh \pmod p and ag + bh = 1 \pmod p, lifts only the cofactors a and b modulo  P = p p_1.See fmpz_poly_hensel_lift.Flint2%fmpz_poly_hensel_lift_without_inverse Gout Hout f g h a b p p1 Given polynomials such that f = gh \pmod p and ag + bh = 1 \pmod p, lifts only the factors g and h modulo  P = p p_1.See fmpz_poly_hensel_lift.Flint2fmpz_poly_hensel_lift G H A B f g h a b p p1 This is the main Hensel lifting routine, which performs a Hensel step from polynomials mod p to polynomials mod  P = p p_1. One starts with polynomials f, g, h such that f = gh \pmod p. The polynomials a, b satisfy ag + bh = 1 \pmod p.The lifting formulae are` G = \biggl( \bigl( \frac{f-gh}{p} \bigr) b \bmod g \biggr) p + g H = \biggl( \bigl( \frac{f-gh}{p} \bigr) a \bmod h \biggr) p + h B = \biggl( \bigl( \frac{1-aG-bH}{p} \bigr) b \bmod g \biggr) p + b A = \biggl( \bigl( \frac{1-aG-bH}{p} \bigr) a \bmod h \biggr) p + aUpon return we have A G + B H = 1 \pmod P and f = G H \pmod P , where  G = g \pmod p etc.We require that 1 < p_1 \leq p! and that the input polynomials f, g, h have degree at least 1! and that the input polynomials a and b are non-zero.The output arguments  G, H, A, B/ may only be aliased with the input arguments  g, h, a, b, respectively.Flint2fmpz_poly_hensel_build_tree link v w fac >Initialises and builds a Hensel tree consisting of two arrays v, w. of polynomials and an array of links, called link.The caller supplies a set of r) local factors (in the factor structure fac) of some polynomial F over  \mathbf{Z}:. They also supply two arrays of initialised polynomials v and w, each of length 2r - 2 and an array link, also of length 2r - 2.We will have five arrays: a v of  fmpz_poly_t 's and a V of  nmod_poly_t's and also a w and a W and link. Here's the idea: we sort each leaf and node of a factor tree by degree, in fact choosing to multiply the two smallest factors, then the next two smallest (factors or products) etc. until a tree is made. The tree will be stored in the v's. The first two elements of v will be the smallest modular factors, the last two elements of v will multiply to form F itself. Since v will be rearranging the original factors we will need to be able to recover the original order. For this we use the array link which has nonnegative even numbers and negative numbers. It is an array of slongs which aligns with V and v if link has a negative number in spot j that means V_j: is an original modular factor which has been lifted, if link[j]$ is a nonnegative even number then V_j) stores a product of the two entries at  V[link[j]] and  V[link[j]+1]. W and w( play the role of the extended GCD, at V_0, V_2, V_4, etc. we have a new product, W_0, W_2, W_4%, etc. are the XGCD cofactors of the V's. For example, *V_0 W_0 + V_1 W_1 \equiv 1 \pmod{p^{\ell}} for some \ell1. These will be lifted along with the entries in V. It is not enough to just lift each factor, we have to lift the entire tree and the tree of XGCD cofactors.Flint2fmpz_poly_signature r1 r2 poly Computes the signature  (r_1, r_2) of the polynomial poly+, which is assumed to be square-free over  \mathbb{Q}. The values of r_1 and 2 r_2 are the number of real and complex roots of the polynomial, respectively. For convenience, the zero polynomial is allowed, in which case the output is (0, 0).If the polynomial is not square-free, the behaviour is undefined and an exception may be raised.This function uses the algorithm described in Algorithm 4.1.11 of  [Coh1996].Flint2_fmpz_poly_signature r1 r2 poly len Computes the signature  (r_1, r_2) of the polynomial  (poly, len)2. Assumes that the polynomial is squarefree over  \mathbb{Q}.Flint2fmpz_poly_power_sums_to_poly res Q ;Compute the (monic) polynomial given its power sums series (Q).Flint2_fmpz_poly_power_sums_to_poly res poly len ?Compute the (monic) polynomial given by its power sums series  (poly,len).Flint2fmpz_poly_power_sums res poly n Compute the (truncated) power sums series of the monic polynomial poly up to length n8. That is the power series whose coefficient of degree i is the sum of the i4-th power of all (complex) roots of the polynomial poly.Flint2fmpz_poly_power_sums_naive res poly n Compute the (truncated) power sum series of the monic polynomial poly up to length n using Newton identities.Flint2_fmpz_poly_power_sums_naive res poly len n Compute the (truncated) power sums series of the monic polynomial  (poly,len) up to length n using Newton identities.Flint2fmpz_poly_sqrt_series b a n Set b" to the square root of the series a9, where the latter is taken to be a series of precision n(. If such a square root exists, return 1, otherwise, return 0.Note that if the valuation of a is not zero, b will not have precision n. It is given only to the precision to which the square root can be computed.Flint2_fmpz_poly_sqrt_series res poly len n Set (res, n)" to the square root of the series  (poly, n), if it exists, and return 1, otherwise, return 0.If the valuation of poly is not zero, res is zero padded to make up for the fact that the square root may not be known to precision n.Flint2fmpz_poly_sqrt b a If a is a perfect square, sets b to the square root of a with positive leading coefficient and returns 1. Otherwise returns 0.Flint2_fmpz_poly_sqrt res poly len If  (poly, len) is a perfect square, sets (res, len / 2 + 1) to the square root of poly with positive leading coefficient and returns 1. Otherwise returns 0.Flint2fmpz_poly_sqrt_divconquer b a If a is a perfect square, sets b to the square root of a with positive leading coefficient and returns 1. Otherwise returns 0.Flint2_fmpz_poly_sqrt_divconquer res poly len exact If exact is 1 and  (poly, len) is a perfect square, sets (res, len / 2 + 1) to the square root of poly with positive leading coefficient and returns 1. Otherwise returns 0.If exact is 0, allows a remainder after the square root, which is not computed.This function first uses various tests to detect nonsquares quickly. Then, it computes the square root iteratively from top to bottom.Flint2fmpz_poly_sqrt_KS b a .Heuristic square root. If the return value is -1, the function failed, otherwise it succeeded and the following applies.If a is a perfect square, sets b to the square root of a with positive leading coefficient and returns 1. Otherwise returns 0.Flint2_fmpz_poly_sqrt_KS res poly len .Heuristic square root. If the return value is -1, the function failed, otherwise it succeeded and the following applies.If  (poly, len) is a perfect square, sets (res, len / 2 + 1) to the square root of poly with positive leading coefficient and returns 1. Otherwise returns 0.This function first uses various tests to detect nonsquares quickly. Then, it computes the square root iteratively from top to bottom.Flint2fmpz_poly_sqrt_classical b a If a is a perfect square, sets b to the square root of a with positive leading coefficient and returns 1. Otherwise returns 0.Flint2_fmpz_poly_sqrt_classical res poly len exact If exact is 1 and  (poly, len) is a perfect square, sets (res, len / 2 + 1) to the square root of poly with positive leading coefficient and returns 1. Otherwise returns 0.If exact is 0, allows a remainder after the square root, which is not computed.This function first uses various tests to detect nonsquares quickly. Then, it computes the square root iteratively from top to bottom, requiring O(n^2) coefficient operations.Flint2fmpz_poly_sqrtrem_divconquer b r a If a can be written as b^2 + r with \deg(r) < \deg(a)/2 , return 1 and set b and r" appropriately. Otherwise return 0.Flint2_fmpz_poly_sqrtrem_divconquer res r poly len temp  Returns 1 if  (poly, len) can be written in the form A^2 + R where deg(R) < deg(poly), otherwise returns 0. If it can be so written,  (res, m - 1) is set to A and (res, m) is set to R , where m = \deg(\mathtt{poly})/2 + 1.For efficiency reasons, r must have room for len coefficients, and may alias poly. Temporary space of len coefficients is required.Flint2fmpz_poly_sqrtrem_classical b r a If a can be written as b^2 + r with \deg(r) < \deg(a)/2 , return 1 and set b and r" appropriately. Otherwise return 0.Flint2_fmpz_poly_sqrtrem_classical res r poly len  Returns 1 if  (poly, len) can be written in the form A^2 + R where deg(R) < deg(poly), otherwise returns 0. If it can be so written,  (res, m - 1) is set to A and (res, m) is set to R , where m = \deg(\mathtt{poly})/2 + 1.For efficiency reasons, r must have room for len coefficients, and may alias poly.Flint2fmpz_poly_revert_series Qinv Q n Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n. It is required that Q_0 = 0 and  Q_1 = \pm 1.This implementation defaults to the fast version of Lagrange interpolation.Flint2_fmpz_poly_revert_series Qinv Q Qlen n Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n). The arguments may not be aliased, and Qlen) must be at least 2. It is required that Q_0 = 0 and  Q_1 = \pm 1.This implementation defaults to the fast version of Lagrange interpolation.Flint2fmpz_poly_revert_series_newton Qinv Q n Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n. It is required that Q_0 = 0 and  Q_1 = \pm 1.*This implementation uses Newton iteration  [BrentKung1978].Flint2_fmpz_poly_revert_series_newton Qinv Q Qlen n Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n). The arguments may not be aliased, and Qlen) must be at least 2. It is required that Q_0 = 0 and  Q_1 = \pm 1.*This implementation uses Newton iteration  [BrentKung1978].Flint2%fmpz_poly_revert_series_lagrange_fast Qinv Q n Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n. It is required that Q_0 = 0 and  Q_1 = \pm 1.This implementation uses a reduced-complexity implementation of the Lagrange inversion formula.Flint2&_fmpz_poly_revert_series_lagrange_fast Qinv Q Qlen n Sets Qinv. to the compositional inverse or reversion of  (Q, Qlen)# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n). The arguments may not be aliased, and Qlen) must be at least 2. It is required that Q_0 = 0 and  Q_1 = \pm 1.This implementation uses a reduced-complexity implementation of the Lagrange inversion formula.Flint2 fmpz_poly_revert_series_lagrange Qinv Q n Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n. It is required that Q_0 = 0 and  Q_1 = \pm 1.8This implementation uses the Lagrange inversion formula.Flint2!_fmpz_poly_revert_series_lagrange Qinv Q Qlen n Sets Qinv. to the compositional inverse or reversion of  (Q, Qlen)# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n). The arguments may not be aliased, and Qlen) must be at least 2. It is required that Q_0 = 0 and  Q_1 = \pm 1.8This implementation uses the Lagrange inversion formula.Flint2fmpz_poly_compose_series res poly1 poly2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero.This implementation automatically switches between the Horner scheme and Brent-Kung algorithm 2.1 depending on the size of the inputs.Flint2_fmpz_poly_compose_series res poly1 len1 poly2 len2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero. Assumes that len1, len2, n > 0, that len1, len2 <= n , and that (len1-1) * (len2-1) + 1 <= n , and that res has space for n coefficients. Does not support aliasing between any of the inputs and the output.This implementation automatically switches between the Horner scheme and Brent-Kung algorithm 2.1 depending on the size of the inputs.Flint2#fmpz_poly_compose_series_brent_kung res poly1 poly2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero.2This implementation uses Brent-Kung algorithm 2.1  [BrentKung1978].Flint2$_fmpz_poly_compose_series_brent_kung res poly1 len1 poly2 len2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero. Assumes that len1, len2, n > 0, that len1, len2 <= n , and that (len1-1) * (len2-1) + 1 <= n , and that res has space for n coefficients. Does not support aliasing between any of the inputs and the output.2This implementation uses Brent-Kung algorithm 2.1  [BrentKung1978].Flint2fmpz_poly_compose_series_horner res poly1 poly2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero.+This implementation uses the Horner scheme.Flint2 _fmpz_poly_compose_series_horner res poly1 len1 poly2 len2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero. Assumes that len1, len2, n > 0, that len1, len2 <= n , and that (len1-1) * (len2-1) + 1 <= n , and that res has space for n coefficients. Does not support aliasing between any of the inputs and the output.+This implementation uses the Horner scheme.Flint2fmpz_poly_taylor_shift g f c $Performs the Taylor shift composing f by x+c.Flint2_fmpz_poly_taylor_shift poly c n $Performs the Taylor shift composing poly by x+c in-place.Flint2 fmpz_poly_taylor_shift_multi_mod g f c $Performs the Taylor shift composing f by x+c. Uses a multimodular algorithm, distributing the computation across flint_get_num_threads threads.Flint2!_fmpz_poly_taylor_shift_multi_mod poly c n $Performs the Taylor shift composing poly by x+c in-place. Uses a multimodular algorithm, distributing the computation across flint_get_num_threads threads.Flint2!fmpz_poly_taylor_shift_divconquer g f c $Performs the Taylor shift composing f by x+c. Uses the divide-and-conquer polynomial composition algorithm.Flint2"_fmpz_poly_taylor_shift_divconquer poly c n $Performs the Taylor shift composing poly by x+c in-place. Uses the divide-and-conquer polynomial composition algorithm.Flint2fmpz_poly_taylor_shift_horner g f c $Performs the Taylor shift composing f by x+c.Flint2_fmpz_poly_taylor_shift_horner poly c n $Performs the Taylor shift composing poly by x+c4 in-place. Uses an efficient version Horner's rule.Flint2fmpz_poly_deflation input %Returns the largest integer by which input2 can be deflated. As special cases, returns 0 if input! is the zero polynomial and 1 if input is a constant polynomial.Flint2fmpz_poly_deflate result input  deflation Sets result to the deflated polynomial  p(x^{1/n}) where p is given by input and n is given by  deflation . Requires n > 0.Flint2fmpz_poly_inflate result input  inflation Sets result to the inflated polynomial p(x^n) where p is given by input and n is given by  inflation.Flint2fmpz_poly_compose res poly1 poly2 Sets res to the composition of poly1 and poly2:. To be precise about the order of composition, denoting res, poly1, and poly2 by f, g, and h, respectively, sets f(t) = g(h(t)).Flint2_fmpz_poly_compose res poly1 len1 poly2 len2 Sets res to the composition of  (poly1, len1) and  (poly2, len2). Assumes that res has space for (len1-1)*(len2-1) + 1 coefficients. Assumes that poly1 and poly2 are non-zero polynomials. Does not support aliasing between any of the inputs and the output.Flint2fmpz_poly_compose_divconquer res poly1 poly2 Sets res to the composition of poly1 and poly2:. To be precise about the order of composition, denoting res, poly1, and poly2 by f, g, and h, respectively, sets f(t) = g(h(t)).Flint2_fmpz_poly_compose_divconquer res poly1 len1 poly2 len2 Computes the composition of  (poly1, len1) and  (poly2, len2) using a divide and conquer approach and places the result into res , assuming res can hold the output of length (len1 - 1) * (len2 - 1) + 1.Assumes len1, len2 > 0$. Does not support aliasing between res and any of  (poly1, len1) and  (poly2, len2).Flint2fmpz_poly_compose_horner res poly1 poly2 Sets res to the composition of poly1 and poly2 . To be more precise, denoting res, poly1, and poly2 by f, g, and h, sets f(t) = g(h(t)).)This implementation uses Horner's method.Flint2_fmpz_poly_compose_horner res poly1 len1 poly2 len2 Sets res to the composition of  (poly1, len1) and  (poly2, len2). Assumes that res has space for (len1-1)*(len2-1) + 1 coefficients. Assumes that poly1 and poly2 are non-zero polynomials. Does not support aliasing between any of the inputs and the output.Flint2fmpz_poly_interpolate_fmpz_vec poly xs ys n Sets poly; to the unique interpolating polynomial of degree at most n - 1 satisfying  f(x_i) = y_i for every pair x_i, y_u in xs and ys9, assuming that this polynomial has integer coefficients.If an interpolating polynomial with integer coefficients does not exist, a  FLINT_INEXACT exception is thrown.It is assumed that the x values are distinct.Flint2_fmpz_poly_newton_to_monomial poly roots n  Converts  (poly, n) in-place from its coefficients given in the Newton basis for the roots r_0, r_1, \ldots, r_{n-2} to the standard monomial basis. In other words, this evaluates c_0 + c_1(x-r_0) + c_2(x-r_0)(x-r_1) + \ldots + c_{n-1}(x-r_0)(x-r_1)\cdots(x-r_{n-2}) where c_i are the input coefficients for poly. Uses Horner's rule.Flint2_fmpz_poly_monomial_to_newton poly roots n  Converts  (poly, n) in-place from its coefficients given in the standard monomial basis to the Newton basis for the roots r_0, r_1, \ldots, r_{n-2}7. In other words, this determines output coefficients c_i such that c_0 + c_1(x-r_0) + c_2(x-r_0)(x-r_1) + \ldots + c_{n-1}(x-r_0)(x-r_1)\cdots(x-r_{n-2}) is equal to the input polynomial. Uses repeated polynomial division.Flint2"_fmpz_poly_evaluate_horner_d_2exp2 exp poly n d dexp  Evaluate poly at d*2^dexp1. Return the result as a double and an exponent exp combination. No attempt is made to do this efficiently or in a numerically stable way. It is currently only used in Flint for quick and dirty evaluations of polynomials with all coefficients positive.Flint2 fmpz_poly_evaluate_horner_d_2exp exp poly d  Evaluate poly at the double d1. Return the result as a double and an exponent exp combination. No attempt is made to do this efficiently or in a numerically stable way. It is currently only used in Flint for quick and dirty evaluations of polynomials with all coefficients positive.Flint2!_fmpz_poly_evaluate_horner_d_2exp exp poly n d  Evaluate  (poly, n) at the double d1. Return the result as a double and an exponent exp combination. No attempt is made to do this efficiently or in a numerically stable way. It is currently only used in Flint for quick and dirty evaluations of polynomials with all coefficients positive.Flint2fmpz_poly_evaluate_horner_d poly d  Evaluate poly at the double d. No attempt is made to do this efficiently or in a numerically stable way. It is currently only used in Flint for quick and dirty evaluations of polynomials with all coefficients positive.Flint2_fmpz_poly_evaluate_horner_d poly n d  Evaluate  (poly, n) at the double d. No attempt is made to do this efficiently or in a numerically stable way. It is currently only used in Flint for quick and dirty evaluations of polynomials with all coefficients positive.Flint2fmpz_poly_evaluate_fmpz_vec res f a n  Evaluates f at the n values given in the vector f, writing the results to res.Flint2fmpz_poly_evaluate_mod poly a n  Evaluates poly at the value a modulo n and returns the result.Flint2_fmpz_poly_evaluate_mod poly len a n ninv  Evaluates  (poly, len) at the value a modulo n, and returns the result. The last argument ninv, must be set to the precomputed inverse of n+, which can be obtained using the function n_preinvert_limb.Flint2fmpz_poly_evaluate_fmpq res f a Evaluates the polynomial f at the rational a , and sets res to the result.Flint2_fmpz_poly_evaluate_fmpq rnum rden f len anum aden Evaluates the polynomial (f, len) at the rational  (anum, aden) and sets  (rnum, rden) to the result in lowest terms.Aliasing between  (rnum, rden) and  (anum, aden) or any of the coefficients of f is not supported.Flint2fmpz_poly_evaluate_horner_fmpq res f a Evaluates the polynomial f at the rational a using Horner's rule, and sets res to the result.Flint2_fmpz_poly_evaluate_horner_fmpq rnum rden f len anum aden Evaluates the polynomial (f, len) at the rational  (anum, aden) using Horner's rule, and sets  (rnum, rden) to the result in lowest terms.Aliasing between  (rnum, rden) and  (anum, aden) or any of the coefficients of f is not supported.Flint2"fmpz_poly_evaluate_divconquer_fmpq res f a Evaluates the polynomial f at the rational a0 using a divide and conquer approach, and sets res to the result.Flint2#_fmpz_poly_evaluate_divconquer_fmpq rnum rden f len anum aden Evaluates the polynomial (f, len) at the rational  (anum, aden)0 using a divide and conquer approach, and sets  (rnum, rden) to the result in lowest terms. Assumes that the length of the polynomial is at least one.Aliasing between  (rnum, rden) and  (anum, aden) or any of the coefficients of f is not supported.Flint2fmpz_poly_evaluate_fmpz res f a Evaluates the polynomial f at the integer a and sets res to the result.As expected, aliasing between res and a is supported. However, res* may not be aliased with a coefficient of f.Flint2_fmpz_poly_evaluate_fmpz res f len a Evaluates the polynomial (f, len) at the integer a and sets res" to the result. Aliasing between res and a or any of the coefficients of f is not supported.Flint2fmpz_poly_evaluate_horner_fmpz res f a Evaluates the polynomial f at the integer a using Horner's rule, and sets res to the result.As expected, aliasing between res and a is supported. However, res+ may not be aliased with a coefficient of f.Flint2_fmpz_poly_evaluate_horner_fmpz res f len a Evaluates the polynomial (f, len) at the integer a using Horner's rule, and sets res! to the result. Aliasing between res and a or any of the coefficients of f is not supported.Flint2"fmpz_poly_evaluate_divconquer_fmpz res poly a Evaluates the polynomial poly at the integer a& using a divide and conquer approach.Aliasing between res and a is supported, however, res may not be part of poly.Flint2#_fmpz_poly_evaluate_divconquer_fmpz res poly len a Evaluates the polynomial  (poly, len) at the integer a using a divide and conquer approach. Assumes that the length of the polynomial is at least one. Allows zero padding. Does not allow aliasing between res and x.Flint2fmpz_poly_nth_derivative res poly n Sets res to the nth derivative of poly.Flint2_fmpz_poly_nth_derivative rpoly poly n len Sets (rpoly, len - n) to the nth derivative of  (poly, len) . Also handles the cases where len <= n" correctly. Supports aliasing of rpoly and poly.Flint2fmpz_poly_derivative res poly Sets res to the derivative of poly.Flint2_fmpz_poly_derivative rpoly poly len Sets (rpoly, len - 1) to the derivative of  (poly, len) . Also handles the cases where len is 0 or 1" correctly. Supports aliasing of rpoly and poly.Flint2fmpz_poly_pseudo_rem R d A B .Pseudo-division, only returning the remainder.Flint2_fmpz_poly_pseudo_rem R d A lenA B lenB inv .Pseudo-division, only returning the remainder.Note: fmpz.h has to be included before  fmpz_poly.h in order for  fmpz_poly.h to declare this function.Flint2fmpz_poly_pseudo_div Q d A B -Pseudo-division, only returning the quotient.Flint2_fmpz_poly_pseudo_div Q d A lenA B lenB inv -Pseudo-division, only returning the quotient.Note: fmpz.h has to be included before  fmpz_poly.h in order for  fmpz_poly.h to declare this function.Flint2fmpz_poly_pseudo_divrem Q R d A B  Computes Q, R, and d such that \ell^d A = B Q + R.Flint2fmpz_poly_pseudo_rem_cohen R A B This is a variant of fmpz_poly_pseudo_rem which computes polynomials Q and R such that \ell^d A = B Q + R, but only returns R. However, the value of d is fixed at >\max{\{0, \operatorname{len}(A) - \operatorname{len}(B) + 1\}}.This function is faster when the remainder is not well behaved, i.e. where it is not expected to be close to zero. Note that this function is not asymptotically fast. It is efficient only for short polynomials, e.g. when \operatorname{len}(B) < 32.This function uses the algorithm described in Algorithm 3.1.2 of  [Coh1996].Flint2_fmpz_poly_pseudo_rem_cohen R A lenA B lenB  Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Assumes that R can fit \operatorname{len}(A)% coefficients. Supports aliasing of  (R, lenA) and  (A, lenA). But other than this, no aliasing of the inputs and outputs is supported.Flint2fmpz_poly_pseudo_divrem_cohen Q R A B This is a variant of fmpz_poly_pseudo_divrem which computes polynomials Q and R such that \ell^d A = B Q + R. However, the value of d is fixed at >\max{\{0, \operatorname{len}(A) - \operatorname{len}(B) + 1\}}.This function is faster when the remainder is not well behaved, i.e. where it is not expected to be close to zero. Note that this function is not asymptotically fast. It is efficient only for short polynomials, e.g. when \operatorname{len}(B) < 32.Flint2_fmpz_poly_pseudo_divrem_cohen Q R A lenA B lenB  Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Assumes that Q can fit 1\operatorname{len}(A) - \operatorname{len}(B) + 1 coefficients, and that R can fit \operatorname{len}(A)% coefficients. Supports aliasing of  (R, lenA) and  (A, lenA). But other than this, no aliasing of the inputs and outputs is supported.Flint2"fmpz_poly_pseudo_divrem_divconquer Q R d A B  Computes Q, R, and d such that \ell^d A = B Q + R , where R$ has length less than the length of B and \ell is the leading coefficient of B. An exception is raised if B is zero.Flint2#_fmpz_poly_pseudo_divrem_divconquer Q R d A lenA B lenB inv  Computes (Q, lenA - lenB + 1),  (R, lenA) such that \ell^d A = B Q + R, only setting the bottom \operatorname{len}(B) - 1 coefficients of R= to their correct values. The remaining top coefficients of  (R, lenA) may be arbitrary.Assumes 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA)7. No aliasing of input and output operands is allowed.>An optional precomputed inverse of the leading coefficient of B from fmpz_preinvn_init can be supplied. Otherwise inv should be NULL.Note: fmpz.h has to be included before  fmpz_poly.h in order for  fmpz_poly.h to declare this function.Flint2 fmpz_poly_pseudo_divrem_basecase Q R d A B If \ell is the leading coefficient of B, then computes Q, R such that \ell^d A = Q B + R6. This function is used for simulating division over  \mathbb{Q}.Flint2!_fmpz_poly_pseudo_divrem_basecase Q R d A lenA B lenB inv If \ell is the leading coefficient of B, then computes Q, R such that \ell^d A = Q B + R6. This function is used for simulating division over  \mathbb{Q}. Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Assumes that Q can fit 1\operatorname{len}(A) - \operatorname{len}(B) + 1 coefficients, and that R can fit \operatorname{len}(A)% coefficients. Supports aliasing of  (R, lenA) and  (A, lenA). But other than this, no aliasing of the inputs and outputs is supported.>An optional precomputed inverse of the leading coefficient of B from fmpz_preinvn_init can be supplied. Otherwise inv should be NULL.Note: fmpz.h has to be included before  fmpz_poly.h in order for  fmpz_poly.h to declare this function.Flint2fmpz_poly_div_series Q A B n "Performs power series division in \mathbb{Z}[[x]] / (x^n)*. The function considers the polynomials A and B as power series of length n> starting with the constant terms. The function assumes that B has constant term \pm 1 and n \geq 1.Flint2fmpz_poly_div_series_divconquer Q A B n Flint2fmpz_poly_div_series_basecase Q A B n Flint2_fmpz_poly_div_series Q A Alen B Blen n Divides  (A, Alen) by  (B, Blen) as power series over  \mathbb{Z} , assuming B has constant term \pm 1 and n \geq 1. Aliasing is not supported.Flint2 _fmpz_poly_div_series_divconquer Q A Alen B Blen n Flint2_fmpz_poly_div_series_basecase Q A Alen B Blen n Flint2fmpz_poly_inv_series Qinv Q n Computes the first n& terms of the inverse power series of Q , assuming Q has constant term \pm 1 and n \geq 1.Flint2_fmpz_poly_inv_series Qinv Q Qlen n Computes the first n' terms of the inverse power series of  (Q, lenQ). Assumes that n \geq 1 and that Q has constant term \pm 1. Does not support aliasing.Flint2fmpz_poly_inv_series_newton Qinv Q n Computes the first n& terms of the inverse power series of Q# using Newton iteration, assuming Q has constant term \pm 1 and n \geq 1.Flint2_fmpz_poly_inv_series_newton Qinv Q Qlen n Computes the first n' terms of the inverse power series of  (Q, lenQ) using Newton iteration. Assumes that n \geq 1 and that Q has constant term \pm 1. Does not support aliasing.Flint2fmpz_poly_inv_series_basecase Qinv Q n Computes the first n& terms of the inverse power series of Q$ using a recurrence, assuming that Q has constant term \pm 1 and n \geq 1.Flint2_fmpz_poly_inv_series_basecase Qinv Q Qlen n Computes the first n' terms of the inverse power series of  (Q, lenQ) using a recurrence. Assumes that n \geq 1 and that Q has constant term \pm 1. Does not support aliasing.Flint2fmpz_poly_divhigh_smodp res f g p n  Compute the n highest coefficients of f divided by g), assuming the division is exact modulo p0. The computed coefficients are reduced modulo p3 using the symmetric remainder system. We require f to be as output by fmpz_poly_mulhigh_n given polynomials g and a polynomial of length n( as inputs. The leading coefficient of g must be coprime to p0. This is a bespoke function used by factoring.Flint2fmpz_poly_divlow_smodp res f g p n  Compute the n lowest coefficients of f divided by g), assuming the division is exact modulo p0. The computed coefficients are reduced modulo p3 using the symmetric remainder system. We require f to be at least n in length. The function can handle trailing zeroes, but the low nonzero coefficient of g must be coprime to p/. This is a bespoke function used by factoring.Flint2fmpz_poly_remove res poly1 poly2 Set res to poly1! divided by the highest power of poly24 that divides it and return the power. The divisor poly2 must not be zero or \pm 1#, otherwise an exception is raised.Flint2fmpz_poly_divides Q A B  Returns 1 if B divides A exactly and sets Q' to the quotient, otherwise returns 0.This function is currently unoptimised and provided for convenience only.Flint2_fmpz_poly_divides Q A lenA B lenB  Returns 1 if  (B, lenB) divides  (A, lenA) exactly and sets Q' to the quotient, otherwise returns 0.It is assumed that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0 and that Q has space for 1\operatorname{len}(A) - \operatorname{len}(B) + 1 coefficients. Aliasing of Q, with either of the inputs is not permitted.This function is currently unoptimised and provided for convenience only.Flint2fmpz_poly_rem_powers_precomp R A B B_inv Set R to the remainder of A divide B given precomputed powers mod B provided by fmpz_poly_powers_precompute.Flint2_fmpz_poly_rem_powers_precomp A m B n powers Set A to the remainder of A divide B given precomputed powers mod B provided by _fmpz_poly_powers_precompute. No aliasing is allowed.Flint2fmpz_poly_powers_clear pinv Clean up resources used by precomputed powers which have been computed by fmpz_poly_powers_precompute.Flint2_fmpz_poly_powers_clear powers len Clean up resources used by precomputed powers which have been computed by _fmpz_poly_powers_precompute.Flint2fmpz_poly_powers_precompute pinv poly  Computes  2*len - 1 powers of x modulo the polynomial B of the given length. This is used as a kind of precomputed inverse in the remainder routine below.Flint2_fmpz_poly_powers_precompute B len  Computes  2*len - 1 powers of x modulo the polynomial B of the given length. This is used as a kind of precomputed inverse in the remainder routine below.Flint2fmpz_poly_divrem_preinv Q R A B B_inv Given a precomputed inverse B_inv of the polynomial B, compute the quotient Q of A by B and the remainder R. Aliasing of B and B_inv is not permitted.Flint2_fmpz_poly_divrem_preinv Q A len1 B B_inv len2 Given a precomputed inverse B_inv of the polynomial B of length len2, compute the quotient Q of A by B#. The remainder is then placed in A. We assume the length len1 of A is at least len2. The polynomial Q must have space for len1 - len2 + 15 coefficients. No aliasing of operands is permitted.Flint2fmpz_poly_div_preinv Q A B B_inv Given a precomputed inverse B_inv of the polynomial B, compute the quotient Q of A by B. Aliasing of B and B_inv is not permitted.Flint2_fmpz_poly_div_preinv Q A len1 B B_inv len2 Given a precomputed inverse B_inv of the polynomial B of length len2, compute the quotient Q of A by B. We assume the length len1 of A is at least len2. The polynomial Q must have space for len1 - len2 + 14 coefficients. No aliasing of operands is permitted.Flint2fmpz_poly_preinvert B_inv B Given a monic polynomial B , compute a precomputed inverse B_inv< for use in the functions below. An exception is raised if B is zero.Flint2_fmpz_poly_preinvert B_inv B n Given a monic polynomial B of length n!, compute a precomputed inverse B_inv of length n1 for use in the functions below. No aliasing of B and B_inv is permitted. We assume n is not zero.Flint2fmpz_poly_div_root Q A c Computes the quotient  (Q, len-1) of (A, len) upon division by x - c.Flint2_fmpz_poly_div_root Q A len c Computes the quotient  (Q, len-1) of (A, len) upon division by x - c.Supports aliasing of Q and A:, but the result is undefined in case of partial overlap.Flint2 fmpz_poly_rem R A B Computes the remainder R of A upon division by B.Notationally, computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B!. If the leading coefficient of B is \pm 1> or the division is exact, this is the same as division over  \mathbb{Q}. An exception is raised if B is zero.Flint2_fmpz_poly_rem R A lenA B lenB Computes the remainder  (R, lenA) of  (A, lenA) upon division by  (B, lenB).Notationally, computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B!. If the leading coefficient of B is \pm 1 or the division is exact, this is the same thing as division over  \mathbb{Q}. Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA)8. Aliasing of input and output operands is not allowed.Flint2fmpz_poly_rem_basecase R A B Computes the remainder R of A upon division by B.Notationally, computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B!. If the leading coefficient of B is \pm 1> or the division is exact, this is the same as division over  \mathbb{Q}. An exception is raised if B is zero.Flint2_fmpz_poly_rem_basecase R A lenA B lenB Computes the remainder  (R, lenA) of  (A, lenA) upon division by  (B, lenB).Notationally, computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B!. If the leading coefficient of B is \pm 1 or the division is exact, this is the same thing as division over  \mathbb{Q}. Assumes that 0\operatorname{len}(A), \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA). R and A may be aliased, but apart from this no aliasing of input and output operands is allowed.Flint2 fmpz_poly_div Q A B Computes the quotient Q of A divided by B.Notationally, computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B!. If the leading coefficient of B is \pm 1> or the division is exact, this is the same as division over Q. An exception is raised if B is zero.Flint2_fmpz_poly_div Q A lenA B lenB exact Computes the quotient (Q, lenA - lenB + 1) of  (A, lenA) divided by  (B, lenB).Notationally, computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B!. If the leading coefficient of B is \pm 1> or the division is exact, this is the same as division over  \mathbb{Q}.Assumes 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA)8. Aliasing of input and output operands is not allowed. If the flag exact is 1, the function stops if an inexact division is encountered, upon which the function will return 0?. If no inexact division is encountered, the function returns 1. Note that this does not guarantee the remainder of the polynomial division is zero, merely that its length is less than that of B. This feature is useful for series division and for divisibility testing (upon testing the remainder).For ordinary use set the flag exact to 0. In this case, no checks or early aborts occur and the function always returns 1.Flint2fmpz_poly_div_divconquer Q A B Computes the quotient Q of A divided by B.Notationally, computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B.If the leading coefficient of B is \pm 1> or the division is exact, this is the same as division over  \mathbb{Q}. An exception is raised if B is zero.Flint2_fmpz_poly_div_divconquer Q A lenA B lenB exact Computes the quotient (Q, lenA - lenB + 1) of  (A, lenA) upon division by  (B, lenB). Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Does not support aliasing. If the flag exact is 1, the function stops if an inexact division is encountered, upon which the function will return 0?. If no inexact division is encountered, the function returns 1. Note that this does not guarantee the remainder of the polynomial division is zero, merely that its length is less than that of B. This feature is useful for series division and for divisibility testing (upon testing the remainder).For ordinary use set the flag exact to 0. In this case, no checks or early aborts occur and the function always returns 1.Flint2#_fmpz_poly_div_divconquer_recursive Q temp A B lenB exact .Recursive short division in the balanced case.Computes the quotient  (Q, lenB) of (A, 2 lenB - 1) upon division by  (B, lenB) . Requires \operatorname{len}(B) > 0. Needs a temporary array temp of length 2 \operatorname{len}(B) - 1!. Does not support any aliasing.For further details, see  [Mul2000]. If the flag exact is 1, the function stops if an inexact division is encountered, upon which the function will return 0?. If no inexact division is encountered, the function returns 1. Note that this does not guarantee the remainder of the polynomial division is zero, merely that its length is less than that of B. This feature is useful for series division and for divisibility testing (upon testing the remainder).For ordinary use set the flag exact to 0. In this case, no checks or early aborts occur and the function always returns 1.Flint2)_fmpz_poly_divremlow_divconquer_recursive Q BQ A B lenB exact Divide and conquer division of (A, 2 lenB - 1) by  (B, lenB), computing only the bottom \operatorname{len}(B) - 1 coefficients of B Q.Assumes \operatorname{len}(B) > 0 . Requires B Q to have length at least 2 \operatorname{len}(B) - 1, although only the bottom \operatorname{len}(B) - 1 coefficients will carry meaningful output. Does not support any aliasing. Allows zero-padding in A, but not in B. If the flag exact is 1, the function stops if an inexact division is encountered, upon which the function will return 0?. If no inexact division is encountered, the function returns 1. Note that this does not guarantee the remainder of the polynomial division is zero, merely that its length is less than that of B. This feature is useful for series division and for divisibility testing (upon testing the remainder).For ordinary use set the flag exact to 0. In this case, no checks or early aborts occur and the function always returns 1.Flint2fmpz_poly_div_basecase Q A B Computes the quotient Q of A divided by Q.Notationally, computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B.If the leading coefficient of B is \pm 1> or the division is exact, this is the same as division over  \mathbb{Q}. An exception is raised if B is zero.Flint2_fmpz_poly_div_basecase Q R A lenA B lenB exact Computes the quotient (Q, lenA - lenB + 1) of  (A, lenA) divided by  (B, lenB).Notationally, computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B.If the leading coefficient of B is \pm 1> or the division is exact, this is the same as division over  \mathbb{Q}.Assumes 0\operatorname{len}(A), \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA). Requires a temporary array R* of size at least the (actual) length of A. For convenience, R may be NULL. R and A may be aliased, but apart from this no aliasing of input and output operands is allowed. If the flag exact is 1, the function stops if an inexact division is encountered, upon which the function will return 0?. If no inexact division is encountered, the function returns 1. Note that this does not guarantee the remainder of the polynomial division is zero, merely that its length is less than that of B. This feature is useful for series division and for divisibility testing (upon testing the remainder).For ordinary use set the flag exact to 0. In this case, no checks or early aborts occur and the function always returns 1.Flint2fmpz_poly_divrem Q R A B  Computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B . If the leading coefficient of B is \pm 1? or the division is exact, this is the same as division over  \mathbb{Q}. An exception is raised if B is zero.Flint2_fmpz_poly_divrem Q R A lenA B lenB exact  Computes (Q, lenA - lenB + 1),  (R, lenA) such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B!. If the leading coefficient of B is \pm 1 or the division is exact, this is the same thing as division over  \mathbb{Q}.Assumes 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA)7. No aliasing of input and output operands is allowed. If the flag exact is 1, the function stops if an inexact division is encountered, upon which the function will return 0?. If no inexact division is encountered, the function returns 1. Note that this does not guarantee the remainder of the polynomial division is zero, merely that its length is less than that of B. This feature is useful for series division and for divisibility testing (upon testing the remainder).For ordinary use set the flag exact to 0. In this case, no checks or early aborts occur and the function always returns 1.Flint2fmpz_poly_divrem_divconquer Q R A B  Computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B . If the leading coefficient of B is \pm 1? or the division is exact, this is the same as division over  \mathbb{Q}. An exception is raised if B is zero.Flint2_fmpz_poly_divrem_divconquer Q R A lenA B lenB exact  Computes (Q, lenA - lenB + 1),  (R, lenA) such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B!. If the leading coefficient of B is \pm 1> or the division is exact, this is the same as division over  \mathbb{Q}.Assumes 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA)7. No aliasing of input and output operands is allowed. If the flag exact is 1, the function stops if an inexact division is encountered, upon which the function will return 0?. If no inexact division is encountered, the function returns 1. Note that this does not guarantee the remainder of the polynomial division is zero, merely that its length is less than that of B. This feature is useful for series division and for divisibility testing (upon testing the remainder).For ordinary use set the flag exact to 0. In this case, no checks or early aborts occur and the function always returns 1.Flint2&_fmpz_poly_divrem_divconquer_recursive Q BQ W A B lenB exact  Computes  (Q, lenB), (BQ, 2 lenB - 1) such that BQ = B \times Q and  A = B Q + R where each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B. We assume that 3\operatorname{len}(A) = 2 \operatorname{len}(B) - 1!. If the leading coefficient of B is \pm 1> or the division is exact, this is the same as division over  \mathbb{Q}.Assumes \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA). Requires a temporary array (W, 2 lenB - 1)7. No aliasing of input and output operands is allowed.'This function does not read the bottom \operatorname{len}(B) - 1 coefficients from A, which means that they might not even need to exist in allocated memory. If the flag exact is 1, the function stops if an inexact division is encountered, upon which the function will return 0?. If no inexact division is encountered, the function returns 1. Note that this does not guarantee the remainder of the polynomial division is zero, merely that its length is less than that of B. This feature is useful for series division and for divisibility testing (upon testing the remainder).For ordinary use set the flag exact to 0. In this case, no checks or early aborts occur and the function always returns 1.Flint2fmpz_poly_divrem_basecase Q R A B  Computes Q, R such that  A = B Q + R and each coefficient of R beyond \operatorname{len}(B) - 1/ is reduced modulo the leading coefficient of B . If the leading coefficient of B is \pm 1 or the division is exact, this is the same thing as division over  \mathbb{Q}. An exception is raised if B is zero.Flint2_fmpz_poly_divrem_basecase Q R A lenA B lenB exact  Computes (Q, lenA - lenB + 1),  (R, lenA) such that  A = B Q + R and each coefficient of R beyond lenB/ is reduced modulo the leading coefficient of B . If the leading coefficient of B is \pm 1 or the division is exact, this is the same thing as division over  \mathbb{Q}. Assumes that 0\operatorname{len}(A), \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA). R and A may be aliased, but apart from this no aliasing of input and output operands is allowed. If the flag exact is 1, the function stops if an inexact division is encountered, upon which the function will return 0?. If no inexact division is encountered, the function returns 1. Note that this does not guarantee the remainder of the polynomial division is zero, merely that its length is less than that of B. This feature is useful for series division and for divisibility testing (upon testing the remainder).For ordinary use set the flag exact to 0. In this case, no checks or early aborts occur and the function always returns 1.Flint2fmpz_poly_is_squarefree poly Returns whether the polynomial poly is square-free. A non-zero polynomial is defined to be square-free if it has no non-unit square factors. We also define the zero polynomial to be square-free.Returns 1 if the length of poly is at most 2. Returns whether the discriminant is zero for quadratic polynomials. Otherwise, returns whether the greatest common divisor of poly and its derivative has length 1.Flint2_fmpz_poly_is_squarefree poly len Returns whether the polynomial  (poly, len) is square-free.Flint2fmpz_poly_primitive_part res poly Sets res to poly divided by the content of poly, and normalises the result to have non-negative leading coefficient. If poly is zero, sets res to zero.Flint2_fmpz_poly_primitive_part res poly len Sets  (res, len) to  (poly, len) divided by the content of  (poly, len), and normalises the result to have non-negative leading coefficient. Assumes that  (poly, len)# is non-zero. Supports aliasing of res and poly.Flint2fmpz_poly_content res poly Sets res to the non-negative content of poly. The content of the zero polynomial is defined to be zero. Supports aliasing, that is, res. is allowed to be one of the coefficients of poly.Flint2_fmpz_poly_content res poly len Sets res to the non-negative content of  (poly, len). Aliasing between res and the coefficients of poly is not supported.Flint2fmpz_poly_discriminant res poly Set res to the discriminant of poly. We normalise the discriminant so that (operatorname{disc}(f) = (-1)^{(n(n-1)/2)} operatorname{res}(f, f')/operatorname{lc}(f)), thus (operatorname{disc}(f) = operatorname{lc}(f)^{(2n - 2)} prod_{i < j} (r_i - r_j)^2), where \operatorname{lc}(f) is the leading coefficient of f, n is the degree of f and r_i are the roots of f.Flint2_fmpz_poly_discriminant res poly len Set res to the discriminant of  (poly, len) . Assumes len > 1.Flint2fmpz_poly_resultant res poly1 poly2 Computes the resultant of poly1 and poly2.For two non-zero polynomials f(x) = a_m x^m + \dotsb + a_0 and g(x) = b_n x^n + \dotsb + b_0 of degrees m and n!, the resultant is defined to be` 5a_m^n b_n^m \prod_{(x, y) : f(x) = g(y) = 0} (x - y).For convenience, we define the resultant to be equal to zero if either of the two polynomials is zero.Flint2_fmpz_poly_resultant res poly1 len1 poly2 len2 Sets res to the resultant of  (poly1, len1) and  (poly2, len2), assuming that len1 >= len2 > 0.Flint2fmpz_poly_resultant_euclidean res poly1 poly2 Computes the resultant of poly1 and poly2.For two non-zero polynomials f(x) = a_m x^m + \dotsb + a_0 and g(x) = b_n x^n + \dotsb + b_0 of degrees m and n!, the resultant is defined to be` 5a_m^n b_n^m \prod_{(x, y) : f(x) = g(y) = 0} (x - y).For convenience, we define the resultant to be equal to zero if either of the two polynomials is zero.This function uses the algorithm described in Algorithm 3.3.7 of  [Coh1996].Flint2_fmpz_poly_resultant_euclidean res poly1 len1 poly2 len2 Sets res to the resultant of  (poly1, len1) and  (poly2, len2), assuming that len1 >= len2 > 0.Flint2fmpz_poly_resultant_modular_div res poly1 poly2 div nbits Computes the resultant of poly1 and poly2 divided by div using a slight modification of the above function. It is assumed that the resultant is exactly divisible by div and the result res has at most nbits7 bits. This bypasses the computation of general bounds.Flint2fmpz_poly_resultant_modular res poly1 poly2 Computes the resultant of poly1 and poly2.For two non-zero polynomials f(x) = a_m x^m + \dotsb + a_0 and g(x) = b_n x^n + \dotsb + b_0 of degrees m and n!, the resultant is defined to be` 5a_m^n b_n^m \prod_{(x, y) : f(x) = g(y) = 0} (x - y).For convenience, we define the resultant to be equal to zero if either of the two polynomials is zero.6This function uses the modular algorithm described in  [Col1971].Flint2_fmpz_poly_resultant_modular res poly1 len1 poly2 len2 Sets res to the resultant of  (poly1, len1) and  (poly2, len2), assuming that len1 >= len2 > 0.Flint2 fmpz_poly_lcm res poly1 poly2 Sets res5 to the least common multiple of the two polynomials poly1 and poly26, normalised to have non-negative leading coefficient./If either of the two polynomials is zero, sets res to zero.This ensures that the equality` )f g = \gcd(f, g) \operatorname{lcm}(f, g)holds up to sign.Flint2_fmpz_poly_lcm res poly1 len1 poly2 len2 Sets (res, len1 + len2 - 1)6 to the least common multiple of the two polynomials  (poly1, len1) and  (poly2, len2)7, normalised to have non-negative leading coefficient. Assumes that len1 >= len2 > 0.Does not support aliasing.Flint2fmpz_poly_xgcd r s t f g Set r to the resultant of f and g. If the resultant is zero, the function then returns immediately, otherwise s and t are found such that  s*f + t*g = r.The function assumes that f and g are primitive (have Gaussian content equal to 1). The result is undefined otherwise.Flint2_fmpz_poly_xgcd r s t f len1 g len2 Set r to the resultant of  (f, len1) and  (g, len2). If the resultant is zero, the function returns immediately. Otherwise it finds polynomials s and t such that  s*f + t*g = r. The length of s will be no greater than len2 and the length of t will be no greater than len1% (both are zero padded if necessary).The function assumes that f and g are primitive (have Gaussian content equal to 1). The result is undefined otherwise.It is assumed that len1 >= len2 > 02. No aliasing of inputs and outputs is permitted.Flint2fmpz_poly_xgcd_modular r s t f g Set r to the resultant of f and g. If the resultant is zero, the function then returns immediately, otherwise s and t are found such that  s*f + t*g = r.The function assumes that f and g are primitive (have Gaussian content equal to 1). The result is undefined otherwise. Uses the multimodular algorithm.Flint2_fmpz_poly_xgcd_modular r s t f len1 g len2 Set r to the resultant of  (f, len1) and  (g, len2). If the resultant is zero, the function returns immediately. Otherwise it finds polynomials s and t such that  s*f + t*g = r. The length of s will be no greater than len2 and the length of t will be no greater than len1% (both are zero padded if necessary).It is assumed that len1 >= len2 > 02. No aliasing of inputs and outputs is permitted.The function assumes that f and g are primitive (have Gaussian content equal to 1). The result is undefined otherwise.Uses a multimodular algorithm. The resultant is first computed and extended GCDs modulo various primes p are computed and combined using CRT. When the CRT stabilises the resulting polynomials are simply reduced modulo further primes until a proven bound is reached.Flint2 fmpz_poly_gcd res poly1 poly2 %Computes the greatest common divisor res of poly1 and poly27, normalised to have non-negative leading coefficient.Flint2_fmpz_poly_gcd res poly1 len1 poly2 len2 %Computes the greatest common divisor res of  (poly1, len1) and  (poly2, len2) , assuming len1 >= len2 > 0. The result is normalised to have positive leading coefficient. Assumes that res has space for len2! coefficients. Aliasing between res, poly1 and poly2 is not supported.Flint2fmpz_poly_gcd_modular res poly1 poly2 %Computes the greatest common divisor res of poly1 and poly27, normalised to have non-negative leading coefficient.This function uses the modular GCD algorithm. The basic strategy is to remove the content of the polynomials, reduce them modulo sufficiently many primes and do CRT reconstruction until some bound is reached (or we can prove with trial division that we have the GCD).Flint2_fmpz_poly_gcd_modular res poly1 len1 poly2 len2 %Computes the greatest common divisor  (res, len2) of  (poly1, len1) and  (poly2, len2) , assuming len1 >= len2 > 0. The result is normalised to have positive leading coefficient. Aliasing between res, poly1 and poly2 is not supported.Flint2fmpz_poly_gcd_heuristic res poly1 poly2 %Computes the greatest common divisor res of poly1 and poly27, normalised to have non-negative leading coefficient.The function may not always succeed in finding the GCD. If it fails, the function returns 0, otherwise it returns 1.This function uses the heuristic GCD algorithm (GCDHEU). The basic strategy is to remove the content of the polynomials, pack them using Kronecker segmentation (given a bound on the size of the coefficients of the GCD) and take the integer GCD. Unpack the result and test divisibility.Flint2_fmpz_poly_gcd_heuristic res poly1 len1 poly2 len2 %Computes the greatest common divisor  (res, len2) of  (poly1, len1) and  (poly2, len2) , assuming len1 >= len2 > 0. The result is normalised to have positive leading coefficient. Aliasing between res, poly1 and poly2 is not supported. The function may not always succeed in finding the GCD. If it fails, the function returns 0, otherwise it returns 1.Flint2fmpz_poly_gcd_subresultant res poly1 poly2 %Computes the greatest common divisor res of poly1 and poly27, normalised to have non-negative leading coefficient.This function uses the subresultant algorithm as described in Algorithm 3.3.1 of  [Coh1996].Flint2_fmpz_poly_gcd_subresultant res poly1 len1 poly2 len2 %Computes the greatest common divisor  (res, len2) of  (poly1, len1) and  (poly2, len2) , assuming len1 >= len2 > 0. The result is normalised to have positive leading coefficient. Aliasing between res, poly1 and poly2 is supported.Flint2 _fmpz_poly_2norm_normalised_bits poly len Returns an upper bound on the number of bits of the normalised Euclidean norm of  (poly, len), i.e. the number of bits of the Euclidean norm divided by the absolute value of the leading coefficient. The returned value will be no more than 1 bit too large.=This is used in the computation of the Landau-Mignotte bound.It is assumed that len > 0. The result only makes sense if the leading coefficient is nonzero.Flint2fmpz_poly_2norm res poly Sets res to the Euclidean norm of poly, that is, the integer square root of the sum of the squares of the coefficients of poly.Flint2_fmpz_poly_2norm res poly len Sets res to the Euclidean norm of  (poly, len), that is, the integer square root of the sum of the squares of the coefficients of poly.Flint2fmpz_poly_height height poly Computes the height of poly, defined as the largest of the absolute values of the coefficients of poly. Equivalently, this gives the infinity norm of the coefficients. If poly is zero, the height is 0.Flint2fmpz_poly_max_bits poly $Computes the maximum number of bits b: required to store the absolute value of coefficients of poly. If all the coefficients of poly are non-negative, b is returned, otherwise -b is returned.Flint2fmpz_poly_max_limbs poly Returns the maximum number of limbs required to store the absolute value of coefficients of poly. If poly is zero, returns 0.Flint2fmpz_poly_shift_right res poly n Sets res to poly shifted right by n coefficients. If n4 is equal to or greater than the current length of poly, res is set to the zero polynomial.Flint2_fmpz_poly_shift_right res poly len n Sets (res, len - n) to  (poly, len) shifted right by n coefficients. Assumes that len and n are positive, that len > n , and that res fits len - n% elements. Supports aliasing between res and poly0, although in this case the top coefficients of poly are not set to zero.Flint2fmpz_poly_shift_left res poly n Sets res to poly shifted left by n) coeffs. Zero coefficients are inserted.Flint2_fmpz_poly_shift_left res poly len n Sets (res, len + n) to  (poly, len) shifted left by n coefficients.9Inserts zero coefficients at the lower end. Assumes that len and n are positive, and that res fits len + n& elements. Supports aliasing between res and poly.Flint2fmpz_poly_pow_trunc res poly e n Notationally raises poly to the power e", truncates the result to length n and writes the result in res. This is computed much more efficiently than simply powering the polynomial and truncating. Thus, if n = 0) the result is zero. Otherwise, whenever e = 06 the result will be the constant polynomial equal to 1.This function can be used to raise power series to a power in an efficient way.Flint2_fmpz_poly_pow_trunc res poly e n Sets (res, n) to  (poly, n) raised to the power e and truncated to length n. Assumes that e, n > 0. Allows zero-padding of  (poly, n)7. Does not support aliasing of any inputs and outputs.Flint2 fmpz_poly_pow res poly e  Computes  res = poly^e. If e. is zero, returns one, so that in particular 0^0 = 1.Flint2_fmpz_poly_pow res poly len e Sets  res = poly^e, assuming that  e, len > 0 and that res has space for e*(len - 1) + 1) coefficients. Does not support aliasing.Flint2_fmpz_poly_pow_small res poly len e Sets  res = poly^e whenever 0 \leq e \leq 4. Assumes that len > 0 and that res! is an array of length at least e*(len - 1) + 1. Does not support aliasing.Flint2fmpz_poly_pow_binexp res poly e  Computes  res = poly^e0 using the binary exponentiation algorithm. If e- is zero, returns one, so that in particular 0^0 = 1.Flint2_fmpz_poly_pow_binexp res poly len e Sets  res = poly^e using left-to-right binary exponentiation as described on p. 461 of  [Knu1997]. Assumes that len > 0, e > 1. Assumes that res! is an array of length at least e*(len - 1) + 1. Does not support aliasing.Flint2fmpz_poly_pow_addchains res poly e  Computes  res = poly^e! using addition chains whenever 0 \leq e \leq 148.If e > 148!, raises an exception and aborts.Flint2_fmpz_poly_pow_addchains res poly len a n Given a star chain  1 = a_0 < a_1 < \dotsb < a_n = e computes  res = poly^e."A star chain is an addition chain 1 = a_0 < a_1 < \dotsb < a_n such that, for all i > 0, a_i = a_{i-1} + a_j for some j < i. Assumes that e > 2, or equivalently n > 1, and len > 0. Does not support aliasing.Flint2fmpz_poly_pow_binomial res poly e  Computes  res = poly^e when poly is of length 2, using binomial expansion.If the length of poly is not 2!, raises an exception and aborts.Flint2_fmpz_poly_pow_binomial res poly e  Computes  res = poly^e5 when poly is of length 2, using binomial expansion.Assumes e > 0. Does not support aliasing.Flint2fmpz_poly_pow_multinomial res poly e  Computes  res = poly^e using a generalisation of binomial expansion called the J.C.P. Miller pure recurrence [1], [2]. If e. is zero, returns one, so that in particular 0^0 = 1.The formal statement of the recurrence is as follows. Write the input polynomial as %P(x) = p_0 + p_1 x + \dotsb + p_m x^m with  p_0 \neq 0 and let` 8P(x)^n = a(n, 0) + a(n, 1) x + \dotsb + a(n, mn) x^{mn}.Then a(n, 0) = p_0^n and, for all 1 \leq k \leq mn,` a(n, k) = (k p_0)^{-1} \sum_{i = 1}^m p_i \bigl( (n + 1) i - k \bigr) a(n, k-i). 1D. Knuth, The Art of Computer Programming Vol. 2, Seminumerical Algorithms, Third Edition (Reading, Massachusetts: Addison-Wesley, 1997)2D. Zeilberger, The J.C.P. Miller Recurrence for Exponentiating a Polynomial, and its q-Analog, Journal of Difference Equations and Applications, 1995, Vol. 1, pp. 57--60Flint2_fmpz_poly_pow_multinomial res poly len e  Computes  res = poly^e:. This uses the J.C.P. Miller pure recurrence as follows:If \ell4 is the index of the lowest non-zero coefficient in poly4, as a first step this method zeros out the lowest e \ell coefficients of res. The recurrence above is then used to compute the remaining coefficients.Assumes len > 0, e > 0. Does not support aliasing.Flint2fmpz_poly_sqrlow res poly n Sets res to the lowest n coefficients of the square of poly.Flint2_fmpz_poly_sqrlow res poly len n Sets (res, n) to the lowest n coefficients of the square of  (poly, len).Assumes len1 >= len2 > 0 and 0 < n <= 2 * len - 1. Allows for zero-padding in the input. Does not support aliasing between the input and the output.Flint2fmpz_poly_sqrlow_classical res poly n Sets res to the first n coefficients of the square of poly.Flint2_fmpz_poly_sqrlow_classical res poly len n Sets (res, n) to the first n coefficients of the square of  (poly, len). Assumes that 0 < n <= 2 * len - 1.Flint2fmpz_poly_sqrlow_karatsuba_n res poly n Sets res to the square of poly# and truncates to the given length.Flint2_fmpz_poly_sqrlow_karatsuba_n res poly n Sets (res, n) to the square of  (poly, n) truncated to length n/, which is assumed to be positive. Allows for poly to be zero-padded.Flint2fmpz_poly_sqrlow_KS res poly n Sets res to the lowest n coefficients of the square of poly.Flint2_fmpz_poly_sqrlow_KS res poly len n Sets (res, n) to the lowest n coefficients of the square of  (poly, len). Assumes that len is positive, but does allow for the polynomial to be zero-padded. The polynomial may be zero, too. Assumes n) is positive. Supports aliasing between res and poly.Flint2 fmpz_poly_sqr rop op Sets rop! to the square of the polynomial op.Flint2_fmpz_poly_sqr rop op len Sets (rop, 2*len - 1) to the square of  (op, len), assuming that len > 0.Supports zero-padding in  (op, len). Does not support aliasing.Flint2fmpz_poly_sqr_classical rop op Sets rop! to the square of the polynomial op+ using the classical or schoolbook method.Flint2_fmpz_poly_sqr_classical rop op len Sets (rop, 2*len - 1) to the square of  (op, len), assuming that len > 0.Supports zero-padding in  (op, len). Does not support aliasing.Flint2fmpz_poly_sqr_karatsuba rop op Sets rop! to the square of the polynomial op/ using the Karatsuba multiplication algorithm.Flint2_fmpz_poly_sqr_karatsuba rop op len Sets (rop, 2*len - 1) to the square of  (op, len), assuming that len > 0.Supports zero-padding in  (op, len). Does not support aliasing.Flint2fmpz_poly_sqr_KS rop op Sets rop! to the square of the polynomial op using Kronecker segmentation.Flint2_fmpz_poly_sqr_KS rop op len Sets (rop, 2*len - 1) to the square of  (op, len), assuming that len > 0.Supports zero-padding in  (op, len). Does not support aliasing.Flint2fmpz_poly_mul_SS_precache res poly1 pre Set res to the product of poly1/ by the polynomial whose FFT was precached by fmpz_poly_mul_SS_precache_init (and stored in pre).+There are no restrictions on the length of poly1( other than those given in the call to fmpz_poly_mul_SS_precache_init.Flint2fmpz_poly_mullow_SS_precache res poly1 pre n Set res to the product of poly1/ by the polynomial whose FFT was precached by fmpz_poly_mul_SS_precache_init2 (and stored in pre). The result is truncated to n coefficients (and normalised).+There are no restrictions on the length of poly1( other than those given in the call to fmpz_poly_mul_SS_precache_init.Flint2_fmpz_poly_mullow_SS_precache output input1 len1 pre trunc  Write into output the first trunc! coefficients of the polynomial (input1, len1)/ by the polynomial whose FFT was precached by fmpz_poly_mul_SS_precache_init and stored in pre.For performance reasons it is recommended that all polynomials be truncated to at most trunc coefficients if possible.Flint2fmpz_poly_mul_precache_clear pre Clear the space allocated by fmpz_poly_mul_SS_precache_init.Flint2fmpz_poly_mul_SS_precache_init pre len1 bits1 poly2 Precompute the FFT of poly2' to enable repeated multiplication of poly2- by polynomials whose length does not exceed len1; and whose number of bits per coefficient does not exceed bits1. The value bits18 may be negative, i.e. it may be the result of calling fmpz_poly_max_bits5. The function only considers the absolute value of bits1.Suppose len2 is the length of poly2 and len = len1 + len2 - 1 is the maximum output length of a polynomial multiplication using pre. Then internally len" is rounded up to a power of two, 2^n say. The truncated FFT algorithm is used to smooth performance but note that it can only do this in the range (2^{n-1}, 2^n]4. Therefore, it may be more efficient to recompute pre4 for cases where the output length will fall below  2^{n-1} + 1. Otherwise the implementation will zero pad them up to that length.Note that the Schoenhage-Strassen algorithm is only efficient for polynomials with relatively large coefficients relative to the length of the polynomials.Also note that there are no restrictions on the polynomials. In particular the polynomial whose FFT is being precached does not have to be either longer or shorter than the polynomials it is to be multiplied by.Flint2_fmpz_poly_mulhigh res poly1 len1 poly2 len2 start Sets all but the low n coefficients of res6 to the corresponding coefficients of the product of poly1 of length len1 and poly2 of length len2, the remaining coefficients being arbitrary. It is assumed that len1 >= len2 > 0 and that 0 < n < len1 + len2 - 1&. Aliasing of inputs is not permitted.Flint2fmpz_poly_mulhigh_n res poly1 poly2 n Sets the high n coefficients of res to the high n! coefficients of the product of poly1 and poly2%, assuming the latter are precisely n coefficients in length, zero padded if necessary. The remaining n - 1 coefficients may be arbitrary.Flint2fmpz_poly_mullow res poly1 poly2 n Sets res to the lowest n coefficients of the product of poly1 and poly2.Flint2_fmpz_poly_mullow res poly1 len1 poly2 len2 n Sets (res, n) to the lowest n! coefficients of the product of  (poly1, len1) and  (poly2, len2).Assumes len1 >= len2 > 0 and 0 < n <= len1 + len2 - 1. Allows for zero-padding in the inputs. Does not support aliasing between the inputs and the output.Flint2 fmpz_poly_mul res poly1 poly2 Sets res to the product of poly1 and poly27. Chooses an optimal algorithm from the choices above.Flint2_fmpz_poly_mul res poly1 len1 poly2 len2 Sets (res, len1 + len2 - 1) to the product of  (poly1, len1) and  (poly2, len2) . Assumes len1 >= len2 > 0. Allows zero-padding of the two input polynomials. Does not support aliasing between the inputs and the output.Flint2fmpz_poly_mullow_SS res poly1 poly2 n Sets res to the lowest n coefficients of the product of poly1 and poly2.Flint2_fmpz_poly_mullow_SS output input1 length1 input2 length2 n Sets (res, n) to the lowest n! coefficients of the product of  (poly1, len1) and  (poly2, len2). Assumes that len1 and len2 are positive, but does allow for the polynomials to be zero-padded. We must have len1 > 1 and len2 > 1 . Assumes n( is positive. Supports aliasing between res, poly1 and poly2.Flint2fmpz_poly_mul_SS res poly1 poly2 Sets res to the product of poly1 and poly2). Uses the Schnhage-Strassen algorithm.Flint2_fmpz_poly_mul_SS output input1 length1 input2 length2 Sets (output, length1 + length2 - 1) to the product of (input1, length1) and (input2, length2). We must have len1 > 1 and len2 > 1. Allows zero-padding of the two input polynomials. Supports aliasing of inputs and outputs.Flint2fmpz_poly_mullow_KS res poly1 poly2 n Sets res to the lowest n coefficients of the product of poly1 and poly2.Flint2_fmpz_poly_mullow_KS res poly1 len1 poly2 len2 n Sets (res, n) to the lowest n! coefficients of the product of  (poly1, len1) and  (poly2, len2). Assumes that len1 and len2 are positive, but does allow for the polynomials to be zero-padded. The polynomials may be zero, too. Assumes n( is positive. Supports aliasing between res, poly1 and poly2.Flint2fmpz_poly_mul_KS res poly1 poly2 Sets res to the product of poly1 and poly2.Flint2_fmpz_poly_mul_KS res poly1 len1 poly2 len2 Sets (res, len1 + len2 - 1) to the product of  (poly1, len1) and  (poly2, len2).Places no assumptions on len1 and len2. Allows zero-padding of the two input polynomials. Supports aliasing of inputs and outputs.Flint2fmpz_poly_mulhigh_karatsuba_n res poly1 poly2 len Sets the first len - 1 coefficients of the result to zero and the remaining coefficients to the corresponding coefficients of the product of poly1 and poly2 . Assumes poly1 and poly2" are at most of the given length.Flint2_fmpz_poly_mulhigh_karatsuba_n res poly1 poly2 len Sets res to the product of poly1 and poly2: and truncates at the top to the given length. The first len - 13 coefficients are set to zero. It is assumed that poly1 and poly2 are precisely the given length, possibly zero padded. Assumes len is not zero.Flint2fmpz_poly_mullow_karatsuba_n res poly1 poly2 n Sets res to the product of poly1 and poly2$ and truncates to the given length.Flint2_fmpz_poly_mullow_karatsuba_n res poly1 poly2 n Sets res to the product of poly1 and poly28 and truncates to the given length. It is assumed that poly1 and poly2 are precisely the given length, possibly zero padded. Assumes n is not zero.Flint2fmpz_poly_mul_karatsuba res poly1 poly2 Sets res to the product of poly1 and poly2.Flint2_fmpz_poly_mul_karatsuba res poly1 len1 poly2 len2 Sets (res, len1 + len2 - 1) to the product of  (poly1, len1) and  (poly2, len2) . Assumes len1 >= len2 > 0. Allows zero-padding of the two input polynomials. No aliasing of inputs with outputs is allowed.Flint2fmpz_poly_mulmid_classical res poly1 poly2 Sets res to the middle len(poly1) - len(poly2) + 1 coefficients of  poly1 * poly2#, i.e. the coefficient from degree len2 - 1 to len1 - 1 inclusive. Assumes that  len1 >= len2.Flint2_fmpz_poly_mulmid_classical res poly1 len1 poly2 len2 Sets res to the middle len1 - len2 + 1! coefficients of the product of  (poly1, len1) and  (poly2, len2)%, i.e. the coefficients from degree len2 - 1 to len1 - 1 inclusive. Assumes that len1 >= len2 > 0.Flint2fmpz_poly_mulhigh_classical res poly1 poly2 start Sets the first start coefficients of res to zero and the remainder to the corresponding coefficients of the product of poly1 and poly2.Flint2_fmpz_poly_mulhigh_classical res poly1 len1 poly2 len2 start Sets the first start coefficients of res to zero and the remainder to the corresponding coefficients of (poly1, len1) * (poly2, len2).Assumes start <= len1 + len2 - 1. Assumes neither len1 nor len2 is zero.Flint2fmpz_poly_mullow_classical res poly1 poly2 n Sets res to the first n coefficients of  poly1 * poly2.Flint2_fmpz_poly_mullow_classical res poly1 len1 poly2 len2 n Sets (res, n) to the first n coefficients of  (poly1, len1) multiplied by  (poly2, len2).Assumes 0 < n <= len1 + len2 - 1. Assumes neither len1 nor len2 is zero.Flint2fmpz_poly_mul_classical res poly1 poly2 Sets res to the product of poly1 and poly25, computed using the classical or schoolbook method.Flint2_fmpz_poly_mul_classical res poly1 len1 poly2 len2 Sets (res, len1 + len2 - 1) to the product of  (poly1, len1) and  (poly2, len2).Assumes len1 and len2 are positive. Allows zero-padding of the two input polynomials. No aliasing of inputs with outputs is allowed.Flint2fmpz_poly_bit_unpack_unsigned poly f bit_size Unpacks the polynomial with unsigned coefficients packed into fields of size bit_size as represented by the integer f. It is required that f is nonnegative.Flint2fmpz_poly_bit_unpack poly f bit_size Unpacks the polynomial with signed coefficients packed into fields of size bit_size as represented by the integer f.Flint2fmpz_poly_bit_pack f poly bit_size Packs poly into bitfields of size bit_size, writing the result to f. The sign of f9 will be the same as that of the leading coefficient of poly.Flint2_fmpz_poly_bit_unpack_unsigned poly len arr bit_size Unpacks the polynomial of given length from the array as packed into fields of the given bit_size/. The coefficients are assumed to be unsigned.Flint2_fmpz_poly_bit_unpack poly len arr bit_size negate Unpacks the polynomial of given length from the array as packed into fields of the given bit_size(, finally negating the coefficients if negate is set to -1. Returns borrow, which is nonzero if a leading term with coefficient \pm1 should be added at position len of poly.Flint2_fmpz_poly_bit_pack arr poly len bit_size negate Packs the coefficients of poly into bitfields of the given bit_size/, negating the coefficients before packing if negate is set to -1.Flint2_fmpz_poly_scale_2exp pol len k Scale  (pol, len) to p(2^k X) in-place and divide by the 2-content (so that the gcd of coefficients is odd). If k. is negative the polynomial is multiplied by 2^{kd}.Flint2_fmpz_poly_remove_content_2exp pol len Remove the 2-content of pol and return the number k3 that is the maximal non-negative integer so that 2^k divides all coefficients of the polynomial. For the zero polynomial, 0 is returned.Flint2fmpz_poly_scalar_smod_fmpz poly1 poly2 p Sets poly1 to poly22, symmetrically reducing each coefficient modulo p > 0?, that is, choosing the unique representative in the interval  (-p/2, p/2].Flint2fmpz_poly_scalar_mod_fmpz poly1 poly2 p Sets poly1 to poly2#, reducing each coefficient modulo p > 0.Flint2fmpz_poly_scalar_divexact_ui poly1 poly2 x Sets poly1 to poly2 divided by the ulong x;, assuming the coefficient is exact for every coefficient.Flint2fmpz_poly_scalar_divexact_si poly1 poly2 x Sets poly1 to poly2 divided by the slong x;, assuming the coefficient is exact for every coefficient.Flint2fmpz_poly_scalar_divexact_fmpz poly1 poly2 x Sets poly1 to poly2 divided by the fmpz_t x8, assuming the division is exact for every coefficient.Flint2fmpz_poly_scalar_tdiv_2exp poly1 poly2 x Sets poly1 to poly2 divided by 2^x , rounding coefficients toward 0.Flint2fmpz_poly_scalar_tdiv_ui poly1 poly2 x Sets poly1 to poly2 divided by the ulong x , rounding coefficients toward 0.Flint2fmpz_poly_scalar_tdiv_si poly1 poly2 x Sets poly1 to poly2 divided by the slong x , rounding coefficients toward 0.Flint2fmpz_poly_scalar_tdiv_fmpz poly1 poly2 x Sets poly1 to poly2 divided by the fmpz_t x , rounding coefficients toward 0.Flint2fmpz_poly_scalar_fdiv_2exp poly1 poly2 x Sets poly1 to poly2 divided by 2^x%, rounding coefficients down toward - \infty.Flint2fmpz_poly_scalar_fdiv_ui poly1 poly2 x Sets poly1 to poly2 divided by the ulong x%, rounding coefficients down toward - \infty.Flint2fmpz_poly_scalar_fdiv_si poly1 poly2 x Sets poly1 to poly2 divided by the slong x%, rounding coefficients down toward - \infty.Flint2fmpz_poly_scalar_fdiv_fmpz poly1 poly2 x Sets poly1 to poly2 divided by the fmpz_t x%, rounding coefficients down toward - \infty.Flint2fmpz_poly_scalar_submul_fmpz poly1 poly2 x Sets poly1 to poly1 - x * poly2.Flint2fmpz_poly_scalar_addmul_fmpz poly1 poly2 x Sets poly1 to poly1 + x * poly2.Flint2fmpz_poly_scalar_addmul_ui poly1 poly2 x Flint2fmpz_poly_scalar_addmul_si poly1 poly2 x Flint2fmpz_poly_scalar_mul_2exp poly1 poly2 exp Sets poly1 to poly2 times 2^exp.Flint2fmpz_poly_scalar_mul_ui poly1 poly2 x Sets poly1 to poly2 times the ulong x.Flint2fmpz_poly_scalar_mul_si poly1 poly2 x Sets poly1 to poly2 times the signed slong x.Flint2fmpz_poly_scalar_mul_fmpz poly1 poly2 x Sets poly1 to poly2 times x.Flint2fmpz_poly_scalar_abs res poly Sets poly1 to the polynomial whose coefficients are the absolute value of those of poly2.Flint2 fmpz_poly_neg res poly Sets res to -poly.Flint2fmpz_poly_sub_series res poly1 poly2 n Notionally truncate poly1 and poly2 to length n and then set res to the sum.Flint2 fmpz_poly_sub res poly1 poly2 Sets res to poly1 minus poly2.Flint2_fmpz_poly_sub res poly1 len1 poly2 len2 Sets res to  (poly1, len1) minus  (poly2, len2). It is assumed that res< has sufficient space for the longer of the two polynomials.Flint2fmpz_poly_add_series res poly1 poly2 n Notionally truncate poly1 and poly2 to length n and then set res to the sum.Flint2 fmpz_poly_add res poly1 poly2 Sets res to the sum of poly1 and poly2.Flint2_fmpz_poly_add res poly1 len1 poly2 len2 Sets res to the sum of  (poly1, len1) and  (poly2, len2). It is assumed that res= has sufficient space for the longer of the two polynomials.Flint2fmpz_poly_is_gen poly Returns 1! if the polynomial is the degree 1 polynomial x, and 0 otherwise.Flint2fmpz_poly_is_unit poly Returns 1. if the polynomial is the constant polynomial \pm 1, and 0 otherwise.Flint2fmpz_poly_is_one poly Returns 1 if the polynomial is one and 0 otherwise.Flint2fmpz_poly_equal_trunc poly1 poly2 n Return 1 if poly1 and poly2", notionally truncated to length n are equal, otherwise return 0.Flint2fmpz_poly_equal poly1 poly2 Returns 1 if poly1 is equal to poly2, otherwise returns 00. The polynomials are assumed to be normalised.Flint2fmpz_poly_set_coeff_ui poly n x Sets coefficient n of poly to the ulong value x1. Coefficient numbering starts from zero and if n" is beyond the current length of poly then the polynomial is extended and zero coefficients inserted if necessary.Flint2fmpz_poly_set_coeff_si poly n x Sets coefficient n of poly to the slong value x1. Coefficient numbering starts from zero and if n" is beyond the current length of poly then the polynomial is extended and zero coefficients inserted if necessary.Flint2fmpz_poly_set_coeff_fmpz poly n x Sets coefficient n of poly to the fmpz value x1. Coefficient numbering starts from zero and if n" is beyond the current length of poly then the polynomial is extended and zero coefficients inserted if necessary.Flint2fmpz_poly_get_coeff_ui poly n Returns coefficient n of poly as a ulong<. The result is undefined if the value does not fit into a ulong-. Coefficient numbering is from zero and if n is set to a value beyond the end of the polynomial, zero is returned.Flint2fmpz_poly_get_coeff_si poly n Returns coefficient n of poly as a slong<. The result is undefined if the value does not fit into a slong-. Coefficient numbering is from zero and if n is set to a value beyond the end of the polynomial, zero is returned.Flint2fmpz_poly_get_coeff_fmpz x poly n Sets x to the n-th coefficient of poly-. Coefficient numbering is from zero and if n is set to a value beyond the end of the polynomial, zero is returned.Flint2fmpz_poly_randtest_irreducible pol state len bits Sets p; to a random irreducible polynomial, whose length is up to len and where each coefficient has up to the given number of bits. There are two algorithms:  irreducible1 generates an irreducible polynomial modulo a random prime number and lifts it to the integers;  irreducible2 generates a random integer polynomial, factors it, and returns a random factor. The default function chooses randomly between these methods.Flint2fmpz_poly_randtest_irreducible2 pol state len bits Flint2fmpz_poly_randtest_irreducible1 pol state len bits Flint2fmpz_poly_randtest_no_real_root p state len bits Sets p to a random polynomial without any real root, whose length is up to len and where each coefficient has up to the given number of bits.Flint2fmpz_poly_randtest_not_zero f state len bits As for fmpz_poly_randtest except that len and bits may not be zero and the polynomial generated is guaranteed not to be the zero polynomial.Flint2fmpz_poly_randtest_unsigned f state len bits Sets f to a random polynomial with up to the given length and where each coefficient has up to the given number of bits.Flint2fmpz_poly_randtest f state len bits Sets f to a random polynomial with up to the given length and where each coefficient has up to the given number of bits. The coefficients are signed randomly.Flint2fmpz_poly_set_trunc res poly n Sets res to a copy of poly, truncated to length n.Flint2fmpz_poly_truncate poly newlen If the current length of poly is greater than newlen, it is truncated to have the given length. Discarded coefficients are not necessarily set to zero.Flint2fmpz_poly_reverse res poly n 'This function considers the polynomial poly to be of length n, notionally truncating and zero padding if required, and reverses the result. Since the function normalises its result res may be of length less than n.Flint2_fmpz_poly_reverse res poly len n Sets (res, n) to the reverse of  (poly, n), where poly is in fact an array of length len. Assumes that  0 < len <= n. Supports aliasing of res and poly=, but the behaviour is undefined in case of partial overlap.Flint2fmpz_poly_swap poly1 poly2 Swaps poly1 and poly2. This is done efficiently without copying data by swapping pointers, etc.Flint2fmpz_poly_zero_coeffs poly i j Sets the coefficients of x^i, \dotsc, x^{j-1} to zero.Flint2 fmpz_poly_one poly Sets poly to the constant polynomial one.Flint2fmpz_poly_zero poly Sets poly to the zero polynomial.Flint2fmpz_poly_get_str_pretty poly x 2Returns a pretty representation of the polynomial poly# using the null-terminated string x as the variable name.Flint2_fmpz_poly_get_str_pretty poly len x 2Returns a pretty representation of the polynomial  (poly, len)# using the null-terminated string x as the variable name.Flint2fmpz_poly_get_str poly Returns the plain FLINT string representation of the polynomial poly.Flint2_fmpz_poly_get_str poly len Returns the plain FLINT string representation of the polynomial  (poly, len).Flint2fmpz_poly_set_str poly str Imports a polynomial from a null-terminated string. If the string str( represents a valid polynomial returns 0, otherwise returns 1.Returns 0 if no error occurred. Otherwise, returns a non-zero value, in which case the resulting value of poly is undefined. If str is not null-terminated, calling this method might result in a segmentation fault.Flint2_fmpz_poly_set_str poly str Sets poly: to the polynomial encoded in the null-terminated string str. Assumes that poly is allocated as a sufficiently large array suitable for the number of coefficients present in str.Returns 0 if no error occurred. Otherwise, returns a non-zero value, in which case the resulting value of poly is undefined. If str is not null-terminated, calling this method might result in a segmentation fault.Flint2fmpz_poly_set_fmpz poly c Sets poly to the integer c.Flint2fmpz_poly_set_ui poly c Sets poly to the unsigned integer c.Flint2fmpz_poly_set_si poly c Sets poly to the signed integer c.Flint2 fmpz_poly_set poly1 poly2 Sets poly1 to equal poly2.Flint2fmpz_poly_degree poly Returns the degree of poly$, which is one less than its length.Flint2fmpz_poly_length poly Returns the length of poly&. The zero polynomial has length zero.Flint2fmpz_poly_attach_shift trunc poly n 0This function sets the uninitialised polynomial trunc to the high coefficients of poly*, i.e. the coefficients not among the low n coefficients of poly. If the latter doesn't have n coefficients trunc/ is set to the zero polynomial. The polynomial trunc> not be cleared or used as the output of any Flint functions.Flint2fmpz_poly_attach_truncate trunc poly n 0This function sets the uninitialised polynomial trunc to the low n coefficients of poly, or to poly if the latter doesn't have n coefficients. The polynomial trunc> not be cleared or used as the output of any Flint functions.Flint2_fmpz_poly_set_length poly newlen Demotes the coefficients of poly beyond newlen and sets the length of poly to newlen.Flint2_fmpz_poly_normalise poly Sets the length of poly so that the top coefficient is non-zero. If all coefficients are zero, the length is set to zero. This function is mainly used internally, as all functions guarantee normalisation.Flint2fmpz_poly_clear poly Clears the given polynomial, releasing any memory used. It must be reinitialised in order to be used again.Flint2fmpz_poly_fit_length poly len If len is greater than the number of coefficients currently allocated, then the polynomial is reallocated to have space for at least len; coefficients. No data is lost when calling this function.3The function efficiently deals with the case where  fit_length is called many times in small increments by at least doubling the number of allocated coefficients when length is larger than the number of coefficients currently allocated.Flint2fmpz_poly_realloc poly alloc 3Reallocates the given polynomial to have space for alloc coefficients. If alloc is zero the polynomial is cleared and then reinitialised. If the current length is greater than alloc. the polynomial is first truncated to length alloc.Flint2fmpz_poly_init2 poly alloc  Initialises poly with space for at least alloc coefficients and sets the length to zero. The allocated coefficients are all set to zero.Flint2fmpz_poly_init poly  Initialises poly? for use, setting its length to zero. A corresponding call to fmpz_poly_clear( must be made after finishing with the  fmpz_poly_t+ to free the memory used by the polynomial.Flint2 newFmpzPolyConstruct a new Flint2 withFmpzPoly poly fExecute f on polyFlint2withNewFmpzPoly poly fExecute f on a new # Safe-Inferred )*14n Safe-Inferred )*1: $ Safe-Inferred )*1;<   Safe-Inferred )*1MfFlint2fmpz_poly_factor  final_fac F A wrapper of the Zassenhaus and van Hoeij factoring algorithms, which takes as input any polynomial F!, and stores a factorization in  final_fac.Flint2_fmpz_poly_factor_quadratic fac f exp Inserts the factorisation of the quadratic (resp. cubic) polynomial f into fac with multiplicity exp.. This function requires that the content of f7 has been removed, and does not update the content of fac&. The factorzation is calculated over  \mathbb{R} or  \mathbb{Q}_2 and then tested over  \mathbb{Z}.Flint2fmpz_poly_factor_zassenhaus  final_fac F A wrapper of the Zassenhaus factoring algorithm, which takes as input any polynomial F , and stores a factorization in  final_fac.The complexity will be exponential in the number of local factors we find for the components of a squarefree factorization of F.Flint2_fmpz_poly_factor_zassenhaus  final_fac exp f cutoff  use_van_hoeij +This is the internal wrapper of Zassenhaus.0It will attempt to find a small prime such that f modulo p has a minimal number of factors. If it cannot find a prime giving less than cutoff& factors it aborts. Then it decides a p-adic precision to lift the factors to, hensel lifts, and finally calls Zassenhaus recombination. Assumes that \operatorname{len}(f) \geq 2. Assumes that f is primitive.)Assumes that the constant coefficient of f is non-zero. Note that this can be easily achieved by taking out factors of the form x^k before calling this routine.If the final flag is set, the function will use the van Hoeij factorisation algorithm with gradual feeding and mod 2^k data truncation to find factors when the number of local factors is large.Flint2)fmpz_poly_factor_zassenhaus_recombination  final_fac  lifted_fac F P exp "Takes as input a factor structure  lifted_fac: containing a squarefree factorization of the polynomial  F \bmod p. The algorithm does a brute force search for irreducible factors of F< over the integers, and each factor is raised to the power exp.=The impact of the algorithm is to augment a factorization of F^exp to the factor structure  final_fac.Flint2fmpz_poly_factor_squarefree fac F Takes as input a polynomial F- and a freshly initialized factor structure fac . Updates fac to contain a factorization of F into (not necessarily irreducible) factors that themselves have no repeated factors. None of the returned factors will have the same exponent. That is we return g_i and unique e_i such thatF = c \prod_{i} g_i^{e_i}where c is the signed content of F and \gcd(g_i, g_i') = 1.Flint2fmpz_poly_factor_print fac Prints the entries of fac to standard output.Flint2fmpz_poly_factor_concat res fac  Concatenates two factorisations.This is equivalent to calling fmpz_poly_factor_insert, repeatedly with the individual factors of fac."Does not support aliasing between res and fac.Flint2fmpz_poly_factor_insert fac p e Adds the primitive polynomial p^e to the factorisation fac. Assumes that \deg(p) \geq 2 and e \neq 0.Flint2fmpz_poly_factor_set res fac Sets res to the same factorisation as fac.Flint2fmpz_poly_factor_clear fac 5Releases all memory occupied by the factor structure.Flint2fmpz_poly_factor_fit_length fac len 9Ensures that the factor structure has space for at least len factors. This functions takes care of the case of repeated calls by always at least doubling the number of factors the structure can hold.Flint2fmpz_poly_factor_realloc fac alloc Reallocates the factor structure to provide space for precisely alloc factors.Flint2fmpz_poly_factor_init2 fac alloc Initialises a new factor structure, providing space for at least alloc factors.Flint2fmpz_poly_factor_init fac #Initialises a new factor structure.% Safe-Inferred )*1M Safe-Inferred )*1qFlint2fmpz_mod_mpoly_deflation shift stride A ctx For each variable v let S_v' be the set of exponents appearing on v. Set shift[v] to \operatorname{min}(S_v) and set  stride[v] to -\operatorname{gcd}(S-\operatorname{min}(S_v)). If A2 is zero, all shifts and strides are set to zero.Flint2fmpz_mod_mpoly_deflate A B shift stride ctx Apply the function e -> (e - shift[v])/stride[v] to each exponent e corresponding to the variable v . If any  stride[v]' is zero, the corresponding numerator  e - shift[v] is assumed to be zero, and the quotient is defined as zero. This allows the function to undo the operation performed by fmpz_mod_mpoly_inflate when possible.Flint2fmpz_mod_mpoly_inflate A B shift stride ctx Apply the function e -> shift[v] + stride[v]*e to each exponent e corresponding to the variable v<. It is assumed that each shift and stride is not negative.Flint2"fmpz_mod_mpoly_univar_discriminant D Ax ctx  Try to set D to the discriminant of Ax.Flint2fmpz_mod_mpoly_univar_resultant R Ax Bx ctx  Try to set R to the resultant of Ax and Bx.Flint2"fmpz_mod_mpoly_univar_set_coeff_ui Ax e c ctx Set the coefficient of X^e in Ax to c.Flint2%fmpz_mod_mpoly_univar_swap_term_coeff c A i ctx Set (resp. swap) c7 to (resp. with) the coefficient of the term of index i of A.Flint2$fmpz_mod_mpoly_univar_get_term_coeff c A i ctx Flint2%fmpz_mod_mpoly_univar_get_term_exp_si A i ctx )Return the exponent of the term of index i of A.Flint2fmpz_mod_mpoly_univar_length A ctx Return the number of terms in A# with respect to the main variable.Flint2$fmpz_mod_mpoly_univar_degree_fits_si A ctx Return 1 if the degree of A, with respect to the main variable fits an slong. Otherwise, return 0.Flint2fmpz_mod_mpoly_from_univar A B var ctx Set A to the normal form of B& by putting in the variable of index var4. This function is undefined if the coefficients of B" depend on the variable of index var.Flint2fmpz_mod_mpoly_to_univar A B var ctx Set A to a univariate form of B' by pulling out the variable of index var. The coefficients of A" will still belong to the content ctx/ but will not depend on the variable of index var.Flint2fmpz_mod_mpoly_univar_swap A B ctx Swap A and B.Flint2fmpz_mod_mpoly_univar_clear A ctx Clear A.Flint2fmpz_mod_mpoly_univar_init A ctx  Initialize A.Flint2fmpz_mod_mpoly_quadratic_root Q A B ctx If Q^2+AQ=B has a solution, set Q to a solution and return 1, otherwise return 0.Flint2fmpz_mod_mpoly_is_square A ctx Return 1 if A' is a perfect square, otherwise return 0.Flint2fmpz_mod_mpoly_sqrt Q A ctx If Q^2=A has a solution, set Q to a solution and return 1, otherwise return 0 and set Q to zero.Flint2fmpz_mod_mpoly_discriminant D A var ctx  Try to set D to the discriminant of A( with respect to the variable of index var.Flint2fmpz_mod_mpoly_resultant R A B var ctx  Try to set R to the resultant of A and B( with respect to the variable of index var.Flint2fmpz_mod_mpoly_gcd_zippel2 G A B ctx  Try to set G to the GCD of A and B using various algorithms.Flint2fmpz_mod_mpoly_gcd_zippel G A B ctx Flint2fmpz_mod_mpoly_gcd_subresultant G A B ctx Flint2fmpz_mod_mpoly_gcd_hensel G A B ctx Flint2fmpz_mod_mpoly_gcd_brown G A B ctx Flint2fmpz_mod_mpoly_gcd_cofactors G Abar Bbar A B ctx Do the operation of fmpz_mod_mpoly_gcd and also compute  Abar = A/G and  Bbar = B/G if successful.Flint2fmpz_mod_mpoly_gcd G A B ctx  Try to set G to the monic GCD of A and B. The GCD of zero and zero is defined to be zero. If the return is 17 the function was successful. Otherwise the return is 0 and G is left untouched.Flint2fmpz_mod_mpoly_content_vars g A vars  vars_length ctx Set g# to the GCD of the coefficients of A/ when viewed as a polynomial in the variables vars . Return 1 for success and 0 for failure. Upon success, g' will be independent of the variables vars.Flint2fmpz_mod_mpoly_term_content M A ctx Set M to the GCD of the terms of A. If A is zero, M will be zero. Otherwise, M) will be a monomial with coefficient one.Flint2fmpz_mod_mpoly_divrem_ideal Q R A B len ctx This function is as per fmpz_mod_mpoly_divrem7 except that it takes an array of divisor polynomials B2 and it returns an array of quotient polynomials Q. The number of divisor (and hence quotient) polynomials, is given by len.Flint2fmpz_mod_mpoly_divrem Q R A B ctx Set Q and R" to the quotient and remainder of A divided by B.Flint2fmpz_mod_mpoly_div Q A B ctx Set Q to the quotient of A by B, discarding the remainder.Flint2fmpz_mod_mpoly_divides Q A B ctx If A is divisible by B, set Q# to the exact quotient and return 1. Otherwise, set Q to zero and return 0.Flint2fmpz_mod_mpoly_pow_ui A B k ctx Set A to B raised to the k-th power. Return 1 for success and 0 for failure.Flint2fmpz_mod_mpoly_pow_fmpz A B k ctx Set A to B raised to the k-th power. Return 1 for success and 0 for failure.Flint2fmpz_mod_mpoly_mul_dense A B C ctx  Try to set A to  B \times C+ using dense arithmetic. If the return is 0, the operation was unsuccessful. Otherwise, it was successful and the return is 1.Flint2fmpz_mod_mpoly_mul_johnson A B C ctx Set A to  B \times C# using Johnson's heap-based method.Flint2fmpz_mod_mpoly_mul A B C ctx Set A to  B \times C.Flint2%fmpz_mod_mpoly_compose_fmpz_mod_mpoly A B C ctxB ctxAC Set A to the evaluation of B where the variables are replaced by the corresponding elements of the array C. Both A and the elements of C have context object ctxAC, while B has context object ctxB. The length of the array C is the number of variables in ctxB . Neither A nor B3 is allowed to alias any other polynomial. Return 1 for success and 0 for failure. The main method attempts to perform the calculation using matrices and chooses heuristically between the  geobucket and horner methods if needed.Flint2/fmpz_mod_mpoly_compose_fmpz_mod_mpoly_geobucket A B C ctxB ctxAC Flint2 fmpz_mod_mpoly_evaluate_one_fmpz A B var val ctx Set A to the evaluation of B where the variable of index var is replaced by val . Return 1 for success and 0 for failure.Flint2 fmpz_mod_mpoly_evaluate_all_fmpz eval A vals ctx Set ev to the evaluation of A where the variables are replaced by the corresponding elements of the array vals.Flint2fmpz_mod_mpoly_derivative A B var ctx Set A to the derivative of B( with respect to the variable of index var.Flint2fmpz_mod_mpoly_make_monic A B ctx Set A to B' divided by the leading coefficient of B. This throws if B6 is zero or the leading coefficient is not invertible.Flint2!fmpz_mod_mpoly_scalar_addmul_fmpz A B C d ctx Sets A to B + C \times d.Flint2fmpz_mod_mpoly_scalar_mul_si A B c ctx Set A to  B \times c.Flint2fmpz_mod_mpoly_scalar_mul_ui A B c ctx Flint2fmpz_mod_mpoly_scalar_mul_fmpz A B c ctx Flint2fmpz_mod_mpoly_neg A B ctx Set A to -B.Flint2fmpz_mod_mpoly_sub A B C ctx Set A to B - C.Flint2fmpz_mod_mpoly_add A B C ctx Set A to B + C.Flint2fmpz_mod_mpoly_sub_si A B c ctx Set A to B - c.Flint2fmpz_mod_mpoly_sub_ui A B c ctx Flint2fmpz_mod_mpoly_sub_fmpz A B c ctx Flint2fmpz_mod_mpoly_add_si A B c ctx Set A to B + c.Flint2fmpz_mod_mpoly_add_ui A B c ctx Flint2fmpz_mod_mpoly_add_fmpz A B c ctx Flint2fmpz_mod_mpoly_randtest_bits A state length exp_bits ctx /Generate a random polynomial with length up to length and exponents whose packed form does not exceed the given bit count.Flint2fmpz_mod_mpoly_randtest_bounds A state length  exp_bounds ctx /Generate a random polynomial with length up to length and exponents in the range [0, exp_bounds[i] - 1]*. The exponents of the variable of index i are generated by calls to n_randint(state, exp_bounds[i]).Flint2fmpz_mod_mpoly_randtest_bound A state length  exp_bound ctx /Generate a random polynomial with length up to length and exponents in the range [0, exp_bound - 1]<. The exponents of each variable are generated by calls to n_randint(state, exp_bound).Flint2!fmpz_mod_mpoly_combine_like_terms A ctx Combine adjacent like terms in A: and delete terms with coefficient zero. If the terms of A were sorted to begin with, the result will be in canonical form. This function runs in linear time in the size of A.Flint2fmpz_mod_mpoly_sort_terms A ctx Sort the terms of A: into the canonical ordering dictated by the ordering in ctx. This function simply reorders the terms: It does not combine like terms, nor does it delete terms with coefficient zero. This function runs in linear time in the size of A.Flint2fmpz_mod_mpoly_push_term_si_ui A c exp ctx Append a term to A with coefficient c and exponent vector exp/. This function runs in constant average time.Flint2fmpz_mod_mpoly_push_term_ui_ui A c exp ctx Flint2 fmpz_mod_mpoly_push_term_fmpz_ui A c exp ctx Flint2 fmpz_mod_mpoly_push_term_si_fmpz A c exp ctx Flint2 fmpz_mod_mpoly_push_term_ui_fmpz A c exp ctx Flint2"fmpz_mod_mpoly_push_term_fmpz_fmpz A c exp ctx Flint2 fmpz_mod_mpoly_get_term_monomial M A i ctx Set M& to the monomial of the term of index i in A. The coefficient of M will be one.Flint2fmpz_mod_mpoly_get_term M A i ctx Set M to the term of index i in A.Flint2fmpz_mod_mpoly_set_term_exp_ui A i exp ctx -Set the exponent vector of the term of index i to exp.Flint2 fmpz_mod_mpoly_set_term_exp_fmpz A i exp ctx Flint2"fmpz_mod_mpoly_get_term_var_exp_si A i var ctx $Return the exponent of the variable var of the term of index i<. This function throws if the exponent does not fit into a ulong (resp. slong).Flint2"fmpz_mod_mpoly_get_term_var_exp_ui A i var ctx Flint2fmpz_mod_mpoly_get_term_exp_si exp A i ctx Set exp- to the exponent vector of the term of index i. The _ui (resp. _si2) version throws if any entry does not fit into a ulong (resp. slong).Flint2fmpz_mod_mpoly_get_term_exp_ui exp A i ctx Flint2 fmpz_mod_mpoly_get_term_exp_fmpz exp A i ctx Flint2fmpz_mod_mpoly_term_exp_fits_ui poly i ctx Return 1= if all entries of the exponent vector of the term of index i fit into an slong (resp. a ulong). Otherwise, return 0.Flint2fmpz_mod_mpoly_term_exp_fits_si poly i ctx Flint2 fmpz_mod_mpoly_set_term_coeff_si A i c ctx )Set the coefficient of the term of index i to c.Flint2 fmpz_mod_mpoly_set_term_coeff_ui A i c ctx Flint2"fmpz_mod_mpoly_set_term_coeff_fmpz A i c ctx Flint2"fmpz_mod_mpoly_get_term_coeff_fmpz c A i ctx Set c) to the coefficient of the term of index i.Flint2fmpz_mod_mpoly_resize A  new_length ctx Set the length of A to  new_length. Terms are either deleted from the end, or new zero terms are appended.Flint2fmpz_mod_mpoly_length A ctx Return the number of terms in A. If the polynomial is in canonical form, this will be the number of nonzero coefficients.Flint2fmpz_mod_mpoly_is_canonical A ctx Return 1 if A) is in canonical form. Otherwise, return 0. To be in canonical form, all of the terms must have nonzero coefficient, and the terms must be sorted from greatest to least.Flint2fmpz_mod_mpoly_cmp A B ctx Return 1 (resp. -1, or 0) if A# is after (resp. before, same as) B in some arbitrary but fixed total ordering of the polynomials. This ordering agrees with the usual ordering of monomials when A and B are both monomials.Flint2 fmpz_mod_mpoly_get_coeff_vars_ui C A vars exps length ctx Set C to the coefficient of A# with respect to the variables in vars( with powers in the corresponding array exps. Both vars and exps point to array of length length. It is assumed that 0 < length \le nvars(A) and that the variables in vars are distinct.Flint2fmpz_mod_mpoly_set_coeff_si_ui A c exp ctx 9Set the coefficient of the monomial with exponent vector exp to c.Flint2fmpz_mod_mpoly_set_coeff_ui_ui A c exp ctx Flint2 fmpz_mod_mpoly_set_coeff_fmpz_ui A c exp ctx Flint2 fmpz_mod_mpoly_set_coeff_si_fmpz A c exp ctx Flint2 fmpz_mod_mpoly_set_coeff_ui_fmpz A c exp ctx Flint2"fmpz_mod_mpoly_set_coeff_fmpz_fmpz A c exp ctx Flint2 fmpz_mod_mpoly_get_coeff_fmpz_ui c A exp ctx Set c9 to the coefficient of the monomial with exponent vector exp.Flint2"fmpz_mod_mpoly_get_coeff_fmpz_fmpz c A exp ctx Flint2&fmpz_mod_mpoly_set_coeff_fmpz_monomial A c M ctx Assuming that M is a monomial, set the coefficient of the corresponding monomial in A to c. This function throws if M is not a monomial.Flint2&fmpz_mod_mpoly_get_coeff_fmpz_monomial c A M ctx Assuming that M is a monomial, set c6 to the coefficient of the corresponding monomial in A. This function throws if M is not a monomial.Flint2fmpz_mod_mpoly_used_vars used A ctx For each variable index i, set used[i]& to nonzero if the variable of index i appears in A and to zero otherwise.Flint2fmpz_mod_mpoly_total_degree_si A ctx Either return or set tdeg to the total degree of A. If A- is zero, the total degree is defined to be -1.Flint2 fmpz_mod_mpoly_total_degree_fmpz tdeg A ctx Flint2#fmpz_mod_mpoly_total_degree_fits_si A ctx Return 1 if the total degree of A fits into an slong, otherwise return 0.Flint2fmpz_mod_mpoly_degree_si A var ctx Either return or set deg to the degree of A( with respect to the variable of index var. If A' is zero, the degree is defined to be -1.Flint2fmpz_mod_mpoly_degree_fmpz deg A var ctx Flint2fmpz_mod_mpoly_degrees_si degs A ctx Set degs to the degrees of A# with respect to each variable. If A" is zero, all degrees are set to -1.Flint2fmpz_mod_mpoly_degrees_fmpz degs A ctx Flint2fmpz_mod_mpoly_degrees_fit_si A ctx Return 1 if the degrees of A, with respect to each variable fit into an slong, otherwise return 0.Flint2fmpz_mod_mpoly_is_one A ctx Return 1 if A is the constant 1, else return 0.Flint2fmpz_mod_mpoly_is_zero A ctx Return 1 if A is the constant 0, else return 0.Flint2fmpz_mod_mpoly_equal_si A c ctx Return 1 if A is equal to the constant c, else return 0.Flint2fmpz_mod_mpoly_equal_ui A c ctx Flint2fmpz_mod_mpoly_equal_fmpz A c ctx Flint2fmpz_mod_mpoly_one A ctx Set A to the constant 1.Flint2fmpz_mod_mpoly_zero A ctx Set A to the constant 0.Flint2fmpz_mod_mpoly_set_si A c ctx Set A to the constant c.Flint2fmpz_mod_mpoly_set_ui A c ctx Flint2fmpz_mod_mpoly_set_fmpz A c ctx Flint2fmpz_mod_mpoly_get_fmpz c A ctx Assuming that A is a constant, set c, to this constant. This function throws if A is not a constant.Flint2fmpz_mod_mpoly_is_fmpz A ctx Return 1 if A is a constant, else return 0.Flint2fmpz_mod_mpoly_swap poly1 poly2 ctx Efficiently swap A and B.Flint2fmpz_mod_mpoly_equal A B ctx Return 1 if A is equal to B, else return 0.Flint2fmpz_mod_mpoly_set A B ctx Set A to B.Flint2fmpz_mod_mpoly_is_gen A var ctx If  var \ge 0 , return 1 if A is equal to the var!-th generator, otherwise return 0. If var < 0 , return 1 if the polynomial is equal to any generator, otherwise return 0.Flint2fmpz_mod_mpoly_gen A var ctx Set A to the variable of index var, where var = 0 corresponds to the variable with the most significance with respect to the ordering.Flint2fmpz_mod_mpoly_set_str_pretty A str x ctx Set A1 to the polynomial in the null-terminates string str given an array x! of variable strings. If parsing str fails, A is set to zero, and -1 is returned. Otherwise, 0 is returned. The operations +, -, *, and /9 are permitted along with integers and the variables in x. The character ^ must be immediately followed by the (integer) exponent. If any division is not exact, parsing fails.Flint2fmpz_mod_mpoly_fprint_pretty file A x ctx Print a string representing A to file.Flint2fmpz_mod_mpoly_get_str_pretty A x ctx Return a string, which the user is responsible for cleaning up, representing A%, given an array of variable strings x.Flint2fmpz_mod_mpoly_clear A ctx  Release any space allocated for A.Flint2fmpz_mod_mpoly_init3 A alloc bits ctx  Initialise A for use with the given an initialised context object. Its value is set to zero. It is allocated with space for alloc terms and bits bits for the exponents.Flint2fmpz_mod_mpoly_init2 A alloc ctx  Initialise A for use with the given an initialised context object. Its value is set to zero. It is allocated with space for alloc terms and at least MPOLY_MIN_BITS bits for the exponents.Flint2fmpz_mod_mpoly_init A ctx  Initialise A for use with the given an initialised context object. Its value is set to zero.Flint2fmpz_mod_mpoly_ctx_clear ctx %Release up any space allocated by an ctx.Flint2fmpz_mod_mpoly_ctx_get_modulus n ctx Set n/ to the modulus used to initialize the context.Flint2fmpz_mod_mpoly_ctx_ord ctx 3Return the ordering used to initialize the context.Flint2fmpz_mod_mpoly_ctx_nvars ctx >Return the number of variables used to initialize the context.Flint2fmpz_mod_mpoly_ctx_init ctx nvars ord p 9Initialise a context object for a polynomial ring modulo n with nvars variables and ordering ord*. The possibilities for the ordering are ORD_LEX,  ORD_DEGLEX and  ORD_DEGREVLEX.Flint2 Create a new LFlint2 Create a new LFlint2 Create a new Flint2Use a Flint2fmpz_mod_mpoly_print_pretty A x ctx Print a string representing A to stdout.& Safe-Inferred )*1 Safe-Inferred )*1 Flint2fmpz_mod_mpoly_factor f A ctx Set f to a factorization of A! where the bases are irreducible.Flint2 fmpz_mod_mpoly_factor_squarefree f A ctx Set f to a factorization of A where the bases are primitive and pairwise relatively prime. If the product of all irreducible factors with a given exponent is desired, it is recommended to call fmpz_mod_mpoly_factor_sort8 and then multiply the bases with the desired exponent.Flint2fmpz_mod_mpoly_factor_sort f ctx Sort the product of f$ first by exponent and then by base.Flint2 fmpz_mod_mpoly_factor_get_exp_si f i ctx )Return the exponent of the term of index i in f. It is assumed to fit an slong.Flint2fmpz_mod_mpoly_factor_swap_base B f i ctx Set (resp. swap) B/ to (resp. with) the base of the term of index i in f.Flint2fmpz_mod_mpoly_factor_get_base B f i ctx Flint2'fmpz_mod_mpoly_factor_get_constant_fmpz c f ctx Set c to the constant of f.Flint2fmpz_mod_mpoly_factor_length f ctx $Return the length of the product in f.Flint2fmpz_mod_mpoly_factor_swap f g ctx Efficiently swap f and g.Flint2fmpz_mod_mpoly_factor_clear f ctx Clear f.Flint2fmpz_mod_mpoly_factor_init f ctx  Initialise f.Flint2 Create a new ' Safe-Inferred )*1 Safe-Inferred )*1WFlint2fmpz_mpoly_symmetric res k ctx Sets res) to the elementary symmetric polynomial e_k(X_1,\ldots,X_n).The gens version takes X_1,\ldots,X_n* to be the subset of generators given by vars and n. The indices in vars- start from zero. Currently, the indices in vars must be distinct.Flint2'fmpz_mpoly_buchberger_naive_with_limits G F ideal_len_limit poly_len_limit poly_bits_limit ctx As fmpz_mpoly_buchberger_naive, but halts if during the execution of Buchberger's algorithm the length of the ideal basis set exceeds ideal_len_limit(, the length of any polynomial exceeds poly_len_limit=, or the size of the coefficients of any polynomial exceeds poly_bits_limit8. Returns 1 for success and 0 for failure. On failure, G is a valid basis for F& but it might not be a Grbner basis.Flint2fmpz_mpoly_buchberger_naive G F ctx Sets G to a Grbner basis for F, computed using a naive implementation of Buchberger's algorithm.Flint2%fmpz_mpoly_vec_autoreduction_groebner H G ctx Sets H+ to the autoreduction (inter-reduction) of G. Assumes that G is a Grbner basis. This produces a reduced Grbner basis, which is unique (up to the sort order of the entries in the vector).Flint2fmpz_mpoly_vec_autoreduction H F ctx Sets H+ to the autoreduction (inter-reduction) of F.Flint2fmpz_mpoly_vec_is_autoreduced F ctx Checks whether the vector F# is autoreduced (or inter-reduced).Flint2fmpz_mpoly_vec_is_groebner G F ctx If F is NULL , checks if G is a Grbner basis. If F is not NULL , checks if G is a Grbner basis for F.Flint2#fmpz_mpoly_reduction_primitive_part res f vec ctx Sets res to the primitive part of the reduction (remainder of multivariate quasidivision with remainder) with respect to the polynomials vec.Flint2fmpz_mpoly_spoly res f g ctx Sets res to the S-polynomial of f and g, scaled to an integer polynomial by computing the LCM of the leading coefficients.Flint2#fmpz_mpoly_vec_set_primitive_unique res src ctx Sets res+ to a vector containing all polynomials in src reduced to their primitive parts, without duplication. The zero polynomial is skipped if present. The output order is arbitrary.Flint2 fmpz_mpoly_vec_randtest_not_zero vec state len poly_len bits  exp_bound ctx Sets vec! to a random vector with exactly len: entries, all nonzero, with random parameters defined by poly_len, bits and  exp_bound.Flint2fmpz_mpoly_vec_set_length vec len ctx Sets the length of vec to len*, truncating or zero-extending as needed.Flint2fmpz_mpoly_vec_insert_unique vec f ctx Inserts f without duplication into vec< and returns its index. If this polynomial already exists, vec5 is unchanged. If this polynomial does not exist in vec, it is appended.Flint2fmpz_mpoly_vec_append vec f ctx Appends f to the end of vec.Flint2fmpz_mpoly_vec_set dest src ctx Sets dest to a copy of src.Flint2fmpz_mpoly_vec_fit_length vec len ctx Allocates room for len entries in vec.Flint2fmpz_mpoly_vec_swap x y ctx Swaps x and y efficiently.Flint2fmpz_mpoly_vec_print vec ctx Prints vec to standard output.Flint2fmpz_mpoly_vec_clear vec ctx Clears vec, freeing its allocated memory.Flint2fmpz_mpoly_vec_init vec len ctx  Initializes vec to a vector of length len., setting all entries to the zero polynomial.Flint2&fmpz_mpoly_divrem_ideal_monagan_pearce q r poly2 poly3 len ctx This function is as per  fmpz_mpoly_divrem_monagan_pearce7 except that it takes an array of divisor polynomials poly33, and it returns an array of quotient polynomials q. The number of divisor (and hence quotient) polynomials is given by len%. The function computes polynomials  q_i = q[i] such that poly2 is &r + \sum_{i=0}^{\mbox{len - 1}} q_ib_i, where b_i = poly3[i].Flint2'_fmpz_mpoly_divrem_ideal_monagan_pearce polyq polyr expr allocr poly2 exp2 len2 poly3 exp3 len N bits ctx This function is as per !_fmpz_mpoly_divrem_monagan_pearce7 except that it takes an array of divisor polynomials poly3+ and an array of repacked exponent arrays exp3*, which may alias the exponent arrays of poly32, and it returns an array of quotient polynomials polyq. The number of divisor (and hence quotient) polynomials is given by len%. The function computes polynomials q_i such that *r = a - \sum_{i=0}^{\mbox{len - 1}} q_ib_i , where the q_i' are the quotient polynomials and the b_i are the divisor polynomials.Flint2fmpz_mpoly_quasidivrem_heap scale q r poly2 poly3 ctx Set scale, q and r so that scale*poly2 = q*poly3 + r and no monomial in r) is divisible by the leading monomial of poly3 , where scale is positive and as small as possible. This function throws an exception if poly3+ is zero or if an exponent overflow occurs.Flint2fmpz_mpoly_divrem_array q r poly2 poly3 ctx Set polyq and polyr" to the quotient and remainder of poly2 divided by poly3 (with remainder coefficients reduced modulo the leading coefficient of poly3). The function is implemented using dense arrays, and is efficient when the inputs are fairly dense. If the array will be larger than some internally set parameter, the function silently returns 0 so that another function can be called, otherwise it returns 1.Flint2_fmpz_mpoly_divrem_array lenr polyq expq allocq polyr expr allocr poly2 exp2 len2 poly3 exp3 len3 mults num bits  Use dense array division to set (polyq, expq, allocq) and (polyr, expr, allocr)# to the quotient and remainder of (poly2, exp2, len2) divided by (poly3, exp3, len3) in num variables, given a list of multipliers to tightly pack exponents and a number of bits for the fields of the exponents of the result. The function reallocates its outputs, hence the double indirection. The array mults is a list of bases to be used in encoding the array indices from the exponents. The function returns the length of the quotient. It is assumed that the input polynomials are not zero. No aliasing is allowed.Flint2 fmpz_mpoly_divrem_monagan_pearce q r poly2 poly3 ctx Set polyq and polyr" to the quotient and remainder of poly2 divided by poly3 (with remainder coefficients reduced modulo the leading coefficient of poly3). Implements "Polynomial division using dynamic arrays, heaps and packed exponents" by Michael Monagan and Roman Pearce.Flint2!_fmpz_mpoly_divrem_monagan_pearce lenr polyq expq allocq polyr expr allocr poly2 exp2 len2 poly3 exp3 len3 bits N Set (polyq, expq, allocq) and (polyr, expr, allocr)# to the quotient and remainder of (poly2, exp2, len2) by (poly3, exp3, len3) (with remainder coefficients reduced modulo the leading coefficient of (poly3, exp3, len3)), and return the length of the quotient. The function reallocates its outputs, hence the double indirection. The function assumes the exponent vectors all fit in N words. The exponent vectors are assumed to have fields with the given number of bits. Assumes input polynomials are nonzero. Implements "Polynomial division using dynamic arrays, heaps and packed exponents" by Michael Monagan and Roman Pearce. No aliasing is allowed.Flint2fmpz_mpoly_div_monagan_pearce polyq poly2 poly3 ctx Set polyq to the quotient of poly2 by poly3, discarding the remainder (with notional remainder coefficients reduced modulo the leading coefficient of poly3). Implements "Polynomial division using dynamic arrays, heaps and packed exponents" by Michael Monagan and Roman Pearce. This function is exceptionally efficient if the division is known to be exact.Flint2_fmpz_mpoly_div_monagan_pearce polyq expq allocq poly2 exp2 len2 poly3 exp3 len3 bits N Set (polyq, expq, allocq) to the quotient of (poly2, exp2, len2) by (poly3, exp3, len3) discarding remainder (with notional remainder coefficients reduced modulo the leading coefficient of (poly3, exp3, len3)), and return the length of the quotient. The function reallocates its output, hence the double indirection. The function assumes the exponent vectors all fit in N words. The exponent vectors are assumed to have fields with the given number of bits. Assumes input polynomials are nonzero. Implements "Polynomial division using dynamic arrays, heaps and packed exponents" by Michael Monagan and Roman Pearce. No aliasing is allowed.Flint2 fmpz_mpoly_divides_heap_threaded Q A B ctx  thread_limit Set poly1 to poly2 divided by poly3 and return 1 if the quotient is exact. Otherwise return 0. The function uses the algorithm of Michael Monagan and Roman Pearce. Note that the function fmpz_mpoly_div_monagan_pearce below may be much faster if the quotient is known to be exact.The threaded version takes an upper limit on the number of threads to use, while the first version always uses one thread.Flint2"_fmpz_mpoly_divides_monagan_pearce poly1 exp1 alloc poly2 exp2 len2 poly3 exp3 len3 bits N Set (poly1, exp1, alloc) to (poly2, exp3, len2) divided by (poly3, exp3, len3) and return 1 if the quotient is exact. Otherwise return 0. The function assumes exponent vectors that each fit in N words, and are packed into fields of the given number of bits. Assumes input polys are nonzero. Implements "Polynomial division using dynamic arrays, heaps and packed exponents" by Michael Monagan and Roman Pearce. No aliasing is allowed.Flint2fmpz_mpoly_divides_array poly1 poly2 poly3 ctx Set poly1 to poly2 divided by poly3, using a big dense array to accumulate coefficients, and return 1 if the quotient is exact. Otherwise, return 0 if the quotient is not exact. If the array will be larger than some internally set parameter, the function fails silently and returns -1 so that some other method may be called. This function is most efficient on dense inputs. Note that the function fmpz_mpoly_div_monagan_pearce below may be much faster if the quotient is known to be exact.Flint2_fmpz_mpoly_divides_array poly1 exp1 alloc poly2 exp2 len2 poly3 exp3 len3 mults num bits &Use dense array exact division to set (poly1, exp1, alloc) to (poly2, exp3, len2) divided by (poly3, exp3, len3) in num variables, given a list of multipliers to tightly pack exponents and a number of bits for the fields of the exponents of the result. The array "mults" is a list of bases to be used in encoding the array indices from the exponents. The function reallocates its output, hence the double indirection, and returns the length of its output if the quotient is exact, or zero if not. It is assumed that poly2& is not zero. No aliasing is allowed.Flint2fmpz_mpoly_pow_fps A B k ctx Set A to B raised to the k-th power, using the Monagan and Pearce FPS algorithm. It is assumed that B is not zero and k \geq 2.Flint2fmpz_mpoly_deflation shift stride A ctx For each variable v let S_v' be the set of exponents appearing on v. Set shift[v] to \operatorname{min}(S_v) and set  stride[v] to -\operatorname{gcd}(S-\operatorname{min}(S_v)). If A2 is zero, all shifts and strides are set to zero.Flint2fmpz_mpoly_deflate A B shift stride ctx Apply the function e -> (e - shift[v])/stride[v] to each exponent e corresponding to the variable v . If any  stride[v]' is zero, the corresponding numerator  e - shift[v] is assumed to be zero, and the quotient is defined as zero. This allows the function to undo the operation performed by fmpz_mpoly_inflate when possible.Flint2fmpz_mpoly_inflate A B shift stride ctx Apply the function e -> shift[v] + stride[v]*e to each exponent e corresponding to the variable v<. It is assumed that each shift and stride is not negative.Flint2 fmpz_mpoly_univar_get_term_coeff c A i ctx Set (resp. swap) c7 to (resp. with) the coefficient of the term of index i of A.Flint2!fmpz_mpoly_univar_get_term_exp_si A i ctx )Return the exponent of the term of index i of A.Flint2fmpz_mpoly_univar_length A ctx Return the number of terms in A# with respect to the main variable.Flint2 fmpz_mpoly_univar_degree_fits_si A ctx Return 1 if the degree of A, with respect to the main variable fits an slong. Otherwise, return 0.Flint2fmpz_mpoly_from_univar A B var ctx Set A to the normal form of B& by putting in the variable of index var4. This function is undefined if the coefficients of B" depend on the variable of index var.Flint2fmpz_mpoly_to_univar A B var ctx Set A to a univariate form of B' by pulling out the variable of index var. The coefficients of A" will still belong to the content ctx/ but will not depend on the variable of index var.Flint2fmpz_mpoly_univar_swap A B ctx Swap A and B.Flint2fmpz_mpoly_univar_clear A ctx Clear A.Flint2fmpz_mpoly_univar_init A ctx  Initialize A.Flint2fmpz_mpoly_is_square A ctx Return 1 if A' is a perfect square, otherwise return 0.Flint2fmpz_mpoly_sqrt q A ctx If A is a perfect square return 1 and set Q to the square root with positive leading coefficient. Otherwise return 0 and set Q to zero.Flint2fmpz_mpoly_sqrt_heap Q A ctx check If A is a perfect square return 1 and set Q to the square root with positive leading coefficient. Otherwise return 0 and set Q to the zero polynomial. If  check = 0 the polynomial is assumed to be a perfect square. This can be significantly faster, but it will not detect non-squares with any reliability, and in the event of being passed a non-square the result is meaningless.Flint2fmpz_mpoly_primitive_part res f ctx Sets res to the primitive part of f, obtained by dividing out the content of all coefficients and normalizing the leading coefficient to be positive. The zero polynomial is unchanged.Flint2fmpz_mpoly_discriminant D A var ctx  Try to set D to the discriminant of A( with respect to the variable of index var.Flint2fmpz_mpoly_resultant R A B var ctx  Try to set R to the resultant of A and B( with respect to the variable of index var.Flint2fmpz_mpoly_gcd_brown G A B ctx  Try to set G to the GCD of A and B using various algorithms.Flint2fmpz_mpoly_gcd_cofactors G Abar Bbar A B ctx Do the operation of fmpz_mpoly_gcd and also compute  Abar = A/G and  Bbar = B/G if successful.Flint2fmpz_mpoly_gcd G A B ctx  Try to set G to the GCD of A and B with positive leading coefficient. The GCD of zero and zero is defined to be zero. If the return is 17 the function was successful. Otherwise the return is 0 and G is left untouched.Flint2fmpz_mpoly_content_vars g A vars  vars_length ctx Set g# to the GCD of the coefficients of A/ when viewed as a polynomial in the variables vars . Return 1 for success and 0 for failure. Upon success, g' will be independent of the variables vars.Flint2fmpz_mpoly_term_content M A ctx Set M to the GCD of the terms of A. If A is zero, M will be zero. Otherwise, M. will be a monomial with positive coefficient.Flint2fmpz_mpoly_quasidivrem_ideal scale Q R A B len ctx This function is as per fmpz_mpoly_quasidivrem7 except that it takes an array of divisor polynomials B2 and it returns an array of quotient polynomials Q. The number of divisor (and hence quotient) polynomials is given by len.Flint2fmpz_mpoly_divrem_ideal Q R A B len ctx This function is as per fmpz_mpoly_divrem7 except that it takes an array of divisor polynomials B2 and it returns an array of quotient polynomials Q. The number of divisor (and hence quotient) polynomials is given by len. Note that this function is not very useful if there is no unit among the leading coefficients in the array B.Flint2fmpz_mpoly_quasidiv scale Q A B ctx Perform the operation of fmpz_mpoly_quasidivrem and discard R.Flint2fmpz_mpoly_div Q A B ctx Perform the operation of fmpz_mpoly_divrem and discard R. Note that this function is not very useful if the division is not exact and the leading coefficient B is not a unit.Flint2fmpz_mpoly_quasidivrem scale Q R A B ctx Set scale, Q and R so that Q and R$ are the quotient and remainder of scale \times A divided by B. No monomials in R/ will be divisible by the leading monomial of B.Flint2fmpz_mpoly_divrem Q R A B ctx Set Q and R" to the quotient and remainder of A divided by B. The monomials in R& divisible by the leading monomial of B will have coefficients reduced modulo the absolute value of the leading coefficient of B. Note that this function is not very useful if the leading coefficient B is not a unit.Flint2fmpz_mpoly_divides Q A B ctx If A is divisible by B, set Q# to the exact quotient and return 1. Otherwise, set Q to zero and return 0.Flint2fmpz_mpoly_pow_ui A B k ctx Set A to B raised to the k-th power. Return 1 for success and 0 for failure.Flint2fmpz_mpoly_pow_fmpz A B k ctx Set A to B raised to the k-th power. Return 1 for success and 0 for failure.Flint2fmpz_mpoly_mul_dense A B C ctx  Try to set A to  B \times C+ using dense arithmetic. If the return is 0, the operation was unsuccessful. Otherwise, it was successful and the return is 1.Flint2fmpz_mpoly_mul_array A B C ctx  Try to set A to  B \times C using arrays. If the return is 0, the operation was unsuccessful. Otherwise, it was successful and the return is 1+. The first version always uses one thread.Flint2fmpz_mpoly_mul_johnson A B C ctx Set A to  B \times C using Johnson's heap-based method. The first version always uses one thread.Flint2fmpz_mpoly_mul A B C ctx Set A to  B \times C.Flint2!fmpz_mpoly_compose_fmpz_mpoly_gen A B c ctxB ctxAC Set A to the evaluation of B where the variable of index i in ctxB& is replaced by the variable of index c[i] in ctxAC. The length of the array C is the number of variables in ctxB . If any c[i], is negative, the corresponding variable of B6 is replaced by zero. Otherwise, it is expected that c[i]* is less than the number of variables in ctxAC.Flint2'fmpz_mpoly_compose_fmpz_mpoly_geobucket A B C ctxB ctxAC Set A to the evaluation of B where the variables are replaced by the corresponding elements of the array C. Both A and the elements of C have context object ctxAC, while B has context object ctxB. The length of the array C is the number of variables in ctxB . Neither A nor B3 is allowed to alias any other polynomial. Return 1 for success and 0 for failure. The main method attempts to perform the calculation using matrices and chooses heuristically between the  geobucket and horner methods if needed.Flint2fmpz_mpoly_compose_fmpz_poly A B C ctxB Set A to the evaluation of B where the variables are replaced by the corresponding elements of the array C. The context object of B is ctxB . Return 1 for success and 0 for failure.Flint2fmpz_mpoly_evaluate_one_fmpz A B var val ctx Set A to the evaluation of B where the variable of index var is replaced by val . Return 1 for success and 0 for failure.Flint2fmpz_mpoly_evaluate_all_fmpz ev A vals ctx Set ev to the evaluation of A where the variables are replaced by the corresponding elements of the array vals . Return 1 for success and 0 for failure.Flint2fmpz_mpoly_integral A scale B var ctx Set A and scale so that A is an integral of scale \times B( with respect to the variable of index var, where scale' is positive and as small as possible.Flint2fmpz_mpoly_derivative A B var ctx Set A to the derivative of B( with respect to the variable of index var.Flint2fmpz_mpoly_scalar_divides_fmpz A B c ctx If B is divisible by c, set A# to the exact quotient and return 1, otherwise set A to zero and return 0.Flint2fmpz_mpoly_scalar_divexact_fmpz A B c ctx Set A to B divided by c&. The division is assumed to be exact.Flint2fmpz_mpoly_scalar_fmma A B c D e ctx Sets A to B \times c + D \times e.Flint2fmpz_mpoly_scalar_mul_fmpz A B c ctx Set A to  B \times c.Flint2fmpz_mpoly_neg A B ctx Set A to -B.Flint2fmpz_mpoly_sub A B C ctx Set A to B - C. If A and B are aliased, this function might run in time proportional to the size of C.Flint2fmpz_mpoly_add A B C ctx Set A to B + C. If A and B are aliased, this function might run in time proportional to the size of C.Flint2fmpz_mpoly_sub_fmpz A B c ctx Set A to B - c. If A and B7 are aliased, this function will probably run quickly.Flint2fmpz_mpoly_add_fmpz A B c ctx Set A to B + c. If A and B7 are aliased, this function will probably run quickly.Flint2fmpz_mpoly_randtest_bits A state length  coeff_bits exp_bits ctx Generate a random polynomial with length up to the given length and exponents whose packed form does not exceed the given bit count.The parameter  coeff_bits to the three functions 'fmpz_mpoly_randtest_{bound|bounds|bits} is merely a suggestion for the approximate bit count of the resulting signed coefficients. The function fmpz_mpoly_max_bits- will give the exact bit count of the result.Flint2fmpz_mpoly_randtest_bounds A state length  coeff_bits  exp_bounds ctx /Generate a random polynomial with length up to length and exponents in the range [0, exp_bounds[i] - 1]*. The exponents of the variable of index i are generated by calls to n_randint(state, exp_bounds[i]).Flint2fmpz_mpoly_randtest_bound A state length  coeff_bits  exp_bound ctx /Generate a random polynomial with length up to length and exponents in the range [0, exp_bound - 1]<. The exponents of each variable are generated by calls to n_randint(state, exp_bound).Flint2fmpz_mpoly_reverse A B ctx Set A to the reversal of B.Flint2fmpz_mpoly_combine_like_terms A ctx Combine adjacent like terms in A: and delete terms with coefficient zero. If the terms of A were sorted to begin with, the result will be in canonical form. This function runs in linear time in the size of A.Flint2fmpz_mpoly_sort_terms A ctx Sort the terms of A: into the canonical ordering dictated by the ordering in ctx. This function simply reorders the terms: It does not combine like terms, nor does it delete terms with coefficient zero. This function runs in linear time in the size of A.Flint2fmpz_mpoly_push_term_fmpz_fmpz A c exp ctx Append a term to A with coefficient c and exponent vector exp/. This function runs in constant average time.Flint2fmpz_mpoly_get_term_monomial M A i ctx Set M& to the monomial of the term of index i in A. The coefficient of M will be one.Flint2fmpz_mpoly_get_term M A i ctx Set M to the term of index i in A.Flint2fmpz_mpoly_set_term_exp_fmpz A i exp ctx -Set the exponent vector of the term of index i to exp.Flint2fmpz_mpoly_get_term_var_exp_ui A i var ctx $Return the exponent of the variable var of the term of index i<. This function throws if the exponent does not fit into a ulong (resp. slong).Flint2fmpz_mpoly_get_term_exp_fmpz exp A i ctx Set exp- to the exponent vector of the term of index i. The _ui (resp. _si2) version throws if any entry does not fit into a ulong (resp. slong).Flint2fmpz_mpoly_term_exp_fits_si poly i ctx Return 1= if all entries of the exponent vector of the term of index i fit into an slong (resp. a ulong). Otherwise, return 0.Flint2fmpz_mpoly_set_term_coeff_fmpz A i c ctx )Set the coefficient of the term of index i to c.Flint2fmpz_mpoly_get_term_coeff_fmpz c A i ctx Either return or set c) to the coefficient of the term of index i.Flint2fmpz_mpoly_resize A  new_length ctx Set the length of A to  new\_length. Terms are either deleted from the end, or new zero terms are appended.Flint2fmpz_mpoly_length A ctx Return the number of terms in A. If the polynomial is in canonical form, this will be the number of nonzero coefficients.Flint2fmpz_mpoly_is_canonical A ctx Return 1 if A) is in canonical form. Otherwise, return 0. To be in canonical form, all of the terms must have nonzero coefficient, and the terms must be sorted from greatest to least.Flint2fmpz_mpoly_term_coeff_ref A i ctx /Return a reference to the coefficient of index i of A.Flint2fmpz_mpoly_set_fmpz_poly A B var ctx Set A to the univariate polynomial B in the variable with index var.Flint2fmpz_mpoly_get_fmpz_poly A B var ctx If B7 is a univariate polynomial in the variable with index var, set A5 to this polynomial and return 1; otherwise return 0.Flint2fmpz_mpoly_is_fmpz_poly A var ctx Return whether A8 is a univariate polynomial in the variable with index var.Flint2fmpz_mpoly_cmp A B ctx Return 1 (resp. -1, or 0) if A# is after (resp. before, same as) B in some arbitrary but fixed total ordering of the polynomials. This ordering agrees with the usual ordering of monomials when A and B are both monomials.Flint2fmpz_mpoly_get_coeff_vars_ui C A vars exps length ctx Set C to the coefficient of A# with respect to the variables in vars( with powers in the corresponding array exps. Both vars and exps point to array of length length. It is assumed that 0 < length \le nvars(A) and that the variables in vars are distinct.Flint2fmpz_mpoly_set_coeff_fmpz_fmpz A c exp ctx 9Set the coefficient of the monomial with exponent vector exp to c.Flint2fmpz_mpoly_get_coeff_fmpz_fmpz c A exp ctx Either return or set c: to the coefficient of the monomial with exponent vector exp.Flint2"fmpz_mpoly_set_coeff_fmpz_monomial poly c poly2 ctx Assuming that M is a monomial, set the coefficient of the corresponding monomial in A to c. This function throws if M is not a monomial.Flint2"fmpz_mpoly_get_coeff_fmpz_monomial c A M ctx Assuming that M is a monomial, set c6 to the coefficient of the corresponding monomial in A. This function throws if M is not a monomial.Flint2fmpz_mpoly_used_vars used A ctx For each variable index i, set used[i]& to nonzero if the variable of index i appears in A and to zero otherwise.Flint2fmpz_mpoly_total_degree_fmpz tdeg A ctx Either return or set tdeg to the total degree of A. If A- is zero, the total degree is defined to be -1.Flint2fmpz_mpoly_total_degree_fits_si A ctx Return 1 if the total degree of A fits into an slong, otherwise return 0.Flint2fmpz_mpoly_degree_fmpz deg A var ctx Either return or set deg to the degree of A( with respect to the variable of index var. If A' is zero, the degree is defined to be -1.Flint2fmpz_mpoly_degrees_fmpz degs A ctx Set degs to the degrees of A# with respect to each variable. If A" is zero, all degrees are set to -1.Flint2fmpz_mpoly_degrees_fit_si A ctx Return 1 if the degrees of A, with respect to each variable fit into an slong, otherwise return 0.Flint2fmpz_mpoly_is_one A ctx Return 1 if A is the constant 1, else return 0.Flint2fmpz_mpoly_is_zero A ctx Return 1 if A is the constant 0, else return 0.Flint2fmpz_mpoly_equal_fmpz A c ctx Return 1 if A is equal to the constant c, else return 0.Flint2fmpz_mpoly_one A ctx Set A to the constant 1.Flint2fmpz_mpoly_zero A ctx Set A to the constant 0.Flint2fmpz_mpoly_set_fmpz A c ctx Set A to the constant c.Flint2fmpz_mpoly_get_fmpz c A ctx Assuming that A is a constant, set c, to this constant. This function throws if A is not a constant.Flint2fmpz_mpoly_is_fmpz A ctx Return 1 if A is a constant, else return 0.Flint2fmpz_mpoly_max_bits A $Computes the maximum number of bits b required to represent the absolute values of the coefficients of A,. If all of the coefficients are positive, b is returned, otherwise -b is returned.Flint2_fmpz_mpoly_fits_small poly len 0Return 1 if the array of coefficients of length len- consists entirely of values that are small fmpz values, i.e. of at most FLINT_BITS - 2 bits plus a sign bit.Flint2fmpz_mpoly_swap poly1 poly2 ctx Efficiently swap A and B.Flint2fmpz_mpoly_equal A B ctx Return 1 if A is equal to B, else return 0.Flint2fmpz_mpoly_set A B ctx Set A to B.Flint2fmpz_mpoly_is_gen A var ctx If  var \ge 0 , return 1 if A is equal to the var!-th generator, otherwise return 0. If var < 0 , return 1 if the polynomial is equal to any generator, otherwise return 0.Flint2fmpz_mpoly_gen A var ctx Set A to the variable of index var, where var = 0 corresponds to the variable with the most significance with respect to the ordering.Flint2fmpz_mpoly_set_str_pretty A str x ctx Set A1 to the polynomial in the null-terminates string str given an array x! of variable strings. If parsing str fails, A is set to zero, and -1 is returned. Otherwise, 0 is returned. The operations +, -, *, and /9 are permitted along with integers and the variables in x. The character ^ must be immediately followed by the (integer) exponent. If any division is not exact, parsing fails.Flint2fmpz_mpoly_fprint_pretty file A x ctx Print a string representing A to file.Flint2fmpz_mpoly_get_str_pretty A x ctx Return a string, which the user is responsible for cleaning up, representing A%, given an array of variable strings x.Flint2fmpz_mpoly_clear A ctx  Release any space allocated for A.Flint2fmpz_mpoly_realloc A alloc ctx  Reallocate A to have space for alloc terms. Assumes the current length of the polynomial is not greater than alloc.Flint2fmpz_mpoly_fit_bits A bits ctx #Ensure that the exponent fields of A have at least bits bits.Flint2fmpz_mpoly_fit_length A len ctx  Ensure that A has space for at least len terms.Flint2fmpz_mpoly_init3 A alloc bits ctx  Initialise A for use with the given and initialised context object. Its value is set to zero. It is allocated with space for alloc terms and bits bits for the exponents.Flint2fmpz_mpoly_init2 A alloc ctx  Initialise A for use with the given and initialised context object. Its value is set to zero. It is allocated with space for alloc terms and at least MPOLY_MIN_BITS bits for the exponents.Flint2fmpz_mpoly_init A ctx  Initialise A for use with the given and initialised context object. Its value is set to zero.Flint2fmpz_mpoly_ctx_clear ctx "Release up any space allocated by ctx.Flint2fmpz_mpoly_ctx_ord ctx 3Return the ordering used to initialize the context.Flint2fmpz_mpoly_ctx_nvars ctx >Return the number of variables used to initialize the context.Flint2fmpz_mpoly_ctx_init ctx nvars ord Initialise a context object for a polynomial ring with the given number of variables and the given ordering. The possibilities for the ordering are ORD_LEX,  ORD_DEGLEX and  ORD_DEGREVLEX.Flint2 newFmpzMPoly ctxConstruct a new  with context ctx.Flint2withNewFmpzMPoly ctxExecute computation f on a new  with context ctx.LFlint2 Create a new LFlint2 Create a new Flint2Use a Flint2fmpz_mpoly_print_pretty A x ctx Print a string representing A to stdout. foreign import ccall "fmpz_mpoly.h fmpz_mpoly_print_pretty" fmpz_mpoly_print_pretty :: Ptr CFmpzMPoly -> Ptr (Ptr CChar) -> Ptr CFmpzMPolyCtx -> IO CInt( Safe-Inferred )*1Y Safe-Inferred )*1mSFlint2_fmpz_mpoly_q_content num den xnum xden ctx Sets res' to the content of the coefficients of x.Flint2fmpz_mpoly_q_inv res x ctx Sets res to the inverse of x. Division by zero calls  flint_abort.Flint2fmpz_mpoly_q_div res x y ctx Sets res to the quotient of x and y. Division by zero calls  flint_abort.Flint2fmpz_mpoly_q_mul res x y ctx Sets res to the product of x and y.Flint2fmpz_mpoly_q_sub res x y ctx Sets res to the difference of x and y.Flint2fmpz_mpoly_q_add res x y ctx Sets res to the sum of x and y.Flint2fmpz_mpoly_q_neg res x ctx Sets res to the negation of x.Flint2fmpz_mpoly_q_equal x y ctx Returns whether x and y are equal.Flint2fmpz_mpoly_q_randtest res state length  coeff_bits  exp_bound ctx Sets res to a random rational function where both numerator and denominator have up to length! terms, coefficients up to size  coeff_bits&, and exponents strictly smaller than  exp_bound.Flint2fmpz_mpoly_q_fprint_pretty out f x ctx Prints f to file out. If x is not NULL, the strings in x+ are used as the symbols for the variables.Flint2fmpz_mpoly_q_get_str_pretty f x ctx !Returns string representation of f. If x is not NULL, the strings in x+ are used as the symbols for the variables.Flint2fmpz_mpoly_q_gen res i ctx Sets res to the generator x_{i+1} . Requires  0 \le i < n where n is the number of variables of ctx.Flint2fmpz_mpoly_q_one res ctx Sets res to the constant 1.Flint2fmpz_mpoly_q_zero res ctx Sets res to the constant 0.Flint2fmpz_mpoly_q_used_vars used f ctx 3For each variable, sets the corresponding entry in used to the boolean flag indicating whether that variable appears in the rational function (respectively its numerator or denominator).Flint2fmpz_mpoly_q_is_one x ctx Returns whether x is the constant 1.Flint2fmpz_mpoly_q_is_zero x ctx Returns whether x is the constant 0.Flint2fmpz_mpoly_q_is_canonical x ctx Returns whether x is in canonical form.In addition to verifying that the numerator and denominator have no common content and that the leading term of the denominator is positive, this function checks that the denominator is nonzero and that the numerator and denominator have correctly sorted terms (these properties should normally hold; verifying them provides an extra consistency check for test code).Flint2fmpz_mpoly_q_canonicalise x ctx &Puts the numerator and denominator of x in canonical form by removing common content and making the leading term of the denominator positive.Flint2fmpz_mpoly_q_set res x ctx Sets res to the value x.Flint2fmpz_mpoly_q_swap x y ctx Swaps the values of x and y efficiently.Flint2fmpz_mpoly_q_clear res ctx Clears res,, freeing or recycling its allocated memory.Flint2fmpz_mpoly_q_init res ctx  Initializes res% for use, and sets its value to zero.Flint2 Create a new Flint2 Use a new Flint2Use the numerator of Flint2Use the denominator of Flint2fmpz_mpoly_q_print_pretty f x ctx Prints f to standard output. If x is not NULL, the strings in x+ are used as the symbols for the variables. ) Safe-Inferred )*1m   Safe-Inferred )*1t Flint2fmpz_mpoly_factor f A ctx Set f to a factorization of A! where the bases are irreducible.Flint2fmpz_mpoly_factor_squarefree f A ctx Set f to a factorization of A where the bases are primitive and pairwise relatively prime. If the product of all irreducible factors with a given exponent is desired, it is recommended to call fmpz_mpoly_factor_sort8 and then multiply the bases with the desired exponent.Flint2fmpz_mpoly_factor_sort f ctxSort the product of f$ first by exponent and then by base.Flint2fmpz_mpoly_factor_get_exp_si f i ctx )Return the exponent of the term of index i in A. It is assumed to fit an slong.Flint2fmpz_mpoly_factor_get_base B f i ctx Set (resp. swap) B/ to (resp. with) the base of the term of index i in A.Flint2#fmpz_mpoly_factor_get_constant_fmpz c f ctx Set c to the constant of f.Flint2fmpz_mpoly_factor_length f ctx $Return the length of the product in f.Flint2fmpz_mpoly_factor_swap f g ctx Efficiently swap f and g.Flint2fmpz_mpoly_factor_clear f ctx Clear f.Flint2fmpz_mpoly_factor_init f ctx  Initialise f.* Safe-Inferred )*1t Safe-Inferred )*1} Flint2_fmpq_vec_fprint file vec len 0Prints the vector of given length to the stream file. The format is the length followed by two spaces, then a space separated list of coefficients. If the length is zero, only 0 is printed.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2 _fmpq_vec_dot res vec1 vec2 len Sets res# to the dot product of the vectors  (vec1, len) and  (vec2, len).Flint2_fmpq_vec_get_fmpz_vec_fmpz num den a len Find a common denominator den of the entries of a and set  (num, len)! to the corresponding numerators.Flint2_fmpq_vec_set_fmpz_vec res vec len Sets  (res, len) to  (vec, len).Flint2_fmpq_vec_sort vec len Sorts the entries of  (vec, len).Flint2_fmpq_vec_randtest_uniq_sorted vec state len bits Sets the entries of a vector of the given length to random distinct rationals with numerator and denominator having up to the given number of bits per entry. The entries in the vector are sorted.Flint2_fmpq_vec_randtest f state len bits Sets the entries of a vector of the given length to random rationals with numerator and denominator having up to the given number of bits per entry.Flint2_fmpq_vec_clear vec n  Frees an fmpq vector.Flint2_fmpq_vec_init n Initialises a vector of fmpq values of length n? and sets all values to 0. This is equivalent to generating a fmpz vector of length 2n with _fmpz_vec_init# and setting all denominators to 1.Flint2_fmpq_vec_print vec len %Prints the vector of given length to stdout.For further details, see _fmpq_vec_fprint(). + Safe-Inferred )*1}   Safe-Inferred )*1 ^LFlint2Data structure containing the CFmpqPolyFactor pointerLFlint2Data structure containing the CFmpqPolyPowersPrecomp pointerFlint2fmpq_poly_fread file poly #Reads a polynomial from the stream file, storing the result in poly.In case of success, returns a positive number. In case of failure, returns a non-positive value.Flint2fmpq_poly_read poly Reads a polynomial from stdin, storing the result in poly.In case of success, returns a positive number. In case of failure, returns a non-positive value.Flint2fmpq_poly_fprint_pretty file poly var $Prints the pretty representation of poly to stdout$, using the null-terminated string var not equal to "\0" as the variable name.2In the current implementation, always returns~`1`.Flint2fmpq_poly_fprint file poly $Prints the polynomial to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2_fmpq_poly_fprint file poly den len Prints the polynomial (poly, den, len) to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2_fmpq_poly_print poly den len Prints the polynomial (poly, den, len) to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value.Flint2fmpq_poly_is_squarefree poly Returns whether the polynomial poly is square-free. A non-zero polynomial is defined to be square-free if it has no non-unit square factors. We also define the zero polynomial to be square-free.Flint2fmpq_poly_make_monic res poly Sets res! to the monic scalar multiple of poly whenever poly is non-zero. If poly is the zero polynomial, sets res to zero.Flint2_fmpq_poly_make_monic rpoly rden poly den len Sets (rpoly, rden, len)" to the monic scalar multiple of (poly, den, len). Assumes that len > 01. Supports aliasing between the two polynomials.Flint2fmpq_poly_is_monic poly Returns whether the polynomial poly; is monic. The zero polynomial is not monic by definition.Flint2_fmpq_poly_is_monic poly den len Returns whether the polynomial (poly, den, len); is monic. The zero polynomial is not monic by definition.Flint2fmpq_poly_primitive_part res poly Sets res to the primitive part, with non-negative leading coefficient, of poly.Flint2_fmpq_poly_primitive_part rpoly rden poly den len Sets (rpoly, rden, len) to the primitive part, with non-negative leading coefficient, of (poly, den, len). Assumes that len > 01. Supports aliasing between the two polynomials.Flint2fmpq_poly_content res poly Sets res to the content of poly<. The content of the zero polynomial is defined to be zero.Flint2_fmpq_poly_content res poly den len Sets res to the content of (poly, den, len). If len == 0, sets res to zero.Flint2fmpq_poly_revert_series res poly n Sets res" to the power series reversion of poly1 modulo x^n. The constant term of poly2 is required to be zero and the linear term is required to be nonzero.This implementation defaults to using Newton iteration. The default  fmpz_poly reversion algorithm is automatically used when the reversion can be performed over the integers.Flint2_fmpq_poly_revert_series res den poly1 den1 len1 n Sets  (res, den)" to the power series reversion of (poly1, den1, len1) modulo x^n.The constant term of poly2 is required to be zero and the linear term is required to be nonzero. Assumes that n > 0. Does not support aliasing between any of the inputs and the output.This implementation defaults to using Newton iteration. The default  fmpz_poly reversion algorithm is automatically used when the reversion can be performed over the integers.Flint2fmpq_poly_revert_series_newton res poly n Sets res" to the power series reversion of poly1 modulo x^n. The constant term of poly2 is required to be zero and the linear term is required to be nonzero.7This implementation uses Newton iteration. The default  fmpz_poly reversion algorithm is automatically used when the reversion can be performed over the integers.Flint2_fmpq_poly_revert_series_newton res den poly1 den1 len1 n Sets  (res, den)" to the power series reversion of (poly1, den1, len1) modulo x^n.The constant term of poly2 is required to be zero and the linear term is required to be nonzero. Assumes that n > 0. Does not support aliasing between any of the inputs and the output.7This implementation uses Newton iteration. The default  fmpz_poly reversion algorithm is automatically used when the reversion can be performed over the integers.Flint2%fmpq_poly_revert_series_lagrange_fast res poly n Sets res" to the power series reversion of poly1 modulo x^n. The constant term of poly2 is required to be zero and the linear term is required to be nonzero.This implementation uses a reduced-complexity implementation of the Lagrange inversion formula. The default  fmpz_poly reversion algorithm is automatically used when the reversion can be performed over the integers.Flint2&_fmpq_poly_revert_series_lagrange_fast res den poly1 den1 len1 n Sets  (res, den)" to the power series reversion of (poly1, den1, len1) modulo x^n.The constant term of poly2 is required to be zero and the linear term is required to be nonzero. Assumes that n > 0. Does not support aliasing between any of the inputs and the output.This implementation uses a reduced-complexity implementation of the Lagrange inversion formula. The default  fmpz_poly reversion algorithm is automatically used when the reversion can be performed over the integers.Flint2 fmpq_poly_revert_series_lagrange res poly n Sets res" to the power series reversion of poly1 modulo x^n. The constant term of poly2 is required to be zero and the linear term is required to be nonzero.This implementation uses the Lagrange inversion formula. The default  fmpz_poly reversion algorithm is automatically used when the reversion can be performed over the integers.Flint2!_fmpq_poly_revert_series_lagrange res den poly1 den1 len1 n Sets  (res, den)" to the power series reversion of (poly1, den1, len1) modulo x^n.The constant term of poly2 is required to be zero and the linear term is required to be nonzero. Assumes that n > 0. Does not support aliasing between any of the inputs and the output.This implementation uses the Lagrange inversion formula. The default  fmpz_poly reversion algorithm is automatically used when the reversion can be performed over the integers.Flint2fmpq_poly_compose_series res poly1 poly2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero.This implementation automatically switches between the Horner scheme and Brent-Kung algorithm 2.1 depending on the size of the inputs. The default  fmpz_poly composition algorithm is automatically used when the composition can be performed over the integers.Flint2_fmpq_poly_compose_series res den poly1 den1 len1 poly2 den2 len2 n Sets  (res, den, n) to the composition of (poly1, den1, len1) and (poly2, den2, len2) modulo x^n, where the constant term of poly2 is required to be zero. Assumes that len1, len2, n > 0, that len1, len2 <= n, that (len1-1) * (len2-1) + 1 <= n , and that res has space for n coefficients. Does not support aliasing between any of the inputs and the output.This implementation automatically switches between the Horner scheme and Brent-Kung algorithm 2.1 depending on the size of the inputs. The default  fmpz_poly composition algorithm is automatically used when the composition can be performed over the integers.Flint2#fmpq_poly_compose_series_brent_kung res poly1 poly2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero.2This implementation uses Brent-Kung algorithm 2.1  [BrentKung1978]. The default  fmpz_poly composition algorithm is automatically used when the composition can be performed over the integers.Flint2$_fmpq_poly_compose_series_brent_kung res den poly1 den1 len1 poly2 den2 len2 n Sets  (res, den, n) to the composition of (poly1, den1, len1) and (poly2, den2, len2) modulo x^n, where the constant term of poly2 is required to be zero. Assumes that len1, len2, n > 0, that len1, len2 <= n, that (len1-1) * (len2-1) + 1 <= n , and that res has space for n coefficients. Does not support aliasing between any of the inputs and the output.2This implementation uses Brent-Kung algorithm 2.1  [BrentKung1978]. The default  fmpz_poly composition algorithm is automatically used when the composition can be performed over the integers.Flint2fmpq_poly_compose_series_horner res poly1 poly2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero.8This implementation uses the Horner scheme. The default  fmpz_poly composition algorithm is automatically used when the composition can be performed over the integers.Flint2 _fmpq_poly_compose_series_horner res den poly1 den1 len1 poly2 den2 len2 n Sets  (res, den, n) to the composition of (poly1, den1, len1) and (poly2, den2, len2) modulo x^n, where the constant term of poly2 is required to be zero. Assumes that len1, len2, n > 0, that len1, len2 <= n, that (len1-1) * (len2-1) + 1 <= n , and that res has space for n coefficients. Does not support aliasing between any of the inputs and the output.8This implementation uses the Horner scheme. The default  fmpz_poly composition algorithm is automatically used when the composition can be performed over the integers.Flint2fmpq_poly_rescale res poly a Sets res to poly$ with the indeterminate rescaled by a.Flint2_fmpq_poly_rescale res denr poly den len anum aden Sets (res, denr, len) to (poly, den, len)% with the indeterminate rescaled by  (anum, aden). Assumes that len > 0 and that  (anum, aden)= is non-zero and in lowest terms. Supports aliasing between (res, denr, len) and (poly, den, len).Flint2fmpq_poly_compose res poly1 poly2 Sets res to the composition of poly1 and poly2.Flint2_fmpq_poly_compose res den poly1 den1 len1 poly2 den2 len2 Sets  (res, den) to the composition of (poly1, den1, len1) and (poly2, den2, len2) , assuming len1, len2 > 0. Assumes that res has space for (len1 - 1) * (len2 - 1) + 1* coefficients. Does not support aliasing.Flint2fmpq_poly_interpolate_fmpz_vec poly xs ys n Sets poly; to the unique interpolating polynomial of degree at most n - 1 satisfying  f(x_i) = y_i for every pair x_i, y_i in xs and ys. It is assumed that the x values are distinct.Flint2_fmpq_poly_interpolate_fmpz_vec poly den xs ys n Sets poly / den; to the unique interpolating polynomial of degree at most n - 1 satisfying  f(x_i) = y_i for every pair x_i, y_i in xs and ys. The vector poly must have room for n+1 coefficients, even if the interpolating polynomial is shorter. Aliasing of poly or den) with any other argument is not allowed.It is assumed that the x values are distinct.This function uses a simple O(n^2) implementation of Lagrange interpolation, clearing denominators to avoid working with fractions. It is currently not designed to be efficient for large n.Flint2fmpq_poly_evaluate_fmpq res poly a Evaluates the polynomial poly at the rational a and sets res to the result.Flint2_fmpq_poly_evaluate_fmpq rnum rden poly den len anum aden Evaluates the polynomial (poly, den, len) at the rational  (anum, aden) and sets  (rnum, rden)2 to the result in lowest terms. Aliasing between  (rnum, rden) and  (anum, aden) is not supported.Flint2fmpq_poly_evaluate_fmpz res poly a Evaluates the polynomial poly at the integer a and sets res to the result.Flint2_fmpq_poly_evaluate_fmpz rnum rden poly den len a Evaluates the polynomial (poly, den, len) at the integer a and sets  (rnum, rden) to the result in lowest terms.Flint2fmpq_poly_gegenbauer_c poly n a Sets poly to the Gegenbauer (ultraspherical) polynomial (C^{(alpha)}_n(x) = frac{(2alpha)_n}{n!}{}_2F_1left(-n,2alpha+n; alpha+frac12;frac{1-x}{2}right)), for integer n\ge0 and rational \alpha>0. The coefficients are calculated using a hypergeometric recurrence.Flint2_fmpq_poly_gegenbauer_c coeffs den n a Sets coeffs to the coefficient array of the Gegenbauer (ultraspherical) polynomial (C^{(alpha)}_n(x) = frac{(2alpha)_n}{n!}{}_2F_1left(-n,2alpha+n; alpha+frac12;frac{1-x}{2}right)), for integer n\ge0 and rational \alpha>0. Sets den to the overall denominator. The coefficients are calculated using a hypergeometric recurrence.Flint2fmpq_poly_laguerre_l poly n Sets poly to the Laguerre polynomial L_n(x), defined by 1(n+1) L_{n+1}(x) = (2n+1-x) L_n(x) - n L_{n-1}(x), for n\ge0. The coefficients are calculated using a hypergeometric recurrence.Flint2_fmpq_poly_laguerre_l coeffs den n Sets coeffs6 to the coefficient array of the Laguerre polynomial L_n(x), defined by 1(n+1) L_{n+1}(x) = (2n+1-x) L_n(x) - n L_{n-1}(x), for n\ge0. Sets den to the overall denominator. The coefficients are calculated using a hypergeometric recurrence. The length of the array will be n+1.Flint2fmpq_poly_legendre_p poly n Sets poly to the Legendre polynomial P_n(x), defined by 1(n+1) P_{n+1}(x) = (2n+1) x P_n(x) - n P_{n-1}(x), for n\ge0. The coefficients are calculated using a hypergeometric recurrence. To improve performance, the common denominator is computed in one step and the coefficients are evaluated using integer arithmetic. The denominator is given by \gcd(n!,2^n) = 2^{\lfloor n/2 \rfloor + \lfloor n/4 \rfloor + \ldots}. See  fmpz_poly& for the shifted Legendre polynomials.Flint2_fmpq_poly_legendre_p coeffs den n Sets coeffs6 to the coefficient array of the Legendre polynomial P_n(x), defined by 1(n+1) P_{n+1}(x) = (2n+1) x P_n(x) - n P_{n-1}(x), for n\ge0. Sets den to the overall denominator. The coefficients are calculated using a hypergeometric recurrence. The length of the array will be n+1. To improve performance, the common denominator is computed in one step and the coefficients are evaluated using integer arithmetic. The denominator is given by \gcd(n!,2^n) = 2^{\lfloor n/2 \rfloor + \lfloor n/4 \rfloor + \ldots}. See  fmpz_poly& for the shifted Legendre polynomials.Flint2fmpq_poly_tanh_series res f n Sets res6 to the series expansion of the hyperbolic tangent of f to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_tanh_series g gden f fden flen n Sets  (g, gden, n)7 to the series expansion of the hyperbolic tangent of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 0. Does not support aliasing between the input and output polynomials.Flint2fmpq_poly_sinh_cosh_series res1 res2 f n Sets res13 to the series expansion of the hyperbolic sine of f to order n > 0, and res2= to the series expansion of the hyperbolic cosine. Requires f to have constant term 0.Flint2_fmpq_poly_sinh_cosh_series s sden c cden f fden flen n Sets  (s, sden, n)4 to the series expansion of the hyperbolic sine of (f, fden, flen), and  (c, cden, n)< to the series expansion of the hyperbolic cosine. Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.Flint2fmpq_poly_cosh_series res f n Sets res5 to the series expansion of the hyperbolic cosine of f to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_cosh_series g gden f fden flen n Sets  (g, gden, n)6 to the series expansion of the hyperbolic cosine of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 0. Does not support aliasing between the input and output polynomials.Flint2fmpq_poly_sinh_series res f n Sets res3 to the series expansion of the hyperbolic sine of f to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_sinh_series g gden f fden flen n Sets  (g, gden, n)4 to the series expansion of the hyperbolic sine of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 0. Does not support aliasing between the input and output polynomials.Flint2fmpq_poly_sin_cos_series res1 res2 f n Sets res1( to the series expansion of the sine of f to order n > 0, and res21 to the series expansion of the cosine. Requires f to have constant term 0.Flint2_fmpq_poly_sin_cos_series s sden c cden f fden flen n Sets  (s, sden, n)) to the series expansion of the sine of (f, fden, flen), and  (c, cden, n)1 to the series expansion of the cosine. Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.Flint2fmpq_poly_cos_series res f n Sets res* to the series expansion of the cosine of f to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_cos_series g gden f fden flen n Sets  (g, gden, n)+ to the series expansion of the cosine of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.Flint2fmpq_poly_sin_series res f n Sets res( to the series expansion of the sine of f to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_sin_series g gden f fden flen n Sets  (g, gden, n)) to the series expansion of the sine of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.Flint2fmpq_poly_tan_series res f n Sets res4 to the series expansion of the tangent function of f to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_tan_series g gden f fden flen n Sets  (g, gden, n)5 to the series expansion of the tangent function of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 0. Does not support aliasing between the input and output polynomials.Flint2fmpq_poly_asinh_series res f n Sets res; to the series expansion of the inverse hyperbolic sine of f to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_asinh_series g gden f fden flen n Sets  (g, gden, n)< to the series expansion of the inverse hyperbolic sine of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.Flint2fmpq_poly_asin_series res f n Sets res0 to the series expansion of the inverse sine of f to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_asin_series g gden f fden flen n Sets  (g, gden, n)1 to the series expansion of the inverse sine of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.Flint2fmpq_poly_atanh_series res f n Sets res? to the series expansion of the inverse hyperbolic tangent of f to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_atanh_series g gden f fden flen n Sets  (g, gden, n)? to the series expansion of the inverse hyperbolic tangent of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.Flint2fmpq_poly_atan_series res f n Sets res3 to the series expansion of the inverse tangent of f to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_atan_series g gden f fden flen n Sets  (g, gden, n)4 to the series expansion of the inverse tangent of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 0. Supports aliasing between the input and output polynomials.Flint2fmpq_poly_exp_expinv_series res1 res2 h n  The same as fmpq_poly_exp_series3, but simultaneously computes the exponential (in res1%) and its multiplicative inverse (in res2).Flint2_fmpq_poly_exp_expinv_series res1 res1den res2 res2den h hden hlen n  The same as fmpq_poly_exp_series3, but simultaneously computes the exponential (in res1, res1den&) and its multiplicative inverse (in res2, res2den?). Supports aliasing between the input and output polynomials.Flint2fmpq_poly_exp_series res h n Sets res8 to the series expansion of the exponential function of h to order n > 0 . Requires f to have constant term 0.Flint2_fmpq_poly_exp_series g gden h hden hlen n Sets  (g, gden, n)9 to the series expansion of the exponential function of (h, hden, hlen) . Assumes n > 0, hlen > 0 and that (h, hden, hlen) has constant term 0. Supports aliasing between the input and output polynomials.Flint2fmpq_poly_log_series res f n Sets res- to the series expansion of the logarithm of f to order n > 0 . Requires f to have constant term 1.Flint2_fmpq_poly_log_series g gden f fden flen n Sets  (g, gden, n). to the series expansion of the logarithm of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 1. Supports aliasing between the input and output polynomials.Flint2fmpq_poly_power_sums_to_poly res Q 8Compute the monic polynomial from its power sums series Q.Flint2!fmpq_poly_power_sums_to_fmpz_poly res Q Compute the integer polynomial with content one and positive leading coefficient given by its power sums series Q.Flint2_fmpq_poly_power_sums_to_poly res poly den len >Compute an integer polynomial given by its power sums series (poly,den,len).Flint2fmpq_poly_power_sums res poly n Compute the (truncated) power sum series of the monic polynomial poly up to length n using Newton identities. That is the power series whose coefficient of degree i is the sum of the i4-th power of all (complex) roots of the polynomial poly.Flint2_fmpq_poly_power_sums res rden poly len n  0 . Requires f to have constant term 1.Flint2_fmpq_poly_invsqrt_series g gden f fden flen n Sets  (g, gden, n)8 to the series expansion of the inverse square root of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 1. Does not support aliasing between the input and output polynomials.Flint2fmpq_poly_sqrt_series res f n Sets res/ to the series expansion of the square root of f to order n > 1 . Requires f to have constant term 1.Flint2_fmpq_poly_sqrt_series g gden f fden flen n Sets  (g, gden, n)0 to the series expansion of the square root of (f, fden, flen) . Assumes n > 0 and that (f, fden, flen) has constant term 1. Does not support aliasing between the input and output polynomials.Flint2fmpq_poly_integral res poly Sets res to the integral of poly. The constant term is set to zero. In particular, the integral of the zero polynomial is the zero polynomial.Flint2_fmpq_poly_integral rpoly rden poly den len Sets (rpoly, rden, len) to the integral of (poly, den, len - 1) . Assumes len >= 0. Supports aliasing between the two polynomials. The output will be in canonical form if the input is in canonical form.Flint2fmpq_poly_nth_derivative res poly n Sets res to the nth derivative of poly.Flint2_fmpq_poly_nth_derivative rpoly rden poly den n len Sets (rpoly, rden, len - n) to the nth derivative of (poly, den, len). Does nothing if len <= n1. Supports aliasing between the two polynomials.Flint2fmpq_poly_derivative res poly Sets res to the derivative of poly.Flint2_fmpq_poly_derivative rpoly rden poly den len Sets (rpoly, rden, len - 1) to the derivative of (poly, den, len). Does nothing if len <= 11. Supports aliasing between the two polynomials.Flint2fmpq_poly_resultant_div r f g div nbits Returns the resultant of f and g divided by div3 under the assumption that the result has at most nbits& bits. The result must be an integer.Flint2fmpq_poly_resultant r f g Returns the resultant of f and g.Enumerating the roots of f and g over \bar{\mathbf{Q}} as r_1, \dotsc, r_m and s_1, \dotsc, s_n, respectively, and letting x and y> denote the leading coefficients, the resultant is defined as` ?x^{\deg(f)} y^{\deg(g)} \prod_{1 \leq i, j \leq n} (r_i - s_j).We handle special cases as follows: if one of the polynomials is zero, the resultant is zero. Note that otherwise if one of the polynomials is constant, the last term in the above expression is the empty product.Flint2_fmpq_poly_resultant rnum rden poly1 den1 len1 poly2 den2 len2 Sets  (rnum, rden)/ to the resultant of the two input polynomials. Assumes that len1 >= len2 > 0. Does not support zero-padding of the input polynomials. Does not support aliasing of the input and output arguments.Flint2 fmpq_poly_lcm L A B )Computes the monic least common multiple L of A and B.In the special case when  A = B = 0, sets L = 0.Flint2_fmpq_poly_lcm L denL A lenA B lenB )Computes the monic least common multiple L of A and B. Assumes that L has space for 1\operatorname{len}(A) + \operatorname{len}(B) - 1 coefficients, where 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0.Aliasing between the output and input arguments is not supported.Does not support zero-padding.Flint2fmpq_poly_xgcd G S T A B Computes polynomials G, S, and T such that G = \gcd(A, B) = S A + T B, where G* is the monic greatest common divisor of A and B.(Corner cases are handled as follows. If  A = B = 0 , returns  G = S = T = 0. If A \neq 0, B = 0+, returns the suitable scalar multiple of G = A, S = 1, and T = 0. The case when A = 0, B \neq 0 is handled similarly.Flint2_fmpq_poly_xgcd G denG S denS T denT A denA lenA B denB lenB Computes polynomials G, S, and T such that G = \gcd(A, B) = S A + T B, where G* is the monic greatest common divisor of A and B. Assumes that G, S, and T have space for \operatorname{len}(B), \operatorname{len}(B), and \operatorname{len}(A)< coefficients, respectively, where it is also assumed that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0.5Does not support zero padding of the input arguments.Flint2 fmpq_poly_gcd G A B +Computes the monic greatest common divisor G of A and B.In the the special case when  A = B = 0, sets G = 0.Flint2_fmpq_poly_gcd G denG A lenA B lenB +Computes the monic greatest common divisor G of A and B. Assumes that G has space for \operatorname{len}(B) coefficients, where 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0.Aliasing between the output and input arguments is not supported.Does not support zero-padding.Flint2fmpq_poly_div_series Q A B n "Performs power series division in \mathbb{Q}[[x]] / (x^n)*. The function considers the polynomials A and B as power series of length~`n` starting with the constant terms. The function assumes that B has non-zero constant term and n \geq 1.Flint2_fmpq_poly_div_series Q denQ A denA lenA B denB lenB n Divides (A, denA, lenA) by (B, denB, lenB) as power series over  \mathbb{Q} , assuming B? has non-zero constant term and that all lengths are positive.Aliasing is not supported.This function ensures that the numerator and denominator are coprime on exit.Flint2fmpq_poly_inv_series res poly n Computes the first n& terms of the inverse power series of poly, assuming that poly has non-zero constant term and n \geq 1.Flint2_fmpq_poly_inv_series rpoly rden poly den n Computes the first n' terms of the inverse power series of (poly, den, len).)The result is produced in canonical form. Assumes that n \geq 1 and that poly8 has non-zero constant term. Does not support aliasing.Flint2fmpq_poly_inv_series_newton res poly n Computes the first n& terms of the inverse power series of poly( using Newton iteration, assuming that poly! has non-zero constant term and n \geq 1.Flint2_fmpq_poly_inv_series_newton rpoly rden poly den len n Computes the first n' terms of the inverse power series of (poly, den, len) using Newton iteration.)The result is produced in canonical form. Assumes that n \geq 1 and that poly8 has non-zero constant term. Does not support aliasing.Flint2fmpq_poly_remove q poly1 poly2 Sets q to the quotient of poly1 by the highest power of poly27 which divides it, and returns the power. The divisor poly21 must not be constant or an exception is raised.Flint2fmpq_poly_divides q poly1 poly2 Return 1 if poly2 divides poly1 and set q$ to the quotient. Otherwise return 0.Flint2_fmpq_poly_divides qpoly qden poly1 den1 len1 poly2 den2 len2 Return 1 if (poly2, den2, len2) divides (poly1, den1, len1) and set (qpoly, qden, len1 - len2 + 1)$ to the quotient. Otherwise return 0. Requires that qpoly has space for len1 - len2 + 1 coefficients and that len1 >= len2 > 0.Flint2fmpq_poly_rem_powers_precomp R A B B_inv Set R to the remainder of A divide B given precomputed powers mod B provided by fmpq_poly_powers_precompute. This function is only faster if A->length <= 2*B->length - 1.The output of this function is not canonicalised.Flint2_fmpq_poly_rem_powers_precomp A denA m B denB n powers Set A to the remainder of A divide B given precomputed powers mod B provided by _fmpq_poly_powers_precompute. No aliasing is allowed. This function is only faster if m \leq 2*n - 1.The output of this function is not canonicalised.Flint2fmpq_poly_powers_clear pinv Clean up resources used by precomputed powers which have been computed by fmpq_poly_powers_precompute.Flint2_fmpq_poly_powers_clear powers len Clean up resources used by precomputed powers which have been computed by _fmpq_poly_powers_precompute.Flint2fmpq_poly_powers_precompute pinv poly  Computes  2*len - 1 powers of $x$ modulo the polynomial $B$ of the given length. This is used as a kind of precomputed inverse in the remainder routine below.Flint2_fmpq_poly_powers_precompute B denB len  Computes  2*len - 1 powers of x modulo the polynomial B of the given length. This is used as a kind of precomputed inverse in the remainder routine below.Flint2 fmpq_poly_rem R poly1 poly2 Finds the remainder R of the Euclidean division of poly1 by poly2.Flint2_fmpq_poly_rem R r A a lenA B b lenB inv Finds the remainder (R, r) of the Euclidean division of (A, a) by (B, b). Assumes that lenA >= lenB > 0;. Supports no aliasing between the inputs and the outputs.>An optional precomputed inverse of the leading coefficient of B from fmpz_preinvn_init can be supplied. Otherwise inv should be NULL.Flint2 fmpq_poly_div Q poly1 poly2 Finds the quotient Q and remainder R of the Euclidean division of poly1 by poly2.Flint2_fmpq_poly_div Q q A a lenA B b lenB inv Finds the quotient (Q, q) of the Euclidean division of (A, a) by (B, b). Assumes that lenA >= lenB > 0;. Supports no aliasing between the inputs and the outputs.>An optional precomputed inverse of the leading coefficient of B from fmpz_preinvn_init can be supplied. Otherwise inv should be NULL.Flint2fmpq_poly_divrem Q R poly1 poly2 Finds the quotient Q and remainder R of the Euclidean division of poly1 by poly2.Flint2_fmpq_poly_divrem Q q R r A a lenA B b lenB inv Finds the quotient (Q, q) and remainder (R, r) of the Euclidean division of (A, a) by (B, b). Assumes that lenA >= lenB > 0. Assumes that R has space for lenA) coefficients, although only the bottom lenB - 1 will carry meaningful data on exit. Supports no aliasing between the two outputs, or between the inputs and the outputs.>An optional precomputed inverse of the leading coefficient of B from fmpz_preinvn_init can be supplied. Otherwise inv should be NULL.Flint2fmpq_poly_shift_right res poly n Set res to poly shifted right by n coefficients. If n4 is equal to or greater than the current length of poly, res is set to the zero polynomial.Flint2fmpq_poly_shift_left res poly n Set res to poly shifted left by n/ coefficients. Zero coefficients are inserted.Flint2fmpq_poly_pow_trunc res poly e n Sets res to poly^e truncated to length n.Flint2_fmpq_poly_pow_trunc res rden f fden flen exp len Sets (rpoly, rden, len) to  (poly, den)^e truncated to length len , where len is at most e * (flen - 1) + 1.Flint2 fmpq_poly_pow res poly e Sets res to poly^e, where the only special case 0^0 is defined as 1.Flint2_fmpq_poly_pow rpoly rden poly den len e Sets  (rpoly, rden) to  (poly, den)^e , assuming  e, len > 0. Assumes that rpoly is an array of length at least e * (len - 1) + 1. Supports aliasing of  (rpoly, den) and  (poly, den).Flint2fmpq_poly_submul rop op1 op2 Subtracts the product of op1 and op2 from rop.Flint2fmpq_poly_addmul rop op1 op2 Adds the product of op1 and op2 to rop.Flint2fmpq_poly_mullow res poly1 poly2 n Sets res to the product of poly1 and poly2, truncated to length~`n`.Flint2_fmpq_poly_mullow rpoly rden poly1 den1 len1 poly2 den2 len2 n Sets (rpoly, rden, n) to the low n coefficients of  (poly1, den1) and  (poly2, den2)8. The output is not guaranteed to be in canonical form.Assumes len1 >= len2 > 0 and 0 < n <= len1 + len2 - 1. Allows for zero-padding in the inputs. Does not allow aliasing between the inputs and outputs.Flint2 fmpq_poly_mul res poly1 poly2 Sets res to the product of poly1 and poly2.Flint2_fmpq_poly_mul rpoly rden poly1 den1 len1 poly2 den2 len2 Sets (rpoly, rden, len1 + len2 - 1) to the product of (poly1, den1, len1) and (poly2, den2, len2). If the input is provided in canonical form, then so is the output.Assumes len1 >= len2 > 0. Allows zero-padding in the input. Does not allow aliasing between the inputs and outputs.Flint2fmpq_poly_scalar_div_si rop op c Sets rop to op divided by the scalar c.Flint2_fmpq_poly_scalar_div_fmpq rpoly rden poly den len r s Sets (rpoly, rden, len) to (poly, den, len) divided by r/s, in lowest terms. Assumes that len is positive. Assumes that r/s= is non-zero and in lowest terms. Supports aliasing between  (rpoly, rden) and  (poly, den). The fmpz_t's r and s may not be part of  (rpoly, poly).Flint2_fmpq_poly_scalar_div_ui rpoly rden poly den len c Sets (rpoly, rden, len) to (poly, den, len) divided by c, in lowest terms. Assumes that len is positive. Assumes that c) is non-zero. Supports aliasing between  (rpoly, rden) and  (poly, den).Flint2_fmpq_poly_scalar_div_si rpoly rden poly den len c Sets (rpoly, rden, len) to (poly, den, len) divided by c, in lowest terms. Assumes that len is positive. Assumes that c) is non-zero. Supports aliasing between  (rpoly, rden) and  (poly, den).Flint2_fmpq_poly_scalar_div_fmpz rpoly rden poly den len c Sets (rpoly, rden, len) to (poly, den, len) divided by c, in lowest terms. Assumes that len is positive. Assumes that c) is non-zero. Supports aliasing between  (rpoly, rden) and  (poly, den). Assumes that c is not part of  (rpoly, rden).Flint2fmpq_poly_scalar_mul_fmpq rop op c Sets rop to c times op.Flint2fmpq_poly_scalar_mul_fmpz rop op c Sets rop to c times op. Assumes that the fmpz_t c is not part of rop.Flint2fmpq_poly_scalar_mul_ui rop op c Sets rop to c times op.Flint2fmpq_poly_scalar_mul_si rop op c Sets rop to c times op.Flint2_fmpq_poly_scalar_mul_fmpq rpoly rden poly den len r s Sets  (rpoly, rden) to the product of r/s and (poly, den, len), in lowest terms. Assumes that (poly, den, len) and r/s- are provided in lowest terms. Assumes that rpoly is an array of length len. Supports aliasing of  (rpoly, den) and  (poly, den). The fmpz_t's r and s may not be part of  (rpoly, rden).Flint2_fmpq_poly_scalar_mul_fmpz rpoly rden poly den len c Sets (rpoly, rden, len) to the product of c of (poly, den, len).If the input is normalised, then so is the output, provided it is non-zero. If the input is in lowest terms, then so is the output. However, even if neither of these conditions are met, the result will be (mathematically) correct. Supports exact aliasing between  (rpoly, den) and  (poly, den).Flint2_fmpq_poly_scalar_mul_ui rpoly rden poly den len c Sets (rpoly, rden, len) to the product of c of (poly, den, len).If the input is normalised, then so is the output, provided it is non-zero. If the input is in lowest terms, then so is the output. However, even if neither of these conditions are met, the result will be (mathematically) correct. Supports exact aliasing between  (rpoly, den) and  (poly, den).Flint2_fmpq_poly_scalar_mul_si rpoly rden poly den len c Sets (rpoly, rden, len) to the product of c of (poly, den, len).If the input is normalised, then so is the output, provided it is non-zero. If the input is in lowest terms, then so is the output. However, even if neither of these conditions are met, the result will be (mathematically) correct. Supports exact aliasing between  (rpoly, den) and  (poly, den).Flint2fmpq_poly_sub_series_can res poly1 poly2 n can As per fmpq_poly_sub_can: but the inputs are first notionally truncated to length n.Flint2fmpq_poly_sub_series res poly1 poly2 n As per  fmpq_poly_sub: but the inputs are first notionally truncated to length n.Flint2_fmpq_poly_sub_series_can rpoly rden poly1 den1 len1 poly2 den2 len2 n can As per _fmpq_poly_sub_can: but the inputs are first notionally truncated to length n. If n is less than len1 or len2' then the output only needs space for n coefficients. We require n \geq 0.Flint2_fmpq_poly_sub_series rpoly rden poly1 den1 len1 poly2 den2 len2 n As per _fmpq_poly_sub: but the inputs are first notionally truncated to length n. If n is less than len1 or len2' then the output only needs space for n coefficients. We require n \geq 0.Flint2fmpq_poly_sub_can res poly1 poly2 can As per _fmpq_poly_sub except that one can specify whether to canonicalise the output or not. This function is intended to be used with weak canonicalisation to prevent explosion in memory usage. It exists for performance reasons.Flint2 fmpq_poly_sub res poly1 poly2 Sets res to the difference of poly1 and poly2, using Henrici's algorithm.Flint2_fmpq_poly_sub_can rpoly rden poly1 den1 len1 poly2 den2 len2 can As per _fmpq_poly_sub except that one can specify whether to canonicalise the output or not. This function is intended to be used with weak canonicalisation to prevent explosion in memory usage. It exists for performance reasons.Flint2_fmpq_poly_sub rpoly rden poly1 den1 len1 poly2 den2 len2 Forms the difference  (rpoly, rden) of (poly1, den1, len1) and (poly2, den2, len2)), placing the result into canonical form. Assumes that rpoly& is an array of length the maximum of len1 and len2. The input operands are assumed to be in canonical form and are also allowed to be of length~`0`. (rpoly, rden) and (poly1, den1, len1) may be aliased, but  (rpoly, rden) and (poly2, den2, len2) may not be aliased.Flint2fmpq_poly_add_series_can res poly1 poly2 n can As per fmpq_poly_add_can: but the inputs are first notionally truncated to length n.Flint2fmpq_poly_add_series res poly1 poly2 n As per  fmpq_poly_add: but the inputs are first notionally truncated to length n.Flint2_fmpq_poly_add_series_can rpoly rden poly1 den1 len1 poly2 den2 len2 n can As per _fmpq_poly_add_can: but the inputs are first notionally truncated to length n. If n is less than len1 or len2' then the output only needs space for n coefficients. We require n \geq 0.Flint2_fmpq_poly_add_series rpoly rden poly1 den1 len1 poly2 den2 len2 n As per _fmpq_poly_add: but the inputs are first notionally truncated to length n. If n is less than len1 or len2' then the output only needs space for n coefficients. We require n \geq 0.Flint2fmpq_poly_add_can res poly1 poly2 can As per  fmpq_poly_add except that one can specify whether to canonicalise the output or not. This function is intended to be used with weak canonicalisation to prevent explosion in memory usage. It exists for performance reasons.Flint2 fmpq_poly_add res poly1 poly2 Sets res to the sum of poly1 and poly2, using Henrici's algorithm.Flint2_fmpq_poly_add_can rpoly rden poly1 den1 len1 poly2 den2 len2 can As per _fmpq_poly_add except that one can specify whether to canonicalise the output or not. This function is intended to be used with weak canonicalisation to prevent explosion in memory usage. It exists for performance reasons.Flint2_fmpq_poly_add rpoly rden poly1 den1 len1 poly2 den2 len2 Forms the sum  (rpoly, rden) of (poly1, den1, len1) and (poly2, den2, len2)), placing the result into canonical form. Assumes that rpoly& is an array of length the maximum of len1 and len2. The input operands are assumed to be in canonical form and are also allowed to be of length~`0`. (rpoly, rden) and  (poly1, den1) may be aliased, but  (rpoly, rden) and  (poly2, den2) may not be aliased.Flint2fmpq_poly_is_gen poly Returns 1 if poly is the degree 1 polynomial x, otherwise returns 0.Flint2fmpq_poly_is_zero poly Returns 1 if poly+ is the zero polynomial, otherwise returns 0.Flint2fmpq_poly_is_one poly Returns 1 if poly4 is the constant polynomial~`1`, otherwise returns 0.Flint2 fmpq_poly_cmp left right Compares the two polynomials left and right.Compares the two polynomials left and right , returning -1, 0, or 1 as left* is less than, equal to, or greater than right. The comparison is first done by the degree, and then, in case of a tie, by the individual coefficients from highest to lowest.Flint2_fmpq_poly_cmp lpoly lden rpoly rden len Compares two non-zero polynomials, assuming they have the same length len > 0.>The polynomials are expected to be provided in canonical form.Flint2fmpq_poly_equal_trunc poly1 poly2 n Return 1 if poly1 and poly2 notionally truncated to length n# are equal, otherwise returns~`0`.Flint2_fmpq_poly_equal_trunc poly1 den1 len1 poly2 den2 len2 n Return 1 if poly1 and poly2 notionally truncated to length n# are equal, otherwise returns~`0`.Flint2fmpq_poly_equal poly1 poly2 Returns 1 if poly1 is equal to poly2, otherwise returns~`0`.Flint2fmpq_poly_set_coeff_fmpq poly n x  Sets the n`th coefficient in poly to the rational :math:`x.Flint2fmpq_poly_set_coeff_fmpz poly n x  Sets the n`th coefficient in poly to the integer :math:`x.Flint2fmpq_poly_set_coeff_ui poly n x  Sets the n`th coefficient in poly to the integer :math:`x.Flint2fmpq_poly_set_coeff_si poly n x  Sets the n`th coefficient in poly to the integer :math:`x.Flint2fmpq_poly_get_coeff_fmpq x poly n Retrieves the n`th coefficient of poly`, in lowest terms.Flint2fmpq_poly_get_coeff_fmpz x poly n Retrieves the %n`th coefficient of the numerator of poly`.Flint2fmpq_poly_reverse res poly n 'This function considers the polynomial poly to be of length n, notionally truncating and zero padding if required, and reverses the result. Since the function normalises its result res may be of length less than n.Flint2fmpq_poly_get_slice rop op i j )Returns the slice with coefficients from x^i (including) to x^j (excluding).Flint2fmpq_poly_set_trunc res poly n Sets res to a copy of poly, truncated to length n.Flint2fmpq_poly_truncate poly n If the current length of poly is greater than n, it is truncated to the given length. Discarded coefficients are demoted, but they are not necessarily set to zero.Flint2fmpq_poly_swap poly1 poly2 "Efficiently swaps the polynomials poly1 and poly2.Flint2 fmpq_poly_inv poly1 poly2 Sets poly1" to the multiplicative inverse of poly2 if possible. Otherwise, if poly2 is not a unit, leaves poly1 unmodified and calls abort.Flint2 fmpq_poly_neg poly1 poly2 Sets poly1 to the additive inverse of poly2.Flint2 fmpq_poly_one poly Sets poly to the constant polynomial 1.Flint2fmpq_poly_zero poly Sets poly to zero.Flint2fmpq_poly_get_str_pretty poly var %Returns the pretty representation of poly$, using the null-terminated string var not equal to "\0" as the variable name.Flint2fmpq_poly_get_str poly %Returns the string representation of poly.Flint2fmpq_poly_set_str poly str Sets poly< to the polynomial specified by the null-terminated string str8. The input format is the same as the output format of fmpq_poly_get_str: the length given as a decimal integer, then two spaces, then the list of coefficients separated by one space.The result is only guaranteed to be in canonical form if all coefficients in the input string are in lowest terms.Returns 0 if no error occurred. Otherwise, returns -1 in which case the resulting value of poly is set to zero. If str is not null-terminated, calling this method might result in a segmentation fault.Flint2_fmpq_poly_set_str poly den str len Sets  (poly, den)< to the polynomial specified by the null-terminated string str of len coefficients. The input format is a sequence of coefficients separated by one space.The result is only guaranteed to be in lowest terms if all coefficients in the input string are in lowest terms.Returns 0 if no error occurred. Otherwise, returns -1 in which case the resulting value of  (poly, den) is undefined. If str is not null-terminated, calling this method might result in a segmentation fault.Flint2fmpq_poly_get_nmod_poly_den rop op den Sets the coefficients of rop, to the coefficients in the denominator of op, reduced by the modulus of rop. If den == 1, the result is multiplied by the inverse of the denominator of op. In this case it is assumed that the reduction of the denominator of op is invertible.Flint2fmpq_poly_get_nmod_poly rop op Sets the coefficients of rop+ to the coefficients in the denominator ofop, reduced by the modulus of rop. The result is multiplied by the inverse of the denominator of op:. It is assumed that the reduction of the denominator of op is invertible.Flint2fmpq_poly_set_nmod_poly rop op Sets the coefficients of rop to the residues in op, normalised to the interval -m/2 \le r < m/2 where m is the modulus.Flint2fmpq_poly_set_fmpz_poly rop op Sets the rational polynomial rop. to the same value as the integer polynomial op.Flint2fmpq_poly_set_fmpq poly x Sets poly to the rational x0, which is assumed to be given in lowest terms.Flint2fmpq_poly_set_fmpz poly x Sets poly to the integer x.Flint2fmpq_poly_set_ui poly x Sets poly to the integer x.Flint2fmpq_poly_set_si poly x Sets poly to the integer x.Flint2 fmpq_poly_set poly1 poly2 Sets poly1 to equal poly2.Flint2fmpq_poly_randtest_not_zero f state len bits As for fmpq_poly_randtest except that len and bits may not be zero and the polynomial generated is guaranteed not to be the zero polynomial. One must call flint_randinit before calling this function.Flint2fmpq_poly_randtest_unsigned f state len bits Sets f to a random polynomial with coefficients up to the given length and where each coefficient has up to the given number of bits. One must call flint_randinit before calling this function.Flint2fmpq_poly_randtest f state len bits Sets f to a random polynomial with coefficients up to the given length and where each coefficient has up to the given number of bits. The coefficients are signed randomly. One must call flint_randinit before calling this function.Flint2fmpq_poly_get_denominator den poly Sets res to the denominator of poly.Flint2fmpq_poly_get_numerator res poly Sets res to the numerator of poly!, e.g. the primitive part as an  fmpz_poly_t if it is in canonical form .Flint2fmpq_poly_length poly Returns the length of poly.Flint2fmpq_poly_degree poly Returns the degree of poly+, which is one less than its length, as a slong.Flint2fmpq_poly_is_canonical poly 4Returns whether the polynomial is in canonical form.Flint2_fmpq_poly_is_canonical poly den len 4Returns whether the polynomial is in canonical form.Flint2fmpq_poly_canonicalise poly Puts the polynomial poly into canonical form. Firstly, the length is set to the actual length of the numerator polynomial. For non-zero polynomials, it is then ensured that the numerator and denominator are coprime and that the denominator is positive. The canonical form of the zero polynomial is a zero numerator polynomial and a one denominator.Flint2_fmpq_poly_canonicalise poly den len Puts  (poly, den) of length len into canonical form.It is assumed that the array poly( contains a non-zero entry in position len - 1 whenever len > 0. Assumes that den is non-zero.Flint2_fmpq_poly_normalise poly Sets the length of poly so that the top coefficient is non-zero. If all coefficients are zero, the length is set to zero. Note that this function does not guarantee the coprimality of the numerator polynomial and the integer denominator.Flint2fmpq_poly_clear poly Clears the given polynomial, releasing any memory used. The polynomial must be reinitialised in order to be used again.Flint2_fmpq_poly_set_length poly len /Sets the length of the numerator polynomial to len, demoting coefficients beyond the new length. Note that this method does not guarantee that the rational polynomial is in canonical form.Flint2fmpq_poly_fit_length poly len If len is greater than the number of coefficients currently allocated, then the polynomial is reallocated to have space for at least len coefficients. No data is lost when calling this function. The function efficiently deals with the case where  fit_length is called many times in small increments by at least doubling the number of allocated coefficients when len is larger than the number of coefficients currently allocated.Flint2fmpq_poly_realloc poly alloc 3Reallocates the given polynomial to have space for alloc coefficients. If alloc is zero then the polynomial is cleared and then reinitialised. If the current length is greater than alloc then poly is first truncated to length alloc. Note that this might leave the rational polynomial in non-canonical form.Flint2fmpq_poly_init2 poly alloc 3Initialises the polynomial with space for at least alloc/ coefficients and set the length to zero. The alloc# coefficients are all set to zero.Flint2fmpq_poly_init poly >Initialises the polynomial for use. The length is set to zero.Flint2fmpq_poly_numref poly coeffs.Flint2fmpq_poly_denref poly ,Returns a reference to the denominator as a fmpz_t8. The integer is guaranteed to be properly initialised.2This function is implemented as a macro returning  (poly)->den.Flint2fmpq_poly_print poly Prints the polynomial to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value. foreign import ccall "fmpq_poly.h fmpq_poly_print"Flint2fmpq_poly_print_pretty poly var $Prints the pretty representation of poly to stdout$, using the null-terminated string var not equal to "\0" as the variable name.1In the current implementation always returns~`1`., Safe-Inferred )*1 { Safe-Inferred )*1 c:Flint2_padic_poly_print poly val len ctx 1Prints a simple representation of the polynomial poly to stdout..In the current implementation, always returns 1.Flint2_padic_poly_fprint file poly val len ctx 1Prints a simple representation of the polynomial poly to the stream file.A non-zero polynomial is represented by the number of coefficients, two spaces, followed by a list of the coefficients, which are printed in a way depending on the print mode,In the  PADIC_TERSE9 mode, the coefficients are printed as rational numbers.The  PADIC_SERIES mode is currently not supported and will raise an abort signal.In the PADIC_VAL_UNIT1 mode, the coefficients are printed in the form p^v u.&The zero polynomial is represented by "0"..In the current implementation, always returns 1.Flint2padic_poly_debug poly Prints the data defining the p-adic polynomial poly3 in a simple format useful for debugging purposes..In the current implementation, always returns 1.Flint2padic_poly_compose_pow rop op k ctx Sets rop to the composition of op and the monomial x^k , where k \geq 1.#Note that no reduction takes place.Flint2_padic_poly_compose_pow rop rval N op val len k ctx Sets (rop, *rval, (len - 1)*k + 1) to the composition of (op, val, len) and the monomial x^k, where k \geq 1. Assumes that len is positive.;Supports aliasing between the input and output polynomials.Flint2padic_poly_compose rop op1 op2 ctx Sets rop to the composition of op1 and op2,, reducing the result in the given context.0To be clear about the order of composition, let f(X) and g(X) denote the polynomials op1 and op2, respectively. Then rop is set to f(g(X)).Flint2_padic_poly_compose rop rval N op1 val1 len1 op2 val2 len2 ctx Sets !(rop, *rval, (len1-1)*(len2-1)+1) to the composition of the two input polynomials, reducing the result modulo p^N. Assumes that len1 is non-zero.Does not support aliasing.Flint2_padic_poly_evaluate_padic u v N poly val len a b ctx  Sets the p -adic number y to poly evaluated at a , reduced in the given context..Suppose that the polynomial can be written as F(X) = p^w f(X) with \operatorname{ord}_p(f) = 1, that \operatorname{ord}_p(a) = b3 and that both are defined to precision~`N`. Then f is defined to precision N-w and so f(a) is defined to precision N-w when a is integral and  N-w+(n-1)b when b < 0 , where  n = \deg(f). Thus, y = F(a) is defined to precision N when a is integral and N+(n-1)b when b < 0.Flint2padic_poly_shift_right rop op n "Notationally, sets the polynomial rop to the polynomial op after floor division by x^n, where n \geq 0", ensuring the result is reduced.Flint2padic_poly_shift_left rop op n ctx "Notationally, sets the polynomial rop to the polynomial op multiplied by x^n, where n \geq 0, and reduces the result.Flint2padic_poly_derivative rop op ctx Sets rop to the derivative of op/, reducing the result modulo the precision of rop.Flint2_padic_poly_derivative rop rval N op val len ctx Sets  (rop, rval) to the derivative of  (op, val) reduced modulo p^N.9Supports aliasing of the input and the output parameters.Flint2padic_poly_inv_series g f n ctx "Computes the power series inverse g of f modulo X^n , where n \geq 1.Given the polynomial +f \in \mathbf{Q}[X] \subset \mathbf{Q}_p[X]$, there exists a unique polynomial f^{-1} \in \mathbf{Q}[X] such that  f f^{-1} = 1 modulo X^n. This function sets g to f^{-1} reduced modulo p^N.)Assumes that the constant coefficient of f is non-zero.Moreover, assumes that the valuation of the constant coefficient of f& is minimal among the coefficients of f.Note that the result g is zero if and only if  - \operatorname{ord}_p(f) \geq N.Flint2padic_poly_pow rop op e ctx Sets the polynomial rop to the polynomial op7 raised to the power~`e`, reduced to the precision in rop.In the special case e = 0, sets rop= to the constant polynomial one reduced to the precision of rop. Also note that when e = 1, this operation sets rop to op and then reduces rop.When the valuation of the input polynomial is negative, this results in a loss of p-adic precision. Suppose that the input polynomial is given to precision~`N` and has valuation~`v < 0`. The result then has valuation e v < 0# but is only correct to precision  N + (e - 1) v.Flint2_padic_poly_pow rop rval N op val len e ctx Sets the polynomial (rop, *rval, e (len - 1) + 1) to the polynomial (op, val, len) raised to the power~`e`. Assumes that e > 1 and len > 0.Does not support aliasing between the input and output arguments.Flint2padic_poly_mul res poly1 poly2 ctx Sets the polynomial res' to the product of the two polynomials poly1 and poly2, reduced modulo p^N.Flint2_padic_poly_mul rop rval N op1 val1 len1 op2 val2 len2 ctx Sets (rop, *rval, len1 + len2 - 1) to the product of (op1, val1, len1) and (op2, val2, len2).%Assumes that the resulting valuation *rval&, which is the sum of the valuations val1 and val21, is less than the precision~`N` of the context. Assumes that len1 >= len2 > 0.Flint2padic_poly_scalar_mul_padic rop op c ctx Sets the polynomial rop" to the product of the polynomial op and the p -adic number c, reducing the result modulo p^N.Flint2_padic_poly_scalar_mul_padic rop rval op val len c ctx Sets (rop, *rval, len) to (op, val, len) multiplied by the scalar c.The result will only be correctly reduced if the polynomial is non-zero. Otherwise, the array  (rop, len)( will be set to zero but the valuation *rval might be wrong.Flint2padic_poly_neg f g ctx Sets f to -g.Flint2padic_poly_sub f g h ctx Sets f to the difference g - h.Flint2_padic_poly_sub rop rval op1 val1 len1 op2 val2 len2 ctx Sets !(rop, *val, FLINT_MAX(len1, len2) to the difference of (op1, val1, len1) and (op2, val2, len2).Assumes that the input is reduced and guarantees that this is also the case for the output. Assumes that \min\{v_1, v_2\} < N.8Support aliasing between the output and input arguments.Flint2padic_poly_add f g h ctx Sets f to the sum g + h.Flint2_padic_poly_add rop rval N op1 val1 len1 N1 op2 val2 len2 N2 ctx Sets !(rop, *val, FLINT_MAX(len1, len2) to the sum of (op1, val1, len1) and (op2, val2, len2).Assumes that the input is reduced and guarantees that this is also the case for the output. Assumes that \min\{v_1, v_2\} < N.9Supports aliasing between the output and input arguments.Flint2padic_poly_is_one poly ctx Returns whether the polynomial poly is equal to the constant polynomial~`1`, taking the precision of the polynomial into account.Flint2padic_poly_is_zero poly Returns whether the polynomial poly is the zero polynomial.Flint2padic_poly_equal poly1 poly2 $Returns whether the two polynomials poly1 and poly2 are equal.Flint2padic_poly_set_coeff_padic f n c ctx Sets the coefficient of x^n in the polynomial f to c., reduced to the precision of the polynomial f.Note that this operation can take linear time in the length of the polynomial.Flint2padic_poly_get_coeff_padic c poly n ctx Sets c to the coefficient of x^n5 in the polynomial, reduced modulo the precision of c.Flint2padic_poly_swap poly1 poly2 Swaps the two polynomials poly1 and poly2, including their precisions..This is done efficiently by swapping pointers.Flint2padic_poly_one poly Sets poly to the constant polynomial 1., reduced to the precision of the polynomial.Flint2padic_poly_zero poly Sets poly to the zero polynomial.Flint2padic_poly_get_fmpq_poly rop op ctx Sets rop1 to the rational polynomial corresponding to the p-adic polynomial op.Flint2padic_poly_get_fmpz_poly rop op ctx Sets the integer polynomial rop to the value of the p-adic polynomial op and returns 1 if the polynomial is p(-adically integral. Otherwise, returns 0.Flint2padic_poly_set_fmpq_poly rop op ctx Sets the polynomial rop) to the value of the rational polynomial op., reduced to the precision of the polynomial.Flint2padic_poly_set_fmpz_poly rop op ctx Sets the polynomial rop to the integer polynomial op- reduced to the precision of the polynomial.Flint2padic_poly_set_fmpq poly x ctx Sets the polynomial poly to the value of the rational x., reduced to the precision of the polynomial.Flint2padic_poly_set_fmpz poly x ctx Sets the polynomial poly to the integer x- reduced to the precision of the polynomial.Flint2padic_poly_set_ui poly x ctx Sets the polynomial poly to the unsigned slong integer x- reduced to the precision of the polynomial.Flint2padic_poly_set_si poly x ctx Sets the polynomial poly to the  signed slong integer x- reduced to the precision of the polynomial.Flint2padic_poly_set poly1 poly2 ctx Sets the polynomial poly1 to the polynomial poly2, reduced to the precision of poly1.Flint2padic_poly_set_padic poly x ctx Sets the polynomial poly to the p -adic number x., reduced to the precision of the polynomial.Flint2padic_poly_randtest_val f state val len ctx Sets f* to a random polynomial of length at most len( with at most the prescribed valuation val and entries reduced modulo p^N.Specifically, we aim to set the valuation to be exactly equal to val, but do not check for additional cancellation when creating the coefficients.Flint2padic_poly_randtest_not_zero f state len ctx Sets f3 to a non-zero random polynomial of length at most len with entries reduced modulo p^N.Flint2padic_poly_prec poly (Returns the precision of the polynomial poly.Note that this is implemented as a macro and can be used as either a lvalue or a rvalue. IO CLongpadic_poly_randtest f state len ctx Sets f* to a random polynomial of length at most len with entries reduced modulo p^N.Flint2padic_poly_val poly (Returns the valuation of the polynomial poly, which is defined to be the minimum valuation of all its coefficients.,The valuation of the zero polynomial is~`0`.Note that this is implemented as a macro and can be used as either a lvalue or a rvalue.Flint2padic_poly_length poly %Returns the length of the polynomial poly.Flint2padic_poly_degree poly %Returns the degree of the polynomial poly.Flint2padic_poly_truncate poly n p /Truncates the polynomial to length at most~`n`.Flint2padic_poly_reduce poly ctx Reduces the polynomial poly modulo p^N1, assuming that it is in canonical form already.Flint2_padic_poly_canonicalise poly v len p Brings the polynomial poly into canonical form, assuming that it is normalised already. Does not carry out any reduction.Flint2_padic_poly_normalise poly Sets the length of poly so that the top coefficient is non-zero. If all coefficients are zero, the length is set to zero. This function is mainly used internally, as all functions guarantee normalisation.Flint2padic_poly_clear poly Clears the given polynomial, releasing any memory used. It must be reinitialised in order to be used again.Flint2_padic_poly_set_length poly len Demotes the coefficients of poly beyond len and sets the length of poly to len.0Note that if the current length is greater than len5 the polynomial may no slonger be in canonical form.Flint2padic_poly_fit_length poly len If len is greater than the number of coefficients currently allocated, then the polynomial is reallocated to have space for at least len; coefficients. No data is lost when calling this function.3The function efficiently deals with the case where  fit_length is called many times in small increments by at least doubling the number of allocated coefficients when length is larger than the number of coefficients currently allocated.Flint2padic_poly_realloc poly alloc p 3Reallocates the given polynomial to have space for alloc coefficients. If alloc is zero the polynomial is cleared and then reinitialised. If the current length is greater than alloc. the polynomial is first truncated to length alloc.Flint2padic_poly_init2 poly alloc prec  Initialises poly with space for at least alloc coefficients and sets the length to zero. The allocated coefficients are all set to zero. The precision is set to prec.Flint2padic_poly_init poly  Initialises poly for use, setting its length to zero. The precision of the polynomial is set to PADIC_DEFAULT_PREC. A corresponding call to padic_poly_clear' must be made after finishing with the  padic_poly_t, to free the memory used by the polynomial.- Safe-Inferred )*1 > Safe-Inferred )*1 LFlint2qadic_get_str__pretty op ctx#Returns a pretty representation of op in a C string.Flint2qadic_fprint_pretty file op ctx "Prints a pretty representation of op to file..In the current implementation, always returns 1. The return code is part of the function's signature to allow for a later implementation to return the number of characters printed or a non-positive error code.Flint2qadic_norm_resultant rop op ctx Sets rop to the norm of op, using the formula` \operatorname{Norm}(x) = \ell(f)^{-\deg(a)} \operatorname{Res}(f(X), a(X)),where +\mathbb{Q}_q \cong \mathbb{Q}_p[X] / (f(X)), \ell(f) is the leading coefficient of f(X), and a(X) \in \mathbb{Q}_p[X]! denotes the same polynomial as x.:The complexity of the current implementation is given by \mathcal{O}(d^4 M(N \log p)), where M(n)+ denotes the complexity of multiplying to n-bit integers.Flint2qadic_norm_analytic rop op ctx  Whenever op has valuation greater than  (p-1)^{-1}", this routine computes its norm rop via` \operatorname{Norm} (x) = \exp \Bigl( \bigl( \operatorname{Trace} \log (x) \bigr) \Bigr).In the special case that op lies in  \mathbb{Q}_p, returns its norm as \operatorname{Norm}(x) = x^d, where d is the extension degree.Otherwise, raises an abort signal.9The complexity of this implementation is quasi-linear in d and N, and polynomial in \log p.Flint2 qadic_norm rop op ctx Computes the norm of op to the given precision.8Algorithm selection is automatic depending on the input.Flint2 _qadic_norm rop op len a j lena p N Sets rop to the norm of the element (op,len) in  \mathbb{Z}_q to precision N, where len is at least one."The result will be reduced modulo p^N.Note that whenever (op,len). is a unit, so is its norm. Thus, the output rop of this function will typically not have to be canonicalised or reduced by the caller.Flint2 _qadic_trace rop op len a j lena pN Sets rop to the trace of op.For an element a \in \mathbb{Q}_q, multiplication by a defines a  \mathbb{Q}_p-linear map on  \mathbb{Q}_q. We define the trace of a, as the trace of this map. Equivalently, if \Sigma generates /\operatorname{Gal}(\mathbb{Q}_q / \mathbb{Q}_p) then the trace of a is equal to \sum_{i=0}^{d-1} \Sigma^i (a).Flint2qadic_teichmuller rop op ctx Sets rop to the Teichm"uller lift of op( to the precision given in the context. For a unit op, this is the unique ((q-1)`th root of unity which is congruent to )op modulo :math:`p.Sets rop to zero if op is zero in the given context.(Raises an exception if the valuation of op is negative.Flint2_qadic_teichmuller rop op len a j lena p N Sets (rop, d) to the Teichm"uller lift of  (op, len) modulo p^N.Does not support aliasing.Flint2qadic_frobenius rop op e ctx Evaluates the homomorphism \Sigma^e at op. Recall that \mathbb{Q}_q / \mathbb{Q}_p is Galois with Galois group 3\langle \Sigma \rangle \cong \langle \sigma \rangle, which is also isomorphic to \mathbb{Z}/d\mathbb{Z} , where 8\sigma \in \operatorname{Gal}(\mathbb{F}_q/\mathbb{F}_p) is the Frobenius element \sigma \colon x \mapsto x^p and \Sigma is its lift to -\operatorname{Gal}(\mathbb{Q}_q/\mathbb{Q}_p).%This functionality is implemented as  GaloisImage() in Magma.Flint2_qadic_frobenius rop op len e a j lena p N Sets  (rop, 2*d-1) to \Sigma evaluated at  (op, len). Assumes that len is positive but at most d. Assumes that  0 < e < d.Does not support aliasing.Flint2_qadic_frobenius_a rop e a j lena p N  Computes \sigma^e(X) \bmod{p^N} where X is such that )\mathbb{Q}_q \cong \mathbb{Q}_p[X]/(f(X)).Assumes that the precision N is at least 27 and that the extension is non-trivial, i.e.(d geq 2). Assumes that  0 < e < d.Sets  (rop, 2*d-1)<, although the actual length of the output will be at most d.Flint2 qadic_log rop op ctx Returns whether the p&-adic logarithm function converges at op, and if so sets rop to its value.The p7-adic logarithm function is defined by the usual series` <\log_p(x) = \sum_{i=1}^{\infty} (-1)^{i-1} \frac{(x-1)^i}{i}but this only converges when \operatorname{ord}_p(x) is at least 2 or 1 when p = 2 or p > 2, respectively.Flint2 _qadic_log z y v len a j lena p N pN  Computes (z, d) as` 5z = - \sum_{i = 1}^{\infty} \frac{y^i}{i} \pmod{p^N}.*Note that this can be used to compute the p!-adic logarithm via the equation` \begin{aligned} \log(x) & = \sum_{i=1}^{\infty} (-1)^{i-1} \frac{(x-1)^i}{i} \\ & = - \sum_{i=1}^{\infty} \frac{(1-x)^i}{i}. \end{aligned} Assumes that  y = 1 - x is non-zero and that v = \operatorname{ord}_p(y) is at least 1 when p is odd and at least 2 when p = 2 so that the series converges. Assumes that (y, d) is reduced modulo p^N. Assumes that v < N, and hence in particular N \geq 2.Supports aliasing between z and y.Flint2qadic_log_balanced rop op ctx Returns whether the p&-adic logarithm function converges at op, and if so sets rop to its value.Flint2_qadic_log_balanced z y len a j lena p N pN  Computes (z, d) as` 5z = - \sum_{i = 1}^{\infty} \frac{y^i}{i} \pmod{p^N}. Assumes that v = \operatorname{ord}_p(y) is at least 1 when p is odd and at least 2 when p = 2 so that the series converges.Supports aliasing between z and y.Flint2qadic_log_rectangular rop op ctx Returns whether the p&-adic logarithm function converges at op, and if so sets rop to its value.Flint2_qadic_log_rectangular z y v len a j lena p N pN Computes` 5z = - \sum_{i = 1}^{\infty} \frac{y^i}{i} \pmod{p^N}.*Note that this can be used to compute the p!-adic logarithm via the equation` \begin{aligned} \log(x) & = \sum_{i=1}^{\infty} (-1)^{i-1} \frac{(x-1)^i}{i} \\ & = - \sum_{i=1}^{\infty} \frac{(1-x)^i}{i}. \end{aligned} Assumes that  y = 1 - x is non-zero and that v = \operatorname{ord}_p(y) is at least 1 when p is odd and at least 2 when p = 2 so that the series converges. Assumes that y is reduced modulo p^N. Assumes that v < N, and in particular N \geq 2.Supports aliasing between y and z.Flint2 qadic_exp rop op ctx 4Returns whether the exponential series converges at op and sets rop3 to its value reduced modulo in the given context.5The exponential series converges if the valuation of op is at least 2 or 1 when p is even or odd, respectively.Flint2 _qadic_exp rop op v len a j lena p N Sets (rop, 2*d - 1) to the exponential of  (op, v, len) reduced modulo p^N%, assuming that the series converges. Assumes that  (op, v, len) is non-zero.Does not support aliasing.Flint2qadic_exp_balanced rop op ctx 4Returns whether the exponential series converges at op and sets rop3 to its value reduced modulo in the given context.Flint2_qadic_exp_balanced rop x v len a j lena p N pN Sets (rop, d) to the exponential of  (op, v, len) reduced modulo p^N%, assuming that the series converges. Assumes that len is in [1,d)= but supports zero padding, including the special case when  (op, len) is zero.Supports aliasing between rop and op.Flint2qadic_exp_rectangular rop op ctx 4Returns whether the exponential series converges at op and sets rop3 to its value reduced modulo in the given context.Flint2_qadic_exp_rectangular rop op v len a j lena p N pN Sets (rop, 2*d - 1) to the exponential of  (op, v, len) reduced modulo p^N%, assuming that the series converges. Assumes that  (op, v, len) is non-zero.Does not support aliasing.Flint2 qadic_sqrt rop op ctx Return 1< if the input is a square (to input precision). If so, set rop2 to a square root (truncated to output precision).Flint2 qadic_pow rop op e ctx Sets rop the op raised to the power e.Currently assumes that e \geq 0.Note that for any input op, rop. is set to one in the given context whenever e = 0.Flint2 _qadic_pow rop op len e a j lena p Sets  (rop, 2*d-1) to (op,len) raised to the power e, reduced modulo f(X) given by  (a, j, lena) and p), which is expected to be a prime power. Assumes that e \geq 0 and that len is positive and at most d.Although we require that rop provides space for 2d - 12 coefficients, the output will be reduces modulo f(X)#, which is a polynomial of degree d.Does not support aliasing.Flint2 qadic_inv rop op ctx Sets rop to the inverse of op, reduced in the given context.Flint2 _qadic_inv rop op len a j lena p N Sets (rop, d) to the inverse of  (op, len) modulo f(X) given by  (a,j,lena) and p^N. Assumes that (op,len) has valuation 0!, that is, that it represents a p -adic unit. Assumes that len is at most d.Does not support aliasing.Flint2 qadic_mul rop op1 op2 ctx Sets rop to the product of op1 and op2,, reducing the output in the given context.Flint2 qadic_neg rop op ctx Sets rop to the negative of op. Assumes that op2 is reduced in the given context and ensures that rop is, too.Flint2 qadic_sub rop op1 op2 ctx Sets rop to the difference of op1 and op2.Assumes that both op1 and op24 are reduced in the given context and ensures that rop is, too.Flint2 qadic_add rop op1 op2 ctx Sets rop to the sum of op1 and op2.Assumes that both op1 and op24 are reduced in the given context and ensures that rop is, too.Flint2 qadic_equal op1 op2 Returns whether op1 and op2 are equal.Flint2 qadic_is_one op ctx Returns whether op& is equal to one in the given context.Flint2 qadic_is_zero op Returns whether op is equal to zero.Flint2qadic_get_padic rop op ctx If the element op lies in  \mathbb{Q}_p, sets rop to its value and returns 1; otherwise, returns 0.Flint2 qadic_set_ui rop op ctx Sets rop to the integer op, reduced in the context.Flint2 qadic_gen rop ctx Sets rop to the generator X for the extension when N > 0, and zero otherwise. If the extension degree is one, raises an abort signal.Flint2 qadic_one rop ctx Sets rop& to one, reduced in the given context.Note that if the precision N is non-positive then rop is actually set to zero.Flint2 qadic_zero rop Sets rop to zero.Flint2 qadic_set rop op Sets rop to op.Flint2qadic_randtest_int rop state ctx Generates a random element of  \mathbb{Q}_q with non-negative valuation.Flint2qadic_randtest_val rop state v ctx Generates a random element of  \mathbb{Q}_q with prescribed valuation val. Note that if v \geq N& then the element is necessarily zero.Flint2qadic_randtest_not_zero rop state ctx 'Generates a random non-zero element of  \mathbb{Q}_q.Flint2qadic_randtest rop state ctx Generates a random element of  \mathbb{Q}_q.Flint2 qadic_prec op Returns the precision of op.Flint2 qadic_val op Returns the valuation of op.Flint2 qadic_reduce rop ctx Reduces rop modulo f(X) and p^N.Flint2_fmpz_mod_poly_reduce R lenR a j len p Reduces a polynomial  (R, lenR)# modulo a sparse monic polynomial f(X) = \sum_{i} a_{i} X^{j_{i}} of degree at least 2 in \mathbb{Z}/(p), where p is typically a prime power.Assumes that the array j of positive length len is sorted in ascending order.Allows zero-padding in  (R, lenR).Flint2_fmpz_poly_reduce R lenR a j len Reduces a polynomial  (R, lenR)# modulo a sparse monic polynomial f(X) = \sum_{i} a_{i} X^{j_{i}} of degree at least 2.Assumes that the array j of positive length len is sorted in ascending order.Allows zero-padding in  (R, lenR).Flint2 qadic_clear rop Clears the element rop.Flint2 qadic_init2 rop prec Initialises the element rop8 with the given output precision, setting the value to 0.Flint2 qadic_init rop Initialises the element rop, setting its value to 0.Flint2qadic_ctx_degree ctx Returns the extension degree.Flint2qadic_ctx_clear ctx Clears all memory that has been allocated as part of the context.Flint2qadic_ctx_init_conway ctx p d min max var mode Initialises the context ctx with prime p, extension degree d, variable name var and printing mode mode. The defining polynomial is chosen as a Conway polynomial, hence has restrictions on the prime and the degree.Stores powers of p with exponents between min (inclusive) and max exclusive. Assumes that min is at most max. Assumes that p is a prime.Assumes that the string var5 is a null-terminated string of length at least one.)Assumes that the printing mode is one of  PADIC_TERSE,  PADIC_SERIES, or PADIC_VAL_UNIT.This function also carries out some relevant precomputation for arithmetic in \mathbb{Q}_p / (p^N) such as powers of p close to p^N.Flint2qadic_ctx_init ctx p d min max var mode Initialises the context ctx with prime p, extension degree d, variable name var and printing mode mode. The defining polynomial is chosen as a Conway polynomial if possible and otherwise as a random sparse polynomial.Stores powers of p with exponents between min (inclusive) and max exclusive. Assumes that min is at most max. Assumes that p is a prime.Assumes that the string var5 is a null-terminated string of length at least one.)Assumes that the printing mode is one of  PADIC_TERSE,  PADIC_SERIES, or PADIC_VAL_UNIT.This function also carries out some relevant precomputation for arithmetic in \mathbb{Q}_p / (p^N) such as powers of p close to p^N.Flint2Create new q-adicFlint2 Use q-adicFlint2Apply f to new q-adicFlint2Apply f to new q-adicFlint2!Create q-adic context with prime p , extension d, precomputed powers p^{min} to p^{max} and  mode. Initialized with .Flint2!Create q-adic context with prime p , extension d, precomputed powers p^{min} to p^{max} and  mode. Initialized with .Flint2Use q-adic contextFlint2qadic_ctx_print ctx 'Prints the data from the given context.Flint2qadic_print_pretty op ctx "Prints a pretty representation of op to stdout..In the current implementation, always returns 1. The return code is part of the function's signature to allow for a later implementation to return the number of characters printed or a non-positive error code.. Safe-Inferred )*1  Safe-Inferred )*1 Flint2nf_clear nf Release resources used by a number field object. The object will need initialisation again before it can be used.Flint2nf_init nf pol Perform basic initialisation of a number field (for element arithmetic) given a defining polynomial over  \mathbb{Q}.Flint2Create a new number fieldFlint2Use number field/ Safe-Inferred )*1 % Safe-Inferred )*1 /$Flint2fmpz_poly_q_get_str_pretty op x Returns the pretty string representation of the rational function op.Flint2fmpz_poly_q_get_str op ;Returns the string representation of the rational function op.Flint2fmpz_poly_q_set_str rop sSets rop. to the rational function given by the string s. The following three methods enable users to construct elements of type  fmpz_poly_q_t from strings or to obtain string representations of such elements. The format used is based on the FLINT format for integer polynomials of type  fmpz_poly_t0, which we recall first: A non-zero polynomial a_0 + a_1 X + \dotsb + a_n X^n/ of length n + 1 is represented by the string "n+1 a_0 a_1 ... a_n", where there are two space characters following the length and single space characters separating the individual coefficients. There is no leading or trailing white-space. The zero polynomial is simply represented by "0". We adapt this notation for rational functions as follows. We denote the zero function by "0". Given a non-zero function with numerator and denominator string representations num and den#, respectively, we use the string num/den to represent the rational function, unless the denominator is equal to one, in which case we simply use num. There is also a _pretty variant available, which bases the string parts for the numerator and denominator on the output of the function fmpz_poly_get_str_pretty and introduces parentheses where necessary. Note that currently these functions are not optimised for performance and are intended to be used only for debugging purposes or one-off input and output, rather than as a low-level parser.Flint2fmpz_poly_q_evaluate_fmpq rop f a Sets rop to f evaluated at the rational a.(If the denominator evaluates to zero at a, returns non-zero and does not modify any of the variables. Otherwise, returns 0 and sets rop to the rational f(a).Flint2fmpz_poly_q_derivative rop op Sets rop to the derivative of op.Flint2fmpz_poly_q_pow rop op exp Sets rop to the exp -th power of op.The corner case of exp == 0 is handled by setting rop to the constant function 1#. Note that this includes the case 0^0 = 1.Flint2fmpz_poly_q_div rop op1 op2 Sets rop to the quotient of op1 and op2.Flint2fmpz_poly_q_mul rop op1 op2 Sets rop to the product of op1 and op2.Flint2fmpz_poly_q_scalar_div_fmpq rop op x Sets rop* to the quotient of the rational function op and the fmpq_t rational x.Flint2fmpz_poly_q_scalar_div_fmpz rop op x Sets rop* to the quotient of the rational function op and the fmpz_t integer x.Flint2fmpz_poly_q_scalar_div_si rop op x Sets rop* to the quotient of the rational function op and the slong integer x.Flint2fmpz_poly_q_scalar_mul_fmpq rop op x Sets rop) to the product of the rational function op and the fmpq_t rational x.Flint2fmpz_poly_q_scalar_mul_fmpz rop op x Sets rop) to the product of the rational function op and the fmpz_t integer x.Flint2fmpz_poly_q_scalar_mul_si rop op x Sets rop) to the product of the rational function op and the slong integer x.Flint2fmpz_poly_q_submul rop op1 op2 Subtracts the product of op1 and op2 from rop.Flint2fmpz_poly_q_addmul rop op1 op2 Adds the product of op1 and op2 to rop.Flint2fmpz_poly_q_sub rop op1 op2 Sets rop to the difference of op1 and op2.Flint2fmpz_poly_q_add rop op1 op2 Sets rop to the sum of op1 and op2.Flint2fmpz_poly_q_equal op1 op2 !Returns whether the two elements op1 and op2 are equal.Flint2fmpz_poly_q_is_one op Returns whether the element rop& is equal to the constant polynomial 1.Flint2fmpz_poly_q_is_zero op Returns whether the element op is zero.Flint2fmpz_poly_q_inv rop op Sets the element rop" to the multiplicative inverse of op.Assumes that the element op is non-zero.Flint2fmpz_poly_q_neg rop op Sets the element rop to the additive inverse of op.Flint2fmpz_poly_q_one rop Sets rop to one.Flint2fmpz_poly_q_zero rop Sets rop to zero.Flint2fmpz_poly_q_swap op1 op2 Swaps the elements op1 and op2..This is done efficiently by swapping pointers.Flint2fmpz_poly_q_set_si rop op Sets the element rop to the value given by the slong op.Flint2fmpz_poly_q_set rop op Sets the element rop" to the same value as the element op.Flint2fmpz_poly_q_randtest_not_zero poly state len1 bits1 len2 bits2 Sets poly( to a random non-zero rational function.Flint2fmpz_poly_q_randtest poly state len1 bits1 len2 bits2 Sets poly to a random rational function.Flint2fmpz_poly_q_is_canonical op %Checks whether the rational function op is in canonical form.Flint2fmpz_poly_q_canonicalise rop Brings rop into canonical form, only assuming that the denominator is non-zero.Flint2fmpz_poly_q_clear rop Clears the object rop.Flint2fmpz_poly_q_init rop  Initialises rop.Flint2fmpz_poly_q_print op 3Prints the representation of the rational function op to stdout.Flint2fmpz_poly_q_print_pretty op x :Prints the pretty representation of the rational function op to stdout.-0 Safe-Inferred )*1 0-- Safe-Inferred )*1 Flint2!fmpq_mpoly_univar_swap_term_coeff c A i ctx Set (resp. swap) c7 to (resp. with) the coefficient of the term of index i of A.Flint2 fmpq_mpoly_univar_get_term_coeff c A i ctx Flint2!fmpq_mpoly_univar_get_term_exp_si A i ctx )Return the exponent of the term of index i of A.Flint2fmpq_mpoly_univar_length A ctx Return the number of terms in A# with respect to the main variable.Flint2 fmpq_mpoly_univar_degree_fits_si A ctx Return 1 if the degree of A, with respect to the main variable fits an slong. Otherwise, return 0.Flint2fmpq_mpoly_from_univar A B var ctx Set A to the normal form of B& by putting in the variable of index var4. This function is undefined if the coefficients of B" depend on the variable of index var.Flint2fmpq_mpoly_to_univar A B var ctx Set A to a univariate form of B' by pulling out the variable of index var. The coefficients of A" will still belong to the content ctx/ but will not depend on the variable of index var.Flint2fmpq_mpoly_univar_swap A B ctx Swap A and B.Flint2fmpq_mpoly_univar_clear A ctx Clear A.Flint2fmpq_mpoly_univar_init A ctx  Initialize A.Flint2fmpq_mpoly_is_square A ctx Return 1 if A' is a perfect square, otherwise return 0.Flint2fmpq_mpoly_sqrt Q A ctx If A is a perfect square return 1 and set Q to the square root with positive leading coefficient. Otherwise return 0 and set Q to zero.Flint2fmpq_mpoly_discriminant D A var ctx  Try to set D to the discriminant of A( with respect to the variable of index var.Flint2fmpq_mpoly_resultant R A B var ctx  Try to set R to the resultant of A and B( with respect to the variable of index var.Flint2fmpq_mpoly_gcd_zippel2 G A B ctx  Try to set G to the GCD of A and B using various algorithms.Flint2fmpq_mpoly_gcd_zippel G A B ctx Flint2fmpq_mpoly_gcd_subresultant G A B ctx Flint2fmpq_mpoly_gcd_hensel G A B ctx Flint2fmpq_mpoly_gcd_brown G A B ctx Flint2fmpq_mpoly_gcd_cofactors G Abar Bbar A B ctx Do the operation of fmpq_mpoly_gcd and also compute  Abar = A/G and  Bbar = B/G if successful.Flint2fmpq_mpoly_gcd G A B ctx  Try to set G to the monic GCD of A and B. The GCD of zero and zero is defined to be zero. If the return is 17 the function was successful. Otherwise the return is 0 and G is left untouched.Flint2fmpq_mpoly_content_vars g A vars  vars_length ctx Set g# to the GCD of the coefficients of A/ when viewed as a polynomial in the variables vars . Return 1 for success and 0 for failure. Upon success, g' will be independent of the variables vars.Flint2fmpq_mpoly_term_content M A ctx Set M to the GCD of the terms of A. If A is zero, M will be zero. Otherwise, M) will be a monomial with coefficient one.Flint2fmpq_mpoly_content g A ctx Set g1 to the (nonnegative) gcd of the coefficients of A.Flint2fmpq_mpoly_divrem_ideal Q R A B len ctx This function is as per fmpq_mpoly_divrem7 except that it takes an array of divisor polynomials B2 and it returns an array of quotient polynomials Q. The number of divisor (and hence quotient) polynomials is given by len.Flint2fmpq_mpoly_divrem Q R A B ctx Set Q and R" to the quotient and remainder of A divided by B.Flint2fmpq_mpoly_div Q A B ctx Set Q to the quotient of A by B, discarding the remainder.Flint2fmpq_mpoly_divides Q A B ctx If A is divisible by B, set Q# to the exact quotient and return 1. Otherwise, set Q to zero and return 0. Note that the function fmpq_mpoly_div5 may be faster if the quotient is known to be exact.Flint2fmpq_mpoly_pow_ui A B k ctx Set A to B raised to the k-th power. Return 1 for success and 0 for failure.Flint2fmpq_mpoly_pow_fmpz A B k ctx Set A to B raised to the k-th power. Return 1 for success and 0 for failure.Flint2fmpq_mpoly_mul A B C ctx Set A to  B \times C.Flint2!fmpq_mpoly_compose_fmpq_mpoly_gen A B c ctxB ctxAC Set A to the evaluation of B where the variable of index i in ctxB& is replaced by the variable of index c[i] in ctxAC. The length of the array C is the number of variables in ctxB . If any c[i], is negative, the corresponding variable of B6 is replaced by zero. Otherwise, it is expected that c[i]* is less than the number of variables in ctxAC.Flint2fmpq_mpoly_compose_fmpq_mpoly A B C ctxB ctxAC Set A to the evaluation of B where the variables are replaced by the corresponding elements of the array C. Both A and the elements of C have context object ctxAC, while B has context object ctxB . Neither A nor B3 is allowed to alias any other polynomial. Return 1 for success and 0 for failure.Flint2fmpq_mpoly_compose_fmpq_poly A B C ctxB Set A to the evaluation of B where the variables are replaced by the corresponding elements of the array C. The context object of B is ctxB . Return 1 for success and 0 for failure.Flint2fmpq_mpoly_evaluate_one_fmpq A B var val ctx Set A to the evaluation of B where the variable of index var is replaced by val . Return 1 for success and 0 for failure.Flint2fmpq_mpoly_evaluate_all_fmpq ev A vals ctx Set ev to the evaluation of A where the variables are replaced by the corresponding elements of the array vals . Return 1 for success and 0 for failure.Flint2fmpq_mpoly_integral A B var ctx Set A4 to the integral with the fewest number of terms of B( with respect to the variable of index var.Flint2fmpq_mpoly_derivative A B var ctx Set A to the derivative of B( with respect to the variable of index var.Flint2fmpq_mpoly_make_monic A B ctx Set A to B' divided by the leading coefficient of B. This throws if B is zero.&All of these functions run quickly if A and B are aliased.Flint2fmpq_mpoly_scalar_div_si A B c ctx Set A to B/c.Flint2fmpq_mpoly_scalar_div_ui A B c ctx Flint2fmpq_mpoly_scalar_div_fmpz A B c ctx Flint2fmpq_mpoly_scalar_div_fmpq A B c ctx Flint2fmpq_mpoly_scalar_mul_si A B c ctx Set A to  B \times c.Flint2fmpq_mpoly_scalar_mul_ui A B c ctx Flint2fmpq_mpoly_scalar_mul_fmpz A B c ctx Flint2fmpq_mpoly_scalar_mul_fmpq A B c ctx Flint2fmpq_mpoly_neg A B ctx Set A to -B.Flint2fmpq_mpoly_sub A B C ctx Set A to B - C.Flint2fmpq_mpoly_add A B C ctx Set A to B + C.Flint2fmpq_mpoly_sub_si A B c ctx Set A to B - c.Flint2fmpq_mpoly_sub_ui A B c ctx Flint2fmpq_mpoly_sub_fmpz A B c ctx Flint2fmpq_mpoly_sub_fmpq A B c ctx Flint2fmpq_mpoly_add_si A B c ctx Set A to B + c.Flint2fmpq_mpoly_add_ui A B c ctx Flint2fmpq_mpoly_add_fmpz A B c ctx Flint2fmpq_mpoly_add_fmpq A B c ctx Flint2fmpq_mpoly_randtest_bits A state length  coeff_bits exp_bits ctx /Generate a random polynomial with length up to length and exponents whose packed form does not exceed the given bit count.The parameter  coeff_bits to the three functions 'fmpq_mpoly_randtest_{bound|bounds|bits} is merely a suggestion for the approximate bit count of the resulting coefficients.Flint2fmpq_mpoly_randtest_bounds A state length  coeff_bits  exp_bounds ctx /Generate a random polynomial with length up to length and exponents in the range [0, exp_bounds[i] - 1]*. The exponents of the variable of index i are generated by calls to n_randint(state, exp_bounds[i]).Flint2fmpq_mpoly_randtest_bound A state length  coeff_bits  exp_bound ctx /Generate a random polynomial with length up to length and exponents in the range [0, exp_bound - 1]<. The exponents of each variable are generated by calls to n_randint(state, exp_bound).Flint2fmpq_mpoly_combine_like_terms A ctx ,Combine adjacent like terms in the internal A->zpoly, and then factor out content via a call to fmpq_mpoly_reduce. If the terms of A were sorted to begin with, the result will be in canonical form.Flint2fmpq_mpoly_sort_terms A ctx Sort the internal A->zpoly: into the canonical ordering dictated by the ordering in ctx. This function does not combine like terms, nor does it delete terms with coefficient zero, nor does it reduce.Flint2fmpq_mpoly_reduce A ctx "Factor out necessary content from A->zpoly) so that it is reduced. If the terms of A were nonzero and sorted with distinct exponents to begin with, the result will be in canonical form.Flint2fmpq_mpoly_push_term_si_ui A c exp ctx Append a term to A with coefficient c and exponent vector exp. This function should run in constant average time if the terms pushed have bounded denominator.Flint2fmpq_mpoly_push_term_ui_ui A c exp ctx Flint2fmpq_mpoly_push_term_fmpz_ui A c exp ctx Flint2fmpq_mpoly_push_term_fmpq_ui A c exp ctx Flint2fmpq_mpoly_push_term_si_fmpz A c exp ctx Flint2fmpq_mpoly_push_term_ui_fmpz A c exp ctx Flint2fmpq_mpoly_push_term_fmpz_fmpz A c exp ctx Flint2fmpq_mpoly_push_term_fmpq_fmpz A c exp ctx Flint2fmpq_mpoly_get_term_monomial M A i ctx Set M& to the monomial of the term of index i in A. The coefficient of M will be one.Flint2fmpq_mpoly_get_term M A i ctx Set M to the term of index i in A.Flint2fmpq_mpoly_set_term_exp_ui A i exps ctx -Set the exponent vector of the term of index i to exp.Flint2fmpq_mpoly_set_term_exp_fmpz A i exps ctx Flint2fmpq_mpoly_get_term_var_exp_si A i var ctx $Return the exponent of the variable var of the term of index i<. This function throws if the exponent does not fit into a ulong (resp. slong).Flint2fmpq_mpoly_get_term_var_exp_ui A i var ctx Flint2fmpq_mpoly_get_term_exp_si exps A i ctx Set exp- to the exponent vector of the term of index i. The _ui (resp. _si2) version throws if any entry does not fit into a ulong (resp. slong).Flint2fmpq_mpoly_get_term_exp_ui exps A i ctx Flint2fmpq_mpoly_get_term_exp_fmpz exps A i ctx Flint2fmpq_mpoly_term_exp_fits_ui A i ctx Return 1= if all entries of the exponent vector of the term of index i fit into an slong (resp. a ulong). Otherwise, return 0.Flint2fmpq_mpoly_term_exp_fits_si A i ctx Flint2fmpq_mpoly_set_term_coeff_fmpq A i c ctx Set the coefficient of index i to c.Flint2fmpq_mpoly_get_term_coeff_fmpq c A i ctx Set c to coefficient of index iFlint2fmpq_mpoly_resize A  new_length ctx Set the length of A to  new_length. Terms are either deleted from the end, or new zero terms are appended.Flint2fmpq_mpoly_length A ctx %Return the number of terms stored in A. If the polynomial is in canonical form, this will be the number of nonzero coefficients.Flint2fmpq_mpoly_is_canonical A ctx Return 1 if A) is in canonical form. Otherwise, return 0. An  fmpq_mpoly_t% is represented as the product of an fmpq_t content and an fmpz_mpoly_t zpoly. The representation is considered canonical when either (1) both content and zpoly are zero, or (2) both content and zpoly are nonzero and canonical and zpoly is reduced. A nonzero zpoly is considered reduced when the coefficients have GCD one and the leading coefficient is positive.Flint2fmpq_mpoly_zpoly_term_coeff_ref A i ctx /Return a reference to the coefficient of index i of the integer polynomial of A.Flint2fmpq_mpoly_zpoly_ref A ctx 0Return a reference to the integer polynomial of A.Flint2fmpq_mpoly_content_ref A ctx %Return a reference to the content of A.Flint2fmpq_mpoly_cmp A B ctx Return 1 (resp. -1, or 0) if A# is after (resp. before, same as) B in some arbitrary but fixed total ordering of the polynomials. This ordering agrees with the usual ordering of monomials when A and B are both monomials.Flint2fmpq_mpoly_get_coeff_vars_ui C A vars exps length ctx Set C to the coefficient of A# with respect to the variables in vars( with powers in the corresponding array exps. Both vars and exps point to array of length length. It is assumed that 0 < length \le nvars(A) and that the variables in vars are distinct.Flint2fmpq_mpoly_set_coeff_fmpq_ui A c exp ctx 2Set the coefficient of the monomial with exponent exp to c.Flint2fmpq_mpoly_set_coeff_fmpq_fmpz A c exp ctx Flint2fmpq_mpoly_get_coeff_fmpq_ui c A exp ctx Set c2 to the coefficient of the monomial with exponent exp.Flint2fmpq_mpoly_get_coeff_fmpq_fmpz c A exp ctx Flint2"fmpq_mpoly_set_coeff_fmpq_monomial A c M ctx Assuming that M is a monomial, set the coefficient of the corresponding monomial in A to c. This function throws if M is not a monomial.Flint2"fmpq_mpoly_get_coeff_fmpq_monomial c A M ctx Assuming that M is a monomial, set c6 to the coefficient of the corresponding monomial in A. This function throws if M is not a monomial.Flint2fmpq_mpoly_get_denominator d A ctx Set d to the denominator of A , the smallest positive integer d such that  d \times A has integer coefficients.Flint2fmpq_mpoly_used_vars used A ctx For each variable index i, set used[i]& to nonzero if the variable of index i appears in A and to zero otherwise.Flint2fmpq_mpoly_total_degree_si A ctx Either return or set tdeg to the total degree of A. If A- is zero, the total degree is defined to be -1.Flint2fmpq_mpoly_total_degree_fmpz tdeg A ctx Flint2fmpq_mpoly_total_degree_fits_si A ctx Return 1 if the total degree of A fits into an slong, otherwise return 0.Flint2fmpq_mpoly_degree_si A var ctx Either return or set deg to the degree of A( with respect to the variable of index var. If A' is zero, the degree is defined to be -1.Flint2fmpq_mpoly_degree_fmpz deg A var ctx Flint2fmpq_mpoly_degrees_si degs A ctx Set degs to the degrees of A# with respect to each variable. If A" is zero, all degrees are set to -1.Flint2fmpq_mpoly_degrees_fmpz degs A ctx Flint2fmpq_mpoly_degrees_fit_si A ctx Return 1 if the degrees of A, with respect to each variable fit into an slong, otherwise return 0.Flint2fmpq_mpoly_is_one A ctx Return 1 if A is equal to the constant 1, else return 0.Flint2fmpq_mpoly_is_zero A ctx Return 1 if A is equal to the constant 0, else return 0.Flint2fmpq_mpoly_equal_si A c ctx Return 1 if A is equal to the constant c, else return 0.Flint2fmpq_mpoly_equal_ui A c ctx Flint2fmpq_mpoly_equal_fmpz A c ctx Flint2fmpq_mpoly_equal_fmpq A c ctx Flint2fmpq_mpoly_one A ctx Set A to the constant 1.Flint2fmpq_mpoly_zero A ctx Set A to the constant 0.Flint2fmpq_mpoly_set_si A c ctx Set A to the constant c.Flint2fmpq_mpoly_set_ui A c ctx Flint2fmpq_mpoly_set_fmpz A c ctx Flint2fmpq_mpoly_set_fmpq A c ctx Flint2fmpq_mpoly_get_fmpq c A ctx Assuming that A is a constant, set c, to this constant. This function throws if A is not a constant.Flint2fmpq_mpoly_is_fmpq A ctx Return 1 if A is a constant, else return 0.Flint2fmpq_mpoly_swap A B ctx Efficiently swap A and B.Flint2fmpq_mpoly_equal A B ctx Return 1 if A is equal to B, else return 0.Flint2fmpq_mpoly_set A B ctx Set A to B.Flint2fmpq_mpoly_is_gen A var ctx If  var \ge 0 , return 1 if A is equal to the var!-th generator, otherwise return 0. If var < 0 , return 1 if the polynomial is equal to any generator, otherwise return 0.Flint2fmpq_mpoly_gen A var ctx Set A to the variable of index var, where var = 0 corresponds to the variable with the most significance with respect to the ordering.Flint2fmpq_mpoly_set_str_pretty A str x ctx Set A1 to the polynomial in the null-terminates string str given an array x! of variable strings. If parsing str fails, A is set to zero, and -1 is returned. Otherwise, 0 is returned. The operations +, -, *, and /9 are permitted along with integers and the variables in x. The character ^ must be immediately followed by the (integer) exponent. If any division is not exact, parsing fails.Flint2fmpq_mpoly_fprint_pretty file A x ctx Print a string representing A to file.Flint2fmpq_mpoly_get_str_pretty A x ctx Return a string, which the user is responsible for cleaning up, representing A%, given an array of variable strings x.Flint2fmpq_mpoly_clear A ctx  Release any space allocated for A.Flint2fmpq_mpoly_realloc A alloc ctx  Reallocate A to have space for alloc terms. Assumes the current length of the polynomial is not greater than alloc.Flint2fmpq_mpoly_fit_bits A bits ctx #Ensure that the exponent fields of A have at least bits bits.Flint2fmpq_mpoly_fit_length A len ctx  Ensure that A has space for at least len terms.Flint2fmpq_mpoly_init3 A alloc bits ctx  Initialise A for use with the given and initialised context object. Its value is set to zero. It is allocated with space for alloc terms and bits bits for the exponents.Flint2fmpq_mpoly_init2 A alloc ctx  Initialise A for use with the given and initialised context object. Its value is set to zero. It is allocated with space for alloc terms and at least MPOLY_MIN_BITS bits for the exponents.Flint2fmpq_mpoly_init A ctx  Initialise A for use with the given and initialised context object. Its value is set to zero.Flint2fmpq_mpoly_ctx_clear ctx "Release up any space allocated by ctx.Flint2fmpq_mpoly_ctx_ord ctx 3Return the ordering used to initialize the context.Flint2fmpq_mpoly_ctx_nvars ctx >Return the number of variables used to initialize the context.Flint2fmpq_mpoly_ctx_init ctx nvars ord Initialise a context object for a polynomial ring with the given number of variables and the given ordering. The possibilities for the ordering are ORD_LEX,  ORD_DEGLEX and  ORD_DEGREVLEX.LFlint2 Create a new LFlint2 Create a new Flint2Use a Flint2fmpq_mpoly_print_pretty A x ctx Print a string representing A to stdout>. foreign import ccall "fmpq_mpoly.h fmpq_mpoly_print_pretty"1 Safe-Inferred )*1  Safe-Inferred )*1 / Flint2fmpq_mpoly_factor f A ctx Set f to a factorization of A! where the bases are irreducible.Flint2fmpq_mpoly_factor_squarefree f A ctx Set f to a factorization of A where the bases are primitive and pairwise relatively prime. If the product of all irreducible factors with a given exponent is desired, it is recommended to call fmpq_mpoly_factor_sort8 and then multiply the bases with the desired exponent.Flint2fmpq_mpoly_factor_make_integral f ctx Make the bases in f monic (resp. integral and primitive with positive leading coefficient). Return 1 for success, 0 for failure.Flint2fmpq_mpoly_factor_make_monic f ctx Flint2fmpq_mpoly_factor_sort f ctx Sort the product of f$ first by exponent and then by base.Flint2fmpq_mpoly_factor_get_exp_si f i ctx )Return the exponent of the term of index i in A. It is assumed to fit an slong.Flint2fmpq_mpoly_factor_swap_base B f i ctx Set (resp. swap) B/ to (resp. with) the base of the term of index i in A.Flint2fmpq_mpoly_factor_get_base B f i ctx Flint2#fmpq_mpoly_factor_get_constant_fmpq c f ctx Set c to the constant of f.Flint2fmpq_mpoly_factor_length f ctx $Return the length of the product in f.Flint2fmpq_mpoly_factor_clear f ctx Clear f.Flint2fmpq_mpoly_factor_init f ctx  Initialise f.2 Safe-Inferred )*1  Safe-Inferred )*1 %Flint2_fexpr_vec_sort_fast vec len  Sorts the len entries in vec using the comparison function fexpr_cmp_fast.Flint2fexpr_vec_set_length vec len Sets the length of vec to len*, truncating or zero-extending as needed.Flint2fexpr_vec_insert_unique vec expr Inserts expr without duplication into vec, returning its position. If this expression already exists, vec5 is unchanged. If this expression does not exist in vec, it is appended.Flint2fexpr_vec_append vec expr Appends expr to the end of the vector vec.Flint2 fexpr_vec_set dest src Sets dest to a copy of src.Flint2fexpr_vec_fit_length vec len  Ensures that vec has space for len entries.Flint2fexpr_vec_swap x y Swaps x and y efficiently.Flint2fexpr_vec_print vec Prints vec to standard output.Flint2fexpr_vec_clear vec Clears the vector vec.Flint2fexpr_vec_init vec len  Initializes vec to a vector of length len/. All entries are set to the atomic integer 0.Flint2fexpr_expanded_normal_form res expr flags Sets res to expr converted to expanded normal form viewed as a formal rational function with its non-arithmetic subexpressions as terminal nodes. This function first computes nodes with fexpr_arithmetic_nodes:, sorts the nodes, evaluates to a rational function with fexpr_get_fmpz_mpoly_q0, and then converts back to an expression with fexpr_set_fmpz_mpoly_q . Optional flags are reserved for future use.Flint2fexpr_set_fmpz_mpoly_q res frac vars ctx Sets res2 to an expression for the multivariate polynomial poly (or rational function frac), using the expressions in vars" as the variables. The length of vars- must agree with the number of variables in ctx. If NULL is passed for vars', a default choice of symbols is used.Flint2fexpr_set_fmpz_mpoly res poly vars ctx Flint2fexpr_get_fmpz_mpoly_q res expr vars ctx Sets res to the expression expr9 as a formal rational function of the subexpressions in vars . The vector vars must have the same length as the number of variables specified in ctx . To build vars( automatically for a given expression, fexpr_arithmetic_nodes may be used.Returns 1 on success and 0 on failure. Failure can occur for the following reasons:A subexpression is encountered that cannot be interpreted as an arithmetic operation and does not appear (exactly) in vars.0Overflow (too many terms or too large exponent).5Division by zero (a zero denominator is encountered).1It is important to note that this function views expr% as a formal rational function with vars as formal indeterminates. It does thus not check for algebraic relations between vars' and can implicitly divide by zero if vars# are not algebraically independent.Flint2fexpr_arithmetic_nodes nodes expr Sets nodes" to a vector of subexpressions of expr such that expr# is an arithmetic expression with nodes as leaves. More precisely, expr will be constructed out of nested application the arithmetic operators Pos, Neg, Add, Sub, Mul, Div# with integers and expressions in nodes as leaves. Powers Pow with an atomic integer exponent are also allowed. The nodes are output without repetition but are not automatically sorted in a canonical order.Flint2fexpr_is_arithmetic_operation expr Returns whether expr is of the form f(e_1,\ldots,e_n) where f% is one of the arithmetic operators Pos, Neg, Add, Sub, Mul, Div.Flint2 fexpr_pow res a b Constructs an arithmetic expression with given arguments. No simplifications whatsoever are performed.Flint2 fexpr_div res a b Flint2 fexpr_mul res a b Flint2 fexpr_sub res a b Flint2 fexpr_add res a b Flint2 fexpr_neg res a Flint2fexpr_set_re_im_d res x y Sets res8 to an expression for the complex number with real part x and imaginary part y.Flint2 fexpr_set_d res x Sets res> to an expression for the value of the floating-point number x. NaN is represented as  Undefined. For a regular value, this creates an atomic integer or a rational fraction if the exponent is small, and otherwise creates an expression of the form Mul(m, Pow(2, e)).Flint2 fexpr_set_arf res x Flint2fexpr_set_fmpq res x Sets res to the rational number x8. This creates an atomic integer if the denominator of x6 is one, and otherwise creates a division expression.Flint2fexpr_replace_vec res expr xs ys Sets res to the expression expr with all occurrences of the subexpressions given by entries in xs/ replaced by the corresponding expressions in ys. It is required that xs and ys have the same length. Returns a boolean value indicating whether any replacements have been performed. Aliasing is allowed between res and expr but not between res and the entries of xs or ys.Flint2fexpr_replace2 res expr x1 y1 x2 y2 Like  fexpr_replace, but simultaneously replaces x1 by y1 and x2 by y2.Flint2 fexpr_replace res expr x y Sets res to the expression expr, with all occurrences of the subexpression x replaced by the expression y. Returns a boolean value indicating whether any replacements have been performed. Aliasing is allowed between res and expr but not between res and x or y.Flint2fexpr_contains expr x Returns whether expr contains the expression x3 as a subexpression (this includes the case where expr and x are equal).Flint2fexpr_call_builtin2 res f x1 x2 Creates the function call f(x_1,\ldots,x_n), where f defines a builtin symbol.Flint2fexpr_call_builtin1 res f x1 Flint2fexpr_call_vec res f args len Creates the function call f(x_1,\ldots,x_n). The vec* version takes the arguments as an array args and n is given by len. Warning: aliasing between inputs and outputs is not implemented.Flint2 fexpr_call4 res f x1 x2 x3 x4 Flint2 fexpr_call3 res f x1 x2 x3 Flint2 fexpr_call2 res f x1 x2 Flint2 fexpr_call1 res f x1 Flint2 fexpr_call0 res f Flint2fexpr_is_any_builtin_call expr Returns whether expr has the form  f(\ldots) where f is any builtin function (see  fexpr-builtin).Flint2fexpr_is_builtin_call expr id Returns whether expr has the form  f(\ldots) where f# is a builtin function defined by id (see  fexpr-builtin).Flint2fexpr_view_next view Assuming that view* is a shallow view of a function argument e_i in a function call f(e_1,\ldots,e_n), sets view! to a view of the next argument e_{i+1}#. This function can be called when view refers to the last argument e_n, provided that view is not used afterwards. This function can also be called when view refers to the function f, in which case it will make view point to e_1.Flint2fexpr_view_arg view expr i As  fexpr_arg , but sets view to a shallow view instead of copying the expression. The variable view? must not be initialized before use or cleared after use, and expr- must not be modified or cleared as long as view is in use.Flint2 fexpr_arg res expr i Assuming that expr represents a function call f(e_1,\ldots,e_n), sets res to the argument e_{i+1}. Note that indexing starts from 0. The index must be in bounds, with  0 \le i < n.Flint2fexpr_view_func view expr As  fexpr_func , but sets view to a shallow view instead of copying the expression. The variable view? must not be initialized before use or cleared after use, and expr- must not be modified or cleared as long as view is in use.Flint2 fexpr_func res expr Assuming that expr represents a function call f(e_1,\ldots,e_n), sets res to the function expression f.Flint2 fexpr_nargs expr  Returns the number of arguments n in the function call f(e_1,\ldots,e_n) represented by expr. If expr is an atom, returns -1.Flint2fexpr_get_str_latex expr flags 0Returns a string of the LaTeX representation of expr!. The string must be freed with  flint_free.Warning: string literals appearing in expressions are currently not escaped.Flint2fexpr_write_latex stream expr flags #Writes the LaTeX representation of expr to stream.Flint2 fexpr_get_str expr #Returns a string representation of expr!. The string must be freed with  flint_free.Warning: string literals appearing in expressions are currently not escaped.Flint2 fexpr_write stream expr Writes expr to stream.Flint2fexpr_get_string expr Assuming that expr is an atomic string, returns a copy of this string. The string must be freed with  flint_free.Flint2fexpr_set_string res s Sets res to the atomic string s.Flint2fexpr_get_symbol_str expr Returns the symbol in expr- as a string. The string must be freed with  flint_free. This aborts if expr is not an atomic symbol.Flint2fexpr_set_symbol_str res s Sets res to the symbol given by s.Flint2fexpr_is_any_builtin_symbol expr Returns whether expr is any builtin symbol (see  fexpr-builtin).Flint2fexpr_is_builtin_symbol expr id Returns whether expr" is the builtin symbol with index id (see  fexpr-builtin).Flint2fexpr_set_symbol_builtin res id Sets res+ to the builtin symbol with internal index id (see  fexpr-builtin).Flint2fexpr_get_fmpz res expr Sets res to the atomic integer in expr. This aborts if expr is not an atomic integer.Flint2fexpr_set_fmpz res c Sets res to the atomic integer c.Flint2 fexpr_set_ui res c Flint2 fexpr_set_si res c Flint2fexpr_is_neg_integer expr Returns whether expr is any negative atomic integer.Flint2 fexpr_is_zero expr Returns whether expr is the atomic integer 0.Flint2 fexpr_zero res Sets res to the atomic integer 0.Flint2 fexpr_is_atom expr Returns whether expr is any atom.Flint2fexpr_is_string expr Returns whether expr is an atomic string.Flint2fexpr_is_symbol expr Returns whether expr is an atomic symbol.Flint2fexpr_is_integer expr Returns whether expr is an atomic integerFlint2fexpr_cmp_fast a b  Compares a and b using an ordering based on the internal representation, returning -1, 0 or 1. This can be used, for instance, to maintain sorted arrays of expressions for binary search; the sort order has no mathematical significance.Flint2 fexpr_hash expr !Returns a hash of the expression expr.Flint2fexpr_equal_ui expr c  Checks if expr' is an atomic integer exactly equal to c.Flint2fexpr_equal_si expr c Flint2 fexpr_equal a b  Checks if a and b" are exactly equal as expressions.Flint2fexpr_allocated_bytes expr Returns the number of allocated bytes in the internal representation of expr<. The count excludes the size of the structure itself. Add sizeof(fexpr_struct)* to get the size of the object as a whole.Flint2fexpr_size_bytes expr >Returns the number of bytes in the internal representation of expr=. The count excludes the size of the structure itself. Add sizeof(fexpr_struct)* to get the size of the object as a whole.Flint2 fexpr_size expr >Returns the number of words in the internal representation of expr.Flint2fexpr_num_leaves expr Returns the number of leaves (atoms, counted with repetition) in the expression expr.Flint2 fexpr_depth expr Returns the depth of expr as a symbolic expression tree.Flint2 fexpr_swap a b Swaps a and b efficiently.Flint2 fexpr_set res expr Sets res to the a copy of expr.Flint2fexpr_fit_size expr size  Ensures that expr has room for size words.Flint2_fexpr_vec_clear vec len  Clears the len expressions in vec and frees vec itself.Flint2_fexpr_vec_init len #Returns a heap-allocated vector of len initialized expressions.Flint2 fexpr_clear expr Clears expr, freeing its allocated memory.Flint2 fexpr_init expr  Initializes expr3 for use. Its value is set to the atomic integer 0.Flint2 fexpr_print expr Prints expr to standard output.Flint2fexpr_print_latex expr flags #Prints the LaTeX representation of expr to standard output.Flint2fexpr_latex_smallGenerate more compact formulas, most importantly by printing fractions inline as p/q instead of as  \frac{p}{q}. This flag is automatically activated within subscripts and superscripts and in certain other parts of formulas.Flint2fexpr_latex_logicUse symbols for logical operators such as Not, And, Or, which by default are rendered as words for legibility.3 Safe-Inferred )*1 H Safe-Inferred )*1 9 Flint2_bernoulli_fmpq_ui num den n Computes the Bernoulli number B_n0 as an exact fraction, for an isolated integer n. This function reads B_n from the global cache if the number is already cached, but does not automatically extend the cache by itself.Flint2_bernoulli_fmpq_ui_zeta num den n Sets num and den to the reduced numerator and denominator of the Bernoulli number B_n.The zeta" version computes the denominator d using the von Staudt-Clausen theorem, numerically approximates B_n using arb_bernoulli_ui_zeta, and then rounds d B_n to the correct numerator.The  multi_mod version reconstructs B_n by computing the high bits via the Riemann zeta function and the low bits via Harvey's multimodular algorithm. The tuning parameter alpha should be a fraction between 0 and 1 controlling the number of bits to compute by the multimodular algorithm. If set to a negative number, a default value will be used.Flint2bernoulli_mod_p_harvey n p  Returns the B_n modulo the prime number p%, computed using Harvey's algorithm  [Har2010] . The running time is linear in p. If p divides the numerator of B_n,  UWORD_MAX is returned as an error code.Flint2bernoulli_bound_2exp_si n Returns an integer b such that  |B_n| \le 2^b!. Uses a lookup table for small n, and for larger n uses the inequality ;|B_n| < 4 n! / (2 \pi)^n < 4 (n+1)^{n+1} e^{-n} / (2 \pi)^n. Uses integer arithmetic throughout, with the bound for the logarithm being looked up from a table. If  |B_n| = 0 , returns LONG_MIN$. Otherwise, the returned exponent b is never more than one percent larger than the true magnitude.'This function is intended for use when n2 small enough that one might comfortably compute B_n exactly. It aborts if n, is so large that internal overflow occurs.Flint2bernoulli_cache_compute n 5Makes sure that the Bernoulli numbers up to at least B_{n-1} are cached. Calling flint_cleanup() frees the cache.!The cache is extended by calling bernoulli_fmpq_vec_no_cache internally.Flint2bernoulli_fmpq_vec_no_cache res a num Writes num" consecutive Bernoulli numbers to res starting with B_a>. This function is not currently optimized for a small count num. The entries are not read from or written to the Bernoulli number cache; if retrieving a vector of Bernoulli numbers is needed more than once, use bernoulli_cache_compute followed by bernoulli_fmpq_ui instead.#This function is a wrapper for the rev4 iterators. It can use multiple threads internally.Flint2bernoulli_rev_clear iter )Frees all memory allocated internally by iter.Flint2bernoulli_rev_next numer denom iter Sets numer and denom to the exact, reduced numerator and denominator of the Bernoulli number B_k and advances the state of iter( so that the next invocation generates B_{k-2}.Flint2bernoulli_rev_init iter n Initializes the iterator iter9. The first Bernoulli number to be generated by calling bernoulli_rev_next is B_n. It is assumed that n is even.4 Safe-Inferred )*1 None )*1 (Flint2mag_hurwitz_zeta_uiui res s a Sets res to an upper bound for +\zeta(s,a) = \sum_{k=0}^{\infty} (k+a)^{-s}. We use the formula` 6\zeta(s,a) \le \frac{1}{a^s} + \frac{1}{(s-1) a^{s-1}};which is obtained by estimating the sum by an integral. If s \le 1 or a = 0, the bound is infinite.Flint2mag_polylog_tail res z s d N Sets res to an upper bound for` .\sum_{k=N}^{\infty} \frac{z^k \log^d(k)}{k^s}.&The bounding strategy is described in algorithms_polylogarithms. Note: in applications where s in this formula may be real or complex, the user can simply substitute any convenient integer s' such that s' \le \operatorname{Re}(s).Flint2mag_bernoulli_div_fac_ui res n Sets res to an upper bound for  |B_n| / n! where B_n denotes a Bernoulli number.Flint2 mag_bin_uiui res n k Sets res1 to an upper bound for the binomial coefficient  {n \choose k}.Flint2 mag_rfac_ui res n Sets res to an upper bound for 1/n!.Flint2 mag_fac_ui res n Sets res to an upper bound for n!.Flint2mag_sinh_lower res x Sets res to an upper or lower bound for \cosh(x) or \sinh(x).Flint2mag_atan_lower res x Sets res- to an upper (respectively lower) bound for \operatorname{atan}(x).Flint2mag_const_pi_lower res Sets res, to an upper (respectively lower) bound for \pi.Flint2mag_geom_series res x N Sets res to an upper bound for \sum_{k=N}^{\infty} x^k.Flint2mag_binpow_uiui res m n Sets res to an upper bound for  (1 + 1/m)^n.Flint2 mag_exp_tail res x N Sets res to an upper bound for \sum_{k=N}^{\infty} x^k / k!.Flint2 mag_expm1 res x Sets res to an upper bound for  \exp(x) - 1.. The bound is computed accurately for small x.Flint2mag_expinv_lower res x Sets res to a lower bound for \exp(-x).Flint2 mag_expinv res x Sets res to an upper bound for \exp(-x).Flint2 mag_exp_lower res x Sets res to a lower bound for \exp(x).Flint2mag_exp res x Sets res to an upper bound for \exp(x).Flint2 mag_log1p res x Sets res to an upper bound for  \log(1+x).. The bound is computed accurately for small x.Flint2 mag_log_ui res n Sets res to an upper bound for \log(n).Flint2mag_neg_log_lower res x Sets res to a lower bound for -\log(\min(1,x)), i.e. a lower bound for  |\log(x)| for x \le 1.Flint2 mag_neg_log res x Sets res to an upper bound for -\log(\min(1,x)), i.e. an upper bound for  |\log(x)| for x \le 1.Flint2 mag_log_lower res x Sets res to a lower bound for \log(\max(1,x)).Flint2mag_log res x Sets res to an upper bound for \log(\max(1,x)).Flint2mag_root res x n Sets res to an upper bound for x^{1/n}.Flint2 mag_hypot res x y Sets res to an upper bound for \sqrt{x^2 + y^2}.Flint2mag_rsqrt_lower res x Sets res to an lower bound for  1/\sqrt{x}.Flint2 mag_rsqrt res x Sets res to an upper bound for  1/\sqrt{x}.Flint2mag_sqrt_lower res x Sets res to a lower bound for \sqrt{x}.Flint2mag_sqrt res x Sets res to an upper bound for \sqrt{x}.Flint2mag_pow_fmpz_lower res x e Sets res to a lower bound for x^e.Flint2 mag_pow_fmpz res x e Sets res to an upper bound for x^e.Flint2mag_fast_mul_2exp_si res x e Sets res to an upper bound for x 2^e.Flint2mag_fast_add_2exp_si res x e Sets res to an upper bound for x + 2^e.Flint2mag_fast_addmul z x y Sets z to an upper bound for z + xy.Flint2 mag_fast_mul res x y Sets res to an upper bound for xy.Flint2mag_fast_is_zero x Returns nonzero iff x to zero.Flint2 mag_fast_zero res Sets res to zero.Flint2mag_fast_init_set x y  Initialises x and sets it to the value of y.Flint2 mag_inv_lower res x Sets res to a lower bound for 1 / x.Flint2mag_inv res x Sets res to an upper bound for 1 / x.Flint2 mag_div_lower res x y Sets res to a lower bound for x / y.Flint2 mag_div_fmpz res x y Sets res to an upper bound for x / y.Flint2 mag_addmul z x y Sets z to an upper bound for z + xy.Flint2mag_mul_fmpz_lower res x y Sets res to a lower bound for xy.Flint2 mag_mul_fmpz res x y Sets res to an upper bound for xy.Flint2mag_mul_2exp_fmpz res x y Sets res to  x \cdot 2^y. This operation is exact.Flint2 mag_sub_lower res x y Sets res to a lower bound for  \max(x-y, 0).Flint2mag_sub res x y Sets res to an upper bound for  \max(x-y, 0).Flint2mag_add_ui_2exp_si res x y e Sets res to an upper bound for  x + y 2^e.Flint2mag_add_2exp_fmpz res x e Sets res to an upper bound for x + 2^e.Flint2mag_add_ui_lower res x y Sets res to a lower bound for x + y.Flint2 mag_add_ui res x y Sets res to an upper bound for x + y.Flint2mag_randtest_special res state expbits Like  mag_randtest, but also sometimes sets res to infinity.Flint2 mag_randtest res state expbits Sets res2 to a random finite value, with an exponent up to expbits bits large.Flint2 mag_load_file x stream Reads x from stream. Returns a nonzero value if the data is not formatted correctly or the read failed. Note that the data is assumed to be delimited by a whitespace or end-of-file, i.e., when writing multiple values with  mag_dump_file make sure to insert a whitespace to separate consecutive values.Flint2 mag_dump_file stream x "Writes a binary representation of x to stream that can be read by  mag_load_file<. Returns a nonzero value if the data could not be written.Flint2 mag_load_str x str Parses str into x. Returns a nonzero value if str is not formatted correctly.Flint2 mag_dump_str x 9Allocates a string and writes a binary representation of x to it that can be read by  mag_load_str4. The returned string needs to be deallocated with  flint_free.Flint2 mag_get_str x% Returns a string representation of x+. The memory needs to be deallocated with  flint_freeFlint2 mag_fprint file x Prints x to the stream file.Flint2mag_max res x y Sets res. respectively to the smaller or the larger of x and y.Flint2mag_cmp_2exp_si x y :Returns negative, zero, or positive, depending on whether x$ is smaller, equal, or larger than 2^y.Flint2mag_cmp x y :Returns negative, zero, or positive, depending on whether x$ is smaller, equal, or larger than y.Flint2 mag_equal x y Returns nonzero iff x and y have the same value.Flint2mag_get_fmpz_lower res x Sets res=, respectively, to the exact rational number represented by x;, the integer exactly representing the ceiling function of x=, or the integer exactly representing the floor function of x.These functions are unsafe: the user must check in advance that x! is of reasonable magnitude. If x is infinite or has a bignum exponent, an abort will be raised. If the exponent otherwise is too large or too small, the available memory could be exhausted resulting in undefined behavior.Flint2mag_get_d_log2_approx x  Returns a double approximating  \log_2(x), suitable for estimating magnitudes (warning: not a rigorous bound). The value is clamped between  COEFF_MIN and  COEFF_MAX.Flint2 mag_get_d x  Returns a double giving an upper bound for x.Flint2mag_set_fmpz_2exp_fmpz_lower res x y Sets res to a lower bound for  |x| \cdot 2^y.Flint2mag_set_ui_2exp_si res x y Sets res to an upper bound for  |x| \cdot 2^y.Flint2mag_set_fmpz_lower res x Sets res to a lower bound for |x|(. The operation may be inexact even if x is exactly representable.Flint2 mag_set_fmpz res x Sets res to an upper bound for |x|(. The operation may be inexact even if x is exactly representable.Flint2mag_set res x Sets res to the value of x!. This operation is always exact.Flint2 mag_init_set res x  Initializes res and sets it to the value of x". This operation is always exact.Flint2 mag_is_finite x Returns nonzero iff x is not positive infinity (since there is no NaN value, this function is exactly the logical negation of  mag_is_inf).Flint2 mag_is_inf x Returns nonzero iff x is positive infinity.Flint2 mag_is_zero x Returns nonzero iff x is zero.Flint2mag_is_special x Returns nonzero iff x is zero or positive infinity.Flint2mag_inf res Sets res to positive infinity.Flint2mag_one res Sets res to one.Flint2mag_zero res Sets res to zero.Flint2mag_allocated_bytes x Returns the total number of bytes heap-allocated internally by this object. The count excludes the size of the structure itself. Add sizeof(mag_struct)* to get the size of the object as a whole.Flint2_mag_vec_clear v n Clears a vector of length n.Flint2 _mag_vec_init n Allocates a vector of length n. All entries are set to zero.Flint2mag_swap x y Swaps x and y efficiently.Flint2 mag_clear x Clears the variable x,, freeing or recycling its allocated memory.Flint2mag_init x Initializes the variable x# for use. Its value is set to zero.Flint2 mag_print x Prints x to standard output. 5 Safe-Inferred )*1 a   Safe-Inferred )*1 yFlint2arb_hypgeom_sum_fmpq_imag_arb res1 res2 a alen b blen z  reciprocal N prec Sets res1 and res2 to the real and imaginary part of the finite hypergeometric sum 8\sum_{n=0}^{N-1} (\textbf{a})_n (i z)^n / (\textbf{b})_n. If  reciprocal is set, replace z by 1 / z.Flint2 arb_hypgeom_sum_fmpq_imag_arb_bs res1 res2 a alen b blen z  reciprocal N prec Flint2 arb_hypgeom_sum_fmpq_imag_arb_rs res1 res2 a alen b blen z  reciprocal N prec Flint2%arb_hypgeom_sum_fmpq_imag_arb_forward res1 res2 a alen b blen z  reciprocal N prec Flint2arb_hypgeom_sum_fmpq_arb res a alen b blen z  reciprocal N prec Sets res# to the finite hypergeometric sum 4\sum_{n=0}^{N-1} (\textbf{a})_n z^n / (\textbf{b})_n where %\textbf{x}_n = (x_1)_n (x_2)_n \cdots(, given vectors of rational parameters a (of length alen) and b (of length blen). If  reciprocal is set, replace z by 1 / z. The forward version uses the forward recurrence, optimized by delaying divisions, the rs version uses rectangular splitting, and the default version uses an automatic algorithm choice.Flint2arb_hypgeom_sum_fmpq_arb_rs res a alen b blen z  reciprocal N prec Flint2 arb_hypgeom_sum_fmpq_arb_forward res a alen b blen z  reciprocal N prec Flint2arb_hypgeom_dilog res z prec Computes the dilogarithm \operatorname{Li}_2(z).Flint2arb_hypgeom_legendre_p_ui_root res weight n k prec Sets res to the k$-th root of the Legendre polynomial P_n(x)). We index the roots in decreasing order` %1 > x_0 > x_1 > \ldots > x_{n-1} > -1,(which corresponds to ordering the roots of P_n(\cos(\theta)) in order of increasing \theta). If weight is non-NULL, it is set to the weight corresponding to the node x_k for Gaussian quadrature on [-1,1]. Note that only \lceil n / 2 \rceil roots need to be computed, since the remaining roots are given by x_k = -x_{n-1-k}.We compute an enclosing interval using an asymptotic approximation followed by some number of Newton iterations, using the error bounds given in  [Pet1999]. If very high precision is requested, the root is subsequently refined using interval Newton steps with doubling working precision.Flint2arb_hypgeom_legendre_p_ui res  res_prime n x prec +Evaluates the ordinary Legendre polynomial P_n(x). If  res_prime7 is non-NULL, simultaneously evaluates the derivative P'_n(x).&The overall algorithm is described in  [JM2018]. The versions zero, one; respectively use the hypergeometric series expansions at x = 0 and x = 1 while the asymp' version uses an asymptotic series on (-1,1) intended for large n. The parameter K specifies the exact number of expansion terms to use (if the series expansion truncated at this point does not give the exact polynomial, an error bound is computed automatically). The asymptotic expansion with error bounds is given in  [Bog2012]. The rec version uses the forward recurrence implemented using fixed-point arithmetic; it is only intended for the interval (-1,1) , moderate n and modest precision.The default version attempts to choose the best algorithm automatically. It also estimates the amount of cancellation in the hypergeometric series and increases the working precision to compensate, bounding the propagated error using derivative bounds.Flint2arb_hypgeom_legendre_p_ui_asymp res  res_prime n x K prec Flint2arb_hypgeom_legendre_p_ui_one res  res_prime n x K prec Flint2arb_hypgeom_legendre_p_ui_zero res  res_prime n x K prec Flint2%arb_hypgeom_legendre_p_ui_deriv_bound dp dp2 n x x2sub1 Sets dp to an upper bound for P'_n(x) and dp2 to an upper bound for P''_n(x) given x* assumed to represent a real number with  |x| \le 1. The variable x2sub1% must contain the precomputed value 1-x^2 (or x^2-1). This method is used internally to bound the propagated error for Legendre polynomials.Flint2arb_hypgeom_legendre_q res n m z type prec ?Computes Legendre functions of the first and second kind. See acb_hypgeom_legendre_p and acb_hypgeom_legendre_q for definitions.Flint2arb_hypgeom_legendre_p res n m z type prec Flint2arb_hypgeom_hermite_h res nu z prec Computes Chebyshev, Jacobi, Gegenbauer, Laguerre or Hermite polynomials, or their extensions to non-integer orders.Flint2arb_hypgeom_laguerre_l res n m z prec Flint2arb_hypgeom_gegenbauer_c res n m z prec Flint2arb_hypgeom_jacobi_p res n a b z prec Flint2arb_hypgeom_chebyshev_u res nu z prec Flint2arb_hypgeom_chebyshev_t res nu z prec Flint2arb_hypgeom_coulomb_series F G l eta z len prec Computes the Coulomb wave functions evaluated at the power series z, truncated to length len. Either of the outputs can be NULL.Flint2_arb_hypgeom_coulomb_series F G l eta z zlen len prec Flint2arb_hypgeom_coulomb_jet F G l eta z len prec  Writes to F, G the respective Taylor expansions of the Coulomb wave functions at the point z, truncated to length len . Either of the outputs can be NULL.Flint2arb_hypgeom_coulomb F G l eta z prec  Writes to F, G6 the values of the respective Coulomb wave functions F_{\ell}(\eta,z) and G_{\ell}(\eta,z) . Either of the outputs can be NULL.Flint2arb_hypgeom_airy_zero a a_prime b b_prime n prec  Computes the n-th real zero a_n, a'_n, b_n, or b'_n for the respective Airy function or Airy function derivative. Any combination of the four output variables can be NULL. The zeros are indexed by increasing magnitude, starting with n = 17 to follow the convention in the literature. An index n that is not positive is invalid input. The implementation uses asymptotic expansions for the zeros  [PS1991]: together with the interval Newton method for refinement.Flint2arb_hypgeom_airy_series ai ai_prime bi bi_prime z len prec :Computes the Airy functions evaluated at the power series z, truncated to length len=. As with the other Airy methods, any of the outputs can be NULL.Flint2_arb_hypgeom_airy_series ai ai_prime bi bi_prime z zlen len prec Flint2arb_hypgeom_airy_jet ai bi z len prec  Writes to ai and bi the respective Taylor expansions of the Airy functions at the point z, truncated to length len . Either of the outputs can be NULL0 to avoid computing that function. The variable z is not allowed to be aliased with the outputs. To simplify the implementation, this method does not compute the series expansions of the primed versions directly; these are easily obtained by computing one extra coefficient and differentiating the output with _arb_poly_derivative.Flint2arb_hypgeom_airy ai ai_prime bi bi_prime z prec Computes the Airy functions (\operatorname{Ai}(z), \operatorname{Ai}'(z), \operatorname{Bi}(z), \operatorname{Bi}'(z)) simultaneously. Any of the four function values can be omitted by passing NULL for the unwanted output variables, speeding up the evaluation.Flint2 arb_hypgeom_bessel_k_integration res nu z scaled prec Computes the modified Bessel functions using numerical integration.Flint2 arb_hypgeom_bessel_i_integration res nu z scaled prec Flint2arb_hypgeom_bessel_k_scaled res nu z prec Computes the function e^{z} K_{\nu}(z).Flint2arb_hypgeom_bessel_k res nu z prec 9Computes the modified Bessel function of the second kind  K_{\nu}(z).Flint2arb_hypgeom_bessel_i_scaled res nu z prec Computes the function e^{-z} I_{\nu}(z).Flint2arb_hypgeom_bessel_i res nu z prec 9Computes the modified Bessel function of the first kind ,I_{\nu}(z) = z^{\nu} (iz)^{-\nu} J_{\nu}(iz).Flint2arb_hypgeom_bessel_jy res1 res2 nu z prec Sets res1 to  J_{\nu}(z) and res2 to  Y_{\nu}(z), computed simultaneously.Flint2arb_hypgeom_bessel_y res nu z prec 0Computes the Bessel function of the second kind  Y_{\nu}(z).Flint2arb_hypgeom_bessel_j res nu z prec /Computes the Bessel function of the first kind  J_{\nu}(z).Flint2arb_hypgeom_li_series res z offset len prec Computes the logarithmic integral (optionally the offset version) of the power series z, truncated to length len.Flint2_arb_hypgeom_li_series res z zlen offset len prec Flint2arb_hypgeom_li res z offset prec If offset- is zero, computes the logarithmic integral 1\operatorname{li}(z) = \operatorname{Ei}(\log(z)).If offset7 is nonzero, computes the offset logarithmic integral \operatorname{Li}(z) = \operatorname{li}(z) - \operatorname{li}(2).The result is indeterminate if z < 03 since the value of the function would be complex.Flint2arb_hypgeom_chi_series res z len prec Computes the complementary error function of the power series z, truncated to length len.Flint2_arb_hypgeom_erfc_series res z zlen len prec Flint2arb_hypgeom_erfc res z prec +Computes the complementary error function 2\operatorname{erfc}(z) = 1 - \operatorname{erf}(z). This function avoids catastrophic cancellation for large positive z.Flint2arb_hypgeom_erf_series res z len prec 0Computes the error function of the power series z, truncated to length len.Flint2_arb_hypgeom_erf_series res z zlen len prec Flint2arb_hypgeom_erf res z prec Computes the error function \operatorname{erf}(z).Flint2arb_hypgeom_2f1_integration res a b z  regularized prec Computes the Gauss hypergeometric function using numerical integration of the representation` {}_2F_1(a,b,c,z) = \frac{\Gamma(a)}{\Gamma(b) \Gamma(c-b)} \int_0^1 t^{b-1} (1-t)^{c-b-1} (1-zt)^{-a} dt.This algorithm can be useful if the parameters are large. This will currently only return a finite enclosure if b \ge 1 and  c - b \ge 1 and z < 1, possibly with a and b exchanged.Flint2arb_hypgeom_2f1 res a b c z  regularized prec +Computes the Gauss hypergeometric function {}_2F_1(a,b,c,z), or :\mathbf{F}(a,b,c,z) = \frac{1}{\Gamma(c)} {}_2F_1(a,b,c,z) if  regularized is set.2Additional evaluation flags can be passed via the  regularized argument; see acb_hypgeom_2f1 for documentation.Flint2arb_hypgeom_u_integration res a b z  regularized prec /Computes the confluent hypergeometric function U(a,b,z)3 using numerical integration of the representation` U(a,b,z) = \frac{1}{\Gamma(a)} \int_0^{\infty} e^{-zt} t^{a-1} (1+t)^{b-a-1} dt.This algorithm can be useful if the parameters are large. This will currently only return a finite enclosure if a \ge 1 and z > 0.Flint2 arb_hypgeom_u res a b z prec /Computes the confluent hypergeometric function U(a,b,z).Flint2arb_hypgeom_1f1_integration res a b z  regularized prec Computes the confluent hypergeometric function using numerical integration of the representation` {}_1F_1(a,b,z) = \frac{\Gamma(b)}{\Gamma(a) \Gamma(b-a)} \int_0^1 e^{zt} t^{a-1} (1-t)^{b-a-1} dt.This algorithm can be useful if the parameters are large. This will currently only return a finite enclosure if a \ge 1 and  b - a \ge 1.Flint2arb_hypgeom_1f1 res a b z  regularized prec  Alias for  arb_hypgeom_m.Flint2 arb_hypgeom_m res a b z  regularized prec 0Computes the confluent hypergeometric function M(a,b,z) = {}_1F_1(a,b,z), or 6\mathbf{M}(a,b,z) = \frac{1}{\Gamma(b)} {}_1F_1(a,b,z) if  regularized is set.Flint2arb_hypgeom_0f1 res a z  regularized prec 5Computes the confluent hypergeometric limit function  {}_0F_1(a,z), or  \frac{1}{\Gamma(a)} {}_0F_1(a,z) if  regularized is set.Flint2arb_hypgeom_pfq res a p b q z  regularized prec 1Computes the generalized hypergeometric function  {}_pF_{q}(z)!, or the regularized version if  regularized is set.Flint2arb_hypgeom_central_bin_ui res n prec *Computes the central binomial coefficient {2n \choose n}.Flint2arb_hypgeom_lgamma res x prec Sets res to the log-gamma function of x, computed using a default algorithm choice.Flint2arb_hypgeom_rgamma res x prec Sets res% to the reciprocal gamma function of x, computed using a default algorithm choice.Flint2arb_hypgeom_gamma_fmpz res x prec Sets res to the gamma function of x, computed using a default algorithm choice.Flint2arb_hypgeom_gamma_fmpq res x prec Flint2arb_hypgeom_gamma res x prec Flint2arb_hypgeom_gamma_taylor res x  reciprocal prec *Attempts to compute the gamma function of x using Taylor series together with argument reduction. This is only supported if x and prec are both small enough. If successful, returns 1; otherwise, does nothing and returns 0. If  reciprocal< is set, the reciprocal gamma function is computed instead.Flint2arb_hypgeom_gamma_stirling res x  reciprocal prec Sets res to the gamma function of x computed using the Stirling series together with argument reduction. If  reciprocal< is set, the reciprocal gamma function is computed instead.Flint2'arb_hypgeom_gamma_stirling_sum_improved res z N K prec Sets res to the final sum in the Stirling series for the gamma function truncated before the term with index N, i.e. computes -\sum_{n=1}^{N-1} B_{2n} / (2n(2n-1) z^{2n-1}). The horner version uses Horner scheme with gradual precision adjustments. The improved version uses rectangular splitting for the low-index terms and reexpands the high-index terms as hypergeometric polynomials, using a splitting parameter K0 (which can be set to 0 to use a default value).Flint2%arb_hypgeom_gamma_stirling_sum_horner res z N prec Flint2'_arb_hypgeom_gamma_stirling_term_bounds bound zinv N For  1 \le n < N, sets bound to an exponent bounding the n-th term in the Stirling series for the gamma function, given a precomputed upper bound for |z|^{-1}. This function is intended for internal use and does not check for underflow or underflow in the exponents.Flint2arb_hypgeom_rising_ui_jet res x n len prec )Computes the jet of the rising factorial (x)_n, truncated to length len-. In other words, constructs the polynomial (X + x)_n \in \mathbb{R}[X], truncated if \operatorname{len} < n + 1 (and zero-extended if \operatorname{len} > n + 1).The powsum, version computes the sequence of powers of x7 and forms integral linear combinations of these. The bs% version uses binary splitting. The rs version uses rectangular splitting. It takes an extra tuning parameter m which can be set to zero to choose automatically. The default version chooses an algorithm automatically.Flint2arb_hypgeom_rising_ui_jet_rs res x n m len prec Flint2arb_hypgeom_rising_ui_jet_bs res x n len prec Flint2 arb_hypgeom_rising_ui_jet_powsum res x n len prec Flint2arb_hypgeom_rising res x n prec Computes the rising factorial (x)_n.The forward* version uses the forward recurrence. The bs% version uses binary splitting. The rs version uses rectangular splitting. It takes an extra tuning parameter m8 which can be set to zero to choose automatically. The rec version chooses an algorithm automatically, avoiding use of the gamma function (so that it can be used in the computation of the gamma function). The default versions ( rising_ui and  rising_ui) choose an algorithm automatically and may additionally fall back on the gamma function.Flint2arb_hypgeom_rising_ui res x n prec Flint2arb_hypgeom_rising_ui_rec res x n prec Flint2arb_hypgeom_rising_ui_rs res x n m prec Flint2arb_hypgeom_rising_ui_bs res x n prec Flint2arb_hypgeom_rising_ui_forward res x n prec Flint2_arb_hypgeom_rising_coeffs_fmpz c k n Sets c9 to the coefficients of the rising factorial polynomial (X+k)_n. The 1 and 2 versions respectively compute single-word and double-word coefficients, without checking for overflow, while the fmpz version allows arbitrarily large coefficients. These functions are mostly intended for internal use; the fmpz version does not use an asymptotically fast algorithm. The degree n must be at least 2.Flint2_arb_hypgeom_rising_coeffs_2 c k n Flint2_arb_hypgeom_rising_coeffs_1 c k n 6 Safe-Inferred )*1  Safe-Inferred )*1 Flint2_arb_vec_get_unique_fmpz_vec res vec len Calls arb_get_unique_fmpz elementwise and returns nonzero if all entries can be rounded uniquely to integers. If any entry in vec9 cannot be rounded uniquely to an integer, returns zero.Flint2 _arb_vec_trim res vec len Applies arb_trim elementwise.Flint2_arb_vec_indeterminate vec len Applies arb_indeterminate elementwise.Flint2_arb_vec_add_error_mag_vec res err len $Adds the magnitude of each entry in err. to the radius of the corresponding entry in res.Flint2_arb_vec_set_powers xs x len prec Sets xs to the powers 1, x, x^2, \ldots, x^{len-1}.Flint2 _arb_vec_bits x len Returns the maximum of arb_bits for all entries in vec.Flint2_arb_vec_get_mag bound vec len prec Sets bound& to an upper bound for the entries in vec.Flint2_arb_vec_scalar_addmul res vec len c prec 5Performs the respective scalar operation elementwise.Flint2 _arb_vec_swap vec1 vec2 len Swaps the entries of vec1 and vec2.Flint2_arb_vec_set_round res vec len prec Sets res to a copy of vec, rounding each entry to prec bits.Flint2 _arb_vec_set res vec len Sets res to a copy of vec.Flint2_arb_vec_is_finite x len #Returns nonzero iff all entries in x certainly are finite.Flint2_arb_vec_is_zero vec len #Returns nonzero iff all entries in x are zero.Flint2 _arb_vec_zero vec n Sets all entries in vec to zero.Flint2arb_atan_newton res x prec /Computes the arctangent using Newton iteration.Flint2arb_sin_cos_arf_atan_reduction res1 res2 x prec  uses lookup tables if possible, and otherwise falls back to arb_atan_arf_bb.Flint2 arb_sinc_pi z x prec Sets 6z = \operatorname{sinc}(\pi x) = \sin(\pi x) / (\pi x).Flint2arb_sinc z x prec Sets (z = \operatorname{sinc}(x) = \sin(x) / x.Flint2 arb_csc_pi res x prec  Computes \csc(\pi x) = 1 / \sin(\pi x).Flint2arb_csc res x prec  Computes \csc(x) = 1 / \sin(x).Flint2arb_sec res x prec  Computes \sec(x) = 1 / \cos(x).Flint2 arb_cot_pi y x prec Sets y = \cot(\pi x).Flint2 arb_tan_pi y x prec Sets y = \tan(\pi x).Flint2arb_cos_pi_fmpq c x prec Sets s = \sin(\pi x), c = \cos(\pi x) where x is a rational number (whose numerator and denominator are assumed to be reduced). We first use trigonometric symmetries to reduce the argument to the octant [0, 1/4];. Then we either multiply by a numerical approximation of \pi and evaluate the trigonometric function the usual way, or we use algebraic methods, depending on which is estimated to be faster. Since the argument has been reduced to the first octant, the first of these two methods gives full accuracy even if the original argument is close to some root other the origin.Flint2arb_cot y x prec Sets y = \cot(x) = \cos(x) / \sin(y).Flint2arb_tan y x prec Sets y = \tan(x) = \sin(x) / \cos(y).Flint2arb_sin_cos_pi s c x prec Sets s = \sin(\pi x), c = \cos(\pi x).Flint2 arb_sin_cos s c x prec Sets  s = \sin(x),  c = \cos(x).Flint2arb_exp_invexp z w x prec Sets  z = \exp(x) and  w = \exp(-x). The second exponential is computed from the first using a division, but propagated error bounds are computed separately.Flint2 arb_expm1 z x prec Sets  z = \exp(x)-1%, using a more accurate method when  x \approx 0.Flint2arb_exp z x prec Sets  z = \exp(x). Error propagation is done using the following rule: assuming  x = m \pm r, the error is largest at m + r, and we have 9\exp(m+r) - \exp(m) = \exp(m) (\exp(r)-1) \le r \exp(m+r).Flint2 arb_log_hypot res x y prec Sets res to \log(\sqrt{x^2+y^2}).Flint2arb_log_base_ui res x b prec Sets res to  \log_b(x)0. The result is computed exactly when possible.Flint2 arb_log1p z x prec Sets  z = \log(1+x), computed accurately when  x \approx 0.Flint2arb_log_ui_from_prev log_k1 k1 log_k0 k0 prec  Computes  \log(k_1), given  \log(k_0) where  k_0 < k_16. At high precision, this function uses the formula \log(k_1) = \log(k_0) + 2 \operatorname{atanh}((k_1-k_0)/(k_1+k_0)), evaluating the inverse hyperbolic tangent using binary splitting (for best efficiency, k_0 should be large and  k_1 - k_0* should be small). Otherwise, it ignores  \log(k_0), and evaluates the logarithm the usual way.Flint2arb_log z x prec Sets  z = \log(x).4At low to medium precision (up to about 4096 bits),  arb_log_arf uses table-based argument reduction and fast Taylor series evaluation via _arb_atan_taylor_rs:. At high precision, it falls back to MPFR. The function arb_log simply calls  arb_log_arf with the midpoint as input, and separately adds the propagated error.Flint2arb_pow z x y prec Sets z = x^y*, computed using binary exponentiation if y is a small exact integer, as z = (x^{1/2})^{2y} if y2 is a small exact half-integer, and generally as z = \exp(y \log x)., except giving the obvious finite result if x is a \pm a and y is positive.Flint2 arb_pow_fmpq y x a prec Sets y = b^e, computed as y = (b^{1/q})^p if the denominator of e = p/q is small, and generally as y = \exp(e \log b).Note that this function can get slow if the exponent is extremely large (in such cases arb_pow may be superior).Flint2 arb_si_pow_ui y b e prec Sets y = b^e; using binary exponentiation (with an initial division if e < 0). Provided that b and e are small enough and the exponent is positive, the exact power can be computed by setting the precision to ARF_PREC_EXACT.Note that these functions can get slow if the exponent is extremely large (in such cases arb_pow may be superior).Flint2arb_sqr y x prec Sets y to be the square of x.Flint2arb_root z x k prec  Alias for  arb_root_ui', provided for backwards compatibility.Flint2 arb_root_ui z x k prec Sets z to the k -th root of x , rounded to prec bits. This function selects between different algorithms. For large k, it evaluates \exp(\log(x)/k) . For small k , it uses arf_root at the midpoint and computes a propagated error bound as follows: if input interval is  [m-r, m+r] with r \le m, the error is largest at m-r where it satisfies` 3m^{1/k} - (m-r)^{1/k} = m^{1/k} [1 - (1-r/m)^{1/k}] #= m^{1/k} [1 - \exp(\log(1-r/m)/k)] #\le m^{1/k} \min(1, -\log(1-r/m)/k) %= m^{1/k} \min(1, \log(1+r/(m-r))/k).This is evaluated using  mag_log1p.Flint2 arb_sqrt1pm1 z x prec Sets z = \sqrt{1+x}-1, computed accurately when  x \approx 0.Flint2 arb_rsqrt_ui z x prec Sets z" to the reciprocal square root of x , rounded to prec bits. At high precision, this is faster than computing a square root.Flint2 arb_hypot z x y prec Sets z to \sqrt{x^2 + y^2}.Flint2 arb_sqrtpos z x prec Sets z to the square root of x, assuming that x represents a nonnegative number (i.e. discarding any negative numbers in the input interval).Flint2 arb_sqrt_ui z x prec Sets z to the square root of x , rounded to prec bits.If  x = m \pm x where  m \ge r \ge 0', the propagated error is bounded by \sqrt{m} - \sqrt{m-r} = \sqrt{m} (1 - \sqrt{1 - r/m}) \le \sqrt{m} (r/m + (r/m)^2)/2.Flint2 arb_dot_ui res initial subtract x xstep y ystep len prec Equivalent to arb_dot!, but with integers in the array y. The uiui and siui? versions take an array of double-limb integers as input; the siui version assumes that these represent signed integers in two's complement form.Flint2arb_approx_dot res s subtract x xstep y ystep len prec $Computes an approximate dot product without error bounds. The radii of the inputs are ignored (only the midpoints are read) and only the midpoint of the output is written. Flint2arb_dot_precise res s subtract x xstep y ystep len prec (Computes the dot product of the vectors x and y , setting res to .s + (-1)^{subtract} \sum_{i=0}^{len-1} x_i y_i.The initial term s+ is optional and can be omitted by passing NULL (equivalently, s = 0). The parameter subtract must be 0 or 1. The length len is allowed to be negative, which is equivalent to a length of zero. The parameters xstep or ystep specify a step length for traversing subsequences of the vectors x and y; either can be negative to step in the reverse direction starting from the initial pointer. Aliasing is allowed between res and s but not between res and the entries of x and y.The default version determines the optimal precision for each term and performs all internal calculations using mpn arithmetic with minimal overhead. This is the preferred way to compute a dot product; it is generally much faster and more precise than a simple loop.The simple version performs fused multiply-add operations in a simple loop. This can be used for testing purposes and is also used as a fallback by the default version when the exponents are out of range for the optimized code.The precise version computes the dot product exactly up to the final rounding. This can be extremely slow and is only intended for testing. Flint2arb_div_2expm1_ui z x n prec Sets z = x / (2^n - 1) , rounded to prec bits. Flint2 arb_ui_div z x y prec Sets  z = x / y , rounded to prec bits. If y contains zero, z is set to  0 \pm \infty,. Otherwise, error propagation uses the rule` \left| \frac{x}{y} - \frac{x+\xi_1 a}{y+\xi_2 b} \right| = \left|\frac{x \xi_2 b - y \xi_1 a}{y (y+\xi_2 b)}\right| \le \frac{|xb|+|ya|}{|y| (|y|-b)}where -1 \le \xi_1, \xi_2 \le 1, and where the triangle inequality has been applied to the numerator and the reverse triangle inequality has been applied to the denominator. Flint2arb_inv z x prec Sets z to 1 / x. Flint2arb_fma res x y z prec Sets res to  x \cdot y + z. This is equivalent to an addmul except that res and z can be separate variables. Flint2arb_submul_fmpz z x y prec Sets z = z - x \cdot y., rounded to prec bits. The precision can be ARF_PREC_EXACT) provided that the result fits in memory. Flint2arb_addmul_fmpz z x y prec Sets z = z + x \cdot y., rounded to prec bits. The precision can be ARF_PREC_EXACT) provided that the result fits in memory. Flint2arb_mul_2exp_fmpz y x e Sets y to x multiplied by 2^e. Flint2 arb_mul_fmpz z x y prec Sets  z = x \cdot y , rounded to prec bits. The precision can be ARF_PREC_EXACT) provided that the result fits in memory. Flint2 arb_sub_fmpz z x y prec Sets  z = x - y , rounded to prec bits. The precision can be ARF_PREC_EXACT) provided that the result fits in memory. Flint2arb_add_fmpz_2exp z x m e prec Sets z = x + m \cdot 2^e , rounded to prec bits. The precision can be ARF_PREC_EXACT) provided that the result fits in memory. Flint2 arb_add_fmpz z x y prec Sets  z = x + y , rounded to prec bits. The precision can be ARF_PREC_EXACT) provided that the result fits in memory. Flint2arb_max z x y prec Sets z0 respectively to the minimum and the maximum of x and y. Flint2arb_sgn_nonzero x  Returns 1 if x is strictly positive, -1 if x! is strictly negative, and 0 if x is zero or a ball containing zero so that its sign is not determined. Flint2arb_sgn y x Sets y to the sign function of x. The result is  [0 \pm 1] if x) contains both zero and nonzero numbers. Flint2arb_nonnegative_abs y x Sets y to the absolute value of x. If x' is finite and it contains zero, sets y to some interval  [r \pm r]& that contains the absolute value of x. Flint2arb_abs y x Sets y to the absolute value of x=. No attempt is made to improve the interval represented by x if it contains zero. Flint2 arb_neg_round y x prec Sets y to the negation of x. Flint2arb_ge x y %Respectively performs the comparison x = y, x \ne y, x < y, x \le y, x > y, x \ge y8 in a mathematically meaningful way. If the comparison t \, (\operatorname{op}) \, u holds for all t \in x and all u \in y", returns 1. Otherwise, returns 0. The balls x and y are viewed as subintervals of the extended real line. Note that balls that are formally different can compare as equal under this definition: for example, ![-\infty \pm 3] = [-\infty \pm 0]. Also ![-\infty] \le [\infty \pm \infty].;The output is always 0 if either input has NaN as midpoint. Flint2arb_contains_interior x y  Tests if y! is contained in the interior of x; that is, contained in x" and not touching either endpoint. Flint2arb_contains_nonnegative x 'Returns nonzero iff there is any point p! in the interval represented by x satisfying, respectively, p = 0, p < 0, p \le 0, p > 0, p \ge 0. If x contains NaN, returns nonzero. Flint2arb_contains_int x 0Returns nonzero iff the interval represented by x contains an integer. Flint2 arb_contains x y /Returns nonzero iff the given number (or ball) y. is contained in the interval represented by x.If x contains NaN, this function always returns nonzero (as it could represent anything, and in particular could represent all the points included in y). If y contains NaN and x# does not, it always returns zero. Flint2 arb_overlaps x y Returns nonzero iff x and y& have some point in common. If either x or y contains NaN, this function always returns nonzero (as a NaN could be anything, it could in particular contain any number that is included in the other operand). Flint2arb_is_nonpositive x Returns nonzero iff all points p in the interval represented by x satisfy, respectively, p > 0, p \ge 0, p < 0, p \le 0. If x contains NaN, returns zero. Flint2 arb_equal_si x y Returns nonzero iff x is equal to the integer y. Flint2 arb_equal x y Returns nonzero iff x and y are equal as balls, i.e. have both the same midpoint and radius.=Note that this is not the same thing as testing whether both x and y: certainly represent the same real number, unless either x or y is exact (and neither contains NaN). To test whether both operands might0 represent the same mathematical quantity, use  arb_overlaps or  arb_contains , depending on the circumstance. Flint2arb_is_int_2exp_si x e Returns nonzero iff x exactly equals n 2^e for some integer n. Flint2 arb_is_int x Returns nonzero iff x is an exact integer. Flint2 arb_is_exact x "Returns nonzero iff the radius of x is zero. Flint2 arb_is_finite x /Returns nonzero iff the midpoint and radius of x are both finite floating-point numbers, i.e. not infinities or NaN. Flint2 arb_is_one f Returns nonzero iff x is exactly 1. Flint2arb_is_nonzero x Returns nonzero iff zero is not contained in the interval represented by x. Flint2 arb_is_zero x /Returns nonzero iff the midpoint and radius of x are both zero. Flint2arb_can_round_mpfr x prec rnd ,Returns nonzero if rounding the midpoint of x to prec bits in the direction rnd is guaranteed to give the unique correctly rounded floating-point approximation for the real number represented by x.Subintervals with any other flag may or may not contain roots.=If no flags other than 1 occur, all roots of the function on interval have been isolated. If there are output subintervals on which the existence or nonexistence of roots could not be determined, the user may attempt further searches on those subintervals (possibly with increased precision and/or increased bounds for the breaking criteria). Note that roots of multiplicity higher than one and roots located exactly at endpoints cannot be isolated by the algorithm.0The following breaking criteria are implemented:At most maxdepth recursive subdivisions are attempted. The smallest details that can be distinguished are therefore about 2^{-\text{maxdepth}} times the width of interval>. A typical, reasonable value might be between 20 and 50.3If the total number of tested subintervals exceeds maxeval, the algorithm is terminated and any untested subintervals are added to the output. The total number of calls to func3 is thereby restricted to a small multiple of maxeval (the actual count can be slightly higher depending on implementation details). A typical, reasonable value might be between 100 and 100000.The algorithm terminates if maxfound7 roots have been isolated. In particular, setting maxfound to 1 can be used to locate just one root of the function even if there are numerous roots. To try to find all roots, LONG_MAX may be passed. The argument prec denotes the precision used to evaluate the function. It is possibly also used for some other arithmetic operations performed internally by the algorithm. Note that it probably does not make sense for maxdepth to exceed prec.2Warning: it is assumed that subdivision points of interval can be represented exactly as floating-point numbers in memory. Do not pass 1 \pm 2^{-10^{100}} as input.!Flint2arf_interval_fprintd file v n .Helper functions for endpoint-based intervals.!Flint2arf_interval_get_arb x v prec !Flint2arf_interval_swap v u !Flint2arf_interval_set v u !Flint2_arf_interval_vec_clear v n !Flint2_arf_interval_vec_init n !Flint2arf_interval_clear v !Flint2arf_interval_init v !Flint2 Create a new ! structure.!Flint2Use ! structure.!Flint2Use new ! structure.!Flint2arf_interval_printd v n .Helper functions for endpoint-based intervals.!!!!!!!!!!!!!!!!!!!!!!!!!9 Safe-Inferred )*1 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Safe-Inferred )*1 ˜!Flint2_arf_set_round_mpn z  exp_shift x xn sgnbit prec rnd Sets the mantissa of z to the mantissa given by the xn limbs in x, negated if sgnbit is 1, rounded to prec% bits in the direction specified by rnd*. Returns the inexact flag. Requires that xn' is positive and that the top limb of x is nonzero. If x- has leading zero bits, writes the shift to  exp_shift.. This method does not write the exponent of z directly. Requires that x! does not point to the limbs of z.!Flint2_arf_set_round_uiui z fix hi lo sgnbit prec rnd Sets the mantissa of z# to the two-limb mantissa given by hi and lo , negated if sgnbit is 1, rounded to prec% bits in the direction specified by rnd. Requires that not both hi and lo) are zero. Writes the exponent shift to fix! without writing the exponent of z directly.!Flint2_arf_set_round_ui z x sgnbit prec rnd Sets z to the integer x , negated if sgnbit is 1, rounded to prec% bits in the direction specified by rnd. There are no assumptions on x.!Flint2_arf_set_mpn_fixed z xp xn fixn negative prec rnd Sets z" to the fixed-point number having xn total limbs and fixn fractional limbs, negated if negative is set, rounding z to prec bits in the direction rnd4 and returning whether the result is inexact. Both xn and fixn must be nonnegative and not so large that the bit shift would overflow an slong9, but otherwise no assumptions are made about the input.!Flint2_arf_get_integer_mpn y xp xn exp Given a floating-point number x represented by xn limbs at xp and an exponent exp, writes the integer part of x to y, returning whether the result is inexact. The correct number of limbs is written (no limbs are written if the integer part of x is zero). Assumes that xp[0]$ is nonzero and that the top bit of xp[xn-1] is set.!Flint2arf_complex_sqr e f a b prec rnd Computes the complex square e + fi = (a + bi)^2,. This function has identical semantics to arf_complex_mul (with  c = a, b = d), but is faster.!Flint2arf_complex_mul_fallback e f a b c d prec rnd Computes the complex product e + fi = (a + bi)(c + di), rounding both e and f correctly to prec% bits in the direction specified by rnd=. The first bit in the return code indicates inexactness of e., and the second bit indicates inexactness of f.If any of the components a, b, c, d is zero, two real multiplications and no additions are done. This convention is used even if any other part contains an infinity or NaN, and the behavior with infinite/NaN input is defined accordingly.The fallback version is implemented naively, for testing purposes. No squaring optimization is implemented.!Flint2arf_complex_mul e f a b c d prec rnd !Flint2arf_root res x k prec rnd Sets res to x^{1/k}. The result is NaN if x is negative. Warning: this function is a wrapper around the MPFR root function. It gets slow and uses much memory for large k. Consider working with  arb_root_ui for large k) instead of using this function directly.!Flint2 arf_rsqrt res x prec rnd Sets res to  1/\sqrt{x}. The result is NaN if x is negative, and +\infty if x is zero.!Flint2 arf_sqrt_fmpz res x prec rnd Sets res to \sqrt{x}. The result is NaN if x is negative.!Flint2 arf_sqrt_ui res x prec rnd !Flint2arf_sqrt res x prec rnd !Flint2arf_fmpz_div_fmpz res x y prec rnd Sets res to x / y , rounded to prec% bits in the direction specified by rnd, returning nonzero iff the operation is inexact. The result is NaN if y is zero.!Flint2 arf_fmpz_div res x y prec rnd !Flint2 arf_div_fmpz res x y prec rnd !Flint2 arf_si_div res x y prec rnd !Flint2 arf_div_si res x y prec rnd !Flint2 arf_ui_div res x y prec rnd !Flint2 arf_div_ui res x y prec rnd !Flint2arf_div res x y prec rnd !Flint2arf_approx_dot res initial subtract x xstep y ystep len prec rnd Computes an approximate dot product, with the same meaning of the parameters as arb_dot. This operation is not correctly rounded: the final rounding is done in the direction rnd8 but intermediate roundings are implementation-defined.!Flint2arf_sum res terms len prec rnd Sets res to the sum of the array terms of length len, rounded to prec$ bits in the direction specified by rnd. The sum is computed as if done without any intermediate rounding error, with only a single rounding applied to the final result. Unlike repeated calls to arf_add with infinite precision, this function does not overflow if the magnitudes of the terms are far apart. Warning: this function is implemented naively, and the running time is quadratic with respect to len in the worst case.!Flint2arf_sosq res x y prec rnd Sets res to  x^2 + y^2 , rounded to prec% bits in the direction specified by rnd.!Flint2arf_fma res x y z prec rnd Sets res to  x \cdot y + z. This is equivalent to an addmul except that res and z can be separate variables.!Flint2arf_submul_fmpz z x y prec rnd #Performs a fused multiply-subtract z = z - x \cdot y , updating z in-place.!Flint2arf_submul_mpz z x y prec rnd !Flint2 arf_submul_si z x y prec rnd !Flint2 arf_submul_ui z x y prec rnd !Flint2 arf_submul z x y prec rnd !Flint2arf_addmul_fmpz z x y prec rnd Performs a fused multiply-add z = z + x \cdot y , updating z in-place.!Flint2arf_addmul_mpz z x y prec rnd !Flint2 arf_addmul_si z x y prec rnd !Flint2 arf_addmul_ui z x y prec rnd !Flint2 arf_addmul z x y prec rnd !Flint2 arf_mul_fmpz res x y prec rnd Sets res to  x \cdot y.!Flint2 arf_mul_mpz res x y prec rnd !Flint2 arf_mul_si res x y prec rnd !Flint2 arf_mul_ui res x y prec rnd !Flint2arf_mul res x y prec rnd !Flint2arf_mul_2exp_fmpz res x e Sets res to x 2^e exactly.!Flint2arf_mul_2exp_si res x e !Flint2 arf_sub_fmpz res x y prec rnd Sets res to x - y.!Flint2 arf_sub_ui res x y prec rnd !Flint2 arf_sub_si res x y prec rnd !Flint2arf_sub res x y prec rnd !Flint2arf_add_fmpz_2exp res x y e prec rnd Sets res to  x + y 2^e.!Flint2 arf_add_fmpz res x y prec rnd Sets res to x + y.!Flint2 arf_add_ui res x y prec rnd !Flint2 arf_add_si res x y prec rnd !Flint2arf_add res x y prec rnd !Flint2 arf_neg_round res x prec rnd Sets res to -x.!Flint2arf_neg res x Sets res to -x exactly.!Flint2arf_abs res x Sets res to the absolute value of x exactly.!Flint2 arf_load_file x stream Reads x from stream. Returns a nonzero value if the data is not formatted correctly or the read failed. Note that the data is assumed to be delimited by a whitespace or end-of-file, i.e., when writing multiple values with  arf_dump_file make sure to insert a whitespace to separate consecutive values.!Flint2 arf_dump_file stream x "Writes a binary representation of x to stream that can be read by  arf_load_file<. Returns a nonzero value if the data could not be written.!Flint2 arf_load_str x str Parses str into x. Returns a nonzero value if str is not formatted correctly.!Flint2 arf_dump_str x 9Allocates a string and writes a binary representation of x to it that can be read by  arf_load_str4. The returned string needs to be deallocated with  flint_free.!Flint2 arf_fprintd file y d Prints x2 as a decimal floating-point number to the stream file, rounding to d4 digits. Rounding is faithful (at most 1 ulp error)."Flint2 arf_fprint file x Prints x3 as an integer mantissa and exponent to the stream file."Flint2 arf_get_str x d Returns x1 as a decimal floating-point number, rounding to d5 digits. Rounding is faithful (at most 1 ulp error)."Flint2 arf_print x Prints x% as an integer mantissa and exponent."Flint2 arf_debug x 8Prints information about the internal representation of x."Flint2 arf_urandom res state bits rnd Sets res; to a uniformly distributed random number in the interval [0, 1]. The method uses rounding from integers to floats based on the rounding mode rnd."Flint2arf_randtest_special res state bits mag_bits  Identical to  arf_randtest, except that the output occasionally is set to an infinity or NaN."Flint2arf_randtest_not_zero res state bits mag_bits  Identical to  arf_randtest3, except that zero is never produced as an output."Flint2 arf_randtest res state bits mag_bits Generates a finite random number whose mantissa has precision at most bits and whose exponent has at most mag_bits bits. The values are distributed non-uniformly: special bit patterns are generated with high probability in order to allow the test code to exercise corner cases."Flint2arf_init_neg_mag_shallow z x  Initializes z shallowly to the negation of x."Flint2arf_init_neg_shallow z x "Flint2arf_init_set_mag_shallow z x  Initializes z to a shallow copy of x. A shallow copy just involves copying struct data (no heap allocation is performed).The target variable z may not be cleared or modified in any way (it can only be used as constant input to functions), and may not be used after x# has been cleared. Moreover, after x! has been assigned shallowly to z, no modification of x is permitted as slong as z is in use."Flint2arf_init_set_shallow z x "Flint2arf_mag_fast_add_ulp res x y prec Sets res" to an upper bound for the sum of x; and the magnitude of the unit in the last place (ulp) of y at precision prec(. Assumes that all exponents are small."Flint2arf_mag_add_ulp res x y prec Sets res" to an upper bound for the sum of x; and the magnitude of the unit in the last place (ulp) of y at precision prec."Flint2arf_mag_set_ulp res x prec Sets res9 to the magnitude of the unit in the last place (ulp) of x at precision prec."Flint2mag_fast_init_set_arf res x  Initializes res# and sets it to an upper bound for x . Assumes that the exponent of res$ is small (this function is unsafe)."Flint2mag_init_set_arf res x  Initializes res# and sets it to an upper bound for x."Flint2 arf_set_mag res x Sets res to x. This operation is exact."Flint2arf_get_mag_lower res x Sets res, to a lower bound for the absolute value of x."Flint2 arf_get_mag res x Sets res- to an upper bound for the absolute value of x."Flint2arf_abs_bound_lt_2exp_si x Returns the smallest integer b such that  |x| < 2^b', clamping the result to lie between -ARF_PREC_EXACT and ARF_PREC_EXACT inclusive. If x is zero, -ARF_PREC_EXACT is returned, and if x is infinity or NaN, ARF_PREC_EXACT is returned."Flint2arf_abs_bound_le_2exp_fmpz res x Sets res to the smallest integer b such that  |x| \le 2^b. If x4 is zero, infinity or NaN, the result is undefined."Flint2arf_abs_bound_lt_2exp_fmpz res x Sets res to the smallest integer b such that  |x| < 2^b. If x4 is zero, infinity or NaN, the result is undefined."Flint2arf_is_int_2exp_si x e Returns nonzero iff x equals n 2^e for some integer n."Flint2 arf_is_int x Returns nonzero iff x is integer-valued."Flint2arf_bits x Returns the number of bits needed to represent the absolute value of the mantissa of x5, i.e. the minimum precision sufficient to represent x exactly. Returns 0 if x is a special value."Flint2arf_max res a b Sets res0 respectively to the minimum and the maximum of a and b."Flint2arf_min res a b "Flint2arf_sgn x Returns -1, 0 or +1 according to the sign of x . The sign of NaN is undefined."Flint2arf_cmpabs_2exp_si x e  Compares x( (respectively its absolute value) with 2^e."Flint2arf_cmp_2exp_si x e "Flint2arf_cmpabs_mag x y  Compares the absolute values of x and y."Flint2 arf_cmpabs_d x y "Flint2 arf_cmpabs_ui x y "Flint2 arf_cmpabs x y "Flint2 arf_cmp_d x y :Returns negative, zero, or positive, depending on whether x9 is respectively smaller, equal, or greater compared to y$. Comparison with NaN is undefined."Flint2 arf_cmp_ui x y "Flint2 arf_cmp_si x y "Flint2arf_cmp x y "Flint2 arf_equal_d x y Returns nonzero iff x and y are exactly equal. NaN is not treated specially, i.e. NaN compares as equal to itself.For comparison with a double, the values -0 and +0 are both treated as zero, and all NaN values are treated as identical."Flint2 arf_equal_ui x y "Flint2 arf_equal_si x y "Flint2 arf_equal x y "Flint2 arf_get_fmpq res x Set res to the exact rational value of x. This method aborts if x, is infinite or NaN, or if the exponent of x: is so large that allocating memory for the result fails."Flint2arf_ceil res x Sets res to \lfloor x \rfloor and \lceil x \rceil respectively. The result is always represented exactly, requiring no more bits to store than the input. To round the result to a floating-point number with a lower precision, call  arf_set_round afterwards."Flint2 arf_floor res x "Flint2arf_get_fmpz_fixed_si res x e  Converts x6 to a mantissa with predetermined exponent, i.e. sets res to an integer y such that y \times 2^e \approx x, truncating if necessary. Returns 0 if exact and 1 if truncation occurred.The warnings for  arf_get_fmpz apply."Flint2arf_get_fmpz_fixed_fmpz res x e "Flint2 arf_get_si x rnd Returns x? rounded to the nearest integer in the direction specified by rnd. If rnd is  ARFRND_NEAR, rounds to the nearest even integer in case of a tie. Aborts if x is infinite, NaN, or the value is too large to fit in a slong."Flint2 arf_get_fmpz res x rnd Sets res to x? rounded to the nearest integer in the direction specified by rnd . If rnd is  ARFRND_NEAR, rounds to the nearest even integer in case of a tie. Returns inexact (beware: accordingly returns whether x is not an integer).This method aborts if x+ is infinite or NaN, or if the exponent of x: is so large that allocating memory for the result fails.Warning: this method will allocate a huge amount of memory to store the result if the exponent of x is huge. Memory allocation could succeed even if the required space is far larger than the physical memory available on the machine, resulting in swapping. It is recommended to check that x9 is within a reasonable range before calling this method."Flint2 arf_get_mpfr res x rnd Sets the MPFR variable res to the value of x. If the precision of x is too small to allow res to be represented exactly, it is rounded in the specified MPFR rounding mode. The return value (-1, 0 or 1) indicates the direction of rounding, following the convention of the MPFR library.If x has an exponent too large or small to fit in the MPFR type, the result overflows to an infinity or underflows to a (signed) zero, and the corresponding MPFR exception flags are set."Flint2 arf_get_d x rnd Returns x3 rounded to a double in the direction specified by rnd. This method rounds correctly when overflowing or underflowing the double exponent range (this was not the case in an earlier version)."Flint2 arf_frexp m e x Writes x as  m \cdot 2^e, where 0.5 \le |m| < 1 if x is a normal value. If x$ is a special value, copies this to m and sets e, to zero. Note: for the inverse operation (ldexp), use arf_mul_2exp_fmpz."Flint2arf_get_fmpz_2exp m e x Sets m and e" to the unique integers such that x = m \cdot 2^e and m is odd, provided that x" is a nonzero finite fraction. If x is zero, both m and e are set to zero. If x. is infinite or NaN, the result is undefined."Flint2arf_set_round_fmpz_2exp res x e prec rnd Sets res to  x \cdot 2^e , rounded to prec% bits in the direction specified by rnd."Flint2arf_set_fmpz_2exp res m e Sets res to  m \cdot 2^e."Flint2arf_set_ui_2exp_si res m e "Flint2arf_set_si_2exp_si res m e "Flint2arf_set_round_fmpz res x prec rnd Sets res to x , rounded to prec% bits in the direction specified by rnd."Flint2arf_set_round_mpz res x prec rnd "Flint2arf_set_round_ui res x prec rnd "Flint2arf_set_round_si res x prec rnd "Flint2 arf_set_round res x prec rnd "Flint2arf_init_set_si res x  Initializes res and sets it to x in a single operation."Flint2arf_init_set_ui res x "Flint2arf_swap x y Swaps x and y efficiently."Flint2 arf_set_d res x Sets res to the exact value of x."Flint2 arf_set_mpfr res x "Flint2 arf_set_si res x "Flint2 arf_set_ui res x "Flint2 arf_set_fmpz res x "Flint2 arf_set_mpz res x "Flint2arf_set res x "Flint2 arf_is_finite x Returns nonzero iff x? is a finite floating-point value, i.e. not one of the values +\infty, -\infty=, NaN. (Note that this is not equivalent to the negation of  arf_is_inf.)"Flint2arf_is_special x Returns nonzero iff x! is one of the special values 0, +\infty, -\infty7, NaN, i.e. not a finite, nonzero floating-point value."Flint2 arf_is_normal x Returns nonzero iff x is a finite, nonzero floating-point value, i.e. not one of the special values 0, +\infty, -\infty, NaN."Flint2 arf_is_inf x Returns nonzero iff x equals either +\infty or -\infty."Flint2 arf_is_nan x Returns nonzero iff x respectively equals 0, 1, +\infty, -\infty, NaN."Flint2arf_is_neg_inf x "Flint2arf_is_pos_inf x "Flint2 arf_is_one x "Flint2 arf_is_zero x "Flint2arf_nan res Sets res respectively to 0, 1, +\infty, -\infty, NaN."Flint2 arf_neg_inf res "Flint2 arf_pos_inf res "Flint2arf_one res "Flint2arf_zero res "Flint2arf_allocated_bytes x Returns the total number of bytes heap-allocated internally by this object. The count excludes the size of the structure itself. Add sizeof(arf_struct)* to get the size of the object as a whole."Flint2 arf_clear x Clears the variable x,, freeing or recycling its allocated memory."Flint2arf_init x Initializes the variable x# for use. Its value is set to zero."Flint2Createst a new   structure encapsulated in  ."Flint2Access to the C pointer in   structure."Flint2 arf_printd x d Prints x1 as a decimal floating-point number, rounding to d5 digits. Rounding is faithful (at most 1 ulp error). !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""": Safe-Inferred )*1 "Q !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" """""""""""""""""""" """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Safe-Inferred )*1 ,"Flint2_acb_vec_sort_pretty vec len Sorts the vector of complex numbers based on the real and imaginary parts. This is intended to reveal structure when printing a set of complex numbers, not to apply an order relation in a rigorous way."Flint2_acb_vec_get_unique_fmpz_vec res vec len Calls acb_get_unique_fmpz elementwise and returns nonzero if all entries can be rounded uniquely to integers. If any entry in vec9 cannot be rounded uniquely to an integer, returns zero."Flint2 _acb_vec_trim res vec len Applies acb_trim elementwise."Flint2_acb_vec_indeterminate vec len Applies acb_indeterminate elementwise."Flint2_acb_vec_add_error_mag_vec res err len $Adds the magnitude of each entry in err. to the radius of the corresponding entry in res."Flint2_acb_vec_unit_roots z order len prec Sets z to the powers  1,z,z^2,\dots z^{\mathrm{len}-1} where $z=\exp(\frac{2i\pi}{\mathrm{order}}) to precision prec. order can be taken negative.In order to avoid precision loss, this function does not simply compute powers of a primitive root."Flint2_acb_vec_set_powers xs x len prec Sets xs to the powers 1, x, x^2, \ldots, x^{len-1}."Flint2 _acb_vec_bits vec len Returns the maximum of arb_bits for all entries in vec."Flint2_acb_vec_scalar_div_fmpz res vec len c prec 5Performs the respective scalar operation elementwise."Flint2 _acb_vec_swap vec1 vec2 len Swaps the entries of vec1 and vec2."Flint2_acb_vec_set_round res vec len prec Sets res to a copy of vec, rounding each entry to prec bits."Flint2 _acb_vec_set res vec len Sets res to a copy of vec."Flint2_acb_vec_is_real v len #Returns nonzero iff all entries in x have zero imaginary part."Flint2_acb_vec_is_zero vec len #Returns nonzero iff all entries in x are zero."Flint2 _acb_vec_zero A n Sets all entries in vec to zero."Flint2acb_real_sqrtpos res z analytic prec )Extends the real square root function on  [0,+\infty): to the usual complex square root on the cut plane. Like  arb_sqrtpos , only the nonnegative part of z is considered if z is purely real and analytic, is not set. This is useful for integrating  \sqrt{f(x)} where it is known that  f(x) \ge 0 : unlike acb_sqrt_analytic, no spurious imaginary terms [\pm \varepsilon] i* are created when the balls computed for f(x) straddle zero."Flint2 acb_real_min res x y analytic prec The real function  \min(x,y) is extended to a piecewise analytic function of two variables by returning x when -\operatorname{Re}(x) \le \operatorname{Re}(y) and returning y when +\operatorname{Re}(x) > \operatorname{Re}(y), with discontinuities where +\operatorname{Re}(x) = \operatorname{Re}(y)."Flint2 acb_real_max res x y analytic prec The real function  \max(x,y) is extended to a piecewise analytic function of two variables by returning x when -\operatorname{Re}(x) \ge \operatorname{Re}(y) and returning y when +\operatorname{Re}(x) < \operatorname{Re}(y), with discontinuities where +\operatorname{Re}(x) = \operatorname{Re}(y)."Flint2 acb_real_ceil res z analytic prec The ceiling function is extended to a piecewise constant function equal to n+1 in the strips with real part (n,n+1)., with discontinuities on the vertical lines \operatorname{Re}(z) = n.#Flint2acb_real_floor res z analytic prec The floor function is extended to a piecewise constant function equal to n in the strips with real part (n,n+1)., with discontinuities on the vertical lines \operatorname{Re}(z) = n.#Flint2acb_real_heaviside res z analytic prec The Heaviside step function (or unit step function) is extended to +1 in the right half plane and 0 in the left half plane, with a discontinuity on the vertical line \operatorname{Re}(z) = 0.#Flint2 acb_real_sgn res z analytic prec !The sign function is extended to +1 in the right half plane and -1 in the left half plane, with a discontinuity on the vertical line \operatorname{Re}(z) = 0. If analytic7 is not set, this is effectively the same function as acb_csgn.#Flint2 acb_real_abs res z analytic prec "The absolute value is extended to +z in the right half plane and -z in the left half plane, with a discontinuity on the vertical line \operatorname{Re}(z) = 0.#Flint2acb_chebyshev_u2_ui a b n x prec Simultaneously evaluates a = T_n(x), b = T_{n-1}(x) or a = U_n(x), b = U_{n-1}(x). Aliasing between a, b and x is not permitted.#Flint2acb_chebyshev_u_ui a n x prec 5Evaluates the Chebyshev polynomial of the first kind  a = T_n(x)1 or the Chebyshev polynomial of the second kind  a = U_n(x).#Flint2acb_agm m x y prec Sets m% to the arithmetic-geometric mean of x and y. The square roots in the AGM iteration are chosen so as to form the "optimal" AGM sequence. This gives a well-defined function of x and y except when x / y is a negative real number, in which case there are two optimal AGM sequences. In that case, an arbitrary but consistent choice is made (if a decision cannot be made due to inexact arithmetic, the union of both choices is returned).#Flint2 acb_agm1_cpx m z len prec #Sets the coefficients in the array m to the power series expansion of the arithmetic-geometric mean at the point z truncated to length len, i.e. M(z+x) \in \mathbb{C}[[x]].#Flint2acb_agm1 m z prec Sets m# to the arithmetic-geometric mean M(z) = \operatorname{agm}(1,z), defined such that the function is continuous in the complex plane except for a branch cut along the negative half axis (where it is continuous from above). This corresponds to always choosing an "optimal" branch for the square root in the arithmetic-geometric mean iteration.#Flint2acb_polylog_si w s z prec Sets w to the polylogarithm \operatorname{Li}_s(z).#Flint2acb_bernoulli_poly_ui res n x prec Sets res* to the value of the Bernoulli polynomial B_n(x)..Warning: this function is only fast if either n or x is a small integer.This function reads Bernoulli numbers from the global cache if they are already cached, but does not automatically extend the cache by itself.#Flint2acb_hurwitz_zeta z s a prec Sets z+ to the value of the Hurwitz zeta function  \zeta(s, a)3. Note: for computing derivatives with respect to s, use acb_poly_zeta_series or related methods.This is a wrapper of acb_dirichlet_hurwitz.#Flint2acb_zeta z s prec Sets z+ to the value of the Riemann zeta function \zeta(s)3. Note: for computing derivatives with respect to s, use acb_poly_zeta_series or related methods.This is a wrapper of acb_dirichlet_zeta.#Flint2acb_log_barnes_g res z prec Computes Barnes G$-function or the logarithmic Barnes G-function, respectively. The logarithmic version has branch cuts on the negative real axis and is continuous elsewhere in the complex plane, in analogy with the logarithmic gamma function. The functional equation` )\log G(z+1) = \log \Gamma(z) + \log G(z).holds for all z.=For small integers, we directly use the recurrence relation G(z+1) = \Gamma(z) G(z)" together with the initial value G(1) = 1. For general z, we use the formula` =\log G(z) = (z-1) \log \Gamma(z) - \zeta'(-1,z) + \zeta'(-1).#Flint2 acb_polygamma res s z prec Sets res5 to the value of the generalized polygamma function  \psi(s,z).If s, is a nonnegative order, this is simply the s/-order derivative of the digamma function. If s = 0, this function simply calls the digamma function internally. For integers s \ge 1, it calls the Hurwitz zeta function. Note that for small integers s \ge 1, it can be faster to use acb_poly_digamma_series and read off the coefficients.&The generalization to other values of s is due to Espinosa and Moll  [EM2004]:` \psi(s,z) = \frac{\zeta'(s+1,z) + (\gamma + \psi(-s)) \zeta(s+1,z)}{\Gamma(-s)}#Flint2acb_log_sin_pi res z prec 1Computes the logarithmic sine function defined by` 4S(z) = \log(\pi) - \log \Gamma(z) + \log \Gamma(1-z)which is equal to` &S(z) = \int_{1/2}^z \pi \cot(\pi t) dtwhere the path of integration goes through the upper half plane if 0 < \arg(z) \le \pi& and through the lower half plane if -\pi < \arg(z) \le 0. Equivalently,` S(z) = \log(\sin(\pi(z-n))) \mp n \pi i, \quad n = \lfloor \operatorname{re}(z) \rfloor$where the negative sign is taken if 0 < \arg(z) \le \pi< and the positive sign is taken otherwise (if the interval \arg(z) does not certainly satisfy either condition, the union of both cases is computed). After subtracting n , we have 0 \le \operatorname{re}(z) < 1. In this strip, we use use S(z) = \log(\sin(\pi(z))) if the imaginary part of z is small. Otherwise, we use /S(z) = i \pi (z-1/2) + \log((1+e^{-2i\pi z})/2) in the lower half-plane and the conjugated expression in the upper half-plane to avoid exponent overflow.The function is evaluated at the midpoint and the propagated error is computed from S'(z)! to get a continuous change when z is non-real and n, spans more than one possible integer value.#Flint2 acb_digamma y x prec Computes the digamma function 8y = \psi(x) = (\log \Gamma(x))' = \Gamma'(x) / \Gamma(x).#Flint2 acb_lgamma y x prec (Computes the logarithmic gamma function y = \log \Gamma(x). This is an alias for acb_hypgeom_lgamma.The branch cut of the logarithmic gamma function is placed on the negative half-axis, which means that *\log \Gamma(z) + \log z = \log \Gamma(z+1) holds for all z , whereas "\log \Gamma(z) \ne \log(\Gamma(z)) in general. In the left half plane, the reflection formula with correct branch structure is evaluated via acb_log_sin_pi.#Flint2 acb_rgamma y x prec 'Computes the reciprocal gamma function y = 1/\Gamma(x), avoiding division by zero at the poles of the gamma function. This is an alias for acb_hypgeom_rgamma.#Flint2 acb_gamma y x prec Computes the gamma function  y = \Gamma(x). This is an alias for acb_hypgeom_gamma.#Flint2 acb_rising_ui z x n prec Computes the rising factorial  z = x (x+1) (x+2) \cdots (x+n-1)#. These functions are aliases for acb_hypgeom_rising_ui and acb_hypgeom_rising.#Flint2 acb_lambertw res z k flags prec Sets res to the Lambert W function W_k(z) where the index k selects the branch (with k = 0 giving the principal branch). The placement of branch cuts follows  [CGHJK1996].If flags. is nonzero, nonstandard branch cuts are used.If flags is set to ACB_LAMBERTW_LEFT , computes W_{\mathrm{left}|k}(z) which corresponds to W_k(z) in the upper half plane and  W_{k+1}(z) in the lower half plane, connected continuously to the left of the branch points. In other words, the branch cut on  (-\infty,0)! is rotated counterclockwise to  (0,+\infty). (For k = -1 and k = 0!, there is also a branch cut on (-1/e,0), continuous from below instead of from above to maintain counterclockwise continuity.)If flags is set to ACB_LAMBERTW_MIDDLE , computes W_{\mathrm{middle}}(z) which corresponds to  W_{-1}(z) in the upper half plane and W_{1}(z): in the lower half plane, connected continuously through (-1/e,0) with branch cuts on (-\infty,-1/e) and  (0,+\infty). W_{\mathrm{middle}}(z)% extends the real analytic function  W_{-1}(x) defined on (-1/e,0)> to a complex analytic function, whereas the standard branch  W_{-1}(z)* has a branch cut along the real segment.The algorithm used to compute the Lambert W function is described in  [Joh2017b].#Flint2acb_lambertw_bound_deriv res z ez1 k Sets res to an upper bound for  |W_k'(z)| . The input ez1* should contain the precomputed value of ez+1.3Along the real line, the directional derivative of W_k(z) is understood to be taken. As a result, the user must handle the branch cut discontinuity separately when using this function to bound perturbations in the value of W_k(z).#Flint2acb_lambertw_check_branch w k prec  Tests if w, definitely lies in the image of the branch W_k(z). This function is used internally to verify that a computed approximation of the Lambert W function lies on the intended branch. Note that this will necessarily evaluate to false for points exactly on (or overlapping) the branch cuts, where a different algorithm has to be used.#Flint2acb_lambertw_asymp res z k L M prec Sets res to the Lambert W function W_k(z) computed using L and M terms in the bivariate series giving the asymptotic expansion at zero or infinity. This algorithm is valid everywhere, but the error bound is only finite when  |\log(z)| is sufficiently large.#Flint2 acb_atanh res z prec Sets res to 4\operatorname{atanh}(z) = -i \operatorname{atan}(iz).#Flint2 acb_acosh res z prec Sets res to 9\operatorname{acosh}(z) = \log(z + \sqrt{z+1} \sqrt{z-1}).#Flint2 acb_asinh res z prec Sets res to 4\operatorname{asinh}(z) = -i \operatorname{asin}(iz).#Flint2acb_csch res z prec  Computes %\operatorname{csch}(z) = 1 / \sinh(z).#Flint2acb_sech res z prec  Computes %\operatorname{sech}(z) = 1 / \cosh(z).#Flint2acb_coth s z prec Respectively computes \sinh(z) = -i\sin(iz), \cosh(z) = \cos(iz), \tanh(z) = -i\tan(iz), \coth(z) = i\cot(iz).#Flint2acb_atan res z prec Sets res to ?\operatorname{atan}(z) = \tfrac{1}{2} i (\log(1-iz)-\log(1+iz)).#Flint2acb_acos res z prec Sets res to \operatorname{acos}(z) = \tfrac{1}{2} \pi - \operatorname{asin}(z).#Flint2acb_asin res z prec Sets res to 3\operatorname{asin}(z) = -i \log(iz + \sqrt{1-z^2}).#Flint2 acb_sinc_pi s z prec Sets 6s = \operatorname{sinc}(\pi x) = \sin(\pi z) / (\pi z).#Flint2acb_sinc s z prec Sets (s = \operatorname{sinc}(x) = \sin(z) / z.#Flint2 acb_csc_pi res z prec  Computes \csc(\pi x) = 1 / \sin(\pi z)%. Evaluates the sine accurately via  acb_sin_pi.#Flint2acb_csc res z prec  Computes \csc(x) = 1 / \sin(z).#Flint2acb_sec res z prec  Computes \sec(z) = 1 / \cos(z).#Flint2 acb_cot_pi s z prec Sets s = \cot(\pi z). Uses the same algorithm as acb_cot4, but evaluates the sine and cosine accurately via arb_sin_cos_pi.#Flint2 acb_tan_pi s z prec Sets s = \tan(\pi z). Uses the same algorithm as acb_tan4, but evaluates the sine and cosine accurately via arb_sin_cos_pi.#Flint2acb_sin_cos_pi s c z prec Sets s = \sin(\pi z), c = \cos(\pi z), evaluating the trigonometric factors of the real and imaginary part accurately via arb_sin_cos_pi.#Flint2acb_cot s z prec Sets s = \cot(z) = \cos(z) / \sin(z). For large imaginary parts, the function is evaluated in a numerically stable way as \pm i' plus a decreasing exponential factor.#Flint2acb_tan s z prec Sets s = \tan(z) = \sin(z) / \cos(z). For large imaginary parts, the function is evaluated in a numerically stable way as \pm i' plus a decreasing exponential factor.#Flint2 acb_sin_cos s c z prec Sets  s = \sin(z),  c = \cos(z), evaluated as 0\sin(a+bi) = \sin(a)\cosh(b) + i \cos(a)\sinh(b), 0\cos(a+bi) = \cos(a)\cosh(b) - i \sin(a)\sinh(b).#Flint2 acb_log1p z x prec Sets  z = \log(1+x), computed accurately when  x \approx 0.#Flint2acb_log_analytic r z analytic prec #Computes the natural logarithm. If analytic+ is set, gives a NaN-containing result if z touches the branch cut.#Flint2acb_log y z prec Sets y5 to the principal branch of the natural logarithm of z, computed as \log(a+bi) = \frac{1}{2} \log(a^2 + b^2) + i \operatorname{arg}(a+bi).#Flint2 acb_expm1 res z prec Sets res to  \exp(z)-1%, using a more accurate method when  z \approx 0.#Flint2acb_exp_invexp s t z prec Sets  s = \exp(z) and  t = \exp(-z).#Flint2 acb_exp_pi_i y z prec Sets y to  \exp(\pi i z).#Flint2acb_exp y z prec Sets y to the exponential function of z, computed as 7\exp(a+bi) = \exp(a) \left( \cos(b) + \sin(b) i \right).#Flint2 acb_unit_root res order prec Sets res to "\exp(\frac{2i\pi}{\mathrm{order}}) to precision prec.#Flint2acb_pow_analytic r x y analytic prec Computes the power x^y. If analytic+ is set, gives a NaN-containing result if x touches the branch cut (unless y is an integer).#Flint2acb_pow z x y prec Sets z = x^y*, computed using binary exponentiation if y if a small exact integer, as z = (x^{1/2})^{2y} if y2 is a small exact half-integer, and generally as z = \exp(y \log x).#Flint2 acb_pow_si y b e prec Sets y = b^e; using binary exponentiation (with an initial division if e < 0). Note that these functions can get slow if the exponent is extremely large (in such cases acb_pow may be superior).#Flint2 acb_root_ui r z k prec Sets r to the principal k -th root of z.#Flint2acb_quadratic_roots_fmpz r1 r2 a b c prec Sets r1 and r2+ to the roots of the quadratic polynomial  ax^2 + bx + c. Requires that a is nonzero. This function is implemented so that both roots are computed accurately even when direct use of the quadratic formula would lose accuracy.#Flint2acb_rsqrt_analytic r z analytic prec (Computes the reciprocal square root. If analytic+ is set, gives a NaN-containing result if z touches the branch cut.#Flint2 acb_rsqrt r z prec Sets r" to the reciprocal square root of z. If either the real or imaginary part is exactly zero, only a single real reciprocal square root is needed. Generally, we use the formula 1/\sqrt{a+bi} = ((a+r) - bi)/v, r = |a+bi|, v = \sqrt{r |a+bi+r|^2}, requiring one real square root and one real reciprocal square root.#Flint2acb_sqrt_analytic r z analytic prec Computes the square root. If analytic+ is set, gives a NaN-containing result if z touches the branch cut.#Flint2acb_sqrt r z prec Sets r to the square root of z. If either the real or imaginary part is exactly zero, only a single real square root is needed. Generally, we use the formula 0\sqrt{a+bi} = u/2 + ib/u, u = \sqrt{2(|a+bi|+a)}., requiring two real square root extractions.#Flint2 acb_const_pi y prec Sets y to the constant \pi.#Flint2 acb_dot_ui res initial subtract x xstep y ystep len prec Equivalent to acb_dot!, but with integers in the array y. The uiui and siui? versions take an array of double-limb integers as input; the siui version assumes that these represent signed integers in two's complement form.#Flint2acb_approx_dot res s subtract x xstep y ystep len prec $Computes an approximate dot product without error bounds. The radii of the inputs are ignored (only the midpoints are read) and only the midpoint of the output is written.#Flint2acb_dot_precise res s subtract x xstep y ystep len prec (Computes the dot product of the vectors x and y , setting res to .s + (-1)^{subtract} \sum_{i=0}^{len-1} x_i y_i.The initial term s+ is optional and can be omitted by passing NULL (equivalently, s = 0). The parameter subtract must be 0 or 1. The length len is allowed to be negative, which is equivalent to a length of zero. The parameters xstep or ystep specify a step length for traversing subsequences of the vectors x and y; either can be negative to step in the reverse direction starting from the initial pointer. Aliasing is allowed between res and s but not between res and the entries of x and y.The default version determines the optimal precision for each term and performs all internal calculations using mpn arithmetic with minimal overhead. This is the preferred way to compute a dot product; it is generally much faster and more precise than a simple loop.The simple version performs fused multiply-add operations in a simple loop. This can be used for testing purposes and is also used as a fallback by the default version when the exponents are out of range for the optimized code.The precise version computes the dot product exactly up to the final rounding. This can be extremely slow and is only intended for testing.#Flint2acb_div z x y prec Sets z to the quotient of x and y.#Flint2acb_inv z x prec Sets z" to the multiplicative inverse of x.#Flint2acb_submul_arb z x y prec Sets z to z minus the product of x and y.#Flint2acb_addmul_arb z x y prec Sets z to z plus the product of x and y.#Flint2acb_cube z x prec Sets z to x cubed, computed efficiently using two real squarings, two real multiplications, and scalar operations.#Flint2acb_sqr z x prec Sets z to x squared.#Flint2acb_mul_2exp_fmpz z x e Sets z to x multiplied by 2^e, without rounding.#Flint2acb_mul z x y prec Sets z to the product of x and y. If at least one part of x or y is zero, the operations is reduced to two real multiplications. If x and y are the same pointers, they are assumed to represent the same mathematical quantity and the squaring formula is used.#Flint2 acb_mul_arb z x y prec Sets z to the product of x and y.#Flint2 acb_div_onei z x Sets z to x divided by the imaginary unit.#Flint2 acb_mul_onei z x Sets z to x" multiplied by the imaginary unit.#Flint2acb_sub z x y prec Sets z to the difference of x and y.#Flint2acb_add z x y prec Sets z to the sum of x and y.#Flint2acb_conj z x Sets z to the complex conjugate of x.#Flint2 acb_neg_round z x prec Sets z to the negation of x.#Flint2acb_csgn r z Sets r to the extension of the real sign function taking the value 1 for z* strictly in the right half plane, -1 for z strictly in the left half plane, and the sign of the imaginary part when z+ is on the imaginary axis. Equivalently, '\operatorname{csgn}(z) = z / \sqrt{z^2}" except that the value is 0 when z is exactly zero.#Flint2acb_sgn r z prec Sets r to the complex sign of z, defined as 0 if z: is exactly zero and the projection onto the unit circle z / |z| = \exp(i \arg(z)) otherwise.#Flint2acb_abs r z prec Sets r to the absolute value of z.#Flint2acb_arg r z prec Sets r to a real interval containing the complex argument (phase) of z:. We define the complex argument have a discontinuity on  (-\infty,0], with the special value \operatorname{arg}(0) = 0, and \operatorname{arg}(a+0i) = \pi for a < 0. Equivalently, if z = a+bi, the argument is given by \operatorname{atan2}(b,a) (see  arb_atan2).#Flint2 acb_get_imag im z Sets im to the imaginary part of z.#Flint2 acb_get_real re z Sets re to the real part of z.#Flint2acb_get_unique_fmpz z x If x! contains a unique integer, sets z3 to that value and returns nonzero. Otherwise (if x represents no integers or more than one integer), returns zero.$Flint2 acb_is_real x *Returns nonzero iff the imaginary part of x5 is zero. It does not test whether the real part of x also is finite.$Flint2acb_trim y x Sets y to a a copy of x6 with both the real and imaginary parts trimmed (see arb_trim).$Flint2acb_indeterminate x Sets x to [\operatorname{NaN} \pm \infty] + [\operatorname{NaN} \pm \infty]i(, representing an indeterminate result.$Flint2acb_bits x Returns the maximum of arb_bits- applied to the real and imaginary parts of x5, i.e. the minimum precision sufficient to represent x exactly.$Flint2acb_rel_one_accuracy_bits x Given a ball with midpoint m and radius r8, returns an approximation of the relative accuracy of [\max(1,|m|) \pm r] measured in bits.$Flint2acb_rel_accuracy_bits x +Returns the effective relative accuracy of x measured in bits, equal to the negative of the return value from acb_rel_error_bits.$Flint2acb_rel_error_bits x (Returns the effective relative error of x3 measured in bits. This is computed as if calling arb_rel_error_bits on the real ball whose midpoint is the larger out of the real and imaginary midpoints of x, and whose radius is the larger out of the real and imaginary radiuses of x.$Flint2acb_contains_interior x y  Tests if y! is contained in the interior of x/. This predicate always evaluates to false if x and y are both real-valued, since an imaginary part of 0 is not considered contained in the interior of the point interval 0. More generally, the same problem occurs for intervals with an exact real or imaginary part. Such intervals must be handled specially by the user where a different interpretation is intended.$Flint2acb_contains_int x 8Returns nonzero iff the complex interval represented by x contains an integer.$Flint2acb_contains_zero x )Returns nonzero iff zero is contained in x.$Flint2 acb_contains x y Returns nonzero iff y is contained in x.$Flint2acb_get_mag_lower u x Sets u, to a lower bound for the absolute value of x.$Flint2 acb_get_mag u x Sets u- to an upper bound for the absolute value of x.$Flint2acb_get_rad_ubound_arf u z prec Sets u+ to an upper bound for the error radius of z0 (the value is currently not computed tightly).$Flint2acb_get_abs_lbound_arf u z prec Sets u, to a lower bound for the absolute value of z), computed using a working precision of prec bits.$Flint2acb_get_abs_ubound_arf u z prec Sets u- to an upper bound for the absolute value of z), computed using a working precision of prec bits.$Flint2 acb_union z x y prec Sets z' to a complex interval containing both x and y.$Flint2 acb_overlaps x y Returns nonzero iff x and y have some point in common.$Flint2acb_ne x y Returns nonzero iff x and y9 are certainly not equal, as determined by testing that arb_ne. holds for either the real or imaginary parts.$Flint2acb_eq x y Returns nonzero iff x and y5 are certainly equal, as determined by testing that arb_eq- holds for both the real and imaginary parts.$Flint2 acb_equal_si x y Returns nonzero iff x is equal to the integer y.$Flint2 acb_equal x y Returns nonzero iff x and y are identical as sets, i.e. if the real and imaginary parts are equal as balls.=Note that this is not the same thing as testing whether both x and y= certainly represent the same complex number, unless either x or y is exact (and neither contains NaN). To test whether both operands might0 represent the same mathematical quantity, use  acb_overlaps or  acb_contains , depending on the circumstance.$Flint2acb_is_int_2exp_si x e Returns nonzero iff z exactly equals n 2^e for some integer n.$Flint2 acb_is_int z Returns nonzero iff z is an exact integer.$Flint2 acb_is_exact z Returns nonzero iff z is exact.$Flint2 acb_is_finite z Returns nonzero iff z certainly is finite.$Flint2 acb_is_one z Returns nonzero iff z is exactly 1.$Flint2 acb_is_zero z Returns nonzero iff z is zero.$Flint2acb_randtest_param z state prec mag_bits Generates a random complex number, with very high probability of generating integers and half-integers.$Flint2acb_randtest_precise z state prec mag_bits Generates a random complex number with precise real and imaginary parts.$Flint2acb_randtest_special z state prec mag_bits Generates a random complex number by generating separate random real and imaginary parts. Also generates NaNs and infinities.$Flint2 acb_randtest z state prec mag_bits Generates a random complex number by generating separate random real and imaginary parts.$Flint2 acb_fprintn file x digits flags (Prints a nice decimal representation of x, using the format of  arb_get_str (or the corresponding  arb_printn$) for the real and imaginary parts.By default, the output shows the midpoint of both the real and imaginary parts with a guaranteed error of at most one unit in the last decimal place. In addition, explicit error bounds are printed so that the displayed decimal interval is guaranteed to enclose x.Any flags understood by  arb_get_str can be passed via flags8 to control the format of the real and imaginary parts.$Flint2 acb_fprintd file x digits Prints x in decimal to stream file. The printed value of the radius is not adjusted to compensate for the fact that the binary-to-decimal conversion of both the midpoint and the radius introduces additional error.$Flint2 acb_fprint file x &Prints the internal representation of x.$Flint2 acb_get_mid m x Sets m to the midpoint of x.$Flint2acb_add_error_arb x err Adds err> to the error bounds of both the real and imaginary parts of x , modifying x in-place.$Flint2acb_swap z x Swaps z and x efficiently.$Flint2acb_set_round_arb z x prec Sets z to x , rounded to prec bits.$Flint2acb_set_arb_arb z x y $Sets the real and imaginary part of z to the values x and y respectively$Flint2 acb_set_arb z c Sets z to the value of x.$Flint2acb_onei z Sets z respectively to 0, 1,  i = \sqrt{-1}.$Flint2!_acb_vec_estimate_allocated_bytes len prec Estimates the number of bytes that need to be allocated for a vector of len elements with prec bits of precision, including the space for internal limb data. See comments for !_arb_vec_estimate_allocated_bytes.$Flint2_acb_vec_allocated_bytes vec len Returns the total number of bytes allocated for this vector, i.e. the space taken up by the vector itself plus the sum of the internal heap allocation sizes for all its member elements.$Flint2acb_allocated_bytes x Returns the total number of bytes heap-allocated internally by this object. The count excludes the size of the structure itself. Add sizeof(acb_struct)* to get the size of the object as a whole.$Flint2_acb_vec_clear v n Clears an array of n initialized  acb_struct:s.$Flint2 _acb_vec_init n !Returns a pointer to an array of n initialized  acb_struct:s.$Flint2 acb_clear x Clears the variable x,, freeing or recycling its allocated memory.$Flint2acb_init x Initializes the variable x% for use, and sets its value to zero.$Flint2 Create new  $Flint2Apply function f to  $Flint2Apply function f to new  $Flint2Apply function f to real part of  $Flint2Apply function f to imaginary part of  $Flint2 acb_realref z acb_realref returns a   pointer to the real part of z.$Flint2 acb_imagref z acb_imagref returns a  " pointer to the imaginary part of z.$Flint2 acb_printd file x digits Prints x in decimal to stdout. The printed value of the radius is not adjusted to compensate for the fact that the binary-to-decimal conversion of both the midpoint and the radius introduces additional error. """"""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$; Safe-Inferred )*1 [ """"""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$################################################################################################################################"""""""""""""""""""""""""""""""""" Safe-Inferred )*1s{$Flint2arb_poly_swinnerton_dyer_ui poly n prec (Computes the Swinnerton-Dyer polynomial S_n, which has degree 2^n and is the rational minimal polynomial of the sum of the square roots of the first n prime numbers.If prec is set to zero, a precision is chosen automatically such that arb_poly_get_unique_fmpz_poly9 should be successful. Otherwise a working precision of prec bits is used.-The underscore version accepts an additional trunc parameter. Even when computing a truncated polynomial, the array poly must have room for 2^n + 1' coefficients, used as temporary space.$Flint2_arb_poly_swinnerton_dyer_ui poly n trunc prec $Flint2_arb_poly_newton_refine_root r poly len start convergence_interval convergence_factor eval_extra_prec prec Refines a precise estimate of a polynomial root to high precision by performing several Newton steps, using nearly optimally chosen doubling precision steps.The inputs are defined as for _arb_poly_newton_step(, except for the precision parameters: prec is the target accuracy and eval_extra_prec is the estimated number of guard bits that need to be added to evaluate the polynomial accurately close to the root (typically, if the polynomial has large coefficients of alternating signs, this needs to be approximately the bit size of the coefficients).$Flint2_arb_poly_newton_step xnew poly len x convergence_interval convergence_factor prec ,Performs a single step with Newton's method.%The input consists of the polynomial f specified by the coefficients  {poly, len}, an interval x = [m-r, m+r]$ known to contain a single root of f, an interval I (convergence_interval) containing x with an associated bound (convergence_factor) for 3C = \sup_{t,u \in I} \frac{1}{2} |f''(t)| / |f'(u)|, and a working precision prec.&The Newton update consists of setting x' = [m'-r', m'+r'] where m' = m - f(m) / f'(m) and  r' = C r^2. The expression m - f(m) / f'(m)? is evaluated using ball arithmetic at a working precision of prec bits, and the rounding error during this evaluation is accounted for in the output. We now check that x' \in I and m' < m+. If both conditions are satisfied, we set xnew to x'8 and return nonzero. If either condition fails, we set xnew to x8 and return zero, indicating that no progress was made.$Flint2#_arb_poly_newton_convergence_factor convergence_factor poly len convergence_interval prec Given an interval I specified by convergence_interval, evaluates a bound for 3C = \sup_{t,u \in I} \frac{1}{2} |f''(t)| / |f'(u)| , where f/ is the polynomial defined by the coefficients  {poly, len}'. The bound is obtained by evaluating f'(I) and f''(I) directly. If f has large coefficients, I< must be extremely precise in order to get a finite factor.$Flint2arb_poly_root_bound_fujiwara bound poly Sets bound to an upper bound for the magnitude of all the complex roots of poly. Uses Fujiwara's bound` 2 \max \left\{\left|\frac{a_{n-1}}{a_n}\right|, \left|\frac{a_{n-2}}{a_n}\right|^{1/2}, \cdots, \left|\frac{a_1}{a_n}\right|^{1/(n-1)}, \left|\frac{a_0}{2a_n}\right|^{1/n} \right\}where a_0, \ldots, a_n are the coefficients of poly.$Flint2_arb_poly_root_bound_fujiwara bound poly len $Flint2 arb_poly_riemann_siegel_z_series res h n prec Sets res9 to the series expansion of the Riemann-Siegel Z-function` $Z(h) = e^{i\theta(h)} \zeta(1/2+ih).The zeros of the Z-function on the real line precisely correspond to the imaginary parts of the zeros of the Riemann zeta function on the critical line.The underscore method supports aliasing of the input and output arrays, and requires that the lengths are greater than zero.$Flint2!_arb_poly_riemann_siegel_z_series res h hlen n prec $Flint2$arb_poly_riemann_siegel_theta_series res h n prec Sets res= to the series expansion of the Riemann-Siegel theta function` \theta(h) = \arg \left(\Gamma\left(\frac{2ih+1}{4}\right)\right) - \frac{\log \pi}{2} hwhere the argument of the gamma function is chosen continuously as the imaginary part of the log gamma function.The underscore method does not support aliasing of the input and output arrays, and requires that the lengths are greater than zero.$Flint2%_arb_poly_riemann_siegel_theta_series res h hlen n prec $Flint2arb_poly_zeta_series res s a deflate n prec Sets res to the Hurwitz zeta function  \zeta(s,a) where s a power series and a$ is a constant, truncated to length n4. To evaluate the usual Riemann zeta function, set a = 1.If deflate is nonzero, evaluates \zeta(s,a) + 1/(1-s)>, which is well-defined as a limit when the constant term of s! is 1. In particular, expanding \zeta(s,a) + 1/(1-s) with s = 1+x gives the Stieltjes constants` 3\sum_{k=0}^{n-1} \frac{(-1)^k}{k!} \gamma_k(a) x^k.If a = 1, this implementation uses the reflection formula if the midpoint of the constant term of s is negative.$Flint2_arb_poly_zeta_series res h hlen a deflate len prec$Flint2arb_poly_rising_ui_series res f r trunc prec Sets res to the rising factorial (f) (f+1) (f+2) \cdots (f+r-1), truncated to length trunc%. The underscore method assumes that flen, r and trunc are at least 1, and does not support aliasing. Uses binary splitting.$Flint2_arb_poly_rising_ui_series res f flen r trunc prec $Flint2arb_poly_digamma_series res h n prec Sets res to the series expansion of  \Gamma(h(x)), 1/\Gamma(h(x)), or \log \Gamma(h(x)),  \psi(h(x)), truncated to length n.These functions first generate the Taylor series at the constant term of h, and then call _arb_poly_compose_series. The Taylor coefficients are generated using the Riemann zeta function if the constant term of h: is a small integer, and with Stirling's series otherwise.The underscore methods support aliasing of the input and output arrays, and require that hlen and n are greater than zero.$Flint2_arb_poly_digamma_series res h hlen n prec $Flint2arb_poly_lgamma_series res h n prec $Flint2_arb_poly_lgamma_series res h hlen n prec $Flint2arb_poly_rgamma_series res h n prec $Flint2_arb_poly_rgamma_series res h hlen n prec $Flint2arb_poly_gamma_series res h n prec $Flint2_arb_poly_gamma_series res h hlen n prec $Flint2arb_poly_lambertw_series res z flags len prec Sets res/ to the Lambert W function of the power series z. If flags- is 0, the principal branch is computed; if flags is 1, the second real branch  W_{-1}(z) is computed. The underscore method allows aliasing, but assumes that the lengths are nonzero.$Flint2_arb_poly_lambertw_series res z zlen flags len prec $Flint2arb_poly_sinc_pi_series s h n prec 5Compute the sinc function of the input multiplied by \pi.$Flint2_arb_poly_sinc_pi_series s h hlen n prec $Flint2arb_poly_sinc_series s h n prec Sets c* to the sinc function of the power series h, truncated to length n.$Flint2_arb_poly_sinc_series s h hlen n prec $Flint2arb_poly_cosh_series c h n prec Sets s and c respectively to the hyperbolic sine and cosine of the power series h, truncated to length n.The implementations mirror those for sine and cosine, except that the  exponential version computes both functions using the exponential function instead of the hyperbolic tangent.$Flint2_arb_poly_cosh_series c h hlen n prec $Flint2arb_poly_sinh_series s h n prec $Flint2_arb_poly_sinh_series s h hlen n prec $Flint2arb_poly_sinh_cosh_series s c h n prec $Flint2_arb_poly_sinh_cosh_series s c h hlen n prec $Flint2%arb_poly_sinh_cosh_series_exponential s c h n prec $Flint2&_arb_poly_sinh_cosh_series_exponential s c h hlen n prec $Flint2"arb_poly_sinh_cosh_series_basecase s c h n prec $Flint2#_arb_poly_sinh_cosh_series_basecase s c h hlen n prec $Flint2arb_poly_cot_pi_series c h n prec Compute the respective trigonometric functions of the input multiplied by \pi.$Flint2_arb_poly_cot_pi_series c h hlen n prec $Flint2arb_poly_cos_pi_series c h n prec $Flint2_arb_poly_cos_pi_series c h hlen n prec $Flint2arb_poly_sin_pi_series s h n prec $Flint2_arb_poly_sin_pi_series s h hlen n prec $Flint2arb_poly_sin_cos_pi_series s c h n prec $Flint2_arb_poly_sin_cos_pi_series s c h hlen n prec $Flint2arb_poly_tan_series g h n prec Sets g to the power series tangent of h. For small n takes the quotient of the sine and cosine as computed using the basecase algorithm. For large n, uses Newton iteration to invert the inverse tangent series. The complexity is O(M(n)).The underscore version does not support aliasing, and requires the lengths to be nonzero.$Flint2_arb_poly_tan_series g h hlen len prec %Flint2arb_poly_cos_series c h n prec Respectively evaluates the power series sine or cosine. These functions simply wrap _arb_poly_sin_cos_series. The underscore methods support aliasing and require the lengths to be nonzero.%Flint2_arb_poly_cos_series c h hlen n prec %Flint2arb_poly_sin_series s h n prec %Flint2_arb_poly_sin_series s h hlen n prec %Flint2arb_poly_sin_cos_series s c h n prec Sets s and c( to the power series sine and cosine of h, computed simultaneously. The underscore method supports aliasing and requires the lengths to be nonzero.%Flint2_arb_poly_sin_cos_series s c h hlen n prec %Flint2arb_poly_exp_series f h n prec Sets f$ to the power series exponential of h, truncated to length n.The basecase version uses a simple recurrence for the coefficients, requiring O(nm) operations where m is the length of h.The main implementation uses Newton iteration, starting from a small number of terms given by the basecase algorithm. The complexity is O(M(n)). Redundant operations in the Newton iteration are avoided by using the scheme described in  [HZ2004].The underscore methods support aliasing and allow the input to be shorter than the output, but require the lengths to be nonzero.%Flint2_arb_poly_exp_series f h hlen n prec %Flint2arb_poly_exp_series_basecase f h n prec %Flint2_arb_poly_exp_series_basecase f h hlen n prec %Flint2arb_poly_acos_series res f n prec Sets res respectively to the power series inverse tangent, inverse sine and inverse cosine of f, truncated to length n.Uses the formulas` -\tan^{-1}(f(x)) = \int f'(x) / (1+f(x)^2) dx, 3\sin^{-1}(f(x)) = \int f'(x) / (1-f(x)^2)^{1/2} dx, 4\cos^{-1}(f(x)) = -\int f'(x) / (1-f(x)^2)^{1/2} dx,4adding the inverse function of the constant term in f! as the constant of integration.The underscore methods supports aliasing of the input and output arrays. They require that flen and n are greater than zero.%Flint2_arb_poly_acos_series res f flen n prec %Flint2arb_poly_asin_series res f n prec %Flint2_arb_poly_asin_series res f flen n prec %Flint2arb_poly_atan_series res f n prec %Flint2_arb_poly_atan_series res f flen n prec %Flint2arb_poly_log1p_series res f n prec Computes the power series  \log(1+f)2, with better accuracy when the constant term of f is small.%Flint2_arb_poly_log1p_series res f flen n prec %Flint2arb_poly_log_series res f n prec Sets res" to the power series logarithm of f, truncated to length n. Uses the formula !\log(f(x)) = \int f'(x) / f(x) dx0, adding the logarithm of the constant term in f as the constant of integration.The underscore method supports aliasing of the input and output arrays. It requires that flen and n are greater than zero.%Flint2_arb_poly_log_series res f flen n prec %Flint2arb_poly_rsqrt_series g h n prec Sets g/ to the reciprocal power series square root of h, truncated to length n&. Uses division-free Newton iteration.The underscore method does not support aliasing of the input and output arrays. It requires that hlen and n are greater than zero.%Flint2_arb_poly_rsqrt_series g h hlen n prec %Flint2arb_poly_sqrt_series g h n prec Sets g$ to the power series square root of h, truncated to length n. Uses division-free Newton iteration for the reciprocal square root, followed by a multiplication.The underscore method does not support aliasing of the input and output arrays. It requires that hlen and n are greater than zero.%Flint2_arb_poly_sqrt_series g h hlen n prec %Flint2arb_poly_pow_arb_series h f g len prec Sets h to the power series f(x)^g = \exp(g \log f(x)) truncated to length len.%Flint2_arb_poly_pow_arb_series h f flen g len prec Sets {h, len} to the power series f(x)^g = \exp(g \log f(x)) truncated to length len/. This function detects special cases such as g! being an exact small integer or \pm 1/2, and computes such powers more efficiently. This function does not support aliasing of the output with either of the input operands. It requires that all lengths are positive, and assumes that flen does not exceed len.%Flint2arb_poly_pow_series h f g len prec Sets h to the power series "f(x)^{g(x)} = \exp(g(x) \log f(x)) truncated to length len/. This function detects special cases such as g! being an exact small integer or \pm 1/2-, and computes such powers more efficiently.%Flint2_arb_poly_pow_series h f flen g glen len prec Sets {h, len} to the power series "f(x)^{g(x)} = \exp(g(x) \log f(x)) truncated to length len/. This function detects special cases such as g" being an exact small integer or \pm 1/2, and computes such powers more efficiently. This function does not support aliasing of the output with either of the input operands. It requires that all lengths are positive, and assumes that flen and glen do not exceed len.%Flint2arb_poly_pow_ui res poly exp prec Sets res to poly raised to the power exp.%Flint2_arb_poly_pow_ui res f flen exp prec Sets res to  {f, flen} raised to the power exp. Does not support aliasing of the input and output, and requires that flen is positive.%Flint2arb_poly_pow_ui_trunc_binexp res poly exp len prec Sets res to poly raised to the power exp, truncated to length len. Uses binary exponentiation.%Flint2_arb_poly_pow_ui_trunc_binexp res f flen exp len prec Sets  {res, len} to  {f, flen} raised to the power exp, truncated to length len. Requires that len is no longer than the length of the power as computed without truncation (i.e. no zero-padding is performed). Does not support aliasing of the input and output, and requires that flen and len* are positive. Uses binary exponentiation.%Flint2arb_poly_graeffe_transform b a prec 3Computes the Graeffe transform of input polynomial.The Graeffe transform G of a polynomial P" is defined through the equation G(x^2) = \pm P(x)P(-x). The sign is given by (-1)^d , where  d = deg(P). The Graeffe transform has the property that its roots are exactly the squares of the roots of P.#The underscore method assumes that a and b are initialized, a is of length len, and b is of length at least len. Both methods allow aliasing.%Flint2_arb_poly_graeffe_transform b a len prec %Flint2arb_poly_binomial_transform b a len prec Computes the binomial transform of the input polynomial, truncating the output to length len0. The binomial transform maps the coefficients a_k- in the input polynomial to the coefficients b_k in the output polynomial via +b_n = \sum_{k=0}^n (-1)^k {n \choose k} a_k. The binomial transform is equivalent to the power series composition f(x) \to (1-x)^{-1} f(x/(x-1)), and is its own inverse.The basecase version evaluates coefficients one by one from the definition, generating the binomial coefficients by a recurrence relation.The  convolution version uses the identity T(f(x)) = B^{-1}(e^x B(f(-x))) where T. denotes the binomial transform operator and B denotes the Borel transform operator. This only costs a single polynomial multiplication, plus some scalar operations.7The default version automatically chooses an algorithm.The underscore methods do not support aliasing, and assume that the lengths are nonzero.%Flint2_arb_poly_binomial_transform b a alen len prec %Flint2'arb_poly_binomial_transform_convolution b a len prec %Flint2(_arb_poly_binomial_transform_convolution b a alen len prec %Flint2$arb_poly_binomial_transform_basecase b a len prec %Flint2%_arb_poly_binomial_transform_basecase b a alen len prec %Flint2arb_poly_inv_borel_transform res poly prec Computes the inverse Borel transform of the input polynomial, mapping \sum_k a_k x^k to \sum_k a_k k! x^k). The underscore method allows aliasing.%Flint2_arb_poly_inv_borel_transform res poly len prec %Flint2arb_poly_borel_transform res poly prec ?Computes the Borel transform of the input polynomial, mapping \sum_k a_k x^k to \sum_k (a_k / k!) x^k). The underscore method allows aliasing.%Flint2_arb_poly_borel_transform res poly len prec %Flint2arb_poly_integral res poly prec Sets res to the integral of poly.%Flint2_arb_poly_integral res poly len prec Sets  {res, len} to the integral of {poly, len - 1}+. Allows aliasing of the input and output.%Flint2arb_poly_nth_derivative res poly prec Sets res to the nth derivative of poly.%Flint2_arb_poly_nth_derivative res poly n len prec Sets {res, len - n} to the nth derivative of  {poly, len}. Does nothing if len <= n*. Allows aliasing of the input and output.%Flint2arb_poly_derivative res poly prec Sets res to the derivative of poly.%Flint2_arb_poly_derivative res poly len prec Sets {res, len - 1} to the derivative of  {poly, len}+. Allows aliasing of the input and output.%Flint2arb_poly_interpolate_fast poly xs ys n prec 1Recovers the unique polynomial of length at most n that interpolates the given x and y values, using fast Lagrange interpolation. The precomp function takes a precomputed product tree over the x values and a vector of interpolation weights as additional inputs.%Flint2_arb_poly_interpolate_fast poly xs ys len prec %Flint2"_arb_poly_interpolate_fast_precomp poly ys tree weights len prec %Flint2_arb_poly_interpolation_weights w tree len prec %Flint2 arb_poly_interpolate_barycentric poly xs ys n prec 1Recovers the unique polynomial of length at most n that interpolates the given x and y values. This implementation uses the barycentric form of Lagrange interpolation.%Flint2!_arb_poly_interpolate_barycentric poly xs ys n prec %Flint2arb_poly_interpolate_newton poly xs ys n prec 1Recovers the unique polynomial of length at most n that interpolates the given x and y values. This implementation first interpolates in the Newton basis and then converts back to the monomial basis.%Flint2_arb_poly_interpolate_newton poly xs ys n prec %Flint2arb_poly_evaluate_vec_fast ys poly xs n prec +Evaluates the polynomial simultaneously at n1 given points, using fast multipoint evaluation.%Flint2_arb_poly_evaluate_vec_fast ys poly plen xs n prec %Flint2#_arb_poly_evaluate_vec_fast_precomp vs poly plen tree len prec %Flint2arb_poly_evaluate_vec_iter ys poly xs n prec +Evaluates the polynomial simultaneously at n given points, calling _arb_poly_evaluate repeatedly.%Flint2_arb_poly_evaluate_vec_iter ys poly plen xs n prec %Flint2_arb_poly_tree_build tree roots len prec 0Constructs a product tree from a given array of len roots. The tree structure must be pre-allocated to the specified length using _arb_poly_tree_alloc.%Flint2_arb_poly_tree_free tree len 0Deallocates a tree structure as allocated using _arb_poly_tree_alloc.%Flint2_arb_poly_tree_alloc len Returns an initialized data structured capable of representing a remainder tree (product tree) of len roots.%Flint2arb_poly_product_roots_complex poly r rn c cn prec Generates the polynomial` \left(\prod_{i=0}^{rn-1} (x-r_i)\right) \left(\prod_{i=0}^{cn-1} (x-c_i)(x-\bar{c_i})\right)having rn real roots given by the array r and having 2cn7 complex roots in conjugate pairs given by the length-cn array c . Either rn or cn or both may be zero.Note that only one representative from each complex conjugate pair is supplied (unless a pair is supposed to be repeated with higher multiplicity). To construct a polynomial from complex roots where the conjugate pairs have not been distinguished, use acb_poly_product_roots instead.%Flint2_arb_poly_product_roots_complex poly r rn c cn prec %Flint2arb_poly_product_roots poly xs n prec Generates the polynomial (x-x_0)(x-x_1)\cdots(x-x_{n-1}).%Flint2_arb_poly_product_roots poly xs n prec %Flint2arb_poly_evaluate2_acb y z f x prec Sets y = f(x), z = f'(x), evaluated respectively using Horner's rule, rectangular splitting, and an automatic algorithm choice.%Flint2_arb_poly_evaluate2_acb y z f len x prec %Flint2"arb_poly_evaluate2_acb_rectangular y z f x prec %Flint2#_arb_poly_evaluate2_acb_rectangular y z f len x prec %Flint2arb_poly_evaluate2_acb_horner y z f x prec %Flint2_arb_poly_evaluate2_acb_horner y z f len x prec %Flint2arb_poly_evaluate2 y z f x prec Sets y = f(x), z = f'(x), evaluated respectively using Horner's rule, rectangular splitting, and an automatic algorithm choice.When Horner's rule is used, the only advantage of evaluating the function and its derivative simultaneously is that one does not have to generate the derivative polynomial explicitly. With the rectangular splitting algorithm, the powers can be reused, making simultaneous evaluation slightly faster.%Flint2_arb_poly_evaluate2 y z f len x prec %Flint2arb_poly_evaluate2_rectangular y z f x prec %Flint2_arb_poly_evaluate2_rectangular y z f len x prec %Flint2arb_poly_evaluate2_horner y z f x prec %Flint2_arb_poly_evaluate2_horner y z f len x prec %Flint2arb_poly_evaluate_acb y f x prec Sets y = f(x) where x is a complex number, evaluating the polynomial respectively using Horner's rule, rectangular splitting, and an automatic algorithm choice.%Flint2_arb_poly_evaluate_acb y f len x prec %Flint2!arb_poly_evaluate_acb_rectangular y f x prec %Flint2"_arb_poly_evaluate_acb_rectangular y f len x prec %Flint2arb_poly_evaluate_acb_horner y f x prec %Flint2_arb_poly_evaluate_acb_horner y f len x prec %Flint2arb_poly_evaluate y f x prec Sets y = f(x), evaluated respectively using Horner's rule, rectangular splitting, and an automatic algorithm choice.%Flint2_arb_poly_evaluate y f len x prec %Flint2arb_poly_evaluate_rectangular y f x prec %Flint2_arb_poly_evaluate_rectangular y f len x prec %Flint2arb_poly_evaluate_horner y f x prec %Flint2_arb_poly_evaluate_horner y f len x prec %Flint2arb_poly_revert_series h f n prec Sets h" to the power series reversion of f<, i.e. the expansion of the compositional inverse function  f^{-1}(x), truncated to order O(x^n), using respectively Lagrange inversion, Newton iteration, fast Lagrange inversion, and a default algorithm choice.%We require that the constant term in f is exactly zero and that the linear term is nonzero. The underscore methods assume that flen- is at least 2, and do not support aliasing.%Flint2_arb_poly_revert_series h f flen n prec %Flint2$arb_poly_revert_series_lagrange_fast h f n prec %Flint2%_arb_poly_revert_series_lagrange_fast h f flen n prec %Flint2arb_poly_revert_series_newton h f n prec %Flint2_arb_poly_revert_series_newton h f flen n prec %Flint2arb_poly_revert_series_lagrange h f n prec %Flint2 _arb_poly_revert_series_lagrange h f flen n prec %Flint2arb_poly_compose_series res poly1 poly2 n prec Sets res! to the power series composition h(x) = f(g(x)) truncated to order O(x^n) where f is given by poly1 and g is given by poly2. Wraps _gr_poly_compose_series9 which chooses automatically between various algorithms.%We require that the constant term in g(x) is exactly zero. The underscore method does not support aliasing of the output with either input polynomial.%Flint2_arb_poly_compose_series res poly1 len1 poly2 len2 n prec %Flint2arb_poly_compose res poly1 poly2 prec Sets res to the composition h(x) = f(g(x)) where f is given by poly1 and g is given by poly2. The underscore method does not support aliasing of the output with either input polynomial.%Flint2_arb_poly_compose res poly1 len1 poly2 len2 prec %Flint2arb_poly_taylor_shift g f c prec Sets g to the Taylor shift f(x+c)*. The underscore methods act in-place on g = f which has length n.%Flint2_arb_poly_taylor_shift g c n prec %Flint2_arb_poly_div_root Q R A len c prec Divides A by the polynomial x - c, computing the quotient Q as well as the remainder R = f(c).%Flint2arb_poly_divrem Q R A B prec Performs polynomial division with remainder, computing a quotient Q and a remainder R such that  A = BQ + R. The implementation reverses the inputs and performs power series division.If the leading coefficient of B contains zero (or if B is identically zero), returns 0 indicating failure without modifying the outputs. Otherwise returns nonzero.%Flint2_arb_poly_divrem Q R A lenA B lenB prec %Flint2 _arb_poly_rem R A lenA B lenB prec %Flint2 _arb_poly_div Q A lenA B lenB prec %Flint2arb_poly_div_series Q A B n prec Sets Q to the power series quotient A divided by B, truncated to length n.%Flint2_arb_poly_div_series Q A Alen B Blen n prec Sets {Q, n}! to the power series quotient of  {A, Alen} by /{B, Blen}/. Uses Newton iteration followed by multiplication.%Flint2arb_poly_inv_series Q A n prec Sets Q to the power series inverse of A, truncated to length n.%Flint2_arb_poly_inv_series Q A Alen len prec Sets {Q, len} to the power series inverse of  {A, Alen}. Uses Newton iteration.%Flint2 arb_poly_mul C A B prec Sets C to the product of A and B&. If the same variable is passed for A and B, sets C to the square of A.%Flint2 _arb_poly_mul C A lenA B lenB prec Sets {C, lenA + lenB - 1} to the product of  {A, lenA} and /{B, lenB}/. The output is not allowed to be aliased with either of the inputs. We require #\mathrm{lenA} \ge \mathrm{lenB} > 08. This function is implemented as a simple wrapper for _arb_poly_mullow.If the input pointers are identical (and the lengths are the same), they are assumed to represent the same polynomial, and its square is computed.%Flint2arb_poly_mullow C A B n prec Sets C to the product of A and B, truncated to length n&. If the same variable is passed for A and B, sets C to the square of A truncated to length n.%Flint2arb_poly_mullow_block C A B n prec %Flint2arb_poly_mullow_classical C A B n prec %Flint2_arb_poly_mullow C A lenA B lenB n prec Sets {C, n} to the product of  {A, lenA} and  {B, lenB}, truncated to length n. The output is not allowed to be aliased with either of the inputs. We require #\mathrm{lenA} \ge \mathrm{lenB} > 0, n > 0, '\mathrm{lenA} + \mathrm{lenB} - 1 \ge n.The  classical version uses a plain loop. This has good numerical stability but gets slow for large n.The block version decomposes the product into several subproducts which are computed exactly over the integers.%It first attempts to find an integer c such that A(2^c x) and B(2^c x) have slowly varying coefficients, to reduce the number of blocks.The scaling factor c is chosen in a quick, heuristic way by picking the first and last nonzero terms in each polynomial. If the indices in A are a_2, a_1 and the log-2 magnitudes are e_2, e_1, and the indices in B are b_2, b_1 with corresponding magnitudes f_2, f_1, then we compute c as the weighted arithmetic mean of the slopes, rounded to the nearest integer:` c = \left\lfloor \frac{(e_2 - e_1) + (f_2 + f_1)}{(a_2 - a_1) + (b_2 - b_1)} + \frac{1}{2} \right \rfloor.This strategy is used because it is simple. It is not optimal in all cases, but will typically give good performance when multiplying two power series with a similar decay rate."The default algorithm chooses the  classical* algorithm for short polynomials and the block algorithm for long polynomials.If the input pointers are identical (and the lengths are the same), they are assumed to represent the same polynomial, and its square is computed.%Flint2_arb_poly_mullow_block C A lenA B lenB n prec %Flint2_arb_poly_mullow_classical C A lenA B lenB n prec %Flint2arb_poly_scalar_div C A c prec Sets C to A divided by c.%Flint2arb_poly_scalar_mul C A c prec Sets C to A multiplied by c.%Flint2arb_poly_scalar_mul_2exp_si C A c Sets C to A multiplied by 2^c.&Flint2 arb_poly_neg C A Sets C to the negation of A.&Flint2arb_poly_sub_series C A B len prec Sets C to the difference of A and B, truncated to length len.&Flint2arb_poly_add_series C A B len prec Sets C to the sum of A and B, truncated to length len.&Flint2 arb_poly_sub C A B prec Sets C to the difference of A and B.&Flint2 _arb_poly_sub C A lenA B lenB prec Sets {C, max(lenA, lenB)} to the difference of  {A, lenA} and /{B, lenB}/. Allows aliasing of the input and output operands.&Flint2arb_poly_add_si C A B prec Sets C to the sum of A and B.&Flint2 arb_poly_add C A B prec &Flint2 _arb_poly_add C A lenA B lenB prec Sets {C, max(lenA, lenB)} to the sum of  {A, lenA} and  {B, lenB}4. Allows aliasing of the input and output operands.&Flint2arb_poly_majorant res poly prec Sets res to an exact real polynomial whose coefficients are upper bounds for the absolute values of the coefficients in poly, rounded to prec bits.&Flint2_arb_poly_majorant res poly len prec &Flint2arb_poly_get_unique_fmpz_poly z x If x, contains a unique integer polynomial, sets z3 to that value and returns nonzero. Otherwise (if x represents no integers or more than one integer), returns zero, possibly partially modifying z.&Flint2arb_poly_overlaps poly1 poly2 Returns nonzero iff poly1 overlaps with poly2). The underscore function requires that len1 ist at least as large as len2.&Flint2_arb_poly_overlaps poly1 len1 poly2 len2 &Flint2arb_poly_equal A B Returns nonzero iff A and B are equal as polynomial balls, i.e. all coefficients have equal midpoint and radius.&Flint2arb_poly_contains_fmpq_poly poly1 poly2 Returns nonzero iff poly1 contains poly2.&Flint2arb_poly_contains_fmpz_poly poly1 poly2 &Flint2arb_poly_contains poly1 poly2 &Flint2arb_poly_randtest poly state len prec mag_bits 0Creates a random polynomial with length at most len.&Flint2arb_poly_fprintd file poly digits Prints the polynomial as an array of coefficients to the stream file#, printing each coefficient using  arb_fprintd.&Flint2arb_poly_set_si poly src Sets poly to src, rounding the coefficients to prec bits.&Flint2arb_poly_set_fmpq_poly poly src prec &Flint2arb_poly_set_fmpz_poly poly src prec &Flint2arb_poly_valuation poly Returns the degree of the lowest term that is not exactly zero in poly. Returns -1 if poly is the zero polynomial.&Flint2arb_poly_truncate poly n  Truncates poly to have length at most n%, i.e. degree strictly smaller than n. We require that n is nonnegative.&Flint2arb_poly_shift_left res poly n Sets res to poly multiplied by x^n. We require that n is nonnegative.&Flint2_arb_poly_shift_left res poly len n &Flint2arb_poly_shift_right res poly n Sets res to poly divided by x^n9, throwing away the lower coefficients. We require that n is nonnegative.&Flint2_arb_poly_shift_right res poly len n &Flint2arb_poly_get_coeff_arb v poly n Sets v, to the value of the coefficient with index n in poly. We require that n is nonnegative.&Flint2arb_poly_set_coeff_arb poly n c  Sets the coefficient with index n in poly to the value c. We require that n is nonnegative.&Flint2arb_poly_set_coeff_si poly n c &Flint2arb_poly_set_trunc_round dest src n prec Sets dest to a copy of src, truncated to length n and rounded to prec bits.&Flint2arb_poly_set_trunc dest src n &Flint2arb_poly_set_round dest src prec Sets dest to a copy of src , rounded to prec bits.&Flint2 arb_poly_set dest src Sets dest to a copy of src.&Flint2 arb_poly_one poly Sets poly" to the constant 0 respectively 1.&Flint2 arb_poly_zero poly &Flint2 arb_poly_is_x poly  Returns 1 if poly# is exactly the polynomial 0, 1 or x$ respectively. Returns 0 otherwise.&Flint2arb_poly_is_one poly &Flint2arb_poly_is_zero poly &Flint2arb_poly_degree poly Returns the degree of poly, defined as one less than its length. Note that if one or several leading coefficients are balls containing zero, this value can be larger than the true degree of the exact polynomial represented by poly, so the return value of this function is effectively an upper bound.&Flint2arb_poly_length poly Returns the length of poly, i.e. zero if poly is identically zero, and otherwise one more than the index of the highest term that is not identically zero.&Flint2arb_poly_allocated_bytes x Returns the total number of bytes heap-allocated internally by this object. The count excludes the size of the structure itself. Add sizeof(arb_poly_struct)* to get the size of the object as a whole.&Flint2_arb_poly_normalise poly =Strips any trailing coefficients which are identical to zero.&Flint2_arb_poly_set_length poly len Directly changes the length of the polynomial, without allocating or deallocating coefficients. The value should not exceed the allocation length.&Flint2arb_poly_fit_length poly len Makes sure that the coefficient array of the polynomial contains at least len initialized coefficients.&Flint2arb_poly_clear poly Clears the polynomial, deallocating all coefficients and the coefficient array.&Flint2 arb_poly_init poly Initializes the polynomial for use, setting it to the zero polynomial.&Flint2Createst a new   structure encapsulated in  .&Flint2Use   in f.&Flint2Use new   ptr in f.&Flint2arb_poly_printd poly digits Prints the polynomial as an array of coefficients, printing each coefficient using  arb_printd. $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&< Safe-Inferred )*1u $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ Safe-Inferred )*1&Flint2acb_poly_validate_real_roots roots poly prec !Given a strictly real polynomial poly (of length len) and isolating intervals for all its complex roots, determines if all the real roots are separated from the non-real roots. If this function returns nonzero, every root enclosure that touches the real axis (as tested by applying arb_contains_zero to the imaginary part) corresponds to a real root (its imaginary part can be set to zero), and every other root enclosure corresponds to a non-real root (with known sign for the imaginary part).If this function returns zero, then the signs of the imaginary parts are not known for certain, based on the accuracy of the inputs and the working precision prec.&Flint2acb_poly_find_roots roots poly initial maxiter prec Attempts to compute all the roots of the given nonzero polynomial poly using a working precision of prec bits. If n denotes the degree of poly, the function writes n approximate roots with rigorous error bounds to the preallocated array roots5, and returns the number of roots that are isolated.If the return value equals the degree of the polynomial, then all roots have been found. If the return value is smaller, all the output intervals are guaranteed to contain roots, but it is possible that not all of the polynomial's roots are contained among them.The roots are computed numerically by performing several steps with the Durand-Kerner method and terminating if the estimated accuracy of the roots approaches the working precision or if the number of steps exceeds maxiter, which can be set to zero in order to use a default value. Finally, the approximate roots are validated rigorously.>Initial values for the iteration can be provided as the array initial. If initial is set to NULL, default values  (0.4+0.9i)^k are used.The polynomial is assumed to be squarefree. If there are repeated roots, the iteration is likely to find them (with low numerical accuracy), but the error bounds will not converge as the precision increases.&Flint2$_acb_poly_refine_roots_durand_kerner roots poly len prec Refines the given roots simultaneously using a single iteration of the Durand-Kerner method. The radius of each root is set to an approximation of the correction, giving a rough estimate of its error (not a rigorous bound).&Flint2_acb_poly_validate_roots roots poly len prec Given a list of approximate roots of the input polynomial, this function sets a rigorous bounding interval for each root, and determines which roots are isolated from all the other roots. It then rearranges the list of roots so that the isolated roots are at the front of the list, and returns the count of isolated roots.If the return value equals the degree of the polynomial, then all roots have been found. If the return value is smaller, all the remaining output intervals are guaranteed to contain roots, but it is possible that not all of the polynomial's roots are contained among them.&Flint2_acb_poly_root_inclusion r m poly polyder len prec Given any complex number m, and a nonconstant polynomial f and its derivative f', sets r# to a complex interval centered on m5 that is guaranteed to contain at least one root of f;. Such an interval is obtained by taking a ball of radius |f(m)/f'(m)| n where n is the degree of f?. Proof: assume that the distance to the nearest root exceeds r = |f(m)/f'(m)| n. Then` \left|\frac{f'(m)}{f(m)}\right| = \left|\sum_i \frac{1}{m-\zeta_i}\right| \le \sum_i \frac{1}{|m-\zeta_i|} < \frac{n}{r} = \left|\frac{f'(m)}{f(m)}\right|which is a contradiction (see  [Kob2010]).&Flint2acb_poly_root_bound_fujiwara bound poly Sets bound to an upper bound for the magnitude of all the complex roots of poly. Uses Fujiwara's bound` 2 \max \left\{\left|\frac{a_{n-1}}{a_n}\right|, \left|\frac{a_{n-2}}{a_n}\right|^{1/2}, \cdots, \left|\frac{a_1}{a_n}\right|^{1/(n-1)}, \left|\frac{a_0}{2a_n}\right|^{1/n} \right\}where a_0, \ldots, a_n are the coefficients of poly.&Flint2acb_poly_agm1_series res z n prec Sets res= to the arithmetic-geometric mean of 1 and the power series z, truncated to length n.&Flint2acb_poly_erf_series res z n prec Sets res+ to the error function of the power series z, truncated to length n?. These methods are provided for backwards compatibility. See acb_hypgeom_erf_series, acb_hypgeom_erfc_series, acb_hypgeom_erfi_series.&Flint2acb_poly_polylog_series w s z len prec Sets w to the polylogarithm \operatorname{Li}_{s}(z) where s; is a given power series, truncating the output to length len. The underscore method requires all lengths to be positive and supports aliasing between all inputs and outputs.&Flint2_acb_poly_polylog_cpx w s z len prec Sets w& to the Taylor series with respect to x of the polylogarithm \operatorname{Li}_{s+x}(z), where s and z are given complex constants. The output is computed to length len+ which must be positive. Aliasing between w and s or z is not permitted.The small version uses the standard power series expansion with respect to z, convergent when |z| < 1. The zeta version evaluates the polylogarithm as a sum of two Hurwitz zeta functions. The default version automatically delegates to the small version when z is close to zero, and the zeta. version otherwise. For further details, see algorithms_polylogarithms.&Flint2acb_poly_zeta_series res f a deflate n prec Sets res to the Hurwitz zeta function  \zeta(s,a) where s a power series and a$ is a constant, truncated to length n4. To evaluate the usual Riemann zeta function, set a = 1.If deflate is nonzero, evaluates \zeta(s,a) + 1/(1-s)>, which is well-defined as a limit when the constant term of s! is 1. In particular, expanding \zeta(s,a) + 1/(1-s) with s = 1+x gives the Stieltjes constants` 4\sum_{k=0}^{n-1} \frac{(-1)^k}{k!} \gamma_k(a) x^k`.If a = 1, this implementation uses the reflection formula if the midpoint of the constant term of s is negative.&Flint2_acb_poly_zeta_cpx_series z s a deflate d prec !Computes the series expansion of  \zeta(s+x,a) (or \zeta(s+x,a) - 1/(s+x-1) if deflate is nonzero) to order d.This function wraps _acb_poly_zeta_em_sum-, automatically choosing default values for N, M using _acb_poly_zeta_em_choose_param, to target an absolute truncation error of 2^{-\operatorname{prec}}.&Flint2_acb_poly_zeta_em_sum z s a deflate N M d prec 5Evaluates the truncated Euler-Maclaurin sum of order N, M for the length-d7 truncated Taylor series of the Hurwitz zeta function  \zeta(s,a) at s, using a working precision of prec bits. With a = 1-, this gives the usual Riemann zeta function.If deflate is nonzero, \zeta(s,a) - 1/(s-1)2 is evaluated (which permits series expansion at s = 1).&Flint2_acb_poly_zeta_em_tail_bsplit z s Na Nasx M len prec Evaluates the tail in the Euler-Maclaurin sum for the Hurwitz zeta function, respectively using the naive recurrence and binary splitting.&Flint2_acb_poly_zeta_em_bound vec s a N M d wp Compute bounds for Euler-Maclaurin evaluation of the Hurwitz zeta function or its power series, using the formulas in  [Joh2013].&Flint2_acb_poly_zeta_em_choose_param bound N M s a d target prec Chooses N and M for Euler-Maclaurin summation of the Hurwitz zeta function, using a default algorithm.&Flint2"_acb_poly_powsum_one_series_sieved z s n len prec Computes` +z = S(s,1,n) \sum_{k=1}^n \frac{1}{k^{s+t}}as a power series in t truncated to length len. This function stores a table of powers that have already been calculated, computing (ij)^r as i^r j^r whenever k = ij> is composite. As a further optimization, it groups all even k+ and evaluates the sum as a polynomial in  2^{-(s+t)}. This scheme requires about  n / \log n powers, n / 2+ multiplications, and temporary storage of n / 6 power series. Due to the extra power series multiplications, it is only faster than the naive algorithm when len is small.&Flint2&_acb_poly_powsum_series_naive_threaded z s a q n len prec Computes` 7z = S(s,a,n) = \sum_{k=0}^{n-1} \frac{q^k}{(k+a)^{s+t}}as a power series in t truncated to length len=. This function evaluates the sum naively term by term. The threaded version splits the computation over the number of threads returned by flint_get_num_threads().&Flint2acb_poly_rising_ui_series res f r trunc prec Sets res to the rising factorial (f) (f+1) (f+2) \cdots (f+r-1), truncated to length trunc%. The underscore method assumes that flen, r and trunc are at least 1, and does not support aliasing. Uses binary splitting.&Flint2acb_poly_digamma_series res h n prec Sets res to the series expansion of  \Gamma(h(x)), 1/\Gamma(h(x)), or \log \Gamma(h(x)),  \psi(h(x)), truncated to length n.These functions first generate the Taylor series at the constant term of h, and then call _acb_poly_compose_series. The Taylor coefficients are generated using Stirling's series.The underscore methods support aliasing of the input and output arrays, and require that hlen and n are greater than zero.&Flint2acb_poly_lambertw_series res z k flags len prec Sets res to branch k0 of the Lambert W function of the power series z. The argument flags is reserved for future use. The underscore method allows aliasing, but assumes that the lengths are nonzero.&Flint2acb_poly_sinc_series s h n prec Sets s* to the sinc function of the power series h, truncated to length n.&Flint2acb_poly_cosh_series c h n prec Sets s and c respectively to the hyperbolic sine and cosine of the power series h, truncated to length n.The implementations mirror those for sine and cosine, except that the  exponential version computes both functions using the exponential function instead of the hyperbolic tangent.&Flint2acb_poly_cot_pi_series c h n prec Compute the respective trigonometric functions of the input multiplied by \pi.&Flint2acb_poly_tan_series g h n prec Sets g to the power series tangent of h. For small n takes the quotient of the sine and cosine as computed using the basecase algorithm. For large n, uses Newton iteration to invert the inverse tangent series. The complexity is O(M(n)).The underscore version does not support aliasing, and requires the lengths to be nonzero.'Flint2acb_poly_cos_series c h n prec Respectively evaluates the power series sine or cosine. These functions simply wrap _acb_poly_sin_cos_series. The underscore methods support aliasing and require the lengths to be nonzero.'Flint2_acb_poly_sin_cos_series s c h hlen n prec Sets s and c( to the power series sine and cosine of h, computed simultaneously. The underscore method supports aliasing and requires the lengths to be nonzero.'Flint2acb_poly_exp_pi_i_series f h n prec Sets f to the power series  \exp(\pi i h) truncated to length n. The underscore method supports aliasing and allows the input to be shorter than the output, but requires the lengths to be nonzero.'Flint2acb_poly_exp_series f h n prec Sets f$ to the power series exponential of h, truncated to length n.The basecase version uses a simple recurrence for the coefficients, requiring O(nm) operations where m is the length of h.The main implementation uses Newton iteration, starting from a small number of terms given by the basecase algorithm. The complexity is O(M(n)). Redundant operations in the Newton iteration are avoided by using the scheme described in  [HZ2004].The underscore methods support aliasing and allow the input to be shorter than the output, but require the lengths to be nonzero.'Flint2acb_poly_atan_series res f n prec Sets res% the power series inverse tangent of f, truncated to length n.Uses the formula` -\tan^{-1}(f(x)) = \int f'(x) / (1+f(x)^2) dx,,adding the function of the constant term in f! as the constant of integration.The underscore method supports aliasing of the input and output arrays. It requires that flen and n are greater than zero.'Flint2acb_poly_log1p_series res f n prec Computes the power series  \log(1+f)2, with better accuracy when the constant term of f is small.'Flint2acb_poly_log_series res f n prec Sets res" to the power series logarithm of f, truncated to length n. Uses the formula !\log(f(x)) = \int f'(x) / f(x) dx0, adding the logarithm of the constant term in f as the constant of integration.The underscore method supports aliasing of the input and output arrays. It requires that flen and n are greater than zero.'Flint2acb_poly_rsqrt_series g h n prec Sets g/ to the reciprocal power series square root of h, truncated to length n&. Uses division-free Newton iteration.The underscore method does not support aliasing of the input and output arrays. It requires that hlen and n are greater than zero.'Flint2acb_poly_sqrt_series g h n prec Sets g$ to the power series square root of h, truncated to length n. Uses division-free Newton iteration for the reciprocal square root, followed by a multiplication.The underscore method does not support aliasing of the input and output arrays. It requires that hlen and n are greater than zero.'Flint2acb_poly_pow_acb_series h f g len prec Sets h to the power series f(x)^g = \exp(g \log f(x)) truncated to length len.'Flint2_acb_poly_pow_acb_series h f flen g len prec Sets {h, len} to the power series f(x)^g = \exp(g \log f(x)) truncated to length len/. This function detects special cases such as g! being an exact small integer or \pm 1/2, and computes such powers more efficiently. This function does not support aliasing of the output with either of the input operands. It requires that all lengths are positive, and assumes that flen does not exceed len.'Flint2acb_poly_pow_series h f g len prec Sets h to the power series "f(x)^{g(x)} = \exp(g(x) \log f(x)) truncated to length len/. This function detects special cases such as g! being an exact small integer or \pm 1/2-, and computes such powers more efficiently.'Flint2_acb_poly_pow_series h f flen g glen len prec Sets {h, len} to the power series "f(x)^{g(x)} = \exp(g(x) \log f(x)) truncated to length len/. This function detects special cases such as g" being an exact small integer or \pm 1/2, and computes such powers more efficiently. This function does not support aliasing of the output with either of the input operands. It requires that all lengths are positive, and assumes that flen and glen do not exceed len.'Flint2acb_poly_pow_ui res poly exp prec Sets res to poly raised to the power exp.'Flint2_acb_poly_pow_ui res f flen exp prec Sets res to  {f, flen} raised to the power exp. Does not support aliasing of the input and output, and requires that flen is positive.'Flint2acb_poly_pow_ui_trunc_binexp res poly exp len prec Sets res to poly raised to the power exp, truncated to length len. Uses binary exponentiation.'Flint2_acb_poly_pow_ui_trunc_binexp res f flen exp len prec Sets  {res, len} to  {f, flen} raised to the power exp, truncated to length len. Requires that len is no longer than the length of the power as computed without truncation (i.e. no zero-padding is performed). Does not support aliasing of the input and output, and requires that flen and len* are positive. Uses binary exponentiation.'Flint2acb_poly_graeffe_transform b a prec Computes the Graeffe transform of input polynomial, which is of length len. See arb_poly_graeffe_transform for details.#The underscore method assumes that a and b are initialized, a is of length len, and b is of length at least len. Both methods allow aliasing.'Flint2acb_poly_binomial_transform b a len prec Computes the binomial transform of the input polynomial, truncating the output to length len. See arb_poly_binomial_transform for details.The underscore methods do not support aliasing, and assume that the lengths are nonzero.'Flint2acb_poly_inv_borel_transform res poly prec Computes the inverse Borel transform of the input polynomial, mapping \sum_k a_k x^k to \sum_k a_k k! x^k). The underscore method allows aliasing.'Flint2acb_poly_borel_transform res poly prec ?Computes the Borel transform of the input polynomial, mapping \sum_k a_k x^k to \sum_k (a_k / k!) x^k). The underscore method allows aliasing.'Flint2acb_poly_integral res poly prec Sets res to the integral of poly.'Flint2_acb_poly_integral res poly len prec Sets  {res, len} to the integral of {poly, len - 1}+. Allows aliasing of the input and output.'Flint2acb_poly_nth_derivative res poly n prec Sets res to the nth derivative of poly.'Flint2_acb_poly_nth_derivative res poly n len prec Sets {res, len - n} to the nth derivative of  {poly, len}. Does nothing if len <= n*. Allows aliasing of the input and output.'Flint2acb_poly_derivative res poly prec Sets res to the derivative of poly.'Flint2_acb_poly_derivative res poly len prec Sets {res, len - 1} to the derivative of  {poly, len}+. Allows aliasing of the input and output.'Flint2acb_poly_interpolate_fast poly xs ys n prec 1Recovers the unique polynomial of length at most n that interpolates the given x and y values, using fast Lagrange interpolation. The precomp function takes a precomputed product tree over the x values and a vector of interpolation weights as additional inputs.'Flint2 acb_poly_interpolate_barycentric poly xs ys n prec 1Recovers the unique polynomial of length at most n that interpolates the given x and y values. This implementation uses the barycentric form of Lagrange interpolation.'Flint2acb_poly_interpolate_newton poly xs ys n prec 1Recovers the unique polynomial of length at most n that interpolates the given x and y values. This implementation first interpolates in the Newton basis and then converts back to the monomial basis.'Flint2acb_poly_evaluate_vec_fast ys poly xs n prec +Evaluates the polynomial simultaneously at n1 given points, using fast multipoint evaluation.'Flint2acb_poly_evaluate_vec_iter ys poly xs n prec +Evaluates the polynomial simultaneously at n given points, calling _acb_poly_evaluate repeatedly.'Flint2_acb_poly_tree_build tree roots len prec 0Constructs a product tree from a given array of len roots. The tree structure must be pre-allocated to the specified length using _acb_poly_tree_alloc.'Flint2_acb_poly_tree_free tree len 0Deallocates a tree structure as allocated using _acb_poly_tree_alloc.'Flint2_acb_poly_tree_alloc len Returns an initialized data structured capable of representing a remainder tree (product tree) of len roots.'Flint2acb_poly_product_roots poly xs n prec Generates the polynomial (x-x_0)(x-x_1)\cdots(x-x_{n-1}).'Flint2acb_poly_evaluate2 y z f x prec Sets y = f(x), z = f'(x), evaluated respectively using Horner's rule, rectangular splitting, and an automatic algorithm choice.When Horner's rule is used, the only advantage of evaluating the function and its derivative simultaneously is that one does not have to generate the derivative polynomial explicitly. With the rectangular splitting algorithm, the powers can be reused, making simultaneous evaluation slightly faster.'Flint2acb_poly_evaluate y f x prec Sets y = f(x), evaluated respectively using Horner's rule, rectangular splitting, and an automatic algorithm choice.'Flint2acb_poly_revert_series h f n prec Sets h" to the power series reversion of f<, i.e. the expansion of the compositional inverse function  f^{-1}(x), truncated to order O(x^n), using respectively Lagrange inversion, Newton iteration, fast Lagrange inversion, and a default algorithm choice.%We require that the constant term in f is exactly zero and that the linear term is nonzero. The underscore methods assume that flen- is at least 2, and do not support aliasing.'Flint2_acb_poly_compose_series res poly1 len1 poly2 len2 n prec Sets res! to the power series composition h(x) = f(g(x)) truncated to order O(x^n) where f is given by poly1 and g is given by poly2. Wraps _gr_poly_compose_series9 which chooses automatically between various algorithms.%We require that the constant term in g(x) is exactly zero. The underscore method does not support aliasing of the output with either input polynomial.'Flint2_acb_poly_compose res poly1 len1 poly2 len2 prec Sets res to the composition h(x) = f(g(x)) where f is given by poly1 and g is given by poly2. The underscore method does not support aliasing of the output with either input polynomial.'Flint2_acb_poly_taylor_shift g c n prec Sets g to the Taylor shift f(x+c)*. The underscore methods act in-place on g = f which has length n.'Flint2_acb_poly_div_root Q R A len c prec Divides A by the polynomial x - c, computing the quotient Q as well as the remainder R = f(c).'Flint2acb_poly_divrem Q R A B prec Performs polynomial division with remainder, computing a quotient Q and a remainder R such that  A = BQ + R. The implementation reverses the inputs and performs power series division.If the leading coefficient of B contains zero (or if B is identically zero), returns 0 indicating failure without modifying the outputs. Otherwise returns nonzero.'Flint2acb_poly_div_series Q A B n prec Sets Q to the power series quotient A divided by B, truncated to length n.'Flint2_acb_poly_div_series Q A Alen B Blen n prec Sets {Q, n}! to the power series quotient of  {A, Alen} by /{B, Blen}/. Uses Newton iteration followed by multiplication.'Flint2acb_poly_inv_series Qinv Q n prec Sets Qinv to the power series inverse of Q.'Flint2_acb_poly_inv_series Qinv Q Qlen len prec Sets  {Qinv, len} to the power series inverse of  {Q, Qlen}. Uses Newton iteration.'Flint2 acb_poly_mul C A1 B2 prec Sets C to the product of A and B&. If the same variable is passed for A and B, sets C to the square of A.'Flint2 _acb_poly_mul C A lenA B lenB prec Sets {C, lenA + lenB - 1} to the product of  {A, lenA} and /{B, lenB}/. The output is not allowed to be aliased with either of the inputs. We require #\mathrm{lenA} \ge \mathrm{lenB} > 08. This function is implemented as a simple wrapper for _acb_poly_mullow.If the input pointers are identical (and the lengths are the same), they are assumed to represent the same polynomial, and its square is computed.'Flint2acb_poly_mullow C A B n prec Sets C to the product of A and B, truncated to length n&. If the same variable is passed for A and B, sets C to the square of A truncated to length n.'Flint2_acb_poly_mullow C A lenA B lenB n prec Sets {C, n} to the product of  {A, lenA} and  {B, lenB}, truncated to length n. The output is not allowed to be aliased with either of the inputs. We require #\mathrm{lenA} \ge \mathrm{lenB} > 0, n > 0, '\mathrm{lenA} + \mathrm{lenB} - 1 \ge n.The  classical version uses a plain loop.The  transpose version evaluates the product using four real polynomial multiplications (via _arb_poly_mullow).The transpose_gauss version evaluates the product using three real polynomial multiplications. This is almost always faster than  transpose, but has worse numerical stability when the coefficients vary in magnitude.The default function _acb_poly_mullow automatically switches been  classical and  transpose multiplication.If the input pointers are identical (and the lengths are the same), they are assumed to represent the same polynomial, and its square is computed.'Flint2acb_poly_scalar_div C A c prec Sets C to A divided by c.'Flint2acb_poly_scalar_mul C A c prec Sets C to A multiplied by c.'Flint2acb_poly_scalar_mul_2exp_si C A c Sets C to A multiplied by 2^c.'Flint2 acb_poly_neg C A Sets C to the negation of A.'Flint2acb_poly_sub_series C A B len prec Sets C to the difference of A and B, truncated to length len.'Flint2acb_poly_add_series C A B len prec Sets C to the sum of A and B, truncated to length len.'Flint2 acb_poly_sub C A B prec Sets C to the difference of A and B.'Flint2 _acb_poly_sub C A lenA B lenB prec Sets {C, max(lenA, lenB)} to the difference of  {A, lenA} and /{B, lenB}/. Allows aliasing of the input and output operands.'Flint2acb_poly_add_si C A B prec Sets C to the sum of A and B.'Flint2 _acb_poly_add C A lenA B lenB prec Sets {C, max(lenA, lenB)} to the sum of  {A, lenA} and  {B, lenB}4. Allows aliasing of the input and output operands.'Flint2acb_poly_majorant res poly prec Sets res to an exact real polynomial whose coefficients are upper bounds for the absolute values of the coefficients in poly, rounded to prec bits.'Flint2acb_poly_set_si poly src Sets poly to src.'Flint2acb_poly_set2_fmpq_poly poly re im prec Sets poly to the given real part re plus the imaginary part im, both rounded to prec bits.(Flint2acb_poly_is_real poly (Returns nonzero iff all coefficients in poly have zero imaginary part.(Flint2acb_poly_get_unique_fmpz_poly z x If x, contains a unique integer polynomial, sets z3 to that value and returns nonzero. Otherwise (if x represents no integers or more than one integer), returns zero, possibly partially modifying z.(Flint2acb_poly_overlaps poly1 poly2 Returns nonzero iff poly1 overlaps with poly2). The underscore function requires that len1 ist at least as large as len2.(Flint2acb_poly_contains_fmpq_poly poly1 poly2 Returns nonzero iff poly2 is contained in poly1.(Flint2acb_poly_equal A B Returns nonzero iff A and B' are identical as interval polynomials.(Flint2acb_poly_randtest poly state len prec mag_bits 0Creates a random polynomial with length at most len.(Flint2acb_poly_fprintd file poly digits Prints the polynomial as an array of coefficients to the stream file#, printing each coefficient using  acb_fprintd.(Flint2acb_poly_valuation poly Returns the degree of the lowest term that is not exactly zero in poly. Returns -1 if poly is the zero polynomial.(Flint2acb_poly_truncate poly n  Truncates poly to have length at most n%, i.e. degree strictly smaller than n. We require that n is nonnegative.(Flint2acb_poly_shift_left res poly n Sets res to poly multiplied by x^n. We require that n is nonnegative.(Flint2acb_poly_shift_right res poly n Sets res to poly divided by x^n9, throwing away the lower coefficients. We require that n is nonnegative.(Flint2acb_poly_get_coeff_acb v poly n Sets v, to the value of the coefficient with index n in poly. We require that n is nonnegative.(Flint2acb_poly_set_coeff_acb poly n c  Sets the coefficient with index n in poly to the value c. We require that n is nonnegative.(Flint2acb_poly_set_trunc_round dest src n prec Sets dest to a copy of src, truncated to length n and rounded to prec bits.(Flint2acb_poly_set_round dest src prec Sets dest to a copy of src , rounded to prec bits.(Flint2 acb_poly_set dest src Sets dest to a copy of src.(Flint2 acb_poly_one poly Sets poly to the constant polynomial 1.(Flint2 acb_poly_zero poly Sets poly to the zero polynomial.(Flint2 acb_poly_is_x poly  Returns 1 if poly# is exactly the polynomial 0, 1 or x$ respectively. Returns 0 otherwise.(Flint2acb_poly_degree poly Returns the degree of poly, defined as one less than its length. Note that if one or several leading coefficients are balls containing zero, this value can be larger than the true degree of the exact polynomial represented by poly, so the return value of this function is effectively an upper bound.(Flint2acb_poly_length poly Returns the length of poly, i.e. zero if poly is identically zero, and otherwise one more than the index of the highest term that is not identically zero.(Flint2acb_poly_allocated_bytes x Returns the total number of bytes heap-allocated internally by this object. The count excludes the size of the structure itself. Add sizeof(acb_poly_struct)* to get the size of the object as a whole.(Flint2 acb_poly_swap poly1 poly2 Swaps poly1 and poly2 efficiently.(Flint2_acb_poly_normalise poly =Strips any trailing coefficients which are identical to zero.(Flint2_acb_poly_set_length poly len Directly changes the length of the polynomial, without allocating or deallocating coefficients. The value should not exceed the allocation length.(Flint2acb_poly_fit_length poly len Makes sure that the coefficient array of the polynomial contains at least len initialized coefficients.(Flint2acb_poly_clear poly Clears the polynomial, deallocating all coefficients and the coefficient array.(Flint2 acb_poly_init poly Initializes the polynomial for use, setting it to the zero polynomial.(Flint2Createst a new & structure encapsulated in &.(Flint2Use & in f.(Flint2Use new & ptr in f.(Flint2acb_poly_printd poly digits Prints the polynomial as an array of coefficients, printing each coefficient using  acb_printd.&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''((((((((((((((((((((((((((((((((((((((((((((((= Safe-Inferred )*1 '&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''((((((((((((((((((((((((((((((((((((((((((((((&&&((((((((((((((((((((((((((((((((((((((((((((((''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& Safe-Inferred )*1!(Flint2"arb_fmpz_poly_gauss_period_minpoly res q n Sets res4 to the minimal polynomial of the Gaussian periods \sum_{a \in H} \zeta^a where \zeta = \exp(2 \pi i / q) and H+ are the cosets of the subgroups of order d = (q - 1) / n of !(\mathbb{Z}/q\mathbb{Z})^{\times}'. The resulting polynomial has degree n. When d = 1+, the result is the cyclotomic polynomial \Phi_q. The implementation assumes that q is prime, and that n is a divisor of q - 1 such that n is coprime with d . If any condition is not met, res is set to the zero polynomial.This method provides a fast (in practice) way to construct finite field extensions of prescribed degree. If q, satisfies the conditions stated above and (q-1)/f additionally is coprime with n, where f! is the multiplicative order of p mod q, then the Gaussian period minimal polynomial is irreducible over \operatorname{GF}(p)  [CP2005].(Flint2arb_fmpz_poly_cos_minpoly res n Sets res$ to the monic minimal polynomial of 2 \cos(2 \pi / n) . This is a wrapper of FLINT's fmpz_poly_cos_minpoly,, provided here for backward compatibility.(Flint2arb_fmpz_poly_complex_roots roots poly flags prec  Writes to roots3 all the real and complex roots of the polynomial poly, computed to at least prec accurate bits. The root enclosures are guaranteed to be disjoint, so that all roots are isolated.The real roots are written first in ascending order (with the imaginary parts set exactly to zero). The following nonreal roots are written in arbitrary order, but with conjugate pairs grouped together (the root in the upper plane leading the root in the lower plane).The input polynomial must be squarefree. For a general polynomial, compute the squarefree part f / \gcd(f,f') or do a full squarefree factorization to obtain the multiplicities of the roots: fmpz_poly_factor_t fac; fmpz_poly_factor_init(fac); fmpz_poly_factor_squarefree(fac, poly); for (i = 0; i < fac->num; i++) { deg = fmpz_poly_degree(fac->p + i); flint_printf("%wd roots of multiplicity %wd\n", deg, fac->exp[i]); roots = _acb_vec_init(deg); arb_fmpz_poly_complex_roots(roots, fac->p + i, 0, prec); _acb_vec_clear(roots, deg); } fmpz_poly_factor_clear(fac);9All roots are refined to a relative accuracy of at least prec bits. The output values will generally have higher actual precision, depending on the precision needed for isolation and the precision used internally by the algorithm.This implementation should be adequate for general use, but it is not currently competitive with state-of-the-art isolation methods for finding real roots alone.The following flags are supported:arb_fmpz_poly_roots_verbose(Flint2arb_fmpz_poly_deflate res poly  deflation Sets res to a copy of poly deflated by the exponent  deflation.(Flint2arb_fmpz_poly_deflation poly $Finds the maximal exponent by which poly can be deflated.(Flint2arb_fmpz_poly_evaluate_acb res poly x prec  Evaluates poly0 (given by a polynomial object or an array with len coefficients) at the given real or complex number, respectively using Horner's rule, rectangular splitting, or a default algorithm choice.(Flint2_arb_fmpz_poly_evaluate_acb res poly len x prec (Flint2&arb_fmpz_poly_evaluate_acb_rectangular res poly x prec (Flint2'_arb_fmpz_poly_evaluate_acb_rectangular res poly len x prec (Flint2!arb_fmpz_poly_evaluate_acb_horner res poly x prec (Flint2"_arb_fmpz_poly_evaluate_acb_horner res poly len x prec (Flint2arb_fmpz_poly_evaluate_arb res poly x prec (Flint2_arb_fmpz_poly_evaluate_arb res poly len x prec (Flint2&arb_fmpz_poly_evaluate_arb_rectangular res poly x prec (Flint2'_arb_fmpz_poly_evaluate_arb_rectangular res poly len x prec (Flint2!arb_fmpz_poly_evaluate_arb_horner res poly x prec (Flint2"_arb_fmpz_poly_evaluate_arb_horner res poly len x prec ((((((((((((((((((> Safe-Inferred )*1"5(((((((((((((((((((((((((((((((((((( Safe-Inferred )*1q.(Flint2acb_modular_hilbert_class_poly res D Sets res1 to the Hilbert class polynomial of discriminant D , defined as` H_D(x) = \prod_{(a,b,c)} \left(x - j\left(\frac{-b+\sqrt{D}}{2a}\right)\right)where (a,b,c) ranges over the primitive reduced positive definite binary quadratic forms of discriminant  b^2 - 4ac = D.0The Hilbert class polynomial is only defined if D < 0 and D7 is congruent to 0 or 1 mod 4. If some other value of D is passed as input, res is set to the zero polynomial.(Flint2acb_modular_eisenstein r tau len prec "Computes simultaneously the first len/ entries in the sequence of Eisenstein series 'G_4(\tau), G_6(\tau), G_8(\tau), \ldots , defined by` ?G_{2k}(\tau) = \sum_{m^2 + n^2 \ne 0} \frac{1}{(m+n\tau )^{2k}}and satisfying` G_{2k} \left(\frac{a\tau+b}{c\tau+d}\right) = (c\tau+d)^{2k} G_{2k}(\tau).We first evaluate  G_4(\tau) and  G_6(\tau) on the fundamental domain using theta functions, and then compute the Eisenstein series of higher index using a recurrence relation.(Flint2acb_modular_delta r tau prec "Computes the modular discriminant \Delta(\tau) = \eta(\tau)^{24}, which transforms as` \Delta\left(\frac{a\tau+b}{c\tau+d}\right) = (c\tau+d)^{12} \Delta(\tau).The modular discriminant is sometimes defined with an extra factor  (2\pi)^{12}', which we omit in this implementation.(Flint2acb_modular_lambda r tau prec Computes the lambda function 7\lambda(\tau) = \theta_2^4(0,\tau) / \theta_3^4(0,\tau)4, which is invariant under modular transformations  (a, b; c, d) where a, d are odd and b, c are even.(Flint2 acb_modular_j r tau prec Computes Klein's j-invariant j(\tau) given \tau> in the upper half-plane. The function is normalized so that  j(i) = 1728. We first move \tau to the fundamental domain, which does not change the value of the function. Then we use the formula j(\tau) = 32 (\theta_2^8+\theta_3^8+\theta_4^8)^3 / (\theta_2 \theta_3 \theta_4)^8 where \theta_i = \theta_i(0,\tau).(Flint2acb_modular_eta r tau prec #Computes the Dedekind eta function  \eta(\tau) given \tau in the upper half-plane. This function applies the functional equation to move \tau* to the fundamental domain before calling acb_modular_eta_sum.(Flint2acb_modular_epsilon_arg g Given g = (a, b; c, d), computes an integer R such that )\varepsilon(a,b,c,d) = \exp(\pi i R / 12) is the 24th root of unity in the transformation formula for the Dedekind eta function,` \eta\left(\frac{a\tau+b}{c\tau+d}\right) = \varepsilon (a,b,c,d) \sqrt{c\tau+d} \eta(\tau).(Flint2acb_modular_eta_sum eta q prec Evaluates the Dedekind eta function without the leading 24th root, i.e.` \exp(-\pi i \tau/12) \eta(\tau) = \sum_{n=-\infty}^{\infty} (-1)^n q^{(3n^2-n)/2}given q = \exp(2 \pi i \tau)!, by summing the defining series.This function is intended for  |q| \ll 1. It can be called with any q, but will return useless intervals if convergence is not rapid. For general evaluation of the eta function, the user should only call this function after applying a suitable modular transformation.The series is evaluated using either a short addition sequence or rectangular splitting, depending on the number of terms. The algorithms are described in  [EHJ2016].(Flint2acb_modular_addseq_eta  exponents aindex bindex num .Constructs an addition sequence for the first num generalized pentagonal numbers (excluding zero), i.e. 1, 2, 5, 7, 12, 15, 22, 26, 35, 40 etc.(Flint2acb_modular_theta_series theta1 theta2 theta3 theta4 z tau len prec Evaluates the respective Jacobi theta functions of the power series z, truncated to length len(. Either of the output variables can be NULL.(Flint2acb_modular_theta_jet theta1 theta2 theta3 theta4 z tau len prec Evaluates the Jacobi theta functions along with their derivatives with respect to z, writing the first len# coefficients in the power series &\theta_i(z+x,\tau) \in \mathbb{C}[[x]]* to each respective output variable. The  notransform version does not move \tau& to the fundamental domain or reduce z during the computation.(Flint2acb_modular_theta theta1 theta2 theta3 theta4 z tau prec %Evaluates the Jacobi theta functions \theta_i(z,\tau), i = 1, 2, 3, 4% simultaneously. This function moves \tau2 to the fundamental domain and then also reduces z modulo \tau before calling acb_modular_theta_sum.(Flint2acb_modular_theta_notransform theta1 theta2 theta3 theta4 z tau prec %Evaluates the Jacobi theta functions \theta_i(z,\tau), i = 1, 2, 3, 4- simultaneously. This function does not move \tau; to the fundamental domain. This is generally worse than acb_modular_theta0, but can be slightly better for moderate input.(Flint2acb_modular_theta_const_sum theta2 theta3 theta4 q prec Computes the respective theta constants by direct summation (without applying modular transformations). This function selects an appropriate N, calls either $acb_modular_theta_const_sum_basecase or acb_modular_theta_const_sum_rs or depending on N-, and adds a bound for the truncation error.(Flint2acb_modular_theta_const_sum_rs theta2 theta3 theta4 q N prec ,Computes the truncated theta constant sums '\theta_2 = \sum_{k(k+1) < N} q^{k(k+1)}, !\theta_3 = \sum_{k^2 < N} q^{k^2}, (\theta_4 = \sum_{k^2 < N} (-1)^k q^{k^2}. The basecase. version uses a short addition sequence. The rs version uses rectangular splitting. The algorithms are described in  [EHJ2016].(Flint2acb_modular_theta_sum theta1 theta2 theta3 theta4 w  w_is_unit q len prec "Simultaneously computes the first len1 coefficients of each of the formal power series` 0\theta_1(z+x,\tau) / q_{1/4} \in \mathbb{C}[[x]] 0\theta_2(z+x,\tau) / q_{1/4} \in \mathbb{C}[[x]] &\theta_3(z+x,\tau) \in \mathbb{C}[[x]] &\theta_4(z+x,\tau) \in \mathbb{C}[[x]]given w = \exp(\pi i z) and q = \exp(\pi i \tau), by summing a finite truncation of the respective theta function series. In particular, with len equal to 1, computes the respective value of the theta function at the point z . We require len to be positive. If  w_is_unit is nonzero, w- is assumed to lie on the unit circle, i.e. z is assumed to be real.Note that the factor q_{1/4} is removed from \theta_1 and \theta_2. To get the true theta function values, the user has to multiply this factor back. This convention avoids unnecessary computations, since the user can compute q_{1/4} = \exp(\pi i \tau / 4) followed by q = (q_{1/4})^4, and in many cases when computing products or quotients of theta functions, the factor q_{1/4} can be eliminated entirely.This function is intended for  |q| \ll 1. It can be called with any q, but will return useless intervals if convergence is not rapid. For general evaluation of theta functions, the user should only call this function after applying a suitable modular transformation.7We consider the sums together, alternatingly updating (\theta_1, \theta_2) or (\theta_3, \theta_4). For k = 0, 1, 2, \ldots, the powers of q are +\lfloor (k+2)^2 / 4 \rfloor = 1, 2, 4, 6, 9 etc. and the powers of w are '\pm (k+2) = \pm 2, \pm 3, \pm 4, \ldots8 etc. The scheme is illustrated by the following table:` \begin{aligned} \begin{array}{llll} & \theta_1, \theta_2 & q^0 & (w^1 \pm w^{-1}) \\ k = 0 & \theta_3, \theta_4 & q^1 & (w^2 \pm w^{-2}) \\ k = 1 & \theta_1, \theta_2 & q^2 & (w^3 \pm w^{-3}) \\ k = 2 & \theta_3, \theta_4 & q^4 & (w^4 \pm w^{-4}) \\ k = 3 & \theta_1, \theta_2 & q^6 & (w^5 \pm w^{-5}) \\ k = 4 & \theta_3, \theta_4 & q^9 & (w^6 \pm w^{-6}) \\ k = 5 & \theta_1, \theta_2 & q^{12} & (w^7 \pm w^{-7}) \\ \end{array} \end{aligned}For some integer N \ge 1-, the summation is stopped just before term k = N. Let Q = |q|, W = \max(|w|,|w^{-1}|), E = \lfloor (N+2)^2 / 4 \rfloor and F = \lfloor (N+1)/2 \rfloor + 17. The error of the zeroth derivative can be bounded as` 2 Q^E W^{N+2} \left[ 1 + Q^F W + Q^{2F} W^2 + \ldots \right] = \frac{2 Q^E W^{N+2}}{1 - Q^F W}provided that the denominator is positive (otherwise we set the error bound to infinity). When len6 is greater than 1, consider the derivative of order r. The term of index k and order r! picks up a factor of magnitude (k+2)^r from differentiation of w^{k+2} (it also picks up a factor \pi^r, but we omit this until we rescale the coefficients at the end of the computation). Thus we have the error bound` 2 Q^E W^{N+2} (N+2)^r \left[ 1 + Q^F W \frac{(N+3)^r}{(N+2)^r} + Q^{2F} W^2 \frac{(N+4)^r}{(N+2)^r} + \ldots \right]which by the inequality "(1 + m/(N+2))^r \le \exp(mr/(N+2)) can be bounded as` 6\frac{2 Q^E W^{N+2} (N+2)^r}{1 - Q^F W \exp(r/(N+2))},-again valid when the denominator is positive.To actually evaluate the series, we write the even cosine terms as w^{2n} + w^{-2n}, the odd cosine terms as w (w^{2n} + w^{-2n-2}), and the sine terms as w (w^{2n} - w^{-2n-2})'. This way we only need even powers of w and w^{-1}3. The implementation is not yet optimized for real z+, in which case further work can be saved.This function does not permit aliasing between input and output arguments.(Flint2acb_modular_addseq_theta  exponents aindex bindex num .Constructs an addition sequence for the first num squares and triangular numbers interleaved (excluding zero), i.e. 1, 2, 4, 6, 9, 12, 16, 20, 25, 30 etc.(Flint2acb_modular_theta_transform R S C g 3We wish to write a theta function with quasiperiod \tau0 in terms of a theta function with quasiperiod \tau' = g \tau, given some .g = (a, b; c, d) \in \text{PSL}(2, \mathbb{Z}). For i = 0, 1, 2, 3", this function computes integers R_i and S_i (R and S# should be arrays of length 4) and C \in \{0, 1\} such that` \theta_{1+i}(z,\tau) = \exp(\pi i R_i / 4) \cdot A \cdot B \cdot \theta_{1+S_i}(z',\tau')where z' = z, A = B = 1 if C = 0, and` z' = \frac{-z}{c \tau + d}, \quad A = \sqrt{\frac{i}{c \tau + d}}, \quad B = \exp\left(-\pi i c \frac{z^2}{c \tau + d}\right)if C = 1 . Note that A is well-defined with the principal branch of the square root since A^2 = i/(c \tau + d) lies in the right half-plane. Firstly, if c = 0 , we have :\theta_i(z, \tau) = \exp(-\pi i b / 4) \theta_i(z, \tau+b) for i = 1, 2 , whereas \theta_3 and \theta_4 remain unchanged when b. is even and swap places with each other when b is odd. In this case we set C = 0.For an arbitrary g with c > 0 , we set C = 17. The general transformations are given by Rademacher  [Rad1973]. We need the function \theta_{m,n}(z,\tau) defined for m, n \in \mathbb{Z} by (beware of the typos in  [Rad1973])` \theta_{0,0}(z,\tau) = \theta_3(z,\tau), \quad \theta_{0,1}(z,\tau) = \theta_4(z,\tau)` \theta_{1,0}(z,\tau) = \theta_2(z,\tau), \quad \theta_{1,1}(z,\tau) = i \theta_1(z,\tau)` 4\theta_{m+2,n}(z,\tau) = (-1)^n \theta_{m,n}(z,\tau)` .\theta_{m,n+2}(z,\tau) = \theta_{m,n}(z,\tau).Then we may write \begin{eqnarray*} \theta_1(z,\tau) &=& \varepsilon_1 A B \theta_1(z', \tau')\\ \theta_2(z,\tau) &=& \varepsilon_2 A B \theta_{1-c,1+a}(z', \tau')\\ \theta_3(z,\tau) &=& \varepsilon_3 A B \theta_{1+d-c,1-b+a}(z', \tau')\\ \theta_4(z,\tau) &=& \varepsilon_4 A B \theta_{1+d,1-b}(z', \tau') \end{eqnarray*} where  \varepsilon_i is an 8th root of unity. Specifically, if we denote the 24th root of unity in the transformation formula of the Dedekind eta function by 2\varepsilon(a,b,c,d) = \exp(\pi i R(a,b,c,d) / 12) (see acb_modular_epsilon_arg), then: \begin{eqnarray*} \varepsilon_1(a,b,c,d) &=& \exp(\pi i [R(-d,b,c,-a) + 1]/4)\\ \varepsilon_2(a,b,c,d) &=& \exp(\pi i [-R(a,b,c,d) + (5+(2-c)a)]/4)\\ \varepsilon_3(a,b,c,d) &=& \exp(\pi i [-R(a,b,c,d) + (4+(c-d-2)(b-a))]/4)\\ \varepsilon_4(a,b,c,d) &=& \exp(\pi i [-R(a,b,c,d) + (3-(2+d)b)]/4)\\ \end{eqnarray*} 7These formulas are easily derived from the formulas in  [Rad1973] (Rademacher has the transformed/untransformed variables exchanged, and his "(varepsilon)" differs from ours by a constant offset in the phase).(Flint2acb_modular_fill_addseq tab len Builds a near-optimal addition sequence for a sequence of integers which is assumed to be reasonably dense..As input, the caller should set each entry in tab to -1 if that index is to be part of the addition sequence, and to 0 otherwise. On output, entry i in tab will either be zero (if the number is not part of the sequence), or a value j such that both j and i - j, are also marked. The first two entries in tab are ignored (the number 1 is always assumed to be part of the sequence).(Flint2$acb_modular_is_in_fundamental_domain z tol prec -Returns nonzero if it is certainly true that |z| \ge 1 - \varepsilon and ,|\operatorname{Re}(z)| \le 1/2 + \varepsilon where  \varepsilon is specified by tol9. Returns zero if this is false or cannot be determined.(Flint2%acb_modular_fundamental_domain_approx w g z  one_minus_eps prec /Attempts to determine a modular transformation g that maps the complex number z to the fundamental domain or just slightly outside the fundamental domain, where the target tolerance (not a strict bound) is specified by  one_minus_eps*. It also computes the transformed value w = gz."This function first tries to use 'acb_modular_fundamental_domain_approx_d and checks if the result is acceptable. If this fails, it calls )acb_modular_fundamental_domain_approx_arf" with higher precision. Finally, w = gz) is evaluated by a single application of g.The algorithm can fail to produce a satisfactory transformation. The output g is always set to some correct modular transformation, but it is up to the user to verify a posteriori that w, is close enough to the fundamental domain.(Flint2)acb_modular_fundamental_domain_approx_arf g x y  one_minus_eps prec /Attempts to determine a modular transformation g that maps the complex number x+yi to the fundamental domain or just slightly outside the fundamental domain, where the target tolerance (not a strict bound) is specified by  one_minus_eps.2The inputs are assumed to be finite numbers, with y positive.Uses floating-point iteration, repeatedly applying either the transformation  z \gets z + b or  z \gets -1/z". The iteration is terminated if  |x| \le 1/2 and x^2 + y^2 \ge 1 - \varepsilon where 1 - \varepsilon is passed as  one_minus_eps. It is also terminated if too many steps have been taken without convergence, or if the numbers end up too large or too small for the working precision.The algorithm can fail to produce a satisfactory transformation. The output g is always set to some correct modular transformation, but it is up to the user to verify a posteriori that g maps x+yi) close enough to the fundamental domain.(Flint2acb_modular_transform w g z prec #Applies the modular transformation g to the complex number z , evaluating` w = g z = \frac{az+b}{cz+d}.(Flint2psl2z_get_perm p s t n xReturns the permutation p corresponding to x by the homomorphism ;\phi:{\textrm PSL}_2\left({\mathbb Z}\right)\rightarrow S_n defined by the permutations s and t: \begin{align} \begin{pmatrix} 0 &-1 \\ 1 & 0 \end{pmatrix} &\mapsto s \\ \begin{pmatrix} 1 & 1 \\ 0 & 1 \end{pmatrix} &\mapsto t. \\ \end{align} (Flint2psl2z_word_get_str_pretty word#Returns a string representation of word7 in tuples of generators with the corresponding power.(Flint2psl2z_word_fprint_pretty wordOutputs word to a file in tuples of generators with the corresponding power.(Flint2psl2z_word_get_str word$Returns as string representation of word as vector. (Flint2psl2z_word_fprint wordOutputs word to a file as vector. (Flint2 perm_set_word x s t n word2Calculate homomorphism for word from permutations s and t.(Flint2 psl2z__word word xCompose x from a word in S and T.(Flint2psl2z_get_word word xDecomposes x into a word in S and T.(Flint2psl2z_randtest g state bits Sets g to a random element of \text{PSL}(2, \mathbb{Z})% with entries of bit length at most bits (or 1, if bits& is not positive). We first generate a and d, compute their Bezout coefficients, divide by the GCD, and then correct the signs.(Flint2psl2z_is_correct g Returns nonzero iff g) contains correct data, i.e. satisfying  ad-bc = 1, c \ge 0, and d > 0 if c = 0.(Flint2 psl2z_inv h g Sets h to the inverse of g.(Flint2 psl2z_mul h f g Sets h to the product of f and g:, namely the matrix product with the signs canonicalized.(Flint2 psl2z_equal f g Returns nonzero iff f and g are equal.(Flint2 psl2z_fprint file g Prints g to the stream file.(Flint2 psl2z_is_one g Returns nonzero iff g is the identity element.(Flint2 psl2z_one g Sets g to the identity element.(Flint2 psl2z_set f g Sets f to a copy of g.(Flint2 psl2z_swap f g Swaps f and g efficiently.(Flint2 psl2z_clear g Clears g.(Flint2 psl2z_init g  Initializes g$ and set it to the identity element.)Flint2 psl2z_print g Prints g to standard output.)Flint2psl2z_word_print wordOutputs word to stdout as vector. )Flint2psl2z_word_print_pretty wordOutputs word to stdout in tuples of generators with the corresponding power.(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))? Safe-Inferred )*1r(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))((((())))((((((()(((((((((()))(((((()(()((((((((((((((((((((((((((((((((((@ Safe-Inferred )*1tB Safe-Inferred )*1)Flint2acb_elliptic_sigma res z tau prec 'Computes the Weierstrass sigma function` \sigma(z, \tau) = z \prod_{n^2+m^2 \ne 0} \left[ \left(1-\frac{z}{m+n\tau}\right) \exp\left(\frac{z}{m+n\tau} + \frac{z^2}{2(m+n\tau)^2} \right) \right]which is quasiperiodic with \sigma(z + 1, \tau) = -e^{2 \zeta(1/2, \tau) (z+1/2)} \sigma(z, \tau) and \sigma(z + \tau, \tau) = -e^{2 \zeta(\tau/2, \tau) (z+\tau/2)} \sigma(z, \tau).)Flint2acb_elliptic_zeta res z tau prec &Computes the Weierstrass zeta function` \zeta(z, \tau) = \frac{1}{z} + \sum_{n^2+m^2 \ne 0} \left[ \frac{1}{z-m-n\tau} + \frac{1}{m+n\tau} + \frac{z}{(m+n\tau)^2} \right]which is quasiperiodic with 6\zeta(z + 1, \tau) = \zeta(z, \tau) + \zeta(1/2, \tau) and <\zeta(z + \tau, \tau) = \zeta(z, \tau) + \zeta(\tau/2, \tau).)Flint2acb_elliptic_inv_p res z tau prec Computes the inverse of the Weierstrass elliptic function, which satisfies  \wp(\wp^{-1}(z, \tau), \tau) = z2. This function is given by the elliptic integral` \wp^{-1}(z, \tau) = \frac{1}{2} \int_z^{\infty} \frac{dt}{\sqrt{(t-e_1)(t-e_2)(t-e_3)}} = R_F(z-e_1,z-e_2,z-e_3).)Flint2acb_elliptic_roots e1 e2 e3 tau prec Computes the lattice roots  e_1, e_2, e_3), which are the roots of the polynomial 4z^3 - g_2 z - g_3.)Flint2acb_elliptic_invariants g2 g3 tau prec  Computes the lattice invariants g_2, g_3. The Weierstrass elliptic function satisfies the differential equation =[\wp'(z, \tau)]^2 = 4 [\wp(z,\tau)]^3 - g_2 \wp(z,\tau) - g_3. Up to constant factors, the lattice invariants are the first two Eisenstein series (see acb_modular_eisenstein).)Flint2acb_elliptic_p_series res z tau len prec Sets res: to the Weierstrass elliptic function of the power series z, with periods 1 and tau, truncated to length len.)Flint2acb_elliptic_p_jet res z tau len prec "Computes the formal power series $\wp(z + x, \tau) \in \mathbb{C}[[x]], truncated to length len. In particular, with len = 2, simultaneously computes \wp(z, \tau), \wp'(z, \tau) which together generate the field of elliptic functions with periods 1 and \tau.)Flint2acb_elliptic_p_prime res z tau prec Computes the derivative  \wp'(z, \tau)% of Weierstrass's elliptic function  \wp(z, \tau).)Flint2acb_elliptic_p res z tau prec (Computes Weierstrass's elliptic function` \wp(z, \tau) = \frac{1}{z^2} + \sum_{n^2+m^2 \ne 0} \left[ \frac{1}{(z+m+n\tau)^2} - \frac{1}{(m+n\tau)^2} \right]which satisfies 5\wp(z, \tau) = \wp(z + 1, \tau) = \wp(z + \tau, \tau);. To evaluate the function efficiently, we use the formula` \wp(z, \tau) = \pi^2 \theta_2^2(0,\tau) \theta_3^2(0,\tau) \frac{\theta_4^2(z,\tau)}{\theta_1^2(z,\tau)} - \frac{\pi^2}{3} \left[ \theta_2^4(0,\tau) + \theta_3^4(0,\tau)\right].)Flint2acb_elliptic_rc1 res x prec 0This helper function computes the special case R_C(1, 1+x) = \operatorname{atan}(\sqrt{x})/\sqrt{x} = {}_2F_1(1,1/2,3/2,-x)(, which is needed in the evaluation of R_J.)Flint2acb_elliptic_rj_integration res x y z p flags prec Evaluates the Carlson symmetric elliptic integral of the third kind` R_J(x,y,z,p) = \frac{3}{2} \int_0^{\infty} \frac{dt}{(t+p)\sqrt{(t+x)(t+y)(t+z)}}2where the square root is taken continuously as in R_F.3Three versions of this function are available: the carlson6 version applies one or more duplication steps until x,y,z,p7 are close enough to use a multivariate Taylor series.The duplication algorithm is not correct for all possible combinations of complex variables, since the square roots taken during the computation can introduce spurious branch cuts. According to  [Car1995], a sufficient (but not necessary) condition for correctness is that x, y, z% have nonnegative real part and that p has positive real part.In other cases, the algorithm might still be correct, but no attempt is made to check this; it is up to the user to verify that the duplication algorithm is appropriate for the given parameters before calling this function.The  integration algorithm uses explicit numerical integration to translate the parameters to the right half-plane. This is reliable but can be slow.The default method uses the carlson algorithm when it is certain to be correct, and otherwise falls back to the slow  integration algorithm.The special case R_D(x, y, z) = R_J(x, y, z, z) may be computed by setting z and p to the same variable. This case is handled specially to avoid redundant arithmetic operations. In this case, the carlson algorithm is correct for all x, y and z.The flags parameter is reserved for future use and currently does nothing. Passing 0 results in default behavior.)Flint2acb_elliptic_rg res x y z flags prec Evaluates the Carlson symmetric elliptic integral of the second kind` R_G(x,y,z) = \frac{1}{4} \int_0^{\infty} \frac{t}{\sqrt{(t+x)(t+y)(t+z)}} \left( \frac{x}{t+x} + \frac{y}{t+y} + \frac{z}{t+z}\right) dt2where the square root is taken continuously as in R_F(. The evaluation is done by expressing R_G in terms of R_F and R_D-. There are no restrictions on the variables.)Flint2acb_elliptic_rf res x y z flags prec Evaluates the Carlson symmetric elliptic integral of the first kind` R_F(x,y,z) = \frac{1}{2} \int_0^{\infty} \frac{dt}{\sqrt{(t+x)(t+y)(t+z)}}where the square root extends continuously from positive infinity. The integral is well-defined for x,y,z \notin (-\infty,0), and with at most one of x,y,z being zero. When some parameters are negative real numbers, the function is still defined by analytic continuation. can be given depending conditionally on the parameters. If %\nu + \tfrac{1}{2} = n \in \mathbb{Z} , we have &A_{\pm} = (\pm i)^{n} (2 \pi z)^{-1/2} . And if \operatorname{Re}(z) > 0 , we have 7A_{\pm} = \exp(\mp i [(2\nu+1)/4] \pi) (2 \pi z)^{-1/2}.*Flint2acb_hypgeom_fresnel_series res1 res2 z  normalized len prec Sets res1" to the Fresnel sine integral and res25 to the Fresnel cosine integral of the power series z, truncated to length len. Optionally, just a single function can be computed by passing NULL as the other output variable.*Flint2_acb_hypgeom_fresnel_series res1 res2 z zlen  normalized len prec *Flint2acb_hypgeom_fresnel res1 res2 z  normalized prec Sets res1 to the Fresnel sine integral S(z) and res2! to the Fresnel cosine integral C(z). Optionally, just a single function can be computed by passing NULL/ as the other output variable. The definition S(z) = \int_0^z \sin(t^2) dt is used if  normalized is 0, and -S(z) = \int_0^z \sin(\tfrac{1}{2} \pi t^2) dt is used if  normalized; is 1 (the latter is the Abramowitz & Stegun convention). C(z) is defined analogously.*Flint2acb_hypgeom_erfi_series res z len prec :Computes the imaginary error function of the power series z, truncated to length len.*Flint2_acb_hypgeom_erfi_series res z zlen len prec *Flint2acb_hypgeom_erfi res z prec 'Computes the imaginary error function 1\operatorname{erfi}(z) = -i\operatorname{erf}(iz) . This is a trivial wrapper of acb_hypgeom_erf.*Flint2acb_hypgeom_erfc_series res z len prec >Computes the complementary error function of the power series z, truncated to length len.*Flint2_acb_hypgeom_erfc_series res z zlen len prec *Flint2acb_hypgeom_erfc res z prec +Computes the complementary error function 2\operatorname{erfc}(z) = 1 - \operatorname{erf}(z). This function avoids catastrophic cancellation for large positive z.*Flint2acb_hypgeom_erf_series res z len prec 0Computes the error function of the power series z, truncated to length len.*Flint2_acb_hypgeom_erf_series res z zlen len prec *Flint2acb_hypgeom_erf res z prec Computes the error function using an automatic algorithm choice. If z is too small to use the asymptotic expansion, a working precision sufficient to circumvent cancellation in the hypergeometric series is determined automatically, and a bound for the propagated error is computed with  acb_hypgeom_erf_propagated_error.*Flint2acb_hypgeom_erf_asymp res z  complementary prec prec2 .Computes the error function respectively using \begin{aligned} \operatorname{erf}(z) &= \frac{2z}{\sqrt{\pi}} {}_1F_1(\tfrac{1}{2}, \tfrac{3}{2}, -z^2)\\ \operatorname{erf}(z) &= \frac{2z e^{-z^2}}{\sqrt{\pi}} {}_1F_1(1, \tfrac{3}{2}, z^2)\\ \operatorname{erf}(z) &= \frac{z}{\sqrt{z^2}} \left(1 - \frac{e^{-z^2}}{\sqrt{\pi}} U(\tfrac{1}{2}, \tfrac{1}{2}, z^2)\right) = \frac{z}{\sqrt{z^2}} - \frac{e^{-z^2}}{z \sqrt{\pi}} U^{*}(\tfrac{1}{2}, \tfrac{1}{2}, z^2). \end{aligned} The asymp1 version takes a second precision to use for the U$ term. It also takes an extra flag  complementary5, computing the complementary error function if set.*Flint2acb_hypgeom_erf_1f1b res z prec *Flint2acb_hypgeom_erf_1f1a res z prec *Flint2 acb_hypgeom_erf_propagated_error re im z Sets re and im to upper bounds for the error in the real and imaginary part resulting from approximating the error function of z5 by the error function evaluated at the midpoint of z. Uses the first derivative.*Flint2acb_hypgeom_0f1 res a z  regularized prec /Computes the confluent hypergeometric function  {}_0F_1(a,z), or  \frac{1}{\Gamma(a)} {}_0F_1(a,z) if  regularized is set, using asymptotic expansions, direct summation, or an automatic algorithm choice. The asymp version uses the asymptotic expansions of Bessel functions, together with the connection formulas` \frac{{}_0F_1(a,z)}{\Gamma(a)} = (-z)^{(1-a)/2} J_{a-1}(2 \sqrt{-z}) = z^{(1-a)/2} I_{a-1}(2 \sqrt{z}). The Bessel-J9 function is used in the left half-plane and the Bessel-I function is used in the right half-plane, to avoid loss of accuracy due to evaluating the square root on the branch cut.*Flint2acb_hypgeom_0f1_direct res a z  regularized prec *Flint2acb_hypgeom_0f1_asymp res a z  regularized prec *Flint2acb_hypgeom_1f1 res a b z  regularized prec  Alias for  acb_hypgeom_m.*Flint2 acb_hypgeom_m res a b z  regularized prec 0Computes the confluent hypergeometric function M(a,b,z) = {}_1F_1(a,b,z), or 6\mathbf{M}(a,b,z) = \frac{1}{\Gamma(b)} {}_1F_1(a,b,z) if  regularized is set.*Flint2acb_hypgeom_m_1f1 res a b z  regularized prec *Flint2acb_hypgeom_m_asymp res a b z  regularized prec *Flint2 acb_hypgeom_u res a b z prec  Computes U(a,b,z)4 using an automatic algorithm choice. The function acb_hypgeom_u_asymp is used if a or a-b+1 is a nonpositive integer (in which case the asymptotic series terminates), or if z# is sufficiently large. Otherwise acb_hypgeom_u_1f1 is used.*Flint2acb_hypgeom_u_1f1 res a b z prec  Computes U(a,b,z)7 as a sum of two convergent hypergeometric series. If b \in \mathbb{Z}#, it computes the limit value via acb_hypgeom_u_1f1_series<. As currently implemented, the output is indeterminate if b% is nonexact and contains an integer.*Flint2acb_hypgeom_u_1f1_series res a b z len prec  Computes U(a,b,z)' as a power series truncated to length len , given a, b, z \in \mathbb{C}[[x]]. If b[0] \in \mathbb{Z}, it computes one extra derivative and removes the singularity (it is then assumed that  b[1] \ne 0=). As currently implemented, the output is indeterminate if b% is nonexact and contains an integer.*Flint2acb_hypgeom_pfq res a p b q z  regularized prec 1Computes the generalized hypergeometric function  {}_pF_{q}(z)!, or the regularized version if  regularized is set.This function automatically delegates to a specialized implementation when the order (p, q) is one of (0,0), (1,0), (0,1), (1,1), (2,1). Otherwise, it falls back to direct summation.While this is a top-level function meant to take care of special cases automatically, it does not generally perform the optimization of deleting parameters that appear in both a and b. This can be done ahead of time by the user in applications where duplicate parameters are likely to occur.*Flint2acb_hypgeom_u_use_asymp z prec Heuristically determines whether the asymptotic series can be used to evaluate U(a,b,z) to prec accurate bits (assuming that a and b are small).*Flint2acb_hypgeom_u_asymp res a b z n prec Sets res to  U^{*}(a,b,z) computed using n terms of the asymptotic series, with a rigorous bound for the error included in the output. We require n \ge 0.*Flint2acb_hypgeom_pfq_series_direct res a p b q z  regularized n len prec  Computes  {}_pf_{q}(z) directly using the defining series, given parameters and argument that are power series. The result is a power series of length len. We require that len is positive.An error bound is computed automatically as a function of the number of terms n. If n < 0., the number of terms is chosen automatically.If  regularized is set, the regularized hypergeometric function is computed instead.*Flint2acb_hypgeom_pfq_series_sum s t a p b q z  regularized n len prec  Computes s = \sum_{k=0}^{n-1} T(k) and t = T(n) given parameters and argument that are power series. Does not allow aliasing between input and output variables. We require n \ge 0 and that len is positive.If  regularized is set, the regularized sum is computed, avoiding division by zero at the poles of the gamma function.The forward, bs, rs and default versions use forward recurrence, binary splitting, rectangular splitting, and an automatic algorithm choice.*Flint2acb_hypgeom_pfq_series_sum_rs s t a p b q z  regularized n len prec *Flint2acb_hypgeom_pfq_series_sum_bs s t a p b q z  regularized n len prec *Flint2"acb_hypgeom_pfq_series_sum_forward s t a p b q z  regularized n len prec *Flint2acb_hypgeom_pfq_direct res a p b q z n prec Computes{}_pf_{q}(z) = \sum_{k=0}^{\infty} T(k) = \sum_{k=0}^{n-1} T(k) + \varepsilondirectly from the defining series, including a rigorous bound for the truncation error  \varepsilon in the output.If n < 0?, this function chooses a number of terms automatically using acb_hypgeom_pfq_choose_n.*Flint2acb_hypgeom_pfq_sum_invz s t a p b q z w n prec Like acb_hypgeom_pfq_sum, but taking advantage of w = 1/z possibly having few bits.*Flint2acb_hypgeom_pfq_sum_bs_invz s t a p b q w n prec *Flint2acb_hypgeom_pfq_sum s t a p b q z n prec  Computes s = \sum_{k=0}^{n-1} T(k) and t = T(n). Does not allow aliasing between input and output variables. We require n \ge 0.The forward3 version computes the sum using forward recurrence.The bs1 version computes the sum using binary splitting.The rs version computes the sum in reverse order using rectangular splitting. It only computes a magnitude bound for the value of t.The fme) version uses fast multipoint evaluation.The default version automatically chooses an algorithm depending on the inputs.*Flint2acb_hypgeom_pfq_sum_fme s t a p b q z n prec *Flint2acb_hypgeom_pfq_sum_bs s t a p b q z n prec *Flint2acb_hypgeom_pfq_sum_rs s t a p b q z n prec *Flint2acb_hypgeom_pfq_sum_forward s t a p b q z n prec *Flint2acb_hypgeom_pfq_choose_n a p b q z prec 3Heuristically attempts to choose a number of terms n> to sum of a hypergeometric series at a working precision of prec bits.Uses double precision arithmetic internally. As currently implemented, it can fail to produce a good result if the parameters are extremely large or extremely close to nonpositive integers.Numerical cancellation is assumed to be significant, so truncation is done when the current term is prec1 bits smaller than the largest encountered term.This function will also attempt to pick a reasonable truncation point for divergent series.*Flint2acb_hypgeom_pfq_bound_factor C a p b q z n Computes a factor C such that 2\left|\sum_{k=n}^{\infty} T(k)\right| \le C |T(n)|. See $algorithms_hypergeometric_convergent=. As currently implemented, the bound becomes infinite when n- is too small, even if the series converges.*Flint2acb_hypgeom_lgamma res x prec Sets res6 to the principal branch of the log-gamma function of x, computed using a default algorithm choice.*Flint2acb_hypgeom_rgamma res x prec Sets res% to the reciprocal gamma function of x, computed using a default algorithm choice.*Flint2acb_hypgeom_gamma res x prec Sets res to the gamma function of x, computed using a default algorithm choice.*Flint2acb_hypgeom_gamma_taylor res x  reciprocal prec *Attempts to compute the gamma function of x using Taylor series together with argument reduction. This is only supported if x and prec are both small enough. If successful, returns 1; otherwise, does nothing and returns 0. If  reciprocal< is set, the reciprocal gamma function is computed instead.*Flint2acb_hypgeom_gamma_stirling res x  reciprocal prec Sets res to the gamma function of x computed using the Stirling series together with argument reduction. If  reciprocal< is set, the reciprocal gamma function is computed instead.*Flint2'acb_hypgeom_gamma_stirling_sum_improved s z N K prec Sets res to the final sum in the Stirling series for the gamma function truncated before the term with index N, i.e. computes -\sum_{n=1}^{N-1} B_{2n} / (2n(2n-1) z^{2n-1}). The horner version uses Horner scheme with gradual precision adjustments. The improved version uses rectangular splitting for the low-index terms and reexpands the high-index terms as hypergeometric polynomials, using a splitting parameter K0 (which can be set to 0 to use a default value).*Flint2%acb_hypgeom_gamma_stirling_sum_horner s z N prec *Flint2acb_hypgeom_log_rising_ui_jet res x n len prec -Computes the jet of the log-rising factorial  \log \, (x)_n, truncated to length len.*Flint2acb_hypgeom_log_rising_ui res x n prec #Computes the log-rising factorial *\log \, (x)_n = \sum_{k=0}^{n-1} \log(x+k).This first computes the ordinary rising factorial and then determines the branch correction  2 \pi i m with respect to the principal logarithm. The correction is computed using Hare's algorithm in floating-point arithmetic if this is safe; otherwise, a direct computation of \sum_{k=0}^{n-1} \arg(x+k) is used as a fallback.*Flint2acb_hypgeom_rising_ui_jet res x n len prec )Computes the jet of the rising factorial (x)_n, truncated to length len-. In other words, constructs the polynomial (X + x)_n \in \mathbb{R}[X], truncated if \operatorname{len} < n + 1 (and zero-extended if \operatorname{len} > n + 1).The powsum, version computes the sequence of powers of x7 and forms integral linear combinations of these. The bs% version uses binary splitting. The rs version uses rectangular splitting. It takes an extra tuning parameter m which can be set to zero to choose automatically. The default version chooses an algorithm automatically.*Flint2acb_hypgeom_rising_ui_jet_rs res x n m len prec *Flint2acb_hypgeom_rising_ui_jet_bs res x n len prec *Flint2 acb_hypgeom_rising_ui_jet_powsum res x n len prec *Flint2acb_hypgeom_rising res x n prec Computes the rising factorial (x)_n.The forward* version uses the forward recurrence. The bs% version uses binary splitting. The rs version uses rectangular splitting. It takes an extra tuning parameter m8 which can be set to zero to choose automatically. The rec version chooses an algorithm automatically, avoiding use of the gamma function (so that it can be used in the computation of the gamma function). The default versions ( rising_ui and  rising_ui) choose an algorithm automatically and may additionally fall back on the gamma function.*Flint2acb_hypgeom_rising_ui res x n prec *Flint2acb_hypgeom_rising_ui_rec res x n prec *Flint2acb_hypgeom_rising_ui_rs res x n m prec *Flint2acb_hypgeom_rising_ui_bs res x n prec *Flint2acb_hypgeom_rising_ui_forward res x n prec ))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))******************************************************************C Safe-Inferred )*1d))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))************************************************************************************************************************************)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) Safe-Inferred )*1**Flint2acb_calc_integrate_taylor res func param a b  inner_radius  outer_radius  accuracy_goal prec Computes the integral` I = \int_a^b f(t) dtwhere f is specified by (func, param?), following a straight-line path between the complex numbers a and b which both must be finite.The integral is approximated by piecewise centered Taylor polynomials. Rigorous truncation error bounds are calculated using the Cauchy integral formula. More precisely, if the Taylor series of f centered at the point m is $f(m+x) = \sum_{n=0}^{\infty} a_n x^n, then` \int f(m+x) = \left( \sum_{n=0}^{N-1} a_n \frac{x^{n+1}}{n+1} \right) + \left( \sum_{n=N}^{\infty} a_n \frac{x^{n+1}}{n+1} \right).For sufficiently small x, the second series converges and its absolute value is bounded by` \sum_{n=N}^{\infty} \frac{C(m,R)}{R^n} \frac{|x|^{n+1}}{N+1} = \frac{C(m,R) R x}{(R-x)(N+1)} \left( \frac{x}{R} \right)^N.)It is required that any singularities of f are isolated from the path of integration by a distance strictly greater than the positive value  outer_radius (which is the integration radius used for the Cauchy bound). Taylor series step lengths are chosen so as not to exceed  inner_radius&, which must be strictly smaller than  outer_radius for convergence. A smaller  inner_radius gives more rapid convergence of each Taylor series but means that more series might have to be used. A reasonable choice might be to set  inner_radius to half the value of  outer_radius+, giving roughly one accurate bit per term.The truncation point of each Taylor series is chosen so that the absolute truncation error is roughly 2^{-p} where p is given by  accuracy_goal (in the future, this might change to a relative accuracy). Arithmetic operations and function evaluations are performed at a precision of prec bits. Note that due to accumulation of numerical errors, both values may have to be set higher (and the endpoints may have to be computed more accurately) to achieve a desired accuracy.This function chooses the evaluation points uniformly rather than implementing adaptive subdivision.*Flint2acb_calc_cauchy_bound bound func param x radius maxdepth prec Sets bound/ to a ball containing the value of the integral` C(x,r) = \frac{1}{2 \pi r} \oint_{|z-x| = r} |f(z)| dz = \int_0^1 |f(x+re^{2\pi i t})| dtwhere f is specified by (func, param) and r is given by radius. The integral is computed using a simple step sum. The integration range is subdivided until the order of magnitude of b can be determined (i.e. its error bound is smaller than its midpoint), or until the step length has been cut in half maxdepth times. This function is currently implemented completely naively, and repeatedly subdivides the whole integration range instead of performing adaptive subdivisions.*Flint2acb_calc_integrate_gl_auto_deg res num_eval func param a b tol  deg_limit flags prec Attempts to compute I = \int_a^b f(t) dt using a single application of Gauss-Legendre quadrature with automatic determination of the quadrature degree so that the error is smaller than tol . Returns ARB_CALC_SUCCESS5 if the integral has been evaluated successfully or ARB_CALC_NO_CONVERGENCE if the tolerance could not be met. The total number of function evaluations is written to num_eval.For the interval [-1,1], the error of the n)-point Gauss-Legendre rule is bounded by` \left| I - \sum_{k=0}^{n-1} w_k f(x_k) \right| \le \frac{64 M}{15 (\rho-1) \rho^{2n-1}}if f is holomorphic with  |f(z)| \le M inside the ellipse E with foci \pm 1 and semiaxes X and Y = \sqrt{X^2 - 1} such that  \rho = X + Y with \rho > 1  [Tre2008].#For an arbitrary interval, we use &\int_a^b f(t) dt = \int_{-1}^1 g(t) dt where g(t) = \Delta f(\Delta t + m), \Delta = \tfrac{1}{2}(b-a), m = \tfrac{1}{2}(a+b). With I = [\pm X] + [\pm Y]i, this means that we evaluate \Delta f(\Delta I + m) to get the bound M. (An improvement would be to reduce the wrapping effect of rotating the ellipse when the path is not rectilinear).We search for an X- that makes the error small by trying steps 2^{2^k} . Larger X will give smaller 1 / \rho^{2n-1} but larger M(. If we try successive larger values of k, we can abort when  M = \infty since this either means that we have hit a singularity or a branch cut or that overestimation in the evaluation of f is becoming too severe.*Flint2acb_calc_integrate_opt_init options  Initializes options= for use, setting all fields to 0 indicating default values.*Flint2acb_calc_integrate res func param a b rel_goal abs_tol options prec -Computes a rigorous enclosure of the integral` I = \int_a^b f(t) dtwhere f is specified by (func, param?), following a straight-line path between the complex numbers a and b. For finite results, a, b must be finite and f must be bounded on the path of integration. To compute improper integrals, the user should therefore truncate the path of integration manually (or make a regularizing change of variables, if possible). Returns ARB_CALC_SUCCESS if the integration converged to the target accuracy on all subintervals, and returns ARB_CALC_NO_CONVERGENCE otherwise.By default, the integrand func will only be called with order = 0 or order, = 1; that is, derivatives are not required."The integrand will be called with order = 0 to evaluate f normally on the integration path (either at a single point or on a subinterval). In this case, f is treated as a pointwise defined function and can have arbitrary discontinuities."The integrand will be called with order = 1 to evaluate f on a domain surrounding a segment of the integration path for the purpose of bounding the error of a quadrature formula. In this case, func must verify that f is holomorphic on this domain (and output a non-finite value if it is not).The integration algorithm combines direct interval enclosures, Gauss-Legendre quadrature where f is holomorphic, and adaptive subdivision. This strategy supports integrands with discontinuities while providing exponential convergence for typical piecewise holomorphic integrands.*The following parameters control accuracy:rel_goal - relative accuracy goal as a number of bits, i.e. target a relative error less than \varepsilon_{rel} = 2^{-r} where r = rel_goal (note the sign: rel_goal should be nonnegative).abs_tol - absolute accuracy goal as a mag_t describing the error tolerance, i.e. target an absolute error less than \varepsilon_{abs} = abs_tol.prec - working precision. This is the working precision used to evaluate the integrand and manipulate interval endpoints. As currently implemented, the algorithm does not attempt to adjust the working precision by itself, and adaptive control of the working precision must be handled by the user.For typical usage, set rel_goal = prec and abs_tol =  2^{-prec}&. It usually only makes sense to have rel_goal between 0 and prec./The algorithm attempts to achieve an error of ,\max(\varepsilon_{abs}, M \varepsilon_{rel}) on each subinterval, where M is the magnitude of the integral. These parameters are only guidelines; the cumulative error may be larger than both the prescribed absolute and relative error goals, depending on the number of subdivisions, cancellation between segments of the integral, and numerical errors in the evaluation of the integrand.To compute tiny integrals with high relative accuracy, one should set -\varepsilon_{abs} \approx M \varepsilon_{rel} where M0 is a known estimate of the magnitude. Setting \varepsilon_{abs} to 0 is also allowed, forcing use of a relative instead of an absolute tolerance goal. This can be handy for exponentially small or large functions of unknown magnitude. It is recommended to avoid setting \varepsilon_{abs} very small if possible since the algorithm might need many extra subdivisions to estimate M automatically; if the approximate magnitude can be estimated by some external means (for example if a midpoint-width or endpoint-width estimate is known to be accurate), providing an appropriate -\varepsilon_{abs} \approx M \varepsilon_{rel} will be more efficient.If the integral has very large magnitude, setting the absolute tolerance to a corresponding large value is recommended for best performance, but it is not necessary for convergence since the absolute tolerance is increased automatically during the execution of the algorithm if the partial integrals are found to have larger error.?Additional options for the integration can be provided via the options5 parameter (documented below). To use all defaults, NULL can be passed for options.***************D Safe-Inferred )*1****************************** Safe-Inferred )*1*Flint2acb_dirichlet_platt_zeta_zeros res n len prec Sets at most the first len entries of res to consecutive zeros of the Riemann zeta function starting with the n-th zero. The number of obtained consecutive zeros is returned. It currently expects 10^4 \leq n \leq 10^{23}6. The user has the option of multi-threading through !flint_set_num_threads(numthreads).*Flint2!acb_dirichlet_platt_hardy_z_zeros res n len prec Sets at most the first len entries of res to consecutive zeros of the Hardy Z-function starting with the n-th zero. The number of obtained consecutive zeros is returned. The first two function variants each make a single call to Platt's grid evaluation of the scaled Lambda function, whereas the third variant performs as many evaluations as necessary to obtain len consecutive zeros. The final several parameters of the underscored local variant have the same meanings as in the functions acb_dirichlet_platt_multieval and $acb_dirichlet_platt_ws_interpolation1. The non-underscored variants currently expect 10^4 \leq n \leq 10^{23}6. The user has the option of multi-threading through !flint_set_num_threads(numthreads).*Flint2$acb_dirichlet_platt_ws_interpolation res deriv t0 p T A B Ns_max H sigma prec Compute !acb_dirichlet_platt_scaled_lambda at t0 by Gaussian-windowed Whittaker-Shannon interpolation of points evaluated by %acb_dirichlet_platt_scaled_lambda_vec?. The derivative is also approximated if the output parameter deriv is not NULL. Ns_max defines the maximum number of supporting points to be used in the interpolation on either side of t0. H? is the standard deviation of the Gaussian window centered on t0* to be applied before the interpolation. sigma. is an odd positive integer tuning parameter \sigma \in 2\mathbb{Z}_{>0}+1 used in computing error bounds.*Flint2&acb_dirichlet_platt_multieval_threaded res T A B h J K sigma prec Compute !acb_dirichlet_platt_scaled_lambda at N=AB. points on a grid, following the notation of  [Pla2017]". The first point on the grid is T - B/2) and the distance between grid points is 1/A. The product N=AB must be an even integer. The multieval versions evaluate the function at all points on the grid simultaneously using discrete Fourier transforms, and they require the four additional tuning parameters h, J, K, and sigma. The threaded multieval version splits the computation over the number of threads returned by flint_get_num_threads(), while the default multieval version chooses whether to use multithreading automatically.*Flint2!acb_dirichlet_platt_scaled_lambda res t prec Compute \Lambda(t) e^{\pi t/4} where` \Lambda(t) = \pi^{-\frac{it}{2}} \Gamma\left(\frac{\frac{1}{2}+it}{2}\right) \zeta\left(\frac{1}{2} + it\right),is defined in the beginning of section 3 of  [Pla2017]. As explained in  [Pla2011]% this function has the same zeros as \zeta(1/2 + it) and is real-valued by the functional equation, and the exponential factor is designed to counteract the decay of the gamma factor as t increases.*Flint2acb_dirichlet_backlund_s_gram n Compute S(g_n) where g_n is the n-th Gram point. Requires n \ge -1.*Flint2acb_dirichlet_zeta_nzeros_gram res n Compute N(g_n). That is, compute the number of zeros (counted according to their multiplicities) of \zeta(s) in the region  0 < \operatorname{Im}(s) \le g_n where g_n is the n-th Gram point. Requires n \ge -1.*Flint2acb_dirichlet_backlund_s_bound res t Compute an upper bound for |S(t)|0 quickly. Theorem 1 and the bounds in (1.2) in  [Tru2014] are used.*Flint2acb_dirichlet_backlund_s res t prec  Compute =S(t) = \frac{1}{\pi}\operatorname{arg}\zeta(\frac{1}{2} + it); where the argument is defined by continuous variation of s in \zeta(s) starting at s = 2, then vertically to  s = 2 + it, then horizontally to s = \frac{1}{2} + it. In particular \operatorname{arg} in this context is not the principal value of the argument, and it cannot be computed directly by acb_arg. In practice S(t) is computed as (S(t) = N(t) - \frac{1}{\pi}\theta(t) - 1 where N(t) is acb_dirichlet_zeta_nzeros and  \theta(t) is acb_dirichlet_hardy_theta.*Flint2acb_dirichlet_zeta_nzeros res t prec Compute the number of zeros (counted according to their multiplicities) of \zeta(s) in the region 0 < \operatorname{Im}(s) \le t.*Flint2acb_dirichlet_zeta_zeros res n len prec Sets the entries of res to len" consecutive nontrivial zeros of \zeta(s) beginning with the n-th zero. Requires positive n.*Flint2acb_dirichlet_hardy_z_zeros res n len prec Sets the entries of res to len consecutive zeros of the Hardy Z-function, beginning with the n-th zero. Requires positive n.*Flint2"_acb_dirichlet_refine_hardy_z_zero res a b prec Sets res= to the unique zero of the Hardy Z-function in the interval (a, b).*Flint2"acb_dirichlet_isolate_hardy_z_zero a b n Computes an interval (a, b) that contains the n-th zero of the Hardy Z-function and contains no other zero, using the most appropriate underscore version of this function. Requires n \ge 1.*Flint2*_acb_dirichlet_isolate_turing_hardy_z_zero a b n Computes an interval (a, b) that contains the n-th zero of the Hardy Z-function and no other zero, following Turing's method. Requires n \ge 2.*Flint2*_acb_dirichlet_isolate_rosser_hardy_z_zero a b n *Uses Rosser's rule to compute an interval (a, b) that contains the n>-th zero of the Hardy Z-function and no other zero. Requires 1 \le n \le 13999526.*Flint2(_acb_dirichlet_isolate_gram_hardy_z_zero a b n 'Uses Gram's law to compute an interval (a, b) that contains the n>-th zero of the Hardy Z-function and no other zero. Requires 1 \le n \le 126.*Flint2_acb_dirichlet_definite_hardy_z res t pprec Sets res to the Hardy Z-function Z(t). The initial precision (* pprec5) is increased as necessary to determine the sign of Z(t). The sign is returned.*Flint2!acb_dirichlet_turing_method_bound p Computes an upper bound B for the minimum number of consecutive good Gram blocks sufficient to count nontrivial zeros of the Riemann zeta function using Turing's method  [Tur1953] as updated by  [Leh1970],  [Bre1979], and  [Tru2011].Let N(T) denote the number of zeros (counted according to their multiplicities) of \zeta(s) in the region 0 < \operatorname{Im}(s) \le T. If at least B% consecutive Gram blocks with union  [g_n, g_p) satisfy Rosser's rule, then N(g_n) \le n + 1 and N(g_p) \ge p + 1.*Flint2acb_dirichlet_gram_point res n G chi prec Sets res to the n-th Gram point g_n%, defined as the unique solution in  [7, \infty) of \theta(g_n) = \pi n. Currently only the Gram points corresponding to the Riemann zeta function are supported and G and chi must both be set to NULL . Requires n \ge -1.*Flint2acb_dirichlet_hardy_z_series res t G chi len prec Sets res to the power series Z(t) where t; is a given power series, truncating the result to length len.*Flint2 acb_dirichlet_hardy_theta_series res t G chi len prec Sets res to the power series  \theta(t) where t; is a given power series, truncating the result to length len.*Flint2acb_dirichlet_hardy_z res t G chi len prec Computes the Hardy Z-function, also known as the Riemann-Siegel Z-function  Z(t) = e^{i \theta(t)} L(1/2+it)!, which is real-valued for real t . The first len: terms in the Taylor expansion are written to the output.*Flint2acb_dirichlet_hardy_theta res t G chi len prec Computes the phase function used to construct the Z-function. We have` \theta(t) = -\frac{t}{2} \log(\pi/q) - \frac{i \log(\epsilon)}{2} + \frac{\log \Gamma((s+\delta)/2) - \log \Gamma((1-s+\delta)/2)}{2i}where  s = 1/2+it, \delta is the parity of chi, and \epsilon$ is the root number as computed by acb_dirichlet_root_number . The first len: terms in the Taylor expansion are written to the output.*Flint2acb_dirichlet_l_series res s G chi deflate len prec Sets res to the power series  L(s,\chi) where s; is a given power series, truncating the result to length len. See acb_dirichlet_l_jet for the meaning of the deflate flag.*Flint2acb_dirichlet_l_jet res s G chi deflate len prec !Computes the Taylor expansion of  L(s,\chi) to length len, i.e. .L(s), L'(s), \ldots, L^{(len-1)}(s) / (len-1)!. If deflate# is set, computes the expansion of` /L(s,\chi) - \frac{\sum_{k=1}^q \chi(k)}{(s-1)q} instead. If chi is a principal character, then this has the effect of subtracting the pole with residue "\sum_{k=1}^q \chi(k) = \phi(q) / q that is located at s = 1$. In particular, when evaluated at s = 1>, this gives the regular part of the Laurent expansion. When chi is non-principal, deflate has no effect.*Flint2acb_dirichlet_l_vec_hurwitz res s precomp G prec Compute all values  L(s,\chi) for \chi mod q, using the Hurwitz zeta function and a discrete Fourier transform. The output res is assumed to have length G->phi_q and values are stored by lexicographically ordered Conrey logs. See acb_dirichlet_dft_conrey.If precomp is NULL, each Hurwitz zeta function value is computed directly. If a pre-initialized precomp object is provided, this will be used instead to evaluate the Hurwitz zeta function.*Flint2acb_dirichlet_l_fmpq res s G chi prec  Computes  L(s,\chi) where s is a rational number. The afe version uses the approximate functional equation; the default version chooses an algorithm automatically.*Flint2acb_dirichlet_l res s G chi prec  Computes  L(s,\chi)% using a default choice of algorithm.*Flint2$_acb_dirichlet_euler_product_real_ui res s chi mod  reciprocal prec  Computes  L(s,\chi)9 directly using the Euler product. This is efficient if s has large positive real part. As implemented, this function only gives a finite result if \operatorname{re}(s) \ge 2.An error bound is computed via mag_hurwitz_zeta_uiui. If s2 is complex, replace it with its real part. Since` \frac{1}{L(s,\chi)} = \prod_{p} \left(1 - \frac{\chi(p)}{p^s}\right) = \sum_{k=1}^{\infty} \frac{\mu(k)\chi(k)}{k^s}and the truncated product gives all smooth-index terms in the series, we have` \left|\prod_{p < N} \left(1 - \frac{\chi(p)}{p^s}\right) - \frac{1}{L(s,\chi)}\right| \le \sum_{k=N}^{\infty} \frac{1}{k^s} = \zeta(s,N)./The underscore version specialized for integer s assumes that \chi; is a real Dirichlet character given by the explicit list chi$ of character values at 0, 1, ..., mod - 1. If  reciprocal is set, it computes  1 / L(s,\chi): (this is faster if the reciprocal can be used directly).*Flint2acb_dirichlet_l_hurwitz res s precomp G chi prec  Computes  L(s,\chi); using decomposition in terms of the Hurwitz zeta functionL(s,\chi) = q^{-s}\sum_{k=1}^q \chi(k) \,\zeta\!\left(s,\frac kq\right).If s = 1 and \chi is non-principal, the deflated Hurwitz zeta function is used to avoid poles.If precomp is NULL, each Hurwitz zeta function value is computed directly. If a pre-initialized precomp object is provided, this will be used instead to evaluate the Hurwitz zeta function.*Flint2acb_dirichlet_root_number res G chi prec Sets res to the root number \epsilon(\chi) for a primitive character chi2, which appears in the functional equation (where p is the parity of \chi):\left(\frac{q}{\pi}\right)^{\frac{s+p}2}\Gamma\left(\frac{s+p}2\right) L(s, \chi) = \epsilon(\chi) \left(\frac{q}{\pi}\right)^{\frac{1-s+p}2}\Gamma\left(\frac{1-s+p}2\right) L(1 - s, \overline\chi)The theta variant uses the evaluation at t=1 of the Theta series.2The default version computes it via the gauss sum.+Flint2acb_dirichlet_dft w v G prec Compute the DFT of v- using Conrey numbers. This function assumes v and w are vectors of size G->q&. All values at index not coprime to G->q are ignored.+Flint2acb_dirichlet_theta_length q t prec Compute the number of terms to be summed in the theta series of argument t so that the tail is less than 2^{-\mathrm{prec}}.+Flint2acb_dirichlet_ui_theta_arb res G a t prec Compute the theta series  \Theta_q(a,t) for real argument t>0. Beware that if t<1 the functional equationt \theta(a,t) = \epsilon(\chi) \theta\left(\frac1a, \frac1t\right)should be used, which is not done automatically (to avoid recomputing the Gauss sum).We call  theta series. of a Dirichlet character the quadratic series5\Theta_q(a) = \sum_{n\geq 0} \chi_q(a, n) n^p x^{n^2}where p is the parity of the character \chi_q(a,\cdot).For \Re(t)>0 we write x(t)=\exp(-\frac{\pi}{N}t^2) and define7\Theta_q(a,t) = \sum_{n\geq 0} \chi_q(a, n) x(t)^{n^2}.+Flint2acb_dirichlet_jacobi_sum_ui res G a b prec Computes the Jacobi sum6J_q(a,b) = \sum_{x \bmod q} \chi_q(a, x)\chi_q(b, 1-x)the naive% version computes the sum as defined.the factor4 version writes it as a product of local Jacobi sumsthe gauss version assumes ab( is primitive and uses the formula J_q(a,b)G_q(ab) = G_q(a)G_q(b)=the default version automatically combines the above methods.the ui' version only takes the Conrey numbers a and b as parameters.+Flint2acb_dirichlet_gauss_sum_ui res G a prec Sets res to the Gauss sum:G_q(a) = \sum_{x \bmod q} \chi_q(a, x) e^{\frac{2i\pi x}q}the naive% version computes the sum as defined.the factor version writes it as a product of local Gauss sums by chinese remainder theorem.the order2 version assumes chi( is real and primitive and returns  i^p\sqrt q where p is the parity of \chi.the theta version assumes that chi is primitive to obtain the Gauss sum by functional equation of the theta series at t=1?. An abort will be raised if the theta series vanishes at t=1. Only 4 exceptional characters of conductor 300 and 600 are known to have this particularity, and none with primepower modulus.=the default version automatically combines the above methods.the ui& version only takes the Conrey number a as parameter.+Flint2acb_dirichlet_pairing_char res G a b prec Sets res' to the value of the Dirichlet pairing  \chi(m,n) at numbers m and n0. The second form takes two characters as input.+Flint2acb_dirichlet_chi_vec v G chi nv prec  Compute the nv first Dirichlet values.+Flint2acb_dirichlet_chi res G chi n prec Sets res to \chi(n)', the value of the Dirichlet character chi at the integer n.+Flint2acb_dirichlet_stieltjes res n a prec Given a nonnegative integer n, sets res( to the generalized Stieltjes constant  \gamma_n(a) which is the coefficient in the Laurent series of the Hurwitz zeta function at the pole` \zeta(s,a) = \frac{1}{s-1} + \sum_{n=0}^\infty \frac{(-1)^n}{n!} \gamma_n(a) (s-1)^n.With a = 1, this gives the ordinary Stieltjes constants for the Riemann zeta function.This function uses an integral representation to permit fast computation for extremely large n  [JB2018]. If n is moderate and the precision is high enough, it falls back to evaluating the Hurwitz zeta function of a power series and reading off the last coefficient.+Note that for computing a range of values  \gamma_0(a), \ldots, \gamma_n(a), it is generally more efficient to evaluate the Hurwitz zeta function series expansion once at s = 10 than to call this function repeatedly, unless n0 is extremely large (at least several hundred).+Flint2 acb_dirichlet_lerch_phi_integral res z s a prec Computes the Lerch transcendent` 5\Phi(z,s,a) = \sum_{k=0}^{\infty} \frac{z^k}{(k+a)^s}$which is analytically continued for  |z| \ge 1.The direct= version evaluates a truncation of the defining series. The integral) version uses the Hankel contour integral` \Phi(z,s,a) = -\frac{\Gamma(1-s)}{2 \pi i} \int_C \frac{(-t)^{s-1} e^{-a t}}{1 - z e^{-t}} dtwhere the path is deformed as needed to avoid poles and branch cuts of the integrand. The default method chooses an algorithm automatically and also checks for some special cases where the function can be expressed in terms of simpler functions (Hurwitz zeta, polylogarithms).+Flint2"acb_dirichlet_hurwitz_precomp_eval res pre p q prec  Evaluates  \zeta(s,p/q)( using precomputed data, assuming that  0 < p/q \le 1.+Flint2#acb_dirichlet_hurwitz_precomp_bound res s A K N Computes an upper bound for the truncation error (not accounting for roundoff error) when evaluating  \zeta(s,a)! with precomputation parameters A, K, N, assuming that  0 < a \le 1. For details, see algorithms_hurwitz.+Flint2*acb_dirichlet_hurwitz_precomp_choose_param A K N s num_eval prec "Chooses precomputation parameters A, K and N to minimize the cost of num_eval6 evaluations of the Hurwitz zeta function at argument s to precision prec. If it is estimated that evaluating each Hurwitz zeta function from scratch would be better than performing a precomputation, A, K and N are all set to 0.+Flint2#acb_dirichlet_hurwitz_precomp_clear pre Clears the precomputed data.+Flint2&acb_dirichlet_hurwitz_precomp_init_num pre s deflate num_eval prec  Initializes pre, choosing the parameters A, K, and N( automatically to minimize the cost of num_eval7 evaluations of the Hurwitz zeta function at argument s to precision prec.+Flint2"acb_dirichlet_hurwitz_precomp_init pre s deflate A K N prec Precomputes a grid of Taylor polynomials for fast evaluation of  \zeta(s,a) on  a \in (0,1] with fixed s. A# is the initial shift to apply to a, K is the number of Taylor terms, N< is the number of grid points. The precomputation requires NK evaluations of the Hurwitz zeta function, and each subsequent evaluation requires 2K< simple arithmetic operations (polynomial evaluation) plus A powers. As K grows, the error is at most  O(1/(2AN)^K).!This function can be called with A set to zero, in which case no Taylor series precomputation is performed. This means that evaluation will be identical to calling acb_dirichlet_hurwitz directly.Otherwise, we require that A, K and N9 are all positive. For a finite error bound, we require K+\operatorname{re}(s) > 1. To avoid an initial "bump" that steals precision and slows convergence, AN) should be at least roughly as large as |s|+, e.g. it is a good idea to have at least  AN > 0.5 |s|.If deflate is set, the deflated Hurwitz zeta function is used, removing the pole at s = 1.+Flint2acb_dirichlet_hurwitz res s a prec #Computes the Hurwitz zeta function  \zeta(s, a). This function automatically delegates to the code for the Riemann zeta function when a = 1. Some other special cases may also be handled by direct formulas. In general, Euler-Maclaurin summation is used.+Flint2acb_dirichlet_zeta_jet_rs res s len prec Computes the first len= terms of the Taylor series of the Riemann zeta function at s using the Riemann Siegel formula. This function currently only supports len = 1 or len = 2. A finite difference is used to compute the first derivative.+Flint2acb_dirichlet_zeta_rs res s K prec  Computes \zeta(s)3 using the Riemann-Siegel formula. Uses precisely K asymptotic terms in the RS formula if this input parameter is positive; otherwise chooses the number of terms automatically based on s and the precision.+Flint2acb_dirichlet_zeta_rs_r res s K prec  Computes \mathcal{R}(s)) in the upper half plane. Uses precisely K asymptotic terms in the RS formula if this input parameter is positive; otherwise chooses the number of terms automatically based on s and the precision.+Flint2acb_dirichlet_zeta_rs_bound err s K Bounds the error term RS_K) following Theorem 4.2 in Arias de Reyna.+Flint2acb_dirichlet_zeta_rs_d_coeffs d sigma k prec Computes the coefficients  d_j^{(k)} for $0 \le j \le \lfloor 3k/2 \rfloor + 1. On input, the array d$ must contain the coefficients for  d_j^{(k-1)} unless k = 03, and these coefficients will be updated in-place.+Flint2acb_dirichlet_zeta_rs_f_coeffs f p n prec Computes the coefficients  F^{(j)}(p) for  0 \le j < n<. Uses power series division. This method breaks down when  p = \pm 1/2 (which is not problem if s$ is an exact floating-point number).+Flint2acb_dirichlet_xi res s prec Sets res to the Riemann xi function \xi(s) = \frac{1}{2} s (s-1) \pi^{-s/2} \Gamma(\frac{1}{2} s) \zeta(s)%. The functional equation for xi is \xi(1-s) = \xi(s).+Flint2acb_dirichlet_eta res s prec Sets res to the Dirichlet eta function \eta(s) = \sum_{k=1}^{\infty} (-1)^{k+1} / k^s = (1-2^{1-s}) \zeta(s), also known as the alternating zeta function. Note that the alternating character \{1,-1\}% is not itself a Dirichlet character.+Flint2acb_dirichlet_zeta_deriv_bound der1 der2 s Sets der1 to a bound for  |\zeta'(s)| and der2 to a bound for  |\zeta''(s)|. These bounds are mainly intended for use in the critical strip and will not be tight.+Flint2acb_dirichlet_zeta_bound res s Computes an upper bound for  |\zeta(s)| quickly. On the critical strip (and slightly outside of it), formula (43.3) in  [Rad1973]8 is used. To the right, evaluating at the real part of s gives a trivial bound. To the left, the functional equation is used.+Flint2acb_dirichlet_zeta_jet res s deflate len prec Computes the first len= terms of the Taylor series of the Riemann zeta function at s. If deflate- is nonzero, computes the deflated function \zeta(s) - 1/(s-1) instead.+Flint2acb_dirichlet_zeta res s prec  Computes \zeta(s)( using an automatic choice of algorithm.+Flint2acb_dirichlet_powsum_smooth res s n len prec Sets res to \sum_{k=1}^n k^{-(s+x)} as a power series in x truncated to length len. This function performs partial sieving by adding multiples of 5-smooth k into separate buckets. Asymptotically, this requires computing 4/15 of the powers, which is slower than sieved, but only requires logarithmic extra space. It is also faster for large len, since most power series multiplications are traded for additions. A slightly bigger gain for larger n could be achieved by using more small prime factors, at the expense of space.+Flint2acb_dirichlet_powsum_sieved res s n len prec Sets res to \sum_{k=1}^n k^{-(s+x)} as a power series in x truncated to length len. This function stores a table of powers that have already been calculated, computing (ij)^r as i^r j^r whenever k = ij> is composite. As a further optimization, it groups all even k* and evaluates the sum as a polynomial in  2^{-(s+x)}. This scheme requires about  n / \log n powers, n / 2, multiplications, and temporary storage of n / 6 power series. Due to the extra power series multiplications, it is only faster than the naive algorithm when len is small.+Flint2acb_dirichlet_powsum_term res log_prev prev s k integer  critical_line len prec Sets res to  k^{-(s+x)} as a power series in x truncated to length len . The flags integer and  critical_line& respectively specify optimizing for s* being an integer or having real part 1/2. On input log_prev9 should contain the natural logarithm of the integer at prev. If prev is close to k1, this can be used to speed up computations. If \log(k)0 is computed internally by this function, then log_prev2 is overwritten by this value, and the integer at prev is overwritten by k , allowing log_prev? to be recycled for the next term when evaluating a power sum.+Flint2acb_dirichlet_root res roots k prec  Computes e^{2\pi i k/n}.+Flint2acb_dirichlet_roots_clear roots Clears the structure.+Flint2acb_dirichlet_roots_init roots n num prec  Initializes roots> with precomputed data for fast evaluation of roots of unity e^{2\pi i k/n} of a fixed order n'. The precomputation is optimized for num evaluations.For very small num, only the single root  e^{2\pi i/n} will be precomputed, which can then be raised to a power. For small prec and large n, this method might even skip precomputing this single root if it estimates that evaluating roots of unity from scratch will be faster than powering.If num is large enough, the whole set of roots in the first quadrant will be precomputed at once. However, this is automatically avoided for large n4 if too much memory would be used. For intermediate num,, baby-step giant-step tables are computed.+Flint2 Create new * n num prec+Flint2Use *+Flint2Use new *+Flint2 Create new *+Flint2Use f on *+Flint2Use f on new ************************************************++++++++++++++++++++++++++++++++++++++++++++++++++++E Safe-Inferred )*1***********************************************++++++++++++++++++++++++++++++++++++++++++++++++++++***++++++++++++++++++++++***++++++++++++++++++++++++++++++***************************************** Safe-Inferred )*1 +Flint2acb_dft_crt_precomp w v t prec Sets w to the DFT of v of size t->n&, using the CRT decomposition scheme t.+Flint2acb_dft_crt_clear t "Initialize a CRT decomposition of \mathbb Z/n\mathbb Z3 as a direct product of cyclic groups. The length len is stored as t->n.+Flint2acb_dft_crt_init t len prec +Flint2 acb_dft_crt w v n prec Computes the DFT of v into w, where v and w have size len, using CRT to express \mathbb Z/n\mathbb Z as a product of cyclic groups.+Flint2acb_dft_convol w f g len prec Sets w to the convolution of f and g of length len.The naive$ version simply uses the definition.The rad2 version embeds the sequence into a power of 2 length and uses the formula4\widehat{f \star g}(\chi) = \hat f(\chi)\hat g(\chi)&to compute it using three radix 2 FFT.,The default version uses radix 2 FFT unless len is a product of small primes where a non padded FFT is faster.+Flint2acb_dft_convol_rad2 w f g len prec +Flint2acb_dft_convol_naive w f g len prec +Flint2acb_dft_inverse_precomp w v pre prec Compute the inverse DFT of v into w.+Flint2acb_dft_precomp w v pre prec !Computes the DFT of the sequence v into w% by applying the precomputed scheme pre. Both v and w must have length pre->n.+Flint2acb_dft_precomp_clear pre Clears pre.+Flint2acb_dft_precomp_init pre len prec *Initializes the fast DFT scheme of length len, using an automatic choice of algorithms depending on the factorization of len. The length len is stored as pre->n.If several computations are to be done on the same group, the FFT scheme should be reused.+Flint2acb_dft_inverse w v n prec Compute the inverse DFT of v into w.+Flint2acb_dft w v n prec Set w to the DFT of v of length len*, using an automatic choice of algorithm.+++++++++++++++++++++++++F Safe-Inferred )*1++++++++++++++++++++++++++++++++++++++++++++++++++ Safe-Inferred )*1 +Flint2acf_approx_dot res initial subtract x xstep y ystep len prec rnd Computes an approximate dot product, with the same meaning of the parameters as arb_dot.+Flint2acf_approx_sqrt res x prec rnd 9Computes an approximate inverse, quotient or square root.+Flint2acf_approx_div res x y prec rnd +Flint2acf_approx_inv res x prec rnd +Flint2acf_mul res x y prec rnd Sets res& to the sum, difference or product of x or y, correctly rounding the real and imaginary parts in direction rnd. The return flag has the least significant bit set if the real part is inexact, and the second least significant bit set if the imaginary part is inexact.+Flint2acf_sub res x y prec rnd +Flint2acf_add res x y prec rnd +Flint2 acf_equal x y Returns whether x and y are equal.+Flint2acf_set z x Sets z to the value x.+Flint2 acf_imag_ptr z 3Returns a pointer to the real or imaginary part of z.+Flint2 acf_real_ptr z +Flint2acf_allocated_bytes x Returns the total number of bytes heap-allocated internally by this object. The count excludes the size of the structure itself. Add sizeof(acf_struct)* to get the size of the object as a whole.+Flint2acf_swap z x Swaps z and x efficiently.+Flint2 acf_clear x Clears the variable x,, freeing or recycling its allocated memory.+Flint2acf_init x Initializes the variable x% for use, and sets its value to zero.+Flint2Createst a new   structure encapsulated in  .+Flint2Access to the C pointer in   structure. ++++++++++++++++++G Safe-Inferred )*1} ++++++++++++++++++ ++++++++++++++++++ Safe-Inferred )*1!>+Flint2d_log2 x  Returns the base 2 logarithm of x provided x is positive. If a domain or pole error occurs, the appropriate error value is returned.+Flint2d_is_nan x $Returns a nonzero integral value if x is D_NAN, and otherwise returns 0.+Flint2 d_lambertw x Computes the principal branch of the Lambert W function, solving the equation x = W(x) \exp(W(x)). If x < -1/e0, the solution is complex, and NaN is returned.Depending on the magnitude of x, we start from a piecewise rational approximation or a zeroth-order truncation of the asymptotic expansion at infinity, and perform 0, 1 or 2 iterations with Halley's method to obtain full accuracy. A test of 10^7 random inputs showed a maximum relative error smaller than 0.95 times  DBL_EPSILON (2^{-52}) for positive x. Accuracy for negative x4 is slightly worse, and can grow to about 10 times  DBL_EPSILON close to -1/e. However, accuracy may be worse depending on compiler flags and the accuracy of the system libm functions.+Flint2 d_polyval poly len x Uses Horner's rule to evaluate the polynomial defined by the given len coefficients. Requires that len is nonzero.+Flint2d_randtest_special state minexp maxexp 5Returns a random signed number with exponent between minexp and maxexp, zero, D_NAN or \pmD_INF.+Flint2d_randtest_signed state minexp maxexp 5Returns a random signed number with exponent between minexp and maxexp or zero.+Flint2 d_randtest state (Returns a random number in the interval [0.5, 1).+++++++H Safe-Inferred )*1!++++++++++++++ Safe-Inferred )*1)+Flint2 di_interval a b Returns the interval [a, b]9. We require that the endpoints are ordered and not NaN.+Flint2 arb_get_di x Returns the ball x* converted to a double-precision interval.+Flint2 arb_set_di res x prec Sets the ball res" to the double-precision interval x, rounded to prec bits.+Flint2di_print x Prints x to standard output. This simply prints decimal representations of the floating-point endpoints; the decimals are not guaranteed to be rounded outward.+Flint2 d_randtest2 state Returns a random non-NaN double< with any exponent. The value can be infinite or subnormal.+Flint2 di_randtest state *Returns an interval with random endpoints.+Flint2di_neg x Returns the exact negation of x.+Flint2 di_fast_add x y +Flint2 di_fast_sub x y +Flint2 di_fast_mul x y +Flint2 di_fast_div x y 4Returns the sum, difference, product or quotient of x and y3. Division by zero is currently defined to return [-\infty, +\infty].+Flint2 di_fast_sqr x Returns the square of x*. The output is clamped to be nonnegative.+Flint2 di_fast_add_d x y +Flint2 di_fast_mul_d x y+Flint2 di_fast_div_d x y Arithmetic with an exact double operand.+Flint2di_fast_log_nonnegative x Returns an enclosure of \log(x). The lower endpoint of x' is rounded up to 0 if it is negative.+Flint2 di_fast_mid x (Returns an enclosure of the midpoint of x.+Flint2di_fast_ubound_radius x )Returns an upper bound for the radius of x.+++++++++++++++++++++++I Safe-Inferred )*1)++++++++++++++++++++++++++++++++++++++++++++++ Safe-Inferred )*1=,Flint2d_mat_qr Q R A  Computes the QR decomposition of a matrix A( using the Gram-Schmidt process. (Sets Q and R such that A = QR where R$ is an upper triangular matrix and Q is an orthogonal matrix.)=This uses an algorithm of Schwarz-Rutishauser. See pp. 9 of 2https://people.inf.ethz.ch/gander/papers/qrneu.pdf,Flint2 d_mat_gso B A Takes a subset of R^m S = {a_1, a_2, \ldots, a_n} (as the columns of a m x n matrix A$) and generates an orthonormal set S' = {b_1, b_2, \ldots, b_n} (as the columns of the m x n matrix B") that spans the same subspace of R^m as S.=This uses an algorithm of Schwarz-Rutishauser. See pp. 9 of 2https://people.inf.ethz.ch/gander/papers/qrneu.pdf,Flint2d_mat_mul_classical C A B Sets C to the matrix product C = A B. The matrices must have compatible dimensions for matrix multiplication (an exception is raised otherwise). Aliasing is allowed.,Flint2d_mat_transpose B A Sets B to A^T, the transpose of A". Dimensions must be compatible. A and B& are allowed to be the same object if A is a square matrix.,Flint2d_mat_is_square mat Returns a non-zero value if the number of rows is equal to the number of columns in mat, and otherwise returns zero.,Flint2d_mat_is_empty mat Returns a non-zero value if the number of rows or the number of columns in mat% is zero, and otherwise returns zero.,Flint2d_mat_is_approx_zero mat eps (Returns a non-zero value if all entries mat are zero to within eps and otherwise returns zero.,Flint2 d_mat_is_zero mat (Returns a non-zero value if all entries mat' are zero, and otherwise returns zero.,Flint2d_mat_approx_equal mat1 mat2 eps Returns a non-zero value if mat1 and mat2. have the same dimensions and entries within eps# of each other, and zero otherwise.,Flint2 d_mat_equal mat1 mat2 Returns a non-zero value if mat1 and mat2; have the same dimensions and entries, and zero otherwise.,Flint2 d_mat_fprint file mat &Prints the given matrix to the stream stdout.,Flint2 d_mat_get_str mat 4Returns a string representation of the given matrix.,Flint2d_mat_randtest mat state minexp maxexp Sets the entries of mat2 to random signed numbers with exponents between minexp and maxexp or zero.,Flint2 d_mat_one mat Sets mat to the unit matrix, having ones on the main diagonal and zeroes elsewhere. If mat= is nonsquare, it is set to the truncation of a unit matrix.,Flint2 d_mat_zero mat Sets all entries of mat to 0.,Flint2d_mat_entry_ptr mat i j "Returns a pointer to the entry of mat at row i and column j. Both i and j. must not exceed the dimensions of the matrix.,Flint2d_mat_get_entry mat i j Returns the entry of mat at row i and column j. Both i and j. must not exceed the dimensions of the matrix.,Flint2d_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.,Flint2 d_mat_swap mat1 mat2 &Swaps two matrices. The dimensions of mat1 and mat2 are allowed to be different.,Flint2 d_mat_set mat1 mat2 Sets mat1 to a copy of mat2. The dimensions of mat1 and mat2 must be the same.,Flint2 d_mat_clear mat Clears the given matrix.,Flint2 d_mat_init mat rows cols Initialises a matrix with the given number of rows and columns for use.,Flint2newDMat rows colsConstruct new + with rows rows and cols columns.,Flint2withDMat mat fApply f to a mat.,Flint2 withNewDMat rows cols fApply f to a new + with rows rows and cols columns.,Flint2 d_mat_entry mat i j Returns the entry of mat at row i and column j. Both i and j must not exceed the dimensions of the matrix. This function is implemented as a macro.,Flint2 d_mat_print mat &Prints the given matrix to the stream stdout.+++,,,,,,,,,,,,,,,,,,,,,,,,,,,,J Safe-Inferred )*1>9+++,,,,,,,,,,,,,,,,,,,,,,,,,,,,+,++,,,,,,,,,,,,,,,,,,,,,,,,,,,K Safe-Inferred )*1> Safe-Inferred )*1JM,Flint2_d_vec_dot_thrice vec1 vec2 len2 err Returns the dot product of  (vec1, len2) and  (vec2, len2) using error-free floating point sums and products to compute the dot product with three times (thrice) the working precision. err is a pointer to a double in which an error bound for the operation will be stored.8This implements the algorithm of Ogita-Rump-Oishi. See  .http://www.ti3.tuhh.de/paper/rump/OgRuOi05.pdf.,Flint2_d_vec_dot_heuristic vec1 vec2 len2 err Returns the dot product of  (vec1, len2) and  (vec2, len2) by adding up the positive and negative products, and doing a single subtraction of the two sums at the end. err is a pointer to a double in which an error bound for the operation will be stored.,Flint2 _d_vec_norm vec len ,Returns the square of the Euclidean norm of  (vec, len).,Flint2 _d_vec_dot vec1 vec2 len2 Returns the dot product of  (vec1, len2) and  (vec2, len2).,Flint2 _d_vec_sub res vec1 vec2 len2 Sets  (res, len2) to  (vec1, len2) minus  (vec2, len2).,Flint2 _d_vec_add res vec1 vec2 len2 Sets  (res, len2) to the sum of  (vec1, len2) and  (vec2, len2).,Flint2_d_vec_approx_equal vec1 vec2 len eps 5Compares two vectors of the given length and returns 1 if their entries are within eps" of each other, otherwise returns 0.,Flint2_d_vec_is_approx_zero vec len eps Returns 1 if the entries of  (vec, len) are zero to within eps, and 0 otherwise.,Flint2_d_vec_is_zero vec len Returns 1 if  (vec, len) is zero, and 0 otherwise.,Flint2 _d_vec_equal vec1 vec2 len 5Compares two vectors of the given length and returns 1' if they are equal, otherwise returns 0.,Flint2 _d_vec_zero vec len Zeros the entries of  (vec, len).,Flint2 _d_vec_set vec1 vec2 len2 Makes a copy of  (vec2, len2) into vec1.,Flint2_d_vec_randtest f state len minexp maxexp Sets the entries of a vector of the given length to random signed numbers with exponents between minexp and maxexp or zero.,Flint2 _d_vec_clear vec Frees the space allocated for vec.,Flint2 _d_vec_init len !Returns an initialised vector of double/s of given length. The entries are not zeroed.,,,,,,,,,,,,,,,L Safe-Inferred )*1J,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, Safe-Inferred )*1Y,Flint2 mpf_mat_qr Q R A  Computes the QR decomposition of a matrix A( using the Gram-Schmidt process. (Sets Q and R such that A = QR where R$ is an upper triangular matrix and Q is an orthogonal matrix.)=This uses an algorithm of Schwarz-Rutishauser. See pp. 9 of 2https://people.inf.ethz.ch/gander/papers/qrneu.pdf,Flint2 mpf_mat_gso B A Takes a subset of R^m S = {a_1, a_2, \ldots ,a_n} (as the columns of a m x n matrix A$) and generates an orthonormal set S' = {b_1, b_2, \ldots ,b_n} (as the columns of the m x n matrix B") that spans the same subspace of R^m as S.=This uses an algorithm of Schwarz-Rutishauser. See pp. 9 of 2https://people.inf.ethz.ch/gander/papers/qrneu.pdf,Flint2 mpf_mat_mul C A B Sets C to the matrix product C = A B. The matrices must have compatible dimensions for matrix multiplication (an exception is raised otherwise). Aliasing is allowed.,Flint2mpf_mat_is_square mat Returns a non-zero value if the number of rows is equal to the number of columns in mat, and otherwise returns zero.,Flint2mpf_mat_is_empty mat Returns a non-zero value if the number of rows or the number of columns in mat% is zero, and otherwise returns zero.,Flint2mpf_mat_is_zero mat (Returns a non-zero value if all entries mat' are zero, and otherwise returns zero.,Flint2mpf_mat_approx_equal mat1 mat2 bits Returns a non-zero value if mat1 and mat2) have the same dimensions and the first bits6 bits of their entries are equal, and zero otherwise.,Flint2 mpf_mat_equal mat1 mat2 Returns a non-zero value if mat1 and mat2; have the same dimensions and entries, and zero otherwise.,Flint2 mpf_mat_print mat &Prints the given matrix to the stream stdout.,Flint2mpf_mat_randtest mat state bits Sets the entries of mat# to random numbers in the interval [0, 1) with bits significant bits in the mantissa or less if their precision is smaller.,Flint2 mpf_mat_one mat Sets mat to the unit matrix, having ones on the main diagonal and zeroes elsewhere. If mat= is nonsquare, it is set to the truncation of a unit matrix.,Flint2 mpf_mat_zero mat Sets all entries of mat to 0.,Flint2mpf_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.,Flint2 mpf_mat_swap mat1 mat2 &Swaps two matrices. The dimensions of mat1 and mat2 are allowed to be different.,Flint2 mpf_mat_set mat1 mat2 Sets mat1 to a copy of mat2. The dimensions of mat1 and mat2 must be the same.,Flint2 mpf_mat_clear mat Clears the given matrix.,Flint2 mpf_mat_init mat rows cols prec Initialises a matrix with the given number of rows and columns and the given precision for use. The precision is at least the precision of the entries.,Flint2 mpf_mat_entry mat i j $Returns a reference to the entry of mat at row i and column j. Both i and j must not exceed the dimensions of the matrix. The return value can be used to either retrieve or set the given entry.,,,,,,,,,,,,,,,,,,,,,,,,,M Safe-Inferred )*1Z=,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, Safe-Inferred )*1,Flint2fmpz_mat_lll_storjohann A delta eta Takes a basis x_1, x_2, \ldots, x_m of the lattice  L \subset R^n (as the rows of a  m \times n matrix A). The output is an (delta, eta)-reduced basis y_1, y_2, \ldots, y_m of the lattice L (as the rows of the same  m \times n matrix A). Uses a modified version of LLL, which has better complexity in terms of the lattice dimension, introduced by Storjohann.See "Faster Algorithms for Integer Lattice Basis Reduction." Technical Report 249. Zurich, Switzerland: Department Informatik, ETH. July 30, 1996.,Flint2fmpz_mat_lll_original A delta eta Takes a basis x_1, x_2, \ldots, x_m of the lattice  L \subset R^n (as the rows of a  m \times n matrix A). The output is an (delta, eta)-reduced basis y_1, y_2, \ldots, y_m of the lattice L (as the rows of the same  m \times n matrix A).,Flint2 fmpz_mat_is_reduced_with_removal A delta eta gs_B newd &Returns a non-zero value if the basis A is LLL-reduced with factor (delta, eta) for each of the first newd vectors and the squared Gram-Schmidt length of each of the remaining i-th vectors (where i \ge newd) is greater than gs_B:, and otherwise returns zero. The second version assumes A! is the Gram matrix of the basis.,Flint2fmpz_mat_is_reduced A delta eta &Returns a non-zero value if the basis A is LLL-reduced with factor (delta, eta;), and otherwise returns zero. The second version assumes A! is the Gram matrix of the basis.,Flint2fmpz_mat_chol_d R A  Computes R, the Cholesky factor of a symmetric, positive definite matrix A1 using the Cholesky decomposition process. (Sets R such that  A = RR^{T} where R is a lower triangular matrix.),Flint2fmpz_mat_get_d_mat_transpose B A Sets the entries of B> as doubles corresponding to the entries of the transpose of A, rounding down towards zero if the latter cannot be represented exactly. The return value is -1 if any entry of A is too large to fit in the normal range of a double, and 0 otherwise.,Flint2fmpz_mat_get_d_mat B A Sets the entries of B, as doubles corresponding to the entries of A, rounding down towards zero if the latter cannot be represented exactly. The return value is -1 if any entry of A is too large to fit in the normal range of a double, and 0 otherwise.,Flint2fmpz_mat_hadamard H Attempts to set the matrix H to a Hadamard matrix, returning 1 if successful and 0 if unsuccessful.A Hadamard matrix of size n can only exist if n is 1, 2, or a multiple of 4. It is not known whether a Hadamard matrix exists for every size that is a multiple of 4. This function uses the Paley construction, which succeeds for all n of the form n = 2^e or n = 2^e (q + 1) where q is an odd prime power. Orders n for which Hadamard matrices are known to exist but for which this construction fails are 92, 116, 156, ... (OEIS A046116).,Flint2fmpz_mat_is_hadamard H Returns nonzero iff H is a Hadamard matrix, meaning that it is a square matrix, only has entries that are \pm 1, and satisfies H^T = n H^{-1} where n is the matrix size.,Flint2 fmpz_mat_gram B A Sets B to the Gram matrix of the m-dimensional lattice L in n-dimensional Euclidean space R^n spanned by the rows of the  m \times n matrix A!. Dimensions must be compatible. A and B' are allowed to be the same object if A is a square matrix.,Flint2fmpz_mat_is_in_snf A Checks that the given matrix is in Smith normal form, returns 1 if so and 0 otherwise.,Flint2fmpz_mat_snf_iliopoulos S A mod Computes an integer matrix S such that S5 is the unique Smith normal form of the nonsingular  n\times n matrix A+. The algorithm used is due to Iliopoulos  [Iliopoulos1989]. Aliasing of S and A is allowed. The size of S must be the same as that of A.,Flint2fmpz_mat_snf_kannan_bachem S A Computes an integer matrix S such that S9 is the unique Smith normal form of the diagonal matrix A7. The algorithm used here is due to Kannan and Bachem [KanBac1979] Aliasing of S and A is allowed. The size of S must be the same as that of A.,Flint2fmpz_mat_snf_diagonal S A Computes an integer matrix S such that S9 is the unique Smith normal form of the diagonal matrix A. The algorithm used simply takes gcds of pairs on the diagonal in turn until the Smith form is obtained. Aliasing of S and A is allowed. The size of S must be the same as that of A.,Flint2 fmpz_mat_snf S A Computes an integer matrix S such that S% is the unique Smith normal form of A. The algorithm used is selected from the implementations in FLINT to be the one most likely to be optimal, based on the characteristics of the input matrix. Aliasing of S and A is allowed. The size of S must be the same as that of A.,Flint2fmpz_mat_is_in_hnf A Checks that the given matrix is in Hermite normal form, returns 1 if so and 0 otherwise.,Flint2fmpz_mat_hnf_pernet_stein H A state Computes an integer matrix H such that H1 is the unique (row) Hermite normal form of the  m\times n matrix A6. The algorithm used here is due to Pernet and Stein  [PernetStein2010]. Aliasing of H and A is allowed. The size of H must be the same as that of A.,Flint2fmpz_mat_hnf_minors H A Computes an integer matrix H such that H1 is the unique (row) Hermite normal form of the  m\times n matrix A, where A is assumed to be of rank n7. The algorithm used here is due to Kannan and Bachem  [KanBac1979] and takes the principal minors to Hermite normal form in turn. Aliasing of H and A is allowed. The size of H must be the same as that of A.,Flint2fmpz_mat_hnf_modular_eldiv A D Transforms the  m\times n matrix A" into Hermite normal form, where A is assumed to be of rank n and D is known to be a positive multiple of the largest elementary divisor of A+. The algorithm used here is described in  [FieHof2014].,Flint2fmpz_mat_hnf_modular H A D Computes an integer matrix H such that H1 is the unique (row) Hermite normal form of the  m\times n matrix A, where A is assumed to be of rank n and D is known to be a positive multiple of the determinant of the non-zero rows of H. The algorithm used here is due to Domich, Kannan and Trotter  [DomKanTro1987]- and is also described in [Algorithm 2.4.8]  [Coh1996]. Aliasing of H and A is allowed. The size of H must be the same as that of A.,Flint2fmpz_mat_hnf_xgcd H A Computes an integer matrix H such that H- is the unique (row) Hermite normal form of A. The algorithm used is an improvement on the basic algorithm and uses extended gcds to speed up computation, this method is described, for example, in [Algorithm 2.4.5]  [Coh1996]. Aliasing of H and A is allowed. The size of H must be the same as that of A.,Flint2fmpz_mat_hnf_classical H A Computes an integer matrix H such that H- is the unique (row) Hermite normal form of A. The algorithm used is straightforward and is described, for example, in [Algorithm 2.4.4]  [Coh1996]. Aliasing of H and A is allowed. The size of H must be the same as that of A.,Flint2fmpz_mat_hnf_transform H U A Computes an integer matrix H such that H- is the unique (row) Hermite normal form of A& along with the transformation matrix U such that UA = H. The algorithm used is selected from the implementations in FLINT as per  fmpz_mat_hnf. Aliasing of H and A is allowed. The size of H must be the same as that of A and U must be square of compatible dimension (having the same number of rows as A).,Flint2 fmpz_mat_hnf H A Computes an integer matrix H such that H- is the unique (row) Hermite normal form of A. The algorithm used is selected from the implementations in FLINT to be the one most likely to be optimal, based on the characteristics of the input matrix. Aliasing of H and A is allowed. The size of H must be the same as that of A.,Flint2fmpz_mat_nullspace B A 5Computes a basis for the right rational nullspace of A; and returns the dimension of the nullspace (or nullity). B is set to a matrix with linearly independent columns and maximal rank such that AB = 0 (i.e. Ab = 0 for each column b in B), and the rank of B is returned.In general, the entries in B; will not be minimal: in particular, the pivot entries in B# will generally differ from unity. B must be allocated with sufficient space to represent the result (at most  n \times n where n is the number of column of A).,Flint2fmpz_mat_howell_form_mod A mod  Transforms A such that A modulo mod0 is the Howell form of the input matrix modulo mod+. For a definition of the Howell form see  [StoMul1998]/. The Howell form is computed by first putting A6 into strong echelon form and then ordering the rows.A, must have at least as many rows as columns.,Flint2 fmpz_mat_strong_echelon_form_mod A mod  Transforms A such that A modulo mod8 is the strong echelon form of the input matrix modulo mod. The Howell form and the strong echelon form are equal up to permutation of the rows, see  [FieHof2014] for a definition of the strong echelon form and the algorithm used here.A, must have at least as many rows as columns.,Flint2fmpz_mat_rref_mod perm A p 3Uses fraction-free Gauss-Jordan elimination to set A: to its reduced row echelon form and returns the rank of A&. All computations are done modulo p.Pivot elements are chosen with fmpz_mat_find_pivot_any. If perm is non-NULL, the permutation of rows in the matrix will also be applied to perm.,Flint2fmpz_mat_is_in_rref_with_rank A den rank Checks that the matrix A/den) is in reduced row echelon form of rank rank", returns 1 if so and 0 otherwise.,Flint2fmpz_mat_rref_mul B den A Sets (B, den%) to the reduced row echelon form of A and returns the rank of A. Aliasing of A and B is allowed.The algorithm works by computing the reduced row echelon form of A modulo a prime p using  nmod_mat_rref. The pivot columns and rows of this matrix will then define a non-singular submatrix of A, nonsingular solving and matrix multiplication can then be used to determine the reduced row echelon form of the whole of A". This procedure is described in  [Stein2007].,Flint2fmpz_mat_rref_fflu B den A Sets (B, den%) to the reduced row echelon form of A and returns the rank of A. Aliasing of A and B is allowed.The algorithm proceeds by first computing a row echelon form using  fmpz_mat_fflu+. Letting the upper part of this matrix be  (U | V) P where U# is full rank upper triangular and P9 is a permutation matrix, we obtain the rref by setting V to U^{-1} V using back substitution. Scaling each completed row in the back substitution to the denominator den, we avoid introducing new fractions. This strategy is equivalent to the fraction-free Gauss-Jordan elimination in  [NakTurWil1997]!, but faster since only the part V4 corresponding to the null space has to be updated.The denominator den is set to \pm \operatorname{det}(S) where S is an appropriate submatrix of A (S = A if A is square). Note that the determinant is not generally the minimal denominator.,Flint2 fmpz_mat_rref B den A Sets (B, den%) to the reduced row echelon form of A and returns the rank of A. Aliasing of A and B is allowed.#The algorithm used chooses between fmpz_mat_rref_fflu and fmpz_mat_rref_mul- based on the dimensions of the input matrix.,Flint2 fmpz_mat_fflu B den perm A  rank_check 0Uses fraction-free Gaussian elimination to set (B, den*) to a fraction-free LU decomposition of A and returns the rank of A. Aliasing of A and B is allowed.Pivot elements are chosen with fmpz_mat_find_pivot_any. If perm is non-NULL, the permutation of rows in the matrix will also be applied to perm.If  rank_check is set, the function aborts and returns 0 if the matrix is detected not to have full rank without completing the elimination.The denominator den is set to \pm \operatorname{det}(S) where S is an appropriate submatrix of A (S = A if A is square) and the sign is decided by the parity of the permutation. Note that the determinant is not generally the minimal denominator.1The fraction-free LU decomposition is defined in  [NakTurWil1997].,Flint2fmpz_mat_find_pivot_any mat  start_row end_row c Attempts to find a pivot entry for row reduction. Returns a row index r between  start_row (inclusive) and stop_row (exclusive) such that column c in mat has a nonzero entry on row r), or returns -1 if no such entry exists.This implementation simply chooses the first nonzero entry from it encounters. This is likely to be a nearly optimal choice if all entries in the matrix have roughly the same size, but can lead to unnecessary coefficient growth if the entries vary in size.,Flint2fmpz_mat_can_solve X den A B Returns 1 if the system AX = B$ can be solved. If so it computes (X, den ) such that  AX = B \times \operatorname{den}:. The computed denominator will not generally be minimal.Note that the matrices A and B may have any shape as long as they have the same number of rows.,Flint2fmpz_mat_can_solve_fflu X den A B Returns 1 if the system AX = B$ can be solved. If so it computes (X, den ) such that  AX = B \times \operatorname{den}:. The computed denominator will not generally be minimal.0Uses a fraction free LU decomposition algorithm.Note that the matrices A and B may have any shape as long as they have the same number of rows.,Flint2 fmpz_mat_can_solve_multi_mod_den X den A B Returns 1 if the system AX = B$ can be solved. If so it computes (X, den ) such that  AX = B \times \operatorname{den}:. The computed denominator will not generally be minimal.#Uses a Chinese remainder algorithm.Note that the matrices A and B may have any shape as long as they have the same number of rows.,Flint2fmpz_mat_solve_multi_mod_den X den A B Solves the equation AX = B for nonsingular A. More precisely, computes (X, den ) such that  AX = B \times \operatorname{den}. Returns 1 if A is nonsingular and 0 if A is singular. The computed denominator will not generally be minimal.Uses a Chinese remainder algorithm with early termination once the lifting stabilises.,Flint2fmpz_mat_solve_dixon_den X den A B Solves the equation AX = B for nonsingular A. More precisely, computes (X, den ) such that  AX = B \times \operatorname{den}. Returns 1 if A is nonsingular and 0 if A is singular. The computed denominator will not generally be minimal.Uses the Dixon lifting algorithm with early termination once the lifting stabilises.,Flint2fmpz_mat_solve_dixon X M A B Solves AX = B# given a nonsingular square matrix A and a matrix B of compatible dimensions, using a modular algorithm. In particular, Dixon's p-adic lifting algorithm is used (currently a non-adaptive version). This is generally the preferred method for large dimensions.2More precisely, this function computes an integer M and an integer matrix X such that AX = B \bmod M and such that all the reduced numerators and denominators of the elements x = p/q in the full solution satisfy  2|p|q < M. As such, the explicit rational solution matrix can be recovered uniquely by passing the output of this function to fmpq_mat_set_fmpz_mat_mod.A nonzero value is returned if A is nonsingular. If A is singular, zero is returned and the values of the output variables will be undefined.6Aliasing between input and output matrices is allowed.,Flint2fmpz_mat_solve_bound N D A B Assuming that A# is nonsingular, computes integers N and D4 such that the reduced numerators and denominators n/d in A^{-1} B satisfy the bounds 0 \le |n| \le N and  0 \le d \le D.,Flint2fmpz_mat_solve_cramer X den A B Solves the equation AX = B for nonsingular A. More precisely, computes (X, den ) such that  AX = B \times \operatorname{den}. Returns 1 if A is nonsingular and 0 if A is singular./Uses Cramer's rule. Only systems of size up to  3 \times 3 are allowed.,Flint2fmpz_mat_solve_fflu_precomp X perm FFLU B Performs fraction-free forward and back substitution given a precomputed fraction-free LU decomposition and corresponding permutation. If no impossible division is encountered, the function returns 1. This does not mean the system has a solution, however a return value of 0, can only occur if the system is insoluble.If the return value is 1 and r is the rank of the matrix A% whose FFLU we have, then the first r rows of  p(A)y = p(b)d hold, where d is the denominator of the FFLU. The remaining rows must be checked by the caller.,Flint2fmpz_mat_solve_fflu X den A B Solves the equation AX = B for nonsingular A. More precisely, computes (X, den ) such that  AX = B \times \operatorname{den}. Returns 1 if A is nonsingular and 0 if A is singular. The computed denominator will not generally be minimal.Uses fraction-free LU decomposition followed by fraction-free forward and back substitution.,Flint2fmpz_mat_solve X den A B Solves the equation AX = B for nonsingular A. More precisely, computes (X, den ) such that  AX = B \times \operatorname{den}. Returns 1 if A is nonsingular and 0 if A is singular. The computed denominator will not generally be minimal.This function uses Cramer's rule for small systems and fraction-free LU decomposition followed by fraction-free forward and back substitution for larger systems.Note that for very large systems, it is faster to compute a modular solution using fmpz_mat_solve_dixon.,Flint2fmpz_mat_col_partition part M  short_circuit Returns the number p of distinct columns of M (or 0 if the flag  short_circuit? is set and this number is greater than the number of rows of M). The entries of array part are set to values in [0, p) such that two entries of part are equal iff the corresponding columns of M are equal. This function is used in van Hoeij polynomial factoring.,Flint2 fmpz_mat_rank A Returns the rank, that is, the number of linearly independent columns (equivalently, rows), of A2. The rank is computed by row reducing a copy of A.,Flint2fmpz_mat_minpoly cp mat &Computes the minimal polynomial of an  n \times n square matrix.,Flint2_fmpz_mat_minpoly cp mat Sets cp! to the minimal polynomial of an  n \times n' square matrix and returns its length.,Flint2fmpz_mat_minpoly_modular cp mat &Computes the minimal polynomial of an  n \times n square matrix. Uses a modular method based on an average time O~(n^3), worst case O(n^4) method over \mathbb{Z}/n\mathbb{Z}.,Flint2_fmpz_mat_minpoly_modular cp mat Sets  (cp, n+1)! to the modular polynomial of an  n \times n' square matrix and returns its length.,Flint2fmpz_mat_charpoly cp mat 1Computes the characteristic polynomial of length n + 1 of an  n \times n square matrix.,Flint2_fmpz_mat_charpoly cp mat Sets  (cp, n+1)( to the characteristic polynomial of an  n \times n square matrix.,Flint2fmpz_mat_charpoly_modular cp mat 1Computes the characteristic polynomial of length n + 1 of an  n \times n3 square matrix. Uses a modular method based on an O(n^3) method over \mathbb{Z}/n\mathbb{Z}.,Flint2_fmpz_mat_charpoly_modular cp mat Sets  (cp, n+1)( to the characteristic polynomial of an  n \times n square matrix.-Flint2fmpz_mat_charpoly_berkowitz cp mat 1Computes the characteristic polynomial of length n + 1 of an  n \times n square matrix. Uses an O(n^4)- algorithm based on the method of Berkowitz.-Flint2_fmpz_mat_charpoly_berkowitz cp mat Sets  (cp, n+1)( to the characteristic polynomial of an  n \times n square matrix.-Flint2fmpz_mat_similarity A r d &Applies a similarity transform to the  n\times n matrix M in-place.If P is the  n\times n0 identity matrix the zero entries of whose row r# (0-indexed) have been replaced by d#, this transform is equivalent to  M = P^{-1}MP.Similarity transforms preserve the determinant, characteristic polynomial and minimal polynomial.-Flint2fmpz_mat_det_divisor d A Sets d to some positive divisor of the determinant of the given square matrix A%, if the determinant is nonzero. If  |\det(A)| = 0, d will always be set to zero.!A divisor is obtained by solving Ax = b, for an arbitrarily chosen right-hand side b using Dixon's algorithm and computing the least common multiple of the denominators in x. This yields a divisor d such that  |\det(A)| / d$ is tiny with very high probability.-Flint2fmpz_mat_det_bound bound A Sets bound to a nonnegative integer B such that |\det(A)| \le B . Assumes A to be a square matrix. The bound is computed from the Hadamard inequality |\det(A)| \le \prod \|a_i\|_2+ where the product is taken over the rows a_i of A.-Flint2"fmpz_mat_det_modular_given_divisor det A d proved Given a positive divisor d of \det(A), sets det* to the determinant of the square matrix A (if proved6 = 1), or a probabilistic value for the determinant (proved0 = 0), computed using a multimodular algorithm.-Flint2 fmpz_mat_det_modular_accelerated det A proved Sets det) to the determinant of the square matrix A (if proved6 = 1), or a probabilistic value for the determinant (proved0 = 0), computed using a multimodular algorithm./This function uses the same basic algorithm as fmpz_mat_det_modular, but instead of computing \det(A)# directly, it generates a divisor d of \det(A) and then computes x = \det(A) / d+ modulo several small primes not dividing d. This typically accelerates the computation by requiring fewer primes for large matrices, since d with high probability will be nearly as large as the determinant. This trick is described in  [AbbottBronsteinMulders1999].-Flint2fmpz_mat_det_modular det A proved Sets det) to the determinant of the square matrix A (if proved6 = 1), or a probabilistic value for the determinant (proved0 = 0), computed using a multimodular algorithm.The determinant is computed modulo several small primes and reconstructed using the Chinese Remainder Theorem. With proved = 1, sufficiently many primes are chosen to satisfy the bound computed by fmpz_mat_det_bound. With proved = 0, the determinant is considered determined if it remains unchanged modulo several consecutive primes (currently if their product exceeds 2^{100}).-Flint2fmpz_mat_det_bareiss det A Sets det) to the determinant of the square matrix A computed using the Bareiss algorithm. A copy of the input matrix is row reduced using fraction-free Gaussian elimination, and the determinant is read off from the last element on the main diagonal.-Flint2fmpz_mat_det_cofactor det A Sets det) to the determinant of the square matrix A computed using direct cofactor expansion. This function only supports matrices up to size  4 \times 4.-Flint2 fmpz_mat_det det A Sets det) to the determinant of the square matrix A. The matrix of dimension  0 \times 0" is defined to have determinant 1.,This function automatically chooses between fmpz_mat_det_cofactor, fmpz_mat_det_bareiss, fmpz_mat_det_modular and  fmpz_mat_det_modular_accelerated (with proved< = 1), depending on the size of the matrix and its entries.-Flint2fmpz_mat_trace trace mat Computes the trace of the matrix, i.e. the sum of the entries on the main diagonal. The matrix is required to be square.-Flint2fmpz_mat_content mat_gcd A Sets mat_gcd. as the gcd of all the elements of the matrix A$. Returns 0 if the matrix is empty.-Flint2fmpz_mat_kronecker_product C A B Sets C to the Kronecker product of A and B.-Flint2 fmpz_mat_inv Ainv den A Sets (Ainv, den) to the inverse matrix of A. Returns 1 if A is nonsingular and 0 if A is singular. Aliasing of Ainv and A is allowed.The denominator is not guaranteed to be minimal, but is guaranteed to be a divisor of the determinant of A.This function uses a direct formula for matrices of size two or less, and otherwise solves for the identity matrix using fraction-free LU decomposition.-Flint2fmpz_mat_fmpz_vec_mul c a alen B #Compute a vector-matrix product of  (a, alen) and B and and store the result in c . The vector  (a, alen) is either truncated or zero-extended to the number of rows of B!. The number entries written to c- is always equal to the number of columns of B.-Flint2fmpz_mat_mul_fmpz_vec c A b blen #Compute a matrix-vector product of A and  (b, blen) and store the result in c . The vector  (b, blen) is either truncated or zero-extended to the number of columns of A!. The number entries written to c* is always equal to the number of rows of A.-Flint2_fmpz_mat_mul_double_word C A B ?This function is only for internal use and assumes that either:- the entries of A and B5 are all nonnegative and strictly less than 2^{2*FLINT_BITS}, or - the entries of A and B% are all strictly less than 2^{2*FLINT_BITS - 1} in absolute value.-Flint2_fmpz_mat_mul_small C A B This internal function sets C to the matrix product C = A B computed using classical matrix algorithm assuming that all entries of A and B are small, that is, have bits  \le FLINT\_BITS - 2. No aliasing is allowed.-Flint2 fmpz_mat_pow B A e Sets B to the matrix A raised to the power e, where A/ must be a square matrix. Aliasing is allowed.-Flint2fmpz_mat_sqr_bodrato B A Sets B to the square of the matrix A, which must be a square matrix. Aliasing is allowed. The bodrato algorithm is described in  [Bodrato2010]. It is highly efficient for squaring matrices which satisfy both the following conditions : (a) large elements (b) dimensions less than 150.-Flint2 fmpz_mat_sqr B A Sets B to the square of the matrix A, which must be a square matrix. Aliasing is allowed. The function calls  fmpz_mat_mul( for dimensions less than 12 and calls fmpz_mat_sqr_bodrato* for cases in which the latter is faster.-Flint2fmpz_mat_mul_fft C A B Aliasing is allowed.-Flint2fmpz_mat_mul_blas C A B  Tries to set C = AB using BLAS and returns 1 for success and 0 for failure. Dimensions must be compatible for matrix multiplication. No aliasing is allowed. This function currently will fail if the matrices are empty, their dimensions are too large, or their max bits size is over one million bits.-Flint2_fmpz_mat_mul_multi_mod C A B sign bits Sets C to the matrix product C = AB+ computed using a multimodular algorithm. C is computed modulo several small prime numbers and reconstructed using the Chinese Remainder Theorem. This generally becomes more efficient than classical multiplication for large matrices.&The absolute value of the elements of C should be < 2^{\text{bits}}, and sign should be 0 if the entries of C! are known to be nonnegative and 1 otherwise. The function fmpz_mat_mul_multi_mod calculates a rigorous bound automatically. If the default bound is too pessimistic, _fmpz_mat_mul_multi_mod" can be used with a custom bound.The matrices must have compatible dimensions for matrix multiplication. No aliasing is allowed.-Flint2fmpz_mat_mul_strassen C A B Sets C = AB<. Dimensions must be compatible for matrix multiplication. C# is not allowed to be aliased with A or B. Uses Strassen multiplication (the Strassen-Winograd variant).-Flint2fmpz_mat_mul_classical C A B Sets C to the matrix product C = A B, computed using classical matrix algorithm.The matrices must have compatible dimensions for matrix multiplication. No aliasing is allowed.-Flint2 fmpz_mat_mul C A B Sets C to the matrix product C = A B. The matrices must have compatible dimensions for matrix multiplication. Aliasing is allowed.This function automatically switches between classical and multimodular multiplication, based on a heuristic comparison of the dimensions and entry sizes.-Flint2fmpz_mat_scalar_smod B A P Set the matrix B to the matrix A:, of the same dimensions, with each entry reduced modulo P- in the symmetric moduli system. We require P > 0.-Flint2fmpz_mat_scalar_tdiv_q_2exp B A exp Set the matrix B to the matrix A&, of the same dimensions, divided by 2^{exp}, rounding down towards zero.-Flint2fmpz_mat_scalar_mul_2exp B A exp Set the matrix B to the matrix A), of the same dimensions, multiplied by 2^{exp}.-Flint2fmpz_mat_scalar_divexact_si B A c Set  A = B / c, where B is an  fmpz_mat_t and c# is a scalar respectively of type slong, ulong, or fmpz_t., which is assumed to divide all elements of B exactly.-Flint2"fmpz_mat_scalar_addmul_nmod_mat_ui B A c Set  B = B + A*c where A is an  nmod_mat_t and c# is a scalar respectively of type ulong or fmpz_t. The dimensions of A and B must be compatible.-Flint2fmpz_mat_scalar_submul_si B A c Set  B = B - A*c where A is an  fmpz_mat_t and c# is a scalar respectively of type slong, ulong, or fmpz_t. The dimensions of A and B must be compatible.-Flint2fmpz_mat_scalar_addmul_si B A c Set  B = B + A*c where A is an  fmpz_mat_t and c# is a scalar respectively of type slong, ulong, or fmpz_t. The dimensions of A and B must be compatible.-Flint2fmpz_mat_scalar_mul_si B A c Set B = A*c where A is an  fmpz_mat_t and c# is a scalar respectively of type slong, ulong, or fmpz_t. The dimensions of A and B must be compatible.-Flint2 fmpz_mat_neg B A Sets B to the elementwise negation of A=. Both inputs must be of the same size. Aliasing is allowed.-Flint2 fmpz_mat_sub C A B Sets C to the elementwise difference A - B<. All inputs must be of the same size. Aliasing is allowed.-Flint2 fmpz_mat_add C A B Sets C to the elementwise sum A + B<. All inputs must be of the same size. Aliasing is allowed.-Flint2fmpz_mat_multi_CRT_ui mat residues nres sign  Reconstructs mat from its images modulo the nres matrices in residues.This function is provided for convenience purposes. For reducing or reconstructing multiple integer matrices over the same set of moduli, it is faster to use fmpz_mat_multi_CRT_ui_precomp.-Flint2fmpz_mat_multi_CRT_ui_precomp mat residues nres comb temp sign  Reconstructs mat from its images modulo the nres matrices in residues, given precomputed comb and  comb_temp structures.-Flint2fmpz_mat_multi_mod_ui residues nres mat Sets each of the nres matrices in residues to mat6 reduced modulo the modulus of the respective matrix.This function is provided for convenience purposes. For reducing or reconstructing multiple integer matrices over the same set of moduli, it is faster to use\ fmpz_mat_multi_mod_precomp.-Flint2fmpz_mat_multi_mod_ui_precomp residues nres mat comb temp Sets each of the nres matrices in residues to mat reduced modulo the modulus of the respective matrix, given precomputed comb and  comb_temp structures.-Flint2fmpz_mat_CRT_ui res mat1 m1 mat2 sign Given mat1 with entries modulo m and mat2 with modulus n, sets res" to the CRT reconstruction modulo mn with entries satisfying -mn/2 <= c < mn/2 (if sign = 1) or  0 <= c < mn (if sign = 0).-Flint2fmpz_mat_set_nmod_mat_unsigned A Amod Sets the entries of Amod to the residues in Amod, normalised to the interval  0 <= r < m where m is the modulus.-Flint2fmpz_mat_set_nmod_mat A Amod Sets the entries of Amod to the residues in Amod, normalised to the interval -m/2 <= r < m/2 where m is the modulus.-Flint2fmpz_mat_get_nmod_mat Amod A Sets the entries of Amod to the entries of A reduced by the modulus of Amod.-Flint2fmpz_mat_concat_horizontal res mat1 mat2 Sets res! to horizontal concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  m \times k, res : m \times (n + k).-Flint2fmpz_mat_concat_vertical res mat1 mat2 Sets res to vertical concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  k \times n, res : (m + k) \times n.-Flint2fmpz_mat_transpose B A Sets B to A^T, the transpose of A". Dimensions must be compatible. A and B& are allowed to be the same object if A is a square matrix.-Flint2fmpz_mat_is_zero_row mat i  Returns a non-zero value if row i of mat is zero.-Flint2fmpz_mat_is_square mat Returns a non-zero value if the number of rows is equal to the number of columns in mat, and otherwise returns zero.-Flint2fmpz_mat_is_empty mat Returns a non-zero value if the number of rows or the number of columns in mat% is zero, and otherwise returns zero.-Flint2fmpz_mat_is_one mat Returns a non-zero value if mat is the unit matrix or the truncation of a unit matrix, and otherwise returns zero.-Flint2fmpz_mat_is_zero mat (Returns a non-zero value if all entries mat' are zero, and otherwise returns zero.-Flint2fmpz_mat_equal mat1 mat2 Returns a non-zero value if mat1 and mat2; have the same dimensions and entries, and zero otherwise.-Flint2 fmpz_mat_read mat Reads a matrix from stdin, storing the result in mat.In case of success, returns a positive number. In case of failure, returns a non-positive value.-Flint2fmpz_mat_fread file mat Reads a matrix from the stream file, storing the result in mat. The expected format is the number of rows, a space, the number of columns, two spaces, then a space separated list of coefficients, one row after the other.In case of success, returns a positive number. In case of failure, returns a non-positive value.-Flint2fmpz_mat_fprint_pretty file mat &Prints the given matrix to the stream file. The format is an opening square bracket then on each line a row of the matrix, followed by a closing square bracket. Each row is written as an opening square bracket followed by a space separated list of coefficients followed by a closing square bracket.In case of success, returns a positive value; otherwise, returns a non-positive value.-Flint2fmpz_mat_fprint file mat &Prints the given matrix to the stream file. The format is the number of rows, a space, the number of columns, two spaces, then a space separated list of coefficients, one row after the other.In case of success, returns a positive value; otherwise, returns a non-positive value.-Flint2fmpz_mat_randops mat state count  Randomises mat by performing elementary row or column operations. More precisely, at most count random additions or subtractions of distinct rows and columns will be performed. This leaves the rank (and for square matrices, the determinant) unchanged.-Flint2fmpz_mat_randdet mat state det Sets mat to a random sparse matrix with minimal number of nonzero entries such that its determinant has the given value.%Note that the matrix will be zero if det is zero. In order to generate a non-zero singular matrix, the function fmpz_mat_randrank can be used.The matrix can be transformed into a dense matrix with unchanged determinant by subsequently calling fmpz_mat_randops.-Flint2fmpz_mat_randrank mat state rank bits Sets mat to a random sparse matrix with the given rank, having exactly as many non-zero elements as the rank, with the nonzero elements being random integers of the given bit size.The matrix can be transformed into a dense matrix with unchanged rank by subsequently calling fmpz_mat_randops.-Flint2fmpz_mat_randpermdiag mat state diag n Sets mat to a random permutation of the rows and columns of a given diagonal matrix. The diagonal matrix is specified in the form of an array of the n& initial entries on the main diagonal.The return value is 0 or 16 depending on whether the permutation is even or odd.-Flint2fmpz_mat_randajtai mat state alpha Sets a square matrix mat to a random ajtai matrix. The diagonal entries (i, i)) are set to a random entry in the range  [1, 2^{b-1}] inclusive where "b = \lfloor(2 r - i)^\alpha\rfloor for some double parameter~`alpha`. The entries below the diagonal in column~`i` are set to a random entry in the range (-2^b + 1, 2^b - 1) whilst the entries to the right of the diagonal in row~`i` are set to zero.-Flint2fmpz_mat_randntrulike2 mat state bits q Sets a square matrix mat of even dimension to a random  NTRU like matrix.The matrix is broken into four square submatrices. The top left submatrix is set to q times the identity matrix. The top right submatrix is set to the zero matrix. The bottom right submatrix is set to the identity matrix. Finally the bottom left submatrix has the following format. A random vector h of length r/2 is created, with random signed entries of the given number of bits. Then entry (i, j) of the submatrix is set to h[i + j \bmod{r/2}].-Flint2fmpz_mat_randntrulike mat state bits q Sets a square matrix mat of even dimension to a random  NTRU like matrix.The matrix is broken into four square submatrices. The top left submatrix is set to the identity. The bottom left submatrix is set to the zero matrix. The bottom right submatrix is set to q times the identity matrix. Finally the top right submatrix has the following format. A random vector h of length r/2 is created, with random signed entries of the given number of bits. Then entry (i, j) of the submatrix is set to h[i + j \bmod{r/2}].-Flint2fmpz_mat_randsimdioph mat state bits bits2 Sets mat to a random simultaneous diophantine matrix.8The matrix must be square. The top left entry is set to 2^bits2. The remainder of that row is then set to signed random integers of the given number of binary bits. The remainder of the first column is zero. Running down the rest of the diagonal are the values 2^bits" with all remaining entries zero.-Flint2fmpz_mat_randintrel mat state bits Sets mat to be a random integer relations= matrix, with signed entries up to the given number of bits.The number of columns of mat must be equal to one more than the number of rows. The format of the matrix is a set of random integers in the left hand column and an identity matrix in the remaining square submatrix.-Flint2fmpz_mat_randtest mat state bits Sets the entries of mat to random signed integers whose absolute values have a random number of bits up to the given number of bits inclusive.-Flint2fmpz_mat_randbits mat state bits Sets the entries of mat to random signed integers whose absolute values have the given number of binary bits.-Flint2fmpz_mat_window_clear window Clears the matrix window and releases any memory that it uses. Note that the memory to the underlying matrix that window points to is not freed.-Flint2fmpz_mat_window_init window mat r1 c1 r2 c2 Initializes the matrix window to be an r2 - r1 by c2 - c1 submatrix of mat whose (0,0) entry is the (r1, c1) entry of mat". The memory for the elements of window is shared with mat.-Flint2fmpz_mat_invert_cols mat perm Swaps columns i and c - i of mat for  0 <= i < c/2, where c is the number of columns of mat. If perm is non-NULL:, the permutation of the columns will also be applied to perm.-Flint2fmpz_mat_invert_rows mat perm  Swaps rows i and r - i of mat for  0 <= i < r/2, where r is the number of rows of mat. If perm is non-NULL7, the permutation of the rows will also be applied to perm.-Flint2fmpz_mat_swap_cols mat perm r s Swaps columns r and s of mat. If perm is non-NULL:, the permutation of the columns will also be applied to perm.-Flint2fmpz_mat_swap_rows mat perm r s  Swaps rows r and s of mat. If perm is non-NULL7, the permutation of the rows will also be applied to perm.-Flint2 fmpz_mat_one mat Sets mat to the unit matrix, having ones on the main diagonal and zeroes elsewhere. If mat= is nonsquare, it is set to the truncation of a unit matrix.-Flint2 fmpz_mat_zero mat Sets all entries of mat to 0.-Flint2fmpz_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.-Flint2 fmpz_mat_swap mat1 mat2 &Swaps two matrices. The dimensions of mat1 and mat2 are allowed to be different.-Flint2fmpz_mat_init_set mat src Initialises the matrix mat to the same size as src and sets it to a copy of src.-Flint2 fmpz_mat_set mat1 mat2 Sets mat1 to a copy of mat2. The dimensions of mat1 and mat2 must be the same.-Flint2fmpz_mat_clear mat Clears the given matrix.-Flint2 fmpz_mat_init mat rows cols Initialises a matrix with the given number of rows and columns for use.-Flint2fmpz_mat_entry mat i j $Returns a reference to the entry of mat at row i and column j. This reference can be passed as an input or output variable to any function in the fmpz module for direct manipulation.Both i and j must not exceed the dimensions of the matrix. No bounds checking is performed.-Flint2fmpz_mat_print mat &Prints the given matrix to the stream stdout. For further details, see fmpz_mat_fprint.-Flint2fmpz_mat_print_pretty mat Prints the given matrix to stdout. For further details, see fmpz_mat_fprint_pretty.,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,------------------------------------------------------------------------------------------------N Safe-Inferred )*1,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,------------------------------------------------------------------------------------------------,,,,------------------------------------------------------------------------------------------------,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, Safe-Inferred )*1?-Flint2qfb_exponent_grh exponent n iters B1 B2_sqrt As per code{qfb_exponent} except that the bound code{c} is automatically generated such that the exponent it guaranteed to be correct, if found, assuming the GRH, namely that the class group is generated by primes less than  6\log^2(|n|) as per~citep{BuchDull1992}% "Distributed Class Group Computation", Johannes Buchmann, Stephan % D"{u}llman, Informatik 1 (1992), pp. 69--79.-Flint2 qfb_exponent exponent n B1 B2_sqrt c 8Compute the exponent of the class group of discriminant n, doing a stage 11 with primes up to at least code{B1} and a stage 2 for a single large prime up to at least the square of code{B2_sqrt}, and with probability at least  1 - 2^{-c}. If the prime limits are exhausted without finding the exponent, the function returns 0, otherwise it returns 1 and code{exponent} is set to the computed exponent, i.e. the minimum power which every element of the class group has to be raised to give the identity.The function performs a stage 2 which stores up to 4\times* code{iters} binary quadratic forms, and 12\times code{iters} additional limbs of data in a hash table, where code{iters} is the square root of code{B2}.)We use algorithm 8.1 of~citep{SuthThesis}% "Order Computations in Generic Groups", Andrew Sutherland, % MIT Thesis 2007. % 9http://groups.csail.mit.edu/cis/theses/sutherland-phd.pdf-Flint2qfb_exponent_element exponent f n B1 B2_sqrt !Find the exponent of the element f3 in the form class group of forms of discriminant n, doing a stage 12 with primes up to at least code{B1} and a stage 2 for a single large prime up to at least the square of code{B2}. If the function fails to find the exponent it returns 0!, otherwise the function returns 1/ and code{exponent} is set to the exponent of f, i.e. the minimum power of f which gives the identity.It is assumed that the form f8 is reduced. We require that code{iters} is a power of 2 and that code{iters} >= 1024.The function performs a stage 2 which stores up to 4\times* code{iters} binary quadratic forms, and 12\times code{iters} additional limbs of data in a hash table, where code{iters} is the square root of code{B2}.-Flint2qfb_prime_form r D p Sets r to the unique prime  (p, b, c) of discriminant D , i.e. with  0 < b \leq p. We require that p is a prime.-Flint2qfb_is_primitive f Return 1 if f is primitive, i.e. the greatest common divisor of its three coefficients is 1!. Otherwise the function returns 0.-Flint2qfb_principal_form f D Set f' to the principal form of discriminant D-, i.e. the identity in the form class group.-Flint2qfb_is_principal_form f D Return 1 if f0 is the reduced principal form of discriminant D,, i.e. the identity in the form class group.-Flint2 qfb_inverse r f Set r- to the inverse of the binary quadratic form f.-Flint2qfb_pow r f D exp As per code{qfb_pow_ui}.-Flint2 qfb_pow_ui r f D exp Compute the near reduced form r which is the result of composing the principal form (identity) with f code{exp} times. We require D" to be set to the discriminant of f and that f is a primitive form.-Flint2 qfb_nudupl r f D L )As for code{nucomp} except that the form f0 is composed with itself. We require that that f is a primitive form.-Flint2 qfb_nucomp r f g D L ,Shanks' NUCOMP as described in~citep{JacvdP}% Computational aspects of NUCOMP", Michael J. Jacobson Jr., % Alfred J. van der Poorten, ANTS 2002, LNCS 2369, pp. 120--133./Computes the near reduced composition of forms f and g given L = \lfloor |D|^{1/4} \rfloor where D is the common discriminant of f and g. The result is returned in r.We require that that f is a primitive form.-Flint2qfb_reduced_forms_large forms d As for qfb_reduced_forms. However, for small |d| it requires fewer primes to be computed at a small cost in speed. It is called automatically by code{qfb_reduced_forms} for large |d| so that  flint_primes is not exhausted.-Flint2qfb_reduced_forms forms d Given a discriminant d (negative for negative definite forms), compute all the reduced binary quadratic forms of that discriminant. The function allocates space for these and returns it in the variable code{forms} (the user is responsible for cleaning this up by a single call to code{qfb_array_clear} on code{forms}, after use. The function returns the number of forms generated (the form class number). The forms are stored in an array of code{qfb} structs, which contain fields code{a, b, c} corresponding to forms  (a, b, c).-Flint2qfb_is_reduced r Returns 1 if q8 is a reduced binary quadratic form. Otherwise returns 1.-Flint2 qfb_reduce r f D Set r> to the reduced form equivalent to the binary quadratic form f of discriminant D.-Flint2qfb_discriminant D f Set D2 to the discriminant of the binary quadratic form f , i.e. to  b^2 - 4ac, where  f = (a, b, c).-Flint2 qfb_equal f g Returns 1 if f and g: are identical binary quadratic forms, otherwise returns 0.-Flint2qfb_set f g Set the binary quadratic form f to be equal to g.-Flint2 qfb_hash_find qhash q depth Search for the given binary quadratic form or its inverse in the given hash table of size  2^{depth}. If it is found, return the index in the table (which is an array of code{qfb_hash_t} structs, otherwise return code{-1L}.-Flint2qfb_hash_insert qhash q q2 iter depth Insert the binary quadratic form code{q} into the given hash table of size  2^{depth} in the field code{q} of the hash structure. Also store the second binary quadratic form code{q2} (if not code{NULL}) in the similarly named field and code{iter} in the similarly named field of the hash structure.-Flint2qfb_hash_clear qhash depth .Frees all memory used by a hash table of size  2^{depth}.-Flint2 qfb_hash_init depth !Initialises a hash table of size  2^{depth}.-Flint2qfb_array_clear forms num Clean up an array of code{qfb} structs allocated by a qfb function. The parameter code{num} must be set to the length of the array.-Flint2 qfb_clear q Clear a code{qfb_t} after use. This releases any memory allocated for q back to flint.-Flint2qfb_init q Initialise a code{qfb_t} q for use..Flint2 Create a Qfb..Flint2 Use Qfb in f..Flint2Apply f to new Qfb..Flint2 qfb_print q Print a binary quadratic form q in the format  (a, b, c) where a, b, c are the entries of q.$--------------------------------....O Safe-Inferred )*1@$--------------------------------....$----...-----------.-----------------P Safe-Inferred )*1A^ Safe-Inferred )*1H .Flint2_perm_fprint_pretty vec n $Prints permutation vector of length n in cycle representation to file..Flint2_perm_get_str_pretty vec n ?Return a string representation of permutation vector of length n in cycle representation..Flint2_perm_randtest vec n state 0Generates a random permutation vector of length n! and returns its parity, 0 or 1.This function uses the Knuth shuffle algorithm to generate a uniformly random permutation without retries..Flint2 _perm_parity vec n Returns the parity of vec, 0 if the permutation is even and 1 if the permutation is odd..Flint2 _perm_compose res vec1 vec2 n Forms the composition \pi_1 \circ \pi_2 of two permutations \pi_1 and \pi_2. Here, \pi_2 is applied first, that is, ((\pi_1 \circ \pi_2)(i) = \pi_1(\pi_2(i)).Allows aliasing of res, vec1 and vec2..Flint2 _perm_inv res vec n Sets res to the inverse permutation of vec. Allows aliasing of res and vec..Flint2 _perm_set_one vec n 1Sets the permutation to the identity permutation..Flint2 _perm_set res vec n Sets the permutation res to the same as the permutation vec..Flint2 _perm_clear vec Clears the permutation..Flint2 _perm_init n $Initialises the permutation for use..Flint2 _perm_print vec n (Prints the permutation vector of length n to stdout..Flint2_perm_print_pretty vec n $Prints permutation vector of length n in cycle representation to stdout................Q Safe-Inferred )*1I\.............................. Safe-Inferred )*1d#.Flint2bool_mat_all_pairs_longest_walk B A Sets B_{ij}; to the length of the longest walk with endpoint vertices i and j( in the graph whose adjacency matrix is A. The matrix A must be square. Empty walks with zero length which begin and end at the same vertex are allowed. If j is not reachable from i then no walk from i to j exists and B_{ij} is set to the special value -1!. If arbitrarily long walks from i to j exist then B_{ij} is set to the special value -2.The function returns -2 if any entry of B_{ij} is -21, and otherwise it returns the maximum entry in B , except if A is empty in which case -1 is returned. Note that the returned value is one less than that of nilpotency_degree.This function can help quantify entrywise errors in a truncated evaluation of a matrix power series. If A is an indicator matrix with the same sparsity pattern as a matrix M+ over the real or complex numbers, and if B_{ij}! does not take the special value -2, then the tail -\left[ \sum_{k=N}^\infty a_k M^k \right]_{ij} vanishes when  N > B_{ij}..Flint2*bool_mat_get_strongly_connected_components p A Partitions the n row and column indices of the  n \times n matrix A according to the strongly connected components (SCC) of the graph for which A+ is the adjacency matrix. If the graph has k! SCCs then the function returns k, and for each vertex i \in [0, n-1], p_i is set to the index of the SCC to which the vertex belongs. The SCCs themselves can be considered as nodes in a directed acyclic graph (DAG), and the SCCs are indexed in postorder with respect to that DAG..Flint2bool_mat_transitive_closure B A Sets B to the transitive closure \sum_{k=1}^\infty A^k. The matrix A is required to be square..Flint2bool_mat_nilpotency_degree A %Returns the nilpotency degree of the  n \times n matrix A$. It returns the smallest positive k such that A^k = 0. If no such k" exists then the function returns -1 if n( is positive, and otherwise it returns 0..Flint2bool_mat_trace mat Returns the trace of the matrix, i.e. the sum of entries on the main diagonal of mat. The matrix is required to be square. The sum is in the boolean semiring, so this function returns nonzero iff any entry on the diagonal of mat is nonzero..Flint2bool_mat_pow_ui B A exp Sets B to A raised to the power exp. Requires that A is a square matrix..Flint2bool_mat_mul_entrywise res mat1 mat2 Sets res to the entrywise product of mat1 and mat2.. The operands must have the same dimensions..Flint2 bool_mat_mul res mat1 mat2 Sets res to the matrix product of mat1 and mat2. The operands must have compatible dimensions for matrix multiplication..Flint2 bool_mat_add res mat1 mat2 Sets res to the sum of mat1 and mat2.. The operands must have the same dimensions..Flint2bool_mat_complement B A Sets B to the logical complement of A . That is B_{ij} is set to  \bar{A_{ij}}-. The operands must have the same dimensions..Flint2bool_mat_transpose dest src Sets dest to the transpose of src. The operands must have compatible dimensions. Aliasing is allowed..Flint2bool_mat_directed_cycle A Sets A_{ij} to j = (i + 1) \mod n where n$ is the order of the square matrix A..Flint2bool_mat_directed_path A Sets A_{ij} to  j = i + 1. Requires that A is a square matrix..Flint2 bool_mat_one mat Sets the entries on the main diagonal to ones, and all other entries to zero..Flint2 bool_mat_zero mat  Sets all entries in mat to zero..Flint2bool_mat_randtest_nilpotent mat state Sets mat to a random nilpotent matrix..Flint2bool_mat_randtest_diagonal mat state Sets mat to a random diagonal matrix..Flint2bool_mat_randtest mat state Sets mat to a random matrix..Flint2bool_mat_is_nilpotent A 2Returns nonzero iff some positive matrix power of A is zero..Flint2bool_mat_is_transitive mat Returns nonzero iff $A_{ij} \wedge A_{jk} \implies A_{ik}..Flint2bool_mat_is_lower_triangular A Returns nonzero iff i < j \implies \bar{A_{ij}}..Flint2bool_mat_is_diagonal A Returns nonzero iff i \ne j \implies \bar{A_{ij}}..Flint2 bool_mat_all mat #Returns nonzero iff all entries of mat are nonzero..Flint2 bool_mat_any mat Returns nonzero iff mat has a nonzero entry..Flint2bool_mat_equal mat1 mat2 Returns nonzero iff the matrices have the same dimensions and identical entries..Flint2bool_mat_fprint file mat .Prints each entry in the matrix to the stream file..Flint2 bool_mat_set dest src Sets dest to src.. The operands must have identical dimensions..Flint2bool_mat_clear mat ,Clears the matrix, deallocating all entries..Flint2 bool_mat_init mat r c ;Initializes the matrix, setting it to the zero matrix with r rows and c columns..Flint2bool_mat_get_entry mat i j Returns the entry of matrix mat at row i and column j7. foreign import ccall "bool_mat.h bool_mat_get_entry".Flint2bool_mat_set_entry mat i j x Sets the entry of matrix mat at row i and column j to x..Flint2bool_mat_is_empty mat Returns nonzero iff the number of rows or the number of columns in mat is zero. Note that this does not depend on the entry values of mat..Flint2bool_mat_is_square mat Returns nonzero iff the number of rows is equal to the number of columns in mat..Flint2bool_mat_print mat  Prints each entry in the matrix..Flint2 bool_mat_sqr B A Sets B to the matrix square of A=. The operands must both be square with the same dimensions.,............................................R Safe-Inferred )*1eo,............................................,............................................S Safe-Inferred )*1fb Safe-Inferred )*1$6.Flint2 fmpz_poly_mat_solve_fflu_precomp X perm FFLU B Performs fraction-free forward and back substitution given a precomputed fraction-free LU decomposition and corresponding permutation..Flint2fmpz_poly_mat_solve_fflu X den A B Solves the equation AX = B for nonsingular A. More precisely, computes (X, den ) such that  AX = B \times \operatorname{den}. Returns 1 if A is nonsingular and 0 if A is singular. The computed denominator will not generally be minimal.Uses fraction-free LU decomposition followed by fraction-free forward and back substitution..Flint2fmpz_poly_mat_solve X den A B Solves the equation AX = B for nonsingular A. More precisely, computes (X, den ) such that  AX = B \times \operatorname{den}. Returns 1 if A is nonsingular and 0 if A is singular. The computed denominator will not generally be minimal.Uses fraction-free LU decomposition followed by fraction-free forward and back substitution..Flint2fmpz_poly_mat_nullspace res mat 4Computes the right rational nullspace of the matrix mat and returns the nullity.More precisely, assume that mat has rank r and nullity n%. Then this function sets the first n columns of res< to linearly independent vectors spanning the nullspace of mat$. As a result, we always have rank(res) = n, and mat \times res is the zero matrix.The computed basis vectors will not generally be in a reduced form. In general, the polynomials in each column vector in the result will have a nontrivial common GCD..Flint2fmpz_poly_mat_inv Ainv den A Sets (Ainv, den) to the inverse matrix of A. Returns 1 if A is nonsingular and 0 if A is singular. Aliasing of Ainv and A is allowed.More precisely, det# will be set to the determinant of A and Ainv( will be set to the adjugate matrix of A. Note that the determinant is not necessarily the minimal denominator.Uses fraction-free LU decomposition, followed by solving for the identity matrix..Flint2fmpz_poly_mat_rank A Returns the rank of A8. Performs fraction-free LU decomposition on a copy of A..Flint2fmpz_poly_mat_det_interpolate det A Sets det) to the determinant of the square matrix A6. The determinant is computed by determining a bound n+ for its length, evaluating the matrix at n distinct points, computing the determinant of each integer matrix, and forming the interpolating polynomial..Flint2fmpz_poly_mat_det_fflu det A Sets det) to the determinant of the square matrix A. The determinant is computed by performing a fraction-free LU decomposition on a copy of A..Flint2fmpz_poly_mat_det det A Sets det) to the determinant of the square matrix A. Uses a direct formula, fraction-free LU decomposition, or interpolation, depending on the size of the matrix..Flint2fmpz_poly_mat_trace trace mat Computes the trace of the matrix, i.e. the sum of the entries on the main diagonal. The matrix is required to be square..Flint2fmpz_poly_mat_rref B den A Sets (B, den%) to the reduced row echelon form of A and returns the rank of A. Aliasing of A and B is allowed.The denominator den is set to \pm \operatorname{det}(A). Note that the determinant is not generally the minimal denominator..Flint2fmpz_poly_mat_fflu B den perm A  rank_check 0Uses fraction-free Gaussian elimination to set (B, den*) to a fraction-free LU decomposition of A and returns the rank of A. Aliasing of A and B is allowed.Pivot elements are chosen with  fmpz_poly_mat_find_pivot_partial. If perm is non-NULL, the permutation of rows in the matrix will also be applied to perm.If  rank_check is set, the function aborts and returns 0 if the matrix is detected not to have full rank without completing the elimination.The denominator den is set to \pm \operatorname{det}(A), where the sign is decided by the parity of the permutation. Note that the determinant is not generally the minimal denominator..Flint2 fmpz_poly_mat_find_pivot_partial mat  start_row end_row c Attempts to find a pivot entry for row reduction. Returns a row index r between  start_row (inclusive) and stop_row (exclusive) such that column c in mat has a nonzero entry on row r), or returns -1 if no such entry exists.This implementation searches all the rows in the column and chooses the nonzero entry of smallest degree. If there are several entries with the same minimal degree, it chooses the entry with the smallest coefficient bit bound. This heuristic typically reduces coefficient growth when the matrix entries vary in size..Flint2fmpz_poly_mat_find_pivot_any mat  start_row end_row c Attempts to find a pivot entry for row reduction. Returns a row index r between  start_row (inclusive) and stop_row (exclusive) such that column c in mat has a nonzero entry on row r), or returns -1 if no such entry exists.This implementation simply chooses the first nonzero entry it encounters. This is likely to be a nearly optimal choice if all entries in the matrix have roughly the same size, but can lead to unnecessary coefficient growth if the entries vary in size..Flint2fmpz_poly_mat_prod res factors n Sets res to the product of the n matrices given in the vector factors, all of which must be square and of the same size. Uses binary splitting..Flint2fmpz_poly_mat_pow_trunc B A exp len Sets B to A raised to the power exp$, truncating all entries to length len, where A is a square matrix. Uses exponentiation by squaring. Aliasing is allowed..Flint2fmpz_poly_mat_pow B A exp Sets B to A raised to the power exp, where A is a square matrix. Uses exponentiation by squaring. Aliasing is allowed..Flint2fmpz_poly_mat_sqrlow B A len Sets B to the square of A, which must be a square matrix, truncating all entries to length len. Aliasing is allowed. This function uses direct formulas for very small matrices, and otherwise classical matrix multiplication..Flint2fmpz_poly_mat_sqr_KS B A Sets B to the square of A, which must be a square matrix. Aliasing is allowed. This function uses Kronecker segmentation..Flint2fmpz_poly_mat_sqr_classical B A Sets B to the square of A, which must be a square matrix. Aliasing is allowed. This function uses direct formulas for very small matrices, and otherwise classical matrix multiplication..Flint2fmpz_poly_mat_sqr B A Sets B to the square of A, which must be a square matrix. Aliasing is allowed. This function automatically chooses between classical and KS squaring..Flint2fmpz_poly_mat_mullow C A B len Sets C to the matrix product of A and B1, truncating each entry in the result to length len. Uses classical matrix multiplication. The matrices must have compatible dimensions for matrix multiplication. Aliasing is allowed..Flint2fmpz_poly_mat_mul_KS C A B Sets C to the matrix product of A and B, computed using Kronecker segmentation. The matrices must have compatible dimensions for matrix multiplication. Aliasing is allowed..Flint2fmpz_poly_mat_mul_classical C A B Sets C to the matrix product of A and B, computed using the classical algorithm. The matrices must have compatible dimensions for matrix multiplication. Aliasing is allowed..Flint2fmpz_poly_mat_mul C A B Sets C to the matrix product of A and B. The matrices must have compatible dimensions for matrix multiplication. Aliasing is allowed. This function automatically chooses between classical and KS multiplication..Flint2fmpz_poly_mat_neg B A Sets B to the negation of A>. The matrices must have the same shape. Aliasing is allowed..Flint2fmpz_poly_mat_sub C A B Sets C to the sum of A and B>. All matrices must have the same shape. Aliasing is allowed..Flint2fmpz_poly_mat_add C A B Sets C to the sum of A and B>. All matrices must have the same shape. Aliasing is allowed..Flint2fmpz_poly_mat_scalar_mul_fmpz B A c Sets B to A% multiplied entrywise by the integer c..Flint2"fmpz_poly_mat_scalar_mul_fmpz_poly B A c Sets B to A( multiplied entrywise by the polynomial c..Flint2fmpz_poly_mat_evaluate_fmpz B A x  Sets the  fmpz_mat_t B to A" evaluated entrywise at the point x..Flint2fmpz_poly_mat_transpose B A Sets B to A^t..Flint2fmpz_poly_mat_max_length A ?Returns the maximum polynomial length among all the entries in A..Flint2fmpz_poly_mat_max_bits A Returns the maximum number of bits among the coefficients of the entries in A?, or the negative of that value if any coefficient is negative..Flint2fmpz_poly_mat_is_square mat Returns a non-zero value if the number of rows is equal to the number of columns in mat, and otherwise returns zero..Flint2fmpz_poly_mat_is_empty mat Returns a non-zero value if the number of rows or the number of columns in mat% is zero, and otherwise returns zero..Flint2fmpz_poly_mat_is_one mat "Returns nonzero if all entries of mat on the main diagonal are the constant polynomial 1 and all remaining entries are zero, and returns zero otherwise. The matrix need not be square..Flint2fmpz_poly_mat_is_zero mat "Returns nonzero if all entries in mat' are zero, and returns zero otherwise..Flint2fmpz_poly_mat_equal mat1 mat2 Returns nonzero if mat1 and mat2 have the same shape and all their entries agree, and returns zero otherwise..Flint2fmpz_poly_mat_one mat Sets mat to the unit or identity matrix of given shape, having the element 1 on the main diagonal and zeros elsewhere. If mat= is nonsquare, it is set to the truncation of a unit matrix..Flint2fmpz_poly_mat_zero mat Sets mat to the zero matrix..Flint2fmpz_poly_mat_randtest_sparse A state len bits density Creates a random matrix with the amount of nonzero entries given approximately by the density variable, which should be a fraction between 0 (most sparse) and 1 (most dense).;The nonzero entries will have random lengths between 1 and len..Flint2fmpz_poly_mat_randtest_unsigned mat state len bits This is equivalent to applying fmpz_poly_randtest_unsigned to all entries in the matrix..Flint2fmpz_poly_mat_randtest mat state len bits This is equivalent to applying fmpz_poly_randtest to all entries in the matrix..Flint2fmpz_poly_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs..Flint2fmpz_poly_mat_swap mat1 mat2 Swaps mat1 and mat2 efficiently..Flint2fmpz_poly_mat_set mat1 mat2 Sets mat1 to a copy of mat2..Flint2fmpz_poly_mat_ncols mat !Returns the number of columns in mat..Flint2fmpz_poly_mat_nrows mat Returns the number of rows in mat..Flint2fmpz_poly_mat_clear mat Frees all memory associated with the matrix. The matrix must be reinitialised if it is to be used again..Flint2fmpz_poly_mat_init_set mat src Initialises a matrix mat of the same dimensions as src, and sets it to a copy of src..Flint2fmpz_poly_mat_init mat rows cols Initialises a matrix with the given number of rows and columns for use..Flint2fmpz_poly_mat_entry mat i j &Gives a reference to the entry at row i and column j. The reference can be passed as an input or output variable to any  fmpz_poly function for direct manipulation of the matrix element. No bounds checking is performed..Flint2fmpz_poly_mat_print mat x Prints the matrix mat( to standard output, using the variable x.=.............................................................T Safe-Inferred )*1=.............................................................=.............................................................U Safe-Inferred )*1.... Safe-Inferred )*1i!/Flint2arith_sum_of_squares_vec r k n For i = 0, 1, \ldots, n-1, sets r_i& to the number of representations of i a sum of k squares, r_k(i)!. This effectively computes the q-expansion of \vartheta_3(q) raised to the k-th power, i.e.` \vartheta_3^k(q) = \left( \sum_{i=-\infty}^{\infty} q^{i^2} \right)^k./Flint2arith_sum_of_squares r k n Sets r to the number of ways r_k(n) in which n! can be represented as a sum of k squares.If k = 2 or k = 4 , we write r_k(n) as a divisor sum. Otherwise, we either recurse on k0 or compute the theta function expansion up to  O(x^{n+1})? and read off the last coefficient. This is generally optimal./Flint2arith_number_of_partitions_mpfr x n 'Sets the pre-initialised MPFR variable x to the exact value of p(n). The value is computed using the Hardy-Ramanujan-Rademacher formula.The precision of x will be changed to allow p(n) to be represented exactly. The interface of this function may be updated in the future to allow computing an approximation of p(n) to smaller precision.The Hardy-Ramanujan-Rademacher formula is given with error bounds in  [Rademacher1937]. We evaluate it in the form` *p(n) = \sum_{k=1}^N B_k(n) U(C/k) + R(n,N)where` U(x) = \cosh(x) + \frac{\sinh(x)}{x}, \quad C = \frac{\pi}{6} \sqrt{24n-1} 2B_k(n) = \sqrt{\frac{3}{k}} \frac{4}{24n-1} A_k(n) and where A_k(n)7 is a certain exponential sum. The remainder satisfies` |R(n,N)| < \frac{44 \pi^2}{225 \sqrt{3}} N^{-1/2} + \frac{\pi \sqrt{2}}{75} \left(\frac{N}{n-1}\right)^{1/2} \sinh\left(\pi \sqrt{\frac{2}{3}} \frac{\sqrt{n}}{N} \right). We choose N such that |R(n,N)| < 0.25#, and a working precision at term k such that the absolute error of the term is expected to be less than 0.25 / N. We also use a summation variable with increased precision, essentially making additions exact. Thus the sum of errors adds up to less than 0.5, giving the correct value of p(n)' when rounding to the nearest integer.The remainder estimate at step k. provides an upper bound for the size of the k-th term. We add \log_2 N* bits to get low bits in the terms below 0.25 / N in magnitude. -- -- Using arith_hrr_expsum_factored, each B_k(n) evaluation is broken -- down to a product of cosines of exact rational multiples of \pi!. We -- transform all angles to  (0, \pi/4) for optimal accuracy. -- -- Since the evaluation of each term involves only  O(\log k) -- multiplications and evaluations of trigonometric functions of small -- angles, the relative rounding error is at most a few bits. We therefore -- just add an additional  \log_2 (C/k) bits for the U(x) when x, -- is large. The cancellation of terms in U(x) is of no concern, since -- Rademacher's bound allows us to terminate before x becomes small. -- -- This analysis should be performed in more detail to give a rigorous -- error bound, but the precision currently implemented is almost certainly -- sufficient, not least considering that Rademacher's remainder bound -- significantly overshoots the actual values. -- -- To improve performance, we switch to doubles when the working precision -- becomes small enough. We also use a separate accumulator variable which -- gets added to the main sum periodically, in order to avoid costly -- updates of the full-precision result when n is large. foreign import ccall "arith.h arith_number_of_partitions_mpfr" arith_number_of_partitions_mpfr :: Ptr CMpfr -> CULong -> IO ()arith_number_of_partitions x n Sets x to p(n), the number of ways that n can be written as a sum of positive integers without regard to order.&This function uses a lookup table for n < 128 (where  p(n) < 2^{32}), and otherwise calls arith_number_of_partitions_mpfr./Flint2arith_hrr_expsum_factored prod k n *Symbolically evaluates the exponential sum` A_k(n) = \sum_{h=0}^{k-1} \exp\left(\pi i \left[ s(h,k) - \frac{2hn}{k}\right]\right);appearing in the Hardy-Ramanujan-Rademacher formula, where s(h,k) is a Dedekind sum.2Rather than evaluating the sum naively, we factor A_k(n) into a product of cosines based on the prime factorisation of k4. This process is based on the identities given in  [Whiteman1956]. The special  trig_prod_t structure prod represents a product of cosines of rational arguments, multiplied by an algebraic prefactor. It must be pre-initialised with trig_prod_init.This function assumes that 24k and 24n$ do not overflow a single limb. If n) is larger, it can be pre-reduced modulo k , since A_k(n) only depends on the value of  n \bmod k./Flint2#arith_number_of_partitions_nmod_vec res len mod Computes first len" values of the partition function p(n) starting with p(0) , modulo the modulus defined by mod/. Uses inversion of Euler's pentagonal series./Flint2arith_number_of_partitions_vec res len Computes first len" values of the partition function p(n) starting with p(0).. Uses inversion of Euler's pentagonal series./Flint2arith_landau_function_vec res len Computes the first len values of Landau's function g(n) starting with g(0). Landau's function gives the largest order of an element of the symmetric group S_n.+Implements the "basic algorithm" given in  [DelegliseNicolasZimmermann2009]. The running time is O(n^{3/2} / \sqrt{\log n})./Flint2arith_ramanujan_tau_series res n Sets res& to the polynomial with coefficients "\tau(0),\tau(1), \dotsc, \tau(n-1), giving the initial n$ terms in the series expansion of 0f(q) = q \prod_{k \geq 1} \bigl(1-q^k\bigr)^{24}."We use the theta function identity` f(q) = q \Biggl( \sum_{k \geq 0} (-1)^k (2k+1) q^{k(k+1)/2} \Biggr)^8which is evaluated using three squarings. The first squaring is done directly since the polynomial is very sparse at this point./Flint2arith_ramanujan_tau res n Sets res to the Ramanujan tau function \tau(n) which is the coefficient of q^n in the series expansion of 3f(q) = q \prod_{k \geq 1} \bigl(1 - q^k\bigr)^{24}. We factor n and use the identity \tau(pq) = \tau(p) \tau(q) along with the recursion 8\tau(p^{r+1}) = \tau(p) \tau(p^r) - p^{11} \tau(p^{r-1}) for prime powers.The base values \tau(p)" are obtained using the function arith_ramanujan_tau_series(). Thus the speed of arith_ramanujan_tau()( depends on the largest prime factor of n.5Future improvement: optimise this function for small n, which could be accomplished using a lookup table or by calling arith_ramanujan_tau_series() directly./Flint2arith_divisors res n 'Set the coefficients of the polynomial res to the divisors of n , including 1 and n itself, in ascending order./Flint2arith_euler_polynomial poly n Sets poly to the Euler polynomial E_n(x). Uses the formula` E_n(x) = \frac{2}{n+1}\left(B_{n+1}(x) - 2^{n+1}B_{n+1}\left(\frac{x}{2}\right)\right),with the Bernoulli polynomial  B_{n+1}(x) evaluated once using bernoulli_polynomial and then rescaled./Flint2arith_euler_number_size n Returns b such that |E_n| < 2^{\lfloor b \rfloor}, using the inequality $|E_n| < \frac{2^{n+2} n!}{\pi^{n+1}} and n! \le (n+1)^{n+1} e^{-n}(. No special treatment is given to odd n . Accuracy is not guaranteed if  n > 10^{14}./Flint2arith_euler_number_vec res n Computes the Euler numbers E_0, E_1, \dotsc, E_{n-1} for n \geq 0 and stores the result in res , which must be an initialised fmpz vector of sufficient size.'This function evaluates the even-index E_k modulo several limb-size primes using the generating function and  nmod_poly arithmetic. A tight bound for the number of needed primes is computed using arith_euler_number_size, and the final integer values are recovered using balanced CRT reconstruction./Flint2arith_euler_number res n Sets res to the Euler number E_n. Currently calls _arith_euler_number_zeta.Warning: this function does not use proven precision bounds, and could return the wrong results for very large n. It is recommended to use the Euler number functions in Arb instead./Flint2%_arith_bernoulli_number_vec_multi_mod num den n Sets the elements of num and den0 to the reduced numerators and denominators of B_0, B_1, B_2, \ldots, B_{n-1}) inclusive. Uses the generating function` \frac{x^2}{\cosh(x)-1} = \sum_{k=0}^{\infty} \frac{(2-4k) B_{2k}}{(2k)!} x^{2k}9which is evaluated modulo several limb-size primes using  nmod_poly arithmetic to yield the numerators of the Bernoulli numbers after multiplication by the denominators and CRT reconstruction. This formula, given (incorrectly) in  [BuhlerCrandallSompolski1992], saves about half of the time compared to the usual generating function  x/(e^x-1) since the odd terms vanish./Flint2%_arith_bernoulli_number_vec_recursive num den n Sets the elements of num and den0 to the reduced numerators and denominators of B_0, B_1, B_2, \ldots, B_{n-1} inclusive.)The first few entries are computed using arith_bernoulli_number5, and then Ramanujan's recursive formula expressing B_m as a sum over B_k for k congruent to m modulo 6 is applied repeatedly.To avoid costly GCDs, the numerators are transformed internally to a common denominator and all operations are performed using integer arithmetic. This makes the algorithm fast for small n, say n < 1000. The common denominator is calculated directly as the primorial of n + 1.%[1]  $https://en.wikipedia.org/w/index.php+? % title=Bernoulli_number&oldid=405938876/Flint2arith_bernoulli_polynomial poly n Sets poly' to the Bernoulli polynomial of degree n, .B_n(x) = \sum_{k=0}^n \binom{n}{k} B_k x^{n-k} where B_k8 is a Bernoulli number. This function basically calls arith_bernoulli_number_vec1 and then rescales the coefficients efficiently./Flint2arith_bernoulli_number_size n Returns b such that |B_n| < 2^{\lfloor b \rfloor}, using the inequality |B_n| < \frac{4 n!}{(2\pi)^n} and n! \le (n+1)^{n+1} e^{-n}(. No special treatment is given to odd n . Accuracy is not guaranteed if  n > 10^{14}./Flint2arith_bernoulli_number_denom den n Sets den# to the reduced denominator of the n-th Bernoulli number B_n . For even n<, the denominator is computed as the product of all primes p for which p - 1 divides n; this property is a consequence of the von Staudt-Clausen theorem. For odd n, the denominator is trivial (den is set to 1 whenever B_n = 00). The initial sequence of values smaller than 2^{32}& are looked up directly from a table./Flint2arith_bernoulli_number_vec x n  Sets the x% to the vector of Bernoulli numbers B_0, B_1, B_2, \ldots, B_{n-1}, inclusive. This function is equivalent to _arith_bernoulli_number_vec' apart from the output being a single fmpq vector./Flint2_arith_bernoulli_number_vec num den n Sets the elements of num and den to the reduced numerators and denominators of the Bernoulli numbers B_0, B_1, B_2, \ldots, B_{n-1}= inclusive. This function automatically chooses between the  recursive, zeta and  multi_mod% algorithms according to the size of n./Flint2arith_bernoulli_number x n Sets x to the n7-th Bernoulli number. This function is equivalent to\ _arith_bernoulli_number' apart from the output being a single fmpq_t variable.Warning: this function does not use proven precision bounds, and could return the wrong results for very large n. It is recommended to use the Bernoulli number functions in Arb instead./Flint2_arith_bernoulli_number num den n Sets  (num, den)2 to the reduced numerator and denominator of the n-th Bernoulli number. As presently implemented, this function simply calls\ _arith_bernoulli_number_zeta./Flint2arith_bell_number_size n Returns b such that B_n < 2^{\lfloor b \rfloor}<. A previous version of this function used the inequality -B_n < \left(\frac{0.792n}{\log(n+1)}\right)^n which is given in  [BerTas2010]; we now use a slightly better bound based on an asymptotic expansion./Flint2arith_bell_number_nmod_vec b n mod Sets b to the vector of Bell numbers B_0, B_1, \ldots, B_{n-1}' inclusive modulo an integer given by mod.The  recursive version uses the O(n^2) triangular recurrence. The ogf version expands the ordinary generating function using binary splitting, which is  O(n \log^2 n).The series3 version uses the exponential generating function 4\sum_{k=0}^{\infty} \frac{B_n}{n!} x^n = \exp(e^x-1), running in  O(n \log n)!. This only works if division by n! is possible, and the function returns whether it is successful. All other versions support any modulus.The default version of this function selects an algorithm automatically./Flint2arith_bell_number_nmod n mod Computes the Bell number B_n modulo an integer given by mod.0After handling special cases, we use the formula` B_n = \sum_{k=0}^n \frac{(n-k)^n}{(n-k)!} \sum_{j=0}^k \frac{(-1)^j}{j!}.We arrange the operations in such a way that we only have to multiply (and not divide) in the main loop. As a further optimisation, we use sieving to reduce the number of powers that need to be evaluated. This results in O(n) memory usage.If the divisions by factorials are impossible, we fall back to calling arith_bell_number_nmod_vec" and reading the last coefficient./Flint2arith_bell_number_vec b n Sets b to the vector of Bell numbers B_0, B_1, \ldots, B_{n-1} inclusive. The  recursive version uses the  O(n^3 \log n)# triangular recurrence, while the  multi_mod version implements multimodular evaluation of the exponential generating function, running in time O(n^2 \log^{O(1)} n):. The default version chooses an algorithm automatically./Flint2arith_bell_number b n Sets b to the Bell number B_n5, defined as the number of partitions of a set with n members. Equivalently, B_n = \sum_{k=0}^n S_2(n,k) where S_2(n,k)/ denotes a Stirling number of the second kind.The default version automatically selects between table lookup, Dobinski's formula, and the multimodular algorithm.The dobinski7 version evaluates a precise truncation of the series /B_n = e^{-1} \sum_{k=0}^{\infty} \frac{k^n}{k!}, (Dobinski's formula). In fact, we compute "P = N! \sum_{k=0}^N \frac{k^n}{k!} and -Q = N! \sum_{k=0}^N \frac{1}{k!} \approx N! e and evaluate B_n = \lceil P / Q \rceil1, avoiding the use of floating-point arithmetic.The  multi_mod version computes the result modulo several limb-size primes and reconstructs the integer value using the fast Chinese remainder algorithm. A bound for the number of needed primes is computed using arith_bell_number_size./Flint2arith_stirling_matrix_2 mat For an arbitrary m-by-n matrix, writes the truncation of the infinite Stirling number matrix: row 0 : S(0,0) row 1 : S(1,0), S(1,1) row 2 : S(2,0), S(2,1), S(2,2) row 3 : S(3,0), S(3,1), S(3,2), S(3,3) up to row m-1 and column n-1? inclusive. The upper triangular part of the matrix is zeroed.For any n, the S_1 and S_24 matrices thus obtained are inverses of each other./Flint2 arith_stirling_number_2_vec_next row prev n klen Given the vector prev' containing a row of Stirling numbers 0S(n-1,0), S(n-1,1), S(n-1,2), ..., S(n-1,klen-1)+, computes and stores in the row argument (S(n,0), S(n,1), S(n,2), ..., S(n,klen-1).If klen is greater than n, the output ends with  S(n,n) = 1 followed by S(n,n+1) = S(n,n+2) = ... = 05. In this case, the input only needs to have length n-1 ; only the input entries up to  S(n-1,n-2) are read.The row and prev arguments are permitted to be the same, meaning that the row will be updated in-place./Flint2arith_stirling_number_2_vec row n klen &Computes the row of Stirling numbers (S(n,0), S(n,1), S(n,2), ..., S(n,klen-1).8To compute a full row, this function can be called with  klen = n+1. It is assumed that klen is at most n + 1./Flint2arith_stirling_number_2 s n k Sets s to S(n,k) where S(n,k)8 denotes an unsigned Stirling number of the first kind  |S_1(n, k)|., a signed Stirling number of the first kind  S_1(n, k)+, or a Stirling number of the second kind  S_2(n, k). The Stirling numbers are defined using the generating functions` #x_{(n)} = \sum_{k=0}^n S_1(n,k) x^k %x^{(n)} = \sum_{k=0}^n |S_1(n,k)| x^k 'x^n = \sum_{k=0}^n S_2(n,k) x_{(k)}where $x_{(n)} = x(x-1)(x-2) \dotsm (x-n+1) is a falling factorial and $x^{(n)} = x(x+1)(x+2) \dotsm (x+n-1) is a rising factorial. S(n,k) is taken to be zero if n < 0 or k < 0.These three functions are useful for computing isolated Stirling numbers efficiently. To compute a range of numbers, the vector or matrix versions should generally be used./Flint2_arith_harmonic_number num den n 7These are aliases for the functions in the fmpq module.)/////////////////////////////////////////V Safe-Inferred )*1)/////////////////////////////////////////)///////////////////////////////////////// Safe-Inferred )*17/Flint2fmpq_mat_minpoly pol mat Set pol( to the minimal polynomial of the given  n\times n matrix. If mat' is not square, an exception is raised./Flint2_fmpq_mat_minpoly coeffs den mat Set  (coeffs, den)( to the minimal polynomial of the given  n\times n1 matrix and return the length of the polynomial./Flint2fmpq_mat_charpoly pol mat Set pol/ to the characteristic polynomial of the given  n\times n matrix. If mat' is not square, an exception is raised./Flint2_fmpq_mat_charpoly coeffs den mat Set  (coeffs, den)0 to the characteristic polynomial of the given  n\times n matrix./Flint2fmpq_mat_similarity A r d &Applies a similarity transform to the  n\times n matrix M in-place.If P is the  n\times n0 identity matrix the zero entries of whose row r# (0-indexed) have been replaced by d#, this transform is equivalent to  M = P^{-1}MP.Similarity transforms preserve the determinant, characteristic polynomial and minimal polynomial./Flint2 fmpq_mat_gso B A Takes a subset of  \mathbb{Q}^m S = \{a_1, a_2, \ldots ,a_n\} (as the columns of a  m \times n matrix A#) and generates an orthogonal set S' = \{b_1, b_2, \ldots ,b_n\} (as the columns of the  m \times n matrix B#) that spans the same subspace of  \mathbb{Q}^m as S./Flint2 fmpq_mat_rref B A Sets B$ to the reduced row echelon form of A and returns the rank. This function automatically chooses between the classical and fraction-free algorithms depending on the size of the matrix./Flint2fmpq_mat_rref_fraction_free B A Sets B$ to the reduced row echelon form of A and returns the rank. Clears denominators and performs fraction-free Gauss-Jordan elimination using fmpz_mat functions./Flint2fmpq_mat_rref_classical B A Sets B$ to the reduced row echelon form of A and returns the rank. Performs Gauss-Jordan elimination directly over the rational numbers. This algorithm is usually inefficient and is mainly intended to be used for testing purposes./Flint2fmpq_mat_pivot perm mat r c =Helper function for row reduction. Returns 1 if the entry of mat at row r and column c is nonzero. Otherwise searches for a nonzero entry in the same column among rows r+1, r+2, \ldots&. If a nonzero entry is found at row s , swaps rows r and s# and the corresponding entries in perm (unless NULL) and returns -1. If no nonzero pivot entry is found, leaves the inputs unchanged and returns 0./Flint2 fmpq_mat_inv B A Sets B to the inverse matrix of A' and returns nonzero. Returns zero if A is singular. A must be a square matrix./Flint2fmpq_mat_can_solve X A B Returns 1 if AX = B has a solution and if so, sets X to one such solution. The matrices can have any shape but must have the same number of rows./Flint2fmpq_mat_can_solve_dixon X A BReturns 1 if AX = B has a solution and if so, sets X to one such solution. The matrices can have any shape but must have the same number of rows./Flint2!fmpq_mat_can_solve_fmpz_mat_dixon X A B Returns if AX = B has a solution and if so, sets X to one such solution. The matrices can have any shape but must have the same number of rows. The input matrices must have integer entries and cannot be an empty matrix./Flint2 fmpq_mat_can_solve_fraction_free X A B Returns 1 if AX = B has a solution and if so, sets X to one such solution. The matrices can have any shape but must have the same number of rows./Flint2fmpq_mat_can_solve_multi_mod X A B Returns 1 if AX = B has a solution and if so, sets X to one such solution. The matrices can have any shape but must have the same number of rows./Flint2fmpq_mat_solve_fmpz_mat X A B Solves AX = B for nonsingular A, where A and B+ are integer matrices. Returns nonzero if A is nonsingular or if the right hand side is empty, and zero otherwise./Flint2!fmpq_mat_solve_fmpz_mat_multi_mod X A B /Flint2fmpq_mat_solve_fmpz_mat_dixon X A B /Flint2%fmpq_mat_solve_fmpz_mat_fraction_free X A B /Flint2fmpq_mat_solve X A B Solves AX = B for nonsingular A. Returns nonzero if A is nonsingular or if the right hand side is empty, and zero otherwise.All algorithms clear denominators to obtain a rescaled system over the integers. The  fraction_free5 algorithm uses FFLU solving over the integers. The dixon and  multi_mod algorithms use Dixon p-adic lifting or multimodular solving, followed by rational reconstruction with an adaptive stopping test. The dixon and  multi_mod= algorithms are generally the best choice for large systems.6The default method chooses an algorithm automatically./Flint2fmpq_mat_solve_multi_mod X A B /Flint2fmpq_mat_solve_dixon X A B /Flint2fmpq_mat_solve_fraction_free X A B /Flint2 fmpq_mat_det det mat Sets det to the determinant of mat. In the general case, the determinant is computed by clearing denominators and computing a determinant over the integers. Matrices of size 0, 1 or 2 are handled directly./Flint2fmpq_mat_trace trace mat Computes the trace of the matrix, i.e. the sum of the entries on the main diagonal. The matrix is required to be square./Flint2fmpq_mat_kronecker_product C A B Sets C to the Kronecker product of A and B./Flint2fmpq_mat_fmpq_vec_mul c a alen B #Compute a vector-matrix product of  (a, alen) and B and and store the result in c . The vector  (a, alen) is either truncated or zero-extended to the number of rows of B!. The number entries written to c- is always equal to the number of columns of B./Flint2fmpq_mat_mul_fmpq_vec c A b blen #Compute a matrix-vector product of A and  (b, blen) and store the result in c . The vector  (b, blen) is either truncated or zero-extended to the number of columns of A!. The number entries written to c* is always equal to the number of rows of A./Flint2fmpq_mat_mul_r_fmpz_mat C A B Sets C to the matrix product AB, with A an integer matrix. This function works efficiently by clearing denominators of B./Flint2fmpq_mat_mul_fmpz_mat C A B Sets C to the matrix product AB, with B an integer matrix. This function works efficiently by clearing denominators of A./Flint2 fmpq_mat_mul C A B Sets C to the matrix product AB. This simply calls fmpq_mat_mul_cleared./Flint2fmpq_mat_mul_cleared C A B Sets C to the matrix product AB, computed by clearing denominators and multiplying over the integers./Flint2fmpq_mat_mul_direct C A B Sets C to the matrix product AB, computed naively using rational arithmetic. This is typically very slow and should only be used in circumstances where clearing denominators would consume too much memory./Flint2fmpq_mat_set_fmpz_mat_mod_fmpz X Xmod mod Set X9 to the entrywise rational reconstruction integer matrix Xmod modulo mod, and returns nonzero if the reconstruction is successful. If rational reconstruction fails for any element, returns zero and sets the entries in X to undefined values./Flint2fmpq_mat_get_fmpz_mat_mod_fmpz dest mat mod Sets each entry in dest to the corresponding entry in mat, reduced modulo mod./Flint2fmpq_mat_set_fmpz_mat_div_fmpz mat num den Sets mat to the integer matrix num$ divided by the common denominator den./Flint2fmpq_mat_set_fmpz_mat dest src Sets dest to src./Flint2fmpq_mat_get_fmpz_mat_colwise num den mat Clears denominators in mat; column by column. The rescaled numerators are written to num , and the denominator of column i is written to position i in den which can be a preinitialised fmpz vector. Alternatively, NULL can be passed as the den> variable, in which case the denominators will not be stored./Flint2fmpq_mat_get_fmpz_mat_rowwise_2 num num2 den mat mat2 'Clears denominators row by row of both mat and mat2(, writing the respective numerators to num and num2'. This is equivalent to concatenating mat and mat2 horizontally, calling fmpq_mat_get_fmpz_mat_rowwise4, and extracting the two submatrices in the result./Flint2fmpq_mat_get_fmpz_mat_rowwise num den mat Clears denominators in mat5 row by row. The rescaled numerators are written to num, and the denominator of row i is written to position i in den which can be a preinitialised fmpz vector. Alternatively, NULL can be passed as the den> variable, in which case the denominators will not be stored./Flint2fmpq_mat_get_fmpz_mat_matwise num den mat Converts all entries in mat> to a common denominator, storing the rescaled numerators in num and the denominator in den5. The denominator will be minimal if the entries in mat are in canonical form./Flint2fmpq_mat_get_fmpz_mat_entrywise num den mat Sets the integer matrices num and den respectively to the numerators and denominators of the entries in mat./Flint2fmpq_mat_get_fmpz_mat dest mat Sets dest to mat' and returns nonzero if all entries in mat, are integer-valued. If not all entries in mat are integer-valued, sets dest to an undefined matrix and returns zero. Assumes that the entries in mat are in canonical form./Flint2fmpq_mat_is_square mat Returns a non-zero value if the number of rows is equal to the number of columns in mat, and otherwise returns zero./Flint2fmpq_mat_is_empty mat Returns a non-zero value if the number of rows or the number of columns in mat% is zero, and otherwise returns zero./Flint2fmpq_mat_is_one mat Returns nonzero if mat ones along the diagonal and zeros elsewhere, and returns zero otherwise./Flint2fmpq_mat_is_zero mat "Returns nonzero if all entries in mat' are zero, and returns zero otherwise./Flint2fmpq_mat_is_integral mat "Returns nonzero if all entries in mat are integer-valued, and returns zero otherwise. Assumes that the entries in mat are in canonical form./Flint2fmpq_mat_equal mat1 mat2 Returns nonzero if mat1 and mat2 have the same shape and all their entries agree, and returns zero otherwise. Assumes the entries in both mat1 and mat2 are in canonical form./Flint2fmpq_mat_hilbert_matrix mat Sets mat to a Hilbert matrix of the given size. That is, the entry at row i and column j is set to  1/(i+j+1)./Flint2fmpq_mat_concat_horizontal res mat1 mat2 Sets res! to horizontal concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  m \times k, res : m \times (n + k)./Flint2fmpq_mat_concat_vertical res mat1 mat2 Sets res to vertical concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  k \times n, res : (m + k) \times n./Flint2fmpq_mat_window_clear window Clears the matrix window and releases any memory that it uses. Note that the memory to the underlying matrix that window points to is not freed./Flint2fmpq_mat_window_init window mat r1 c1 r2 c2 Initializes the matrix window to be an r2 - r1 by c2 - c1 submatrix of mat whose (0,0) entry is the (r1, c1) entry of mat". The memory for the elements of window is shared with mat./Flint2fmpq_mat_randtest mat state bits This is equivalent to applying  fmpq_randtest to all entries in the matrix./Flint2fmpq_mat_randbits mat state bits This is equivalent to applying  fmpq_randbits to all entries in the matrix./Flint2fmpq_mat_fprint file mat Prints the matrix mat to the stream file./Flint2fmpq_mat_get_str mat Returns a string representation./Flint2fmpq_mat_scalar_div_fmpz rop op x Sets rop to op divided by the integer x, assuming that the two matrices have the same dimensions and that x is non-zero.Note that the integer x5 may not be aliased with any part of the entries of rop./Flint2fmpq_mat_scalar_mul_fmpz rop op x Sets rop to op multiplied by the integer x;, assuming that the two matrices have the same dimensions.Note that the integer x5 may not be aliased with any part of the entries of rop./Flint2fmpq_mat_scalar_mul_fmpq rop op x Sets rop to op multiplied by the rational x;, assuming that the two matrices have the same dimensions.Note that the rational x5 may not be aliased with any part of the entries of rop./Flint2 fmpq_mat_neg rop op Sets rop to the negative of op;, assuming that the two matrices have the same dimensions./Flint2 fmpq_mat_sub mat mat1 mat2 Sets mat to the difference of mat1 and mat2=, assuming that all three matrices have the same dimensions./Flint2 fmpq_mat_add mat mat1 mat2 Sets mat to the sum of mat1 and mat2=, assuming that all three matrices have the same dimensions./Flint2fmpq_mat_invert_cols mat perm Swaps columns i and c - i of mat for  0 <= i < c/2, where c is the number of columns of mat. If perm is non-NULL:, the permutation of the columns will also be applied to perm./Flint2fmpq_mat_invert_rows mat perm  Swaps rows i and r - i of mat for  0 <= i < r/2, where r is the number of rows of mat. If perm is non-NULL7, the permutation of the rows will also be applied to perm./Flint2fmpq_mat_swap_cols mat perm r s Swaps columns r and s of mat. If perm is non-NULL:, the permutation of the columns will also be applied to perm./Flint2fmpq_mat_swap_rows mat perm r s  Swaps rows r and s of mat. If perm is non-NULL7, the permutation of the rows will also be applied to perm./Flint2fmpq_mat_transpose rop op Sets the matrix rop to the transpose of the matrix op1, assuming that their dimensions are compatible./Flint2 fmpq_mat_one mat Let m be the minimum of the number of rows and columns in the matrix mat. This function sets the first  m \times m block to the identity matrix, and the remaining block to zero./Flint2 fmpq_mat_zero mat Sets mat to the zero matrix./Flint2 fmpq_mat_set dest src Sets the entries in dest to the same values as in src6, assuming the two matrices have the same dimensions./Flint2fmpq_mat_ncols mat +Return the number of columns of the matrix mat./Flint2fmpq_mat_nrows mat (Return the number of rows of the matrix mat./Flint2fmpq_mat_entry_den mat i j 9Gives a reference to the denominator of the entry at row i and column j. The reference can be passed as an input or output variable to any fmpz function for direct manipulation of the matrix element. No bounds checking is performed./Flint2fmpq_mat_entry_num mat i j 7Gives a reference to the numerator of the entry at row i and column j. The reference can be passed as an input or output variable to any fmpz function for direct manipulation of the matrix element. No bounds checking is performed./Flint2fmpq_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs./Flint2 fmpq_mat_swap mat1 mat2 &Swaps two matrices. The dimensions of mat1 and mat2 are allowed to be different.0Flint2fmpq_mat_clear mat Frees all memory associated with the matrix. The matrix must be reinitialised if it is to be used again.0Flint2fmpq_mat_init_set mat1 mat2  Initialises mat1 and sets it equal to mat2.0Flint2 fmpq_mat_init mat rows cols Initialises a matrix with the given number of rows and columns for use.0Flint2fmpq_mat_entry mat i j &Gives a reference to the entry at row i and column j. The reference can be passed as an input or output variable to any fmpq function for direct manipulation of the matrix element. No bounds checking is performed.0Flint2fmpq_mat_print mat Prints the matrix mat to standard output.///////////////////////////////////////////////////////////////////////////////////0000000000W Safe-Inferred )*18///////////////////////////////////////////////////////////////////////////////////0000000000////000000//0//00//////////////////0///////////////////////////////////////////////////////// Safe-Inferred )*1Va,0Flint2 padic_mat_mul C A B ctx Sets C to the product A B of the two matrices A and B, ensuring that C is reduced.0Flint2padic_mat_scalar_div_fmpz B A c ctx Sets B to c^{-1} A, assuming that c \neq 0. Ensures that the result B is reduced.0Flint2padic_mat_scalar_mul_fmpz B A c ctx Sets B to c A&, ensuring that the result is reduced.0Flint2_padic_mat_scalar_mul_fmpz B A c ctx Sets B to c A0, ensuring that the result is in canonical form.0Flint2padic_mat_scalar_mul_padic B A c ctx Sets B to c A&, ensuring that the result is reduced.0Flint2_padic_mat_scalar_mul_padic B A c ctx Sets B to c A0, ensuring that the result is in canonical form.0Flint2 padic_mat_neg B A ctx Sets B to -A!, ensuring the result is reduced.0Flint2_padic_mat_neg B A Sets B to -A in canonical form.0Flint2 padic_mat_sub C A B ctx Sets C to A - B&, ensuring that the result is reduced.0Flint2_padic_mat_sub C A B ctx Sets C to the exact difference A - B1, ensuring that the result is in canonical form.0Flint2 padic_mat_add C A B ctx Sets C to the sum A + B modulo p^N.0Flint2_padic_mat_add C A B ctx Sets C to the exact sum A + B1, ensuring that the result is in canonical form.0Flint2padic_mat_transpose B A Sets B to A^t.0Flint2padic_mat_randtest A state ctx Sets A to a random matrix.#The valuation will be in the range [- \lceil N/10\rceil, N),  - \lceil -N/10\rceil, N), or [-10, 0) as N is positive, negative or zero.0Flint2padic_mat_fprint_pretty file A ctx  Prints a pretty representation of the matrix A to the output stream file..In the current implementation, always returns 1.0Flint2padic_mat_fprint file A ctx -Prints a simple representation of the matrix A to the output stream file. The format is the number of rows, a space, the number of columns, two spaces, followed by a list of all the entries, one row after the other..In the current implementation, always returns 1.0Flint2padic_mat_is_zero A Returns whether the matrix A is zero.0Flint2padic_mat_equal A B !Returns whether the two matrices A and B are equal.0Flint2padic_mat_set_entry_padic rop i j op ctx Sets the entry in position (i, j) in the matrix to rop.0Flint2padic_mat_get_entry_padic rop op i j ctx Sets rop to the entry in position (i, j) in the matrix op.0Flint2padic_mat_get_fmpq_mat B A ctx Sets the rational matrix B to the p-adic matrices A; no reduction takes place.0Flint2padic_mat_set_fmpq_mat B A ctx  Sets the p -adic matrix B to the rational matrix A*, reduced according to the given context.0Flint2 padic_mat_one A Sets the matrix A to the identity matrix. If the precision is negative then the matrix will be the zero matrix.0Flint2padic_mat_zero A Sets the matrix A to zero.0Flint2padic_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.0Flint2padic_mat_swap A B Swaps the two matrices A and B1. This is done efficiently by swapping pointers.0Flint2 padic_mat_set B A Sets B to a copy of A, respecting the precision of B.0Flint2padic_mat_is_canonical A p Returns whether the matrix A is in canonical form.0Flint2padic_mat_is_square A Returns whether the matrix A is square.0Flint2padic_mat_is_empty A Returns whether the matrix A> is empty, that is, whether it has zero rows or zero columns.0Flint2padic_mat_reduce A ctx Ensures that the matrix A is reduced modulo p^N=, without assuming that it is necessarily in canonical form.0Flint2_padic_mat_reduce A ctx Ensures that the matrix A is reduced modulo p^N1, assuming that it is in canonical form already.0Flint2_padic_mat_canonicalise A ctx Ensures that the matrix A is in canonical form.0Flint2padic_mat_clear A Clears the matrix A.0Flint2padic_mat_init2 A r c prec Initialises the matrix A as a zero matrix with the specified numbers of rows and columns and the given precision.0Flint2padic_mat_init A r c Initialises the matrix A as a zero matrix with the specified numbers of rows and columns and precision PADIC_DEFAULT_PREC.0Flint2padic_mat_ncols A ,Returns the number of columns of the matrix A.0Flint2padic_mat_nrows A )Returns the number of rows of the matrix A.0Flint2padic_mat_get_prec A  Returns the p-adic precision of the matrix.0Flint2padic_mat_get_val A $Returns the valuation of the matrix.0Flint2 padic_mat A Returns a pointer to the unit part of the matrix, which is a matrix over  \mathbf{Z}.The return value can be used as an argument to the functions in the fmpz_mat module.0Flint2padic_mat_entry A i j 8Returns a pointer to unit part of the entry in position (i, j),. Note that this is not necessarily a unit.The return value can be used as an argument to the functions in the fmpz module.0Flint2padic_mat_print file A ctx -Prints a simple representation of the matrix A to stdout. The format is the number of rows, a space, the number of columns, two spaces, followed by a list of all the entries, one row after the other..In the current implementation, always returns 1.0Flint2padic_mat_print_pretty file A ctx  Prints a pretty representation of the matrix A to stdout..In the current implementation, always returns 1.40000000000000000000000000000000000000000000000000000X Safe-Inferred )*1W 4000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000 Safe-Inferred )*1蝡0Flint2_qqbar_acb_lindep rel vec len check prec #Attempts to find an integer vector rel giving a linear relation between the elements of the real or complex vector vec, using the LLL algorithm./The working precision is set to the minimum of prec and the relative accuracy of vec (that is, the difference between the largest magnitude and the largest error magnitude within vec). 95% of the bits within the working precision are used for the LLL matrix, and the remaining 5% bits are used to validate the linear relation by evaluating the linear combination and checking that the resulting interval contains zero. This validation does not prove the existence or nonexistence of a linear relation, but it provides a quick heuristic way to eliminate spurious relations.If check is set, the return value indicates whether the validation was successful; otherwise, the return value simply indicates whether the algorithm was executed normally (failure may occur, for example, if the input vector is non-finite).In principle, this method can be used to produce a proof that no linear relation exists with coefficients up to a specified bit size, but this has not yet been implemented.0Flint2qqbar_enclosure_raw res x prec Sets res to an enclosure of x accurate to about prec> bits (the actual accuracy can be slightly lower, or higher).This function uses repeated interval Newton steps to polish the initial enclosure z, doubling the working precision each time. If any step fails to improve the accuracy significantly, the root is recomputed from scratch to higher precision.-If the initial enclosure is accurate enough, res is set to this value without rounding and without further computation.0Flint2_qqbar_enclosure_raw res poly z prec 0Flint2$_qqbar_validate_existence_uniqueness res poly z max_prec Given any complex interval z:, certifies that the enclosure contains a unique root of poly, and in that case sets res to a new (possibly improved) enclosure for the same root, returning 1. Returns 0 if existence and uniqueness cannot be certified.The enclosure is validated by performing a single step with the interval Newton method. The working precision is determined from the accuracy of z, but limited by max_prec bits.0Flint2_qqbar_validate_uniqueness res poly z max_prec Given z2 known to be an enclosure of at least one root of poly, certifies that the enclosure contains a unique root, and in that case sets res to a new (possibly improved) enclosure for the same root, returning 1. Returns 0 if uniqueness cannot be certified.The enclosure is validated by performing a single step with the interval Newton method. The working precision is determined from the accuracy of z, but limited by max_prec bits.,This method slightly inflates the enclosure z to improve the chances that the interval Newton step will succeed. Uniqueness on this larger interval implies uniqueness of the original interval, but not existence; when existence has not been ensured a priori, $_qqbar_validate_existence_uniqueness should be used instead.0Flint2qqbar_binary_op res x y op Performs a binary operation using a generic algorithm. This does not check for special cases.0Flint2qqbar_fmpz_poly_composed_op res A B op Given nonconstant polynomials A and B, sets res" to a polynomial whose roots are a+b, a-b, ab or a/b for all roots a of A and all roots b of B. The parameter op selects the arithmetic operation: 0 for addition, 1 for subtraction, 2 for multiplication and 3 for division. If op is 3, B must not have zero as a root.0Flint2qqbar_get_fexpr_formula res x flags )Attempts to express the algebraic number x as a closed-form expression using arithmetic operations, radicals, and possibly exponentials or trigonometric functions, but without using PolynomialRootNearest or PolynomialRootIndexed(. Returns 0 on failure and 1 on success.The flags parameter toggles different methods for generating formulas. It can be set to any combination of the following. If flags. is 0, only rational numbers will be handled.QQBAR_FORMULA_ALL,Toggles all methods (potentially expensive).QQBAR_FORMULA_GAUSSIANS!Detect Gaussian rational numbers a + bi.QQBAR_FORMULA_QUADRATICSSolve quadratics in the form a + b \sqrt{d}.QQBAR_FORMULA_CYCLOTOMICSDetect elements of cyclotomic fields. This works by trying plausible cyclotomic fields (based on the degree of the input), using LLL to find candidate number field elements, and certifying candidates through an exact computation. Detection is heuristic and is not guaranteed to find all cyclotomic numbers.QQBAR_FORMULA_CUBICS QQBAR_FORMULA_QUARTICS QQBAR_FORMULA_QUINTICSSolve polynomials of degree 3, 4 and (where applicable) 5 using cubic, quartic and quintic formulas (not yet implemented).QQBAR_FORMULA_DEPRESSION2Use depression to try to generate simpler numbers.QQBAR_FORMULA_DEFLATIONUse deflation to try to generate simpler numbers. This allows handling number of the form a^{1/n} where a$ can be represented in closed form.QQBAR_FORMULA_SEPARATIONTry separating real and imaginary parts or sign and magnitude of complex numbers. This allows handling numbers of the form a + bi or  m \cdot s (with m > 0, |s| = 1) where a and b or m and s can be represented in closed form. This is only attempted as a fallback after other methods fail: if an explicit Cartesian or magnitude-sign represented is desired, the user should manually separate the number into complex parts before calling qqbar_get_fexpr_formula.QQBAR_FORMULA_EXP_FORM QQBAR_FORMULA_TRIG_FORM QQBAR_FORMULA_RADICAL_FORM QQBAR_FORMULA_AUTO_FORM/Select output form for cyclotomic numbers. The auto form (equivalent to no flags being set) results in radicals for numbers of low degree, trigonometric functions for real numbers, and complex exponentials for nonreal numbers. The other flags (not fully implemented) can be used to force exponential form, trigonometric form, or radical form.0Flint2qqbar_get_fexpr_root_indexed res x Sets res3 to a symbolic expression unambiguously describing x in the form *PolynomialRootIndexed(List(coeffs), index) where index is the index of x among its conjugate roots in the builtin root sort order. The output can be converted back to a qqbar_t value using qqbar_set_fexpr. This is a useful format for human-readable presentation when the numerical value is important, but serialization and deserialization can be expensive.0Flint2qqbar_get_fexpr_root_nearest res x Sets res3 to a symbolic expression unambiguously describing x in the form *PolynomialRootNearest(List(coeffs), point) where point is an approximation of x guaranteed to be closer to x than any conjugate root. The output can be converted back to a qqbar_t value using qqbar_set_fexpr. This is a useful format for human-readable presentation, but serialization and deserialization can be expensive.0Flint2qqbar_get_fexpr_repr res x Sets res to a symbolic expression reflecting the exact internal representation of x!. The output will have the form 2AlgebraicNumberSerialized(List(coeffs), enclosure)). The output can be converted back to a qqbar_t value using qqbar_set_fexpr. This is the recommended format for serializing algebraic numbers as it requires minimal computation, but it has the disadvantage of not being human-readable.0Flint2qqbar_set_fexpr res expr Sets res to the algebraic number represented by the symbolic expression expr*, returning 1 on success and 0 on failure.3This function performs a "static" evaluation using qqbar arithmetic, supporting only closed-form expressions with explicitly algebraic subexpressions. It can be used to recover values generated by qqbar_get_expr_formula and variants. For evaluating more complex expressions involving other types of values or requiring symbolic simplifications, the user should preprocess expr1 so that it is in a form which can be parsed by qqbar_set_fexpr.(The following expressions are supported: Integer constants-Arithmetic operations with algebraic operands!Square roots of algebraic numbersPowers with algebraic base and exponent an explicit rational number!NumberI, GoldenRatio, RootOfUnity9Floor, Ceil, Abs, Sign, Csgn, Conjugate, Re, Im, Max, MinTrigonometric functions with argument an explicit rational number times PiExponentials with argument an explicit rational number times Pi * NumberIThe Decimal() constructorAlgebraicNumberSerialized() (assuming valid data, which is not checked)PolynomialRootIndexed()PolynomialRootNearest()Examples of formulas that are not supported, despite the value being an algebraic number:Pi - Pi; (general transcendental simplifications are not performed) 1 / Infinity (only numbers are handled)Sum(n, For(n, 1, 10))& (only static evaluation is performed)0Flint2qqbar_get_quadratic a b c q x  factoring Assuming that x& has degree 1 or 2, computes integers a, b, c and q such that` x = \frac{a + b \sqrt{c}}{q}and such that c is not a perfect square, q is positive, and q% has no content in common with both a and b5. In other words, this determines a quadratic field \mathbb{Q}(\sqrt{c}) containing x5, and then finds the canonical reduced coefficients a, b and q expressing x in this field. For convenience, this function supports rational x , for which b and c will both be set to zero. The following remarks apply to irrationals. The radicand c will not be a perfect square, but will not automatically be squarefree since this would require factoring the discriminant. As a special case, c will be set to -1 if x is a Gaussian rational number. Otherwise, behavior is controlled by the  factoring parameter.If  factoring is 0, no factorization is performed apart from removing powers of two.If  factoring. is 1, a complete factorization is performed (c will be minimal). This can be very expensive if the discriminant is large.If  factoring is 2, a smooth factorization is performed to remove small factors from c. This is a tradeoff that provides pretty output in most cases while avoiding extreme worst-case slowdown. The smooth factorization guarantees finding all small factors (up to some trial division limit determined internally by Flint), but large factors are only found heuristically.0Flint2qqbar_express_in_field res alpha x max_bits flags prec Attempts to express x" in the number field generated by alpha+, returning success (0 or 1). On success, res is set to a polynomial f$ of degree less than the degree of alpha and with height (counting both the numerator and the denominator, when the coefficients of g. are put on a common denominator) bounded by max_bits bits, such that  f(\alpha) = x.(Exception: the max_bits# parameter is currently ignored if x is rational, in which case res is just set to the value of x.)This function looks for a linear relation heuristically using a working precision of prec bits. If x is expressible in terms of alpha4, then this function is guaranteed to succeed when prec& is taken large enough. The identity  f(\alpha) = x is checked rigorously, i.e. a return value of 1 implies a proof of correctness. In principle, choosing a sufficiently large prec can be used to prove that x) does not lie in the field generated by alpha, but the present implementation does not support doing so automatically.4This function does a single iteration at the target max_bits and and prec. For best performance, one should invoke this function repeatedly with successively larger parameters when the size of the intended solution is unknown or may be much smaller than a worst-case bound.0Flint2 qqbar_guess res z max_deg max_bits flags prec %Attempts to find an algebraic number res of degree at most max_deg and height at most max_bits' bits matching the numerical enclosure z. The return flag indicates success. This is only a heuristic method, and the return flag neither implies a rigorous proof that res is the correct result, nor a rigorous proof that no suitable algebraic number with the given max_deg and max_bits exists. (Proof of nonexistence could in principle be computed, but this is not yet implemented.)The working precision prec? should normally be the same as the precision used to compute z. It does not make much sense to run this algorithm with precision smaller than O(max_deg  max_bits).4This function does a single iteration at the target max_deg, max_bits, and prec. For best performance, one should invoke this function repeatedly with successively larger parameters when the size of the intended solution is unknown or may be much smaller than a worst-case bound.0Flint2 qqbar_acsc_pi p q x If  y = \operatorname{acsc}(x) / \pi5 is algebraic, and hence necessarily rational, sets  y = p / q$ to the reduced such fraction with $-\tfrac{1}{2} \le y \le \tfrac{1}{2} and returns 1. If y is not algebraic, returns 0.0Flint2 qqbar_asec_pi p q x If  y = \operatorname{asec}(x) / \pi5 is algebraic, and hence necessarily rational, sets  y = p / q$ to the reduced such fraction with  0 \le y \le 1 and returns 1. If y is not algebraic, returns 0.0Flint2 qqbar_acot_pi p q x If  y = \operatorname{acot}(x) / \pi5 is algebraic, and hence necessarily rational, sets  y = p / q$ to the reduced such fraction with "-\tfrac{1}{2} < y \le \tfrac{1}{2} and returns 1. If y is not algebraic, returns 0.0Flint2 qqbar_acos_pi p q x If  y = \operatorname{acos}(x) / \pi5 is algebraic, and hence necessarily rational, sets  y = p / q$ to the reduced such fraction with  0 \le y \le 1 and returns 1. If y is not algebraic, returns 0.0Flint2 qqbar_asin_pi p q x If  y = \operatorname{asin}(x) / \pi5 is algebraic, and hence necessarily rational, sets  y = p / q$ to the reduced such fraction with |y| \le \tfrac{1}{2} and returns 1. If y is not algebraic, returns 0.0Flint2 qqbar_atan_pi p q x If  y = \operatorname{atan}(x) / \pi5 is algebraic, and hence necessarily rational, sets  y = p / q$ to the reduced such fraction with |y| < \tfrac{1}{2} and returns 1. If y is not algebraic, returns 0.0Flint2qqbar_log_pi_i p q x If #y = \operatorname{log}(x) / (\pi i)5 is algebraic, and hence necessarily rational, sets  y = p / q$ to the reduced such fraction with  -1 < y \le 1 and returns 1. If y is not algebraic, returns 0.0Flint2 qqbar_csc_pi res p q Sets res to the trigonometric function  \cos(\pi x),  \sin(\pi x) , etc., with x = \tfrac{p}{q}. The functions tan, cot, sec and csc return the flag 1 if the value exists, and return 0 if the evaluation point is a pole of the function.0Flint2 qqbar_sec_pi res p q 0Flint2 qqbar_cot_pi res p q 0Flint2 qqbar_tan_pi res p q 0Flint2 qqbar_sin_pi res p q 0Flint2 qqbar_cos_pi res p q 0Flint2qqbar_exp_pi_i res p q Sets res to the root of unity e^{\pi i p / q}.0Flint2qqbar_is_root_of_unity p q x If x' is not a root of unity, returns 0. If x$ is a root of unity, returns 1. If p and q are not NULL and x% is a root of unity, this also sets p and q to the minimal integers with  0 \le p < q such that x = e^{2 \pi i p / q}.0Flint2qqbar_root_of_unity res p q Sets res to the root of unity e^{2 \pi i p / q}.0Flint2qqbar_eigenvalues_fmpq_mat res mat flags Sets the entries of the vector res* to the eigenvalues of the square matrix mat<. These functions compute the characteristic polynomial of mat and then call qqbar_roots_fmpz_poly with the same flags.0Flint2qqbar_eigenvalues_fmpz_mat res mat flags 0Flint2qqbar_roots_fmpq_poly res poly flags Sets the entries of the vector res to the d roots of the polynomial poly. Roots with multiplicity appear with repetition in the output array. By default, the roots will be sorted in a convenient canonical order (as defined by qqbar_cmp_root_order=). Instances of a repeated root always appear consecutively.The following flags are supported:"QQBAR_ROOTS_IRREDUCIBLE - if set, poly is assumed to be irreducible (it may still have constant content), and no polynomial factorization is performed internally.QQBAR_ROOTS_UNSORTED - if set, the roots will not be guaranteed to be sorted (except for repeated roots being listed consecutively).0Flint2qqbar_roots_fmpz_poly res poly flags 0Flint2qqbar_evaluate_fmpz_mpoly res poly x  deg_limit  bits_limit ctx Sets res to the value of poly9 evaluated at the algebraic numbers given in the vector x<. The number of variables is defined by the context object ctx.The parameters  deg_limit and  bits_limit define evaluation limits: if any temporary result exceeds these limits (not necessarily the final value, in case of cancellation), the evaluation is aborted and 0 (failure) is returned. If evaluation succeeds, 1 is returned.The iter version iterates over all terms in succession and computes the powers that appear. The horner version uses a multivariate implementation of the Horner scheme. The default algorithm currently uses the Horner scheme.0Flint2 qqbar_evaluate_fmpz_mpoly_horner res poly x  deg_limit  bits_limit ctx 0Flint2qqbar_evaluate_fmpz_mpoly_iter res poly x  deg_limit  bits_limit ctx 0Flint2qqbar_evaluate_fmpz_poly res poly x Sets res& to the value of the given polynomial poly$ evaluated at the algebraic number x. These methods detect simple special cases and automatically reduce poly if its degree is greater or equal to that of the minimal polynomial of x. In the generic case, evaluation is done by computing minimal polynomials of representation matrices.0Flint2_qqbar_evaluate_fmpz_poly res poly len x 0Flint2qqbar_evaluate_fmpq_poly res poly x 0Flint2_qqbar_evaluate_fmpq_poly res poly den len x 0Flint2qqbar_conjugates res x Sets the entries of the vector res to the d algebraic conjugates of x , including x itself, where d is the degree of x<. The output is sorted in a canonical order (as defined by qqbar_cmp_root_order).0Flint2qqbar_numerator res y Sets res to the numerator of y, i.e. y multiplied by its denominator.0Flint2qqbar_denominator res y Sets res to the denominator of y=, i.e. the leading coefficient of the minimal polynomial of y.0Flint2qqbar_cache_enclosure res prec #Polishes the internal enclosure of res to at least prec( bits of precision in-place. Normally, qqbar operations that need high-precision enclosures compute them on the fly without caching the results; if res will be used as an invariant operand for many operations, calling this function as a precomputation step can improve performance.0Flint2qqbar_get_arb_im res x prec Sets res* to an enclosure of the imaginary part of x rounded to prec bits.0Flint2qqbar_get_arb_re res x prec Sets res% to an enclosure of the real part of x rounded to prec bits.0Flint2 qqbar_get_arb res x prec Sets res to an enclosure of x rounded to prec bits, assuming that x is a real number. If x is not real, res is set to [\operatorname{NaN} \pm \infty].0Flint2 qqbar_get_acb res x prec Sets res to an enclosure of x rounded to prec bits.0Flint2 qqbar_pow res x y General exponentiation: if x^y is an algebraic number, sets res" to this value and returns 1. If x^y is transcendental or undefined, returns 0. Note that this function returns 0 instead of aborting on division zero.0Flint2qqbar_fmpq_pow_si_ui res x m n Sets res to the principal branch of x^{m/n} . The order n+ must be positive. Division by zero calls  flint_abort.0Flint2qqbar_fmpq_root_ui res x n Sets res to the principal n -th root of x . The order n must be positive.0Flint2 qqbar_root_ui res x n 0Flint2qqbar_pow_fmpq res x n Sets res to x raised to the n4-th power. Raising zero to a negative power aborts.0Flint2qqbar_pow_fmpz res x n 0Flint2 qqbar_pow_si res x n 0Flint2 qqbar_pow_ui res x n 0Flint2 qqbar_rsqrt res x Sets res3 to the reciprocal of the principal square root of x. Division by zero calls  flint_abort.0Flint2 qqbar_sqrt_ui res x Sets res! to the principal square root of x.0Flint2 qqbar_sqrt res x 0Flint2qqbar_scalar_op res x a b c Sets res' to the rational affine transformation (ax+b)/c, performed as a single operation. There are no restrictions on a, b and c except that c) must be nonzero. Division by zero calls  flint_abort.0Flint2 qqbar_si_div res x y Sets res to the quotient of x and y. Division by zero calls  flint_abort.1Flint2 qqbar_ui_div res x y 1Flint2qqbar_fmpz_div res x y 1Flint2qqbar_fmpq_div res x y 1Flint2 qqbar_div_si res x y 1Flint2 qqbar_div_ui res x y 1Flint2qqbar_div_fmpz res x y 1Flint2qqbar_div_fmpq res x y 1Flint2 qqbar_div res x y 1Flint2 qqbar_inv res x y Sets res" to the multiplicative inverse of y. Division by zero calls  flint_abort.1Flint2 qqbar_sqr res x Sets res to the square of x.1Flint2qqbar_mul_2exp_si res x e Sets res to x multiplied by 2^e.1Flint2 qqbar_mul_si res x y Sets res to the product of x and y.1Flint2 qqbar_mul_ui res x y 1Flint2qqbar_mul_fmpz res x y 1Flint2qqbar_mul_fmpq res x y 1Flint2 qqbar_mul res x y 1Flint2 qqbar_si_sub res x y Sets res to the difference of x and y.1Flint2 qqbar_ui_sub res x y 1Flint2qqbar_fmpz_sub res x y 1Flint2qqbar_fmpq_sub res x y 1Flint2 qqbar_sub_si res x y 1Flint2 qqbar_sub_ui res x y 1Flint2qqbar_sub_fmpz res x y 1Flint2qqbar_sub_fmpq res x y 1Flint2 qqbar_sub res x y 1Flint2 qqbar_add_si res x y Sets res to the sum of x and y.1Flint2 qqbar_add_ui res x y 1Flint2qqbar_add_fmpz res x y 1Flint2qqbar_add_fmpq res x y 1Flint2 qqbar_add res x y 1Flint2 qqbar_neg res x Sets res to the negation of x.1Flint2 qqbar_ceil res x Sets res to the ceiling function of x. If x is not real, the value is defined as the ceiling function of the real part of x.1Flint2 qqbar_floor res x Sets res to the floor function of x. If x is not real, the value is defined as the floor function of the real part of x.1Flint2 qqbar_csgn x Returns the extension of the real sign function taking the value 1 for x* strictly in the right half plane, -1 for x strictly in the left half plane, and the sign of the imaginary part when x+ is on the imaginary axis. Equivalently, '\operatorname{csgn}(x) = x / \sqrt{x^2}" except that the value is 0 when x is zero.1Flint2 qqbar_sgn_im x *Returns the sign of the imaginary part of x (-1, 0 or +1).1Flint2 qqbar_sgn_re x %Returns the sign of the real part of x (-1, 0 or +1).1Flint2 qqbar_sgn res x Sets res to the complex sign of x, defined as 0 if x is zero and as x / |x| otherwise.1Flint2 qqbar_abs2 res x Sets res( to the square of the absolute value of x.1Flint2 qqbar_abs res x Sets res to the absolute value of x:1Flint2 qqbar_re_im res1 res2 x Sets res1 to the real part of x and res2 to the imaginary part of x.1Flint2qqbar_im res x Sets res to the imaginary part of x.1Flint2qqbar_re res x Sets res to the real part of x.1Flint2 qqbar_conj res x Sets res to the complex conjugate of x.1Flint2 qqbar_hash x Returns a hash of x. As currently implemented, this function only hashes the minimal polynomial of x. The user should mix in some bits based on the numerical value if it is critical to distinguish between conjugates of the same minimal polynomial. This function is also likely to produce serial runs of values for lexicographically close minimal polynomials. This is not necessarily a problem for use in hash tables, but if it is important that all bits in the output are random, the user should apply an integer hash function to the output.1Flint2qqbar_cmp_root_order x y  Compares x and y using an arbitrary but convenient ordering defined on the complex numbers. This is useful for sorting the roots of a polynomial in a canonical order.We define the root order as follows: real roots come first, in descending order. Nonreal roots are subsequently ordered first by real part in descending order, then in ascending order by the absolute value of the imaginary part, and then in descending order of the sign. This implies that complex conjugate roots are adjacent, with the root in the upper half plane first.1Flint2 qqbar_cmpabs x y  Compares the absolute values of x and y, returning -1, 0 or +1.1Flint2qqbar_cmpabs_im x y 7Compares the absolute values of the imaginary parts of x and y, returning -1, 0 or +1.1Flint2qqbar_cmpabs_re x y 2Compares the absolute values of the real parts of x and y, returning -1, 0 or +1.1Flint2 qqbar_cmp_im x y  Compares the imaginary parts of x and y, returning -1, 0 or +1.1Flint2 qqbar_cmp_re x y Compares the real parts of x and y, returning -1, 0 or +1.1Flint2qqbar_equal_fmpq_poly_val x f y Returns whether x is equal to f(y)3. This function is more efficient than evaluating f(y) and comparing the results.1Flint2 qqbar_equal x y Returns whether x and y are equal.1Flint2qqbar_randtest_nonreal res state deg bits Sets res8 to a random nonreal algebraic number with degree up to deg+ and with height (measured in bits) up to bits5. Since all algebraic numbers of degree 1 are real, deg must be at least 2.1Flint2qqbar_randtest_real res state deg bits Sets res5 to a random real algebraic number with degree up to deg+ and with height (measured in bits) up to bits.1Flint2qqbar_randtest res state deg bits Sets res0 to a random algebraic number with degree up to deg+ and with height (measured in bits) up to bits.1Flint2 qqbar_phi res Sets res to the golden ratio $\varphi = \tfrac{1}{2}(\sqrt{5} + 1).1Flint2qqbar_i res Sets res to the imaginary unit i.1Flint2 qqbar_one res Sets res to the number 1.1Flint2 qqbar_zero res Sets res to the number 0.1Flint2qqbar_get_fmpz res x Sets res to x . Aborts if x is not an integer.1Flint2qqbar_get_fmpq res x Sets res to x . Aborts if x is not a rational number.1Flint2_qqbar_get_fmpq num den x Sets num and den% to the numerator and denominator of x . Aborts if x is not a rational number.1Flint2qqbar_binop_within_limits x y  deg_limit  bits_limit  Checks if x + y, x - y,  x \cdot y and x / y# certainly have degree bounded by  deg_limit! (by multiplying the degrees for x and y! to obtain a trivial bound). For  bits_limits!, the sum of the bit heights of x and y> is checked against the bound (this is only a heuristic). If  deg_limit> is set to 0, the degree check is skipped, and similarly for  bits_limit.1Flint2qqbar_within_limits x  deg_limit  bits_limit  Checks if x has degree bounded by  deg_limit and height bounded by  bits_limit+ bits, returning 0 (false) or 1 (true). If  deg_limit> is set to 0, the degree check is skipped, and similarly for  bits_limit.1Flint2qqbar_height_bits x Returns the height of x (the largest absolute value of the coefficients of the minimal polynomial of x) measured in bits.1Flint2 qqbar_height res x Sets res to the height of x (the largest absolute value of the coefficients of the minimal polynomial of x).1Flint2 qqbar_is_real x Returns whether x is a real number.1Flint2qqbar_is_neg_i x Returns whether x is the imaginary unit i (respectively -i).1Flint2 qqbar_is_i x 1Flint2qqbar_is_neg_one x Returns whether x is the number 0, 1, -1.1Flint2 qqbar_is_one x 1Flint2 qqbar_is_zero x 1Flint2qqbar_is_algebraic_integer x Returns whether x is an algebraic integer, i.e. whether its minimal polynomial has leading coefficient 1.1Flint2qqbar_is_integer x Returns whether x is an integer (an element of  \mathbb{Z}).1Flint2qqbar_is_rational x Returns whether x is a rational number.1Flint2 qqbar_degree x Returns the degree of x,, i.e. the degree of the minimal polynomial.1Flint2qqbar_set_re_im_d res x y Sets res to the value x or x + yi< respectively. These functions performs error handling: if x and y are finite, the conversion succeeds and the return flag is 1. If x or y is non-finite (infinity or NaN), the conversion fails and the return flag is 0.1Flint2 qqbar_set_d res x 1Flint2qqbar_set_re_im res x y Sets res to the value x + yi.1Flint2qqbar_set_fmpq res x Sets res to the value x.1Flint2qqbar_set_fmpz res x 1Flint2 qqbar_set_ui res x 1Flint2 qqbar_set_si res x 1Flint2 qqbar_set res x 1Flint2 qqbar_swap x y Swaps the values of x and y efficiently.1Flint2_qqbar_vec_clear vec len  Clears all len entries in the vector vec and frees the vector itself.1Flint2_qqbar_vec_init len !Returns a pointer to an array of len initialized  qqbar_struct:s.LFlint2 qqbar_clear res Clears the variable res,, freeing or recycling its allocated memory.LFlint2 qqbar_init res Initializes the variable res% for use, and sets its value to zero.1Flint2Create a QQbar.1Flint2Create a QQbar from Fmpz.1Flint2Create a QQbar from Fmpq.1Flint2Create a QQbar from Double.1Flint2 Use QQbar in f.1Flint2Apply f to new QQbar.1Flint2 qqbar_print x Prints res to standard output. The output shows the degree and the list of coefficients of the minimal polynomial followed by a decimal representation of the enclosing interval. This function is mainly intended for debugging.1Flint2 qqbar_printn x n Prints res to standard output. The output shows a decimal approximation to n digits.1Flint2 qqbar_printnd x n Prints res to standard output. The output shows a decimal approximation to n. digits, followed by the degree of the number.000000000000000000000000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111Y Safe-Inferred )*1,000000000000000000000000000000000000000000000000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000Z Safe-Inferred )*11111 Safe-Inferred )*1F1Flint2ca_field_cache_insert_ext cache x len ctx %Adds the field defined by the length-len list of extension numbers x to cache9 without duplication. If such a field already exists in cache, a pointer to that instance is returned. Otherwise, a field with extension numbers x is inserted into cache and a pointer to that new instance is returned. Upon insertion of a new field, the reduction ideal is constructed via ca_field_build_ideal.1Flint2ca_field_cache_clear cache ctx Clears cache, freeing the memory allocated internally. This does not clear the individual extension numbers, which are only held as references.1Flint2ca_field_cache_init cache ctx  Initializes cache for use.1Flint2 ca_field_cmp K1 K2 ctx Compares the field objects K1 and K2 in a canonical sort order, returning -1, 0 or 1. This only performs a lexicographic comparison of the representations of K1 and K2; the return value does not say anything meaningful about the relative structures of K1 and K2 as mathematical fields.1Flint2ca_field_build_ideal_erf K ctx Builds relations for error functions present among the extension numbers in K. This heuristic adds relations that are consequences of the functional equations /\operatorname{erf}(x) = -\operatorname{erf}(-x), 0\operatorname{erfc}(x) = 1-\operatorname{erf}(x), 1\operatorname{erfi}(x) = -i\operatorname{erf}(ix).1Flint2ca_field_build_ideal K ctx Given K with assigned extension numbers, builds the reduction ideal in-place.1Flint2ca_field_print K ctx "Prints a description of the field K to standard output.1Flint2ca_field_clear K ctx Clears the field K. This does not clear the individual extension numbers, which are only held as references.1Flint2ca_field_set_ext K i x_index ctx &Sets the extension number at position i (here indexed from 0) of K+ to the generator of the field with index x_index in ctx. (It is assumed that the generating field is a univariate field.):This only inserts a shallow reference: the field at index x_index must be kept alive until K has been cleared.1Flint2ca_field_init_multi K len ctx  Initializes K$ to represent a multivariate field \mathbb{Q}(a_1, \ldots, a_n) in n extension numbers. The extension numbers must subsequently be assigned one by one using ca_field_set_ext.1Flint2ca_field_init_fxy K func x y ctx  Initializes K to represent the field \mathbb{Q}(a,b) where  a = f(x, y).1Flint2ca_field_init_fx K func x ctx  Initializes K to represent the field  \mathbb{Q}(a) where a = f(x), given a number x$ and a builtin univariate function func (example: func = CA_Exp for e^x).1Flint2ca_field_init_const K func ctx  Initializes K to represent the field  \mathbb{Q}(x) where x# is a builtin constant defined by func (example: func = CA_Pi for x = \pi).1Flint2ca_field_init_nf K x ctx  Initializes K* to represent the algebraic number field  \mathbb{Q}(x).1Flint2ca_field_init_qq K ctx  Initializes K to represent the trivial field  \mathbb{Q}.111111111111111[ Safe-Inferred )*1111111111111111111111111111111 Safe-Inferred )*11Flint2 _ca_make_fmpq x ctx 'Changes the internal representation of x- to that of an element of the trivial field  \mathbb{Q} . This may destroy the value of x.1Flint2_ca_make_field_element x  new_index ctx 'Changes the internal representation of x0 to that of an element of the field with index  new_index in the context object ctx!. This may destroy the value of x.1Flint2 ca_factor res x flags ctx Sets res to a factorization of x of the form (x = b_1^{e_1} b_2^{e_2} \cdots b_n^{e_n}. Requires that x is not a special value. The type of factorization is controlled by flags, which can be set to a combination of constants in the following section.1Flint2ca_factor_get_ca res fac ctx Expands fac back to a single ca_t: by evaluating the powers and multiplying out the result.1Flint2ca_factor_insert fac base exp ctx Inserts b^e into fac where b is given by base and e is given by exp.. If a base element structurally identical to base already exists in fac/, the corresponding exponent is incremented by exp&; otherwise, this factor is appended.1Flint2ca_factor_print fac ctx Prints a description of fac to standard output.1Flint2 ca_factor_one fac ctx Sets fac9 to the empty factorization (equivalent to the number 1).1Flint2ca_factor_clear fac ctx #Clears the factorization structure fac.2Flint2ca_factor_init fac ctx  Initializes fac and sets it to the empty factorization (equivalent to the number 1).2Flint2ca_rewrite_complex_normal_form res x deep ctx Sets res to x rewritten using standardizing transformations over the complex numbers:Elementary functions are rewritten in terms of (complex) exponentials, roots and logarithmsComplex parts are rewritten using logarithms, square roots, and (deep) complex conjugatesAlgebraic numbers are rewritten in terms of cyclotomic fields where applicableIf deep is set, the rewriting is applied recursively to the tower of extension numbers; otherwise, the rewriting is only applied to the top-level extension numbers.The result is not a normal form in the strong sense (the same number can have many possible representations even after applying this transformation), but in practice this is a powerful heuristic for simplification.2Flint2ca_get_decimal_str x digits flags ctx #Returns a decimal approximation of x with precision up to digits. The output is guaranteed to be correct within 1 ulp in the returned digits, but the number of returned digits may be smaller than digits/ if the numerical evaluation does not succeed.If flags is set to 1, attempts to achieve full accuracy for both the real and imaginary parts separately.If x is not finite or a finite enclosure cannot be produced, returns the string "?"..The user should free the returned string with  flint_free.2Flint2ca_get_acb_accurate_parts res x prec ctx Sets res+ to an enclosure of the numerical value of x. The working precision is increased adaptively to try to ensure prec# accurate bits in the output. The accurate_parts version tries to ensure prec accurate bits for both the real and imaginary part separately.\operatorname{atan}(c \infty) = \operatorname{csgn}(c) \pi / 2=\operatorname{atan}(\tilde \infty) = \operatorname{Undefined}2Flint2ca_atan_direct res x ctx 2Flint2ca_atan_logarithm res x ctx 2Flint2ca_cot res x ctx Sets res to the cotangent x. This is equivalent to computing the reciprocal of the tangent.2Flint2ca_tan res x ctx Sets res to the tangent of x. The  sine_cosine version evaluates the tangent as a quotient of a sine and cosine, the direct version evaluates it directly as a tangent (possibly after transforming the variable), and the  exponential version evaluates it in terms of complex exponentials. Simple algebraic values will automatically simplify to elements of trigonometric or cyclotomic number fields.+By default, the standard function uses the  exponential representation as this typically works best for field arithmetic and simplifications, although it has the disadvantage of introducing complex numbers where real numbers would be sufficient. The behavior of the standard function can be changed using the CA_OPT_TRIG_FORM context setting.4For special values, the following definitions apply: At poles, *\tan((n+\tfrac{1}{2}) \pi) = \tilde \infty6\tan(e^{i \theta} \infty) = +i, \quad 0 < \theta < \pi7\tan(e^{i \theta} \infty) = -i, \quad -\pi < \theta < 0\tan(\pm \infty) = \tan(\tilde \infty) = \operatorname{Undefined}2Flint2 ca_tan_direct res x ctx 2Flint2ca_tan_exponential res x ctx 2Flint2ca_tan_sine_cosine res x ctx 2Flint2ca_cos res x ctx Sets res to the sine or cosine of x%. These functions are shortcuts for  ca_sin_cos.2Flint2ca_sin res x ctx 2Flint2 ca_sin_cos res1 res2 x ctx Sets res1 to the sine of x and res2 to the cosine of x . Either res1 or res2 can be NULL to compute only the other function. Various representations are implemented:The  exponential version expresses the sine and cosine in terms of complex exponentials. Simple algebraic values will simplify to rational numbers or elements of cyclotomic fields.The direct method expresses the sine and cosine in terms of the original functions (perhaps after applying some symmetry transformations, which may interchange sin and cos). Extremely simple algebraic values will automatically simplify to elements of real algebraic number fields.The tangent8 version expresses the sine and cosine in terms of  \tan(x/2), perhaps after applying some symmetry transformations. Extremely simple algebraic values will automatically simplify to elements of real algebraic number fields.+By default, the standard function uses the  exponential representation as this typically works best for field arithmetic and simplifications, although it has the disadvantage of introducing complex numbers where real numbers would be sufficient. The behavior of the standard function can be changed using the ca_opt_trigformM context setting.4For special values, the following definitions apply:!\sin(\pm i \infty) = \pm i \infty\cos(\pm i \infty) = +\inftyAll other infinities give \operatorname{Undefined}2Flint2ca_sin_cos_tangent res1 res2 x ctx 2Flint2ca_sin_cos_direct res1 res2 x ctx 2Flint2ca_sin_cos_exponential res1 res2 x ctx 2Flint2ca_log res x ctx Sets res to the natural logarithm of x.For special values and at the origin, the following definitions apply:For any infinity, -\log(c\infty) = \log(\tilde \infty) = +\infty.\log(0) = -\infty. The result is Unknown if deciding x = 0 fails.Both  Undefined and Unknown map to themselves.The following symbolic simplifications are performed automatically: \log(1) = 0$\log\left(e^z\right) = z + 2 \pi i k<\log\left(\sqrt{z}\right) = \tfrac{1}{2} \log(z) + 2 \pi i k,\log\left(z^a\right) = a \log(z) + 2 \pi i k\log(x) = \log(-x) + \pi i for negative real xIn the generic case, this function outputs an element of the formal field \mathbb{Q}(\log(x)).2Flint2ca_exp res x ctx Sets res to the exponential function of x.4For special values, the following definitions apply:e^{+\infty} = +\inftye^{c \infty} = \tilde \infty if 0 < \operatorname{Re}(c) < 1.e^{c \infty} = 0 if \operatorname{Re}(c) < 0.e^{c \infty} = \text{Undefined} if \operatorname{Re}(c) = 0.$e^{\tilde \infty} = \text{Undefined}.Both  Undefined and Unknown map to themselves.The following symbolic simplifications are performed automatically:e^0 = 1e^{\log(z)} = ze^{(p/q) \log(z)} = z^{p/q} (for rational p/q)e^{(p/q) \pi i}4 = algebraic root of unity (for small rational p/q)In the generic case, this function outputs an element of the formal field \mathbb{Q}(e^x).2Flint2ca_ceil res x ctx Sets res to the ceiling function of x. The result is  Undefined if x is any infinity (including a real infinity). For complex numbers, this is presently defined to take the ceiling of the real part.2Flint2ca_floor res x ctx Sets res to the floor function of x. The result is  Undefined if x is any infinity (including a real infinity). For complex numbers, this is presently defined to take the floor of the real part.2Flint2ca_conj res x ctx Sets res to the complex conjugate of x. The shallow* version creates a new extension element  \overline{x} unless x can be trivially conjugated in-place in the existing field. The deep version recursively conjugates the extension numbers in the field of x.2Flint2ca_conj_shallow res x ctx 2Flint2 ca_conj_deep res x ctx 2Flint2ca_im res x ctx Sets res to the imaginary part of x. The result is  Undefined if x3 is any infinity (including an imaginary infinity).2Flint2ca_re res x ctx Sets res to the real part of x. The result is  Undefined if x. is any infinity (including a real infinity).2Flint2ca_arg res x ctx Sets res$ to the complex argument (phase) of x, normalized to the range  (-\pi, +\pi]. The argument of 0 is defined as 0. For special values, the following definitions apply:4\operatorname{arg}(c \infty) = \operatorname{arg}(c).<\operatorname{arg}(\tilde \infty) = \operatorname{Undefined}.Both  Undefined and Unknown map to themselves.2Flint2ca_csgn res x ctx Sets res to the extension of the real sign function taking the value 1 for z* strictly in the right half plane, -1 for z strictly in the left half plane, and the sign of the imaginary part when z+ is on the imaginary axis. Equivalently, '\operatorname{csgn}(z) = z / \sqrt{z^2}" except that the value is 0 when z& is exactly zero. This function gives  Undefined for unsigned infinity and \operatorname{csgn}(\operatorname{sgn}(c \infty)) = \operatorname{csgn}(c) for signed infinities.2Flint2ca_sgn res x ctx Sets res to the sign of x , defined by` \begin{aligned} \operatorname{sgn}(x) = \begin{cases} 0 & x = 0 \\ \frac{x}{|x|} & x \ne 0 \end{cases} \end{aligned}for numbers. For special values, the following definitions apply: \operatorname{sgn}(c \infty) = c.<\operatorname{sgn}(\tilde \infty) = \operatorname{Undefined}.Both  Undefined and Unknown map to themselves.This function will attempt to simplify its argument through an exact computation. It may in particular attempt to simplify \operatorname{sgn}(x) to a single element in \overline{\mathbb{Q}}.In the generic case, this function outputs an element of the formal field !\mathbb{Q}(\operatorname{sgn}(x)).2Flint2ca_abs res x ctx Sets res to the absolute value of x.4For special values, the following definitions apply:&|c \infty| = |\tilde \infty| = +\infty.Both  Undefined and Unknown map to themselves.This function will attempt to simplify its argument through an exact computation. It may in particular attempt to simplify |x| to a single element in \overline{\mathbb{Q}}.In the generic case, this function outputs an element of the formal field \mathbb{Q}(|x|).2Flint2 ca_sqrt_ui res n ctx Sets res! to the principal square root of n.2Flint2ca_sqrt res x ctx Sets res! to the principal square root of x.4For special values, the following definitions apply:!\sqrt{c \infty} = \sqrt{c} \infty$\sqrt{\tilde \infty} = \tilde \infty.Both  Undefined and Unknown map to themselves.The inert4 version outputs the generator in the formal field \mathbb{Q}(\sqrt{x}) without simplifying.The factor version writes  x = A^2 B in K where K is the field of x, and outputs  A \sqrt{B} or  -A \sqrt{B}6 (whichever gives the correct sign) as an element of  K(\sqrt{B}) or some subfield thereof. This factorization is only a heuristic and is not guaranteed to make B: minimal. Factorization options can be passed through to flags: see  ca_factor for details.The nofactor version will not perform a general factorization, but may still perform other simplifications. It may in particular attempt to simplify \sqrt{x} to a single element in \overline{\mathbb{Q}}.2Flint2ca_sqrt_factor res x flags ctx 2Flint2ca_sqrt_nofactor res x ctx 2Flint2 ca_sqrt_inert res x ctx 2Flint2ca_pow_si_arithmetic res x n ctx Sets res to x raised to the power n . Whereas ca_pow,  ca_pow_si etc. may create x^n as an extension number if n is large, this function always perform the exponentiation using field arithmetic.2Flint2ca_pow res x y ctx Sets res to x raised to the power y5. Handling of special values is not yet implemented.2Flint2 ca_pow_si res x y ctx 2Flint2 ca_pow_ui res x y ctx 2Flint2 ca_pow_fmpz res x y ctx 2Flint2 ca_pow_fmpq res x y ctx 2Flint2ca_sqr res x ctx Sets res to the square of x.2Flint2ca_inv_no_division_by_zero res x ctx These functions behave like the normal arithmetic functions, but assume (and do not check) that division by zero cannot occur. Division by zero will result in undefined behavior.2Flint2,ca_fmpz_mpoly_q_evaluate_no_division_by_zero res f x mctx ctx 2Flint2ca_fmpz_mpoly_q_evaluate res f x mctx ctx Sets res' to the multivariate rational function f' evaluated at the vector of arguments x.2Flint2ca_fmpz_mpoly_evaluate res f x mctx ctx Sets res to the multivariate polynomial f' evaluated at the vector of arguments x.2Flint2ca_fmpz_mpoly_evaluate_horner res f x mctx ctx 2Flint2ca_fmpq_poly_evaluate res poly x ctx Sets res to the polynomial poly evaluated at x.2Flint2ca_fmpz_poly_evaluate res poly x ctx 2Flint2ca_dot res initial subtract x xstep y ystep len ctx (Computes the dot product of the vectors x and y , setting res to .s + (-1)^{subtract} \sum_{i=0}^{len-1} x_i y_i.The initial term s+ is optional and can be omitted by passing NULL (equivalently, s = 0). The parameter subtract must be 0 or 1. The length len is allowed to be negative, which is equivalent to a length of zero. The parameters xstep or ystep specify a step length for traversing subsequences of the vectors x and y; either can be negative to step in the reverse direction starting from the initial pointer. Aliasing is allowed between res and s but not between res and the entries of x and y.2Flint2ca_div res x y ctx Sets res to the quotient of x and y#. This is equivalent to computing x \cdot (1 / y). For special values and division by zero, this implies the following rules (c infty denotes a signed infinity, |c| = 1):(c \infty) / (d \infty) = (c \infty) / \tilde \infty = \tilde \infty / (c \infty) = \tilde \infty / \tilde \infty = \text{Undefined}1c \infty / z = (c / \operatorname{sgn}(z)) \infty if  z \in \mathbb{C} \setminus \{0\}0c \infty / 0 = \tilde \infty / 0 = \tilde \infty&z / (c \infty) = z / \tilde \infty = 0 if z \in \mathbb{C}z / 0 = \tilde \infty if  z \in \mathbb{C} \setminus \{0\}0 / 0 = \text{Undefined}'z / \text{Undefined} = \text{Undefined} for any value z (including Unknown)'\text{Undefined} / z = \text{Undefined} for any value z (including Unknown)In any other case involving special values, or if the specific case cannot be distinguished, the result is Unknown.2Flint2 ca_div_si res x y ctx 2Flint2 ca_div_ui res x y ctx 2Flint2 ca_div_fmpz res x y ctx 2Flint2 ca_div_fmpq res x y ctx 2Flint2 ca_si_div res x y ctx 2Flint2 ca_ui_div res x y ctx 2Flint2 ca_fmpz_div res x y ctx 2Flint2 ca_fmpq_div res x y ctx 2Flint2ca_inv res x ctx Sets res" to the multiplicative inverse of x. In a univariate algebraic number field, this always produces a rational denominator, but the denominator might not be rationalized in a multivariate field. For special values and zero, the following rules apply:&1 / (c \infty) = 1 / \tilde \infty = 01 / 0 = \tilde \infty'1 / \text{Undefined} = \text{Undefined}#1 / \text{Unknown} = \text{Unknown}#If it cannot be determined whether x$ is zero or nonzero, the result is Unknown.2Flint2ca_mul res x y ctx Sets res to the product of x and y. For special values, the following rules apply (c infty denotes a signed infinity, |c| = 1):$c \infty \cdot d \infty = c d \infty,c \infty \cdot \tilde \infty = \tilde \infty1\tilde \infty \cdot \tilde \infty = \tilde \infty1c \infty \cdot z = \operatorname{sgn}(z) c \infty if  z \in \mathbb{C} \setminus \{0\}#c \infty \cdot 0 = \text{Undefined}(\tilde \infty \cdot 0 = \text{Undefined},z \cdot \text{Undefined} = \text{Undefined} for any value z (including Unknown)In any other case involving special values, or if the specific case cannot be distinguished, the result is Unknown.2Flint2 ca_mul_si res x y ctx 2Flint2 ca_mul_ui res x y ctx 2Flint2 ca_mul_fmpz res x y ctx 2Flint2 ca_mul_fmpq res x y ctx 2Flint2ca_sub res x y ctx Sets res to the difference of x and y#. This is equivalent to computing x + (-y).2Flint2 ca_si_sub res x y ctx 2Flint2 ca_ui_sub res x y ctx 2Flint2 ca_fmpz_sub res x y ctx 2Flint2 ca_fmpq_sub res x y ctx 2Flint2 ca_sub_si res x y ctx 2Flint2 ca_sub_ui res x y ctx 2Flint2 ca_sub_fmpz res x y ctx 2Flint2 ca_sub_fmpq res x y ctx 2Flint2ca_add res x y ctx Sets res to the sum of x and y. For special values, the following rules apply (c infty denotes a signed infinity, |c| = 1):c \infty + d \infty = c \infty if c = d&c \infty + d \infty = \text{Undefined} if c \ne d\tilde \infty + c \infty = \tilde \infty + \tilde \infty = \text{Undefined}c \infty + z = c \infty if z \in \mathbb{C}!\tilde \infty + z = \tilde \infty if z \in \mathbb{C}'z + \text{Undefined} = \text{Undefined} for any value z (including Unknown)In any other case involving special values, or if the specific case cannot be distinguished, the result is Unknown.2Flint2 ca_add_si res x y ctx 2Flint2 ca_add_ui res x y ctx 2Flint2 ca_add_fmpz res x y ctx 2Flint2 ca_add_fmpq res x y ctx 2Flint2ca_neg res x ctx Sets res to the negation of x. For numbers, this operation amounts to a direct negation within the formal field. For a signed infinity c \infty, negation gives  (-c) \infty*; all other special values are unchanged.2Flint2ca_is_gen_as_ext x ctx If x& is a generator of its formal field, &x = a_k \in \mathbb{Q}(a_1,\ldots,a_n)6, returns a pointer to the extension number defining a_k. If x is not a generator, returns NULL.2Flint2ca_condense_field res ctx  Attempts to demote the value of res to a trivial subfield of its current field by removing unused generators. In particular, this demotes any obviously rational value to the trivial field  \mathbb{Q}.This function is applied automatically in most operations (arithmetic operations, etc.).2Flint2ca_merge_fields resx resy x y ctx Sets resx and resy to copies of x and y" coerced to a common field. Both x and y- must be field elements (not special values).In the present implementation, this simply merges the lists of generators, avoiding duplication. In the future, it will be able to eliminate generators satisfying algebraic relations.2Flint2 ca_check_ge x y ctx  Compares x and y), implementing the respective operations x < y, x \le y, x > y, x \ge y. Only real numbers and -\infty and +\infty* are considered comparable. The result is T_FALSE (not  T_UNKNOWN) if either operand is not comparable (being a nonreal complex number, unsigned infinity, or undefined).2Flint2 ca_check_gt x y ctx 2Flint2 ca_check_le x y ctx 2Flint2 ca_check_lt x y ctx 2Flint2ca_check_equal x y ctx Tests x = y+ as a mathematical equality. The result is  T_UNKNOWN if either operand is Unknown. The result may also be  T_UNKNOWN if x and y are numerically indistinguishable and cannot be proved equal or unequal by an exact computation.2Flint2ca_check_is_neg_i_inf x ctx  Tests if x! is equal to the signed infinity +\infty, -\infty,  +i \infty,  -i \infty, respectively.2Flint2ca_check_is_pos_i_inf x ctx 2Flint2ca_check_is_neg_inf x ctx 2Flint2ca_check_is_pos_inf x ctx 2Flint2ca_check_is_signed_inf x ctx  Tests if x is any signed infinity.2Flint2ca_check_is_uinf x ctx  Tests if x is unsigned infinity {\tilde \infty}.2Flint2ca_check_is_infinity x ctx  Tests if x& is any infinity (unsigned or signed).2Flint2ca_check_is_undefined x ctx  Tests if x is the special value  Undefined.2Flint2ca_check_is_imaginary x ctx  Tests if x/ is an imaginary number. Warning: this returns T_FALSE if x$ is an infinity with imaginary sign.2Flint2ca_check_is_negative_real x ctx  Tests if x2 is a negative real number. Warning: this returns T_FALSE if x is negative infinity.2Flint2ca_check_is_real x ctx  Tests if x) is a real number. Warning: this returns T_FALSE if x is an infinity with real sign.2Flint2ca_check_is_integer x ctx  Tests if x is respectively an algebraic number, a rational number, or an integer.2Flint2ca_check_is_rational x ctx 2Flint2ca_check_is_algebraic x ctx 2Flint2ca_check_is_neg_i x ctx  Tests if x is equal to the number 0, 1, -1, i, or -i.2Flint2 ca_check_is_i x ctx 2Flint2ca_check_is_neg_one x ctx 2Flint2ca_check_is_one x ctx 2Flint2ca_check_is_zero x ctx 2Flint2ca_check_is_number x ctx  Tests if x is a number. The result is T_TRUE is x3 is a field element (and hence a complex number), T_FALSE if x is an infinity or  Undefined, and  T_UNKNOWN if x is Unknown.2Flint2ca_is_generic_elem x ctx Returns whether x is represented as a generic field element; i.e. it is not a special value, not represented as an element of the rational field, and not represented as an element of a univariate algebraic number field.2Flint2ca_is_cyclotomic_nf_elem p q x ctx Returns whether x is represented as an element of a univariate cyclotomic field, i.e.  \mathbb{Q}(a) where a is a root of unity. If p and q are not NULL and x is represented as an element of a cyclotomic field, this also sets p and q to the minimal integers with  0 \le p < q, such that the generating root of unity is a = e^{2 \pi i p / q}.. Note that the answer 0 does not prove that x+ is not a cyclotomic number, and the order q/ is also not necessarily the generator of the smallest cyclotomic field containing x. For the purposes of this function, only nontrivial cyclotomic fields count; the return value is 0 if x& is represented as a rational number.2Flint2 ca_is_nf_elem x ctx Returns whether x is represented as an element of a univariate algebraic number field  \mathbb{Q}(a).2Flint2ca_is_qq_elem_integer x ctx Returns whether x is represented as the element 0, 1 or any integer in the rational field  \mathbb{Q}.2Flint2ca_is_qq_elem_one x ctx 2Flint2ca_is_qq_elem_zero x ctx 2Flint2 ca_is_qq_elem x ctx Returns whether x5 is represented as an element of the rational field  \mathbb{Q}.3Flint2 ca_is_special x ctx Returns whether x8 is a special value or metavalue (not a field element).3Flint2 ca_is_unknown x ctx Returns whether x is Unknown.3Flint2 ca_hash_repr x ctx Hashes the representation of x.3Flint2 ca_cmp_repr x y ctx  Compares the representations of x and y in a canonical sort order, returning -1, 0 or 1. This only performs a lexicographic comparison of the representations of x and y; the return value does not say anything meaningful about the numbers represented by x and y.3Flint2 ca_equal_repr x y ctx Returns whether x and y have identical representation. For field elements, this checks if x and y belong to the same formal field (with generators having identical representation) and are represented by the same rational function within that field.For special values, this tests equality of the special values, with Unknown handled as if it were a value rather than a meta-value: that is, Unknown = Unknown gives 1, and Unknown = y& gives 0 for any other kind of value y . If neither x nor y is Unknown-, then representation equality implies that x and y describe to the same mathematical value, but if either operand is Unknown9, the result is meaningless for mathematical comparison.3Flint2ca_randtest_same_nf res state x bits den_bits ctx Sets res1 to a random element in the same number field as x%, with numerator coefficients up to bits in size and denominator up to den_bits& in size. This function requires that x, is an element of an absolute number field.3Flint2ca_randtest_special res state depth bits ctx 6Randomly generates either a special value or a number.3Flint2 ca_randtest res state depth bits ctx Sets res to a random number generated by evaluating a random expression. The algorithm randomly selects between generating a "simple" number (a random rational number or quadratic field element with coefficients up to bits0 in size, or a random builtin constant), or if depth is nonzero, applying a random arithmetic operation or function to operands produced through recursive calls with depth - 1. The output is guaranteed to be a number, not a special value.3Flint2ca_randtest_rational res state bits ctx Sets res to a random rational number with numerator and denominator up to bits bits in size.3Flint2ca_can_evaluate_qqbar x ctx  Checks if  ca_get_qqbar has a chance to succeed. In effect, this checks if all extension numbers are manifestly algebraic numbers (without doing any evaluation).3Flint2 ca_get_qqbar res x ctx Attempts to evaluate x to an explicit integer, rational or algebraic number. If successful, sets res; to this number and returns 1. If unsuccessful, returns 0."The conversion certainly fails if x does not represent an integer, rational or algebraic number (respectively), but can also fail if x is too expensive to compute under the current evaluation limits. In particular, the evaluation will be aborted if an intermediate algebraic number (or more precisely, the resultant polynomial prior to factorization) exceeds CA_OPT_QQBAR_DEG_LIMIT. or the coefficients exceed some multiple of CA_OPT_PREC_LIMIT. Note that evaluation may hit those limits even if the minimal polynomial for x itself is small. The conversion can also fail if no algorithm has been implemented for the functions appearing in the construction of x.3Flint2 ca_get_fmpq res x ctx 3Flint2 ca_get_fmpz res x ctx 3Flint2 ca_set_qqbar res x ctx Sets res to the algebraic number x.If x is rational, res is set to the canonical representation as an element in the trivial field  \mathbb{Q}.If x* is irrational, this function always sets res- to an element of a univariate number field  \mathbb{Q}(a)&. It will not, for example, identify \sqrt{2} + \sqrt{3} as an element of \mathbb{Q}(\sqrt{2}, \sqrt{3}). However, it may attempt to find a simpler number field than that generated by x itself. For example:If x: is quadratic, it will be expressed as an element of \mathbb{Q}(\sqrt{N}) where N has no small repeated factors (obtained by performing a smooth factorization of the discriminant).TODO: if possible, coerce x" to a low-degree cyclotomic field.3Flint2 ca_transfer res res_ctx src src_ctx Sets res to src) where the corresponding context objects res_ctx and src_ctx may be different.?This operation preserves the mathematical value represented by src, but may result in a different internal representation depending on the settings of the context objects.3Flint2 ca_set_d_d res x y ctx Sets res to the value of x, or the complex value x + yi. NaN is interpreted as Unknown (not  Undefined).3Flint2ca_set_d res x ctx 3Flint2 ca_set_fmpq res v ctx Sets res# to the integer or rational number v. This creates a canonical representation of this number as an element of the trivial field  \mathbb{Q}.3Flint2 ca_set_fmpz res v ctx 3Flint2 ca_set_ui res v ctx 3Flint2 ca_set_si res v ctx 3Flint2ca_set res x ctx Sets res to a copy of x.3Flint2 ca_neg_i_inf res ctx Sets res to the signed infinity +\infty, -\infty,  +i \infty or  -i \infty.3Flint2 ca_pos_i_inf res ctx 3Flint2 ca_neg_inf res ctx 3Flint2 ca_pos_inf res ctx 3Flint2ca_uinf res ctx Sets res to unsigned infinity {\tilde \infty}.3Flint2 ca_undefined res ctx Sets res to  Undefined.3Flint2 ca_unknown res ctx Sets res to the meta-value Unknown.3Flint2ca_euler res ctx Sets res to Euler's constant \gamma. This creates an element of the (transcendental?) number field \mathbb{Q}(\gamma).3Flint2ca_pi_i res ctx Sets res to the constant \pi i2. This creates an element of the composite field \mathbb{Q}(i,\pi) rather than representing \pi i (or even 2 \pi i, which for some purposes would be more elegant) as an atomic quantity.3Flint2ca_pi res ctx Sets res to the constant \pi>. This creates an element of the transcendental number field \mathbb{Q}(\pi).3Flint2ca_neg_i res ctx Sets res to the imaginary unit  i = \sqrt{-1}, or its negation -i-. This creates a canonical representation of i1 as the generator of the algebraic number field  \mathbb{Q}(i).3Flint2ca_i res ctx 3Flint2 ca_neg_one res ctx Sets res to the integer 0, 1 or -1. This creates a canonical representation of this number as an element of the trivial field  \mathbb{Q}.3Flint2ca_one res ctx 3Flint2ca_zero res ctx 3Flint2 ca_printn x n ctx  Prints an n#-digit numerical representation of x to standard output.3Flint2 ca_get_str x ctx Prints x to a string which is returned. The user should free this string by calling  flint_free.3Flint2 ca_fprint fp x ctx Prints x to the file fp.3Flint2 ca_set_fexpr res expr ctx Sets res5 to the value represented by the symbolic expression expr. Returns 1 on success and 0 on failure. This function essentially just traverses the expression tree using ca arithmetic; it does not provide advanced symbolic evaluation. It is guaranteed to at least be able to parse the output of  ca_get_fexpr.3Flint2 ca_get_fexpr res x flags ctx Sets res' to a symbolic expression representing x.3Flint2ca_swap x y ctx  Efficiently swaps the variables x and y.3Flint2ca_clear x ctx Clears the variable x.3Flint2ca_init x ctx Initializes the variable x2 for use, associating it with the context object ctx. The value of x! is set to the rational number 0.3Flint2ca_ctx_set_option ctx i value3Flint2ca_ctx_get_options ctx i3Flint2 ca_ctx_print ctx $Prints a description of the context ctx to standard output. This will give a complete listing of the cached fields in ctx.3Flint2 ca_ctx_clear ctx Clears the context object ctx, freeing any memory allocated internally. This function should only be called after all ca_t8 instances referring to this context have been cleared.3Flint2 ca_ctx_init ctx Initializes the context object ctx for use. Any evaluation options stored in the context object are set to default values.3Flint2 ca_print_nPrint a decimal approximation of the number. The approximation is guaranteed to be correctly rounded to within one unit in the last place.If combined with 3, numbers appearing within the symbolic representation will also be printed with decimal approximations.Warning: printing a decimal approximation requires a computation, which can be expensive. It can also mutate cached data (numerical enclosures of extension numbers), affecting subsequent computations.3Flint2ca_print_digitsMultiplied by a positive integer, specifies the number of decimal digits to show with 35. If not given, the default precision is six digits.3Flint2 ca_print_reprPrint the symbolic representation of the number (including its recursive elements). If used together with 3, field elements will print as ``decimal {symbolic}`` while extension numbers will print as ``decimal [symbolic]``.6All extension numbers appearing in the field defining `x` and in the inner constructions of those extension numbers will be given local labels `a`, `b`, etc. for this printing.3Flint2ca_print_fieldFor each field element, explicitly print its formal field along with its reduction ideal if present, e.g. `QQ` or ``QQ(a,b,c) /  a-b,c^2+1``.3Flint2ca_print_defaultThe default print style. Equivalent to ``ca_print_n | ca_print_repr``.3Flint2ca_print_debugVerbose print style for debugging. Equivalent to ``ca_print_n | ca_print_repr | ca_print_field``.3Flint2ca_print x ctx Prints x to standard output.3Flint2ca_factor_poly_none#No polynomial factorization at all.3Flint2ca_factor_poly_content"Only extract the rational content.3Flint2ca_factor_poly_sqfPerform a squarefree factorization in addition to extracting the rational content.3Flint2ca_factor_poly_full5Perform a full multivariate polynomial factorization.The following flags select the factorization to perform over `mathbb{Z}`. Integer factorization is applied if *x* is an element of `mathbb{Q}`, and to the extracted rational content of polynomials. Each flag in the list strictly encompasses the factorization power of the preceding flag, so it is unnecessary to pass more than one flag.3Flint2ca_factor_zz_none No integer factorization at all.3Flint2ca_factor_zz_smoothPerform a smooth factorization to extract small prime factors (heuristically up to `CA_OPT_SMOOTH_LIMIT`2 bits) in addition to identifying perfect powers.3Flint2ca_factor_zz_fullPerform a complete integer factorization into prime numbers. This is prohibitively slow for general integers exceeding 70-80 digits.3Flint2ca_opt_verbose5Whether to print debug information. Default value: 0.3Flint2ca_opt_print_flagsPrinting style. See :ref:`ca-printing` for details. Default value: `CA_PRINT_DEFAULT`.3Flint2ca_opt_mpoly_ordMonomial ordering to use for multivariate polynomials. Possible values are  `ORD_LEX`,  `ORD_DEGLEX` and `ORD_DEGREVLEX`. Default value:  `ORD_LEX`9. This option must be set before doing any computations.3Flint2ca_opt_prec_limitMaximum precision to use internally for numerical evaluation with Arb, and in some cases for the magntiude of exact coefficients. This parameter affects the possibility to prove inequalities and find simplifications between related extension numbers. This is not a strict limit; some calculations may use higher precision when there is a good reason to do so. Default value: 4096.3Flint2ca_opt_qqbar_deg_limitMaximum degree of :type:qqbar_t elements allowed internally during simplification of algebraic numbers. This limit may be exceeded when the user provides explicit :type:qqbar_t- input of higher degree. Default value: 120.3Flint2ca_opt_low_precNumerical precision to use for fast checks (typically, before attempting more expensive operations). Default value: 64.3Flint2ca_opt_smooth_limitSize in bits for factors in smooth integer factorization. Default value: 32.3Flint2ca_opt_lll_precPrecision to use to find integer relations using LLL. Default value: 128.3Flint2ca_opt_pow_limitLargest exponent to expand powers automatically. This only applies in multivariate and transcendental fields: in number fields, `CA_OPT_PREC_LIMIT`$ applies instead. Default value: 20.3Flint2ca_opt_use_groebnerBoolean flag for whether to use Grbner basis computation. This flag and the following limits affect the ability to prove multivariate identities. Default value: 1.3Flint2ca_opt_groebner_length_limitMaximum length of ideal basis allowed in Buchberger's algorithm. Default value: 100.3Flint2!ca_opt_groebner_poly_length_limitMaximum length of polynomials allowed in Buchberger's algorithm. Default value: 1000.3Flint2ca_opt_groebner_poly_bits_limitMaximum coefficient size in bits of polynomials allowed in Buchberger's algorithm. Default value: 10000.3Flint2ca_opt_vieta_limitMaximum degree *n* of algebraic numbers for which to add Vieta's formulas to the reduction ideal. This must be set relatively low since the number of terms in Vieta's formulas is `O(2^n)` and the resulting Grbner basis computations can be expensive. Default value: 6.3Flint2ca_opt_trig_form2Default representation of trigonometric functions.Default value: 3.The *exponential* representation is currently used by default as typically works best for field arithmetic and simplifications, although it has the disadvantage of introducing complex numbers where real numbers would be sufficient. This may change in the future."The following values are possible:3Flint2ca_trig_direct0Use the direct functions (with some exceptions).3Flint2ca_trig_exponentialUse complex exponentials.3Flint2ca_trig_sine_cosineUse sines and cosines.3Flint2ca_trig_tangent Use tangents.11111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333\ Safe-Inferred )*11111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333313333333333333333333333333333333333333333333333322222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222223321111113333333333333333333333333311None )*13Flint2_ca_vec_set_fmpz_vec_div_fmpz res v den len ctx Sets res, to the rational vector given by numerators v and the common denominator den.3Flint2!_ca_vec_fmpq_vec_get_fmpz_vec_den c den vec len ctx Assuming that all elements of vec are structurally rational numbers, converts them to a vector of integers c on a common denominator den.3Flint2_ca_vec_fmpq_vec_is_fmpz_vec vec len ctx Assuming that all elements of vec are structurally rational numbers, checks if all elements are integers.3Flint2_ca_vec_is_fmpq_vec vec len ctx Checks if all elements of vec# are structurally rational numbers.3Flint2_ca_vec_check_is_zero vec len ctx Returns whether vec is the zero vector.3Flint2_ca_vec_scalar_submul_ca res src len c ctx  Subtracts src multiplied by c from the vector res, all vectors having length len.3Flint2_ca_vec_scalar_addmul_ca res src len c ctx Adds src multiplied by c to the vector res, all vectors having length len.3Flint2_ca_vec_scalar_div_ca res src len c ctx Sets res to src divided by c, all vectors having length len.3Flint2_ca_vec_scalar_mul_ca res src len c ctx Sets res to src multiplied by c, all vectors having length len.3Flint2 _ca_vec_sub res vec1 vec2 len ctx Sets res to the sum or difference of vec1 and vec2, all vectors having length len.3Flint2 _ca_vec_add res vec1 vec2 len ctx 3Flint2 ca_vec_neg res src ctx Sets res to the negation of src.3Flint2 _ca_vec_neg res src len ctx 3Flint2 ca_vec_append vec f ctx Appends f to the end of vec.3Flint2 ca_vec_printn poly digits ctx #Prints a decimal representation of vec with precision specified by digits. The coefficients are comma-separated and the whole list is enclosed in square brackets.3Flint2 ca_vec_print vec ctx Prints vec to standard output. The coefficients are printed on separate lines.3Flint2 ca_vec_zero res len ctx Sets res to the length len zero vector.3Flint2 _ca_vec_zero res len ctx  Sets the len entries in res to zeros.3Flint2 ca_vec_set res src ctx Sets res to a copy of src.3Flint2 _ca_vec_set res src len ctx Sets res to a copy of src of length len.3Flint2ca_vec_set_length vec len ctx Sets the length of vec to len. If vec4 is shorter on input, it will be zero-extended. If vec* is longer on input, it will be truncated.3Flint2_ca_vec_fit_length vec len ctx Allocates space in vec for len elements.3Flint2 ca_vec_length vec ctx Returns the length of vec.3Flint2 ca_vec_swap vec1 vec2 ctx Swaps the vectors vec1 and vec2 efficiently.3Flint2 _ca_vec_swap vec1 vec2 len ctx Swaps the entries in vec1 and vec2 efficiently.3Flint2 ca_vec_clear vec ctx Clears the vector vec.3Flint2 _ca_vec_clear vec len ctx  Clears all len entries in vec and frees the pointer vec itself.3Flint2 ca_vec_init vec len ctx  Initializes vec to a length len% vector. All entries are set to zero.3Flint2 _ca_vec_init len ctx !Returns a pointer to an array of len" coefficients initialized to zero.$333333333333333333333333333333333] Safe-Inferred )*1t$333333333333333333333333333333333$333333333333333333333333333333333 Safe-Inferred )*13Flint2ca_poly_vec_append vec poly ctx Appends poly to the end of the vector vec.3Flint2ca_poly_vec_clear vec ctx Clears the vector vec.3Flint2_ca_poly_vec_clear vec len ctx 3Flint2ca_poly_vec_set_length vec len ctx Resizes vec to length len, zero-extending if needed.3Flint2_ca_poly_vec_fit_length vec len ctx Allocates space for len polynomials in vec.4Flint2ca_poly_vec_init res len ctx Initializes a vector with len polynomials.4Flint2_ca_poly_vec_init len ctx 4Flint2 ca_poly_roots roots exp poly ctx >Attempts to compute all complex roots of the given polynomial poly". On success, returns 1 and sets roots to a vector containing all the distinct roots with corresponding multiplicities in exp2. On failure, returns 0 and leaves the values in roots7 arbitrary. The roots are returned in arbitrary order.1Failure will occur if the leading coefficient of poly cannot be proved to be nonzero, if determining the correct multiplicities fails, or if the builtin algorithms do not have a means to represent the roots symbolically.The underscore method assumes that the polynomial is squarefree. The non-underscore method performs a squarefree factorization.4Flint2_ca_poly_roots roots poly len ctx 4Flint2ca_poly_set_roots poly roots exp ctx Sets poly" to the monic polynomial with the n roots given in the vector roots*, with multiplicities given in the vector exp3. In other words, this constructs the polynomial 8(x-r_0)^{e_0} (x-r_1)^{e_1} \cdots (x-r_{n-1})^{e_{n-1}}. Uses binary splitting.4Flint2_ca_poly_set_roots poly roots exp n ctx 4Flint2ca_poly_squarefree_part res poly ctx Sets res to the squarefree part of poly, normalized to be monic. This algorithm can fail if GCD computation fails internally. Returns 1 on success and 0 on failure.4Flint2ca_poly_factor_squarefree c fac exp F ctx )Computes the squarefree factorization of F, giving a product F = c f_1 f_2^2 \ldots f_n^n where all f_i with  f_i \ne 1> are squarefree and pairwise coprime. The nontrivial factors f_i are written to fac0 and the corresponding exponents are written to exp. This algorithm can fail if GCD computation fails internally. Returns 1 on success and 0 on failure.4Flint2 ca_poly_gcd res A g ctx Sets res to the GCD of A and B and returns 1 on success. On failure, returns 0 leaving the value of res arbitrary. The computation can fail if testing a leading coefficient for zero fails in the execution of the GCD algorithm. The output is normalized to be monic if it is not the zero polynomial.The underscore methods assume !\text{lenA} \ge \text{lenB} \ge 1, and that both A and B have nonzero leading coefficient. They return the length of the GCD, or 0 if the computation fails.The  euclidean version implements the standard Euclidean algorithm. The default version first checks for rational polynomials or attempts to certify numerically that the polynomials are coprime and otherwise falls back to an automatic choice of algorithm (currently only the Euclidean algorithm).4Flint2 _ca_poly_gcd res A lenA B lenB ctx 4Flint2ca_poly_gcd_euclidean res A B ctx 4Flint2_ca_poly_gcd_euclidean res A lenA B lenB ctx 4Flint2ca_poly_log_series res f len ctx Sets res" to the power series logarithm of f truncated to length len.4Flint2_ca_poly_log_series res f flen len ctx 4Flint2ca_poly_exp_series res f len ctx Sets res$ to the power series exponential of f truncated to length len.4Flint2_ca_poly_exp_series res f flen len ctx 4Flint2ca_poly_div_series res f g len ctx Sets res! to the power series quotient of f and g truncated to length len#. This function divides by zero if g has constant term zero; the user should manually remove initial zeros when an exact cancellation is required.4Flint2_ca_poly_div_series res f flen g glen len ctx 4Flint2ca_poly_inv_series res f len ctx Sets res to the power series inverse of f truncated to length len.4Flint2_ca_poly_inv_series res f flen len ctx 4Flint2ca_poly_integral res poly ctx Sets res to the integral of poly9. The underscore method needs one more coefficient than len for the output array.4Flint2_ca_poly_integral res poly len ctx 4Flint2ca_poly_derivative res poly ctx Sets res to the derivative of poly9. The underscore method needs one less coefficient than len for the output array.4Flint2_ca_poly_derivative res poly len ctx 4Flint2ca_poly_compose res poly1 poly2 ctx Sets res to the composition of poly1 with poly2.4Flint2_ca_poly_compose res poly1 len1 poly2 len2 ctx 4Flint2ca_poly_evaluate res f a ctx Sets res to f evaluated at the point a.4Flint2_ca_poly_evaluate res f len x ctx 4Flint2ca_poly_evaluate_horner res f a ctx 4Flint2_ca_poly_evaluate_horner res f len x ctx 4Flint2ca_poly_pow_ui res poly exp ctx Sets res to poly raised to the power exp.4Flint2_ca_poly_pow_ui res f flen exp ctx 4Flint2ca_poly_pow_ui_trunc res poly exp len ctx Sets res to poly raised to the power exp, truncated to length len.4Flint2_ca_poly_pow_ui_trunc res f flen exp len ctx 4Flint2 ca_poly_rem R A B ctx If the leading coefficient of B can be proved invertible, sets Q and R9 to the quotient and remainder of polynomial division of A by B and returns 1. If the leading coefficient cannot be proved invertible, returns 0. The underscore method takes a precomputed inverse of the leading coefficient of B.4Flint2 ca_poly_div Q A B ctx 4Flint2ca_poly_divrem Q R A B ctx 4Flint2_ca_poly_divrem Q R A lenA B lenB invB ctx 4Flint2ca_poly_divrem_basecase Q R A B ctx 4Flint2_ca_poly_divrem_basecase Q R A lenA B lenB invB ctx 4Flint2ca_poly_div_ca res poly c ctx Sets res to poly divided by the scalar c.4Flint2ca_poly_mul_ca res poly c ctx Sets res to poly multiplied by the scalar c.4Flint2ca_poly_mullow res poly1 poly2 n ctx Sets res to the product of poly1 and poly2 truncated to length n.4Flint2_ca_poly_mullow C poly1 len1 poly2 len2 n ctx 4Flint2 ca_poly_mul res poly1 poly2 ctx Sets res to the product of poly1 and poly2.4Flint2 _ca_poly_mul res poly1 len1 poly2 len2 ctx 4Flint2 ca_poly_sub res poly1 poly2 ctx Sets res to the difference of poly1 and poly2.4Flint2 _ca_poly_sub res poly1 len1 poly2 len2 ctx 4Flint2 ca_poly_add res poly1 poly2 ctx Sets res to the sum of poly1 and poly2.4Flint2 _ca_poly_add res poly1 len1 poly2 len2 ctx 4Flint2 ca_poly_neg res src ctx Sets res to the negation of src.4Flint2ca_poly_shift_right res poly n ctx Sets res to poly shifted n1 coefficients to the right; that is, divided by x^n.4Flint2_ca_poly_shift_right res poly len n ctx 4Flint2ca_poly_shift_left res poly n ctx Sets res to poly shifted n3 coefficients to the left; that is, multiplied by x^n.4Flint2_ca_poly_shift_left res poly len n ctx 4Flint2ca_poly_check_is_one poly ctx  Checks if poly is the constant polynomial 1.4Flint2ca_poly_check_is_zero poly ctx  Checks if poly is the zero polynomial.4Flint2ca_poly_check_equal poly1 poly2 ctx  Checks if poly1 and poly2 represent the same polynomial. The underscore method assumes that len1 is at least as large as len2.4Flint2_ca_poly_check_equal poly1 len1 poly2 len2 ctx 4Flint2ca_poly_reverse res poly n ctx Sets res to the reversal of poly' considered as a polynomial of length n>, zero-padding if needed. The underscore method assumes that len' is positive and less than or equal to n.4Flint2_ca_poly_reverse res poly len n ctx 4Flint2ca_poly_make_monic res poly ctx Makes poly monic by dividing by the leading coefficient if possible and returns 1. Returns 0 if the leading coefficient cannot be certified to be nonzero, or if poly is the zero polynomial.4Flint2ca_poly_is_proper poly ctx  Checks that poly represents an element of  \mathbb{C}[X] with well-defined degree. This returns 1 if the leading coefficient of poly% is nonzero and all coefficients of poly are numbers (not special values). It returns 0 otherwise. It returns 1 when poly is precisely the zero polynomial (which does not have a leading coefficient).4Flint2ca_poly_printn poly digits ctx #Prints a decimal representation of poly with precision specified by digits. The coefficients are comma-separated and the whole list is enclosed in square brackets.4Flint2ca_poly_fprint file poly ctx Prints poly: to file. The coefficients are printed on separate lines.4Flint2ca_poly_get_str poly ctx #Returns a string representation of poly2. The coefficients are printed on separate lines.4Flint2ca_poly_randtest_rational poly state len bits ctx Sets poly1 to a random rational polynomial of length up to len and with entries up to bits bits in size.4Flint2ca_poly_randtest poly state len depth bits ctx Sets poly( to a random polynomial of length up to len+ and with entries having complexity up to depth and bits (see  ca_randtest).4Flint2ca_poly_transfer res res_ctx src src_ctx Sets res to src) where the corresponding context objects res_ctx and src_ctx may be different.?This operation preserves the mathematical value represented by src, but may result in a different internal representation depending on the settings of the context objects.4Flint2ca_poly_set_coeff_ca poly n x ctx !Sets the coefficient at position n in poly to x.4Flint2ca_poly_set_fmpq_poly res src ctx Sets poly the polynomial src.4Flint2ca_poly_set_fmpz_poly res src ctx 4Flint2 ca_poly_set res src ctx 4Flint2ca_poly_set_si poly c ctx Sets poly to the constant polynomial c.4Flint2ca_poly_set_ca poly c ctx 4Flint2 ca_poly_x poly ctx Sets poly to the monomial x.4Flint2 ca_poly_one poly ctx Sets poly to the constant polynomial 1.4Flint2 ca_poly_zero poly ctx Sets poly to the zero polynomial.4Flint2_ca_poly_normalise poly ctx Strips any top coefficients which can be proved identical to zero.4Flint2_ca_poly_set_length poly len ctx Directly changes the length of the polynomial, without allocating or deallocating coefficients. The value should not exceed the allocation length.4Flint2ca_poly_fit_length poly len ctx Makes sure that the coefficient array of the polynomial contains at least len initialized coefficients.4Flint2 ca_poly_clear poly ctx Clears the polynomial, deallocating all coefficients and the coefficient array.4Flint2 ca_poly_init poly ctx Initializes the polynomial for use, setting it to the zero polynomial.4Flint2 ca_poly_print poly ctx Prints poly to standard output. The coefficients are printed on separate lines.33333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444^ Safe-Inferred )*13333344444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444433333 Safe-Inferred )*14Flint2ca_ext_cache_insert cache x ctx Adds x to cache without duplication. If a structurally identical instance already exists in cache, a pointer to that instance is returned. Otherwise, a copy of x is inserted into cache1 and a pointer to that new instance is returned.4Flint2ca_ext_cache_clear cache ctx Clears cache*, freeing the memory allocated internally.4Flint2ca_ext_cache_init cache ctx  Initializes cache for use.4Flint2ca_ext_get_acb_raw res x prec ctx Sets res+ to an enclosure of the numerical value of x. A working precision of prec? bits is used for the evaluation, without adaptive refinement.4Flint2ca_ext_cmp_repr x y ctx  Compares the representations of x and y in a canonical sort order, returning -1, 0 or 1. This only performs a structural comparison of the symbolic representations; the return value does not say anything meaningful about the numbers represented by x and y.4Flint2ca_ext_equal_repr x y ctx Tests x and y; for structural equality, returning 0 (false) or 1 (true).4Flint2 ca_ext_hash x ctx 3Returns a hash of the structural representation of x.4Flint2ca_ext_get_arg res x i ctx Sets res to argument i (indexed from zero) of x. This calls  flint_abort if i is out of range.4Flint2 ca_ext_nargs x ctx ,Returns the number of function arguments of x. The return value is 0 for any algebraic constant and for any built-in symbolic constant such as \pi.4Flint2 ca_ext_clear res ctx Clears res.4Flint2ca_ext_init_set res x ctx  Initializes res and sets it to a copy of x.4Flint2ca_ext_init_fxn res func x nargs ctx  Initializes res1 and sets it to the multivariate function value f(x_1, \ldots, x_n) where f is defined by func and n is given by nargs.4Flint2ca_ext_init_fxy res func x y ctx  Initializes res. and sets it to the bivariate function value f(x, y) where f is defined by func (example: func = CA_Pow for x^y).4Flint2ca_ext_init_fx res func x ctx  Initializes res. and sets it to the univariate function value f(x) where f is defined by func (example: func = CA_Exp for e^x).4Flint2ca_ext_init_const res func ctx  Initializes res( and sets it to the constant defined by func (example: func = CA_Pi for x = \pi).4Flint2ca_ext_init_qqbar res x ctx  Initializes res' and sets it to the algebraic constant x.4Flint2 ca_ext_print x ctx Prints a description of x to standard output.44444444444444444444444_ Safe-Inferred )*14444444444444444444444444444444444444444444444` Safe-Inferred )*1 4444 Safe-Inferred )*14Flint2 ca_mat_log res A ctx (Matrix logarithm: given a square matrix A, sets res to a logarithm \log(A) and returns T_TRUE on success. If A. can be proved to have no logarithm, returns T_FALSE=. If the existence of a logarithm cannot be proved, returns  T_UNKNOWN.This function uses the Jordan decomposition, and the branch of the matrix logarithm is defined by taking the principal values of the logarithms of all eigenvalues.4Flint2 ca_mat_exp res A ctx *Matrix exponential: given a square matrix A, sets res to e^A and returns 1 on success. If unsuccessful, returns 0, leaving the values in res arbitrary.This function uses Jordan decomposition. The matrix exponential always exists, but computation can fail if computing the Jordan decomposition fails.4Flint2ca_mat_jordan_form J P A ctx "Computes the Jordan decomposition A = P J P^{-1} of the given square matrix A. The user can pass NULL for the output variable P, in which case only J is computed. On success, returns 1. On failure, returns 0, leaving the values of J and P arbitrary..This function is a convenience wrapper around ca_mat_jordan_blocks, ca_mat_set_jordan_blocks and ca_mat_jordan_transformation. For computations with the Jordan decomposition, it is often better to use those methods directly since they give direct access to the spectrum and block structure.4Flint2ca_mat_jordan_transformation mat lambda  num_blocks  block_lambda  block_size A ctx 2Given the precomputed Jordan block decomposition (lambda,  num_blocks,  block_lambda,  block_size) of the square matrix A4, computes the corresponding transformation matrix P such that A = P J P^{-1}. On success, writes P to mat= and returns 1. On failure, returns 0, leaving the value of mat arbitrary.4Flint2ca_mat_set_jordan_blocks mat lambda  num_blocks  block_lambda  block_size ctx Sets mat4 to the concatenation of the Jordan blocks given in lambda,  num_blocks,  block_lambda and  block_size. See ca_mat_jordan_blocks' for an explanation of these variables.4Flint2ca_mat_jordan_blocks lambda  num_blocks  block_lambda  block_size A ctx 4Computes the blocks of the Jordan canonical form of A". On success, returns 1 and sets lambda to the unique eigenvalues of A, sets  num_blocks' to the number of Jordan blocks, entry i of  block_lambda1 to the index of the eigenvalue in Jordan block i , and entry i of  block_size to the size of Jordan block i. On failure, returns 0, leaving arbitrary values in the output variables. The user should allocate space in  block_lambda and  block_size for up to n entries where n is the size of the matrix.The Jordan form is unique up to the ordering of blocks, which is arbitrary.4Flint2ca_mat_diagonalization D P A ctx >Matrix diagonalization: attempts to compute a diagonal matrix D and an invertible matrix P such that  A = PDP^{-1} . Returns T_TRUE if A1 is diagonalizable and the computation succeeds, T_FALSE if A& is provably not diagonalizable, and  T_UNKNOWN if it is unknown whether A/ is diagonalizable. If the return value is not T_TRUE, the values in D and P are arbitrary.4Flint2ca_mat_eigenvalues lambda exp mat ctx Attempts to compute all complex eigenvalues of the given matrix mat". On success, returns 1 and sets lambda to the distinct eigenvalues with corresponding multiplicities in exp. The eigenvalues are returned in arbitrary order. On failure, returns 0 and leaves the values in lambda and exp arbitrary.This function effectively computes the characteristic polynomial and then calls  ca_poly_roots.4Flint2ca_mat_companion mat poly ctx Sets mat to the companion matrix of poly:. This function verifies that the leading coefficient of poly is provably nonzero and that the output matrix has the right size, returning 1 on success. It returns 0 if the leading coefficient of poly cannot be proved nonzero or if the size of the output matrix does not match.4Flint2ca_mat_charpoly cp mat ctx Sets poly% to the characteristic polynomial of mat3 which must be a square matrix. If the matrix has n1 rows, the underscore method requires space for n + 1 output coefficients.The  berkowitz3 version uses a division-free algorithm requiring O(n^4) operations. The  danilevsky version only performs O(n^3) operations, but performs divisions and needs to check for zero which can fail. This version returns 1 on success and 0 on failure. The default version chooses an algorithm automatically.4Flint2_ca_mat_charpoly cp mat ctx 5Flint2ca_mat_charpoly_danilevsky cp mat ctx 5Flint2_ca_mat_charpoly_danilevsky cp mat ctx 5Flint2ca_mat_charpoly_berkowitz cp mat ctx 5Flint2_ca_mat_charpoly_berkowitz cp mat ctx 5Flint2ca_mat_adjugate adj det A ctx Sets adj to the adjuate matrix of A and det to the determinant of A$, both computed simultaneously. The cofactor' version uses cofactor expansion. The charpoly version computes and evaluates the characteristic polynomial. The default version uses an automatic algorithm choice.5Flint2ca_mat_adjugate_charpoly adj det A ctx 5Flint2ca_mat_adjugate_cofactor adj det A ctx 5Flint2 ca_mat_det det A ctx Sets det) to the determinant of the square matrix A$. Various algorithms are available:The  berkowitz version uses the division-free Berkowitz algorithm performing O(n^4) operations. Since no zero tests are required, it is guaranteed to succeed.The cofactor version performs cofactor expansion. This is currently only supported for matrices up to size 4.The lu and bareiss versions use rational LU decomposition and fraction-free LU decomposition (Bareiss algorithm) respectively, requiring O(n^3) operations. These algorithms can fail if zero certification fails (see ca_mat_nonsingular_lu); they return 1 for success and 0 for failure. Note that the Bareiss algorithm, despite being "fraction-free", may introduce fractions due to incomplete symbolic simplifications.The default function chooses an algorithm automatically. It will, in addition, recognize trivially rational and integer matrices and evaluate those determinants using  fmpq_mat_t or  fmpz_mat_t.The various algorithms can produce different symbolic forms of the same determinant. Which algorithm performs better depends strongly and sometimes unpredictably on the structure of the matrix.5Flint2ca_mat_det_cofactor det A ctx 5Flint2ca_mat_det_bareiss det A ctx 5Flint2 ca_mat_det_lu det A ctx 5Flint2ca_mat_det_berkowitz det A ctx 5Flint2 ca_mat_trace trace mat ctx Sets trace3 to the sum of the entries on the main diagonal of mat.5Flint2ca_mat_right_kernel X A ctx Sets X/ to a basis of the right kernel (nullspace) of A. The output matrix X will be resized in-place to have a number of columns equal to the nullity of A. Returns 1 on success. On failure, returns 0 and leaves the data in X meaningless.5Flint2 ca_mat_rref rank R A ctx Computes the reduced row echelon form (rref) of a given matrix. On success, sets R to the rref of A, writes the rank to rank, and returns 1. On failure to certify the correct rank, returns 0, leaving the data in rank and R meaningless.The fflu version computes a fraction-free LU decomposition and then converts the output ro rref form. The lu version computes a regular LU decomposition and then converts the output to rref form. The default version uses an automatic algorithm choice and may implement additional methods for special cases.5Flint2ca_mat_rref_lu rank R A ctx 5Flint2ca_mat_rref_fflu rank R A ctx 5Flint2 ca_mat_rank rank A ctx  Computes the rank of the matrix A3. If successful, returns 1 and writes the rank to rank. If unsuccessful, returns 0.5Flint2ca_mat_solve_lu_precomp X P LU B ctx Solves AX = B5 given the precomputed nonsingular LU decomposition A = PLU4 or fraction-free LU decomposition with denominator den. The matrices X and B1 are allowed to be aliased with each other, but X# is not allowed to be aliased with LU.5Flint2ca_mat_solve_fflu_precomp X perm A den B ctx 5Flint2ca_mat_solve_triu X U B unit ctx #Solves the lower triangular system LX = B! or the upper triangular system UX = B, respectively. It is assumed (not checked) that the diagonal entries are nonzero. If unit is set, the main diagonal of L or U is taken to consist of all ones, and in that case the actual entries on the diagonal are not read at all and can contain other data.The  classical: versions perform the computations iteratively while the  recursive versions perform the computations in a block recursive way to benefit from fast matrix multiplication. The default versions choose an algorithm automatically.5Flint2ca_mat_solve_triu_recursive X U B unit ctx 5Flint2ca_mat_solve_triu_classical X U B unit ctx 5Flint2ca_mat_solve_tril X L B unit ctx 5Flint2ca_mat_solve_tril_recursive X L B unit ctx 5Flint2ca_mat_solve_tril_classical X L B unit ctx 5Flint2ca_mat_nonsingular_solve X A B ctx  Determines if the square matrix A, is nonsingular, and if successful, solves AX = B and returns T_TRUE . Returns T_FALSE if A is singular, and  T_UNKNOWN if the rank of A cannot be determined.5Flint2ca_mat_nonsingular_solve_lu X A B ctx 5Flint2ca_mat_nonsingular_solve_fflu X A B ctx 5Flint2!ca_mat_nonsingular_solve_adjugate X A B ctx 5Flint2 ca_mat_inv X A ctx  Determines if the square matrix A* is nonsingular, and if successful, sets  X = A^{-1} and returns T_TRUE . Returns T_FALSE if A is singular, and  T_UNKNOWN if the rank of A cannot be determined.5Flint2ca_mat_nonsingular_fflu P LU den A ctx  Wrapper for  ca_mat_fflu . Similar to ca_mat_nonsingular_lu, but computes a fraction-free LU decomposition using the Bareiss algorithm. The denominator is written to den. Note that despite being "fraction-free", this algorithm may introduce fractions due to incomplete symbolic simplifications.5Flint2ca_mat_nonsingular_lu P LU A ctx  Wrapper for  ca_mat_lu. If A6 can be proved to be invertible/nonsingular, returns T_TRUE and sets P and LU to a LU decomposition A = PLU. If A( can be proved to be singular, returns T_FALSE. If A cannot be proved to be either singular or nonsingular, returns  T_UNKNOWN. When the return value is T_FALSE or  T_UNKNOWN;, the LU factorization is not completed and the values of P and LU are arbitrary.5Flint2 ca_mat_fflu rank P LU den A  rank_check ctx  Similar to  ca_mat_lu, but computes a fraction-free LU decomposition using the Bareiss algorithm. The denominator is written to den. Note that despite being "fraction-free", this algorithm may introduce fractions due to incomplete symbolic simplifications.5Flint2 ca_mat_lu rank P LU A  rank_check ctx (Computes a generalized LU decomposition A = PLU of a given matrix A, writing the rank of A to rank.If A! is a nonsingular square matrix, LU9 will be set to a unit diagonal lower triangular matrix L and an upper triangular matrix U (the diagonal of L will not be stored explicitly).If A is an arbitrary matrix of rank r, U% will be in row echelon form having r nonzero rows, and L, will be lower triangular but truncated to r& columns, having implicit ones on the r first entries of the main diagonal. All other entries will be zero.If a nonzero value for  rank_check is passed, the function will abandon the output matrix in an undefined state and set the rank to 0 if A# is detected to be rank-deficient.The algorithm can fail if it fails to certify that a pivot element is zero or nonzero, in which case the correct rank cannot be determined. The return value is 1 on success and 0 on failure. On failure, the data in the output variables rank, P and LU will be meaningless.The  classical3 version uses iterative Gaussian elimination. The  recursive version uses a block recursive algorithm to take advantage of fast matrix multiplication.5Flint2ca_mat_lu_recursive rank P LU A  rank_check ctx 5Flint2ca_mat_lu_classical rank P LU A  rank_check ctx 5Flint2ca_mat_find_pivot  pivot_row mat  start_row end_row column ctx $Attempts to find a nonzero entry in mat with column index column and row index between  start_row (inclusive) and end_row (exclusive).If the return value is T_TRUE, such an element exists, and  pivot_row2 is set to the row index. If the return value is T_FALSE, no such element exists (all entries in this part of the column are zero). If the return value is  T_UNKNOWN, it is unknown whether such an element exists (zero certification failed).This function is destructive: any elements that are nontrivially zero but can be certified zero will be overwritten by exact zeros.5Flint2ca_mat_ca_poly_evaluate res poly A ctx Sets res to f(A) where f is the polynomial given by poly and A< is a square matrix. Uses the Paterson-Stockmeyer algorithm.5Flint2_ca_mat_ca_poly_evaluate res poly len A ctx 5Flint2ca_mat_pow_ui_binexp B A exp ctx Sets B to A raised to the power exp), evaluated using binary exponentiation.5Flint2 ca_mat_sqr B A ctx Sets B to the square of A.5Flint2ca_mat_submul_ca B A c ctx Sets the matrix B to B plus (or minus) the matrix A multiplied by the scalar c.5Flint2ca_mat_addmul_ca B A c ctx 5Flint2 ca_mat_sub_ca B A c ctx Sets B to A plus or minus the scalar c% (interpreted as a diagonal matrix).5Flint2 ca_mat_add_ca B A c ctx 5Flint2 ca_mat_div_ca B A c ctx Sets B to A divided by the scalar c.5Flint2ca_mat_div_fmpq B A c ctx 5Flint2ca_mat_div_fmpz B A c ctx 5Flint2 ca_mat_div_si B A c ctx 5Flint2 ca_mat_mul_ca B A c ctx Sets B to A multiplied by the scalar c.5Flint2ca_mat_mul_fmpq B A c ctx 5Flint2ca_mat_mul_fmpz B A c ctx 5Flint2 ca_mat_mul_si B A c ctx 5Flint2 ca_mat_mul res A B ctx Sets res to the matrix product of A and B. The  classical- version uses classical multiplication. The same_nf* version assumes (not checked) that both A and B> have coefficients in the same simple algebraic number field K or in  \mathbb{Q}:. The default version chooses an algorithm automatically.5Flint2ca_mat_mul_same_nf res A B K ctx 5Flint2ca_mat_mul_classical res A B ctx 5Flint2 ca_mat_sub res A B ctx Sets res to the difference of A and B.5Flint2 ca_mat_add res A B ctx Sets res to the sum of A and B.5Flint2 ca_mat_neg res A ctx Sets res to the negation of A.5Flint2ca_mat_conj_transpose res A ctx Sets res5 to the conjugate transpose (Hermitian transpose) of A.5Flint2 ca_mat_conj res A ctx Sets res' to the entrywise complex conjugate of A.5Flint2ca_mat_transpose res A ctx Sets res to the transpose of A.5Flint2ca_mat_check_is_one A ctx  Tests if A3 has ones on the main diagonal and zeros elsewhere.5Flint2ca_mat_check_is_zero A ctx  Tests if A is the zero matrix.5Flint2ca_mat_check_equal A B ctx  Compares A and B for equality.5Flint2 ca_mat_dft mat type ctx Sets mat9 to the DFT (discrete Fourier transform) matrix of order n where n is the smallest dimension of mat (if mat is not square, the matrix is extended periodically along the larger dimension). The type parameter selects between four different versions of the DFT matrix (in which \omega = e^{2\pi i/n}):Type 0 -- entries A_{j,k} = \omega^{-jk}Type 1 -- entries A_{j,k} = \omega^{jk} / nType 2 -- entries !A_{j,k} = \omega^{-jk} / \sqrt{n}Type 3 -- entries  A_{j,k} = \omega^{jk} / \sqrt{n}The type 0 and 1 matrices are inverse pairs, and similarly for the type 2 and 3 matrices.5Flint2ca_mat_hilbert mat ctx Sets mat+ to the Hilbert matrix, which has entries A_{i,j} = 1/(i+j+1).5Flint2ca_mat_stirling mat kind ctx Sets mat? to a Stirling matrix, whose entries are Stirling numbers. If kind is 0, the entries are set to the unsigned Stirling numbers of the first kind. If kind is 1, the entries are set to the signed Stirling numbers of the first kind. If kind is 2, the entries are set to the Stirling numbers of the second kind.5Flint2 ca_mat_pascal mat  triangular ctx Sets mat to a Pascal matrix, whose entries are binomial coefficients. If  triangular is 0, constructs a full symmetric matrix with the rows of Pascal's triangle as successive antidiagonals. If  triangular is 1, constructs the upper triangular matrix with the rows of Pascal's triangle as columns, and if  triangular is -1, constructs the lower triangular matrix with the rows of Pascal's triangle as rows.5Flint2 ca_mat_ones mat ctx Sets all entries in mat to one.5Flint2 ca_mat_one mat ctx )Sets the entries on the main diagonal of mat( to one, and all other entries to zero.5Flint2 ca_mat_zero mat ctx Sets all entries in mat to zero.5Flint2 ca_mat_printn mat digits ctx #Prints a decimal representation of mat with precision specified by digits. The entries are comma-separated with square brackets and comma separation for the rows.5Flint2ca_mat_randops mat state count ctx  Randomizes mat in-place by performing elementary row or column operations. More precisely, at most count random additions or subtractions of distinct rows and columns will be performed. This leaves the rank (and for square matrices, the determinant) unchanged.5Flint2ca_mat_randtest_rational mat state bits ctx Sets mat0 to a random rational matrix with entries up to bits bits in size.5Flint2ca_mat_randtest mat state depth bits ctx Sets mat: to a random matrix with entries having complexity up to depth and bits (see  ca_randtest).5Flint2ca_mat_transfer res res_ctx src src_ctx Sets res to src) where the corresponding context objects res_ctx and src_ctx may be different.?This operation preserves the mathematical value represented by src, but may result in a different internal representation depending on the settings of the context objects.5Flint2 ca_mat_set_ca mat c ctx Sets mat to the matrix with the scalar c+ on the main diagonal and zeros elsewhere.5Flint2ca_mat_set_fmpq_mat dest src ctx Sets dest to src.. The operands must have identical dimensions.5Flint2ca_mat_set_fmpz_mat dest src ctx 5Flint2 ca_mat_set dest src ctx 5Flint2ca_mat_window_clear window ctx Frees the window matrix.5Flint2ca_mat_window_init window mat r1 c1 r2 c2 ctx  Initializes window* to a window matrix into the submatrix of mat starting at the corner at row r1 and column c1 (inclusive) and ending at row r2 and column c2 (exclusive).5Flint2 ca_mat_swap mat1 mat2 ctx Efficiently swaps mat1 and mat2.5Flint2 ca_mat_clear mat ctx ,Clears the matrix, deallocating all entries.5Flint2 ca_mat_init mat r c ctx ;Initializes the matrix, setting it to the zero matrix with r rows and c columns.5Flint2ca_mat_entry_ptr mat i j &Returns a pointer to the entry at row i and column j. Equivalent to  ca_mat_entry but implemented as a function.5Flint2 ca_mat_print mat ctx Prints mat to standard output. The entries are printed on separate lines.4444444444455555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555a Safe-Inferred )*144444444444555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555544444444444 Safe-Inferred )*15Flint2arb_mat_add_error_mag mat err Adds err) in-place to the radii of the entries of mat.5Flint2arb_mat_get_mid B A Sets the entries of B* to the exact midpoints of the entries of A.5Flint2arb_mat_count_not_is_zero mat !Returns the number of entries of mat that are not certainly zero.5Flint2arb_mat_count_is_zero mat !Returns the number of entries of mat' that are certainly zero according to  arb_is_zero.5Flint2arb_mat_entrywise_not_is_zero dest src Sets each entry of dest1 to indicate whether the corresponding entry of src0 is not certainly zero. This the complement of arb_mat_entrywise_is_zero.5Flint2arb_mat_diag_prod res mat prec Sets res7 to the product of the entries on the main diagonal of mat. The underscore method computes the product of the entries between index a inclusive and b* exclusive (the indices must be in range).5Flint2 arb_mat_trace trace mat prec Sets trace to the trace of the matrix, i.e. the sum of entries on the main diagonal of mat&. The matrix is required to be square.5Flint2 arb_mat_exp B A prec Sets B" to the exponential of the matrix A, defined by the Taylor series` -\exp(A) = \sum_{k=0}^{\infty} \frac{A^k}{k!}.The function is evaluated as \exp(A/2^r)^{2^r}, where r& is chosen to give rapid convergence.>The elementwise error when truncating the Taylor series after N terms is bounded by the error in the infinity norm, for which we have` \left\|\exp(2^{-r}A) - \sum_{k=0}^{N-1} \frac{\left(2^{-r} A\right)^k}{k!} \right\|_{\infty} = \left\|\sum_{k=N}^{\infty} \frac{\left(2^{-r} A\right)^k}{k!}\right\|_{\infty} \le \sum_{k=N}^{\infty} \frac{(2^{-r} \|A\|_{\infty})^k}{k!}.$We bound the sum on the right using  mag_exp_tail. Truncation error is not added to entries whose values are determined by the sparsity structure of A.5Flint2arb_mat_exp_taylor_sum S A N prec Sets S- to the truncated exponential Taylor series S = \sum_{k=0}^{N-1} A^k / k!7. Uses rectangular splitting to compute the sum using  O(\sqrt{N}) matrix multiplications. The recurrence relation for factorials is used to get scalars that are small integers instead of full factorials. As in  [Joh2014b], all divisions are postponed to the end by computing partial factorials of length  O(\sqrt{N}). The scalars could be reduced by doing more divisions, but this appears to be slower in most cases.5Flint2arb_mat_companion mat poly prec  Sets the n by n matrix mat, to the companion matrix of the polynomial poly which must have degree n. The underscore method reads n + 1 input coefficients.5Flint2arb_mat_charpoly poly mat prec Sets poly% to the characteristic polynomial of mat3 which must be a square matrix. If the matrix has n1 rows, the underscore method requires space for n + 1? output coefficients. Employs a division-free algorithm using O(n^4) operations.5Flint2arb_mat_inv_ldl_precomp X L prec Sets  X = A^{-1} where A0 is a symmetric positive definite matrix whose LDL^T decomposition encoded by L has been computed with  arb_mat_ldl1. The inverse is calculated using the method of  [Kri2013]& which is more efficient than solving AX = I with arb_mat_solve_ldl_precomp.5Flint2arb_mat_solve_ldl_precomp X L B prec Solves AX = B given the precomputed  A = LDL^T decomposition encoded by L. The matrices X and B1 are allowed to be aliased with each other, but X# is not allowed to be aliased with L.5Flint2 arb_mat_ldl res A prec  Computes the LDL^T decomposition of A, returning nonzero iff the symmetric matrix defined by the lower triangular part of A! is certainly positive definite.%If a nonzero value is returned, then res7 is set to a lower triangular matrix that encodes the  L * D * L^T decomposition of A. In particular, L is a lower triangular matrix with ones on its diagonal and whose strictly lower triangular region is the same as that of res. D8 is a diagonal matrix with the same diagonal as that of res.If zero is returned, then either the matrix is not symmetric positive definite, the input matrix was computed to insufficient precision, or the decomposition was attempted at insufficient precision.The underscore methods compute res from A in-place, leaving the strict upper triangular region undefined. The default method uses algorithm 4.1.2 from  [GVL1996].5Flint2arb_mat_spd_inv X A prec Sets  X = A^{-1} where A is a symmetric positive definite matrix. It is calculated using the method of  [Kri2013]9 which computes fewer intermediate results than solving AX = I with arb_mat_spd_solve.If A cannot be factored using Cholesky decomposition (indicating either that A is not symmetric positive definite or that the precision is insufficient), the values in the output matrix are left undefined and zero is returned. A nonzero return value guarantees that the symmetric matrix defined through the lower triangular part of A is invertible and that the exact inverse is contained in the output.5Flint2arb_mat_inv_cho_precomp X L prec Sets  X = A^{-1} where A is a symmetric positive definite matrix whose Cholesky decomposition L has been computed with  arb_mat_cho1. The inverse is calculated using the method of  [Kri2013]' which is more efficient than solving AX = I with arb_mat_solve_cho_precomp.5Flint2arb_mat_spd_solve X A B prec Solves AX = B where A. is a symmetric positive definite matrix and X and B are  n \times m( matrices, using Cholesky decomposition.If m > 0 and A cannot be factored using Cholesky decomposition (indicating either that A is not symmetric positive definite or that the precision is insufficient), the values in the output matrix are left undefined and zero is returned. A nonzero return value guarantees that the symmetric matrix defined through the lower triangular part of A is invertible and that the exact solution matrix is contained in the output.5Flint2arb_mat_solve_cho_precomp X L B prec Solves AX = B/ given the precomputed Cholesky decomposition  A = L L^T. The matrices X and B1 are allowed to be aliased with each other, but X# is not allowed to be aliased with L.5Flint2 arb_mat_cho L A prec 'Computes the Cholesky decomposition of A, returning nonzero iff the symmetric matrix defined by the lower triangular part of A! is certainly positive definite.%If a nonzero value is returned, then L2 is set to the lower triangular matrix such that  A = L * L^T.If zero is returned, then either the matrix is not symmetric positive definite, the input matrix was computed to insufficient precision, or the decomposition was attempted at insufficient precision.The underscore method computes L from A in-place, leaving the strict upper triangular region undefined.5Flint2arb_mat_approx_inv X A prec *These methods perform approximate solving without any error control. The radii in the input matrices are ignored, the computations are done numerically with floating-point arithmetic (using ordinary Gaussian elimination and triangular solving, accelerated through the use of block recursive strategies for large matrices), and the output matrices are set to the approximate floating-point results with zeroed error bounds.Approximate solutions are useful for computing preconditioning matrices for certified solutions. Some users may also find these methods useful for doing ordinary numerical linear algebra in applications where error bounds are not needed.6Flint2 arb_mat_det det A prec Sets det" to the determinant of the matrix A.The lu version uses Gaussian elimination with partial pivoting. If at some point an invertible pivot element cannot be found, the elimination is stopped and the magnitude of the determinant of the remaining submatrix is bounded using Hadamard's inequality.The precond5 version computes an approximate LU factorization of A and multiplies by the inverse L and U martices as preconditioners to obtain a matrix close to the identity matrix  [Rum2010]. An enclosure for this determinant is computed using Gershgorin circles. This is about four times slower than direct Gaussian elimination, but much more numerically stable.6The default version automatically selects between the lu and precond versions and additionally handles small or triangular matrices by direct formulas.6Flint2 arb_mat_inv X A prec Sets  X = A^{-1} where A5 is a square matrix, computed by solving the system AX = I.If A8 cannot be inverted numerically (indicating either that A is singular or that the precision is insufficient), the values in the output matrix are left undefined and zero is returned. A nonzero return value guarantees that the matrix is invertible and that the exact inverse is contained in the output.6Flint2arb_mat_solve_preapprox X A B R T prec Solves AX = B where A is a nonsingular  n \times n matrix and X and B are  n \times m# matrices, given an approximation R of the matrix inverse of A, and given the approximation T of the solution X.If m > 0 and A9 cannot be inverted numerically (indicating either that A= is singular or that the precision is insufficient, or that R7 is not a close enough approximation of the inverse of A), the values in the output matrix are left undefined and zero is returned. A nonzero return value guarantees that A is invertible and that the exact solution matrix is contained in the output.6Flint2arb_mat_solve_precond X A B prec Solves AX = B where A is a nonsingular  n \times n matrix and X and B are  n \times m matrices.If m > 0 and A9 cannot be inverted numerically (indicating either that A is singular or that the precision is insufficient), the values in the output matrix are left undefined and zero is returned. A nonzero return value guarantees that A is invertible and that the exact solution matrix is contained in the output.Three algorithms are provided:The lu version performs LU decomposition directly in ball arithmetic. This is fast, but the bounds typically blow up exponentially with n, even if the system is well-conditioned. This algorithm is usually the best choice at very high precision.The precond version computes an approximate inverse to precondition the system  [HS1967]. This is usually several times slower than direct LU decomposition, but the bounds do not blow up with n if the system is well-conditioned. This algorithm is usually the best choice for large systems at low to moderate precision.$The default version selects between lu and precomp automatically.The automatic choice should be reasonable most of the time, but users may benefit from trying either lu or precond- in specific applications. For example, the lu solver often performs better for ill-conditioned systems where use of very high precision is unavoidable.6Flint2arb_mat_solve_lu_precomp X perm LU B prec Solves AX = B5 given the precomputed nonsingular LU decomposition A = PLU. The matrices X and B1 are allowed to be aliased with each other, but X# is not allowed to be aliased with LU.6Flint2arb_mat_solve_triu X U B unit prec #Solves the lower triangular system LX = B! or the upper triangular system UX = B, respectively. If unit is set, the main diagonal of L or U is taken to consist of all ones, and in that case the actual entries on the diagonal are not read at all and can contain other data.The  classical: versions perform the computations iteratively while the  recursive versions perform the computations in a block recursive way to benefit from fast matrix multiplication. The default versions choose an algorithm automatically.6Flint2 arb_mat_lu perm LU A prec  Given an  n \times n matrix A , computes an LU decomposition PLU = A using Gaussian elimination with partial pivoting. The input and output matrices can be the same, performing the decomposition in-place.Entry i in the permutation vector perm is set to the row index in the input matrix corresponding to row i in the output matrix.:The algorithm succeeds and returns nonzero if it can find n invertible (i.e. not containing zero) pivot entries. This guarantees that the matrix is invertible.=The algorithm fails and returns zero, leaving the entries in P and LU undefined, if it cannot find n invertible pivot elements. In this case, either the matrix is singular, the input matrix was computed to insufficient precision, or the LU decomposition was attempted at insufficient precision.The  classical7 version uses Gaussian elimination directly while the  recursive version performs the computation in a block recursive way to benefit from fast matrix multiplication. The default version chooses an algorithm automatically.6Flint2arb_mat_scalar_div_arb B A c prec Sets B to A / c.6Flint2arb_mat_scalar_mul_arb B A c prec Sets B to  A \times c.6Flint2arb_mat_scalar_addmul_arb B A c prec Sets B to B + A \times c.6Flint2arb_mat_scalar_mul_2exp_si B A c Sets B to A multiplied by 2^c.6Flint2arb_mat_approx_mul res mat1 mat2 prec Approximate matrix multiplication. The input radii are ignored and the output matrix is set to an approximate floating-point result. The radii in the output matrix will not necessarily be zeroed.6Flint2_arb_mat_addmul_rad_mag_fast C A B ar ac bc Helper function for matrix multiplication. Adds to the radii of C4 the matrix product of the matrices represented by A and B, where A; is a linear array of coefficients in row-major order and B is a linear array of coefficients in column-major order. This function assumes that all exponents are small and is unsafe for general use.6Flint2arb_mat_pow_ui res mat exp prec Sets res to mat raised to the power exp. Requires that mat is a square matrix.6Flint2 arb_mat_sqr res mat prec Sets res to the matrix square of mat=. The operands must both be square with the same dimensions.6Flint2arb_mat_mul_entrywise C A B prec Sets C to the entrywise product of A and B.. The operands must have the same dimensions.6Flint2 arb_mat_mul res mat1 mat2 prec Sets res to the matrix product of mat1 and mat2. The operands must have compatible dimensions for matrix multiplication.The  classical< version performs matrix multiplication in the trivial way.The block version decomposes the input matrices into one or several blocks of uniformly scaled matrices and multiplies large blocks via  fmpz_mat_mul. It also invokes _arb_mat_addmul_rad_mag_fast( for the radius matrix multiplications.The threaded version performs classical multiplication but splits the computation over the number of threads returned by flint_get_num_threads().7The default version chooses an algorithm automatically.6Flint2 arb_mat_sub res mat1 mat2 prec Sets res to the difference of mat1 and mat2.. The operands must have the same dimensions.6Flint2 arb_mat_add res mat1 mat2 prec Sets res to the sum of mat1 and mat2.. The operands must have the same dimensions.6Flint2 arb_mat_neg dest src Sets dest to the exact negation of src.. The operands must have the same dimensions.6Flint2arb_mat_bound_frobenius_norm res A Sets res- to an upper bound for the Frobenius norm of A.6Flint2arb_mat_frobenius_norm res A prec Sets res to the Frobenius norm (i.e. the square root of the sum of squares of entries) of A.6Flint2arb_mat_bound_inf_norm b A Sets b to an upper bound for the infinity norm (i.e. the largest absolute value row sum) of A.6Flint2arb_mat_transpose dest src Sets dest to the exact transpose src. The operands must have compatible dimensions. Aliasing is allowed.6Flint2 arb_mat_dct mat type prec Sets mat8 to the DCT (discrete cosine transform) matrix of order n where n is the smallest dimension of mat (if mat is not square, the matrix is extended periodically along the larger dimension). There are many different conventions for defining DCT matrices; here, we use the normalized "DCT-II" transform matrix` A_{j,k} = \sqrt{\frac{2}{n}} \cos\left(\frac{\pi j}{n} \left(k+\frac{1}{2}\right)\right)which satisfies  A^{-1} = A^T. The type parameter is currently ignored and should be set to 0. In the future, it might be used to select a different convention.6Flint2arb_mat_stirling mat kind prec Sets mat? to a Stirling matrix, whose entries are Stirling numbers. If kind is 0, the entries are set to the unsigned Stirling numbers of the first kind. If kind is 1, the entries are set to the signed Stirling numbers of the first kind. If kind is 2, the entries are set to the Stirling numbers of the second kind.The entries are computed using recurrence relations. When the dimensions get large, some precision loss is possible; in that case, the user may wish to create the matrix at slightly higher precision and then round it to the final precision.6Flint2arb_mat_pascal mat  triangular prec Sets mat to a Pascal matrix, whose entries are binomial coefficients. If  triangular is 0, constructs a full symmetric matrix with the rows of Pascal's triangle as successive antidiagonals. If  triangular is 1, constructs the upper triangular matrix with the rows of Pascal's triangle as columns, and if  triangular is -1, constructs the lower triangular matrix with the rows of Pascal's triangle as rows.The entries are computed using recurrence relations. When the dimensions get large, some precision loss is possible; in that case, the user may wish to create the matrix at slightly higher precision and then round it to the final precision.6Flint2arb_mat_hilbert mat prec Sets mat+ to the Hilbert matrix, which has entries A_{j,k} = 1/(j+k+1).6Flint2arb_mat_indeterminate mat 6Sets all entries in the matrix to indeterminate (NaN).6Flint2 arb_mat_ones mat 'Sets all entries in the matrix to ones.6Flint2 arb_mat_one mat Sets the entries on the main diagonal to ones, and all other entries to zero.6Flint2 arb_mat_zero mat  Sets all entries in mat to zero.6Flint2arb_mat_is_diag mat Returns whether mat is a diagonal matrix; that is, all entries off the main diagonal are exactly zero.6Flint2arb_mat_is_tril mat Returns whether mat is lower triangular; that is, all entries above the main diagonal are exactly zero.6Flint2arb_mat_is_triu mat Returns whether mat is upper triangular; that is, all entries below the main diagonal are exactly zero.6Flint2arb_mat_is_finite mat Returns whether all entries in mat are finite.6Flint2arb_mat_is_zero mat Returns whether all entries in mat are exactly zero.6Flint2arb_mat_is_exact mat Returns whether all entries in mat have zero radius.6Flint2arb_mat_is_square mat Returns whether the number of rows is equal to the number of columns in mat.6Flint2arb_mat_is_empty mat ?Returns whether the number of rows or the number of columns in mat is zero.6Flint2 arb_mat_ne mat1 mat2 Returns whether mat1 and mat2- certainly do not represent the same matrix.6Flint2 arb_mat_eq mat1 mat2 Returns whether mat1 and mat2% certainly represent the same matrix.6Flint2arb_mat_contains_fmpq_mat mat1 mat2 Returns whether the matrices have the same dimensions and each entry in mat2, is contained in the corresponding entry in mat1.6Flint2arb_mat_overlaps mat1 mat2 Returns whether the matrices have the same dimensions and each entry in mat1* overlaps with the corresponding entry in mat2.6Flint2 arb_mat_equal mat1 mat2 Returns whether the matrices have the same dimensions and identical intervals as entries.6Flint2arb_mat_fprintd file mat digits Prints each entry in the matrix with the specified number of decimal digits to the stream file.6Flint2arb_mat_randtest mat state prec mag_bits Sets mat to a random matrix with up to prec6 bits of precision and with exponents of width up to mag_bits.6Flint2arb_mat_set_fmpq_mat dest src prec Sets dest to src.. The operands must have identical dimensions.6Flint2arb_mat_window_clear window Frees the window matrix.6Flint2arb_mat_window_init window mat r1 c1 r2 c2  Initializes window* to a window matrix into the submatrix of mat starting at the corner at row r1 and column c1 (inclusive) and ending at row r2 and column c2 (exclusive).6Flint2arb_mat_allocated_bytes x Returns the total number of bytes heap-allocated internally by this object. The count excludes the size of the structure itself. Add sizeof(arb_mat_struct)* to get the size of the object as a whole.6Flint2 arb_mat_clear mat ,Clears the matrix, deallocating all entries.6Flint2 arb_mat_init mat r c ;Initializes the matrix, setting it to the zero matrix with r rows and c columns.6Flint2arb_mat_printd mat digits Prints each entry in the matrix with the specified number of decimal digits.55555555555555555555555555555555566666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666b Safe-Inferred )*1+5555555555555555555555555555555556666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666655556666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666655555555555555555555555555555c Safe-Inferred )*1d Safe-Inferred )*1N6Flint2acb_mat_eig_multiple E A E_approx R_approx prec *Computes all the eigenvalues of the given n by n matrix A!. On success, the output vector E contains n9 complex intervals, each representing one eigenvalue of A with the correct multiplicities in case of overlap. The output intervals are either disjoint or identical, and identical intervals are guaranteed to be grouped consecutively. Each complete run of k; identical intervals thus represents a cluster of exactly k eigenvalues which could not be separated from each other at the current precision, but which could be isolated from the other n - k eigenvalues of the matrix.!The user supplies approximations E_approx and R_approx of the eigenvalues and the right eigenvectors. The initial approximations can, for instance, be computed using acb_mat_approx_eig_qr2. No assumptions are made about the structure of A- or the quality of the given approximations.The rump algorithm groups approximate eigenvalues that are close and calls acb_mat_eig_enclosure_rump9 repeatedly to validate each cluster. The complexity is O(m n^3) for m clusters.The default version, as currently implemented, first attempts to call $acb_mat_eig_simple_vdhoeven_mourrain hoping that the eigenvalues are actually simple. It then uses the rump algorithm as a fallback.6Flint2acb_mat_eig_simple E L R A E_approx R_approx prec Computes all the eigenvalues (and optionally corresponding eigenvectors) of the given n by n matrix A.Attempts to prove that A has n simple (isolated) eigenvalues, returning 1 if successful and 0 otherwise. On success, isolating complex intervals for the eigenvalues are written to the vector E, in no particular order. If L is not NULL, enclosures of the corresponding left eigenvectors are written to the rows of L. If R is not NULL, enclosures of the corresponding right eigenvectors are written to the columns of R.-The left eigenvectors are normalized so that  L = R^{-1}#. This produces a diagonalization LAR = D where D- is the diagonal matrix with the entries in E on the diagonal.!The user supplies approximations E_approx and R_approx of the eigenvalues and the right eigenvectors. The initial approximations can, for instance, be computed using acb_mat_approx_eig_qr2. No assumptions are made about the structure of A- or the quality of the given approximations.Two algorithms are implemented:The rump version calls acb_mat_eig_enclosure_rump repeatedly to certify eigenvalue-eigenvector pairs one by one. The iteration is stopped to return non-success if a new eigenvalue overlaps with previously computed one. Finally, L= is computed by a matrix inversion. This has complexity O(n^4).The vdhoeven_mourrain version uses the algorithm in  [HM2017] to certify all eigenvalues and eigenvectors in one step. This has complexity O(n^3).#The default version currently uses vdhoeven_mourrain.By design, these functions terminate instead of attempting to compute eigenvalue clusters if some eigenvalues cannot be isolated. To compute all eigenvalues of a matrix allowing for overlap, acb_mat_eig_multiple_rump may be used as a fallback, or acb_mat_eig_multiple may be used in the first place.6Flint2acb_mat_eig_enclosure_rump lambda J R A  lambda_approx R_approx prec  Given an n by n matrix A1 and an approximate eigenvalue-eigenvector pair  lambda_approx and R_approx (where R_approx is an n& by 1 matrix), computes an enclosure lambda; guaranteed to contain at least one of the eigenvalues of A, along with an enclosure R( for a corresponding right eigenvector.More generally, this function can handle clustered (or repeated) eigenvalues. If R_approx is an n by k matrix containing approximate eigenvectors for a presumed cluster of k eigenvalues near  lambda_approx&, this function computes an enclosure lambda! guaranteed to contain at least k eigenvalues of A along with a matrix R( guaranteed to contain a basis for the k-dimensional invariant subspace associated with these eigenvalues. Note that for multiple eigenvalues, determining the individual eigenvectors is an ill-posed problem; describing an enclosure of the invariant subspace is the best we can hope for.For k = 1, it is guaranteed that AR - R \lambda contains the zero matrix. For k > 27, this cannot generally be guaranteed (in particular, A might not diagonalizable). In this case, we can still compute an approximately diagonal k by k interval matrix J \approx \lambda I such that AR - RJ is guaranteed to contain the zero matrix. This matrix has the property that the Jordan canonical form of (any exact matrix contained in) A has a k by k submatrix equal to the Jordan canonical form of (some exact matrix contained in) J . The output J is optional (the user can pass NULL to omit it).&The algorithm follows section 13.4 in  [Rum2010], corresponding to the  verifyeig() routine in INTLAB. The initial approximations can, for instance, be computed using acb_mat_approx_eig_qr2. No assumptions are made about the structure of A- or the quality of the given approximations.6Flint2acb_mat_eig_global_enclosure eps A E R prec  Given an n by n matrix A , a length-n vector E2 containing approximations of the eigenvalues of A , and an n by n matrix R containing approximations of the corresponding right eigenvectors, computes a rigorous bound  \varepsilon such that every eigenvalue \lambda of A satisfies *|\lambda - \hat \lambda_k| \le \varepsilon for some \hat \lambda_k in E*. In other words, the union of the balls 2B_k = \{z : |z - \hat \lambda_k| \le \varepsilon\}9 is guaranteed to be an enclosure of all eigenvalues of A./Note that there is no guarantee that each ball B_k can be identified with a single eigenvalue: it is possible that some balls contain several eigenvalues while other balls contain no eigenvalues. In other words, this method is not powerful enough to compute isolating balls for the individual eigenvalues (or even for clusters of eigenvalues other than the whole spectrum). Nevertheless, in practice the balls B_k will represent eigenvalues one-to-one with high probability if the given approximations are good.:The output can be used to certify that all eigenvalues of A lie in some region of the complex plane (such as a specific half-plane, strip, disk, or annulus) without the need to certify the individual eigenvalues. The output is easily converted into lower or upper bounds for the absolute values or real or imaginary parts of the spectrum, and with high probability these bounds will be tight. Using acb_add_error_mag and  acb_union0, the output can also be converted to a single acb_t! enclosing the whole spectrum of A in a rectangle, but note that to test whether a condition holds for all eigenvalues of A?, it is typically better to iterate over the individual balls B_k. 0 and A9 cannot be inverted numerically (indicating either that A is singular or that the precision is insufficient), the values in the output matrix are left undefined and zero is returned. A nonzero return value guarantees that A is invertible and that the exact solution matrix is contained in the output.Three algorithms are provided:The lu version performs LU decomposition directly in ball arithmetic. This is fast, but the bounds typically blow up exponentially with n, even if the system is well-conditioned. This algorithm is usually the best choice at very high precision.The precond version computes an approximate inverse to precondition the system. This is usually several times slower than direct LU decomposition, but the bounds do not blow up with n if the system is well-conditioned. This algorithm is usually the best choice for large systems at low to moderate precision.$The default version selects between lu and precomp automatically.The automatic choice should be reasonable most of the time, but users may benefit from trying either lu or precond- in specific applications. For example, the lu solver often performs better for ill-conditioned systems where use of very high precision is unavoidable.7Flint2acb_mat_solve_lu_precomp X perm LU B prec Solves AX = B5 given the precomputed nonsingular LU decomposition A = PLU. The matrices X and B1 are allowed to be aliased with each other, but X# is not allowed to be aliased with LU.7Flint2acb_mat_solve_triu X U B unit prec #Solves the lower triangular system LX = B! or the upper triangular system UX = B, respectively. If unit is set, the main diagonal of L or U is taken to consist of all ones, and in that case the actual entries on the diagonal are not read at all and can contain other data.The  classical: versions perform the computations iteratively while the  recursive versions perform the computations in a block recursive way to benefit from fast matrix multiplication. The default versions choose an algorithm automatically.7Flint2 acb_mat_lu perm LU A prec  Given an  n \times n matrix A , computes an LU decomposition PLU = A using Gaussian elimination with partial pivoting. The input and output matrices can be the same, performing the decomposition in-place.Entry i in the permutation vector perm is set to the row index in the input matrix corresponding to row i in the output matrix.:The algorithm succeeds and returns nonzero if it can find n invertible (i.e. not containing zero) pivot entries. This guarantees that the matrix is invertible.=The algorithm fails and returns zero, leaving the entries in P and LU undefined, if it cannot find n invertible pivot elements. In this case, either the matrix is singular, the input matrix was computed to insufficient precision, or the LU decomposition was attempted at insufficient precision.The  classical7 version uses Gaussian elimination directly while the  recursive version performs the computation in a block recursive way to benefit from fast matrix multiplication. The default version chooses an algorithm automatically.7Flint2acb_mat_scalar_div_acb B A c prec Sets B to A / c.7Flint2acb_mat_scalar_mul_acb B A c prec Sets B to  A \times c.7Flint2acb_mat_scalar_addmul_acb B A c prec Sets B to B + A \times c.7Flint2acb_mat_scalar_mul_2exp_si B A c Sets B to A multiplied by 2^c.7Flint2acb_mat_approx_mul res mat1 mat2 prec Approximate matrix multiplication. The input radii are ignored and the output matrix is set to an approximate floating-point result. For performance reasons, the radii in the output matrix will not necessarily be written (zeroed), but will remain zero if they are already zeroed in res before calling this function.7Flint2acb_mat_pow_ui res mat exp prec Sets res to mat raised to the power exp. Requires that mat is a square matrix.7Flint2 acb_mat_sqr res mat prec Sets res to the matrix square of mat=. The operands must both be square with the same dimensions.7Flint2acb_mat_mul_entrywise res mat1 mat2 prec Sets res to the entrywise product of mat1 and mat2.. The operands must have the same dimensions.7Flint2 acb_mat_mul res mat1 mat2 prec Sets res to the matrix product of mat1 and mat2. The operands must have compatible dimensions for matrix multiplication.The  classical< version performs matrix multiplication in the trivial way.The threaded version performs classical multiplication but splits the computation over the number of threads returned by flint_get_num_threads().The reorder version reorders the data and performs one to four real matrix multiplications via  arb_mat_mul.7The default version chooses an algorithm automatically.7Flint2 acb_mat_sub res mat1 mat2 prec Sets res to the difference of mat1 and mat2.. The operands must have the same dimensions.7Flint2 acb_mat_add res mat1 mat2 prec Sets res to the sum of mat1 and mat2.. The operands must have the same dimensions.7Flint2 acb_mat_neg dest src Sets dest to the exact negation of src.. The operands must have the same dimensions.7Flint2acb_mat_bound_frobenius_norm res A Sets res- to an upper bound for the Frobenius norm of A.7Flint2acb_mat_frobenius_norm res A prec Sets res to the Frobenius norm (i.e. the square root of the sum of squares of entries) of A.7Flint2acb_mat_bound_inf_norm b A Sets b to an upper bound for the infinity norm (i.e. the largest absolute value row sum) of A.7Flint2acb_mat_conjugate dest src Sets dest) to the elementwise complex conjugate of src.7Flint2acb_mat_conjugate_transpose dest src Sets dest to the conjugate transpose of src. The operands must have compatible dimensions. Aliasing is allowed.7Flint2acb_mat_transpose dest src Sets dest to the exact transpose src. The operands must have compatible dimensions. Aliasing is allowed.7Flint2 acb_mat_dft mat type prec Sets mat9 to the DFT (discrete Fourier transform) matrix of order n where n is the smallest dimension of mat (if mat is not square, the matrix is extended periodically along the larger dimension). Here, we use the normalized DFT matrix` A_{j,k} = \frac{\omega^{jk}}{\sqrt{n}}, \quad \omega = e^{-2\pi i/n}.The type parameter is currently ignored and should be set to 0. In the future, it might be used to select a different convention.7Flint2acb_mat_indeterminate mat 6Sets all entries in the matrix to indeterminate (NaN).7Flint2 acb_mat_ones mat 'Sets all entries in the matrix to ones.7Flint2 acb_mat_one mat Sets the entries on the main diagonal to ones, and all other entries to zero.7Flint2 acb_mat_zero mat  Sets all entries in mat to zero.7Flint2acb_mat_is_diag mat Returns whether mat is a diagonal matrix; that is, all entries off the main diagonal are exactly zero.7Flint2acb_mat_is_tril mat Returns whether mat is lower triangular; that is, all entries above the main diagonal are exactly zero.7Flint2acb_mat_is_triu mat Returns whether mat is upper triangular; that is, all entries below the main diagonal are exactly zero.7Flint2acb_mat_is_finite mat Returns whether all entries in mat are finite.7Flint2acb_mat_is_zero mat Returns whether all entries in mat are exactly zero.7Flint2acb_mat_is_exact mat Returns whether all entries in mat have zero radius.7Flint2acb_mat_is_square mat Returns whether the number of rows is equal to the number of columns in mat.7Flint2acb_mat_is_empty mat ?Returns whether the number of rows or the number of columns in mat is zero.7Flint2acb_mat_is_real mat Returns whether all entries in mat have zero imaginary part.7Flint2 acb_mat_ne mat1 mat2 Returns whether mat1 and mat2- certainly do not represent the same matrix.7Flint2 acb_mat_eq mat1 mat2 Returns whether mat1 and mat2% certainly represent the same matrix.7Flint2acb_mat_contains_fmpq_mat mat1 mat2 Returns whether the matrices have the same dimensions and each entry in mat2, is contained in the corresponding entry in mat1.7Flint2acb_mat_overlaps mat1 mat2 Returns whether the matrices have the same dimensions and each entry in mat1* overlaps with the corresponding entry in mat2.7Flint2 acb_mat_equal mat1 mat2 Returns whether the matrices have the same dimensions and identical intervals as entries.7Flint2acb_mat_fprintd file mat digits Prints each entry in the matrix with the specified number of decimal digits to the stream file.7Flint2acb_mat_fprintd file mat digits Prints each entry in the matrix with the specified number of decimal digits to the stream file.7Flint2acb_mat_randtest_eig mat state E prec Sets mat to a random matrix with the prescribed eigenvalues supplied as the vector E. The output matrix is required to be square. We generate a random unitary matrix via a matrix exponential, and then evaluate an inverse Schur decomposition.7Flint2acb_mat_randtest mat state prec mag_bits Sets mat to a random matrix with up to prec6 bits of precision and with exponents of width up to mag_bits.7Flint2acb_mat_set_round_arb_mat dest src prec Sets dest to src.. The operands must have identical dimensions.7Flint2acb_mat_window_init window mat r1 c1 r2 c2  Initializes window* to a window matrix into the submatrix of mat starting at the corner at row r1 and column c1 (inclusive) and ending at row r2 and column c2 (exclusive).7Flint2acb_mat_allocated_bytes x Returns the total number of bytes heap-allocated internally by this object. The count excludes the size of the structure itself. Add sizeof(acb_mat_struct)* to get the size of the object as a whole.7Flint2 acb_mat_clear mat ,Clears the matrix, deallocating all entries.7Flint2 acb_mat_init mat r c ;Initializes the matrix, setting it to the zero matrix with r rows and c columns.7Flint2acb_mat_printd mat digits Prints each entry in the matrix with the specified number of decimal digits.7Flint2acb_mat_printn mat digits optionsPrints each entry in the matrix with the specified number of decimal digits.66666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777d Safe-Inferred )*1P6666666666666666666666666666666666677777777777777777777777777777777777777777777777777777777777777777777777777777777777777777766667777777777777777777777777777777777777777777777777777777777777777777777777777777777777777776666666666666666666666666666666e Safe-Inferred )*1RR Safe-Inferred )*17Flint2fmpz_lll_with_removal B U gs_B fl Reduces B in place according to the parameters specified by the LLL context object fl and removes vectors whose squared Gram-Schmidt length is greater than the bound gs_B,. The return value is the new dimension of B* to be considered for further computation.This is the main LLL with removals function which should be called by the user. Like fmpz_lll it calls ULLL, but it also sets the Gram-Schmidt bound to that supplied and does removals.7Flint2fmpz_lll B U fl Reduces B in place according to the parameters specified by the LLL context object fl.This is the main LLL function which should be called by the user. It currently calls the ULLL algorithm (without removals). The ULLL function in turn calls a LLL wrapper which tries to choose an optimal LLL algorithm, starting with a version using just doubles (ULLL tries to maximise usage of this), then a heuristic LLL a full precision floating point LLL if required.U is the matrix used to capture the unimodular transformations if it is not NULL. An exception is raised if  U != NULL and  U->r != d, where d is the lattice dimension. fl is the context object containing information containing the LLL parameters delta and eta. The function can perform reduction on both the lattice basis as well as its Gram matrix. The type of lattice representation can be specified via the parameter fl->rt. The type of Gram matrix to be used in computation (approximate or exact) can also be specified through the variable fl->gt (applies only if fl->rt == Z\_BASIS).7Flint2fmpz_lll_storjohann_ulll FM new_size fl Performs ULLL using fmpz_mat_lll_storjohann as the LLL function.7Flint2fmpz_lll_is_reduced B fl prec The return from these functions is always conclusive: the functions * fmpz_mat_is_reduced or fmpz_mat_is_reduced_gram *  fmpz_mat_is_reduced_with_removal or %fmpz_mat_is_reduced_gram_with_removal are optimzied by calling the above heuristics first and returning right away if they give a conclusive answer.7Flint2fmpz_lll_is_reduced_d B fl A non-zero return indicates the matrix is definitely reduced, that is, that * fmpz_mat_is_reduced or fmpz_mat_is_reduced_gram (for the first two) *  fmpz_mat_is_reduced_with_removal or %fmpz_mat_is_reduced_gram_with_removal (for the last two) return non-zero. A zero return value is inconclusive. The _d9 variants are performed in machine precision, while the _mpfr uses a precision of prec bits.7Flint2fmpz_lll_with_removal_ulll FM UM new_size gs_B fl ULLL is a new style of LLL which does adjoins an identity matrix to the input lattice FM", then scales the lattice down to new_size bits and reduces this augmented lattice. This tends to be more stable numerically than traditional LLL which means higher dimensions can be attacked using doubles. In each iteration a new identity matrix is adjoined to the truncated lattice. UM; is used to capture the unimodular transformations, while gs_B and fl have the same role as in the previous routines. The function is optimised for factoring polynomials.7Flint2&fmpz_lll_wrapper_with_removal_knapsack B U gs_B fl A wrapper of the procedures implementing the LLL specialized to knapsack-type lattices. It begins with the greediest version and the engine of this version, ( fmpz_lll_d_with_removal_knapsack), then adapts to the version using heuristic inner products only (!fmpz_lll_d_heuristic_with_removal) if fl->rt == Z\_BASIS and fl->gt == APPROX#, and finally to the mpf version (fmpz_lll_mpf_with_removal ) if needed.7Flint2 fmpz_lll_d_with_removal_knapsack B U gs_B fl This is floating point LLL specialized to knapsack-type lattices. It performs early size reductions occasionally which makes things faster in the knapsack case. Otherwise, it is similar to fmpz_lll_d_with_removal.7Flint2fmpz_lll_wrapper_with_removal B U gs_B fl A wrapper of the procedures implementing the base case LLL with the addition of the removal boundary. It begins with the greediest version (fmpz_lll_d_with_removal), then adapts to the version using heuristic inner products only (!fmpz_lll_d_heuristic_with_removal) if fl->rt == Z\_BASIS and fl->gt == APPROX#, and finally to the mpf version (fmpz_lll_mpf_with_removal ) if needed.7Flint2fmpz_lll_mpf_with_removal B U gs_B fl  A wrapper of fmpz_lll_mpf2_with_removal. This currently begins with prec == D\_BITS, then for the first 20 loops, increases the precision one limb at a time. After 20 loops, it doubles the precision each time. There is a proof that this will eventually work. The return value of this function is the new dimension of B if removals are desired or -1 if the precision maxes out before B is LLL-reduced.7Flint2fmpz_lll_mpf2_with_removal B U prec gs_B fl Same as  fmpz_lll_mpf2 but with a removal bound, gs_B,. The return value is the new dimension of B if removals are desired.7Flint2!fmpz_lll_d_heuristic_with_removal B U gs_B fl Same as fmpz_lll_d_heuristic but with a removal bound, gs_B,. The return value is the new dimension of B if removals are desired.7Flint2fmpz_lll_d_with_removal B U gs_B fl Same as  fmpz_lll_d but with a removal bound, gs_B,. The return value is the new dimension of B if removals are desired.7Flint2fmpz_lll_wrapper B U fl A wrapper of the above procedures. It begins with the greediest version ( fmpz_lll_d), then adapts to the version using heuristic inner products only (fmpz_lll_d_heuristic) if fl->rt == Z\_BASIS and fl->gt == APPROX", and finally to the mpf version ( fmpz_lll_mpf ) if needed.U is the matrix used to capture the unimodular transformations if it is not NULL. An exception is raised if  U != NULL and  U->r != d, where d is the lattice dimension. fl is the context object containing information containing the LLL parameters delta and eta. The function can perform reduction on both the lattice basis as well as its Gram matrix. The type of lattice representation can be specified via the parameter fl->rt. The type of Gram matrix to be used in computation (approximate or exact) can also be specified through the variable fl->gt (applies only if fl->rt == Z\_BASIS).7Flint2 fmpz_lll_mpf B U fl  A wrapper of  fmpz_lll_mpf2. This currently begins with prec == D_BITS, then for the first 20 loops, increases the precision one limb at a time. After 20 loops, it doubles the precision each time. There is a proof that this will eventually work. The return value of this function is 0 if the LLL is successful or -1 if the precision maxes out before B is LLL-reduced.7Flint2 fmpz_lll_mpf2 B U prec fl This is LLL using mpf with the given precision, prec% for the underlying GSO. It reduces B- in place like the other LLL functions. The mpf2, in the function name refers to the way the mpf_t's are initialised.7Flint2fmpz_lll_d_heuristic B U fl This LLL reduces B0 in place using doubles only. It is similar to  fmpz_lll_d but only uses the heuristic inner products which attempt to detect cancellations.7Flint2 fmpz_lll_d B U fl This is a mildly greedy version of floating point LLL using doubles only. It tries the fast version of the Babai algorithm (fmpz_lll_check_babai>). If that fails, then it switches to the heuristic version ( fmpz_lll_check_babai_heuristic_d) for only one loop and switches right back to the fast version. It reduces B in place. U is the matrix used to capture the unimodular transformations if it is not NULL. An exception is raised if  U != NULL and  U->r != d, where d is the lattice dimension. fl is the context object containing information containing the LLL parameters delta and eta. The function can perform reduction on both the lattice basis as well as its Gram matrix. The type of lattice representation can be specified via the parameter fl->rt. The type of Gram matrix to be used in computation (approximate or exact) can also be specified through the variable fl->gt (applies only if fl->rt == Z\_BASIS).7Flint2fmpz_lll_shift B Computes the largest number of non-zero entries after the diagonal in B.7Flint2(fmpz_lll_advance_check_babai_heuristic_d  cur_kappa kappa B U mu r s appB expo A a zeros kappamax n fl Same as fmpz_lll_advance_check_babai but using the heuristic inner product rather than a purely floating point inner product. The heuristic will compute at full precision when there is cancellation.7Flint2fmpz_lll_advance_check_babai  cur_kappa kappa B U mu r s appB expo A a zeros kappamax n fl This is a Babai procedure which is used when size reducing a vector beyond an index which LLL has reached.  cur_kappa* is the index behind which we can assume B is LLL reduced, while kappa is the vector to be reduced. This procedure only size reduces the kappa-th row by vectors upto  cur_kappa, textbf{not}  kappa - 1.7Flint2fmpz_lll_check_babai_heuristic kappa B U mu r s appB A a zeros kappamax n tmp rtmp prec fl This function is like the mpf version of  fmpz_lll_check_babai_heuristic_d,. However, it also inherits some temporary mpf_t variables tmp and rtmp.7Flint2 fmpz_lll_check_babai_heuristic_d kappa B U mu r s appB expo A a zeros kappamax n fl Same as fmpz_lll_check_babai but using the heuristic inner product rather than a purely floating point inner product. The heuristic will compute at full precision when there is cancellation.7Flint2fmpz_lll_check_babai kappa B U mu r s appB expo A a zeros kappamax n fl /Performs floating point size reductions of the kappa -th row of B+ by all of the previous rows, uses d_mats mu and r for storing the GSO data. U is used to capture the unimodular transformations if it is not NULL. The double array s will contain the size of the kappa(-th row if it were moved into position i . The d_mat appB is an approximation of B0 with each row receiving an exponent stored in expo2 which gets populated only when needed. The d_mat A->appSP is an approximation of the Gram matrix whose entries are scalar products of the rows of B and is used when fl->gt == APPROX. When fl->gt == EXACT the fmpz_mat  A->exactSP- (the exact Gram matrix) is used. The index a; is the smallest row index which will be reduced from the kappa-th row. Index zeros, is the number of zero rows in the matrix. kappamax? is the highest index which has been size-reduced so far, and n0 is the number of columns you want to consider. fl is an LLL (L^2) context object. The output is the value -1 if the process fails (usually due to insufficient precision) or 0 if everything was successful. These descriptions will be true for the future Babai procedures as well.7Flint2fmpz_lll_heuristic_dot vec1 vec2 len2 B k j exp_adj 3Computes the dot product of two vectors of doubles vec1 and vec2, which are respectively double9 approximations (up to scaling by a power of 2) to rows k and j in the exact integer matrix B. If massive cancellation is detected an exact computation is made.#The exact computation is scaled by  2^{-exp_adj }, where exp_adj = r2 + r1 where r2 is the exponent for row j and r1 is the exponent for row k (i.e. row j2 is notionally thought of as being multiplied by 2^{r2}, etc.).The final dot product computed by this function is then notionally the return value times  2^{exp_adj}.7Flint2fmpz_lll_randtest fl state Sets  fl->delta and fl->eta# to random values in the interval  (0.25, 1) and (0.5, sqrt{delta}) respectively. fl->rt is set to GRAM or Z\_BASIS and fl->gt is set to APPROX or EXACT in a pseudo random way.7Flint2fmpz_lll_context_init fl delta eta rt gt Sets  fl->delta, fl->eta, fl->rt and fl->gt to delta, eta, rt and gt (given as input) respectively. delta and eta are the L^2 parameters. delta and eta must lie in the intervals  (0.25, 1) and (0.5, sqrt{delta9}) respectively. The representation type is input using rt and can have the values Z\_BASIS for a lattice basis and GRAM for a Gram matrix. The Gram type to be used during computation can be specified using gt which can assume the values APPROX and EXACT . Note that gt has meaning only when rt is Z\_BASIS.7Flint2fmpz_lll_context_init_default fl Sets  fl->delta, fl->eta, fl->rt and fl->gt' to their default values, 0.99, 0.51, Z\_BASIS and APPROX respectively.,77777777777777777777777777777777777778888888f Safe-Inferred )*1,77777777777777777777777777777777777778888888,77777777888877788877777777777777777777777777 Safe-Inferred )*18Flint2_mpf_vec_norm2 res vec len prec Sets res( to the square of the Euclidean norm of  (vec, len). The temporary variable used has its precision set to be at least prec bits.8Flint2 _mpf_vec_dot2 res vec1 vec2 len2 prec Sets res to the dot product of  (vec1, len2) with  (vec2, len2). The temporary variable used has its precision set to be at least prec bits. Returns 0 if a probable cancellation is detected, and otherwise returns a non-zero value.8Flint2 _mpf_vec_norm res vec len Sets res( to the square of the Euclidean norm of  (vec, len).8Flint2 _mpf_vec_dot res vec1 vec2 len2 Sets res to the dot product of  (vec1, len2) with  (vec2, len2).8Flint2_mpf_vec_scalar_mul_2exp res vec len exp 3Multiplies the given vector of the given length by 2^exp.8Flint2_mpf_vec_scalar_mul_mpf res vec len c 6Multiplies the vector with given length by the scalar c and sets res to the result.8Flint2 _mpf_vec_sub res vec1 vec2 len2 Sets  (res, len2) to  (vec1, len2) minus  (vec2, len2).8Flint2 _mpf_vec_add res vec1 vec2 len2 Adds the given vectors of the given length together and stores the result in res.8Flint2_mpf_vec_approx_equal vec1 vec2 len bits 5Compares two vectors of the given length and returns 1 if the first bits4 bits of their entries are equal, otherwise returns 0.8Flint2_mpf_vec_is_zero vec len Returns 1 if  (vec, len) is zero, and 0 otherwise.8Flint2_mpf_vec_equal vec1 vec2 len 5Compares two vectors of the given length and returns 1' if they are equal, otherwise returns 0.8Flint2_mpf_vec_set_fmpz_vec appv vec len Export the array of len! entries starting at the pointer vec to an array of mpfs appv.8Flint2 _mpf_vec_set vec1 vec2 len2 Copies the vector vec2 of the given length into vec1. A check is made to ensure vec1 and vec2 are different.8Flint2 _mpf_vec_zero vec len Zeros the vector  (vec, len).8Flint2_mpf_vec_randtest f state len bits Sets the entries of a vector of the given length to random numbers in the interval [0, 1) with bits significant bits in the mantissa or less if their precision is smaller.8Flint2_mpf_vec_clear vec len Clears the given vector.8Flint2 _mpf_vec_init len 4Returns a vector of the given length of initialised mpf&'s with at least the given precision.88888888888888888g Safe-Inferred )*18888888888888888888888888888888888 Safe-Inferred )*1 8Flint2mpfr_mat_mul_classical C A B rnd Set C to the product of A and B> with the given rounding mode, using the classical algorithm.8Flint2mpfr_mat_randtest mat state Generate a random matrix with random number of rows and columns and random entries for use in test code.8Flint2mpfr_mat_equal mat1 mat2 Return 18 if the two given matrices are equal, otherwise return 0.8Flint2 mpfr_mat_zero mat Set mat to the zero matrix.8Flint2 mpfr_mat_set mat1 mat2 Set mat1 to the value of mat2.8Flint2mpfr_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.8Flint2 mpfr_mat_swap mat1 mat2 Efficiently swap matrices mat1 and mat2.8Flint2mpfr_mat_clear mat Clears the given matrix.8Flint2 mpfr_mat_init mat rows cols prec Initialises a matrix with the given number of rows and columns and the given precision for use. The precision is the exact precision of the entries.88888888888888888h Safe-Inferred )*18888888888888888888888888888888888 Safe-Inferred )*1b8Flint2_mpfr_vec_scalar_product res vec1 vec2 len Sets res to the scalar product of  (vec1, len) with  (vec2, len) . Assumes len > 0.8Flint2_mpfr_vec_scalar_mul_2exp res vec len exp 3Multiplies the given vector of the given length by 2^exp.8Flint2_mpfr_vec_scalar_mul_mpfr res vec len c 6Multiplies the vector with given length by the scalar c and sets res to the result.8Flint2 _mpfr_vec_add res vec1 vec2 len Adds the given vectors of the given length together and stores the result in res.8Flint2 _mpfr_vec_set vec1 vec2 len Copies the vector vec2 of the given length into vec1. No check is made to ensure vec1 and vec2 are different.8Flint2_mpfr_vec_zero vec len Zeros the vector  (vec, len).8Flint2_mpfr_vec_clear vec len Clears the given vector.8Flint2_mpfr_vec_init len prec 4Returns a vector of the given length of initialised mpfr#'s with the given exact precision.88888888i Safe-Inferred )*18888888888888888 Safe-Inferred )*18Flint2 n_factor_ecm f curves B1 B2 state n 9Outer wrapper function for the ECM algorithm. It factors n which must fit into a  mp_limb_t.The function calls stage I and II, and the precomputations (builds  prime_array for stage I,  GCD_table and  prime_table for stage II).f is set as the factor if found. curves. is the number of random curves being tried. B1, B2. are the two bounds or stage I and stage II. n is the number being factored.!If a factor is found in stage I, 11 is returned. If a factor is found in stage II, 2? is returned. If a factor is found while selecting the curve, -1 is returned. Otherwise 0 is returned.8Flint2n_factor_ecm_stage_II f B1 B2 P n  n_ecm_inf -Stage II implementation of the ECM algorithm.f is set as the factor if found. B1, B2 are the two bounds. P+ is the primorial (approximately equal to  \sqrt{B2}). n is the number being factored.If the factor is found, 1 is returned, otherwise 0.8Flint2n_factor_ecm_stage_I f  prime_array num B1 n  n_ecm_inf ,Stage I implementation of the ECM algorithm.f is set as the factor if found. num is number of prime numbers <= the bound B1.  prime_array is an array of first B1 primes. n is the number being factored.If the factor is found, 1 is returned, otherwise 0.8Flint2n_factor_ecm_select_curve f sigma n  n_ecm_inf 7Selects a random elliptic curve given a random integer sigma, according to Suyama's parameterization. If the factor is found while selecting the curve, 18 is returned. In case the curve found is not suitable, 0 is returned.Also selects the initial point x_0, and the value of  (a + 2)/4 , where a is a curve parameter. Sets z_0 as 1 (shifted left by n_ecm_inf->normbits). All these are stored in the n_ecm_t struct.The curve selected is of Montgomery form, the points selected satisfy the curve and are projective coordinates.8Flint2"n_factor_ecm_mul_montgomery_ladder x z x0 z0 k n  n_ecm_inf Montgomery ladder algorithm for scalar multiplication of elliptic points.Sets the point (x : z) to  k(x_0 : z_0) modulo n.Valid only for points expressed in Montgomery projective coordinates.8Flint2n_factor_ecm_add x z x1 z1 x2 z2 x0 z0 n  n_ecm_inf Sets the point (x : z) to the sum of  (x_1 : z_1) and  (x_2 : z_2) modulo n, given the difference  (x_0 : z_0) according to the formulaThis group doubling is valid only for points expressed in Montgomery projective coordinates.8Flint2n_factor_ecm_double x z x0 z0 n  n_ecm_inf Sets the point (x : z) to two times  (x_0 : z_0) modulo n according to the formula-x = (x_0 + z_0)^2 \cdot (x_0 - z_0)^2 \mod n,z = 4 x_0 z_0 \left((x_0 - z_0)^2 + 4a_{24}x_0z_0\right) \mod n.This group doubling is valid only for points expressed in Montgomery projective coordinates.8Flint2n_discrete_log_bsgs b a n "Returns the discrete logarithm of b with respect to a$ in the multiplicative subgroup of \mathbb{Z}/n\mathbb{Z} when \mathbb{Z}/n\mathbb{Z}) is cyclic. That is, it returns a number x such that a^x = b \bmod n3. The multiplicative subgroup is only cyclic when n is 2, 4, p^k, or 2p^k where p is an odd prime and k is a positive integer.8Flint2n_primitive_root_prime p =Returns a primitive root for the multiplicative subgroup of \mathbb{Z}/p\mathbb{Z} where p is prime.8Flint2 n_primitive_root_prime_prefactor p factors =Returns a primitive root for the multiplicative subgroup of \mathbb{Z}/p\mathbb{Z} where p$ is prime given the factorisation (factors) of p - 1.8Flint2n_factorial_mod2_preinv n p pinv Returns  n! \bmod p given a precomputed inverse of p as computed by n_preinvert_limb. p is not required to be a prime, but no special optimisations are made for composite p.Uses a lookup table for small n%, otherwise computes the product if n is not too large, and calls the fast algorithm for extremely large n.8Flint2n_factorial_fast_mod2_preinv n p pinv Returns  n! \bmod p given a precomputed inverse of p as computed by n_preinvert_limb. p is not required to be a prime, but no special optimisations are made for composite p5. Uses fast multipoint evaluation, running in about  O(n^{1/2}) time.8Flint2 n_euler_phi n $Computes the Euler totient function \phi(n), counting the number of positive integers less than or equal to n that are coprime to n.8Flint2n_is_squarefree n Returns 0 if n* is divisible by some perfect square, and 14 otherwise. This simply amounts to testing whether  \mu(n) \neq 0. As special cases, 1 is considered squarefree and 0 is not considered squarefree.8Flint2n_moebius_mu_vec mu len  Computes \mu(n) for n = 0, 1, ..., len - 1. This is done by sieving over each prime in the range, flipping the sign of \mu(n) for every multiple of a prime p and setting  \mu(n) = 0 for every multiple of p^2.8Flint2 n_moebius_mu n Computes the Moebius function \mu(n), which is defined as  \mu(n) = 0 if n2 has a prime factor of multiplicity greater than 1,  \mu(n) = -1 if n3 has an odd number of distinct prime factors, and  \mu(n) = 1 if n? has an even number of distinct prime factors. By convention,  \mu(0) = 0.(For even numbers, we use the identities  \mu(4n) = 0 and \mu(2n) = - \mu(n). Odd numbers up to a cutoff are then looked up from a precomputed table storing  \mu(n) + 1 in groups of two bits. For larger n, we first check if n8 is divisible by a small odd square and otherwise call  n_factor() and count the factors.8Flint2n_factor_pollard_brent factor state n_in  max_tries  max_iters Pollard Rho algorithm, modified as suggested by Richard Brent. Makes a call to n_factor_pollard_brent_single&. The input parameters ai and xi for n_factor_pollard_brent_single are selected at random.If the algorithm fails to find a non trivial factor in one call, it tries again (this time with a different set of random values). This process is repeated a maximum of  max\_tries times.Assumes n is not prime. factor is set as the factor found, if factorization is successful. In such a case, 1 is returned. Otherwise, 0 is returned. Factor discovered is not necessarily prime.8Flint2n_factor_pollard_brent_single factor n ninv ai xi normbits  max_iters Pollard Rho algorithm (with Brent modification) for integer factorization. Assumes that the n is not prime. factor is set as the factor if found. It is not assured that the factor found will be prime. Does not compute the complete factorization, just one factor. Returns 1 if factorization is successful (non trivial factor is found), else returns 0. Assumes n is normalized (shifted by normbits bits), and takes as input a precomputed inverse of n as computed by n_preinvert_limb. ai and xi! should also be shifted left by normbits.ai) is the constant of the polynomial used, xi is the initial value.  max\_iters is the number of iterations tried in process of finding the cycle.The algorithm used is a modification of the original Pollard Rho algorithm, suggested by Richard Brent in the paper, available at 5https://maths-people.anu.edu.au/~brent/pd/rpb051i.pdf8Flint2n_factor_pp1_wrapper n A simple wrapper around  n_factor_pp1 which works in the range 31-64 bits. Below this point, trial factoring will always succeed. This function mainly exists for n_factor( and is tuned to minimise the time for n_factor on numbers that reach the  n_factor_pp1; stage, i.e. after trial factoring and one line factoring.8Flint2 n_factor_pp1 n B1 c Factors n using Williams' p + 1/ factoring algorithm, with prime limit set to B1 . We require c to be set to a random value. Each trial of the algorithm with a different value of c! gives another chance to factor n, with roughly exponentially decreasing chance of finding a missing factor. If p + 1 (or p - 1 ) is not smooth for any factor p of n/, the algorithm will never succeed. The value c should be less than n and greater than 2.If the algorithm succeeds, it returns the factor, otherwise it returns 0 or 1 (the trivial factors modulo n).8Flint2n_factor_partial factors n limit proved Factors n>, but stops when the product of prime factors so far exceeds limit.One requires an initialised  n_factor_t structure, but factors will be added by default to an already used  n_factor_t. Use the function n_factor_init() defined in  ulong_extras6 if initialisation has not already been completed on factors. On exit, num will contain the number of distinct prime factors found. The field p is an array of ulong*s containing the distinct prime factors, exp1 an array containing the corresponding exponents.The return value is the unfactored cofactor after factoring is done. The factors are proved prime if proved is 1,, otherwise they are merely probably prime.8Flint2n_factor_trial_partial factors n prod  num_primes limit Attempts trial factoring of n with the first num_primes primes>, but stops when the product of prime factors so far exceeds limit.One requires an initialised  n_factor_t structure, but factors will be added by default to an already used  n_factor_t. Use the function  n_factor_init defined in  ulong_extras6 if initialisation has not already been completed on factors.Once completed, num will contain the number of distinct prime factors found. The field p is an array of ulong*s containing the distinct prime factors, exp1 an array containing the corresponding exponents.The return value is the unfactored cofactor after trial factoring is done. The value prod1 will be set to the product of the factors found.The function calls n_compute_primes automatically. See the documentation for that function regarding limits.The algorithm stops when the current prime has a square exceeding n, as no prime factor of n can exceed this unless n is prime.8The precomputed inverses of all the primes computed by n_compute_primes are utilised with the n_remove2_precomp function.8Flint2n_factor factors n proved Factors n with no restrictions on n. If the prime factors are required to be checked with a primality test, one may set proved to 1, otherwise set it to 0, and they will only be probable primes. NB: at the present there is no difference because the probable prime tests have been exhaustively tested up to 2^{64}.However, in future, this flag may produce and separately check a primality certificate. This may be quite slow (and probably no less reliable in practice).For details on the  n_factor_t structure, see n_factor_trial.This function first tries trial factoring with a number of primes specified by the constant FLINT_FACTOR_TRIAL_PRIMES. If the cofactor is 14 or prime the function returns with all the factors./Otherwise, the cofactor is placed in the array  factor_arr. Whilst there are factors remaining in there which have not been split, the algorithm continues. At each step each factor is first checked to determine if it is a perfect power. If so it is replaced by the power that has been found. Next if the factor is small enough and composite, in particular, less than FLINT_FACTOR_ONE_LINE_MAX then n_factor_one_line is called with FLINT_FACTOR_ONE_LINE_ITERS to try and split the factor. If that fails or the factor is too large for n_factor_one_line then n_factor_SQUFOF is called, with FLINT_FACTOR_SQUFOF_ITERS. If that fails an error results and the program aborts. However this should not happen in practice.8Flint2n_factor_SQUFOF n iters Attempts to split n= using the given number of iterations of SQUFOF. Simply set iters to WORD(0) for maximum persistence.The version of SQUFOF implemented here is as described by Gower and Wagstaff  [GowWag2008].&We start by trying SQUFOF directly on n9. If that fails we multiply it by each of the primes in flint_primes_small in turn. As this multiplication may result in a two limb value we allow this in our implementation of SQUFOF. As SQUFOF works with values about half the size of n1 it only needs single limb arithmetic internally.If SQUFOF fails to factor n we return 0, however with iters( large enough this should never happen.8Flint2n_factor_lehman n 4Lehman's factoring algorithm. Currently works up to 10^{16}, but is not particularly efficient and so is not used in the general factor function. Always returns a factor of n.8Flint2n_factor_one_line n iters 9This implements Bill Hart's one line factoring algorithm  [Har2012]. It is a variant of Fermat's algorithm which cycles through a large number of multipliers instead of incrementing the square root. It is faster than SQUFOF for n less than about 2^{40}.8Flint2n_factor_power235 exp n Returns 0 if n is not a perfect square, cube or fifth power. Otherwise it returns the root and sets exp to either 2, 3 or 5 appropriately.This function uses a series of modular tests to reject most non 235-powers. Each modular test returns a value from 0 to 7 whose bits respectively indicate whether the value is a square, cube or fifth power modulo the given modulus. When these are logically AND-ed together, this gives a powerful test which will reject most non-235 powers.If a bit remains set indicating it may be a square, a standard square root test is performed. Similarly a cube root or fifth root can be taken, if indicated, to determine whether the power of that root is exactly equal to n.8Flint2n_factor_trial factors n  num_primes This function calls n_factor_trial_range, with the value of 0 for start7. By default this adds factors to an already existing  n_factor_t or to a newly initialised one.8Flint2n_factor_trial_range factors n start  num_primes  Trial factor n with the first  num_primes primes, but starting at the prime with index start (counting from zero).One requires an initialised  n_factor_t structure, but factors will be added by default to an already used  n_factor_t. Use the function  n_factor_init defined in  ulong_extras> if initialisation has not already been completed on factors.Once completed, num will contain the number of distinct prime factors found. The field p is an array of ulong*s containing the distinct prime factors, exp1 an array containing the corresponding exponents.The return value is the unfactored cofactor after trial factoring is done.The function calls n_compute_primes automatically. See the documentation for that function regarding limits.The algorithm stops when the current prime has a square exceeding n, as no prime factor of n can exceed this unless n is prime.8The precomputed inverses of all the primes computed by n_compute_primes are utilised with the n_remove2_precomp function.8Flint2n_factor_insert factors p exp %Inserts the given prime power factor p^exp into the  n_factor_t factors. See the documentation for n_factor_trial for a description of the  n_factor_t type.1The algorithm performs a simple search to see if p already exists as a prime factor in the structure. If so the exponent there is increased by the supplied exponent. Otherwise a new factor p^exp' is added to the end of the structure.There is no test code for this function other than its use by the various factoring functions, which have test code.8Flint2n_remove2_precomp n p ppre &Removes the highest possible power of p from n , replacing n> with the quotient. The return value is the highest power of p that divided n . Assumes n is not 0 . We require ppre( to be set to a precomputed inverse of p computed with n_precompute_inverse.For p = 2/ trailing zeroes are counted. For other primes p we make repeated use of n_divrem2_precomp until division by p is no longer possible.8Flint2n_remove n p &Removes the highest possible power of p from n , replacing n> with the quotient. The return value is the highest power of p that divided n . Assumes n is not 0.For p = 2/ trailing zeroes are counted. For other primes p is repeatedly squared and stored in a table of powers with the current highest power of p removed at each step until no higher power can be removed. The algorithm then proceeds down the power tree again removing powers of p until none remain.8Flint2 n_cbrtrem  remainder n This function returns the integer truncation of the cube root of n. Remainder is set as n& minus the cube of the value returned.8Flint2n_cbrt_chebyshev_approx n This function returns the integer truncation of the cube root of n-. The number is first expressed in the form  x * 2^exp. This ensures x is in the range [0.5, 1]. Cube root of x is calculated using Chebyshev's approximation polynomial for the function  y = x^{1/3}. The values of the coefficient are calculated from the Python module mpmath,  https://mpmath.org3, using the function chebyfit. x is multiplied by 2^exp/ and the cube root of 1, 2 or 4 (according to exp%3).8Flint2n_cbrt_binary_search n This function returns the integer truncation of the cube root of n/. Uses binary search to get the correct value.8Flint2n_cbrt_newton_iteration n This function returns the integer truncation of the cube root of n. Makes use of Newton iterations to get a close value, and then adjusts the estimate so as to get the correct value.8Flint2n_cbrt n This function returns the integer truncation of the cube root of n. First approximation is calculated by an algorithm mentioned in this article:  6https://en.wikipedia.org/wiki/Fast_inverse_square_root . Instead of the inverse square root, the cube root is calculated. This functions uses different algorithms to calculate the cube root, depending upon the size of n. For numbers greater than 2^{46} , it uses n_cbrt_chebyshev_approx.. Otherwise, it makes use of the iteration, x \leftarrow x - (x\cdot x\cdot x - a)\cdot x/(2\cdot x\cdot x\cdot x + a) for getting a good estimate, as mentioned in the paper by W. Kahan  [Kahan1991] .8Flint2 n_rootrem  remainder n root This function uses the Newton iteration method to calculate the nth root of a number. First approximation is calculated by an algorithm mentioned in this article:  6https://en.wikipedia.org/wiki/Fast_inverse_square_root . Instead of the inverse square root, the nth root is calculated.Returns the integer part of  n ^ 1/root. Remainder is set as  n - base^root . In case n < 1 or root < 1, 0 is returned.8Flint2n_is_perfect_power root n If n = r^k , return k and set root to r . Note that 0 and 16 are considered squares. No guarantees are made about r or k" being the minimum possible value.8Flint2n_is_perfect_power235 n Returns 1 if n* is a perfect square, cube or fifth power.This function uses a series of modular tests to reject most non 235-powers. Each modular test returns a value from 0 to 7 whose bits respectively indicate whether the value is a square, cube or fifth power modulo the given modulus. When these are logically AND-ed together, this gives a powerful test which will reject most non-235 powers.If a bit remains set indicating it may be a square, a standard square root test is performed. Similarly a cube root or fifth root can be taken, if indicated, to determine whether the power of that root is exactly equal to n.8Flint2 n_is_square x Returns 1 if x is a square, otherwise 0.This code first checks if x is a square modulo 64, 63 = 3 \times 3 \times 7 and 65 = 5 \times 13, using lookup tables, and if so it then takes a square root and checks that the square of this equals the original value.8Flint2 n_sqrtrem r a 6Computes the integer truncation of the square root of a.The integer itself is represented by the nearest double and its square root is computed to the nearest place. If a is one below a square, the rounding may be up, whereas if it is one above a square, the rounding will be down. Thus the square root may be one too large in some instances which we then adjust by checking if we have the right value. We also have to be careful when the square of this too large value causes an overflow. The same assumptions hold for a single precision float provided the square root itself can be represented in a single float, i.e. for a < 281474976710656 = 2^{46}.The remainder is computed by subtracting the square of the computed square root from a.8Flint2n_sqrt a 6Computes the integer truncation of the square root of a.The implementation uses a call to the IEEE floating point sqrt function. The integer itself is represented by the nearest double and its square root is computed to the nearest place. If a is one below a square, the rounding may be up, whereas if it is one above a square, the rounding will be down. Thus the square root may be one too large in some instances which we then adjust by checking if we have the right value. We also have to be careful when the square of this too large value causes an overflow. The same assumptions hold for a single precision float provided the square root itself can be represented in a single float, i.e. for a < 281474976710656 = 2^{46}.8Flint2n_CRT r1 m1 r2 m2 >Use the Chinese Remainder Theorem to return the unique value  0 \le x < M congruent to r_1 modulo m_1 and r_2 modulo m_2, where M = m_1 \times m_2 is assumed to fit a ulong.It is assumed that m_1 and m_2% are positive integers greater than 1! and coprime. It is assumed that 0 \le r_1 < m_1 and 0 \le r_2 < m_2.8Flint2n_is_probabprime n  Tests if n is a probable prime. Up to FLINT_ODDPRIME_SMALL_CUTOFF this algorithm uses n_is_oddprime_small which uses a lookup table.Next it calls n_compute_primes with the maximum table size and uses this table to perform a binary search for n up to the table limit. Then up to  10505355013 it uses a number of strong probable prime tests, n_is_strong_probabprime_preinv, etc., for various bases. The output of the algorithm is guaranteed to be correct up to this bound due to exhaustive tables, described at  %http://uucode.com/obf/dalbec/alg.html .Beyond that point the BPSW probabilistic primality test is used, by calling the function n_is_probabprime_BPSW. There are no known counterexamples, and it has been checked against the tables of Feitsma and Galway and up to the accuracy of those tables, this is an exhaustive check up to 2^{64}$, i.e. there are no counterexamples.8Flint2n_is_probabprime_lucas n 1For details on Lucas pseudoprimes, see [pp. 143]  [CraPom2005].We implement a variant of the Lucas pseudoprime test similar to that described by Baillie and Wagstaff  [BaiWag1980].8Flint2n_is_probabprime_BPSW n Implements a Baillie--Pomerance--Selfridge--Wagstaff probable primality test. This is a variant of the usual BPSW test (which only uses strong base-2 probable prime and Lucas-Selfridge tests, see Baillie and Wagstaff  [BaiWag1980]).This implementation makes use of a weakening of the usual Baillie-PSW test given in  [Chen2003]>, namely replacing the Lucas test with a Fibonacci test when n \equiv 2, 3 \pmod{5}' (see also the comment on page 143 of  [CraPom2005]$), regarding Fibonacci pseudoprimes.There are no known counterexamples to this being a primality test.Up to 2^{64} the test we use has been checked against tables of pseudoprimes. Thus it is a primality test up to this limit.8Flint2n_is_probabprime_fibonacci n Let F_j be the j&th element of the Fibonacci sequence 0, 1, 1, 2, 3, 5, \dotsc, starting at j = 0 . Then if n is prime we have F_{n - (n/5)} = 0 \pmod n, where (n/5) is the Jacobi symbol.!For further details, see pp. 142  [CraPom2005].We require that n is not divisible by 2 or 5.8Flint2n_is_probabprime_fermat n i Returns 1 if n is a base i" Fermat probable prime. Requires  1 < i < n and that i does not divide n.By Fermat's Little Theorem if i^{n-1} is not congruent to 1 then n is not prime.8Flint2n_is_strong_probabprime2_preinv n ninv a d  Tests if n( is a strong probable prime to the base a. We require that d% is set to the largest odd factor of n - 1 and npre is a precomputed inverse of n computed with n_preinvert_limb%. We require a to be reduced modulo n and not 0 and n to be odd. If we write  n - 1 = 2^s d where d is odd then n) is a strong probable prime to the base a (an a-SPRP) if either a^d = 1 \pmod n or (a^d)^{2^r} = -1 \pmod n for some r less than s.8A description of strong probable primes is given here: 4https://mathworld.wolfram.com/StrongPseudoprime.html8Flint2n_is_strong_probabprime_precomp n npre a d  Tests if n( is a strong probable prime to the base a. We require that d% is set to the largest odd factor of n - 1 and npre is a precomputed inverse of n computed with n_precompute_inverse. We also require that  n < 2^{53}, a to be reduced modulo n and not 0 and n to be odd. If we write  n - 1 = 2^s d where d is odd then n) is a strong probable prime to the base a , i.e. an a-SPRP, if either a^d = 1 \pmod n or (a^d)^{2^r} = -1 \pmod n for some r less than s.8A description of strong probable primes is given here: 4https://mathworld.wolfram.com/StrongPseudoprime.html8Flint2 n_is_prime n  Tests if n is a prime. This first sieves for small prime factors, then simply calls n_is_probabprime. This has been checked against the tables of Feitsma and Galway  6http://www.cecm.sfu.ca/Pseudoprimes/index-2-to-64.html and thus constitutes a check for primality (rather than just pseudoprimality) up to 2^{64}.In future, this test may produce and check a certificate of primality. This is likely to be significantly slower for prime inputs.8Flint2n_is_prime_pseudosquare n  Tests if n% is a prime according to Theorem 2.7  [LukPatWil1996].We first factor N' using trial division up to some limit B. In fact, the number of primes used in the trial factoring is at most FLINT_PSEUDOSQUARES_CUTOFF.Next we compute N/B and find the next pseudosquare L_p1 above this value, using a static table as per  $https://oeis.org/A002189/b002189.txt .As noted in the text, if p is prime then Step 3 will pass. This test rejects many composites, and so by this time we suspect that p is prime. If N is 3 or 7 modulo 8, we are done, and N is prime.We now run a probable prime test, for which no known counterexamples are known, to reject any composites. We then proceed to prove N. prime by executing Step 4. In the case that N is 1 modulo 83, if Step 4 fails, we extend the number of primes p_i at Step 3 and hope to find one which passes Step 4. We take the test one past the largest p! for which we have pseudosquares L_p5 tabulated, as this already corresponds to the next L_p which is bigger than 2^{64}6 and hence larger than any prime we might be testing.5As explained in the text, Condition 4 cannot fail if N is prime.The possibility exists that the probable prime test declares a composite prime. However in that case an error is printed, as that would be of independent interest.8Flint2n_is_prime_pocklington n  iterations  Tests if n> is a prime using the Pocklington--Lehmer primality test. If 1 is returned n has been proved prime. If 0 is returned n is composite. However -1 may be returned if nothing was proved either way due to the number of iterations being too small.;The most time consuming part of the algorithm is factoring n - 1. For this reason n_factor_partial is used, which uses a combination of trial factoring and Hart's one line factor algorithm  [Har2012] to try to quickly factor n - 1. Additionally if the cofactor is less than the square root of n - 1! the algorithm can still proceed.One can also specify a number of iterations if less time should be taken. Simply set this to WORD(0) if this is irrelevant. In most cases a greater number of iterations will not significantly affect timings as most of the time is spent factoring.See  6https://mathworld.wolfram.com/PocklingtonsTheorem.html% for a description of the algorithm.8Flint2n_is_oddprime_binary n This function performs a simple binary search through the table of cached primes for n'. If it exists in the array it returns 1 , otherwise 0). For the algorithm to operate correctly n should be odd and at least 17.)Lower and upper bounds are computed with n_prime_pi_bounds. Once we have bounds on where to look in the table, we refine our search with a simple binary algorithm, taking the top or bottom of the current interval as necessary.8Flint2n_is_oddprime_small n Returns 1 if n is an odd prime smaller than FLINT_ODDPRIME_SMALL_CUTOFF . Expects n( to be odd and smaller than the cutoff.This function merely uses a lookup table with one bit allocated for each odd number up to the cutoff.8Flint2n_nth_prime_bounds lo hi n *Calculates lower and upper bounds for the nth prime number p_n , lo <= p_n <= hi. If lo and hi point to the same location, the high value will be stored. Note that this function will overflow for sufficiently large n.*We use the following estimates, valid for n > 5 :` \begin{aligned} p_n & > n (\ln n + \ln \ln n - 1) \\ p_n & < n (\ln n + \ln \ln n) \\ p_n & < n (\ln n + \ln \ln n - 0.9427) \quad (n \geq 15985) \end{aligned}*The first inequality was proved by Dusart  [Dus1999],, and the last is due to Massias and Robin  [MasRob1996]. For a further overview, see  #http://primes.utm.edu/howmany.shtml . We bound \ln n using the number of bits in n as in n_prime_pi_bounds(), and estimate  \ln \ln n; to the nearest integer; this function is nearly constant.8Flint2 n_nth_prime n  Returns the nth prime number p_n., using the mathematical indexing convention p_1 = 2, p_2 = 3, \dotsc.This function simply ensures that the table of cached primes is large enough and then looks up the entry.8Flint2n_prime_pi_bounds lo hi n Calculates lower and upper bounds for the value of the prime counting function lo <= pi(n) <= hi. If lo and hi< point to the same location, the high value will be stored.This does a table lookup for small values, then switches over to some proven bounds.The upper approximation is 1.25506 n / \ln n, and the lower is  n / \ln n1. These bounds are due to Rosser and Schoenfeld  [RosSch1962] and valid for  n \geq 17.We use the number of bits in n, (or one less) to form an approximation to \ln n, taking care to use a value too small or too large to maintain the inequality.8Flint2 n_prime_pi n 1Returns the value of the prime counting function \pi(n)3, i.e. the number of primes less than or equal to n. The invariant n_prime_pi(n_nth_prime(n)) == n.Currently, this function simply extends the table of cached primes up to an upper limit and then performs a binary search.8Flint2 n_nextprime n proved Returns the next prime after n%. Assumes the result will fit in an ulong. If proved is 0>, i.e. false, the prime is not proven prime, otherwise it is.8Flint2n_cleanup_primes Frees the internal cache of prime numbers used by the current thread. This will invalidate any pointers returned by n_primes_arr_readonly or n_prime_inverses_arr_readonly.8Flint2n_prime_inverses_arr_readonly n Returns a pointer to a read-only array of inverses of the first  num_primes prime numbers. The computed primes are cached for repeated calls. The pointer is valid until the user calls n_cleanup_primes in the same thread.8Flint2n_primes_arr_readonly  num_primes 4Returns a pointer to a read-only array of the first  num_primes prime numbers. The computed primes are cached for repeated calls. The pointer is valid until the user calls n_cleanup_primes in the same thread.8Flint2n_compute_primes  num_primes Precomputes at least  num_primes primes and their double precomputed inverses and stores them in an internal cache. Assuming that FLINT has been built with support for thread-local storage, each thread has its own cache.8Flint2n_primes_sieve_range iter a b Sets the block endpoints of iter2 to the smallest and largest odd numbers between a and b inclusive, and sieves to mark all odd primes in this range. The iterator state is changed to point to the first number in the sieved range.8Flint2n_primes_extend_small iter bound %Extends the table of small primes in iter9 to contain at least two primes larger than or equal to bound.8Flint2n_primes_jump_after iter n Changes the state of iter" to start generating primes after n (excluding n itself).8Flint2 n_primes_next iter 8Returns the next prime number and advances the state of iter. The first call returns 2. Small primes are looked up from flint_small_primes. When this table is exhausted, primes are generated in blocks by calling n_primes_sieve_range.8Flint2n_primes_clear iter 5Clears memory allocated by the prime number iterator iter.8Flint2 n_primes_init iter &Initialises the prime number iterator iter for use.8Flint2 n_divides q n p Returns 1 if p divides n and sets q% to the quotient, otherwise returns 0 and sets q to 0.9Flint2n_mulmod_precomp_shoup w p Returns w', scaled approximation of w / p. w'" is equal to the integer part of $w \cdot 2^{\mathtt{FLINT\_BITS}} / p.9Flint2n_mulmod_shoup w t  w_precomp p Returns  w t \bmod{p}. given a precomputed scaled approximation of w / p computed by n_mulmod_precomp_shoup. The value of p should be less than 2^{\mathtt{FLINT\_BITS} - 1}. w and t should be less than p. Works faster than n_mulmod2_preinv if w fixed and t< from array (for example, scalar multiplication of vector).9Flint2 n_sqrtmodn sqrt a fac !Computes all the square roots of a modulo m given the factorisation of m in fac. The roots are stored in an array which is created and whose address is stored in the location pointed to by sqrt. The array of roots is allocated by the function but must be cleaned up by the user by calling  flint_free7. The number of roots is returned by the function. If a# is not a quadratic residue modulo m6 then 0 is returned by the function and the location sqrt points to is set to NULL.9Flint2n_sqrtmod_primepow sqrt a p exp !Computes all the square roots of a modulo p^exp. The roots are stored in an array which is created and whose address is stored in the location pointed to by sqrt. The array of roots is allocated by the function but must be cleaned up by the user by calling  flint_free7. The number of roots is returned by the function. If a$ is not a quadratic residue modulo p^exp6 then 0 is returned by the function and the location sqrt points to is set to NULL.9Flint2n_sqrtmod_2pow sqrt a exp !Computes all the square roots of a modulo 2^exp. The roots are stored in an array which is created and whose address is stored in the location pointed to by sqrt. The array of roots is allocated by the function but must be cleaned up by the user by calling  flint_free7. The number of roots is returned by the function. If a$ is not a quadratic residue modulo 2^exp6 then 0 is returned by the function and the location sqrt points to is set to NULL.9Flint2 n_sqrtmod a p If p$ is prime, compute a square root of a modulo p if a is a quadratic residue modulo p, otherwise return 0.If p2 is not prime the result is with high probability 0, indicating that p is not prime, or a is not a square modulo p&. Otherwise the result is meaningless. Assumes that a is reduced modulo p.9Flint2n_powmod2_fmpz_preinv a exp n ninv Returns  (a^exp) % n given a precomputed inverse of n computed by n_preinvert_limb . We require  0 \leq a < n$, but there are no restrictions on n. The exponent exp must not be negative.This is implemented as a standard binary powering algorithm using repeated squaring and reducing modulo n at each step.9Flint2n_powmod2_ui_preinv a exp n ninv Returns  (a^exp) % n given a precomputed inverse of n computed by n_preinvert_limb . We require  0 \leq a < n$, but there are no restrictions on n. The exponent exp3 is unsigned and so can be larger than allowed by n_powmod2_preinv.This is implemented as a standard binary powering algorithm using repeated squaring and reducing modulo n at each step.9Flint2 n_powmod2 a exp n Returns  (a^exp) % n . We require  0 \leq a < n$, but there are no restrictions on n or on exp, i.e. it can be negative.This is implemented by precomputing an inverse limb and calling the preinv version of this function.If exp is negative but a is not invertible modulo n, an exception is raised.9Flint2n_powmod2_preinv a exp n ninv Returns  (a^exp) % n given a precomputed inverse of n computed by n_preinvert_limb . We require  0 \leq a < n$, but there are no restrictions on n or on exp, i.e. it can be negative.This is implemented as a standard binary powering algorithm using repeated squaring and reducing modulo n at each step.If exp is negative but a is not invertible modulo n, an exception is raised.9Flint2n_powmod a exp n Returns a^exp modulo n . We require n < 2^FLINT_D_BITS and  0 \leq a < n. There are no restrictions on exp, i.e. it can be negative.?This is implemented by precomputing an inverse and calling the precomp version of this function.9Flint2n_powmod_ui_precomp a exp n npre Returns a^exp modulo n given a precomputed inverse of n computed by n_precompute_inverse . We require  n < 2^{53} and  0 \leq a < n. The exponent exp3 is unsigned and so can be larger than allowed by n_powmod_precomp.This is implemented as a standard binary powering algorithm using repeated squaring and reducing modulo n at each step.9Flint2n_powmod_precomp a exp n npre Returns a^exp modulo n given a precomputed inverse of n computed by n_precompute_inverse . We require  n < 2^{53} and  0 \leq a < n. There are no restrictions on exp, i.e. it can be negative.This is implemented as a standard binary powering algorithm using repeated squaring and reducing modulo n at each step.9Flint2n_invmod x y Returns the inverse of x modulo y2, if it exists. Otherwise an exception is thrown.This is merely an adaption of the extended Euclidean algorithm with appropriate normalisation.9Flint2n_submod a b n Returns (a - b) \bmod{n}.9Flint2n_addmod a b n Returns (a + b) \bmod{n}.9Flint2n_jacobi_unsigned x y %Computes the Jacobi symbol, allowing x to go up to a full limb.9Flint2n_jacobi x y Computes the Jacobi symbol \left(\frac{x}{y}\right) for any x and odd y.9Flint2n_xgcd a b x y $Returns the greatest common divisor g of x and y and unsigned values a and b such that  a x - b y = g. We require x \geq y.We claim that computing the extended greatest common divisor via the Euclidean algorithm always results in cofactor \lvert a \rvert < x/2, \lvert b\rvert < x/21, with perhaps some small degenerate exceptions.We proceed by induction.3Suppose we are at some step of the algorithm, with x_n = q y_n + r with r \geq 1, and suppose 1 = s y_n - t r with  s < y_n / 2,  t < y_n / 2 by hypothesis.Write 31 = s y_n - t (x_n - q y_n) = (s + t q) y_n - t x_n.It suffices to show that (s + t q) < x_n / 2 as t < y_n / 2 < x_n / 2), which will complete the induction step.But at the previous step in the backsubstitution we would have had  1 = s r - c d with s < r/2 and c < r/2.Then 3s + t q < r/2 + y_n / 2 q = (r + q y_n)/2 = x_n / 2.See the documentation of n_gcd for a description of the branching in the algorithm, which is faster than using division.9Flint2n_gcdinv a x y $Returns the greatest common divisor g of x and y and computes a such that  0 \leq a < y and a x = \gcd(x, y) \bmod{y}$, when this is defined. We require x < y.When y = 1' the greatest common divisor is set to 1 and a is set to 0.This is merely an adaption of the extended Euclidean algorithm computing just one cofactor and reducing it modulo y.9Flint2n_gcd x y $Returns the greatest common divisor g of x and y,. No assumptions are made about the values x and y.This function wraps GMP's  mpn_gcd_1.9Flint2n_mulmod_preinv a b n ninv norm Returns  a b \pmod{n} given a precomputed inverse of n computed by n_preinvert_limb , assuming a and b are reduced modulo n and n is normalised, i.e. with most significant bit set. There are no other restrictions on a, b or n. The value norm! is provided for convenience. As n/ is required to be normalised, it may be that a and b# have been shifted to the left by norm bits before calling the function. Their product then has an extra factor of  2^\text{norm}. Specifying a nonzero norm will shift the product right by this many bits before reducing it.2The algorithm used is that of Granlund and Mller  [GraMol2010].9Flint2 n_mulmod2 a b n Returns  a b \bmod{n}. There are no restrictions on a, b or on n+. This is implemented by multiplying using  umul_ppmm and then reducing using n_ll_mod_preinv' after computing a precomputed inverse.9Flint2n_mulmod2_preinv a b n ninv Returns  a b \bmod{n} given a precomputed inverse of n computed by n_preinvert_limb. There are no restrictions on a, b or on n+. This is implemented by multiplying using  umul_ppmm and then reducing using n_ll_mod_preinv.9Flint2n_mulmod_precomp a b n ninv Returns  a b \bmod{n} given a precomputed inverse of n computed by n_precompute_inverse . We require n < 2^FLINT_D_BITS and 0 \leq a, b < n.We assume the processor is in the standard round to nearest mode. Thus ninv is correct to 53 binary bits, the least significant bit of which we shall call a place, and can be at most half a place out. The product of a and b4 is computed with error at most half a place. When a * b is multiplied by ninv we find that the exact quotient and computed quotient differ by less than two places. As the quotient is less than n/ this means that the exact quotient is at most 1 away from the computed quotient. We truncate this quotient to an integer which reduces the value by less than 1. We end up with a value which can be no more than two above the quotient we are after and no less than two below. However an argument similar to that for  n_mod_precomp shows that the truncated computed quotient cannot be two smaller than the truncated exact quotient. In other words the computed integer quotient is at most two above and one below the quotient we are after.9Flint2n_lll_mod_preinv a_hi a_mi a_lo n ninv Returns  a \bmod{n}, where a has three limbs (a_hi, a_mi, a_lo)!, given a precomputed inverse of n computed by n_preinvert_limb. It is assumed that a_hi is reduced modulo n . There are no restrictions on n.8This function uses the algorithm of Granlund and Mller  [GraMol2010]+ to first reduce the top two limbs modulo n., then does the same on the bottom two limbs.9Flint2n_ll_mod_preinv a_hi a_lo n ninv Returns  a \bmod{n} given a precomputed inverse of n computed by n_preinvert_limb. There are no restrictions on a, which will be two limbs  (a_hi, a_lo), or on n.=The old version of this function merely reduced the top limb a_hi modulo n so that udiv_qrnnd_preinv() could be used.,The new version reduces the top limb modulo n as per  n_mod2_preinv0 and then the algorithm of Granlund and Mller  [GraMol2010]! is used again to reduce modulo n.9Flint2n_divrem2_precomp q a n npre Returns  a \bmod{n} given a precomputed inverse of n computed by n_precompute_inverse and sets q0 to the quotient. There are no restrictions on a or on n.This is as for n_mod2_precomp with some additional care taken to retain the quotient information. There are also special cases to deal with the case where a is already reduced modulo n and where n is 64 bits and a is not reduced modulo n.9Flint2 n_mod2_preinv a n ninv Returns  a \bmod{n} given a precomputed inverse of n computed by n_preinvert_limb(). There are no restrictions on a and the only restriction on n is that it be nonzero./This uses the algorithm of Granlund and Mller  [GraMol2010] . First n is normalised and a is shifted into two limbs to compensate. Then their algorithm is applied verbatim and the result shifted back.9Flint2 n_div2_preinv a n ninv "Returns the Euclidean quotient of a by n! given a precomputed inverse of n computed by n_preinvert_limb . There are no restrictions on a and the only restriction on n is that it be nonzero./This uses the algorithm of Granlund and Mller  [GraMol2010] . First n is normalised and a is shifted into two limbs to compensate. Then their algorithm is applied verbatim.9Flint2n_divrem2_preinv q a n ninv Returns  a \bmod{n} and sets q to the quotient of a by n", given a precomputed inverse of n computed by n_preinvert_limb() . There are no restrictions on a and the only restriction on n is that it be nonzero./This uses the algorithm of Granlund and Mller  [GraMol2010] . First n is normalised and a is shifted into two limbs to compensate. Then their algorithm is applied verbatim and the remainder shifted back.9Flint2n_mod2_precomp a n ninv Returns  a \bmod{n} given a precomputed inverse of n computed by n_precompute_inverse. There are no restrictions on a or on n.As for  n_mod_precomp for  n < 2^{53} and a < n^2 the computed quotient is either what we are after or one too large or small. We deal with these cases. Otherwise we can be sure that the top 52 bits of the quotient are computed correctly. We take the remainder and adjust the quotient by multiplying the remainder by ninv1 to compute another approximate quotient as per  mod_precomp. Now the remainder may be either negative or positive, so the quotient we compute may be one out in either direction.9Flint2 n_mod_precomp a n ninv Returns  a \bmod{n} given a precomputed inverse of n computed by n_precompute_inverse . We require n < 2^FLINT_D_BITS and a < 2^(FLINT_BITS-1) and 0 \leq a < n^2.We assume the processor is in the standard round to nearest mode. Thus ninv is correct to 53 binary bits, the least significant bit of which we shall call a place, and can be at most half a place out. When a is multiplied by ninv, the binary representation of a) is exact and the mantissa is less than 2, thus we see that a * ninv: can be at most one out in the mantissa. We now truncate a * ninv to the nearest integer, which is always a round down. Either we already have an integer, or we need to make a change down of at least 1 in the last place. In the latter case we either get precisely the exact quotient or below it as when we rounded the product to the nearest place we changed by at most half a place. In the case that truncating to an integer takes us below the exact quotient, we have rounded down by less than 14 plus half a place. But as the product is less than n and n is less than 2^{53}, half a place is less than 1 , thus we are out by less than 2 from the exact quotient, i.e. the quotient we have computed is the quotient we are after or one too small. That leaves only the case where we had to round up to the nearest place which happened to be an integer, so that truncating to an integer didn't change anything. But this implies that the exact quotient a/n is less than 2^{-54} from an integer. We deal with this rare case by subtracting 1 from the quotient. Then the quotient we have computed is either exactly what we are after, or one too small.9Flint2n_precompute_inverse n !Returns a precomputed inverse of n with double precision value 1/n. This precomputed inverse can be used with all of the functions that take a precomputed inverse whose names are suffixed by _precomp. We require n > 0.9Flint2n_preinvert_limb n !Returns a precomputed inverse of n, as defined in  [GraMol2010]. This precomputed inverse can be used with all of the functions that take a precomputed inverse whose names are suffixed by _preinv. We require n > 0.9Flint2n_preinvert_limb_prenorm n  Computes an approximate inverse invxl of the limb xl;, with an implicit leading~`1`. More formally it computes: +invxl = (B^2 - B*x - 1)/x = (B^2 - 1)/x - B Note that x must be normalised, i.e. with msb set. This inverse makes use of the following theorem of Torbjorn Granlund and Peter Montgomery~[Lemma~8.1] [GraMon1994]:Let d be normalised, d < B,, i.e. it fits in a word, and suppose that m d < B^2 \leq (m+1) d. Let 0 \leq n \leq B d - 1 . Write n = n_2 B + n_1 B/2 + n_0 with n_1 = 0 or 1 and  n_0 < B/2 . Suppose =q_1 B + q_0 = n_2 B + (n_2 + n_1) (m - B) + n_1 (d-B/2) + n_0 and 0 \leq q_0 < B. Then 0 \leq q_1 < B and 0 \leq n - q_1 d < 2 d.In the theorem, m is the inverse of d . If we let  m = invxl + B and d = x we have m d = B^2 - 1 < B^2 and (m+1) x = B^2 + d - 1 \geq B^2.3The theorem is often applied as follows: note that n_0 and  n_1 (d-B/2) are both less than B/2. Also note that  n_1 (m-B) < B7. Thus the sum of all these terms contributes at most 1 to q_1. We are left with n_2 B + n_2 (m-B). But note that (m-B)& is precisely our precomputed inverse invxl. If we write q_1 B + q_0 = n_2 B + n_2 (m-B)", then from the theorem, we have 0 \leq n - q_1 d < 3 d&, i.e. the quotient is out by at most 2, and is always either correct or too small.9Flint2 n_sizeinbase n base 7Returns the exact number of digits needed to represent n as a string in base base0 assumed to be between 2 and 36. Returns 1 when n = 0.9Flint2n_revbin n b Returns the binary reverse of n, assuming it is b bits in length, e.g. n_revbin(10110, 6) will return 110100.9Flint2 n_clog_2exp n b Returns \lceil\log_b 2^n\rceil. Assumes that b \geq 2.9Flint2n_clog n b Returns \lceil\log_b n\rceil. Assumes that n \geq 1 and b \geq 2.9Flint2n_flog n b Returns \lfloor\log_b n\rfloor. Assumes that n \geq 1 and b \geq 2.9Flint2n_pow n exp Returns n^exp. No checking is done for overflow. The exponent may be zero. We define 0^0 = 1.The algorithm simply uses a for loop. Repeated squaring is unlikely to speed up this algorithm.9Flint2n_randtest_prime state proved Returns a random prime number  (proved = 1) or probable prime  (proved = 0)) with size randomly chosen between 2 and  FLINT_BITS7 bits. This function is intended for use in test code.9Flint2 n_randprime state bits proved Returns a random prime number  (proved = 1) or probable prime  (proved = 0) with bits bits, where bits! must be at least 2 and at most  FLINT_BITS.9Flint2n_randtest_not_zero state As for  n_randtest, but does not return 02. This function is intended for use in test code.9Flint2 n_randtest state Returns a pseudo random number with a random number of bits, from 0 to  FLINT_BITS(. The probability of the special values 0, 1,  COEFF_MAX and WORD_MAX is increased as is the probability of a value with sparse binary representation. This random function is mainly used for testing purposes. This function is intended for use in test code.9Flint2 n_urandint state limit Returns a uniformly pseudo random number up to but not including the given limit. If zero is passed as a parameter, an entire random limb is returned. This function provides somewhat better randomness as compared to  n_randint(, especially for larger values of limit.9Flint2 n_randint state limit Returns a uniformly pseudo random number up to but not including the given limit. If zero is passed as a parameter, an entire random limb is returned.9Flint2n_randtest_bits state bits Returns a uniformly pseudo random number with the given number of bits. The most significant bit is always set, unless zero is passed, in which case zero is returned. The probability of a value with a sparse binary representation being returned is increased. This function is intended for use in test code.9Flint2 n_randbits state bits Returns a uniformly pseudo random number with the given number of bits. The most significant bit is always set, unless zero is passed, in which case zero is returned.9Flint2 n_randlimb state 'Returns a uniformly pseudo random limb..The algorithm generates two random half limbs s_j, j = 0, 1, by iterating respectively  v_{i+1} = (v_i a + b) \bmod{p_j} for some initial seed v_0, randomly chosen values a and b and "p_0 = 4294967311 = nextprime(2^32) on a 64-bit machine and p_0 = nextprime(2^16) on a 32-bit machine and p_1 = nextprime(p_0).888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999j Safe-Inferred )*1A888888888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999888999888899999999999999999999999999999999999999999999999999999888888888888888888888888888888888888888888888888888888888888888888888888 Safe-Inferred )*1+9Flint2thread_pool_clear T Release any resources used by T. All threads should be given back before this function is called.9Flint2thread_pool_give_back T i  Put thread i back in the available state. This thread should be sleeping when this function is called.9Flint2thread_pool_wait T i Wait for thread i( to finish working and go back to sleep.9Flint2thread_pool_wake T i  max_workers f a Wake up a sleeping thread i and have it work on f(a)3. The thread being woken will be allowed to start  max_workers additional worker threads. Usually this value should be set to 0.9Flint2thread_pool_request T out  requested  Put at most  requested threads in the unavailable state and return their handles. The handles are written to out and the number of handles written is returned. These threads must be released by a call to thread_pool_give_back.9Flint2thread_pool_set_size T new_size If all threads in T$ are in the available state, resize T" and return 1. Otherwise, return 0.9Flint2thread_pool_get_size T  Return the number of threads in T.9Flint2thread_pool_init T size  Initialise T and create size2 sleeping threads that are available to work. If  size \le 0- no threads are created and future calls to thread_pool_request will return 0 (unless thread_pool_set_size has been called).99999999999999k Safe-Inferred )*19999999999999999999999999999 Safe-Inferred )*1֥29Flint2 nmod_poly_mat_solve_fflu_precomp X perm FFLU B Performs fraction-free forward and back substitution given a precomputed fraction-free LU decomposition and corresponding permutation.9Flint2nmod_poly_mat_solve_fflu X den A B Solves the equation AX = B for nonsingular A. More precisely, computes (X, den ) such that  AX = B \times \operatorname{den}. Returns 1 if A is nonsingular and 0 if A is singular. The computed denominator will not generally be minimal.Uses fraction-free LU decomposition followed by fraction-free forward and back substitution.9Flint2nmod_poly_mat_solve X den A B Solves the equation AX = B for nonsingular A. More precisely, computes (X, den ) such that  AX = B \times \operatorname{den}. Returns 1 if A is nonsingular and 0 if A is singular. The computed denominator will not generally be minimal.Uses fraction-free LU decomposition followed by fraction-free forward and back substitution.9Flint2nmod_poly_mat_nullspace res mat 4Computes the right rational nullspace of the matrix mat and returns the nullity.More precisely, assume that mat has rank r and nullity n%. Then this function sets the first n columns of res< to linearly independent vectors spanning the nullspace of mat$. As a result, we always have rank(res) = n, and mat \times res is the zero matrix.The computed basis vectors will not generally be in a reduced form. In general, the polynomials in each column vector in the result will have a nontrivial common GCD.9Flint2nmod_poly_mat_inv Ainv den A Sets (Ainv, den) to the inverse matrix of A. Returns 1 if A is nonsingular and 0 if A is singular. Aliasing of Ainv and A is allowed.More precisely, det# will be set to the determinant of A and Ainv( will be set to the adjugate matrix of A. Note that the determinant is not necessarily the minimal denominator.Uses fraction-free LU decomposition, followed by solving for the identity matrix.9Flint2nmod_poly_mat_rank A Returns the rank of A8. Performs fraction-free LU decomposition on a copy of A.9Flint2nmod_poly_mat_det_interpolate det A Sets det) to the determinant of the square matrix A6. The determinant is computed by determining a bound n+ for its length, evaluating the matrix at n distinct points, computing the determinant of each coefficient matrix, and forming the interpolating polynomial.)If the coefficient ring does not contain n, distinct points (that is, if working over \mathbf{Z}/p\mathbf{Z} where p < n.), this function automatically falls back to nmod_poly_mat_det_fflu.9Flint2nmod_poly_mat_det_fflu det A Sets det) to the determinant of the square matrix A. The determinant is computed by performing a fraction-free LU decomposition on a copy of A.9Flint2nmod_poly_mat_det det A Sets det) to the determinant of the square matrix A. Uses a direct formula, fraction-free LU decomposition, or interpolation, depending on the size of the matrix.9Flint2nmod_poly_mat_trace trace mat Computes the trace of the matrix, i.e. the sum of the entries on the main diagonal. The matrix is required to be square.9Flint2nmod_poly_mat_rref B den A Sets (B, den%) to the reduced row echelon form of A and returns the rank of A. Aliasing of A and B is allowed.The denominator den is set to \pm \operatorname{det}(A). Note that the determinant is not generally the minimal denominator.9Flint2nmod_poly_mat_fflu B den perm A  rank_check 0Uses fraction-free Gaussian elimination to set (B, den*) to a fraction-free LU decomposition of A and returns the rank of A. Aliasing of A and B is allowed.Pivot elements are chosen with  nmod_poly_mat_find_pivot_partial. If perm is non-NULL, the permutation of rows in the matrix will also be applied to perm.If  rank_check is set, the function aborts and returns 0 if the matrix is detected not to have full rank without completing the elimination.The denominator den is set to \pm \operatorname{det}(A), where the sign is decided by the parity of the permutation. Note that the determinant is not generally the minimal denominator.9Flint2 nmod_poly_mat_find_pivot_partial mat  start_row end_row c Attempts to find a pivot entry for row reduction. Returns a row index r between  start_row (inclusive) and stop_row (exclusive) such that column c in mat has a nonzero entry on row r), or returns -1 if no such entry exists.This implementation searches all the rows in the column and chooses the nonzero entry of smallest degree. This heuristic typically reduces coefficient growth when the matrix entries vary in size.9Flint2nmod_poly_mat_find_pivot_any mat  start_row end_row c Attempts to find a pivot entry for row reduction. Returns a row index r between  start_row (inclusive) and stop_row (exclusive) such that column c in mat has a nonzero entry on row r), or returns -1 if no such entry exists.This implementation simply chooses the first nonzero entry from it encounters. This is likely to be a nearly optimal choice if all entries in the matrix have roughly the same size, but can lead to unnecessary coefficient growth if the entries vary in size.9Flint2nmod_poly_mat_pow B A exp Sets B to A raised to the power exp, where A is a square matrix. Uses exponentiation by squaring. Aliasing is allowed.9Flint2nmod_poly_mat_sqr_interpolate B A Sets B to the square of A, which must be a square matrix, computed through evaluation and interpolation. For interpolation to be well-defined, we require that the modulus is a prime at least as large as 2n - 1 where n is the maximum length of polynomials in the input matrix. Aliasing is allowed.9Flint2nmod_poly_mat_sqr_KS B A Sets B to the square of A, which must be a square matrix. Aliasing is allowed. This function uses Kronecker segmentation.9Flint2nmod_poly_mat_sqr_classical B A Sets B to the square of A, which must be a square matrix. Aliasing is allowed. This function uses direct formulas for very small matrices, and otherwise classical matrix multiplication.9Flint2nmod_poly_mat_sqr B A Sets B to the square of A, which must be a square matrix. Aliasing is allowed. This function automatically chooses between classical and KS squaring.9Flint2nmod_poly_mat_mul_interpolate C A B Sets C to the matrix product of A and B, computed through evaluation and interpolation. The matrices must have compatible dimensions for matrix multiplication. For interpolation to be well-defined, we require that the modulus is a prime at least as large as  m + n - 1 where m and n are the maximum lengths of polynomials in the input matrices. Aliasing is allowed.9Flint2nmod_poly_mat_mul_KS C A B Sets C to the matrix product of A and B, computed using Kronecker segmentation. The matrices must have compatible dimensions for matrix multiplication. Aliasing is allowed.9Flint2nmod_poly_mat_mul_classical C A B Sets C to the matrix product of A and B, computed using the classical algorithm. The matrices must have compatible dimensions for matrix multiplication. Aliasing is allowed.9Flint2nmod_poly_mat_mul C A B Sets C to the matrix product of A and B. The matrices must have compatible dimensions for matrix multiplication. Aliasing is allowed. This function automatically chooses between classical, KS and evaluation-interpolation multiplication.9Flint2nmod_poly_mat_neg B A Sets B to the negation of A>. The matrices must have the same shape. Aliasing is allowed.9Flint2nmod_poly_mat_sub C A B Sets C to the sum of A and B>. All matrices must have the same shape. Aliasing is allowed.9Flint2nmod_poly_mat_add C A B Sets C to the sum of A and B>. All matrices must have the same shape. Aliasing is allowed.9Flint2nmod_poly_mat_scalar_mul_nmod B A c Sets B to A) multiplied entrywise by the coefficient c5, which is assumed to be reduced modulo the modulus.9Flint2"nmod_poly_mat_scalar_mul_nmod_poly B A c Sets B to A( multiplied entrywise by the polynomial c.9Flint2nmod_poly_mat_evaluate_nmod B A x  Sets the  nmod_mat_t B to A" evaluated entrywise at the point x.9Flint2nmod_poly_mat_max_length A ?Returns the maximum polynomial length among all the entries in A.9Flint2nmod_poly_mat_is_square mat Returns a non-zero value if the number of rows is equal to the number of columns in mat, and otherwise returns zero.9Flint2nmod_poly_mat_is_empty mat Returns a non-zero value if the number of rows or the number of columns in mat% is zero, and otherwise returns zero.9Flint2nmod_poly_mat_is_one mat  Returns nonzero if all entry of mat on the main diagonal are the constant polynomial 1 and all remaining entries are zero, and returns zero otherwise. The matrix need not be square.9Flint2nmod_poly_mat_is_zero mat "Returns nonzero if all entries in mat' are zero, and returns zero otherwise.9Flint2nmod_poly_mat_equal mat1 mat2 Returns nonzero if mat1 and mat2 have the same shape and all their entries agree, and returns zero otherwise.9Flint2nmod_poly_mat_one mat Sets mat to the unit or identity matrix of given shape, having the element 1 on the main diagonal and zeros elsewhere. If mat= is nonsquare, it is set to the truncation of a unit matrix.9Flint2nmod_poly_mat_zero mat Sets mat to the zero matrix.9Flint2nmod_poly_mat_randtest_sparse A state len density Creates a random matrix with the amount of nonzero entries given approximately by the density variable, which should be a fraction between 0 (most sparse) and 1 (most dense).;The nonzero entries will have random lengths between 1 and len.9Flint2nmod_poly_mat_randtest mat state len This is equivalent to applying nmod_poly_randtest to all entries in the matrix.9Flint2nmod_poly_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.9Flint2nmod_poly_mat_swap mat1 mat2 Swaps mat1 and mat2 efficiently.9Flint2nmod_poly_mat_set mat1 mat2 Sets mat1 to a copy of mat2.9Flint2nmod_poly_mat_modulus mat Returns the modulus of mat.9Flint2nmod_poly_mat_ncols mat !Returns the number of columns in mat.9Flint2nmod_poly_mat_nrows mat Returns the number of rows in mat.9Flint2nmod_poly_mat_clear mat Frees all memory associated with the matrix. The matrix must be reinitialised if it is to be used again.9Flint2nmod_poly_mat_init_set mat src Initialises a matrix mat' of the same dimensions and modulus as src, and sets it to a copy of src.9Flint2nmod_poly_mat_init mat rows cols n Initialises a matrix with the given number of rows and columns for use. The modulus is set to n.9Flint2nmod_poly_mat_entry mat i j &Gives a reference to the entry at row i and column j. The reference can be passed as an input or output variable to any  nmod_poly function for direct manipulation of the matrix element. No bounds checking is performed.9Flint2nmod_poly_mat_print mat x Prints the matrix mat( to standard output, using the variable x.89999999999999999999999999999999999999999999999999999l Safe-Inferred )*1Y8999999999999999999999999999999999999999999999999999989999999999999999999999999999999999999999999999999999 Safe-Inferred )*1$9Flint2_nmod_poly_interval_poly_worker arg_ptr Worker function to compute interval polynomials in distinct degree factorisation. Input/output is stored in nmod_poly_interval_poly_arg_t.9Flint2nmod_poly_factor res f  Factorises a general polynomial f into monic irreducible factors and returns the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs either Cantor-Zassenhaus or Berlekamp on all the individual square-free factors. Currently Cantor-Zassenhaus is used by default unless the modulus is 2, in which case Berlekamp is used.9Flint2$nmod_poly_factor_with_kaltofen_shoup res f  Factorises a general polynomial f into monic irreducible factors and returns the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Kaltofen-Shoup on all the individual square-free factors.9Flint2'nmod_poly_factor_with_cantor_zassenhaus res f  Factorises a general polynomial f into monic irreducible factors and returns the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Cantor-Zassenhaus on all the individual square-free factors.9Flint2nmod_poly_factor_with_berlekamp res f  Factorises a general polynomial f into monic irreducible factors and returns the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Berlekamp on all the individual square-free factors.9Flint2nmod_poly_factor_kaltofen_shoup res poly %Factorises a non-constant polynomial f into monic irreducible factors using the fast version of Cantor-Zassenhaus algorithm proposed by Kaltofen and Shoup (1998). More precisely this algorithm uses a @baby step/giant step@ strategy for the distinct-degree factorization step. If flint_get_num_threads is greater than one &nmod_poly_factor_distinct_deg_threaded is used.:Flint2nmod_poly_factor_berlekamp res f 1Factorises a non-constant, squarefree polynomial f? into monic irreducible factors using the Berlekamp algorithm.:Flint2"nmod_poly_factor_cantor_zassenhaus res f %Factorises a non-constant polynomial f into monic irreducible factors using the Cantor-Zassenhaus algorithm.:Flint2&nmod_poly_factor_distinct_deg_threaded res poly degs Multithreaded version of nmod_poly_factor_distinct_deg.:Flint2nmod_poly_factor_distinct_deg res poly degs 6Factorises a monic non-constant squarefree polynomial poly of degree n into factors f[d] such that for 1 \leq d \leq n f[d]5 is the product of the monic irreducible factors of poly of degree d . Factors f[d] are stored in res, and the degree d* of the irreducible factors is stored in degs# in the same order as the factors.Requires that degs has enough space for (n/2)+1 * sizeof(slong).:Flint2nmod_poly_factor_equal_deg factors pol d  Assuming pol3 is a product of irreducible factors all of degree d, finds all those factors and places them in factors. Requires that pol( be monic, non-constant and squarefree.:Flint2nmod_poly_factor_equal_deg_prob factor state pol d ,Probabilistic equal degree factorisation of pol% into irreducible factors of degree d. If it passes, a factor is placed in factor and 1 is returned, otherwise 0 is returned and the value of factor is undetermined.Requires that pol' be monic, non-constant and squarefree.:Flint2nmod_poly_factor_squarefree res f Sets res# to a square-free factorization of f.:Flint2nmod_poly_is_squarefree f  Returns 1 if f is squarefree, and 0 otherwise. As a special case, the zero polynomial is not considered squarefree.:Flint2_nmod_poly_is_squarefree f len mod  Returns 1 if (f, len) is squarefree, and 0 otherwise. As a special case, the zero polynomial is not considered squarefree. There are no restrictions on the length.:Flint2nmod_poly_is_irreducible_rabin f Returns 1 if the polynomial f is irreducible, otherwise returns 0. Uses Rabin irreducibility test.:Flint2nmod_poly_is_irreducible_ddf f Returns 1 if the polynomial f is irreducible, otherwise returns 0. Uses fast distinct-degree factorisation.:Flint2nmod_poly_is_irreducible f Returns 1 if the polynomial f% is irreducible, otherwise returns 0.:Flint2nmod_poly_remove f p &Removes the highest possible power of p from f and returns the exponent.:Flint2nmod_poly_factor_pow fac exp Raises fac to the power exp.:Flint2nmod_poly_factor_concat res fac  Concatenates two factorisations.This is equivalent to calling nmod_poly_factor_insert, repeatedly with the individual factors of fac."Does not support aliasing between res and fac.:Flint2nmod_poly_factor_insert fac poly exp Inserts the factor poly with multiplicity exp into the factorisation fac.If fac already contains poly, then exp: simply gets added to the exponent of the existing entry.:Flint2nmod_poly_factor_fprint_pretty fac xPrints the entries of fac to stream a polynomials.:Flint2nmod_poly_factor_fprint fac Prints the entries of fac to stream.:Flint2nmod_poly_factor_get_str_pretty fac x0Returns string representation of the entries of fac as polynomials.:Flint2nmod_poly_factor_get_str fac0Returns string representation of the entries of fac.:Flint2nmod_poly_factor_set res fac Sets res to the same factorisation as fac.:Flint2nmod_poly_factor_fit_length fac len 9Ensures that the factor structure has space for at least len factors. This function takes care of the case of repeated calls by always at least doubling the number of factors the structure can hold.:Flint2nmod_poly_factor_realloc fac alloc Reallocates the factor structure to provide space for precisely alloc factors.:Flint2nmod_poly_factor_clear fac !Frees all memory associated with fac.:Flint2nmod_poly_factor_init fac  Initialises fac for use. An nmod_poly_factor_t represents a polynomial in factorised form as a product of polynomials with associated exponents.:Flint2 Create new :Flint2Use :Flint2Use new :Flint2nmod_poly_factor_print fac Prints the entries of fac to standard output.:Flint2nmod_poly_factor_print_pretty fac xPrints the entries of fac# to standard output as polynomials.(999999::::::::::::::::::::::::::::::m Safe-Inferred )*1(999999::::::::::::::::::::::::::::::(::::::::::::::::::::::::::::::999999 Safe-Inferred )*1:Flint2nmod_berlekamp_massey_R_poly B Return the polynomial R in B.:Flint2nmod_berlekamp_massey_V_poly B Return the polynomial V in B.:Flint2nmod_berlekamp_massey_points B 2Return a pointer to the array of points stored in B. This may be NULL if !nmod_berlekamp_massey_point_count returns 0.:Flint2!nmod_berlekamp_massey_point_count B &Return the number of points stored in B.:Flint2nmod_berlekamp_massey_reduce B Ensure that the polynomials V and R& are up to date. The return value is 1 if this function changed V and 0 otherwise. For example, if this function is called twice in a row without adding any points in between, the return of the second call should be 0. As another example, suppose the object is emptied, the points  1, 1, 2, 3> are added, then reduce is called. This reduce should return 1 with \deg(R) < \deg(V) = 2 because the Fibonacci sequence has been recognized. The further addition of the two points 5, 80 and a reduce will result in a return value of 0.:Flint2 nmod_berlekamp_massey_add_points B a count (Add point(s) to the stream processed by B<. The addition of any number of points will not update the V and R polynomial.:Flint2nmod_berlekamp_massey_set_prime B p Set the characteristic of the field and empty the stream of points in B.:Flint2 nmod_berlekamp_massey_start_over B Empty the stream of points in B.:Flint2nmod_berlekamp_massey_clear B Free any space used by B.:Flint2nmod_berlekamp_massey_init B p  Initialize B in characteristic p with an empty stream.:Flint2_nmod_poly_multi_crt_run outputs CRT inputs Perform the same operation as nmod_poly_multi_crt_precomp using supplied temporary space. The actual output is placed in  outputs + 0, and outputs should contain space for all temporaries and should be at least as long as $_nmod_poly_multi_crt_local_size(CRT). Of course the moduli of these temporaries should match the modulus of the inputs.:Flint2_nmod_poly_multi_crt_local_size CRT -Return the required length of the output for _nmod_poly_multi_crt_run.:Flint2nmod_poly_multi_crt_clear CRT Free all space used by CRT.:Flint2nmod_poly_multi_crt output moduli values len Perform the same operation as nmod_poly_multi_crt_precomp while internally constructing and destroying the precomputed data. All of the remarks in nmod_poly_multi_crt_precompute apply.:Flint2nmod_poly_multi_crt_precomp output CRT values Set output to the polynomial of lowest possible degree that is congruent to  values + i modulo the  moduli + i in nmod_poly_multi_crt_precompute. The inputs !values + 0, ..., values + len - 1 where len was used in nmod_poly_multi_crt_precompute are expected to be valid and have modulus matching the modulus of the moduli used in nmod_poly_multi_crt_precompute.:Flint2nmod_poly_multi_crt_precompute CRT moduli len  Configure CRT& for repeated Chinese remaindering of moduli. The number of moduli, len", should be positive. A return of 0= indicates that the compilation failed and future calls to nmod_poly_multi_crt_precomp/ will leave the output undefined. A return of 1 indicates that the compilation was successful, which occurs if and only if either (1) len == 1 and  modulus + 0 is nonzero, or (2) all of the moduli have positive degree and are pairwise relatively prime.:Flint2nmod_poly_multi_crt_init CRT  Initialize CRT for Chinese remaindering.:Flint2nmod_poly_deflation input %Returns the largest integer by which input2 can be deflated. As special cases, returns 0 if input! is the zero polynomial and 1 of input is a constant polynomial.:Flint2nmod_poly_deflate result input  deflation Sets result to the deflated polynomial  p(x^{1/n}) where p is given by input and n is given by  deflation . Requires n > 0.:Flint2nmod_poly_inflate result input  inflation Sets result to the inflated polynomial p(x^n) where p is given by input and n is given by  deflation.:Flint2_nmod_poly_tree_build tree roots len mod  0 and that h' is zero-padded as necessary to length n. Uses the identity  \tanh(x) = (e^{2x}-1)/(e^{2x}+1).:Flint2nmod_poly_cosh_series g h n Set #g = \operatorname{cosh}(h) + O(x^n).:Flint2_nmod_poly_cosh_series g h n mod Set "g = \operatorname{cos}(h) + O(x^n) . Assumes n > 0 and that h' is zero-padded as necessary to length n. Aliasing of g and h# is not allowed. Uses the identity \cosh(x) = (e^x + e^{-x})/2.:Flint2nmod_poly_sinh_series g h n Set #g = \operatorname{sinh}(h) + O(x^n).:Flint2_nmod_poly_sinh_series g h n mod Set #g = \operatorname{sinh}(h) + O(x^n) . Assumes n > 0 and that h' is zero-padded as necessary to length n. Aliasing of g and h# is not allowed. Uses the identity \sinh(x) = (e^x - e^{-x})/2.:Flint2nmod_poly_tan_series g h n Set "g = \operatorname{tan}(h) + O(x^n).:Flint2_nmod_poly_tan_series g h n mod Set "g = \operatorname{tan}(h) + O(x^n) . Assumes n > 0 and that h' is zero-padded as necessary to length n. Aliasing of g and h is not allowed. Uses Newton iteration to invert the atan function.:Flint2nmod_poly_cos_series g h n Set "g = \operatorname{cos}(h) + O(x^n).:Flint2_nmod_poly_cos_series g h n mod Set "g = \operatorname{cos}(h) + O(x^n) . Assumes n > 0 and that h' is zero-padded as necessary to length n. Aliasing of g and h7 is allowed. The value is computed using the identity .\cos(x) = (1-\tan^2(x/2)) / (1 + \tan^2(x/2)).:Flint2nmod_poly_sin_series g h n Set "g = \operatorname{sin}(h) + O(x^n).:Flint2_nmod_poly_sin_series g h n mod Set "g = \operatorname{sin}(h) + O(x^n) . Assumes n > 0 and that h' is zero-padded as necessary to length n. Aliasing of g and h7 is allowed. The value is computed using the identity +\sin(x) = 2 \tan(x/2)) / (1 + \tan^2(x/2)).:Flint2nmod_poly_asinh_series g h n Set $g = \operatorname{asinh}(h) + O(x^n).:Flint2_nmod_poly_asinh_series g h hlen n mod Set $g = \operatorname{asinh}(h) + O(x^n) . Assumes n > 0. Aliasing of g and h is allowed.:Flint2nmod_poly_asin_series g h n Set #g = \operatorname{asin}(h) + O(x^n).:Flint2_nmod_poly_asin_series g h hlen n mod Set #g = \operatorname{asin}(h) + O(x^n) . Assumes n > 0. Aliasing of g and h is allowed.:Flint2nmod_poly_atanh_series g h n Set $g = \operatorname{atanh}(h) + O(x^n).:Flint2_nmod_poly_atanh_series g h n mod Set $g = \operatorname{atanh}(h) + O(x^n) . Assumes n > 0. Aliasing of g and h is allowed.:Flint2nmod_poly_atan_series g h n Set #g = \operatorname{atan}(h) + O(x^n).:Flint2_nmod_poly_atan_series g h n mod Set #g = \operatorname{atan}(h) + O(x^n) . Assumes n > 0. Aliasing of g and h is allowed.:Flint2nmod_poly_exp_series g h n Set g = \exp(h) + O(x^n) . The case h = cx^r is automatically detected and handled efficiently. Otherwise this function automatically uses the basecase algorithm for small n! and Newton iteration otherwise.:Flint2_nmod_poly_exp_expinv_series f g h n mod Set f = \exp(h) + O(x^n) and g = \exp(-h) + O(x^n), more efficiently for large n1 than performing a separate inversion to obtain g . Assumes n > 0 and that h( is zero-padded as necessary to length n. Aliasing is not allowed.,Uses Newton iteration (the version given in  [HanZim2004]). For small n', falls back to the basecase algorithm.:Flint2_nmod_poly_exp_series f h hlen n mod Set f = \exp(h) + O(x^n) where h is a polynomial. Assume n > 0. Aliasing of g and h is not allowed.Uses Newton iteration (an improved version of the algorithm in  [HanZim2004] ). For small n', falls back to the basecase algorithm.:Flint2nmod_poly_log_series g h n Set g = \log(h) + O(x^n) . The case  h = 1+cx^r4 is automatically detected and handled efficiently.:Flint2_nmod_poly_log_series g h hlen n mod Set g = \log(h) + O(x^n) . Assumes n > 0 and hlen > 0. Aliasing of g and h is allowed.:Flint2nmod_poly_power_sums_to_poly res Q >Compute the (monic) polynomial given by its power sums series Q.:Flint2_nmod_poly_power_sums_to_poly res poly len mod ?Compute the (monic) polynomial given by its power sums series  (poly,len).:Flint2'nmod_poly_power_sums_to_poly_schoenhage res Q >Compute the (monic) polynomial given by its power sums series Q7 using series expansion (a formula due to Schoenhage).:Flint2(_nmod_poly_power_sums_to_poly_schoenhage res poly len mod ?Compute the (monic) polynomial given by its power sums series  (poly,len)6 using series expansion (a formula due to Schoenhage).:Flint2"nmod_poly_power_sums_to_poly_naive res Q >Compute the (monic) polynomial given by its power sums series Q using Newton identities.:Flint2#_nmod_poly_power_sums_to_poly_naive res poly len mod ?Compute the (monic) polynomial given by its power sums series  (poly,len) using Newton identities.:Flint2nmod_poly_power_sums res poly n  0, that h1 has constant term 1. Aliasing is not permitted.:Flint2nmod_poly_invsqrt_series g h n Set g to the series expansion of  1/\sqrt{h} to order O(x^n). It is assumed that h has constant term 1.:Flint2_nmod_poly_invsqrt_series g h hlen n mod Set the first n terms of g to the series expansion of  1/\sqrt{h}. It is assumed that n > 0, that h1 has constant term 1. Aliasing is not permitted.:Flint2nmod_poly_revert_series Qinv Q n Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n.It is required that Q_0 = 0 and that Q_1 as well as the integers 1, 2, \ldots, n-1# are invertible modulo the modulus.This implementation automatically chooses between the Lagrange inversion formula and Newton iteration based on the size of the input.:Flint2_nmod_poly_revert_series Qinv Q n mod Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n'. The arguments must both have length n and may not be aliased.It is required that Q_0 = 0 and that Q_1 as well as the integers 1, 2, \ldots, n-1# are invertible modulo the modulus.This implementation automatically chooses between the Lagrange inversion formula and Newton iteration based on the size of the input.:Flint2nmod_poly_revert_series_newton Qinv Q n Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n.It is required that Q_0 = 0 and that Q_1 as well as the integers 1, 2, \ldots, n-1# are invertible modulo the modulus.*This implementation uses Newton iteration  [BrentKung1978].:Flint2_nmod_poly_revert_series_newton Qinv Q n mod Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n'. The arguments must both have length n and may not be aliased.It is required that Q_0 = 0 and that Q_1 as well as the integers 1, 2, \ldots, n-1# are invertible modulo the modulus.*This implementation uses Newton iteration  [BrentKung1978].:Flint2%nmod_poly_revert_series_lagrange_fast Qinv Q n Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n.It is required that Q_0 = 0 and that Q_1 as well as the integers 1, 2, \ldots, n-1# are invertible modulo the modulus.This implementation uses a reduced-complexity implementation of the Lagrange inversion formula.:Flint2&_nmod_poly_revert_series_lagrange_fast Qinv Q n mod Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n'. The arguments must both have length n and may not be aliased.It is required that Q_0 = 0 and that Q_1 as well as the integers 1, 2, \ldots, n-1# are invertible modulo the modulus.This implementation uses a reduced-complexity implementation of the Lagrange inversion formula.:Flint2 nmod_poly_revert_series_lagrange Qinv Q n Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n.It is required that Q_0 = 0 and that Q_1 as well as the integers 1, 2, \ldots, n-1# are invertible modulo the modulus.8This implementation uses the Lagrange inversion formula.:Flint2!_nmod_poly_revert_series_lagrange Qinv Q n mod Sets Qinv. to the compositional inverse or reversion of Q# as a power series, i.e. computes Q^{-1} such that )Q(Q^{-1}(x)) = Q^{-1}(Q(x)) = x \bmod x^n'. The arguments must both have length n and may not be aliased.It is required that Q_0 = 0 and that Q_1 as well as the integers 1, 2, \ldots, n-1# are invertible modulo the modulus.8This implementation uses the Lagrange inversion formula.:Flint2nmod_poly_compose_series res poly1 poly2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero.:Flint2_nmod_poly_compose_series res poly1 len1 poly2 len2 n Sets res to the composition of poly1 and poly2 modulo x^n, where the constant term of poly2 is required to be zero. Assumes that len1, len2, n > 0, that len1, len2 <= n , and that\ (len1-1) * (len2-1) + 1 <= n , and that res has space for n coefficients. Does not support aliasing between any of the inputs and the output.Wraps _gr_poly_compose_series9 which chooses automatically between various algorithms.:Flint2nmod_poly_discriminant f Return the discriminant of f. We normalise the discriminant so that (operatorname{disc}(f) = (-1)^(n(n-1)2) operatorname{res}(f, f') * operatorname{lc}(f)^(n - m - 2)), where  n = len(f) and  m = len(f'). Thus (operatorname{disc}(f) = operatorname{lc}(f)^(2n - 2) prod_{i < j} (r_i - r_j)^2), where \operatorname{lc}(f) is the leading coefficient of f and r_i are the roots of f.:Flint2_nmod_poly_discriminant poly len mod Return the discriminant of  (poly, len) . Assumes len > 1.:Flint2nmod_poly_invmod A B P Attempts to set A to the inverse of B modulo P in the polynomial ring (\mathbf{Z}/p\mathbf{Z})[X], where we assume that p is a prime number.If \operatorname{len}(P) < 2, raises an exception."If the greatest common divisor of B and P is~`1`, returns~`1` and sets A to the inverse of B+. Otherwise, returns~`0` and the value of A on exit is undefined.:Flint2_nmod_poly_invmod A B lenB P lenP mod Attempts to set  (A, lenP-1) to the inverse of  (B, lenB) modulo the polynomial  (P, lenP) . Returns 1 if  (B, lenB) is invertible and 0 otherwise. Assumes that 10 < \operatorname{len}(B) < \operatorname{len}(P), and hence also \operatorname{len}(P) \geq 2 , but supports zero-padding in  (B, lenB).Does not support aliasing. Assumes that mod is a prime number.:Flint2nmod_poly_gcdinv G S A B Computes polynomials G and S&, both reduced modulo~`B`, such that G \cong S A \pmod{B}, where B is assumed to have \operatorname{len}(B) \geq 2.In the case that A = 0 \pmod{B} , returns  G = S = 0.:Flint2_nmod_poly_gcdinv G S A lenA B lenB mod  Computes  (G, lenA),  (S, lenB-1) such that G \cong S A \pmod{B}", returning the actual length of G. Assumes that 10 < \operatorname{len}(A) < \operatorname{len}(B).:Flint2nmod_poly_resultant f g Computes the resultant of f and g.For two non-zero polynomials f(x) = a_m x^m + \dotsb + a_0 and g(x) = b_n x^n + \dotsb + b_0 of degrees m and n!, the resultant is defined to be` 5a_m^n b_n^m \prod_{(x, y) : f(x) = g(y) = 0} (x - y).For convenience, we define the resultant to be equal to zero if either of the two polynomials is zero.:Flint2_nmod_poly_resultant poly1 len1 poly2 len2 mod Returns the resultant of  (poly1, len1) and  (poly2, len2). Assumes that len1 >= len2 > 0."Assumes that the modulus is prime.:Flint2nmod_poly_resultant_hgcd f g Computes the resultant of f and g using the half-gcd algorithm.For two non-zero polynomials f(x) = a_m x^m + \dotsb + a_0 and g(x) = b_n x^n + \dotsb + b_0 of degrees m and n!, the resultant is defined to be` 5a_m^n b_n^m \prod_{(x, y) : f(x) = g(y) = 0} (x - y).For convenience, we define the resultant to be equal to zero if either of the two polynomials is zero.:Flint2_nmod_poly_resultant_hgcd poly1 len1 poly2 len2 mod Returns the resultant of  (poly1, len1) and  (poly2, len2) using the half-gcd algorithm.,This algorithm computes the half-gcd as per _nmod_poly_gcd_hgcd but additionally updates the resultant every time a division occurs. The half-gcd algorithm computes the GCD recursively. Given inputs a and b it lets  m = len(a)/2 and (recursively) performs all quotients in the Euclidean algorithm which do not require the low m coefficients of a and b.This performs quotients in exactly the same order as the ordinary Euclidean algorithm except that the low m coefficients of the polynomials in the remainder sequence are not computed. A correction step after hgcd has been called computes these low m coefficients (by matrix multiplication by a transformation matrix also computed by hgcd).This means that from the point of view of the resultant, all but the last quotient performed by a recursive call to hgcd is an ordinary quotient as per the usual Euclidean algorithm. However, the final quotient may give a remainder of less than m + 1 coefficients, which won't be corrected until the hgcd correction step is performed afterwards.To compute the adjustments to the resultant coming from this corrected quotient, we save the relevant information in an nmod_poly_res_t struct at the time the quotient is performed so that when the correction step is performed later, the adjustments to the resultant can be computed at that time also.The only time an adjustment to the resultant is not required after a call to hgcd is if hgcd does nothing (the remainder may already have had less than m + 1$ coefficients when hgcd was called). Assumes that len1 >= len2 > 0."Assumes that the modulus is prime.:Flint2nmod_poly_resultant_euclidean f g Computes the resultant of f and g using the Euclidean algorithm.For two non-zero polynomials f(x) = a_m x^m + \dotsb + a_0 and g(x) = b_n x^n + \dotsb + b_0 of degrees m and n!, the resultant is defined to be8` a_m^n b_n^m \prod_{(x, y) : f(x) = g(y) = 0} (x - y).For convenience, we define the resultant to be equal to zero if either of the two polynomials is zero.:Flint2_nmod_poly_resultant_euclidean poly1 len1 poly2 len2 mod Returns the resultant of  (poly1, len1) and  (poly2, len2) using the Euclidean algorithm. Assumes that len1 >= len2 > 0."Assumes that the modulus is prime.:Flint2nmod_poly_xgcd G S T A B Computes the GCD of A and B. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic.The polynomials S and T are set such that  S*A + T*B = G. The length of S will be at most lenB and the length of T will be at most lenA.:Flint2_nmod_poly_xgcd G S T A lenA B lenB mod Computes the GCD of A and B , where 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0, together with cofactors S and T such that  S A + T B = G. Returns the length of G.)No attempt is made to make the GCD monic.Requires that G have space for \operatorname{len}(B) coefficients. Writes \operatorname{len}(B) - 1 and \operatorname{len}(A) - 1 coefficients to S and T&, respectively. Note that, in fact, \operatorname{len}(S) \leq \operatorname{len}(B) - \operatorname{len}(G) and \operatorname{len}(T) \leq \operatorname{len}(A) - \operatorname{len}(G).6No aliasing of input and output operands is permitted.:Flint2nmod_poly_xgcd_hgcd G S T A B Computes the GCD of A and B. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic. Polynomials S and T are computed such that  S*A + T*B = G. The length of S will be at most lenB and the length of T will be at most lenA.:Flint2_nmod_poly_xgcd_hgcd G S T A A_len B B_len mod Computes the GCD of A and B , where 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0, together with cofactors S and T such that  S A + T B = G. Returns the length of G.)No attempt is made to make the GCD monic.Requires that G have space for \operatorname{len}(B) coefficients. Writes \operatorname{len}(B) - 1 and \operatorname{len}(A) - 1 coefficients to S and T&, respectively. Note that, in fact, \operatorname{len}(S) \leq \operatorname{len}(B) - \operatorname{len}(G) and \operatorname{len}(T) \leq \operatorname{len}(A) - \operatorname{len}(G).Both S and T must have space for at least 2 coefficients.6No aliasing of input and output operands is permitted.:Flint2nmod_poly_xgcd_euclidean G S T A B Computes the GCD of A and B. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic. Polynomials S and T are computed such that  S*A + T*B = G. The length of S will be at most lenB and the length of T will be at most lenA.:Flint2_nmod_poly_xgcd_euclidean G S T A A_len B B_len mod Computes the GCD of A and B together with cofactors S and T such that  S A + T B = G. Returns the length of G. Assumes that 7\operatorname{len}(A) \geq \operatorname{len}(B) \geq 1 and 8(\operatorname{len}(A),\operatorname{len}(B)) \neq (1,1).)No attempt is made to make the GCD monic.Requires that G have space for \operatorname{len}(B) coefficients. Writes \operatorname{len}(B)-1 and \operatorname{len}(A)-1 coefficients to S and T&, respectively. Note that, in fact, \operatorname{len}(S) \leq \max(\operatorname{len}(B) - \operatorname{len}(G), 1) and \operatorname{len}(T) \leq \max(\operatorname{len}(A) - \operatorname{len}(G), 1).6No aliasing of input and output operands is permitted.:Flint2 nmod_poly_gcd G A B Computes the GCD of A and B. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic.;Flint2_nmod_poly_gcd G A lenA B lenB mod Computes the GCD of A of length lenA and B of length lenB , where lenA >= lenB > 0. The length of the GCD G is returned by the function. No attempt is made to make the GCD monic. It is required that G have space for lenB coefficients.;Flint2nmod_poly_gcd_hgcd G A B Computes the monic GCD of A and B using the HGCD algorithm.As a special case, the GCD of two zero polynomials is defined to be the zero polynomial.(The time complexity of the algorithm is \mathcal{O}(n \log^2 n). For further details, see~ [ThullYap1990].;Flint2_nmod_poly_gcd_hgcd G A lenA B lenB mod Computes the monic GCD of A and B, assuming that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Assumes that G has space for \operatorname{len}(B)) coefficients and returns the length of G on output.;Flint2_nmod_poly_hgcd M lenM A lenA B lenB a lena b lenb mod Computes the HGCD of a and b=, that is, a matrix~`M`, a sign~`sigma` and two polynomials A and B such that` +(A,B)^t = M^{-1} (a,b)^t, \sigma = \det(M),and A and B are consecutive remainders in the Euclidean remainder sequence for the division of a by b> satisfying deg(A) ge frac{deg(a)}{2} > deg(B). Furthermore, M will be the product of  [[q 1][1 0]] for the quotients q8 generated by such a remainder sequence. Assumes that 1\operatorname{len}(a) > \operatorname{len}(b) > 0, i.e. \deg(a) > :math:`deg(b) > 1. Assumes that A and B have space of size at least \operatorname{len}(a) and \operatorname{len}(b), respectively. On exit, *lenA and *lenB% will contain the correct lengths of A and B. Assumes that M[0], M[1], M[2], and M[3]* each point to a vector of size at least \operatorname{len}(a).;Flint2nmod_poly_gcd_euclidean G A B Computes the GCD of A and B. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic.;Flint2_nmod_poly_gcd_euclidean G A lenA B lenB mod Computes the GCD of A of length lenA and B of length lenB , where lenA >= lenB > 0. The length of the GCD G is returned by the function. No attempt is made to make the GCD monic. It is required that G have space for lenB coefficients.;Flint2nmod_poly_compose_mod res f g h Sets res to the composition f(g) modulo h. We require that h is nonzero.;Flint2_nmod_poly_compose_mod res f lenf g h lenh mod Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.;Flint24nmod_poly_compose_mod_brent_kung_vec_preinv_threaded res polys len1 n g poly polyinv Multithreaded version of +nmod_poly_compose_mod_brent_kung_vec_preinv.. Distributing the Horner evaluations across flint_get_num_threads threads.;Flint29nmod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool res polys len1 n g poly polyinv threads  num_threads Multithreaded version of +nmod_poly_compose_mod_brent_kung_vec_preinv.. Distributing the Horner evaluations across flint_get_num_threads threads.;Flint2:_nmod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool res polys lenpolys l g glen poly len polyinv leninv mod threads  num_threads Multithreaded version of ,_nmod_poly_compose_mod_brent_kung_vec_preinv.. Distributing the Horner evaluations across flint_get_num_threads threads.;Flint2+nmod_poly_compose_mod_brent_kung_vec_preinv res polys len1 n g h hinv Sets res to the composition f_i(g) modulo h for 1\leq i \leq n where f_i are the first n elements of polys. We require res) to have enough memory allocated to hold n nmod_poly_struct. The entries of res need to be initialised and n needs to be less than len1. We require that h is nonzero and that f_i and g have smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h. No aliasing of res and polys is allowed. The algorithm used is the Brent-Kung matrix algorithm.;Flint2,_nmod_poly_compose_mod_brent_kung_vec_preinv res polys len1 l g leng h lenh hinv lenhinv mod Sets res to the composition f_i(g) modulo h for 1\leq i \leq l, where f_i are the first l elements of polys. We require that h# is nonzero and that the length of g is less than the length of h%. We also require that the length of f_i is less than the length of h . We require res* to have enough memory allocated to hold l nmod_poly_struct's. The entries of res need to be initialised and l needs to be less than len1 Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.;Flint2/nmod_poly_compose_mod_brent_kung_precomp_preinv res f A h hinv Sets res to the composition f(g) modulo h". We require that the ith row of A contains g^i for i=1,\ldots,\sqrt{\deg(h)}, i.e. A is a \sqrt{\deg(h)}\times \deg(h) matrix. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h. This version of Brent-Kung modular composition is particularly useful if one has to perform several modular composition of the form f(g) modulo h for fixed g and h.;Flint20_nmod_poly_compose_mod_brent_kung_precomp_preinv res f lenf A h lenh hinv lenhinv mod Sets res to the composition f(g) modulo h. We require that h, is nonzero. We require that the ith row of A contains g^i for i=1,\ldots,\sqrt{\deg(h)}, i.e. A is a \sqrt{\deg(h)}\times \deg(h)- matrix. We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.;Flint27_nmod_poly_compose_mod_brent_kung_precomp_preinv_worker arg_ptr Worker function version of 0_nmod_poly_compose_mod_brent_kung_precomp_preinv. Input/output is stored in *nmod_poly_compose_mod_precomp_preinv_arg_t.;Flint2nmod_poly_precompute_matrix A f g ginv Sets the ith row of A to f^i modulo g for i=1,\ldots,\sqrt{\deg(g)} . We require A to be a \sqrt{\deg(g)}\times \deg(g) matrix. We require ginv& to be the inverse of the reverse of g.;Flint2_nmod_poly_precompute_matrix A f g leng ginv lenginv mod Sets the ith row of A to f^i modulo g for i=1,\ldots,\sqrt{\deg(g)} . We require A to be a \sqrt{\deg(g)}\times \deg(g) matrix. We require ginv& to be the inverse of the reverse of g and g to be nonzero. f has to be reduced modulo g and of length one less than leng (possibly with zero padding).;Flint2#_nmod_poly_precompute_matrix_worker arg_ptr Worker function version of _nmod_poly_precompute_matrix. Input/output is stored in !nmod_poly_matrix_precompute_arg_t.;Flint2!_nmod_poly_reduce_matrix_mod_poly A B f Sets the ith row of A$ to the reduction of the ith row of B modulo f for i=1,\ldots,\sqrt{\deg(f)} . We require B to be at least a \sqrt{\deg(f)}\times \deg(f) matrix and f to be nonzero.;Flint2'nmod_poly_compose_mod_brent_kung_preinv res f g h hinv Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h9. The algorithm used is the Brent-Kung matrix algorithm.;Flint2(_nmod_poly_compose_mod_brent_kung_preinv res f lenf g h lenh hinv lenhinv mod Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.;Flint2 nmod_poly_compose_mod_brent_kung res f g h Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h9. The algorithm used is the Brent-Kung matrix algorithm.;Flint2!_nmod_poly_compose_mod_brent_kung res f lenf g h lenh mod Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.;Flint2nmod_poly_compose_mod_horner res f g h Sets res to the composition f(g) modulo h. We require that h1 is nonzero. The algorithm used is Horner's rule.;Flint2_nmod_poly_compose_mod_horner res f lenf g h lenh mod Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.$The algorithm used is Horner's rule.;Flint2nmod_poly_taylor_shift g f c $Performs the Taylor shift composing f by x+c*. We require that the modulus is a prime.;Flint2_nmod_poly_taylor_shift poly c len mod $Performs the Taylor shift composing poly by x+c3 in-place. We require that the modulus is a prime.;Flint2"nmod_poly_taylor_shift_convolution g f c $Performs the Taylor shift composing f by x+c<. Writes the composition as a single convolution with cost O(M(n)). We require that the modulus is a prime at least as large as the length.;Flint2#_nmod_poly_taylor_shift_convolution poly c len mod $Performs the Taylor shift composing poly by x+c in-place. Writes the composition as a single convolution with cost O(M(n)). We require that the modulus is a prime at least as large as the length.;Flint2nmod_poly_taylor_shift_horner g f c $Performs the Taylor shift composing f by x+c.;Flint2_nmod_poly_taylor_shift_horner poly c len mod $Performs the Taylor shift composing poly by x+c4 in-place. Uses an efficient version Horner's rule.;Flint2nmod_poly_compose res poly1 poly2  Composes poly1 with poly2 and sets res$ to the result, that is, evaluates poly1 at poly2.;Flint2_nmod_poly_compose res poly1 len1 poly2 len2 mod  Composes poly1 of length len1 with poly2 of length len2 and sets res to the result, i.e.evaluates poly1 at poly2. We require that res have space for (len1 - 1)*(len2 - 1) + 1# coefficients. It is assumed that len1 > 0 and len2 > 0.;Flint2nmod_poly_compose_horner res poly1 poly2  Composes poly1 with poly2 and sets res to the result, i.e.evaluates poly1 at poly2,. The algorithm used is Horner's algorithm.;Flint2_nmod_poly_compose_horner res poly1 len1 poly2 len2 mod  Composes poly1 of length len1 with poly2 of length len2 and sets res to the result, i.e.evaluates poly1 at poly2=. The algorithm used is Horner's algorithm. We require that res have space for (len1 - 1)*(len2 - 1) + 1" coefficients. It is assumed that len1 > 0 and len2 > 0.;Flint2*nmod_poly_interpolate_nmod_vec_barycentric poly xs ys n Forms the interpolating polynomial using a naive implementation of the barycentric form of Lagrange interpolation.;Flint2+_nmod_poly_interpolate_nmod_vec_barycentric poly xs ys n mod Forms the interpolating polynomial using a naive implementation of the barycentric form of Lagrange interpolation.;Flint2%nmod_poly_interpolate_nmod_vec_newton poly xs ys n Forms the interpolating polynomial in the Newton basis using the method of divided differences and then converts it to monomial form.;Flint2&_nmod_poly_interpolate_nmod_vec_newton poly xs ys n mod Forms the interpolating polynomial in the Newton basis using the method of divided differences and then converts it to monomial form.;Flint2#nmod_poly_interpolate_nmod_vec_fast poly xs ys n Performs interpolation using the fast Lagrange interpolation algorithm, generating a temporary subproduct tree.;Flint2$_nmod_poly_interpolate_nmod_vec_fast poly xs ys n mod Performs interpolation using the fast Lagrange interpolation algorithm, generating a temporary subproduct tree.;Flint2,_nmod_poly_interpolate_nmod_vec_fast_precomp poly ys tree weights len mod Performs interpolation using the fast Lagrange interpolation algorithm, generating a temporary subproduct tree.!The function values are given as ys4. The function takes a precomputed subproduct tree tree' and barycentric interpolation weights weights corresponding to the roots.;Flint2 _nmod_poly_interpolation_weights w tree len mod Sets w to the barycentric interpolation weights for fast Lagrange interpolation with respect to a given subproduct tree.;Flint2nmod_poly_interpolate_nmod_vec poly xs ys n Sets poly$ to the unique polynomial of length n that interpolates the n given evaluation points xs and values ys. The values in xs and ys/ should be reduced modulo the modulus, and all xs must be distinct.;Flint2_nmod_poly_interpolate_nmod_vec poly xs ys n mod Sets poly, to the unique polynomial of length at most n that interpolates the n given evaluation points xs and values ys:. If the interpolating polynomial is shorter than length n,, the leading coefficients are set to zero.The values in xs and ys0 should be reduced modulo the modulus, and all xs$ must be distinct. Aliasing between poly and xs or ys is not allowed.;Flint2nmod_poly_evaluate_nmod_vec ys poly xs n  Evaluates poly at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.;Flint2_nmod_poly_evaluate_nmod_vec ys poly len xs n mod  Evaluates (poly, len ) at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.;Flint2 nmod_poly_evaluate_nmod_vec_fast ys poly xs n  Evaluates poly at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.Uses fast multipoint evaluation, building a temporary subproduct tree.;Flint2!_nmod_poly_evaluate_nmod_vec_fast ys poly len xs n mod  Evaluates (coeffs, len ) at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.Uses fast multipoint evaluation, building a temporary subproduct tree.;Flint2)_nmod_poly_evaluate_nmod_vec_fast_precomp vs poly plen tree len mod  Evaluates (poly, plen ) at the len2 values given by the precomputed subproduct tree tree.;Flint2 nmod_poly_evaluate_nmod_vec_iter ys poly xs n  Evaluates poly at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.!Uses Horner's method iteratively.;Flint2!_nmod_poly_evaluate_nmod_vec_iter ys poly len xs n mod  Evaluates (coeffs, len ) at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.!Uses Horner's method iteratively.;Flint2nmod_poly_evaluate_mat dest poly c  Evaluates poly) with matrix as an argument at the value c and stores the result in dest. The dimension and modulus of dest# is assumed to be same as that of c. dest and c may be aliased. This function automatically switches between Horner's method and the Paterson-Stockmeyer algorithm.;Flint2*nmod_poly_evaluate_mat_paterson_stockmeyer dest poly c  Evaluates poly) with matrix as an argument at the value c and stores the result in dest. The dimension and modulus of dest# is assumed to be same as that of c. dest and c may be aliased. Paterson-Stockmeyer algorithm is used to compute the result. The algorithm is described in  [Paterson1973].;Flint2nmod_poly_evaluate_mat_horner dest poly c  Evaluates poly) with matrix as an argument at the value c and stores the result in dest. The dimension and modulus of dest# is assumed to be same as that of c. dest and c may be aliased. Horner's Method is used to compute the result.;Flint2nmod_poly_evaluate_nmod poly c  Evaluates poly at the value~c$ and reduces modulo the modulus of poly . The value~c should be reduced modulo the modulus. The algorithm used is Horner's method.;Flint2_nmod_poly_evaluate_nmod poly len c mod  Evaluates poly at the value~c* and reduces modulo the given modulus of poly . The value~c should be reduced modulo the modulus. The algorithm used is Horner's method.;Flint2nmod_poly_integral x_int x Set x_int to the indefinite integral of x with constant term zero. The result is only well-defined if the modulus is a prime number strictly larger than the degree of x.;Flint2_nmod_poly_integral x_int x len mod Set the first len coefficients of x_int to the integral of x# which is assumed to be of length len - 1. The constant term of x_int% is set to zero. It is assumed that len > 0. The result is only well-defined if the modulus is a prime number strictly larger than the degree of x0. Supports aliasing between the two polynomials.;Flint2nmod_poly_derivative x_prime x Sets x_prime to the derivative of x.;Flint2_nmod_poly_derivative x_prime x len mod Sets the first len - 1 coefficients of x_prime to the derivative of x" which is assumed to be of length len. It is assumed that len > 0.;Flint2nmod_poly_divides Q A B Returns 1 if B divides A and sets Q% to the quotient. Otherwise returns 0 and sets Q to zero.;Flint2_nmod_poly_divides Q A lenA B lenB mod Returns 1 if  (B, lenB) divides  (A, lenA) and sets (Q, lenA - lenB + 1)% to the quotient. Otherwise, returns 0 and sets (Q, lenA - lenB + 1) to zero. We require that lenA >= lenB > 0.;Flint2nmod_poly_divides_classical Q A B Returns 1 if B divides A and sets Q% to the quotient. Otherwise returns 0 and sets Q to zero.;Flint2_nmod_poly_divides_classical Q A lenA B lenB mod Returns 1 if  (B, lenB) divides  (A, lenA) and sets (Q, lenA - lenB + 1)% to the quotient. Otherwise, returns 0 and sets (Q, lenA - lenB + 1) to zero. We require that lenA >= lenB > 0.;Flint2nmod_poly_div_root Q A c Sets Q to the quotient of A on division by (x - c)4, and returns the remainder, equal to the value of A evaluated at c.;Flint2_nmod_poly_div_root Q A len c mod Sets  (Q, len-1) to the quotient of (A, len) on division by (x - c)3, and returns the remainder, equal to the value of A evaluated at c. A and Q are allowed to be the same, but may not overlap partially in any other way.;Flint2 nmod_poly_divrem_newton_n_preinv Q R A B Binv  Computes Q and R such that  A = BQ + R with -\operatorname{len}(R) < \operatorname{len}(B) . We assume Binv# is the inverse of the reverse of B mod x^{\operatorname{len}(B)}."It is required that the length of A+ is less than or equal to 2*the length of B - 2.The algorithm used is to call  div_newton_n2 and then multiply out and compute the remainder.;Flint2!_nmod_poly_divrem_newton_n_preinv Q R A lenA B lenB Binv lenBinv mod  Computes Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB. We require that Q have space for lenA - lenB + 1+ coefficients. Furthermore, we assume that Binv# is the inverse of the reverse of B mod x^{\operatorname{len}(B)}!. The algorithm used is to call div_newton_n_preinv1 and then multiply out and compute the remainder.;Flint2nmod_poly_div_newton_n_preinv Q A B Binv Notionally computes Q and R such that  A = BQ + R with -\operatorname{len}(R) < \operatorname{len}(B), but returns only Q.*We assume that the leading coefficient of B is a unit and that Binv" is the inverse of the reverse of B mod x^{\operatorname{len}(B)}."It is required that the length of A+ is less than or equal to 2*the length of B - 2.The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.;Flint2_nmod_poly_div_newton_n_preinv Q A lenA B lenB Binv lenBinv mod  Notionally computes polynomials Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB, but return only Q.We require that Q have space for lenA - lenB + 1: coefficients and assume that the leading coefficient of B) is a unit. Furthermore, we assume that Binv" is the inverse of the reverse of B mod x^{\operatorname{len}(B)}.The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.;Flint2nmod_poly_div_series Q A B n Given polynomials A and B considered modulo n, finds the polynomial Q of length at most n such that  Q * B = A modulo x^n . We assume n > 0& and that the constant coefficient of B> is invertible modulo the modulus. An exception is raised if n == 0! or the constant coefficient of B is zero.;Flint2_nmod_poly_div_series Q A Alen B Blen n mod Given polynomials A and B of length Alen and Blen, finds the polynomial Q of length n such that  Q * B = A modulo x^n . We assume n > 0& and that the constant coefficient of B9 is invertible modulo the given modulus. The polynomial Q must have space for n coefficients.;Flint2nmod_poly_div_series_basecase Q A B n Given polynomials A and B considered modulo n, finds the polynomial Q of length at most n such that  Q * B = A modulo x^n . We assume n > 0& and that the constant coefficient of B> is invertible modulo the modulus. An exception is raised if n == 0! or the constant coefficient of B is zero.;Flint2_nmod_poly_div_series_basecase Q A Alen B Blen n mod Given polynomials A and B of length Alen and Blen, finds the polynomial Q of length n such that  Q * B = A modulo x^n . We assume n > 0& and that the constant coefficient of B9 is invertible modulo the given modulus. The polynomial Q must have space for n coefficients.;Flint2nmod_poly_inv_series Qinv Q n Given Q find Qinv such that Q * Qinv is 1 modulo x^n. The constant coefficient of Q+ must be invertible modulo the modulus of Q7. An exception is raised if this is not the case or if n = 0;. This function can be viewed as inverting a power series.;Flint2_nmod_poly_inv_series Qinv Q Qlen n mod Given Q of length Qlenn whose constant coefficient is invertible modulo the given modulus, find a polynomial Qinv of length n such that Q * Qinv is 1 modulo x^n . Requires n > 0;. This function can be viewed as inverting a power series.;Flint2nmod_poly_inv_series_newton Qinv Q n Given Q find Qinv such that Q * Qinv is 1 modulo x^n. The constant coefficient of Q+ must be invertible modulo the modulus of Q7. An exception is raised if this is not the case or if n = 0. This function can be viewed as inverting a power series via Newton iteration.;Flint2_nmod_poly_inv_series_newton Qinv Q Qlen n mod Given Q of length Qlen whose constant coefficient is invertible modulo the given modulus, find a polynomial Qinv of length n such that Q * Qinv is 1 modulo x^n . Requires n > 0. This function can be viewed as inverting a power series via Newton iteration.;Flint2nmod_poly_inv_series_basecase Qinv Q n Given Q of length at least n find Qinv of length n such that the top n coefficients of the product Q * Qinv is  x^{n - 1}. An exception is raised if n = 0 or if the length of Q is less than n. The leading coefficient of Q+ must be invertible modulo the modulus of Q:. This function can be viewed as inverting a power series.;Flint2_nmod_poly_inv_series_basecase Qinv Q Qlen n mod Given Q of length Qlen whose leading coefficient is invertible modulo the given modulus, finds a polynomial Qinv of length n such that the top n coefficients of the product Q * Qinv is  x^{n - 1}. Requires that n > 0;. This function can be viewed as inverting a power series.;Flint2 nmod_poly_rem R A B Computes the remainder R on polynomial division of A by B.;Flint2_nmod_poly_rem R A lenA B lenB mod Computes the remainder R on polynomial division of A by B.;Flint2 nmod_poly_div Q A B Computes the quotient Q on polynomial division of A and B.;Flint2_nmod_poly_div Q A lenA B lenB mod  Notionally computes polynomials Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB, but returns only Q. We require that Q have space for lenA - lenB + 1 coefficients.;Flint2nmod_poly_divrem Q R A B  Computes Q and R such that  A = BQ + R with -\operatorname{len}(R) < \operatorname{len}(B).;Flint2_nmod_poly_divrem Q R A lenA B lenB mod  Computes Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB. We require that Q have space for lenA - lenB + 1 coefficients.;Flint2nmod_poly_divrem_basecase Q R A B Finds Q and R such that  A = B Q + R with -\operatorname{len}(R) < \operatorname{len}(B). If \operatorname{len}(B) = 0 an exception is raised.;Flint2_nmod_poly_divrem_basecase Q R W A A_len B B_len mod Finds Q and R such that  A = B Q + R with -\operatorname{len}(R) < \operatorname{len}(B). If \operatorname{len}(B) = 0* an exception is raised. We require that W is temporary space of &NMOD_DIVREM_BC_ITCH(A_len, B_len, mod) coefficients.;Flint2nmod_poly_powers_mod_bsgs res f n g Set the entries of the array res to f^0, f^1, ..., f^(n-1) mod g3. No aliasing is permitted between the entries of res and either of the inputs.;Flint2%_nmod_poly_powers_mod_preinv_threaded res f flen n g glen ginv ginvlen mod Compute f^0, f^1, ..., f^(n-1) mod g, where g has length glen and f is reduced mod g and has length flen" (possibly zero spaced). Assumes res is an array of n& arrays each with space for at least glen - 1 coefficients and that flen > 0. We require that ginv of length ginvlen7 is set to the power series inverse of the reverse of g.;Flint2*_nmod_poly_powers_mod_preinv_threaded_pool res f flen n g glen ginv ginvlen mod threads  num_threads Compute f^0, f^1, ..., f^(n-1) mod g, where g has length glen and f is reduced mod g and has length flen" (possibly zero spaced). Assumes res is an array of n& arrays each with space for at least glen - 1 coefficients and that flen > 0. We require that ginv of length ginvlen7 is set to the power series inverse of the reverse of g.;Flint2nmod_poly_powers_mod_naive res f n g Set the entries of the array res to f^0, f^1, ..., f^(n-1) mod g3. No aliasing is permitted between the entries of res and either of the inputs.;Flint2"_nmod_poly_powers_mod_preinv_naive res f flen n g glen ginv ginvlen mod Compute f^0, f^1, ..., f^(n-1) mod g, where g has length glen and f is reduced mod g and has length flen" (possibly zero spaced). Assumes res is an array of n& arrays each with space for at least glen - 1 coefficients and that flen > 0. We require that ginv of length ginvlen7 is set to the power series inverse of the reverse of g.;Flint2nmod_poly_powmod_x_fmpz_preinv res e f finv Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.;Flint2_nmod_poly_powmod_x_fmpz_preinv res e f lenf finv lenfinv mod Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 2 . The output res must have room for lenf - 1 coefficients.;Flint2nmod_poly_powmod_x_ui_preinv res e f finv Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.;Flint2_nmod_poly_powmod_x_ui_preinv res e f lenf finv lenfinv mod Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 2 . The output res must have room for lenf - 1 coefficients.;Flint2#nmod_poly_powmod_fmpz_binexp_preinv res poly e f finv Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.;Flint2$_nmod_poly_powmod_fmpz_binexp_preinv res poly e f lenf finv lenfinv mod Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.;Flint2"nmod_poly_powmod_mpz_binexp_preinv res poly e f finv Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.;Flint2#_nmod_poly_powmod_mpz_binexp_preinv res poly e f lenf finv lenfinv mod Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f . We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.;Flint2!nmod_poly_powmod_ui_binexp_preinv res poly e f finv Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.;Flint2"_nmod_poly_powmod_ui_binexp_preinv res poly e f lenf finv lenfinv mod Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.;Flint2nmod_poly_powmod_fmpz_binexp res poly e f Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.;Flint2_nmod_poly_powmod_fmpz_binexp res poly e f lenf mod Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.;Flint2nmod_poly_powmod_mpz_binexp res poly e f Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.;Flint2_nmod_poly_powmod_mpz_binexp res poly e f lenf mod Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.;Flint2nmod_poly_powmod_ui_binexp res poly e f Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.;Flint2_nmod_poly_powmod_ui_binexp res poly e f lenf mod Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.;Flint2nmod_poly_pow_trunc res poly e trunc Sets res to the low trunc coefficients of poly to the power e. This is equivalent to doing a powering followed by a truncation.;Flint2_nmod_poly_pow_trunc res poly e trunc mod Sets res to the low trunc coefficients of poly4 (assumed to be zero padded if necessary to length trunc) to the power e. This is equivalent to doing a powering followed by a truncation. We require that res has enough space for trunc coefficients, that  trunc > 0 and that e > 1. Aliasing is not permitted.;Flint2nmod_poly_pow_trunc_binexp res poly e trunc Sets res to the low trunc coefficients of poly to the power e. This is equivalent to doing a powering followed by a truncation. Uses the binary exponentiation method.;Flint2_nmod_poly_pow_trunc_binexp res poly e trunc mod Sets res to the low trunc coefficients of poly4 (assumed to be zero padded if necessary to length trunc) to the power e. This is equivalent to doing a powering followed by a truncation. We require that res has enough space for trunc coefficients, that  trunc > 0 and that e > 1. Aliasing is not permitted. Uses the binary exponentiation method.;Flint2 nmod_poly_pow res poly e Raises poly to the power e and sets res to the result.;Flint2_nmod_poly_pow res poly len e mod Raises poly of length len to the power e and sets res! to the result. We require that res has enough space for (len - 1)*e + 1 coefficients. Assumes that len > 0, e > 1. Aliasing is not permitted.;Flint2nmod_poly_pow_binexp res poly e Raises poly to the power e and sets res7 to the result. Uses the binary exponentiation method.;Flint2_nmod_poly_pow_binexp res poly len e mod Raises poly of length len to the power e and sets res! to the result. We require that res has enough space for (len - 1)*e + 1 coefficients. Assumes that len > 0, e > 1. Aliasing is not permitted. Uses the binary exponentiation method.;Flint2nmod_poly_mulmod_preinv res poly1 poly2 f finv Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f. finv" is the inverse of the reverse of f. It is required that poly1 and poly2 are reduced modulo f.;Flint2_nmod_poly_mulmod_preinv res poly1 len1 poly2 len2 f lenf finv lenfinv mod Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.It is required that finv" is the inverse of the reverse of f mod x^lenf. It is required that len1 + len2 - lenf > 0, which is equivalent to requiring that the result will actually be reduced. It is required that  len1 < lenf and  len2 < lenf. Otherwise, simply use _nmod_poly_mul instead. Aliasing of `res) with any of the inputs is not permitted.;Flint2nmod_poly_mulmod res poly1 poly2 f Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.;Flint2_nmod_poly_mulmod res poly1 len1 poly2 len2 f lenf mod Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.It is required that len1 + len2 - lenf > 0, which is equivalent to requiring that the result will actually be reduced. Otherwise, simply use _nmod_poly_mul instead. Aliasing of f and res is not permitted.;Flint2nmod_poly_mulhigh res poly1 poly2 n Sets all but the low n coefficients of res6 to the corresponding coefficients of the product of poly1 and poly2., the remaining coefficients being arbitrary.;Flint2_nmod_poly_mulhigh res poly1 len1 poly2 len2 n mod Sets all but the low n coefficients of res6 to the corresponding coefficients of the product of poly1 of length len1 and poly2 of length len2>, the other coefficients being arbitrary. It is assumed that len1 >= len2 > 0 and that 0 < n <= len1 + len2 - 12. Aliasing of inputs and output is not permitted.;Flint2nmod_poly_mullow res poly1 poly2 trunc Sets res to the first trunc coefficients of the product of poly1 and poly2.;Flint2_nmod_poly_mullow res poly1 len1 poly2 len2 n mod Sets res to the first n coefficients of the product of poly1 of length len1 and poly2 of length len2. It is assumed that 0 < n <= len1 + len2 - 1 and that len1 >= len2 > 01. No aliasing of inputs and output is permitted.<Flint2 nmod_poly_mul res poly poly2 Sets res to the product of poly1 and poly2.<Flint2_nmod_poly_mul res poly1 len1 poly2 len2 mod Sets res to the product of poly1 of length len1 and poly2 of length len2 . Assumes len1 >= len2 > 0>. No aliasing is permitted between the inputs and the output.<Flint2nmod_poly_mullow_KS res poly1 poly2 bits n Set res to the low n coefficients of in1 of length len1 times in2 of length len2.<Flint2_nmod_poly_mullow_KS out in1 len1 in2 len2 bits n mod Sets out to the low n coefficients of in1 of length len1 times in2 of length len2!. The output must have space for n coefficients. We assume that len1 >= len2 > 0 and that 0 < n <= len1 + len2 - 1.<Flint2nmod_poly_mul_KS4 res poly1 poly2 Sets res to the product of poly1 and poly2.<Flint2_nmod_poly_mul_KS4 res op1 n1 op2 n2 mod Sets res to the product of op1 and op2. Assumes that len1 >= len2 > 0.<Flint2nmod_poly_mul_KS2 res poly1 poly2 Sets res to the product of poly1 and poly2.<Flint2_nmod_poly_mul_KS2 res op1 n1 op2 n2 mod Sets res to the product of op1 and op2. Assumes that len1 >= len2 > 0.<Flint2nmod_poly_mul_KS res poly1 poly2 bits Sets res to the product of poly1 and poly2 assuming the output coefficients are at most the given number of bits wide. If bits is set to 00 an appropriate value is computed automatically.<Flint2_nmod_poly_mul_KS out in1 len1 in2 len2 bits mod Sets res to the product of in1 and in2 assuming the output coefficients are at most the given number of bits wide. If bits is set to 0? an appropriate value is computed automatically. Assumes that len1 >= len2 > 0.<Flint2nmod_poly_mulhigh_classical res poly1 poly2 start Computes the product of poly1 and poly2# and writes the coefficients from start' onwards into the high coefficients of res:, the remaining coefficients being arbitrary but reduced.<Flint2_nmod_poly_mulhigh_classical res poly1 len1 poly2 len2 start mod Computes the product of  (poly1, len1) and  (poly2, len2)# and writes the coefficients from start( onwards into the high coefficients of res, the remaining coefficients being arbitrary but reduced. Assumes that len1 >= len2 > 01. Aliasing of inputs and output is not permitted.<Flint2nmod_poly_mullow_classical res poly1 poly2 trunc Sets res to the lower trunc coefficients of the product of poly1 and poly2.<Flint2_nmod_poly_mullow_classical res poly1 len1 poly2 len2 trunc mod Sets res to the lower trunc! coefficients of the product of  (poly1, len1) and  (poly2, len2). Assumes that len1 >= len2 > 0 and  trunc > 01. Aliasing of inputs and output is not permitted.<Flint2nmod_poly_mul_classical res poly1 poly2 Sets res to the product of poly1 and poly2.<Flint2_nmod_poly_mul_classical res poly1 len1 poly2 len2 mod Sets (res, len1 + len2 - 1) to the product of  (poly1, len1) and  (poly2, len2) . Assumes len1 >= len2 > 02. Aliasing of inputs and output is not permitted.<Flint2_nmod_poly_KS2_recover_reduce res s op1 op2 n b mod *Reduction code used by KS4 multiplication.<Flint2_nmod_poly_KS2_recover_reduce3 res s op1 op2 n b mod Same as _nmod_poly_KS2_recover_reduce, but requires (2 * FLINT_BITS < 2 * b <= 3 * FLINT_BITS.<Flint2_nmod_poly_KS2_recover_reduce2b res s op1 op2 n b mod Same as _nmod_poly_KS2_recover_reduce, but requires b == FLINT_BITS.<Flint2_nmod_poly_KS2_recover_reduce2 res s op1 op2 n b mod Same as _nmod_poly_KS2_recover_reduce, but requires !FLINT_BITS < 2 * b < 2*FLINT_BITS.<Flint2_nmod_poly_KS2_recover_reduce1 res s op1 op2 n b mod Same as _nmod_poly_KS2_recover_reduce, but requires 0 < 2 * b <= FLINT_BITS.<Flint2_nmod_poly_KS2_reduce res s op n w mod 2Reduction code used by KS2 and KS4 multiplication.<Flint2_nmod_poly_KS2_unpack res op n b k 6Bit unpacking code used by KS2 and KS4 multiplication.<Flint2_nmod_poly_KS2_unpack3 res op n b k Same as _nmod_poly_KS2_unpack, but requires #2 * FLINT_BITS < b < 3 * FLINT_BITS, (i.e. writes three words per coefficient).<Flint2_nmod_poly_KS2_unpack2 res op n b k Same as _nmod_poly_KS2_unpack, but requires  FLINT_BITS < b <= 2 * FLINT_BITS* (i.e. writes two words per coefficient).<Flint2_nmod_poly_KS2_unpack1 res op n b k Same as _nmod_poly_KS2_unpack, but requires b <= FLINT_BITS) (i.e. writes one word per coefficient).<Flint2_nmod_poly_KS2_pack res op n s b k r 7Bit packing routine used by KS2 and KS4 multiplication.<Flint2_nmod_poly_KS2_pack1 res op n s b k r Same as _nmod_poly_KS2_pack, but requires b <= FLINT_BITS.<Flint2nmod_poly_bit_unpack poly f bit_size +Unpacks the polynomial from fields of size bit_size as represented by the integer f.<Flint2nmod_poly_bit_pack f poly bit_size Packs poly into bitfields of size bit_size, writing the result to f.<Flint2_nmod_poly_bit_unpack res len mpn bits mod Unpacks len( coefficients stored in the big integer mpn in bit fields of the given number of bits, reduces them modulo the given modulus, then stores them in the polynomial res . We assume len > 0 and 3 * FLINT_BITS > bits > 0. There are no restrictions on the size of the actual coefficients as stored within the bitfields.<Flint2_nmod_poly_bit_pack res poly len bits Packs len coefficients of poly? into fields of the given number of bits in the large integer res, i.e.evaluates poly at 2^bits and store the result in res . Assumes len > 0 and bits > 0'. Also assumes that no coefficient of poly is bigger than bits/2 bits. We also assume bits < 3 * FLINT_BITS.<Flint2nmod_poly_make_monic output input Sets output to be the scalar multiple of input with leading coefficient one, if such a polynomial exists. If input is zero an exception is raised. If the leading coefficient of input is not invertible, output is set to the multiple of input whose leading coefficient is the greatest common divisor of the leading coefficient and the modulus of input.<Flint2_nmod_poly_make_monic output input len mod Sets output to be the scalar multiple of input of length len > 0 that has leading coefficient one, if such a polynomial exists. If the leading coefficient of input is not invertible, output is set to the multiple of input whose leading coefficient is the greatest common divisor of the leading coefficient and the modulus of input.<Flint2nmod_poly_scalar_mul_nmod res poly c Sets res to  (poly, len) multiplied by~`c`, where~`c` is reduced modulo the modulus of poly.<Flint2 nmod_poly_neg res poly Sets res to the negation of poly.<Flint2nmod_poly_sub_series res poly1 poly2 n Notionally truncate poly1 and poly2 to length n and set res to the difference.<Flint2 nmod_poly_sub res poly1 poly2 Sets res to the difference of poly1 and poly2.<Flint2_nmod_poly_sub res poly1 len1 poly2 len2 mod Sets res to the difference of  (poly1, len1) and  (poly2, len2),. There are no restrictions on the lengths.<Flint2nmod_poly_add_series res poly1 poly2 n Notionally truncate poly1 and poly2 to length n and set res to the sum.<Flint2 nmod_poly_add res poly1 poly2 Sets res to the sum of poly1 and poly2.<Flint2_nmod_poly_add res poly1 len1 poly2 len2 mod Sets res to the sum of  (poly1, len1) and  (poly2, len2),. There are no restrictions on the lengths.<Flint2nmod_poly_shift_right res poly k Sets res to poly shifted right by k coefficients, i.e.divide by x^k# and throws away the remainder. If k, is greater than or equal to the length of poly$, the result is the zero polynomial.<Flint2_nmod_poly_shift_right res poly len k Sets (res, len - k) to  (poly, len) shifted left by k# coefficients. It is assumed that k <= len and that res has space for at least len - k coefficients.<Flint2nmod_poly_shift_left res poly k Sets res to poly shifted left by k" coefficients, i.e.multiplied by x^k.<Flint2_nmod_poly_shift_left res poly len k Sets (res, len + k) to  (poly, len) shifted left by k coefficients. Assumes that res has space for len + k coefficients.<Flint2nmod_poly_is_one poly Returns~`1` if the polynomial poly6 is the constant polynomial 1, otherwise returns~`0`.<Flint2nmod_poly_is_zero poly Returns~`1` if the polynomial poly0 is the zero polynomial, otherwise returns~`0`.<Flint2nmod_poly_equal_trunc poly1 poly2 n Notionally truncate poly1 and poly2 to length n and return 11 if the truncations are equal, otherwise return 0.<Flint2nmod_poly_equal a b 8Returns~`1` if the polynomials are equal, otherwise~`0`.<Flint2nmod_poly_read poly Read poly from stdin". The format is as described for nmod_poly_print. If a polynomial in the correct format is read, a positive value is returned, otherwise a non-positive value is returned.<Flint2nmod_poly_fprint_pretty f poly x 'Writes a polynomial to the file stream f. If this is a file then the file should be closed and reopened before being read. The format is as described for nmod_poly_print_pretty. If the polynomial is written correctly, a positive value is returned, otherwise a non-positive value is returned.3It is assumed that the top coefficient is non-zero.In case of success, returns a positive value. In case of failure, returns a non-positive value.<Flint2nmod_poly_fprint f poly 'Writes a polynomial to the file stream f. If this is a file then the file should be closed and reopened before being read. The format is as described for nmod_poly_print. If the polynomial is written correctly, a positive value is returned, otherwise a non-positive value is returned.In case of success, returns a positive value. In case of failure, returns a non-positive value.<Flint2nmod_poly_fread f poly Reads poly from the file stream f. If this is a file that has just been written, the file should be closed then opened again. The format is as described for nmod_poly_print. If a polynomial in the correct format is read, a positive value is returned, otherwise a non-positive value is returned.<Flint2nmod_poly_set_str poly s Reads poly from a string s". The format is as described for nmod_poly_print. If a polynomial in the correct format is read, a positive value is returned, otherwise a non-positive value is returned.<Flint2nmod_poly_get_str_pretty poly x Writes poly to a pretty string representation. The format is as described for nmod_poly_print_pretty. The string must be freed by the user when finished. For this it is sufficient to call  flint_free.3It is assumed that the top coefficient is non-zero.<Flint2nmod_poly_get_str poly Writes poly= to a string representation. The format is as described for nmod_poly_print. The string must be freed by the user when finished. For this it is sufficient to call  flint_free.<Flint2nmod_poly_set_coeff_ui poly j c Sets the coefficient of poly at index j, where coefficients are numbered with zero being the constant coefficient, to the value c reduced modulo the modulus of poly. If j4 refers to a coefficient beyond the current end of poly, the polynomial is first resized, with intervening coefficients being set to zero.<Flint2nmod_poly_get_coeff_ui poly j Returns the coefficient of poly at index~j, where coefficients are numbered with zero being the constant coefficient, and returns it as an ulong. If j+ refers to a coefficient beyond the end of poly, zero is returned.<Flint2%nmod_poly_randtest_sparse_irreducible poly state len Attempts to set poly8 to a sparse, monic irreducible polynomial with length len. It attempts to find an irreducible trinomial. If that does not succeed, it attempts to find a irreducible pentomial. If that fails, then poly6 is just set to a random monic irreducible polynomial.<Flint2(nmod_poly_randtest_pentomial_irreducible poly state len  max_attempts Attempts to set poly, to a monic irreducible pentomial of length len. It will generate up to  max_attempts7 pentomials in attempt to find an irreducible one. If  max_attempts is 0, then it will keep generating pentomials until an irreducible one is found. Returns 1 if one is found and 0 otherwise.<Flint2nmod_poly_randtest_pentomial poly state len -Generates a random monic pentomial of length len.<Flint2(nmod_poly_randtest_trinomial_irreducible poly state len  max_attempts Attempts to set poly, to a monic irreducible trinomial of length len. It will generate up to  max_attempts7 trinomials in attempt to find an irreducible one. If  max_attempts is 0, then it will keep generating trinomials until an irreducible one is found. Returns 1 if one is found and 0 otherwise.<Flint2nmod_poly_randtest_trinomial poly state len -Generates a random monic trinomial of length len.<Flint2"nmod_poly_randtest_monic_primitive poly state len Generates a random monic irreducible primitive polynomial with length len.<Flint2$nmod_poly_randtest_monic_irreducible poly state len = op2 return 0 and set res to  op1 - op2 else return 1 and set res to  op2 - op1.<Flint2nmod_poly_print a Prints the polynomial to stdout. The length is printed, followed by a space, then the modulus. If the length is zero this is all that is printed, otherwise two spaces followed by a space separated list of coefficients is printed, beginning with the constant coefficient.In case of success, returns a positive value. In case of failure, returns a non-positive value.<Flint2nmod_poly_print_pretty a x Prints the polynomial to stdout using the string x! to represent the indeterminate.3It is assumed that the top coefficient is non-zero.In case of success, returns a positive value. In case of failure, returns a non-positive value.::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<n Safe-Inferred )*1::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Safe-Inferred )*1<Flint2nmod_mat_howell_form A Puts A into Howell form and returns the number of non-zero rows. For a definition of the Howell form see  [StoMul1998]0. The Howell form is computed by first putting A6 into strong echelon form and then ordering the rows.A, must have at least as many rows as columns.<Flint2nmod_mat_strong_echelon_form A Puts A into strong echelon form. The Howell form and the strong echelon form are equal up to permutation of the rows, see  [FieHof2014] for a definition of the strong echelon form and the algorithm used here. Note that  [FieHof2014] defines strong echelon form as a lower left normal form, while the implemented version returns an upper right normal form, agreeing with the definition of Howell form in  [StoMul1998].A, must have at least as many rows as columns.<Flint2nmod_mat_minpoly p M Compute the minimal polynomial p of the matrix M. The matrix is required to be square, otherwise an exception is raised.<Flint2nmod_mat_charpoly_berkowitz p M &Compute the characteristic polynomial p of the matrix M. The matrix is required to be square, otherwise an exception is raised. The  danilevsky- algorithm assumes that the modulus is prime.<Flint2nmod_mat_similarity M r d &Applies a similarity transform to the  n\times n matrix M in-place.If P is the  n\times n0 identity matrix the zero entries of whose row r# (0-indexed) have been replaced by d#, this transform is equivalent to  M = P^{-1}MP.Similarity transforms preserve the determinant, characteristic polynomial and minimal polynomial. The value d is required to be reduced modulo the modulus of the entries in the matrix.<Flint2nmod_mat_nullspace X A Computes the nullspace of A and returns the nullity.#More precisely, this function sets X% to a maximum rank matrix such that AX = 0 and returns the rank of X. The columns of X) will form a basis for the nullspace of A.X must have sufficient space to store all basis vectors in the nullspace.This function computes the reduced row echelon form and then reads off the basis vectors.<Flint2nmod_mat_reduce_row A P L n Reduce row n of the matrix A, assuming the prior rows are in Gauss form. However those rows may not be in order. The entry i of the array P is the row of A which has a pivot in the i1-th column. If no such row exists, the entry of P will be -10. The function returns the column in which the n-th row has a pivot after reduction. This will always be chosen to be the first available column for a pivot from the left. This information is also updated in P . Entry i of the array L5 contains the number of possibly nonzero columns of A row i-. This speeds up reduction in the case that A5 is chambered on the right. Otherwise the entries of L- can all be set to the number of columns of A. We require the entries of L to be monotonic increasing.<Flint2 nmod_mat_rref A Puts A5 in reduced row echelon form and returns the rank of A.The rref is computed by first obtaining an unreduced row echelon form via LU decomposition and then solving an additional triangular system.<Flint2 nmod_mat_lu P A  rank_check (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A.If A is a nonsingular square matrix, it will be overwritten with a unit diagonal lower triangular matrix L! and an upper triangular matrix U (the diagonal of L will not be stored explicitly).If A is an arbitrary matrix of rank r, U% will be in row echelon form having r nonzero rows, and L, will be lower triangular but truncated to r' columns, having implicit ones on the r first entries of the main diagonal. All other entries will be zero.If a nonzero value for  rank_check is passed, the function will abandon the output matrix in an undefined state and return 0 if A# is detected to be rank-deficient.The  classical0 version uses direct Gaussian elimination. The classical_delayed version also uses Gaussian elimination, but performs delayed modular reductions. The  recursive version uses block recursive decomposition. The default function chooses an algorithm automatically.<Flint2nmod_mat_solve_vec x A b "Solves the matrix-vector equation Ax = b over \mathbb{Z} / p \mathbb{Z} where p is the modulus of A which must be a prime number.Returns 1 if A" has full rank; otherwise returns 0 and sets the elements of x to undefined values.<Flint2nmod_mat_can_solve X A B "Solves the matrix-matrix equation AX = B over \mathbb{Z} / p \mathbb{Z} where p is the modulus of X which must be a prime number. X, A, and B should have the same moduli.Returns 1) if a solution exists; otherwise returns 0 and sets the elements of X to zero. If more than one solution exists, one of the valid solutions is given.*There are no restrictions on the shape of A and it may be singular.<Flint2nmod_mat_can_solve_inner rank perm pivots X A B As for nmod_mat_can_solve except that if rank is not NULL4 the value it points to will be set to the rank of A. If perm is not NULL then it must be a valid initialised permutation whose length is the number of rows of A. After the function call it will be set to the row permutation given by LU decomposition of A. If pivots is not NULL5 then it must an initialised vector. Only the first *rank of these will be set by the function call. They are set to the columns of the pivots chosen by the LU decomposition of A.<Flint2nmod_mat_solve X A B "Solves the matrix-matrix equation AX = B over \mathbb{Z} / p \mathbb{Z} where p is the modulus of X which must be a prime number. X, A, and B should have the same moduli.Returns 1 if A" has full rank; otherwise returns 0 and sets the elements of X to undefined values. The matrix A must be square.<Flint2nmod_mat_solve_triu_recursive X U B unit Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses the block inversion formula\begin{aligned} ` \begin{pmatrix} A & B \\ 0 & D \end{pmatrix}^{-1} \begin{pmatrix} X \\ Y \end{pmatrix} = \begin{pmatrix} A^{-1} (X - B D^{-1} Y) \\ D^{-1} Y \end{pmatrix} \end{aligned}to reduce the problem to matrix multiplication and triangular solving of smaller systems.<Flint2nmod_mat_solve_triu_classical X U B unit Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses forward substitution.<Flint2nmod_mat_solve_triu X U B unit Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Automatically chooses between the classical and recursive algorithms.<Flint2nmod_mat_solve_tril_recursive X L B unit Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses the block inversion formula\begin{aligned} ` \begin{pmatrix} A & 0 \\ C & D \end{pmatrix}^{-1} \begin{pmatrix} X \\ Y \end{pmatrix} = \begin{pmatrix} A^{-1} X \\ D^{-1} ( Y - C A^{-1} X ) \end{pmatrix} \end{aligned}to reduce the problem to matrix multiplication and triangular solving of smaller systems.<Flint2nmod_mat_solve_tril_classical X L B unit Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses forward substitution.<Flint2nmod_mat_solve_tril X L B unit Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Automatically chooses between the classical and recursive algorithms.<Flint2 nmod_mat_inv B A Sets  B = A^{-1} and returns 1 if A is invertible. If A is singular, returns 0 and sets the elements of B to undefined values.A and B must be square matrices with the same dimensions and modulus. The modulus must be prime.<Flint2 nmod_mat_rank A Returns the rank of A. The modulus of A must be a prime number.<Flint2 nmod_mat_det A Returns the determinant of A.<Flint2nmod_mat_det_howell A Returns the determinant of A.<Flint2nmod_mat_trace mat Computes the trace of the matrix, i.e. the sum of the entries on the main diagonal. The matrix is required to be square.<Flint2 nmod_mat_pow dest mat pow Sets dest = mat^{pow}. dest and mat8 may be aliased. Implements exponentiation by squaring.<Flint2 _nmod_mat_pow dest mat pow Sets dest = mat^{pow}. dest and mat; cannot be aliased. Implements exponentiation by squaring.<Flint2nmod_mat_nmod_vec_mul c a alen B #Compute a vector-matrix product of  (a, alen) and B and and store the result in c . The vector  (a, alen) is either truncated or zero-extended to the number of rows of B!. The number entries written to c- is always equal to the number of columns of B.<Flint2nmod_mat_mul_nmod_vec c A b blen #Compute a matrix-vector product of A and  (b, blen) and store the result in c . The vector  (b, blen) is either truncated or zero-extended to the number of columns of A!. The number entries written to c* is always equal to the number of rows of A.<Flint2nmod_mat_submul D C A B Sets  D = C + AB. C and D. may be aliased with each other but not with A or B.<Flint2nmod_mat_addmul D C A B Sets  D = C + AB. C and D. may be aliased with each other but not with A or B. Automatically selects between classical and Strassen multiplication.<Flint2nmod_mat_mul_blas C A B  Tries to set C = AB using BLAS and returns 1 for success and 0 for failure. Dimensions must be compatible for matrix multiplication.<Flint2nmod_mat_mul_strassen C A B Sets C = AB<. Dimensions must be compatible for matrix multiplication. C# is not allowed to be aliased with A or B. Uses Strassen multiplication (the Strassen-Winograd variant).<Flint2nmod_mat_mul_classical_threaded C A B Multithreaded version of nmod_mat_mul_classical.=Flint2#_nmod_mat_mul_classical_threaded_op D C A B op Multithreaded version of _nmod_mat_mul_classical.=Flint2(_nmod_mat_mul_classical_threaded_pool_op D C A B op threads  num_threads Multithreaded version of _nmod_mat_mul_classical.=Flint2nmod_mat_mul_classical C A B Sets C = AB<. Dimensions must be compatible for matrix multiplication. C# is not allowed to be aliased with A or B. Uses classical matrix multiplication, creating a temporary transposed copy of B to improve memory locality if the matrices are large enough, and packing several entries of B. into each word if the modulus is very small.=Flint2_nmod_mat_mul_classical_op D C A B op Sets  D = A*B op C where op is +1 for addition, -1 for subtraction and 0 to ignore C.=Flint2 nmod_mat_mul C A B Sets C = AB. Dimensions must be compatible for matrix multiplication. Aliasing is allowed. This function automatically chooses between classical and Strassen multiplication.=Flint2nmod_mat_scalar_mul_fmpz res M c Sets B = cA, where the scalar c is of type fmpz_t. Dimensions of A and B must be identical.=Flint2nmod_mat_scalar_addmul_ui dest X Y b Sets  dest = X + bY, where the scalar b is assumed to be reduced modulo the modulus. Dimensions of dest, X and Y must be identical. dest can be aliased with X or Y.=Flint2nmod_mat_scalar_mul B A c Sets B = cA, where the scalar c= is assumed to be reduced modulo the modulus. Dimensions of A and B must be identical.=Flint2 nmod_mat_neg A B Sets B = -A. Dimensions must be identical.=Flint2 nmod_mat_sub C A B  Computes  C = A - B. Dimensions must be identical.=Flint2 nmod_mat_add C A B  Computes  C = A + B. Dimensions must be identical.=Flint2nmod_mat_permute_rows mat perm_act  perm_store Permutes rows of the matrix mat according to permutation perm_act and, if  perm_store is not NULL#, apply the same permutation to it.=Flint2nmod_mat_invert_cols mat perm Swaps columns i and c - i of mat for  0 <= i < c/2, where c is the number of columns of mat. If perm is non-NULL:, the permutation of the columns will also be applied to perm.=Flint2nmod_mat_invert_rows mat perm  Swaps rows i and r - i of mat for  0 <= i < r/2, where r is the number of rows of mat. If perm is non-NULL7, the permutation of the rows will also be applied to perm.=Flint2nmod_mat_swap_cols mat perm r s Swaps columns r and s of mat. If perm is non-NULL:, the permutation of the columns will also be applied to perm.=Flint2nmod_mat_swap_rows mat perm r s  Swaps rows r and s of mat. If perm is non-NULL7, the permutation of the rows will also be applied to perm.=Flint2nmod_mat_transpose B A Sets B to the transpose of A". Dimensions must be compatible. B and A= may be the same object if and only if the matrix is square.=Flint2nmod_mat_is_zero_row mat i  Returns a non-zero value if row i of mat is zero.=Flint2nmod_mat_equal mat1 mat2 Returns nonzero if mat1 and mat2 have the same dimensions and elements, and zero otherwise. The moduli are ignored.=Flint2nmod_mat_randtriu mat state unit Sets mat) to a random upper triangular matrix. If unit is 1, it will have ones on the main diagonal, otherwise it will have random nonzero entries on the main diagonal.=Flint2nmod_mat_randtril mat state unit Sets mat) to a random lower triangular matrix. If unit is 1, it will have ones on the main diagonal, otherwise it will have random nonzero entries on the main diagonal.=Flint2nmod_mat_randops mat count state  Randomises mat by performing elementary row or column operations. More precisely, at most count random additions or subtractions of distinct rows and columns will be performed. This leaves the rank (and for square matrices, determinant) unchanged.=Flint2nmod_mat_randrank mat state rank Sets mat to a random sparse matrix with the given rank, having exactly as many non-zero elements as the rank, with the non-zero elements being uniformly random integers between 0 and m-1 inclusive, where m is the modulus of mat.The matrix can be transformed into a dense matrix with unchanged rank by subsequently calling nmod_mat_randops.=Flint2nmod_mat_randpermdiag mat state diag n Sets mat5 to a random permutation of the diagonal matrix with n& leading entries given by the vector diag+. It is assumed that the main diagonal of mat has room for at least n entries.Returns 0 or 1, depending on whether the permutation is even or odd respectively.=Flint2nmod_mat_randfull mat state Sets the element to random numbers likely to be close to the modulus of the matrix. This is used to test potential overflow-related bugs.=Flint2nmod_mat_randtest mat state :Sets the elements to a random matrix with entries between 0 and m-1 inclusive, where m is the modulus of mat;. A sparse matrix is generated with increased probability.=Flint2nmod_mat_print_pretty mat Pretty-prints mat to stdout. A header is printed followed by the rows enclosed in brackets. Each column is right-aligned to the width of the modulus written in decimal, and the columns are separated by spaces. For example: <2 x 3 integer matrix mod 2903> [ 0 0 2607] [ 622 0 0]=Flint2nmod_mat_concat_horizontal res mat1 mat2 Sets res! to horizontal concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  m \times k, res : m \times (n + k).=Flint2nmod_mat_concat_vertical res mat1 mat2 Sets res% to vertical concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  k \times n, res : (m + k) \times n.=Flint2nmod_mat_window_clear window Clears the matrix window and releases any memory that it uses. Note that the memory to the underlying matrix that window points to is not freed.=Flint2nmod_mat_window_init window mat r1 c1 r2 c2 Initializes the matrix window to be an r2 - r1 by c2 - c1 submatrix of mat whose (0,0) entry is the (r1, c1) entry of mat". The memory for the elements of window is shared with mat.=Flint2nmod_mat_is_zero mat Returns 1 if all entries of the matrix mat are zero.=Flint2 nmod_mat_zero mat Sets all entries of the matrix mat to zero.=Flint2nmod_mat_ncols mat !Returns the number of columns in mat.=Flint2nmod_mat_nrows mat Returns the number of rows in mat.=Flint2nmod_mat_set_entry mat i j x Set the entry at row i and column j of the matrix mat to x.=Flint2nmod_mat_entry_ptr mat i j %Return a pointer to the entry at row i and column j of the matrix mat.=Flint2nmod_mat_get_entry mat i j Get the entry at row i and column j of the matrix mat.=Flint2nmod_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.=Flint2 nmod_mat_swap mat1 mat2  Exchanges mat1 and mat2.=Flint2 nmod_mat_set mat src Sets mat to a copy of src. It is assumed that mat and src have identical dimensions.=Flint2nmod_mat_clear mat Clears the matrix and releases any memory it used. The matrix cannot be used again until it is initialised. This function must be called exactly once when finished using an  nmod_mat_t object.=Flint2nmod_mat_init_set mat src  Initialises mat< and sets its dimensions, modulus and elements to those of src.=Flint2 nmod_mat_init mat rows cols n  Initialises mat to a rows-by-cols" matrix with coefficients modulo n, where n can be any nonzero integer that fits in a limb. All elements are set to zero.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<===============================================o Safe-Inferred )*1<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<==============================================================================================<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Safe-Inferred )*1 =Flint2fq_nmod_modulus_derivative_inv m_prime  m_prime_inv ctx Compute the derivative m_prime of the modulus of ctx as an element of ctx, and its inverse  m_prime_inv.=Flint2fq_nmod_modulus_pow_series_inv res ctx trunc Compute the power series inverse of the reverse of the modulus of ctx up to O(x^\texttt{trunc}).=Flint2!fq_nmod_embed_dual_to_mono_matrix res ctx :Compute the change of basis matrix from the dual basis of ctx to its monomial basis.=Flint2!fq_nmod_embed_mono_to_dual_matrix res ctx >Compute the change of basis matrix from the monomial basis of ctx to its dual basis.=Flint2fq_nmod_embed_mul_matrix matrix gen ctx  Compute the multiplication matrix of gen.For an element a in  \mathbf{F}_{p^n}=\mathbf{F}_p[x], its multiplication matrix is the matrix whose columns are (a, ax, dots, ax^{n-1}).=Flint2$fq_nmod_embed_composition_matrix_sub matrix gen ctx trunc  Compute the composition matrix of gen, truncated to trunc columns.=Flint2 fq_nmod_embed_composition_matrix matrix gen ctx  Compute the composition matrix of gen.For an element a\in\mathbf{F}_{p^n}:, its composition matrix is the matrix whose columns are a^0, a^1, \ldots, a^{n-1}.=Flint2fq_nmod_embed_trace_matrix res basis sub_ctx sup_ctx Given: two contexts sub_ctx and sup_ctx , of degrees m and n, such that m divides n;an  n\times m matrix basis that maps sub_ctx# to an isomorphic subfield in sup_ctx; Compute the  m\times n matrix of the trace from sup_ctx to sub_ctx.This matrix is computed as%embed_dual_to_mono_matrix(_, sub_ctx) \times basist \times &embed_mono_to_dual_matrix(_, sup_ctx)}.Note: if m=n, basis? represents a Frobenius, and the result is its inverse matrix.=Flint2fq_nmod_embed_matrices embed project gen_sub sub_ctx gen_sup sup_ctx  gen_minpoly Given: two contexts sub_ctx and sup_ctx, of respective degrees m and n , such that m divides n; a generator gen_sub of sub_ctx, its minimal polynomial  gen_minpoly , and a root gen_sup of  gen_minpoly in sup_ctx, as returned by fq_nmod_embed_gens;Compute:the  n\times m matrix embed mapping gen_sub to gen_sup(, and all their powers accordingly;an  m\times n matrix project such that project \times embed is the  m\times m identity matrix.=Flint2_fq_nmod_embed_gens_naive gen_sub gen_sup minpoly sub_ctx sup_ctx Given two contexts sub_ctx and sup_ctx , such that degree(sub_ctx) divides degree(sup_ctx), compute an embedding of sub_ctx into sup_ctx defined as follows:gen_sub is the canonical generator of sup_ctx (i.e., the class of X),minpoly is the defining polynomial of sub_ctx,gen_sup is a root of minpoly" inside the field defined by sup_ctx.=Flint2fq_nmod_embed_gens gen_sub gen_sup minpoly sub_ctx sup_ctx Given two contexts sub_ctx and sup_ctx , such that degree(sub_ctx) divides degree(sup_ctx) , compute: an element gen_sub in sub_ctx such that gen_sub, generates the finite field defined by sub_ctx,its minimal polynomial minpoly,a root gen_sup of minpoly inside the field defined by sup_ctx.+These data uniquely define an embedding of sub_ctx into sup_ctx. ===========p Safe-Inferred )*1C =========== =========== Safe-Inferred )*1(1=Flint2fmpz_mod_mat_similarity M r d ctx &Applies a similarity transform to the  n\times n matrix M in-place.If P is the  n\times n0 identity matrix the zero entries of whose row r# (0-indexed) have been replaced by d#, this transform is equivalent to  M = P^{-1}MP.Similarity transforms preserve the determinant, characteristic polynomial and minimal polynomial. The value d is required to be reduced modulo the modulus of the entries in the matrix.#The modulus is assumed to be prime.=Flint2fmpz_mod_mat_can_solve X A B ctx "Solves the matrix-matrix equation AX = B over Fp.Returns 1) if a solution exists; otherwise returns 0 and sets the elements of X to zero. If more than one solution exists, one of the valid solutions is given.*There are no restrictions on the shape of A and it may be singular.#The modulus is assumed to be prime.=Flint2fmpz_mod_mat_solve X A B ctx "Solves the matrix-matrix equation AX = B.Returns 1 if A" has full rank; otherwise returns 0 and sets the elements of X to undefined values. The matrix A must be square.#The modulus is assumed to be prime.=Flint2fmpz_mod_mat_solve_triu X U B unit ctx Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Automatically chooses between the classical and recursive algorithms.#The modulus is assumed to be prime.=Flint2fmpz_mod_mat_solve_tril X L B unit ctx Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Automatically chooses between the classical and recursive algorithms.#The modulus is assumed to be prime.=Flint2fmpz_mod_mat_lu P A  rank_check ctx (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A.If A is a nonsingular square matrix, it will be overwritten with a unit diagonal lower triangular matrix L! and an upper triangular matrix U (the diagonal of L will not be stored explicitly).If A is an arbitrary matrix of rank r, U% will be in row echelon form having r nonzero rows, and L, will be lower triangular but truncated to r' columns, having implicit ones on the r first entries of the main diagonal. All other entries will be zero.If a nonzero value for  rank_check is passed, the function will abandon the output matrix in an undefined state and return 0 if A# is detected to be rank-deficient.#The modulus is assumed to be prime.=Flint2fmpz_mod_mat_inv B A ctx Sets  B = A^{-1} and returns 1 if A is invertible. If A is singular, returns 0 and sets the elements of B to undefined values.A and B2 must be square matrices with the same dimensions.#The modulus is assumed to be prime.=Flint2fmpz_mod_mat_howell_form mat  Transforms mat into the Howell form of mat+. For a definition of the Howell form see  [StoMul1998]0. The Howell form is computed by first putting mat6 into strong echelon form and then ordering the rows.mat, must have at least as many rows as columns.=Flint2 fmpz_mod_mat_strong_echelon_form mat  Transforms mat! into the strong echelon form of mat. The Howell form and the strong echelon form are equal up to permutation of the rows, see  [FieHof2014] for a definition of the strong echelon form and the algorithm used here.mat, must have at least as many rows as columns.=Flint2fmpz_mod_mat_rref perm mat %Uses Gauss-Jordan elimination to set mat: to its reduced row echelon form and returns the rank of mat.If perm is non-NULL, the permutation of rows in the matrix will also be applied to perm.#The modulus is assumed to be prime.=Flint2fmpz_mod_mat_trace trace mat Set trace to the trace of the matrix mat.=Flint2fmpz_mod_mat_fmpz_vec_mul c a alen B #Compute a vector-matrix product of  (a, alen) and B and and store the result in c . The vector  (a, alen) is either truncated or zero-extended to the number of rows of B!. The number entries written to c- is always equal to the number of columns of B.=Flint2fmpz_mod_mat_mul_fmpz_vec c A b blen #Compute a matrix-vector product of A and  (b, blen) and store the result in c . The vector  (b, blen) is either truncated or zero-extended to the number of columns of A!. The number entries written to c* is always equal to the number of rows of A.=Flint2fmpz_mod_mat_sqr B A Set B to A^2 . The matrix A must be square.=Flint2#fmpz_mod_mat_mul_classical_threaded C A B Set C to  A\times B. The number of rows of B& must match the number of columns of A.=Flint2,_fmpz_mod_mat_mul_classical_threaded_pool_op D C A B op threads  num_threads Set D to A\times B + op*C where op is +1, -1 or 0.=Flint2fmpz_mod_mat_mul C A B Set C to  A\times B. The number of rows of B& must match the number of columns of A.=Flint2fmpz_mod_mat_scalar_mul_fmpz B A c Set B to cA where c is a constant.=Flint2fmpz_mod_mat_scalar_mul_ui B A c Set B to cA where c is a constant.=Flint2fmpz_mod_mat_scalar_mul_si B A c Set B to cA where c is a constant.=Flint2fmpz_mod_mat_neg B A Set B to -A.=Flint2fmpz_mod_mat_sub C A B Set C to A - B.=Flint2fmpz_mod_mat_add C A B Set C to A + B.=Flint2fmpz_mod_mat_get_fmpz_mat A B Set A to a lift of B.=Flint2fmpz_mod_mat_set_fmpz_mat A B Set A to the matrix B reducing modulo the modulus of A.=Flint2fmpz_mod_mat_transpose B A Set B to the transpose of A.=Flint2fmpz_mod_mat_set B A Set B to equal A.=Flint2fmpz_mod_mat_is_zero mat Return 1 if mat is the zero matrix.=Flint2fmpz_mod_mat_print_pretty mat Prints the given matrix to stdout. The format is an opening square bracket then on each line a row of the matrix, followed by a closing square bracket. Each row is written as an opening square bracket followed by a space separated list of coefficients followed by a closing square bracket.=Flint2fmpz_mod_mat_concat_vertical res mat1 mat2 Sets res! to horizontal concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  m \times k, res : m \times (n + k).=Flint2fmpz_mod_mat_concat_horizontal res mat1 mat2 Sets res to vertical concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  k \times n, res : (m + k) \times n.=Flint2fmpz_mod_mat_window_clear window Clears the matrix window and releases any memory that it uses. Note that the memory to the underlying matrix that window points to is not freed.=Flint2fmpz_mod_mat_window_init window mat r1 c1 r2 c2 Initializes the matrix window to be an r2 - r1 by c2 - c1 submatrix of mat whose (0, 0) entry is the (r1, c1) entry of mat!. The memory for the elements of window is shared with mat.=Flint2fmpz_mod_mat_randtest mat state Generate a random matrix with the existing dimensions and entries in [0, n) where n is the modulus.=Flint2_fmpz_mod_mat_reduce mat Reduce all the entries of mat by the modulus n+. This function is only needed internally.=Flint2fmpz_mod_mat_is_square mat Return 1 if mat) has the same number of rows and columns.=Flint2fmpz_mod_mat_is_empty mat Return 1 if mat! has either zero rows or columns.=Flint2fmpz_mod_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.=Flint2fmpz_mod_mat_swap mat1 mat2 Efficiently swap the matrices mat1 and mat2.=Flint2fmpz_mod_mat_zero mat Set mat to the zero matrix.=Flint2fmpz_mod_mat_one mat Set mat1 to the identity matrix (ones down the diagonal).=Flint2_fmpz_mod_mat_set_mod mat n Set the modulus of the matrix mat to n.=Flint2fmpz_mod_mat_ncols mat  Return the number of columns of mat.=Flint2fmpz_mod_mat_nrows mat Return the number of rows of mat.=Flint2fmpz_mod_mat_clear mat Clear mat and release any memory it used.=Flint2fmpz_mod_mat_init_set mat src  Initialise mat and set it equal to the matrix src<, including the number of rows and columns and the modulus.=Flint2fmpz_mod_mat_init mat rows cols n  Initialise mat& as a matrix with the given number of rows and cols and modulus n.=Flint2fmpz_mod_mat_set_entry mat i j val Set the entry at row i and column j of mat to val.=Flint2fmpz_mod_mat_entry mat i j )Return a reference to the element at row i and column j of mat.8========================================================q Safe-Inferred )*1)78========================================================8======================================================== Safe-Inferred )*1X]=Flint2fmpz_mod_mat_minpoly p M ctx Compute the minimal polynomial p of the matrix M. The matrix is required to be square, otherwise an exception is raised.#The modulus is assumed to be prime.=Flint2fmpz_mod_mat_charpoly p M ctx &Compute the characteristic polynomial p of the matrix M. The matrix is required to be square, otherwise an exception is raised.=Flint2 fmpz_mod_berlekamp_massey_R_poly B Return the polynomial R in B.=Flint2 fmpz_mod_berlekamp_massey_V_poly B Return the polynomial V in B.=Flint2 fmpz_mod_berlekamp_massey_points B /Return a pointer the array of points stored in B. This may be NULL9 if func::fmpz_mod_berlekamp_massey_point_count returns 0.=Flint2%fmpz_mod_berlekamp_massey_point_count B &Return the number of points stored in B.=Flint2 fmpz_mod_berlekamp_massey_reduce B ctx Ensure that the polynomials V and R& are up to date. The return value is 1 if this function changed V and 0 otherwise. For example, if this function is called twice in a row without adding any points in between, the return of the second call should be 0. As another example, suppose the object is emptied, the points  1, 1, 2, 3> are added, then reduce is called. This reduce should return 1 with \deg(R) < \deg(V) = 2 because the Fibonacci sequence has been recognized. The further addition of the two points 5, 80 and a reduce will result in a return value of 0.>Flint2$fmpz_mod_berlekamp_massey_add_points B a count ctx (Add point(s) to the stream processed by B<. The addition of any number of points will not update the V and R polynomial.>Flint2$fmpz_mod_berlekamp_massey_start_over B ctx Empty the stream of points in B.>Flint2fmpz_mod_berlekamp_massey_clear B ctx Free any space used by B.>Flint2fmpz_mod_berlekamp_massey_init B ctx  Initialize B with an empty stream.>Flint2fmpz_mod_poly_deflation input ctx %Returns the largest integer by which input2 can be deflated. As special cases, returns 0 if input! is the zero polynomial and 1 of input is a constant polynomial.>Flint2fmpz_mod_poly_deflate result input  deflation ctx Sets result to the deflated polynomial  p(x^{1/n}) where p is given by input and n is given by  deflation . Requires n > 0.>Flint2fmpz_mod_poly_inflate result input  inflation ctx Sets result to the inflated polynomial p(x^n) where p is given by input and n is given by  inflation.>Flint2fmpz_mod_poly_fprint_pretty file poly x ctx $Prints the pretty representation of  (poly, len) to the stream file, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.>Flint2fmpz_mod_poly_fprint file poly ctx $Prints the polynomial to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.>Flint2_fmpz_mod_poly_fprint file poly len p Prints the polynomial  (poly, len) to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.>Flint2fmpz_mod_poly_radix B F D ctx Given a polynomial F and the precomputed data D for the radix R, computes polynomials B_0, \dotsc, B_N of degree less than \deg(R) such that` #F = B_0 + B_1 R + \dotsb + B_N R^N,where necessarily #N = \lfloor\deg(F) / \deg(R)\rfloor. Assumes that R is non-constant, i.e.(deg(R) geq 1), and that the leading coefficient is a unit.>Flint2_fmpz_mod_poly_radix B F Rpow Rinv degR k i W p :This is the main recursive function used by the function fmpz_mod_poly_radix.Assumes that, for all i = 0, \dotsc, N , the vector B[i] has space for \deg(R) coefficients. The variable k denotes the factors of r7 that have previously been counted for the polynomial F#, which is assumed to have length 2^{i+1} \deg(R)", possibly including zero-padding. Assumes that W2 is a vector providing temporary space of length '\operatorname{len}(F) = 2^{i+1} \deg(R).(The entire computation takes place over \mathbf{Z} / p \mathbf{Z} , where p \geq 2 is a natural number.#Thus, the top level call will have F" as in the original problem, and k = 0.>Flint2fmpz_mod_poly_radix_init D R degF ctx Carries out the precomputation necessary to perform radix conversion to radix~`R` for polynomials~`F` of degree at most degF. Assumes that R is non-constant, i.e. \deg(R) \geq 1., and that the leading coefficient is a unit.>Flint2_fmpz_mod_poly_radix_init Rpow Rinv R lenR k invL p Computes powers of R of the form R^{2^i}# and their Newton inverses modulo x^{2^{i} \deg(R)} for i = 0, \dotsc, k-1.Assumes that the vectors Rpow[i] and Rinv[i] have space for 2^i \deg(R) + 1 and  2^i \deg(R) coefficients, respectively.Assumes that the polynomial R is non-constant, i.e. \deg(R) \geq 1.(Assumes that the leading coefficient of R" is a unit and that the argument invL. is the inverse of the coefficient modulo~`p`.*The argument~`p` is the modulus, which in p-adic applications is typically a prime power, although this is not necessary. Here, we only assume that p \geq 2.4Note that this precomputed data can be used for any F such that &\operatorname{len}(F) \leq 2^k \deg(R).>Flint2_fmpz_mod_poly_tree_build tree roots len mod Flint2_fmpz_mod_poly_tree_free tree len ,Free the allocated space for the subproduct.>Flint2_fmpz_mod_poly_tree_alloc len Allocates space for a subproduct tree of the given length, having linear factors at the lowest level.>Flint28fmpz_mod_poly_compose_mod_brent_kung_vec_preinv_threaded res polys len1 n g poly polyinv ctx Multithreaded version of /fmpz_mod_poly_compose_mod_brent_kung_vec_preinv.. Distributing the Horner evaluations across flint_get_num_threads threads.>Flint2=fmpz_mod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool res polys len1 n g poly polyinv ctx threads  num_threads Multithreaded version of /fmpz_mod_poly_compose_mod_brent_kung_vec_preinv.. Distributing the Horner evaluations across flint_get_num_threads threads.>Flint2>_fmpz_mod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool res polys lenpolys l g glen poly len polyinv leninv p threads  num_threads Multithreaded version of 0_fmpz_mod_poly_compose_mod_brent_kung_vec_preinv.. Distributing the Horner evaluations across flint_get_num_threads threads.>Flint2/fmpz_mod_poly_compose_mod_brent_kung_vec_preinv res polys len1 n g h hinv ctx Sets res to the composition f_i(g) modulo h for 1\leq i \leq n where f_i are the n elements of polys. We require res) to have enough memory allocated to hold n fmpz_mod_poly_struct's. The entries of res need to be initialised and n needs to be less than len1. We require that h is nonzero and that f_i and g have smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h. No aliasing of res and polys is allowed. The algorithm used is the Brent-Kung matrix algorithm.>Flint20_fmpz_mod_poly_compose_mod_brent_kung_vec_preinv res polys len1 l g glen h lenh hinv lenhinv p Sets res to the composition f_i(g) modulo h for 1\leq i \leq l, where f_i are the l elements of polys. We require that h# is nonzero and that the length of g is less than the length of h%. We also require that the length of f_i is less than the length of h . We require res* to have enough memory allocated to hold l fmpz_mod_poly_struct's. The entries of res need to be initialised and l needs to be less than len1 Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.>Flint2+fmpz_mod_poly_compose_mod_brent_kung_preinv res f g h hinv ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h9. The algorithm used is the Brent-Kung matrix algorithm.>Flint2,_fmpz_mod_poly_compose_mod_brent_kung_preinv res f lenf g h lenh hinv lenhinv p Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.>Flint23fmpz_mod_poly_compose_mod_brent_kung_precomp_preinv res f A h hinv ctx Sets res to the composition f(g) modulo h". We require that the ith row of A contains g^i for i=1,\ldots,\sqrt{\deg(h)}, i.e. A is a \sqrt{\deg(h)}\times \deg(h) matrix. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h. This version of Brent-Kung modular composition is particularly useful if one has to perform several modular composition of the form f(g) modulo h for fixed g and h.>Flint24_fmpz_mod_poly_compose_mod_brent_kung_precomp_preinv res f lenf A h lenh hinv lenhinv p Sets res to the composition f(g) modulo h. We require that h, is nonzero. We require that the ith row of A contains g^i for i=1,\ldots,\sqrt{\deg(h)}, i.e. A is a \sqrt{\deg(h)}\times \deg(h)- matrix. We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.>Flint2;_fmpz_mod_poly_compose_mod_brent_kung_precomp_preinv_worker arg_ptr Worker function version of 4_fmpz_mod_poly_compose_mod_brent_kung_precomp_preinv. Input/output is stored in .fmpz_mod_poly_compose_mod_precomp_preinv_arg_t.>Flint2fmpz_mod_poly_precompute_matrix A f g ginv ctx Sets the ith row of A to f^i modulo g for i=1,\ldots,\sqrt{\deg(g)} . We require A to be a \sqrt{\deg(g)}\times \deg(g) matrix. We require ginv& to be the inverse of the reverse of g.>Flint2 _fmpz_mod_poly_precompute_matrix A f g leng ginv lenginv p Sets the ith row of A to f^i modulo g for i=1,\ldots,\sqrt{\deg(g)} . We require A to be a \sqrt{\deg(g)}\times \deg(g) matrix. We require ginv& to be the inverse of the reverse of g and g to be nonzero. f has to be reduced modulo g and of length one less than leng (possibly with zero padding).>Flint2'_fmpz_mod_poly_precompute_matrix_worker arg_ptr Worker function version of  _fmpz_mod_poly_precompute_matrix. Input/output is stored in %fmpz_mod_poly_matrix_precompute_arg_t.>Flint2%_fmpz_mod_poly_reduce_matrix_mod_poly A B f ctx Sets the ith row of A$ to the reduction of the ith row of B modulo f for i=1,\ldots,\sqrt{\deg(f)} . We require B to be at least a \sqrt{\deg(f)}\times \deg(f) matrix and f to be nonzero.>Flint2$fmpz_mod_poly_compose_mod_brent_kung res f g h ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h9. The algorithm used is the Brent-Kung matrix algorithm.>Flint2%_fmpz_mod_poly_compose_mod_brent_kung res f len1 g h len3 p Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.>Flint2 fmpz_mod_poly_compose_mod_horner res f g h ctx Sets res to the composition f(g) modulo h. We require that h1 is nonzero. The algorithm used is Horner's rule.>Flint2!_fmpz_mod_poly_compose_mod_horner res f lenf g h lenh p Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.$The algorithm used is Horner's rule.>Flint2fmpz_mod_poly_compose_mod res f g h ctx Sets res to the composition f(g) modulo h. We require that h is nonzero.>Flint2_fmpz_mod_poly_compose_mod res f lenf g h lenh p Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.>Flint2fmpz_mod_poly_sqrt s p mod If p is a perfect square, sets s to a square root of p% and returns 1. Otherwise returns 0.>Flint2_fmpz_mod_poly_sqrt s p n mod If (p, n) is a perfect square, sets (s, n / 2 + 1) to a square root of p$ and returns 1. Otherwise returns 0.>Flint2fmpz_mod_poly_sqrt_series g h n ctx Set g to the series expansion of \sqrt{h} to order O(x^n). It is assumed that h has constant term 1.>Flint2_fmpz_mod_poly_sqrt_series g h n ctx Set the first n terms of g to the series expansion of \sqrt{h}. It is assumed that n > 0, that h has constant term 1 and that h' is zero-padded as necessary to length n. Aliasing is not permitted.>Flint2fmpz_mod_poly_invsqrt_series g h n ctx Set g to the series expansion of  1/\sqrt{h} to order O(x^n). It is assumed that h has constant term 1.>Flint2_fmpz_mod_poly_invsqrt_series g h n mod Set the first n terms of g to the series expansion of  1/\sqrt{h}. It is assumed that n > 0, that h has constant term 1 and that h' is zero-padded as necessary to length n. Aliasing is not permitted.>Flint2fmpz_mod_poly_compose res poly1 poly2 ctx Sets res to the composition of poly1 and poly2.7To be precise about the order of composition, denoting res, poly1, and poly2 by f, g, and h, respectively, sets f(t) = g(h(t)).>Flint2_fmpz_mod_poly_compose res poly1 len1 poly2 len2 p Sets res to the composition of  (poly1, len1) and  (poly2, len2). Assumes that res has space for (len1-1)*(len2-1) + 1 coefficients, although in \mathbf{Z}_p[X] this might not actually be the length of the resulting polynomial when p is not a prime. Assumes that poly1 and poly2 are non-zero polynomials. Does not support aliasing between any of the inputs and the output.>Flint2fmpz_mod_poly_evaluate_fmpz_vec ys poly xs n ctx  Evaluates poly at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.>Flint2 _fmpz_mod_poly_evaluate_fmpz_vec ys coeffs len xs n mod  Evaluates (coeffs, len ) at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.>Flint2$fmpz_mod_poly_evaluate_fmpz_vec_fast ys poly xs n ctx  Evaluates poly at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.Uses fast multipoint evaluation, building a temporary subproduct tree.>Flint2%_fmpz_mod_poly_evaluate_fmpz_vec_fast ys poly plen xs n mod  Evaluates (coeffs, len ) at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.Uses fast multipoint evaluation, building a temporary subproduct tree.>Flint2-_fmpz_mod_poly_evaluate_fmpz_vec_fast_precomp vs poly plen tree len mod  Evaluates (poly, plen ) at the len2 values given by the precomputed subproduct tree tree.>Flint2$fmpz_mod_poly_evaluate_fmpz_vec_iter ys poly xs n ctx  Evaluates poly at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.!Uses Horner's method iteratively.>Flint2%_fmpz_mod_poly_evaluate_fmpz_vec_iter ys coeffs len xs n mod  Evaluates (coeffs, len ) at the n values given in the vector xs , writing the output values to ys. The values in xs' should be reduced modulo the modulus.!Uses Horner's method iteratively.>Flint2fmpz_mod_poly_evaluate_fmpz res poly a ctx Evaluates the polynomial poly at the integer a and sets res to the result.As expected, aliasing between res and a is supported. However, res* may not be aliased with a coefficient of poly.>Flint2_fmpz_mod_poly_evaluate_fmpz res poly len a p Evaluates the polynomial  (poly, len) at the integer a and sets res! to the result. Aliasing between res and a or any of the coefficients of poly is not supported.>Flint2fmpz_mod_poly_derivative res poly ctx Sets res to the derivative of poly.>Flint2_fmpz_mod_poly_derivative res poly len p Sets (res, len - 1) to the derivative of  (poly, len) . Also handles the cases where len is 0 or 1" correctly. Supports aliasing of res and poly.>Flint2fmpz_mod_poly_discriminant d f ctx Set d to the discriminant of f. We normalise the discriminant so that (operatorname{disc}(f) = (-1)^(n(n-1)2) operatorname{res}(f, f') * operatorname{lc}(f)^(n - m - 2)), where  n = len(f) and  m = len(f'). Thus (operatorname{disc}(f) = operatorname{lc}(f)^(2n - 2) prod_{i < j} (r_i - r_j)^2), where \operatorname{lc}(f) is the leading coefficient of f and r_i are the roots of f.>Flint2_fmpz_mod_poly_discriminant d poly len mod Set d to the discriminant of  (poly, len) . Assumes len > 1.>Flint2fmpz_mod_poly_resultant res f g ctx &Computes the resultant of $f$ and $g$.For two non-zero polynomials f(x) = a_m x^m + \dotsb + a_0 and g(x) = b_n x^n + \dotsb + b_0 of degrees m and n!, the resultant is defined to be` 5a_m^n b_n^m \prod_{(x, y) : f(x) = g(y) = 0} (x - y).For convenience, we define the resultant to be equal to zero if either of the two polynomials is zero.>Flint2_fmpz_mod_poly_resultant res poly1 len1 poly2 len2 mod Returns the resultant of  (poly1, len1) and  (poly2, len2). Assumes that len1 >= len2 > 0."Assumes that the modulus is prime.>Flint2fmpz_mod_poly_resultant_hgcd res f g ctx Computes the resultant of f and g using the half-gcd algorithm.For two non-zero polynomials f(x) = a_m x^m + \dotsb + a_0 and g(x) = b_n x^n + \dotsb + b_0 of degrees m and n!, the resultant is defined to be` 5a_m^n b_n^m \prod_{(x, y) : f(x) = g(y) = 0} (x - y).For convenience, we define the resultant to be equal to zero if either of the two polynomials is zero.>Flint2_fmpz_mod_poly_resultant_hgcd res A lenA B lenB mod Sets res to the resultant of  (A, lenA) and  (B, lenB) using the half-gcd algorithm.,This algorithm computes the half-gcd as per _fmpz_mod_poly_gcd_hgcd but additionally updates the resultant every time a division occurs. The half-gcd algorithm computes the GCD recursively. Given inputs a and b it lets  m = len(a)/2 and (recursively) performs all quotients in the Euclidean algorithm which do not require the low m coefficients of a and b.This performs quotients in exactly the same order as the ordinary Euclidean algorithm except that the low m coefficients of the polynomials in the remainder sequence are not computed. A correction step after hgcd has been called computes these low m coefficients (by matrix multiplication by a transformation matrix also computed by hgcd).This means that from the point of view of the resultant, all but the last quotient performed by a recursive call to hgcd is an ordinary quotient as per the usual Euclidean algorithm. However, the final quotient may give a remainder of less than m + 1 coefficients, which won't be corrected until the hgcd correction step is performed afterwards.To compute the adjustments to the resultant coming from this corrected quotient, we save the relevant information in an nmod_poly_res_t struct at the time the quotient is performed so that when the correction step is performed later, the adjustments to the resultant can be computed at that time also.The only time an adjustment to the resultant is not required after a call to hgcd is if hgcd does nothing (the remainder may already have had less than m + 1$ coefficients when hgcd was called). Assumes that lenA >= lenB > 0."Assumes that the modulus is prime.>Flint2!fmpz_mod_poly_resultant_euclidean r f g ctx Computes the resultant of f and g using the Euclidean algorithm.For two non-zero polynomials f(x) = a_m x^m + \dotsb + a_0 and g(x) = b_n x^n + \dotsb + b_0 of degrees m and n!, the resultant is defined to be` 5a_m^n b_n^m \prod_{(x, y) : f(x) = g(y) = 0} (x - y).For convenience, we define the resultant to be equal to zero if either of the two polynomials is zero.>Flint2"_fmpz_mod_poly_resultant_euclidean res poly1 len1 poly2 len2 mod Sets r to the resultant of  (poly1, len1) and  (poly2, len2) using the Euclidean algorithm. Assumes that len1 >= len2 > 0."Assumes that the modulus is prime.>Flint2fmpz_mod_poly_minpoly poly seq len ctx Sets poly1 to a minimal generating polynomial for sequence seq of length len.7A minimal generating polynomial is a monic polynomial /f = x^d + c_{d-1}x^{d-1} + \cdots + c_1 x + c_0, of minimal degree d#, that annihilates any consecutive d+1 terms in seq. That is, for any  i < len - d,(seq_i = -\sum_{j=0}^{d-1} seq_{i+j}*f_j."Assumes that the modulus is prime.This version automatically chooses the fastest underlying implementation based on len and the size of the modulus.>Flint2_fmpz_mod_poly_minpoly poly seq len p Sets poly to the coefficients of a minimal generating polynomial for sequence  (seq, len) modulo p.&The return value equals the length of poly.It is assumed that p is prime and poly has space for at least len+1 coefficients. No aliasing between inputs and outputs is allowed.>Flint2fmpz_mod_poly_minpoly_hgcd poly seq len ctx Sets poly1 to a minimal generating polynomial for sequence seq of length len."Assumes that the modulus is prime.=This version uses the HGCD algorithm, whose running time is  O(n \log^2 n) field operations, regardless of the actual size of the minimal generator.>Flint2_fmpz_mod_poly_minpoly_hgcd poly seq len p Sets poly to the coefficients of a minimal generating polynomial for sequence  (seq, len) modulo p.&The return value equals the length of poly.It is assumed that p is prime and poly has space for at least len+1 coefficients. No aliasing between inputs and outputs is allowed.>Flint2fmpz_mod_poly_minpoly_bm poly seq len ctx Sets poly1 to a minimal generating polynomial for sequence seq of length len."Assumes that the modulus is prime.This version uses the Berlekamp-Massey algorithm, whose running time is proportional to len) times the size of the minimal generator.>Flint2_fmpz_mod_poly_minpoly_bm poly seq len p Sets poly to the coefficients of a minimal generating polynomial for sequence  (seq, len) modulo p.&The return value equals the length of poly.It is assumed that p is prime and poly has space for at least len+1 coefficients. No aliasing between inputs and outputs is allowed.>Flint2fmpz_mod_poly_invmod_f f A B P ctx If f returns with the value 1%, then the function operates as per fmpz_mod_poly_invmod . Otherwise f# is set to a nontrivial factor of p.>Flint2fmpz_mod_poly_invmod A B P ctx Attempts to set A to the inverse of B modulo P in the polynomial ring (\mathbf{Z}/p\mathbf{Z})[X], where we assume that p is a prime number.If  \deg(P) < 2, raises an exception."If the greatest common divisor of B and P is~`1`, returns~`1` and sets A to the inverse of B+. Otherwise, returns~`0` and the value of A on exit is undefined.>Flint2_fmpz_mod_poly_invmod_f f A B lenB P lenP p If f returns with the value 1%, then the function operates as per _fmpz_mod_poly_invmod . Otherwise f# is set to a nontrivial factor of p.>Flint2_fmpz_mod_poly_invmod A B lenB P lenP p Attempts to set  (A, lenP-1) to the inverse of  (B, lenB) modulo the polynomial  (P, lenP) . Returns 1 if  (B, lenB) is invertible and 0 otherwise. Assumes that 10 < \operatorname{len}(B) < \operatorname{len}(P), and hence also \operatorname{len}(P) \geq 2 , but supports zero-padding in  (B, lenB).Does not support aliasing. Assumes that p is a prime number.>Flint2fmpz_mod_poly_gcdinv_f f G S A B ctx If f returns with value 1$ then the function operates as per fmpz_mod_poly_gcdinv , otherwise f( will be set to a nontrivial factor of p.>Flint2fmpz_mod_poly_gcdinv G S A B ctx Computes polynomials G and S&, both reduced modulo~`B`, such that G \cong S A \pmod{B}, where B is assumed to have \operatorname{len}(B) \geq 2.In the case that A = 0 \pmod{B} , returns  G = S = 0.>Flint2_fmpz_mod_poly_gcdinv_f f G S A lenA B lenB p If f returns with value 1$ then the function operates as per _fmpz_mod_poly_gcdinv , otherwise f( will be set to a nontrivial factor of p.>Flint2_fmpz_mod_poly_gcdinv G S A lenA B lenB p  Computes  (G, lenA),  (S, lenB-1) such that G \cong S A \pmod{B}", returning the actual length of G. Assumes that 10 < \operatorname{len}(A) < \operatorname{len}(B).>Flint2 fmpz_mod_poly_gcdinv_euclidean_f f G S A B ctx If f returns with value 1$ then the function operates as per fmpz_mod_poly_gcdinv_euclidean , otherwise f2 is set to a nontrivial factor of the modulus of A.>Flint2!_fmpz_mod_poly_gcdinv_euclidean_f f G S A lenA B lenB p If f returns with value 1$ then the function operates as per _fmpz_mod_poly_gcdinv_euclidean , otherwise f# is set to a nontrivial factor of p.>Flint2fmpz_mod_poly_gcdinv_euclidean G S A B ctx Computes polynomials G and S&, both reduced modulo~`B`, such that G \cong S A \pmod{B}, where B is assumed to have \operatorname{len}(B) \geq 2.In the case that A = 0 \pmod{B} , returns  G = S = 0.>Flint2_fmpz_mod_poly_gcdinv_euclidean G S A lenA B lenB p  Computes  (G, lenA),  (S, lenB-1) such that G \cong S A \pmod{B}", returning the actual length of G. Assumes that 10 < \operatorname{len}(A) < \operatorname{len}(B).>Flint2fmpz_mod_poly_xgcd_f f G S T A B ctx If f returns with the value 1$ then the function operates as per fmpz_mod_poly_xgcd , otherwise f# is set to a nontrivial factor of p.>Flint2fmpz_mod_poly_xgcd G S T A B ctx Computes the GCD of A and B. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic. Polynomials S and T are computed such that  S*A + T*B = G. The length of S will be at most lenB and the length of T will be at most lenA.>Flint2_fmpz_mod_poly_xgcd G S T A lenA B lenB invB p Computes the GCD of A and B together with cofactors S and T such that  S A + T B = G. Returns the length of G. Assumes that 7\operatorname{len}(A) \geq \operatorname{len}(B) \geq 1 and 8(\operatorname{len}(A),\operatorname{len}(B)) \neq (1,1).)No attempt is made to make the GCD monic.Requires that G have space for \operatorname{len}(B) coefficients. Writes \operatorname{len}(B)-1 and \operatorname{len}(A)-1 coefficients to S and T&, respectively. Note that, in fact, \operatorname{len}(S) \leq \max(\operatorname{len}(B) - \operatorname{len}(G), 1) and \operatorname{len}(T) \leq \max(\operatorname{len}(A) - \operatorname{len}(G), 1).6No aliasing of input and output operands is permitted.>Flint2fmpz_mod_poly_xgcd_euclidean_f f G S T A B ctx If f returns with the value 1$ then the function operates as per fmpz_mod_poly_xgcd_euclidean , otherwise f# is set to a nontrivial factor of p.>Flint2_fmpz_mod_poly_xgcd_euclidean_f f G S T A lenA B lenB invB p If f returns with the value 1$ then the function operates as per _fmpz_mod_poly_xgcd_euclidean , otherwise f# is set to a nontrivial factor of p.>Flint2_fmpz_mod_poly_hgcd M lenM A lenA B lenB a lena b lenb mod Computes the HGCD of a and b=, that is, a matrix~`M`, a sign~`sigma` and two polynomials A and B such that`  (A,B)^t = \sigma M^{-1} (a,b)^t. Assumes that 1\operatorname{len}(a) > \operatorname{len}(b) > 0. Assumes that A and B have space of size at least \operatorname{len}(a) and \operatorname{len}(b), respectively. On exit, *lenA and *lenB% will contain the correct lengths of A and B. Assumes that M[0], M[1], M[2], and M[3]* each point to a vector of size at least \operatorname{len}(a).>Flint2fmpz_mod_poly_gcd_f f G A B ctx  Either sets f = 1 and G# to the greatest common divisor of A and B, or  f \in (1,p) to a non-trivial factor of p.In general, the greatest common divisor is defined in the polynomial ring (\mathbf{Z}/(p \mathbf{Z}))[X] if and only if p is a prime number.>Flint2_fmpz_mod_poly_gcd_f f G A lenA B lenB p  Either sets f = 1 and G$ to the greatest common divisor of (A, \operatorname{len}(A)) and (B, \operatorname{len}(B))" and returns its length, or sets  f \in (1,p) to a non-trivial factor of p' and leaves the contents of the vector  (G, lenB) undefined. Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0 and that the vector G. has space for sufficiently many coefficients.Does not support aliasing of any of the input arguments with any of the output arguments.>Flint2fmpz_mod_poly_gcd_euclidean_f f G A B ctx  Either sets f = 1 and G# to the greatest common divisor of A and B, or  \in (1,p) to a non-trivial factor of p.In general, the greatest common divisor is defined in the polynomial ring (\mathbf{Z}/(p \mathbf{Z}))[X] if and only if p is a prime number.>Flint2_fmpz_mod_poly_gcd_euclidean_f f G A lenA B lenB p  Either sets f = 1 and G$ to the greatest common divisor of (A, \operatorname{len}(A)) and (B, \operatorname{len}(B))" and returns its length, or sets  f \in (1,p) to a non-trivial factor of p' and leaves the contents of the vector  (G, lenB) undefined. Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0 and that the vector G. has space for sufficiently many coefficients.Does not support aliasing of any of the input arguments with any of the output argument.>Flint2fmpz_mod_poly_gcd G A B ctx Sets G# to the greatest common divisor of A and B.In general, the greatest common divisor is defined in the polynomial ring (\mathbf{Z}/(p \mathbf{Z}))[X] if and only if p6 is a prime number. Thus, this function assumes that p is prime.>Flint2_fmpz_mod_poly_gcd G A lenA B lenB invB p Sets G$ to the greatest common divisor of (A, \operatorname{len}(A)) and (B, \operatorname{len}(B)) and returns its length. Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0 and that the vector G. has space for sufficiently many coefficients. Assumes that invB/ is the inverse of the leading coefficients of B modulo the prime number p.>Flint2fmpz_mod_poly_make_monic_f f res poly ctx  Either set f to 1 and res to poly, divided by its leading coefficient or set f to a nontrivial factor of p and leave res undefined.>Flint2fmpz_mod_poly_make_monic res poly ctx If poly is non-zero, sets res to poly divided by its leading coefficient. This assumes that the leading coefficient of poly is invertible modulo p.Otherwise, if poly is zero, sets res to zero.>Flint2fmpz_mod_poly_div_series Q A B n ctx Set Q to the quotient of the series A by B8, thinking of the series as though they were of length n,. We assume that the bottom coefficient of B is a unit.>Flint2_fmpz_mod_poly_div_series Q A Alen B Blen p n Set (Q, n) to the quotient of the series (A, Alen) and  (B, Blen) assuming Alen, Blen <= n&. We assume the bottom coefficient of B is invertible modulo p.>Flint2fmpz_mod_poly_inv_series_f f Qinv Q n ctx  Either sets f to a nontrivial factor of p with the value of Qinv undefined, or sets Qinv to the inverse of Q modulo x^n , where n \geq 1.>Flint2fmpz_mod_poly_inv_series Qinv Q n ctx Sets Qinv to the inverse of Q modulo x^n, where n \geq 1+, assuming that the bottom coefficient of Q is a unit.>Flint2_fmpz_mod_poly_inv_series Qinv Q n cinv p Sets  (Qinv, n) to the inverse of (Q, n) modulo x^n , where n \geq 1*, assuming that the bottom coefficient of Q is invertible modulo p and that its inverse is cinv.>Flint2fmpz_mod_poly_divides Q A B ctx Returns 1 if B divides A and sets Q% to the quotient. Otherwise returns 0 and sets Q to zero.>Flint2_fmpz_mod_poly_divides Q A lenA B lenB mod Returns 1 if  (B, lenB) divides  (A, lenA) and sets (Q, lenA - lenB + 1)% to the quotient. Otherwise, returns 0 and sets (Q, lenA - lenB + 1) to zero. We require that lenA >= lenB > 0.>Flint2fmpz_mod_poly_divides_classical Q A B ctx Returns 1 if B divides A and sets Q% to the quotient. Otherwise returns 0 and sets Q to zero.>Flint2 _fmpz_mod_poly_divides_classical Q A lenA B lenB mod Returns 1 if  (B, lenB) divides  (A, lenA) and sets (Q, lenA - lenB + 1)% to the quotient. Otherwise, returns 0 and sets (Q, lenA - lenB + 1) to zero. We require that lenA >= lenB > 0.>Flint2_fmpz_mod_poly_rem R A lenA B lenB invB p Notationally, computes (Q, lenA - lenB + 1),  (R, lenB - 1) such that  A = B Q + R and 40 \leq \operatorname{len}(R) < \operatorname{len}(B)%, returning only the remainder part. Assumes that B. is non-zero, that the leading coefficient of B is invertible modulo p and that invB is the inverse.Assumes 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA)7. No aliasing of input and output operands is allowed.>Flint2fmpz_mod_poly_divrem_f f Q R A B ctx Either finds a non-trivial factor~`f` of the modulus~`p`, or computes Q, R such that  A = B Q + R and 40 \leq \operatorname{len}(R) < \operatorname{len}(B).If the leading coefficient of B is invertible in \mathbf{Z}/(p)9, the division with remainder operation is carried out, Q and R are computed correctly, and f is set to 1 . Otherwise, f$ is set to a non-trivial factor of p and Q and R are not touched. Assumes that B is non-zero.>Flint2fmpz_mod_poly_divrem Q R A B ctx  Computes Q, R such that  A = B Q + R and 40 \leq \operatorname{len}(R) < \operatorname{len}(B). Assumes that B1 is non-zero and that the leading coefficient of B is invertible modulo p.>Flint2_fmpz_mod_poly_divrem Q R A lenA B lenB invB p  Computes (Q, lenA - lenB + 1),  (R, lenB - 1) such that  A = B Q + R and 40 \leq \operatorname{len}(R) < \operatorname{len}(B). Assumes that B. is non-zero, that the leading coefficient of B is invertible modulo p and that invB is the inverse.Assumes 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA)7. No aliasing of input and output operands is allowed.>Flint2fmpz_mod_poly_div Q A B ctx Notationally, computes Q, R such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B)$ assuming that the leading term of B is a unit.>Flint2_fmpz_mod_poly_div Q A lenA B lenB p Notationally, computes Q, R such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B) but only sets (Q, lenA - lenB + 1).(Assumes that the leading coefficient of B is a unit modulo p.>Flint2fmpz_mod_poly_rem_basecase R A B ctx Notationally, computes Q, R such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B)$ assuming that the leading term of B is a unit.>Flint2_fmpz_mod_poly_rem_basecase R A lenA B lenB invB p Notationally, computes Q, R such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B) but only sets  (R, lenB - 1).Allows aliasing only between A and R. Allows zero-padding in A but not in B*. Assumes that the leading coefficient of B is a unit modulo p.>Flint2fmpz_mod_poly_remove f g ctx &Removes the highest possible power of g from f and returns the exponent.>Flint2!fmpz_mod_poly_div_newton_n_preinv Q A B Binv ctx Notionally computes Q and R such that  A = BQ + R with -\operatorname{len}(R) < \operatorname{len}(B), but returns only Q.*We assume that the leading coefficient of B is a unit and that Binv" is the inverse of the reverse of B mod x^{\operatorname{len}(B)}."It is required that the length of A+ is less than or equal to 2*the length of B - 2.The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.>Flint2"_fmpz_mod_poly_div_newton_n_preinv Q A lenA B lenB Binv lenBinv mod  Notionally computes polynomials Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB, but return only Q.We require that Q have space for lenA - lenB + 1: coefficients and assume that the leading coefficient of B) is a unit. Furthermore, we assume that Binv" is the inverse of the reverse of B mod x^{\operatorname{len}(B)}.The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.>Flint2$fmpz_mod_poly_divrem_newton_n_preinv Q R A B Binv ctx  Computes Q and R such that  A = BQ + R with -\operatorname{len}(R) < \operatorname{len}(B) . We assume Binv# is the inverse of the reverse of B mod x^{\operatorname{len}(B)}."It is required that the length of A+ is less than or equal to 2*the length of B - 2.The algorithm used is to call  div_newton_n2 and then multiply out and compute the remainder.>Flint2%_fmpz_mod_poly_divrem_newton_n_preinv Q R A lenA B lenB Binv lenBinv mod  Computes Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB. We require that Q have space for lenA - lenB + 1+ coefficients. Furthermore, we assume that Binv# is the inverse of the reverse of B mod x^{\operatorname{len}(B)}!. The algorithm used is to call div_newton_n_preinv1 and then multiply out and compute the remainder.>Flint2fmpz_mod_poly_divrem_basecase Q R A B ctx  Computes Q, R such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B).(Assumes that the leading coefficient of B is invertible modulo p.>Flint2_fmpz_mod_poly_divrem_basecase Q R A lenA B lenB invB p  Computes (Q, lenA - lenB + 1),  (R, lenA) such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B).(Assumes that the leading coefficient of B is invertible modulo p , and that invB is the inverse. Assumes that 0\operatorname{len}(A), \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA). R and A may be aliased, but apart from this no aliasing of input and output operands is allowed.>Flint2$fmpz_mod_poly_frobenius_powers_clear pow ctx Clear resources used by the  fmpz_mod_poly_frobenius_powers_t struct.>Flint2&fmpz_mod_poly_frobenius_powers_precomp pow f finv m ctx If p = f->p , compute  x^{(p^0)},  x^{(p^1)},  x^{(p^2)},  x^{(p^3)}, ..., x^{(p^m)} \pmod{f}. Requires precomputed inverse of f, i.e. newton inverse.>Flint2fmpz_mod_poly_frobenius_power res pow f m ctx If p = f->p , compute x^{(p^m)} \pmod{f}.3Requires precomputed frobenius powers supplied by +fmpz_mod_poly_frobenius_powers_2exp_precomp.If m == 0 and f has degree 0 or 1, this performs a division. However an impossible inverse by the leading coefficient of f will have been caught by +fmpz_mod_poly_frobenius_powers_2exp_precomp.>Flint2)fmpz_mod_poly_frobenius_powers_2exp_clear pow ctx Clear resources used by the %fmpz_mod_poly_frobenius_powers_2exp_t struct.>Flint2+fmpz_mod_poly_frobenius_powers_2exp_precomp pow f finv m ctx If p = f->p , compute  x^{(p^1)},  x^{(p^2)},  x^{(p^4)}, ..., x^{(p^{(2^l)})} \pmod{f} where 2^l is the greatest power of 2 less than or equal to m.Allows construction of  x^{(p^k)} for k = 0, 1, ..., x^{(p^m)} \pmod{f} using fmpz_mod_poly_frobenius_power. Requires precomputed inverse of f, i.e. newton inverse.>Flint2fmpz_mod_poly_powers_mod_bsgs res f n g ctx Set the entries of the array res to f^0, f^1, ..., f^(n-1) mod g3. No aliasing is permitted between the entries of res and either of the inputs.>Flint2._fmpz_mod_poly_powers_mod_preinv_threaded_pool res f flen n g glen ginv ginvlen p threads  num_threads Compute f^0, f^1, ..., f^(n-1) mod g, where g has length glen and f is reduced mod g and has length flen" (possibly zero spaced). Assumes res is an array of n& arrays each with space for at least glen - 1 coefficients and that flen > 0. We require that ginv of length ginvlen7 is set to the power series inverse of the reverse of g.?Flint2fmpz_mod_poly_powers_mod_naive res f n g ctx Set the entries of the array res to f^0, f^1, ..., f^(n-1) mod g3. No aliasing is permitted between the entries of res and either of the inputs.?Flint2&_fmpz_mod_poly_powers_mod_preinv_naive res f flen n g glen ginv ginvlen p Compute f^0, f^1, ..., f^(n-1) mod g, where g has length glen and f is reduced mod g and has length flen" (possibly zero spaced). Assumes res is an array of n& arrays each with space for at least glen - 1 coefficients and that flen > 0. We require that ginv of length ginvlen7 is set to the power series inverse of the reverse of g.?Flint2"fmpz_mod_poly_powmod_x_fmpz_preinv res e f finv ctx Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e >= 0 . We require finv( to be the inverse of the reverse of ``?Flint2#_fmpz_mod_poly_powmod_x_fmpz_preinv res e f lenf finv lenfinv p Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 2 . The output res must have room for lenf - 1 coefficients.?Flint2'fmpz_mod_poly_powmod_fmpz_binexp_preinv res poly e f finv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.?Flint2(_fmpz_mod_poly_powmod_fmpz_binexp_preinv res poly e f lenf finv lenfinv p Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.?Flint2 fmpz_mod_poly_powmod_fmpz_binexp res poly e f ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.?Flint2!_fmpz_mod_poly_powmod_fmpz_binexp res poly e f lenf p Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.?Flint2%fmpz_mod_poly_powmod_ui_binexp_preinv res poly e f finv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.?Flint2&_fmpz_mod_poly_powmod_ui_binexp_preinv res poly e f lenf finv lenfinv p Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.?Flint2fmpz_mod_poly_powmod_ui_binexp res poly e f ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.?Flint2_fmpz_mod_poly_powmod_ui_binexp res poly e f lenf p Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.?Flint2fmpz_mod_poly_pow_trunc_binexp res poly e trunc ctx Sets res to the low trunc coefficients of poly to the power e. This is equivalent to doing a powering followed by a truncation. Uses the binary exponentiation method.?Flint2_fmpz_mod_poly_pow_trunc_binexp res poly e trunc p Sets res to the low trunc coefficients of poly4 (assumed to be zero padded if necessary to length trunc) to the power e. This is equivalent to doing a powering followed by a truncation. We require that res has enough space for trunc coefficients, that  trunc > 0 and that e > 1. Aliasing is not permitted. Uses the binary exponentiation method.?Flint2fmpz_mod_poly_pow_trunc res poly e trunc ctx Sets res to the low trunc coefficients of poly to the power e. This is equivalent to doing a powering followed by a truncation.?Flint2_fmpz_mod_poly_pow_trunc res poly e trunc p Sets res to the low trunc coefficients of poly4 (assumed to be zero padded if necessary to length trunc) to the power e. This is equivalent to doing a powering followed by a truncation. We require that res has enough space for trunc coefficients, that  trunc > 0 and that e > 1. Aliasing is not permitted.?Flint2fmpz_mod_poly_pow rop op e ctx  Computes  rop = poly^e. If e. is zero, returns one, so that in particular 0^0 = 1.?Flint2_fmpz_mod_poly_pow rop op len e p Sets  rop = poly^e, assuming that e > 1 and elen > 0 , and that res has space for e*(len - 1) + 1* coefficients. Does not support aliasing.?Flint2)fmpz_mod_poly_find_distinct_nonzero_roots roots A ctx If A has \deg(A) distinct nonzero roots in  \mathbb{F}_p, write these roots out to roots[0] to roots[deg(A) - 1] and return 1. Otherwise, return 0. It is assumed that A% is nonzero and that the modulus of A is prime. This function uses Rabin's probabilistic method via gcd's with  (x + \delta)^{\frac{p-1}{2}} - 1.?Flint2$fmpz_mod_poly_product_roots_fmpz_vec poly xs n f ctx Sets poly2 to the monic polynomial which is the product of '(x - x_0)(x - x_1) \cdots (x - x_{n-1}) , the roots x_i being given by xs.. It is required that the roots are canonical.?Flint2%_fmpz_mod_poly_product_roots_fmpz_vec poly xs n f Sets  (poly, n + 1)2 to the monic polynomial which is the product of '(x - x_0)(x - x_1) \cdots (x - x_{n-1}) , the roots x_i being given by xs.. It is required that the roots are canonical.0Aliasing of the input and output is not allowed.?Flint2fmpz_mod_poly_mulmod_preinv res poly1 poly2 f finv ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f. finv" is the inverse of the reverse of f. It is required that poly1 and poly2 are reduced modulo f.?Flint2_fmpz_mod_poly_mulmod_preinv res poly1 len1 poly2 len2 f lenf finv lenfinv p Sets res, len1 + len2 - 1$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.It is required that finv" is the inverse of the reverse of f mod x^lenf. It is required that len1 + len2 - lenf > 0, which is equivalent to requiring that the result will actually be reduced. It is required that  len1 < lenf and  len2 < lenf. Otherwise, simply use _fmpz_mod_poly_mul instead. Aliasing of f or finv and res is not permitted.?Flint2fmpz_mod_poly_mulmod res poly1 poly2 f ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.?Flint2_fmpz_mod_poly_mulmod res poly1 len1 poly2 len2 f lenf p Sets res, len1 + len2 - 1$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.It is required that len1 + len2 - lenf > 0, which is equivalent to requiring that the result will actually be reduced. Otherwise, simply use _fmpz_mod_poly_mul instead. Aliasing of f and res is not permitted.?Flint2fmpz_mod_poly_mulhigh res poly1 poly2 start ctx Computes the product of poly1 and poly2# and writes the coefficients from start' onwards into the high coefficients of res., the remaining coefficients being arbitrary.?Flint2fmpz_mod_poly_sqr res poly ctx  Computes res as the square of poly.?Flint2_fmpz_mod_poly_sqr res poly len p Sets res to the square of poly.?Flint2fmpz_mod_poly_mullow res poly1 poly2 n ctx Sets res to the lowest n coefficients of the product of poly1 and poly2.?Flint2_fmpz_mod_poly_mullow res poly1 len1 poly2 len2 p n Sets (res, n) to the lowest n! coefficients of the product of  (poly1, len1) and  (poly2, len2).Assumes len1 >= len2 > 0 and 0 < n <= len1 + len2 - 1. Allows for zero-padding in the inputs. Does not support aliasing between the inputs and the output.?Flint2fmpz_mod_poly_mul res poly1 poly2 ctx Sets res to the product of poly1 and poly2.?Flint2_fmpz_mod_poly_mul res poly1 len1 poly2 len2 p Sets (res, len1 + len2 - 1) to the product of  (poly1, len1) and  (poly2, len2) . Assumes len1 >= len2 > 04. Allows zero-padding of the two input polynomials.?Flint2fmpz_mod_poly_scalar_div_fmpz res poly x ctx Sets res to poly divided by x&, (i.e. multiplied by the inverse of  x \pmod{p} ). The result is reduced modulo p.?Flint2_fmpz_mod_poly_scalar_div_fmpz res poly len x p Sets  (res, len) to  (poly, len) divided by x% (i.e. multiplied by the inverse of  x \pmod{p} ). The result is reduced modulo p.?Flint2 fmpz_mod_poly_scalar_addmul_fmpz rop op x ctx Adds to rop the product of op by the scalar x.?Flint2fmpz_mod_poly_scalar_mul_fmpz res poly x ctx Sets res to poly multiplied by x.?Flint2_fmpz_mod_poly_scalar_mul_fmpz res poly len x p Sets  (res, len) to  (poly, len) multiplied by x, reduced modulo p.?Flint2fmpz_mod_poly_neg res poly ctx Sets res to the negative of poly modulo p.?Flint2_fmpz_mod_poly_neg res poly len p Sets  (res, len) to the negative of  (poly, len) modulo p.?Flint2fmpz_mod_poly_sub_series res poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n and set res to the difference.?Flint2fmpz_mod_poly_sub res poly1 poly2 ctx Sets res to poly1 minus poly2.?Flint2_fmpz_mod_poly_sub res poly1 len1 poly2 len2 p Sets res to  (poly1, len1) minus  (poly2, len2). It is assumed that res< has sufficient space for the longer of the two polynomials.?Flint2fmpz_mod_poly_add_series res poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n and set res to the sum.?Flint2fmpz_mod_poly_add res poly1 poly2 ctx Sets res to the sum of poly1 and poly2.?Flint2_fmpz_mod_poly_add res poly1 len1 poly2 len2 p Sets res to the sum of  (poly1, len1) and  (poly2, len2). It is assumed that res= has sufficient space for the longer of the two polynomials.?Flint2fmpz_mod_poly_shift_right f g n ctx Sets res to poly shifted right by n coefficients. If n4 is equal to or greater than the current length of poly, res is set to the zero polynomial.?Flint2_fmpz_mod_poly_shift_right res poly len n ctx Sets (res, len - n) to  (poly, len) shifted right by n coefficients. Assumes that len and n are positive, that len > n , and that res fits len - n% elements. Supports aliasing between res and poly0, although in this case the top coefficients of poly are not set to zero.?Flint2fmpz_mod_poly_shift_left f g n ctx Sets res to poly shifted left by n) coeffs. Zero coefficients are inserted.?Flint2_fmpz_mod_poly_shift_left res poly len n ctx Sets (res, len + n) to  (poly, len) shifted left by n coefficients.9Inserts zero coefficients at the lower end. Assumes that len and n are positive, and that res fits len + n& elements. Supports aliasing between res and poly.?Flint2fmpz_mod_poly_get_coeff_fmpz x poly n ctx Sets x to the coefficient of X^n in the polynomial, assuming n \geq 0.?Flint2fmpz_mod_poly_set_coeff_ui poly n x ctx Sets the coefficient of X^n in the polynomial to x , assuming n \geq 0.?Flint2fmpz_mod_poly_set_coeff_fmpz poly n x ctx Sets the coefficient of X^n in the polynomial to x , assuming n \geq 0.?Flint2fmpz_mod_poly_is_gen poly ctx 1Returns non-zero if the polynomial is the degree 1 polynomial x.?Flint2fmpz_mod_poly_is_one poly ctx 3Returns non-zero if the polynomial is the constant 1.?Flint2fmpz_mod_poly_is_zero poly ctx +Returns non-zero if the polynomial is zero.?Flint2fmpz_mod_poly_equal_trunc poly1 poly2 n ctx 3Notionally truncates the two polynomials to length n and returns non-zero if the two polynomials are equal, otherwise returns zero.?Flint2fmpz_mod_poly_equal poly1 poly2 ctx Returns non-zero if the two polynomials are equal, otherwise returns zero.?Flint2fmpz_mod_poly_set_nmod_poly f g Sets f to g assuming the modulus of both polynomials is the same (no checking is performed).?Flint2fmpz_mod_poly_get_nmod_poly f g Sets f to g assuming the modulus of both polynomials is the same (no checking is performed).?Flint2fmpz_mod_poly_get_fmpz_poly f g ctx Sets f to g6. This is done simply by lifting the coefficients of g taking representatives [0, p) \subset \mathbf{Z}.?Flint2fmpz_mod_poly_set_fmpz_poly f g ctx Sets f to g reduced modulo p, where p7 is the modulus that is part of the data structure of f.?Flint2fmpz_mod_poly_set_fmpz f c ctx Sets the polynomial f to the constant c reduced modulo p.?Flint2fmpz_mod_poly_set_ui f c ctx Sets the polynomial f to the constant c reduced modulo p.?Flint2fmpz_mod_poly_reverse res poly n ctx 'This function considers the polynomial poly to be of length n, notionally truncating and zero padding if required, and reverses the result. Since the function normalises its result res may be of length less than n.?Flint2fmpz_mod_poly_zero_coeffs poly i j ctx Sets the coefficients of X^k for  k \in [i, j) in the polynomial to zero.?Flint2fmpz_mod_poly_one poly ctx Sets poly to the constant polynomial 1.?Flint2fmpz_mod_poly_zero poly ctx Sets poly to the zero polynomial.?Flint2fmpz_mod_poly_swap poly1 poly2 ctx Swaps the two polynomials. This is done efficiently by swapping pointers rather than individual coefficients.?Flint2fmpz_mod_poly_set poly1 poly2 ctx Sets the polynomial poly1 to the value of poly2.?Flint2fmpz_mod_poly_lead poly ctx 6Returns a pointer to the first leading coefficient of poly) if this is non-zero, otherwise returns NULL.?Flint2fmpz_mod_poly_length poly ctx Returns the length of the polynomial, which is one more than its degree.?Flint2fmpz_mod_poly_degree poly ctx Returns the degree of the polynomial. The degree of the zero polynomial is defined to be -1.?Flint2)fmpz_mod_poly_randtest_sparse_irreducible poly state len ctx Attempts to set poly8 to a sparse, monic irreducible polynomial with length len. It attempts to find an irreducible trinomial. If that does not succeed, it attempts to find a irreducible pentomial. If that fails, then poly6 is just set to a random monic irreducible polynomial.?Flint2,fmpz_mod_poly_randtest_pentomial_irreducible poly state len  max_attempts ctx Attempts to set poly, to a monic irreducible pentomial of length len. It will generate up to  max_attempts7 pentomials in attempt to find an irreducible one. If  max_attempts is 0, then it will keep generating pentomials until an irreducible one is found. Returns 1 if one is found and 0 otherwise.?Flint2 fmpz_mod_poly_randtest_pentomial poly state len ctx -Generates a random monic pentomial of length len.?Flint2,fmpz_mod_poly_randtest_trinomial_irreducible poly state len  max_attempts ctx Attempts to set poly, to a monic irreducible trinomial of length len. It will generate up to  max_attempts7 trinomials in attempt to find an irreducible one. If  max_attempts is 0, then it will keep generating trinomials until an irreducible one is found. Returns 1 if one is found and 0 otherwise.?Flint2 fmpz_mod_poly_randtest_trinomial poly state len ctx -Generates a random monic trinomial of length len.?Flint2&fmpz_mod_poly_randtest_monic_primitive poly state len ctx Generates a random monic irreducible primitive polynomial with length len.?Flint2(fmpz_mod_poly_randtest_monic_irreducible poly state len ctx >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>???????????????????????????????????????????????????????????????????????????????????????????????????r Safe-Inferred )*1Z==============>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>???????????????????????????????????????????????????????????????????????????????????????????????????====???????????????????????????????????????????????????????????????????????????????????????????????>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>===??>>>>>>>>??>>>>>>>======= Safe-Inferred )*1u:?Flint2nf_elem_coprime_den_signed res a mod nf Return an element z such that the denominator of z - a is coprime to code{mod}.Reduction takes place with respect to the symmetric residue system.?Flint2nf_elem_coprime_den res a mod nf Return an element z such that the denominator of z - a is coprime to code{mod}.Reduction takes place with respect to the positive residue system.?Flint2nf_elem_smod_fmpz res a mod nf Return an element z such that z - a has denominator 1 and the coefficients of z - a2 are divisible by code{mod}. The coefficients of z) are reduced modulo code{mod * d}, where d is the denominator of b.Reduction takes place with respect to the symmetric residue system.?Flint2nf_elem_mod_fmpz res a mod nf Return an element z such that z - a has denominator 1 and the coefficients of z - a2 are divisible by code{mod}. The coefficients of z) are reduced modulo code{mod * d}, where d is the denominator of b.Reduction takes place with respect to the positive residue system.?Flint2nf_elem_smod_fmpz_den z a mod nf %If code{den == 0}, return an element z with denominator 1!, such that the coefficients of z - da# are divisble by code{mod}, where d is the denominator of a. The coefficients of z are reduced modulo code{mod}.%If code{den == 1}, return an element z , such that z - a has denominator 1 and the coefficients of z - a1 are divisble by code{mod}. The coefficients of z* are reduced modulo code{mod * d}, where d is the denominator of a.Reduction takes place with respect to the symmetric residue system.?Flint2nf_elem_mod_fmpz_den z a mod nf %If code{den == 0}, return an element z with denominator 1!, such that the coefficients of z - da# are divisble by code{mod}, where d is the denominator of a. The coefficients of z are reduced modulo code{mod}.%If code{den == 1}, return an element z , such that z - a has denominator 1 and the coefficients of z - a1 are divisble by code{mod}. The coefficients of z* are reduced modulo code{mod * d}, where d is the denominator of a.Reduction takes place with respect to the positive residue system.?Flint2nf_elem_rep_mat_fmpz_mat_den res den a nf Return a tuple M, d such that M/d5 is the matrix representing the multiplication with a with respect to the basis 1, a, \dotsc, a^{d - 1}, where a* is the generator of the number field of d$ is its degree. The integral matrix M is primitive.?Flint2nf_elem_rep_mat res a nf Set code{res} to the matrix representing the multiplication with a with respect to the basis 1, a, \dotsc, a^{d - 1}, where a* is the generator of the number field of d is its degree.?Flint2 nf_elem_trace res a nf Set code{res} to the absolute trace of the given number field element a.?Flint2_nf_elem_trace rnum rden a nf Set code{{rnum, rden}} to the absolute trace of the given number field element a.?Flint2_nf_elem_norm_div rnum rden a nf divisor nbits Set code{{rnum, rden}} to the absolute norm of the given number field element a, divided by code{div} . Assumes the result to be an integer and having at most code{nbits} bits.?Flint2nf_elem_norm_div res a nf div nbits Set code{res} to the absolute norm of the given number field element a, divided by code{div} . Assumes the result to be an integer and having at most code{nbits} bits.?Flint2 nf_elem_norm res a nf Set code{res} to the absolute norm of the given number field element a.?Flint2 _nf_elem_norm rnum rden a nf Set code{{rnum, rden}} to the absolute norm of the given number field element a.?Flint2 nf_elem_pow res a e nf Set code{res} = code{a^e} using the binary exponentiation algorithm. If e; is zero, returns one, so that in particular code{0^0 = 1}.?Flint2 _nf_elem_pow res a e nf Set code{res} to a^e using left-to-right binary exponentiation as described in~citep[p.~461]{Knu1997}. Assumes that a \neq 0 and e > 1. Does not support aliasing.?Flint2 nf_elem_div a b c nf Set a to b/c in the given number field.?Flint2 _nf_elem_div a b c nf Set a to b/c( in the given number field. Aliasing of a and b is not permitted.?Flint2 nf_elem_inv r a nf 7Invert an element of a number field code{nf}, i.e. set  r = a^{-1}.?Flint2 _nf_elem_inv r a nf 7Invert an element of a number field code{nf}, i.e. set  r = a^{-1}:. Aliasing of the input with the output is not supported.?Flint2nf_elem_mul_red a b c nf red As per code{nf_elem_mul}, but reduction modulo the defining polynomial of the number field is only carried out if code{red == 1}. Assumes both inputs are reduced.?Flint2 nf_elem_mul a b c nf  0.@Flint2nf_elem_get_fmpz_mod_poly pol a nf Set code{pol} to the reduction of the polynomial corresponding to the numerator of a. The result is multiplied by the inverse of the denominator of a:. It is assumed that the reduction of the denominator of a is invertible.@Flint2nf_elem_get_fmpz_mod_poly_den pol a nf den Set code{pol} to the reduction of the polynomial corresponding to the numerator of a. If code{den == 1}, the result is multiplied by the inverse of the denominator of a. In this case it is assumed that the reduction of the denominator of a is invertible.@Flint2nf_elem_get_nmod_poly pol a nf Set code{pol} to the reduction of the polynomial corresponding to the numerator of a. The result is multiplied by the inverse of the denominator of a:. It is assumed that the reduction of the denominator of a is invertible.@Flint2nf_elem_get_nmod_poly_den pol a nf den Set code{pol} to the reduction of the polynomial corresponding to the numerator of a. If code{den == 1}, the result is multiplied by the inverse of the denominator of a. In this case it is assumed that the reduction of the denominator of a is invertible.@Flint2nf_elem_get_fmpq_poly pol a nf /Set code{pol} to a polynomial corresponding to a6, reduced modulo the defining polynomial of code{nf}.@Flint2nf_elem_set_fmpq_poly a pol nf Set a: to the element corresponding to the polynomial code{pol}.@Flint2nf_elem_get_fmpz_mat_row M i den b nf  Set the row i of the matrix M6 to the coefficients of the numerator of the element b and d to the denominator of b . Column 0 of the matrix corresponds to the constant coefficient of the number field element.@Flint2nf_elem_set_fmpz_mat_row b M i den nf Set b! to the element specified by row i of the matrix M! and with the given denominator d . Column 0 of the matrix corresponds to the constant coefficient of the number field element.@Flint2_nf_elem_invertible_check a nf Whilst the defining polynomial for a number field should by definition be irreducible, it is not enforced. Thus in test code, it is convenient to be able to check that a given number field element is invertible modulo the defining polynomial of the number field. This function does precisely this.If a is invertible modulo the defining polynomial of code{nf} the value 1 is returned, otherwise 0 is returned.6The function is only intended to be used in test code.@Flint2nf_elem_reduce a nf Reduce a number field element modulo the defining polynomial. This is used with functions such as code{nf_elem_mul_red} which allow reduction to be delayed.@Flint2_nf_elem_reduce a nf Reduce a number field element modulo the defining polynomial. This is used with functions such as code{nf_elem_mul_red} which allow reduction to be delayed. Does not canonicalise.@Flint2nf_elem_canonicalise a nf Canonicalise a number field element, i.e. reduce numerator and denominator to lowest terms. If the numerator is 0, set the denominator to 1.@Flint2nf_elem_randtest a state bits nf 'Generate a random number field element a in the number field code{nf} whose coefficients have up to the given number of bits.@Flint2 nf_elem_clear a nf Clear resources allocated by the given number field element in the given number field.@Flint2 nf_elem_init a nf Initialise a number field element to belong to the given number field code{nf}. The element is set to zero.@Flint2Use number-field element.@Flint2nf_elem_print_pretty a nf var Print the given number field element to code{stdout} using the null-terminated string code{var} not equal to code{"0"} as the name of the primitive element. foreign import ccall "nf_elem.h nf_elem_print_pretty"?????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@s Safe-Inferred )*1:?????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@???@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@?????????????????????????? Safe-Inferred )*1^@Flint2,Context of the finite field (opaque pointer)@Flint2 fq_bit_unpack rop f bit_size ctx  Unpacks into rop; the element with coefficients packed into fields of size bit_size as represented by the integer f.@Flint2 fq_bit_pack f op bit_size ctx Packs op into bitfields of size bit_size, writing the result to f.@Flint2fq_is_primitive op ctx Returns whether op is primitive, i.e., whether it is a generator of the multiplicative group of ctx.@Flint2fq_multiplicative_order ord op ctx Computes the order of op/ as an element of the multiplicative group of ctx. Returns 0 if op! is 0, otherwise it returns 1 if op is a generator of the multiplicative group, and -1 if it is not.This function can also be used to check primitivity of a generator of a finite field whose defining polynomial is not primitive.@Flint2 fq_frobenius rop op e ctx Evaluates the homomorphism \Sigma^e at op. Recall that \mathbf{F}_q / \mathbf{F}_p is Galois with Galois group \langle \sigma \rangle, which is also isomorphic to \mathbf{Z}/d\mathbf{Z} , where 8\sigma \in \operatorname{Gal}(\mathbf{F}_q/\mathbf{F}_p) is the Frobenius element \sigma \colon x \mapsto x^p.@Flint2 _fq_frobenius rop op len e ctx Sets  (rop, 2d-1) to the image of  (op, len) under the Frobenius operator raised to the e-th power, assuming that neither op nor e are zero.@Flint2fq_norm rop op ctx Computes the norm of op.For an element a \in \mathbf{F}_q, multiplication by a defines a  \mathbf{F}_p-linear map on  \mathbf{F}_q. We define the norm of a2 as the determinant of this map. Equivalently, if \Sigma generates /\operatorname{Gal}(\mathbf{F}_q / \mathbf{F}_p) then the trace of a is equal to \prod_{i=0}^{d-1} \Sigma^i (a) , where +d = \text{dim}_{\mathbf{F}_p}(\mathbf{F}_q).8Algorithm selection is automatic depending on the input.@Flint2_fq_norm rop op len ctx Sets rop% to the norm of the non-zero element  (op, len) in \mathbf{F}_{q}.@Flint2fq_trace rop op ctx Sets rop to the trace of op.For an element a \in \mathbf{F}_q, multiplication by a defines a  \mathbf{F}_p-linear map on  \mathbf{F}_q. We define the trace of a, as the trace of this map. Equivalently, if \Sigma generates /\operatorname{Gal}(\mathbf{F}_q / \mathbf{F}_p) then the trace of a is equal to \sum_{i=0}^{d-1} \Sigma^i (a), where (d = log_{p} q).@Flint2 _fq_trace rop op len ctx Sets rop& to the trace of the non-zero element  (op, len) in \mathbf{F}_{q}.@Flint2fq_is_invertible_f f op ctx Returns whether op. is an invertible element. If it is not, then f$ is set of a factor of the modulus.@Flint2fq_is_invertible op ctx Returns whether op is an invertible element.@Flint2fq_equal op1 op2 ctx Returns whether op1 and op2 are equal.@Flint2 fq_is_one op ctx Returns whether op is equal to one.@Flint2 fq_is_zero op ctx Returns whether op is equal to zero.@Flint2fq_set_fmpz_mod_mat a col ctx Convert a column vector col of length  degree(ctx) to an element of ctx.@Flint2fq_get_fmpz_mod_mat col a ctx Convert a to a column vector of length  degree(ctx).@Flint2fq_set_fmpz_mod_poly a b ctx Set a to the element in ctx with representative b$. The representatives are taken in  (\mathbb{Z}/p\mathbb{Z})[x]/h(x) where h(x) is the defining polynomial in ctx.@Flint2fq_get_fmpz_mod_poly a b ctx Set a to a representative of b in ctx$. The representatives are taken in  (\mathbb{Z}/p\mathbb{Z})[x]/h(x) where h(x) is the defining polynomial in ctx.@Flint2 fq_get_fmpz rop op ctx If op$ has a lift to the integers, return 1 and set rop to the lift in [0,p). Otherwise, return 0 and leave rop undefined.@Flint2fq_gen rop ctx Sets rop to a generator for the finite field. There is no guarantee this is a multiplicative generator of the finite field.@Flint2fq_one rop ctx Sets rop& to one, reduced in the given context.@Flint2fq_zero rop ctx Sets rop to zero.@Flint2fq_swap op1 op2 ctx Swaps the two elements op1 and op2.@Flint2 fq_set_fmpz rop x ctx Sets rop to x, considered as an element of  \mathbf{F}_p.@Flint2 fq_set_ui rop x ctx Sets rop to x, considered as an element of  \mathbf{F}_p.@Flint2 fq_set_si rop x ctx Sets rop to x, considered as an element of  \mathbf{F}_p.@Flint2fq_set rop op ctx Sets rop to op.@Flint2fq_rand_not_zero rop state ctx 4Generates a high quality non-zero random element of  \mathbf{F}_q.@Flint2fq_rand rop state ctx +Generates a high quality random element of  \mathbf{F}_q.@Flint2fq_randtest_dense rop state ctx Generates a random element of  \mathbf{F}_q= which has an underlying polynomial with dense coefficients.@Flint2fq_randtest_not_zero rop state ctx 'Generates a random non-zero element of  \mathbf{F}_q.@Flint2 fq_randtest rop state ctx Generates a random element of  \mathbf{F}_q.@Flint2fq_get_str_pretty op ctx /Returns a pretty representation of the element op# using the null-terminated string x as the variable name.@Flint2 fq_get_str op ctx =Returns the plain FLINT string representation of the element op.@Flint2 fq_fprint file op ctx Prints a representation of op to file.5For further details on the representation used, see fmpz_mod_poly_fprint.@Flint2fq_fprint_pretty file op ctx "Prints a pretty representation of op to file..In the current implementation, always returns 1. The return code is part of the function's signature to allow for a later implementation to return the number of characters printed or a non-positive error code.@Flint2 fq_is_square op ctx Return 1 if op is a square.@Flint2 fq_pth_root rop op1 ctx Sets rop to a p^{th} root root of op10. Currently, this computes the root by raising op1 to p^{d-1} where d! is the degree of the extension.@Flint2fq_sqrt rop op1 ctx Sets rop to the square root of op1 if it is a square, and return 1, otherwise return 0.@Flint2 fq_pow_ui rop op e ctx Sets rop the op raised to the power e.Currently assumes that e \geq 0.Note that for any input op, rop is set to 1 whenever e = 0.@Flint2fq_pow rop op e ctx Sets rop the op raised to the power e.Currently assumes that e \geq 0.Note that for any input op, rop is set to 1 whenever e = 0.@Flint2_fq_pow rop op len e ctx Sets  (rop, 2*d-1) to (op,len) raised to the power e, reduced modulo f(X), the modulus of ctx. Assumes that e \geq 0 and that len is positive and at most d.Although we require that rop provides space for 2d - 12 coefficients, the output will be reduced modulo f(X)#, which is a polynomial of degree d.Does not support aliasing.@Flint2 fq_gcdinv f inv op ctx Sets inv to be the inverse of op modulo the modulus of ctx. If op is not invertible, then f is set to a factor of the modulus; otherwise, it is set to one.@Flint2fq_inv rop op ctx Sets rop( to the inverse of the non-zero element op.@Flint2_fq_inv rop op len ctx Sets (rop, d)( to the inverse of the non-zero element  (op, len).@Flint2fq_div rop op1 op2 ctx Sets rop to the quotient of op1 and op2,, reducing the output in the given context.@Flint2fq_sqr rop op ctx Sets rop to the square of op,, reducing the output in the given context.@Flint2 fq_mul_ui rop op x ctx Sets rop to the product of op and x,, reducing the output in the given context.@Flint2 fq_mul_si rop op x ctx Sets rop to the product of op and x,, reducing the output in the given context.@Flint2 fq_mul_fmpz rop op x ctx Sets rop to the product of op and x,, reducing the output in the given context.@Flint2fq_mul rop op1 op2 ctx Sets rop to the product of op1 and op2,, reducing the output in the given context.@Flint2fq_neg rop op ctx Sets rop to the negative of op.@Flint2 fq_sub_one rop op1 ctx Sets rop to the difference of op1 and 1.@Flint2fq_sub rop op1 op2 ctx Sets rop to the difference of op1 and op2.@Flint2fq_add rop op1 op2 ctx Sets rop to the sum of op1 and op2.@Flint2 fq_reduce rop ctx Reduces the polynomial rop as an element of \mathbf{F}_p[X] / (f(X)).@Flint2 _fq_reduce r lenR ctx Reduces  (R, lenR) modulo the polynomial f given by the modulus of ctx2. Does either sparse or dense reduction based on ctx->sparse_modulus.@Flint2_fq_dense_reduce R lenR ctx Reduces  (R, lenR) modulo the polynomial f given by the modulus of ctx using Newton division.@Flint2_fq_sparse_reduce R lenR ctx Reduces  (R, lenR) modulo the polynomial f given by the modulus of ctx.@Flint2fq_clear rop ctx Clears the element rop.@Flint2fq_init2 rop ctx  Initialises poly8 with at least enough space for it to be an element of ctx and sets it to 0.@Flint2fq_init rop ctx Initialises the element rop, setting its value to 0.@Flint2fq_ctx_randtest_reducible ctx  Initializes ctx to a random extension of a prime field. The modulus may or may not be irreducible. Assumes that  fq_ctx_init has not been called on ctx already.@Flint2fq_ctx_randtest ctx  Initializes ctx( to a random finite field. Assumes that  fq_ctx_init has not been called on ctx already.@Flint2 fq_ctx_fprint file ctx "Prints the context information to file>. Returns 1 for a success and a negative number for an error.@Flint2 fq_ctx_order f ctx Sets f$ to be the size of the finite field.@Flint2 fq_ctx_prime ctx Returns a pointer to the prime p in the context.@Flint2 fq_ctx_degree ctx +Returns the degree of the field extension ![\mathbf{F}_{q} : \mathbf{F}_{p}], which is equal to  \log_{p} q.@Flint2fq_ctx_modulus ctx 0Returns a pointer to the modulus in the context.@Flint2 fq_ctx_clear ctx Clears all memory that has been allocated as part of the context.@Flint2fq_ctx_init_modulus ctx modulus ctxp var "Initialises the context for given modulus with name var for the generator. Assumes that modulus5 is an irreducible polynomial over the finite field \mathbf{F}_{p} in ctxp.Assumes that the string var5 is a null-terminated string of length at least one.@Flint2fq_ctx_init_conway ctx p d var "Initialises the context for prime p and extension degree d , with name var= for the generator using a Conway polynomial for the modulus. Assumes that p is a prime.Assumes that the string var5 is a null-terminated string of length at least one.@Flint2_fq_ctx_init_conway ctx p d var -Attempts to initialise the context for prime p and extension degree d , with name var> for the generator using a Conway polynomial for the modulus.Returns 1 if the Conway polynomial is in the database for the given size and the initialization is successful; otherwise, returns 0. Assumes that p is a prime.Assumes that the string var5 is a null-terminated string of length at least one.@Flint2 fq_ctx_init ctx p d var "Initialises the context for prime p and extension degree d , with name var for the generator. By default, it will try use a Conway polynomial; if one is not available, a random irreducible polynomial will be used. Assumes that p is a prime.Assumes that the string var5 is a null-terminated string of length at least one.@Flint2 Create a new  with context ctx.@Flint2Use .@Flint2 Use a new .@Flint2 Create a new  context using @.@Flint2Use the @.@Flint2Apply function to new @. parameters as in @.@Flint2 Create a new  context using @.@Flint2Apply function to new  initialized with @.@Flint2 Create a new  context using @.@Flint2 Create a new  initialized using @.@Flint2 fq_ctx_print ctx "Prints the context information to stdout.@Flint2fq_print_pretty op ctx "Prints a pretty representation of op to stdout..In the current implementation, always returns 1. The return code is part of the function's signature to allow for a later implementation to return the number of characters printed or a non-positive error code.AFlint2fq_print op ctx Prints a representation of op to stdout.5For further details on the representation used, see fmpz_mod_poly_print.@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@At Safe-Inferred )*1e@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@A@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@A@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ Safe-Inferred )*1AFlint2 _fq_vec_dot res vec1 vec2 len2 ctx Sets res to the dot product of (vec1, len) and (vec2, len).AFlint2_fq_vec_scalar_submul_fq vec1 vec2 len2 c ctx  Subtracts  (vec2, len2) times c from  (vec1, len2), where c is a fq_t.AFlint2_fq_vec_scalar_addmul_fq vec1 vec2 len2 c ctx Adds  (vec2, len2) times c to  (vec1, len2), where c is a fq_t.AFlint2 _fq_vec_sub res vec1 vec2 len2 ctx Sets  (res, len2) to  (vec1, len2) minus  (vec2, len2).AFlint2 _fq_vec_add res vec1 vec2 len2 ctx Sets  (res, len2) to the sum of  (vec1, len2) and  (vec2, len2).AFlint2_fq_vec_is_zero vec len ctx Returns 1 if  (vec, len) is zero, and 0 otherwise.AFlint2 _fq_vec_equal vec1 vec2 len ctx 5Compares two vectors of the given length and returns 1' if they are equal, otherwise returns 0.AFlint2 _fq_vec_neg vec1 vec2 len2 ctx Negates  (vec2, len2) and places it into vec1.AFlint2 _fq_vec_zero vec len ctx Zeros the entries of  (vec, len).AFlint2 _fq_vec_swap vec1 vec2 len2 ctx Swaps the elements in  (vec1, len2) and  (vec2, len2).AFlint2 _fq_vec_set vec1 vec2 len2 ctx Makes a copy of  (vec2, len2) into vec1.AFlint2 _fq_vec_print vec len ctx %Prints the vector of given length to stdout.For further details, see _fq_vec_fprint().AFlint2_fq_vec_fprint file vec len ctx 0Prints the vector of given length to the stream file. The format is the length followed by two spaces, then a space separated list of coefficients. If the length is zero, only 0 is printed.In case of success, returns a positive value. In case of failure, returns a non-positive value.AFlint2_fq_vec_randtest f state len ctx Sets the entries of a vector of the given length to elements of the finite field.AFlint2 _fq_vec_clear vec len ctx Clears the entries of  (vec, len)$ and frees the space allocated for vec.AFlint2 _fq_vec_init len ctx !Returns an initialised vector of fq's of given length.AAAAAAAAAAAAAAAAu Safe-Inferred )*1tAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Safe-Inferred )*1,AFlint2fq_nmod_mat_minpoly p M ctx Compute the minimal polynomial p of the matrix M. The matrix is required to be square, otherwise an exception is raised.AFlint2fq_nmod_mat_charpoly p M ctx &Compute the characteristic polynomial p of the matrix M. The matrix is required to be square, otherwise an exception is raised.AFlint2fq_nmod_mat_charpoly_danilevsky p M ctx &Compute the characteristic polynomial p of the matrix M&. The matrix is assumed to be square.AFlint2fq_nmod_mat_similarity M r d ctx &Applies a similarity transform to the  n\times n matrix M in-place.If P is the  n\times n0 identity matrix the zero entries of whose row r# (0-indexed) have been replaced by d#, this transform is equivalent to  M = P^{-1}MP.Similarity transforms preserve the determinant, characteristic polynomial and minimal polynomial. The value d is required to be reduced modulo the modulus of the entries in the matrix.AFlint2fq_nmod_mat_can_solve X A B ctx "Solves the matrix-matrix equation AX = B over Fq.Returns 1) if a solution exists; otherwise returns 0 and sets the elements of X to zero. If more than one solution exists, one of the valid solutions is given.*There are no restrictions on the shape of A and it may be singular.AFlint2fq_nmod_mat_solve X A B ctx "Solves the matrix-matrix equation AX = B.Returns 1 if A" has full rank; otherwise returns 0 and sets the elements of X to undefined values. The matrix A must be square.AFlint2 fq_nmod_mat_solve_triu_recursive X U B unit ctx Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses the block inversion formula\begin{aligned} ` \begin{pmatrix} A & B \\ 0 & D \end{pmatrix}^{-1} \begin{pmatrix} X \\ Y \end{pmatrix} = \begin{pmatrix} A^{-1} (X - B D^{-1} Y) \\ D^{-1} Y \end{pmatrix} \end{aligned}to reduce the problem to matrix multiplication and triangular solving of smaller systems.AFlint2 fq_nmod_mat_solve_triu_classical X U B unit ctx Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses forward substitution.AFlint2fq_nmod_mat_solve_triu X U B unit ctx Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Automatically chooses between the classical and recursive algorithms.AFlint2 fq_nmod_mat_solve_tril_recursive X L B unit ctx Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses the block inversion formula\begin{aligned} ` \begin{pmatrix} A & 0 \\ C & D \end{pmatrix}^{-1} \begin{pmatrix} X \\ Y \end{pmatrix} = \begin{pmatrix} A^{-1} X \\ D^{-1} ( Y - C A^{-1} X ) \end{pmatrix} \end{aligned}to reduce the problem to matrix multiplication and triangular solving of smaller systems.AFlint2 fq_nmod_mat_solve_tril_classical X L B unit ctx Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses forward substitution.AFlint2fq_nmod_mat_solve_tril X L B unit ctx Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Automatically chooses between the classical and recursive algorithms.AFlint2fq_nmod_mat_reduce_row A P L n ctx Reduce row n of the matrix A, assuming the prior rows are in Gauss form. However those rows may not be in order. The entry i of the array P is the row of A which has a pivot in the i1-th column. If no such row exists, the entry of P will be -10. The function returns the column in which the n-th row has a pivot after reduction. This will always be chosen to be the first available column for a pivot from the left. This information is also updated in P . Entry i of the array L5 contains the number of possibly nonzero columns of A row i-. This speeds up reduction in the case that A5 is chambered on the right. Otherwise the entries of L- can all be set to the number of columns of A. We require the entries of L to be monotonic increasing.AFlint2fq_nmod_mat_rref A ctx Puts A5 in reduced row echelon form and returns the rank of A.The rref is computed by first obtaining an unreduced row echelon form via LU decomposition and then solving an additional triangular system.AFlint2fq_nmod_mat_lu_recursive P A  rank_check ctx (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A9. The behavior of this function is identical to that of fq_nmod_mat_lu. Uses recursive block decomposition, switching to classical Gaussian elimination for sufficiently small blocks.AFlint2fq_nmod_mat_lu_classical P A  rank_check ctx (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A9. The behavior of this function is identical to that of fq_nmod_mat_lu. Uses Gaussian elimination.AFlint2fq_nmod_mat_lu P A  rank_check ctx (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A.If A is a nonsingular square matrix, it will be overwritten with a unit diagonal lower triangular matrix L! and an upper triangular matrix U (the diagonal of L will not be stored explicitly).If A is an arbitrary matrix of rank r, U% will be in row echelon form having r nonzero rows, and L, will be lower triangular but truncated to r' columns, having implicit ones on the r first entries of the main diagonal. All other entries will be zero.If a nonzero value for  rank_check is passed, the function will abandon the output matrix in an undefined state and return 0 if A# is detected to be rank-deficient.This function calls fq_nmod_mat_lu_recursive.AFlint2fq_nmod_mat_inv B A ctx Sets  B = A^{-1} and returns 1 if A is invertible. If A is singular, returns 0 and sets the elements of B to undefined values.A and B2 must be square matrices with the same dimensions.AFlint2fq_nmod_mat_vec_mul_ptr c a alen B #Compute a vector-matrix product of  (a, alen) and B and and store the result in c . The vector  (a, alen) is either truncated or zero-extended to the number of rows of B!. The number entries written to c- is always equal to the number of columns of B.AFlint2fq_nmod_mat_vec_mul c a alen B AFlint2fq_nmod_mat_mul_vec_ptr c A b blen #Compute a matrix-vector product of A and  (b, blen) and store the result in c . The vector  (b, blen) is either truncated or zero-extended to the number of columns of A!. The number entries written to c* is always equal to the number of rows of A.AFlint2fq_nmod_mat_mul_vec c A b blen AFlint2fq_nmod_mat_submul D C A B ctx Sets  D = C + AB. C and D. may be aliased with each other but not with A or B.AFlint2fq_nmod_mat_mul_KS C A B ctx Sets C = AB<. Dimensions must be compatible for matrix multiplication. C# is not allowed to be aliased with A or B. Uses Kronecker substitution to perform the multiplication over the integers.AFlint2fq_nmod_mat_mul_classical C A B ctx Sets C = AB<. Dimensions must be compatible for matrix multiplication. C# is not allowed to be aliased with A or B(. Uses classical matrix multiplication.AFlint2fq_nmod_mat_mul C A B ctx Sets C = AB. Dimensions must be compatible for matrix multiplication. Aliasing is allowed. This function automatically chooses between classical and KS multiplication.AFlint2fq_nmod_mat_neg A B ctx Sets B = -A. Dimensions must be identical.AFlint2fq_nmod_mat_sub C A B ctx  Computes  C = A - B. Dimensions must be identical.AFlint2fq_nmod_mat_add C A B ctx  Computes  C = A + B. Dimensions must be identical.AFlint2fq_nmod_mat_is_square mat ctx Returns a non-zero value if the number of rows is equal to the number of columns in mat, and otherwise returns zero.AFlint2fq_nmod_mat_is_empty mat ctx Returns a non-zero value if the number of rows or the number of columns in mat% is zero, and otherwise returns zero.AFlint2fq_nmod_mat_is_one mat ctx (Returns a non-zero value if all entries mat are zero except the diagonal entries which must be one, otherwise returns zero.AFlint2fq_nmod_mat_is_zero mat ctx (Returns a non-zero value if all entries mat' are zero, and otherwise returns zero.AFlint2fq_nmod_mat_equal mat1 mat2 ctx Returns nonzero if mat1 and mat2 have the same dimensions and elements, and zero otherwise.AFlint2fq_nmod_mat_randtriu mat state unit ctx Sets mat) to a random upper triangular matrix. If unit is 1, it will have ones on the main diagonal, otherwise it will have random nonzero entries on the main diagonal.AFlint2fq_nmod_mat_randtril mat state unit ctx Sets mat) to a random lower triangular matrix. If unit is 1, it will have ones on the main diagonal, otherwise it will have random nonzero entries on the main diagonal.AFlint2fq_nmod_mat_randops mat count state ctx  Randomises mat by performing elementary row or column operations. More precisely, at most count random additions or subtractions of distinct rows and columns will be performed. This leaves the rank (and for square matrices, determinant) unchanged.AFlint2fq_nmod_mat_randrank mat state rank ctx Sets mat to a random sparse matrix with the given rank, having exactly as many non-zero elements as the rank, with the non-zero elements being uniformly random elements of \mathbf{F}_{q}.The matrix can be transformed into a dense matrix with unchanged rank by subsequently calling fq_nmod_mat_randops.AFlint2fq_nmod_mat_randpermdiag mat state diag n ctx Sets mat5 to a random permutation of the diagonal matrix with n& leading entries given by the vector diag+. It is assumed that the main diagonal of mat has room for at least n entries.Returns 0 or 1, depending on whether the permutation is even or odd respectively.AFlint2fq_nmod_mat_randtest mat state ctx Sets the elements of mat to random elements of \mathbf{F}_{q} , given by ctx.AFlint2fq_nmod_mat_window_clear window ctx Clears the matrix window and releases any memory that it uses. Note that the memory to the underlying matrix that window points to is not freed.AFlint2fq_nmod_mat_window_init window mat r1 c1 r2 c2 ctx Initializes the matrix window to be an r2 - r1 by c2 - c1 submatrix of mat whose (0,0) entry is the (r1, c1) entry of mat". The memory for the elements of window is shared with mat.AFlint2fq_nmod_mat_fprint file mat ctx Prints mat to file. A header is printed followed by the rows enclosed in brackets.In case of success, returns a positive value. In case of failure, returns a non-positive value.AFlint2fq_nmod_mat_print mat ctx Prints mat to stdout. A header is printed followed by the rows enclosed in brackets.AFlint2fq_nmod_mat_fprint_pretty file mat ctx Pretty-prints mat to file. A header is printed followed by the rows enclosed in brackets.In case of success, returns a positive value. In case of failure, returns a non-positive value.AFlint2fq_nmod_mat_print_pretty mat ctx Pretty-prints mat to stdout. A header is printed followed by the rows enclosed in brackets.AFlint2fq_nmod_mat_concat_horizontal res mat1 mat2 ctx Sets res! to horizontal concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  m \times k, res : m \times (n + k).AFlint2fq_nmod_mat_concat_vertical res mat1 mat2 ctx Sets res to vertical concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  k \times n, res : (m + k) \times n.AFlint2fq_nmod_mat_set_fmpz_mod_mat mat1 mat2 ctx Sets the matrix mat1 to the matrix mat2.AFlint2fq_nmod_mat_set_nmod_mat mat1 mat2 ctx Sets the matrix mat1 to the matrix mat2.AFlint2fq_nmod_mat_invert_cols mat perm Swaps columns i and c - i of mat for  0 <= i < c/2, where c is the number of columns of mat. If perm is non-NULL:, the permutation of the columns will also be applied to perm.AFlint2fq_nmod_mat_invert_rows mat perm  Swaps rows i and r - i of mat for  0 <= i < r/2, where r is the number of rows of mat. If perm is non-NULL7, the permutation of the rows will also be applied to perm.AFlint2fq_nmod_mat_swap_cols mat perm r s Swaps columns r and s of mat. If perm is non-NULL:, the permutation of the columns will also be applied to perm.AFlint2fq_nmod_mat_swap_rows mat perm r s  Swaps rows r and s of mat. If perm is non-NULL7, the permutation of the rows will also be applied to perm.AFlint2fq_nmod_mat_one mat ctx Sets all diagonal entries of mat! to 1 and all other entries to 0.AFlint2fq_nmod_mat_zero mat ctx Sets all entries of mat to 0.AFlint2fq_nmod_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.AFlint2fq_nmod_mat_swap mat1 mat2 ctx &Swaps two matrices. The dimensions of mat1 and mat2 are allowed to be different.AFlint2fq_nmod_mat_ncols mat ctx !Returns the number of columns in mat.AFlint2fq_nmod_mat_nrows mat ctx Returns the number of rows in mat.AFlint2fq_nmod_mat_entry_set mat i j x ctx Sets the entry in mat in row i and column j to x.AFlint2fq_nmod_mat_set mat src ctx Sets mat to a copy of src. It is assumed that mat and src have identical dimensions.AFlint2fq_nmod_mat_clear mat ctx Clears the matrix and releases any memory it used. The matrix cannot be used again until it is initialised. This function must be called exactly once when finished using an  fq_nmod_mat_t object.AFlint2fq_nmod_mat_init_set mat src ctx  Initialises mat3 and sets its dimensions and elements to those of src.AFlint2fq_nmod_mat_init mat rows cols ctx  Initialises mat to a rows-by-cols matrix with coefficients in \mathbf{F}_{q} given by ctx. All elements are set to zero.AFlint2fq_nmod_mat_entry mat i j Directly accesses the entry in mat in row i and column j6, indexed from zero. No bounds checking is performed. AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAv Safe-Inferred )*1-] AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Safe-Inferred )*1jAFlint2fq_zech_bit_unpack rop f bit_size ctx  Unpacks into rop; the element with coefficients packed into fields of size bit_size as represented by the integer f.AFlint2fq_zech_bit_pack f op bit_size ctx Packs op into bitfields of size bit_size, writing the result to f.AFlint2fq_zech_multiplicative_order ord op ctx Computes the order of op/ as an element of the multiplicative group of ctx. Returns 0 if op! is 0, otherwise it returns 1 if op is a generator of the multiplicative group, and -1 if it is not. Note that ctx must already correspond to a finite field defined by a primitive polynomial and so this function cannot be used to check primitivity of the generator, but can be used to check that other elements are primitive.AFlint2fq_zech_frobenius rop op e ctx Evaluates the homomorphism \Sigma^e at op. Recall that \mathbf{F}_q / \mathbf{F}_p is Galois with Galois group \langle \sigma \rangle, which is also isomorphic to \mathbf{Z}/d\mathbf{Z} , where 8\sigma \in \operatorname{Gal}(\mathbf{F}_q/\mathbf{F}_p) is the Frobenius element \sigma \colon x \mapsto x^p.AFlint2 fq_zech_norm rop op ctx Computes the norm of op.For an element a \in \mathbf{F}_q, multiplication by a defines a  \mathbf{F}_p-linear map on  \mathbf{F}_q. We define the norm of a2 as the determinant of this map. Equivalently, if \Sigma generates /\operatorname{Gal}(\mathbf{F}_q / \mathbf{F}_p) then the trace of a is equal to \prod_{i=0}^{d-1} \Sigma^i (a) , where +d = \text{dim}_{\mathbf{F}_p}(\mathbf{F}_q).8Algorithm selection is automatic depending on the input.AFlint2 fq_zech_trace rop op ctx Sets rop to the trace of op.For an element a \in \mathbf{F}_q, multiplication by a defines a  \mathbf{F}_p-linear map on  \mathbf{F}_q. We define the trace of a, as the trace of this map. Equivalently, if \Sigma generates /\operatorname{Gal}(\mathbf{F}_q / \mathbf{F}_p) then the trace of a is equal to \sum_{i=0}^{d-1} \Sigma^i (a), where (d = log_{p} q).AFlint2fq_zech_is_invertible_f f op ctx Returns whether op. is an invertible element. If it is not, then f> is set of a factor of the modulus. Since the modulus for an  fq_zech_ctx_t+ is always irreducible, then any non-zero op will be invertible.AFlint2fq_zech_is_invertible op ctx Returns whether op is an invertible element.AFlint2 fq_zech_equal op1 op2 ctx Returns whether op1 and op2 are equal.AFlint2fq_zech_is_one op ctx Returns whether op is equal to one.AFlint2fq_zech_is_zero op ctx Returns whether op is equal to zero.AFlint2fq_zech_set_nmod_mat a col ctx Convert a column vector col of length  degree(ctx) to an element of ctx.AFlint2fq_zech_get_nmod_mat col a ctx Convert a to a column vector of length  degree(ctx).AFlint2fq_zech_set_nmod_poly a b ctx Set a to the element in ctx with representative b$. The representatives are taken in  (\mathbb{Z}/p\mathbb{Z})[x]/h(x) where h(x) is the defining polynomial in ctx.AFlint2fq_zech_get_nmod_poly a b ctx Set a to a representative of b in ctx$. The representatives are taken in  (\mathbb{Z}/p\mathbb{Z})[x]/h(x) where h(x) is the defining polynomial in ctx.AFlint2fq_zech_set_fq_nmod rop op ctx Sets rop to the  fq_zech_t element corresponding to op.AFlint2fq_zech_get_fq_nmod rop op ctx Sets rop to the  fq_nmod_t element corresponding to op.AFlint2fq_zech_get_fmpz rop op ctx If op$ has a lift to the integers, return 1 and set rop to the lift in [0,p). Otherwise, return 0 and leave rop undefined.AFlint2 fq_zech_gen rop ctx Sets rop to a generator for the finite field. There is no guarantee this is a multiplicative generator of the finite field.AFlint2 fq_zech_one rop ctx Sets rop& to one, reduced in the given context.AFlint2 fq_zech_zero rop ctx Sets rop to zero.AFlint2 fq_zech_swap op1 op2 ctx Swaps the two elements op1 and op2.AFlint2fq_zech_set_fmpz rop x ctx Sets rop to x, considered as an element of  \mathbf{F}_p.AFlint2fq_zech_set_ui rop x ctx Sets rop to x, considered as an element of  \mathbf{F}_p.AFlint2fq_zech_set_si rop x ctx Sets rop to x, considered as an element of  \mathbf{F}_p.AFlint2 fq_zech_set rop op ctx Sets rop to op.AFlint2fq_zech_rand_not_zero rop state ctx 4Generates a high quality non-zero random element of  \mathbf{F}_q.AFlint2 fq_zech_rand rop state ctx +Generates a high quality random element of  \mathbf{F}_q.AFlint2fq_zech_randtest_not_zero rop state ctx 'Generates a random non-zero element of  \mathbf{F}_q.AFlint2fq_zech_randtest rop state ctx Generates a random element of  \mathbf{F}_q.AFlint2fq_zech_get_str_pretty op ctx /Returns a pretty representation of the element op# using the null-terminated string x as the variable name.AFlint2fq_zech_get_str op ctx =Returns the plain FLINT string representation of the element op.AFlint2fq_zech_fprint file op ctx Prints a representation of op to file.AFlint2fq_zech_fprint_pretty file op ctx "Prints a pretty representation of op to file..In the current implementation, always returns 1. The return code is part of the function's signature to allow for a later implementation to return the number of characters printed or a non-positive error code.AFlint2fq_zech_is_square op ctx Return 1 if op is a square.AFlint2fq_zech_pth_root rop op1 ctx Sets rop to a p^{th} root root of op10. Currently, this computes the root by raising op1 to p^{d-1} where d! is the degree of the extension.AFlint2 fq_zech_sqrt rop op1 ctx Sets rop to the square root of op1 if it is a square, and return 1, otherwise return 0.AFlint2fq_zech_pow_ui rop op e ctx Sets rop the op raised to the power e.Currently assumes that e \geq 0.Note that for any input op, rop is set to 1 whenever e = 0.AFlint2 fq_zech_pow rop op e ctx Sets rop the op raised to the power e.Currently assumes that e \geq 0.Note that for any input op, rop is set to 1 whenever e = 0.AFlint2fq_zech_gcdinv f inv op ctx Sets inv to be the inverse of op modulo the modulus of ctx and sets f to one. Since the modulus for ctx is always irreducible, op is always invertible.AFlint2 fq_zech_inv rop op ctx Sets rop( to the inverse of the non-zero element op.AFlint2 fq_zech_div rop op1 op2 ctx Sets rop to the quotient of op1 and op2,, reducing the output in the given context.AFlint2 fq_zech_sqr rop op ctx Sets rop to the square of op,, reducing the output in the given context.BFlint2fq_zech_mul_ui rop op x ctx Sets rop to the product of op and x,, reducing the output in the given context.BFlint2fq_zech_mul_si rop op x ctx Sets rop to the product of op and x,, reducing the output in the given context.BFlint2fq_zech_mul_fmpz rop op x ctx Sets rop to the product of op and x,, reducing the output in the given context.BFlint2 fq_zech_mul rop op1 op2 ctx Sets rop to the product of op1 and op2,, reducing the output in the given context.BFlint2 fq_zech_neg rop op ctx Sets rop to the negative of op.BFlint2fq_zech_sub_one rop op1 ctx Sets rop to the difference of op1 and 1.BFlint2 fq_zech_sub rop op1 op2 ctx Sets rop to the difference of op1 and op2.BFlint2 fq_zech_add rop op1 op2 ctx Sets rop to the sum of op1 and op2.BFlint2fq_zech_reduce rop ctx Reduces the polynomial rop as an element of \mathbf{F}_p[X] / (f(X)).BFlint2 fq_zech_clear rop ctx Clears the element rop.BFlint2 fq_zech_init2 rop ctx  Initialises poly8 with at least enough space for it to be an element of ctx and sets it to 0.BFlint2 fq_zech_init rop ctx Initialises the element rop, setting its value to 0.BFlint2fq_zech_ctx_randtest_reducible ctx Since the Zech logarithm representation does not work with a non-irreducible modulus, does the same as fq_zech_ctx_randtest.BFlint2fq_zech_ctx_randtest ctx  Initializes ctx) to a random finite field. Assumes that fq_zech_ctx_init has not been called on ctx already.BFlint2fq_zech_ctx_fprint file ctx Prints the context information to {tt{file}}. Returns 1 for a success and a negative number for an error.BFlint2fq_zech_ctx_order_ui ctx %Returns the size of the finite field.BFlint2fq_zech_ctx_order f ctx Sets f$ to be the size of the finite field.BFlint2fq_zech_ctx_degree ctx +Returns the degree of the field extension ![\mathbf{F}_{q} : \mathbf{F}_{p}], which is equal to  \log_{p} q.BFlint2fq_zech_ctx_modulus ctx 0Returns a pointer to the modulus in the context.BFlint2fq_zech_ctx_clear ctx Clears all memory that has been allocated as part of the context.BFlint2"fq_zech_ctx_init_fq_nmod_ctx_check ctx ctxn )As per the previous function but returns 02 if a non-primitive modulus is detected. Returns 0: if the Zech representation was successfully initialised.BFlint2fq_zech_ctx_init_fq_nmod_ctx ctx ctxn Initializes the context ctx> to be the Zech representation for the finite field given by ctxn.BFlint2fq_zech_ctx_init_modulus_check ctx modulus var *As per the previous function, but returns 0' if the modulus was not primitive and 1 if the context was successfully initialised with the given modulus. No exception is raised.BFlint2fq_zech_ctx_init_modulus ctx modulus var "Initialises the context for given modulus with name var for the generator. Assumes that modulus" is an primitive polynomial over \mathbf{F}_{p}. An exception is raised if a non-primitive modulus is detected.Assumes that the string var5 is a null-terminated string of length at least one.BFlint2fq_zech_ctx_init_random ctx p d var "Initialises the context for prime p and extension degree d , with name var7 for the generator using a random primitive polynomial. Assumes that p is a prime and p^d < 2^\mathtt{FLINT\_BITS}.Assumes that the string var5 is a null-terminated string of length at least one.BFlint2fq_zech_ctx_init_conway ctx p d var "Initialises the context for prime p and extension degree d , with name var= for the generator using a Conway polynomial for the modulus. Assumes that p is a prime and p^d < 2^\mathtt{FLINT\_BITS}.Assumes that the string var5 is a null-terminated string of length at least one.BFlint2_fq_zech_ctx_init_conway ctx p d var -Attempts to initialise the context for prime p and extension degree d , with name var> for the generator using a Conway polynomial for the modulus.Returns 1 if the Conway polynomial is in the database for the given size and the initialization is successful; otherwise, returns 0. Assumes that p is a prime and p^d < 2^\mathtt{FLINT\_BITS}.Assumes that the string var5 is a null-terminated string of length at least one.BFlint2fq_zech_ctx_init ctx p d var "Initialises the context for prime p and extension degree d , with name var for the generator. By default, it will try use a Conway polynomial; if one is not available, a random primitive polynomial will be used. Assumes that p is a prime and p^d < 2^{\mathtt{FLINT\_BITS}}.Assumes that the string var5 is a null-terminated string of length at least one.BFlint2fq_zech_ctx_print ctx /Prints the context information to {tt{stdout}}.BFlint2fq_zech_print_pretty op ctx "Prints a pretty representation of op to stdout..In the current implementation, always returns 1. The return code is part of the function's signature to allow for a later implementation to return the number of characters printed or a non-positive error code.BFlint2 fq_zech_print op ctx Prints a representation of op to stdout.AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBw Safe-Inferred )*1k AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBAAAAAAAAAABABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA Safe-Inferred )*1x BFlint2_fq_zech_vec_dot res vec1 vec2 len2 ctx Sets res to the dot product of (vec1, len) and (vec2, len).BFlint2"_fq_zech_vec_scalar_submul_fq_zech vec1 vec2 len2 c ctx  Subtracts  (vec2, len2) times c from  (vec1, len2), where c is a  fq_zech_t.BFlint2"_fq_zech_vec_scalar_addmul_fq_zech vec1 vec2 len2 c ctx Adds  (vec2, len2) times c to  (vec1, len2), where c is a  fq_zech_t.BFlint2_fq_zech_vec_sub res vec1 vec2 len2 ctx Sets  (res, len2) to  (vec1, len2) minus  (vec2, len2).BFlint2_fq_zech_vec_add res vec1 vec2 len2 ctx Sets  (res, len2) to the sum of  (vec1, len2) and  (vec2, len2).BFlint2_fq_zech_vec_is_zero vec len ctx Returns 1 if  (vec, len) is zero, and 0 otherwise.BFlint2_fq_zech_vec_equal vec1 vec2 len ctx 5Compares two vectors of the given length and returns 1' if they are equal, otherwise returns 0.BFlint2_fq_zech_vec_neg vec1 vec2 len2 ctx Negates  (vec2, len2) and places it into vec1.BFlint2_fq_zech_vec_zero vec len ctx Zeros the entries of  (vec, len).BFlint2_fq_zech_vec_swap vec1 vec2 len2 ctx Swaps the elements in  (vec1, len2) and  (vec2, len2).BFlint2_fq_zech_vec_set vec1 vec2 len2 ctx Makes a copy of  (vec2, len2) into vec1.BFlint2_fq_zech_vec_print vec len ctx %Prints the vector of given length to stdout.For further details, see _fq_zech_vec_fprint().BFlint2_fq_zech_vec_fprint file vec len ctx 0Prints the vector of given length to the stream file. The format is the length followed by two spaces, then a space separated list of coefficients. If the length is zero, only 0 is printed.In case of success, returns a positive value. In case of failure, returns a non-positive value.BFlint2_fq_zech_vec_randtest f state len ctx Sets the entries of a vector of the given length to elements of the finite field.BFlint2_fq_zech_vec_clear vec len ctx Clears the entries of  (vec, len)$ and frees the space allocated for vec.BFlint2_fq_zech_vec_init len ctx !Returns an initialised vector of fq_zech's of given length.BBBBBBBBBBBBBBBBx Safe-Inferred )*1xnBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Safe-Inferred )*1?=BFlint2fq_zech_mat_minpoly p M ctx Compute the minimal polynomial p of the matrix M. The matrix is required to be square, otherwise an exception is raised.BFlint2fq_zech_mat_charpoly p M &Compute the characteristic polynomial p of the matrix M. The matrix is required to be square, otherwise an exception is raised.BFlint2fq_zech_mat_charpoly_danilevsky p M ctx &Compute the characteristic polynomial p of the matrix M&. The matrix is assumed to be square.BFlint2fq_zech_mat_similarity M r d ctx &Applies a similarity transform to the  n\times n matrix M in-place.If P is the  n\times n0 identity matrix the zero entries of whose row r# (0-indexed) have been replaced by d#, this transform is equivalent to  M = P^{-1}MP.Similarity transforms preserve the determinant, characteristic polynomial and minimal polynomial. The value d is required to be reduced modulo the modulus of the entries in the matrix.BFlint2fq_zech_mat_can_solve X A B ctx "Solves the matrix-matrix equation AX = B over Fq.Returns 1) if a solution exists; otherwise returns 0 and sets the elements of X to zero. If more than one solution exists, one of the valid solutions is given.*There are no restrictions on the shape of A and it may be singular.BFlint2fq_zech_mat_solve X A B ctx "Solves the matrix-matrix equation AX = B.Returns 1 if A" has full rank; otherwise returns 0 and sets the elements of X to undefined values. The matrix A must be square.BFlint2 fq_zech_mat_solve_triu_recursive X U B unit ctx Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses the block inversion formula\begin{aligned} ` \begin{pmatrix} A & B \\ 0 & D \end{pmatrix}^{-1} \begin{pmatrix} X \\ Y \end{pmatrix} = \begin{pmatrix} A^{-1} (X - B D^{-1} Y) \\ D^{-1} Y \end{pmatrix} \end{aligned}to reduce the problem to matrix multiplication and triangular solving of smaller systems.BFlint2 fq_zech_mat_solve_triu_classical X U B unit ctx Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses forward substitution.BFlint2fq_zech_mat_solve_triu X U B unit ctx Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Automatically chooses between the classical and recursive algorithms.BFlint2 fq_zech_mat_solve_tril_recursive X L B unit ctx Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses the block inversion formula\begin{aligned} ` \begin{pmatrix} A & 0 \\ C & D \end{pmatrix}^{-1} \begin{pmatrix} X \\ Y \end{pmatrix} = \begin{pmatrix} A^{-1} X \\ D^{-1} ( Y - C A^{-1} X ) \end{pmatrix} \end{aligned}to reduce the problem to matrix multiplication and triangular solving of smaller systems.BFlint2 fq_zech_mat_solve_tril_classical X L B unit ctx Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses forward substitution.BFlint2fq_zech_mat_solve_tril X L B unit ctx Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Automatically chooses between the classical and recursive algorithms.BFlint2fq_zech_mat_reduce_row A P L n ctx Reduce row n of the matrix A, assuming the prior rows are in Gauss form. However those rows may not be in order. The entry i of the array P is the row of A which has a pivot in the i1-th column. If no such row exists, the entry of P will be -10. The function returns the column in which the n-th row has a pivot after reduction. This will always be chosen to be the first available column for a pivot from the left. This information is also updated in P . Entry i of the array L5 contains the number of possibly nonzero columns of A row i-. This speeds up reduction in the case that A5 is chambered on the right. Otherwise the entries of L- can all be set to the number of columns of A. We require the entries of L to be monotonic increasing.BFlint2fq_zech_mat_rref A ctx Puts A5 in reduced row echelon form and returns the rank of A.The rref is computed by first obtaining an unreduced row echelon form via LU decomposition and then solving an additional triangular system.BFlint2fq_zech_mat_lu_recursive P A  rank_check ctx (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A9. The behavior of this function is identical to that of fq_zech_mat_lu. Uses recursive block decomposition, switching to classical Gaussian elimination for sufficiently small blocks.BFlint2fq_zech_mat_lu_classical P A  rank_check ctx (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A9. The behavior of this function is identical to that of fq_zech_mat_lu. Uses Gaussian elimination.BFlint2fq_zech_mat_lu P A  rank_check ctx (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A.If A is a nonsingular square matrix, it will be overwritten with a unit diagonal lower triangular matrix L! and an upper triangular matrix U (the diagonal of L will not be stored explicitly).If A is an arbitrary matrix of rank r, U% will be in row echelon form having r nonzero rows, and L, will be lower triangular but truncated to r' columns, having implicit ones on the r first entries of the main diagonal. All other entries will be zero.If a nonzero value for  rank_check is passed, the function will abandon the output matrix in an undefined state and return 0 if A# is detected to be rank-deficient.This function calls fq_zech_mat_lu_recursive.BFlint2fq_zech_mat_vec_mul_ptr c a alen B #Compute a vector-matrix product of  (a, alen) and B and and store the result in c . The vector  (a, alen) is either truncated or zero-extended to the number of rows of B!. The number entries written to c- is always equal to the number of columns of B.BFlint2fq_zech_mat_vec_mul c a alen B BFlint2fq_zech_mat_mul_vec_ptr c A b blen #Compute a matrix-vector product of A and  (b, blen) and store the result in c . The vector  (b, blen) is either truncated or zero-extended to the number of columns of A!. The number entries written to c* is always equal to the number of rows of A.BFlint2fq_zech_mat_mul_vec c A b blen BFlint2fq_zech_mat_submul D C A B ctx Sets  D = C + AB. C and D. may be aliased with each other but not with A or B.BFlint2fq_zech_mat_mul_KS C A B ctx Sets C = AB<. Dimensions must be compatible for matrix multiplication. C# is not allowed to be aliased with A or B. Uses Kronecker substitution to perform the multiplication over the integers.BFlint2fq_zech_mat_mul_classical C A B ctx Sets C = AB<. Dimensions must be compatible for matrix multiplication. C# is not allowed to be aliased with A or B(. Uses classical matrix multiplication.BFlint2fq_zech_mat_mul C A B ctx Sets C = AB<. Dimensions must be compatible for matrix multiplication. C# is not allowed to be aliased with A or B. This function automatically chooses between classical and KS multiplication.BFlint2fq_zech_mat_neg A B ctx Sets B = -A. Dimensions must be identical.BFlint2fq_zech_mat_sub C A B ctx  Computes  C = A - B. Dimensions must be identical.BFlint2fq_zech_mat_add C A B ctx  Computes  C = A + B. Dimensions must be identical.BFlint2fq_zech_mat_is_square mat ctx Returns a non-zero value if the number of rows is equal to the number of columns in mat, and otherwise returns zero.BFlint2fq_zech_mat_is_empty mat ctx Returns a non-zero value if the number of rows or the number of columns in mat% is zero, and otherwise returns zero.BFlint2fq_zech_mat_is_one mat ctx (Returns a non-zero value if all entries mat are zero except the diagonal entries which must be one, otherwise returns zero.BFlint2fq_zech_mat_is_zero mat ctx (Returns a non-zero value if all entries mat' are zero, and otherwise returns zero.BFlint2fq_zech_mat_equal mat1 mat2 ctx Returns nonzero if mat1 and mat2 have the same dimensions and elements, and zero otherwise.BFlint2fq_zech_mat_randtriu mat state unit ctx Sets mat) to a random upper triangular matrix. If unit is 1, it will have ones on the main diagonal, otherwise it will have random nonzero entries on the main diagonal.BFlint2fq_zech_mat_randtril mat state unit ctx Sets mat) to a random lower triangular matrix. If unit is 1, it will have ones on the main diagonal, otherwise it will have random nonzero entries on the main diagonal.BFlint2fq_zech_mat_randops mat count state ctx  Randomises mat by performing elementary row or column operations. More precisely, at most count random additions or subtractions of distinct rows and columns will be performed. This leaves the rank (and for square matrices, determinant) unchanged.BFlint2fq_zech_mat_randrank mat state rank ctx Sets mat to a random sparse matrix with the given rank, having exactly as many non-zero elements as the rank, with the non-zero elements being uniformly random elements of \mathbf{F}_{q}.The matrix can be transformed into a dense matrix with unchanged rank by subsequently calling fq_zech_mat_randops.BFlint2fq_zech_mat_randpermdiag mat state diag n ctx Sets mat5 to a random permutation of the diagonal matrix with n& leading entries given by the vector diag+. It is assumed that the main diagonal of mat has room for at least n entries.Returns 0 or 1, depending on whether the permutation is even or odd respectively.BFlint2fq_zech_mat_randtest mat state ctx Sets the elements of mat to random elements of \mathbf{F}_{q} , given by ctx.BFlint2fq_zech_mat_window_clear window ctx Clears the matrix window and releases any memory that it uses. Note that the memory to the underlying matrix that window points to is not freed.BFlint2fq_zech_mat_window_init window mat r1 c1 r2 c2 ctx Initializes the matrix window to be an r2 - r1 by c2 - c1 submatrix of mat whose (0,0) entry is the (r1, c1) entry of mat". The memory for the elements of window is shared with mat.BFlint2fq_zech_mat_fprint file mat ctx Prints mat to file. A header is printed followed by the rows enclosed in brackets.In case of success, returns a positive value. In case of failure, returns a non-positive value.BFlint2fq_zech_mat_fprint_pretty file mat ctx Pretty-prints mat to file. A header is printed followed by the rows enclosed in brackets.In case of success, returns a positive value. In case of failure, returns a non-positive value.BFlint2fq_zech_mat_concat_horizontal res mat1 mat2 ctx Sets res! to horizontal concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  m \times k, res : m \times (n + k).BFlint2fq_zech_mat_concat_vertical res mat1 mat2 ctx Sets res to vertical concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  k \times n, res : (m + k) \times n.BFlint2fq_zech_mat_set_fmpz_mod_mat mat1 mat2 ctx Sets the matrix mat1 to the matrix mat2.BFlint2fq_zech_mat_set_nmod_mat mat1 mat2 ctx Sets the matrix mat1 to the matrix mat2.BFlint2fq_zech_mat_one mat ctx Sets all diagonal entries of mat! to 1 and all other entries to 0.BFlint2fq_zech_mat_zero mat ctx Sets all entries of mat to 0.BFlint2fq_zech_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.BFlint2fq_zech_mat_swap mat1 mat2 ctx &Swaps two matrices. The dimensions of mat1 and mat2 are allowed to be different.BFlint2fq_zech_mat_ncols mat ctx !Returns the number of columns in mat.BFlint2fq_zech_mat_nrows mat ctx Returns the number of rows in mat.BFlint2fq_zech_mat_entry_set mat i j x ctx Sets the entry in mat in row i and column j to x.BFlint2fq_zech_mat_set mat src ctx Sets mat to a copy of src. It is assumed that mat and src have identical dimensions.BFlint2fq_zech_mat_clear mat ctx Clears the matrix and releases any memory it used. The matrix cannot be used again until it is initialised. This function must be called exactly once when finished using an  fq_zech_mat_t object.BFlint2fq_zech_mat_init_set mat src ctx  Initialises mat3 and sets its dimensions and elements to those of src.BFlint2fq_zech_mat_init mat rows cols ctx  Initialises mat to a rows-by-cols matrix with coefficients in \mathbf{F}_{q} given by ctx. All elements are set to zero.BFlint2fq_zech_mat_entry mat i j Directly accesses the entry in mat in row i and column j6, indexed from zero. No bounds checking is performed.BFlint2fq_zech_mat_print_pretty mat ctx Pretty-prints mat to stdout. A header is printed followed by the rows enclosed in brackets.BFlint2fq_zech_mat_print mat ctx Prints mat to stdout. A header is printed followed by the rows enclosed in brackets.BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBy Safe-Inferred )*1 BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB Safe-Inferred )*1ϯ BFlint2fq_zech_modulus_derivative_inv m_prime  m_prime_inv ctx Compute the derivative m_prime of the modulus of ctx as an element of ctx, and its inverse  m_prime_inv.BFlint2fq_zech_modulus_pow_series_inv res ctx trunc Compute the power series inverse of the reverse of the modulus of ctx up to O(x^\texttt{trunc}).BFlint2!fq_zech_embed_dual_to_mono_matrix res ctx :Compute the change of basis matrix from the dual basis of ctx to its monomial basis.BFlint2!fq_zech_embed_mono_to_dual_matrix res ctx >Compute the change of basis matrix from the monomial basis of ctx to its dual basis.BFlint2fq_zech_embed_mul_matrix matrix gen ctx  Compute the multiplication matrix of gen.For an element a in  \mathbf{F}_{p^n}=\mathbf{F}_p[x], its multiplication matrix is the matrix whose columns are (a, ax, dots, ax^{n-1}).BFlint2$fq_zech_embed_composition_matrix_sub matrix gen ctx trunc  Compute the composition matrix of gen, truncated to trunc columns.BFlint2 fq_zech_embed_composition_matrix matrix gen ctx  Compute the composition matrix of gen.For an element a\in\mathbf{F}_{p^n}:, its composition matrix is the matrix whose columns are a^0, a^1, \ldots, a^{n-1}.CFlint2fq_zech_embed_trace_matrix res basis sub_ctx sup_ctx Given: two contexts sub_ctx and sup_ctx , of degrees m and n, such that m divides n;an  n\times m matrix basis that maps sub_ctx# to an isomorphic subfield in sup_ctx; Compute the  m\times n matrix of the trace from sup_ctx to sub_ctx.This matrix is computed as%embed_dual_to_mono_matrix(_, sub_ctx) \times basist \times &embed_mono_to_dual_matrix(_, sup_ctx)}.Note: if m=n, basis? represents a Frobenius, and the result is its inverse matrix.CFlint2fq_zech_embed_matrices embed project gen_sub sub_ctx gen_sup sup_ctx  gen_minpoly Given: two contexts sub_ctx and sup_ctx, of respective degrees m and n , such that m divides n; a generator gen_sub of sub_ctx, its minimal polynomial  gen_minpoly , and a root gen_sup of  gen_minpoly in sup_ctx, as returned by fq_zech_embed_gens;Compute:the  n\times m matrix embed mapping gen_sub to gen_sup(, and all their powers accordingly;an  m\times n matrix project such that project \times embed is the  m\times m identity matrix.CFlint2_fq_zech_embed_gens_naive gen_sub gen_sup minpoly sub_ctx sup_ctx Given two contexts sub_ctx and sup_ctx , such that degree(sub_ctx) divides degree(sup_ctx), compute an embedding of sub_ctx into sup_ctx defined as follows:gen_sub is the canonical generator of sup_ctx (i.e., the class of X),minpoly is the defining polynomial of sub_ctx,gen_sup is a root of minpoly" inside the field defined by sup_ctx.CFlint2fq_zech_embed_gens gen_sub gen_sup minpoly sub_ctx sup_ctx Given two contexts sub_ctx and sup_ctx , such that degree(sub_ctx) divides degree(sup_ctx) , compute: an element gen_sub in sub_ctx such that gen_sub, generates the finite field defined by sub_ctx,its minimal polynomial minpoly,a root gen_sup of minpoly inside the field defined by sup_ctx.+These data uniquely define an embedding of sub_ctx into sup_ctx. BBBBBBBCCCCz Safe-Inferred )*1 BBBBBBBCCCC CCCCBBBBBBB Safe-Inferred )*1CFlint2_fq_nmod_vec_dot res vec1 vec2 len2 ctx Sets res to the dot product of (vec1, len) and (vec2, len).CFlint2"_fq_nmod_vec_scalar_submul_fq_nmod vec1 vec2 len2 c ctx  Subtracts  (vec2, len2) times c from  (vec1, len2), where c is a  fq_nmod_t.CFlint2"_fq_nmod_vec_scalar_addmul_fq_nmod vec1 vec2 len2 c ctx Adds  (vec2, len2) times c to  (vec1, len2), where c is a  fq_nmod_t.CFlint2_fq_nmod_vec_sub res vec1 vec2 len2 ctx Sets  (res, len2) to  (vec1, len2) minus  (vec2, len2).CFlint2_fq_nmod_vec_add res vec1 vec2 len2 ctx Sets  (res, len2) to the sum of  (vec1, len2) and  (vec2, len2).CFlint2_fq_nmod_vec_is_zero vec len ctx Returns 1 if  (vec, len) is zero, and 0 otherwise.CFlint2_fq_nmod_vec_equal vec1 vec2 len ctx 5Compares two vectors of the given length and returns 1' if they are equal, otherwise returns 0.CFlint2_fq_nmod_vec_neg vec1 vec2 len2 ctx Negates  (vec2, len2) and places it into vec1.CFlint2_fq_nmod_vec_zero vec len ctx Zeros the entries of  (vec, len).CFlint2_fq_nmod_vec_swap vec1 vec2 len2 ctx Swaps the elements in  (vec1, len2) and  (vec2, len2).CFlint2_fq_nmod_vec_set vec1 vec2 len2 ctx Makes a copy of  (vec2, len2) into vec1.CFlint2_fq_nmod_vec_print vec len ctx %Prints the vector of given length to stdout.For further details, see _fq_nmod_vec_fprint().CFlint2_fq_nmod_vec_fprint file vec len ctx 0Prints the vector of given length to the stream file. The format is the length followed by two spaces, then a space separated list of coefficients. If the length is zero, only 0 is printed.In case of success, returns a positive value. In case of failure, returns a non-positive value.CFlint2_fq_nmod_vec_randtest f state len ctx Sets the entries of a vector of the given length to elements of the finite field.CFlint2_fq_nmod_vec_clear vec len ctx Clears the entries of  (vec, len)$ and frees the space allocated for vec.CFlint2_fq_nmod_vec_init len ctx !Returns an initialised vector of fq_nmod's of given length.CCCCCCCCCCCCCCCC{ Safe-Inferred )*1,CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC Safe-Inferred )*1$CFlint2fq_mat_minpoly p M ctx Compute the minimal polynomial p of the matrix M. The matrix is required to be square, otherwise an exception is raised.CFlint2fq_mat_charpoly p M ctx &Compute the characteristic polynomial p of the matrix M. The matrix is required to be square, otherwise an exception is raised.CFlint2fq_mat_charpoly_danilevsky p M ctx &Compute the characteristic polynomial p of the matrix M&. The matrix is assumed to be square.CFlint2fq_mat_similarity M r d ctx &Applies a similarity transform to the  n\times n matrix M in-place.If P is the  n\times n0 identity matrix the zero entries of whose row r# (0-indexed) have been replaced by d#, this transform is equivalent to  M = P^{-1}MP.Similarity transforms preserve the determinant, characteristic polynomial and minimal polynomial. The value d is required to be reduced modulo the modulus of the entries in the matrix.CFlint2fq_mat_can_solve X A B ctx "Solves the matrix-matrix equation AX = B over Fq.Returns 1) if a solution exists; otherwise returns 0 and sets the elements of X to zero. If more than one solution exists, one of the valid solutions is given.*There are no restrictions on the shape of A and it may be singular.CFlint2 fq_mat_solve X A B ctx "Solves the matrix-matrix equation AX = B.Returns 1 if A" has full rank; otherwise returns 0 and sets the elements of X to undefined values. The matrix A must be square.CFlint2fq_mat_solve_triu_recursive X U B unit ctx Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses the block inversion formula\begin{aligned} ` \begin{pmatrix} A & B \\ 0 & D \end{pmatrix}^{-1} \begin{pmatrix} X \\ Y \end{pmatrix} = \begin{pmatrix} A^{-1} (X - B D^{-1} Y) \\ D^{-1} Y \end{pmatrix} \end{aligned}to reduce the problem to matrix multiplication and triangular solving of smaller systems.CFlint2fq_mat_solve_triu_classical X U B unit ctx Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses forward substitution.CFlint2fq_mat_solve_triu X U B unit ctx Sets  X = U^{-1} B where U4 is a full rank upper triangular square matrix. If unit = 1, U is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Automatically chooses between the classical and recursive algorithms.CFlint2fq_mat_solve_tril_recursive X L B unit ctx Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses the block inversion formula\begin{aligned} ` \begin{pmatrix} A & 0 \\ C & D \end{pmatrix}^{-1} \begin{pmatrix} X \\ Y \end{pmatrix} = \begin{pmatrix} A^{-1} X \\ D^{-1} ( Y - C A^{-1} X ) \end{pmatrix} \end{aligned}to reduce the problem to matrix multiplication and triangular solving of smaller systems.CFlint2fq_mat_solve_tril_classical X L B unit ctx Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Uses forward substitution.CFlint2fq_mat_solve_tril X L B unit ctx Sets  X = L^{-1} B where L4 is a full rank lower triangular square matrix. If unit = 1, L is assumed to have ones on its main diagonal, and the main diagonal will not be read. X and B are allowed to be the same matrix, but no other aliasing is allowed. Automatically chooses between the classical and recursive algorithms.CFlint2fq_mat_reduce_row A P L n ctx Reduce row n of the matrix A, assuming the prior rows are in Gauss form. However those rows may not be in order. The entry i of the array P is the row of A which has a pivot in the i1-th column. If no such row exists, the entry of P will be -10. The function returns the column in which the n-th row has a pivot after reduction. This will always be chosen to be the first available column for a pivot from the left. This information is also updated in P . Entry i of the array L5 contains the number of possibly nonzero columns of A row i-. This speeds up reduction in the case that A5 is chambered on the right. Otherwise the entries of L- can all be set to the number of columns of A. We require the entries of L to be monotonic increasing.CFlint2 fq_mat_rref A ctx Puts A5 in reduced row echelon form and returns the rank of A.The rref is computed by first obtaining an unreduced row echelon form via LU decomposition and then solving an additional triangular system.CFlint2fq_mat_lu_recursive P A  rank_check ctx (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A9. The behavior of this function is identical to that of  fq_mat_lu. Uses recursive block decomposition, switching to classical Gaussian elimination for sufficiently small blocks.CFlint2fq_mat_lu_classical P A  rank_check ctx (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A9. The behavior of this function is identical to that of  fq_mat_lu. Uses Gaussian elimination.CFlint2 fq_mat_lu P A  rank_check ctx (Computes a generalised LU decomposition LU = PA of a given matrix A, returning the rank of A.If A is a nonsingular square matrix, it will be overwritten with a unit diagonal lower triangular matrix L! and an upper triangular matrix U (the diagonal of L will not be stored explicitly).If A is an arbitrary matrix of rank r, U% will be in row echelon form having r nonzero rows, and L, will be lower triangular but truncated to r' columns, having implicit ones on the r first entries of the main diagonal. All other entries will be zero.If a nonzero value for  rank_check is passed, the function will abandon the output matrix in an undefined state and return 0 if A# is detected to be rank-deficient.This function calls fq_mat_lu_recursive.CFlint2 fq_mat_inv B A ctx Sets  B = A^{-1} and returns 1 if A is invertible. If A is singular, returns 0 and sets the elements of B to undefined values.A and B2 must be square matrices with the same dimensions.CFlint2fq_mat_vec_mul_ptr c a alen B #Compute a vector-matrix product of  (a, alen) and B and and store the result in c . The vector  (a, alen) is either truncated or zero-extended to the number of rows of B!. The number entries written to c- is always equal to the number of columns of B.CFlint2fq_mat_vec_mul c a alen B CFlint2fq_mat_mul_vec_ptr c A b blen #Compute a matrix-vector product of A and  (b, blen) and store the result in c . The vector  (b, blen) is either truncated or zero-extended to the number of columns of A!. The number entries written to c* is always equal to the number of rows of A.CFlint2fq_mat_mul_vec c A b blen CFlint2 fq_mat_submul D C A B ctx Sets  D = C + AB. C and D. may be aliased with each other but not with A or B.CFlint2 fq_mat_mul_KS C A B ctx Sets C = AB<. Dimensions must be compatible for matrix multiplication. C# is not allowed to be aliased with A or B. Uses Kronecker substitution to perform the multiplication over the integers.CFlint2fq_mat_mul_classical C A B ctx Sets C = AB<. Dimensions must be compatible for matrix multiplication. C# is not allowed to be aliased with A or B(. Uses classical matrix multiplication.CFlint2 fq_mat_mul C A B ctx Sets C = AB. Dimensions must be compatible for matrix multiplication. Aliasing is allowed. This function automatically chooses between classical and KS multiplication.CFlint2 fq_mat_neg A B ctx Sets B = -A. Dimensions must be identical.CFlint2 fq_mat_sub C A B ctx  Computes  C = A - B. Dimensions must be identical.CFlint2 fq_mat_add C A B ctx  Computes  C = A + B. Dimensions must be identical.CFlint2fq_mat_is_square mat ctx Returns a non-zero value if the number of rows is equal to the number of columns in mat, and otherwise returns zero.CFlint2fq_mat_is_empty mat ctx Returns a non-zero value if the number of rows or the number of columns in mat% is zero, and otherwise returns zero.CFlint2 fq_mat_is_one mat ctx (Returns a non-zero value if all entries mat are zero except the diagonal entries which must be one, otherwise returns zero..CFlint2fq_mat_is_zero mat ctx +Returns a non-zero value if all entries of mat' are zero, and otherwise returns zero.CFlint2 fq_mat_equal mat1 mat2 ctx Returns nonzero if mat1 and mat2 have the same dimensions and elements, and zero otherwise.CFlint2fq_mat_randtriu mat state unit ctx Sets mat) to a random upper triangular matrix. If unit is 1, it will have ones on the main diagonal, otherwise it will have random nonzero entries on the main diagonal.CFlint2fq_mat_randtril mat state unit ctx Sets mat) to a random lower triangular matrix. If unit is 1, it will have ones on the main diagonal, otherwise it will have random nonzero entries on the main diagonal.CFlint2fq_mat_randops mat count state ctx  Randomises mat by performing elementary row or column operations. More precisely, at most count random additions or subtractions of distinct rows and columns will be performed. This leaves the rank (and for square matrices, determinant) unchanged.CFlint2fq_mat_randrank mat state rank ctx Sets mat to a random sparse matrix with the given rank, having exactly as many non-zero elements as the rank, with the non-zero elements being uniformly random elements of \mathbf{F}_{q}.The matrix can be transformed into a dense matrix with unchanged rank by subsequently calling fq_mat_randops.CFlint2fq_mat_randpermdiag mat state diag n ctx Sets mat5 to a random permutation of the diagonal matrix with n& leading entries given by the vector diag+. It is assumed that the main diagonal of mat has room for at least n entries.Returns 0 or 1, depending on whether the permutation is even or odd respectively.CFlint2fq_mat_randtest mat state ctx Sets the elements of mat to random elements of \mathbf{F}_{q} , given by ctx.CFlint2fq_mat_window_clear window ctx Clears the matrix window and releases any memory that it uses. Note that the memory to the underlying matrix that window points to is not freed.CFlint2fq_mat_window_init window mat r1 c1 r2 c2 ctx Initializes the matrix window to be an r2 - r1 by c2 - c1 submatrix of mat whose (0,0) entry is the (r1, c1) entry of mat". The memory for the elements of window is shared with mat.CFlint2 fq_mat_fprint file mat ctx Prints mat to file. A header is printed followed by the rows enclosed in brackets.In case of success, returns a positive value. In case of failure, returns a non-positive value.CFlint2 fq_mat_print mat ctx Prints mat to stdout. A header is printed followed by the rows enclosed in brackets.CFlint2fq_mat_fprint_pretty file mat ctx Pretty-prints mat to file. A header is printed followed by the rows enclosed in brackets.In case of success, returns a positive value. In case of failure, returns a non-positive value.CFlint2fq_mat_print_pretty mat ctx Pretty-prints mat to stdout. A header is printed followed by the rows enclosed in brackets.CFlint2fq_mat_concat_horizontal res mat1 mat2 ctx Sets res! to horizontal concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  m \times k, res : m \times (n + k).CFlint2fq_mat_concat_vertical res mat1 mat2 ctx Sets res to vertical concatenation of (mat1, mat2&) in that order. Matrix dimensions : mat1 :  m \times n, mat2 :  k \times n, res : (m + k) \times n.CFlint2fq_mat_set_fmpz_mod_mat mat1 mat2 ctx Sets the matrix mat1 to the matrix mat2.CFlint2fq_mat_set_nmod_mat mat1 mat2 ctx Sets the matrix mat1 to the matrix mat2.CFlint2fq_mat_invert_cols mat perm Swaps columns i and c - i of mat for  0 <= i < c/2, where c is the number of columns of mat. If perm is non-NULL:, the permutation of the columns will also be applied to perm.CFlint2fq_mat_invert_rows mat perm  Swaps rows i and r - i of mat for  0 <= i < r/2, where r is the number of rows of mat. If perm is non-NULL7, the permutation of the rows will also be applied to perm.CFlint2fq_mat_swap_cols mat perm r s Swaps columns r and s of mat. If perm is non-NULL:, the permutation of the columns will also be applied to perm.CFlint2fq_mat_swap_rows mat perm r s  Swaps rows r and s of mat. If perm is non-NULL7, the permutation of the rows will also be applied to perm.CFlint2 fq_mat_one mat ctx !Sets all the diagonal entries of mat! to 1 and all other entries to 0.CFlint2 fq_mat_zero mat ctx Sets all entries of mat to 0.CFlint2fq_mat_swap_entrywise mat1 mat2 Swaps two matrices by swapping the individual entries rather than swapping the contents of the structs.CFlint2 fq_mat_swap mat1 mat2 ctx &Swaps two matrices. The dimensions of mat1 and mat2 are allowed to be different.CFlint2 fq_mat_ncols mat ctx !Returns the number of columns in mat.CFlint2 fq_mat_nrows mat ctx Returns the number of rows in mat.CFlint2fq_mat_entry_set mat i j x ctx Sets the entry in mat in row i and column j to x.CFlint2 fq_mat_set mat src ctx Sets mat to a copy of src. It is assumed that mat and src have identical dimensions.CFlint2 fq_mat_clear mat ctx Clears the matrix and releases any memory it used. The matrix cannot be used again until it is initialised. This function must be called exactly once when finished using an fq_mat_t object.CFlint2fq_mat_init_set mat src ctx  Initialises mat3 and sets its dimensions and elements to those of src.CFlint2 fq_mat_init mat rows cols ctx  Initialises mat to a rows-by-cols matrix with coefficients in \mathbf{F}_{q} given by ctx. All elements are set to zero.CFlint2 fq_mat_entry mat i j Directly accesses the entry in mat in row i and column j6, indexed from zero. No bounds checking is performed.CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC| Safe-Inferred )*1%CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC Safe-Inferred )*1 CFlint2fq_poly_deflation input ctx %Returns the largest integer by which input2 can be deflated. As special cases, returns 0 if input! is the zero polynomial and 1 of input is a constant polynomial.CFlint2fq_poly_deflate result input  deflation ctx Sets result to the deflated polynomial  p(x^{1/n}) where p is given by input and n is given by  deflation . Requires n > 0.CFlint2fq_poly_inflate result input  inflation ctx Sets result to the inflated polynomial p(x^n) where p is given by input and n is given by  inflation.CFlint2fq_poly_get_str_pretty poly x ctx 2Returns a pretty representation of the polynomial poly# using the null-terminated string x as the variable nameCFlint2_fq_poly_get_str_pretty poly len x ctx 2Returns a pretty representation of the polynomial  (poly, len)# using the null-terminated string x as the variable name.CFlint2fq_poly_get_str poly ctx Returns the plain FLINT string representation of the polynomial poly.CFlint2_fq_poly_get_str poly len ctx Returns the plain FLINT string representation of the polynomial  (poly, len).CFlint2_fq_poly_print poly len ctx $Prints the pretty representation of  (poly, len) to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value.CFlint2fq_poly_fprint file poly ctx $Prints the pretty representation of poly to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.CFlint2_fq_poly_fprint file poly len ctx $Prints the pretty representation of  (poly, len) to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.CFlint2_fq_poly_print_pretty poly len x ctx $Prints the pretty representation of  (poly, len) to stdout, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.CFlint2fq_poly_fprint_pretty file poly x ctx $Prints the pretty representation of poly to the stream file, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.CFlint2_fq_poly_fprint_pretty file poly len x ctx $Prints the pretty representation of  (poly, len) to the stream file, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.CFlint2-fq_poly_compose_mod_brent_kung_precomp_preinv res f A h hinv ctx Sets res to the composition f(g) modulo h". We require that the ith row of A contains g^i for i=1,\ldots,\sqrt{\deg(h)}, i.e. A: is a (sqrt{deg(h)}times deg(h)) matrix. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv& to be the inverse of the reverse of h. This version of Brent-Kung modular composition is particularly useful if one has to perform several modular composition of the form f(g) modulo h for fixed g and h.CFlint2._fq_poly_compose_mod_brent_kung_precomp_preinv res f lenf A h lenh hinv lenhinv ctx Sets res to the composition f(g) modulo h. We require that h, is nonzero. We require that the ith row of A contains g^i for i=1,\ldots,\sqrt{\deg(h)}, i.e. A is a \sqrt{\deg(h)}\times \deg(h)- matrix. We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.CFlint2fq_poly_precompute_matrix A f g ginv ctx Sets the ith row of A to f^i modulo g for i=1,\ldots,\sqrt{\deg(g)} . We require A to be a \sqrt{\deg(g)}\times \deg(g) matrix. We require ginv& to be the inverse of the reverse of g.CFlint2_fq_poly_precompute_matrix A f g leng ginv lenginv ctx Sets the ith row of A to f^i modulo g for i=1,\ldots,\sqrt{\deg(g)} . We require A to be a \sqrt{\deg(g)}\times \deg(g) matrix. We require ginv& to be the inverse of the reverse of g and g to be nonzero.CFlint2_fq_poly_reduce_matrix_mod_poly A B f ctx Sets the ith row of A$ to the reduction of the ith row of B modulo f for i=1,\ldots,\sqrt{\deg(f)} . We require B to be at least a \sqrt{\deg(f)}\times \deg(f) matrix and f to be nonzero.CFlint2fq_poly_compose_mod_preinv res f g h hinv ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h.CFlint2_fq_poly_compose_mod_preinv res f lenf g h lenh hinv lenhiv ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.CFlint2fq_poly_compose_mod res f g h ctx Sets res to the composition f(g) modulo h. We require that h is nonzero.CFlint2_fq_poly_compose_mod res f lenf g h lenh ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.CFlint2%fq_poly_compose_mod_brent_kung_preinv res f g h hinv ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h9. The algorithm used is the Brent-Kung matrix algorithm.CFlint2&_fq_poly_compose_mod_brent_kung_preinv res f lenf g h lenh hinv lenhiv ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.CFlint2fq_poly_compose_mod_brent_kung res f g h ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h9. The algorithm used is the Brent-Kung matrix algorithm.CFlint2_fq_poly_compose_mod_brent_kung res f lenf g h lenh ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.CFlint2!fq_poly_compose_mod_horner_preinv res f g h hinv ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h'. The algorithm used is Horner's rule.CFlint2"_fq_poly_compose_mod_horner_preinv res f lenf g h lenh hinv lenhiv ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.$The algorithm used is Horner's rule.CFlint2fq_poly_compose_mod_horner res f g h ctx Sets res to the composition f(g) modulo h. We require that h1 is nonzero. The algorithm used is Horner's rule.CFlint2_fq_poly_compose_mod_horner res f lenf g h lenh ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.$The algorithm used is Horner's rule.CFlint2fq_poly_compose rop op1 op2 ctx Sets rop to the composition of op1 and op2:. To be precise about the order of composition, denoting rop, op1, and op2 by f, g, and h, respectively, sets f(t) = g(h(t)).CFlint2_fq_poly_compose rop op1 len1 op2 len2 ctx Sets rop to the composition of  (op1, len1) and  (op2, len2). Assumes that rop has space for (len1-1)*(len2-1) + 1 coefficients. Assumes that op1 and op2 are non-zero polynomials. Does not support aliasing between any of the inputs and the output.CFlint2fq_poly_evaluate_fq rop f a ctx Sets rop to the value of f(a).As the coefficient ring  \mathbf{F}_q+ is finite, Horner's method is sufficient.CFlint2_fq_poly_evaluate_fq rop op len a ctx Sets rop to  (op, len) evaluated at a.4Supports zero padding. There are no restrictions on len , that is, len is allowed to be zero, too.CFlint2 fq_poly_sqrt s p mod If p is a perfect square, sets s to a square root of p% and returns 1. Otherwise returns 0.DFlint2 _fq_poly_sqrt s p n mod If (p, n) is a perfect square, sets (s, n / 2 + 1) to a square root of p$ and returns 1. Otherwise returns 0.DFlint2fq_poly_sqrt_series g h n ctx Set g to the series expansion of \sqrt{h} to order O(x^n). It is assumed that h has constant term 1.DFlint2_fq_poly_sqrt_series g h n ctx Set the first n terms of g to the series expansion of \sqrt{h}. It is assumed that n > 0, that h has constant term 1 and that h' is zero-padded as necessary to length n. Aliasing is not permitted.DFlint2fq_poly_invsqrt_series g h n ctx Set g to the series expansion of  1/\sqrt{h} to order O(x^n). It is assumed that h has constant term 1.DFlint2_fq_poly_invsqrt_series g h n mod Set the first n terms of g to the series expansion of  1/\sqrt{h}. It is assumed that n > 0, that h has constant term 1 and that h' is zero-padded as necessary to length n. Aliasing is not permitted.DFlint2fq_poly_derivative rop op ctx Sets rop to the derivative of op.DFlint2_fq_poly_derivative rop op len ctx Sets (rop, len - 1) to the derivative of  (op, len) . Also handles the cases where len is 0 or 1" correctly. Supports aliasing of rop and op.DFlint2fq_poly_divides Q A B ctx Returns 1 if B divides A exactly and sets Q% to the quotient, otherwise returns 0.This function is currently unoptimised and provided for convenience only.DFlint2_fq_poly_divides Q A lenA B lenB invB ctx Returns 1 if  (B, lenB) divides  (A, lenA) exactly and sets Q% to the quotient, otherwise returns 0.It is assumed that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0 and that Q has space for 1\operatorname{len}(A) - \operatorname{len}(B) + 1 coefficients. Aliasing of Q, with either of the inputs is not permitted.This function is currently unoptimised and provided for convenience only.DFlint2fq_poly_xgcd_euclidean_f f G S T A B ctx  Either sets f = 1 and computes the GCD of A and B or sets f+ to a non-trivial factor of the modulus of ctx.$If the GCD is computed, polynomials S and T are computed such that  S*A + T*B = G/; otherwise, they are undefined. The length of S will be at most lenB and the length of T will be at most lenA.The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P4. Except in the case where the GCD is zero, the GCD G is made monic.DFlint2_fq_poly_xgcd_euclidean_f f G S T A lenA B lenB invB ctx  Either sets f = 1 and computes the GCD of A and B together with cofactors S and T such that  S A + T B = G; otherwise, sets f+ to a non-trivial factor of the modulus of ctx and leaves G, S, and T" undefined. Returns the length of G. Assumes that 7\operatorname{len}(A) \geq \operatorname{len}(B) \geq 1 and 8(\operatorname{len}(A),\operatorname{len}(B)) \neq (1,1).)No attempt is made to make the GCD monic.Requires that G have space for \operatorname{len}(B) coefficients. Writes \operatorname{len}(B)-1 and \operatorname{len}(A)-1 coefficients to S and T&, respectively. Note that, in fact, \operatorname{len}(S) \leq \max(\operatorname{len}(B) - \operatorname{len}(G), 1) and \operatorname{len}(T) \leq \max(\operatorname{len}(A) - \operatorname{len}(G), 1).6No aliasing of input and output operands is permitted.DFlint2 fq_poly_xgcd G S T A B ctx Computes the GCD of A and B. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic. Polynomials S and T are computed such that  S*A + T*B = G. The length of S will be at most lenB and the length of T will be at most lenA.DFlint2 _fq_poly_xgcd G S T A lenA B lenB ctx Computes the GCD of A and B together with cofactors S and T such that  S A + T B = G. Returns the length of G. Assumes that 7\operatorname{len}(A) \geq \operatorname{len}(B) \geq 1 and 8(\operatorname{len}(A),\operatorname{len}(B)) \neq (1,1).)No attempt is made to make the GCD monic.Requires that G have space for \operatorname{len}(B) coefficients. Writes \operatorname{len}(B)-1 and \operatorname{len}(A)-1 coefficients to S and T&, respectively. Note that, in fact, \operatorname{len}(S) \leq \max(\operatorname{len}(B) - \operatorname{len}(G), 1) and \operatorname{len}(T) \leq \max(\operatorname{len}(A) - \operatorname{len}(G), 1).6No aliasing of input and output operands is permitted.DFlint2fq_poly_gcd_euclidean_f f G A B ctx  Either sets f = 1 and G# to the greatest common divisor of A and B or sets f to a factor of the modulus of ctx.DFlint2_fq_poly_gcd_euclidean_f f G A lenA B lenB ctx  Either sets f = 1 and G$ to the greatest common divisor of (A,\operatorname{len}(A)) and (B, \operatorname{len}(B))" and returns its length, or sets f, to a non-trivial factor of the modulus of ctx' and leaves the contents of the vector  (G, lenB) undefined. Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0 and that the vector G. has space for sufficiently many coefficients.DFlint2 _fq_poly_gcd G A lenA B lenB ctx Computes the GCD of A of length lenA and B of length lenB , where lenA >= lenB > 0 and sets G to it. The length of the GCD G is returned by the function. No attempt is made to make the GCD monic. It is required that G have space for lenB coefficients.DFlint2 fq_poly_gcd rop op1 op2 ctx Sets rop# to the greatest common divisor of op1 and op2, using the either the Euclidean or HGCD algorithm. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic.DFlint2fq_poly_div_series Q A B n ctx Set Q to the quotient of the series A by B8, thinking of the series as though they were of length n,. We assume that the bottom coefficient of B is invertible.DFlint2_fq_poly_div_series Q A Alen B Blen n ctx Set (Q, n) to the quotient of the series (A, Alen) and  (B, Blen) assuming Alen, Blen <= n&. We assume the bottom coefficient of B is invertible.DFlint2fq_poly_inv_series Qinv Q n ctx Given Q find Qinv such that Q * Qinv is 1 modulo x^n. The constant coefficient of Q+ must be invertible modulo the modulus of Q7. An exception is raised if this is not the case or if n = 0.DFlint2_fq_poly_inv_series Qinv Q n ctx Given Q of length n whose constant coefficient is invertible modulo the given modulus, find a polynomial Qinv of length n such that Q * Qinv is 1 modulo x^n . Requires n > 0.DFlint2fq_poly_inv_series_newton Qinv Q n ctx Given Q find Qinv such that Q * Qinv is 1 modulo x^n. The constant coefficient of Q+ must be invertible modulo the modulus of Q7. An exception is raised if this is not the case or if n = 0. This function can be viewed as inverting a power series via Newton iteration.DFlint2_fq_poly_inv_series_newton Qinv Q n ctx Given Q of length n whose constant coefficient is invertible modulo the given modulus, find a polynomial Qinv of length n such that Q * Qinv is 1 modulo x^n . Requires n > 0. This function can be viewed as inverting a power series via Newton iteration.DFlint2_fq_poly_divrem_newton_n_preinv Q R A lenA B lenB Binv lenBinv ctx  Computes Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB. We require that Q have space for lenA - lenB + 1+ coefficients. Furthermore, we assume that Binv# is the inverse of the reverse of B mod x^{\operatorname{len}(B)}!. The algorithm used is to call div_newton_n_preinv1 and then multiply out and compute the remainder.DFlint2fq_poly_div_newton_n_preinv Q A B Binv ctx Notionally computes Q and R such that  A = BQ + R with -\operatorname{len}(R) < \operatorname{len}(B), but returns only Q.*We assume that the leading coefficient of B is a unit and that Binv" is the inverse of the reverse of B mod x^{\operatorname{len}(B)}."It is required that the length of A+ is less than or equal to 2*the length of B - 2.The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.DFlint2_fq_poly_div_newton_n_preinv Q A lenA B lenB Binv lenBinv ctx_t  Notionally computes polynomials Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB, but return only Q.We require that Q have space for lenA - lenB + 1: coefficients and assume that the leading coefficient of B) is a unit. Furthermore, we assume that Binv" is the inverse of the reverse of B mod x^{\operatorname{len}(B)}.The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.DFlint2 fq_poly_div Q A B ctx Notionally finds polynomials Q and R such that  A = B Q + R with -\operatorname{len}(R) < \operatorname{len}(B), but returns only Q. If \operatorname{len}(B) = 0 an exception is raised.DFlint2 _fq_poly_div Q A lenA B lenB invB ctx Notationally, computes Q, R such that  A = B Q + R with (0 leq operatorname{len}(R) < operatorname{len}(B)) but only sets (Q, lenA - lenB + 1). Allows zero-padding in A but not in B+. Assumes that the leading coefficient of B is a unit.DFlint2 fq_poly_rem R A B ctx Sets R% to the remainder of the division of A by B in the context described by ctx.DFlint2 _fq_poly_rem R A lenA B lenB invB ctx Sets R% to the remainder of the division of (A,lenA) by (B,lenB)+. Assumes that the leading coefficient of (B,lenB) is invertible and that invB is its inverse.DFlint2fq_poly_divrem_f f Q R A B ctx "Either finds a non-trivial factor f of the modulus of ctx, or computes Q, R such that  A = B Q + R and 40 \leq \operatorname{len}(R) < \operatorname{len}(B).If the leading coefficient of B is invertible, the division with remainder operation is carried out, Q and R are computed correctly, and f is set to 1 . Otherwise, f4 is set to a non-trivial factor of the modulus and Q and R are not touched. Assumes that B is non-zero.DFlint2fq_poly_divrem Q R A B ctx  Computes Q, R such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B).(Assumes that the leading coefficient of B is invertible. This can be taken for granted the context is for a finite field, that is, when p is prime and f(X) is irreducible.DFlint2_fq_poly_divrem Q R A lenA B lenB invB ctx  Computes (Q, lenA - lenB + 1),  (R, lenA) such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B).(Assumes that the leading coefficient of B is invertible and that invB is its inverse. Assumes that 0\operatorname{len}(A), \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA). R and A may be aliased, but apart from this no aliasing of input and output operands is allowed.DFlint2fq_poly_hamming_weight op ctx 9Returns the number of non-zero entries in the polynomial op.DFlint2fq_poly_shift_right rop op n ctx Sets rop to op shifted right by n coefficients. If n4 is equal to or greater than the current length of op, rop is set to the zero polynomial.DFlint2_fq_poly_shift_right rop op len n ctx Sets (rop, len - n) to  (op, len) shifted right by n coefficients. Assumes that len and n are positive, that len > n , and that rop fits len - n% elements. Supports aliasing between rop and op1, although in this case the top coefficients of op are not set to zero.DFlint2fq_poly_shift_left rop op n ctx Sets rop to op shifted left by n) coeffs. Zero coefficients are inserted.DFlint2_fq_poly_shift_left rop op len n ctx Sets (rop, len + n) to  (op, len) shifted left by n coefficients.9Inserts zero coefficients at the lower end. Assumes that len and n are positive, and that rop fits len + n& elements. Supports aliasing between rop and op.DFlint2fq_poly_pow_trunc res poly e trunc ctx Sets res to the low trunc coefficients of poly to the power e. This is equivalent to doing a powering followed by a truncation.DFlint2_fq_poly_pow_trunc res poly e trunc mod Sets res to the low trunc coefficients of poly4 (assumed to be zero padded if necessary to length trunc) to the power e. This is equivalent to doing a powering followed by a truncation. We require that res has enough space for trunc coefficients, that  trunc > 0 and that e > 1. Aliasing is not permitted.DFlint2fq_poly_pow_trunc_binexp res poly e trunc ctx Sets res to the low trunc coefficients of poly to the power e. This is equivalent to doing a powering followed by a truncation. Uses the binary exponentiation method.DFlint2_fq_poly_pow_trunc_binexp res poly e trunc ctx Sets res to the low trunc coefficients of poly4 (assumed to be zero padded if necessary to length trunc) to the power e. This is equivalent to doing a powering followed by a truncation. We require that res has enough space for trunc coefficients, that  trunc > 0 and that e > 1. Aliasing is not permitted. Uses the binary exponentiation method.DFlint2fq_poly_powmod_x_fmpz_preinv res e f finv ctx Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.DFlint2_fq_poly_powmod_x_fmpz_preinv res e f lenf finv lenfinv ctx Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 2 . The output res must have room for lenf - 1 coefficients.DFlint2"fq_poly_powmod_fmpz_sliding_preinv res poly e k f finv ctx Sets res to poly raised to the power e modulo f8, using sliding-window exponentiation with window size k . We require e >= 0. We require finv% to be the inverse of the reverse of f. If k is set to zero, then an "optimum" size will be selected automatically base on e.DFlint2#_fq_poly_powmod_fmpz_sliding_preinv res poly e k f lenf finv lenfinv ctx Sets res to poly raised to the power e modulo f8, using sliding-window exponentiation with window size k . We require e > 0. We require finv% to be the inverse of the reverse of f. If k is set to zero, then an "optimum" size will be selected automatically base on e. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.DFlint2!fq_poly_powmod_fmpz_binexp_preinv res poly e f finv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.DFlint2"_fq_poly_powmod_fmpz_binexp_preinv res poly e f lenf finv lenfinv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.DFlint2fq_poly_powmod_fmpz_binexp res poly e f ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.DFlint2_fq_poly_powmod_fmpz_binexp res poly e f lenf ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.DFlint2fq_poly_powmod_ui_binexp_preinv res poly e f finv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.DFlint2 _fq_poly_powmod_ui_binexp_preinv res poly e f lenf finv lenfinv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.DFlint2fq_poly_powmod_ui_binexp res poly e f ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.DFlint2_fq_poly_powmod_ui_binexp res poly e f lenf ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.DFlint2 fq_poly_pow rop op e ctx  Computes  rop = op^e. If e. is zero, returns one, so that in particular 0^0 = 1.DFlint2 _fq_poly_pow rop op len e ctx Sets  rop = op^e, assuming that  e, len > 0 and that rop has space for e*(len - 1) + 1) coefficients. Does not support aliasing.DFlint2 fq_poly_sqr rop op ctx Sets rop to the square of op$, choosing an appropriate algorithm.DFlint2 _fq_poly_sqr rop op len ctx Sets (rop, 2* len - 1) to the square of  (op, len)%, choosing an appropriate algorithm.0Permits zero padding. Does not support aliasing.DFlint2fq_poly_sqr_KS rop op ctx Sets rop to the square op using Kronecker substitution, that is, by encoding each coefficient in \mathbf{F}_{q} as an integer and reducing this problem to multiplying two polynomials over the integers.DFlint2_fq_poly_sqr_KS rop op len ctx Sets (rop, 2*len - 1) to the square of  (op, len).>Permits zero padding and places no assumptions on the lengths len1 and len2. Supports aliasing.DFlint2fq_poly_sqr_reorder rop op ctx Sets rop to the square of op, assuming that len0 is not zero reordering the two indeterminates X and Y. when viewing the polynomials as elements of \mathbf{F}_p[X,Y]. See fq_poly_mul_reorder.DFlint2_fq_poly_sqr_reorder rop op len ctx Sets (rop, 2*len- 1) to the square of  (op, len), assuming that len0 is not zero reordering the two indeterminates X and Y. when viewing the polynomials as elements of \mathbf{F}_p[X,Y].(Permits zero padding. Supports aliasing.DFlint2fq_poly_sqr_classical rop op ctx Sets rop to the square of op using classicalpolynomial multiplication.DFlint2_fq_poly_sqr_classical rop op len ctx Sets (rop, 2*len - 1) to the square of  (op, len), assuming that (op,len); is not zero and using classical polynomial multiplication.3Permits zero padding. Does not support aliasing of rop with either op1 or op2.DFlint2fq_poly_mulmod_preinv res poly1 poly2 f finv ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f. finv" is the inverse of the reverse of f.DFlint2_fq_poly_mulmod_preinv res poly1 len1 poly2 len2 f lenf finv lenfinv ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.It is required that finv" is the inverse of the reverse of f mod x^lenf. Aliasing of res) with any of the inputs is not permitted.DFlint2fq_poly_mulmod res poly1 poly2 f ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.DFlint2_fq_poly_mulmod res poly1 len1 poly2 len2 f lenf ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.It is required that len1 + len2 - lenf > 0, which is equivalent to requiring that the result will actually be reduced. Otherwise, simply use  _fq_poly_mul instead. Aliasing of f and res is not permitted.DFlint2fq_poly_mulhigh res poly1 poly2 start ctx Computes the product of poly1 and poly2# and writes the coefficients from start' onwards into the high coefficients of res:, the remaining coefficients being arbitrary but reduced.DFlint2_fq_poly_mulhigh res poly1 len1 poly2 len2 start ctx Computes the product of  (poly1, len1) and  (poly2, len2)# and writes the coefficients from start( onwards into the high coefficients of res, the remaining coefficients being arbitrary but reduced. Assumes that len1 >= len2 > 01. Aliasing of inputs and output is not permitted.DFlint2fq_poly_mulhigh_classical res poly1 poly2 start ctx Computes the product of poly1 and poly2# and writes the coefficients from start' onwards into the high coefficients of res, the remaining coefficients being arbitrary but reduced. Algorithm is classical multiplication.DFlint2_fq_poly_mulhigh_classical res poly1 len1 poly2 len2 start ctx Computes the product of  (poly1, len1) and  (poly2, len2)# and writes the coefficients from start( onwards into the high coefficients of res, the remaining coefficients being arbitrary but reduced. Assumes that len1 >= len2 > 0. Aliasing of inputs and output is not permitted. Algorithm is classical multiplication.DFlint2fq_poly_mullow rop op1 op2 n ctx Sets rop to the lowest n coefficients of the product of op1 and op2.DFlint2_fq_poly_mullow rop op1 len1 op2 len2 n ctx Sets (rop, n) to the lowest n! coefficients of the product of  (op1, len1) and  (op2, len2).Assumes 0 < n <= len1 + len2 - 1. Allows for zero-padding in the inputs. Does not support aliasing between the inputs and the output.DFlint2fq_poly_mullow_KS rop op1 op2 n ctx Sets rop to the lowest n coefficients of the product of op1 and op2.DFlint2_fq_poly_mullow_KS rop op1 len1 op2 len2 n ctx Sets (rop, n) to the lowest n! coefficients of the product of  (op1, len1) and  (op2, len2). Assumes that len1 and len2 are positive, but does allow for the polynomials to be zero-padded. The polynomials may be zero, too. Assumes n( is positive. Supports aliasing between rop, op1 and op2.DFlint2fq_poly_mullow_univariate rop op1 op2 n ctx Sets rop to the lowest n coefficients of the product of op1 and op2:, computed using a bivariate to univariate transformation.DFlint2_fq_poly_mullow_univariate rop op1 len1 op2 len2 n ctx Sets (rop, n) to the lowest n! coefficients of the product of  (op1, len1) and  (op2, len2);, computed using a bivariate to univariate transformation. Assumes that len1 and len2 are positive, but does allow for the polynomials to be zero-padded. The polynomials may be zero, too. Assumes n( is positive. Supports aliasing between res, poly1 and poly2.DFlint2fq_poly_mullow_classical rop op1 op2 n ctx Sets rop to the product of poly1 and poly25, computed using the classical or schoolbook method.DFlint2_fq_poly_mullow_classical rop op1 len1 op2 len2 n ctx Sets (rop, n) to the first n coefficients of  (op1, len1) multiplied by  (op2, len2).Assumes 0 < n <= len1 + len2 - 1. Assumes neither len1 nor len2 is zero.DFlint2 fq_poly_mul rop op1 op2 ctx Sets rop to the product of op1 and op2%, choosing an appropriate algorithm.DFlint2 _fq_poly_mul rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2)$, choosing an appropriate algorithm.0Permits zero padding. Does not support aliasing.DFlint2fq_poly_mul_KS rop op1 op2 ctx Sets rop to the product of op1 and op2 using Kronecker substitution, that is, by encoding each coefficient in \mathbf{F}_{q} as an integer and reducing this problem to multiplying two polynomials over the integers.DFlint2_fq_poly_mul_KS rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2).>Permits zero padding and places no assumptions on the lengths len1 and len2. Supports aliasing.DFlint2fq_poly_mul_univariate rop op1 op2 ctx Sets rop to the product of op1 and op2 using a bivariate to univariate transformation and reducing this problem to multiplying two univariate polynomials.DFlint2_fq_poly_mul_univariate rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2).>Permits zero padding and places no assumptions on the lengths len1 and len2. Supports aliasing.DFlint2fq_poly_mul_reorder rop op1 op2 ctx Sets rop to the product of op1 and op2%, reordering the two indeterminates X and Y. when viewing the polynomials as elements of \mathbf{F}_p[X,Y].Suppose &\mathbf{F}_q = \mathbf{F}_p[X]/ (f(X)) and recall that elements of  \mathbf{F}_q1 are internally represented by elements of type  fmpz_poly2. For small degree extensions but polynomials in \mathbf{F}_q[Y] of large degree n", we change the representation to` \begin{aligned} \begin{split} g(Y) & = \sum_{i=0}^{n} a_i(X) Y^i \\ & = \sum_{j=0}^{d} \sum_{i=0}^{n} \text{Coeff}(a_i(X), j) Y^i. \end{split} \end{aligned}This allows us to use a poor algorithm (such as classical multiplication) in the X-direction and leverage the existing fast integer multiplication routines in the Y(-direction where the polynomial degree n is large.DFlint2_fq_poly_mul_reorder rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2), assuming that len1 and len2 are non-zero.(Permits zero padding. Supports aliasing.DFlint2fq_poly_mul_classical rop op1 op2 ctx Sets rop to the product of op1 and op2, using classical polynomial multiplication.DFlint2_fq_poly_mul_classical rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2), assuming that len1 is at least len2 and neither is zero.3Permits zero padding. Does not support aliasing of rop with either op1 or op2.DFlint2fq_poly_scalar_div_fq rop op x ctx Sets rop to the quotient of op by the scalar x, in the context defined by ctx. An exception is raised if x is zero.DFlint2_fq_poly_scalar_div_fq rop op len x ctx Sets  (rop,len) to the quotient of (op,len) by the scalar x, in the context defined by ctx. An exception is raised if x is zero.DFlint2fq_poly_scalar_submul_fq rop op x ctx Subtracts from rop the product of op by the scalar x, in the context defined by ctx.DFlint2_fq_poly_scalar_submul_fq rop op len x ctx Subtracts from  (rop,len) the product of (op,len) by the scalar x, in the context defined by ctx.. In particular, assumes the same length for op and rop.DFlint2fq_poly_scalar_addmul_fq rop op x ctx Adds to rop the product of op by the scalar x, in the context defined by ctx.DFlint2_fq_poly_scalar_addmul_fq rop op len x ctx Adds to  (rop,len) the product of (op,len) by the scalar x, in the context defined by ctx.. In particular, assumes the same length for op and rop.DFlint2fq_poly_scalar_mul_fq rop op x ctx Sets rop to the product of op by the scalar x, in the context defined by ctx.DFlint2_fq_poly_scalar_mul_fq rop op len x ctx Sets  (rop,len) to the product of (op,len) by the scalar x, in the context defined by ctx.DFlint2 fq_poly_neg res poly ctx Sets res to the additive inverse of poly.DFlint2 _fq_poly_neg rop op len ctx Sets rop to the additive inverse of  (poly,len).DFlint2fq_poly_sub_series res poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n and set res to the difference.DFlint2 fq_poly_sub res poly1 poly2 ctx Sets res to the difference of poly1 and poly2.DFlint2 _fq_poly_sub res poly1 len1 poly2 len2 ctx Sets res to the difference of  (poly1,len1) and  (poly2,len2).DFlint2fq_poly_add_series res poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n and set res to the sum.DFlint2fq_poly_add_si res poly1 c ctx Sets res to the sum of poly1 and c.DFlint2 fq_poly_add res poly1 poly2 ctx Sets res to the sum of poly1 and poly2.DFlint2 _fq_poly_add res poly1 len1 poly2 len2 ctx Sets res to the sum of  (poly1,len1) and  (poly2,len2).DFlint2fq_poly_equal_fq poly c ctx Returns whether the polynomial poly is equal the (constant)  \mathbf{F}_q element cDFlint2fq_poly_is_unit op ctx Returns whether the polynomial poly# is a unit in the polynomial ring \mathbf{F}_q[X], i.e. if it has degree 0 and is non-zero.DFlint2fq_poly_is_gen op ctx Returns whether the polynomial poly is equal to the polynomial x.DFlint2fq_poly_is_one op Returns whether the polynomial poly& is equal to the constant polynomial 1.DFlint2fq_poly_is_zero poly ctx Returns whether the polynomial poly is the zero polynomial.DFlint2fq_poly_equal_trunc poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n> and return nonzero if they are equal, otherwise return zero.DFlint2 fq_poly_equal poly1 poly2 ctx 'Returns nonzero if the two polynomials poly1 and poly2$ are equal, otherwise returns zero.DFlint2fq_poly_set_coeff_fmpz poly n x ctx Sets the coefficient of X^n in the polynomial to x , assuming n \geq 0.DFlint2fq_poly_set_coeff poly n x ctx Sets the coefficient of X^n in poly to x.DFlint2fq_poly_get_coeff x poly n ctx Sets x to the coefficient of X^n in poly.DFlint2_fq_poly_make_monic rop op length ctx Sets rop to  (op,length)6, normed to have leading coefficient 1. Assumes that rop4 has enough space for the polynomial, assumes that op> is not zero (and thus has an invertible leading coefficient).DFlint2fq_poly_make_monic rop op ctx Sets rop to op', normed to have leading coefficient 1.DFlint2 fq_poly_gen poly ctx Sets poly to the polynomial x.DFlint2 fq_poly_one poly ctx Sets poly to the constant polynomial 1.DFlint2 fq_poly_zero poly ctx Sets poly to the zero polynomial.DFlint2 _fq_poly_zero rop len ctx Sets  (rop, len) to the zero polynomial.DFlint2 fq_poly_swap op1 op2 ctx Swaps the two polynomials op1 and op2.DFlint2fq_poly_set_nmod_poly rop op ctx Sets the polynomial rop to the polynomial opDFlint2fq_poly_set_fmpz_mod_poly rop op ctx Sets the polynomial rop to the polynomial opDFlint2fq_poly_set_fq poly c ctx Sets the polynomial poly to c.DFlint2 fq_poly_set poly1 poly2 ctx Sets the polynomial poly1 to the polynomial poly2.EFlint2 _fq_poly_set rop op len ctx Sets  (rop, len) to  (op, len).EFlint2fq_poly_randtest_irreducible f state len ctx Sets f5 to a random monic, irreducible polynomial of length len) with entries in the field described by ctx.EFlint2fq_poly_randtest_monic f state len ctx Sets f( to a random monic polynomial of length len) with entries in the field described by ctx.EFlint2fq_poly_randtest_not_zero f state len ctx Same as fq_poly_randtest1 but guarantees that the polynomial is not zero.EFlint2fq_poly_randtest f state len ctx Sets f* to a random polynomial of length at most len) with entries in the field described by ctx.EFlint2 fq_poly_lead poly ctx 0Returns a pointer to the leading coefficient of poly, or NULL if poly is the zero polynomial.EFlint2fq_poly_length poly ctx %Returns the length of the polynomial poly.EFlint2fq_poly_degree poly ctx %Returns the degree of the polynomial poly.EFlint2fq_poly_reverse output input m ctx Sets output to the reverse of input,, thinking of it as a polynomial of length m3, notionally zero-padded if necessary). The length m must be non-negative, but there are no other restrictions. The output polynomial will be set to length m and then normalised.EFlint2_fq_poly_reverse output input len m ctx Sets output to the reverse of input, which is of length len0, but thinking of it as a polynomial of length m3, notionally zero-padded if necessary. The length m must be non-negative, but there are no other restrictions. The polynomial output must have space for m coefficients.EFlint2fq_poly_set_trunc poly1 poly2 newlen ctx Sets poly1 to poly2 truncated to length n.EFlint2fq_poly_truncate poly newlen ctx +Truncates the polynomial to length at most n.EFlint2_fq_poly_normalise2 poly length ctx Sets the length length of  (poly,length) so that the top coefficient is non-zero. If all coefficients are zero, the length is set to zero. This function is mainly used internally, as all functions guarantee normalisation.EFlint2_fq_poly_normalise poly ctx Sets the length of poly so that the top coefficient is non-zero. If all coefficients are zero, the length is set to zero. This function is mainly used internally, as all functions guarantee normalisation.EFlint2 fq_poly_clear poly ctx Clears the given polynomial, releasing any memory used. It must be reinitialised in order to be used again.EFlint2_fq_poly_set_length poly newlen ctx Sets the coefficients of poly beyond len! to zero and sets the length of poly to len.EFlint2fq_poly_fit_length poly len ctx If len is greater than the number of coefficients currently allocated, then the polynomial is reallocated to have space for at least len; coefficients. No data is lost when calling this function.3The function efficiently deals with the case where  fit_length is called many times in small increments by at least doubling the number of allocated coefficients when length is larger than the number of coefficients currently allocated.EFlint2fq_poly_realloc poly alloc ctx 3Reallocates the given polynomial to have space for alloc coefficients. If alloc is zero the polynomial is cleared and then reinitialised. If the current length is greater than alloc. the polynomial is first truncated to length alloc.EFlint2 fq_poly_init2 poly alloc ctx  Initialises poly with space for at least alloc coefficients and sets the length to zero. The allocated coefficients are all set to zero. A corresponding call to  fq_poly_clear( must be made after finishing with the  fq_poly_t+ to free the memory used by the polynomial.EFlint2 fq_poly_init poly ctx  Initialises poly for use, with context ctx, and setting its length to zero. A corresponding call to  fq_poly_clear( must be made after finishing with the  fq_poly_t, to free the memory used by the polynomial.EFlint2 Create a new C structure with context ctx.EFlint2Use C structure.EFlint2Use new C structure.EFlint2fq_poly_print_pretty poly x ctx $Prints the pretty representation of poly to stdout, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.EFlint2 fq_poly_print poly ctx Prints the representation of poly to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value.CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEE} Safe-Inferred )*1 [CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEECCCCEEEEEEEEEEEEEEEEEEEEEEEDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDCCCCCCCCCCCCCCCCCCCCCCCCCECCCECCCCCCC Safe-Inferred )*1髱EFlint2fq_zech_poly_deflation input ctx %Returns the largest integer by which input2 can be deflated. As special cases, returns 0 if input! is the zero polynomial and 1 of input is a constant polynomial.EFlint2fq_zech_poly_deflate result input  deflation ctx Sets result to the deflated polynomial  p(x^{1/n}) where p is given by input and n is given by  deflation . Requires n > 0.EFlint2fq_zech_poly_inflate result input  inflation ctx Sets result to the inflated polynomial p(x^n) where p is given by input and n is given by  inflation.EFlint2fq_zech_poly_get_str_pretty poly x ctx 2Returns a pretty representation of the polynomial poly# using the null-terminated string x as the variable nameEFlint2_fq_zech_poly_get_str_pretty poly len x ctx 2Returns a pretty representation of the polynomial  (poly, len)# using the null-terminated string x as the variable name.EFlint2fq_zech_poly_get_str poly ctx Returns the plain FLINT string representation of the polynomial poly.EFlint2_fq_zech_poly_get_str poly len ctx Returns the plain FLINT string representation of the polynomial  (poly, len).EFlint2_fq_zech_poly_print poly len ctx $Prints the pretty representation of  (poly, len) to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value.EFlint2fq_zech_poly_fprint file poly ctx $Prints the pretty representation of poly to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.EFlint2_fq_zech_poly_fprint file poly len ctx $Prints the pretty representation of  (poly, len) to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.EFlint2_fq_zech_poly_print_pretty poly len x ctx $Prints the pretty representation of  (poly, len) to stdout, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.EFlint2fq_zech_poly_fprint_pretty file poly x ctx $Prints the pretty representation of poly to the stream file, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.EFlint2_fq_zech_poly_fprint_pretty file poly len x ctx $Prints the pretty representation of  (poly, len) to the stream file, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.EFlint22fq_zech_poly_compose_mod_brent_kung_precomp_preinv res f A h hinv ctx Sets res to the composition f(g) modulo h". We require that the ith row of A contains g^i for i=1,\ldots,\sqrt{\deg(h)}, i.e. A: is a (sqrt{deg(h)}times deg(h)) matrix. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv& to be the inverse of the reverse of h. This version of Brent-Kung modular composition is particularly useful if one has to perform several modular composition of the form f(g) modulo h for fixed g and h.EFlint23_fq_zech_poly_compose_mod_brent_kung_precomp_preinv res f lenf A h lenh hinv lenhinv ctx Sets res to the composition f(g) modulo h. We require that h, is nonzero. We require that the ith row of A contains g^i for i=1,\ldots,\sqrt{\deg(h)}, i.e. A is a \sqrt{\deg(h)}\times \deg(h)- matrix. We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.EFlint2fq_zech_poly_precompute_matrix A f g ginv ctx Sets the ith row of A to f^i modulo g for i=1,\ldots,\sqrt{\deg(g)} . We require A to be a \sqrt{\deg(g)}\times \deg(g) matrix. We require ginv& to be the inverse of the reverse of g.EFlint2_fq_zech_poly_precompute_matrix A f g leng ginv lenginv ctx Sets the ith row of A to f^i modulo g for i=1,\ldots,\sqrt{\deg(g)} . We require A to be a \sqrt{\deg(g)}\times \deg(g) matrix. We require ginv& to be the inverse of the reverse of g and g to be nonzero.EFlint2$_fq_zech_poly_reduce_matrix_mod_poly A B f ctx Sets the ith row of A$ to the reduction of the ith row of B modulo f for i=1,\ldots,\sqrt{\deg(f)} . We require B to be at least a \sqrt{\deg(f)}\times \deg(f) matrix and f to be nonzero.EFlint2fq_zech_poly_compose_mod_preinv res f g h hinv ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h.EFlint2 _fq_zech_poly_compose_mod_preinv res f lenf g h lenh hinv lenhiv ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.EFlint2fq_zech_poly_compose_mod res f g h ctx Sets res to the composition f(g) modulo h. We require that h is nonzero.EFlint2_fq_zech_poly_compose_mod res f lenf g h lenh ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.EFlint2*fq_zech_poly_compose_mod_brent_kung_preinv res f g h hinv ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h9. The algorithm used is the Brent-Kung matrix algorithm.EFlint2+_fq_zech_poly_compose_mod_brent_kung_preinv res f lenf g h lenh hinv lenhiv ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.EFlint2#fq_zech_poly_compose_mod_brent_kung res f g h ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h9. The algorithm used is the Brent-Kung matrix algorithm.EFlint2$_fq_zech_poly_compose_mod_brent_kung res f lenf g h lenh ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.EFlint2&fq_zech_poly_compose_mod_horner_preinv res f g h hinv ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h'. The algorithm used is Horner's rule.EFlint2'_fq_zech_poly_compose_mod_horner_preinv res f lenf g h lenh hinv lenhiv ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.$The algorithm used is Horner's rule.EFlint2fq_zech_poly_compose_mod_horner res f g h ctx Sets res to the composition f(g) modulo h. We require that h1 is nonzero. The algorithm used is Horner's rule.EFlint2 _fq_zech_poly_compose_mod_horner res f lenf g h lenh ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.$The algorithm used is Horner's rule.EFlint2fq_zech_poly_compose rop op1 op2 ctx Sets rop to the composition of op1 and op2:. To be precise about the order of composition, denoting rop, op1, and op2 by f, g, and h, respectively, sets f(t) = g(h(t)).EFlint2_fq_zech_poly_compose rop op1 len1 op2 len2 ctx Sets rop to the composition of  (op1, len1) and  (op2, len2). Assumes that rop has space for (len1-1)*(len2-1) + 1 coefficients. Assumes that op1 and op2 are non-zero polynomials. Does not support aliasing between any of the inputs and the output.EFlint2fq_zech_poly_evaluate_fq_zech rop f a ctx Sets rop to the value of f(a).As the coefficient ring  \mathbf{F}_q+ is finite, Horner's method is sufficient.EFlint2_fq_zech_poly_evaluate_fq_zech rop op len a ctx Sets rop to  (op, len) evaluated at a.4Supports zero padding. There are no restrictions on len , that is, len is allowed to be zero, too.EFlint2fq_zech_poly_sqrt s p mod If p is a perfect square, sets s to a square root of p% and returns 1. Otherwise returns 0.EFlint2_fq_zech_poly_sqrt s p n mod If (p, n) is a perfect square, sets (s, n / 2 + 1) to a square root of p$ and returns 1. Otherwise returns 0.EFlint2fq_zech_poly_sqrt_series g h n ctx Set g to the series expansion of \sqrt{h} to order O(x^n). It is assumed that h has constant term 1.EFlint2_fq_zech_poly_sqrt_series g h n ctx Set the first n terms of g to the series expansion of \sqrt{h}. It is assumed that n > 0, that h has constant term 1 and that h' is zero-padded as necessary to length n. Aliasing is not permitted.EFlint2fq_zech_poly_invsqrt_series g h n ctx Set g to the series expansion of  1/\sqrt{h} to order O(x^n). It is assumed that h has constant term 1.EFlint2_fq_zech_poly_invsqrt_series g h n mod Set the first n terms of g to the series expansion of  1/\sqrt{h}. It is assumed that n > 0, that h has constant term 1 and that h' is zero-padded as necessary to length n. Aliasing is not permitted.EFlint2fq_zech_poly_derivative rop op ctx Sets rop to the derivative of op.EFlint2_fq_zech_poly_derivative rop op len ctx Sets (rop, len - 1) to the derivative of  (op, len) . Also handles the cases where len is 0 or 1" correctly. Supports aliasing of rop and op.EFlint2fq_zech_poly_divides Q A B ctx Returns 1 if B divides A exactly and sets Q% to the quotient, otherwise returns 0.This function is currently unoptimised and provided for convenience only.EFlint2_fq_zech_poly_divides Q A lenA B lenB invB ctx Returns 1 if  (B, lenB) divides  (A, lenA) exactly and sets Q% to the quotient, otherwise returns 0.It is assumed that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0 and that Q has space for 1\operatorname{len}(A) - \operatorname{len}(B) + 1 coefficients. Aliasing of Q, with either of the inputs is not permitted.This function is currently unoptimised and provided for convenience only.EFlint2fq_zech_poly_xgcd_euclidean_f f G S T A B ctx  Either sets f = 1 and computes the GCD of A and B or sets f+ to a non-trivial factor of the modulus of ctx.$If the GCD is computed, polynomials S and T are computed such that  S*A + T*B = G/; otherwise, they are undefined. The length of S will be at most lenB and the length of T will be at most lenA.The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P4. Except in the case where the GCD is zero, the GCD G is made monic.EFlint2_fq_zech_poly_xgcd_euclidean_f f G S T A lenA B lenB invB ctx  Either sets f = 1 and computes the GCD of A and B together with cofactors S and T such that  S A + T B = G; otherwise, sets f+ to a non-trivial factor of the modulus of ctx and leaves G, S, and T" undefined. Returns the length of G. Assumes that 7\operatorname{len}(A) \geq \operatorname{len}(B) \geq 1 and 8(\operatorname{len}(A),\operatorname{len}(B)) \neq (1,1).)No attempt is made to make the GCD monic.Requires that G have space for \operatorname{len}(B) coefficients. Writes \operatorname{len}(B)-1 and \operatorname{len}(A)-1 coefficients to S and T&, respectively. Note that, in fact, \operatorname{len}(S) \leq \max(\operatorname{len}(B) - \operatorname{len}(G), 1) and \operatorname{len}(T) \leq \max(\operatorname{len}(A) - \operatorname{len}(G), 1).6No aliasing of input and output operands is permitted.EFlint2fq_zech_poly_xgcd G S T A B ctx Computes the GCD of A and B. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic. Polynomials S and T are computed such that  S*A + T*B = G. The length of S will be at most lenB and the length of T will be at most lenA.EFlint2_fq_zech_poly_xgcd G S T A lenA B lenB invB ctx Computes the GCD of A and B together with cofactors S and T such that  S A + T B = G. Returns the length of G. Assumes that 7\operatorname{len}(A) \geq \operatorname{len}(B) \geq 1 and 8(\operatorname{len}(A),\operatorname{len}(B)) \neq (1,1).)No attempt is made to make the GCD monic.Requires that G have space for \operatorname{len}(B) coefficients. Writes \operatorname{len}(B)-1 and \operatorname{len}(A)-1 coefficients to S and T&, respectively. Note that, in fact, \operatorname{len}(S) \leq \max(\operatorname{len}(B) - \operatorname{len}(G), 1) and \operatorname{len}(T) \leq \max(\operatorname{len}(A) - \operatorname{len}(G), 1).6No aliasing of input and output operands is permitted.EFlint2fq_zech_poly_gcd_euclidean_f f G A B ctx  Either sets f = 1 and G# to the greatest common divisor of A and B or sets f to a factor of the modulus of ctx.EFlint2_fq_zech_poly_gcd_euclidean_f f G A lenA B lenB ctx  Either sets f = 1 and G$ to the greatest common divisor of (A,\operatorname{len}(A)) and (B, \operatorname{len}(B))" and returns its length, or sets f, to a non-trivial factor of the modulus of ctx' and leaves the contents of the vector  (G, lenB) undefined. Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0 and that the vector G. has space for sufficiently many coefficients.EFlint2_fq_zech_poly_gcd G A lenA B lenB ctx Computes the GCD of A of length lenA and B of length lenB , where lenA >= lenB > 0 and sets G to it. The length of the GCD G is returned by the function. No attempt is made to make the GCD monic. It is required that G have space for lenB coefficients.EFlint2fq_zech_poly_gcd rop op1 op2 ctx Sets rop# to the greatest common divisor of op1 and op2, using the either the Euclidean or HGCD algorithm. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic.EFlint2fq_zech_poly_div_series Q A B n ctx Set Q to the quotient of the series A by B8, thinking of the series as though they were of length n,. We assume that the bottom coefficient of B is invertible.EFlint2_fq_zech_poly_div_series Q A Alen B Blen n ctx Set (Q, n) to the quotient of the series (A, Alen) and  (B, Blen) assuming Alen, Blen <= n&. We assume the bottom coefficient of B is invertible.EFlint2fq_zech_poly_inv_series Qinv Q n ctx Given Q find Qinv such that Q * Qinv is 1 modulo x^n. The constant coefficient of Q+ must be invertible modulo the modulus of Q7. An exception is raised if this is not the case or if n = 0.EFlint2_fq_zech_poly_inv_series Qinv Q n ctx Given Q of length n whose constant coefficient is invertible modulo the given modulus, find a polynomial Qinv of length n such that Q * Qinv is 1 modulo x^n . Requires n > 0.EFlint2fq_zech_poly_inv_series_newton Qinv Q n ctx Given Q find Qinv such that Q * Qinv is 1 modulo x^n. The constant coefficient of Q+ must be invertible modulo the modulus of Q7. An exception is raised if this is not the case or if n = 0. This function can be viewed as inverting a power series via Newton iteration.EFlint2_fq_zech_poly_inv_series_newton Qinv Q n ctx Given Q of length n whose constant coefficient is invertible modulo the given modulus, find a polynomial Qinv of length n such that Q * Qinv is 1 modulo x^n . Requires n > 0. This function can be viewed as inverting a power series via Newton iteration.EFlint2#fq_zech_poly_divrem_newton_n_preinv Q R A B Binv ctx  Computes Q and R such that  A = BQ + R with (operatorname{len}(R) < operatorname{len}(B)). We assume Binv# is the inverse of the reverse of B mod x^{\operatorname{len}(B)}."It is required that the length of A+ is less than or equal to 2*the length of B - 2.The algorithm used is to call  div_newton2 and then multiply out and compute the remainder.EFlint2$_fq_zech_poly_divrem_newton_n_preinv Q R A lenA B lenB Binv lenBinv ctx  Computes Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB. We require that Q have space for lenA - lenB + 1+ coefficients. Furthermore, we assume that Binv# is the inverse of the reverse of B mod x^{\operatorname{len}(B)}!. The algorithm used is to call div_newton_preinv1 and then multiply out and compute the remainder.EFlint2 fq_zech_poly_div_newton_n_preinv Q A B Binv ctx Notionally computes Q and R such that  A = BQ + R with -\operatorname{len}(R) < \operatorname{len}(B), but returns only Q.*We assume that the leading coefficient of B is a unit and that Binv" is the inverse of the reverse of B mod x^{\operatorname{len}(B)}."It is required that the length of A+ is less than or equal to 2*the length of B - 2.The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.EFlint2!_fq_zech_poly_div_newton_n_preinv Q A lenA B lenB Binv lenBinv ctx_t  Notionally computes polynomials Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB, but return only Q.We require that Q have space for lenA - lenB + 1: coefficients and assume that the leading coefficient of B) is a unit. Furthermore, we assume that Binv" is the inverse of the reverse of B mod x^{\operatorname{len}(B)}.The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.EFlint2fq_zech_poly_div Q A B ctx Notionally finds polynomials Q and R such that  A = B Q + R with -\operatorname{len}(R) < \operatorname{len}(B), but returns only Q. If \operatorname{len}(B) = 0 an exception is raised.EFlint2_fq_zech_poly_div Q A lenA B lenB invB ctx Notationally, computes Q, R such that  A = B Q + R with (0 leq operatorname{len}(R) < operatorname{len}(B)) but only sets (Q, lenA - lenB + 1).Allows zero-padding in A but not in B+. Assumes that the leading coefficient of B is a unit.EFlint2fq_zech_poly_rem R A B ctx Sets R% to the remainder of the division of A by B in the context described by ctx.EFlint2_fq_zech_poly_rem R A lenA B lenB invB ctx Sets R% to the remainder of the division of (A,lenA) by (B,lenB)+. Assumes that the leading coefficient of (B,lenB) is invertible and that invB is its inverse.EFlint2fq_zech_poly_divrem_f f Q R A B ctx "Either finds a non-trivial factor f of the modulus of ctx, or computes Q, R such that  A = B Q + R and 40 \leq \operatorname{len}(R) < \operatorname{len}(B).If the leading coefficient of B is invertible, the division with remainder operation is carried out, Q and R are computed correctly, and f is set to 1 . Otherwise, f4 is set to a non-trivial factor of the modulus and Q and R are not touched. Assumes that B is non-zero.EFlint2fq_zech_poly_divrem Q R A B ctx  Computes Q, R such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B).(Assumes that the leading coefficient of B is invertible. This can be taken for granted the context is for a finite field, that is, when p is prime and f(X) is irreducible.EFlint2_fq_zech_poly_divrem Q R A lenA B lenB invB ctx  Computes (Q, lenA - lenB + 1),  (R, lenA) such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B).(Assumes that the leading coefficient of B is invertible and that invB is its inverse. Assumes that 0\operatorname{len}(A), \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA). R and A may be aliased, but apart from this no aliasing of input and output operands is allowed.EFlint2fq_zech_poly_hamming_weight op ctx 9Returns the number of non-zero entries in the polynomial op.EFlint2_fq_zech_poly_hamming_weight op len ctx *Returns the number of non-zero entries in  (op, len).EFlint2fq_zech_poly_shift_right rop op n ctx Sets rop to op shifted right by n coefficients. If n4 is equal to or greater than the current length of op, rop is set to the zero polynomial.EFlint2_fq_zech_poly_shift_right rop op len n ctx Sets (rop, len - n) to  (op, len) shifted right by n coefficients. Assumes that len and n are positive, that len > n , and that rop fits len - n% elements. Supports aliasing between rop and op1, although in this case the top coefficients of op are not set to zero.EFlint2fq_zech_poly_shift_left rop op n ctx Sets rop to op shifted left by n) coeffs. Zero coefficients are inserted.EFlint2_fq_zech_poly_shift_left rop op len n ctx Sets (rop, len + n) to  (op, len) shifted left by n coefficients.9Inserts zero coefficients at the lower end. Assumes that len and n are positive, and that rop fits len + n& elements. Supports aliasing between rop and op.EFlint2fq_zech_poly_pow_trunc res poly e trunc ctx Sets res to the low trunc coefficients of poly to the power e. This is equivalent to doing a powering followed by a truncation.EFlint2_fq_zech_poly_pow_trunc res poly e trunc mod Sets res to the low trunc coefficients of poly4 (assumed to be zero padded if necessary to length trunc) to the power e. This is equivalent to doing a powering followed by a truncation. We require that res has enough space for trunc coefficients, that  trunc > 0 and that e > 1. Aliasing is not permitted.EFlint2fq_zech_poly_pow_trunc_binexp res poly e trunc ctx Sets res to the low trunc coefficients of poly to the power e. This is equivalent to doing a powering followed by a truncation. Uses the binary exponentiation method.EFlint2_fq_zech_poly_pow_trunc_binexp res poly e trunc ctx Sets res to the low trunc coefficients of poly4 (assumed to be zero padded if necessary to length trunc) to the power e. This is equivalent to doing a powering followed by a truncation. We require that res has enough space for trunc coefficients, that  trunc > 0 and that e > 1. Aliasing is not permitted. Uses the binary exponentiation method.EFlint2!fq_zech_poly_powmod_x_fmpz_preinv res e f finv ctx Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.EFlint2"_fq_zech_poly_powmod_x_fmpz_preinv res e f lenf finv lenfinv ctx Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 2 . The output res must have room for lenf - 1 coefficients.EFlint2'fq_zech_poly_powmod_fmpz_sliding_preinv res poly e k f finv ctx Sets res to poly raised to the power e modulo f8, using sliding-window exponentiation with window size k . We require e >= 0. We require finv% to be the inverse of the reverse of f. If k is set to zero, then an "optimum" size will be selected automatically base on e.EFlint2(_fq_zech_poly_powmod_fmpz_sliding_preinv res poly e k f lenf finv lenfinv ctx Sets res to poly raised to the power e modulo f8, using sliding-window exponentiation with window size k . We require e > 0. We require finv% to be the inverse of the reverse of f. If k is set to zero, then an "optimum" size will be selected automatically base on e. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.EFlint2&fq_zech_poly_powmod_fmpz_binexp_preinv res poly e f finv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.EFlint2'_fq_zech_poly_powmod_fmpz_binexp_preinv res poly e f lenf finv lenfinv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.EFlint2fq_zech_poly_powmod_fmpz_binexp res poly e f ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.EFlint2 _fq_zech_poly_powmod_fmpz_binexp res poly e f lenf ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.EFlint2$fq_zech_poly_powmod_ui_binexp_preinv res poly e f finv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.EFlint2%_fq_zech_poly_powmod_ui_binexp_preinv res poly e f lenf finv lenfinv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.EFlint2fq_zech_poly_powmod_ui_binexp res poly e f ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.EFlint2_fq_zech_poly_powmod_ui_binexp res poly e f lenf ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.EFlint2fq_zech_poly_pow rop op e ctx  Computes  rop = op^e. If e. is zero, returns one, so that in particular 0^0 = 1.EFlint2_fq_zech_poly_pow rop op len e ctx Sets  rop = op^e, assuming that  e, len > 0 and that res has space for e*(len - 1) + 1) coefficients. Does not support aliasing.EFlint2fq_zech_poly_sqr rop op ctx Sets rop to the square of op$, choosing an appropriate algorithm.EFlint2_fq_zech_poly_sqr rop op len ctx Sets (rop, 2* len - 1) to the square of  (op, len)%, choosing an appropriate algorithm.0Permits zero padding. Does not support aliasing.EFlint2fq_zech_poly_sqr_KS rop op ctx Sets rop to the square op using Kronecker substitution, that is, by encoding each coefficient in \mathbf{F}_{q} as an integer and reducing this problem to multiplying two polynomials over the integers.EFlint2_fq_zech_poly_sqr_KS rop op len ctx Sets (rop, 2*len - 1) to the square of  (op, len).>Permits zero padding and places no assumptions on the lengths len1 and len2. Supports aliasing.EFlint2fq_zech_poly_sqr_classical rop op ctx Sets rop to the square of op, using classical polynomial multiplication.EFlint2_fq_zech_poly_sqr_classical rop op len ctx Sets (rop, 2*len - 1) to the square of  (op, len), assuming that (op,len); is not zero and using classical polynomial multiplication.3Permits zero padding. Does not support aliasing of rop with either op1 or op2.EFlint2fq_zech_poly_mulmod_preinv res poly1 poly2 f finv ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f. finv" is the inverse of the reverse of f.EFlint2_fq_zech_poly_mulmod_preinv res poly1 len1 poly2 len2 f lenf finv lenfinv ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.It is required that finv" is the inverse of the reverse of f mod x^lenf. Aliasing of res) with any of the inputs is not permitted.EFlint2fq_zech_poly_mulmod res poly1 poly2 f ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.EFlint2_fq_zech_poly_mulmod res poly1 len1 poly2 len2 f lenf ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.It is required that len1 + len2 - lenf > 0, which is equivalent to requiring that the result will actually be reduced. Otherwise, simply use _fq_zech_poly_mul instead. Aliasing of f and res is not permitted.FFlint2fq_zech_poly_mulhigh res poly1 poly2 start ctx Computes the product of poly1 and poly2# and writes the coefficients from start' onwards into the high coefficients of res:, the remaining coefficients being arbitrary but reduced.FFlint2_fq_zech_poly_mulhigh res poly1 len1 poly2 len2 start ctx Computes the product of  (poly1, len1) and  (poly2, len2)# and writes the coefficients from start( onwards into the high coefficients of res, the remaining coefficients being arbitrary but reduced. Assumes that len1 >= len2 > 01. Aliasing of inputs and output is not permitted.FFlint2fq_zech_poly_mulhigh_classical res poly1 poly2 start ctx Computes the product of poly1 and poly2# and writes the coefficients from start' onwards into the high coefficients of res, the remaining coefficients being arbitrary but reduced. Algorithm is classical multiplication.FFlint2_fq_zech_poly_mulhigh_classical res poly1 len1 poly2 len2 start ctx Computes the product of  (poly1, len1) and  (poly2, len2)# and writes the coefficients from start( onwards into the high coefficients of res, the remaining coefficients being arbitrary but reduced. Assumes that len1 >= len2 > 0. Aliasing of inputs and output is not permitted. Algorithm is classical multiplication.FFlint2fq_zech_poly_mullow rop op1 op2 n ctx Sets rop to the lowest n coefficients of the product of op1 and op2.FFlint2_fq_zech_poly_mullow rop op1 len1 op2 len2 n ctx Sets (rop, n) to the lowest n! coefficients of the product of  (op1, len1) and  (op2, len2).Assumes 0 < n <= len1 + len2 - 1. Allows for zero-padding in the inputs. Does not support aliasing between the inputs and the output.FFlint2fq_zech_poly_mullow_KS rop op1 op2 n ctx Sets rop to the product of op1 and op2.FFlint2_fq_zech_poly_mullow_KS rop op1 len1 op2 len2 n ctx Sets (rop, n) to the lowest n! coefficients of the product of  (op1, len1) and  (op2, len2). Assumes that len1 and len2 are positive, but does allow for the polynomials to be zero-padded. The polynomials may be zero, too. Assumes n( is positive. Supports aliasing between rop, op1 and op2.FFlint2fq_zech_poly_mullow_classical rop op1 op2 n ctx Sets rop to the product of op1 and op25, computed using the classical or schoolbook method.FFlint2_fq_zech_poly_mullow_classical rop op1 len1 op2 len2 n ctx Sets (rop, n) to the first n coefficients of  (op1, len1) multiplied by  (op2, len2).Assumes 0 < n <= len1 + len2 - 1. Assumes neither len1 nor len2 is zero.FFlint2fq_zech_poly_mul rop op1 op2 ctx Sets rop to the product of op1 and op2%, choosing an appropriate algorithm.FFlint2_fq_zech_poly_mul rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2)$, choosing an appropriate algorithm.0Permits zero padding. Does not support aliasing.FFlint2fq_zech_poly_mul_KS rop op1 op2 ctx Sets rop to the product of op1 and op2 using Kronecker substitution, that is, by encoding each coefficient in \mathbf{F}_{q} as an integer and reducing this problem to multiplying two polynomials over the integers.FFlint2_fq_zech_poly_mul_KS rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2).>Permits zero padding and places no assumptions on the lengths len1 and len2. Supports aliasing.FFlint2fq_zech_poly_mul_classical rop op1 op2 ctx Sets rop to the product of op1 and op2, using classical polynomial multiplication.FFlint2_fq_zech_poly_mul_classical rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2), assuming that len1 is at least len2 and neither is zero.3Permits zero padding. Does not support aliasing of rop with either op1 or op2.FFlint2"fq_zech_poly_scalar_submul_fq_zech rop op x ctx Subtracts from rop the product of op by the scalar x, in the context defined by ctx.FFlint2#_fq_zech_poly_scalar_submul_fq_zech rop op len x ctx Subtracts from  (rop,len) the product of (op,len) by the scalar x, in the context defined by ctx.. In particular, assumes the same length for op and rop.FFlint2"fq_zech_poly_scalar_addmul_fq_zech rop op x ctx Adds to rop the product of op by the scalar x, in the context defined by ctx.FFlint2#_fq_zech_poly_scalar_addmul_fq_zech rop op len x ctx Adds to  (rop,len) the product of (op,len) by the scalar x, in the context defined by ctx.. In particular, assumes the same length for op and rop.FFlint2fq_zech_poly_scalar_mul_fq_zech rop op x ctx Sets rop to the product of op by the scalar x, in the context defined by ctx.FFlint2 _fq_zech_poly_scalar_mul_fq_zech rop op len x ctx Sets  (rop,len) to the product of (op,len) by the scalar x, in the context defined by ctx.FFlint2fq_zech_poly_neg res poly ctx Sets res to the additive inverse of poly.FFlint2_fq_zech_poly_neg rop op len ctx Sets rop to the additive inverse of (op,len).FFlint2fq_zech_poly_sub_series res poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n and set res to the difference.FFlint2fq_zech_poly_sub res poly1 poly2 ctx Sets res to the difference of poly1 and poly2.FFlint2_fq_zech_poly_sub res poly1 len1 poly2 len2 ctx Sets res to the difference of  (poly1,len1) and  (poly2,len2).FFlint2fq_zech_poly_add_series res poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n and set res to the sum.FFlint2fq_zech_poly_add_si res poly1 c ctx Sets res to the sum of poly1 and c.FFlint2fq_zech_poly_add res poly1 poly2 ctx Sets res to the sum of poly1 and poly2.FFlint2_fq_zech_poly_add res poly1 len1 poly2 len2 ctx Sets res to the sum of  (poly1,len1) and  (poly2,len2).FFlint2fq_zech_poly_equal_fq_zech poly c ctx Returns whether the polynomial poly is equal the (constant)  \mathbf{F}_q element cFFlint2fq_zech_poly_is_unit op ctx Returns whether the polynomial poly# is a unit in the polynomial ring \mathbf{F}_q[X], i.e. if it has degree 0 and is non-zero.FFlint2fq_zech_poly_is_gen op ctx Returns whether the polynomial poly is equal to the polynomial x.FFlint2fq_zech_poly_is_one op Returns whether the polynomial poly& is equal to the constant polynomial 1.FFlint2fq_zech_poly_is_zero poly ctx Returns whether the polynomial poly is the zero polynomial.FFlint2fq_zech_poly_equal_trunc poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n> and return nonzero if they are equal, otherwise return zero.FFlint2fq_zech_poly_equal poly1 poly2 ctx 'Returns nonzero if the two polynomials poly1 and poly2# are equal, otherwise return zero.FFlint2fq_zech_poly_set_coeff_fmpz poly n x ctx Sets the coefficient of X^n in the polynomial to x , assuming n \geq 0.FFlint2fq_zech_poly_set_coeff poly n x ctx Sets the coefficient of X^n in poly to x.FFlint2fq_zech_poly_get_coeff x poly n ctx Sets x to the coefficient of X^n in poly.FFlint2_fq_zech_poly_make_monic rop op length ctx Sets rop to  (op,length)6, normed to have leading coefficient 1. Assumes that rop4 has enough space for the polynomial, assumes that op> is not zero (and thus has an invertible leading coefficient).FFlint2fq_zech_poly_make_monic rop op ctx Sets rop to op', normed to have leading coefficient 1.FFlint2fq_zech_poly_gen poly ctx Sets poly to the polynomial x.FFlint2fq_zech_poly_one poly ctx Sets poly to the constant polynomial 1.FFlint2fq_zech_poly_zero poly ctx Sets poly to the zero polynomial.FFlint2_fq_zech_poly_zero rop len ctx Sets  (rop, len) to the zero polynomial.FFlint2fq_zech_poly_swap op1 op2 ctx Swaps the two polynomials op1 and op2.FFlint2fq_zech_poly_set_nmod_poly rop op ctx Sets the polynomial rop to the polynomial opFFlint2fq_zech_poly_set_fmpz_mod_poly rop op ctx Sets the polynomial rop to the polynomial opFFlint2fq_zech_poly_set_fq_zech poly c ctx Sets the polynomial poly to c.FFlint2fq_zech_poly_set poly1 poly2 ctx Sets the polynomial poly1 to the polynomial poly2.FFlint2_fq_zech_poly_set rop op len ctx Sets  (rop, len) to  (op, len).FFlint2!fq_zech_poly_randtest_irreducible f state len ctx Sets f5 to a random monic, irreducible polynomial of length len) with entries in the field described by ctx.FFlint2fq_zech_poly_randtest_monic f state len ctx Sets f( to a random monic polynomial of length len) with entries in the field described by ctx.FFlint2fq_zech_poly_randtest_not_zero f state len ctx Same as fq_zech_poly_randtest1 but guarantees that the polynomial is not zero.FFlint2fq_zech_poly_randtest f state len ctx Sets f* to a random polynomial of length at most len) with entries in the field described by ctx.FFlint2fq_zech_poly_lead poly ctx 0Returns a pointer to the leading coefficient of poly, or NULL if poly is the zero polynomial.FFlint2fq_zech_poly_length poly ctx %Returns the length of the polynomial poly.FFlint2fq_zech_poly_degree poly ctx %Returns the degree of the polynomial poly.FFlint2fq_zech_poly_reverse output input m ctx Sets output to the reverse of input,, thinking of it as a polynomial of length m3, notionally zero-padded if necessary). The length m must be non-negative, but there are no other restrictions. The output polynomial will be set to length m and then normalised.FFlint2_fq_zech_poly_reverse output input len m ctx Sets output to the reverse of input, which is of length len0, but thinking of it as a polynomial of length m3, notionally zero-padded if necessary. The length m must be non-negative, but there are no other restrictions. The polynomial output must have space for m coefficients.FFlint2fq_zech_poly_set_trunc poly1 poly2 newlen ctx Sets poly1 to poly2 truncated to length n.FFlint2fq_zech_poly_truncate poly newlen ctx +Truncates the polynomial to length at most n.FFlint2_fq_zech_poly_normalise2 poly length ctx Sets the length length of  (poly,length) so that the top coefficient is non-zero. If all coefficients are zero, the length is set to zero. This function is mainly used internally, as all functions guarantee normalisation.FFlint2_fq_zech_poly_normalise poly ctx Sets the length of poly so that the top coefficient is non-zero. If all coefficients are zero, the length is set to zero. This function is mainly used internally, as all functions guarantee normalisation.FFlint2fq_zech_poly_clear poly ctx Clears the given polynomial, releasing any memory used. It must be reinitialised in order to be used again.FFlint2_fq_zech_poly_set_length poly newlen ctx Sets the coefficients of poly beyond len! to zero and sets the length of poly to len.FFlint2fq_zech_poly_fit_length poly len ctx If len is greater than the number of coefficients currently allocated, then the polynomial is reallocated to have space for at least len; coefficients. No data is lost when calling this function.3The function efficiently deals with the case where  fit_length is called many times in small increments by at least doubling the number of allocated coefficients when length is larger than the number of coefficients currently allocated.FFlint2fq_zech_poly_realloc poly alloc ctx 3Reallocates the given polynomial to have space for alloc coefficients. If alloc is zero the polynomial is cleared and then reinitialised. If the current length is greater than alloc. the polynomial is first truncated to length alloc.FFlint2fq_zech_poly_init2 poly alloc ctx  Initialises poly with space for at least alloc coefficients and sets the length to zero. The allocated coefficients are all set to zero. A corresponding call to fq_zech_poly_clear( must be made after finishing with the fq_zech_poly_t+ to free the memory used by the polynomial.FFlint2fq_zech_poly_init poly ctx  Initialises poly for use, with context ctx, and setting its length to zero. A corresponding call to fq_zech_poly_clear( must be made after finishing with the fq_zech_poly_t, to free the memory used by the polynomial.FFlint2fq_zech_poly_print_pretty poly x ctx $Prints the pretty representation of poly to stdout, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.FFlint2fq_zech_poly_print poly ctx Prints the representation of poly to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value.EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF~ Safe-Inferred )*1\EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFEEEFEEEEEEE Safe-Inferred )*1>FFlint2fq_zech_poly_roots r f with_multiplicity ctx Fill r with factors of the form x - r_i where the r_i& are the distinct roots of a nonzero f in F_q. If with\_multiplicity is zero, the exponent e_i of the factor x - r_i is 1. Otherwise, it is the largest e_i such that  (x-r_i)^e_i divides f. This function throws if f. is zero, but is otherwise always successful.FFlint2&fq_zech_poly_iterated_frobenius_preinv rop n v vinv ctx Sets rop[i] to be x^{q^i} \bmod v for  0 \le i < n.It is required that vinv" is the inverse of the reverse of v mod x^lenv.FFlint2'fq_zech_poly_factor_with_kaltofen_shoup res  leading_coeff f ctx  Factorises a general polynomial f* into monic irreducible factors and sets  leading_coeff to the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Kaltofen-Shoup on all the individual square-free factors.FFlint2*fq_zech_poly_factor_with_cantor_zassenhaus res  leading_coeff f ctx  Factorises a general polynomial f* into monic irreducible factors and sets  leading_coeff to the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Cantor-Zassenhaus on all the individual square-free factors.FFlint2"fq_zech_poly_factor_with_berlekamp res  leading_coeff f ctx  Factorises a general polynomial f* into monic irreducible factors and sets  leading_coeff to the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Berlekamp on all the individual square-free factors.FFlint2fq_zech_poly_factor_berlekamp factors f ctx %Factorises a non-constant polynomial f? into monic irreducible factors using the Berlekamp algorithm.FFlint2"fq_zech_poly_factor_kaltofen_shoup res poly ctx %Factorises a non-constant polynomial f into monic irreducible factors using the fast version of Cantor-Zassenhaus algorithm proposed by Kaltofen and Shoup (1998). More precisely this algorithm uses a @baby step/giant step@ strategy for the distinct-degree factorization step.FFlint2%fq_zech_poly_factor_cantor_zassenhaus res f ctx %Factorises a non-constant polynomial f into monic irreducible factors using the Cantor-Zassenhaus algorithm.FFlint2fq_zech_poly_factor res lead f ctx %Factorises a non-constant polynomial f into monic irreducible factors choosing the best algorithm for given modulo and degree. The output lead& is set to the leading coefficient of f upon return. Choice of algorithm is based on heuristic measurements.FFlint2fq_zech_poly_factor_squarefree res f ctx Sets res" to a squarefree factorization of f.FFlint2 fq_zech_poly_factor_distinct_deg res poly degs ctx 6Factorises a monic non-constant squarefree polynomial poly of degree n into factors f[d] such that for 1 \leq d \leq n f[d]5 is the product of the monic irreducible factors of poly of degree d. Factors are stored in res>, associated powers of irreducible polynomials are stored in degs in the same order as factors.Requires that degs have enough space for irreducible polynomials' powers (maximum space required is n * sizeof(slong)).FFlint2 fq_zech_poly_factor_split_single  linfactor input ctx  Assuming input is a product of factors all of degree 1, finds a single linear factor of input and places it in  linfactor. Requires that input be monic and non-constant.FFlint2fq_zech_poly_factor_equal_deg factors pol d ctx  Assuming pol3 is a product of irreducible factors all of degree d, finds all those factors and places them in factors. Requires that pol( be monic, non-constant and squarefree.FFlint2"fq_zech_poly_factor_equal_deg_prob factor state pol d ctx ,Probabilistic equal degree factorisation of pol% into irreducible factors of degree d. If it passes, a factor is placed in factor and 1 is returned, otherwise 0 is returned and the value of factor is undetermined.Requires that pol' be monic, non-constant and squarefree.FFlint2fq_zech_poly_is_squarefree f ctx  Returns 1 if f is squarefree, and 0 otherwise. As a special case, the zero polynomial is not considered squarefree.FFlint2_fq_zech_poly_is_squarefree f len ctx  Returns 1 if (f, len) is squarefree, and 0 otherwise. As a special case, the zero polynomial is not considered squarefree. There are no restrictions on the length.FFlint2"fq_zech_poly_is_irreducible_ben_or f ctx Returns 1 if the polynomial f is irreducible, otherwise returns 0. Uses Ben-Or's irreducibility test.FFlint2fq_zech_poly_is_irreducible_ddf f ctx Returns 1 if the polynomial f is irreducible, otherwise returns 0. Uses fast distinct-degree factorisation.FFlint2fq_zech_poly_is_irreducible f ctx Returns 1 if the polynomial f% is irreducible, otherwise returns 0.FFlint2fq_zech_poly_remove f p ctx &Removes the highest possible power of p from f and returns the exponent.FFlint2fq_zech_poly_factor_pow fac exp ctx Raises fac to the power exp.FFlint2fq_zech_poly_factor_concat res fac ctx  Concatenates two factorisations.This is equivalent to calling fq_zech_poly_factor_insert(), repeatedly with the individual factors of fac."Does not support aliasing between res and fac.FFlint2fq_zech_poly_factor_insert fac poly exp ctx Inserts the factor poly with multiplicity exp into the factorisation fac.If fac already contains poly, then exp: simply gets added to the exponent of the existing entry.FFlint2fq_zech_poly_factor_set res fac ctx Sets res to the same factorisation as fac.FFlint2fq_zech_poly_factor_fit_length fac len ctx 9Ensures that the factor structure has space for at least len factors. This function takes care of the case of repeated calls by always at least doubling the number of factors the structure can hold.FFlint2fq_zech_poly_factor_realloc fac alloc ctx Reallocates the factor structure to provide space for precisely alloc factors.FFlint2fq_zech_poly_factor_clear fac ctx !Frees all memory associated with fac.FFlint2fq_zech_poly_factor_init fac ctx  Initialises fac for use. An fq_zech_poly_factor_t represents a polynomial in factorised form as a product of polynomials with associated exponents.FFlint2 fq_zech_poly_factor_print_pretty fac var ctx Pretty-prints the entries of fac to standard output.FFlint2fq_zech_poly_factor_print fac ctx Prints the entries of fac to standard output.$FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF Safe-Inferred )*1$FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF$FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF Safe-Inferred )*10FFlint2 fq_poly_roots r f with_multiplicity ctx Fill r with factors of the form x - r_i where the r_i& are the distinct roots of a nonzero f in F_q. If with\_multiplicity is zero, the exponent e_i of the factor x - r_i is 1. Otherwise, it is the largest e_i such that  (x-r_i)^e_i divides f. This function throws if f. is zero, but is otherwise always successful.FFlint2!fq_poly_iterated_frobenius_preinv rop n v vinv ctx Sets rop[i] to be x^{q^i}\bmod v for  0 \le i < n.It is required that vinv" is the inverse of the reverse of v mod x^lenv.FFlint2"fq_poly_factor_with_kaltofen_shoup res  leading_coeff f ctx  Factorises a general polynomial f* into monic irreducible factors and sets  leading_coeff to the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Kaltofen-Shoup on all the individual square-free factors.FFlint2%fq_poly_factor_with_cantor_zassenhaus res  leading_coeff f ctx  Factorises a general polynomial f* into monic irreducible factors and sets  leading_coeff to the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Cantor-Zassenhaus on all the individual square-free factors.FFlint2fq_poly_factor_with_berlekamp res  leading_coeff f ctx  Factorises a general polynomial f* into monic irreducible factors and sets  leading_coeff to the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Berlekamp factorisation on all the individual square-free factors.FFlint2fq_poly_factor_berlekamp factors f ctx %Factorises a non-constant polynomial f? into monic irreducible factors using the Berlekamp algorithm.FFlint2fq_poly_factor_kaltofen_shoup res poly ctx %Factorises a non-constant polynomial f into monic irreducible factors using the fast version of Cantor-Zassenhaus algorithm proposed by Kaltofen and Shoup (1998). More precisely this algorithm uses a @baby step/giant step@ strategy for the distinct-degree factorization step.FFlint2 fq_poly_factor_cantor_zassenhaus res f ctx %Factorises a non-constant polynomial f into monic irreducible factors using the Cantor-Zassenhaus algorithm.FFlint2fq_poly_factor res lead f ctx %Factorises a non-constant polynomial f into monic irreducible factors choosing the best algorithm for given modulo and degree. The output lead& is set to the leading coefficient of f upon return. Choice of algorithm is based on heuristic measurements.FFlint2fq_poly_factor_squarefree res f ctx Sets res" to a squarefree factorization of f.FFlint2fq_poly_factor_distinct_deg res poly degs ctx 6Factorises a monic non-constant squarefree polynomial poly of degree n into factors f[d] such that for 1 \leq d \leq n f[d]5 is the product of the monic irreducible factors of poly of degree d. Factors are stored in res>, associated powers of irreducible polynomials are stored in degs in the same order as factors.Requires that degs have enough space for irreducible polynomials' powers (maximum space required is n * sizeof(slong)).FFlint2fq_poly_factor_split_single  linfactor input ctx  Assuming input is a product of factors all of degree 1, finds a single linear factor of input and places it in  linfactor. Requires that input be monic and non-constant.FFlint2fq_poly_factor_equal_deg factors pol d ctx  Assuming pol3 is a product of irreducible factors all of degree d, finds all those factors and places them in factors. Requires that pol( be monic, non-constant and squarefree.FFlint2fq_poly_factor_equal_deg_prob factor state pol d ctx ,Probabilistic equal degree factorisation of pol% into irreducible factors of degree d. If it passes, a factor is placed in factor and 1 is returned, otherwise 0 is returned and the value of factor is undetermined.Requires that pol' be monic, non-constant and squarefree.FFlint2fq_poly_is_squarefree f ctx  Returns 1 if f is squarefree, and 0 otherwise. As a special case, the zero polynomial is not considered squarefree.FFlint2_fq_poly_is_squarefree f len ctx  Returns 1 if (f, len) is squarefree, and 0 otherwise. As a special case, the zero polynomial is not considered squarefree. There are no restrictions on the length.GFlint2fq_poly_is_irreducible_ben_or f ctx Returns 1 if the polynomial f is irreducible, otherwise returns 0. Uses Ben-Or's irreducibility test.GFlint2fq_poly_is_irreducible_ddf f ctx Returns 1 if the polynomial f is irreducible, otherwise returns 0. Uses fast distinct-degree factorisation.GFlint2fq_poly_is_irreducible f ctx Returns 1 if the polynomial f% is irreducible, otherwise returns 0.GFlint2fq_poly_remove f p ctx &Removes the highest possible power of p from f and returns the exponent.GFlint2fq_poly_factor_pow fac exp ctx Raises fac to the power exp.GFlint2fq_poly_factor_concat res fac ctx  Concatenates two factorisations.This is equivalent to calling fq_poly_factor_insert, repeatedly with the individual factors of fac."Does not support aliasing between res and fac.GFlint2fq_poly_factor_insert fac poly exp ctx Inserts the factor poly with multiplicity exp into the factorisation fac.If fac already contains poly, then exp: simply gets added to the exponent of the existing entry.GFlint2fq_poly_factor_set res fac ctx Sets res to the same factorisation as fac.GFlint2fq_poly_factor_fit_length fac len ctx 9Ensures that the factor structure has space for at least len factors. This function takes care of the case of repeated calls by always at least doubling the number of factors the structure can hold.GFlint2fq_poly_factor_realloc fac alloc ctx Reallocates the factor structure to provide space for precisely alloc factors.GFlint2fq_poly_factor_clear fac ctx !Frees all memory associated with fac.GFlint2fq_poly_factor_init fac ctx  Initialises fac for use. An fq_poly_factor_t represents a polynomial in factorised form as a product of polynomials with associated exponents.GFlint2fq_poly_factor_print_pretty fac var ctx Pretty-prints the entries of fac to standard output.GFlint2fq_poly_factor_print fac ctx Prints the entries of fac to standard output.%FFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGG Safe-Inferred )*11]%FFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGG%FFFFGGGGGGGGGGGGGGGGGFFFFFFFFFFFFFFFF Safe-Inferred )*1 GFlint2fq_nmod_poly_deflation input ctx %Returns the largest integer by which input2 can be deflated. As special cases, returns 0 if input! is the zero polynomial and 1 of input is a constant polynomial.GFlint2fq_nmod_poly_deflate result input  deflation ctx Sets result to the deflated polynomial  p(x^{1/n}) where p is given by input and n is given by  deflation . Requires n > 0.GFlint2fq_nmod_poly_inflate result input  inflation ctx Sets result to the inflated polynomial p(x^n) where p is given by input and n is given by  inflation.GFlint2fq_nmod_poly_get_str_pretty poly x ctx 2Returns a pretty representation of the polynomial poly# using the null-terminated string x as the variable nameGFlint2_fq_nmod_poly_get_str_pretty poly len x ctx 2Returns a pretty representation of the polynomial  (poly, len)# using the null-terminated string x as the variable name.GFlint2fq_nmod_poly_get_str poly ctx Returns the plain FLINT string representation of the polynomial poly.GFlint2_fq_nmod_poly_get_str poly len ctx Returns the plain FLINT string representation of the polynomial  (poly, len).GFlint2_fq_nmod_poly_print poly len ctx $Prints the pretty representation of  (poly, len) to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value.GFlint2fq_nmod_poly_fprint file poly ctx $Prints the pretty representation of poly to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.GFlint2_fq_nmod_poly_fprint file poly len ctx $Prints the pretty representation of  (poly, len) to the stream file.In case of success, returns a positive value. In case of failure, returns a non-positive value.GFlint2_fq_nmod_poly_print_pretty poly len x ctx $Prints the pretty representation of  (poly, len) to stdout, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.GFlint2fq_nmod_poly_fprint_pretty file poly x ctx $Prints the pretty representation of poly to the stream file, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.GFlint2_fq_nmod_poly_fprint_pretty file poly len x ctx $Prints the pretty representation of  (poly, len) to the stream file, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.GFlint22fq_nmod_poly_compose_mod_brent_kung_precomp_preinv res f A h hinv ctx Sets res to the composition f(g) modulo h". We require that the ith row of A contains g^i for i=1,\ldots,\sqrt{\deg(h)}, i.e. A: is a (sqrt{deg(h)}times deg(h)) matrix. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv& to be the inverse of the reverse of h. This version of Brent-Kung modular composition is particularly useful if one has to perform several modular composition of the form f(g) modulo h for fixed g and h.GFlint23_fq_nmod_poly_compose_mod_brent_kung_precomp_preinv res f lenf A h lenh hinv lenhinv ctx Sets res to the composition f(g) modulo h. We require that h, is nonzero. We require that the ith row of A contains g^i for i=1,\ldots,\sqrt{\deg(h)}, i.e. A is a \sqrt{\deg(h)}\times \deg(h)- matrix. We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.GFlint2fq_nmod_poly_precompute_matrix A f g ginv ctx Sets the ith row of A to f^i modulo g for i=1,\ldots,\sqrt{\deg(g)} . We require A to be a \sqrt{\deg(g)}\times \deg(g) matrix. We require ginv& to be the inverse of the reverse of g.GFlint2_fq_nmod_poly_precompute_matrix A f g leng ginv lenginv ctx Sets the ith row of A to f^i modulo g for i=1,\ldots,\sqrt{\deg(g)} . We require A to be a \sqrt{\deg(g)}\times \deg(g) matrix. We require ginv& to be the inverse of the reverse of g and g to be nonzero.GFlint2$_fq_nmod_poly_reduce_matrix_mod_poly A B f ctx Sets the ith row of A$ to the reduction of the ith row of B modulo f for i=1,\ldots,\sqrt{\deg(f)} . We require B to be at least a \sqrt{\deg(f)}\times \deg(f) matrix and f to be nonzero.GFlint2fq_nmod_poly_compose_mod_preinv res f g h hinv ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h.GFlint2 _fq_nmod_poly_compose_mod_preinv res f lenf g h lenh hinv lenhiv ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.GFlint2fq_nmod_poly_compose_mod res f g h ctx Sets res to the composition f(g) modulo h. We require that h is nonzero.GFlint2_fq_nmod_poly_compose_mod res f lenf g h lenh ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.GFlint2*fq_nmod_poly_compose_mod_brent_kung_preinv res f g h hinv ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h9. The algorithm used is the Brent-Kung matrix algorithm.GFlint2+_fq_nmod_poly_compose_mod_brent_kung_preinv res f lenf g h lenh hinv lenhiv ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.GFlint2#fq_nmod_poly_compose_mod_brent_kung res f g h ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h9. The algorithm used is the Brent-Kung matrix algorithm.GFlint2$_fq_nmod_poly_compose_mod_brent_kung res f lenf g h lenh ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. The output is not allowed to be aliased with any of the inputs.6The algorithm used is the Brent-Kung matrix algorithm.GFlint2&fq_nmod_poly_compose_mod_horner_preinv res f g h hinv ctx Sets res to the composition f(g) modulo h. We require that h is nonzero and that f has smaller degree than h. Furthermore, we require hinv% to be the inverse of the reverse of h'. The algorithm used is Horner's rule.GFlint2'_fq_nmod_poly_compose_mod_horner_preinv res f lenf g h lenh hinv lenhiv ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). We also require that the length of f is less than the length of h. Furthermore, we require hinv% to be the inverse of the reverse of h. The output is not allowed to be aliased with any of the inputs.$The algorithm used is Horner's rule.GFlint2fq_nmod_poly_compose_mod_horner res f g h ctx Sets res to the composition f(g) modulo h. We require that h1 is nonzero. The algorithm used is Horner's rule.GFlint2 _fq_nmod_poly_compose_mod_horner res f lenf g h lenh ctx Sets res to the composition f(g) modulo h. We require that h# is nonzero and that the length of g! is one less than the length of h (possibly with zero padding). The output is not allowed to be aliased with any of the inputs.$The algorithm used is Horner's rule.GFlint2fq_nmod_poly_compose rop op1 op2 ctx Sets rop to the composition of op1 and op2:. To be precise about the order of composition, denoting rop, op1, and op2 by f, g, and h, respectively, sets f(t) = g(h(t)).GFlint2_fq_nmod_poly_compose rop op1 len1 op2 len2 ctx Sets rop to the composition of  (op1, len1) and  (op2, len2). Assumes that rop has space for (len1-1)*(len2-1) + 1 coefficients. Assumes that op1 and op2 are non-zero polynomials. Does not support aliasing between any of the inputs and the output.GFlint2fq_nmod_poly_evaluate_fq_nmod rop f a ctx Sets rop to the value of f(a).As the coefficient ring  \mathbf{F}_q+ is finite, Horner's method is sufficient.GFlint2_fq_nmod_poly_evaluate_fq_nmod rop op len a ctx Sets rop to  (op, len) evaluated at a.4Supports zero padding. There are no restrictions on len , that is, len is allowed to be zero, too.GFlint2fq_nmod_poly_sqrt s p mod If p is a perfect square, sets s to a square root of p% and returns 1. Otherwise returns 0.GFlint2_fq_nmod_poly_sqrt s p n mod If (p, n) is a perfect square, sets (s, n / 2 + 1) to a square root of p$ and returns 1. Otherwise returns 0.GFlint2fq_nmod_poly_sqrt_series g h n ctx Set g to the series expansion of \sqrt{h} to order O(x^n). It is assumed that h has constant term 1.GFlint2_fq_nmod_poly_sqrt_series g h n ctx Set the first n terms of g to the series expansion of \sqrt{h}. It is assumed that n > 0, that h has constant term 1 and that h' is zero-padded as necessary to length n. Aliasing is not permitted.GFlint2fq_nmod_poly_invsqrt_series g h n ctx Set g to the series expansion of  1/\sqrt{h} to order O(x^n). It is assumed that h has constant term 1.GFlint2_fq_nmod_poly_invsqrt_series g h n mod Set the first n terms of g to the series expansion of  1/\sqrt{h}. It is assumed that n > 0, that h has constant term 1 and that h' is zero-padded as necessary to length n. Aliasing is not permitted.GFlint2fq_nmod_poly_derivative rop op ctx Sets rop to the derivative of op.GFlint2_fq_nmod_poly_derivative rop op len ctx Sets (rop, len - 1) to the derivative of  (op, len) . Also handles the cases where len is 0 or 1" correctly. Supports aliasing of rop and op.GFlint2fq_nmod_poly_divides Q A B ctx Returns 1 if B divides A exactly and sets Q% to the quotient, otherwise returns 0.This function is currently unoptimised and provided for convenience only.GFlint2_fq_nmod_poly_divides Q A lenA B lenB invB ctx Returns 1 if  (B, lenB) divides  (A, lenA) exactly and sets Q% to the quotient, otherwise returns 0.It is assumed that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0 and that Q has space for 1\operatorname{len}(A) - \operatorname{len}(B) + 1 coefficients. Aliasing of Q, with either of the inputs is not permitted.This function is currently unoptimised and provided for convenience only.GFlint2fq_nmod_poly_xgcd_euclidean_f f G S T A B ctx  Either sets f = 1 and computes the GCD of A and B or sets f+ to a non-trivial factor of the modulus of ctx.$If the GCD is computed, polynomials S and T are computed such that  S*A + T*B = G/; otherwise, they are undefined. The length of S will be at most lenB and the length of T will be at most lenA.The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P4. Except in the case where the GCD is zero, the GCD G is made monic.GFlint2_fq_nmod_poly_xgcd_euclidean_f f G S T A lenA B lenB invB ctx  Either sets f = 1 and computes the GCD of A and B together with cofactors S and T such that  S A + T B = G; otherwise, sets f+ to a non-trivial factor of the modulus of ctx and leaves G, S, and T" undefined. Returns the length of G. Assumes that 7\operatorname{len}(A) \geq \operatorname{len}(B) \geq 1 and 8(\operatorname{len}(A),\operatorname{len}(B)) \neq (1,1).)No attempt is made to make the GCD monic.Requires that G have space for \operatorname{len}(B) coefficients. Writes \operatorname{len}(B)-1 and \operatorname{len}(A)-1 coefficients to S and T&, respectively. Note that, in fact, \operatorname{len}(S) \leq \max(\operatorname{len}(B) - \operatorname{len}(G), 1) and \operatorname{len}(T) \leq \max(\operatorname{len}(A) - \operatorname{len}(G), 1).6No aliasing of input and output operands is permitted.GFlint2fq_nmod_poly_xgcd G S T A B ctx Computes the GCD of A and B. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic. Polynomials S and T are computed such that  S*A + T*B = G. The length of S will be at most lenB and the length of T will be at most lenA.GFlint2_fq_nmod_poly_xgcd G S T A lenA B lenB ctx Computes the GCD of A and B together with cofactors S and T such that  S A + T B = G. Returns the length of G. Assumes that 7\operatorname{len}(A) \geq \operatorname{len}(B) \geq 1 and 8(\operatorname{len}(A),\operatorname{len}(B)) \neq (1,1).)No attempt is made to make the GCD monic.Requires that G have space for \operatorname{len}(B) coefficients. Writes \operatorname{len}(B)-1 and \operatorname{len}(A)-1 coefficients to S and T&, respectively. Note that, in fact, \operatorname{len}(S) \leq \max(\operatorname{len}(B) - \operatorname{len}(G), 1) and \operatorname{len}(T) \leq \max(\operatorname{len}(A) - \operatorname{len}(G), 1).6No aliasing of input and output operands is permitted.GFlint2fq_nmod_poly_gcd_euclidean_f f G A B ctx  Either sets f = 1 and G# to the greatest common divisor of A and B or sets f to a factor of the modulus of ctx.GFlint2_fq_nmod_poly_gcd_euclidean_f f G A lenA B lenB ctx  Either sets f = 1 and G$ to the greatest common divisor of (A,\operatorname{len}(A)) and (B, \operatorname{len}(B))" and returns its length, or sets f, to a non-trivial factor of the modulus of ctx' and leaves the contents of the vector  (G, lenB) undefined. Assumes that 4\operatorname{len}(A) \geq \operatorname{len}(B) > 0 and that the vector G. has space for sufficiently many coefficients.GFlint2_fq_nmod_poly_gcd G A lenA B lenB ctx Computes the GCD of A of length lenA and B of length lenB , where lenA >= lenB > 0 and sets G to it. The length of the GCD G is returned by the function. No attempt is made to make the GCD monic. It is required that G have space for lenB coefficients.GFlint2fq_nmod_poly_gcd rop op1 op2 ctx Sets rop# to the greatest common divisor of op1 and op2, using the either the Euclidean or HGCD algorithm. The GCD of zero polynomials is defined to be zero, whereas the GCD of the zero polynomial and some other polynomial P is defined to be P5. Except in the case where the GCD is zero, the GCD G is made monic.GFlint2fq_nmod_poly_div_series Q A B n ctx Set Q to the quotient of the series A by B8, thinking of the series as though they were of length n,. We assume that the bottom coefficient of B is invertible.GFlint2_fq_nmod_poly_div_series Q A Alen B Blen n ctx Set (Q, n) to the quotient of the series (A, Alen) and  (B, Blen) assuming Alen, Blen <= n&. We assume the bottom coefficient of B is invertible.GFlint2fq_nmod_poly_inv_series Qinv Q n ctx Given Q find Qinv such that Q * Qinv is 1 modulo x^n. The constant coefficient of Q+ must be invertible modulo the modulus of Q7. An exception is raised if this is not the case or if n = 0.GFlint2_fq_nmod_poly_inv_series Qinv Q n ctx Given Q of length n whose constant coefficient is invertible modulo the given modulus, find a polynomial Qinv of length n such that Q * Qinv is 1 modulo x^n . Requires n > 0.GFlint2fq_nmod_poly_inv_series_newton Qinv Q n ctx Given Q find Qinv such that Q * Qinv is 1 modulo x^n. The constant coefficient of Q+ must be invertible modulo the modulus of Q7. An exception is raised if this is not the case or if n = 0. This function can be viewed as inverting a power series via Newton iteration.GFlint2_fq_nmod_poly_inv_series_newton Qinv Q n ctx Given Q of length n whose constant coefficient is invertible modulo the given modulus, find a polynomial Qinv of length n such that Q * Qinv is 1 modulo x^n . Requires n > 0. This function can be viewed as inverting a power series via Newton iteration.GFlint2#fq_nmod_poly_divrem_newton_n_preinv Q R A B Binv ctx  Computes Q and R such that  A = BQ + R with (operatorname{len}(R) < operatorname{len}(B)). We assume Binv# is the inverse of the reverse of B mod x^{\operatorname{len}(B)}."It is required that the length of A+ is less than or equal to 2*the length of B - 2.The algorithm used is to call  div_newton2 and then multiply out and compute the remainder.GFlint2$_fq_nmod_poly_divrem_newton_n_preinv Q R A lenA B lenB Binv lenBinv ctx  Computes Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB. We require that Q have space for lenA - lenB + 1+ coefficients. Furthermore, we assume that Binv# is the inverse of the reverse of B mod x^{\operatorname{len}(B)}!. The algorithm used is to call div_newton_preinv1 and then multiply out and compute the remainder.GFlint2 fq_nmod_poly_div_newton_n_preinv Q A B Binv ctx Notionally computes Q and R such that  A = BQ + R with -\operatorname{len}(R) < \operatorname{len}(B), but returns only Q.*We assume that the leading coefficient of B is a unit and that Binv" is the inverse of the reverse of B mod x^{\operatorname{len}(B)}."It is required that the length of A+ is less than or equal to 2*the length of B - 2.The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.GFlint2!_fq_nmod_poly_div_newton_n_preinv Q A lenA B lenB Binv lenBinv ctx_t  Notionally computes polynomials Q and R such that  A = BQ + R with \operatorname{len}(R) less than lenB, where A is of length lenA and B is of length lenB, but return only Q.We require that Q have space for lenA - lenB + 1: coefficients and assume that the leading coefficient of B) is a unit. Furthermore, we assume that Binv" is the inverse of the reverse of B mod x^{\operatorname{len}(B)}.The algorithm used is to reverse the polynomials and divide the resulting power series, then reverse the result.GFlint2fq_nmod_poly_div Q A B ctx Notionally finds polynomials Q and R such that  A = B Q + R with -\operatorname{len}(R) < \operatorname{len}(B), but returns only Q. If \operatorname{len}(B) = 0 an exception is raised.GFlint2_fq_nmod_poly_div Q A lenA B lenB invB ctx Notationally, computes Q, R such that  A = B Q + R with (0 leq operatorname{len}(R) < operatorname{len}(B)) but only sets (Q, lenA - lenB + 1).Allows zero-padding in A but not in B+. Assumes that the leading coefficient of B is a unit.GFlint2fq_nmod_poly_rem R A B ctx Sets R% to the remainder of the division of A by B in the context described by ctx.GFlint2_fq_nmod_poly_rem R A lenA B lenB invB ctx Sets R% to the remainder of the division of (A,lenA) by (B,lenB)+. Assumes that the leading coefficient of (B,lenB) is invertible and that invB is its inverse.GFlint2fq_nmod_poly_divrem_f f Q R A B ctx "Either finds a non-trivial factor f of the modulus of ctx, or computes Q, R such that  A = B Q + R and 40 \leq \operatorname{len}(R) < \operatorname{len}(B).If the leading coefficient of B is invertible, the division with remainder operation is carried out, Q and R are computed correctly, and f is set to 1 . Otherwise, f4 is set to a non-trivial factor of the modulus and Q and R are not touched. Assumes that B is non-zero.GFlint2fq_nmod_poly_divrem Q R A B ctx  Computes Q, R such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B).(Assumes that the leading coefficient of B is invertible. This can be taken for granted the context is for a finite field, that is, when p is prime and f(X) is irreducible.GFlint2_fq_nmod_poly_divrem Q R A lenA B lenB invB ctx  Computes (Q, lenA - lenB + 1),  (R, lenA) such that  A = B Q + R with 40 \leq \operatorname{len}(R) < \operatorname{len}(B).(Assumes that the leading coefficient of B is invertible and that invB is its inverse. Assumes that 0\operatorname{len}(A), \operatorname{len}(B) > 0. Allows zero-padding in  (A, lenA). R and A may be aliased, but apart from this no aliasing of input and output operands is allowed.GFlint2fq_nmod_poly_hamming_weight op ctx 9Returns the number of non-zero entries in the polynomial op.GFlint2_fq_nmod_poly_hamming_weight op len ctx *Returns the number of non-zero entries in  (op, len).GFlint2fq_nmod_poly_shift_right rop op n ctx Sets rop to op shifted right by n coefficients. If n4 is equal to or greater than the current length of op, rop is set to the zero polynomial.GFlint2_fq_nmod_poly_shift_right rop op len n ctx Sets (rop, len - n) to  (op, len) shifted right by n coefficients. Assumes that len and n are positive, that len > n , and that rop fits len - n% elements. Supports aliasing between rop and op1, although in this case the top coefficients of op are not set to zero.GFlint2fq_nmod_poly_shift_left rop op n ctx Sets rop to op shifted left by n) coeffs. Zero coefficients are inserted.GFlint2_fq_nmod_poly_shift_left rop op len n ctx Sets (rop, len + n) to  (op, len) shifted left by n coefficients.9Inserts zero coefficients at the lower end. Assumes that len and n are positive, and that rop fits len + n& elements. Supports aliasing between rop and op.GFlint2fq_nmod_poly_pow_trunc res poly e trunc ctx Sets res to the low trunc coefficients of poly to the power e. This is equivalent to doing a powering followed by a truncation.GFlint2_fq_nmod_poly_pow_trunc res poly e trunc mod Sets res to the low trunc coefficients of poly4 (assumed to be zero padded if necessary to length trunc) to the power e. This is equivalent to doing a powering followed by a truncation. We require that res has enough space for trunc coefficients, that  trunc > 0 and that e > 1. Aliasing is not permitted.GFlint2fq_nmod_poly_pow_trunc_binexp res poly e trunc ctx Sets res to the low trunc coefficients of poly to the power e. This is equivalent to doing a powering followed by a truncation. Uses the binary exponentiation method.GFlint2_fq_nmod_poly_pow_trunc_binexp res poly e trunc ctx Sets res to the low trunc coefficients of poly4 (assumed to be zero padded if necessary to length trunc) to the power e. This is equivalent to doing a powering followed by a truncation. We require that res has enough space for trunc coefficients, that  trunc > 0 and that e > 1. Aliasing is not permitted. Uses the binary exponentiation method.GFlint2!fq_nmod_poly_powmod_x_fmpz_preinv res e f finv ctx Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.GFlint2"_fq_nmod_poly_powmod_x_fmpz_preinv res e f lenf finv lenfinv ctx Sets res to x raised to the power e modulo f3, using sliding window exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 2 . The output res must have room for lenf - 1 coefficients.GFlint2'fq_nmod_poly_powmod_fmpz_sliding_preinv res poly e k f finv ctx Sets res to poly raised to the power e modulo f8, using sliding-window exponentiation with window size k . We require e >= 0. We require finv% to be the inverse of the reverse of f. If k is set to zero, then an "optimum" size will be selected automatically base on e.GFlint2(_fq_nmod_poly_powmod_fmpz_sliding_preinv res poly e k f lenf finv lenfinv ctx Sets res to poly raised to the power e modulo f8, using sliding-window exponentiation with window size k . We require e > 0. We require finv% to be the inverse of the reverse of f. If k is set to zero, then an "optimum" size will be selected automatically base on e. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.GFlint2&fq_nmod_poly_powmod_fmpz_binexp_preinv res poly e f finv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.GFlint2'_fq_nmod_poly_powmod_fmpz_binexp_preinv res poly e f lenf finv lenfinv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.GFlint2fq_nmod_poly_powmod_fmpz_binexp res poly e f ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.GFlint2 _fq_nmod_poly_powmod_fmpz_binexp res poly e f lenf ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.GFlint2$fq_nmod_poly_powmod_ui_binexp_preinv res poly e f finv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0 . We require finv& to be the inverse of the reverse of f.GFlint2%_fq_nmod_poly_powmod_ui_binexp_preinv res poly e f lenf finv lenfinv ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0 . We require finv& to be the inverse of the reverse of f. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.GFlint2fq_nmod_poly_powmod_ui_binexp res poly e f ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e >= 0.GFlint2_fq_nmod_poly_powmod_ui_binexp res poly e f lenf ctx Sets res to poly raised to the power e modulo f+, using binary exponentiation. We require e > 0. We require lenf > 1. It is assumed that poly is already reduced modulo f6 and zero-padded as necessary to have length exactly lenf - 1 . The output res must have room for lenf - 1 coefficients.GFlint2fq_nmod_poly_pow rop op e ctx  Computes  rop = op^e. If e. is zero, returns one, so that in particular 0^0 = 1.GFlint2_fq_nmod_poly_pow rop op len e ctx Sets  rop = op^e, assuming that  e, len > 0 and that rop has space for e*(len - 1) + 1) coefficients. Does not support aliasing.GFlint2fq_nmod_poly_sqr rop op ctx Sets rop to the square of op$, choosing an appropriate algorithm.GFlint2_fq_nmod_poly_sqr rop op len ctx Sets (rop, 2* len - 1) to the square of  (op, len)%, choosing an appropriate algorithm.0Permits zero padding. Does not support aliasing.GFlint2fq_nmod_poly_sqr_KS rop op ctx Sets rop to the square op using Kronecker substitution, that is, by encoding each coefficient in \mathbf{F}_{q} as an integer and reducing this problem to multiplying two polynomials over the integers.GFlint2_fq_nmod_poly_sqr_KS rop op len ctx Sets (rop, 2*len - 1) to the square of  (op, len).>Permits zero padding and places no assumptions on the lengths len1 and len2. Supports aliasing.GFlint2fq_nmod_poly_sqr_classical rop op ctx Sets rop to the square of op, using classical polynomial multiplication.GFlint2_fq_nmod_poly_sqr_classical rop op len ctx Sets (rop, 2*len - 1) to the square of  (op, len), assuming that (op,len); is not zero and using classical polynomial multiplication.3Permits zero padding. Does not support aliasing of rop with either op1 or op2.GFlint2fq_nmod_poly_mulmod_preinv res poly1 poly2 f finv ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f. finv" is the inverse of the reverse of f.GFlint2_fq_nmod_poly_mulmod_preinv res poly1 len1 poly2 len2 f lenf finv lenfinv ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.It is required that finv" is the inverse of the reverse of f mod x^lenf. Aliasing of res) with any of the inputs is not permitted.GFlint2fq_nmod_poly_mulmod res poly1 poly2 f ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.GFlint2_fq_nmod_poly_mulmod res poly1 len1 poly2 len2 f lenf ctx Sets res$ to the remainder of the product of poly1 and poly2 upon polynomial division by f.It is required that len1 + len2 - lenf > 0, which is equivalent to requiring that the result will actually be reduced. Otherwise, simply use _fq_nmod_poly_mul instead. Aliasing of f and res is not permitted.GFlint2fq_nmod_poly_mulhigh res poly1 poly2 start ctx Computes the product of poly1 and poly2# and writes the coefficients from start' onwards into the high coefficients of res:, the remaining coefficients being arbitrary but reduced.GFlint2_fq_nmod_poly_mulhigh res poly1 len1 poly2 len2 start ctx Computes the product of  (poly1, len1) and  (poly2, len2)# and writes the coefficients from start( onwards into the high coefficients of res, the remaining coefficients being arbitrary but reduced. Assumes that len1 >= len2 > 01. Aliasing of inputs and output is not permitted.GFlint2fq_nmod_poly_mulhigh_classical res poly1 poly2 start ctx Computes the product of poly1 and poly2# and writes the coefficients from start' onwards into the high coefficients of res, the remaining coefficients being arbitrary but reduced. Algorithm is classical multiplication.GFlint2_fq_nmod_poly_mulhigh_classical res poly1 len1 poly2 len2 start ctx Computes the product of  (poly1, len1) and  (poly2, len2)# and writes the coefficients from start( onwards into the high coefficients of res, the remaining coefficients being arbitrary but reduced. Assumes that len1 >= len2 > 0. Aliasing of inputs and output is not permitted. Algorithm is classical multiplication.GFlint2fq_nmod_poly_mullow rop op1 op2 n ctx Sets rop to the lowest n coefficients of the product of op1 and op2.GFlint2_fq_nmod_poly_mullow rop op1 len1 op2 len2 n ctx Sets (rop, n) to the lowest n! coefficients of the product of  (op1, len1) and  (op2, len2).Assumes 0 < n <= len1 + len2 - 1. Allows for zero-padding in the inputs. Does not support aliasing between the inputs and the output.GFlint2fq_nmod_poly_mullow_KS rop op1 op2 n ctx Sets rop to the product of op1 and op2.GFlint2_fq_nmod_poly_mullow_KS rop op1 len1 op2 len2 n ctx Sets (rop, n) to the lowest n! coefficients of the product of  (op1, len1) and  (op2, len2). Assumes that len1 and len2 are positive, but does allow for the polynomials to be zero-padded. The polynomials may be zero, too. Assumes n( is positive. Supports aliasing between rop, op1 and op2.HFlint2fq_nmod_poly_mullow_univariate rop op1 op2 n ctx Sets rop to the lowest n coefficients of the product of poly1 and poly2:, computed using a bivariate to univariate transformation.HFlint2_fq_nmod_poly_mullow_univariate rop op1 len1 op2 len2 n ctx Sets (rop, n) to the lowest n! coefficients of the product of  (op1, len1) and  (op2, len2);, computed using a bivariate to univariate transformation. Assumes that len1 and len2 are positive, but does allow for the polynomials to be zero-padded. The polynomials may be zero, too. Assumes n( is positive. Supports aliasing between rop, op1 and op2.HFlint2fq_nmod_poly_mullow_classical rop op1 op2 n ctx Sets rop to the product of op1 and op25, computed using the classical or schoolbook method.HFlint2_fq_nmod_poly_mullow_classical rop op1 len1 op2 len2 n ctx Sets (rop, n) to the first n coefficients of  (op1, len1) multiplied by  (op2, len2).Assumes 0 < n <= len1 + len2 - 1. Assumes neither len1 nor len2 is zero.HFlint2fq_nmod_poly_mul rop op1 op2 ctx Sets rop to the product of op1 and op2%, choosing an appropriate algorithm.HFlint2_fq_nmod_poly_mul rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2)$, choosing an appropriate algorithm.0Permits zero padding. Does not support aliasing.HFlint2fq_nmod_poly_mul_KS rop op1 op2 ctx Sets rop to the product of op1 and op2 using Kronecker substitution, that is, by encoding each coefficient in \mathbf{F}_{q} as an integer and reducing this problem to multiplying two polynomials over the integers.HFlint2_fq_nmod_poly_mul_KS rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2).>Permits zero padding and places no assumptions on the lengths len1 and len2. Supports aliasing.HFlint2fq_nmod_poly_mul_univariate rop op1 op2 ctx Sets rop to the product of op1 and op2 using a bivariate to univariate transformation and reducing this problem to multiplying two univariate polynomials.HFlint2_fq_nmod_poly_mul_univariate rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2).1Permits zero padding and makes no assumptions on len1 and len2. Supports aliasing.HFlint2fq_nmod_poly_mul_classical rop op1 op2 ctx Sets rop to the product of op1 and op2, using classical polynomial multiplication.HFlint2_fq_nmod_poly_mul_classical rop op1 len1 op2 len2 ctx Sets (rop, len1 + len2 - 1) to the product of  (op1, len1) and  (op2, len2), assuming that len1 is at least len2 and neither is zero.3Permits zero padding. Does not support aliasing of rop with either op1 or op2.HFlint2"fq_nmod_poly_scalar_submul_fq_nmod rop op x ctx Subtracts from rop the product of op by the scalar x, in the context defined by ctx.HFlint2#_fq_nmod_poly_scalar_submul_fq_nmod rop op len x ctx Subtracts from  (rop,len) the product of (op,len) by the scalar x, in the context defined by ctx.. In particular, assumes the same length for op and rop.HFlint2"fq_nmod_poly_scalar_addmul_fq_nmod rop op x ctx Adds to rop the product of op by the scalar x, in the context defined by ctx.HFlint2#_fq_nmod_poly_scalar_addmul_fq_nmod rop op len x ctx Adds to  (rop,len) the product of (op,len) by the scalar x, in the context defined by ctx.. In particular, assumes the same length for op and rop.HFlint2fq_nmod_poly_scalar_mul_fq_nmod rop op x ctx Sets rop to the product of op by the scalar x, in the context defined by ctx.HFlint2 _fq_nmod_poly_scalar_mul_fq_nmod rop op len x ctx Sets  (rop,len) to the product of (op,len) by the scalar x, in the context defined by ctx.HFlint2fq_nmod_poly_neg res poly ctx Sets res to the additive inverse of poly.HFlint2_fq_nmod_poly_neg rop op len ctx Sets rop to the additive inverse of  (poly,len).HFlint2fq_nmod_poly_sub_series res poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n and set res to the difference.HFlint2fq_nmod_poly_sub res poly1 poly2 ctx Sets res to the difference of poly1 and poly2.HFlint2_fq_nmod_poly_sub res poly1 len1 poly2 len2 ctx Sets res to the difference of  (poly1,len1) and  (poly2,len2).HFlint2fq_nmod_poly_add_series res poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n and set res to the sum.HFlint2fq_nmod_poly_add_si res poly1 c ctx Sets res to the sum of poly1 and c.HFlint2fq_nmod_poly_add res poly1 poly2 ctx Sets res to the sum of poly1 and poly2.HFlint2_fq_nmod_poly_add res poly1 len1 poly2 len2 ctx Sets res to the sum of  (poly1,len1) and  (poly2,len2).HFlint2fq_nmod_poly_equal_fq_nmod poly c ctx Returns whether the polynomial poly is equal the (constant)  \mathbf{F}_q element cHFlint2fq_nmod_poly_is_unit op ctx Returns whether the polynomial poly# is a unit in the polynomial ring \mathbf{F}_q[X], i.e. if it has degree 0 and is non-zero.HFlint2fq_nmod_poly_is_gen op ctx Returns whether the polynomial poly is equal to the polynomial x.HFlint2fq_nmod_poly_is_one op Returns whether the polynomial poly& is equal to the constant polynomial 1.HFlint2fq_nmod_poly_is_zero poly ctx Returns whether the polynomial poly is the zero polynomial.HFlint2fq_nmod_poly_equal_trunc poly1 poly2 n ctx Notionally truncate poly1 and poly2 to length n> and return nonzero if they are equal, otherwise return zero.HFlint2fq_nmod_poly_equal poly1 poly2 ctx 'Returns nonzero if the two polynomials poly1 and poly2# are equal, otherwise return zero.HFlint2fq_nmod_poly_set_coeff_fmpz poly n x ctx Sets the coefficient of X^n in the polynomial to x , assuming n \geq 0.HFlint2fq_nmod_poly_set_coeff poly n x ctx Sets the coefficient of X^n in poly to x.HFlint2fq_nmod_poly_get_coeff x poly n ctx Sets x to the coefficient of X^n in poly.HFlint2_fq_nmod_poly_make_monic rop op length ctx Sets rop to  (op,length)6, normed to have leading coefficient 1. Assumes that rop4 has enough space for the polynomial, assumes that op> is not zero (and thus has an invertible leading coefficient).HFlint2fq_nmod_poly_make_monic rop op ctx Sets rop to op', normed to have leading coefficient 1.HFlint2fq_nmod_poly_gen poly ctx Sets poly to the polynomial x.HFlint2fq_nmod_poly_one poly ctx Sets poly to the constant polynomial 1.HFlint2fq_nmod_poly_zero poly ctx Sets poly to the zero polynomial.HFlint2_fq_nmod_poly_zero rop len ctx Sets  (rop, len) to the zero polynomial.HFlint2fq_nmod_poly_swap op1 op2 ctx Swaps the two polynomials op1 and op2.HFlint2fq_nmod_poly_set_nmod_poly rop op ctx Sets the polynomial rop to the polynomial opHFlint2fq_nmod_poly_set_fmpz_mod_poly rop op ctx Sets the polynomial rop to the polynomial opHFlint2fq_nmod_poly_set_fq_nmod poly c ctx Sets the polynomial poly to c.HFlint2fq_nmod_poly_set poly1 poly2 ctx Sets the polynomial poly1 to the polynomial poly2.HFlint2_fq_nmod_poly_set rop op len ctx Sets  (rop, len) to  (op, len).HFlint2!fq_nmod_poly_randtest_irreducible f state len ctx Sets f5 to a random monic, irreducible polynomial of length len) with entries in the field described by ctx.HFlint2fq_nmod_poly_randtest_monic f state len ctx Sets f( to a random monic polynomial of length len) with entries in the field described by ctx.HFlint2fq_nmod_poly_randtest_not_zero f state len ctx Same as fq_nmod_poly_randtest1 but guarantees that the polynomial is not zero.HFlint2fq_nmod_poly_randtest f state len ctx Sets f* to a random polynomial of length at most len) with entries in the field described by ctx.HFlint2fq_nmod_poly_lead poly ctx 0Returns a pointer to the leading coefficient of poly, or NULL if poly is the zero polynomial.HFlint2fq_nmod_poly_length poly ctx %Returns the length of the polynomial poly.HFlint2fq_nmod_poly_degree poly ctx %Returns the degree of the polynomial poly.HFlint2fq_nmod_poly_reverse output input m ctx Sets output to the reverse of input,, thinking of it as a polynomial of length m3, notionally zero-padded if necessary). The length m must be non-negative, but there are no other restrictions. The output polynomial will be set to length m and then normalised.HFlint2_fq_nmod_poly_reverse output input len m ctx Sets output to the reverse of input, which is of length len0, but thinking of it as a polynomial of length m3, notionally zero-padded if necessary. The length m must be non-negative, but there are no other restrictions. The polynomial output must have space for m coefficients.HFlint2fq_nmod_poly_set_trunc poly1 poly2 newlen ctx Sets poly1 to poly2 truncated to length n.HFlint2fq_nmod_poly_truncate poly newlen ctx +Truncates the polynomial to length at most n.HFlint2_fq_nmod_poly_normalise2 poly length ctx Sets the length length of  (poly,length) so that the top coefficient is non-zero. If all coefficients are zero, the length is set to zero. This function is mainly used internally, as all functions guarantee normalisation.HFlint2_fq_nmod_poly_normalise poly ctx Sets the length of poly so that the top coefficient is non-zero. If all coefficients are zero, the length is set to zero. This function is mainly used internally, as all functions guarantee normalisation.HFlint2fq_nmod_poly_clear poly ctx Clears the given polynomial, releasing any memory used. It must be reinitialised in order to be used again.HFlint2_fq_nmod_poly_set_length poly newlen ctx Sets the coefficients of poly beyond len! to zero and sets the length of poly to len.HFlint2fq_nmod_poly_fit_length poly len ctx If len is greater than the number of coefficients currently allocated, then the polynomial is reallocated to have space for at least len; coefficients. No data is lost when calling this function.3The function efficiently deals with the case where  fit_length is called many times in small increments by at least doubling the number of allocated coefficients when length is larger than the number of coefficients currently allocated.HFlint2fq_nmod_poly_realloc poly alloc ctx 3Reallocates the given polynomial to have space for alloc coefficients. If alloc is zero the polynomial is cleared and then reinitialised. If the current length is greater than alloc. the polynomial is first truncated to length alloc.HFlint2fq_nmod_poly_init2 poly alloc ctx  Initialises poly with space for at least alloc coefficients and sets the length to zero. The allocated coefficients are all set to zero. A corresponding call to fq_nmod_poly_clear( must be made after finishing with the fq_nmod_poly_t+ to free the memory used by the polynomial.HFlint2fq_nmod_poly_init poly ctx  Initialises poly for use, with context ctx, and setting its length to zero. A corresponding call to fq_nmod_poly_clear( must be made after finishing with the fq_nmod_poly_t, to free the memory used by the polynomial.HFlint2fq_nmod_poly_print_pretty poly x ctx $Prints the pretty representation of poly to stdout, using the string x to represent the indeterminate.In case of success, returns a positive value. In case of failure, returns a non-positive value.HFlint2fq_nmod_poly_print poly ctx Prints the representation of poly to stdout.In case of success, returns a positive value. In case of failure, returns a non-positive value. GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH Safe-Inferred )*1 h GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHGGGHGGGGGGG Safe-Inferred )*1 7MHFlint2fq_nmod_poly_roots r f with_multiplicity ctx Fill r with factors of the form x - r_i where the r_i& are the distinct roots of a nonzero f in F_q. If with\_multiplicity is zero, the exponent e_i of the factor x - r_i is 1. Otherwise, it is the largest e_i such that  (x-r_i)^e_i divides f. This function throws if f. is zero, but is otherwise always successful.HFlint2&fq_nmod_poly_iterated_frobenius_preinv rop n v vinv ctx Sets rop[i] to be x^{q^i} \bmod v for  0 \le i < n.It is required that vinv" is the inverse of the reverse of v mod x^lenv.HFlint2'fq_nmod_poly_factor_with_kaltofen_shoup res  leading_coeff f ctx  Factorises a general polynomial f* into monic irreducible factors and sets  leading_coeff to the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Kaltofen-Shoup on all the individual square-free factors.HFlint2*fq_nmod_poly_factor_with_cantor_zassenhaus res  leading_coeff f ctx  Factorises a general polynomial f* into monic irreducible factors and sets  leading_coeff to the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Cantor-Zassenhaus on all the individual square-free factors.HFlint2"fq_nmod_poly_factor_with_berlekamp res  leading_coeff f ctx  Factorises a general polynomial f* into monic irreducible factors and sets  leading_coeff to the leading coefficient of f , or 0 if f is the zero polynomial.=This function first checks for small special cases, deflates f if it is of the form p(x^m) for some m > 1, then performs a square-free factorisation, and finally runs Berlekamp on all the individual square-free factors.HFlint2fq_nmod_poly_factor_berlekamp factors f ctx %Factorises a non-constant polynomial f? into monic irreducible factors using the Berlekamp algorithm.HFlint2"fq_nmod_poly_factor_kaltofen_shoup res poly ctx %Factorises a non-constant polynomial f into monic irreducible factors using the fast version of Cantor-Zassenhaus algorithm proposed by Kaltofen and Shoup (1998). More precisely this algorithm uses a @baby step/giant step@ strategy for the distinct-degree factorization step.HFlint2%fq_nmod_poly_factor_cantor_zassenhaus res f ctx %Factorises a non-constant polynomial f into monic irreducible factors using the Cantor-Zassenhaus algorithm.HFlint2fq_nmod_poly_factor res lead f ctx %Factorises a non-constant polynomial f into monic irreducible factors choosing the best algorithm for given modulo and degree. The output lead& is set to the leading coefficient of f upon return. Choice of algorithm is based on heuristic measurements.HFlint2fq_nmod_poly_factor_squarefree res f ctx Sets res" to a squarefree factorization of f.HFlint2 fq_nmod_poly_factor_distinct_deg res poly degs ctx 6Factorises a monic non-constant squarefree polynomial poly of degree n into factors f[d] such that for 1 \leq d \leq n f[d]5 is the product of the monic irreducible factors of poly of degree d. Factors are stored in res>, associated powers of irreducible polynomials are stored in degs in the same order as factors.Requires that degs have enough space for irreducible polynomials' powers (maximum space required is n * sizeof(slong)).HFlint2 fq_nmod_poly_factor_split_single  linfactor input ctx  Assuming input is a product of factors all of degree 1, finds a single linear factor of input and places it in  linfactor. Requires that input be monic and non-constant.HFlint2fq_nmod_poly_factor_equal_deg factors pol d ctx  Assuming pol3 is a product of irreducible factors all of degree d, finds all those factors and places them in factors. Requires that pol( be monic, non-constant and squarefree.HFlint2"fq_nmod_poly_factor_equal_deg_prob factor state pol d ctx ,Probabilistic equal degree factorisation of pol% into irreducible factors of degree d. If it passes, a factor is placed in factor and 1 is returned, otherwise 0 is returned and the value of factor is undetermined.Requires that pol' be monic, non-constant and squarefree.HFlint2fq_nmod_poly_is_squarefree f ctx  Returns 1 if f is squarefree, and 0 otherwise. As a special case, the zero polynomial is not considered squarefree.HFlint2_fq_nmod_poly_is_squarefree f len ctx  Returns 1 if (f, len) is squarefree, and 0 otherwise. As a special case, the zero polynomial is not considered squarefree. There are no restrictions on the length.HFlint2"fq_nmod_poly_is_irreducible_ben_or f ctx Returns 1 if the polynomial f is irreducible, otherwise returns 0. Uses Ben-Or's irreducibility test.HFlint2fq_nmod_poly_is_irreducible_ddf f ctx Returns 1 if the polynomial f is irreducible, otherwise returns 0. Uses fast distinct-degree factorisation.HFlint2fq_nmod_poly_is_irreducible f ctx Returns 1 if the polynomial f% is irreducible, otherwise returns 0.HFlint2fq_nmod_poly_remove f p ctx &Removes the highest possible power of p from f and returns the exponent.HFlint2fq_nmod_poly_factor_pow fac exp ctx Raises fac to the power exp.HFlint2fq_nmod_poly_factor_concat res fac ctx  Concatenates two factorisations.This is equivalent to calling fq_nmod_poly_factor_insert, repeatedly with the individual factors of fac."Does not support aliasing between res and fac.HFlint2fq_nmod_poly_factor_insert fac poly exp ctx Inserts the factor poly with multiplicity exp into the factorisation fac.If fac already contains poly, then exp: simply gets added to the exponent of the existing entry.HFlint2fq_nmod_poly_factor_print fac ctx Prints the entries of fac to standard output.HFlint2fq_nmod_poly_factor_set res fac ctx Sets res to the same factorisation as fac.HFlint2fq_nmod_poly_factor_fit_length fac len ctx 9Ensures that the factor structure has space for at least len factors. This function takes care of the case of repeated calls by always at least doubling the number of factors the structure can hold.HFlint2fq_nmod_poly_factor_realloc fac alloc ctx Reallocates the factor structure to provide space for precisely alloc factors.HFlint2fq_nmod_poly_factor_clear fac ctx !Frees all memory associated with fac.HFlint2fq_nmod_poly_factor_init fac ctx  Initialises fac for use. An fq_nmod_poly_factor_t represents a polynomial in factorised form as a product of polynomials with associated exponents.HFlint2 fq_nmod_poly_factor_print_pretty fac ctx Pretty-prints the entries of fac to standard output.$ HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH Safe-Inferred )*1 7$ HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH$ HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH Safe-Inferred )*1 HFlint2$fq_nmod_mpoly_univar_swap_term_coeff c A i ctx Set (resp. swap) c7 to (resp. with) the coefficient of the term of index i of A.HFlint2#fq_nmod_mpoly_univar_get_term_coeff c A i ctx HFlint2$fq_nmod_mpoly_univar_get_term_exp_si A i ctx )Return the exponent of the term of index i of A.HFlint2fq_nmod_mpoly_univar_length A ctx Return the number of terms in A# with respect to the main variable.HFlint2#fq_nmod_mpoly_univar_degree_fits_si A ctx Return 1 if the degree of A, with respect to the main variable fits an slong. Otherwise, return 0.HFlint2fq_nmod_mpoly_from_univar A B var ctx Set A to the normal form of B& by putting in the variable of index var4. This function is undefined if the coefficients of B" depend on the variable of index var.HFlint2fq_nmod_mpoly_to_univar A B var ctx Set A to a univariate form of B' by pulling out the variable of index var. The coefficients of A" will still belong to the content ctx/ but will not depend on the variable of index var.HFlint2fq_nmod_mpoly_univar_swap A B ctx Swap A and B.HFlint2fq_nmod_mpoly_univar_clear A ctx Clear A.HFlint2fq_nmod_mpoly_univar_init A ctx  Initialize A.HFlint2fq_nmod_mpoly_quadratic_root Q A B ctx If Q^2+AQ=B has a solution, set Q to a solution and return 1, otherwise return 0.HFlint2fq_nmod_mpoly_is_square A ctx Return 1 if A' is a perfect square, otherwise return 0.HFlint2fq_nmod_mpoly_sqrt Q A ctx If Q^2=A has a solution, set Q to a solution and return 1, otherwise return 0 and set Q to zero.HFlint2fq_nmod_mpoly_discriminant D A var ctx  Try to set D to the discriminant of A( with respect to the variable of index var.HFlint2fq_nmod_mpoly_resultant R A B var ctx  Try to set R to the resultant of A and B( with respect to the variable of index var.HFlint2fq_nmod_mpoly_gcd_zippel G A B ctx  Try to set G to the GCD of A and B using various algorithms.HFlint2fq_nmod_mpoly_gcd_hensel G A B ctx HFlint2fq_nmod_mpoly_gcd_brown G A B ctx HFlint2fq_nmod_mpoly_gcd_cofactors G Abar Bbar A B ctx Do the operation of fq_nmod_mpoly_gcd and also compute  Abar = A/G and  Bbar = B/G if successful.HFlint2fq_nmod_mpoly_gcd G A B ctx  Try to set G to the monic GCD of A and B. The GCD of zero and zero is defined to be zero. If the return is 17 the function was successful. Otherwise the return is 0 and G is left untouched.HFlint2fq_nmod_mpoly_content_vars g A vars  vars_length ctx Set g# to the GCD of the coefficients of A/ when viewed as a polynomial in the variables vars . Return 1 for success and 0 for failure. Upon success, g' will be independent of the variables vars.IFlint2fq_nmod_mpoly_term_content M A ctx Set M to the GCD of the terms of A. If A is zero, M will be zero. Otherwise, M) will be a monomial with coefficient one.IFlint2fq_nmod_mpoly_divrem_ideal Q R A B len ctx This function is as per fq_nmod_mpoly_divrem7 except that it takes an array of divisor polynomials B2 and it returns an array of quotient polynomials Q. The number of divisor (and hence quotient) polynomials, is given by len.IFlint2fq_nmod_mpoly_divrem Q R A B ctx Set Q and R" to the quotient and remainder of A divided by B.IFlint2fq_nmod_mpoly_div Q A B ctx Set Q to the quotient of A by B, discarding the remainder.IFlint2fq_nmod_mpoly_divides Q A B ctx If A is divisible by B, set Q# to the exact quotient and return 1. Otherwise, set Q to zero and return 0.IFlint2fq_nmod_mpoly_pow_ui A B k ctx Set A to B raised to the k-th power. Return 1 for success and 0 for failure.IFlint2fq_nmod_mpoly_pow_fmpz A B k ctx Set A to B raised to the k-th power. Return 1 for success and 0 for failure.IFlint2fq_nmod_mpoly_mul A B C ctx Set A to B times C.IFlint2'fq_nmod_mpoly_compose_fq_nmod_mpoly_gen A B c ctxB ctxAC Set A to the evaluation of B where the variable of index i in ctxB& is replaced by the variable of index c[i] in ctxAC. The length of the array C is the number of variables in ctxB . If any c[i], is negative, the corresponding variable of B6 is replaced by zero. Otherwise, it is expected that c[i]* is less than the number of variables in ctxAC.IFlint2#fq_nmod_mpoly_compose_fq_nmod_mpoly A B C ctxB ctxAC Set A to the evaluation of B where the variables are replaced by the corresponding elements of the array C. Both A and the elements of C have context object ctxAC, while B has context object ctxB . Neither A nor B3 is allowed to alias any other polynomial. Return 1 for success and 0 for failure.IFlint2"fq_nmod_mpoly_compose_fq_nmod_poly A B C ctx Set A to the evaluation of B where the variables are replaced by the corresponding elements of the array C. The context object of B is ctxB . Return 1 for success and 0 for failure.IFlint2"fq_nmod_mpoly_evaluate_one_fq_nmod A B var val ctx Set A to the evaluation of B where the variable of index var is replaced by val.IFlint2"fq_nmod_mpoly_evaluate_all_fq_nmod ev A vals ctx Set ev the evaluation of A where the variables are replaced by the corresponding elements of the array vals.IFlint2fq_nmod_mpoly_derivative A B var ctx Set A to the derivative of B( with respect to the variable of index var.IFlint2fq_nmod_mpoly_make_monic A B ctx Set A to B' divided by the leading coefficient of B. This throws if B is zero.IFlint2 fq_nmod_mpoly_scalar_mul_fq_nmod A B c ctx Set A to  B \times c.IFlint2fq_nmod_mpoly_neg A B ctx Set A to -B.IFlint2fq_nmod_mpoly_sub A B C ctx Set A to B - C.IFlint2fq_nmod_mpoly_add A B C ctx Set A to B + C.IFlint2fq_nmod_mpoly_sub_fq_nmod A B C ctx Set A to B - c.IFlint2fq_nmod_mpoly_add_fq_nmod A B C ctx Set A to B + c.IFlint2fq_nmod_mpoly_randtest_bits A state length exp_bits ctx /Generate a random polynomial with length up to length and exponents whose packed form does not exceed the given bit count.IFlint2fq_nmod_mpoly_randtest_bounds A state length  exp_bounds ctx /Generate a random polynomial with length up to length and exponents in the range [0, exp_bounds[i] - 1]*. The exponents of the variable of index i are generated by calls to n_randint(state, exp_bounds[i]).IFlint2fq_nmod_mpoly_randtest_bound A state length  exp_bound ctx /Generate a random polynomial with length up to length and exponents in the range [0, exp_bound - 1]<. The exponents of each variable are generated by calls to n_randint(state, exp_bound).IFlint2fq_nmod_mpoly_reverse A B ctx Set A to the reversal of B.IFlint2 fq_nmod_mpoly_combine_like_terms A ctx Combine adjacent like terms in A: and delete terms with coefficient zero. If the terms of A were sorted to begin with, the result will be in canonical form. This function runs in linear time in the bit size of A.IFlint2fq_nmod_mpoly_sort_terms A ctx Sort the terms of A: into the canonical ordering dictated by the ordering in ctx. This function simply reorders the terms: It does not combine like terms, nor does it delete terms with coefficient zero. This function runs in linear time in the bit size of A.IFlint2"fq_nmod_mpoly_push_term_fq_nmod_ui A c exp ctx Append a term to A with coefficient c and exponent vector exp/. This function runs in constant average time.IFlint2$fq_nmod_mpoly_push_term_fq_nmod_fmpz A c exp ctx IFlint2fq_nmod_mpoly_get_term_monomial M A i ctx Set M& to the monomial of the term of index i in A. The coefficient of M will be one.IFlint2fq_nmod_mpoly_get_term M A i ctx Set M to the term of index i in A.IFlint2fq_nmod_mpoly_set_term_exp_ui A i exp ctx &Set the exponent of the term of index i to exp.IFlint2fq_nmod_mpoly_set_term_exp_fmpz A i exp ctx IFlint2!fq_nmod_mpoly_get_term_var_exp_si A i var ctx $Return the exponent of the variable var of the term of index i<. This function throws if the exponent does not fit into a ulong (resp. slong).IFlint2!fq_nmod_mpoly_get_term_var_exp_ui A i var ctx IFlint2fq_nmod_mpoly_get_term_exp_si exp A i ctx Set exp- to the exponent vector of the term of index i. The _ui (resp. _si2) version throws if any entry does not fit into a ulong (resp. slong).IFlint2fq_nmod_mpoly_get_term_exp_ui exp A i ctx IFlint2fq_nmod_mpoly_get_term_exp_fmpz exp A i ctx IFlint2fq_nmod_mpoly_term_exp_fits_ui A i ctx Return 1= if all entries of the exponent vector of the term of index i fit into an slong (resp. a ulong). Otherwise, return 0.IFlint2fq_nmod_mpoly_term_exp_fits_si A i ctx IFlint2$fq_nmod_mpoly_get_term_coeff_fq_nmod c A i ctx Set c) to the coefficient of the term of index i.IFlint2fq_nmod_mpoly_resize A  new_length ctx Set the length of A to  new_length. Terms are either deleted from the end, or new zero terms are appended.IFlint2fq_nmod_mpoly_length A ctx Return the number of terms in A. If the polynomial is in canonical form, this will be the number of nonzero coefficients.IFlint2fq_nmod_mpoly_is_canonical A ctx Return 1 if A) is in canonical form. Otherwise, return 0. To be in canonical form, all of the terms must have nonzero coefficients, and the terms must be sorted from greatest to least.IFlint2fq_nmod_mpoly_cmp A B ctx Return 1 (resp. -1, or 0) if A# is after (resp. before, same as) B in some arbitrary but fixed total ordering of the polynomials. This ordering agrees with the usual ordering of monomials when A and B are both monomials.IFlint2fq_nmod_mpoly_get_coeff_vars_ui C A vars exps length ctx Set C to the coefficient of A# with respect to the variables in vars( with powers in the corresponding array exps. Both vars and exps point to array of length length. It is assumed that 0 < length \le nvars(A) and that the variables in vars are distinct.IFlint2"fq_nmod_mpoly_set_coeff_fq_nmod_ui A c exp ctx 2Set the coefficient of the monomial with exponent exp to c.IFlint2$fq_nmod_mpoly_set_coeff_fq_nmod_fmpz A c exp ctx IFlint2"fq_nmod_mpoly_get_coeff_fq_nmod_ui c A exp ctx Set c9 to the coefficient of the monomial with exponent vector exp.IFlint2$fq_nmod_mpoly_get_coeff_fq_nmod_fmpz c A exp ctx IFlint2(fq_nmod_mpoly_set_coeff_fq_nmod_monomial A c M ctx Assuming that M is a monomial, set the coefficient of the corresponding monomial in A to c. This function throws if M is not a monomial.IFlint2(fq_nmod_mpoly_get_coeff_fq_nmod_monomial c A M ctx Assuming that M is a monomial, set c6 to the coefficient of the corresponding monomial in A. This function throws if M is not a monomial.IFlint2fq_nmod_mpoly_used_vars used A ctx For each variable index i, set used[i]& to nonzero if the variable of index i appears in A and to zero otherwise.IFlint2fq_nmod_mpoly_total_degree_si A ctx Either return or set tdeg to the total degree of A. If A- is zero, the total degree is defined to be -1.IFlint2fq_nmod_mpoly_total_degree_fmpz tdeg A ctx IFlint2"fq_nmod_mpoly_total_degree_fits_si A ctx Return 1 if the total degree of A fits into an slong, otherwise return 0.IFlint2fq_nmod_mpoly_degree_si A var ctx Either return or set deg to the degree of A( with respect to the variable of index var. If A' is zero, the degree is defined to be -1.IFlint2fq_nmod_mpoly_degree_fmpz deg A var ctx IFlint2fq_nmod_mpoly_degrees_si degs A ctx Set degs to the degrees of A# with respect to each variable. If A" is zero, all degrees are set to -1.IFlint2fq_nmod_mpoly_degrees_fmpz degs A ctx IFlint2fq_nmod_mpoly_degrees_fit_si A ctx Return 1 if the degrees of A, with respect to each variable fit into an slong, otherwise return 0.IFlint2fq_nmod_mpoly_is_one A ctx Return 1 if A is the constant 1, else return 0.IFlint2fq_nmod_mpoly_is_zero A ctx Return 1 if A is the constant 0, else return 0.IFlint2fq_nmod_mpoly_equal_fq_nmod A c ctx Return 1 if A is equal to the constant c, else return 0.IFlint2fq_nmod_mpoly_one A ctx Set A to the constant 1.IFlint2fq_nmod_mpoly_zero A ctx Set A to the constant 0.IFlint2fq_nmod_mpoly_set_fq_nmod_gen A ctx Set A to the constant given by  fq_nmod_gen.IFlint2fq_nmod_mpoly_set_ui A c ctx Set A to the constant c.IFlint2fq_nmod_mpoly_set_fq_nmod A c ctx IFlint2fq_nmod_mpoly_get_fq_nmod c A ctx Assuming that A is a constant, set c, to this constant. This function throws if A is not a constant.IFlint2fq_nmod_mpoly_is_fq_nmod A ctx Return 1 if A is a constant, else return 0.IFlint2fq_nmod_mpoly_swap A B ctx Efficiently swap A and B.IFlint2fq_nmod_mpoly_equal A B ctx Return 1 if A is equal to B, else return 0.IFlint2fq_nmod_mpoly_set A B ctx Set A to B.IFlint2fq_nmod_mpoly_is_gen A var ctx If  var \ge 0 , return 1 if A is equal to the var!-th generator, otherwise return 0. If var < 0 , return 1 if the polynomial is equal to any generator, otherwise return 0.IFlint2fq_nmod_mpoly_gen A var ctx Set A to the variable of index var, where var = 0 corresponds to the variable with the most significance with respect to the ordering.IFlint2fq_nmod_mpoly_set_str_pretty A str x ctx Set A1 to the polynomial in the null-terminates string str given an array x! of variable strings. If parsing str fails, A is set to zero, and -1 is returned. Otherwise, 0 is returned. The operations +, -, *, and /9 are permitted along with integers and the variables in x. The character ^ must be immediately followed by the (integer) exponent. If any division is not exact, parsing fails.IFlint2fq_nmod_mpoly_fprint_pretty file A x ctx Print a string representing A to file.IFlint2fq_nmod_mpoly_get_str_pretty A x ctx Return a string, which the user is responsible for cleaning up, representing A%, given an array of variable strings x.IFlint2fq_nmod_mpoly_clear A ctx  Release any space allocated for A.IFlint2fq_nmod_mpoly_realloc A alloc ctx  Reallocate A to have space for alloc terms. Assumes the current length of the polynomial is not greater than alloc.IFlint2fq_nmod_mpoly_fit_length A len ctx  Ensure that A has space for at least len terms.IFlint2fq_nmod_mpoly_init3 A alloc bits ctx  Initialise A for use with the given an initialised context object. Its value is set to zero. It is allocated with space for alloc terms and bits bits for the exponents.IFlint2fq_nmod_mpoly_init2 A alloc ctx  Initialise A for use with the given an initialised context object. Its value is set to zero. It is allocated with space for alloc terms and at least MPOLY_MIN_BITS bits for the exponents.IFlint2fq_nmod_mpoly_init A ctx  Initialise A for use with the given an initialised context object. Its value is set to zero.IFlint2fq_nmod_mpoly_ctx_clear ctx "Release any space allocated by an ctx.IFlint2fq_nmod_mpoly_ctx_ord ctx 3Return the ordering used to initialize the context.IFlint2fq_nmod_mpoly_ctx_nvars ctx >Return the number of variables used to initialize the context.IFlint2fq_nmod_mpoly_ctx_init ctx nvars ord fqctx Initialise a context object for a polynomial ring with the given number of variables and the given ordering. It will have coefficients in the finite field fqctx). The possibilities for the ordering are ORD_LEX,  ORD_DEGLEX and  ORD_DEGREVLEX.LFlint2 Create a new LIFlint2 Create a new HIFlint2Use a HIFlint2fq_nmod_mpoly_print_pretty A x ctx Print a string representing A to stdout. HHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII Safe-Inferred )*1 @ HHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII IIHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIHHHHHHHHHHHHHHHHHHHHH Safe-Inferred )*1 IFlint2fq_nmod_mpoly_factor f A ctx Set f to a factorization of A! where the bases are irreducible.IFlint2fq_nmod_mpoly_factor_squarefree f A ctx Set f to a factorization of A where the bases are primitive and pairwise relatively prime. If the product of all irreducible factors with a given exponent is desired, it is recommended to call fq_nmod_mpoly_factor_sort8 and then multiply the bases with the desired exponent.IFlint2fq_nmod_mpoly_factor_sort f ctx Sort the product of f$ first by exponent and then by base.IFlint2fq_nmod_mpoly_factor_get_exp_si f i ctx )Return the exponent of the term of index i in A. It is assumed to fit an slong.IFlint2fq_nmod_mpoly_factor_swap_base p f i ctx Set (resp. swap) B/ to (resp. with) the base of the term of index i in A.IFlint2fq_nmod_mpoly_factor_get_base p f i ctx IFlint2)fq_nmod_mpoly_factor_get_constant_fq_nmod c f ctx Set c to the constant of f.IFlint2fq_nmod_mpoly_factor_length f ctx $Return the length of the product in f.IFlint2fq_nmod_mpoly_factor_swap f g ctx Efficiently swap f and g.IFlint2fq_nmod_mpoly_factor_clear f ctx Clear f.IFlint2fq_nmod_mpoly_factor_init f ctx  Initialise f.IIIIIIIIIIIIIIIII Safe-Inferred )*1 FIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII Safe-Inferred )*1 IFlint2fq_modulus_derivative_inv m_prime  m_prime_inv ctx Compute the derivative m_prime of the modulus of ctx as an element of ctx, and its inverse  m_prime_inv.IFlint2fq_modulus_pow_series_inv res ctx trunc Compute the power series inverse of the reverse of the modulus of ctx up to O(x^\texttt{trunc}).IFlint2fq_embed_dual_to_mono_matrix res ctx :Compute the change of basis matrix from the dual basis of ctx to its monomial basis.IFlint2fq_embed_mono_to_dual_matrix res ctx >Compute the change of basis matrix from the monomial basis of ctx to its dual basis.IFlint2fq_embed_mul_matrix matrix gen ctx  Compute the multiplication matrix of gen.For an element a in  \mathbf{F}_{p^n}=\mathbf{F}_p[x], its multiplication matrix is the matrix whose columns are (a, ax, dots, ax^{n-1}).IFlint2fq_embed_composition_matrix_sub matrix gen ctx trunc  Compute the composition matrix of gen, truncated to trunc columns.IFlint2fq_embed_composition_matrix matrix gen ctx  Compute the composition matrix of gen.For an element a\in\mathbf{F}_{p^n}:, its composition matrix is the matrix whose columns are a^0, a^1, \ldots, a^{n-1}.IFlint2fq_embed_trace_matrix res basis sub_ctx sup_ctx Given: two contexts sub_ctx and sup_ctx , of degrees m and n, such that m divides n;an  n\times m matrix basis that maps sub_ctx# to an isomorphic subfield in sup_ctx; Compute the  m\times n matrix of the trace from sup_ctx to sub_ctx.This matrix is computed as%embed_dual_to_mono_matrix(_, sub_ctx) \times basist \times %embed_mono_to_dual_matrix(_, sup_ctx).Note: if m=n, basis? represents a Frobenius, and the result is its inverse matrix.IFlint2fq_embed_matrices embed project gen_sub sub_ctx gen_sup sup_ctx  gen_minpoly Given: two contexts sub_ctx and sup_ctx, of respective degrees m and n , such that m divides n; a generator gen_sub of sub_ctx, its minimal polynomial  gen_minpoly , and a root gen_sup of  gen_minpoly in sup_ctx, as returned by  fq_embed_gens;Compute:the  n\times m matrix embed mapping gen_sub to gen_sup(, and all their powers accordingly;an  m\times n matrix project such that project \times embed is the  m\times m identity matrix.IFlint2_fq_embed_gens_naive gen_sub gen_sup minpoly sub_ctx sup_ctx Given two contexts sub_ctx and sup_ctx , such that degree(sub_ctx) divides degree(sup_ctx), compute an embedding of sub_ctx into sup_ctx defined as follows:gen_sub is the canonical generator of sup_ctx (i.e., the class of X),minpoly is the defining polynomial of sub_ctx,gen_sup is a root of minpoly" inside the field defined by sup_ctx.IFlint2 fq_embed_gens gen_sub gen_sup minpoly sub_ctx sup_ctx Given two contexts sub_ctx and sup_ctx , such that degree(sub_ctx) divides degree(sup_ctx) , compute: an element gen_sub in sub_ctx such that gen_sub, generates the finite field defined by sub_ctx,its minimal polynomial minpoly,a root gen_sup of minpoly inside the field defined by sup_ctx.+These data uniquely define an embedding of sub_ctx into sup_ctx. IIIIIIIIIII Safe-Inferred )*1 ? IIIIIIIIIII IIIIIIIIIII Safe-Inferred )*1 IFlint2fmpz_mod_poly_roots_factored r f with_multiplicity n ctx Fill r with factors of the form x - r_i where the r_i& are the distinct roots of a nonzero f in Z/nZ'. It is expected and not checked that n- is a prime factorization of the modulus of ctx. If with\_multiplicity is zero, the exponent e_i of the factor x - r_i is 1. Otherwise, it is the largest e_i such that  (x-r_i)^e_i divides f2. The roots are first found modulo the primes in n, then lifted to the corresponding prime powers, then combined into roots of the original polynomial f. A return of 15 indicates the function was successful. A return of 0 indicates the function was not able to find the roots, possibly because there are too many of them. This function throws if f is zero.IFlint2fmpz_mod_poly_roots r f with_multiplicity ctx Fill r with factors of the form x - r_i where the r_i& are the distinct roots of a nonzero f in Z/pZ6. It is expected and not checked that the modulus of ctx is prime. If with\_multiplicity is zero, the exponent e_i of the factor x - r_i is 1. Otherwise, it is the largest e_i such that  (x-r_i)^e_i divides f. This function throws if f. is zero, but is otherwise always successful.JFlint2fmpz_mod_poly_factor_berlekamp factors f ctx %Factorises a non-constant polynomial f? into monic irreducible factors using the Berlekamp algorithm.JFlint2#fmpz_mod_poly_factor_kaltofen_shoup res poly ctx %Factorises a non-constant polynomial poly into monic irreducible factors using the fast version of Cantor-Zassenhaus algorithm proposed by Kaltofen and Shoup (1998). More precisely this algorithm uses a baby step/giant step strategy for the distinct-degree factorization step. If flint_get_num_threads is greater than one *fmpz_mod_poly_factor_distinct_deg_threaded is used.JFlint2&fmpz_mod_poly_factor_cantor_zassenhaus res f ctx %Factorises a non-constant polynomial f into monic irreducible factors using the Cantor-Zassenhaus algorithm.JFlint2fmpz_mod_poly_factor res f ctx %Factorises a non-constant polynomial f into monic irreducible factors choosing the best algorithm for given modulo and degree. Choice is based on heuristic measurements.JFlint2fmpz_mod_poly_factor_squarefree res f ctx Sets res" to a squarefree factorization of f.JFlint2*fmpz_mod_poly_factor_distinct_deg_threaded res poly degs ctx Multithreaded version of !fmpz_mod_poly_factor_distinct_deg.JFlint2!fmpz_mod_poly_factor_distinct_deg res poly degs ctx 6Factorises a monic non-constant squarefree polynomial poly of degree n into factors f[d] such that for 1 \leq d \leq n f[d]5 is the product of the monic irreducible factors of poly of degree d . Factors f[d] are stored in res, and the degree d* of the irreducible factors is stored in degs# in the same order as the factors.Requires that degs has enough space for (n/2)+1 * sizeof(slong).JFlint2fmpz_mod_poly_factor_equal_deg factors pol d ctx  Assuming pol3 is a product of irreducible factors all of degree d, finds all those factors and places them in factors. Requires that pol( be monic, non-constant and squarefree.JFlint2#fmpz_mod_poly_factor_equal_deg_prob factor state pol d ctx ,Probabilistic equal degree factorisation of pol% into irreducible factors of degree d&. If it passes, a factor is placed in factor and 1 is returned, otherwise 0 is returned and the value of factor is undetermined.Requires that pol' be monic, non-constant and squarefree.JFlint2fmpz_mod_poly_is_squarefree_f fac f ctx If fac returns with the value 1$ then the function operates as per fmpz_mod_poly_is_squarefree , otherwise f# is set to a nontrivial factor of p.JFlint2fmpz_mod_poly_is_squarefree f ctx  Returns 1 if f is squarefree, and 0 otherwise. As a special case, the zero polynomial is not considered squarefree.JFlint2_fmpz_mod_poly_is_squarefree_f fac f len ctx If fac returns with the value 1$ then the function operates as per _fmpz_mod_poly_is_squarefree , otherwise f# is set to a nontrivial factor of p.JFlint2_fmpz_mod_poly_is_squarefree f len ctx  Returns 1 if (f, len) is squarefree, and 0 otherwise. As a special case, the zero polynomial is not considered squarefree. There are no restrictions on the length.JFlint2$fmpz_mod_poly_is_irreducible_rabin_f r f ctx  Either sets r to 1! and returns 1 if the polynomial f is irreducible or 0 otherwise, or sets r to a nontrivial factor of p.,This algorithm correctly determines whether f is irreducible over \mathbb{Z}/p\mathbb{Z}, even for composite f, or it finds a factor of p.JFlint2"fmpz_mod_poly_is_irreducible_rabin f ctx Returns 1 if the polynomial f is irreducible, otherwise returns 0. Uses Rabin irreducibility test.JFlint2 fmpz_mod_poly_is_irreducible_ddf f ctx Returns 1 if the polynomial f is irreducible, otherwise returns 0. Uses fast distinct-degree factorisation.JFlint2fmpz_mod_poly_is_irreducible f ctx Returns 1 if the polynomial f% is irreducible, otherwise returns 0.JFlint2fmpz_mod_poly_factor_pow fac exp ctx Raises fac to the power exp.JFlint2fmpz_mod_poly_factor_concat res fac ctx  Concatenates two factorisations.This is equivalent to calling fmpz_mod_poly_factor_insert, repeatedly with the individual factors of fac."Does not support aliasing between res and fac.JFlint2fmpz_mod_poly_factor_insert fac poly exp ctx Inserts the factor poly with multiplicity exp into the factorisation fac.If fac already contains poly, then exp: simply gets added to the exponent of the existing entry.JFlint2fmpz_mod_poly_factor_set res fac ctx Sets res to the same factorisation as fac.JFlint2fmpz_mod_poly_factor_fit_length fac len ctx 9Ensures that the factor structure has space for at least len factors. This function takes care of the case of repeated calls by always at least doubling the number of factors the structure can hold.JFlint2fmpz_mod_poly_factor_realloc fac alloc ctx Reallocates the factor structure to provide space for precisely alloc factors.JFlint2fmpz_mod_poly_factor_clear fac ctx !Frees all memory associated with fac.JFlint2fmpz_mod_poly_factor_init fac ctx  Initialises fac for use.JFlint2fmpz_mod_poly_factor_print fac ctx Prints the entries of fac to standard output.JFlint2!fmpz_mod_poly_factor_print_pretty fac var ctx Prints the entries of fac to standard output.#IIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ Safe-Inferred )*1 j#IIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ#IIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJII Safe-Inferred )*1 JFlint2unity_zpq_gauss_sum_sigma_pow f q p Sets  f = \tau^{\sigma_n}(\chi_{p, q}).JFlint2unity_zpq_gauss_sum f q p Sets f = \tau(\chi_{p, q}).JFlint2unity_zpq_pow_ui f g p Sets f to g^p. f and g must be initialized with same p, q and n.JFlint2 unity_zpq_pow f g p Sets f to g^p. f and g must be initialized with same p, q and n.JFlint2unity_zpq_mul_unity_p_pow f g k Sets f to g \cdot \zeta_p^k.JFlint2_unity_zpq_mul_unity_p f Sets f = f \cdot \zeta_p.JFlint2 unity_zpq_mul f g h  Sets the f to  g \cdot h. f, g and h must be initialized with same q, p and n.JFlint2 unity_zpq_add f g h Sets f to g + h. f, g and h must be initialized with same q, p and n.JFlint2unity_zpq_coeff_add f i j x Adds x to the coefficient of \zeta_p^i \zeta_q^j. x must be less than n.JFlint2unity_zpq_coeff_set_ui f i j x Sets the coefficient of \zeta_q^i \zeta_p^j to x. i must be less than q and j must be less then p.JFlint2unity_zpq_coeff_set_fmpz f i j x Sets the coefficient of \zeta_q^i \zeta_p^j to x. i must be less than q and j must be less than p.JFlint2unity_zpq_is_p_unity_generator f Returns nonzero if f% is a generator of the cyclic group \langle\zeta_p\rangle.JFlint2unity_zpq_is_p_unity f Returns nonzero if  f = \zeta_p^x.JFlint2unity_zpq_p_unity f If  f = \zeta_p^x returns x \in [0, p - 1]; otherwise returns p.JFlint2unity_zpq_equal f g Returns nonzero if f = g.JFlint2unity_zpq_swap f q Swaps f and g. f and g must be initialized with same p, q and n.JFlint2unity_zpq_copy f g Sets f to g. f and g must be initialized with same p, q and n.JFlint2unity_zpq_clear f Clears the given element. It must be reinitialized in order to be used again.JFlint2unity_zpq_init f q p n  Initializes f as an element of  \mathbb{Z}[\zeta_q, \zeta_p]/(n).JFlint2unity_zp_jacobi_sum_2q_two f q Sets f to the Jacobi sum (J_3(1) = j(chi_{2, q}, chi_{2, q}, chi_{2, q}) = J(2, q) cdot j(chi_{2, q}^2, chi_{2, q})).JFlint2unity_zp_jacobi_sum_2q_one f q Sets f to the Jacobi sum J_2(q) = j(\chi_{2, q}^{2^{k - 3}}, \chi_{2, q}^{3 \cdot 2^{k - 3}}))^2.JFlint2unity_zp_jacobi_sum_pq f q p Sets f to the Jacobi sum %J(p, q) = j(\chi_{p, q}, \chi_{p, q}).JFlint2unity_zp_aut_inv f g x Sets f = \sigma_x^{-1}(g), so \sigma_x(f) = g. g must be reduced by \Phi_{p^{exp}}. f and g$ must be initialized with the same p, exp and n.JFlint2 unity_zp_aut f g x Sets f = \sigma_x(g), the automorphism \sigma_x(\zeta)=\zeta^x. f and g# must be initialized with the same p, exp and n.JFlint2unity_zp_reduce_cyclotomic f g Sets f = g \bmod \Phi_{p^{exp}}. \Phi_{p^{exp}} is the p^{exp}-th cyclotomic polynomial.JFlint2_unity_zp_reduce_cyclotomic f Sets f = f \bmod \Phi_{p^{exp}}. \Phi_{p^{exp}} is the p^{exp}-th cyclotomic polynomial. g must be reduced by  x^{p^{exp}}-1 poly. f and g must be initialized with same p, exp and n.JFlint2"_unity_zp_reduce_cyclotomic_divmod f JFlint2unity_zp_pow_sliding_fmpz f g pow Sets f to g^{pow}2 using the sliding window exponentiation method. f and g must be initialized with same p, exp and n.JFlint2unity_zp_pow_2k_ui f g pow Sets f to g^{pow} using the 2^k-ary exponentiation method. f and g must be initialized with same p, exp and n.JFlint2unity_zp_pow_2k_fmpz f g pow Sets f to g^{pow} using the 2^k-ary exponentiation method. f and g must be initialized with same p, exp and n.JFlint2_unity_zp_pow_select_k n Returns the smallest integer k satisfying 5\log (n) < (k(k + 1)2^{2k}) / (2^{k + 1} - k - 2) + 1JFlint2unity_zp_pow_ui f g pow Sets f to g^{pow}. f and g must be initialized with same p, exp and n.JFlint2unity_zp_pow_fmpz f g pow Sets f to g^{pow}. f and g must be initialized with same p, exp and n.JFlint2unity_zp_sqr_inplace f g t Sets f to  g \cdot g. If "p^{exp} = 3, 4, 5, 7, 8, 9, 11, 16 special multiplication functions are used. The preallocated array t of fmpz_t, is used for all computations in this case. f and g must be initialized with same p, exp and n.JFlint2unity_zp_mul_inplace f g h t Sets f to  g \cdot h. If "p^{exp} = 3, 4, 5, 7, 8, 9, 11, 16 special multiplication functions are used. The preallocated array t of fmpz_t, is used for all computations in this case. f, g and h must be initialized with same p, exp and n.JFlint2 unity_zp_sqr f g Sets f to  g \cdot g. f, g and h must be initialized with same p, exp and n.JFlint2 unity_zp_mul f g h Sets f to  g \cdot h. f, g and h must be initialized with same p, exp and n.JFlint2 unity_zp_add f g h Sets f to g + h. f, g and h must be initialized with same p, exp and n.JFlint2unity_zp_mul_scalar_ui f g s Sets f to  s \cdot g. f and g must be initialized with same p, exp and n.JFlint2unity_zp_mul_scalar_fmpz f g s Sets f to  s \cdot g. f and g must be initialized with same p, exp and n.JFlint2unity_zp_coeff_dec f ind Decrements the coefficient of  \zeta^{ind}. ind must be less than p^{exp}.JFlint2unity_zp_coeff_inc f ind Increments the coefficient of  \zeta^{ind}. ind must be less than p^{exp}.JFlint2unity_zp_coeff_add_ui f ind x Adds x to the coefficient of  \zeta^{ind}. x must be less than n. ind must be less than p^{exp}.JFlint2unity_zp_coeff_add_fmpz f ind x JFlint2unity_zp_coeff_set_ui f ind x Sets the coefficient of  \zeta^{ind} to x. ind must be less than p^{exp}.JFlint2unity_zp_coeff_set_fmpz f ind x JFlint2unity_zp_equal f g Returns nonzero if f = g reduced by the p^{exp}-th cyclotomic polynomial.JFlint2unity_zp_is_unity f If  f = \zeta^h! returns h; otherwise returns -1.JFlint2unity_zp_set_zero f Sets f to zero.JFlint2 unity_zp_swap f q Swaps f and g. f and g must be initialized with same p and n.JFlint2 unity_zp_copy f g Sets f to g. f and g must be initialized with same p and n.JFlint2unity_zp_clear f Clears the given element. It must be reinitialised in order to be used again.JFlint2 unity_zp_init f p exp n  Initializes f as an element of \mathbb{Z}[\zeta_{p^{exp}}]/(n).JFlint2aprcl_config_jacobi_clear conf Clears the given  aprcl_config> element. It must be reinitialised in order to be used again.JFlint2aprcl_config_jacobi_init conf n  Computes the s and R0 values used in the cyclotomic primality test, s^2 > n and a^R \equiv 1 \mod{s} for all a coprime to s. Also stores factors of R and s.JFlint2 aprcl_R_value n Returns a precomputed R/ value for APRCL, such that the corresponding s value is greater than \sqrt{n}. The maximum stored value  6983776800 allows to test numbers up to 6000 digits.JFlint2aprcl_config_gauss_clear conf Clears the given  aprcl_config> element. It must be reinitialised in order to be used again.JFlint2aprcl_config_gauss_init_min_R conf n R  Computes the s with fixed minimum R such that a^R \equiv 1 \mod{s} for all integers a coprime to s.JFlint2aprcl_config_gauss_init conf n  Computes the s and R0 values used in the cyclotomic primality test, s^2 > n and 9s=\prod\limits_{\substack{q-1\mid R \\ q \text{ prime}}}q. Also stores factors of R and s.JFlint2aprcl_is_prime_final_division n s r Returns 0 if for some a = n^k \bmod s, where k \in [1, r - 1], we have that a \mid n; otherwise returns 1.JFlint2aprcl_is_prime_gauss_min_R n R Same as aprcl_is_prime_gauss with fixed minimum value of R.JFlint2_aprcl_is_prime_gauss n config Tests n for primality with fixed config. Possible return values: PRIME,  COMPOSITE and  PROBABPRIME (if we cannot prove primality).JFlint2_aprcl_is_prime_jacobi n config Jacobi sum test for n. Possible return values: PRIME,  COMPOSITE and UNKNOWN (if we cannot prove primality).JFlint2aprcl_is_prime_gauss n If n is prime returns 1; otherwise returns 0. Uses the cyclotomic primality testing algorithm described in "Four primality testing algorithms" by Rene Schoof. The minimum required numbers s and R are computed automatically. By default  R \ge 1803. In some cases this function fails to prove that n1 is prime. This means that we select a too small R value. In this event,  flint_abort+ is called. To handle this condition, the _aprcl_is_prime_jacobi function can be used.JFlint2aprcl_is_prime_jacobi n If n is prime returns 1; otherwise returns 0. The algorithm is well described in "Implementation of a New Primality Test" by H. Cohen and A.K. Lenstra and "A Course in Computational Algebraic Number Theory" by H. Cohen.It is theoretically possible that this function fails to prove that n is prime. In this event,  flint_abort+ is called. To handle this condition, the _aprcl_is_prime_jacobi function can be used.JFlint2aprcl_is_prime n Tests n: for primality using the APRCL test. This is the same as aprcl_is_prime_jacobi.JFlint2unity_zp_print f Prints the contents of the f.JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ Safe-Inferred )*1 zJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ Safe-Inferred )*1 JFlint2factor x Factor x into prime factors x = p_1^{e_1}\ldots p_n^{e_n} with the representation [(p_1, e_1) \ldots (p_n, e_n)]JFlint2 unfactor fFind x$ which has the unique factorization f.JJJJJJ Safe-Inferred )*1 m LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWLWWWWWWWWWWWWWWWWWWW Safe-Inferred )*1!4JJJJJJ Safe-Inferred )*1! Safe-Inferred )*1! LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWLWWWWWWWWWWWWWWWWWWW Safe-Inferred )*1! Safe-Inferred )*1! Safe-Inferred )*1!/KKKKKKKKKK Safe-Inferred )*1!$KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK$KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK Safe-Inferred )*1![   Safe-Inferred )*1!*KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK*KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK Safe-Inferred )*1! LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWLWWWWWWWWWWWWWWWWWWW   Safe-Inferred )*1!#Z LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWLWWWWWWWWWWWWWWWWWWW&&&& Safe-Inferred )*1!/!LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWLWWWWWWWWWWWWWWWWWWW  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))********************************************************************************************************************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--------------------------------------------------------------------------------------------------------------------------------............................................................................................................................////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111122222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333334444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555556666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777788888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""""""""""""""""""""""""""""""""""""""""""""""""""""""8""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""################################################################################################################################$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))**************@*@*@*@*@*@**************************B***********************************************************************************++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,----------------------K--------------------------------------------------------------------------------------------------------------..........................................................................................................................P........////////////////////////////////////////////////////S//////////////////////////////////////////////////////////////U U U/U/U/U///////////////0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222Z Z Z2Z2Z2222222222222222222222222222222222222222222222222233333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444445555555555555555555555555555555555555555555555555555555555555555555555555555555555555` ` `5`5`5`5`5555555555555555555555555555555555555556666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777c777777777777777777777777777777777777777777777777777777777777777777788888888888888888888888888888888888888888888888888888888888e888888888888888888888888888888888888888888888888888888888888888888888888899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<================================================================================================================================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK  KKKKKKKKKKKKKKKKKKKKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMLLMLLMLLMLMMLMMLLMLMMLMMLLMLMMLMMLLMLMMLMMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLMMLLMLLMLLMLLMLLMLLMLMMLMMLLMLLMLLMLLMLLMLLMLMMLMMLMMLMMLLMLLMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLMMLLMLMMLMMLMMLMMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLNLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLOLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLPLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLQLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLRLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLSLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLTLLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLULLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLVLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLWLLXLLXLXXLXXLXXLLXLLXLLXLLXLLXLLXLLXLLXLLXLXXLXXLXXLXXLLXLLXLLXLLXLLXLMXLMXLLXLLXFlint2-0.1.0.2-inplaceData.Number.Flint.Arb.FpWrap'Data.Number.Flint.Calcium.Fexpr.Builtin Data.Number.Flint.Flint.InternalData.Number.Flint.Flint Data.Number.Flint.Flint.ExternalData.Number.Flint.FFT"Data.Number.Flint.Calcium.Ca.TypesData.Number.Flint.Fq.Zech.Types"Data.Number.Flint.Groups.DirichletData.Number.Flint.NModData.Number.Flint.Groups.DLogData.Number.Flint.NMod.TypesData.Number.Flint.FmpzData.Number.Flint.NF.Fmpzi$Data.Number.Flint.NF.Fmpzi.InstancesData.Number.Flint.MPolyData.Number.Flint.NMod.MPoly#Data.Number.Flint.NMod.MPoly.FactorData.Number.Flint.Fq.NMod.TypesData.Number.Flint.Fq.NModData.Number.Flint.Fmpz.VecData.Number.Flint.Fmpz.ModData.Number.Flint.Fmpz.Mod.VecData.Number.Flint.Fmpz.FactorData.Number.Flint.Arb.TypesData.Number.Flint.HypgeomData.Number.Flint.Acb.TypesData.Number.Flint.CalciumData.Number.Flint.PartitionsData.Number.Flint.QSieveData.Number.Flint.QuotientData.Number.Flint.FmpqData.Number.Flint.PadicData.Number.Flint.NMod.VecData.Number.Flint.Fmpz.PolyData.Number.Flint.Fq.Types"Data.Number.Flint.Fmpz.Poly.Factor Data.Number.Flint.Fmpz.Mod.MPoly'Data.Number.Flint.Fmpz.Mod.MPoly.FactorData.Number.Flint.Fmpz.MPolyData.Number.Flint.Fmpz.MPoly.Q#Data.Number.Flint.Fmpz.MPoly.FactorData.Number.Flint.Fmpq.VecData.Number.Flint.Fmpq.PolyData.Number.Flint.Padic.PolyData.Number.Flint.QadicData.Number.Flint.NFData.Number.Flint.Fmpz.Poly.QData.Number.Flint.Fmpq.MPoly#Data.Number.Flint.Fmpq.MPoly.FactorData.Number.Flint.Calcium.FexprData.Number.Flint.BernoulliData.Number.Flint.Arb.MagData.Number.Flint.Arb.HypgeomData.Number.Flint.ArbData.Number.Flint.Arb.InstancesData.Number.Flint.Arb.CalcData.Number.Flint.Arb.ArfData.Number.Flint.AcbData.Number.Flint.Arb.PolyData.Number.Flint.Acb.PolyData.Number.Flint.Arb.Fmpz.PolyData.Number.Flint.Acb.Modular'Data.Number.Flint.Acb.Modular.InstancesData.Number.Flint.Acb.EllipticData.Number.Flint.Acb.InstancesData.Number.Flint.Acb.HypgeomData.Number.Flint.Acb.CalcData.Number.Flint.Acb.DirichletData.Number.Flint.Acb.DFTData.Number.Flint.Acb.Acf"Data.Number.Flint.Support.D.Extras$Data.Number.Flint.Support.D.IntervalData.Number.Flint.Support.D.Mat)Data.Number.Flint.Support.D.Mat.InstancesData.Number.Flint.Support.D.Vec!Data.Number.Flint.Support.Mpf.MatData.Number.Flint.Fmpz.MatData.Number.Flint.Groups.Qfb&Data.Number.Flint.Groups.Qfb.InstancesData.Number.Flint.Groups.Perm!Data.Number.Flint.Groups.Bool.Mat+Data.Number.Flint.Groups.Bool.Mat.InstancesData.Number.Flint.Fmpz.Poly.Mat$Data.Number.Flint.Fmpz.Mat.InstancesData.Number.Flint.Fmpz.ArithData.Number.Flint.Fmpq.MatData.Number.Flint.Padic.MatData.Number.Flint.NF.QQbar$Data.Number.Flint.NF.QQbar.Instances"Data.Number.Flint.Calcium.Ca.FieldData.Number.Flint.Calcium.Ca Data.Number.Flint.Calcium.Ca.Vec!Data.Number.Flint.Calcium.Ca.Poly Data.Number.Flint.Calcium.Ca.Ext$Data.Number.Flint.Fmpq.Mat.Instances Data.Number.Flint.Calcium.Ca.MatData.Number.Flint.Arb.Mat#Data.Number.Flint.Arb.Mat.InstancesData.Number.Flint.Acb.Mat#Data.Number.Flint.Acb.Mat.InstancesData.Number.Flint.Fmpz.LLL!Data.Number.Flint.Support.Mpf.Vec"Data.Number.Flint.Support.Mpfr.Mat"Data.Number.Flint.Support.Mpfr.Vec&Data.Number.Flint.Support.ULong.ExtrasData.Number.Flint.ThreadPoolData.Number.Flint.NMod.Poly.Mat"Data.Number.Flint.NMod.Poly.FactorData.Number.Flint.NMod.PolyData.Number.Flint.NMod.MatData.Number.Flint.Fq.NMod.EmbedData.Number.Flint.Fmpz.Mod.MatData.Number.Flint.Fmpz.Mod.PolyData.Number.Flint.NF.ElemData.Number.Flint.FqData.Number.Flint.Fq.VecData.Number.Flint.Fq.NMod.MatData.Number.Flint.Fq.ZechData.Number.Flint.Fq.Zech.VecData.Number.Flint.Fq.Zech.MatData.Number.Flint.Fq.Zech.EmbedData.Number.Flint.Fq.NMod.VecData.Number.Flint.Fq.MatData.Number.Flint.Fq.PolyData.Number.Flint.Fq.Zech.Poly%Data.Number.Flint.Fq.Zech.Poly.Factor Data.Number.Flint.Fq.Poly.FactorData.Number.Flint.Fq.NMod.Poly%Data.Number.Flint.Fq.NMod.Poly.FactorData.Number.Flint.Fq.NMod.MPoly&Data.Number.Flint.Fq.NMod.MPoly.FactorData.Number.Flint.Fq.Embed&Data.Number.Flint.Fmpz.Mod.Poly.FactorData.Number.Flint.APRCLData.Number.Flint.UFD%Data.Number.Flint.NMod.Poly.Instances Data.Number.Flint.Fmpz.Instances'Data.Number.Flint.Fmpz.Poly.Q.Instances%Data.Number.Flint.Fmpz.Poly.Instances Data.Number.Flint.Fmpq.Instances%Data.Number.Flint.Fmpq.Poly.Instances)Data.Number.Flint.Calcium.Fexpr.InstancesData.Number.Flint.Arb.RealField#Data.Number.Flint.Arb.Mag.Instances"Data.Number.Flint.Acb.ComplexField$Data.Number.Flint.Arb.Poly.Instances$Data.Number.Flint.Acb.Poly.Instances Data.Number.Flint.Arb.FpWrap.FFI$Data.Number.Flint.Flint.Internal.FFIData.Number.Flint.Flint.FFI)Data.Number.Flint.Flint.External.Mpfr.FFI(Data.Number.Flint.Flint.External.GMP.FFIData.Number.Flint.FFT.FFI&Data.Number.Flint.Calcium.Ca.Types.FFI#Data.Number.Flint.Fq.Zech.Types.FFI&Data.Number.Flint.Groups.Dirichlet.FFIData.Number.Flint.NMod.FFI!Data.Number.Flint.Groups.DLog.FFI Data.Number.Flint.NMod.Types.FFIData.Number.Flint.Fmpz.FFIData.Number.Flint.NF.Fmpzi.FFIData.Number.Flint.MPoly.FFI Data.Number.Flint.NMod.MPoly.FFI'Data.Number.Flint.NMod.MPoly.Factor.FFI#Data.Number.Flint.Fq.NMod.Types.FFIData.Number.Flint.Fq.NMod.FFIData.Number.Flint.Fmpz.Vec.FFIData.Number.Flint.Fmpz.Mod.FFI"Data.Number.Flint.Fmpz.Mod.Vec.FFI!Data.Number.Flint.Fmpz.Factor.FFIData.Number.Flint.Arb.Types.FFIData.Number.Flint.Hypgeom.FFIData.Number.Flint.Acb.Types.FFIData.Number.Flint.Calcium.FFI Data.Number.Flint.Partitions.FFIData.Number.Flint.QSieve.FFIData.Number.Flint.Fmpq.FFIData.Number.Flint.Padic.FFIData.Number.Flint.NMod.Vec.FFIData.Number.Flint.Fmpz.Poly.FFIData.Number.Flint.Fq.Types.FFI&Data.Number.Flint.Fmpz.Poly.Factor.FFI$Data.Number.Flint.Fmpz.Mod.MPoly.FFI+Data.Number.Flint.Fmpz.Mod.MPoly.Factor.FFI Data.Number.Flint.Fmpz.MPoly.FFI"Data.Number.Flint.Fmpz.MPoly.Q.FFI'Data.Number.Flint.Fmpz.MPoly.Factor.FFIData.Number.Flint.Fmpq.Vec.FFIData.Number.Flint.Fmpq.Poly.FFI Data.Number.Flint.Padic.Poly.FFIData.Number.Flint.Qadic.FFIData.Number.Flint.NF.FFI!Data.Number.Flint.Fmpz.Poly.Q.FFI Data.Number.Flint.Fmpq.MPoly.FFI'Data.Number.Flint.Fmpq.MPoly.Factor.FFI#Data.Number.Flint.Calcium.Fexpr.FFIData.Number.Flint.Bernoulli.FFIData.Number.Flint.Arb.Mag.FFI!Data.Number.Flint.Arb.Hypgeom.FFIData.Number.Flint.Arb.FFIData.Number.Flint.Arb.Calc.FFIData.Number.Flint.Arb.Arf.FFIData.Number.Flint.Acb.FFIData.Number.Flint.Arb.Poly.FFIData.Number.Flint.Acb.Poly.FFI#Data.Number.Flint.Arb.Fmpz.Poly.FFI!Data.Number.Flint.Acb.Modular.FFI"Data.Number.Flint.Acb.Elliptic.FFI!Data.Number.Flint.Acb.Hypgeom.FFIData.Number.Flint.Acb.Calc.FFI#Data.Number.Flint.Acb.Dirichlet.FFIData.Number.Flint.Acb.DFT.FFIData.Number.Flint.Acb.Acf.FFI&Data.Number.Flint.Support.D.Extras.FFI(Data.Number.Flint.Support.D.Interval.FFI#Data.Number.Flint.Support.D.Mat.FFI#Data.Number.Flint.Support.D.Vec.FFI%Data.Number.Flint.Support.Mpf.Mat.FFIData.Number.Flint.Fmpz.Mat.FFI Data.Number.Flint.Groups.Qfb.FFI!Data.Number.Flint.Groups.Perm.FFI%Data.Number.Flint.Groups.Bool.Mat.FFI#Data.Number.Flint.Fmpz.Poly.Mat.FFI Data.Number.Flint.Fmpz.Arith.FFIData.Number.Flint.Fmpq.Mat.FFIData.Number.Flint.Padic.Mat.FFIData.Number.Flint.NF.QQbar.FFI&Data.Number.Flint.Calcium.Ca.Field.FFI Data.Number.Flint.Calcium.Ca.FFI$Data.Number.Flint.Calcium.Ca.Vec.FFI%Data.Number.Flint.Calcium.Ca.Poly.FFI$Data.Number.Flint.Calcium.Ca.Ext.FFI$Data.Number.Flint.Calcium.Ca.Mat.FFIData.Number.Flint.Arb.Mat.FFIData.Number.Flint.Acb.Mat.FFIData.Number.Flint.Fmpz.LLL.FFI%Data.Number.Flint.Support.Mpf.Vec.FFI&Data.Number.Flint.Support.Mpfr.Mat.FFI&Data.Number.Flint.Support.Mpfr.Vec.FFI*Data.Number.Flint.Support.ULong.Extras.FFI Data.Number.Flint.ThreadPool.FFI#Data.Number.Flint.NMod.Poly.Mat.FFI&Data.Number.Flint.NMod.Poly.Factor.FFIData.Number.Flint.NMod.Poly.FFIData.Number.Flint.NMod.Mat.FFI#Data.Number.Flint.Fq.NMod.Embed.FFI"Data.Number.Flint.Fmpz.Mod.Mat.FFI#Data.Number.Flint.Fmpz.Mod.Poly.FFIData.Number.Flint.NF.Elem.FFIData.Number.Flint.Fq.FFIData.Number.Flint.Fq.Vec.FFI!Data.Number.Flint.Fq.NMod.Mat.FFIData.Number.Flint.Fq.Zech.FFI!Data.Number.Flint.Fq.Zech.Vec.FFI!Data.Number.Flint.Fq.Zech.Mat.FFI#Data.Number.Flint.Fq.Zech.Embed.FFI!Data.Number.Flint.Fq.NMod.Vec.FFIData.Number.Flint.Fq.Mat.FFIData.Number.Flint.Fq.Poly.FFI"Data.Number.Flint.Fq.Zech.Poly.FFI)Data.Number.Flint.Fq.Zech.Poly.Factor.FFI$Data.Number.Flint.Fq.Poly.Factor.FFI"Data.Number.Flint.Fq.NMod.Poly.FFI)Data.Number.Flint.Fq.NMod.Poly.Factor.FFI#Data.Number.Flint.Fq.NMod.MPoly.FFI*Data.Number.Flint.Fq.NMod.MPoly.Factor.FFIData.Number.Flint.Fq.Embed.FFI*Data.Number.Flint.Fmpz.Mod.Poly.Factor.FFIData.Number.Flint.APRCL.FFIData.Number.Flint FpWrapReturn _FpWrapReturn arb_fpwrap_cdouble_modular_delta!arb_fpwrap_cdouble_modular_lambdaarb_fpwrap_cdouble_modular_jarb_fpwrap_cdouble_dedekind_eta!arb_fpwrap_cdouble_jacobi_theta_4!arb_fpwrap_cdouble_jacobi_theta_3!arb_fpwrap_cdouble_jacobi_theta_2!arb_fpwrap_cdouble_jacobi_theta_1!arb_fpwrap_cdouble_elliptic_sigma arb_fpwrap_cdouble_elliptic_zeta!arb_fpwrap_cdouble_elliptic_inv_p#arb_fpwrap_cdouble_elliptic_p_primearb_fpwrap_cdouble_elliptic_parb_fpwrap_cdouble_elliptic_rjarb_fpwrap_cdouble_elliptic_rgarb_fpwrap_cdouble_elliptic_rf"arb_fpwrap_cdouble_elliptic_pi_inc!arb_fpwrap_cdouble_elliptic_e_incarb_fpwrap_cdouble_elliptic_farb_fpwrap_cdouble_elliptic_piarb_fpwrap_cdouble_elliptic_earb_fpwrap_cdouble_elliptic_karb_fpwrap_cdouble_agmarb_fpwrap_double_agmarb_fpwrap_cdouble_hypgeom_pfqarb_fpwrap_double_hypgeom_pfqarb_fpwrap_cdouble_hypgeom_2f1arb_fpwrap_double_hypgeom_2f1arb_fpwrap_cdouble_hypgeom_uarb_fpwrap_double_hypgeom_uarb_fpwrap_cdouble_hypgeom_1f1arb_fpwrap_double_hypgeom_1f1arb_fpwrap_cdouble_hypgeom_0f1arb_fpwrap_double_hypgeom_0f1arb_fpwrap_cdouble_spherical_yarb_fpwrap_double_legendre_rootarb_fpwrap_cdouble_legendre_qarb_fpwrap_double_legendre_qarb_fpwrap_cdouble_legendre_parb_fpwrap_double_legendre_parb_fpwrap_cdouble_hermite_harb_fpwrap_double_hermite_harb_fpwrap_cdouble_laguerre_larb_fpwrap_double_laguerre_larb_fpwrap_cdouble_gegenbauer_carb_fpwrap_double_gegenbauer_carb_fpwrap_cdouble_jacobi_parb_fpwrap_double_jacobi_parb_fpwrap_cdouble_chebyshev_uarb_fpwrap_double_chebyshev_uarb_fpwrap_cdouble_chebyshev_tarb_fpwrap_double_chebyshev_tarb_fpwrap_cdouble_coulomb_hnegarb_fpwrap_cdouble_coulomb_hposarb_fpwrap_cdouble_coulomb_garb_fpwrap_double_coulomb_garb_fpwrap_cdouble_coulomb_farb_fpwrap_double_coulomb_f$arb_fpwrap_double_airy_bi_prime_zeroarb_fpwrap_double_airy_bi_zero$arb_fpwrap_double_airy_ai_prime_zeroarb_fpwrap_double_airy_ai_zero arb_fpwrap_cdouble_airy_bi_primearb_fpwrap_double_airy_bi_primearb_fpwrap_cdouble_airy_biarb_fpwrap_double_airy_bi arb_fpwrap_cdouble_airy_ai_primearb_fpwrap_double_airy_ai_primearb_fpwrap_cdouble_airy_aiarb_fpwrap_double_airy_ai"arb_fpwrap_cdouble_bessel_k_scaled!arb_fpwrap_double_bessel_k_scaledarb_fpwrap_cdouble_bessel_karb_fpwrap_double_bessel_karb_fpwrap_cdouble_bessel_iarb_fpwrap_double_bessel_iarb_fpwrap_cdouble_bessel_yarb_fpwrap_double_bessel_yarb_fpwrap_cdouble_bessel_jarb_fpwrap_double_bessel_jarb_fpwrap_cdouble_dilogarb_fpwrap_double_dilogarb_fpwrap_cdouble_log_integralarb_fpwrap_double_log_integral arb_fpwrap_cdouble_cosh_integralarb_fpwrap_double_cosh_integral arb_fpwrap_cdouble_sinh_integralarb_fpwrap_double_sinh_integralarb_fpwrap_cdouble_cos_integralarb_fpwrap_double_cos_integralarb_fpwrap_cdouble_sin_integralarb_fpwrap_double_sin_integral"arb_fpwrap_cdouble_exp_integral_ei!arb_fpwrap_double_exp_integral_ei!arb_fpwrap_cdouble_exp_integral_e arb_fpwrap_double_exp_integral_earb_fpwrap_cdouble_beta_lowerarb_fpwrap_double_beta_lowerarb_fpwrap_cdouble_gamma_lowerarb_fpwrap_double_gamma_lowerarb_fpwrap_cdouble_gamma_upperarb_fpwrap_double_gamma_upperarb_fpwrap_cdouble_fresnel_carb_fpwrap_double_fresnel_carb_fpwrap_cdouble_fresnel_sarb_fpwrap_double_fresnel_sarb_fpwrap_double_erfcinvarb_fpwrap_double_erfinvarb_fpwrap_cdouble_erfiarb_fpwrap_double_erfiarb_fpwrap_cdouble_erfcarb_fpwrap_double_erfcarb_fpwrap_cdouble_erfarb_fpwrap_double_erfarb_fpwrap_cdouble_zeta_zeroarb_fpwrap_cdouble_hardy_zarb_fpwrap_cdouble_hardy_thetaarb_fpwrap_cdouble_riemann_xi arb_fpwrap_cdouble_dirichlet_etaarb_fpwrap_cdouble_polylogarb_fpwrap_double_polylogarb_fpwrap_cdouble_polygammaarb_fpwrap_double_polygammaarb_fpwrap_cdouble_log_barnes_garb_fpwrap_double_log_barnes_garb_fpwrap_cdouble_barnes_garb_fpwrap_double_barnes_garb_fpwrap_cdouble_lerch_phiarb_fpwrap_double_lerch_phiarb_fpwrap_cdouble_hurwitz_zetaarb_fpwrap_double_hurwitz_zetaarb_fpwrap_cdouble_zetaarb_fpwrap_double_zetaarb_fpwrap_cdouble_digammaarb_fpwrap_double_digammaarb_fpwrap_cdouble_lgammaarb_fpwrap_double_lgammaarb_fpwrap_cdouble_rgammaarb_fpwrap_double_rgammaarb_fpwrap_cdouble_gammaarb_fpwrap_double_gammaarb_fpwrap_cdouble_risingarb_fpwrap_double_risingarb_fpwrap_cdouble_lambertwarb_fpwrap_double_lambertwarb_fpwrap_cdouble_atanharb_fpwrap_double_atanharb_fpwrap_cdouble_acosharb_fpwrap_double_acosharb_fpwrap_cdouble_asinharb_fpwrap_double_asinharb_fpwrap_double_atan2arb_fpwrap_cdouble_atanarb_fpwrap_double_atanarb_fpwrap_cdouble_acosarb_fpwrap_double_acosarb_fpwrap_cdouble_asinarb_fpwrap_double_asinarb_fpwrap_cdouble_sinc_piarb_fpwrap_double_sinc_piarb_fpwrap_cdouble_cot_piarb_fpwrap_double_cot_piarb_fpwrap_cdouble_tan_piarb_fpwrap_double_tan_piarb_fpwrap_cdouble_cos_piarb_fpwrap_double_cos_piarb_fpwrap_cdouble_sin_piarb_fpwrap_double_sin_piarb_fpwrap_cdouble_sincarb_fpwrap_double_sincarb_fpwrap_cdouble_cscarb_fpwrap_double_cscarb_fpwrap_cdouble_secarb_fpwrap_double_secarb_fpwrap_cdouble_cotarb_fpwrap_double_cotarb_fpwrap_cdouble_tanarb_fpwrap_double_tanarb_fpwrap_cdouble_cosarb_fpwrap_double_cosarb_fpwrap_cdouble_sinarb_fpwrap_double_sinarb_fpwrap_cdouble_cbrtarb_fpwrap_double_cbrtarb_fpwrap_cdouble_rsqrtarb_fpwrap_double_rsqrtarb_fpwrap_cdouble_sqrtarb_fpwrap_double_sqrtarb_fpwrap_cdouble_powarb_fpwrap_double_powarb_fpwrap_cdouble_log1parb_fpwrap_double_log1parb_fpwrap_cdouble_logarb_fpwrap_double_logarb_fpwrap_cdouble_expm1arb_fpwrap_double_expm1arb_fpwrap_cdouble_exparb_fpwrap_double_expfpwrap_success fpwrap_unablefpwrap_accurate_partsfpwrap_correct_roundingfpwrap_work_limit FEXR_Builtin FEXPR_AGMFEXPR_AGMSequence FEXPR_Abs FEXPR_Acos FEXPR_Acosh FEXPR_Acot FEXPR_Acoth FEXPR_Acsc FEXPR_Acsch FEXPR_Add FEXPR_AiryAiFEXPR_AiryAiZero FEXPR_AiryBiFEXPR_AiryBiZeroFEXPR_AlgebraicNumberSerializedFEXPR_AlgebraicNumbers FEXPR_AllFEXPR_AnalyticContinuation FEXPR_AndFEXPR_AngleBracketsFEXPR_Approximation FEXPR_Arg FEXPR_ArgMaxFEXPR_ArgMaxUnique FEXPR_ArgMinFEXPR_ArgMinUnique FEXPR_Asec FEXPR_Asech FEXPR_Asin FEXPR_AsinhFEXPR_AsymptoticTo FEXPR_Atan FEXPR_Atan2 FEXPR_Atanh FEXPR_BarnesGFEXPR_BellNumberFEXPR_BernoulliBFEXPR_BernoulliPolynomialFEXPR_BernsteinEllipse FEXPR_BesselI FEXPR_BesselJFEXPR_BesselJZero FEXPR_BesselK FEXPR_BesselYFEXPR_BesselYZeroFEXPR_BetaFunctionFEXPR_Binomial FEXPR_BracesFEXPR_BracketsFEXPR_CC FEXPR_CallFEXPR_CallIndeterminateFEXPR_CardinalityFEXPR_CarlsonHypergeometricRFEXPR_CarlsonHypergeometricTFEXPR_CarlsonRCFEXPR_CarlsonRDFEXPR_CarlsonRFFEXPR_CarlsonRGFEXPR_CarlsonRJFEXPR_CartesianPowerFEXPR_CartesianProduct FEXPR_Case FEXPR_CasesFEXPR_CatalanConstant FEXPR_CeilFEXPR_CharacteristicFEXPR_ChebyshevTFEXPR_ChebyshevUFEXPR_ClosedComplexDiskFEXPR_ClosedOpenIntervalFEXPR_Coefficient FEXPR_ColumnFEXPR_ColumnMatrixFEXPR_CommutativeRingsFEXPR_ComplexBranchDerivativeFEXPR_ComplexDerivativeFEXPR_ComplexInfinitiesFEXPR_ComplexLimitFEXPR_ComplexSignedInfinitiesFEXPR_ComplexSingularityClosureFEXPR_ComplexZeroMultiplicityFEXPR_ConcatenationFEXPR_CongruentModFEXPR_ConjugateFEXPR_ConreyGenerator FEXPR_CosFEXPR_CosIntegral FEXPR_CoshFEXPR_CoshIntegral FEXPR_Cot FEXPR_CothFEXPR_CoulombCFEXPR_CoulombFFEXPR_CoulombGFEXPR_CoulombHFEXPR_CoulombSigma FEXPR_Csc FEXPR_Csch FEXPR_CsgnFEXPR_CurvePathFEXPR_Cyclotomic FEXPR_DecimalFEXPR_DedekindEtaFEXPR_DedekindEtaEpsilonFEXPR_DedekindSum FEXPR_Def FEXPR_Delta FEXPR_Delta_FEXPR_Derivative FEXPR_DetFEXPR_DiagonalMatrixFEXPR_DigammaFunctionFEXPR_DigammaFunctionZeroFEXPR_DirichletCharacterFEXPR_DirichletGroupFEXPR_DirichletLFEXPR_DirichletLZeroFEXPR_DirichletLambdaFEXPR_DiscreteLog FEXPR_Div FEXPR_DividesFEXPR_DivisorProductFEXPR_DivisorSigmaFEXPR_DivisorSumFEXPR_DoubleFactorialFEXPR_EisensteinEFEXPR_EisensteinG FEXPR_ElementFEXPR_EllipsisFEXPR_EllipticEFEXPR_EllipticKFEXPR_EllipticPiFEXPR_EllipticRootEFEXPR_Enclosure FEXPR_EqualFEXPR_EqualAndElementFEXPR_EqualNearestDecimalFEXPR_EqualQSeriesEllipsisFEXPR_Equivalent FEXPR_Erf FEXPR_Erfc FEXPR_Erfi FEXPR_Euler FEXPR_EulerEFEXPR_EulerPhiFEXPR_EulerPolynomialFEXPR_EulerQSeries FEXPR_Exists FEXPR_ExpFEXPR_ExpIntegralEFEXPR_ExpIntegralEiFEXPR_ExtendedRealNumbersFEXPR_FactorialFEXPR_FallingFactorial FEXPR_FalseFEXPR_Fibonacci FEXPR_FieldsFEXPR_FiniteField FEXPR_Floor FEXPR_ForFEXPR_FormalLaurentSeriesFEXPR_FormalPowerSeriesFEXPR_FormalPuiseuxSeriesFEXPR_FresnelCFEXPR_FresnelS FEXPR_Fun FEXPR_GCD FEXPR_GammaFEXPR_GaussLegendreWeightFEXPR_GaussSumFEXPR_GegenbauerCFEXPR_GeneralLinearGroupFEXPR_GeneralizedBernoulliB"FEXPR_GeneralizedRiemannHypothesisFEXPR_GlaisherConstantFEXPR_GoldenRatio FEXPR_GreaterFEXPR_GreaterEqualFEXPR_GreekGammaFEXPR_GreekGamma_ FEXPR_GreekPiFEXPR_GreekPi_ FEXPR_GuessFEXPR_HankelH1FEXPR_HankelH2FEXPR_HarmonicNumberFEXPR_HermiteHFEXPR_HilbertClassPolynomialFEXPR_HilbertMatrixFEXPR_HurwitzZetaFEXPR_Hypergeometric0F1"FEXPR_Hypergeometric0F1RegularizedFEXPR_Hypergeometric1F1"FEXPR_Hypergeometric1F1RegularizedFEXPR_Hypergeometric1F2"FEXPR_Hypergeometric1F2RegularizedFEXPR_Hypergeometric2F0FEXPR_Hypergeometric2F1"FEXPR_Hypergeometric2F1RegularizedFEXPR_Hypergeometric2F2"FEXPR_Hypergeometric2F2RegularizedFEXPR_Hypergeometric3F2"FEXPR_Hypergeometric3F2RegularizedFEXPR_HypergeometricUFEXPR_HypergeometricUStar"FEXPR_HypergeometricUStarRemainderFEXPR_IdentityMatrixFEXPR_Im FEXPR_ImpliesFEXPR_IncompleteBetaFEXPR_IncompleteBetaRegularizedFEXPR_IncompleteEllipticEFEXPR_IncompleteEllipticFFEXPR_IncompleteEllipticPiFEXPR_IndefiniteIntegralEqual FEXPR_InfimumFEXPR_InfinityFEXPR_IntegersGreaterEqualFEXPR_IntegersLessEqualFEXPR_IntegralFEXPR_IntersectionFEXPR_Interval FEXPR_IsEvenFEXPR_IsHolomorphicOnFEXPR_IsMeromorphicOn FEXPR_IsOdd FEXPR_IsPrime FEXPR_Item FEXPR_JacobiPFEXPR_JacobiSymbolFEXPR_JacobiThetaFEXPR_JacobiThetaEpsilonFEXPR_JacobiThetaPermutationFEXPR_JacobiThetaQFEXPR_KeiperLiLambdaFEXPR_KhinchinConstantFEXPR_KroneckerDeltaFEXPR_KroneckerSymbol FEXPR_LCMFEXPR_LaguerreLFEXPR_LambertW FEXPR_Lamda FEXPR_Lamda_ FEXPR_LandauG FEXPR_LatticeFEXPR_LeftLimitFEXPR_LegendrePFEXPR_LegendrePolynomialZeroFEXPR_LegendreSymbol FEXPR_LengthFEXPR_LerchPhi FEXPR_LessFEXPR_LessEqual FEXPR_LimitFEXPR_LiouvilleLambda FEXPR_List FEXPR_LogFEXPR_LogBarnesGFEXPR_LogBarnesGRemainderFEXPR_LogGammaFEXPR_LogIntegral FEXPR_LogicFEXPR_LowerGammaFEXPR_Matrices FEXPR_MatrixFEXPR_Matrix2x2 FEXPR_Max FEXPR_MaximumFEXPR_MeromorphicDerivativeFEXPR_MeromorphicLimit FEXPR_Min FEXPR_Minimum FEXPR_ModFEXPR_ModularGroupAction#FEXPR_ModularGroupFundamentalDomainFEXPR_ModularJFEXPR_ModularLambda$FEXPR_ModularLambdaFundamentalDomainFEXPR_MoebiusMu FEXPR_MulFEXPR_MultiZetaValueFEXPR_NN FEXPR_Neg FEXPR_NotFEXPR_NotElementFEXPR_NotEqual FEXPR_NumberE FEXPR_NumberI FEXPR_Omega FEXPR_Omega_ FEXPR_OneFEXPR_OpenClosedIntervalFEXPR_OpenComplexDiskFEXPR_OpenIntervalFEXPR_OpenRealBallFEXPR_OrFEXPR_Otherwise FEXPR_PSL2ZFEXPR_ParenthesesFEXPR_PartitionsP FEXPR_Path FEXPR_Phi FEXPR_Phi_FEXPR_Pi FEXPR_Pol FEXPR_Poles FEXPR_PolyLogFEXPR_PolynomialFEXPR_PolynomialDegreeFEXPR_PolynomialFractionsFEXPR_PolynomialRootIndexedFEXPR_PolynomialRootNearestFEXPR_Polynomials FEXPR_Pos FEXPR_Pow FEXPR_Prime FEXPR_PrimePiFEXPR_PrimeProductFEXPR_PrimeSum FEXPR_Primes"FEXPR_PrimitiveDirichletCharacters:FEXPR_PrimitiveReducedPositiveIntegralBinaryQuadraticForms FEXPR_ProductFEXPR_ProjectiveComplexNumbersFEXPR_ProjectiveRealNumbers FEXPR_Psi FEXPR_Psi_FEXPR_QQFEXPR_QSeriesCoefficientFEXPR_QuotientRingFEXPR_RR FEXPR_RangeFEXPR_Re FEXPR_RealAbsFEXPR_RealAlgebraicNumbersFEXPR_RealBallFEXPR_RealDerivativeFEXPR_RealInfinitiesFEXPR_RealLimitFEXPR_RealSignedInfinitiesFEXPR_RealSingularityClosure FEXPR_Repeat FEXPR_ResidueFEXPR_RiemannHypothesisFEXPR_RiemannXiFEXPR_RiemannZetaFEXPR_RiemannZetaZeroFEXPR_RightLimit FEXPR_RingsFEXPR_RisingFactorial FEXPR_RootFEXPR_RootOfUnity FEXPR_RowFEXPR_RowMatrix FEXPR_SL2Z FEXPR_Same FEXPR_Sec FEXPR_SechFEXPR_SequenceLimitFEXPR_SequenceLimitInferiorFEXPR_SequenceLimitSuperior FEXPR_Ser FEXPR_SetFEXPR_SetMinus FEXPR_SetsFEXPR_ShowExpandedNormalForm FEXPR_Sigma FEXPR_Sigma_ FEXPR_Sign FEXPR_SignExtendedComplexNumbers FEXPR_SinFEXPR_SinIntegral FEXPR_SincFEXPR_SingularValues FEXPR_SinhFEXPR_SinhIntegral FEXPR_SloaneAFEXPR_SolutionsFEXPR_SpecialLinearGroupFEXPR_SpectrumFEXPR_SphericalHarmonicY FEXPR_SqrtFEXPR_SquaresR FEXPR_StepFEXPR_StieltjesGammaFEXPR_StirlingCycleFEXPR_StirlingS1FEXPR_StirlingS2FEXPR_StirlingSeriesRemainder FEXPR_SubFEXPR_Subscript FEXPR_SubsetFEXPR_SubsetEqual FEXPR_Subsets FEXPR_SumFEXPR_SupremumFEXPR_SymmetricPolynomial FEXPR_Tan FEXPR_Tanh FEXPR_Theta FEXPR_Theta_ FEXPR_True FEXPR_Tuple FEXPR_TuplesFEXPR_Undefined FEXPR_UnionFEXPR_UniqueSolutionFEXPR_UniqueZeroFEXPR_UnitCircle FEXPR_UnknownFEXPR_UnsignedInfinityFEXPR_UpperGammaFEXPR_UpperHalfPlaneFEXPR_WeierstrassPFEXPR_WeierstrassSigmaFEXPR_WeierstrassZeta FEXPR_Where FEXPR_XGCDFEXPR_XXFEXPR_Xi FEXPR_Xi_FEXPR_ZZ FEXPR_ZeroFEXPR_ZeroMatrix FEXPR_Zeros FEXPR_alpha FEXPR_alpha_ FEXPR_beta FEXPR_beta_ FEXPR_chi FEXPR_chi_ FEXPR_delta FEXPR_delta_ FEXPR_ell FEXPR_ell_ FEXPR_epsilonFEXPR_epsilon_ FEXPR_eta FEXPR_eta_ FEXPR_gamma FEXPR_gamma_ FEXPR_iota FEXPR_iota_ FEXPR_kappa FEXPR_kappa_ FEXPR_lamda FEXPR_lamda_FEXPR_mu FEXPR_mu_FEXPR_nu FEXPR_nu_ FEXPR_omega FEXPR_omega_ FEXPR_phi FEXPR_phi_FEXPR_pi FEXPR_pi_ FEXPR_rho FEXPR_rho_ FEXPR_sigma FEXPR_sigma_ FEXPR_tau FEXPR_tau_ FEXPR_theta FEXPR_theta_ FEXPR_varphi FEXPR_varphi_FEXPR_varthetaFEXPR_vartheta_FEXPR_xi FEXPR_xi_ FEXPR_zeta FEXPR_zeta_fexpr_builtin_lookupfexpr_builtin_namefexpr_builtin_lengthfexpr_builtin_hashfexpr_builtin_hash_name$fShowFEXR_Builtin$fEqFEXR_Builtin$fEnumFEXR_Builtin$fOrdFEXR_BuiltinCFBitCntFlintCFlint printCStr printCVec CFRandState FRandStateflint_reset_num_workersflint_set_num_workersflint_get_num_threadsflint_set_num_threadsflint_randclearflint_randinitflint_rand_freeflint_rand_alloc flint_calloc flint_realloc flint_malloc flint_bits newFRandStatewithFRandState CMpfrPrec _MpfrPrecCMpfrRnd_MpfrRndCMpfrMpfr CGmpRandstate GmpRandstateCMpfMpfCMpqMpqCMpzMpzCMpMp CMpBitCntCMpSizeCMpSLimbCMpLimbfft_convolution_precache fft_precachefft_convolutionflint_mpn_mul_fft_mainmul_mfa_truncate_sqrt2mul_truncate_sqrt2fft_mulmod_2expp1fft_adjust_limbs_fft_mulmod_2expp1fft_naive_convolution_1ifft_negacyclicfft_negacyclicifft_mfa_truncate_sqrt2_outerfft_mfa_truncate_sqrt2_innerfft_mfa_truncate_sqrt2_outerifft_mfa_truncate_sqrt2fft_mfa_truncate_sqrt2ifft_truncate1_twiddlefft_truncate1_twiddleifft_radix2_twiddlefft_radix2_twiddleifft_butterfly_twiddlefft_butterfly_twiddleifft_truncate_sqrt2fft_truncate_sqrt2ifft_butterfly_sqrt2fft_butterfly_sqrt2ifft_truncate1 ifft_truncate ifft_radix2 fft_truncate1 fft_truncate fft_radix2ifft_butterfly fft_butterflybutterfly_rshBbutterfly_lshBfft_adjust_sqrt2 fft_adjustmpn_div_2expmod_2expp1mpn_mul_2expmod_2expp1mpn_normmod_2expp1mpn_addmod_2expp1_1mpn_negmod_2expp1 fermat_to_mpzfft_combine_bitsfft_combine_limbsfft_split_bitsfft_split_limbsCFexpr CCaExtCache CaExtCacheCCaExtCaExt CCaFieldCache CaFieldCacheCCaFieldCaField CCaPolyVec CaPolyVecCCaPolyCaPolyCCaMatCaMatCCaVecCaVecCCaCtxCaCtx CCaFactorCaFactorCCaCa CFqZechMat FqZechMatCFqZechPolyFactorFqZechPolyFactor CFqZechPoly FqZechPoly CFqZechCtx FqZechCtxCFqZechFqZechCDirichletChar DirichletCharCDirichletGroupDirichletGroupdirichlet_char_lowerdirichlet_char_liftdirichlet_char_powdirichlet_char_muldirichlet_chi_vec_orderdirichlet_chi_vec dirichlet_chidirichlet_pairing_chardirichlet_pairingdirichlet_char_is_primitivedirichlet_char_is_realdirichlet_order_chardirichlet_order_uidirichlet_parity_chardirichlet_parity_uidirichlet_conductor_chardirichlet_conductor_uidirichlet_char_is_principaldirichlet_char_eq_deepdirichlet_char_eqdirichlet_char_indexdirichlet_index_chardirichlet_char_next_primitivedirichlet_char_nextdirichlet_char_setdirichlet_char_first_primitivedirichlet_char_one_dirichlet_char_expdirichlet_char_expdirichlet_char_logdirichlet_char_cleardirichlet_char_initdirichlet_group_dlog_cleardirichlet_group_dlog_precomputedirichlet_group_num_primitivedirichlet_group_sizedirichlet_group_cleardirichlet_subgroup_initdirichlet_group_initnewDirichletGroupwithDirichletGroupwithNewDirichletGroupnewDirichletCharwithDirichletCharwithNewDirichletChardirichlet_char_printCNModDiscreteLogPohligHellmanNModDiscreteLogPohligHellmanCNModNMod$nmod_discrete_log_pohlig_hellman_run/nmod_discrete_log_pohlig_hellman_primitive_root1nmod_discrete_log_pohlig_hellman_precompute_prime&nmod_discrete_log_pohlig_hellman_clear%nmod_discrete_log_pohlig_hellman_init nmod_pow_uinmod_divnmod_inv_nmod_mul_fullwordnmod_mulnmod_negnmod_sub _nmod_subnmod_add _nmod_add nmod_initnewNModwithNMod withNewNMod CDLogPrecomp DLogPrecompdlog_vec_sievedlog_vec_sieve_adddlog_vec_eratos_adddlog_vec_eratosdlog_vec_loop_add dlog_vec_loop dlog_vec_adddlog_vecdlog_vec_set_not_found dlog_vec_filldlog_precomp_small_initdlog_precomp_pe_initdlog_precomp_p_initdlog_precomp_modpe_initdlog_precomp_clear dlog_precompdlog_precomp_n_init dlog_oncenewDLogPrecompNnewDLogPrecompModpenewDLogPrecompPnewDLogPrecompPEnewDLogPrecompSmallwithDLogPrecomp CNModPolyMat NModPolyMatCNModMatNModMatCNModPolyFactorNModPolyFactor CNModPolyNModPoly CFmpzFactor FmpzFactor CFmpzMultiCRT FmpzMultiCRT CFmpzCombTemp FmpzCombTemp CFmpzCombFmpzComb CFmpzPreInvN FmpzPreInvNCFmpzFmpzfmpz_divisor_sigmafmpz_factor_divisor_sigmafmpz_moebius_mufmpz_factor_moebius_mufmpz_euler_phifmpz_factor_euler_phifmpz_primorialfmpz_nextprime%fmpz_divisor_in_residue_class_lenstrafmpz_lucas_chain_VtoUfmpz_lucas_chain_mulfmpz_lucas_chain_addfmpz_lucas_chain_doublefmpz_lucas_chain_fullfmpz_lucas_chain fmpz_is_prime_fmpz_np1_trial_factorsfmpz_is_prime_morrison_fmpz_nm1_trial_factorsfmpz_is_prime_pocklingtonfmpz_is_prime_pseudosquarefmpz_is_probabprimefmpz_is_probabprime_BPSWfmpz_is_probabprime_lucasfmpz_is_strong_probabprimefmpz_multi_CRT_clearfmpz_multi_CRTfmpz_multi_CRT_precompfmpz_multi_CRT_precomputefmpz_multi_CRT_initfmpz_comb_temp_clearfmpz_comb_clearfmpz_comb_temp_initfmpz_comb_initfmpz_multi_CRT_uifmpz_multi_mod_uifmpz_CRT fmpz_CRT_ui fmpz_popcntfmpz_xorfmpz_orfmpz_and fmpz_combit fmpz_clrbitfmpz_complementfmpz_bit_unpack_unsignedfmpz_bit_unpack fmpz_bit_packfmpz_divides_mod_listfmpz_kronecker fmpz_jacobi fmpz_negmod fmpz_invmod fmpz_remove _fmpz_removefmpz_xgcd_partialfmpz_xgcd_canonical_bezout fmpz_xgcd fmpz_gcdinvfmpz_lcm fmpz_gcd3fmpz_gcd fmpz_gcd_uifmpz_mul_si_tdiv_q_2expfmpz_mul_tdiv_q_2expfmpz_rfac_uiui fmpz_rfac_ui _fmpz_rfac_ui fmpz_bin_uiui fmpz_fib_ui fmpz_fac_uifmpz_is_perfect_power fmpz_rootfmpz_is_square fmpz_sqrtrem fmpz_sqrt fmpz_sqrtmod fmpz_dlog fmpz_flog fmpz_clog_ui fmpz_clog fmpz_powm fmpz_powm_ui fmpz_pow_fmpz fmpz_pow_uifmpz_fdiv_qr_preinvnfmpz_preinvn_clearfmpz_preinvn_init fmpz_smod fmpz_mod_uifmpz_mod fmpz_dividesfmpz_divisible_sifmpz_divisiblefmpz_divexact2_uiuifmpz_divexact_uifmpz_divexact_si fmpz_divexact fmpz_tdiv_ui fmpz_fdiv_ui fmpz_cdiv_uifmpz_tdiv_r_2expfmpz_fdiv_r_2expfmpz_cdiv_r_2exp fmpz_fdiv_rfmpz_tdiv_q_2expfmpz_fdiv_q_2expfmpz_cdiv_q_2expfmpz_tdiv_q_uifmpz_fdiv_q_uifmpz_cdiv_q_uifmpz_tdiv_q_sifmpz_fdiv_q_sifmpz_cdiv_q_si fmpz_tdiv_q fmpz_fdiv_q fmpz_cdiv_q fmpz_ndiv_qr fmpz_tdiv_qr fmpz_fdiv_qr fmpz_cdiv_qr fmpz_fmms fmpz_fmmafmpz_submul_sifmpz_submul_ui fmpz_submulfmpz_addmul_sifmpz_addmul_ui fmpz_addmul fmpz_one_2exp fmpz_mul_2expfmpz_mul2_uiui fmpz_mul_si fmpz_mul_uifmpz_mul fmpz_sub_si fmpz_sub_uifmpz_sub fmpz_add_si fmpz_add_uifmpz_addfmpz_absfmpz_neg fmpz_is_odd fmpz_is_even fmpz_is_pm1 fmpz_is_one fmpz_is_zero fmpz_equal_si fmpz_equal_ui fmpz_equal fmpz_cmp2abs fmpz_cmpabs fmpz_cmp_si fmpz_cmp_uifmpz_cmpfmpz_abs_ubound_ui_2expfmpz_abs_lbound_ui_2exp fmpz_tstbit fmpz_setbit fmpz_fits_sifmpz_abs_fits_uifmpz_one fmpz_zerofmpz_set fmpz_swap fmpz_val2fmpz_sgn fmpz_size fmpz_bitsfmpz_sizeinbase fmpz_out_raw fmpz_fprint fmpz_inp_raw fmpz_fread fmpz_readfmpz_clear_readonlyfmpz_init_set_readonlyflint_mpz_clear_readonlyflint_mpz_init_set_readonlyfmpz_set_ui_smod fmpz_set_str fmpz_set_mpzfmpz_get_signed_uiuifmpz_get_signed_ui_arrayfmpz_get_ui_arrayfmpz_set_signed_ui_arrayfmpz_set_ui_arrayfmpz_set_signed_uiuiuifmpz_set_signed_uiui fmpz_neg_uiui fmpz_set_uiui fmpz_neg_uifmpz_set_d_2exp fmpz_set_d fmpz_set_ui fmpz_set_si fmpz_get_str fmpz_get_mpn fmpz_get_mpzfmpz_get_d_2exp fmpz_get_mpfr fmpz_get_mpf fmpz_set_mpf fmpz_get_d fmpz_get_nmod fmpz_get_uiui fmpz_get_ui fmpz_get_sifmpz_randprimefmpz_randtest_mod_signedfmpz_randtest_mod fmpz_randmfmpz_randtest_not_zerofmpz_randtest_unsigned fmpz_randtest fmpz_randbitsfmpz_init_set_sifmpz_init_set_ui fmpz_init_set fmpz_clear fmpz_init2 fmpz_init_fmpz_demote_val _fmpz_demote_fmpz_promote_val _fmpz_promote _fmpz_cleanup_fmpz_cleanup_mpz_content _fmpz_new_mpznewFmpzwithFmpz withNewFmpz fmpz_print newFmpzComb withFmpzCombnewFmpzCombTempwithFmpzCombTempnewFmpzMultiCRTwithFmpzMultiCRTCFmpziFmpzifmpzi_gcd_euclideanfmpzi_remove_one_plus_ifmpzi_divrem_approx fmpzi_divremfmpzi_divexact fmpzi_pow_ui fmpzi_mul fmpzi_sqr fmpzi_sub fmpzi_add fmpzi_neg fmpzi_conj fmpzi_norm fmpzi_bitsfmpzi_canonicalise_unitfmpzi_canonical_unit_i_pow fmpzi_is_unit fmpzi_is_one fmpzi_is_zero fmpzi_equalfmpzi_randtest fmpzi_fprint fmpzi_get_strfmpzi_set_si_si fmpzi_set fmpzi_one fmpzi_zero fmpzi_swap fmpzi_clear fmpzi_initnewFmpzi newFmpzi_ withFmpzi withFmpziReal withFmpziImag withNewFmpzi fmpzi_printlift1lift2 $fNumFmpzi $fEqFmpzi $fShowFmpzi COrdering _Ordering CMPolyCtxMPolyCtx_mpoly_heap_pop1_mpoly_heap_pop_mpoly_heap_insert1_mpoly_heap_insertmpoly_main_variable_terms1mpoly_unpack_monomials_tightmpoly_pack_monomials_tightmpoly_repack_monomialsmpoly_unpack_vec_fmpzmpoly_unpack_vec_uimpoly_pack_vec_fmpzmpoly_pack_vec_uimpoly_set_monomial_pfmpzmpoly_set_monomial_ffmpzmpoly_set_monomial_uimpoly_get_monomial_pfmpzmpoly_get_monomial_ffmpzmpoly_get_monomial_uimpoly_term_exp_fits_simpoly_term_exp_fits_uimpoly_search_monomialsmpoly_monomial_existsmpoly_max_degrees_tightmpoly_max_fields_fmpzmpoly_max_fields_ui_spmpoly_exp_bits_required_pfmpzmpoly_exp_bits_required_ffmpzmpoly_exp_bits_required_uimpoly_monomial_divides_tightmpoly_monomial_divides1mpoly_monomial_divides_mpmpoly_monomial_dividesmpoly_monomial_cmpmpoly_monomial_gtmpoly_monomial_ltmpoly_get_cmpmaskmpoly_monomial_equalmpoly_monomial_is_zerompoly_monomial_mul_uimpoly_monomial_swapmpoly_monomial_setmpoly_monomial_overflows1mpoly_monomial_overflows_mpmpoly_monomial_overflowsmpoly_monomial_sub_mpmpoly_monomial_submpoly_monomial_add_mpmpoly_monomial_addmpoly_ordering_printmpoly_ordering_isrevmpoly_ordering_isdegmpoly_ctx_init_randmpoly_ordering_randtestmpoly_ctx_clearmpoly_ctx_init newMPolyCtx withMPolyCtxord_lex ord_deglex ord_degrevlex CNModMPolyCtx NModMPolyCtx CNModMPoly NModMPoly&nmod_mpoly_divrem_ideal_monagan_pearce nmod_mpoly_divrem_monagan_pearcenmod_mpoly_div_monagan_pearcenmod_mpoly_pow_rmul!nmod_mpoly_univar_swap_term_coeff nmod_mpoly_univar_get_term_coeff!nmod_mpoly_univar_get_term_exp_sinmod_mpoly_univar_length nmod_mpoly_univar_degree_fits_sinmod_mpoly_from_univarnmod_mpoly_to_univarnmod_mpoly_univar_swapnmod_mpoly_univar_clearnmod_mpoly_univar_initnmod_mpoly_quadratic_rootnmod_mpoly_is_squarenmod_mpoly_sqrtnmod_mpoly_discriminantnmod_mpoly_resultantnmod_mpoly_gcd_zippelnmod_mpoly_gcd_henselnmod_mpoly_gcd_brownnmod_mpoly_gcd_cofactorsnmod_mpoly_gcdnmod_mpoly_content_varsnmod_mpoly_term_content nmod_mpoly_divides_heap_threaded!nmod_mpoly_divides_monagan_pearcenmod_mpoly_divides_densenmod_mpoly_divrem_idealnmod_mpoly_divremnmod_mpoly_divnmod_mpoly_dividesnmod_mpoly_pow_uinmod_mpoly_pow_fmpznmod_mpoly_mul_densenmod_mpoly_mul_array_threadednmod_mpoly_mul_arraynmod_mpoly_mul_heap_threadednmod_mpoly_mul_johnsonnmod_mpoly_mul!nmod_mpoly_compose_nmod_mpoly_gennmod_mpoly_compose_nmod_mpoly$nmod_mpoly_compose_nmod_mpoly_horner'nmod_mpoly_compose_nmod_mpoly_geobucketnmod_mpoly_compose_nmod_polynmod_mpoly_evaluate_one_uinmod_mpoly_evaluate_all_uinmod_mpoly_derivativenmod_mpoly_make_monicnmod_mpoly_scalar_mul_uinmod_mpoly_negnmod_mpoly_subnmod_mpoly_addnmod_mpoly_sub_uinmod_mpoly_add_uinmod_mpoly_randtest_bitsnmod_mpoly_randtest_boundsnmod_mpoly_randtest_boundnmod_mpoly_reversenmod_mpoly_combine_like_termsnmod_mpoly_sort_termsnmod_mpoly_push_term_ui_uinmod_mpoly_push_term_ui_fmpznmod_mpoly_get_term_monomialnmod_mpoly_get_termnmod_mpoly_set_term_exp_uinmod_mpoly_set_term_exp_fmpznmod_mpoly_get_term_var_exp_sinmod_mpoly_get_term_var_exp_uinmod_mpoly_get_term_exp_sinmod_mpoly_get_term_exp_uinmod_mpoly_get_term_exp_fmpznmod_mpoly_term_exp_fits_uinmod_mpoly_term_exp_fits_sinmod_mpoly_set_term_coeff_uinmod_mpoly_get_term_coeff_uinmod_mpoly_resizenmod_mpoly_lengthnmod_mpoly_is_canonicalnmod_mpoly_term_coeff_refnmod_mpoly_cmpnmod_mpoly_get_coeff_vars_uinmod_mpoly_set_coeff_ui_uinmod_mpoly_set_coeff_ui_fmpznmod_mpoly_get_coeff_ui_uinmod_mpoly_get_coeff_ui_fmpz nmod_mpoly_set_coeff_ui_monomial nmod_mpoly_get_coeff_ui_monomialnmod_mpoly_used_varsnmod_mpoly_total_degree_sinmod_mpoly_total_degree_fmpznmod_mpoly_total_degree_fits_sinmod_mpoly_degree_sinmod_mpoly_degree_fmpznmod_mpoly_degrees_sinmod_mpoly_degrees_fmpznmod_mpoly_degrees_fit_sinmod_mpoly_is_onenmod_mpoly_is_zeronmod_mpoly_equal_uinmod_mpoly_onenmod_mpoly_zeronmod_mpoly_set_uinmod_mpoly_get_uinmod_mpoly_is_uinmod_mpoly_swapnmod_mpoly_equalnmod_mpoly_setnmod_mpoly_is_gennmod_mpoly_gennmod_mpoly_set_str_prettynmod_mpoly_fprint_prettynmod_mpoly_get_str_prettynmod_mpoly_clearnmod_mpoly_reallocnmod_mpoly_fit_lengthnmod_mpoly_init3nmod_mpoly_init2nmod_mpoly_initnmod_mpoly_ctx_clearnmod_mpoly_ctx_modulusnmod_mpoly_ctx_ordnmod_mpoly_ctx_nvarsnmod_mpoly_ctx_init newNModMPoly withNModMPolynewNModMPolyCtxwithNModMPolyCtxnmod_mpoly_print_prettyCNModMPolyFactorNModMPolyFactornmod_mpoly_factornmod_mpoly_factor_squarefreenmod_mpoly_factor_sortnmod_mpoly_factor_get_exp_sinmod_mpoly_factor_swap_basenmod_mpoly_factor_get_base!nmod_mpoly_factor_get_constant_uinmod_mpoly_factor_lengthnmod_mpoly_factor_swapnmod_mpoly_factor_clearnmod_mpoly_factor_initnewNModMPolyFactorwithNModMPolyFactor CFqNModMat FqNModMat CFqNModMPoly FqNModMPolyCFqNModPolyFactorFqNModPolyFactor CFqNModPoly FqNModPoly CFqNModCtx FqNModCtxCFqNModFqNModfq_nmod_bit_unpackfq_nmod_bit_packfq_nmod_is_primitivefq_nmod_multiplicative_orderfq_nmod_frobenius_fq_nmod_frobenius fq_nmod_norm _fq_nmod_norm fq_nmod_trace_fq_nmod_trace fq_nmod_cmpfq_nmod_is_invertible_ffq_nmod_is_invertible fq_nmod_equalfq_nmod_is_onefq_nmod_is_zerofq_nmod_set_nmod_matfq_nmod_get_nmod_matfq_nmod_set_nmod_polyfq_nmod_get_nmod_polyfq_nmod_get_fmpz fq_nmod_gen fq_nmod_one fq_nmod_zero fq_nmod_swapfq_nmod_set_fmpzfq_nmod_set_uifq_nmod_set_si fq_nmod_setfq_nmod_rand_not_zero fq_nmod_randfq_nmod_randtest_densefq_nmod_randtest_not_zerofq_nmod_randtestfq_nmod_get_str_prettyfq_nmod_get_strfq_nmod_fprintfq_nmod_fprint_prettyfq_nmod_is_squarefq_nmod_pth_root fq_nmod_sqrtfq_nmod_pow_ui fq_nmod_pow _fq_nmod_powfq_nmod_gcdinv fq_nmod_inv _fq_nmod_inv fq_nmod_sqrfq_nmod_mul_uifq_nmod_mul_sifq_nmod_mul_fmpz fq_nmod_mul fq_nmod_negfq_nmod_sub_one fq_nmod_sub fq_nmod_addfq_nmod_reduce_fq_nmod_reduce_fq_nmod_dense_reduce_fq_nmod_sparse_reduce fq_nmod_clear fq_nmod_init2 fq_nmod_initfq_nmod_ctx_randtest_reduciblefq_nmod_ctx_randtestfq_nmod_ctx_fprintfq_nmod_ctx_orderfq_nmod_ctx_degreefq_nmod_ctx_modulusfq_nmod_ctx_clearfq_nmod_ctx_init_modulusfq_nmod_ctx_init_conway_fq_nmod_ctx_init_conwayfq_nmod_ctx_init newFqNMod withFqNMod newFqNModCtxnewFqNModCtxConwaynewFqNModCtxModulus withFqNModCtxfq_nmod_ctx_printfq_nmod_print_pretty fq_nmod_print_fmpz_vec_dot_ptr _fmpz_vec_dot _fmpz_vec_lcm_fmpz_vec_content_chained_fmpz_vec_content_fmpz_vec_scalar_smod_fmpz_fmpz_vec_scalar_mod_fmpz_fmpz_vec_prod _fmpz_vec_sum_fmpz_vec_scalar_submul_si_2exp_fmpz_vec_scalar_submul_si_fmpz_vec_scalar_submul_fmpz_fmpz_vec_scalar_addmul_si_2exp_fmpz_vec_scalar_addmul_fmpz_fmpz_vec_scalar_addmul_ui_fmpz_vec_scalar_addmul_si_fmpz_vec_scalar_tdiv_q_2exp_fmpz_vec_scalar_tdiv_q_ui_fmpz_vec_scalar_tdiv_q_si_fmpz_vec_scalar_tdiv_q_fmpz_fmpz_vec_scalar_fdiv_r_2exp_fmpz_vec_scalar_fdiv_q_2exp_fmpz_vec_scalar_fdiv_q_ui_fmpz_vec_scalar_fdiv_q_si_fmpz_vec_scalar_fdiv_q_fmpz_fmpz_vec_scalar_divexact_ui_fmpz_vec_scalar_divexact_si_fmpz_vec_scalar_divexact_fmpz_fmpz_vec_scalar_mul_2exp_fmpz_vec_scalar_mul_ui_fmpz_vec_scalar_mul_si_fmpz_vec_scalar_mul_fmpz _fmpz_vec_sub _fmpz_vec_add_fmpz_vec_sort_fmpz_vec_max_inplace _fmpz_vec_max_fmpz_vec_is_zero_fmpz_vec_equal_fmpz_vec_scalar_abs _fmpz_vec_neg_fmpz_vec_zero_fmpz_vec_swap _fmpz_vec_set_fmpz_vec_get_d_vec_2exp_fmpz_vec_set_fft_fmpz_vec_get_fft_fmpz_vec_set_nmod_vec_fmpz_vec_get_nmod_vec_fmpz_vec_fprint_fmpz_vec_read_fmpz_vec_fread_fmpz_vec_get_str_fmpz_vec_height_index_fmpz_vec_height_fmpz_vec_max_limbs_fmpz_vec_sum_max_bits_fmpz_vec_max_bits_ref_fmpz_vec_max_bits_fmpz_vec_randtest_unsigned_fmpz_vec_randtest_fmpz_vec_clear_fmpz_vec_init_fmpz_vec_print CFmpzModCtx FmpzModCtxfmpz_next_smooth_prime(fmpz_mod_discrete_log_pohlig_hellman_run3fmpz_mod_discrete_log_pohlig_hellman_primitive_root5fmpz_mod_discrete_log_pohlig_hellman_precompute_prime*fmpz_mod_discrete_log_pohlig_hellman_clear)fmpz_mod_discrete_log_pohlig_hellman_initfmpz_mod_pow_fmpzfmpz_mod_pow_uifmpz_mod_divides fmpz_mod_inv fmpz_mod_mul fmpz_mod_negfmpz_mod_fmpz_subfmpz_mod_sub_fmpz fmpz_mod_subfmpz_mod_add_fmpz fmpz_mod_addfmpz_mod_is_onefmpz_mod_is_canonicalfmpz_mod_set_fmpzfmpz_mod_ctx_set_modulusfmpz_mod_ctx_clearfmpz_mod_ctx_init newFmpzModCtxwithFmpzModCtxwithNewFmpzModCtx_fmpz_mod_vec_mul_fmpz_mod_vec_dot_rev_fmpz_mod_vec_dot!_fmpz_mod_vec_scalar_div_fmpz_mod$_fmpz_mod_vec_scalar_addmul_fmpz_mod!_fmpz_mod_vec_scalar_mul_fmpz_mod_fmpz_mod_vec_sub_fmpz_mod_vec_add_fmpz_mod_vec_neg_fmpz_mod_vec_set_fmpz_vecCEcmEcmfmpz_factor_ecmfmpz_factor_ecm_stage_IIfmpz_factor_ecm_stage_Ifmpz_factor_ecm_select_curve%fmpz_factor_ecm_mul_montgomery_ladderfmpz_factor_ecm_addfmpz_factor_ecm_doublefmpz_factor_ecm_submodfmpz_factor_ecm_addmodfmpz_factor_ecm_clearfmpz_factor_ecm_initfmpz_factor_pollard_brent fmpz_factor_pollard_brent_singlefmpz_factor_pp1fmpz_factor_expand_iterativefmpz_factor_refinefmpz_factor_trialfmpz_factor_trial_rangefmpz_factor_sifmpz_factor_smooth fmpz_factor_fmpz_factor_append_fmpz_factor_append_uifmpz_factor_fprintfmpz_factor_get_strfmpz_factor_clearfmpz_factor_init newFmpzFactorwithFmpzFactorwithNewFmpzFactorfmpz_factor_printCArbPolyArbPoly ArbStrOptionCArbArbArfRnd_ArfRndCArfArfCMagMag arf_rnd_up arf_rnd_down arf_rnd_floor arf_rnd_ceil arf_rnd_neararf_prec_exact arb_str_none arb_str_morearb_str_no_radiusarb_str_condenseCHypgeomHypgeomarb_hypgeom_infsumarb_hypgeom_sumhypgeom_precompute hypgeom_boundhypgeom_estimate_terms hypgeom_clear hypgeom_init newHypgeom withHypgeomwithNewHypgeomCAcfAcfCAcbAcbCCalciumFunctionCode_CCalciumFunctionCodeCTruth_CTruthCCalciumStream CalciumStreamcalcium_write_acbcalcium_write_arbcalcium_write_fmpzcalcium_write_si calcium_writecalcium_stream_init_filecalcium_func_namecalcium_versionnewCalciumStreamFilenewCalciumStreamStrwithCalciumStreamt_truet_false t_unknownca_QQBarca_Negca_Addca_Subca_Mulca_Divca_Sqrtca_Cbrtca_Rootca_Floorca_Ceilca_Absca_Signca_Reca_Imca_Arg ca_Conjugateca_Pica_Sinca_Cosca_Expca_Logca_Powca_Tanca_Cotca_Coshca_Sinhca_Tanhca_Cothca_Atanca_Acosca_Asinca_Acotca_Atanhca_Acoshca_Asinhca_Acothca_Eulerca_Gamma ca_LogGammaca_Psica_Erfca_Erfcca_Erfica_RiemannZetaca_HurwitzZetaca_FUNC_CODE_LENGTHcalcium_stream_init_strcalcium_write_freepartitions_leading_fmpzpartitions_fmpz_uipartitions_fmpz_fmpzpartitions_hrr_sum_arbpartitions_rademacher_boundCQsQs qsieve_factorqsieve_process_relationqsieve_remove_duplicatesqsieve_compare_relationqsieve_merge_relationqsieve_parse_relationqsieve_add_to_hashtableqsieve_get_table_entryqsieve_write_to_fileqsieve_collect_relationsqsieve_evaluate_sieveqsieve_evaluate_candidateqsieve_do_sieving2qsieve_do_sievingqsieve_compute_Cqsieve_init_poly_nextqsieve_init_poly_first qsieve_next_A qsieve_init_Aqsieve_primes_incrementqsieve_primes_initqsieve_knuth_schroeppelnewQswithQsQuotient// numerator denominatorCFmpqFmpqfmpq_dedekind_sum_naivefmpq_dedekind_sumfmpq_harmonic_ui_fmpq_harmonic_uifmpq_set_cfrac_stfmpq_get_cfrac_stfmpq_cfrac_boundfmpq_set_cfracfmpq_get_cfracfmpq_simplest_between fmpq_mediantfmpq_farey_neighbors_fmpq_next_signed_calkin_wilf_fmpq_next_calkin_wilf_fmpq_next_signed_minimal_fmpq_next_minimal_fmpq_reconstruct_fmpz_fmpq_reconstruct_fmpz_2_naive_fmpq_mod_fmpz_fmpq_mul_small_fmpq_add_smallfmpq_gcd_cofactors_fmpq_gcd_cofactorsfmpq_gcd _fmpq_gcd fmpq_div_2exp fmpq_mul_2exp fmpq_div_fmpz fmpq_mul_fmpz fmpq_pow_fmpz fmpq_pow_si _fmpq_pow_sifmpq_inv _fmpq_addmul fmpq_submul fmpq_addmul fmpq_mul_ui _fmpq_mul_ui _fmpq_mul_si fmpq_sub_fmpz fmpq_add_fmpz fmpq_sub_ui fmpq_add_ui fmpq_sub_si fmpq_add_si_fmpq_sub_fmpz_fmpq_add_fmpz _fmpq_sub_ui _fmpq_add_ui _fmpq_sub_si _fmpq_add_si _fmpq_div _fmpq_mul _fmpq_sub _fmpq_addfmpq_divfmpq_mulfmpq_subfmpq_add_fmpq_randbits fmpq_randbitsfmpq_randtest_not_zero_fmpq_randtest fmpq_randtest _fmpq_print _fmpq_fprint fmpq_fprintfmpq_clear_readonlyfmpq_init_set_readonlyflint_mpq_clear_readonlyflint_mpq_init_set_readonly _fmpq_get_str fmpq_get_str fmpq_get_mpfr fmpq_get_mpq fmpq_get_dfmpq_init_set_mpz_frac_readonly fmpq_set_str fmpq_set_mpq _fmpq_set_ui fmpq_set_ui _fmpq_set_si fmpq_set_sifmpq_get_mpz_fracfmpq_get_fmpz_fracfmpq_set_fmpz_fracfmpq_height_bits fmpq_height fmpq_equal_si fmpq_equal_ui fmpq_cmp_si fmpq_cmp_fmpzfmpq_cmpfmpq_sgn fmpq_equal fmpq_is_pm1 fmpq_is_one fmpq_is_zerofmpq_one fmpq_zerofmpq_absfmpq_neg fmpq_swapfmpq_set_fmpq_is_canonicalfmpq_is_canonical_fmpq_canonicalisefmpq_canonicalise fmpq_clear fmpq_initnewFmpqwithFmpq withNewFmpq withFmpqNum withFmpqDen fmpq_printPadicPrintMode_PadicPrintMode CPadicCtxPadicCtxCPadicPadic padic_debug _padic_print _padic_fprint padic_get_str padic_val_facpadic_val_fac_uipadic_val_fac_ui_2padic_teichmuller_padic_teichmullerpadic_log_balancedpadic_log_satohpadic_log_rectangular padic_log _padic_log_padic_log_boundpadic_exp_balancedpadic_exp_rectangular padic_exp_padic_exp_rectangular_padic_exp_bound padic_pow_si padic_sqrt padic_inv _padic_inv_padic_inv_precomp_padic_inv_clear_padic_inv_precompute padic_div padic_shift padic_mul padic_neg padic_sub padic_add_padic_lifts_pows_padic_lifts_exps padic_equal padic_is_one padic_is_zero padic_one padic_zero padic_swap padic_get_mpq padic_get_mpzpadic_get_fmpqpadic_get_fmpz padic_set_mpq padic_set_mpzpadic_set_fmpqpadic_set_fmpz padic_set_ui padic_set_si padic_setpadic_randtest_intpadic_randtest_not_zeropadic_randtest padic_reduce _padic_reduce_padic_canonicalise padic_clear padic_init2 padic_init_padic_ctx_pow_uipadic_ctx_clearpadic_ctx_initnewPadic withPadic withNewPadic newPadicCtx withPadicCtxwithNewPadicCtx padic_unit padic_get_valpadic_get_precpadic_ctx_print padic_terse padic_seriespadic_val_unit padic_print_nmod_vec_dot_ptr_nmod_vec_dot_rev _nmod_vec_dot_nmod_vec_dot_bound_limbs_nmod_vec_scalar_addmul_nmod_nmod_vec_scalar_mul_nmod_shoup_nmod_vec_scalar_mul_nmod _nmod_vec_neg _nmod_vec_sub _nmod_vec_add_nmod_vec_equal_nmod_vec_max_bits_nmod_vec_reduce_nmod_vec_swap_nmod_vec_zero _nmod_vec_set_nmod_vec_randtest_nmod_vec_clear_nmod_vec_init CFmpzPolyFmpzPolyfmpz_poly_CLD_boundfmpz_poly_theta_qexp_fmpz_poly_theta_qexpfmpz_poly_eta_qexp_fmpz_poly_eta_qexpfmpz_poly_fibonacci_fmpz_poly_fibonaccifmpz_poly_hermite_he_fmpz_poly_hermite_hefmpz_poly_hermite_h_fmpz_poly_hermite_hfmpz_poly_legendre_pt_fmpz_poly_legendre_ptfmpz_poly_chebyshev_u_fmpz_poly_chebyshev_ufmpz_poly_chebyshev_t_fmpz_poly_chebyshev_tfmpz_poly_swinnerton_dyer_fmpz_poly_swinnerton_dyerfmpz_poly_cos_minpoly_fmpz_poly_cos_minpolyfmpz_poly_is_cyclotomic_fmpz_poly_is_cyclotomicfmpz_poly_cyclotomic_fmpz_poly_cyclotomicfmpz_poly_num_real_roots_fmpz_poly_num_real_rootsfmpz_poly_num_real_roots_sturm_fmpz_poly_num_real_roots_sturmfmpz_poly_bound_roots_fmpz_poly_bound_roots fmpz_poly_product_roots_fmpq_vec!_fmpz_poly_product_roots_fmpq_vec fmpz_poly_product_roots_fmpz_vec!_fmpz_poly_product_roots_fmpz_vecfmpz_poly_CRT_ui_fmpz_poly_CRT_ui_fmpz_poly_CRT_ui_precomp fmpz_poly_set_nmod_poly_unsignedfmpz_poly_set_nmod_polyfmpz_poly_get_nmod_polyfmpz_poly_fread_prettyfmpz_poly_freadfmpz_poly_read_prettyfmpz_poly_readfmpz_poly_fprint_pretty_fmpz_poly_fprint_prettyfmpz_poly_fprint_fmpz_poly_fprintfmpz_poly_print_pretty_fmpz_poly_print_prettyfmpz_poly_print_fmpz_poly_printfmpz_poly_hensel_lift_once_fmpz_poly_hensel_continue_lift_fmpz_poly_hensel_start_liftfmpz_poly_hensel_lift_tree$fmpz_poly_hensel_lift_tree_recursive"fmpz_poly_hensel_lift_only_inverse%fmpz_poly_hensel_lift_without_inversefmpz_poly_hensel_liftfmpz_poly_hensel_build_treefmpz_poly_signature_fmpz_poly_signaturefmpz_poly_power_sums_to_poly_fmpz_poly_power_sums_to_polyfmpz_poly_power_sumsfmpz_poly_power_sums_naive_fmpz_poly_power_sums_naivefmpz_poly_sqrt_series_fmpz_poly_sqrt_seriesfmpz_poly_sqrt_fmpz_poly_sqrtfmpz_poly_sqrt_divconquer_fmpz_poly_sqrt_divconquerfmpz_poly_sqrt_KS_fmpz_poly_sqrt_KSfmpz_poly_sqrt_classical_fmpz_poly_sqrt_classicalfmpz_poly_sqrtrem_divconquer_fmpz_poly_sqrtrem_divconquerfmpz_poly_sqrtrem_classical_fmpz_poly_sqrtrem_classicalfmpz_poly_revert_series_fmpz_poly_revert_seriesfmpz_poly_revert_series_newton_fmpz_poly_revert_series_newton%fmpz_poly_revert_series_lagrange_fast&_fmpz_poly_revert_series_lagrange_fast fmpz_poly_revert_series_lagrange!_fmpz_poly_revert_series_lagrangefmpz_poly_compose_series_fmpz_poly_compose_series#fmpz_poly_compose_series_brent_kung$_fmpz_poly_compose_series_brent_kungfmpz_poly_compose_series_horner _fmpz_poly_compose_series_hornerfmpz_poly_taylor_shift_fmpz_poly_taylor_shift fmpz_poly_taylor_shift_multi_mod!_fmpz_poly_taylor_shift_multi_mod!fmpz_poly_taylor_shift_divconquer"_fmpz_poly_taylor_shift_divconquerfmpz_poly_taylor_shift_horner_fmpz_poly_taylor_shift_hornerfmpz_poly_deflationfmpz_poly_deflatefmpz_poly_inflatefmpz_poly_compose_fmpz_poly_composefmpz_poly_compose_divconquer_fmpz_poly_compose_divconquerfmpz_poly_compose_horner_fmpz_poly_compose_hornerfmpz_poly_interpolate_fmpz_vec_fmpz_poly_newton_to_monomial_fmpz_poly_monomial_to_newton"_fmpz_poly_evaluate_horner_d_2exp2 fmpz_poly_evaluate_horner_d_2exp!_fmpz_poly_evaluate_horner_d_2expfmpz_poly_evaluate_horner_d_fmpz_poly_evaluate_horner_dfmpz_poly_evaluate_fmpz_vecfmpz_poly_evaluate_mod_fmpz_poly_evaluate_modfmpz_poly_evaluate_fmpq_fmpz_poly_evaluate_fmpqfmpz_poly_evaluate_horner_fmpq_fmpz_poly_evaluate_horner_fmpq"fmpz_poly_evaluate_divconquer_fmpq#_fmpz_poly_evaluate_divconquer_fmpqfmpz_poly_evaluate_fmpz_fmpz_poly_evaluate_fmpzfmpz_poly_evaluate_horner_fmpz_fmpz_poly_evaluate_horner_fmpz"fmpz_poly_evaluate_divconquer_fmpz#_fmpz_poly_evaluate_divconquer_fmpzfmpz_poly_nth_derivative_fmpz_poly_nth_derivativefmpz_poly_derivative_fmpz_poly_derivativefmpz_poly_pseudo_rem_fmpz_poly_pseudo_remfmpz_poly_pseudo_div_fmpz_poly_pseudo_divfmpz_poly_pseudo_divremfmpz_poly_pseudo_rem_cohen_fmpz_poly_pseudo_rem_cohenfmpz_poly_pseudo_divrem_cohen_fmpz_poly_pseudo_divrem_cohen"fmpz_poly_pseudo_divrem_divconquer#_fmpz_poly_pseudo_divrem_divconquer fmpz_poly_pseudo_divrem_basecase!_fmpz_poly_pseudo_divrem_basecasefmpz_poly_div_seriesfmpz_poly_div_series_divconquerfmpz_poly_div_series_basecase_fmpz_poly_div_series _fmpz_poly_div_series_divconquer_fmpz_poly_div_series_basecasefmpz_poly_inv_series_fmpz_poly_inv_seriesfmpz_poly_inv_series_newton_fmpz_poly_inv_series_newtonfmpz_poly_inv_series_basecase_fmpz_poly_inv_series_basecasefmpz_poly_divhigh_smodpfmpz_poly_divlow_smodpfmpz_poly_removefmpz_poly_divides_fmpz_poly_dividesfmpz_poly_rem_powers_precomp_fmpz_poly_rem_powers_precompfmpz_poly_powers_clear_fmpz_poly_powers_clearfmpz_poly_powers_precompute_fmpz_poly_powers_precomputefmpz_poly_divrem_preinv_fmpz_poly_divrem_preinvfmpz_poly_div_preinv_fmpz_poly_div_preinvfmpz_poly_preinvert_fmpz_poly_preinvertfmpz_poly_div_root_fmpz_poly_div_root fmpz_poly_rem_fmpz_poly_remfmpz_poly_rem_basecase_fmpz_poly_rem_basecase fmpz_poly_div_fmpz_poly_divfmpz_poly_div_divconquer_fmpz_poly_div_divconquer#_fmpz_poly_div_divconquer_recursive)_fmpz_poly_divremlow_divconquer_recursivefmpz_poly_div_basecase_fmpz_poly_div_basecasefmpz_poly_divrem_fmpz_poly_divremfmpz_poly_divrem_divconquer_fmpz_poly_divrem_divconquer&_fmpz_poly_divrem_divconquer_recursivefmpz_poly_divrem_basecase_fmpz_poly_divrem_basecasefmpz_poly_is_squarefree_fmpz_poly_is_squarefreefmpz_poly_primitive_part_fmpz_poly_primitive_partfmpz_poly_content_fmpz_poly_contentfmpz_poly_discriminant_fmpz_poly_discriminantfmpz_poly_resultant_fmpz_poly_resultantfmpz_poly_resultant_euclidean_fmpz_poly_resultant_euclideanfmpz_poly_resultant_modular_divfmpz_poly_resultant_modular_fmpz_poly_resultant_modular fmpz_poly_lcm_fmpz_poly_lcmfmpz_poly_xgcd_fmpz_poly_xgcdfmpz_poly_xgcd_modular_fmpz_poly_xgcd_modular fmpz_poly_gcd_fmpz_poly_gcdfmpz_poly_gcd_modular_fmpz_poly_gcd_modularfmpz_poly_gcd_heuristic_fmpz_poly_gcd_heuristicfmpz_poly_gcd_subresultant_fmpz_poly_gcd_subresultant _fmpz_poly_2norm_normalised_bitsfmpz_poly_2norm_fmpz_poly_2normfmpz_poly_heightfmpz_poly_max_bitsfmpz_poly_max_limbsfmpz_poly_shift_right_fmpz_poly_shift_rightfmpz_poly_shift_left_fmpz_poly_shift_leftfmpz_poly_pow_trunc_fmpz_poly_pow_trunc fmpz_poly_pow_fmpz_poly_pow_fmpz_poly_pow_smallfmpz_poly_pow_binexp_fmpz_poly_pow_binexpfmpz_poly_pow_addchains_fmpz_poly_pow_addchainsfmpz_poly_pow_binomial_fmpz_poly_pow_binomialfmpz_poly_pow_multinomial_fmpz_poly_pow_multinomialfmpz_poly_sqrlow_fmpz_poly_sqrlowfmpz_poly_sqrlow_classical_fmpz_poly_sqrlow_classicalfmpz_poly_sqrlow_karatsuba_n_fmpz_poly_sqrlow_karatsuba_nfmpz_poly_sqrlow_KS_fmpz_poly_sqrlow_KS fmpz_poly_sqr_fmpz_poly_sqrfmpz_poly_sqr_classical_fmpz_poly_sqr_classicalfmpz_poly_sqr_karatsuba_fmpz_poly_sqr_karatsubafmpz_poly_sqr_KS_fmpz_poly_sqr_KSfmpz_poly_mul_SS_precachefmpz_poly_mullow_SS_precache_fmpz_poly_mullow_SS_precachefmpz_poly_mul_precache_clearfmpz_poly_mul_SS_precache_init_fmpz_poly_mulhighfmpz_poly_mulhigh_nfmpz_poly_mullow_fmpz_poly_mullow fmpz_poly_mul_fmpz_poly_mulfmpz_poly_mullow_SS_fmpz_poly_mullow_SSfmpz_poly_mul_SS_fmpz_poly_mul_SSfmpz_poly_mullow_KS_fmpz_poly_mullow_KSfmpz_poly_mul_KS_fmpz_poly_mul_KSfmpz_poly_mulhigh_karatsuba_n_fmpz_poly_mulhigh_karatsuba_nfmpz_poly_mullow_karatsuba_n_fmpz_poly_mullow_karatsuba_nfmpz_poly_mul_karatsuba_fmpz_poly_mul_karatsubafmpz_poly_mulmid_classical_fmpz_poly_mulmid_classicalfmpz_poly_mulhigh_classical_fmpz_poly_mulhigh_classicalfmpz_poly_mullow_classical_fmpz_poly_mullow_classicalfmpz_poly_mul_classical_fmpz_poly_mul_classicalfmpz_poly_bit_unpack_unsignedfmpz_poly_bit_unpackfmpz_poly_bit_pack_fmpz_poly_bit_unpack_unsigned_fmpz_poly_bit_unpack_fmpz_poly_bit_pack_fmpz_poly_scale_2exp_fmpz_poly_remove_content_2expfmpz_poly_scalar_smod_fmpzfmpz_poly_scalar_mod_fmpzfmpz_poly_scalar_divexact_uifmpz_poly_scalar_divexact_sifmpz_poly_scalar_divexact_fmpzfmpz_poly_scalar_tdiv_2expfmpz_poly_scalar_tdiv_uifmpz_poly_scalar_tdiv_sifmpz_poly_scalar_tdiv_fmpzfmpz_poly_scalar_fdiv_2expfmpz_poly_scalar_fdiv_uifmpz_poly_scalar_fdiv_sifmpz_poly_scalar_fdiv_fmpzfmpz_poly_scalar_submul_fmpzfmpz_poly_scalar_addmul_fmpzfmpz_poly_scalar_addmul_uifmpz_poly_scalar_addmul_sifmpz_poly_scalar_mul_2expfmpz_poly_scalar_mul_uifmpz_poly_scalar_mul_sifmpz_poly_scalar_mul_fmpzfmpz_poly_scalar_abs fmpz_poly_negfmpz_poly_sub_series fmpz_poly_sub_fmpz_poly_subfmpz_poly_add_series fmpz_poly_add_fmpz_poly_addfmpz_poly_is_genfmpz_poly_is_unitfmpz_poly_is_onefmpz_poly_equal_truncfmpz_poly_equalfmpz_poly_set_coeff_uifmpz_poly_set_coeff_sifmpz_poly_set_coeff_fmpzfmpz_poly_get_coeff_uifmpz_poly_get_coeff_sifmpz_poly_get_coeff_fmpzfmpz_poly_randtest_irreduciblefmpz_poly_randtest_irreducible2fmpz_poly_randtest_irreducible1fmpz_poly_randtest_no_real_rootfmpz_poly_randtest_not_zerofmpz_poly_randtest_unsignedfmpz_poly_randtestfmpz_poly_set_truncfmpz_poly_truncatefmpz_poly_reverse_fmpz_poly_reversefmpz_poly_swapfmpz_poly_zero_coeffs fmpz_poly_onefmpz_poly_zerofmpz_poly_get_str_pretty_fmpz_poly_get_str_prettyfmpz_poly_get_str_fmpz_poly_get_strfmpz_poly_set_str_fmpz_poly_set_strfmpz_poly_set_fmpzfmpz_poly_set_uifmpz_poly_set_si fmpz_poly_setfmpz_poly_degreefmpz_poly_lengthfmpz_poly_attach_shiftfmpz_poly_attach_truncate_fmpz_poly_set_length_fmpz_poly_normalisefmpz_poly_clearfmpz_poly_fit_lengthfmpz_poly_reallocfmpz_poly_init2fmpz_poly_init newFmpzPoly withFmpzPolywithNewFmpzPolyCFqMatFqMatCFqPolyFqPolyCFqFqCFmpzPolyFactorFmpzPolyFactorfmpz_poly_factor_fmpz_poly_factor_quadraticfmpz_poly_factor_zassenhaus_fmpz_poly_factor_zassenhaus)fmpz_poly_factor_zassenhaus_recombinationfmpz_poly_factor_squarefreefmpz_poly_factor_printfmpz_poly_factor_concatfmpz_poly_factor_insertfmpz_poly_factor_setfmpz_poly_factor_clearfmpz_poly_factor_fit_lengthfmpz_poly_factor_reallocfmpz_poly_factor_init2fmpz_poly_factor_initnewFmpzPolyFactorwithFmpzPolyFactorwithNewFmpzPolyFactorCFmpzModMPolyCtxFmpzModMPolyCtx CFmpzModMPoly FmpzModMPolyfmpz_mod_mpoly_deflationfmpz_mod_mpoly_deflatefmpz_mod_mpoly_inflate"fmpz_mod_mpoly_univar_discriminantfmpz_mod_mpoly_univar_resultant"fmpz_mod_mpoly_univar_set_coeff_ui%fmpz_mod_mpoly_univar_swap_term_coeff$fmpz_mod_mpoly_univar_get_term_coeff%fmpz_mod_mpoly_univar_get_term_exp_sifmpz_mod_mpoly_univar_length$fmpz_mod_mpoly_univar_degree_fits_sifmpz_mod_mpoly_from_univarfmpz_mod_mpoly_to_univarfmpz_mod_mpoly_univar_swapfmpz_mod_mpoly_univar_clearfmpz_mod_mpoly_univar_initfmpz_mod_mpoly_quadratic_rootfmpz_mod_mpoly_is_squarefmpz_mod_mpoly_sqrtfmpz_mod_mpoly_discriminantfmpz_mod_mpoly_resultantfmpz_mod_mpoly_gcd_zippel2fmpz_mod_mpoly_gcd_zippelfmpz_mod_mpoly_gcd_subresultantfmpz_mod_mpoly_gcd_henselfmpz_mod_mpoly_gcd_brownfmpz_mod_mpoly_gcd_cofactorsfmpz_mod_mpoly_gcdfmpz_mod_mpoly_content_varsfmpz_mod_mpoly_term_contentfmpz_mod_mpoly_divrem_idealfmpz_mod_mpoly_divremfmpz_mod_mpoly_divfmpz_mod_mpoly_dividesfmpz_mod_mpoly_pow_uifmpz_mod_mpoly_pow_fmpzfmpz_mod_mpoly_mul_densefmpz_mod_mpoly_mul_johnsonfmpz_mod_mpoly_mul%fmpz_mod_mpoly_compose_fmpz_mod_mpoly/fmpz_mod_mpoly_compose_fmpz_mod_mpoly_geobucket fmpz_mod_mpoly_evaluate_one_fmpz fmpz_mod_mpoly_evaluate_all_fmpzfmpz_mod_mpoly_derivativefmpz_mod_mpoly_make_monic!fmpz_mod_mpoly_scalar_addmul_fmpzfmpz_mod_mpoly_scalar_mul_sifmpz_mod_mpoly_scalar_mul_uifmpz_mod_mpoly_scalar_mul_fmpzfmpz_mod_mpoly_negfmpz_mod_mpoly_subfmpz_mod_mpoly_addfmpz_mod_mpoly_sub_sifmpz_mod_mpoly_sub_uifmpz_mod_mpoly_sub_fmpzfmpz_mod_mpoly_add_sifmpz_mod_mpoly_add_uifmpz_mod_mpoly_add_fmpzfmpz_mod_mpoly_randtest_bitsfmpz_mod_mpoly_randtest_boundsfmpz_mod_mpoly_randtest_bound!fmpz_mod_mpoly_combine_like_termsfmpz_mod_mpoly_sort_termsfmpz_mod_mpoly_push_term_si_uifmpz_mod_mpoly_push_term_ui_ui fmpz_mod_mpoly_push_term_fmpz_ui fmpz_mod_mpoly_push_term_si_fmpz fmpz_mod_mpoly_push_term_ui_fmpz"fmpz_mod_mpoly_push_term_fmpz_fmpz fmpz_mod_mpoly_get_term_monomialfmpz_mod_mpoly_get_termfmpz_mod_mpoly_set_term_exp_ui fmpz_mod_mpoly_set_term_exp_fmpz"fmpz_mod_mpoly_get_term_var_exp_si"fmpz_mod_mpoly_get_term_var_exp_uifmpz_mod_mpoly_get_term_exp_sifmpz_mod_mpoly_get_term_exp_ui fmpz_mod_mpoly_get_term_exp_fmpzfmpz_mod_mpoly_term_exp_fits_uifmpz_mod_mpoly_term_exp_fits_si fmpz_mod_mpoly_set_term_coeff_si fmpz_mod_mpoly_set_term_coeff_ui"fmpz_mod_mpoly_set_term_coeff_fmpz"fmpz_mod_mpoly_get_term_coeff_fmpzfmpz_mod_mpoly_resizefmpz_mod_mpoly_lengthfmpz_mod_mpoly_is_canonicalfmpz_mod_mpoly_cmp fmpz_mod_mpoly_get_coeff_vars_uifmpz_mod_mpoly_set_coeff_si_uifmpz_mod_mpoly_set_coeff_ui_ui fmpz_mod_mpoly_set_coeff_fmpz_ui fmpz_mod_mpoly_set_coeff_si_fmpz fmpz_mod_mpoly_set_coeff_ui_fmpz"fmpz_mod_mpoly_set_coeff_fmpz_fmpz fmpz_mod_mpoly_get_coeff_fmpz_ui"fmpz_mod_mpoly_get_coeff_fmpz_fmpz&fmpz_mod_mpoly_set_coeff_fmpz_monomial&fmpz_mod_mpoly_get_coeff_fmpz_monomialfmpz_mod_mpoly_used_varsfmpz_mod_mpoly_total_degree_si fmpz_mod_mpoly_total_degree_fmpz#fmpz_mod_mpoly_total_degree_fits_sifmpz_mod_mpoly_degree_sifmpz_mod_mpoly_degree_fmpzfmpz_mod_mpoly_degrees_sifmpz_mod_mpoly_degrees_fmpzfmpz_mod_mpoly_degrees_fit_sifmpz_mod_mpoly_is_onefmpz_mod_mpoly_is_zerofmpz_mod_mpoly_equal_sifmpz_mod_mpoly_equal_uifmpz_mod_mpoly_equal_fmpzfmpz_mod_mpoly_onefmpz_mod_mpoly_zerofmpz_mod_mpoly_set_sifmpz_mod_mpoly_set_uifmpz_mod_mpoly_set_fmpzfmpz_mod_mpoly_get_fmpzfmpz_mod_mpoly_is_fmpzfmpz_mod_mpoly_swapfmpz_mod_mpoly_equalfmpz_mod_mpoly_setfmpz_mod_mpoly_is_genfmpz_mod_mpoly_genfmpz_mod_mpoly_set_str_prettyfmpz_mod_mpoly_fprint_prettyfmpz_mod_mpoly_get_str_prettyfmpz_mod_mpoly_clearfmpz_mod_mpoly_init3fmpz_mod_mpoly_init2fmpz_mod_mpoly_initfmpz_mod_mpoly_ctx_clearfmpz_mod_mpoly_ctx_get_modulusfmpz_mod_mpoly_ctx_ordfmpz_mod_mpoly_ctx_nvarsfmpz_mod_mpoly_ctx_initnewFmpzModMPolywithFmpzModMPolynewFmpzModMPolyCtxwithFmpzModMPolyCtxfmpz_mod_mpoly_print_prettyCFmpzModMPolyFactorFmpzModMPolyFactorfmpz_mod_mpoly_factor fmpz_mod_mpoly_factor_squarefreefmpz_mod_mpoly_factor_sort fmpz_mod_mpoly_factor_get_exp_sifmpz_mod_mpoly_factor_swap_basefmpz_mod_mpoly_factor_get_base'fmpz_mod_mpoly_factor_get_constant_fmpzfmpz_mod_mpoly_factor_lengthfmpz_mod_mpoly_factor_swapfmpz_mod_mpoly_factor_clearfmpz_mod_mpoly_factor_initnewFmpzModMPolyFactorwithFmpzModMPolyFactor CFmpzMPolyCtx FmpzMPolyCtx CFmpzMPoly FmpzMPolyfmpz_mpoly_symmetricfmpz_mpoly_symmetric_gens'fmpz_mpoly_buchberger_naive_with_limitsfmpz_mpoly_buchberger_naive%fmpz_mpoly_vec_autoreduction_groebnerfmpz_mpoly_vec_autoreductionfmpz_mpoly_vec_is_autoreducedfmpz_mpoly_vec_is_groebner#fmpz_mpoly_reduction_primitive_partfmpz_mpoly_spoly#fmpz_mpoly_vec_set_primitive_unique fmpz_mpoly_vec_randtest_not_zerofmpz_mpoly_vec_set_lengthfmpz_mpoly_vec_insert_uniquefmpz_mpoly_vec_appendfmpz_mpoly_vec_setfmpz_mpoly_vec_fit_lengthfmpz_mpoly_vec_swapfmpz_mpoly_vec_printfmpz_mpoly_vec_clearfmpz_mpoly_vec_init&fmpz_mpoly_divrem_ideal_monagan_pearce'_fmpz_mpoly_divrem_ideal_monagan_pearcefmpz_mpoly_quasidivrem_heapfmpz_mpoly_divrem_array_fmpz_mpoly_divrem_array fmpz_mpoly_divrem_monagan_pearce!_fmpz_mpoly_divrem_monagan_pearcefmpz_mpoly_div_monagan_pearce_fmpz_mpoly_div_monagan_pearce fmpz_mpoly_divides_heap_threaded!fmpz_mpoly_divides_monagan_pearce"_fmpz_mpoly_divides_monagan_pearcefmpz_mpoly_divides_array_fmpz_mpoly_divides_arrayfmpz_mpoly_pow_fpsfmpz_mpoly_deflationfmpz_mpoly_deflatefmpz_mpoly_inflate fmpz_mpoly_univar_get_term_coeff!fmpz_mpoly_univar_get_term_exp_sifmpz_mpoly_univar_length fmpz_mpoly_univar_degree_fits_sifmpz_mpoly_from_univarfmpz_mpoly_to_univarfmpz_mpoly_univar_swapfmpz_mpoly_univar_clearfmpz_mpoly_univar_initfmpz_mpoly_is_squarefmpz_mpoly_sqrtfmpz_mpoly_sqrt_heapfmpz_mpoly_primitive_partfmpz_mpoly_discriminantfmpz_mpoly_resultantfmpz_mpoly_gcd_brownfmpz_mpoly_gcd_cofactorsfmpz_mpoly_gcdfmpz_mpoly_content_varsfmpz_mpoly_term_contentfmpz_mpoly_quasidivrem_idealfmpz_mpoly_divrem_idealfmpz_mpoly_quasidivfmpz_mpoly_divfmpz_mpoly_quasidivremfmpz_mpoly_divremfmpz_mpoly_dividesfmpz_mpoly_pow_uifmpz_mpoly_pow_fmpzfmpz_mpoly_mul_densefmpz_mpoly_mul_arrayfmpz_mpoly_mul_johnsonfmpz_mpoly_mul!fmpz_mpoly_compose_fmpz_mpoly_gen'fmpz_mpoly_compose_fmpz_mpoly_geobucketfmpz_mpoly_compose_fmpz_polyfmpz_mpoly_evaluate_one_fmpzfmpz_mpoly_evaluate_all_fmpzfmpz_mpoly_integralfmpz_mpoly_derivativefmpz_mpoly_scalar_divides_fmpzfmpz_mpoly_scalar_divexact_fmpzfmpz_mpoly_scalar_fmmafmpz_mpoly_scalar_mul_fmpzfmpz_mpoly_negfmpz_mpoly_subfmpz_mpoly_addfmpz_mpoly_sub_fmpzfmpz_mpoly_add_fmpzfmpz_mpoly_randtest_bitsfmpz_mpoly_randtest_boundsfmpz_mpoly_randtest_boundfmpz_mpoly_reversefmpz_mpoly_combine_like_termsfmpz_mpoly_sort_termsfmpz_mpoly_push_term_fmpz_fmpzfmpz_mpoly_get_term_monomialfmpz_mpoly_get_termfmpz_mpoly_set_term_exp_fmpzfmpz_mpoly_get_term_var_exp_uifmpz_mpoly_get_term_exp_fmpzfmpz_mpoly_term_exp_fits_sifmpz_mpoly_set_term_coeff_fmpzfmpz_mpoly_get_term_coeff_fmpzfmpz_mpoly_resizefmpz_mpoly_lengthfmpz_mpoly_is_canonicalfmpz_mpoly_term_coeff_reffmpz_mpoly_set_fmpz_polyfmpz_mpoly_get_fmpz_polyfmpz_mpoly_is_fmpz_polyfmpz_mpoly_cmpfmpz_mpoly_get_coeff_vars_uifmpz_mpoly_set_coeff_fmpz_fmpzfmpz_mpoly_get_coeff_fmpz_fmpz"fmpz_mpoly_set_coeff_fmpz_monomial"fmpz_mpoly_get_coeff_fmpz_monomialfmpz_mpoly_used_varsfmpz_mpoly_total_degree_fmpzfmpz_mpoly_total_degree_fits_sifmpz_mpoly_degree_fmpzfmpz_mpoly_degrees_fmpzfmpz_mpoly_degrees_fit_sifmpz_mpoly_is_onefmpz_mpoly_is_zerofmpz_mpoly_equal_fmpzfmpz_mpoly_onefmpz_mpoly_zerofmpz_mpoly_set_fmpzfmpz_mpoly_get_fmpzfmpz_mpoly_is_fmpzfmpz_mpoly_max_bits_fmpz_mpoly_fits_smallfmpz_mpoly_swapfmpz_mpoly_equalfmpz_mpoly_setfmpz_mpoly_is_genfmpz_mpoly_genfmpz_mpoly_set_str_prettyfmpz_mpoly_fprint_prettyfmpz_mpoly_get_str_prettyfmpz_mpoly_clearfmpz_mpoly_reallocfmpz_mpoly_fit_bitsfmpz_mpoly_fit_lengthfmpz_mpoly_init3fmpz_mpoly_init2fmpz_mpoly_initfmpz_mpoly_ctx_clearfmpz_mpoly_ctx_ordfmpz_mpoly_ctx_nvarsfmpz_mpoly_ctx_init newFmpzMPoly withFmpzMPolywithNewFmpzMPolynewFmpzMPolyCtxwithFmpzMPolyCtxwithNewFmpzMPolyCtxfmpz_mpoly_print_pretty CFmpzMPolyQ FmpzMPolyQ_fmpz_mpoly_q_contentfmpz_mpoly_q_invfmpz_mpoly_q_divfmpz_mpoly_q_mulfmpz_mpoly_q_subfmpz_mpoly_q_addfmpz_mpoly_q_negfmpz_mpoly_q_equalfmpz_mpoly_q_randtestfmpz_mpoly_q_fprint_prettyfmpz_mpoly_q_get_str_prettyfmpz_mpoly_q_genfmpz_mpoly_q_onefmpz_mpoly_q_zerofmpz_mpoly_q_used_varsfmpz_mpoly_q_is_onefmpz_mpoly_q_is_zerofmpz_mpoly_q_is_canonicalfmpz_mpoly_q_canonicalisefmpz_mpoly_q_setfmpz_mpoly_q_swapfmpz_mpoly_q_clearfmpz_mpoly_q_init newFmpzMPolyQwithFmpzMPolyQwithFmpzMPolyQNumeratorwithFmpzMPolyQDenominatorfmpz_mpoly_q_print_prettyCFmpzMPolyFactorFmpzMPolyFactorfmpz_mpoly_factorfmpz_mpoly_factor_squarefreefmpz_mpoly_factor_sortfmpz_mpoly_factor_get_exp_sifmpz_mpoly_factor_get_base#fmpz_mpoly_factor_get_constant_fmpzfmpz_mpoly_factor_lengthfmpz_mpoly_factor_swapfmpz_mpoly_factor_fprint_prettyfmpz_mpoly_factor_clearfmpz_mpoly_factor_initnewFmpzMPolyFactorwithFmpzMPolyFactorwithNewFmpzMPolyFactorfmpz_mpoly_factor_print_pretty_fmpq_vec_fprint_fmpq_vec_get_str _fmpq_vec_dot_fmpq_vec_get_fmpz_vec_fmpz_fmpq_vec_set_fmpz_vec_fmpq_vec_sort_fmpq_vec_randtest_uniq_sorted_fmpq_vec_randtest_fmpq_vec_clear_fmpq_vec_init_fmpq_vec_print CFmpqPolyFmpqPoly"fmpq_poly_get_str_pretty_as_series!fmpq_poly_fprint_pretty_as_seriesfmpq_poly_freadfmpq_poly_readfmpq_poly_fprint_pretty_fmpq_poly_fprint_prettyfmpq_poly_fprint_fmpq_poly_fprint_fmpq_poly_print_pretty_fmpq_poly_printfmpq_poly_is_squarefreefmpq_poly_make_monic_fmpq_poly_make_monicfmpq_poly_is_monic_fmpq_poly_is_monicfmpq_poly_primitive_part_fmpq_poly_primitive_partfmpq_poly_content_fmpq_poly_contentfmpq_poly_revert_series_fmpq_poly_revert_seriesfmpq_poly_revert_series_newton_fmpq_poly_revert_series_newton%fmpq_poly_revert_series_lagrange_fast&_fmpq_poly_revert_series_lagrange_fast fmpq_poly_revert_series_lagrange!_fmpq_poly_revert_series_lagrangefmpq_poly_compose_series_fmpq_poly_compose_series#fmpq_poly_compose_series_brent_kung$_fmpq_poly_compose_series_brent_kungfmpq_poly_compose_series_horner _fmpq_poly_compose_series_hornerfmpq_poly_rescale_fmpq_poly_rescalefmpq_poly_compose_fmpq_poly_composefmpq_poly_interpolate_fmpz_vec_fmpq_poly_interpolate_fmpz_vecfmpq_poly_evaluate_fmpq_fmpq_poly_evaluate_fmpqfmpq_poly_evaluate_fmpz_fmpq_poly_evaluate_fmpzfmpq_poly_monien_h_fmpq_poly_monien_hfmpq_poly_gegenbauer_c_fmpq_poly_gegenbauer_cfmpq_poly_laguerre_l_fmpq_poly_laguerre_lfmpq_poly_legendre_p_fmpq_poly_legendre_pfmpq_poly_tanh_series_fmpq_poly_tanh_seriesfmpq_poly_sinh_cosh_series_fmpq_poly_sinh_cosh_seriesfmpq_poly_cosh_series_fmpq_poly_cosh_seriesfmpq_poly_sinh_series_fmpq_poly_sinh_seriesfmpq_poly_sin_cos_series_fmpq_poly_sin_cos_seriesfmpq_poly_cos_series_fmpq_poly_cos_seriesfmpq_poly_sin_series_fmpq_poly_sin_seriesfmpq_poly_tan_series_fmpq_poly_tan_seriesfmpq_poly_asinh_series_fmpq_poly_asinh_seriesfmpq_poly_asin_series_fmpq_poly_asin_seriesfmpq_poly_atanh_series_fmpq_poly_atanh_seriesfmpq_poly_atan_series_fmpq_poly_atan_seriesfmpq_poly_exp_expinv_series_fmpq_poly_exp_expinv_seriesfmpq_poly_exp_series_fmpq_poly_exp_seriesfmpq_poly_log_series_fmpq_poly_log_seriesfmpq_poly_power_sums_to_poly!fmpq_poly_power_sums_to_fmpz_poly_fmpq_poly_power_sums_to_polyfmpq_poly_power_sums_fmpq_poly_power_sumsfmpq_poly_invsqrt_series_fmpq_poly_invsqrt_seriesfmpq_poly_sqrt_series_fmpq_poly_sqrt_seriesfmpq_poly_integral_fmpq_poly_integralfmpq_poly_nth_derivative_fmpq_poly_nth_derivativefmpq_poly_derivative_fmpq_poly_derivativefmpq_poly_resultant_divfmpq_poly_resultant_fmpq_poly_resultant fmpq_poly_lcm_fmpq_poly_lcmfmpq_poly_xgcd_fmpq_poly_xgcd fmpq_poly_gcd_fmpq_poly_gcdfmpq_poly_div_series_fmpq_poly_div_seriesfmpq_poly_inv_series_fmpq_poly_inv_seriesfmpq_poly_inv_series_newton_fmpq_poly_inv_series_newtonfmpq_poly_removefmpq_poly_divides_fmpq_poly_dividesfmpq_poly_rem_powers_precomp_fmpq_poly_rem_powers_precompfmpq_poly_powers_clear_fmpq_poly_powers_clearfmpq_poly_powers_precompute_fmpq_poly_powers_precompute fmpq_poly_rem_fmpq_poly_rem fmpq_poly_div_fmpq_poly_divfmpq_poly_divrem_fmpq_poly_divremfmpq_poly_shift_rightfmpq_poly_shift_leftfmpq_poly_pow_trunc_fmpq_poly_pow_trunc fmpq_poly_pow_fmpq_poly_powfmpq_poly_submulfmpq_poly_addmulfmpq_poly_mullow_fmpq_poly_mullow fmpq_poly_mul_fmpq_poly_mulfmpq_poly_scalar_div_fmpqfmpq_poly_scalar_div_fmpzfmpq_poly_scalar_div_uifmpq_poly_scalar_div_si_fmpq_poly_scalar_div_fmpq_fmpq_poly_scalar_div_ui_fmpq_poly_scalar_div_si_fmpq_poly_scalar_div_fmpzfmpq_poly_scalar_mul_fmpqfmpq_poly_scalar_mul_fmpzfmpq_poly_scalar_mul_uifmpq_poly_scalar_mul_si_fmpq_poly_scalar_mul_fmpq_fmpq_poly_scalar_mul_fmpz_fmpq_poly_scalar_mul_ui_fmpq_poly_scalar_mul_sifmpq_poly_sub_series_canfmpq_poly_sub_series_fmpq_poly_sub_series_can_fmpq_poly_sub_seriesfmpq_poly_sub_can fmpq_poly_sub_fmpq_poly_sub_can_fmpq_poly_subfmpq_poly_add_series_canfmpq_poly_add_series_fmpq_poly_add_series_can_fmpq_poly_add_seriesfmpq_poly_add_can fmpq_poly_add_fmpq_poly_add_can_fmpq_poly_addfmpq_poly_is_genfmpq_poly_is_zerofmpq_poly_is_one fmpq_poly_cmp_fmpq_poly_cmpfmpq_poly_equal_trunc_fmpq_poly_equal_truncfmpq_poly_equalfmpq_poly_set_coeff_fmpqfmpq_poly_set_coeff_fmpzfmpq_poly_set_coeff_uifmpq_poly_set_coeff_sifmpq_poly_get_coeff_fmpqfmpq_poly_get_coeff_fmpzfmpq_poly_reversefmpq_poly_get_slicefmpq_poly_set_truncfmpq_poly_truncatefmpq_poly_swap fmpq_poly_inv fmpq_poly_neg fmpq_poly_onefmpq_poly_zerofmpq_poly_get_str_prettyfmpq_poly_get_strfmpq_poly_set_str_fmpq_poly_set_strfmpq_poly_get_nmod_poly_denfmpq_poly_get_nmod_polyfmpq_poly_set_nmod_polyfmpq_poly_set_fmpz_polyfmpq_poly_set_fmpqfmpq_poly_set_fmpzfmpq_poly_set_uifmpq_poly_set_si fmpq_poly_setfmpq_poly_randtest_not_zerofmpq_poly_randtest_unsignedfmpq_poly_randtestfmpq_poly_get_denominatorfmpq_poly_get_numeratorfmpq_poly_lengthfmpq_poly_degreefmpq_poly_is_canonical_fmpq_poly_is_canonicalfmpq_poly_canonicalise_fmpq_poly_canonicalise_fmpq_poly_normalisefmpq_poly_clear_fmpq_poly_set_lengthfmpq_poly_fit_lengthfmpq_poly_reallocfmpq_poly_init2fmpq_poly_init newFmpqPoly withFmpqPolywithNewFmpqPolyfmpq_poly_numreffmpq_poly_denreffmpq_poly_printfmpq_poly_print_pretty fmpq_poly_print_pretty_as_series CPadicPoly PadicPoly_padic_poly_is_canonicalpadic_poly_get_str_prettypadic_poly_get_strpadic_poly_fprint_pretty_padic_poly_print_pretty_padic_poly_fprint_pretty_padic_poly_printpadic_poly_fprint_padic_poly_fprintpadic_poly_debugpadic_poly_compose_pow_padic_poly_compose_powpadic_poly_compose_padic_poly_composepadic_poly_evaluate_padic_padic_poly_evaluate_padicpadic_poly_shift_rightpadic_poly_shift_leftpadic_poly_derivative_padic_poly_derivativepadic_poly_inv_seriespadic_poly_pow_padic_poly_powpadic_poly_mul_padic_poly_mulpadic_poly_scalar_mul_padic_padic_poly_scalar_mul_padicpadic_poly_negpadic_poly_sub_padic_poly_subpadic_poly_add_padic_poly_addpadic_poly_is_onepadic_poly_is_zeropadic_poly_equalpadic_poly_set_coeff_padicpadic_poly_get_coeff_padicpadic_poly_swappadic_poly_onepadic_poly_zeropadic_poly_get_fmpq_polypadic_poly_get_fmpz_polypadic_poly_set_fmpq_polypadic_poly_set_fmpz_polypadic_poly_set_fmpqpadic_poly_set_fmpzpadic_poly_set_uipadic_poly_set_sipadic_poly_setpadic_poly_set_padicpadic_poly_randtest_valpadic_poly_randtest_not_zeropadic_poly_randtestpadic_poly_valpadic_poly_lengthpadic_poly_degreepadic_poly_truncatepadic_poly_reduce_padic_poly_canonicalise_padic_poly_normalisepadic_poly_clear_padic_poly_set_lengthpadic_poly_fit_lengthpadic_poly_reallocpadic_poly_init2padic_poly_init newPadicPoly withPadicPolywithNewPadicPolypadic_poly_printpadic_poly_print_pretty CQadicCtxQadicCtxCQadicQadicqadic_fprint_prettyqadic_norm_resultantqadic_norm_analytic qadic_norm _qadic_norm _qadic_traceqadic_teichmuller_qadic_teichmullerqadic_frobenius_qadic_frobenius_qadic_frobenius_a qadic_log _qadic_logqadic_log_balanced_qadic_log_balancedqadic_log_rectangular_qadic_log_rectangular qadic_exp _qadic_expqadic_exp_balanced_qadic_exp_balancedqadic_exp_rectangular_qadic_exp_rectangular qadic_sqrt qadic_pow _qadic_pow qadic_inv _qadic_inv qadic_mul qadic_neg qadic_sub qadic_add qadic_equal qadic_is_one qadic_is_zeroqadic_get_padic qadic_set_ui qadic_gen qadic_one qadic_zero qadic_setqadic_randtest_intqadic_randtest_valqadic_randtest_not_zeroqadic_randtest qadic_prec qadic_val qadic_reduce_fmpz_mod_poly_reduce_fmpz_poly_reduce qadic_clear qadic_init2 qadic_initqadic_ctx_degreeqadic_ctx_clearqadic_ctx_init_conwayqadic_ctx_initnewQadic withQadic withNewQadicnewQadicWithPrecwithNewQadicWithPrec newQadicCtxnewQadicCtxConway withQadicCtxwithNewQadicCtxwithNewQadicCtxConwayqadic_ctx_printqadic_print_prettyCNFNFnf_clearnf_initnewNFwithNF CFmpzPolyQ FmpzPolyQfmpz_poly_q_get_str_prettyfmpz_poly_q_get_strfmpz_poly_q_set_strfmpz_poly_q_evaluate_fmpqfmpz_poly_q_derivativefmpz_poly_q_powfmpz_poly_q_divfmpz_poly_q_mulfmpz_poly_q_scalar_div_fmpqfmpz_poly_q_scalar_div_fmpzfmpz_poly_q_scalar_div_sifmpz_poly_q_scalar_mul_fmpqfmpz_poly_q_scalar_mul_fmpzfmpz_poly_q_scalar_mul_sifmpz_poly_q_submulfmpz_poly_q_addmulfmpz_poly_q_subfmpz_poly_q_addfmpz_poly_q_equalfmpz_poly_q_is_onefmpz_poly_q_is_zerofmpz_poly_q_invfmpz_poly_q_negfmpz_poly_q_onefmpz_poly_q_zerofmpz_poly_q_swapfmpz_poly_q_set_sifmpz_poly_q_setfmpz_poly_q_randtest_not_zerofmpz_poly_q_randtestfmpz_poly_q_is_canonicalfmpz_poly_q_canonicalisefmpz_poly_q_clearfmpz_poly_q_init newFmpzPolyQ withFmpzPolyQwithNewFmpzPolyQwithFmpzPolyQNumwithFmpzPolyQDenfmpz_poly_q_printfmpz_poly_q_print_pretty CFmpqMPolyCtx FmpqMPolyCtx CFmpqMPoly FmpqMPoly!fmpq_mpoly_univar_swap_term_coeff fmpq_mpoly_univar_get_term_coeff!fmpq_mpoly_univar_get_term_exp_sifmpq_mpoly_univar_length fmpq_mpoly_univar_degree_fits_sifmpq_mpoly_from_univarfmpq_mpoly_to_univarfmpq_mpoly_univar_swapfmpq_mpoly_univar_clearfmpq_mpoly_univar_initfmpq_mpoly_is_squarefmpq_mpoly_sqrtfmpq_mpoly_discriminantfmpq_mpoly_resultantfmpq_mpoly_gcd_zippel2fmpq_mpoly_gcd_zippelfmpq_mpoly_gcd_subresultantfmpq_mpoly_gcd_henselfmpq_mpoly_gcd_brownfmpq_mpoly_gcd_cofactorsfmpq_mpoly_gcdfmpq_mpoly_content_varsfmpq_mpoly_term_contentfmpq_mpoly_contentfmpq_mpoly_divrem_idealfmpq_mpoly_divremfmpq_mpoly_divfmpq_mpoly_dividesfmpq_mpoly_pow_uifmpq_mpoly_pow_fmpzfmpq_mpoly_mul!fmpq_mpoly_compose_fmpq_mpoly_genfmpq_mpoly_compose_fmpq_mpolyfmpq_mpoly_compose_fmpq_polyfmpq_mpoly_evaluate_one_fmpqfmpq_mpoly_evaluate_all_fmpqfmpq_mpoly_integralfmpq_mpoly_derivativefmpq_mpoly_make_monicfmpq_mpoly_scalar_div_sifmpq_mpoly_scalar_div_uifmpq_mpoly_scalar_div_fmpzfmpq_mpoly_scalar_div_fmpqfmpq_mpoly_scalar_mul_sifmpq_mpoly_scalar_mul_uifmpq_mpoly_scalar_mul_fmpzfmpq_mpoly_scalar_mul_fmpqfmpq_mpoly_negfmpq_mpoly_subfmpq_mpoly_addfmpq_mpoly_sub_sifmpq_mpoly_sub_uifmpq_mpoly_sub_fmpzfmpq_mpoly_sub_fmpqfmpq_mpoly_add_sifmpq_mpoly_add_uifmpq_mpoly_add_fmpzfmpq_mpoly_add_fmpqfmpq_mpoly_randtest_bitsfmpq_mpoly_randtest_boundsfmpq_mpoly_randtest_boundfmpq_mpoly_combine_like_termsfmpq_mpoly_sort_termsfmpq_mpoly_reducefmpq_mpoly_push_term_si_uifmpq_mpoly_push_term_ui_uifmpq_mpoly_push_term_fmpz_uifmpq_mpoly_push_term_fmpq_uifmpq_mpoly_push_term_si_fmpzfmpq_mpoly_push_term_ui_fmpzfmpq_mpoly_push_term_fmpz_fmpzfmpq_mpoly_push_term_fmpq_fmpzfmpq_mpoly_get_term_monomialfmpq_mpoly_get_termfmpq_mpoly_set_term_exp_uifmpq_mpoly_set_term_exp_fmpzfmpq_mpoly_get_term_var_exp_sifmpq_mpoly_get_term_var_exp_uifmpq_mpoly_get_term_exp_sifmpq_mpoly_get_term_exp_uifmpq_mpoly_get_term_exp_fmpzfmpq_mpoly_term_exp_fits_uifmpq_mpoly_term_exp_fits_sifmpq_mpoly_set_term_coeff_fmpqfmpq_mpoly_get_term_coeff_fmpqfmpq_mpoly_resizefmpq_mpoly_lengthfmpq_mpoly_is_canonicalfmpq_mpoly_zpoly_term_coeff_reffmpq_mpoly_zpoly_reffmpq_mpoly_content_reffmpq_mpoly_cmpfmpq_mpoly_get_coeff_vars_uifmpq_mpoly_set_coeff_fmpq_uifmpq_mpoly_set_coeff_fmpq_fmpzfmpq_mpoly_get_coeff_fmpq_uifmpq_mpoly_get_coeff_fmpq_fmpz"fmpq_mpoly_set_coeff_fmpq_monomial"fmpq_mpoly_get_coeff_fmpq_monomialfmpq_mpoly_get_denominatorfmpq_mpoly_used_varsfmpq_mpoly_total_degree_sifmpq_mpoly_total_degree_fmpzfmpq_mpoly_total_degree_fits_sifmpq_mpoly_degree_sifmpq_mpoly_degree_fmpzfmpq_mpoly_degrees_sifmpq_mpoly_degrees_fmpzfmpq_mpoly_degrees_fit_sifmpq_mpoly_is_onefmpq_mpoly_is_zerofmpq_mpoly_equal_sifmpq_mpoly_equal_uifmpq_mpoly_equal_fmpzfmpq_mpoly_equal_fmpqfmpq_mpoly_onefmpq_mpoly_zerofmpq_mpoly_set_sifmpq_mpoly_set_uifmpq_mpoly_set_fmpzfmpq_mpoly_set_fmpqfmpq_mpoly_get_fmpqfmpq_mpoly_is_fmpqfmpq_mpoly_swapfmpq_mpoly_equalfmpq_mpoly_setfmpq_mpoly_is_genfmpq_mpoly_genfmpq_mpoly_set_str_prettyfmpq_mpoly_fprint_prettyfmpq_mpoly_get_str_prettyfmpq_mpoly_clearfmpq_mpoly_reallocfmpq_mpoly_fit_bitsfmpq_mpoly_fit_lengthfmpq_mpoly_init3fmpq_mpoly_init2fmpq_mpoly_initfmpq_mpoly_ctx_clearfmpq_mpoly_ctx_ordfmpq_mpoly_ctx_nvarsfmpq_mpoly_ctx_init newFmpqMPoly withFmpqMPolynewFmpqMPolyCtxwithFmpqMPolyCtxfmpq_mpoly_print_prettyCFmpqMPolyFactorFmpqMPolyFactorfmpq_mpoly_factorfmpq_mpoly_factor_squarefreefmpq_mpoly_factor_make_integralfmpq_mpoly_factor_make_monicfmpq_mpoly_factor_sortfmpq_mpoly_factor_get_exp_sifmpq_mpoly_factor_swap_basefmpq_mpoly_factor_get_base#fmpq_mpoly_factor_get_constant_fmpqfmpq_mpoly_factor_lengthfmpq_mpoly_factor_clearfmpq_mpoly_factor_initnewFmpqMPolyFactorwithFmpqMPolyFactorFexpr_fexpr_vec_sort_fastfexpr_vec_set_lengthfexpr_vec_insert_uniquefexpr_vec_append fexpr_vec_setfexpr_vec_fit_lengthfexpr_vec_swapfexpr_vec_printfexpr_vec_clearfexpr_vec_initfexpr_expanded_normal_formfexpr_set_fmpz_mpoly_qfexpr_set_fmpz_mpolyfexpr_get_fmpz_mpoly_qfexpr_arithmetic_nodesfexpr_is_arithmetic_operation fexpr_pow fexpr_div fexpr_mul fexpr_sub fexpr_add fexpr_negfexpr_set_re_im_d fexpr_set_d fexpr_set_arffexpr_set_fmpqfexpr_replace_vecfexpr_replace2 fexpr_replacefexpr_containsfexpr_call_builtin2fexpr_call_builtin1fexpr_call_vec fexpr_call4 fexpr_call3 fexpr_call2 fexpr_call1 fexpr_call0fexpr_is_any_builtin_callfexpr_is_builtin_callfexpr_view_nextfexpr_view_arg fexpr_argfexpr_view_func fexpr_func fexpr_nargsfexpr_get_str_latexfexpr_write_latex fexpr_get_str fexpr_writefexpr_get_stringfexpr_set_stringfexpr_get_symbol_strfexpr_set_symbol_strfexpr_is_any_builtin_symbolfexpr_is_builtin_symbolfexpr_set_symbol_builtinfexpr_get_fmpzfexpr_set_fmpz fexpr_set_ui fexpr_set_sifexpr_is_neg_integer fexpr_is_zero fexpr_zero fexpr_is_atomfexpr_is_stringfexpr_is_symbolfexpr_is_integerfexpr_cmp_fast fexpr_hashfexpr_equal_uifexpr_equal_si fexpr_equalfexpr_allocated_bytesfexpr_size_bytes fexpr_sizefexpr_num_leaves fexpr_depth fexpr_swap fexpr_setfexpr_fit_size_fexpr_vec_clear_fexpr_vec_init fexpr_clear fexpr_initnewFexpr withFexpr withNewFexprfexpr_type_small_intfexpr_type_small_symbolfexpr_type_small_stringfexpr_type_big_int_posfexpr_type_big_int_negfexpr_type_big_symbolfexpr_type_big_stringfexpr_type_call0fexpr_type_call1fexpr_type_call2fexpr_type_call3fexpr_type_call4fexpr_type_calln fexpr_printfexpr_print_latexfexpr_latex_smallfexpr_latex_logic newFexprVec withFexprVecwithNewFexprVec CBernoulliRev BernoulliRevbernoulli_fmpq_ui_bernoulli_fmpq_ui_bernoulli_fmpq_ui_multi_mod_bernoulli_fmpq_ui_zetabernoulli_mod_p_harveybernoulli_bound_2exp_sibernoulli_cache_computebernoulli_fmpq_vec_no_cachebernoulli_rev_clearbernoulli_rev_nextbernoulli_rev_initnewBernoulliRevwithBernoulliRevwithNewBernoulliRevmag_hurwitz_zeta_uiuimag_polylog_tailmag_bernoulli_div_fac_ui mag_bin_uiui mag_rfac_ui mag_fac_uimag_sinh_lowermag_sinhmag_cosh_lowermag_coshmag_atan_lowermag_atanmag_const_pi_lower mag_const_pimag_geom_seriesmag_binpow_uiui mag_exp_tail mag_expm1mag_expinv_lower mag_expinv mag_exp_lowermag_exp mag_log1p mag_log_uimag_neg_log_lower mag_neg_log mag_log_lowermag_logmag_root mag_hypotmag_rsqrt_lower mag_rsqrtmag_sqrt_lowermag_sqrtmag_pow_fmpz_lowermag_pow_ui_lower mag_pow_fmpz mag_pow_uimag_fast_mul_2exp_simag_fast_add_2exp_simag_fast_addmul mag_fast_mulmag_fast_is_zero mag_fast_zeromag_fast_init_set mag_inv_lowermag_inv mag_div_lower mag_div_fmpz mag_div_uimag_div mag_addmulmag_mul_fmpz_lowermag_mul_ui_lower mag_mul_lower mag_mul_fmpz mag_mul_uimag_mulmag_mul_2exp_fmpzmag_mul_2exp_si mag_sub_lowermag_submag_add_ui_2exp_simag_add_2exp_fmpzmag_add_ui_lower mag_add_lower mag_add_uimag_addmag_randtest_special mag_randtest mag_load_file mag_dump_file mag_load_str mag_dump_str mag_get_str mag_fprintmag_maxmag_minmag_cmp_2exp_simag_cmp mag_equalmag_get_fmpz_lower mag_get_fmpz mag_get_fmpqmag_get_d_log2_approx mag_get_dmag_set_fmpz_2exp_fmpz_lowermag_set_d_2exp_fmpz_lowermag_set_ui_2exp_simag_set_fmpz_2exp_fmpzmag_set_d_2exp_fmpzmag_set_fmpz_lowermag_set_ui_lowermag_set_d_lower mag_set_fmpz mag_set_ui mag_set_dmag_set mag_init_setmag_d_log_upper_boundmag_d_log_lower_bound mag_is_finite mag_is_inf mag_is_zeromag_is_specialmag_infmag_onemag_zeromag_allocated_bytes_mag_vec_clear _mag_vec_initmag_swap mag_clearmag_initnewMagwithMag withNewMag mag_printarb_hypgeom_sum_fmpq_imag_arb arb_hypgeom_sum_fmpq_imag_arb_bs arb_hypgeom_sum_fmpq_imag_arb_rs%arb_hypgeom_sum_fmpq_imag_arb_forwardarb_hypgeom_sum_fmpq_arbarb_hypgeom_sum_fmpq_arb_rs arb_hypgeom_sum_fmpq_arb_forwardarb_hypgeom_dilogarb_hypgeom_legendre_p_ui_rootarb_hypgeom_legendre_p_uiarb_hypgeom_legendre_p_ui_asymparb_hypgeom_legendre_p_ui_onearb_hypgeom_legendre_p_ui_zero%arb_hypgeom_legendre_p_ui_deriv_boundarb_hypgeom_legendre_qarb_hypgeom_legendre_parb_hypgeom_hermite_harb_hypgeom_laguerre_larb_hypgeom_gegenbauer_carb_hypgeom_jacobi_parb_hypgeom_chebyshev_uarb_hypgeom_chebyshev_tarb_hypgeom_coulomb_series_arb_hypgeom_coulomb_seriesarb_hypgeom_coulomb_jetarb_hypgeom_coulombarb_hypgeom_airy_zeroarb_hypgeom_airy_series_arb_hypgeom_airy_seriesarb_hypgeom_airy_jetarb_hypgeom_airy arb_hypgeom_bessel_k_integration arb_hypgeom_bessel_i_integrationarb_hypgeom_bessel_k_scaledarb_hypgeom_bessel_karb_hypgeom_bessel_i_scaledarb_hypgeom_bessel_iarb_hypgeom_bessel_jyarb_hypgeom_bessel_yarb_hypgeom_bessel_jarb_hypgeom_li_series_arb_hypgeom_li_seriesarb_hypgeom_liarb_hypgeom_chi_series_arb_hypgeom_chi_seriesarb_hypgeom_chiarb_hypgeom_shi_series_arb_hypgeom_shi_seriesarb_hypgeom_shiarb_hypgeom_ci_series_arb_hypgeom_ci_seriesarb_hypgeom_ci_arb_hypgeom_ci_2f3_arb_hypgeom_ci_asymparb_hypgeom_si_series_arb_hypgeom_si_seriesarb_hypgeom_si_arb_hypgeom_si_1f2_arb_hypgeom_si_asymparb_hypgeom_ei_series_arb_hypgeom_ei_seriesarb_hypgeom_eiarb_hypgeom_expint!_arb_gamma_upper_fmpq_step_bsplit+_arb_hypgeom_gamma_upper_singular_si_bsplit-_arb_hypgeom_gamma_upper_singular_si_choose_N&_arb_hypgeom_gamma_lower_fmpq_0_bsplit(_arb_hypgeom_gamma_lower_fmpq_0_choose_N(_arb_hypgeom_gamma_upper_fmpq_inf_bsplit*_arb_hypgeom_gamma_upper_fmpq_inf_choose_N!_arb_hypgeom_gamma_upper_sum_rs_1!_arb_hypgeom_gamma_lower_sum_rs_1arb_hypgeom_beta_lower_series_arb_hypgeom_beta_lower_seriesarb_hypgeom_beta_lowerarb_hypgeom_gamma_lower_series_arb_hypgeom_gamma_lower_seriesarb_hypgeom_gamma_lowerarb_hypgeom_gamma_upper_series_arb_hypgeom_gamma_upper_series#arb_hypgeom_gamma_upper_integrationarb_hypgeom_gamma_upperarb_hypgeom_fresnel_series_arb_hypgeom_fresnel_seriesarb_hypgeom_fresnelarb_hypgeom_erfcinvarb_hypgeom_erfinvarb_hypgeom_erfi_series_arb_hypgeom_erfi_seriesarb_hypgeom_erfiarb_hypgeom_erfc_series_arb_hypgeom_erfc_seriesarb_hypgeom_erfcarb_hypgeom_erf_series_arb_hypgeom_erf_seriesarb_hypgeom_erfarb_hypgeom_2f1_integrationarb_hypgeom_2f1arb_hypgeom_u_integration arb_hypgeom_uarb_hypgeom_1f1_integrationarb_hypgeom_1f1 arb_hypgeom_marb_hypgeom_0f1arb_hypgeom_pfqarb_hypgeom_central_bin_uiarb_hypgeom_lgammaarb_hypgeom_rgammaarb_hypgeom_gamma_fmpzarb_hypgeom_gamma_fmpqarb_hypgeom_gammaarb_hypgeom_gamma_taylorarb_hypgeom_gamma_stirling'arb_hypgeom_gamma_stirling_sum_improved%arb_hypgeom_gamma_stirling_sum_horner'_arb_hypgeom_gamma_stirling_term_boundsarb_hypgeom_rising_ui_jetarb_hypgeom_rising_ui_jet_rsarb_hypgeom_rising_ui_jet_bs arb_hypgeom_rising_ui_jet_powsumarb_hypgeom_risingarb_hypgeom_rising_uiarb_hypgeom_rising_ui_recarb_hypgeom_rising_ui_rsarb_hypgeom_rising_ui_bsarb_hypgeom_rising_ui_forward_arb_hypgeom_rising_coeffs_fmpz_arb_hypgeom_rising_coeffs_2_arb_hypgeom_rising_coeffs_1_arb_vec_get_unique_fmpz_vec _arb_vec_trim_arb_vec_indeterminate_arb_vec_add_error_mag_vec_arb_vec_add_error_arf_vec_arb_vec_set_powers _arb_vec_bits_arb_vec_get_mag_arb_vec_scalar_addmul_arb_vec_scalar_mul_2exp_si_arb_vec_scalar_mul_fmpz_arb_vec_scalar_div_arb_vec_scalar_mul _arb_vec_add _arb_vec_sub _arb_vec_neg _arb_vec_swap_arb_vec_set_round _arb_vec_set_arb_vec_is_finite_arb_vec_is_zero _arb_vec_zeroarb_atan_newtonarb_sin_cos_arf_atan_reduction_arb_atan_gauss_p_ensure_cached arb_atan_gauss_primes_vec_bsplitarb_log_newton arb_exp_arfarb_exp_arf_genericarb_exp_arf_log_reduction_arb_log_p_ensure_cachedarb_log_primes_vec_bsplitarb_sin_cos_genericarb_sin_cos_widearb_sin_cos_arf_bbarb_sin_cos_arf_genericarb_atan_frac_bsplitarb_atan_arf_bb_arb_atan_sum_bs_powtab_arb_atan_sum_bs_simplearb_exp_arf_rs_generic_arb_exp_sum_bs_powtab_arb_exp_sum_bs_simplearb_exp_arf_bb_arb_exp_taylor_bound_arb_get_mpn_fixed_mod_pi4_arb_get_mpn_fixed_mod_log2_arb_sin_cos_taylor_rs_arb_sin_cos_taylor_naive_arb_exp_taylor_rs_arb_exp_taylor_naive_arb_atan_taylor_rs_arb_atan_taylor_naivearb_primorial_uiarb_primorial_nth_uiarb_partitions_uiarb_partitions_fmpz"arb_fmpz_euler_number_ui_multi_modarb_euler_number_fmpz arb_bell_ui arb_bell_fmpzarb_bell_sum_taylorarb_bell_sum_bsplitarb_chebyshev_u2_uiarb_chebyshev_t2_uiarb_chebyshev_u_uiarb_chebyshev_t_uiarb_agm arb_fib_fmpzarb_polylog_si arb_polylogarb_power_sum_vecarb_bernoulli_poly_uiarb_bernoulli_ui_zetaarb_bernoulli_fmpzarb_bernoulli_uiarb_hurwitz_zetaarb_zeta arb_zeta_uiarb_zeta_ui_vec_oddarb_zeta_ui_vec_evenarb_zeta_ui_vecarb_zeta_ui_borwein_bsplitarb_zeta_ui_bernoulliarb_zeta_ui_euler_productarb_zeta_ui_asymparb_zeta_ui_vec_borwein arb_digamma arb_rgamma arb_lgamma arb_gamma arb_bin_uiui arb_bin_uiarb_doublefac_ui arb_fac_uiarb_rising_fmpq_ui arb_rising_ui arb_lambertwarb_const_aperyarb_const_glaisherarb_const_khinchin arb_const_earb_const_catalanarb_const_eulerarb_const_log10arb_const_log2arb_const_log_sqrt2piarb_const_sqrt_pi arb_const_pi arb_acosh arb_asinh arb_atanharb_cscharb_secharb_cotharb_tanh arb_sinh_cosharb_cosharb_sinharb_acosarb_asin arb_atan2arb_atan arb_atan_arf arb_sinc_piarb_sinc arb_csc_piarb_cscarb_sec arb_cot_pi arb_tan_piarb_cos_pi_fmpqarb_sin_pi_fmpqarb_sin_cos_pi_fmpqarb_cotarb_tanarb_sin_cos_pi arb_cos_pi arb_sin_pi arb_sin_cosarb_cosarb_sinarb_exp_invexp arb_expm1arb_exp arb_log_hypotarb_log_base_ui arb_log1parb_log_ui_from_prevarb_log arb_log_arf arb_log_fmpz arb_log_uiarb_pow arb_pow_fmpq arb_si_pow_ui arb_ui_pow_ui arb_pow_ui arb_pow_fmpzarb_pow_fmpz_binexparb_sqrarb_root arb_root_ui arb_sqrt1pm1 arb_rsqrt_ui arb_rsqrt arb_hypot arb_sqrtpos arb_sqrt_ui arb_sqrt_fmpz arb_sqrt_arfarb_sqrt arb_dot_uiarb_approx_dotarb_dot_precisearb_div_2expm1_ui arb_ui_divarb_fmpz_div_fmpz arb_div_fmpz arb_div_ui arb_div_si arb_div_arfarb_divarb_invarb_fmaarb_submul_fmpz arb_submul_ui arb_submul_siarb_submul_arf arb_submularb_addmul_fmpz arb_addmul_ui arb_addmul_siarb_addmul_arf arb_addmularb_mul_2exp_fmpzarb_mul_2exp_si arb_mul_fmpz arb_mul_ui arb_mul_si arb_mul_arfarb_mul arb_sub_fmpz arb_sub_si arb_sub_ui arb_sub_arfarb_subarb_add_fmpz_2exp arb_add_fmpz arb_add_si arb_add_ui arb_add_arfarb_addarb_maxarb_minarb_sgn_nonzeroarb_sgnarb_nonnegative_absarb_abs arb_neg_roundarb_negarb_gearb_gtarb_learb_ltarb_nearb_eqarb_contains_interiorarb_contains_nonnegativearb_contains_positivearb_contains_nonpositivearb_contains_negativearb_contains_zeroarb_contains_int arb_containsarb_contains_mpfrarb_contains_siarb_contains_fmpzarb_contains_fmpqarb_contains_arf arb_overlapsarb_is_nonpositivearb_is_negativearb_is_nonnegativearb_is_positive arb_equal_si arb_equalarb_is_int_2exp_si arb_is_int arb_is_exact arb_is_finite arb_is_onearb_is_nonzero arb_is_zeroarb_can_round_mpfrarb_can_round_arfarb_get_fmpz_mid_rad_10exp arb_floorarb_get_unique_fmpzarb_trimarb_bitsarb_rel_one_accuracy_bitsarb_rel_accuracy_bitsarb_rel_error_bitsarb_get_interval_mpfrarb_get_interval_arfarb_set_interval_neg_pos_magarb_set_interval_mpfrarb_set_interval_arfarb_set_interval_magarb_get_interval_fmpz_2exparb_get_mag_lower_nonnegativearb_get_mag_lower arb_get_magarb_get_lbound_arfarb_get_ubound_arfarb_get_abs_lbound_arfarb_get_abs_ubound_arfarb_nonnegative_partarb_intersection arb_unionarb_add_error_2exp_fmpzarb_add_error_2exp_si arb_add_errorarb_add_error_magarb_add_error_arfarb_get_rad_arbarb_get_mid_arb arb_urandomarb_get_rand_fmpqarb_randtest_specialarb_randtest_widearb_randtest_precisearb_randtest_exact arb_randtest arb_load_file arb_dump_file arb_load_str arb_dump_str arb_fprintn arb_fprintd arb_fprintarb_unit_intervalarb_zero_pm_onearb_indeterminatearb_zero_pm_inf arb_neg_inf arb_pos_infarb_onearb_zero arb_get_strn arb_get_strd arb_get_str arb_set_str arb_set_fmpqarb_set_round_fmpz_2exparb_set_round_fmpz arb_set_roundarb_set_fmpz_2exp arb_set_fmpz arb_set_d arb_set_ui arb_set_si arb_set_arfarb_set!_arb_vec_estimate_allocated_bytes_arb_vec_allocated_bytesarb_allocated_bytesarb_swap_arb_vec_clear _arb_vec_init arb_cleararb_initnewArbnewArbFromFmpznewArbFromFmpqwithArb withNewArbwithNewArbFromFmpzwithNewArbFromFmpq arb_midref arb_radref arb_print arb_printd arb_printn $fShowArb CArbCalcFunc CArfInterval ArfIntervalarb_calc_refine_root_newtonarb_calc_newton_steparb_calc_newton_conv_factorarb_calc_refine_root_bisectarb_calc_isolate_rootsarf_interval_fprintdarf_interval_get_arbarf_interval_swaparf_interval_set_arf_interval_vec_clear_arf_interval_vec_initarf_interval_cleararf_interval_initnewArfIntervalwithArfIntervalwithNewArfIntervalarb_calc_successarb_calc_imprecise_inputarb_calc_no_convergencearf_interval_printd_arf_set_round_mpn_arf_set_round_uiui_arf_set_round_ui_arf_set_mpn_fixed_arf_get_integer_mpnarf_complex_sqrarf_complex_mul_fallbackarf_complex_mularf_root arf_rsqrt arf_sqrt_fmpz arf_sqrt_uiarf_sqrtarf_fmpz_div_fmpz arf_fmpz_div arf_div_fmpz arf_si_div arf_div_si arf_ui_div arf_div_uiarf_divarf_approx_dotarf_sumarf_sosqarf_fmaarf_submul_fmpzarf_submul_mpz arf_submul_si arf_submul_ui arf_submularf_addmul_fmpzarf_addmul_mpz arf_addmul_si arf_addmul_ui arf_addmul arf_mul_fmpz arf_mul_mpz arf_mul_si arf_mul_uiarf_mularf_mul_2exp_fmpzarf_mul_2exp_si arf_sub_fmpz arf_sub_ui arf_sub_siarf_subarf_add_fmpz_2exp arf_add_fmpz arf_add_ui arf_add_siarf_add arf_neg_roundarf_negarf_abs arf_load_file arf_dump_file arf_load_str arf_dump_str arf_fprintd arf_fprint arf_get_str arf_print arf_debug arf_urandomarf_randtest_specialarf_randtest_not_zero arf_randtestarf_init_neg_mag_shallowarf_init_neg_shallowarf_init_set_mag_shallowarf_init_set_shallowarf_mag_fast_add_ulparf_mag_add_ulparf_mag_set_ulpmag_fast_init_set_arfmag_init_set_arf arf_set_magarf_get_mag_lower arf_get_magarf_abs_bound_lt_2exp_siarf_abs_bound_le_2exp_fmpzarf_abs_bound_lt_2exp_fmpzarf_is_int_2exp_si arf_is_intarf_bitsarf_maxarf_minarf_sgnarf_cmpabs_2exp_siarf_cmp_2exp_siarf_cmpabs_mag arf_cmpabs_d arf_cmpabs_ui arf_cmpabs arf_cmp_d arf_cmp_ui arf_cmp_siarf_cmp arf_equal_d arf_equal_ui arf_equal_si arf_equal arf_get_fmpqarf_ceil arf_floorarf_get_fmpz_fixed_siarf_get_fmpz_fixed_fmpz arf_get_si arf_get_fmpz arf_get_mpfr arf_get_d arf_frexparf_get_fmpz_2exparf_set_round_fmpz_2exparf_set_fmpz_2exparf_set_ui_2exp_siarf_set_si_2exp_siarf_set_round_fmpzarf_set_round_mpzarf_set_round_uiarf_set_round_si arf_set_roundarf_init_set_siarf_init_set_uiarf_swap arf_set_d arf_set_mpfr arf_set_si arf_set_ui arf_set_fmpz arf_set_mpzarf_set arf_is_finitearf_is_special arf_is_normal arf_is_inf arf_is_nanarf_is_neg_infarf_is_pos_inf arf_is_one arf_is_zeroarf_nan arf_neg_inf arf_pos_infarf_onearf_zeroarf_allocated_bytes arf_cleararf_initnewArfwithArf withNewArf arf_printd_acb_vec_sort_pretty_acb_vec_get_unique_fmpz_vec _acb_vec_trim_acb_vec_indeterminate_acb_vec_add_error_mag_vec_acb_vec_add_error_arf_vec_acb_vec_unit_roots_acb_vec_set_powers _acb_vec_bits_acb_vec_scalar_div_fmpz_acb_vec_scalar_mul_fmpz_acb_vec_scalar_div_arb_acb_vec_scalar_mul_arb_acb_vec_scalar_div_acb_vec_scalar_div_ui_acb_vec_scalar_mul_onei_acb_vec_scalar_mul_2exp_si_acb_vec_scalar_mul_ui_acb_vec_scalar_mul_acb_vec_scalar_addmul_acb_vec_scalar_submul _acb_vec_sub _acb_vec_add _acb_vec_neg _acb_vec_swap_acb_vec_set_round _acb_vec_set_acb_vec_is_real_acb_vec_is_zero _acb_vec_zeroacb_real_sqrtpos acb_real_min acb_real_max acb_real_ceilacb_real_flooracb_real_heaviside acb_real_sgn acb_real_absacb_chebyshev_u2_uiacb_chebyshev_t2_uiacb_chebyshev_u_uiacb_chebyshev_t_uiacb_agm acb_agm1_cpxacb_agm1acb_polylog_si acb_polylogacb_bernoulli_poly_uiacb_hurwitz_zetaacb_zetaacb_log_barnes_g acb_barnes_g acb_polygammaacb_log_sin_pi acb_digamma acb_lgamma acb_rgamma acb_gamma acb_rising_ui acb_lambertwacb_lambertw_bound_derivacb_lambertw_check_branchacb_lambertw_asymp acb_atanh acb_acosh acb_asinhacb_cschacb_sechacb_cothacb_tanh acb_sinh_coshacb_coshacb_sinhacb_atanacb_acosacb_asin acb_sinc_piacb_sinc acb_csc_piacb_cscacb_sec acb_cot_pi acb_tan_piacb_sin_cos_pi acb_cos_pi acb_sin_piacb_cotacb_tan acb_sin_cosacb_cosacb_sin acb_log1pacb_log_analyticacb_log acb_expm1acb_exp_invexp acb_exp_pi_iacb_exp acb_unit_rootacb_pow_analyticacb_pow acb_pow_arb acb_pow_si acb_pow_ui acb_pow_fmpz acb_root_uiacb_quadratic_roots_fmpzacb_rsqrt_analytic acb_rsqrtacb_sqrt_analyticacb_sqrt acb_const_pi acb_dot_uiacb_approx_dotacb_dot_preciseacb_div acb_div_arb acb_div_fmpz acb_div_si acb_div_uiacb_invacb_submul_arbacb_submul_fmpz acb_submul_si acb_submul_ui acb_submulacb_addmul_arbacb_addmul_fmpz acb_addmul_si acb_addmul_ui acb_addmulacb_cubeacb_sqracb_mul_2exp_fmpzacb_mul_2exp_siacb_mul acb_mul_arb acb_mul_fmpz acb_mul_si acb_mul_ui acb_div_onei acb_mul_oneiacb_sub acb_sub_arb acb_sub_fmpz acb_sub_si acb_sub_uiacb_add acb_add_arb acb_add_fmpz acb_add_si acb_add_uiacb_conj acb_neg_roundacb_negacb_csgnacb_sgnacb_absacb_arg acb_get_imag acb_get_realacb_get_unique_fmpz acb_is_realacb_trimacb_indeterminateacb_bitsacb_rel_one_accuracy_bitsacb_rel_accuracy_bitsacb_rel_error_bitsacb_contains_interioracb_contains_intacb_contains_zero acb_containsacb_contains_fmpzacb_contains_fmpqacb_get_mag_lower acb_get_magacb_get_rad_ubound_arfacb_get_abs_lbound_arfacb_get_abs_ubound_arf acb_union acb_overlapsacb_neacb_eq acb_equal_si acb_equalacb_is_int_2exp_si acb_is_int acb_is_exact acb_is_finite acb_is_one acb_is_zeroacb_randtest_paramacb_randtest_preciseacb_randtest_special acb_randtest acb_fprintn acb_fprintd acb_fprint acb_get_strn acb_get_strd acb_get_str acb_get_midacb_add_error_arbacb_add_error_magacb_add_error_arfacb_swapacb_set_round_arbacb_set_round_fmpz acb_set_round acb_set_fmpqacb_set_arb_arbacb_set_fmpz_fmpz acb_set_d_d acb_set_si_si acb_set_arb acb_set_fmpz acb_set_d acb_set_si acb_set_uiacb_setacb_oneiacb_oneacb_zero!_acb_vec_estimate_allocated_bytes_acb_vec_allocated_bytesacb_allocated_bytes_acb_vec_clear _acb_vec_init acb_clearacb_initnewAcbwithAcb withNewAcb withAcbRe withAcbIm acb_realref acb_imagref acb_print acb_printd acb_printnarb_poly_swinnerton_dyer_ui_arb_poly_swinnerton_dyer_ui_arb_poly_newton_refine_root_arb_poly_newton_step#_arb_poly_newton_convergence_factorarb_poly_root_bound_fujiwara_arb_poly_root_bound_fujiwara arb_poly_riemann_siegel_z_series!_arb_poly_riemann_siegel_z_series$arb_poly_riemann_siegel_theta_series%_arb_poly_riemann_siegel_theta_seriesarb_poly_zeta_series_arb_poly_zeta_seriesarb_poly_rising_ui_series_arb_poly_rising_ui_seriesarb_poly_digamma_series_arb_poly_digamma_seriesarb_poly_lgamma_series_arb_poly_lgamma_seriesarb_poly_rgamma_series_arb_poly_rgamma_seriesarb_poly_gamma_series_arb_poly_gamma_seriesarb_poly_lambertw_series_arb_poly_lambertw_seriesarb_poly_sinc_pi_series_arb_poly_sinc_pi_seriesarb_poly_sinc_series_arb_poly_sinc_seriesarb_poly_cosh_series_arb_poly_cosh_seriesarb_poly_sinh_series_arb_poly_sinh_seriesarb_poly_sinh_cosh_series_arb_poly_sinh_cosh_series%arb_poly_sinh_cosh_series_exponential&_arb_poly_sinh_cosh_series_exponential"arb_poly_sinh_cosh_series_basecase#_arb_poly_sinh_cosh_series_basecasearb_poly_cot_pi_series_arb_poly_cot_pi_seriesarb_poly_cos_pi_series_arb_poly_cos_pi_seriesarb_poly_sin_pi_series_arb_poly_sin_pi_seriesarb_poly_sin_cos_pi_series_arb_poly_sin_cos_pi_seriesarb_poly_tan_series_arb_poly_tan_seriesarb_poly_cos_series_arb_poly_cos_seriesarb_poly_sin_series_arb_poly_sin_seriesarb_poly_sin_cos_series_arb_poly_sin_cos_seriesarb_poly_exp_series_arb_poly_exp_seriesarb_poly_exp_series_basecase_arb_poly_exp_series_basecasearb_poly_acos_series_arb_poly_acos_seriesarb_poly_asin_series_arb_poly_asin_seriesarb_poly_atan_series_arb_poly_atan_seriesarb_poly_log1p_series_arb_poly_log1p_seriesarb_poly_log_series_arb_poly_log_seriesarb_poly_rsqrt_series_arb_poly_rsqrt_seriesarb_poly_sqrt_series_arb_poly_sqrt_seriesarb_poly_pow_arb_series_arb_poly_pow_arb_seriesarb_poly_pow_series_arb_poly_pow_seriesarb_poly_pow_ui_arb_poly_pow_uiarb_poly_pow_ui_trunc_binexp_arb_poly_pow_ui_trunc_binexparb_poly_graeffe_transform_arb_poly_graeffe_transformarb_poly_binomial_transform_arb_poly_binomial_transform'arb_poly_binomial_transform_convolution(_arb_poly_binomial_transform_convolution$arb_poly_binomial_transform_basecase%_arb_poly_binomial_transform_basecasearb_poly_inv_borel_transform_arb_poly_inv_borel_transformarb_poly_borel_transform_arb_poly_borel_transformarb_poly_integral_arb_poly_integralarb_poly_nth_derivative_arb_poly_nth_derivativearb_poly_derivative_arb_poly_derivativearb_poly_interpolate_fast_arb_poly_interpolate_fast"_arb_poly_interpolate_fast_precomp_arb_poly_interpolation_weights arb_poly_interpolate_barycentric!_arb_poly_interpolate_barycentricarb_poly_interpolate_newton_arb_poly_interpolate_newtonarb_poly_evaluate_vec_fast_arb_poly_evaluate_vec_fast#_arb_poly_evaluate_vec_fast_precomparb_poly_evaluate_vec_iter_arb_poly_evaluate_vec_iter_arb_poly_tree_build_arb_poly_tree_free_arb_poly_tree_allocarb_poly_product_roots_complex_arb_poly_product_roots_complexarb_poly_product_roots_arb_poly_product_rootsarb_poly_evaluate2_acb_arb_poly_evaluate2_acb"arb_poly_evaluate2_acb_rectangular#_arb_poly_evaluate2_acb_rectangulararb_poly_evaluate2_acb_horner_arb_poly_evaluate2_acb_hornerarb_poly_evaluate2_arb_poly_evaluate2arb_poly_evaluate2_rectangular_arb_poly_evaluate2_rectangulararb_poly_evaluate2_horner_arb_poly_evaluate2_hornerarb_poly_evaluate_acb_arb_poly_evaluate_acb!arb_poly_evaluate_acb_rectangular"_arb_poly_evaluate_acb_rectangulararb_poly_evaluate_acb_horner_arb_poly_evaluate_acb_hornerarb_poly_evaluate_arb_poly_evaluatearb_poly_evaluate_rectangular_arb_poly_evaluate_rectangulararb_poly_evaluate_horner_arb_poly_evaluate_hornerarb_poly_revert_series_arb_poly_revert_series$arb_poly_revert_series_lagrange_fast%_arb_poly_revert_series_lagrange_fastarb_poly_revert_series_newton_arb_poly_revert_series_newtonarb_poly_revert_series_lagrange _arb_poly_revert_series_lagrangearb_poly_compose_series_arb_poly_compose_seriesarb_poly_compose_arb_poly_composearb_poly_taylor_shift_arb_poly_taylor_shift_arb_poly_div_rootarb_poly_divrem_arb_poly_divrem _arb_poly_rem _arb_poly_divarb_poly_div_series_arb_poly_div_seriesarb_poly_inv_series_arb_poly_inv_series arb_poly_mul _arb_poly_mularb_poly_mullowarb_poly_mullow_blockarb_poly_mullow_classical_arb_poly_mullow_arb_poly_mullow_block_arb_poly_mullow_classicalarb_poly_scalar_divarb_poly_scalar_mularb_poly_scalar_mul_2exp_si arb_poly_negarb_poly_sub_seriesarb_poly_add_series arb_poly_sub _arb_poly_subarb_poly_add_si arb_poly_add _arb_poly_addarb_poly_majorant_arb_poly_majorantarb_poly_get_unique_fmpz_polyarb_poly_overlaps_arb_poly_overlapsarb_poly_equalarb_poly_contains_fmpq_polyarb_poly_contains_fmpz_polyarb_poly_containsarb_poly_randtestarb_poly_fprintdarb_poly_get_strdarb_poly_set_siarb_poly_set_fmpq_polyarb_poly_set_fmpz_polyarb_poly_valuationarb_poly_truncatearb_poly_shift_left_arb_poly_shift_leftarb_poly_shift_right_arb_poly_shift_rightarb_poly_get_coeff_arbarb_poly_set_coeff_arbarb_poly_set_coeff_siarb_poly_set_trunc_roundarb_poly_set_truncarb_poly_set_round arb_poly_set arb_poly_one arb_poly_zero arb_poly_is_xarb_poly_is_onearb_poly_is_zeroarb_poly_degreearb_poly_lengtharb_poly_allocated_bytes_arb_poly_normalise_arb_poly_set_lengtharb_poly_fit_lengtharb_poly_clear arb_poly_init newArbPolynewArbPolyFromFmpzPolynewArbPolyFromFmpqPoly withArbPolywithNewArbPolywithNewArbPolyFromFmpzPolywithNewArbPolyFromFmpqPolyarb_poly_printdCAcbPolyAcbPolyacb_poly_validate_real_roots_acb_poly_validate_real_rootsacb_poly_find_roots_acb_poly_find_roots$_acb_poly_refine_roots_durand_kerner_acb_poly_validate_roots_acb_poly_root_inclusionacb_poly_root_bound_fujiwara_acb_poly_root_bound_fujiwaraacb_poly_elliptic_p_series_acb_poly_elliptic_p_seriesacb_poly_elliptic_k_series_acb_poly_elliptic_k_seriesacb_poly_agm1_series_acb_poly_agm1_seriesacb_poly_erf_series_acb_poly_erf_seriesacb_poly_polylog_series_acb_poly_polylog_series_acb_poly_polylog_cpx_acb_poly_polylog_cpx_zeta_acb_poly_polylog_cpx_smallacb_poly_zeta_series_acb_poly_zeta_series_acb_poly_zeta_cpx_series_acb_poly_zeta_em_sum_acb_poly_zeta_em_tail_bsplit_acb_poly_zeta_em_tail_naive_acb_poly_zeta_em_bound_acb_poly_zeta_em_bound1_acb_poly_zeta_em_choose_param"_acb_poly_powsum_one_series_sieved&_acb_poly_powsum_series_naive_threaded_acb_poly_powsum_series_naiveacb_poly_rising_ui_series_acb_poly_rising_ui_seriesacb_poly_digamma_series_acb_poly_digamma_seriesacb_poly_lgamma_series_acb_poly_lgamma_seriesacb_poly_rgamma_series_acb_poly_rgamma_seriesacb_poly_gamma_series_acb_poly_gamma_seriesacb_poly_lambertw_series_acb_poly_lambertw_seriesacb_poly_sinc_series_acb_poly_sinc_seriesacb_poly_cosh_series_acb_poly_cosh_seriesacb_poly_sinh_series_acb_poly_sinh_seriesacb_poly_sinh_cosh_series_acb_poly_sinh_cosh_series%acb_poly_sinh_cosh_series_exponential&_acb_poly_sinh_cosh_series_exponential"acb_poly_sinh_cosh_series_basecase#_acb_poly_sinh_cosh_series_basecaseacb_poly_cot_pi_series_acb_poly_cot_pi_seriesacb_poly_cos_pi_series_acb_poly_cos_pi_seriesacb_poly_sin_pi_series_acb_poly_sin_pi_seriesacb_poly_sin_cos_pi_series_acb_poly_sin_cos_pi_seriesacb_poly_tan_series_acb_poly_tan_seriesacb_poly_cos_series_acb_poly_cos_seriesacb_poly_sin_series_acb_poly_sin_series_acb_poly_sin_cos_seriesacb_poly_exp_pi_i_series_acb_poly_exp_pi_i_seriesacb_poly_exp_series_acb_poly_exp_seriesacb_poly_exp_series_basecase_acb_poly_exp_series_basecaseacb_poly_atan_series_acb_poly_atan_seriesacb_poly_log1p_series_acb_poly_log1p_seriesacb_poly_log_series_acb_poly_log_seriesacb_poly_rsqrt_series_acb_poly_rsqrt_seriesacb_poly_sqrt_series_acb_poly_sqrt_seriesacb_poly_pow_acb_series_acb_poly_pow_acb_seriesacb_poly_pow_series_acb_poly_pow_seriesacb_poly_pow_ui_acb_poly_pow_uiacb_poly_pow_ui_trunc_binexp_acb_poly_pow_ui_trunc_binexpacb_poly_graeffe_transform_acb_poly_graeffe_transformacb_poly_binomial_transform_acb_poly_binomial_transform'acb_poly_binomial_transform_convolution(_acb_poly_binomial_transform_convolution$acb_poly_binomial_transform_basecase%_acb_poly_binomial_transform_basecaseacb_poly_inv_borel_transform_acb_poly_inv_borel_transformacb_poly_borel_transform_acb_poly_borel_transformacb_poly_integral_acb_poly_integralacb_poly_nth_derivative_acb_poly_nth_derivativeacb_poly_derivative_acb_poly_derivativeacb_poly_interpolate_fast_acb_poly_interpolate_fast"_acb_poly_interpolate_fast_precomp_acb_poly_interpolation_weights acb_poly_interpolate_barycentric!_acb_poly_interpolate_barycentricacb_poly_interpolate_newton_acb_poly_interpolate_newtonacb_poly_evaluate_vec_fast_acb_poly_evaluate_vec_fast#_acb_poly_evaluate_vec_fast_precompacb_poly_evaluate_vec_iter_acb_poly_evaluate_vec_iter_acb_poly_tree_build_acb_poly_tree_free_acb_poly_tree_allocacb_poly_product_roots_acb_poly_product_rootsacb_poly_evaluate2_acb_poly_evaluate2acb_poly_evaluate2_rectangular_acb_poly_evaluate2_rectangularacb_poly_evaluate2_horner_acb_poly_evaluate2_horneracb_poly_evaluate_acb_poly_evaluateacb_poly_evaluate_rectangular_acb_poly_evaluate_rectangularacb_poly_evaluate_horner_acb_poly_evaluate_horneracb_poly_revert_series_acb_poly_revert_series$acb_poly_revert_series_lagrange_fast%_acb_poly_revert_series_lagrange_fastacb_poly_revert_series_newton_acb_poly_revert_series_newtonacb_poly_revert_series_lagrange _acb_poly_revert_series_lagrange_acb_poly_compose_series_acb_poly_compose_acb_poly_taylor_shift_acb_poly_div_rootacb_poly_divrem_acb_poly_divrem _acb_poly_rem _acb_poly_divacb_poly_div_series_acb_poly_div_seriesacb_poly_inv_series_acb_poly_inv_series acb_poly_mul _acb_poly_mulacb_poly_mullowacb_poly_mullow_transpose_gaussacb_poly_mullow_transposeacb_poly_mullow_classical_acb_poly_mullow _acb_poly_mullow_transpose_gauss_acb_poly_mullow_transpose_acb_poly_mullow_classicalacb_poly_scalar_divacb_poly_scalar_mulacb_poly_scalar_mul_2exp_si acb_poly_negacb_poly_sub_seriesacb_poly_add_series acb_poly_sub _acb_poly_subacb_poly_add_si acb_poly_add _acb_poly_addacb_poly_majorant_acb_poly_majorantacb_poly_set_siacb_poly_set_acbacb_poly_set2_fmpq_polyacb_poly_set_fmpq_polyacb_poly_set2_arb_polyacb_poly_set_arb_polyacb_poly_set2_fmpz_polyacb_poly_set_fmpz_polyacb_poly_is_realacb_poly_get_unique_fmpz_polyacb_poly_overlaps_acb_poly_overlapsacb_poly_contains_fmpq_polyacb_poly_contains_fmpz_polyacb_poly_containsacb_poly_equalacb_poly_randtestacb_poly_fprintdacb_poly_get_strdacb_poly_valuationacb_poly_truncateacb_poly_shift_left_acb_poly_shift_leftacb_poly_shift_right_acb_poly_shift_rightacb_poly_get_coeff_acbacb_poly_set_coeff_acbacb_poly_set_coeff_siacb_poly_set_trunc_roundacb_poly_set_truncacb_poly_set_round acb_poly_set acb_poly_one acb_poly_zero acb_poly_is_xacb_poly_is_oneacb_poly_is_zeroacb_poly_degreeacb_poly_lengthacb_poly_allocated_bytes acb_poly_swap_acb_poly_normalise_acb_poly_set_lengthacb_poly_fit_lengthacb_poly_clear acb_poly_init newAcbPolynewAcbPolyFromFmpzPolynewAcbPolyFromFmpqPoly withAcbPolywithNewAcbPolywithNewAcbPolyFromFmpzPolywithNewAcbPolyFromFmpqPolyacb_poly_printd"arb_fmpz_poly_gauss_period_minpolyarb_fmpz_poly_cos_minpolyarb_fmpz_poly_complex_rootsarb_fmpz_poly_deflatearb_fmpz_poly_deflationarb_fmpz_poly_evaluate_acb_arb_fmpz_poly_evaluate_acb&arb_fmpz_poly_evaluate_acb_rectangular'_arb_fmpz_poly_evaluate_acb_rectangular!arb_fmpz_poly_evaluate_acb_horner"_arb_fmpz_poly_evaluate_acb_hornerarb_fmpz_poly_evaluate_arb_arb_fmpz_poly_evaluate_arb&arb_fmpz_poly_evaluate_arb_rectangular'_arb_fmpz_poly_evaluate_arb_rectangular!arb_fmpz_poly_evaluate_arb_horner"_arb_fmpz_poly_evaluate_arb_hornerarb_fmpz_poly_roots_verbose CPSL2ZWord PSL2ZWordCPSL2ZPSL2Zacb_modular_hilbert_class_polyacb_modular_elliptic_p_zpxacb_modular_elliptic_pacb_modular_elliptic_eacb_modular_elliptic_k_cpxacb_modular_elliptic_kacb_modular_eisensteinacb_modular_deltaacb_modular_lambda acb_modular_jacb_modular_etaacb_modular_epsilon_argacb_modular_eta_sumacb_modular_addseq_etaacb_modular_theta_series_acb_modular_theta_seriesacb_modular_theta_jet!acb_modular_theta_jet_notransformacb_modular_thetaacb_modular_theta_notransformacb_modular_theta_const_sumacb_modular_theta_const_sum_rs$acb_modular_theta_const_sum_basecaseacb_modular_theta_sumacb_modular_addseq_thetaacb_modular_theta_transformacb_modular_fill_addseq$acb_modular_is_in_fundamental_domain%acb_modular_fundamental_domain_approx)acb_modular_fundamental_domain_approx_arf'acb_modular_fundamental_domain_approx_dacb_modular_transformpsl2z_get_permpsl2z_word_get_str_prettypsl2z_word_fprint_prettypsl2z_word_get_strpsl2z_word_fprint_perm_set_wordpsl2z_set_wordpsl2z_get_wordpsl2z_word_clearpsl2z_word_initpsl2z_randtestpsl2z_is_correct psl2z_inv psl2z_mul psl2z_equal psl2z_fprint psl2z_get_str psl2z_is_one psl2z_one psl2z_set psl2z_swap psl2z_clear psl2z_initnewPSL2Z newPSL2Z_ withPSL2Z withNewPSL2Z withNewPSL2Z_ psl2z_print newPSL2ZWord withPSL2ZWordwithNewPSL2ZWordpsl2z_word_printpsl2z_word_print_pretty$fShowPSL2ZWord $fGroupPSL2Z$fSemigroupPSL2Z $fMonoidPSL2Z $fEqPSL2Z $fShowPSL2Zacb_elliptic_sigmaacb_elliptic_zetaacb_elliptic_inv_pacb_elliptic_rootsacb_elliptic_invariantsacb_elliptic_p_series_acb_elliptic_p_seriesacb_elliptic_p_jetacb_elliptic_p_primeacb_elliptic_pacb_elliptic_rc1acb_elliptic_rj_integrationacb_elliptic_rj_carlsonacb_elliptic_rjacb_elliptic_rgacb_elliptic_rfacb_elliptic_pi_incacb_elliptic_e_incacb_elliptic_facb_elliptic_piacb_elliptic_eacb_elliptic_k_series_acb_elliptic_k_seriesacb_elliptic_k_jetacb_elliptic_k $fShowAcbacb_hypgeom_dilogacb_hypgeom_dilog_bitburstacb_hypgeom_dilog_continuationacb_hypgeom_dilog_transformacb_hypgeom_dilog_zeroacb_hypgeom_dilog_zero_tayloracb_hypgeom_spherical_yacb_hypgeom_legendre_p_uiui_recacb_hypgeom_legendre_qacb_hypgeom_legendre_pacb_hypgeom_hermite_hacb_hypgeom_laguerre_lacb_hypgeom_gegenbauer_cacb_hypgeom_jacobi_pacb_hypgeom_chebyshev_uacb_hypgeom_chebyshev_tacb_hypgeom_2f1acb_hypgeom_2f1_chooseacb_hypgeom_2f1_corneracb_hypgeom_2f1_transform_limitacb_hypgeom_2f1_transformacb_hypgeom_2f1_directacb_hypgeom_2f1_series_directacb_hypgeom_2f1_continuationacb_hypgeom_li_series_acb_hypgeom_li_seriesacb_hypgeom_liacb_hypgeom_chi_series_acb_hypgeom_chi_seriesacb_hypgeom_chiacb_hypgeom_chi_2f3acb_hypgeom_chi_asympacb_hypgeom_shi_series_acb_hypgeom_shi_seriesacb_hypgeom_shiacb_hypgeom_ci_series_acb_hypgeom_ci_seriesacb_hypgeom_ciacb_hypgeom_ci_2f3acb_hypgeom_ci_asympacb_hypgeom_si_series_acb_hypgeom_si_seriesacb_hypgeom_siacb_hypgeom_si_1f2acb_hypgeom_si_asympacb_hypgeom_ei_series_acb_hypgeom_ei_seriesacb_hypgeom_eiacb_hypgeom_ei_2f2acb_hypgeom_ei_asympacb_hypgeom_expintacb_hypgeom_beta_lower_series_acb_hypgeom_beta_lower_seriesacb_hypgeom_beta_loweracb_hypgeom_gamma_lower_series_acb_hypgeom_gamma_lower_seriesacb_hypgeom_gamma_loweracb_hypgeom_gamma_upper_series_acb_hypgeom_gamma_upper_seriesacb_hypgeom_gamma_upper acb_hypgeom_gamma_upper_singularacb_hypgeom_gamma_upper_1f1bacb_hypgeom_gamma_upper_1f1aacb_hypgeom_gamma_upper_asympacb_hypgeom_coulomb_series_acb_hypgeom_coulomb_seriesacb_hypgeom_coulomb_jetacb_hypgeom_coulombacb_hypgeom_airy_series_acb_hypgeom_airy_seriesacb_hypgeom_airy_jetacb_hypgeom_airyacb_hypgeom_airy_boundacb_hypgeom_airy_asympacb_hypgeom_airy_directacb_hypgeom_bessel_k_scaledacb_hypgeom_bessel_kacb_hypgeom_bessel_k_0f1acb_hypgeom_bessel_k_0f1_seriesacb_hypgeom_bessel_k_asympacb_hypgeom_bessel_i_scaledacb_hypgeom_bessel_iacb_hypgeom_bessel_i_0f1acb_hypgeom_bessel_i_asympacb_hypgeom_bessel_jyacb_hypgeom_bessel_yacb_hypgeom_bessel_jacb_hypgeom_bessel_j_0f1acb_hypgeom_bessel_j_asympacb_hypgeom_fresnel_series_acb_hypgeom_fresnel_seriesacb_hypgeom_fresnelacb_hypgeom_erfi_series_acb_hypgeom_erfi_seriesacb_hypgeom_erfiacb_hypgeom_erfc_series_acb_hypgeom_erfc_seriesacb_hypgeom_erfcacb_hypgeom_erf_series_acb_hypgeom_erf_seriesacb_hypgeom_erfacb_hypgeom_erf_asympacb_hypgeom_erf_1f1bacb_hypgeom_erf_1f1a acb_hypgeom_erf_propagated_erroracb_hypgeom_0f1acb_hypgeom_0f1_directacb_hypgeom_0f1_asympacb_hypgeom_1f1 acb_hypgeom_macb_hypgeom_m_1f1acb_hypgeom_m_asymp acb_hypgeom_uacb_hypgeom_u_1f1acb_hypgeom_u_1f1_seriesacb_hypgeom_pfqacb_hypgeom_u_use_asympacb_hypgeom_u_asympacb_hypgeom_pfq_series_directacb_hypgeom_pfq_series_sumacb_hypgeom_pfq_series_sum_rsacb_hypgeom_pfq_series_sum_bs"acb_hypgeom_pfq_series_sum_forwardacb_hypgeom_pfq_directacb_hypgeom_pfq_sum_invzacb_hypgeom_pfq_sum_bs_invzacb_hypgeom_pfq_sumacb_hypgeom_pfq_sum_fmeacb_hypgeom_pfq_sum_bsacb_hypgeom_pfq_sum_rsacb_hypgeom_pfq_sum_forwardacb_hypgeom_pfq_choose_nacb_hypgeom_pfq_bound_factoracb_hypgeom_lgammaacb_hypgeom_rgammaacb_hypgeom_gammaacb_hypgeom_gamma_tayloracb_hypgeom_gamma_stirling'acb_hypgeom_gamma_stirling_sum_improved%acb_hypgeom_gamma_stirling_sum_horneracb_hypgeom_log_rising_ui_jetacb_hypgeom_log_rising_uiacb_hypgeom_rising_ui_jetacb_hypgeom_rising_ui_jet_rsacb_hypgeom_rising_ui_jet_bs acb_hypgeom_rising_ui_jet_powsumacb_hypgeom_risingacb_hypgeom_rising_uiacb_hypgeom_rising_ui_recacb_hypgeom_rising_ui_rsacb_hypgeom_rising_ui_bsacb_hypgeom_rising_ui_forward CAcbCalcFuncCAcbCalcIntegrateOptAcbCalcIntegrateOptacb_calc_integrate_tayloracb_calc_cauchy_boundacb_calc_integrate_gl_auto_degacb_calc_integrate_opt_initacb_calc_integratenewAcbCalcIntegrateOptnewAcbCalcIntegrateOpt_withAcbCalcIntegrateOptwithNewAcbCalcIntegrateOptwithNewAcbCalcIntegrateOpt_CDirichletHurwitzPrecompDirichletHurwitzPrecompCDirichletRootsDirichletRootsacb_dirichlet_platt_zeta_zeros!acb_dirichlet_platt_hardy_z_zeros'acb_dirichlet_platt_local_hardy_z_zeros(_acb_dirichlet_platt_local_hardy_z_zeros$acb_dirichlet_platt_ws_interpolation&acb_dirichlet_platt_multieval_threadedacb_dirichlet_platt_multieval%acb_dirichlet_platt_scaled_lambda_vec!acb_dirichlet_platt_scaled_lambdaacb_dirichlet_backlund_s_gramacb_dirichlet_zeta_nzeros_gramacb_dirichlet_backlund_s_boundacb_dirichlet_backlund_sacb_dirichlet_zeta_nzeros _acb_dirichlet_exact_zeta_nzerosacb_dirichlet_zeta_zerosacb_dirichlet_hardy_z_zeros"_acb_dirichlet_refine_hardy_z_zero"acb_dirichlet_isolate_hardy_z_zero*_acb_dirichlet_isolate_turing_hardy_z_zero*_acb_dirichlet_isolate_rosser_hardy_z_zero(_acb_dirichlet_isolate_gram_hardy_z_zero_acb_dirichlet_definite_hardy_z!acb_dirichlet_turing_method_boundacb_dirichlet_gram_pointacb_dirichlet_hardy_z_series_acb_dirichlet_hardy_z_series acb_dirichlet_hardy_theta_series!_acb_dirichlet_hardy_theta_seriesacb_dirichlet_hardy_zacb_dirichlet_hardy_thetaacb_dirichlet_l_series_acb_dirichlet_l_seriesacb_dirichlet_l_jetacb_dirichlet_l_vec_hurwitzacb_dirichlet_l_fmpqacb_dirichlet_l$_acb_dirichlet_euler_product_real_uiacb_dirichlet_l_euler_productacb_dirichlet_l_hurwitzacb_dirichlet_root_numberacb_dirichlet_root_number_thetaacb_dirichlet_dftacb_dirichlet_theta_lengthacb_dirichlet_ui_theta_arbacb_dirichlet_jacobi_sum_uiacb_dirichlet_jacobi_sumacb_dirichlet_jacobi_sum_gaussacb_dirichlet_jacobi_sum_factoracb_dirichlet_jacobi_sum_naiveacb_dirichlet_gauss_sum_uiacb_dirichlet_gauss_sumacb_dirichlet_gauss_sum_thetaacb_dirichlet_gauss_sum_order2acb_dirichlet_gauss_sum_factoracb_dirichlet_gauss_sum_naiveacb_dirichlet_pairing_characb_dirichlet_pairingacb_dirichlet_chi_vecacb_dirichlet_chiacb_dirichlet_stieltjes acb_dirichlet_lerch_phi_integral"acb_dirichlet_hurwitz_precomp_eval#acb_dirichlet_hurwitz_precomp_bound*acb_dirichlet_hurwitz_precomp_choose_param#acb_dirichlet_hurwitz_precomp_clear&acb_dirichlet_hurwitz_precomp_init_num"acb_dirichlet_hurwitz_precomp_initacb_dirichlet_hurwitzacb_dirichlet_zeta_jet_rsacb_dirichlet_zeta_rsacb_dirichlet_zeta_rs_racb_dirichlet_zeta_rs_boundacb_dirichlet_zeta_rs_d_coeffsacb_dirichlet_zeta_rs_f_coeffsacb_dirichlet_xiacb_dirichlet_etaacb_dirichlet_zeta_deriv_boundacb_dirichlet_zeta_boundacb_dirichlet_zeta_jetacb_dirichlet_zetaacb_dirichlet_powsum_smoothacb_dirichlet_powsum_sievedacb_dirichlet_powsum_termacb_dirichlet_rootacb_dirichlet_roots_clearacb_dirichlet_roots_initnewDirichletRootswithDirichletRootswithNewDirichletRootsnewDirichletHurwitzPrecompwithDirichletHurwitzPrecompwithNewDirichletHurwitzPrecomp CAcbDftCrt AcbDftCrt CAcbDftPre AcbDftPreacb_dft_crt_precompacb_dft_crt_clearacb_dft_crt_init acb_dft_crtacb_dft_convolacb_dft_convol_rad2acb_dft_convol_naiveacb_dft_inverse_precompacb_dft_precompacb_dft_precomp_clearacb_dft_precomp_initacb_dft_inverseacb_dft newAcbDftPre withAcbDftPrewithNewAcbDftPre newAcbDftCrt withAcbDftCrtwithNewAcbDftCrtacf_approx_dotacf_approx_sqrtacf_approx_divacf_approx_invacf_mulacf_subacf_add acf_equalacf_set acf_imag_ptr acf_real_ptracf_allocated_bytesacf_swap acf_clearacf_initnewAcfwithAcf withNewAcfd_log2d_is_nan d_lambertw d_polyvald_randtest_speciald_randtest_signed d_randtestCDiDi di_interval arb_get_di arb_set_didi_print di_randtest2 di_randtestdi_neg di_fast_add di_fast_sub di_fast_mul di_fast_div di_fast_sqr di_fast_add_d di_fast_sub_d di_fast_mul_d di_fast_div_ddi_fast_log_nonnegative di_fast_middi_fast_ubound_radiusCDMatDMatd_mat_qr d_mat_gsod_mat_mul_classicald_mat_transposed_mat_is_squared_mat_is_emptyd_mat_is_approx_zero d_mat_is_zerod_mat_approx_equal d_mat_equal d_mat_fprint d_mat_get_strd_mat_randtest d_mat_one d_mat_zerod_mat_entry_ptrd_mat_get_entryd_mat_swap_entrywise d_mat_swap d_mat_set d_mat_clear d_mat_initnewDMatwithDMat withNewDMat d_mat_entry d_mat_print $fShowDMat_d_vec_dot_thrice_d_vec_dot_heuristic _d_vec_norm _d_vec_dot _d_vec_sub _d_vec_add_d_vec_approx_equal_d_vec_is_approx_zero_d_vec_is_zero _d_vec_equal _d_vec_zero _d_vec_set_d_vec_randtest _d_vec_clear _d_vec_initCMpfMatMpfMat mpf_mat_qr mpf_mat_gso mpf_mat_mulmpf_mat_is_squarempf_mat_is_emptympf_mat_is_zerompf_mat_approx_equal mpf_mat_equal mpf_mat_printmpf_mat_randtest mpf_mat_one mpf_mat_zerompf_mat_swap_entrywise mpf_mat_swap mpf_mat_set mpf_mat_clear mpf_mat_init newMpfMat withMpfMat withNewMpfMat mpf_mat_entryCFmpzMatFmpzMatfmpz_mat_lll_storjohannfmpz_mat_lll_original fmpz_mat_is_reduced_with_removalfmpz_mat_is_reducedfmpz_mat_chol_dfmpz_mat_get_d_mat_transposefmpz_mat_get_d_matfmpz_mat_hadamardfmpz_mat_is_hadamard fmpz_mat_gramfmpz_mat_is_in_snffmpz_mat_snf_iliopoulosfmpz_mat_snf_kannan_bachemfmpz_mat_snf_diagonal fmpz_mat_snffmpz_mat_is_in_hnffmpz_mat_hnf_pernet_steinfmpz_mat_hnf_minorsfmpz_mat_hnf_modular_eldivfmpz_mat_hnf_modularfmpz_mat_hnf_xgcdfmpz_mat_hnf_classicalfmpz_mat_hnf_transform fmpz_mat_hnffmpz_mat_nullspacefmpz_mat_howell_form_mod fmpz_mat_strong_echelon_form_modfmpz_mat_rref_modfmpz_mat_is_in_rref_with_rankfmpz_mat_rref_mulfmpz_mat_rref_fflu fmpz_mat_rref fmpz_mat_fflufmpz_mat_find_pivot_anyfmpz_mat_can_solvefmpz_mat_can_solve_fflu fmpz_mat_can_solve_multi_mod_denfmpz_mat_solve_multi_mod_denfmpz_mat_solve_dixon_denfmpz_mat_solve_dixonfmpz_mat_solve_boundfmpz_mat_solve_cramerfmpz_mat_solve_fflu_precompfmpz_mat_solve_fflufmpz_mat_solvefmpz_mat_col_partition fmpz_mat_rankfmpz_mat_minpoly_fmpz_mat_minpolyfmpz_mat_minpoly_modular_fmpz_mat_minpoly_modularfmpz_mat_charpoly_fmpz_mat_charpolyfmpz_mat_charpoly_modular_fmpz_mat_charpoly_modularfmpz_mat_charpoly_berkowitz_fmpz_mat_charpoly_berkowitzfmpz_mat_similarityfmpz_mat_det_divisorfmpz_mat_det_bound_nonzerofmpz_mat_det_bound"fmpz_mat_det_modular_given_divisor fmpz_mat_det_modular_acceleratedfmpz_mat_det_modularfmpz_mat_det_bareissfmpz_mat_det_cofactor fmpz_mat_detfmpz_mat_tracefmpz_mat_contentfmpz_mat_kronecker_product fmpz_mat_invfmpz_mat_fmpz_vec_mulfmpz_mat_mul_fmpz_vec_fmpz_mat_mul_double_word_fmpz_mat_mul_small fmpz_mat_powfmpz_mat_sqr_bodrato fmpz_mat_sqrfmpz_mat_mul_fftfmpz_mat_mul_blas_fmpz_mat_mul_multi_modfmpz_mat_mul_strassenfmpz_mat_mul_classical fmpz_mat_mulfmpz_mat_scalar_smodfmpz_mat_scalar_tdiv_q_2expfmpz_mat_scalar_mul_2expfmpz_mat_scalar_divexact_si"fmpz_mat_scalar_addmul_nmod_mat_uifmpz_mat_scalar_submul_sifmpz_mat_scalar_addmul_sifmpz_mat_scalar_mul_si fmpz_mat_neg fmpz_mat_sub fmpz_mat_addfmpz_mat_multi_CRT_uifmpz_mat_multi_CRT_ui_precompfmpz_mat_multi_mod_uifmpz_mat_multi_mod_ui_precompfmpz_mat_CRT_uifmpz_mat_set_nmod_mat_unsignedfmpz_mat_set_nmod_matfmpz_mat_get_nmod_matfmpz_mat_concat_horizontalfmpz_mat_concat_verticalfmpz_mat_transposefmpz_mat_is_zero_rowfmpz_mat_is_squarefmpz_mat_is_emptyfmpz_mat_is_onefmpz_mat_is_zerofmpz_mat_equal fmpz_mat_readfmpz_mat_freadfmpz_mat_get_str_prettyfmpz_mat_fprint_prettyfmpz_mat_get_strfmpz_mat_fprintfmpz_mat_randopsfmpz_mat_randdetfmpz_mat_randrankfmpz_mat_randpermdiagfmpz_mat_randajtaifmpz_mat_randntrulike2fmpz_mat_randntrulikefmpz_mat_randsimdiophfmpz_mat_randintrelfmpz_mat_randtestfmpz_mat_randbitsfmpz_mat_window_clearfmpz_mat_window_initfmpz_mat_invert_colsfmpz_mat_invert_rowsfmpz_mat_swap_colsfmpz_mat_swap_rows fmpz_mat_one fmpz_mat_zerofmpz_mat_swap_entrywise fmpz_mat_swapfmpz_mat_init_set fmpz_mat_setfmpz_mat_clear fmpz_mat_init newFmpzMat withFmpzMatwithNewFmpzMatfmpz_mat_entryfmpz_mat_set_entryfmpz_mat_get_entryfmpz_mat_printfmpz_mat_print_prettyCQfbQfbqfb_exponent_grh qfb_exponentqfb_exponent_elementqfb_prime_formqfb_is_primitiveqfb_principal_formqfb_is_principal_form qfb_inverseqfb_pow qfb_pow_ui qfb_nudupl qfb_nucompqfb_reduced_forms_largeqfb_reduced_formsqfb_is_reduced qfb_reduceqfb_discriminant qfb_fprint qfb_get_str qfb_equalqfb_set qfb_hash_findqfb_hash_insertqfb_hash_clear qfb_hash_initqfb_array_clear qfb_clearqfb_initnewQfbwithQfb withNewQfb qfb_print $fShowQfb_perm_fprint_pretty_perm_get_str_pretty_perm_randtest _perm_mat _perm_order _perm_parity _perm_power _perm_compose _perm_inv _perm_set_one _perm_set _perm_clear _perm_init _perm_print_perm_print_prettyCBoolMatBoolMatbool_mat_all_pairs_longest_walk*bool_mat_get_strongly_connected_componentsbool_mat_transitive_closurebool_mat_nilpotency_degreebool_mat_tracebool_mat_pow_uibool_mat_mul_entrywise bool_mat_mul bool_mat_addbool_mat_complementbool_mat_transposebool_mat_directed_cyclebool_mat_directed_path bool_mat_one bool_mat_zerobool_mat_randtest_nilpotentbool_mat_randtest_diagonalbool_mat_randtestbool_mat_is_nilpotentbool_mat_is_transitivebool_mat_is_lower_triangularbool_mat_is_diagonal bool_mat_all bool_mat_anybool_mat_equalbool_mat_fprintbool_mat_get_str bool_mat_setbool_mat_clear bool_mat_init newBoolMat withBoolMatwithNewBoolMatbool_mat_get_entrybool_mat_set_entrybool_mat_is_emptybool_mat_is_squarebool_mat_entrybool_mat_print bool_mat_sqr $fShowBoolMat CFmpzPolyMat FmpzPolyMat fmpz_poly_mat_solve_fflu_precompfmpz_poly_mat_solve_fflufmpz_poly_mat_solvefmpz_poly_mat_nullspacefmpz_poly_mat_invfmpz_poly_mat_rankfmpz_poly_mat_det_interpolatefmpz_poly_mat_det_fflufmpz_poly_mat_detfmpz_poly_mat_tracefmpz_poly_mat_rreffmpz_poly_mat_fflu fmpz_poly_mat_find_pivot_partialfmpz_poly_mat_find_pivot_anyfmpz_poly_mat_prodfmpz_poly_mat_pow_truncfmpz_poly_mat_powfmpz_poly_mat_sqrlowfmpz_poly_mat_sqr_KSfmpz_poly_mat_sqr_classicalfmpz_poly_mat_sqrfmpz_poly_mat_mullowfmpz_poly_mat_mul_KSfmpz_poly_mat_mul_classicalfmpz_poly_mat_mulfmpz_poly_mat_negfmpz_poly_mat_subfmpz_poly_mat_addfmpz_poly_mat_scalar_mul_fmpz"fmpz_poly_mat_scalar_mul_fmpz_polyfmpz_poly_mat_evaluate_fmpzfmpz_poly_mat_transposefmpz_poly_mat_max_lengthfmpz_poly_mat_max_bitsfmpz_poly_mat_is_squarefmpz_poly_mat_is_emptyfmpz_poly_mat_is_onefmpz_poly_mat_is_zerofmpz_poly_mat_equalfmpz_poly_mat_onefmpz_poly_mat_zerofmpz_poly_mat_randtest_sparsefmpz_poly_mat_randtest_unsignedfmpz_poly_mat_randtestfmpz_poly_mat_swap_entrywisefmpz_poly_mat_swapfmpz_poly_mat_setfmpz_poly_mat_ncolsfmpz_poly_mat_nrowsfmpz_poly_mat_clearfmpz_poly_mat_init_setfmpz_poly_mat_initnewFmpzPolyMatwithFmpzPolyMatwithNewFmpzPolyMatfmpz_poly_mat_entryfmpz_poly_mat_print$fSemigroupFmpzMat $fNumFmpzMat $fEqFmpzMat $fShowFmpzMatarith_sum_of_squares_vecarith_sum_of_squaresarith_number_of_partitionsarith_hrr_expsum_factored#arith_number_of_partitions_nmod_vecarith_number_of_partitions_vecarith_landau_function_vecarith_ramanujan_tau_seriesarith_ramanujan_tauarith_divisorsarith_euler_polynomialarith_euler_number_sizearith_euler_number_vecarith_euler_number%_arith_bernoulli_number_vec_multi_mod%_arith_bernoulli_number_vec_recursivearith_bernoulli_polynomialarith_bernoulli_number_sizearith_bernoulli_number_denomarith_bernoulli_number_vec_arith_bernoulli_number_vecarith_bernoulli_number_arith_bernoulli_numberarith_bell_number_sizearith_bell_number_nmod_vecarith_bell_number_nmodarith_bell_number_vecarith_bell_numberarith_stirling_matrix_2arith_stirling_matrix_1arith_stirling_matrix_1u arith_stirling_number_2_vec_next arith_stirling_number_1_vec_next!arith_stirling_number_1u_vec_nextarith_stirling_number_2_vecarith_stirling_number_1_vecarith_stirling_number_1u_vecarith_stirling_number_2arith_stirling_number_1arith_stirling_number_1u_arith_harmonic_numberCFmpqMatFmpqMatfmpq_mat_minpoly_fmpq_mat_minpolyfmpq_mat_charpoly_fmpq_mat_charpolyfmpq_mat_similarity fmpq_mat_gso fmpq_mat_rreffmpq_mat_rref_fraction_freefmpq_mat_rref_classicalfmpq_mat_pivot fmpq_mat_invfmpq_mat_can_solvefmpq_mat_can_solve_dixon!fmpq_mat_can_solve_fmpz_mat_dixon fmpq_mat_can_solve_fraction_freefmpq_mat_can_solve_multi_modfmpq_mat_solve_fmpz_mat!fmpq_mat_solve_fmpz_mat_multi_modfmpq_mat_solve_fmpz_mat_dixon%fmpq_mat_solve_fmpz_mat_fraction_freefmpq_mat_solvefmpq_mat_solve_multi_modfmpq_mat_solve_dixonfmpq_mat_solve_fraction_free fmpq_mat_detfmpq_mat_tracefmpq_mat_kronecker_productfmpq_mat_fmpq_vec_mulfmpq_mat_mul_fmpq_vecfmpq_mat_mul_r_fmpz_matfmpq_mat_mul_fmpz_mat fmpq_mat_mulfmpq_mat_mul_clearedfmpq_mat_mul_directfmpq_mat_set_fmpz_mat_mod_fmpzfmpq_mat_get_fmpz_mat_mod_fmpzfmpq_mat_set_fmpz_mat_div_fmpzfmpq_mat_set_fmpz_matfmpq_mat_get_fmpz_mat_colwisefmpq_mat_get_fmpz_mat_rowwise_2fmpq_mat_get_fmpz_mat_rowwisefmpq_mat_get_fmpz_mat_matwisefmpq_mat_get_fmpz_mat_entrywisefmpq_mat_get_fmpz_matfmpq_mat_is_squarefmpq_mat_is_emptyfmpq_mat_is_onefmpq_mat_is_zerofmpq_mat_is_integralfmpq_mat_equalfmpq_mat_hilbert_matrixfmpq_mat_concat_horizontalfmpq_mat_concat_verticalfmpq_mat_window_clearfmpq_mat_window_initfmpq_mat_randtestfmpq_mat_randbitsfmpq_mat_fprintfmpq_mat_get_strfmpq_mat_scalar_div_fmpzfmpq_mat_scalar_mul_fmpzfmpq_mat_scalar_mul_fmpq fmpq_mat_neg fmpq_mat_sub fmpq_mat_addfmpq_mat_invert_colsfmpq_mat_invert_rowsfmpq_mat_swap_colsfmpq_mat_swap_rowsfmpq_mat_transpose fmpq_mat_one fmpq_mat_zero fmpq_mat_setfmpq_mat_ncolsfmpq_mat_nrowsfmpq_mat_entry_denfmpq_mat_entry_numfmpq_mat_swap_entrywise fmpq_mat_swapfmpq_mat_clearfmpq_mat_init_set fmpq_mat_init newFmpqMat withFmpqMatwithNewFmpqMatfmpq_mat_entryfmpq_mat_set_entryfmpq_mat_get_entryfmpq_mat_print CPadicMatPadicMat padic_mat_mulpadic_mat_scalar_div_fmpzpadic_mat_scalar_mul_fmpz_padic_mat_scalar_mul_fmpzpadic_mat_scalar_mul_padic_padic_mat_scalar_mul_padic padic_mat_neg_padic_mat_neg padic_mat_sub_padic_mat_sub padic_mat_add_padic_mat_addpadic_mat_transposepadic_mat_randtestpadic_mat_fprint_prettypadic_mat_fprintpadic_mat_get_str_prettypadic_mat_get_strpadic_mat_is_zeropadic_mat_equalpadic_mat_set_entry_padicpadic_mat_get_entry_padicpadic_mat_get_fmpq_matpadic_mat_set_fmpq_mat padic_mat_onepadic_mat_zeropadic_mat_swap_entrywisepadic_mat_swap padic_mat_setpadic_mat_is_canonicalpadic_mat_is_squarepadic_mat_is_emptypadic_mat_reduce_padic_mat_reduce_padic_mat_canonicalisepadic_mat_clearpadic_mat_init2padic_mat_initpadic_mat_ncolspadic_mat_nrowspadic_mat_get_precpadic_mat_get_val newPadicMat withPadicMat padic_matpadic_mat_entrypadic_mat_printpadic_mat_print_prettyCQQbarQQbar_qqbar_acb_lindepqqbar_enclosure_raw_qqbar_enclosure_raw$_qqbar_validate_existence_uniqueness_qqbar_validate_uniquenessqqbar_binary_opqqbar_fmpz_poly_composed_opqqbar_get_fexpr_formulaqqbar_get_fexpr_root_indexedqqbar_get_fexpr_root_nearestqqbar_get_fexpr_reprqqbar_set_fexprqqbar_get_quadraticqqbar_express_in_field qqbar_guess qqbar_acsc_pi qqbar_asec_pi qqbar_acot_pi qqbar_acos_pi qqbar_asin_pi qqbar_atan_piqqbar_log_pi_i qqbar_csc_pi qqbar_sec_pi qqbar_cot_pi qqbar_tan_pi qqbar_sin_pi qqbar_cos_piqqbar_exp_pi_iqqbar_is_root_of_unityqqbar_root_of_unityqqbar_eigenvalues_fmpq_matqqbar_eigenvalues_fmpz_matqqbar_roots_fmpq_polyqqbar_roots_fmpz_polyqqbar_evaluate_fmpz_mpoly qqbar_evaluate_fmpz_mpoly_hornerqqbar_evaluate_fmpz_mpoly_iterqqbar_evaluate_fmpz_poly_qqbar_evaluate_fmpz_polyqqbar_evaluate_fmpq_poly_qqbar_evaluate_fmpq_polyqqbar_conjugatesqqbar_numeratorqqbar_denominatorqqbar_cache_enclosureqqbar_get_arb_imqqbar_get_arb_re qqbar_get_arb qqbar_get_acb qqbar_powqqbar_fmpq_pow_si_uiqqbar_fmpq_root_ui qqbar_root_uiqqbar_pow_fmpqqqbar_pow_fmpz qqbar_pow_si qqbar_pow_ui qqbar_rsqrt qqbar_sqrt_ui qqbar_sqrtqqbar_scalar_op qqbar_si_div qqbar_ui_divqqbar_fmpz_divqqbar_fmpq_div qqbar_div_si qqbar_div_uiqqbar_div_fmpzqqbar_div_fmpq qqbar_div qqbar_inv qqbar_sqrqqbar_mul_2exp_si qqbar_mul_si qqbar_mul_uiqqbar_mul_fmpzqqbar_mul_fmpq qqbar_mul qqbar_si_sub qqbar_ui_subqqbar_fmpz_subqqbar_fmpq_sub qqbar_sub_si qqbar_sub_uiqqbar_sub_fmpzqqbar_sub_fmpq qqbar_sub qqbar_add_si qqbar_add_uiqqbar_add_fmpzqqbar_add_fmpq qqbar_add qqbar_neg qqbar_ceil qqbar_floor qqbar_csgn qqbar_sgn_im qqbar_sgn_re qqbar_sgn qqbar_abs2 qqbar_abs qqbar_re_imqqbar_imqqbar_re qqbar_conj qqbar_hashqqbar_cmp_root_order qqbar_cmpabsqqbar_cmpabs_imqqbar_cmpabs_re qqbar_cmp_im qqbar_cmp_reqqbar_equal_fmpq_poly_val qqbar_equalqqbar_randtest_nonrealqqbar_randtest_realqqbar_randtestqqbar_get_strndqqbar_get_strn qqbar_get_str qqbar_phiqqbar_i qqbar_one qqbar_zeroqqbar_get_fmpzqqbar_get_fmpq_qqbar_get_fmpqqqbar_binop_within_limitsqqbar_within_limitsqqbar_height_bits qqbar_height qqbar_is_realqqbar_is_neg_i qqbar_is_iqqbar_is_neg_one qqbar_is_one qqbar_is_zeroqqbar_is_algebraic_integerqqbar_is_integerqqbar_is_rational qqbar_degreeqqbar_set_re_im_d qqbar_set_dqqbar_set_re_imqqbar_set_fmpqqqbar_set_fmpz qqbar_set_ui qqbar_set_si qqbar_set qqbar_swap_qqbar_vec_clear_qqbar_vec_initnewQQbarnewQQbarFromFmpznewQQbarFromFmpqnewQQbarFromDouble withQQbar withNewQQbar qqbar_print qqbar_printn qqbar_printnd $fNumQQbar $fEqQQbar $fShowQQbarca_field_cache_insert_extca_field_cache_clearca_field_cache_init ca_field_cmpca_field_build_ideal_erfca_field_build_idealca_field_printca_field_clearca_field_set_extca_field_init_multica_field_init_fxyca_field_init_fxca_field_init_constca_field_init_nfca_field_init_qqCalciumPrintOption _ca_make_fmpq_ca_make_field_element ca_factorca_factor_get_caca_factor_insertca_factor_print ca_factor_oneca_factor_clearca_factor_initca_rewrite_complex_normal_formca_get_decimal_strca_get_acb_accurate_parts ca_get_acbca_get_acb_rawca_erfica_erfcca_erfca_gammaca_acosca_asinca_acos_directca_asin_directca_acos_logarithmca_asin_logarithmca_atanca_atan_directca_atan_logarithmca_cotca_tan ca_tan_directca_tan_exponentialca_tan_sine_cosineca_cosca_sin ca_sin_cosca_sin_cos_tangentca_sin_cos_directca_sin_cos_exponentialca_logca_expca_ceilca_floorca_conjca_conj_shallow ca_conj_deepca_imca_reca_argca_csgnca_sgnca_abs ca_sqrt_uica_sqrtca_sqrt_factorca_sqrt_nofactor ca_sqrt_inertca_pow_si_arithmeticca_pow ca_pow_si ca_pow_ui ca_pow_fmpz ca_pow_fmpqca_sqrca_inv_no_division_by_zero,ca_fmpz_mpoly_q_evaluate_no_division_by_zeroca_fmpz_mpoly_q_evaluateca_fmpz_mpoly_evaluateca_fmpz_mpoly_evaluate_hornerca_fmpq_poly_evaluateca_fmpz_poly_evaluateca_dotca_div ca_div_si ca_div_ui ca_div_fmpz ca_div_fmpq ca_si_div ca_ui_div ca_fmpz_div ca_fmpq_divca_invca_mul ca_mul_si ca_mul_ui ca_mul_fmpz ca_mul_fmpqca_sub ca_si_sub ca_ui_sub ca_fmpz_sub ca_fmpq_sub ca_sub_si ca_sub_ui ca_sub_fmpz ca_sub_fmpqca_add ca_add_si ca_add_ui ca_add_fmpz ca_add_fmpqca_negca_is_gen_as_extca_condense_fieldca_merge_fields ca_check_ge ca_check_gt ca_check_le ca_check_ltca_check_equalca_check_is_neg_i_infca_check_is_pos_i_infca_check_is_neg_infca_check_is_pos_infca_check_is_signed_infca_check_is_uinfca_check_is_infinityca_check_is_undefinedca_check_is_imaginaryca_check_is_negative_realca_check_is_realca_check_is_integerca_check_is_rationalca_check_is_algebraicca_check_is_neg_i ca_check_is_ica_check_is_neg_oneca_check_is_oneca_check_is_zeroca_check_is_numberca_is_generic_elemca_is_cyclotomic_nf_elem ca_is_nf_elemca_is_qq_elem_integerca_is_qq_elem_oneca_is_qq_elem_zero ca_is_qq_elem ca_is_special ca_is_unknown ca_hash_repr ca_cmp_repr ca_equal_reprca_randtest_same_nfca_randtest_special ca_randtestca_randtest_rationalca_can_evaluate_qqbar ca_get_qqbar ca_get_fmpq ca_get_fmpz ca_set_qqbar ca_transfer ca_set_d_dca_set_d ca_set_fmpq ca_set_fmpz ca_set_ui ca_set_sica_set ca_neg_i_inf ca_pos_i_inf ca_neg_inf ca_pos_infca_uinf ca_undefined ca_unknownca_eulerca_pi_ica_pica_neg_ica_i ca_neg_oneca_oneca_zero ca_printn ca_get_str ca_fprint ca_set_fexpr ca_get_fexprca_swapca_clearca_initca_ctx_set_optionca_ctx_get_option ca_ctx_print ca_ctx_clear ca_ctx_initnewCawithCa withNewCa newCaFactor withCaFactornewCaCtx withCaCtx ca_print_nca_print_digits ca_print_reprca_print_fieldca_print_defaultca_print_debugca_printca_factor_poly_noneca_factor_poly_contentca_factor_poly_sqfca_factor_poly_fullca_factor_zz_noneca_factor_zz_smoothca_factor_zz_fullca_opt_verboseca_opt_print_flagsca_opt_mpoly_ordca_opt_prec_limitca_opt_qqbar_deg_limitca_opt_low_precca_opt_smooth_limitca_opt_lll_precca_opt_pow_limitca_opt_use_groebnerca_opt_groebner_length_limit!ca_opt_groebner_poly_length_limitca_opt_groebner_poly_bits_limitca_opt_vieta_limitca_opt_trig_formca_trig_directca_trig_exponentialca_trig_sine_cosineca_trig_tangent_ca_vec_set_fmpz_vec_div_fmpz!_ca_vec_fmpq_vec_get_fmpz_vec_den_ca_vec_fmpq_vec_is_fmpz_vec_ca_vec_is_fmpq_vec_ca_vec_check_is_zero_ca_vec_scalar_submul_ca_ca_vec_scalar_addmul_ca_ca_vec_scalar_div_ca_ca_vec_scalar_mul_ca _ca_vec_sub _ca_vec_add ca_vec_neg _ca_vec_neg ca_vec_append ca_vec_printn ca_vec_print ca_vec_zero _ca_vec_zero ca_vec_set _ca_vec_setca_vec_entry_ptrca_vec_set_length_ca_vec_fit_length ca_vec_length ca_vec_swap _ca_vec_swap ca_vec_clear _ca_vec_clear ca_vec_init _ca_vec_initnewCaVec withCaVec withNewCaVecca_poly_vec_appendca_poly_vec_clear_ca_poly_vec_clearca_poly_vec_set_length_ca_poly_vec_fit_lengthca_poly_vec_init_ca_poly_vec_init ca_poly_roots_ca_poly_rootsca_poly_set_roots_ca_poly_set_rootsca_poly_squarefree_partca_poly_factor_squarefree ca_poly_gcd _ca_poly_gcdca_poly_gcd_euclidean_ca_poly_gcd_euclideanca_poly_log_series_ca_poly_log_seriesca_poly_exp_series_ca_poly_exp_seriesca_poly_div_series_ca_poly_div_seriesca_poly_inv_series_ca_poly_inv_seriesca_poly_integral_ca_poly_integralca_poly_derivative_ca_poly_derivativeca_poly_compose_ca_poly_composeca_poly_evaluate_ca_poly_evaluateca_poly_evaluate_horner_ca_poly_evaluate_hornerca_poly_pow_ui_ca_poly_pow_uica_poly_pow_ui_trunc_ca_poly_pow_ui_trunc ca_poly_rem ca_poly_divca_poly_divrem_ca_poly_divremca_poly_divrem_basecase_ca_poly_divrem_basecaseca_poly_div_caca_poly_mul_caca_poly_mullow_ca_poly_mullow ca_poly_mul _ca_poly_mul ca_poly_sub _ca_poly_sub ca_poly_add _ca_poly_add ca_poly_negca_poly_shift_right_ca_poly_shift_rightca_poly_shift_left_ca_poly_shift_leftca_poly_check_is_oneca_poly_check_is_zeroca_poly_check_equal_ca_poly_check_equalca_poly_reverse_ca_poly_reverseca_poly_make_monicca_poly_is_properca_poly_printnca_poly_fprintca_poly_get_strca_poly_randtest_rationalca_poly_randtestca_poly_transferca_poly_set_coeff_caca_poly_set_fmpq_polyca_poly_set_fmpz_poly ca_poly_setca_poly_set_sica_poly_set_ca ca_poly_x ca_poly_one ca_poly_zero_ca_poly_normalise_ca_poly_set_lengthca_poly_fit_length ca_poly_clear ca_poly_init newCaPoly withCaPoly withNewCaPoly ca_poly_printca_ext_cache_insertca_ext_cache_clearca_ext_cache_initca_ext_get_acb_rawca_ext_cmp_reprca_ext_equal_repr ca_ext_hashca_ext_get_arg ca_ext_nargs ca_ext_clearca_ext_init_setca_ext_init_fxnca_ext_init_fxyca_ext_init_fxca_ext_init_constca_ext_init_qqbar newCaExtQQbar newCaExtConst newCaExtFx newCaExtFxy newCaExtFxn withCaExt ca_ext_print$fSemigroupFmpqMat$fFractionalFmpqMat $fNumFmpqMat $fEqFmpqMat $fShowFmpqMat ca_mat_log ca_mat_expca_mat_jordan_formca_mat_jordan_transformationca_mat_set_jordan_blocksca_mat_jordan_blocksca_mat_diagonalizationca_mat_eigenvaluesca_mat_companionca_mat_charpoly_ca_mat_charpolyca_mat_charpoly_danilevsky_ca_mat_charpoly_danilevskyca_mat_charpoly_berkowitz_ca_mat_charpoly_berkowitzca_mat_adjugateca_mat_adjugate_charpolyca_mat_adjugate_cofactor ca_mat_detca_mat_det_cofactorca_mat_det_bareiss ca_mat_det_luca_mat_det_berkowitz ca_mat_traceca_mat_right_kernel ca_mat_rrefca_mat_rref_luca_mat_rref_fflu ca_mat_rankca_mat_solve_lu_precompca_mat_solve_fflu_precompca_mat_solve_triuca_mat_solve_triu_recursiveca_mat_solve_triu_classicalca_mat_solve_trilca_mat_solve_tril_recursiveca_mat_solve_tril_classicalca_mat_nonsingular_solveca_mat_nonsingular_solve_luca_mat_nonsingular_solve_fflu!ca_mat_nonsingular_solve_adjugate ca_mat_invca_mat_nonsingular_ffluca_mat_nonsingular_lu ca_mat_fflu ca_mat_luca_mat_lu_recursiveca_mat_lu_classicalca_mat_find_pivotca_mat_ca_poly_evaluate_ca_mat_ca_poly_evaluateca_mat_pow_ui_binexp ca_mat_sqrca_mat_submul_caca_mat_addmul_ca ca_mat_sub_ca ca_mat_add_ca ca_mat_div_caca_mat_div_fmpqca_mat_div_fmpz ca_mat_div_si ca_mat_mul_caca_mat_mul_fmpqca_mat_mul_fmpz ca_mat_mul_si ca_mat_mulca_mat_mul_same_nfca_mat_mul_classical ca_mat_sub ca_mat_add ca_mat_negca_mat_conj_transpose ca_mat_conjca_mat_transposeca_mat_check_is_oneca_mat_check_is_zeroca_mat_check_equal ca_mat_dftca_mat_hilbertca_mat_stirling ca_mat_pascal ca_mat_ones ca_mat_one ca_mat_zero ca_mat_printn ca_mat_fprintca_mat_get_strca_mat_randopsca_mat_randtest_rationalca_mat_randtestca_mat_transfer ca_mat_set_caca_mat_set_fmpq_matca_mat_set_fmpz_mat ca_mat_setca_mat_window_clearca_mat_window_init ca_mat_swap ca_mat_clear ca_mat_initca_mat_entry_ptrnewCaMat withCaMat withNewCaMat ca_mat_entry ca_mat_printCArbMatArbMatarb_mat_add_error_magarb_mat_get_midarb_mat_count_not_is_zeroarb_mat_count_is_zeroarb_mat_entrywise_not_is_zeroarb_mat_diag_prod_arb_mat_diag_prod arb_mat_trace arb_mat_exparb_mat_exp_taylor_sumarb_mat_companion_arb_mat_companionarb_mat_charpoly_arb_mat_charpolyarb_mat_inv_ldl_precomparb_mat_solve_ldl_precomp arb_mat_ldl_arb_mat_ldl_golub_and_van_loan_arb_mat_ldl_inplacearb_mat_spd_invarb_mat_inv_cho_precomparb_mat_spd_solvearb_mat_solve_cho_precomp arb_mat_cho_arb_mat_cholesky_banachiewiczarb_mat_approx_invarb_mat_approx_solvearb_mat_approx_solve_lu_precomparb_mat_approx_luarb_mat_approx_solve_trilarb_mat_approx_solve_triu arb_mat_detarb_mat_det_precondarb_mat_det_lu arb_mat_invarb_mat_solve_preapproxarb_mat_solve_precondarb_mat_solve_lu arb_mat_solvearb_mat_solve_lu_precomparb_mat_solve_triuarb_mat_solve_triu_recursivearb_mat_solve_triu_classicalarb_mat_solve_trilarb_mat_solve_tril_recursivearb_mat_solve_tril_classical arb_mat_luarb_mat_lu_recursivearb_mat_lu_classicalarb_mat_scalar_div_arbarb_mat_scalar_div_fmpzarb_mat_scalar_div_siarb_mat_scalar_mul_arbarb_mat_scalar_mul_fmpzarb_mat_scalar_mul_siarb_mat_scalar_addmul_arbarb_mat_scalar_addmul_fmpzarb_mat_scalar_addmul_siarb_mat_scalar_mul_2exp_siarb_mat_approx_mul_arb_mat_addmul_rad_mag_fastarb_mat_pow_ui arb_mat_sqrarb_mat_sqr_classicalarb_mat_mul_entrywise arb_mat_mularb_mat_mul_blockarb_mat_mul_threadedarb_mat_mul_classical arb_mat_sub arb_mat_add arb_mat_negarb_mat_bound_frobenius_normarb_mat_frobenius_normarb_mat_bound_inf_normarb_mat_transpose arb_mat_dctarb_mat_stirlingarb_mat_pascalarb_mat_hilbertarb_mat_indeterminate arb_mat_ones arb_mat_one arb_mat_zeroarb_mat_is_diagarb_mat_is_trilarb_mat_is_triuarb_mat_is_finitearb_mat_is_zeroarb_mat_is_exactarb_mat_is_squarearb_mat_is_empty arb_mat_ne arb_mat_eqarb_mat_contains_fmpq_matarb_mat_contains_fmpz_matarb_mat_containsarb_mat_overlaps arb_mat_equalarb_mat_fprintnarb_mat_fprintdarb_mat_get_strnarb_mat_get_strdarb_mat_randtestarb_mat_set_fmpq_matarb_mat_set_round_fmpz_matarb_mat_set_fmpz_mat arb_mat_entry arb_mat_setarb_mat_window_cleararb_mat_window_initarb_mat_allocated_bytes arb_mat_clear arb_mat_init newArbMatnewArbMatFromFmpzMatnewArbMatFromFmpzMatRoundnewArbMatFromFmpqMat withArbMat withNewArbMatarb_mat_printd $fShowArbMatCAcbMatAcbMatacb_mat_eig_multipleacb_mat_eig_multiple_rumpacb_mat_eig_simple$acb_mat_eig_simple_vdhoeven_mourrainacb_mat_eig_simple_rumpacb_mat_eig_enclosure_rumpacb_mat_eig_global_enclosureacb_mat_approx_eig_qracb_mat_add_error_magacb_mat_get_midacb_mat_diag_prod_acb_mat_diag_prod acb_mat_trace acb_mat_expacb_mat_exp_taylor_sumacb_mat_companion_acb_mat_companionacb_mat_charpoly_acb_mat_charpolyacb_mat_approx_invacb_mat_approx_solveacb_mat_approx_solve_lu_precompacb_mat_approx_luacb_mat_approx_solve_trilacb_mat_approx_solve_triu acb_mat_detacb_mat_det_precondacb_mat_det_lu acb_mat_invacb_mat_solve_precondacb_mat_solve_lu acb_mat_solveacb_mat_solve_lu_precompacb_mat_solve_triuacb_mat_solve_triu_recursiveacb_mat_solve_triu_classicalacb_mat_solve_trilacb_mat_solve_tril_recursiveacb_mat_solve_tril_classical acb_mat_luacb_mat_lu_recursiveacb_mat_lu_classicalacb_mat_scalar_div_acbacb_mat_scalar_div_arbacb_mat_scalar_div_fmpzacb_mat_scalar_div_siacb_mat_scalar_mul_acbacb_mat_scalar_mul_arbacb_mat_scalar_mul_fmpzacb_mat_scalar_mul_siacb_mat_scalar_addmul_acbacb_mat_scalar_addmul_arbacb_mat_scalar_addmul_fmpzacb_mat_scalar_addmul_siacb_mat_scalar_mul_2exp_siacb_mat_approx_mulacb_mat_pow_ui acb_mat_sqracb_mat_sqr_classicalacb_mat_mul_entrywise acb_mat_mulacb_mat_mul_reorderacb_mat_mul_threadedacb_mat_mul_classical acb_mat_sub acb_mat_add acb_mat_negacb_mat_bound_frobenius_normacb_mat_frobenius_normacb_mat_bound_inf_normacb_mat_conjugateacb_mat_conjugate_transposeacb_mat_transpose acb_mat_dftacb_mat_indeterminate acb_mat_ones acb_mat_one acb_mat_zeroacb_mat_is_diagacb_mat_is_trilacb_mat_is_triuacb_mat_is_finiteacb_mat_is_zeroacb_mat_is_exactacb_mat_is_squareacb_mat_is_emptyacb_mat_is_real acb_mat_ne acb_mat_eqacb_mat_contains_fmpq_matacb_mat_contains_fmpz_matacb_mat_containsacb_mat_overlaps acb_mat_equalacb_mat_fprintnacb_mat_fprintdacb_mat_get_strnacb_mat_get_strdacb_mat_randtest_eigacb_mat_randtestacb_mat_set_round_arb_matacb_mat_set_arb_matacb_mat_set_fmpq_matacb_mat_set_round_fmpz_matacb_mat_set_fmpz_mat acb_mat_set acb_mat_entryacb_mat_window_initacb_mat_allocated_bytes acb_mat_clear acb_mat_init newAcbMatnewAcbMatFromFmpzMatnewAcbMatFromFmpzMatRoundnewAcbMatFromFmpqMatnewAcbMatFromArbMatnewAcbMatFromArbMatRound withAcbMat withNewAcbMatacb_mat_printdacb_mat_printn $fShowAcbMatCFmpzLLLdeltaetartgtFmpzLLLfmpz_lll_with_removalfmpz_lllfmpz_lll_storjohann_ulllfmpz_lll_is_reducedfmpz_lll_is_reduced_dfmpz_lll_with_removal_ulll&fmpz_lll_wrapper_with_removal_knapsack fmpz_lll_d_with_removal_knapsackfmpz_lll_wrapper_with_removalfmpz_lll_mpf_with_removalfmpz_lll_mpf2_with_removal!fmpz_lll_d_heuristic_with_removalfmpz_lll_d_with_removalfmpz_lll_wrapper fmpz_lll_mpf fmpz_lll_mpf2fmpz_lll_d_heuristic fmpz_lll_dfmpz_lll_shift(fmpz_lll_advance_check_babai_heuristic_dfmpz_lll_advance_check_babaifmpz_lll_check_babai_heuristic fmpz_lll_check_babai_heuristic_dfmpz_lll_check_babaifmpz_lll_heuristic_dotfmpz_lll_randtestfmpz_lll_context_initfmpz_lll_context_init_defaultgramz_basisapproxexact newFmpzLLLnewFmpzLLLDefault withFmpzLLLwithNewFmpzLLLDefault_mpf_vec_norm2 _mpf_vec_dot2 _mpf_vec_norm _mpf_vec_dot_mpf_vec_scalar_mul_2exp_mpf_vec_scalar_mul_mpf _mpf_vec_sub _mpf_vec_add_mpf_vec_approx_equal_mpf_vec_is_zero_mpf_vec_equal_mpf_vec_set_fmpz_vec _mpf_vec_set _mpf_vec_zero_mpf_vec_randtest_mpf_vec_clear _mpf_vec_initCMpfrMatMpfrMatmpfr_mat_mul_classicalmpfr_mat_randtestmpfr_mat_equal mpfr_mat_zero mpfr_mat_setmpfr_mat_swap_entrywise mpfr_mat_swapmpfr_mat_clear mpfr_mat_init newMpfrMat withMpfrMatwithNewMpfrMatmpfr_mat_entry_mpfr_vec_scalar_product_mpfr_vec_scalar_mul_2exp_mpfr_vec_scalar_mul_mpfr _mpfr_vec_add _mpfr_vec_set_mpfr_vec_zero_mpfr_vec_clear_mpfr_vec_initCNPrimesNPrimesCNFactorNFactor n_factor_ecmn_factor_ecm_stage_IIn_factor_ecm_stage_In_factor_ecm_select_curve"n_factor_ecm_mul_montgomery_laddern_factor_ecm_addn_factor_ecm_doublen_discrete_log_bsgsn_primitive_root_prime n_primitive_root_prime_prefactorn_factorial_mod2_preinvn_factorial_fast_mod2_preinv n_euler_phin_is_squarefreen_moebius_mu_vec n_moebius_mun_factor_pollard_brentn_factor_pollard_brent_singlen_factor_pp1_wrapper n_factor_pp1n_factor_partialn_factor_trial_partialn_factorn_factor_SQUFOFn_factor_lehmann_factor_one_linen_factor_power235n_factor_trialn_factor_trial_rangen_factor_insertn_remove2_precompn_remove n_cbrtremn_cbrt_chebyshev_approxn_cbrt_binary_searchn_cbrt_newton_iterationn_cbrt n_rootremn_is_perfect_powern_is_perfect_power235 n_is_square n_sqrtremn_sqrtn_CRTn_is_probabprimen_is_probabprime_lucasn_is_probabprime_BPSWn_is_probabprime_fibonaccin_is_probabprime_fermatn_is_strong_probabprime2_preinvn_is_strong_probabprime_precomp n_is_primen_is_prime_pseudosquaren_is_prime_pocklingtonn_is_oddprime_binaryn_is_oddprime_smalln_nth_prime_bounds n_nth_primen_prime_pi_bounds n_prime_pi n_nextprimen_cleanup_primesn_prime_inverses_arr_readonlyn_primes_arr_readonlyn_compute_primesn_primes_sieve_rangen_primes_extend_smalln_primes_jump_after n_primes_nextn_primes_clear n_primes_init n_dividesn_mulmod_precomp_shoupn_mulmod_shoup n_sqrtmodnn_sqrtmod_primepown_sqrtmod_2pow n_sqrtmodn_powmod2_fmpz_preinvn_powmod2_ui_preinv n_powmod2n_powmod2_preinvn_powmodn_powmod_ui_precompn_powmod_precompn_invmodn_submodn_addmodn_jacobi_unsignedn_jacobin_xgcdn_gcdinvn_gcdn_mulmod_preinv n_mulmod2n_mulmod2_preinvn_mulmod_precompn_lll_mod_preinvn_ll_mod_preinvn_divrem2_precomp n_mod2_preinv n_div2_preinvn_divrem2_preinvn_mod2_precomp n_mod_precompn_precompute_inversen_preinvert_limbn_preinvert_limb_prenorm n_sizeinbasen_revbin n_clog_2expn_clogn_flogn_pown_randtest_prime n_randprimen_randtest_not_zero n_randtest n_urandint n_randintn_randtest_bits n_randbits n_randlimb newNFactor withNFactor newNPrimes withNPrimeswithNewNPrimesCThreadPoolHandleThreadPoolHandle CThreadPool ThreadPoolthread_pool_clearthread_pool_give_backthread_pool_waitthread_pool_wakethread_pool_requestthread_pool_set_sizethread_pool_get_sizethread_pool_init nmod_poly_mat_solve_fflu_precompnmod_poly_mat_solve_fflunmod_poly_mat_solvenmod_poly_mat_nullspacenmod_poly_mat_invnmod_poly_mat_ranknmod_poly_mat_det_interpolatenmod_poly_mat_det_fflunmod_poly_mat_detnmod_poly_mat_tracenmod_poly_mat_rrefnmod_poly_mat_fflu nmod_poly_mat_find_pivot_partialnmod_poly_mat_find_pivot_anynmod_poly_mat_pownmod_poly_mat_sqr_interpolatenmod_poly_mat_sqr_KSnmod_poly_mat_sqr_classicalnmod_poly_mat_sqrnmod_poly_mat_mul_interpolatenmod_poly_mat_mul_KSnmod_poly_mat_mul_classicalnmod_poly_mat_mulnmod_poly_mat_negnmod_poly_mat_subnmod_poly_mat_addnmod_poly_mat_scalar_mul_nmod"nmod_poly_mat_scalar_mul_nmod_polynmod_poly_mat_evaluate_nmodnmod_poly_mat_max_lengthnmod_poly_mat_is_squarenmod_poly_mat_is_emptynmod_poly_mat_is_onenmod_poly_mat_is_zeronmod_poly_mat_equalnmod_poly_mat_onenmod_poly_mat_zeronmod_poly_mat_randtest_sparsenmod_poly_mat_randtestnmod_poly_mat_swap_entrywisenmod_poly_mat_swapnmod_poly_mat_setnmod_poly_mat_modulusnmod_poly_mat_ncolsnmod_poly_mat_nrowsnmod_poly_mat_clearnmod_poly_mat_init_setnmod_poly_mat_initnewNModPolyMatwithNModPolyMatnmod_poly_mat_entrynmod_poly_mat_print_nmod_poly_interval_poly_workernmod_poly_factor$nmod_poly_factor_with_kaltofen_shoup'nmod_poly_factor_with_cantor_zassenhausnmod_poly_factor_with_berlekampnmod_poly_factor_kaltofen_shoupnmod_poly_factor_berlekamp"nmod_poly_factor_cantor_zassenhaus&nmod_poly_factor_distinct_deg_threadednmod_poly_factor_distinct_degnmod_poly_factor_equal_degnmod_poly_factor_equal_deg_probnmod_poly_factor_squarefreenmod_poly_is_squarefree_nmod_poly_is_squarefreenmod_poly_is_irreducible_rabinnmod_poly_is_irreducible_ddfnmod_poly_is_irreduciblenmod_poly_removenmod_poly_factor_pownmod_poly_factor_concatnmod_poly_factor_insertnmod_poly_factor_fprint_prettynmod_poly_factor_fprintnmod_poly_factor_get_str_prettynmod_poly_factor_get_strnmod_poly_factor_setnmod_poly_factor_fit_lengthnmod_poly_factor_reallocnmod_poly_factor_clearnmod_poly_factor_initnewNModPolyFactorwithNModPolyFactorwithNewNModPolyFactornmod_poly_factor_printnmod_poly_factor_print_prettynmod_berlekamp_massey_R_polynmod_berlekamp_massey_V_polynmod_berlekamp_massey_points!nmod_berlekamp_massey_point_countnmod_berlekamp_massey_reduce nmod_berlekamp_massey_add_pointsnmod_berlekamp_massey_set_prime nmod_berlekamp_massey_start_overnmod_berlekamp_massey_clearnmod_berlekamp_massey_init_nmod_poly_multi_crt_run_nmod_poly_multi_crt_local_sizenmod_poly_multi_crt_clearnmod_poly_multi_crtnmod_poly_multi_crt_precompnmod_poly_multi_crt_precomputenmod_poly_multi_crt_initnmod_poly_deflationnmod_poly_deflatenmod_poly_inflate_nmod_poly_tree_build_nmod_poly_tree_free_nmod_poly_tree_alloc%nmod_poly_find_distinct_nonzero_roots nmod_poly_product_roots_nmod_vec!_nmod_poly_product_roots_nmod_vecnmod_poly_tanh_series_nmod_poly_tanh_seriesnmod_poly_cosh_series_nmod_poly_cosh_seriesnmod_poly_sinh_series_nmod_poly_sinh_seriesnmod_poly_tan_series_nmod_poly_tan_seriesnmod_poly_cos_series_nmod_poly_cos_seriesnmod_poly_sin_series_nmod_poly_sin_seriesnmod_poly_asinh_series_nmod_poly_asinh_seriesnmod_poly_asin_series_nmod_poly_asin_seriesnmod_poly_atanh_series_nmod_poly_atanh_seriesnmod_poly_atan_series_nmod_poly_atan_seriesnmod_poly_exp_series_nmod_poly_exp_expinv_series_nmod_poly_exp_seriesnmod_poly_log_series_nmod_poly_log_seriesnmod_poly_power_sums_to_poly_nmod_poly_power_sums_to_poly'nmod_poly_power_sums_to_poly_schoenhage(_nmod_poly_power_sums_to_poly_schoenhage"nmod_poly_power_sums_to_poly_naive#_nmod_poly_power_sums_to_poly_naivenmod_poly_power_sums_nmod_poly_power_sumsnmod_poly_power_sums_schoenhage _nmod_poly_power_sums_schoenhagenmod_poly_power_sums_naive_nmod_poly_power_sums_naivenmod_poly_sqrt_nmod_poly_sqrtnmod_poly_sqrt_series_nmod_poly_sqrt_seriesnmod_poly_invsqrt_series_nmod_poly_invsqrt_seriesnmod_poly_revert_series_nmod_poly_revert_seriesnmod_poly_revert_series_newton_nmod_poly_revert_series_newton%nmod_poly_revert_series_lagrange_fast&_nmod_poly_revert_series_lagrange_fast nmod_poly_revert_series_lagrange!_nmod_poly_revert_series_lagrangenmod_poly_compose_series_nmod_poly_compose_seriesnmod_poly_discriminant_nmod_poly_discriminantnmod_poly_invmod_nmod_poly_invmodnmod_poly_gcdinv_nmod_poly_gcdinvnmod_poly_resultant_nmod_poly_resultantnmod_poly_resultant_hgcd_nmod_poly_resultant_hgcdnmod_poly_resultant_euclidean_nmod_poly_resultant_euclideannmod_poly_xgcd_nmod_poly_xgcdnmod_poly_xgcd_hgcd_nmod_poly_xgcd_hgcdnmod_poly_xgcd_euclidean_nmod_poly_xgcd_euclidean nmod_poly_gcd_nmod_poly_gcdnmod_poly_gcd_hgcd_nmod_poly_gcd_hgcd_nmod_poly_hgcdnmod_poly_gcd_euclidean_nmod_poly_gcd_euclideannmod_poly_compose_mod_nmod_poly_compose_mod4nmod_poly_compose_mod_brent_kung_vec_preinv_threaded9nmod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool:_nmod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool+nmod_poly_compose_mod_brent_kung_vec_preinv,_nmod_poly_compose_mod_brent_kung_vec_preinv/nmod_poly_compose_mod_brent_kung_precomp_preinv0_nmod_poly_compose_mod_brent_kung_precomp_preinv7_nmod_poly_compose_mod_brent_kung_precomp_preinv_workernmod_poly_precompute_matrix_nmod_poly_precompute_matrix#_nmod_poly_precompute_matrix_worker!_nmod_poly_reduce_matrix_mod_poly'nmod_poly_compose_mod_brent_kung_preinv(_nmod_poly_compose_mod_brent_kung_preinv nmod_poly_compose_mod_brent_kung!_nmod_poly_compose_mod_brent_kungnmod_poly_compose_mod_horner_nmod_poly_compose_mod_hornernmod_poly_taylor_shift_nmod_poly_taylor_shift"nmod_poly_taylor_shift_convolution#_nmod_poly_taylor_shift_convolutionnmod_poly_taylor_shift_horner_nmod_poly_taylor_shift_hornernmod_poly_compose_nmod_poly_composenmod_poly_compose_horner_nmod_poly_compose_horner*nmod_poly_interpolate_nmod_vec_barycentric+_nmod_poly_interpolate_nmod_vec_barycentric%nmod_poly_interpolate_nmod_vec_newton&_nmod_poly_interpolate_nmod_vec_newton#nmod_poly_interpolate_nmod_vec_fast$_nmod_poly_interpolate_nmod_vec_fast,_nmod_poly_interpolate_nmod_vec_fast_precomp _nmod_poly_interpolation_weightsnmod_poly_interpolate_nmod_vec_nmod_poly_interpolate_nmod_vecnmod_poly_evaluate_nmod_vec_nmod_poly_evaluate_nmod_vec nmod_poly_evaluate_nmod_vec_fast!_nmod_poly_evaluate_nmod_vec_fast)_nmod_poly_evaluate_nmod_vec_fast_precomp nmod_poly_evaluate_nmod_vec_iter!_nmod_poly_evaluate_nmod_vec_iternmod_poly_evaluate_mat*nmod_poly_evaluate_mat_paterson_stockmeyernmod_poly_evaluate_mat_hornernmod_poly_evaluate_nmod_nmod_poly_evaluate_nmodnmod_poly_integral_nmod_poly_integralnmod_poly_derivative_nmod_poly_derivativenmod_poly_divides_nmod_poly_dividesnmod_poly_divides_classical_nmod_poly_divides_classicalnmod_poly_div_root_nmod_poly_div_root nmod_poly_divrem_newton_n_preinv!_nmod_poly_divrem_newton_n_preinvnmod_poly_div_newton_n_preinv_nmod_poly_div_newton_n_preinvnmod_poly_div_series_nmod_poly_div_seriesnmod_poly_div_series_basecase_nmod_poly_div_series_basecasenmod_poly_inv_series_nmod_poly_inv_seriesnmod_poly_inv_series_newton_nmod_poly_inv_series_newtonnmod_poly_inv_series_basecase_nmod_poly_inv_series_basecase nmod_poly_rem_nmod_poly_rem_nmod_poly_rem_q1 nmod_poly_div_nmod_poly_divnmod_poly_divrem_nmod_poly_divremnmod_poly_divrem_basecase_nmod_poly_divrem_basecasenmod_poly_powers_mod_bsgs%_nmod_poly_powers_mod_preinv_threaded*_nmod_poly_powers_mod_preinv_threaded_poolnmod_poly_powers_mod_naive"_nmod_poly_powers_mod_preinv_naivenmod_poly_powmod_x_fmpz_preinv_nmod_poly_powmod_x_fmpz_preinvnmod_poly_powmod_x_ui_preinv_nmod_poly_powmod_x_ui_preinv#nmod_poly_powmod_fmpz_binexp_preinv$_nmod_poly_powmod_fmpz_binexp_preinv"nmod_poly_powmod_mpz_binexp_preinv#_nmod_poly_powmod_mpz_binexp_preinv!nmod_poly_powmod_ui_binexp_preinv"_nmod_poly_powmod_ui_binexp_preinvnmod_poly_powmod_fmpz_binexp_nmod_poly_powmod_fmpz_binexpnmod_poly_powmod_mpz_binexp_nmod_poly_powmod_mpz_binexpnmod_poly_powmod_ui_binexp_nmod_poly_powmod_ui_binexpnmod_poly_pow_trunc_nmod_poly_pow_truncnmod_poly_pow_trunc_binexp_nmod_poly_pow_trunc_binexp nmod_poly_pow_nmod_poly_pownmod_poly_pow_binexp_nmod_poly_pow_binexpnmod_poly_mulmod_preinv_nmod_poly_mulmod_preinvnmod_poly_mulmod_nmod_poly_mulmodnmod_poly_mulhigh_nmod_poly_mulhighnmod_poly_mullow_nmod_poly_mullow nmod_poly_mul_nmod_poly_mulnmod_poly_mullow_KS_nmod_poly_mullow_KSnmod_poly_mul_KS4_nmod_poly_mul_KS4nmod_poly_mul_KS2_nmod_poly_mul_KS2nmod_poly_mul_KS_nmod_poly_mul_KSnmod_poly_mulhigh_classical_nmod_poly_mulhigh_classicalnmod_poly_mullow_classical_nmod_poly_mullow_classicalnmod_poly_mul_classical_nmod_poly_mul_classical_nmod_poly_KS2_recover_reduce_nmod_poly_KS2_recover_reduce3_nmod_poly_KS2_recover_reduce2b_nmod_poly_KS2_recover_reduce2_nmod_poly_KS2_recover_reduce1_nmod_poly_KS2_reduce_nmod_poly_KS2_unpack_nmod_poly_KS2_unpack3_nmod_poly_KS2_unpack2_nmod_poly_KS2_unpack1_nmod_poly_KS2_pack_nmod_poly_KS2_pack1nmod_poly_bit_unpacknmod_poly_bit_pack_nmod_poly_bit_unpack_nmod_poly_bit_packnmod_poly_make_monic_nmod_poly_make_monicnmod_poly_scalar_mul_nmod nmod_poly_negnmod_poly_sub_series nmod_poly_sub_nmod_poly_subnmod_poly_add_series nmod_poly_add_nmod_poly_addnmod_poly_shift_right_nmod_poly_shift_rightnmod_poly_shift_left_nmod_poly_shift_leftnmod_poly_is_onenmod_poly_is_zeronmod_poly_equal_truncnmod_poly_equalnmod_poly_readnmod_poly_fprint_prettynmod_poly_fprintnmod_poly_freadnmod_poly_set_strnmod_poly_get_str_prettynmod_poly_get_strnmod_poly_set_coeff_uinmod_poly_get_coeff_ui%nmod_poly_randtest_sparse_irreducible(nmod_poly_randtest_pentomial_irreduciblenmod_poly_randtest_pentomial(nmod_poly_randtest_trinomial_irreduciblenmod_poly_randtest_trinomial"nmod_poly_randtest_monic_primitive$nmod_poly_randtest_monic_irreduciblenmod_poly_randtest_monicnmod_poly_randtest_irreduciblenmod_poly_randtestnmod_poly_reverse_nmod_poly_reversenmod_poly_set_truncnmod_poly_truncatenmod_poly_zeronmod_poly_swap nmod_poly_setnmod_poly_max_bitsnmod_poly_modulusnmod_poly_degreenmod_poly_length_nmod_poly_normalisenmod_poly_fit_lengthnmod_poly_clearnmod_poly_reallocnmod_poly_init2_preinvnmod_poly_init2nmod_poly_init_modnmod_poly_init_preinvnmod_poly_initsigned_mpn_sub_n newNModPoly withNModPolywithNewNModPolynmod_poly_printnmod_poly_print_prettynmod_mat_howell_formnmod_mat_strong_echelon_formnmod_mat_minpolynmod_mat_charpoly_berkowitznmod_mat_similaritynmod_mat_nullspacenmod_mat_reduce_row nmod_mat_rref nmod_mat_lunmod_mat_solve_vecnmod_mat_can_solvenmod_mat_can_solve_innernmod_mat_solvenmod_mat_solve_triu_recursivenmod_mat_solve_triu_classicalnmod_mat_solve_triunmod_mat_solve_tril_recursivenmod_mat_solve_tril_classicalnmod_mat_solve_tril nmod_mat_inv nmod_mat_rank nmod_mat_detnmod_mat_det_howellnmod_mat_trace nmod_mat_pow _nmod_mat_pownmod_mat_nmod_vec_mulnmod_mat_mul_nmod_vecnmod_mat_submulnmod_mat_addmulnmod_mat_mul_blasnmod_mat_mul_strassennmod_mat_mul_classical_threaded#_nmod_mat_mul_classical_threaded_op(_nmod_mat_mul_classical_threaded_pool_opnmod_mat_mul_classical_nmod_mat_mul_classical_op nmod_mat_mulnmod_mat_scalar_mul_fmpznmod_mat_scalar_addmul_uinmod_mat_scalar_mul nmod_mat_neg nmod_mat_sub nmod_mat_addnmod_mat_permute_rowsnmod_mat_invert_colsnmod_mat_invert_rowsnmod_mat_swap_colsnmod_mat_swap_rowsnmod_mat_transposenmod_mat_is_zero_rownmod_mat_equalnmod_mat_randtriunmod_mat_randtrilnmod_mat_randopsnmod_mat_randranknmod_mat_randpermdiagnmod_mat_randfullnmod_mat_randtestnmod_mat_print_prettynmod_mat_concat_horizontalnmod_mat_concat_verticalnmod_mat_window_clearnmod_mat_window_initnmod_mat_is_zero nmod_mat_zeronmod_mat_ncolsnmod_mat_nrowsnmod_mat_set_entrynmod_mat_entry_ptrnmod_mat_get_entrynmod_mat_swap_entrywise nmod_mat_swap nmod_mat_setnmod_mat_clearnmod_mat_init_set nmod_mat_init newNModMat withNModMatnmod_mat_entryfq_nmod_modulus_derivative_invfq_nmod_modulus_pow_series_inv!fq_nmod_embed_dual_to_mono_matrix!fq_nmod_embed_mono_to_dual_matrixfq_nmod_embed_mul_matrix$fq_nmod_embed_composition_matrix_sub fq_nmod_embed_composition_matrixfq_nmod_embed_trace_matrixfq_nmod_embed_matrices_fq_nmod_embed_gens_naivefq_nmod_embed_gens CFmpzModMat FmpzModMatfmpz_mod_mat_similarityfmpz_mod_mat_can_solvefmpz_mod_mat_solvefmpz_mod_mat_solve_triufmpz_mod_mat_solve_trilfmpz_mod_mat_lufmpz_mod_mat_invfmpz_mod_mat_howell_form fmpz_mod_mat_strong_echelon_formfmpz_mod_mat_rreffmpz_mod_mat_tracefmpz_mod_mat_fmpz_vec_mulfmpz_mod_mat_mul_fmpz_vecfmpz_mod_mat_sqr#fmpz_mod_mat_mul_classical_threaded,_fmpz_mod_mat_mul_classical_threaded_pool_opfmpz_mod_mat_mulfmpz_mod_mat_scalar_mul_fmpzfmpz_mod_mat_scalar_mul_uifmpz_mod_mat_scalar_mul_sifmpz_mod_mat_negfmpz_mod_mat_subfmpz_mod_mat_addfmpz_mod_mat_get_fmpz_matfmpz_mod_mat_set_fmpz_matfmpz_mod_mat_transposefmpz_mod_mat_setfmpz_mod_mat_is_zerofmpz_mod_mat_print_prettyfmpz_mod_mat_concat_verticalfmpz_mod_mat_concat_horizontalfmpz_mod_mat_window_clearfmpz_mod_mat_window_initfmpz_mod_mat_randtest_fmpz_mod_mat_reducefmpz_mod_mat_is_squarefmpz_mod_mat_is_emptyfmpz_mod_mat_swap_entrywisefmpz_mod_mat_swapfmpz_mod_mat_zerofmpz_mod_mat_one_fmpz_mod_mat_set_modfmpz_mod_mat_ncolsfmpz_mod_mat_nrowsfmpz_mod_mat_clearfmpz_mod_mat_init_setfmpz_mod_mat_initfmpz_mod_mat_set_entry newFmpzModMatwithFmpzModMatwithNewFmpzModMatfmpz_mod_mat_entryCFmpzModPolyRadixFmpzModPolyRadix CFmpzModPoly FmpzModPolyfmpz_mod_mat_minpolyfmpz_mod_mat_charpoly fmpz_mod_berlekamp_massey_R_poly fmpz_mod_berlekamp_massey_V_poly fmpz_mod_berlekamp_massey_points%fmpz_mod_berlekamp_massey_point_count fmpz_mod_berlekamp_massey_reduce$fmpz_mod_berlekamp_massey_add_points$fmpz_mod_berlekamp_massey_start_overfmpz_mod_berlekamp_massey_clearfmpz_mod_berlekamp_massey_initfmpz_mod_poly_deflationfmpz_mod_poly_deflatefmpz_mod_poly_inflatefmpz_mod_poly_fprint_prettyfmpz_mod_poly_fprint_fmpz_mod_poly_fprintfmpz_mod_poly_radix_fmpz_mod_poly_radixfmpz_mod_poly_radix_clearfmpz_mod_poly_radix_init_fmpz_mod_poly_radix_init_fmpz_mod_poly_tree_build_fmpz_mod_poly_tree_free_fmpz_mod_poly_tree_alloc8fmpz_mod_poly_compose_mod_brent_kung_vec_preinv_threaded=fmpz_mod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool>_fmpz_mod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool/fmpz_mod_poly_compose_mod_brent_kung_vec_preinv0_fmpz_mod_poly_compose_mod_brent_kung_vec_preinv+fmpz_mod_poly_compose_mod_brent_kung_preinv,_fmpz_mod_poly_compose_mod_brent_kung_preinv3fmpz_mod_poly_compose_mod_brent_kung_precomp_preinv4_fmpz_mod_poly_compose_mod_brent_kung_precomp_preinv;_fmpz_mod_poly_compose_mod_brent_kung_precomp_preinv_workerfmpz_mod_poly_precompute_matrix _fmpz_mod_poly_precompute_matrix'_fmpz_mod_poly_precompute_matrix_worker%_fmpz_mod_poly_reduce_matrix_mod_poly$fmpz_mod_poly_compose_mod_brent_kung%_fmpz_mod_poly_compose_mod_brent_kung fmpz_mod_poly_compose_mod_horner!_fmpz_mod_poly_compose_mod_hornerfmpz_mod_poly_compose_mod_fmpz_mod_poly_compose_modfmpz_mod_poly_sqrt_fmpz_mod_poly_sqrtfmpz_mod_poly_sqrt_series_fmpz_mod_poly_sqrt_seriesfmpz_mod_poly_invsqrt_series_fmpz_mod_poly_invsqrt_seriesfmpz_mod_poly_compose_fmpz_mod_poly_composefmpz_mod_poly_evaluate_fmpz_vec _fmpz_mod_poly_evaluate_fmpz_vec$fmpz_mod_poly_evaluate_fmpz_vec_fast%_fmpz_mod_poly_evaluate_fmpz_vec_fast-_fmpz_mod_poly_evaluate_fmpz_vec_fast_precomp$fmpz_mod_poly_evaluate_fmpz_vec_iter%_fmpz_mod_poly_evaluate_fmpz_vec_iterfmpz_mod_poly_evaluate_fmpz_fmpz_mod_poly_evaluate_fmpzfmpz_mod_poly_derivative_fmpz_mod_poly_derivativefmpz_mod_poly_discriminant_fmpz_mod_poly_discriminantfmpz_mod_poly_resultant_fmpz_mod_poly_resultantfmpz_mod_poly_resultant_hgcd_fmpz_mod_poly_resultant_hgcd!fmpz_mod_poly_resultant_euclidean"_fmpz_mod_poly_resultant_euclideanfmpz_mod_poly_minpoly_fmpz_mod_poly_minpolyfmpz_mod_poly_minpoly_hgcd_fmpz_mod_poly_minpoly_hgcdfmpz_mod_poly_minpoly_bm_fmpz_mod_poly_minpoly_bmfmpz_mod_poly_invmod_ffmpz_mod_poly_invmod_fmpz_mod_poly_invmod_f_fmpz_mod_poly_invmodfmpz_mod_poly_gcdinv_ffmpz_mod_poly_gcdinv_fmpz_mod_poly_gcdinv_f_fmpz_mod_poly_gcdinv fmpz_mod_poly_gcdinv_euclidean_f!_fmpz_mod_poly_gcdinv_euclidean_ffmpz_mod_poly_gcdinv_euclidean_fmpz_mod_poly_gcdinv_euclideanfmpz_mod_poly_xgcd_ffmpz_mod_poly_xgcd_fmpz_mod_poly_xgcdfmpz_mod_poly_xgcd_euclidean_f_fmpz_mod_poly_xgcd_euclidean_f_fmpz_mod_poly_hgcdfmpz_mod_poly_gcd_f_fmpz_mod_poly_gcd_ffmpz_mod_poly_gcd_euclidean_f_fmpz_mod_poly_gcd_euclidean_ffmpz_mod_poly_gcd_fmpz_mod_poly_gcdfmpz_mod_poly_make_monic_ffmpz_mod_poly_make_monicfmpz_mod_poly_div_series_fmpz_mod_poly_div_seriesfmpz_mod_poly_inv_series_ffmpz_mod_poly_inv_series_fmpz_mod_poly_inv_seriesfmpz_mod_poly_divides_fmpz_mod_poly_dividesfmpz_mod_poly_divides_classical _fmpz_mod_poly_divides_classical_fmpz_mod_poly_remfmpz_mod_poly_divrem_ffmpz_mod_poly_divrem_fmpz_mod_poly_divremfmpz_mod_poly_div_fmpz_mod_poly_divfmpz_mod_poly_rem_basecase_fmpz_mod_poly_rem_basecasefmpz_mod_poly_remove!fmpz_mod_poly_div_newton_n_preinv"_fmpz_mod_poly_div_newton_n_preinv$fmpz_mod_poly_divrem_newton_n_preinv%_fmpz_mod_poly_divrem_newton_n_preinvfmpz_mod_poly_divrem_basecase_fmpz_mod_poly_divrem_basecase$fmpz_mod_poly_frobenius_powers_clear&fmpz_mod_poly_frobenius_powers_precompfmpz_mod_poly_frobenius_power)fmpz_mod_poly_frobenius_powers_2exp_clear+fmpz_mod_poly_frobenius_powers_2exp_precompfmpz_mod_poly_powers_mod_bsgs._fmpz_mod_poly_powers_mod_preinv_threaded_poolfmpz_mod_poly_powers_mod_naive&_fmpz_mod_poly_powers_mod_preinv_naive"fmpz_mod_poly_powmod_x_fmpz_preinv#_fmpz_mod_poly_powmod_x_fmpz_preinv'fmpz_mod_poly_powmod_fmpz_binexp_preinv(_fmpz_mod_poly_powmod_fmpz_binexp_preinv fmpz_mod_poly_powmod_fmpz_binexp!_fmpz_mod_poly_powmod_fmpz_binexp%fmpz_mod_poly_powmod_ui_binexp_preinv&_fmpz_mod_poly_powmod_ui_binexp_preinvfmpz_mod_poly_powmod_ui_binexp_fmpz_mod_poly_powmod_ui_binexpfmpz_mod_poly_pow_trunc_binexp_fmpz_mod_poly_pow_trunc_binexpfmpz_mod_poly_pow_trunc_fmpz_mod_poly_pow_truncfmpz_mod_poly_pow_fmpz_mod_poly_pow)fmpz_mod_poly_find_distinct_nonzero_roots$fmpz_mod_poly_product_roots_fmpz_vec%_fmpz_mod_poly_product_roots_fmpz_vecfmpz_mod_poly_mulmod_preinv_fmpz_mod_poly_mulmod_preinvfmpz_mod_poly_mulmod_fmpz_mod_poly_mulmodfmpz_mod_poly_mulhighfmpz_mod_poly_sqr_fmpz_mod_poly_sqrfmpz_mod_poly_mullow_fmpz_mod_poly_mullowfmpz_mod_poly_mul_fmpz_mod_poly_mulfmpz_mod_poly_scalar_div_fmpz_fmpz_mod_poly_scalar_div_fmpz fmpz_mod_poly_scalar_addmul_fmpzfmpz_mod_poly_scalar_mul_fmpz_fmpz_mod_poly_scalar_mul_fmpzfmpz_mod_poly_neg_fmpz_mod_poly_negfmpz_mod_poly_sub_seriesfmpz_mod_poly_sub_fmpz_mod_poly_subfmpz_mod_poly_add_seriesfmpz_mod_poly_add_fmpz_mod_poly_addfmpz_mod_poly_shift_right_fmpz_mod_poly_shift_rightfmpz_mod_poly_shift_left_fmpz_mod_poly_shift_leftfmpz_mod_poly_get_coeff_fmpzfmpz_mod_poly_set_coeff_uifmpz_mod_poly_set_coeff_fmpzfmpz_mod_poly_is_genfmpz_mod_poly_is_onefmpz_mod_poly_is_zerofmpz_mod_poly_equal_truncfmpz_mod_poly_equalfmpz_mod_poly_set_nmod_polyfmpz_mod_poly_get_nmod_polyfmpz_mod_poly_get_fmpz_polyfmpz_mod_poly_set_fmpz_polyfmpz_mod_poly_set_fmpzfmpz_mod_poly_set_uifmpz_mod_poly_reversefmpz_mod_poly_zero_coeffsfmpz_mod_poly_onefmpz_mod_poly_zerofmpz_mod_poly_swapfmpz_mod_poly_setfmpz_mod_poly_leadfmpz_mod_poly_lengthfmpz_mod_poly_degree)fmpz_mod_poly_randtest_sparse_irreducible,fmpz_mod_poly_randtest_pentomial_irreducible fmpz_mod_poly_randtest_pentomial,fmpz_mod_poly_randtest_trinomial_irreducible fmpz_mod_poly_randtest_trinomial&fmpz_mod_poly_randtest_monic_primitive(fmpz_mod_poly_randtest_monic_irreduciblefmpz_mod_poly_randtest_monicfmpz_mod_poly_randtest_not_zero"fmpz_mod_poly_randtest_irreduciblefmpz_mod_poly_randtestfmpz_mod_poly_set_truncfmpz_mod_poly_truncate_fmpz_mod_poly_set_length_fmpz_mod_poly_normalisefmpz_mod_poly_fit_lengthfmpz_mod_poly_reallocfmpz_mod_poly_clearfmpz_mod_poly_init2fmpz_mod_poly_initnewFmpzModPolywithFmpzModPolywithNewFmpzModPolynewFmpzModPolyRadixwithFmpzModPolyRadixfmpz_mod_poly_printfmpz_mod_poly_print_prettyCNFElemNFElemnf_elem_coprime_den_signednf_elem_coprime_dennf_elem_smod_fmpznf_elem_mod_fmpznf_elem_smod_fmpz_dennf_elem_mod_fmpz_dennf_elem_rep_mat_fmpz_mat_dennf_elem_rep_mat nf_elem_trace_nf_elem_trace_nf_elem_norm_divnf_elem_norm_div nf_elem_norm _nf_elem_norm nf_elem_pow _nf_elem_pow nf_elem_div _nf_elem_div nf_elem_inv _nf_elem_invnf_elem_mul_red nf_elem_mul_nf_elem_mul_red _nf_elem_mul nf_elem_sub _nf_elem_sub nf_elem_add _nf_elem_addnf_elem_mul_gen nf_elem_swap nf_elem_neg nf_elem_set nf_elem_one nf_elem_zeronf_elem_get_str_prettynf_elem_is_onenf_elem_is_zero nf_elem_equal_nf_elem_equal_nf_elem_set_coeff_num_fmpznf_elem_get_dennf_elem_set_dennf_elem_get_fmpz_mod_polynf_elem_get_fmpz_mod_poly_dennf_elem_get_nmod_polynf_elem_get_nmod_poly_dennf_elem_get_fmpq_polynf_elem_set_fmpq_polynf_elem_get_fmpz_mat_rownf_elem_set_fmpz_mat_row_nf_elem_invertible_checknf_elem_reduce_nf_elem_reducenf_elem_canonicalisenf_elem_randtest nf_elem_clear nf_elem_init newNFElem withNFElem withNewNFElemnf_elem_print_prettyCFqCtxFqCtx fq_bit_unpack fq_bit_packfq_is_primitivefq_multiplicative_order fq_frobenius _fq_frobeniusfq_norm_fq_normfq_trace _fq_tracefq_is_invertible_ffq_is_invertiblefq_equal fq_is_one fq_is_zerofq_set_fmpz_mod_matfq_get_fmpz_mod_matfq_set_fmpz_mod_polyfq_set_fmpz_polyfq_get_fmpz_mod_polyfq_get_fmpz_poly fq_get_fmpzfq_genfq_onefq_zerofq_swap fq_set_fmpz fq_set_ui fq_set_sifq_setfq_rand_not_zerofq_randfq_randtest_densefq_randtest_not_zero fq_randtestfq_get_str_pretty fq_get_str fq_fprintfq_fprint_pretty fq_is_square fq_pth_rootfq_sqrt fq_pow_uifq_pow_fq_pow fq_gcdinvfq_inv_fq_invfq_divfq_sqr fq_mul_ui fq_mul_si fq_mul_fmpzfq_mulfq_neg fq_sub_onefq_subfq_add fq_reduce _fq_reduce_fq_dense_reduce_fq_sparse_reducefq_clearfq_init2fq_initfq_ctx_randtest_reduciblefq_ctx_randtest fq_ctx_fprintfq_ctx_get_str fq_ctx_order fq_ctx_prime fq_ctx_degreefq_ctx_modulus fq_ctx_clearfq_ctx_init_modulusfq_ctx_init_conway_fq_ctx_init_conway fq_ctx_initnewFqwithFq withNewFqnewFqCtx withFqCtx withNewFqCtxnewFqCtxConwaywithNewFqCtxConwaynewFqCtxModuluswithNewFqCtxModulus fq_ctx_printfq_print_prettyfq_print _fq_vec_dot_fq_vec_scalar_submul_fq_fq_vec_scalar_addmul_fq _fq_vec_sub _fq_vec_add_fq_vec_is_zero _fq_vec_equal _fq_vec_neg _fq_vec_zero _fq_vec_swap _fq_vec_set _fq_vec_print_fq_vec_fprint_fq_vec_randtest _fq_vec_clear _fq_vec_initfq_nmod_mat_minpolyfq_nmod_mat_charpolyfq_nmod_mat_charpoly_danilevskyfq_nmod_mat_similarityfq_nmod_mat_can_solvefq_nmod_mat_solve fq_nmod_mat_solve_triu_recursive fq_nmod_mat_solve_triu_classicalfq_nmod_mat_solve_triu fq_nmod_mat_solve_tril_recursive fq_nmod_mat_solve_tril_classicalfq_nmod_mat_solve_trilfq_nmod_mat_reduce_rowfq_nmod_mat_rreffq_nmod_mat_lu_recursivefq_nmod_mat_lu_classicalfq_nmod_mat_lufq_nmod_mat_invfq_nmod_mat_vec_mul_ptrfq_nmod_mat_vec_mulfq_nmod_mat_mul_vec_ptrfq_nmod_mat_mul_vecfq_nmod_mat_submulfq_nmod_mat_mul_KSfq_nmod_mat_mul_classicalfq_nmod_mat_mulfq_nmod_mat_negfq_nmod_mat_subfq_nmod_mat_addfq_nmod_mat_is_squarefq_nmod_mat_is_emptyfq_nmod_mat_is_onefq_nmod_mat_is_zerofq_nmod_mat_equalfq_nmod_mat_randtriufq_nmod_mat_randtrilfq_nmod_mat_randopsfq_nmod_mat_randrankfq_nmod_mat_randpermdiagfq_nmod_mat_randtestfq_nmod_mat_window_clearfq_nmod_mat_window_initfq_nmod_mat_fprintfq_nmod_mat_printfq_nmod_mat_fprint_prettyfq_nmod_mat_print_prettyfq_nmod_mat_concat_horizontalfq_nmod_mat_concat_verticalfq_nmod_mat_set_fmpz_mod_matfq_nmod_mat_set_nmod_matfq_nmod_mat_invert_colsfq_nmod_mat_invert_rowsfq_nmod_mat_swap_colsfq_nmod_mat_swap_rowsfq_nmod_mat_onefq_nmod_mat_zerofq_nmod_mat_swap_entrywisefq_nmod_mat_swapfq_nmod_mat_ncolsfq_nmod_mat_nrowsfq_nmod_mat_entry_setfq_nmod_mat_setfq_nmod_mat_clearfq_nmod_mat_init_setfq_nmod_mat_init newFqNModMat withFqNModMatfq_nmod_mat_entryfq_zech_bit_unpackfq_zech_bit_packfq_zech_multiplicative_orderfq_zech_frobenius fq_zech_norm fq_zech_tracefq_zech_is_invertible_ffq_zech_is_invertible fq_zech_equalfq_zech_is_onefq_zech_is_zerofq_zech_set_nmod_matfq_zech_get_nmod_matfq_zech_set_nmod_polyfq_zech_get_nmod_polyfq_zech_set_fq_nmodfq_zech_get_fq_nmodfq_zech_get_fmpz fq_zech_gen fq_zech_one fq_zech_zero fq_zech_swapfq_zech_set_fmpzfq_zech_set_uifq_zech_set_si fq_zech_setfq_zech_rand_not_zero fq_zech_randfq_zech_randtest_not_zerofq_zech_randtestfq_zech_get_str_prettyfq_zech_get_strfq_zech_fprintfq_zech_fprint_prettyfq_zech_is_squarefq_zech_pth_root fq_zech_sqrtfq_zech_pow_ui fq_zech_powfq_zech_gcdinv fq_zech_inv fq_zech_div fq_zech_sqrfq_zech_mul_uifq_zech_mul_sifq_zech_mul_fmpz fq_zech_mul fq_zech_negfq_zech_sub_one fq_zech_sub fq_zech_addfq_zech_reduce fq_zech_clear fq_zech_init2 fq_zech_initfq_zech_ctx_randtest_reduciblefq_zech_ctx_randtestfq_zech_ctx_fprintfq_zech_ctx_get_strfq_zech_ctx_order_uifq_zech_ctx_orderfq_zech_ctx_degreefq_zech_ctx_modulusfq_zech_ctx_clear"fq_zech_ctx_init_fq_nmod_ctx_checkfq_zech_ctx_init_fq_nmod_ctxfq_zech_ctx_init_modulus_checkfq_zech_ctx_init_modulusfq_zech_ctx_init_randomfq_zech_ctx_init_conway_fq_zech_ctx_init_conwayfq_zech_ctx_init newFqZech withFqZech newFqZechCtxnewFqZechCtxConwaynewFqZechCtxRandomnewFqZechCtxModulusnewFqZechCtxModulusChecknewFqZechCtxFqNModCtxnewFqZechCtxFqNModCtxCheck withFqZechCtxfq_zech_ctx_printfq_zech_print_pretty fq_zech_print_fq_zech_vec_dot"_fq_zech_vec_scalar_submul_fq_zech"_fq_zech_vec_scalar_addmul_fq_zech_fq_zech_vec_sub_fq_zech_vec_add_fq_zech_vec_is_zero_fq_zech_vec_equal_fq_zech_vec_neg_fq_zech_vec_zero_fq_zech_vec_swap_fq_zech_vec_set_fq_zech_vec_print_fq_zech_vec_fprint_fq_zech_vec_randtest_fq_zech_vec_clear_fq_zech_vec_initfq_zech_mat_minpolyfq_zech_mat_charpolyfq_zech_mat_charpoly_danilevskyfq_zech_mat_similarityfq_zech_mat_can_solvefq_zech_mat_solve fq_zech_mat_solve_triu_recursive fq_zech_mat_solve_triu_classicalfq_zech_mat_solve_triu fq_zech_mat_solve_tril_recursive fq_zech_mat_solve_tril_classicalfq_zech_mat_solve_trilfq_zech_mat_reduce_rowfq_zech_mat_rreffq_zech_mat_lu_recursivefq_zech_mat_lu_classicalfq_zech_mat_lufq_zech_mat_vec_mul_ptrfq_zech_mat_vec_mulfq_zech_mat_mul_vec_ptrfq_zech_mat_mul_vecfq_zech_mat_submulfq_zech_mat_mul_KSfq_zech_mat_mul_classicalfq_zech_mat_mulfq_zech_mat_negfq_zech_mat_subfq_zech_mat_addfq_zech_mat_is_squarefq_zech_mat_is_emptyfq_zech_mat_is_onefq_zech_mat_is_zerofq_zech_mat_equalfq_zech_mat_randtriufq_zech_mat_randtrilfq_zech_mat_randopsfq_zech_mat_randrankfq_zech_mat_randpermdiagfq_zech_mat_randtestfq_zech_mat_window_clearfq_zech_mat_window_initfq_zech_mat_fprintfq_zech_mat_fprint_prettyfq_zech_mat_concat_horizontalfq_zech_mat_concat_verticalfq_zech_mat_set_fmpz_mod_matfq_zech_mat_set_nmod_matfq_zech_mat_onefq_zech_mat_zerofq_zech_mat_swap_entrywisefq_zech_mat_swapfq_zech_mat_ncolsfq_zech_mat_nrowsfq_zech_mat_entry_setfq_zech_mat_setfq_zech_mat_clearfq_zech_mat_init_setfq_zech_mat_init newFqZechMat withFqZechMatfq_zech_mat_entryfq_zech_mat_print_prettyfq_zech_mat_printfq_zech_modulus_derivative_invfq_zech_modulus_pow_series_inv!fq_zech_embed_dual_to_mono_matrix!fq_zech_embed_mono_to_dual_matrixfq_zech_embed_mul_matrix$fq_zech_embed_composition_matrix_sub fq_zech_embed_composition_matrixfq_zech_embed_trace_matrixfq_zech_embed_matrices_fq_zech_embed_gens_naivefq_zech_embed_gens_fq_nmod_vec_dot"_fq_nmod_vec_scalar_submul_fq_nmod"_fq_nmod_vec_scalar_addmul_fq_nmod_fq_nmod_vec_sub_fq_nmod_vec_add_fq_nmod_vec_is_zero_fq_nmod_vec_equal_fq_nmod_vec_neg_fq_nmod_vec_zero_fq_nmod_vec_swap_fq_nmod_vec_set_fq_nmod_vec_print_fq_nmod_vec_fprint_fq_nmod_vec_randtest_fq_nmod_vec_clear_fq_nmod_vec_initfq_mat_minpolyfq_mat_charpolyfq_mat_charpoly_danilevskyfq_mat_similarityfq_mat_can_solve fq_mat_solvefq_mat_solve_triu_recursivefq_mat_solve_triu_classicalfq_mat_solve_triufq_mat_solve_tril_recursivefq_mat_solve_tril_classicalfq_mat_solve_trilfq_mat_reduce_row fq_mat_rreffq_mat_lu_recursivefq_mat_lu_classical fq_mat_lu fq_mat_invfq_mat_vec_mul_ptrfq_mat_vec_mulfq_mat_mul_vec_ptrfq_mat_mul_vec fq_mat_submul fq_mat_mul_KSfq_mat_mul_classical fq_mat_mul fq_mat_neg fq_mat_sub fq_mat_addfq_mat_is_squarefq_mat_is_empty fq_mat_is_onefq_mat_is_zero fq_mat_equalfq_mat_randtriufq_mat_randtrilfq_mat_randopsfq_mat_randrankfq_mat_randpermdiagfq_mat_randtestfq_mat_window_clearfq_mat_window_init fq_mat_fprint fq_mat_printfq_mat_fprint_prettyfq_mat_print_prettyfq_mat_concat_horizontalfq_mat_concat_verticalfq_mat_set_fmpz_mod_matfq_mat_set_nmod_matfq_mat_invert_colsfq_mat_invert_rowsfq_mat_swap_colsfq_mat_swap_rows fq_mat_one fq_mat_zerofq_mat_swap_entrywise fq_mat_swap fq_mat_ncols fq_mat_nrowsfq_mat_entry_set fq_mat_set fq_mat_clearfq_mat_init_set fq_mat_initnewFqMat withFqMat withNewFqMat fq_mat_entryfq_poly_deflationfq_poly_deflatefq_poly_inflatefq_poly_get_str_pretty_fq_poly_get_str_prettyfq_poly_get_str_fq_poly_get_str_fq_poly_printfq_poly_fprint_fq_poly_fprint_fq_poly_print_prettyfq_poly_fprint_pretty_fq_poly_fprint_pretty-fq_poly_compose_mod_brent_kung_precomp_preinv._fq_poly_compose_mod_brent_kung_precomp_preinvfq_poly_precompute_matrix_fq_poly_precompute_matrix_fq_poly_reduce_matrix_mod_polyfq_poly_compose_mod_preinv_fq_poly_compose_mod_preinvfq_poly_compose_mod_fq_poly_compose_mod%fq_poly_compose_mod_brent_kung_preinv&_fq_poly_compose_mod_brent_kung_preinvfq_poly_compose_mod_brent_kung_fq_poly_compose_mod_brent_kung!fq_poly_compose_mod_horner_preinv"_fq_poly_compose_mod_horner_preinvfq_poly_compose_mod_horner_fq_poly_compose_mod_hornerfq_poly_compose_fq_poly_composefq_poly_evaluate_fq_fq_poly_evaluate_fq fq_poly_sqrt _fq_poly_sqrtfq_poly_sqrt_series_fq_poly_sqrt_seriesfq_poly_invsqrt_series_fq_poly_invsqrt_seriesfq_poly_derivative_fq_poly_derivativefq_poly_divides_fq_poly_dividesfq_poly_xgcd_euclidean_f_fq_poly_xgcd_euclidean_f fq_poly_xgcd _fq_poly_xgcdfq_poly_gcd_euclidean_f_fq_poly_gcd_euclidean_f _fq_poly_gcd fq_poly_gcdfq_poly_div_series_fq_poly_div_seriesfq_poly_inv_series_fq_poly_inv_seriesfq_poly_inv_series_newton_fq_poly_inv_series_newton_fq_poly_divrem_newton_n_preinvfq_poly_div_newton_n_preinv_fq_poly_div_newton_n_preinv fq_poly_div _fq_poly_div fq_poly_rem _fq_poly_remfq_poly_divrem_ffq_poly_divrem_fq_poly_divremfq_poly_hamming_weightfq_poly_shift_right_fq_poly_shift_rightfq_poly_shift_left_fq_poly_shift_leftfq_poly_pow_trunc_fq_poly_pow_truncfq_poly_pow_trunc_binexp_fq_poly_pow_trunc_binexpfq_poly_powmod_x_fmpz_preinv_fq_poly_powmod_x_fmpz_preinv"fq_poly_powmod_fmpz_sliding_preinv#_fq_poly_powmod_fmpz_sliding_preinv!fq_poly_powmod_fmpz_binexp_preinv"_fq_poly_powmod_fmpz_binexp_preinvfq_poly_powmod_fmpz_binexp_fq_poly_powmod_fmpz_binexpfq_poly_powmod_ui_binexp_preinv _fq_poly_powmod_ui_binexp_preinvfq_poly_powmod_ui_binexp_fq_poly_powmod_ui_binexp fq_poly_pow _fq_poly_pow fq_poly_sqr _fq_poly_sqrfq_poly_sqr_KS_fq_poly_sqr_KSfq_poly_sqr_reorder_fq_poly_sqr_reorderfq_poly_sqr_classical_fq_poly_sqr_classicalfq_poly_mulmod_preinv_fq_poly_mulmod_preinvfq_poly_mulmod_fq_poly_mulmodfq_poly_mulhigh_fq_poly_mulhighfq_poly_mulhigh_classical_fq_poly_mulhigh_classicalfq_poly_mullow_fq_poly_mullowfq_poly_mullow_KS_fq_poly_mullow_KSfq_poly_mullow_univariate_fq_poly_mullow_univariatefq_poly_mullow_classical_fq_poly_mullow_classical fq_poly_mul _fq_poly_mulfq_poly_mul_KS_fq_poly_mul_KSfq_poly_mul_univariate_fq_poly_mul_univariatefq_poly_mul_reorder_fq_poly_mul_reorderfq_poly_mul_classical_fq_poly_mul_classicalfq_poly_scalar_div_fq_fq_poly_scalar_div_fqfq_poly_scalar_submul_fq_fq_poly_scalar_submul_fqfq_poly_scalar_addmul_fq_fq_poly_scalar_addmul_fqfq_poly_scalar_mul_fq_fq_poly_scalar_mul_fq fq_poly_neg _fq_poly_negfq_poly_sub_series fq_poly_sub _fq_poly_subfq_poly_add_seriesfq_poly_add_si fq_poly_add _fq_poly_addfq_poly_equal_fqfq_poly_is_unitfq_poly_is_genfq_poly_is_onefq_poly_is_zerofq_poly_equal_trunc fq_poly_equalfq_poly_set_coeff_fmpzfq_poly_set_coefffq_poly_get_coeff_fq_poly_make_monicfq_poly_make_monic fq_poly_gen fq_poly_one fq_poly_zero _fq_poly_zero fq_poly_swapfq_poly_set_nmod_polyfq_poly_set_fmpz_mod_polyfq_poly_set_fq fq_poly_set _fq_poly_setfq_poly_randtest_irreduciblefq_poly_randtest_monicfq_poly_randtest_not_zerofq_poly_randtest fq_poly_leadfq_poly_lengthfq_poly_degreefq_poly_reverse_fq_poly_reversefq_poly_set_truncfq_poly_truncate_fq_poly_normalise2_fq_poly_normalise fq_poly_clear_fq_poly_set_lengthfq_poly_fit_lengthfq_poly_realloc fq_poly_init2 fq_poly_init newFqPoly withFqPoly withNewFqPolyfq_poly_print_pretty fq_poly_printfq_zech_poly_deflationfq_zech_poly_deflatefq_zech_poly_inflatefq_zech_poly_get_str_pretty_fq_zech_poly_get_str_prettyfq_zech_poly_get_str_fq_zech_poly_get_str_fq_zech_poly_printfq_zech_poly_fprint_fq_zech_poly_fprint_fq_zech_poly_print_prettyfq_zech_poly_fprint_pretty_fq_zech_poly_fprint_pretty2fq_zech_poly_compose_mod_brent_kung_precomp_preinv3_fq_zech_poly_compose_mod_brent_kung_precomp_preinvfq_zech_poly_precompute_matrix_fq_zech_poly_precompute_matrix$_fq_zech_poly_reduce_matrix_mod_polyfq_zech_poly_compose_mod_preinv _fq_zech_poly_compose_mod_preinvfq_zech_poly_compose_mod_fq_zech_poly_compose_mod*fq_zech_poly_compose_mod_brent_kung_preinv+_fq_zech_poly_compose_mod_brent_kung_preinv#fq_zech_poly_compose_mod_brent_kung$_fq_zech_poly_compose_mod_brent_kung&fq_zech_poly_compose_mod_horner_preinv'_fq_zech_poly_compose_mod_horner_preinvfq_zech_poly_compose_mod_horner _fq_zech_poly_compose_mod_hornerfq_zech_poly_compose_fq_zech_poly_composefq_zech_poly_evaluate_fq_zech_fq_zech_poly_evaluate_fq_zechfq_zech_poly_sqrt_fq_zech_poly_sqrtfq_zech_poly_sqrt_series_fq_zech_poly_sqrt_seriesfq_zech_poly_invsqrt_series_fq_zech_poly_invsqrt_seriesfq_zech_poly_derivative_fq_zech_poly_derivativefq_zech_poly_divides_fq_zech_poly_dividesfq_zech_poly_xgcd_euclidean_f_fq_zech_poly_xgcd_euclidean_ffq_zech_poly_xgcd_fq_zech_poly_xgcdfq_zech_poly_gcd_euclidean_f_fq_zech_poly_gcd_euclidean_f_fq_zech_poly_gcdfq_zech_poly_gcdfq_zech_poly_div_series_fq_zech_poly_div_seriesfq_zech_poly_inv_series_fq_zech_poly_inv_seriesfq_zech_poly_inv_series_newton_fq_zech_poly_inv_series_newton#fq_zech_poly_divrem_newton_n_preinv$_fq_zech_poly_divrem_newton_n_preinv fq_zech_poly_div_newton_n_preinv!_fq_zech_poly_div_newton_n_preinvfq_zech_poly_div_fq_zech_poly_divfq_zech_poly_rem_fq_zech_poly_remfq_zech_poly_divrem_ffq_zech_poly_divrem_fq_zech_poly_divremfq_zech_poly_hamming_weight_fq_zech_poly_hamming_weightfq_zech_poly_shift_right_fq_zech_poly_shift_rightfq_zech_poly_shift_left_fq_zech_poly_shift_leftfq_zech_poly_pow_trunc_fq_zech_poly_pow_truncfq_zech_poly_pow_trunc_binexp_fq_zech_poly_pow_trunc_binexp!fq_zech_poly_powmod_x_fmpz_preinv"_fq_zech_poly_powmod_x_fmpz_preinv'fq_zech_poly_powmod_fmpz_sliding_preinv(_fq_zech_poly_powmod_fmpz_sliding_preinv&fq_zech_poly_powmod_fmpz_binexp_preinv'_fq_zech_poly_powmod_fmpz_binexp_preinvfq_zech_poly_powmod_fmpz_binexp _fq_zech_poly_powmod_fmpz_binexp$fq_zech_poly_powmod_ui_binexp_preinv%_fq_zech_poly_powmod_ui_binexp_preinvfq_zech_poly_powmod_ui_binexp_fq_zech_poly_powmod_ui_binexpfq_zech_poly_pow_fq_zech_poly_powfq_zech_poly_sqr_fq_zech_poly_sqrfq_zech_poly_sqr_KS_fq_zech_poly_sqr_KSfq_zech_poly_sqr_classical_fq_zech_poly_sqr_classicalfq_zech_poly_mulmod_preinv_fq_zech_poly_mulmod_preinvfq_zech_poly_mulmod_fq_zech_poly_mulmodfq_zech_poly_mulhigh_fq_zech_poly_mulhighfq_zech_poly_mulhigh_classical_fq_zech_poly_mulhigh_classicalfq_zech_poly_mullow_fq_zech_poly_mullowfq_zech_poly_mullow_KS_fq_zech_poly_mullow_KSfq_zech_poly_mullow_classical_fq_zech_poly_mullow_classicalfq_zech_poly_mul_fq_zech_poly_mulfq_zech_poly_mul_KS_fq_zech_poly_mul_KSfq_zech_poly_mul_classical_fq_zech_poly_mul_classical"fq_zech_poly_scalar_submul_fq_zech#_fq_zech_poly_scalar_submul_fq_zech"fq_zech_poly_scalar_addmul_fq_zech#_fq_zech_poly_scalar_addmul_fq_zechfq_zech_poly_scalar_mul_fq_zech _fq_zech_poly_scalar_mul_fq_zechfq_zech_poly_neg_fq_zech_poly_negfq_zech_poly_sub_seriesfq_zech_poly_sub_fq_zech_poly_subfq_zech_poly_add_seriesfq_zech_poly_add_sifq_zech_poly_add_fq_zech_poly_addfq_zech_poly_equal_fq_zechfq_zech_poly_is_unitfq_zech_poly_is_genfq_zech_poly_is_onefq_zech_poly_is_zerofq_zech_poly_equal_truncfq_zech_poly_equalfq_zech_poly_set_coeff_fmpzfq_zech_poly_set_coefffq_zech_poly_get_coeff_fq_zech_poly_make_monicfq_zech_poly_make_monicfq_zech_poly_genfq_zech_poly_onefq_zech_poly_zero_fq_zech_poly_zerofq_zech_poly_swapfq_zech_poly_set_nmod_polyfq_zech_poly_set_fmpz_mod_polyfq_zech_poly_set_fq_zechfq_zech_poly_set_fq_zech_poly_set!fq_zech_poly_randtest_irreduciblefq_zech_poly_randtest_monicfq_zech_poly_randtest_not_zerofq_zech_poly_randtestfq_zech_poly_leadfq_zech_poly_lengthfq_zech_poly_degreefq_zech_poly_reverse_fq_zech_poly_reversefq_zech_poly_set_truncfq_zech_poly_truncate_fq_zech_poly_normalise2_fq_zech_poly_normalisefq_zech_poly_clear_fq_zech_poly_set_lengthfq_zech_poly_fit_lengthfq_zech_poly_reallocfq_zech_poly_init2fq_zech_poly_init newFqZechPolywithFqZechPolyfq_zech_poly_print_prettyfq_zech_poly_printfq_zech_poly_roots&fq_zech_poly_iterated_frobenius_preinv'fq_zech_poly_factor_with_kaltofen_shoup*fq_zech_poly_factor_with_cantor_zassenhaus"fq_zech_poly_factor_with_berlekampfq_zech_poly_factor_berlekamp"fq_zech_poly_factor_kaltofen_shoup%fq_zech_poly_factor_cantor_zassenhausfq_zech_poly_factorfq_zech_poly_factor_squarefree fq_zech_poly_factor_distinct_deg fq_zech_poly_factor_split_singlefq_zech_poly_factor_equal_deg"fq_zech_poly_factor_equal_deg_probfq_zech_poly_is_squarefree_fq_zech_poly_is_squarefree"fq_zech_poly_is_irreducible_ben_orfq_zech_poly_is_irreducible_ddffq_zech_poly_is_irreduciblefq_zech_poly_removefq_zech_poly_factor_powfq_zech_poly_factor_concatfq_zech_poly_factor_insertfq_zech_poly_factor_setfq_zech_poly_factor_fit_lengthfq_zech_poly_factor_reallocfq_zech_poly_factor_clearfq_zech_poly_factor_initnewFqZechPolyFactorwithFqZechPolyFactor fq_zech_poly_factor_print_prettyfq_zech_poly_factor_print CFqPolyFactor FqPolyFactor fq_poly_roots!fq_poly_iterated_frobenius_preinv"fq_poly_factor_with_kaltofen_shoup%fq_poly_factor_with_cantor_zassenhausfq_poly_factor_with_berlekampfq_poly_factor_berlekampfq_poly_factor_kaltofen_shoup fq_poly_factor_cantor_zassenhausfq_poly_factorfq_poly_factor_squarefreefq_poly_factor_distinct_degfq_poly_factor_split_singlefq_poly_factor_equal_degfq_poly_factor_equal_deg_probfq_poly_is_squarefree_fq_poly_is_squarefreefq_poly_is_irreducible_ben_orfq_poly_is_irreducible_ddffq_poly_is_irreduciblefq_poly_removefq_poly_factor_powfq_poly_factor_concatfq_poly_factor_insertfq_poly_factor_setfq_poly_factor_fit_lengthfq_poly_factor_reallocfq_poly_factor_clearfq_poly_factor_initnewFqPolyFactorwithFqPolyFactorwithNewFqPolyFactorfq_poly_factor_print_prettyfq_poly_factor_printfq_nmod_poly_deflationfq_nmod_poly_deflatefq_nmod_poly_inflatefq_nmod_poly_get_str_pretty_fq_nmod_poly_get_str_prettyfq_nmod_poly_get_str_fq_nmod_poly_get_str_fq_nmod_poly_printfq_nmod_poly_fprint_fq_nmod_poly_fprint_fq_nmod_poly_print_prettyfq_nmod_poly_fprint_pretty_fq_nmod_poly_fprint_pretty2fq_nmod_poly_compose_mod_brent_kung_precomp_preinv3_fq_nmod_poly_compose_mod_brent_kung_precomp_preinvfq_nmod_poly_precompute_matrix_fq_nmod_poly_precompute_matrix$_fq_nmod_poly_reduce_matrix_mod_polyfq_nmod_poly_compose_mod_preinv _fq_nmod_poly_compose_mod_preinvfq_nmod_poly_compose_mod_fq_nmod_poly_compose_mod*fq_nmod_poly_compose_mod_brent_kung_preinv+_fq_nmod_poly_compose_mod_brent_kung_preinv#fq_nmod_poly_compose_mod_brent_kung$_fq_nmod_poly_compose_mod_brent_kung&fq_nmod_poly_compose_mod_horner_preinv'_fq_nmod_poly_compose_mod_horner_preinvfq_nmod_poly_compose_mod_horner _fq_nmod_poly_compose_mod_hornerfq_nmod_poly_compose_fq_nmod_poly_composefq_nmod_poly_evaluate_fq_nmod_fq_nmod_poly_evaluate_fq_nmodfq_nmod_poly_sqrt_fq_nmod_poly_sqrtfq_nmod_poly_sqrt_series_fq_nmod_poly_sqrt_seriesfq_nmod_poly_invsqrt_series_fq_nmod_poly_invsqrt_seriesfq_nmod_poly_derivative_fq_nmod_poly_derivativefq_nmod_poly_divides_fq_nmod_poly_dividesfq_nmod_poly_xgcd_euclidean_f_fq_nmod_poly_xgcd_euclidean_ffq_nmod_poly_xgcd_fq_nmod_poly_xgcdfq_nmod_poly_gcd_euclidean_f_fq_nmod_poly_gcd_euclidean_f_fq_nmod_poly_gcdfq_nmod_poly_gcdfq_nmod_poly_div_series_fq_nmod_poly_div_seriesfq_nmod_poly_inv_series_fq_nmod_poly_inv_seriesfq_nmod_poly_inv_series_newton_fq_nmod_poly_inv_series_newton#fq_nmod_poly_divrem_newton_n_preinv$_fq_nmod_poly_divrem_newton_n_preinv fq_nmod_poly_div_newton_n_preinv!_fq_nmod_poly_div_newton_n_preinvfq_nmod_poly_div_fq_nmod_poly_divfq_nmod_poly_rem_fq_nmod_poly_remfq_nmod_poly_divrem_ffq_nmod_poly_divrem_fq_nmod_poly_divremfq_nmod_poly_hamming_weight_fq_nmod_poly_hamming_weightfq_nmod_poly_shift_right_fq_nmod_poly_shift_rightfq_nmod_poly_shift_left_fq_nmod_poly_shift_leftfq_nmod_poly_pow_trunc_fq_nmod_poly_pow_truncfq_nmod_poly_pow_trunc_binexp_fq_nmod_poly_pow_trunc_binexp!fq_nmod_poly_powmod_x_fmpz_preinv"_fq_nmod_poly_powmod_x_fmpz_preinv'fq_nmod_poly_powmod_fmpz_sliding_preinv(_fq_nmod_poly_powmod_fmpz_sliding_preinv&fq_nmod_poly_powmod_fmpz_binexp_preinv'_fq_nmod_poly_powmod_fmpz_binexp_preinvfq_nmod_poly_powmod_fmpz_binexp _fq_nmod_poly_powmod_fmpz_binexp$fq_nmod_poly_powmod_ui_binexp_preinv%_fq_nmod_poly_powmod_ui_binexp_preinvfq_nmod_poly_powmod_ui_binexp_fq_nmod_poly_powmod_ui_binexpfq_nmod_poly_pow_fq_nmod_poly_powfq_nmod_poly_sqr_fq_nmod_poly_sqrfq_nmod_poly_sqr_KS_fq_nmod_poly_sqr_KSfq_nmod_poly_sqr_classical_fq_nmod_poly_sqr_classicalfq_nmod_poly_mulmod_preinv_fq_nmod_poly_mulmod_preinvfq_nmod_poly_mulmod_fq_nmod_poly_mulmodfq_nmod_poly_mulhigh_fq_nmod_poly_mulhighfq_nmod_poly_mulhigh_classical_fq_nmod_poly_mulhigh_classicalfq_nmod_poly_mullow_fq_nmod_poly_mullowfq_nmod_poly_mullow_KS_fq_nmod_poly_mullow_KSfq_nmod_poly_mullow_univariate_fq_nmod_poly_mullow_univariatefq_nmod_poly_mullow_classical_fq_nmod_poly_mullow_classicalfq_nmod_poly_mul_fq_nmod_poly_mulfq_nmod_poly_mul_KS_fq_nmod_poly_mul_KSfq_nmod_poly_mul_univariate_fq_nmod_poly_mul_univariatefq_nmod_poly_mul_classical_fq_nmod_poly_mul_classical"fq_nmod_poly_scalar_submul_fq_nmod#_fq_nmod_poly_scalar_submul_fq_nmod"fq_nmod_poly_scalar_addmul_fq_nmod#_fq_nmod_poly_scalar_addmul_fq_nmodfq_nmod_poly_scalar_mul_fq_nmod _fq_nmod_poly_scalar_mul_fq_nmodfq_nmod_poly_neg_fq_nmod_poly_negfq_nmod_poly_sub_seriesfq_nmod_poly_sub_fq_nmod_poly_subfq_nmod_poly_add_seriesfq_nmod_poly_add_sifq_nmod_poly_add_fq_nmod_poly_addfq_nmod_poly_equal_fq_nmodfq_nmod_poly_is_unitfq_nmod_poly_is_genfq_nmod_poly_is_onefq_nmod_poly_is_zerofq_nmod_poly_equal_truncfq_nmod_poly_equalfq_nmod_poly_set_coeff_fmpzfq_nmod_poly_set_coefffq_nmod_poly_get_coeff_fq_nmod_poly_make_monicfq_nmod_poly_make_monicfq_nmod_poly_genfq_nmod_poly_onefq_nmod_poly_zero_fq_nmod_poly_zerofq_nmod_poly_swapfq_nmod_poly_set_nmod_polyfq_nmod_poly_set_fmpz_mod_polyfq_nmod_poly_set_fq_nmodfq_nmod_poly_set_fq_nmod_poly_set!fq_nmod_poly_randtest_irreduciblefq_nmod_poly_randtest_monicfq_nmod_poly_randtest_not_zerofq_nmod_poly_randtestfq_nmod_poly_leadfq_nmod_poly_lengthfq_nmod_poly_degreefq_nmod_poly_reverse_fq_nmod_poly_reversefq_nmod_poly_set_truncfq_nmod_poly_truncate_fq_nmod_poly_normalise2_fq_nmod_poly_normalisefq_nmod_poly_clear_fq_nmod_poly_set_lengthfq_nmod_poly_fit_lengthfq_nmod_poly_reallocfq_nmod_poly_init2fq_nmod_poly_init newFqNModPolywithFqNModPolyfq_nmod_poly_print_prettyfq_nmod_poly_printfq_nmod_poly_roots&fq_nmod_poly_iterated_frobenius_preinv'fq_nmod_poly_factor_with_kaltofen_shoup*fq_nmod_poly_factor_with_cantor_zassenhaus"fq_nmod_poly_factor_with_berlekampfq_nmod_poly_factor_berlekamp"fq_nmod_poly_factor_kaltofen_shoup%fq_nmod_poly_factor_cantor_zassenhausfq_nmod_poly_factorfq_nmod_poly_factor_squarefree fq_nmod_poly_factor_distinct_deg fq_nmod_poly_factor_split_singlefq_nmod_poly_factor_equal_deg"fq_nmod_poly_factor_equal_deg_probfq_nmod_poly_is_squarefree_fq_nmod_poly_is_squarefree"fq_nmod_poly_is_irreducible_ben_orfq_nmod_poly_is_irreducible_ddffq_nmod_poly_is_irreduciblefq_nmod_poly_removefq_nmod_poly_factor_powfq_nmod_poly_factor_concatfq_nmod_poly_factor_insertfq_nmod_poly_factor_printfq_nmod_poly_factor_setfq_nmod_poly_factor_fit_lengthfq_nmod_poly_factor_reallocfq_nmod_poly_factor_clearfq_nmod_poly_factor_initnewFqNModPolyFactorwithFqNModPolyFactor fq_nmod_poly_factor_print_prettyCFqNModMPolyCtxFqNModMPolyCtx$fq_nmod_mpoly_univar_swap_term_coeff#fq_nmod_mpoly_univar_get_term_coeff$fq_nmod_mpoly_univar_get_term_exp_sifq_nmod_mpoly_univar_length#fq_nmod_mpoly_univar_degree_fits_sifq_nmod_mpoly_from_univarfq_nmod_mpoly_to_univarfq_nmod_mpoly_univar_swapfq_nmod_mpoly_univar_clearfq_nmod_mpoly_univar_initfq_nmod_mpoly_quadratic_rootfq_nmod_mpoly_is_squarefq_nmod_mpoly_sqrtfq_nmod_mpoly_discriminantfq_nmod_mpoly_resultantfq_nmod_mpoly_gcd_zippelfq_nmod_mpoly_gcd_henselfq_nmod_mpoly_gcd_brownfq_nmod_mpoly_gcd_cofactorsfq_nmod_mpoly_gcdfq_nmod_mpoly_content_varsfq_nmod_mpoly_term_contentfq_nmod_mpoly_divrem_idealfq_nmod_mpoly_divremfq_nmod_mpoly_divfq_nmod_mpoly_dividesfq_nmod_mpoly_pow_uifq_nmod_mpoly_pow_fmpzfq_nmod_mpoly_mul'fq_nmod_mpoly_compose_fq_nmod_mpoly_gen#fq_nmod_mpoly_compose_fq_nmod_mpoly"fq_nmod_mpoly_compose_fq_nmod_poly"fq_nmod_mpoly_evaluate_one_fq_nmod"fq_nmod_mpoly_evaluate_all_fq_nmodfq_nmod_mpoly_derivativefq_nmod_mpoly_make_monic fq_nmod_mpoly_scalar_mul_fq_nmodfq_nmod_mpoly_negfq_nmod_mpoly_subfq_nmod_mpoly_addfq_nmod_mpoly_sub_fq_nmodfq_nmod_mpoly_add_fq_nmodfq_nmod_mpoly_randtest_bitsfq_nmod_mpoly_randtest_boundsfq_nmod_mpoly_randtest_boundfq_nmod_mpoly_reverse fq_nmod_mpoly_combine_like_termsfq_nmod_mpoly_sort_terms"fq_nmod_mpoly_push_term_fq_nmod_ui$fq_nmod_mpoly_push_term_fq_nmod_fmpzfq_nmod_mpoly_get_term_monomialfq_nmod_mpoly_get_termfq_nmod_mpoly_set_term_exp_uifq_nmod_mpoly_set_term_exp_fmpz!fq_nmod_mpoly_get_term_var_exp_si!fq_nmod_mpoly_get_term_var_exp_uifq_nmod_mpoly_get_term_exp_sifq_nmod_mpoly_get_term_exp_uifq_nmod_mpoly_get_term_exp_fmpzfq_nmod_mpoly_term_exp_fits_uifq_nmod_mpoly_term_exp_fits_si$fq_nmod_mpoly_get_term_coeff_fq_nmodfq_nmod_mpoly_resizefq_nmod_mpoly_lengthfq_nmod_mpoly_is_canonicalfq_nmod_mpoly_cmpfq_nmod_mpoly_get_coeff_vars_ui"fq_nmod_mpoly_set_coeff_fq_nmod_ui$fq_nmod_mpoly_set_coeff_fq_nmod_fmpz"fq_nmod_mpoly_get_coeff_fq_nmod_ui$fq_nmod_mpoly_get_coeff_fq_nmod_fmpz(fq_nmod_mpoly_set_coeff_fq_nmod_monomial(fq_nmod_mpoly_get_coeff_fq_nmod_monomialfq_nmod_mpoly_used_varsfq_nmod_mpoly_total_degree_sifq_nmod_mpoly_total_degree_fmpz"fq_nmod_mpoly_total_degree_fits_sifq_nmod_mpoly_degree_sifq_nmod_mpoly_degree_fmpzfq_nmod_mpoly_degrees_sifq_nmod_mpoly_degrees_fmpzfq_nmod_mpoly_degrees_fit_sifq_nmod_mpoly_is_onefq_nmod_mpoly_is_zerofq_nmod_mpoly_equal_fq_nmodfq_nmod_mpoly_onefq_nmod_mpoly_zerofq_nmod_mpoly_set_fq_nmod_genfq_nmod_mpoly_set_uifq_nmod_mpoly_set_fq_nmodfq_nmod_mpoly_get_fq_nmodfq_nmod_mpoly_is_fq_nmodfq_nmod_mpoly_swapfq_nmod_mpoly_equalfq_nmod_mpoly_setfq_nmod_mpoly_is_genfq_nmod_mpoly_genfq_nmod_mpoly_set_str_prettyfq_nmod_mpoly_fprint_prettyfq_nmod_mpoly_get_str_prettyfq_nmod_mpoly_clearfq_nmod_mpoly_reallocfq_nmod_mpoly_fit_lengthfq_nmod_mpoly_init3fq_nmod_mpoly_init2fq_nmod_mpoly_initfq_nmod_mpoly_ctx_clearfq_nmod_mpoly_ctx_ordfq_nmod_mpoly_ctx_nvarsfq_nmod_mpoly_ctx_initnewFqNModMPolywithFqNModMPolynewFqNModMPolyCtxwithFqNModMPolyCtxfq_nmod_mpoly_print_prettyCFqNModMPolyFactorFqNModMPolyFactorfq_nmod_mpoly_factorfq_nmod_mpoly_factor_squarefreefq_nmod_mpoly_factor_sortfq_nmod_mpoly_factor_get_exp_sifq_nmod_mpoly_factor_swap_basefq_nmod_mpoly_factor_get_base)fq_nmod_mpoly_factor_get_constant_fq_nmodfq_nmod_mpoly_factor_lengthfq_nmod_mpoly_factor_swapfq_nmod_mpoly_factor_clearfq_nmod_mpoly_factor_initnewFqNModMPolyFactorwithFqNModMPolyFactorfq_modulus_derivative_invfq_modulus_pow_series_invfq_embed_dual_to_mono_matrixfq_embed_mono_to_dual_matrixfq_embed_mul_matrixfq_embed_composition_matrix_subfq_embed_composition_matrixfq_embed_trace_matrixfq_embed_matrices_fq_embed_gens_naive fq_embed_gensCFmpzModPolyFactorFmpzModPolyFactorfmpz_mod_poly_roots_factoredfmpz_mod_poly_rootsfmpz_mod_poly_factor_berlekamp#fmpz_mod_poly_factor_kaltofen_shoup&fmpz_mod_poly_factor_cantor_zassenhausfmpz_mod_poly_factorfmpz_mod_poly_factor_squarefree*fmpz_mod_poly_factor_distinct_deg_threaded!fmpz_mod_poly_factor_distinct_degfmpz_mod_poly_factor_equal_deg#fmpz_mod_poly_factor_equal_deg_probfmpz_mod_poly_is_squarefree_ffmpz_mod_poly_is_squarefree_fmpz_mod_poly_is_squarefree_f_fmpz_mod_poly_is_squarefree$fmpz_mod_poly_is_irreducible_rabin_f"fmpz_mod_poly_is_irreducible_rabin fmpz_mod_poly_is_irreducible_ddffmpz_mod_poly_is_irreduciblefmpz_mod_poly_factor_powfmpz_mod_poly_factor_concatfmpz_mod_poly_factor_insertfmpz_mod_poly_factor_setfmpz_mod_poly_factor_fit_lengthfmpz_mod_poly_factor_reallocfmpz_mod_poly_factor_clearfmpz_mod_poly_factor_initnewFmpzModPolyFactorwithFmpzModPolyFactorfmpz_mod_poly_factor_print!fmpz_mod_poly_factor_print_prettyCUnityZpUnityZp CUnityZpqUnityZpq CAPRCLConfig APRCLConfigGaussJacobiunity_zpq_gauss_sum_sigma_powunity_zpq_gauss_sumunity_zpq_pow_ui unity_zpq_powunity_zpq_mul_unity_p_pow_unity_zpq_mul_unity_p unity_zpq_mul unity_zpq_addunity_zpq_coeff_addunity_zpq_coeff_set_uiunity_zpq_coeff_set_fmpzunity_zpq_is_p_unity_generatorunity_zpq_is_p_unityunity_zpq_p_unityunity_zpq_equalunity_zpq_swapunity_zpq_copyunity_zpq_clearunity_zpq_initunity_zp_jacobi_sum_2q_twounity_zp_jacobi_sum_2q_oneunity_zp_jacobi_sum_pqunity_zp_aut_inv unity_zp_autunity_zp_reduce_cyclotomic_unity_zp_reduce_cyclotomic"_unity_zp_reduce_cyclotomic_divmodunity_zp_pow_sliding_fmpzunity_zp_pow_2k_uiunity_zp_pow_2k_fmpz_unity_zp_pow_select_kunity_zp_pow_uiunity_zp_pow_fmpzunity_zp_sqr_inplaceunity_zp_mul_inplace unity_zp_sqr unity_zp_mul unity_zp_addunity_zp_mul_scalar_uiunity_zp_mul_scalar_fmpzunity_zp_coeff_decunity_zp_coeff_incunity_zp_coeff_add_uiunity_zp_coeff_add_fmpzunity_zp_coeff_set_uiunity_zp_coeff_set_fmpzunity_zp_equalunity_zp_is_unityunity_zp_set_zero unity_zp_swap unity_zp_copyunity_zp_clear unity_zp_initaprcl_config_jacobi_clearaprcl_config_jacobi_init aprcl_R_valueaprcl_config_gauss_clearaprcl_config_gauss_init_min_Raprcl_config_gauss_initaprcl_is_prime_final_divisionaprcl_is_prime_gauss_min_R_aprcl_is_prime_gauss_aprcl_is_prime_jacobiaprcl_is_prime_gaussaprcl_is_prime_jacobiaprcl_is_primenewAPRCLConfigGaussnewAPRCLConfigJacobiwithAPRCLConfig newUnityZpq withUnityZpq newUnityZp withUnityZpunity_zp_printUFDfactorunfactor $fUFDNModPoly$fIntegralNModPoly$fEnumNModPoly$fRealNModPoly $fOrdNModPoly $fEqNModPoly$fSemigroupNModPoly $fNumNModPoly$fShowNModPoly$fArbitraryFmpz $fUFDFmpz$fIntegralFmpz $fRealFmpz $fNumFmpz $fEnumFmpz $fOrdFmpz$fEqFmpz $fReadFmpz $fShowFmpz$fEnumFmpzPolyQ$fRealFmpzPolyQ$fOrdFmpzPolyQ $fEqFmpzPolyQ$fNumFmpzPolyQ$fQuotientFmpzPolyQFmpzPoly$fShowFmpzPolyQ$fIsListFmpzPoly$fArbitraryFmpzPoly $fUFDFmpzPoly$fIntegralFmpzPoly$fEnumFmpzPoly$fRealFmpzPoly $fOrdFmpzPoly $fEqFmpzPoly$fSemigroupFmpzPoly $fNumFmpzPoly$fReadFmpzPoly$fShowFmpzPoly$fRealFracFmpq $fRealFmpq$fFractionalFmpq $fNumFmpq $fOrdFmpq$fEqFmpq $fReadFmpq $fShowFmpq $fNumFmpqPoly$fReadFmpqPoly$fShowFmpqPoly$fIsListFmpqPolyFlintExpressiontoFexprliftTo $fNumFexpr $fShowFexpr$fFlintExpression[]$fFlintExpressionArf$fFlintExpressionCULong$fFlintExpressionCLong$fFlintExpressionCDouble$fFlintExpressionFmpq$fFlintExpressionFmpz$fFlintExpressionFEXR_BuiltinSpecialgammadigammalgammazetaerfairy airyZerosbesselJbesselYbesselIbesselKmodjmodjqmodetamodetaq modlambda modlambdaqellipp ellipzeta ellipsigmabarnesgagmfresnelsfresnelcRF'eulerglaishercatalankhinchinpolylogmidPointRF fromDoubletoDouble$fReadRF$fShowRF $fFloatingRF $fRealFracRF$fRealRF $fRealFloatRF$fFractionalRF$fNumRF$fOrdRF$fEqRF$fRF'RF $fSpecialRF$fFractionalMag$fNumMag$fOrdMag$fEqMag $fShowMagCFrealPartimagPartmkPolarcispolar magnitudephase conjugate$fRF'CF $fSpecialCF$fShowCF $fFloatingCF $fRealFracCF$fRealCF$fFractionalCF$fNumCF$fOrdCF$fEqCF$fIsListArbPoly $fShowArbPoly$fIsListAcbPoly $fShowAcbPoly nmod_pow_fmpznewNModMPolyUnivarNModMPolyUnivarfq_nmod_ctx_get_strfq_nmod_ctx_prime fmpq_mul_siFmpzPolyMulPrecacheFmpzPolyPowersPrecompnewFmpzModMPolyUnivarFmpzModMPolyUnivarnewFmpzMPolyUnivarFmpzMPolyUnivarFmpqPolyFactorFmpqPolyPowersPrecompqadic_get_str_prettynewFmpqMPolyUniVarFmpqMPolyUniVar qqbar_clear qqbar_initnewFqNModMPolyUnivarFqNModMPolyUnivarbaseGHC.Baseaugmentbuildghc-primGHC.Primseq realWorld# GHC.CStringunpackCStringUtf8#unpackFoldrCString#unpackCString#void#cstringLength# nullAddr# leftSection rightSection GHC.MagiclazyoneShotrunRW# breakpointbreakpointCondinlineGHC.Exts groupWithnoinlineconsiderAccessible magicDictcoerceIsListtoList fromListNItemfromListproxy# Unsafe.Coerce unsafeCoerce# Data.StringIsString fromStringAddr#Array# ByteArray#Char# GHC.TypesCharC#Double#DoubleD#Float#FloatF#Int#IntI#Int8#Int16#Int32#Int64#Weak# MutableArray#MutableByteArray#MVar#IOPort# RealWorld StablePtr#~~ ArrayArray#MutableArrayArray#State# StableName#MutVar#Word#WordW#Word8#Word16#Word32#Word64# ThreadId#BCOGHC.PtrPtrFunPtrTVar#Compact# UnliftedType ConstraintLevityLiftedUnlifted RuntimeRep DoubleRepFloatRepAddrRep Word64Rep Word32Rep Word16RepWord8RepWordRepInt64RepInt32RepInt16RepInt8RepIntRepBoxedRepSumRepVecRepTupleRepVecCountVec64Vec32Vec16Vec8Vec2Vec4VecElem DoubleElemRep FloatElemRep Word64ElemRep Word32ElemRep Word16ElemRep Word8ElemRep Int64ElemRep Int32ElemRep Int8ElemRep Int16ElemRep LiftedRep UnliftedRep CoercibleProxy#SPECSPEC2Any SmallArray#SmallMutableArray#Int8X16#Int16X8#Int32X4#Int64X2#Int8X32# Int16X16#Int32X8#Int64X4#Int8X64# Int16X32# Int32X16#Int64X8# Word8X16# Word16X8# Word32X4# Word64X2# Word8X32# Word16X16# Word32X8# Word64X4# Word8X64# Word16X32# Word32X16# Word64X8#FloatX4# DoubleX2#FloatX8# DoubleX4# FloatX16# DoubleX8#gtChar#geChar#eqChar#neChar#ltChar#leChar#ord# int8ToInt# intToInt8# negateInt8# plusInt8#subInt8# timesInt8# quotInt8#remInt8# quotRemInt8#uncheckedShiftLInt8#uncheckedShiftRAInt8#uncheckedShiftRLInt8# int8ToWord8#eqInt8#geInt8#gtInt8#leInt8#ltInt8#neInt8# word8ToWord# wordToWord8# plusWord8# subWord8# timesWord8# quotWord8# remWord8# quotRemWord8# andWord8#orWord8# xorWord8# notWord8#uncheckedShiftLWord8#uncheckedShiftRLWord8# word8ToInt8#eqWord8#geWord8#gtWord8#leWord8#ltWord8#neWord8# int16ToInt# intToInt16# negateInt16# plusInt16# subInt16# timesInt16# quotInt16# remInt16# quotRemInt16#uncheckedShiftLInt16#uncheckedShiftRAInt16#uncheckedShiftRLInt16#int16ToWord16#eqInt16#geInt16#gtInt16#leInt16#ltInt16#neInt16# word16ToWord# wordToWord16# plusWord16# subWord16# timesWord16# quotWord16# remWord16#quotRemWord16# andWord16# orWord16# xorWord16# notWord16#uncheckedShiftLWord16#uncheckedShiftRLWord16#word16ToInt16# eqWord16# geWord16# gtWord16# leWord16# ltWord16# neWord16# int32ToInt# intToInt32# negateInt32# plusInt32# subInt32# timesInt32# quotInt32# remInt32# quotRemInt32#uncheckedShiftLInt32#uncheckedShiftRAInt32#uncheckedShiftRLInt32#int32ToWord32#eqInt32#geInt32#gtInt32#leInt32#ltInt32#neInt32# word32ToWord# wordToWord32# plusWord32# subWord32# timesWord32# quotWord32# remWord32#quotRemWord32# andWord32# orWord32# xorWord32# notWord32#uncheckedShiftLWord32#uncheckedShiftRLWord32#word32ToInt32# eqWord32# geWord32# gtWord32# leWord32# ltWord32# neWord32#+#-#*# timesInt2#mulIntMayOflo#quotInt#remInt# quotRemInt#andI#orI#xorI#notI# negateInt#addIntC#subIntC#>#>=#==#/=#<#<=#chr# int2Word# int2Float# int2Double# word2Float# word2Double#uncheckedIShiftL#uncheckedIShiftRA#uncheckedIShiftRL# plusWord# addWordC# subWordC# plusWord2# minusWord# timesWord# timesWord2# quotWord#remWord# quotRemWord# quotRemWord2#and#or#xor#not#uncheckedShiftL#uncheckedShiftRL# word2Int#gtWord#geWord#eqWord#neWord#ltWord#leWord#popCnt8# popCnt16# popCnt32# popCnt64#popCnt#pdep8#pdep16#pdep32#pdep64#pdep#pext8#pext16#pext32#pext64#pext#clz8#clz16#clz32#clz64#clz#ctz8#ctz16#ctz32#ctz64#ctz# byteSwap16# byteSwap32# byteSwap64# byteSwap# bitReverse8# bitReverse16# bitReverse32# bitReverse64# bitReverse# narrow8Int# narrow16Int# narrow32Int# narrow8Word# narrow16Word# narrow32Word#>##>=##==##/=##<##<=##+##-##*##/## negateDouble# fabsDouble# double2Int# double2Float# expDouble# expm1Double# logDouble# log1pDouble# sqrtDouble# sinDouble# cosDouble# tanDouble# asinDouble# acosDouble# atanDouble# sinhDouble# coshDouble# tanhDouble# asinhDouble# acoshDouble# atanhDouble#**##decodeDouble_2Int#decodeDouble_Int64#gtFloat#geFloat#eqFloat#neFloat#ltFloat#leFloat# plusFloat# minusFloat# timesFloat# divideFloat# negateFloat# fabsFloat# float2Int# expFloat# expm1Float# logFloat# log1pFloat# sqrtFloat# sinFloat# cosFloat# tanFloat# asinFloat# acosFloat# atanFloat# sinhFloat# coshFloat# tanhFloat# asinhFloat# acoshFloat# atanhFloat# powerFloat# float2Double#decodeFloat_Int# newArray#sameMutableArray# readArray# writeArray# sizeofArray#sizeofMutableArray# indexArray#unsafeFreezeArray#unsafeThawArray# copyArray#copyMutableArray# cloneArray#cloneMutableArray# freezeArray# thawArray# casArray#newSmallArray#sameSmallMutableArray#shrinkSmallMutableArray#readSmallArray#writeSmallArray#sizeofSmallArray#sizeofSmallMutableArray#getSizeofSmallMutableArray#indexSmallArray#unsafeFreezeSmallArray#unsafeThawSmallArray#copySmallArray#copySmallMutableArray#cloneSmallArray#cloneSmallMutableArray#freezeSmallArray#thawSmallArray#casSmallArray# newByteArray#newPinnedByteArray#newAlignedPinnedByteArray#isMutableByteArrayPinned#isByteArrayPinned#byteArrayContents#mutableByteArrayContents#sameMutableByteArray#shrinkMutableByteArray#resizeMutableByteArray#unsafeFreezeByteArray#sizeofByteArray#sizeofMutableByteArray#getSizeofMutableByteArray#indexCharArray#indexWideCharArray#indexIntArray#indexWordArray#indexAddrArray#indexFloatArray#indexDoubleArray#indexStablePtrArray#indexInt8Array#indexInt16Array#indexInt32Array#indexInt64Array#indexWord8Array#indexWord16Array#indexWord32Array#indexWord64Array#indexWord8ArrayAsChar#indexWord8ArrayAsWideChar#indexWord8ArrayAsInt#indexWord8ArrayAsWord#indexWord8ArrayAsAddr#indexWord8ArrayAsFloat#indexWord8ArrayAsDouble#indexWord8ArrayAsStablePtr#indexWord8ArrayAsInt16#indexWord8ArrayAsInt32#indexWord8ArrayAsInt64#indexWord8ArrayAsWord16#indexWord8ArrayAsWord32#indexWord8ArrayAsWord64#readCharArray#readWideCharArray# readIntArray#readWordArray#readAddrArray#readFloatArray#readDoubleArray#readStablePtrArray#readInt8Array#readInt16Array#readInt32Array#readInt64Array#readWord8Array#readWord16Array#readWord32Array#readWord64Array#readWord8ArrayAsChar#readWord8ArrayAsWideChar#readWord8ArrayAsInt#readWord8ArrayAsWord#readWord8ArrayAsAddr#readWord8ArrayAsFloat#readWord8ArrayAsDouble#readWord8ArrayAsStablePtr#readWord8ArrayAsInt16#readWord8ArrayAsInt32#readWord8ArrayAsInt64#readWord8ArrayAsWord16#readWord8ArrayAsWord32#readWord8ArrayAsWord64#writeCharArray#writeWideCharArray#writeIntArray#writeWordArray#writeAddrArray#writeFloatArray#writeDoubleArray#writeStablePtrArray#writeInt8Array#writeInt16Array#writeInt32Array#writeInt64Array#writeWord8Array#writeWord16Array#writeWord32Array#writeWord64Array#writeWord8ArrayAsChar#writeWord8ArrayAsWideChar#writeWord8ArrayAsInt#writeWord8ArrayAsWord#writeWord8ArrayAsAddr#writeWord8ArrayAsFloat#writeWord8ArrayAsDouble#writeWord8ArrayAsStablePtr#writeWord8ArrayAsInt16#writeWord8ArrayAsInt32#writeWord8ArrayAsInt64#writeWord8ArrayAsWord16#writeWord8ArrayAsWord32#writeWord8ArrayAsWord64#compareByteArrays#copyByteArray#copyMutableByteArray#copyByteArrayToAddr#copyMutableByteArrayToAddr#copyAddrToByteArray# setByteArray#atomicReadIntArray#atomicWriteIntArray# casIntArray#fetchAddIntArray#fetchSubIntArray#fetchAndIntArray#fetchNandIntArray#fetchOrIntArray#fetchXorIntArray#newArrayArray#sameMutableArrayArray#unsafeFreezeArrayArray#sizeofArrayArray#sizeofMutableArrayArray#indexByteArrayArray#indexArrayArrayArray#readByteArrayArray#readMutableByteArrayArray#readArrayArrayArray#readMutableArrayArrayArray#writeByteArrayArray#writeMutableByteArrayArray#writeArrayArrayArray#writeMutableArrayArrayArray#copyArrayArray#copyMutableArrayArray# plusAddr# minusAddr#remAddr# addr2Int# int2Addr#gtAddr#geAddr#eqAddr#neAddr#ltAddr#leAddr#indexCharOffAddr#indexWideCharOffAddr#indexIntOffAddr#indexWordOffAddr#indexAddrOffAddr#indexFloatOffAddr#indexDoubleOffAddr#indexStablePtrOffAddr#indexInt8OffAddr#indexInt16OffAddr#indexInt32OffAddr#indexInt64OffAddr#indexWord8OffAddr#indexWord16OffAddr#indexWord32OffAddr#indexWord64OffAddr#readCharOffAddr#readWideCharOffAddr#readIntOffAddr#readWordOffAddr#readAddrOffAddr#readFloatOffAddr#readDoubleOffAddr#readStablePtrOffAddr#readInt8OffAddr#readInt16OffAddr#readInt32OffAddr#readInt64OffAddr#readWord8OffAddr#readWord16OffAddr#readWord32OffAddr#readWord64OffAddr#writeCharOffAddr#writeWideCharOffAddr#writeIntOffAddr#writeWordOffAddr#writeAddrOffAddr#writeFloatOffAddr#writeDoubleOffAddr#writeStablePtrOffAddr#writeInt8OffAddr#writeInt16OffAddr#writeInt32OffAddr#writeInt64OffAddr#writeWord8OffAddr#writeWord16OffAddr#writeWord32OffAddr#writeWord64OffAddr#atomicExchangeAddrAddr#atomicExchangeWordAddr#atomicCasAddrAddr#atomicCasWordAddr#fetchAddWordAddr#fetchSubWordAddr#fetchAndWordAddr#fetchNandWordAddr#fetchOrWordAddr#fetchXorWordAddr#atomicReadWordAddr#atomicWriteWordAddr# newMutVar# readMutVar# writeMutVar# sameMutVar#atomicModifyMutVar2#atomicModifyMutVar_# casMutVar#catch#raise#raiseIO#maskAsyncExceptions#maskUninterruptible#unmaskAsyncExceptions#getMaskingState# atomically#retry# catchRetry# catchSTM#newTVar# readTVar# readTVarIO# writeTVar# sameTVar#newMVar# takeMVar# tryTakeMVar#putMVar# tryPutMVar# readMVar# tryReadMVar# sameMVar# isEmptyMVar# newIOPort# readIOPort# writeIOPort# sameIOPort#delay# waitRead# waitWrite#fork#forkOn# killThread#yield# myThreadId# labelThread#isCurrentThreadBound# noDuplicate# threadStatus#mkWeak#mkWeakNoFinalizer#addCFinalizerToWeak# deRefWeak# finalizeWeak#touch#makeStablePtr#deRefStablePtr# eqStablePtr#makeStableName# eqStableName#stableNameToInt# compactNew#compactResize#compactContains#compactContainsAny#compactGetFirstBlock#compactGetNextBlock#compactAllocateBlock#compactFixupPointers# compactAdd#compactAddWithSharing# compactSize#reallyUnsafePtrEquality#par#spark#seq# getSpark# numSparks# keepAlive# dataToTag# tagToEnum# addrToAny# anyToAddr# mkApUpd0#newBCO#unpackClosure# closureSize#getApStackVal# getCCSOf#getCurrentCCS# clearCCS# whereFrom# traceEvent#traceBinaryEvent# traceMarker#setThreadAllocationCounter#broadcastInt8X16#broadcastInt16X8#broadcastInt32X4#broadcastInt64X2#broadcastInt8X32#broadcastInt16X16#broadcastInt32X8#broadcastInt64X4#broadcastInt8X64#broadcastInt16X32#broadcastInt32X16#broadcastInt64X8#broadcastWord8X16#broadcastWord16X8#broadcastWord32X4#broadcastWord64X2#broadcastWord8X32#broadcastWord16X16#broadcastWord32X8#broadcastWord64X4#broadcastWord8X64#broadcastWord16X32#broadcastWord32X16#broadcastWord64X8#broadcastFloatX4#broadcastDoubleX2#broadcastFloatX8#broadcastDoubleX4#broadcastFloatX16#broadcastDoubleX8# packInt8X16# packInt16X8# packInt32X4# packInt64X2# packInt8X32# packInt16X16# packInt32X8# packInt64X4# packInt8X64# packInt16X32# packInt32X16# packInt64X8# packWord8X16# packWord16X8# packWord32X4# packWord64X2# packWord8X32#packWord16X16# packWord32X8# packWord64X4# packWord8X64#packWord16X32#packWord32X16# packWord64X8# packFloatX4# packDoubleX2# packFloatX8# packDoubleX4# packFloatX16# packDoubleX8#unpackInt8X16#unpackInt16X8#unpackInt32X4#unpackInt64X2#unpackInt8X32#unpackInt16X16#unpackInt32X8#unpackInt64X4#unpackInt8X64#unpackInt16X32#unpackInt32X16#unpackInt64X8#unpackWord8X16#unpackWord16X8#unpackWord32X4#unpackWord64X2#unpackWord8X32#unpackWord16X16#unpackWord32X8#unpackWord64X4#unpackWord8X64#unpackWord16X32#unpackWord32X16#unpackWord64X8#unpackFloatX4#unpackDoubleX2#unpackFloatX8#unpackDoubleX4#unpackFloatX16#unpackDoubleX8#insertInt8X16#insertInt16X8#insertInt32X4#insertInt64X2#insertInt8X32#insertInt16X16#insertInt32X8#insertInt64X4#insertInt8X64#insertInt16X32#insertInt32X16#insertInt64X8#insertWord8X16#insertWord16X8#insertWord32X4#insertWord64X2#insertWord8X32#insertWord16X16#insertWord32X8#insertWord64X4#insertWord8X64#insertWord16X32#insertWord32X16#insertWord64X8#insertFloatX4#insertDoubleX2#insertFloatX8#insertDoubleX4#insertFloatX16#insertDoubleX8# plusInt8X16# plusInt16X8# plusInt32X4# plusInt64X2# plusInt8X32# plusInt16X16# plusInt32X8# plusInt64X4# plusInt8X64# plusInt16X32# plusInt32X16# plusInt64X8# plusWord8X16# plusWord16X8# plusWord32X4# plusWord64X2# plusWord8X32#plusWord16X16# plusWord32X8# plusWord64X4# plusWord8X64#plusWord16X32#plusWord32X16# plusWord64X8# plusFloatX4# plusDoubleX2# plusFloatX8# plusDoubleX4# plusFloatX16# plusDoubleX8# minusInt8X16# minusInt16X8# minusInt32X4# minusInt64X2# minusInt8X32#minusInt16X16# minusInt32X8# minusInt64X4# minusInt8X64#minusInt16X32#minusInt32X16# minusInt64X8#minusWord8X16#minusWord16X8#minusWord32X4#minusWord64X2#minusWord8X32#minusWord16X16#minusWord32X8#minusWord64X4#minusWord8X64#minusWord16X32#minusWord32X16#minusWord64X8# minusFloatX4#minusDoubleX2# minusFloatX8#minusDoubleX4#minusFloatX16#minusDoubleX8# timesInt8X16# timesInt16X8# timesInt32X4# timesInt64X2# timesInt8X32#timesInt16X16# timesInt32X8# timesInt64X4# timesInt8X64#timesInt16X32#timesInt32X16# timesInt64X8#timesWord8X16#timesWord16X8#timesWord32X4#timesWord64X2#timesWord8X32#timesWord16X16#timesWord32X8#timesWord64X4#timesWord8X64#timesWord16X32#timesWord32X16#timesWord64X8# timesFloatX4#timesDoubleX2# timesFloatX8#timesDoubleX4#timesFloatX16#timesDoubleX8#divideFloatX4#divideDoubleX2#divideFloatX8#divideDoubleX4#divideFloatX16#divideDoubleX8# quotInt8X16# quotInt16X8# quotInt32X4# quotInt64X2# quotInt8X32# quotInt16X16# quotInt32X8# quotInt64X4# quotInt8X64# quotInt16X32# quotInt32X16# quotInt64X8# quotWord8X16# quotWord16X8# quotWord32X4# quotWord64X2# quotWord8X32#quotWord16X16# quotWord32X8# quotWord64X4# quotWord8X64#quotWord16X32#quotWord32X16# quotWord64X8# remInt8X16# remInt16X8# remInt32X4# remInt64X2# remInt8X32# remInt16X16# remInt32X8# remInt64X4# remInt8X64# remInt16X32# remInt32X16# remInt64X8# remWord8X16# remWord16X8# remWord32X4# remWord64X2# remWord8X32# remWord16X16# remWord32X8# remWord64X4# remWord8X64# remWord16X32# remWord32X16# remWord64X8#negateInt8X16#negateInt16X8#negateInt32X4#negateInt64X2#negateInt8X32#negateInt16X16#negateInt32X8#negateInt64X4#negateInt8X64#negateInt16X32#negateInt32X16#negateInt64X8#negateFloatX4#negateDoubleX2#negateFloatX8#negateDoubleX4#negateFloatX16#negateDoubleX8#indexInt8X16Array#indexInt16X8Array#indexInt32X4Array#indexInt64X2Array#indexInt8X32Array#indexInt16X16Array#indexInt32X8Array#indexInt64X4Array#indexInt8X64Array#indexInt16X32Array#indexInt32X16Array#indexInt64X8Array#indexWord8X16Array#indexWord16X8Array#indexWord32X4Array#indexWord64X2Array#indexWord8X32Array#indexWord16X16Array#indexWord32X8Array#indexWord64X4Array#indexWord8X64Array#indexWord16X32Array#indexWord32X16Array#indexWord64X8Array#indexFloatX4Array#indexDoubleX2Array#indexFloatX8Array#indexDoubleX4Array#indexFloatX16Array#indexDoubleX8Array#readInt8X16Array#readInt16X8Array#readInt32X4Array#readInt64X2Array#readInt8X32Array#readInt16X16Array#readInt32X8Array#readInt64X4Array#readInt8X64Array#readInt16X32Array#readInt32X16Array#readInt64X8Array#readWord8X16Array#readWord16X8Array#readWord32X4Array#readWord64X2Array#readWord8X32Array#readWord16X16Array#readWord32X8Array#readWord64X4Array#readWord8X64Array#readWord16X32Array#readWord32X16Array#readWord64X8Array#readFloatX4Array#readDoubleX2Array#readFloatX8Array#readDoubleX4Array#readFloatX16Array#readDoubleX8Array#writeInt8X16Array#writeInt16X8Array#writeInt32X4Array#writeInt64X2Array#writeInt8X32Array#writeInt16X16Array#writeInt32X8Array#writeInt64X4Array#writeInt8X64Array#writeInt16X32Array#writeInt32X16Array#writeInt64X8Array#writeWord8X16Array#writeWord16X8Array#writeWord32X4Array#writeWord64X2Array#writeWord8X32Array#writeWord16X16Array#writeWord32X8Array#writeWord64X4Array#writeWord8X64Array#writeWord16X32Array#writeWord32X16Array#writeWord64X8Array#writeFloatX4Array#writeDoubleX2Array#writeFloatX8Array#writeDoubleX4Array#writeFloatX16Array#writeDoubleX8Array#indexInt8X16OffAddr#indexInt16X8OffAddr#indexInt32X4OffAddr#indexInt64X2OffAddr#indexInt8X32OffAddr#indexInt16X16OffAddr#indexInt32X8OffAddr#indexInt64X4OffAddr#indexInt8X64OffAddr#indexInt16X32OffAddr#indexInt32X16OffAddr#indexInt64X8OffAddr#indexWord8X16OffAddr#indexWord16X8OffAddr#indexWord32X4OffAddr#indexWord64X2OffAddr#indexWord8X32OffAddr#indexWord16X16OffAddr#indexWord32X8OffAddr#indexWord64X4OffAddr#indexWord8X64OffAddr#indexWord16X32OffAddr#indexWord32X16OffAddr#indexWord64X8OffAddr#indexFloatX4OffAddr#indexDoubleX2OffAddr#indexFloatX8OffAddr#indexDoubleX4OffAddr#indexFloatX16OffAddr#indexDoubleX8OffAddr#readInt8X16OffAddr#readInt16X8OffAddr#readInt32X4OffAddr#readInt64X2OffAddr#readInt8X32OffAddr#readInt16X16OffAddr#readInt32X8OffAddr#readInt64X4OffAddr#readInt8X64OffAddr#readInt16X32OffAddr#readInt32X16OffAddr#readInt64X8OffAddr#readWord8X16OffAddr#readWord16X8OffAddr#readWord32X4OffAddr#readWord64X2OffAddr#readWord8X32OffAddr#readWord16X16OffAddr#readWord32X8OffAddr#readWord64X4OffAddr#readWord8X64OffAddr#readWord16X32OffAddr#readWord32X16OffAddr#readWord64X8OffAddr#readFloatX4OffAddr#readDoubleX2OffAddr#readFloatX8OffAddr#readDoubleX4OffAddr#readFloatX16OffAddr#readDoubleX8OffAddr#writeInt8X16OffAddr#writeInt16X8OffAddr#writeInt32X4OffAddr#writeInt64X2OffAddr#writeInt8X32OffAddr#writeInt16X16OffAddr#writeInt32X8OffAddr#writeInt64X4OffAddr#writeInt8X64OffAddr#writeInt16X32OffAddr#writeInt32X16OffAddr#writeInt64X8OffAddr#writeWord8X16OffAddr#writeWord16X8OffAddr#writeWord32X4OffAddr#writeWord64X2OffAddr#writeWord8X32OffAddr#writeWord16X16OffAddr#writeWord32X8OffAddr#writeWord64X4OffAddr#writeWord8X64OffAddr#writeWord16X32OffAddr#writeWord32X16OffAddr#writeWord64X8OffAddr#writeFloatX4OffAddr#writeDoubleX2OffAddr#writeFloatX8OffAddr#writeDoubleX4OffAddr#writeFloatX16OffAddr#writeDoubleX8OffAddr#indexInt8ArrayAsInt8X16#indexInt16ArrayAsInt16X8#indexInt32ArrayAsInt32X4#indexInt64ArrayAsInt64X2#indexInt8ArrayAsInt8X32#indexInt16ArrayAsInt16X16#indexInt32ArrayAsInt32X8#indexInt64ArrayAsInt64X4#indexInt8ArrayAsInt8X64#indexInt16ArrayAsInt16X32#indexInt32ArrayAsInt32X16#indexInt64ArrayAsInt64X8#indexWord8ArrayAsWord8X16#indexWord16ArrayAsWord16X8#indexWord32ArrayAsWord32X4#indexWord64ArrayAsWord64X2#indexWord8ArrayAsWord8X32#indexWord16ArrayAsWord16X16#indexWord32ArrayAsWord32X8#indexWord64ArrayAsWord64X4#indexWord8ArrayAsWord8X64#indexWord16ArrayAsWord16X32#indexWord32ArrayAsWord32X16#indexWord64ArrayAsWord64X8#indexFloatArrayAsFloatX4#indexDoubleArrayAsDoubleX2#indexFloatArrayAsFloatX8#indexDoubleArrayAsDoubleX4#indexFloatArrayAsFloatX16#indexDoubleArrayAsDoubleX8#readInt8ArrayAsInt8X16#readInt16ArrayAsInt16X8#readInt32ArrayAsInt32X4#readInt64ArrayAsInt64X2#readInt8ArrayAsInt8X32#readInt16ArrayAsInt16X16#readInt32ArrayAsInt32X8#readInt64ArrayAsInt64X4#readInt8ArrayAsInt8X64#readInt16ArrayAsInt16X32#readInt32ArrayAsInt32X16#readInt64ArrayAsInt64X8#readWord8ArrayAsWord8X16#readWord16ArrayAsWord16X8#readWord32ArrayAsWord32X4#readWord64ArrayAsWord64X2#readWord8ArrayAsWord8X32#readWord16ArrayAsWord16X16#readWord32ArrayAsWord32X8#readWord64ArrayAsWord64X4#readWord8ArrayAsWord8X64#readWord16ArrayAsWord16X32#readWord32ArrayAsWord32X16#readWord64ArrayAsWord64X8#readFloatArrayAsFloatX4#readDoubleArrayAsDoubleX2#readFloatArrayAsFloatX8#readDoubleArrayAsDoubleX4#readFloatArrayAsFloatX16#readDoubleArrayAsDoubleX8#writeInt8ArrayAsInt8X16#writeInt16ArrayAsInt16X8#writeInt32ArrayAsInt32X4#writeInt64ArrayAsInt64X2#writeInt8ArrayAsInt8X32#writeInt16ArrayAsInt16X16#writeInt32ArrayAsInt32X8#writeInt64ArrayAsInt64X4#writeInt8ArrayAsInt8X64#writeInt16ArrayAsInt16X32#writeInt32ArrayAsInt32X16#writeInt64ArrayAsInt64X8#writeWord8ArrayAsWord8X16#writeWord16ArrayAsWord16X8#writeWord32ArrayAsWord32X4#writeWord64ArrayAsWord64X2#writeWord8ArrayAsWord8X32#writeWord16ArrayAsWord16X16#writeWord32ArrayAsWord32X8#writeWord64ArrayAsWord64X4#writeWord8ArrayAsWord8X64#writeWord16ArrayAsWord16X32#writeWord32ArrayAsWord32X16#writeWord64ArrayAsWord64X8#writeFloatArrayAsFloatX4#writeDoubleArrayAsDoubleX2#writeFloatArrayAsFloatX8#writeDoubleArrayAsDoubleX4#writeFloatArrayAsFloatX16#writeDoubleArrayAsDoubleX8#indexInt8OffAddrAsInt8X16#indexInt16OffAddrAsInt16X8#indexInt32OffAddrAsInt32X4#indexInt64OffAddrAsInt64X2#indexInt8OffAddrAsInt8X32#indexInt16OffAddrAsInt16X16#indexInt32OffAddrAsInt32X8#indexInt64OffAddrAsInt64X4#indexInt8OffAddrAsInt8X64#indexInt16OffAddrAsInt16X32#indexInt32OffAddrAsInt32X16#indexInt64OffAddrAsInt64X8#indexWord8OffAddrAsWord8X16#indexWord16OffAddrAsWord16X8#indexWord32OffAddrAsWord32X4#indexWord64OffAddrAsWord64X2#indexWord8OffAddrAsWord8X32#indexWord16OffAddrAsWord16X16#indexWord32OffAddrAsWord32X8#indexWord64OffAddrAsWord64X4#indexWord8OffAddrAsWord8X64#indexWord16OffAddrAsWord16X32#indexWord32OffAddrAsWord32X16#indexWord64OffAddrAsWord64X8#indexFloatOffAddrAsFloatX4#indexDoubleOffAddrAsDoubleX2#indexFloatOffAddrAsFloatX8#indexDoubleOffAddrAsDoubleX4#indexFloatOffAddrAsFloatX16#indexDoubleOffAddrAsDoubleX8#readInt8OffAddrAsInt8X16#readInt16OffAddrAsInt16X8#readInt32OffAddrAsInt32X4#readInt64OffAddrAsInt64X2#readInt8OffAddrAsInt8X32#readInt16OffAddrAsInt16X16#readInt32OffAddrAsInt32X8#readInt64OffAddrAsInt64X4#readInt8OffAddrAsInt8X64#readInt16OffAddrAsInt16X32#readInt32OffAddrAsInt32X16#readInt64OffAddrAsInt64X8#readWord8OffAddrAsWord8X16#readWord16OffAddrAsWord16X8#readWord32OffAddrAsWord32X4#readWord64OffAddrAsWord64X2#readWord8OffAddrAsWord8X32#readWord16OffAddrAsWord16X16#readWord32OffAddrAsWord32X8#readWord64OffAddrAsWord64X4#readWord8OffAddrAsWord8X64#readWord16OffAddrAsWord16X32#readWord32OffAddrAsWord32X16#readWord64OffAddrAsWord64X8#readFloatOffAddrAsFloatX4#readDoubleOffAddrAsDoubleX2#readFloatOffAddrAsFloatX8#readDoubleOffAddrAsDoubleX4#readFloatOffAddrAsFloatX16#readDoubleOffAddrAsDoubleX8#writeInt8OffAddrAsInt8X16#writeInt16OffAddrAsInt16X8#writeInt32OffAddrAsInt32X4#writeInt64OffAddrAsInt64X2#writeInt8OffAddrAsInt8X32#writeInt16OffAddrAsInt16X16#writeInt32OffAddrAsInt32X8#writeInt64OffAddrAsInt64X4#writeInt8OffAddrAsInt8X64#writeInt16OffAddrAsInt16X32#writeInt32OffAddrAsInt32X16#writeInt64OffAddrAsInt64X8#writeWord8OffAddrAsWord8X16#writeWord16OffAddrAsWord16X8#writeWord32OffAddrAsWord32X4#writeWord64OffAddrAsWord64X2#writeWord8OffAddrAsWord8X32#writeWord16OffAddrAsWord16X16#writeWord32OffAddrAsWord32X8#writeWord64OffAddrAsWord64X4#writeWord8OffAddrAsWord8X64#writeWord16OffAddrAsWord16X32#writeWord32OffAddrAsWord32X16#writeWord64OffAddrAsWord64X8#writeFloatOffAddrAsFloatX4#writeDoubleOffAddrAsDoubleX2#writeFloatOffAddrAsFloatX8#writeDoubleOffAddrAsDoubleX4#writeFloatOffAddrAsFloatX16#writeDoubleOffAddrAsDoubleX8#prefetchByteArray3#prefetchMutableByteArray3#prefetchAddr3#prefetchValue3#prefetchByteArray2#prefetchMutableByteArray2#prefetchAddr2#prefetchValue2#prefetchByteArray1#prefetchMutableByteArray1#prefetchAddr1#prefetchValue1#prefetchByteArray0#prefetchMutableByteArray0#prefetchAddr0#prefetchValue0# GHC.Prim.ExtgetThreadAllocationCounter#INT64WORD64SpecConstrAnnotationForceSpecConstr NoSpecConstr traceEventthesortWithresizeSmallMutableArray# maxTupleSizeatomicModifyMutVar#Data.OrdDowngetDown GHC.Stack.CCScurrentCallStackshiftRL#shiftL# iShiftRL# iShiftRA#iShiftL#isTrue#Void#unpackAppendCString# unpackNBytes#