#include #include #include #include #include char *name = "jeff quadratic root 2"; double f_if(float a, float b, float c) { float r20797 = b; float r20798 = 0; bool r20799 = r20797 >= r20798; float r20800 = 2; float r20801 = c; float r20802 = r20800 * r20801; float r20803 = -r20797; float r20804 = r20797 * r20797; float r20805 = 4; float r20806 = a; float r20807 = r20805 * r20806; float r20808 = r20807 * r20801; float r20809 = r20804 - r20808; float r20810 = sqrt(r20809); float r20811 = r20803 - r20810; float r20812 = r20802 / r20811; float r20813 = r20803 + r20810; float r20814 = r20800 * r20806; float r20815 = r20813 / r20814; float r20816 = r20799 ? r20812 : r20815; return r20816; } double f_id(double a, double b, double c) { double r20817 = b; double r20818 = 0; bool r20819 = r20817 >= r20818; double r20820 = 2; double r20821 = c; double r20822 = r20820 * r20821; double r20823 = -r20817; double r20824 = r20817 * r20817; double r20825 = 4; double r20826 = a; double r20827 = r20825 * r20826; double r20828 = r20827 * r20821; double r20829 = r20824 - r20828; double r20830 = sqrt(r20829); double r20831 = r20823 - r20830; double r20832 = r20822 / r20831; double r20833 = r20823 + r20830; double r20834 = r20820 * r20826; double r20835 = r20833 / r20834; double r20836 = r20819 ? r20832 : r20835; return r20836; } double f_of(float a, float b, float c) { float r20837 = b; float r20838 = 0; bool r20839 = r20837 >= r20838; float r20840 = 2; float r20841 = c; float r20842 = r20840 * r20841; float r20843 = 4; float r20844 = a; float r20845 = r20844 * r20841; float r20846 = r20843 * r20845; float r20847 = -r20837; float r20848 = r20837 * r20837; float r20849 = r20843 * r20844; float r20850 = r20849 * r20841; float r20851 = r20848 - r20850; float r20852 = sqrt(r20851); float r20853 = r20847 + r20852; float r20854 = r20846 / r20853; float r20855 = r20842 / r20854; float r20856 = r20840 * r20844; float r20857 = r20853 / r20856; float r20858 = r20839 ? r20855 : r20857; float r20859 = -inf.0; bool r20860 = r20858 <= r20859; float r20861 = r20841 + r20841; float r20862 = r20847 - r20837; float r20863 = r20837 / r20844; float r20864 = r20861 / r20863; float r20865 = r20862 + r20864; float r20866 = r20861 / r20865; float r20867 = r20841 / r20837; float r20868 = r20867 - r20863; float r20869 = r20839 ? r20866 : r20868; float r20870 = 4.578275131907385e+300; bool r20871 = r20858 <= r20870; float r20872 = r20847 - r20852; float r20873 = r20842 / r20872; float r20874 = sqrt(r20852); float r20875 = r20874 * r20874; float r20876 = r20847 + r20875; float r20877 = r20876 / r20856; float r20878 = r20839 ? r20873 : r20877; float r20879 = r20871 ? r20878 : r20869; float r20880 = r20860 ? r20869 : r20879; return r20880; } double f_od(double a, double b, double c) { double r20881 = b; double r20882 = 0; bool r20883 = r20881 >= r20882; double r20884 = 2; double r20885 = c; double r20886 = r20884 * r20885; double r20887 = 4; double r20888 = a; double r20889 = r20888 * r20885; double r20890 = r20887 * r20889; double r20891 = -r20881; double r20892 = r20881 * r20881; double r20893 = r20887 * r20888; double r20894 = r20893 * r20885; double r20895 = r20892 - r20894; double r20896 = sqrt(r20895); double r20897 = r20891 + r20896; double r20898 = r20890 / r20897; double r20899 = r20886 / r20898; double r20900 = r20884 * r20888; double r20901 = r20897 / r20900; double r20902 = r20883 ? r20899 : r20901; double r20903 = -inf.0; bool r20904 = r20902 <= r20903; double r20905 = r20885 + r20885; double r20906 = r20891 - r20881; double r20907 = r20881 / r20888; double r20908 = r20905 / r20907; double r20909 = r20906 + r20908; double r20910 = r20905 / r20909; double r20911 = r20885 / r20881; double r20912 = r20911 - r20907; double r20913 = r20883 ? r20910 : r20912; double r20914 = 4.578275131907385e+300; bool r20915 = r20902 <= r20914; double r20916 = r20891 - r20896; double r20917 = r20886 / r20916; double r20918 = sqrt(r20896); double r20919 = r20918 * r20918; double r20920 = r20891 + r20919; double r20921 = r20920 / r20900; double r20922 = r20883 ? r20917 : r20921; double r20923 = r20915 ? r20922 : r20913; double r20924 = r20904 ? r20913 : r20923; return r20924; } void mpfr_fmod2(mpfr_t r, mpfr_t n, mpfr_t d, mpfr_rnd_t rmd) { mpfr_fmod(r, n, d, rmd); if (mpfr_cmp_ui(r, 0) < 0) mpfr_add(r, r, d, rmd); } static mpfr_t r20925, r20926, r20927, r20928, r20929, r20930, r20931, r20932, r20933, r20934, r20935, r20936, r20937, r20938, r20939, r20940, r20941, r20942, r20943, r20944; void setup_mpfr_f_im() { mpfr_set_default_prec(400); mpfr_init(r20925); mpfr_init_set_str(r20926, "0", 10, MPFR_RNDN); mpfr_init(r20927); mpfr_init_set_str(r20928, "2", 10, MPFR_RNDN); mpfr_init(r20929); mpfr_init(r20930); mpfr_init(r20931); mpfr_init(r20932); mpfr_init_set_str(r20933, "4", 10, MPFR_RNDN); mpfr_init(r20934); mpfr_init(r20935); mpfr_init(r20936); mpfr_init(r20937); mpfr_init(r20938); mpfr_init(r20939); mpfr_init(r20940); mpfr_init(r20941); mpfr_init(r20942); mpfr_init(r20943); mpfr_init(r20944); } double f_im(double a, double b, double c) { mpfr_set_d(r20925, b, MPFR_RNDN); ; mpfr_set_si(r20927, mpfr_cmp(r20925, r20926) >= 0, MPFR_RNDN); ; mpfr_set_d(r20929, c, MPFR_RNDN); mpfr_mul(r20930, r20928, r20929, MPFR_RNDN); mpfr_neg(r20931, r20925, MPFR_RNDN); mpfr_mul(r20932, r20925, r20925, MPFR_RNDN); ; mpfr_set_d(r20934, a, MPFR_RNDN); mpfr_mul(r20935, r20933, r20934, MPFR_RNDN); mpfr_mul(r20936, r20935, r20929, MPFR_RNDN); mpfr_sub(r20937, r20932, r20936, MPFR_RNDN); mpfr_sqrt(r20938, r20937, MPFR_RNDN); mpfr_sub(r20939, r20931, r20938, MPFR_RNDN); mpfr_div(r20940, r20930, r20939, MPFR_RNDN); mpfr_add(r20941, r20931, r20938, MPFR_RNDN); mpfr_mul(r20942, r20928, r20934, MPFR_RNDN); mpfr_div(r20943, r20941, r20942, MPFR_RNDN); if (mpfr_get_si(r20927, MPFR_RNDN)) { mpfr_set(r20944, r20940, MPFR_RNDN); } else { mpfr_set(r20944, r20943, MPFR_RNDN); }; return mpfr_get_d(r20944, MPFR_RNDN); } static mpfr_t r20945, r20946, r20947, r20948, r20949, r20950, r20951, r20952, r20953, r20954, r20955, r20956, r20957, r20958, r20959, r20960, r20961, r20962, r20963, r20964, r20965, r20966, r20967, r20968, r20969, r20970, r20971, r20972, r20973, r20974, r20975, r20976, r20977, r20978, r20979, r20980, r20981, r20982, r20983, r20984, r20985, r20986, r20987, r20988; void setup_mpfr_f_fm() { mpfr_set_default_prec(400); mpfr_init(r20945); mpfr_init_set_str(r20946, "0", 10, MPFR_RNDN); mpfr_init(r20947); mpfr_init_set_str(r20948, "2", 10, MPFR_RNDN); mpfr_init(r20949); mpfr_init(r20950); mpfr_init_set_str(r20951, "4", 10, MPFR_RNDN); mpfr_init(r20952); mpfr_init(r20953); mpfr_init(r20954); mpfr_init(r20955); mpfr_init(r20956); mpfr_init(r20957); mpfr_init(r20958); mpfr_init(r20959); mpfr_init(r20960); mpfr_init(r20961); mpfr_init(r20962); mpfr_init(r20963); mpfr_init(r20964); mpfr_init(r20965); mpfr_init(r20966); mpfr_init_set_str(r20967, "-inf.0", 10, MPFR_RNDN); mpfr_init(r20968); mpfr_init(r20969); mpfr_init(r20970); mpfr_init(r20971); mpfr_init(r20972); mpfr_init(r20973); mpfr_init(r20974); mpfr_init(r20975); mpfr_init(r20976); mpfr_init(r20977); mpfr_init_set_str(r20978, "4.578275131907385e+300", 10, MPFR_RNDN); mpfr_init(r20979); mpfr_init(r20980); mpfr_init(r20981); mpfr_init(r20982); mpfr_init(r20983); mpfr_init(r20984); mpfr_init(r20985); mpfr_init(r20986); mpfr_init(r20987); mpfr_init(r20988); } double f_fm(double a, double b, double c) { mpfr_set_d(r20945, b, MPFR_RNDN); ; mpfr_set_si(r20947, mpfr_cmp(r20945, r20946) >= 0, MPFR_RNDN); ; mpfr_set_d(r20949, c, MPFR_RNDN); mpfr_mul(r20950, r20948, r20949, MPFR_RNDN); ; mpfr_set_d(r20952, a, MPFR_RNDN); mpfr_mul(r20953, r20952, r20949, MPFR_RNDN); mpfr_mul(r20954, r20951, r20953, MPFR_RNDN); mpfr_neg(r20955, r20945, MPFR_RNDN); mpfr_mul(r20956, r20945, r20945, MPFR_RNDN); mpfr_mul(r20957, r20951, r20952, MPFR_RNDN); mpfr_mul(r20958, r20957, r20949, MPFR_RNDN); mpfr_sub(r20959, r20956, r20958, MPFR_RNDN); mpfr_sqrt(r20960, r20959, MPFR_RNDN); mpfr_add(r20961, r20955, r20960, MPFR_RNDN); mpfr_div(r20962, r20954, r20961, MPFR_RNDN); mpfr_div(r20963, r20950, r20962, MPFR_RNDN); mpfr_mul(r20964, r20948, r20952, MPFR_RNDN); mpfr_div(r20965, r20961, r20964, MPFR_RNDN); if (mpfr_get_si(r20947, MPFR_RNDN)) { mpfr_set(r20966, r20963, MPFR_RNDN); } else { mpfr_set(r20966, r20965, MPFR_RNDN); }; ; mpfr_set_si(r20968, mpfr_cmp(r20966, r20967) <= 0, MPFR_RNDN); mpfr_add(r20969, r20949, r20949, MPFR_RNDN); mpfr_sub(r20970, r20955, r20945, MPFR_RNDN); mpfr_div(r20971, r20945, r20952, MPFR_RNDN); mpfr_div(r20972, r20969, r20971, MPFR_RNDN); mpfr_add(r20973, r20970, r20972, MPFR_RNDN); mpfr_div(r20974, r20969, r20973, MPFR_RNDN); mpfr_div(r20975, r20949, r20945, MPFR_RNDN); mpfr_sub(r20976, r20975, r20971, MPFR_RNDN); if (mpfr_get_si(r20947, MPFR_RNDN)) { mpfr_set(r20977, r20974, MPFR_RNDN); } else { mpfr_set(r20977, r20976, MPFR_RNDN); }; ; mpfr_set_si(r20979, mpfr_cmp(r20966, r20978) <= 0, MPFR_RNDN); mpfr_sub(r20980, r20955, r20960, MPFR_RNDN); mpfr_div(r20981, r20950, r20980, MPFR_RNDN); mpfr_sqrt(r20982, r20960, MPFR_RNDN); mpfr_mul(r20983, r20982, r20982, MPFR_RNDN); mpfr_add(r20984, r20955, r20983, MPFR_RNDN); mpfr_div(r20985, r20984, r20964, MPFR_RNDN); if (mpfr_get_si(r20947, MPFR_RNDN)) { mpfr_set(r20986, r20981, MPFR_RNDN); } else { mpfr_set(r20986, r20985, MPFR_RNDN); }; if (mpfr_get_si(r20979, MPFR_RNDN)) { mpfr_set(r20987, r20986, MPFR_RNDN); } else { mpfr_set(r20987, r20977, MPFR_RNDN); }; if (mpfr_get_si(r20968, MPFR_RNDN)) { mpfr_set(r20988, r20977, MPFR_RNDN); } else { mpfr_set(r20988, r20987, MPFR_RNDN); }; return mpfr_get_d(r20988, MPFR_RNDN); } static mpfr_t r20989, r20990, r20991, r20992, r20993, r20994, r20995, r20996, r20997, r20998, r20999, r21000, r21001, r21002, r21003, r21004, r21005, r21006, r21007, r21008, r21009, r21010, r21011, r21012, r21013, r21014, r21015, r21016, r21017, r21018, r21019, r21020, r21021, r21022, r21023, r21024, r21025, r21026, r21027, r21028, r21029, r21030, r21031, r21032; void setup_mpfr_f_dm() { mpfr_set_default_prec(400); mpfr_init(r20989); mpfr_init_set_str(r20990, "0", 10, MPFR_RNDN); mpfr_init(r20991); mpfr_init_set_str(r20992, "2", 10, MPFR_RNDN); mpfr_init(r20993); mpfr_init(r20994); mpfr_init_set_str(r20995, "4", 10, MPFR_RNDN); mpfr_init(r20996); mpfr_init(r20997); mpfr_init(r20998); mpfr_init(r20999); mpfr_init(r21000); mpfr_init(r21001); mpfr_init(r21002); mpfr_init(r21003); mpfr_init(r21004); mpfr_init(r21005); mpfr_init(r21006); mpfr_init(r21007); mpfr_init(r21008); mpfr_init(r21009); mpfr_init(r21010); mpfr_init_set_str(r21011, "-inf.0", 10, MPFR_RNDN); mpfr_init(r21012); mpfr_init(r21013); mpfr_init(r21014); mpfr_init(r21015); mpfr_init(r21016); mpfr_init(r21017); mpfr_init(r21018); mpfr_init(r21019); mpfr_init(r21020); mpfr_init(r21021); mpfr_init_set_str(r21022, "4.578275131907385e+300", 10, MPFR_RNDN); mpfr_init(r21023); mpfr_init(r21024); mpfr_init(r21025); mpfr_init(r21026); mpfr_init(r21027); mpfr_init(r21028); mpfr_init(r21029); mpfr_init(r21030); mpfr_init(r21031); mpfr_init(r21032); } double f_dm(double a, double b, double c) { mpfr_set_d(r20989, b, MPFR_RNDN); ; mpfr_set_si(r20991, mpfr_cmp(r20989, r20990) >= 0, MPFR_RNDN); ; mpfr_set_d(r20993, c, MPFR_RNDN); mpfr_mul(r20994, r20992, r20993, MPFR_RNDN); ; mpfr_set_d(r20996, a, MPFR_RNDN); mpfr_mul(r20997, r20996, r20993, MPFR_RNDN); mpfr_mul(r20998, r20995, r20997, MPFR_RNDN); mpfr_neg(r20999, r20989, MPFR_RNDN); mpfr_mul(r21000, r20989, r20989, MPFR_RNDN); mpfr_mul(r21001, r20995, r20996, MPFR_RNDN); mpfr_mul(r21002, r21001, r20993, MPFR_RNDN); mpfr_sub(r21003, r21000, r21002, MPFR_RNDN); mpfr_sqrt(r21004, r21003, MPFR_RNDN); mpfr_add(r21005, r20999, r21004, MPFR_RNDN); mpfr_div(r21006, r20998, r21005, MPFR_RNDN); mpfr_div(r21007, r20994, r21006, MPFR_RNDN); mpfr_mul(r21008, r20992, r20996, MPFR_RNDN); mpfr_div(r21009, r21005, r21008, MPFR_RNDN); if (mpfr_get_si(r20991, MPFR_RNDN)) { mpfr_set(r21010, r21007, MPFR_RNDN); } else { mpfr_set(r21010, r21009, MPFR_RNDN); }; ; mpfr_set_si(r21012, mpfr_cmp(r21010, r21011) <= 0, MPFR_RNDN); mpfr_add(r21013, r20993, r20993, MPFR_RNDN); mpfr_sub(r21014, r20999, r20989, MPFR_RNDN); mpfr_div(r21015, r20989, r20996, MPFR_RNDN); mpfr_div(r21016, r21013, r21015, MPFR_RNDN); mpfr_add(r21017, r21014, r21016, MPFR_RNDN); mpfr_div(r21018, r21013, r21017, MPFR_RNDN); mpfr_div(r21019, r20993, r20989, MPFR_RNDN); mpfr_sub(r21020, r21019, r21015, MPFR_RNDN); if (mpfr_get_si(r20991, MPFR_RNDN)) { mpfr_set(r21021, r21018, MPFR_RNDN); } else { mpfr_set(r21021, r21020, MPFR_RNDN); }; ; mpfr_set_si(r21023, mpfr_cmp(r21010, r21022) <= 0, MPFR_RNDN); mpfr_sub(r21024, r20999, r21004, MPFR_RNDN); mpfr_div(r21025, r20994, r21024, MPFR_RNDN); mpfr_sqrt(r21026, r21004, MPFR_RNDN); mpfr_mul(r21027, r21026, r21026, MPFR_RNDN); mpfr_add(r21028, r20999, r21027, MPFR_RNDN); mpfr_div(r21029, r21028, r21008, MPFR_RNDN); if (mpfr_get_si(r20991, MPFR_RNDN)) { mpfr_set(r21030, r21025, MPFR_RNDN); } else { mpfr_set(r21030, r21029, MPFR_RNDN); }; if (mpfr_get_si(r21023, MPFR_RNDN)) { mpfr_set(r21031, r21030, MPFR_RNDN); } else { mpfr_set(r21031, r21021, MPFR_RNDN); }; if (mpfr_get_si(r21012, MPFR_RNDN)) { mpfr_set(r21032, r21021, MPFR_RNDN); } else { mpfr_set(r21032, r21031, MPFR_RNDN); }; return mpfr_get_d(r21032, MPFR_RNDN); }