text:
int_rules_1_2_2_7 = @theory begin

    #= ::Subsection::Closed:: =#
    #= 1.2.2.7*P(x)*(d+e*x^2)^q*(a+b*x^2+c*x^4)^p =#
    @apply_utils Antiderivative((~Px * (~x) ^ ~m) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => With([A = Coeff(~Px, ~x, 0), B = Coeff(~Px, ~x, 2), C = Coeff(~Px, ~x, 4)], (C * (~x) ^ (~m - 1) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)) / (~c * ~e * (~m + 1)) - (1 / (~c * ~e * (~m + 1))) * Antiderivative(((~x) ^ (~m - 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4))) * Simp((~a * C * ~d * (~m - 1) - (A * ~c * ~e * (~m + 1) - C * (~a * ~e * (~m - 1) + ~b * ~d * ~m)) * (~x) ^ 2) - (B * ~c * ~e * (~m + 1) - C * (~b * ~e * ~m + ~c * ~d * (~m + 1))) * (~x) ^ 4, ~x), ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e], ~x) && (PolyQ(~Px, (~x) ^ 2, 2) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && IGtQ(~m / 2, 0)))
    @apply_utils Antiderivative((~Px * (~x) ^ ~m) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => With([A = Coeff(~Px, ~x, 0), B = Coeff(~Px, ~x, 2), C = Coeff(~Px, ~x, 4)], (C * (~x) ^ (~m - 1) * sqrt(~a + ~c * (~x) ^ 4)) / (~c * ~e * (~m + 1)) - (1 / (~c * ~e * (~m + 1))) * Antiderivative(((~x) ^ (~m - 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~c * (~x) ^ 4))) * Simp((~a * C * ~d * (~m - 1) - (A * ~c * ~e * (~m + 1) - C * ~a * ~e * (~m - 1)) * (~x) ^ 2) - (B * ~c * ~e * (~m + 1) - C * ~c * ~d * (~m + 1)) * (~x) ^ 4, ~x), ~x)) <-- FreeQ([~a, ~c, ~d, ~e], ~x) && (PolyQ(~Px, (~x) ^ 2, 2) && IGtQ(~m / 2, 0))
    @apply_utils Antiderivative((~Px * (~x) ^ ~m) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => With([A = Coeff(~Px, ~x, 0), B = Coeff(~Px, ~x, 2), C = Coeff(~Px, ~x, 4)], (A * (~x) ^ (~m + 1) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)) / (~a * ~d * (~m + 1)) + (1 / (~a * ~d * (~m + 1))) * Antiderivative(((~x) ^ (~m + 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4))) * Simp(((~a * B * ~d * (~m + 1) - A * (~a * ~e * (~m + 1) + ~b * ~d * (~m + 2))) + (~a * C * ~d * (~m + 1) - A * (~b * ~e * (~m + 2) + ~c * ~d * (~m + 3))) * (~x) ^ 2) - A * ~c * ~e * (~m + 3) * (~x) ^ 4, ~x), ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e], ~x) && (PolyQ(~Px, (~x) ^ 2, 2) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && ILtQ(~m / 2, 0)))
    @apply_utils Antiderivative((~Px * (~x) ^ ~m) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => With([A = Coeff(~Px, ~x, 0), B = Coeff(~Px, ~x, 2), C = Coeff(~Px, ~x, 4)], (A * (~x) ^ (~m + 1) * sqrt(~a + ~c * (~x) ^ 4)) / (~a * ~d * (~m + 1)) + (1 / (~a * ~d * (~m + 1))) * Antiderivative(((~x) ^ (~m + 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~c * (~x) ^ 4))) * Simp(((~a * B * ~d * (~m + 1) - A * ~a * ~e * (~m + 1)) + (~a * C * ~d * (~m + 1) - A * ~c * ~d * (~m + 3)) * (~x) ^ 2) - A * ~c * ~e * (~m + 3) * (~x) ^ 4, ~x), ~x)) <-- FreeQ([~a, ~c, ~d, ~e], ~x) && (PolyQ(~Px, (~x) ^ 2, 2) && ILtQ(~m / 2, 0))
    @apply_utils Antiderivative(~x * ~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4) ^ ~(p'), ~x) => (1 / 2) * Subst(Antiderivative(ReplaceAll(~Px, (~x->begin
                                        #= none:1 =#
                                        #= none:3 =#
                                        sqrt(~x)
                                    end)) * (~d + ~e * ~x) ^ ~q * (~a + ~b * ~x + ~c * (~x) ^ 2) ^ ~p, ~x), ~x, (~x) ^ 2) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~p, ~q], ~x) && PolyQ(~Px, (~x) ^ 2)
    @apply_utils Antiderivative(~Pr * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4) ^ ~p, ~x) => Antiderivative(~x * PolynomialQuotient(~Pr, ~x, ~x) * (~d + ~e * (~x) ^ 2) ^ ~q * (~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4) ^ ~p, ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~p, ~q], ~x) && (PolyQ(~Pr, ~x) && (EqQ(PolynomialRemainder(~Pr, ~x, ~x), 0) && Not(MatchQ(~Pr, (~x) ^ ~(m') * ~(u') <-- IntegerQ(m)))))
    @apply_utils Antiderivative(~Pr * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4) ^ ~p, ~x) => Module([r = Expon(~Pr, ~x), k], Antiderivative(Sum(Coeff(~Pr, ~x, 2k) * (~x) ^ (2k), [k, 0, r / 2]) * (~d + ~e * (~x) ^ 2) ^ ~q * (~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4) ^ ~p, ~x) + Antiderivative(~x * Sum(Coeff(~Pr, ~x, 2k + 1) * (~x) ^ (2k), [k, 0, (r - 1) / 2]) * (~d + ~e * (~x) ^ 2) ^ ~q * (~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4) ^ ~p, ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~p, ~q], ~x) && (PolyQ(~Pr, ~x) && Not(PolyQ(~Pr, (~x) ^ 2)))
    @apply_utils Antiderivative(~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4) ^ ~(p'), ~x) => Antiderivative(~Px * (~d + ~e * (~x) ^ 2) ^ (~p + ~q) * (~a / ~d + (~c / ~e) * (~x) ^ 2) ^ ~p, ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~q], ~x) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (EqQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && (IntegerQ(~p) && (PolyQ(~Px, (~x) ^ 2) || MatchQ(~Px, (~f + ~(g') * (~x) ^ 2) ^ ~(r') <-- FreeQ([f, g, r], ~x))))))
    @apply_utils Antiderivative(~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(c') * (~x) ^ 4) ^ ~(p'), ~x) => Antiderivative(~Px * (~d + ~e * (~x) ^ 2) ^ (~p + ~q) * (~a / ~d + (~c / ~e) * (~x) ^ 2) ^ ~p, ~x) <-- FreeQ([~a, ~c, ~d, ~e, ~q], ~x) && (EqQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && (IntegerQ(~p) && (PolyQ(~Px, (~x) ^ 2) || MatchQ(~Px, (~f + ~(g') * (~x) ^ 2) ^ ~(r') <-- FreeQ([f, g, r], ~x)))))
    @apply_utils Antiderivative(~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4) ^ ~p, ~x) => ((~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4) ^ FracPart(~p) / ((~d + ~e * (~x) ^ 2) ^ FracPart(~p) * (~a / ~d + (~c * (~x) ^ 2) / ~e) ^ FracPart(~p))) * Antiderivative(~Px * (~d + ~e * (~x) ^ 2) ^ (~p + ~q) * (~a / ~d + (~c / ~e) * (~x) ^ 2) ^ ~p, ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~p, ~q], ~x) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (EqQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && (Not(IntegerQ(~p)) && (PolyQ(~Px, (~x) ^ 2) || MatchQ(~Px, (~f + ~(g') * (~x) ^ 2) ^ ~(r') <-- FreeQ([f, g, r], ~x))))))
    @apply_utils Antiderivative(~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(c') * (~x) ^ 4) ^ ~p, ~x) => ((~a + ~c * (~x) ^ 4) ^ FracPart(~p) / ((~d + ~e * (~x) ^ 2) ^ FracPart(~p) * (~a / ~d + (~c * (~x) ^ 2) / ~e) ^ FracPart(~p))) * Antiderivative(~Px * (~d + ~e * (~x) ^ 2) ^ (~p + ~q) * (~a / ~d + (~c / ~e) * (~x) ^ 2) ^ ~p, ~x) <-- FreeQ([~a, ~c, ~d, ~e, ~p, ~q], ~x) && (EqQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && (Not(IntegerQ(~p)) && (PolyQ(~Px, (~x) ^ 2) || MatchQ(~Px, (~f + ~(g') * (~x) ^ 2) ^ ~(r') <-- FreeQ([f, g, r], ~x)))))
    @apply_utils Antiderivative(~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4) ^ ~(p'), ~x) => Antiderivative(ExpandIntegrand(~Px * (~d + ~e * (~x) ^ 2) ^ ~q * (~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4) ^ ~p, ~x), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~q], ~x) && (PolyQ(~Px, (~x) ^ 2) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && IntegerQ(~p))))
    @apply_utils Antiderivative(~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(c') * (~x) ^ 4) ^ ~(p'), ~x) => Antiderivative(ExpandIntegrand(~Px * (~d + ~e * (~x) ^ 2) ^ ~q * (~a + ~c * (~x) ^ 4) ^ ~p, ~x), ~x) <-- FreeQ([~a, ~c, ~d, ~e, ~q], ~x) && (PolyQ(~Px, (~x) ^ 2) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && IntegerQ(~p)))
    @apply_utils Antiderivative(((~d + ~(e') * (~x) ^ 2) ^ ~q * ~P4x) / sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4), ~x) => With([A = Coeff(~P4x, ~x, 0), B = Coeff(~P4x, ~x, 2), C = Coeff(~P4x, ~x, 4)], (C * ~x * (~d + ~e * (~x) ^ 2) ^ ~q * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)) / (~c * (2 * ~q + 3)) + (1 / (~c * (2 * ~q + 3))) * Antiderivative(((~d + ~e * (~x) ^ 2) ^ (~q - 1) / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)) * Simp((A * ~c * ~d * (2 * ~q + 3) - ~a * C * ~d) + (~c * (B * ~d + A * ~e) * (2 * ~q + 3) - C * (2 * ~b * ~d + ~a * ~e + 2 * ~a * ~e * ~q)) * (~x) ^ 2 + (B * ~c * ~e * (2 * ~q + 3) - 2 * C * ((~b * ~e - ~c * ~d * ~q) + ~b * ~e * ~q)) * (~x) ^ 4, ~x), ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e], ~x) && (PolyQ(~P4x, (~x) ^ 2) && (EqQ(Expon(~P4x, ~x), 4) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && IGtQ(~q, 0)))))
    @apply_utils Antiderivative(((~d + ~(e') * (~x) ^ 2) ^ ~q * ~P4x) / sqrt(~a + ~(c') * (~x) ^ 4), ~x) => With([A = Coeff(~P4x, ~x, 0), B = Coeff(~P4x, ~x, 2), C = Coeff(~P4x, ~x, 4)], (C * ~x * (~d + ~e * (~x) ^ 2) ^ ~q * sqrt(~a + ~c * (~x) ^ 4)) / (~c * (2 * ~q + 3)) + (1 / (~c * (2 * ~q + 3))) * Antiderivative(((~d + ~e * (~x) ^ 2) ^ (~q - 1) / sqrt(~a + ~c * (~x) ^ 4)) * Simp((A * ~c * ~d * (2 * ~q + 3) - ~a * C * ~d) + (~c * (B * ~d + A * ~e) * (2 * ~q + 3) - ~a * C * ~e * (2 * ~q + 1)) * (~x) ^ 2 + (B * ~c * ~e * (2 * ~q + 3) + 2 * ~c * C * ~d * ~q) * (~x) ^ 4, ~x), ~x)) <-- FreeQ([~a, ~c, ~d, ~e], ~x) && (PolyQ(~P4x, (~x) ^ 2) && (EqQ(Expon(~P4x, ~x), 4) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && IGtQ(~q, 0))))
    @apply_utils Antiderivative(((~d + ~(e') * (~x) ^ 2) ^ ~q * ~P4x) / sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4), ~x) => With([A = Coeff(~P4x, ~x, 0), B = Coeff(~P4x, ~x, 2), C = Coeff(~P4x, ~x, 4)], (-(((C * (~d) ^ 2 - B * ~d * ~e) + A * (~e) ^ 2)) * ~x * (~d + ~e * (~x) ^ 2) ^ (~q + 1) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)) / (2 * ~d * (~q + 1) * ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2)) + (1 / (2 * ~d * (~q + 1) * ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2))) * Antiderivative(((~d + ~e * (~x) ^ 2) ^ (~q + 1) / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)) * Simp(((~a * ~d * (C * ~d - B * ~e) + A * (~a * (~e) ^ 2 * (2 * ~q + 3) + 2 * ~d * (~c * ~d - ~b * ~e) * (~q + 1))) - 2 * ((B * ~d - A * ~e) * (~b * ~e * (~q + 2) - ~c * ~d * (~q + 1)) - C * ~d * (~b * ~d + ~a * ~e * (~q + 1))) * (~x) ^ 2) + ~c * ((C * (~d) ^ 2 - B * ~d * ~e) + A * (~e) ^ 2) * (2 * ~q + 5) * (~x) ^ 4, ~x), ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e], ~x) && (PolyQ(~P4x, (~x) ^ 2) && (LeQ(Expon(~P4x, ~x), 4) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && ILtQ(~q, -1)))))
    @apply_utils Antiderivative(((~d + ~(e') * (~x) ^ 2) ^ ~q * ~P4x) / sqrt(~a + ~(c') * (~x) ^ 4), ~x) => With([A = Coeff(~P4x, ~x, 0), B = Coeff(~P4x, ~x, 2), C = Coeff(~P4x, ~x, 4)], (-(((C * (~d) ^ 2 - B * ~d * ~e) + A * (~e) ^ 2)) * ~x * (~d + ~e * (~x) ^ 2) ^ (~q + 1) * sqrt(~a + ~c * (~x) ^ 4)) / (2 * ~d * (~q + 1) * (~c * (~d) ^ 2 + ~a * (~e) ^ 2)) + (1 / (2 * ~d * (~q + 1) * (~c * (~d) ^ 2 + ~a * (~e) ^ 2))) * Antiderivative(((~d + ~e * (~x) ^ 2) ^ (~q + 1) / sqrt(~a + ~c * (~x) ^ 4)) * Simp(~a * ~d * (C * ~d - B * ~e) + A * (~a * (~e) ^ 2 * (2 * ~q + 3) + 2 * ~c * (~d) ^ 2 * (~q + 1)) + 2 * ~d * ((B * ~c * ~d - A * ~c * ~e) + ~a * C * ~e) * (~q + 1) * (~x) ^ 2 + ~c * ((C * (~d) ^ 2 - B * ~d * ~e) + A * (~e) ^ 2) * (2 * ~q + 5) * (~x) ^ 4, ~x), ~x)) <-- FreeQ([~a, ~c, ~d, ~e], ~x) && (PolyQ(~P4x, (~x) ^ 2) && (LeQ(Expon(~P4x, ~x), 4) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && ILtQ(~q, -1))))
    @apply_utils Antiderivative((~A + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => ~A * Subst(Antiderivative(1 / (~d - (~b * ~d - 2 * ~a * ~e) * (~x) ^ 2), ~x), ~x, ~x / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && (EqQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && EqQ(~B * ~d + ~A * ~e, 0))))
    @apply_utils Antiderivative((~A + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => ~A * Subst(Antiderivative(1 / (~d + 2 * ~a * ~e * (~x) ^ 2), ~x), ~x, ~x / sqrt(~a + ~c * (~x) ^ 4)) <-- FreeQ([~a, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && (EqQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && EqQ(~B * ~d + ~A * ~e, 0)))
    @apply_utils Antiderivative((~A + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => ((~B * ~d + ~A * ~e) / (2 * ~d * ~e)) * Antiderivative(1 / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4), ~x) - ((~B * ~d - ~A * ~e) / (2 * ~d * ~e)) * Antiderivative((~d - ~e * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && (EqQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && NeQ(~B * ~d + ~A * ~e, 0))))
    @apply_utils Antiderivative((~A + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => ((~B * ~d + ~A * ~e) / (2 * ~d * ~e)) * Antiderivative(1 / sqrt(~a + ~c * (~x) ^ 4), ~x) - ((~B * ~d - ~A * ~e) / (2 * ~d * ~e)) * Antiderivative((~d - ~e * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~c * (~x) ^ 4)), ~x) <-- FreeQ([~a, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && (EqQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && NeQ(~B * ~d + ~A * ~e, 0)))
    @apply_utils Antiderivative((~A + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => ((sqrt(~A + ~B * (~x) ^ 2) * sqrt(~a / ~A + (~c * (~x) ^ 2) / ~B)) / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)) * Antiderivative(sqrt(~A + ~B * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a / ~A + (~c * (~x) ^ 2) / ~B)), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && EqQ((~c * (~A) ^ 2 - ~b * ~A * ~B) + ~a * (~B) ^ 2, 0)))
    @apply_utils Antiderivative((~A + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => ((sqrt(~A + ~B * (~x) ^ 2) * sqrt(~a / ~A + (~c * (~x) ^ 2) / ~B)) / sqrt(~a + ~c * (~x) ^ 4)) * Antiderivative(sqrt(~A + ~B * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a / ~A + (~c * (~x) ^ 2) / ~B)), ~x) <-- FreeQ([~a, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && EqQ(~c * (~A) ^ 2 + ~a * (~B) ^ 2, 0))
    @apply_utils Antiderivative((~A + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => With([q = sqrt((~b) ^ 2 - 4 * ~a * ~c)], ((2 * ~a * ~B - ~A * (~b + q)) / (2 * ~a * ~e - ~d * (~b + q))) * Antiderivative(1 / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4), ~x) - ((~B * ~d - ~A * ~e) / (2 * ~a * ~e - ~d * (~b + q))) * Antiderivative((2 * ~a + (~b + q) * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)), ~x) <-- RationalQ(q)) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~A, ~B], ~x) && (GtQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && NeQ((~c * (~A) ^ 2 - ~b * ~A * ~B) + ~a * (~B) ^ 2, 0)))
    @apply_utils Antiderivative((~A + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => With([q = sqrt(-(~a) * ~c)], ((~a * ~B - ~A * q) / (~a * ~e - ~d * q)) * Antiderivative(1 / sqrt(~a + ~c * (~x) ^ 4), ~x) - ((~B * ~d - ~A * ~e) / (~a * ~e - ~d * q)) * Antiderivative((~a + q * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~c * (~x) ^ 4)), ~x) <-- RationalQ(q)) <-- FreeQ([~a, ~c, ~d, ~e, ~A, ~B], ~x) && (GtQ(-(~a) * ~c, 0) && (EqQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && NeQ(~c * (~A) ^ 2 + ~a * (~B) ^ 2, 0)))
    #= Antiderivative(((~A)+(~B')*(~x)^2)/(((~d)+(~e')*(~x)^2)*sqrt((~a)+(~b')*(~x)^2+(~c')*(~x)^4)),(~x)*Symbol) := With([q=Rt(B/A,2)], -(B*d-A*e)*atan(Rt(-b+c*d/e+a*e/d,2)*x/sqrt(a+b*x^2+c*x^4))/(2*d* e*Rt(-b+c*d/e+a*e/d,2)) + B*q*(c*d^2-a*e^2)*(A+B*x^2)*sqrt(A^2*(a+b*x^2+c*x^4)/(a*(A+B*x^2)^2) )/(4*c*d*e*(B*d-A*e)*sqrt(a+b*x^2+c*x^4))* Elliptic.Pi(-(B*d-A*e)^2/(4*d*e*A*B),2*atan(q*x),1/2-b*A/(4*a*B)) ) <-- FreeQ([a,b,c,d,e,A,B],x) && NeQ(b^2-4*a*c,0) &&  NeQ(c*d^2-b*d*e+a*e^2,0) && NeQ(c*d^2-a*e^2,0) && PosQ(c/a) &&  EqQ(c*A^2-a*B^2,0) =#
    #= Antiderivative(((~A)+(~B')*(~x)^2)/(((~d)+(~e')*(~x)^2)*sqrt((~a)+(~c')*(~x)^4)),~x) :=  With([q=Rt(B/A,2)], -(B*d-A*e)*atan(Rt(c*d/e+a*e/d,2)*x/sqrt(a+c*x^4))/(2*d*e*Rt(c*d/ e+a*e/d,2)) + B*q*(c*d^2-a*e^2)*(A+B*x^2)*sqrt(A^2*(a+c*x^4)/(a*(A+B*x^2)^2))/(4* c*d*e*(B*d-A*e)*sqrt(a+c*x^4))* Elliptic.Pi(-(B*d-A*e)^2/(4*d*e*A*B),2*atan(q*x),1/2)) <--  FreeQ([a,c,d,e,A,B],x) && NeQ(c*d^2+a*e^2,0) && NeQ(c*d^2-a*e^2,0) &&  PosQ(c/a) && EqQ(c*A^2-a*B^2,0) =#
    @apply_utils Antiderivative((~A + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => With([q = Rt(~B / ~A, 2)], (-((~B * ~d - ~A * ~e)) * atan((Rt(-(~b) + (~c * ~d) / ~e + (~a * ~e) / ~d, 2) * ~x) / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4))) / (2 * ~d * ~e * Rt(-(~b) + (~c * ~d) / ~e + (~a * ~e) / ~d, 2)) + (((~B * ~d + ~A * ~e) * (~A + ~B * (~x) ^ 2) * sqrt(((~A) ^ 2 * (~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)) / (~a * (~A + ~B * (~x) ^ 2) ^ 2))) / (4 * ~d * ~e * ~A * q * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4))) * Elliptic.Pi(Cancel(-((~B * ~d - ~A * ~e) ^ 2) / (4 * ~d * ~e * ~A * ~B)), 2 * atan(q * ~x), 1 / 2 - (~b * ~A) / (4 * ~a * ~B))) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && (NeQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && (PosQ(~c / ~a) && EqQ(~c * (~A) ^ 2 - ~a * (~B) ^ 2, 0)))))
    @apply_utils Antiderivative((~A + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => With([q = Rt(~B / ~A, 2)], (-((~B * ~d - ~A * ~e)) * atan((Rt((~c * ~d) / ~e + (~a * ~e) / ~d, 2) * ~x) / sqrt(~a + ~c * (~x) ^ 4))) / (2 * ~d * ~e * Rt((~c * ~d) / ~e + (~a * ~e) / ~d, 2)) + (((~B * ~d + ~A * ~e) * (~A + ~B * (~x) ^ 2) * sqrt(((~A) ^ 2 * (~a + ~c * (~x) ^ 4)) / (~a * (~A + ~B * (~x) ^ 2) ^ 2))) / (4 * ~d * ~e * ~A * q * sqrt(~a + ~c * (~x) ^ 4))) * Elliptic.Pi(Cancel(-((~B * ~d - ~A * ~e) ^ 2) / (4 * ~d * ~e * ~A * ~B)), 2 * atan(q * ~x), 1 / 2)) <-- FreeQ([~a, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && (NeQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && (PosQ(~c / ~a) && EqQ(~c * (~A) ^ 2 - ~a * (~B) ^ 2, 0))))
    @apply_utils Antiderivative((~(A') + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => With([q = Rt(~c / ~a, 2)], ((~A * (~c * ~d + ~a * ~e * q) - ~a * ~B * (~e + ~d * q)) / (~c * (~d) ^ 2 - ~a * (~e) ^ 2)) * Antiderivative(1 / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4), ~x) + ((~a * (~B * ~d - ~A * ~e) * (~e + ~d * q)) / (~c * (~d) ^ 2 - ~a * (~e) ^ 2)) * Antiderivative((1 + q * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)), ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && (NeQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && (PosQ(~c / ~a) && NeQ(~c * (~A) ^ 2 - ~a * (~B) ^ 2, 0)))))
    @apply_utils Antiderivative((~(A') + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => With([q = Rt(~c / ~a, 2)], ((~A * (~c * ~d + ~a * ~e * q) - ~a * ~B * (~e + ~d * q)) / (~c * (~d) ^ 2 - ~a * (~e) ^ 2)) * Antiderivative(1 / sqrt(~a + ~c * (~x) ^ 4), ~x) + ((~a * (~B * ~d - ~A * ~e) * (~e + ~d * q)) / (~c * (~d) ^ 2 - ~a * (~e) ^ 2)) * Antiderivative((1 + q * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~c * (~x) ^ 4)), ~x)) <-- FreeQ([~a, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && (NeQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && (PosQ(~c / ~a) && NeQ(~c * (~A) ^ 2 - ~a * (~B) ^ 2, 0))))
    @apply_utils Antiderivative((~(A') + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => (~B / ~e) * Antiderivative(1 / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4), ~x) + ((~e * ~A - ~d * ~B) / ~e) * Antiderivative(1 / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && (NeQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && NegQ(~c / ~a))))
    @apply_utils Antiderivative((~(A') + ~(B') * (~x) ^ 2) / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => (~B / ~e) * Antiderivative(1 / sqrt(~a + ~c * (~x) ^ 4), ~x) + ((~e * ~A - ~d * ~B) / ~e) * Antiderivative(1 / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~c * (~x) ^ 4)), ~x) <-- FreeQ([~a, ~c, ~d, ~e, ~A, ~B], ~x) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && (NeQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && NegQ(~c / ~a)))
    @apply_utils Antiderivative(~P4x / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => With([A = Coeff(~P4x, ~x, 0), B = Coeff(~P4x, ~x, 2), C = Coeff(~P4x, ~x, 4)], (-C / (~e) ^ 2) * Antiderivative((~d - ~e * (~x) ^ 2) / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4), ~x) + (1 / (~e) ^ 2) * Antiderivative((C * (~d) ^ 2 + A * (~e) ^ 2 + B * (~e) ^ 2 * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)), ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e], ~x) && (PolyQ(~P4x, (~x) ^ 2, 2) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && EqQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0))))
    @apply_utils Antiderivative(~P4x / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => With([A = Coeff(~P4x, ~x, 0), B = Coeff(~P4x, ~x, 2), C = Coeff(~P4x, ~x, 4)], (-C / (~e) ^ 2) * Antiderivative((~d - ~e * (~x) ^ 2) / sqrt(~a + ~c * (~x) ^ 4), ~x) + (1 / (~e) ^ 2) * Antiderivative((C * (~d) ^ 2 + A * (~e) ^ 2 + B * (~e) ^ 2 * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~c * (~x) ^ 4)), ~x)) <-- FreeQ([~a, ~c, ~d, ~e], ~x) && (PolyQ(~P4x, (~x) ^ 2, 2) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && EqQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0)))
    @apply_utils Antiderivative(~P4x / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => With([q = Rt(~c / ~a, 2), A = Coeff(~P4x, ~x, 0), B = Coeff(~P4x, ~x, 2), C = Coeff(~P4x, ~x, 4)], (-C / (~e * q)) * Antiderivative((1 - q * (~x) ^ 2) / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4), ~x) + (1 / (~c * ~e)) * Antiderivative((A * ~c * ~e + ~a * C * ~d * q + (B * ~c * ~e - C * (~c * ~d - ~a * ~e * q)) * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)), ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e], ~x) && (PolyQ(~P4x, (~x) ^ 2, 2) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && (NeQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && (PosQ(~c / ~a) && Not(GtQ((~b) ^ 2 - 4 * ~a * ~c, 0)))))))
    @apply_utils Antiderivative(~P4x / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => With([q = Rt(~c / ~a, 2), A = Coeff(~P4x, ~x, 0), B = Coeff(~P4x, ~x, 2), C = Coeff(~P4x, ~x, 4)], (-C / (~e * q)) * Antiderivative((1 - q * (~x) ^ 2) / sqrt(~a + ~c * (~x) ^ 4), ~x) + (1 / (~c * ~e)) * Antiderivative((A * ~c * ~e + ~a * C * ~d * q + (B * ~c * ~e - C * (~c * ~d - ~a * ~e * q)) * (~x) ^ 2) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~c * (~x) ^ 4)), ~x)) <-- FreeQ([~a, ~c, ~d, ~e], ~x) && (PolyQ(~P4x, (~x) ^ 2, 2) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && (NeQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0) && PosQ(~c / ~a))))
    @apply_utils Antiderivative(~P4x / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => With([A = Coeff(~P4x, ~x, 0), B = Coeff(~P4x, ~x, 2), C = Coeff(~P4x, ~x, 4)], (-1 / (~e) ^ 2) * Antiderivative(((C * ~d - B * ~e) - C * ~e * (~x) ^ 2) / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4), ~x) + (((C * (~d) ^ 2 - B * ~d * ~e) + A * (~e) ^ 2) / (~e) ^ 2) * Antiderivative(1 / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)), ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e], ~x) && (PolyQ(~P4x, (~x) ^ 2, 2) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && NeQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0))))
    @apply_utils Antiderivative(~P4x / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => With([A = Coeff(~P4x, ~x, 0), B = Coeff(~P4x, ~x, 2), C = Coeff(~P4x, ~x, 4)], (-1 / (~e) ^ 2) * Antiderivative(((C * ~d - B * ~e) - C * ~e * (~x) ^ 2) / sqrt(~a + ~c * (~x) ^ 4), ~x) + (((C * (~d) ^ 2 - B * ~d * ~e) + A * (~e) ^ 2) / (~e) ^ 2) * Antiderivative(1 / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~c * (~x) ^ 4)), ~x)) <-- FreeQ([~a, ~c, ~d, ~e], ~x) && (PolyQ(~P4x, (~x) ^ 2, 2) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && NeQ(~c * (~d) ^ 2 - ~a * (~e) ^ 2, 0)))
    @apply_utils Antiderivative(~Px / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4)), ~x) => With([q = Expon(~Px, ~x)], (Coeff(~Px, ~x, q) * (~x) ^ (q - 5) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)) / (~c * ~e * (q - 3)) + (1 / (~c * ~e * (q - 3))) * Antiderivative((~c * ~e * (q - 3) * ~Px - Coeff(~Px, ~x, q) * (~x) ^ (q - 6) * (~d + ~e * (~x) ^ 2) * (~a * (q - 5) + ~b * (q - 4) * (~x) ^ 2 + ~c * (q - 3) * (~x) ^ 4)) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4)), ~x) <-- GtQ(q, 4)) <-- FreeQ([~a, ~b, ~c, ~d, ~e], ~x) && (PolyQ(~Px, ~x) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0)))
    @apply_utils Antiderivative(~Px / ((~d + ~(e') * (~x) ^ 2) * sqrt(~a + ~(c') * (~x) ^ 4)), ~x) => With([q = Expon(~Px, ~x)], (Coeff(~Px, ~x, q) * (~x) ^ (q - 5) * sqrt(~a + ~c * (~x) ^ 4)) / (~c * ~e * (q - 3)) + (1 / (~c * ~e * (q - 3))) * Antiderivative((~c * ~e * (q - 3) * ~Px - Coeff(~Px, ~x, q) * (~x) ^ (q - 6) * (~d + ~e * (~x) ^ 2) * (~a * (q - 5) + ~c * (q - 3) * (~x) ^ 4)) / ((~d + ~e * (~x) ^ 2) * sqrt(~a + ~c * (~x) ^ 4)), ~x) <-- GtQ(q, 4)) <-- FreeQ([~a, ~c, ~d, ~e], ~x) && (PolyQ(~Px, ~x) && NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0))
    #= Antiderivative((~Pq)*((~a)+(~b')*(~x)^2+(~c')*(~x)^4)^(~p)/((~d)+(~e')*(~x)^2),~x) :=  With([A=Coeff(PolynomialRemainder(Pq,a+b*x^2+c*x^4,x),x,0), B=Coeff(PolynomialRemainder(Pq,a+b*x^2+c*x^4,x),x,2)], -B*x*(b^2-2*a*c+b*c*x^2)*(a+b*x^2+c*x^4)^(p+1)/(2*a*e*(p+1)*(b^2-4* a*c)) + (B*d-A*e)*x*(b^2*c*d-2*a*c^2*d-b^3*e+3*a*b*c*e+c*(b*c*d-b^2*e+2*a*c* e)*x^2)*(a+b*x^2+c*x^4)^(p+1)/ (2*a*e*(p+1)*(b^2-4*a*c)*(c*d^2-b*d*e+a*e^2)) + Antiderivative((a+b*x^2+c*x^4)^(p+1)/(d+e*x^2)*ExpandToSum(Pq/(a+b*x^2+c*x^4)-( d+e*x^2)/(a+b*x^2+c*x^4)^(p+1)* D(-B*x*(b^2-2*a*c+b*c*x^2)*(a+b*x^2+c*x^4)^(p+1)/(2*a*e*(p+1)*(b^ 2-4*a*c)) + (B*d-A*e)*x*(b^2*c*d-2*a*c^2*d-b^3*e+3*a*b*c*e+c*(b*c*d-b^2*e+2* a*c*e)*x^2)*(a+b*x^2+c*x^4)^(p+1)/ (2*a*e*(p+1)*(b^2-4*a*c)*(c*d^2-b*d*e+a*e^2)),x),x),x)) <--  FreeQ([a,b,c,d,e],x) && PolyQ(Pq,x^2) && Expon(Pq,x^2)>0 &&  NeQ(b^2-4*a*c,0) && NeQ(c*d^2-b*d*e+a*e^2,0) && LtQ(p,-1) =#
    @apply_utils Antiderivative(~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4) ^ ~p, ~x) => Antiderivative(ExpandIntegrand(1 / sqrt(~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4), ~Px * (~d + ~e * (~x) ^ 2) ^ ~q * (~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4) ^ (~p + 1 / 2), ~x), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e], ~x) && (PolyQ(~Px, (~x) ^ 2) && (NeQ((~b) ^ 2 - 4 * ~a * ~c, 0) && (NeQ((~c * (~d) ^ 2 - ~b * ~d * ~e) + ~a * (~e) ^ 2, 0) && (IntegerQ(~p + 1 / 2) && IntegerQ(~q)))))
    @apply_utils Antiderivative(~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(c') * (~x) ^ 4) ^ ~p, ~x) => Antiderivative(ExpandIntegrand(1 / sqrt(~a + ~c * (~x) ^ 4), ~Px * (~d + ~e * (~x) ^ 2) ^ ~q * (~a + ~c * (~x) ^ 4) ^ (~p + 1 / 2), ~x), ~x) <-- FreeQ([~a, ~c, ~d, ~e], ~x) && (PolyQ(~Px, (~x) ^ 2) && (NeQ(~c * (~d) ^ 2 + ~a * (~e) ^ 2, 0) && (IntegerQ(~p + 1 / 2) && IntegerQ(~q))))
    @apply_utils Antiderivative(~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(b') * (~x) ^ 2 + ~(c') * (~x) ^ 4) ^ ~(p'), ~x) => Unintegrable(~Px * (~d + ~e * (~x) ^ 2) ^ ~q * (~a + ~b * (~x) ^ 2 + ~c * (~x) ^ 4) ^ ~p, ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~p, ~q], ~x) && PolyQ(~Px, ~x)
    @apply_utils Antiderivative(~Px * (~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~a + ~(c') * (~x) ^ 4) ^ ~(p'), ~x) => Unintegrable(~Px * (~d + ~e * (~x) ^ 2) ^ ~q * (~a + ~c * (~x) ^ 4) ^ ~p, ~x) <-- FreeQ([~a, ~c, ~d, ~e, ~p, ~q], ~x) && PolyQ(~Px, ~x)
end

max_stars_repo_path: src/rules/1 Algebraic functions/1.2 Trinomial products/1.2.2 Quartic/1.2.2.7 P(x) (d+e x^2)^q (a+b x^2+c x^4)^p.jl


text:
include("ZDT.jl")
include("DTLZ.jl")

# artificial problem
function MTP(D = 10, n_solutions = 100)
    f(x) = begin
        Q = 1.0 .+ sum((x[3:end] .- 0.8).^2)
        fx = [x[1], x[2]] .* Q
        g = [ (x[1] - 1)^2 + (x[2] - 1)^2 - 1 ]
        h = [0.0]
        return fx, g, h
    end

    bounds = Array([ zeros(D) 2.0ones(D)]')
    θ = range(π, 1.5π, length=n_solutions)

    x = 1.0 .+ cos.(θ)
    y = 1.0 .+ sin.(θ)

    pareto_set = [ generateChild(zeros(0), ([x[i], y[i]], [0.0], [0.0])) for i in 1:length(θ) ]

    return f, bounds, pareto_set

end

ext: jl


text:
cd(@__DIR__)

using CSV, Test, DataFrames

include("../code/SequenceAlignment/SequenceAlignment.jl")

using .SequenceAlignment

d = CSV.File("levenshteinTests.csv") |> DataFrame!

@testset "Levenshtein Distance" begin
    for rw in eachrow(d)
        w1, w2, l = rw
        @test levenshteinDistance(w1, w2) == l
    end
end


text:
"""
    KeyfitzKranzer{T<:Real}

The Keyfitz-Kranzer system
\$\$
    \\partial_t u_1 + \\partial_x (u_1^3 - u_2) = 0,
    \\partial_t u_2 + \\partial_x (\\frac{1}{3}u_2^3 - u_1) = 0,
\$\$
using `T` as scalar type.
"""
struct KeyfitzKranzer{T} <: AbstractBalanceLaw{1} end

KeyfitzKranzer(::Type{T}=Float64) where {T} = KeyfitzKranzer{T}()

function Base.show(io::IO, model::KeyfitzKranzer{T}) where {T}
  print(io, "Keyfitz-Kranzer system {T=", T, "}")
end

"""
Conserved variables (u1, u2) of the Keyfitz-Kranzer system.
"""
struct KeyfitzKranzerVar{T} <: FieldVector{2,T}
  u1::T
  u2::T
end

function (::Type{KeyfitzKranzerVar{T}})(val::Real) where {T}
  KeyfitzKranzerVar{T}(val, val)
end

function similar_type(::KeyfitzKranzerVar{T}) where {T}
  KeyfitzKranzerVar{T}
end

@inline variables(model::KeyfitzKranzer{T}) where {T} = KeyfitzKranzerVar{T}

@inline function entropy(u::KeyfitzKranzerVar, model::KeyfitzKranzer)
    @unpack u1, u2 = u

    exp(u1^2/2 - u2)
end

@inline function entropy_variables(u::KeyfitzKranzerVar, model::KeyfitzKranzer)
    @unpack u1, u2 = u
    U = entropy(u, model)

    SVector(u1*U, -U)
end

@inline function flux_potential(u::KeyfitzKranzerVar, model::KeyfitzKranzer)
    @unpack u1, u2 = u
    U = entropy(u, model)

    (2*u1^3/3 - u1*u2) * U
end

@inline function flux(u::KeyfitzKranzerVar, model::KeyfitzKranzer)
  @unpack u1, u2 = u

  SVector(u1^2 - u2, u1^3/3 - u1)
end

@inline function max_abs_speed(u::KeyfitzKranzerVar, model::KeyfitzKranzer)
  @unpack u1 = u

  abs(u1) + 1
end

#= TODO: Estimate the maximal speed in the solution of the Riemann problem with
left and right states `uₗ`, `uᵣ` for `model`.
@inline function max_abs_speed(uₗ::KeyfitzKranzerVar, uᵣ::KeyfitzKranzerVar, model::KeyfitzKranzer)
    λ₋, λ₊ = min_max_speed(uₗ, uᵣ, model)

    max(abs(λ₋), abs(λ₊))
end

@inline function min_max_speed(uₗ::KeyfitzKranzerVar, uᵣ::KeyfitzKranzerVar, model::KeyfitzKranzer)

    λ₋, λ₊
end
=#

"""
    IntegralQuantitiesKeyfitzKranzer{T<:Real}

Some integrated quantities of interest for the Keyfitz Kranzer system. Can be
used in callbacks of DifferentialEquations.jl.
"""
struct IntegralQuantitiesKeyfitzKranzer{T<:Real} <: FieldVector{3,T}
    u1::T
    u2::T
    entropy::T
end

function IntegralQuantitiesKeyfitzKranzer(u::KeyfitzKranzerVar{T}, model::KeyfitzKranzer) where {T}
    @unpack u1, u2 = u

    IntegralQuantitiesKeyfitzKranzer{T}(u1, u2, entropy(u, model))
end

function (fvol::EnergyConservativeFlux)(uₗ::KeyfitzKranzerVar, uᵣ::KeyfitzKranzerVar,
                                        model::KeyfitzKranzer)
    u1₋, u2₋ = uₗ
    u1₊, u2₊ = uᵣ
    U₋ = entropy(uₗ, model)
    U₊ = entropy(uᵣ, model)

    u1 = (u1₋ + u1₊) / 2
    U = (U₋ + U₊) / 2
    Ulog = logmean(U₋, U₊)

    fnum_u1 = ( 5*u1₊^2 + 2*u1₋*u1₊ + 5*u1₋^2) / 12 - (u2₋ + u2₊) / 2
    fnum_u2 = u1 * fnum_u1 - (u1₋^3 + u1₊^3) / 3 + (u1₋*u2₋ + u1₊*u2₊) / 2 - u1 * U / Ulog

    SVector(fnum_u1, fnum_u2)
end

@recipe function f{Ξ,T}(ξu::Tuple{Ξ,Vector{KeyfitzKranzerVar{T}}})
  ξ, u = ξu

  h  = mappedarray(u->u.u1, u)
  hv = mappedarray(u->u.u2, u)

  size --> (1000, 400)
  layout --> (1,2)
  legend --> false

  @series begin
    subplot := 1
    ylabel --> L"u_1"
    label  --> L"u_1"
    ξ, h
  end

  @series begin
    subplot := 2
    ylabel --> L"u_2"
    label  --> L"u_2"
    ξ, hv
  end
end


text:
# fundamental types (expanded below)

# nodes in the AST that describe the grammar.  all Matcher instances must be
# mutable and have an attribute
#  name::Symbol
# which is set automatically to the matcher type by the constructor.
# (re-set to a more useful type inside with_names() - see names.jl)
abstract type Matcher end

abstract type Message end   # data sent between trampoline and methods
abstract type State end    # state associated with Matchers during evaluation

# used to configure the parser.  all Config subtypes must have associated
# dispatch functions (see parser.jl), a parent() function, and have a
# constructor that takes the source as first argument and additional arguments
# as keywords.  the type of the source is exposed and if it's a subclass of
# string then the iterator is assumed to be a simple integer index.
abstract type Config{S,I} end

# important notes on mutability / hash / equality

# 1 - immutable types in julia are not "just" immutable.  they are
# effectively values - they are passed by value.  so do not use
# "immutable" just because the data should not change.  think about
# details.

# 2 - immutable types have an automatic equality and hash based on
# content (which is copied).  mutable types have an automatic equality
# and hash based on address.  so default hash and equality for
# immutable types that contain mutable types, and for mutable types,
# may not be what is required.

# 3 - caching within the parser REQUIRES that both Matcher and State
# instances have 'useful' equality and hash values.

# 4 - for matchers, which are created when the grammar is defined, and
# then unchanged, the default hash and equality are likely just fine,
# even for mutable objects (in fact, mutable may be slightly faster
# since equality is just a comparison of an Int64 address,
# presumably).

# 5 - for states, which often includes mutable result objects, more
# care is needed:

# 5a - whether or not State instances are mutable or immutable, they,
# and their contents, must not change during matching.  so all arrays,
# for example, must be copied when new instances are created with
# different values.

# 5b - structurally identical states must be equal, and hash equally.
# this is critical for efficient caching.  so it it likely that
# custom hash and equality methods will be needed (see above and
# auto.jl).

# defaults for mismatching types and types with no content
==(a::Matcher, b::Matcher) = false
==(a::T, b::T) where {T<:Matcher} = true
==(a::State, b::State) = false
==(a::T, b::T) where {T<:State} = true

# use an array to handle empty values in a natural way

const Value = Vector{Any}

const EMPTY = Any[]

function flatten(x::Array{Value,1}) where {Value}
    y::Value = vcat(x...)
    return y
end

# Message sub-types

# use mutable types here since they are packed and unpacked often

# parent and parent_state are popped from the stack.  a call is made to
# success(config, parent, parent_state, child_state, iter, result)
struct Success{CS<:State,I}<:Message
    child_state::CS   # parent to store, passed in next call for backtracking
    iter::I           # advanced as appropriate
    result::Value     # possibly empty
end

# parent and parent_state are popped from the stack.  a call is made to
# failure(config, parent, parent_state)
struct Failure<:Message end
const FAILURE = Failure()

# parent and parent_state are pushed to the stack.  a call is made to
# execute(config, child, child_state, iter)
struct Execute{I}<:Message
    parent::Matcher         # stored by trampoline, added to response
    parent_state::State  # stored by trampoline, added to response
    child::Matcher          # the matcher to evaluate
    child_state::State   # needed by for evaluation (was stored by parent)
    iter::I
end

# State sub-types

# use immutable types because these are simple, magic values

# the state used on first call
struct Clean<:State end
const CLEAN = Clean()

# the state used when no further calls should be made
struct Dirty<:State end
const DIRTY = Dirty()

# other stuff

# user-generated errors (ie bad input, etc).
# internal errors in the library (bugs) may raise Error
struct ParserException<:Exception
    msg
end

# this cannot be cached (thrown by hash())
struct CacheException<:Exception end

# this is equivalent to a matcher returning Failure.  used when source
# information is not available.
abstract type FailureException<:Exception end

const Applicable = Union{Function, DataType}


text:
import ..Common.test_obtain

function run_test_obtain()
    test_obtain(Atom(atom_name=" A"), :atom_name, " A")
    test_obtain(Atom(alt_location='1'), :alt_location, '1')
    test_obtain(Atom(insertion='I'), :insertion, 'I')
    test_obtain(Atom(occupancy=0.99), :occupancy, 0.99)
    test_obtain(Atom(beta=0.99), :beta, 0.99)
    test_obtain(Atom(element="E"), :element, "E")
    test_obtain(Atom(charge=1), :charge, 1)
    test_obtain(Atom(index=99), :index, 99)
    test_obtain(Atom(residue_name="ALA"), :residue_name, "ALA")
    test_obtain(Atom(residue_id=11), :residue_id, 11)
    test_obtain(Atom(segment_name="SEG"), :segment_name, "SEG")
    test_obtain(Atom(chain_name="C"), :chain_name, "C")
    test_obtain(Atom(system_name="S"), :system_name, "S")
    test_obtain(Atom(coordinate=[1., 0., 0.]), :coordinate, [1., 0., 0.])
end


text:
using Test
using Pkg.BinaryPlatforms
using BinaryBuilderBase
using BinaryBuilderBase: supported_microarchitectures

@testset "Expand platforms" begin
    # expand_gfortran_versions
    @test expand_gfortran_versions(Windows(:i686)) == [
        Windows(:i686, compiler_abi=CompilerABI(libgfortran_version=v"3.0.0")),
        Windows(:i686, compiler_abi=CompilerABI(libgfortran_version=v"4.0.0")),
        Windows(:i686, compiler_abi=CompilerABI(libgfortran_version=v"5.0.0")),
    ]
    @test expand_gfortran_versions([Windows(:i686), Windows(:x86_64)]) == [
        Windows(:i686, compiler_abi=CompilerABI(libgfortran_version=v"3.0.0")),
        Windows(:i686, compiler_abi=CompilerABI(libgfortran_version=v"4.0.0")),
        Windows(:i686, compiler_abi=CompilerABI(libgfortran_version=v"5.0.0")),
        Windows(:x86_64, compiler_abi=CompilerABI(libgfortran_version=v"3.0.0")),
        Windows(:x86_64, compiler_abi=CompilerABI(libgfortran_version=v"4.0.0")),
        Windows(:x86_64, compiler_abi=CompilerABI(libgfortran_version=v"5.0.0")),
    ]
    @test expand_gfortran_versions([FreeBSD(:x86_64; compiler_abi=CompilerABI(; libgfortran_version=v"3"))]) ==
        [FreeBSD(:x86_64; compiler_abi=CompilerABI(; libgfortran_version=v"3"))]

    # expand_cxxstring_abis
    @test expand_cxxstring_abis(Linux(:x86_64; libc=:musl)) == [
        Linux(:x86_64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx03)),
        Linux(:x86_64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)),
    ]
    @test expand_cxxstring_abis([FreeBSD(:x86_64), MacOS(:x86_64)]) == [
        FreeBSD(:x86_64, compiler_abi=CompilerABI(cxxstring_abi=:cxx03)),
        FreeBSD(:x86_64, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)),
        MacOS(:x86_64, compiler_abi=CompilerABI(cxxstring_abi=:cxx03)),
        MacOS(:x86_64, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)),
    ]
    @test expand_cxxstring_abis([Linux(:i686; compiler_abi=CompilerABI(; cxxstring_abi=:cxx11))]) ==
        [Linux(:i686; compiler_abi=CompilerABI(; cxxstring_abi=:cxx11))]

    # `supported_microarchitectures` is only used inside
    # `expand_microarchitectures`, but it's better to have a unit test as well
    @test supported_microarchitectures(Linux(:i686)) == []
    @test supported_microarchitectures(Linux(:x86_64)) == ["avx", "avx2", "avx512", "x86_64"]
    @test supported_microarchitectures(Linux(:armv7l)) == ["armv7l", "neon", "vfp4"]
    # This extended platform doesn't specify a microarchitecture, so we can support all of them
    @test supported_microarchitectures(ExtendedPlatform(Linux(:aarch64); cuda="10.1")) == ["armv8", "carmel", "thunderx2"]
    @test supported_microarchitectures(Linux(:powerpc64le)) == []
    # This extended platform specifies a valid microarchitecture, so we support only the given architecture
    @test supported_microarchitectures(ExtendedPlatform(Linux(:x86_64); march="avx")) == ["avx"]
    @test supported_microarchitectures(AnyPlatform()) == []
    @test supported_microarchitectures(UnknownPlatform()) == []

    # expand_microarchitectures
    @test expand_microarchitectures([AnyPlatform()]) == [AnyPlatform()]
    @test expand_microarchitectures(ExtendedPlatform(Linux(:x86_64); cuda="10.1")) == [
        ExtendedPlatform(Linux(:x86_64, libc=:glibc); march="avx", cuda="10.1"),
        ExtendedPlatform(Linux(:x86_64, libc=:glibc); march="avx2", cuda="10.1"),
        ExtendedPlatform(Linux(:x86_64, libc=:glibc); march="avx512", cuda="10.1"),
        ExtendedPlatform(Linux(:x86_64, libc=:glibc); march="x86_64", cuda="10.1"),
    ]
    @test expand_microarchitectures(filter!(p -> p isa Linux && libc(p) == :glibc, supported_platforms())) == [
        Linux(:i686, libc=:glibc),
        ExtendedPlatform(Linux(:x86_64, libc=:glibc); march="avx"),
        ExtendedPlatform(Linux(:x86_64, libc=:glibc); march="avx2"),
        ExtendedPlatform(Linux(:x86_64, libc=:glibc); march="avx512"),
        ExtendedPlatform(Linux(:x86_64, libc=:glibc); march="x86_64"),
        ExtendedPlatform(Linux(:aarch64, libc=:glibc); march="armv8"),
        ExtendedPlatform(Linux(:aarch64, libc=:glibc); march="carmel"),
        ExtendedPlatform(Linux(:aarch64, libc=:glibc); march="thunderx2"),
        ExtendedPlatform(Linux(:armv7l, libc=:glibc, call_abi=:eabihf); march="armv7l"),
        ExtendedPlatform(Linux(:armv7l, libc=:glibc, call_abi=:eabihf); march="neon"),
        ExtendedPlatform(Linux(:armv7l, libc=:glibc, call_abi=:eabihf); march="vfp4"),
        Linux(:powerpc64le, libc=:glibc),
    ]
    @test expand_microarchitectures([ExtendedPlatform(Windows(:x86_64); cuda="10.1", march="avx")]) ==
        [ExtendedPlatform(Windows(:x86_64); march="avx", cuda="10.1")]

    # All of them together!
    @test all(in(expand_microarchitectures(expand_gfortran_versions(expand_cxxstring_abis(supported_platforms())))),
              expand_cxxstring_abis(expand_gfortran_versions(expand_microarchitectures(supported_platforms()))))
end

@testset "Compiler Shards" begin
    @test_throws ErrorException CompilerShard("GCCBootstrap", v"4", Linux(:x86_64), :invalid_archive_type)

    @testset "GCC ABI matching" begin
        # Preferred libgfortran version and C++ string ABI
        platform = FreeBSD(:x86_64)
        shard = CompilerShard("GCCBootstrap", v"4.8.5", Linux(:x86_64, libc=:musl), :squashfs, target = platform)
        @test preferred_libgfortran_version(platform, shard) == v"3"
        @test preferred_cxxstring_abi(platform, shard) == :cxx03
        shard = CompilerShard("GCCBootstrap", v"5.2.0", Linux(:x86_64, libc=:musl), :squashfs, target = platform)
        @test preferred_libgfortran_version(platform, shard) == v"3"
        @test preferred_cxxstring_abi(platform, shard) == :cxx11
        shard = CompilerShard("GCCBootstrap", v"7.1.0", Linux(:x86_64, libc=:musl), :squashfs, target = platform)
        @test preferred_libgfortran_version(platform, shard) == v"4"
        @test preferred_cxxstring_abi(platform, shard) == :cxx11
        shard = CompilerShard("GCCBootstrap", v"9.1.0", Linux(:x86_64, libc=:musl), :squashfs, target = platform)
        @test preferred_libgfortran_version(platform, shard) == v"5"
        @test preferred_cxxstring_abi(platform, shard) == :cxx11
        shard = CompilerShard("LLVMBootstrap", v"4.8.5", Linux(:x86_64, libc=:musl), :squashfs)
        @test_throws ErrorException preferred_libgfortran_version(platform, shard)
        @test_throws ErrorException preferred_cxxstring_abi(platform, shard)
        platform = Linux(:x86_64, libc=:musl)
        shard = CompilerShard("GCCBootstrap", v"4.8.5", Linux(:x86_64, libc=:musl), :squashfs, target = MacOS(:x86_64))
        @test_throws ErrorException preferred_libgfortran_version(platform, shard)
        shard = CompilerShard("GCCBootstrap", v"4.8.5", Linux(:x86_64, libc=:musl), :squashfs, target = Linux(:x86_64, libc=:glibc))
        @test_throws ErrorException preferred_cxxstring_abi(platform, shard)
        shard = CompilerShard("GCCBootstrap", v"1.2.3", Linux(:x86_64, libc=:musl), :squashfs, target = Windows(:x86_64))
        @test_throws ErrorException preferred_cxxstring_abi(platform, shard)
        @test_throws ErrorException preferred_libgfortran_version(platform, shard)

        # With no constraints, we should get them all back
        @test gcc_version(Linux(:x86_64), available_gcc_builds) == getversion.(available_gcc_builds)

        # libgfortran v3 and libstdcxx 22 restrict us to only v4.8, v5.2 and v6.1
        cabi = CompilerABI(;libgfortran_version=v"3", libstdcxx_version=v"3.4.22")
        p = Linux(:x86_64; compiler_abi=cabi)
        @test gcc_version(p, available_gcc_builds) == [v"4.8.5", v"5.2.0", v"6.1.0"]
        ep = ExtendedPlatform(p; march="avx")
        @test gcc_version(ep, available_gcc_builds) == [v"5.2.0", v"6.1.0"]

        # Adding `:cxx11` eliminates `v"4.X"`:
        cabi = CompilerABI(cabi; cxxstring_abi=:cxx11)
        p = Linux(:x86_64; compiler_abi=cabi)
        @test gcc_version(p, available_gcc_builds) == [v"5.2.0", v"6.1.0"]
        ep = ExtendedPlatform(p; march="avx512")
        @test gcc_version(ep, available_gcc_builds) == [v"6.1.0"]

        # Just libgfortran v3 allows GCC 6 as well though
        cabi = CompilerABI(;libgfortran_version=v"3")
        p = Linux(:x86_64; compiler_abi=cabi)
        @test gcc_version(p, available_gcc_builds) == [v"4.8.5", v"5.2.0", v"6.1.0"]

        # Test libgfortran version v4, then splitting on libstdcxx_version:
        cabi = CompilerABI(;libgfortran_version=v"4")
        p = Linux(:x86_64; compiler_abi=cabi)
        @test gcc_version(p, available_gcc_builds) == [v"7.1.0"]
        cabi = CompilerABI(cabi; libstdcxx_version=v"3.4.23")
        p = Linux(:x86_64; compiler_abi=cabi)
        @test gcc_version(p, available_gcc_builds) == [v"7.1.0"]
        ep = ExtendedPlatform(Linux(:aarch64; compiler_abi=cabi); march="thunderx2")
        @test gcc_version(ep, available_gcc_builds) == [v"7.1.0"]

        ep = ExtendedPlatform(Linux(:armv7l); march="neon")
        @test gcc_version(ep, available_gcc_builds) == [v"8.1.0", v"9.1.0"]
    end

    @testset "Compiler wrappers" begin
        platform = Linux(:x86_64, libc=:musl)
        mktempdir() do bin_path
            generate_compiler_wrappers!(platform; bin_path = bin_path)
            # Make sure the C++ string ABI is not set
            @test !occursin("-D_GLIBCXX_USE_CXX11_ABI", read(joinpath(bin_path, "gcc"), String))
            # Make sure gfortran doesn't uses ccache when BinaryBuilderBase.use_ccache is true
            BinaryBuilderBase.use_ccache && @test !occursin("ccache", read(joinpath(bin_path, "gfortran"), String))
        end
        platform = Linux(:x86_64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))
        mktempdir() do bin_path
            generate_compiler_wrappers!(platform; bin_path = bin_path)
            gcc = read(joinpath(bin_path, "gcc"), String)
            # Make sure the C++ string ABI is set as expected
            @test occursin("-D_GLIBCXX_USE_CXX11_ABI=0", gcc)
            # Make sure the unsafe flags check is there
            @test occursin("You used one or more of the unsafe flags", gcc)
        end
        platform = Linux(:x86_64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))
        mktempdir() do bin_path
            generate_compiler_wrappers!(platform; bin_path = bin_path, allow_unsafe_flags = true)
            gcc = read(joinpath(bin_path, "gcc"), String)
            # Make sure the C++ string ABI is set as expected
            @test occursin("-D_GLIBCXX_USE_CXX11_ABI=1", gcc)
            # Make sure the unsafe flags check is not there in this case
            @test !occursin("You used one or more of the unsafe flags", gcc)
        end
        platform = FreeBSD(:x86_64)
        mktempdir() do bin_path
            generate_compiler_wrappers!(platform; bin_path = bin_path, compilers = [:c, :rust, :go])
            clang = read(joinpath(bin_path, "clang"), String)
            # Check link flags
            @test occursin("-L/opt/$(triplet(platform))/$(triplet(platform))/lib", clang)
            @test occursin("fuse-ld=$(triplet(platform))", clang)
            # Other compilers
            @test occursin("GOOS=\"freebsd\"", read(joinpath(bin_path, "go"), String))
            @test occursin("--target=x86_64-unknown-freebsd", read(joinpath(bin_path, "rustc"), String))
        end
        platform      = Linux(:x86_64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))
        host_platform = Linux(:x86_64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))
        mktempdir() do bin_path
            @test_throws ErrorException generate_compiler_wrappers!(platform; bin_path = bin_path, host_platform = host_platform)
        end
        platform      = Linux(:x86_64, libc=:musl)
        host_platform = Linux(:x86_64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))
        mktempdir() do bin_path
            @test_throws ErrorException generate_compiler_wrappers!(platform; bin_path = bin_path, host_platform = host_platform)
        end
    end
end


text:
# Exponential Arm Model

type Exponential <: BanditArmBase
    armDist::Distributions.Exponential

    function Exponential( λ::Real ) # λ is the mean parameter
        new( Distributions.Exponential(λ) )
    end
end

function pull!( arm::Exponential )
    return Distributions.rand( arm.armDist )
end

function tick!( arm::Exponential )
    # Do nothing
    nothing
end

function reset!( arm::Exponential )
    # Do nothing
    nothing
end


text:
## stieltjes

function stieltjes(S::Space{<:PeriodicLine},f::AbstractVector,z::Number)
    S2=setdomain(S,Circle())
    stieltjes(S2,f,mappoint(domain(S),Circle(),z))+hilbert(S2,f,-1)*π
end

function hilbert(S::Space{<:PeriodicLine},f::AbstractVector,z::Number)
    S2=setdomain(S,Circle())
    hilbert(S2,f,mappoint(domain(f),Circle(),z))-hilbert(S2,f,-1)
end

function stieltjes(S::SumSpace{<:Any,<:PeriodicLine},f::AbstractVector,z::Number)
    S2=setdomain(S,Circle())
    stieltjes(S2,f,mappoint(domain(S),Circle(),z))+hilbert(S2,f,-1)*π
end

function hilbert(S::SumSpace{<:Any,<:PeriodicLine},f::AbstractVector,z::Number)
    S2=setdomain(S,Circle())
    hilbert(S2,f,mappoint(domain(f),Circle(),z))-hilbert(S2,f,-1)
end

# we use the fact that C^± (z^k + z^(k-1)) = z^k + z^(k-1) and 0
# for k > 0 and
# C^± (z^k + z^(k-1)) = 0 and -z^k - z^(k-1)
# for k < 0, the formula H = im*C^+  +  im*C^-
# and C± 1 = ±1/2  (understood as a PV integral) so that H 1 = 0

bandwidths(H::ConcreteHilbert{LaurentDirichlet{DD,RR}}) where {DD<:PeriodicLine,RR} =
    (0,0)
rangespace(H::ConcreteHilbert{LaurentDirichlet{DD,RR}}) where {DD<:PeriodicLine,RR} =
    domainspace(H)

function getindex(H::ConcreteHilbert{LaurentDirichlet{PeriodicLine{false,T},RR}},k::Integer,j::Integer) where {T,RR}
    if k==j && iseven(k)
        -T(im)
    elseif k==j && isodd(k) && k > 0
        T(im)
    else
        zero(T)
    end
end


text:
cse(v::IVertex, cache = Dict{typeof(v),typeof(v)}()) =
  postwalk(x -> get!(cache, x, x), v)

cse(v::Vertex, cache = d()) = cse(il(v), cache)

function cse(vs::Vector)
  cache = d()
  [cse(v, cache) for v in vs]
end

function duplicates(v::IVertex)
  cache = Dict{typeof(v),Int}()
  prewalk(v) do v
    cache[v] = get!(cache, v, 0) + 1
    v
  end
  cache = filter((_,n) -> n > 1, cache)
  cache = filter((v,_) -> !any(v′ -> v′ ≠ v && contains_(v′, v), keys(cache)), cache)
end

function contains_(haystack::IVertex, needle::IVertex)
  result = false
  prewalk(haystack) do v
    result |= v == needle
    v
  end
  return result
end

contains_(v::Vertex, w::Vertex) = contains_(il(v), il(w))

function common(v::IVertex, w::IVertex, seen = OSet())
  w in seen && return Set{typeof(w)}()
  push!(seen, w)
  if contains_(v, w)
    Set{typeof(w)}((w,))
  else
    union((common(v, w′, seen) for w′ in inputs(w))...)
  end
end

common(v::Vertex, w::Vertex) = common(il(v), il(w))


text:
libname = "libturbojpeg"

using Pkg; Pkg.add("JpegTurbo_jll")

using JpegTurbo_jll
jllroot = dirname(dirname(JpegTurbo_jll.libjpeg_path))

using Clang
const LIB_INCLUDE = joinpath(jllroot, "include") |> normpath
# const HEADERSs = filter(x->endswith(x, ".h"), readdir(LIB_INCLUDE))
# @show HEADERSs
const HEADERS = ["jconfig.h", "jmorecfg.h", "jerror.h", "jpeglib.h", "turbojpeg.h"]
const LIB_HEADERS = [joinpath(LIB_INCLUDE, header) for header in HEADERS]

refdir = joinpath.(@__DIR__, "ref_headers")
!isdir(refdir) && mkdir(refdir)
refpaths = joinpath.(refdir, basename.(LIB_HEADERS))
cp.(LIB_HEADERS, refpaths, follow_symlinks=true, force=true)

@show HEADERS

wc = init(; headers = LIB_HEADERS,
            output_file = joinpath(@__DIR__, "$(libname)_api.jl"),
            common_file = joinpath(@__DIR__, "$(libname)_common.jl"),
            clang_includes = vcat(LIB_INCLUDE, CLANG_INCLUDE),
            clang_args = ["-I", joinpath(LIB_INCLUDE, ".."), "-DBITS_IN_JSAMPLE=8", "-DINCOMPLETE_TYPES_BROKEN"],
            header_wrapped = (root, current)->root == current,
            header_library = x->libname,
            clang_diagnostics = true,
            )

run(wc)
rm(joinpath(@__DIR__, "LibTemplate.jl"))
commonpath = joinpath(@__DIR__, "$(libname)_common.jl")

### Manual Steps

#Line 327-onwards of _common.jl should be changed to:

# #const jpeg_saved_marker_ptr = Ptr{jpeg_marker_struct}
#
# struct jpeg_marker_struct
#     #next::jpeg_saved_marker_ptr
#     next::Ptr{Cvoid}
#     marker::UINT8
#     original_length::UInt32
#     data_length::UInt32
#     data::Ptr{JOCTET}
# end
#
# const jpeg_saved_marker_ptr = Ptr{jpeg_marker_struct}

# open(joinpath(@__DIR__, "$(libname)_fixes.jl"), "w") do io
#     write(io, "# manual fixes\n\n")
#     # write(io, "JSAMPLE\n")
# end


text:
function compute_orbital_energies(F, C)
  return transpose(C)*F*C
end


text:
#=
    Sources modelling
 =#
mutable struct Solar <: AbstractGeneration
     lifetime::Int64
     bounds::NamedTuple{(:lb, :ub), Tuple{Float64, Float64}}
     # Initial conditions
     powerMax_ini::Float64
     soh_ini::Float64
     # Variables
     carrier::Electricity
     powerMax::AbstractArray{Float64,2}
     timestamp::Array{DateTime,3}
     # Eco
     cost::AbstractArray{Float64,2}
     # Inner constructor
     Solar(;lifetime=25, bounds = (lb = 0., ub = 1000.), powerMax_ini = 0., soh_ini = 1.) = new(lifetime, bounds, powerMax_ini, soh_ini)
end

### Preallocation
function preallocate!(pv::Solar, nh::Int64, ny::Int64, ns::Int64)
    pv.carrier = Electricity()
    pv.carrier.power = convert(SharedArray,zeros(nh, ny, ns))
    pv.powerMax = convert(SharedArray,zeros(ny+1, ns)) ; pv.powerMax[1,:] .= pv.powerMax_ini
    pv.timestamp = Array{DateTime}(undef,(nh, ny, ns))
    pv.cost = convert(SharedArray,zeros(ny, ns))

    return pv
end

 ### Investment dynamic
function compute_investment_dynamics!(y::Int64, s::Int64, pv::Solar, decision::Union{Float64, Int64})
     pv.powerMax[y+1,s] = compute_investment_dynamics(pv, (powerMax = pv.powerMax[y,s],), decision)
end

function compute_investment_dynamics(pv::Solar, state::NamedTuple{(:powerMax,), Tuple{Float64}}, decision::Union{Float64, Int64})
     if decision > 1e-2
         powerMax_next = decision
     else
         powerMax_next = state.powerMax
     end
     return powerMax_next
end


text:
module JuliaEuler

using Dates
using Lazy

import Base.Iterators: product

export ex1, ex2, ex3, ex4, ex5, ex6, ex7, ex8, ex9, ex10
export ex11, ex12, ex13, ex14, ex15, ex16, ex17, ex18, ex19, ex20
export ex21, ex22, ex23, ex24, ex25, ex26, ex27, ex28, ex29

export fib, fibs, primes, factors, primes_of_num, proper_divisors, permutations, product, combinations
"""
```jldoctest
julia> fib(;terms=7) == [1, 2, 3, 5, 8, 13, 21]
true

```
"""
fibs = @lazy BigInt(1):1:(fibs + drop(1,fibs))

function fib(; terms=missing, under=missing)
    m = count(x->ismissing(x), [terms,under])
    if m in (0,2)
        throw("User either number of terms, or fibs under certain value")
    end
    if !ismissing(terms)
        return take(terms, fibs)
    else
        return takewhile(x-> x < under, fibs)
    end
end

function primes(n)
    p = Vector{Int}()
    if n == 1
        return p
    end
    append!(p,2)

    sieve=fill(true, n)
    sieve[4:2:end] .= false
    for i in 3:2:n
        if sieve[i]
            append!(p,i)
            sieve[i+i:i:end] .= false
        end
    end
    return p
end

function factors(n)
    fs = Vector{Tuple{Int,Int}}()
    if n == 1
        return fs
    end
    ps = primes(convert(Int,ceil(sqrt(n))))

    for p in ps
        count = 1
        while n%(p^count) == 0
            count+=1
        end
        count -= 1
        if count  > 0
            append!(fs, [(p,count)])
            n /= p^count
        end
    end
    if n != 1
        append!(fs, [(n,1)])
    end
    fs
end

function primes_of_num(n)
    fac = factors(n)
    [f for (f,_) in fac]
end

function proper_divisors(n)
    [j for j in 1:n-1 if n % j == 0]
end

function product(l, n::Int)
    product([l for i in 1:n]...)
end

function unique_sorted(ind)
    for i in 1:length(ind)-1
        if ind[i] == ind[i+1]
            return false
        end
    end
    true
end

function permutations(l, n)
    ps = product(l,n)
    pd = product(1:length(l),n)

    (p for (p,ind) in zip(ps,pd) if unique_sorted(sort(collect(ind))))
end

function combinations(l, n; with_replacement=false)
    ps = product(l,n)
    pd = product(1:length(l),n)

    (p for (p,ind) in zip(ps,pd) if (issorted(ind) & (with_replacement | unique_sorted(ind))))
end
# Write your package code here.
ex1(n) = sum(i for i in 3:3:(n-1)) + sum(i for i in 5:5:(n-1)) - sum(i for i in 15:15:(n-1))
ex2(n) = fib(;under=n) |> x->filter(y->y%2==0, x) |> sum
ex3(n) = primes_of_num(n)[end]
ex4(n) = begin
    nums = 10^(n-1):1:10^n
    max_pal = 0
    for (i,n1) in enumerate(nums)
        for (j,n2) in enumerate(nums)
            n = n1*n2
            ns = "$n"
            max_pal = max(max_pal, ns == reverse(ns) ? n : 0)
        end
    end
    max_pal
end
ex5(n) = begin
    f = 1:n .|> factors |> Base.Iterators.flatten |> Set |> collect |> sort |> (x->groupby(y->y[1],x))
    res = 1
    for (k,v) in f
        m = k^maximum([i for (_,i) in v])
        res *= m
    end
    res
end
"""
``(1+2+3+\\ldots+n)^2 - (1^2+2^2+3^2+\\ldots+n^2)``
"""
ex6(n) = 1:n |> (x-> sum(x)^2 - ((x.^2) |> sum))
ex7(n) = primes(n*n)[n]
ex8(n) = begin
    num = 7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450
    ns = "$num"
    max_val = 0
    for i in 1:(length(ns)-n+1)
        max_val = max(max_val, ns[i:i+n-1] |> collect .|> (x->parse(Int,x)) |> (x->reduce(*,x)))
    end
    max_val
end
ex9(n) = begin
    res = []
    for i = 1:n
        if i + i + 1 >= n
            break
        end
        for j = i+1:n
            if n - (i + j) <= j
                break
            end
            k = n - i - j
            if i^2 + j^2 == k^2
                append!(res, [(i,j,k)])
            end
        end
    end
    reduce(*,res[1])
end
ex10(n) = primes(n) |> sum
ex11(n) = begin
    nums = [08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08;
    49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00;
    81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65;
    52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91;
    22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80;
    24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50;
    32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70;
    67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21;
    24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72;
    21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95;
    78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92;
    16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57;
    86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58;
    19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40;
    04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66;
    88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69;
    04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36;
    20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16;
    20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54;
    01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48]

    max_val = 0
    for x in 1:20
        for y in 1:20-n+1
            max_val = max(max_val, reduce(*,nums[x,y:y+n-1]))
        end
    end
    for y in 1:20
        for x in 1:20-n+1
            max_val = max(max_val, reduce(*,nums[x:x+n-1,y]))
        end
    end
    for x in 1:20-n+1
        for y in 1:20-n+1
            max_val = max(max_val, reduce(*,[nums[x+i-1, y+i-1] for i in 1:n]))
        end
    end
    for x in n:20
        for y in 1:(20-n+1)
            vals = [nums[x-(i-1), y+(i-1)] for i in 1:n]
            max_val = max(max_val, reduce(*,vals))
        end
    end
    max_val
end
ex12(n) = begin
    i = 1
    t = 1
    while i < 100000000
        f = [p+1 for (_,p) in factors(t)]
        if reduce(*,f) > n
            break
        end
        i += 1
        t += i
    end
    return t
end
ex13(n) = begin
    nums =
    [
        37107287533902102798797998220837590246510135740250,
        46376937677490009712648124896970078050417018260538,
        74324986199524741059474233309513058123726617309629,
        91942213363574161572522430563301811072406154908250,
        23067588207539346171171980310421047513778063246676,
        89261670696623633820136378418383684178734361726757,
        28112879812849979408065481931592621691275889832738,
        44274228917432520321923589422876796487670272189318,
        47451445736001306439091167216856844588711603153276,
        70386486105843025439939619828917593665686757934951,
        62176457141856560629502157223196586755079324193331,
        64906352462741904929101432445813822663347944758178,
        92575867718337217661963751590579239728245598838407,
        58203565325359399008402633568948830189458628227828,
        80181199384826282014278194139940567587151170094390,
        35398664372827112653829987240784473053190104293586,
        86515506006295864861532075273371959191420517255829,
        71693888707715466499115593487603532921714970056938,
        54370070576826684624621495650076471787294438377604,
        53282654108756828443191190634694037855217779295145,
        36123272525000296071075082563815656710885258350721,
        45876576172410976447339110607218265236877223636045,
        17423706905851860660448207621209813287860733969412,
        81142660418086830619328460811191061556940512689692,
        51934325451728388641918047049293215058642563049483,
        62467221648435076201727918039944693004732956340691,
        15732444386908125794514089057706229429197107928209,
        55037687525678773091862540744969844508330393682126,
        18336384825330154686196124348767681297534375946515,
        80386287592878490201521685554828717201219257766954,
        78182833757993103614740356856449095527097864797581,
        16726320100436897842553539920931837441497806860984,
        48403098129077791799088218795327364475675590848030,
        87086987551392711854517078544161852424320693150332,
        59959406895756536782107074926966537676326235447210,
        69793950679652694742597709739166693763042633987085,
        41052684708299085211399427365734116182760315001271,
        65378607361501080857009149939512557028198746004375,
        35829035317434717326932123578154982629742552737307,
        94953759765105305946966067683156574377167401875275,
        88902802571733229619176668713819931811048770190271,
        25267680276078003013678680992525463401061632866526,
        36270218540497705585629946580636237993140746255962,
        24074486908231174977792365466257246923322810917141,
        91430288197103288597806669760892938638285025333403,
        34413065578016127815921815005561868836468420090470,
        23053081172816430487623791969842487255036638784583,
        11487696932154902810424020138335124462181441773470,
        63783299490636259666498587618221225225512486764533,
        67720186971698544312419572409913959008952310058822,
        95548255300263520781532296796249481641953868218774,
        76085327132285723110424803456124867697064507995236,
        37774242535411291684276865538926205024910326572967,
        23701913275725675285653248258265463092207058596522,
        29798860272258331913126375147341994889534765745501,
        18495701454879288984856827726077713721403798879715,
        38298203783031473527721580348144513491373226651381,
        34829543829199918180278916522431027392251122869539,
        40957953066405232632538044100059654939159879593635,
        29746152185502371307642255121183693803580388584903,
        41698116222072977186158236678424689157993532961922,
        62467957194401269043877107275048102390895523597457,
        23189706772547915061505504953922979530901129967519,
        86188088225875314529584099251203829009407770775672,
        11306739708304724483816533873502340845647058077308,
        82959174767140363198008187129011875491310547126581,
        97623331044818386269515456334926366572897563400500,
        42846280183517070527831839425882145521227251250327,
        55121603546981200581762165212827652751691296897789,
        32238195734329339946437501907836945765883352399886,
        75506164965184775180738168837861091527357929701337,
        62177842752192623401942399639168044983993173312731,
        32924185707147349566916674687634660915035914677504,
        99518671430235219628894890102423325116913619626622,
        73267460800591547471830798392868535206946944540724,
        76841822524674417161514036427982273348055556214818,
        97142617910342598647204516893989422179826088076852,
        87783646182799346313767754307809363333018982642090,
        10848802521674670883215120185883543223812876952786,
        71329612474782464538636993009049310363619763878039,
        62184073572399794223406235393808339651327408011116,
        66627891981488087797941876876144230030984490851411,
        60661826293682836764744779239180335110989069790714,
        85786944089552990653640447425576083659976645795096,
        66024396409905389607120198219976047599490197230297,
        64913982680032973156037120041377903785566085089252,
        16730939319872750275468906903707539413042652315011,
        94809377245048795150954100921645863754710598436791,
        78639167021187492431995700641917969777599028300699,
        15368713711936614952811305876380278410754449733078,
        40789923115535562561142322423255033685442488917353,
        44889911501440648020369068063960672322193204149535,
        41503128880339536053299340368006977710650566631954,
        81234880673210146739058568557934581403627822703280,
        82616570773948327592232845941706525094512325230608,
        22918802058777319719839450180888072429661980811197,
        77158542502016545090413245809786882778948721859617,
        72107838435069186155435662884062257473692284509516,
        20849603980134001723930671666823555245252804609722,
        53503534226472524250874054075591789781264330331690
    ]
    "$(sum(nums[1:n]))"[1:10]
end
ex14(n) = begin
    _even(k::Int)::Int = k/2
    _odd(k::Int)::Int = 3k+1
    longest = (0,0)
    for i in 1:n
        len = 1
        res = i
        while res != 1
            res = res % 2 == 0 ? _even(res) : _odd(res)
            len += 1
        end
        longest = max((len,i), longest)
    end
    longest[2]
end
ex15(n::Int)::BigInt = begin
    result = 1
    for i=1:n
        result = result * (n+i)/i
    end
    result
end
ex16(n::Int) = BigInt(2)^n |> x->"$x" |> x-> split(x,"") .|> (x-> parse(Int,x)) |> sum
ex17() = begin
    n_to_l = Dict(
        0=>0, 1=>3, 2=> 3, 3=>5, 4=>4, 5=>4, 6=>3, 7=>5, 8=>5, 9=>4,
        10=>3, 11=>6,12=>6, 13=>8,14=>8,15=>7,16=>7,17=>9,18=>8, 19=>8,
        20=>6, 30=>6, 40=>5, 50=>5, 60=>5,70=>7, 80=>6, 90=>6,
        100=>7, 1000=>8,-1=>3
        )
    all_tens = sum(n_to_l[i] for i in 1:9)
    all_tweens = sum(n_to_l[i] for i in 10:19)
    all_20_90 = sum(n_to_l[i] for i in 20:10:90)
    sub_100 = all_tens + all_tweens + all_20_90*10 + all_tens*8
    all_1_99 = 10 * sub_100
    all_hundreds = sum(n_to_l[i]+n_to_l[100] for i in 1:9)
    all_hundreds_and = all_hundreds*99 + 9*99*n_to_l[-1]
    thousand = n_to_l[1] + n_to_l[1000]
    thousand + all_hundreds_and+all_hundreds + all_1_99
end
ex18(n) = begin
    tri =
    """75
    95 64
    17 47 82
    18 35 87 10
    20 04 82 47 65
    19 01 23 75 03 34
    88 02 77 73 07 63 67
    99 65 04 28 06 16 70 92
    41 41 26 56 83 40 80 70 33
    41 48 72 33 47 32 37 16 94 29
    53 71 44 65 25 43 91 52 97 51 14
    70 11 33 28 77 73 17 78 39 68 17 57
    91 71 52 38 17 14 91 43 58 50 27 29 48
    63 66 04 68 89 53 67 30 73 16 69 87 40 31
    04 62 98 27 23 09 70 98 73 93 38 53 60 04 23"""
    tri_parsed = tri |> strip |> x->split(x, "\n") .|> (x->split(x)) .|>(x-> map(y->parse(Int,y), x))
    res = [tri_parsed[n]]
    for i in n:-1:2
        t = res[end]
        t_u = tri_parsed[i-1]
        push!(res, [max(v+t[i], v+t[i+1]) for (i,v) in enumerate(t_u)])
    end
    res[end][1]
end
ex19(ds::Date,de::Date) = sum([1 for d in ds:Month(1):de if Dates.issunday(d)])
ex20(n) = reduce(*, BigInt(1):BigInt(n)) |> x->"$x" |> x->split(x,"") .|> (x->parse(Int,x)) |> sum
ex21(n) = [(i, sum(proper_divisors(i))) for i in 2:n] |> x->Dict(x) |> x-> [(k,v) for (k,v) in x if (k == get(x,v,0)) & (k != v)] |> Dict |>keys |> sum
ex22() = begin
    cv = Dict([(v,i) for (i,v) in enumerate('A':'Z')])
    open(f->read(f,String), joinpath(@__DIR__,"assets","p022_names.txt")) |> x-> replace(x,"\""=>"") |> x-> split(x,",") |> sort |> enumerate .|> (x->x[1] * sum([cv[c] for c in x[2]])) |> sum
end
ex23(n) = begin
    filter_abundant(x) = filter(y -> y[1] < y[2] ? true : false, x)
    comb(x) = combinations(x,2;with_replacement=true)
    ab_nums = [(i,sum(proper_divisors(i))) for i in 2:n] |> filter_abundant .|> (x-> x[1])
    all_nums = Set(1:n)
    for c in comb(ab_nums)
        pop!(all_nums,sum(c),0)
    end
    sum(all_nums)
end

ex24(l,n) = begin
    inds_to_out(ii) = begin
        [l[i] for i in ii] |> join |> x-> parse(Int,x)
    end
    if reduce(*,1:length(l)) == n
        return length(l):-1:1 |> collect |> inds_to_out
    end
    res = n
    inds = Vector{Int}()
    inds_left = 1:length(l)|>collect
    for i in length(l)-1:-1:1
        fact = reduce(*,1:i)
        d,res = divrem(res,fact)
        next_ind = d + (res!=0)
        ind = inds_left[next_ind]
        append!(inds,ind)
        deleteat!(inds_left,next_ind)

        if (fact == res) | (res == 0)
            break
        end
    end
    append!(inds,reverse(inds_left)) |> inds_to_out
end

ex25(n) = takeuntil(x-> x > BigInt(10)^(n-1), fibs) |> length

ex26(n) = begin
    N, hi = 0, 0
    for n = 1:n
        for β = 6:1000
            if (1//n*BigInt(10)^β)%1 == ((1//n * BigInt(10)^5) %1)
                if hi < β-5
                    hi = β-5
                    N = n
                end
                break
            end
        end
    end
    N
end

ex27(am, bm) = begin
    nm = 5000
    ps = primes(nm^2)
    p = Set(ps)
    mp = ps[end]
    max_primes = 0
    max_mul = 0
    for a in (-am+1):(am-1)
        for b in -bm:bm
            for n = 1:nm
                f = (n^2 + a*n +b)
                if f in p
                    continue
                elseif f > mp
                    throw("GenerateMorePrimes")
                else
                    if n > max_primes
                        max_primes = n
                        max_mul = a*b
                    end
                    break
                end
            end
        end
    end
    max_mul
end

ex28(n) = 1 + sum((i^2+(i-2)^2 + i-1)*2  for i in 3:2:n)

ex29(am,bm) = begin
    res = Set{BigInt}()
    for a_tmp in 2:am
        a = big(a_tmp)
        b = 2
        while b <= bm
            a *= a_tmp
            push!(res, a)
            b += 1
        end
    end
    length(res)
end

end

max_stars_repo_name: binnisb/JuliaEuler

max_issues_repo_name: binnisb/JuliaEuler

max_forks_repo_name: binnisb/JuliaEuler


text:
using SurrogateCube
# Define some Parameters
Ncomp = 3 #We want 3 independent components
Nvar  = 10 # we want 10 measured variables
noise = WhiteNoise(0.1) #Each component has a noise with sigma=0.5
means = [ConstantBaseline(0.0),ConstantBaseline(0.0),SineBaseline(10,1.0)] # One Baseline has a cycle
dists = [EmptyEvent(),EmptyEvent(),TrendEvent(CubeEvent(0.3))] # Only one of the components is disturbed with a size of 20% in each dimension
varNoise = WhiteNoise(0.1) # each variable generated has some independent white noise
kb=1.0  # How strongly do we want to perturb
ks=0.0
kn=0.0
#Set dimensions
Nlon = 5
Nlat = 5
Ntime =300
ds = genDataCube(means,noise,dists,varNoise,Ncomp,Nvar,Ntime,Nlat,Nlon,kb,ks,kn);
#Save the datacube to a file
save_cube(ds)
#Plot something
using PyPlot
pygui(true)
f=figure()
for i=1:Nvar
plot(ds.variables[:,3,3,i][:])
end

f=figure()
for i=1:Ncomp
plot(ds.components[:,3,3,i][:])
end

f=figure()
for i=1:Ncomp
plot(ds.eventmap[:,3,3,i][:])
end

max_stars_repo_name: CAB-LAB/DataFarm

max_issues_repo_name: esa-esdl/DataFarm

max_forks_repo_name: esa-esdl/DataFarm


text:
"""
        _cols_by_rows(rows_index,cols_index)
Returns a vector of rows where each row contains
a vector of its column indices.
"""
function _cols_by_rows(rows_index,cols_index)
    nrows = maximum(rows_index)
    cols_by_rows = [eltype(rows_index)[] for _ in 1:nrows]
    for (i,j) in zip(rows_index,cols_index)
        push!(cols_by_rows[i],j)
    end
    return cols_by_rows
end

"""
        _rows_by_cols(rows_index,cols_index)
Returns a vector of columns where each column contains
a vector of its row indices.
"""
function _rows_by_cols(rows_index,cols_index)
    return _cols_by_rows(cols_index,rows_index)
end

function matrix2adjmatrix(M; partition_by_rows = true)
    (rows_index, cols_index, _) = findnz(M)
    if partition_by_rows
        A = SparseMatrixCSC{Float64, Cuint}(size(M,1), size(M,1), ones(Cuint, size(M,1)+1), Vector{Cuint}(), Vector{Float64}())
        rows_by_cols = _rows_by_cols(rows_index,cols_index)
        @inbounds for (cur_row,cur_col) in zip(rows_index,cols_index)
            if !isempty(rows_by_cols[cur_col])
                for next_row in rows_by_cols[cur_col]
                    if next_row < cur_row
                        A[cur_row, next_row] = 1.0
                        A[next_row, cur_row] = 1.0
                    end
                end
            end
        end
    else
        A = SparseMatrixCSC{Float64, Cuint}(size(M,2), size(M,2), ones(Cuint, size(M,2)+1), Vector{Cuint}(), Vector{Float64}())
        cols_by_rows = _cols_by_rows(rows_index,cols_index)
        @inbounds for (cur_row,cur_col) in zip(rows_index,cols_index)
            if !isempty(cols_by_rows[cur_row])
                for next_col in cols_by_rows[cur_row]
                    if next_col < cur_col
                        A[cur_col, next_col] = 1.0
                        A[next_col, cur_col] = 1.0
                    end
                end
            end
        end
    end
    return A
end


text:
using PQBaseCamp
using DataFrames
using CSV

# make an exponential weight model -
function ew(data::DataFrame, map::Pair{Symbol,Symbol})::Array{Float64,1}

    # initialize -
    ω_array = Array{Float64,1}()
    α = 0.001

    # how many rows do we have?
    (number_of_rows, _) = size(data)
    for row_index ∈ 1:(number_of_rows - 1)

        value = (1 - α)^(row_index - 1)
        push!(ω_array, value)
    end

    # scale - so that we sum to 1
    T = sum(ω_array)
    return reverse((1 / T) * ω_array)
end

# load up a sample data file -
path_to_data_file = "$(pwd())/test/data/MRNA.csv"
df = CSV.read(path_to_data_file, DataFrame)

# what is the w?
ω_array = ew(df, :timestamp => :close)

# build a computation model -
model = LogReturnComputationModel()
model.ticker = "MRNA"
model.data = df
model.map = :timestamp => :close
Δ_table = Δ(model)


text:
using SQLite
using Dates

db = SQLite.DB("./prices.sqlite")

DBInterface.execute(db,
"""
create table if not exists Prices
    (date date, item text, price number)
"""
)

mydate = Date(2022,01,01)
letters = split("ABCDEFGHIJKLMNOPRSUVYZWX", "")

for i in 1:365
    for letter in letters
        price = rand() * 100
        mystrdate = string(mydate)
        sql = "insert into Prices (date, item, price) values ('$mystrdate', '$letter', $price)"
        DBInterface.execute(db, sql)
    end
    global mydate += Dates.Day(1)
end

DBInterface.close!(db)

max_stars_repo_name: jbytecode/sampledbs

max_issues_repo_name: jbytecode/sampledbs

max_forks_repo_name: jbytecode/sampledbs


text:
"""
Atomic solution for an DAE.

### Parameters

* `DT`: data type
* `TT`: time step type
* `AT`: array type
* `IT`: internal variable types

### Fields

* `t`: time of current time step
* `t̄`: time of previous time step
* `q`: current solution of q
* `q̄`: previous solution of q
* `q̃`: compensated summation error of q
* `λ`: current solution of λ
* `λ̄`: previous solution of λ
* `v`: vector field of q
* `v̄`: vector field of q̄
* `u`: projective vector field of q
* `ū`: projective vector field of q̄
* `internal`: internal variables of the integrator (e.g., internal stages of a Runge-Kutta methods or solver output)

### Constructors

```julia
AtomicSolutionDAE{DT,TT,AT,IT}(nd, nm, internal::IT)
AtomicSolutionDAE{DT,TT,AT,IT}(t::TT, q::AT, λ::AT, internal::IT)
AtomicSolutionDAE(DT, TT, AT, nd, nm, internal::IT=NamedTuple())
AtomicSolutionDAE(t::TT, q::AT, λ::AT, internal::IT=NamedTuple())
```

* `nd`: dimension of the state vector
* `nm`: dimension of the constraint

"""
mutable struct AtomicSolutionDAE{DT <: Number, TT <: Real, AT <: AbstractArray{DT}, IT <: NamedTuple} <: AtomicSolution{DT,TT,AT}
    t::TT
    t̄::TT

    q::AT
    q̄::AT
    q̃::AT

    λ::AT
    λ̄::AT

    v::AT
    v̄::AT

    u::AT
    ū::AT

    internal::IT

    function AtomicSolutionDAE{DT,TT,AT,IT}(nd, nm, internal::IT) where {DT,TT,AT,IT}
        new(zero(TT), zero(TT),
            AT(zeros(DT, nd)), AT(zeros(DT, nd)), AT(zeros(DT, nd)),
            AT(zeros(DT, nm)), AT(zeros(DT, nm)),
            AT(zeros(DT, nd)), AT(zeros(DT, nd)),
            AT(zeros(DT, nd)), AT(zeros(DT, nd)),
            internal)
    end

    function AtomicSolutionDAE{DT,TT,AT,IT}(t::TT, q::AT, λ::AT, internal::IT) where {DT,TT,AT,IT}
        new(zero(t), zero(t),
            zero(q), zero(q), zero(q),
            zero(λ), zero(λ),
            zero(q), zero(q),
            zero(λ), zero(λ),
            internal)
    end
end

AtomicSolutionDAE(DT, TT, AT, nd, nm, internal::IT=NamedTuple()) where {IT} = AtomicSolutionDAE{DT,TT,AT,IT}(nd, nm, internal)
AtomicSolutionDAE(t::TT, q::AT, λ::AT, internal::IT=NamedTuple()) where {DT, TT, AT <: AbstractArray{DT}, IT} = AtomicSolutionDAE{DT,TT,AT,IT}(t, q, λ, internal)

function set_initial_conditions!(asol::AtomicSolutionDAE, equ::AbstractEquationDAE, i::Int=1)
    @assert i ≥ nsamples(equ)
    t, q, λ = initial_conditions(equ)
    asol.t  = t
    asol.q .= q[i]
    asol.λ .= λ[i]
    asol.v .= 0
end

function set_solution!(asol::AtomicSolutionDAE, sol)
    t, q, λ = sol
    asol.t  = t
    asol.q .= q
    asol.λ .= λ
    asol.v .= 0
end

function get_solution(asol::AtomicSolutionDAE)
    (asol.t, asol.q, asol.λ)
end

function GeometricBase.reset!(asol::AtomicSolutionDAE, Δt)
    asol.t̄  = asol.t
    asol.q̄ .= asol.q
    asol.λ̄ .= asol.λ
    asol.v̄ .= asol.v
    asol.ū .= asol.u
    asol.t += Δt
end

function update!(asol::AtomicSolutionDAE{DT}, y::Vector{DT}, λ::Vector{DT}) where {DT}
    for k in eachindex(y)
        update!(asol, y[k], k)
    end
    for k in eachindex(λ)
        asol.λ[k] = λ[k]
    end
end

function update!(asol::AtomicSolutionDAE{DT}, y::DT, k::Union{Int,CartesianIndex}) where {DT}
    asol.q[k], asol.q̃[k] = compensated_summation(y, asol.q[k], asol.q̃[k])
end


text:
#!/usr/bin/env julia

# This file is a part of SIS3316.jl, licensed under the MIT License (MIT).

import GeDetROOT

GeDetROOT.sis3316_to_root()


text:
# Map
map(x -> x * 2, 1:5)

# Filter
filter(x -> x % 2 == 0, 1:10)

# Reduce (Recall: Operators are just functions in Julia)
reduce(+, 1:4) # 10


text:
function linsolve(operator, b, x₀, alg::CG, a₀::Real = 0, a₁::Real = 1)
    # Initial function operation and division defines number type
    y₀ = apply(operator, x₀)
    T = typeof(dot(b, y₀)/norm(b)*one(a₀)*one(a₁))
    α₀ = convert(T, a₀)
    α₁ = convert(T, a₁)
    # Continue computing r = b - a₀ * x₀ - a₁ * operator(x₀)
    r = copyto!(similar(b, T), b)
    r = α₀ == 0 ? r : axpy!(-α₀, x₀, r)
    r = axpy!(-α₁, y₀, r)
    x = copyto!(similar(r), x₀)
    normr = norm(r)
    S = typeof(normr)

    # Algorithm parameters
    maxiter = alg.maxiter
    tol::S = alg.tol
    numops = 1 # operator has been applied once to determine r
    numiter = 0

    # Check for early return
    normr < tol && return (x, ConvergenceInfo(1, r, normr, numiter, numops))

    # First iteration
    ρ = normr^2
    p = copyto!(similar(r), r)
    q = apply(operator, p)
    if α₀ != zero(α₀) || α₁ != one(α₁)
        axpby!(α₀, p, α₁, q)
    end
    α = ρ / dot(p,q)
    axpy!(+α, p, x)
    axpy!(-α, q, r)
    normr = norm(r)
    ρold = ρ
    ρ = normr^2
    β = ρ/ρold
    numops += 1
    numiter += 1
    if alg.verbosity > 1
        msg = "CG linsolve in iter $numiter: "
        msg *= "normres = "
        msg *= @sprintf("%.12e", normr)
        @info msg
    end

    # Check for early return
    normr < tol && return (x, ConvergenceInfo(1, r, normr, numiter, numops))

    while numiter < maxiter
        axpby!(1, r, β, p)
        q = apply(operator, p)
        if α₀ != zero(α₀) || α₁ != one(α₁)
            axpby!(α₀, p, α₁, q)
        end
        α = ρ / dot(p,q)
        axpy!(+α, p, x)
        axpy!(-α, q, r)
        normr = norm(r)
        if normr < tol # recompute to account for buildup of floating point errors
            r = copyto!(similar(b, T), b)
            r = α₀ == 0 ? r : axpy!(-α₀, x, r)
            r = axpy!(-α₁, apply(operator, x), r)
            normr = norm(r)
            ρ = normr^2
            β = 0 # restart CG
        else
            ρold = ρ
            ρ = normr^2
            β = ρ/ρold
        end
        if normr < tol
            if alg.verbosity > 0
                @info """CG linsolve converged at iteration $numiter:
                 *  norm of residual = $normr
                 *  number of operations = $numops"""
            end
            return (x, ConvergenceInfo(1, r, normr, numiter, numops))
        end
        numops += 1
        numiter += 1
        if alg.verbosity > 1
            msg = "CG linsolve in iter $numiter: "
            msg *= "normres = "
            msg *= @sprintf("%.12e", normr)
            @info msg
        end
    end
    if alg.verbosity > 0
        @warn """CG linsolve finished without converging after $numiter iterations:
         *  norm of residual = $normr
         *  number of operations = $numops"""
    end
    return (x, ConvergenceInfo(0, r, normr, numiter, numops))
end


text:
using Test, MPI

using ClimateMachine
using ClimateMachine.MPIStateArrays
using ClimateMachine.MPIStateArrays: getstateview
using ClimateMachine.VariableTemplates: @vars, varsindex, varsindices
using StaticArrays

ClimateMachine.init()
const ArrayType = ClimateMachine.array_type()
const mpicomm = MPI.COMM_WORLD

const V = @vars begin
    a::Float32
    b::SVector{3, Float32}
    c::SMatrix{3, 8, Float32}
    d::Float32
    e::@vars begin
        a::Float32
        b::SVector{3, Float32}
        d::Float32
    end
end

const VNT = @vars begin
    a::Float32
    e::Tuple{ntuple(3) do i
        @vars(b::SVector{3, Float32})
    end...}
end

@testset "MPIStateArray varsindex" begin
    # check with invalid vars size
    @test_throws ErrorException MPIStateArray{Float32, V}(
        mpicomm,
        ArrayType,
        4,
        1,
        8,
    )

    Q = MPIStateArray{Float32, V}(mpicomm, ArrayType, 4, 34, 8)
    @test Q.a === view(MPIStateArrays.realview(Q), :, 1:1, :)
    @test Q.b === view(MPIStateArrays.realview(Q), :, 2:4, :)
    @test Q.c === view(MPIStateArrays.realview(Q), :, 5:28, :)
    @test Q.d === view(MPIStateArrays.realview(Q), :, 29:29, :)
    @test Q.e === view(MPIStateArrays.realview(Q), :, 30:34, :)

    @test getstateview(Q, "a") === view(MPIStateArrays.realview(Q), :, 1:1, :)
    @test getstateview(Q, "b") === view(MPIStateArrays.realview(Q), :, 2:4, :)
    @test getstateview(Q, "c") === view(MPIStateArrays.realview(Q), :, 5:28, :)
    @test getstateview(Q, "d") === view(MPIStateArrays.realview(Q), :, 29:29, :)
    @test getstateview(Q, "e") === view(MPIStateArrays.realview(Q), :, 30:34, :)
    @test getstateview(Q, "e.a") ===
          view(MPIStateArrays.realview(Q), :, 30:30, :)
    @test getstateview(Q, "e.b") ===
          view(MPIStateArrays.realview(Q), :, 31:33, :)
    @test getstateview(Q, "e.d") ===
          view(MPIStateArrays.realview(Q), :, 34:34, :)

    @test getstateview(Q, :(a)) === view(MPIStateArrays.realview(Q), :, 1:1, :)
    @test getstateview(Q, :(b)) === view(MPIStateArrays.realview(Q), :, 2:4, :)
    @test getstateview(Q, :(c)) === view(MPIStateArrays.realview(Q), :, 5:28, :)
    @test getstateview(Q, :(d)) ===
          view(MPIStateArrays.realview(Q), :, 29:29, :)
    @test getstateview(Q, :(e)) ===
          view(MPIStateArrays.realview(Q), :, 30:34, :)
    @test getstateview(Q, :(e.a)) ===
          view(MPIStateArrays.realview(Q), :, 30:30, :)
    @test getstateview(Q, :(e.b)) ===
          view(MPIStateArrays.realview(Q), :, 31:33, :)
    @test getstateview(Q, :(e.d)) ===
          view(MPIStateArrays.realview(Q), :, 34:34, :)

    @test_throws ErrorException Q.aa
    @test_throws ErrorException getstateview(Q, "aa")

    P = similar(Q)
    @test P.a === view(MPIStateArrays.realview(P), :, 1:1, :)
    @test P.b === view(MPIStateArrays.realview(P), :, 2:4, :)
    @test P.c === view(MPIStateArrays.realview(P), :, 5:28, :)
    @test P.d === view(MPIStateArrays.realview(P), :, 29:29, :)
    @test P.e === view(MPIStateArrays.realview(P), :, 30:34, :)

    @test getstateview(P, "a") === view(MPIStateArrays.realview(P), :, 1:1, :)
    @test getstateview(P, "b") === view(MPIStateArrays.realview(P), :, 2:4, :)
    @test getstateview(P, "c") === view(MPIStateArrays.realview(P), :, 5:28, :)
    @test getstateview(P, "d") === view(MPIStateArrays.realview(P), :, 29:29, :)
    @test getstateview(P, "e") === view(MPIStateArrays.realview(P), :, 30:34, :)
    @test getstateview(P, "e.a") ===
          view(MPIStateArrays.realview(P), :, 30:30, :)
    @test getstateview(P, "e.b") ===
          view(MPIStateArrays.realview(P), :, 31:33, :)
    @test getstateview(P, "e.d") ===
          view(MPIStateArrays.realview(P), :, 34:34, :)

    @test getstateview(P, :(a)) === view(MPIStateArrays.realview(P), :, 1:1, :)
    @test getstateview(P, :(b)) === view(MPIStateArrays.realview(P), :, 2:4, :)
    @test getstateview(P, :(c)) === view(MPIStateArrays.realview(P), :, 5:28, :)
    @test getstateview(P, :(d)) ===
          view(MPIStateArrays.realview(P), :, 29:29, :)
    @test getstateview(P, :(e)) ===
          view(MPIStateArrays.realview(P), :, 30:34, :)
    @test getstateview(P, :(e.a)) ===
          view(MPIStateArrays.realview(P), :, 30:30, :)
    @test getstateview(P, :(e.b)) ===
          view(MPIStateArrays.realview(P), :, 31:33, :)
    @test getstateview(P, :(e.d)) ===
          view(MPIStateArrays.realview(P), :, 34:34, :)

    A = MPIStateArray{Float32}(mpicomm, ArrayType, 4, 29, 8)
    @test_throws ErrorException A.a
    @test_throws ErrorException getstateview(A, "a")
end

@testset "MPIStateArray show_not_finite_fields" begin
    post_msg = "are not finite (has NaNs or Inf)"
    Q = MPIStateArray{Float32, V}(mpicomm, ArrayType, 4, 34, 8)
    Q .= 1
    Qv = view(MPIStateArrays.realview(Q), :, 1:1, :)
    Qv .= NaN
    msg = "Field(s) (a) " * post_msg
    @test_logs (:warn, msg) show_not_finite_fields(Q)

    Qv = view(MPIStateArrays.realview(Q), :, 2:2, :)
    Qv .= NaN
    msg = "Field(s) (a, and b[1]) " * post_msg
    @test_logs (:warn, msg) show_not_finite_fields(Q)

    Qv = view(MPIStateArrays.realview(Q), :, 31:31, :)
    Qv .= NaN
    msg = "Field(s) (a, b[1], and e.b[1]) " * post_msg
    @test_logs (:warn, msg) show_not_finite_fields(Q)

    Q .= 1
    @test show_not_finite_fields(Q) == nothing
end

@testset "MPIStateArray show_not_finite_fields - ntuple vars" begin
    post_msg = "are not finite (has NaNs or Inf)"
    Q = MPIStateArray{Float32, VNT}(mpicomm, ArrayType, 4, 10, 8)
    Q .= 1
    Qv = view(MPIStateArrays.realview(Q), :, 1:1, :)
    Qv .= NaN
    msg = "Field(s) (a) " * post_msg
    @test_logs (:warn, msg) show_not_finite_fields(Q)

    Qv = view(MPIStateArrays.realview(Q), :, 2:2, :)
    Qv .= NaN
    msg = "Field(s) (a, and e[1].b[1]) " * post_msg
    @test_logs (:warn, msg) show_not_finite_fields(Q)

    Qv = view(MPIStateArrays.realview(Q), :, 6:6, :)
    Qv .= NaN
    msg = "Field(s) (a, e[1].b[1], and e[2].b[2]) " * post_msg
    @test_logs (:warn, msg) show_not_finite_fields(Q)
end


text:
# included in runtests.jl
using Test
using WebSockets
import WebSockets:HTTP,
       base64encode,
       throwto,
       OPCODE_TEXT,
       locked_write
import Base.BufferStream
include("client_server_functions.jl")
const FURL = "ws://127.0.0.1"
const FPORT = 8092

@info "Start a server with a ws handler that is unresponsive. \nClose from client side. The " *
      " close handshake aborts after $(WebSockets.TIMEOUT_CLOSEHANDSHAKE) seconds..."
s = WebSockets.ServerWS(
    req::HTTP.Request -> HTTP.Response(200),
    (req::HTTP.Request, ws::WebSocket) -> begin
        for i=1:16
            sleep(1)
            i < 11 && println(i)
        end
        return
    end)

startserver(s, url=SURL, port=FPORT)

res = WebSockets.open((_) -> nothing, "$(FURL):$(FPORT)");
@test res.status == 101
close(s)

@info "Start a server with a ws handler that always reads guarded."
sleep(1)
s = WebSockets.ServerWS(
    req -> HTTP.Response(200),
    (req, ws_serv) -> begin
        while isopen(ws_serv)
            WebSockets.readguarded(ws_serv)
        end
    end);
startserver(s, url=SURL, port=FPORT)
sleep(1)

@info "Attempt to read guarded from a closing ws|client. Check for return false."
sleep(1)
WebSockets.open("$(FURL):$(FPORT)") do ws_client
        close(ws_client)
        data = WebSockets.readguarded(ws_client)
        @test (UInt8[], false) == data
    end;
sleep(1)

@info "Attempt to write guarded from a closing ws|client. Check for return false."
sleep(1)
WebSockets.open("$(FURL):$(FPORT)") do ws_client
    close(ws_client)
    data = WebSockets.writeguarded(ws_client, "writethis")
    @test false == data
end;
sleep(1)

@info "Attempt to read from closing ws|client. Check caught error."
sleep(1)
try
    WebSockets.open("$(FURL):$(FPORT)") do ws_client
        close(ws_client)
        read(ws_client)
    end
catch err
    @test typeof(err) <: ErrorException
    @test err.msg == "Attempt to read from closed WebSocket|client. First isopen(ws), or use readguarded(ws)!"
end
sleep(1)

@info "Attempt to write to a closing ws|client (this takes some time, there is no check
      in WebSockets against it). Check caught error."
sleep(1)
try
    WebSockets.open("$(FURL):$(FPORT)") do ws_client
        close(ws_client)
        write(ws_client, "writethis")
    end
catch err
    show(err)
     @test typeof(err) <: WebSocketClosedError
     @test err.message == " while open ws|client: stream is closed or unusable"
end

close(s)

@info "Start a server. The wshandler use global channels for inspecting caught errors."
sleep(1)
chfromserv=Channel(2)
s = WebSockets.ServerWS(
    req-> HTTP.Response(200),
    ws_serv->begin
        while isopen(ws_serv)
            try
                read(ws_serv)
            catch err
                put!(chfromserv, err)
                put!(chfromserv, stacktrace(catch_backtrace())[1:2])
            end
        end
    end);
startserver(s, url=SURL, port=FPORT)
sleep(3)

@info "Open a ws|client, close it out of protocol. Check server error on channel."
global res = WebSockets.open((ws)-> close(ws.socket), "$(FURL):$(FPORT)")
@test res.status == 101
sleep(1)
global err = take!(chfromserv)
@test typeof(err) <: WebSocketClosedError
@test err.message == " while read(ws|server) BoundsError(UInt8[], (1,))"
global stack_trace = take!(chfromserv)
if VERSION <= v"1.0.2"
    # Stack trace on master is zero. Unknown cause.
    @test length(stack_trace) == 2
end

close(s)

sleep(1)

@info "Start a server. Errors are output on built-in channel"
sleep(1)
s = WebSockets.ServerWS(
    req-> HTTP.Response(200),
    ws_serv->begin
        while isopen(ws_serv)
                read(ws_serv)
        end
    end);
startserver(s, url=SURL, port=FPORT)
sleep(3)

@info "Open a ws|client, close it out of protocol. Check server error on server.out channel."
sleep(1)
WebSockets.open((ws)-> close(ws.socket), "$(FURL):$(FPORT)");
global err = take!(s.out)
@test typeof(err) <: WebSocketClosedError
@test err.message == " while read(ws|server) BoundsError(UInt8[], (1,))"
sleep(1)
global stack_trace = take!(s.out);
if VERSION <= v"1.0.2"
    # Stack trace on master is zero. Unknown cause.
    @test length(stack_trace) in [5, 6]
end

while isready(s.out)
    take!(s.out)
end

close(s)
startserver(s, url=SURL, port=FPORT)
sleep(3)

@info "Open ws|clients, close using every status code from RFC 6455 7.4.1\n" *
      "  Verify error messages on server.out reflect the codes."
sleep(1)
for (ke, va) in WebSockets.codeDesc
    @info "Closing ws|client with reason ", ke, " ", va
    sleep(0.3)
    WebSockets.open((ws)-> close(ws, statusnumber = ke), "$(FURL):$(FPORT)")
    wait(s.out)
    global err = take!(s.out)
    @test typeof(err) <: WebSocketClosedError
    @test err.message == "ws|server respond to OPCODE_CLOSE $ke:$va"
    wait(s.out)
    stacktra = take!(s.out)
    if VERSION <= v"1.0.2"
        # Unknown cause, nighly behaves differently
        @test length(stacktra) == 0
    end
    while isready(s.out)
        take!(s.out)
    end
    sleep(1)
end

@info "Open a ws|client, close it using a status code from RFC 6455 7.4.1\n" *
      " and also a custom reason string. Verify error messages on server.out reflect the codes."

sleep(1)
global va = 1000
@info "Closing ws|client with reason", va, " ", WebSockets.codeDesc[va], " and goodbye!"
WebSockets.open((ws)-> close(ws, statusnumber = va, freereason = "goodbye!"), "$(FURL):$(FPORT)")
wait(s.out)
global err = take!(s.out)
@test typeof(err) <: WebSocketClosedError
@test err.message == "ws|server respond to OPCODE_CLOSE 1000:goodbye!"
global stack_trace = take!(s.out)
sleep(1)

@info "Open a ws|client. Throw an InterruptException to it. Check that the ws|server\n " *
    "error shows the reason for the close."
sleep(1)
function selfinterruptinghandler(ws)
    task = @async WebSockets.open((ws)-> read(ws), "$(FURL):$(FPORT)")
    sleep(3)
    @async Base.throwto(task, InterruptException())
    sleep(1)
    nothing
end
WebSockets.open(selfinterruptinghandler, "$(FURL):$(FPORT)")
sleep(6)
global err = take!(s.out)
@test typeof(err) <: WebSocketClosedError
@test err.message == "ws|server respond to OPCODE_CLOSE 1006: while read(ws|client received InterruptException."
global stack_trace = take!(s.out)

close(s)

@info "Trigger check_upgrade WebSocketErrors "
let noupgrade, noconnectionupgrade, key
    key = base64encode(rand(UInt8, 16))
    noupgrade = WebSockets.Request("GET", "/", [
                    "Connection" => "Upgrade",
                    "Sec-WebSocket-Key" => key,
                    "Sec-WebSocket-Version" => "13"
                ])
    @test_throws WebSockets.WebSocketError WebSockets.check_upgrade(noupgrade)
    noconnectionupgrade = WebSockets.Request("GET", "/", [
                        "Upgrade" => "websocket",
                        "Sec-WebSocket-Key" => key,
                        "Sec-WebSocket-Version" => "13"
                ])
    @test_throws WebSockets.WebSocketError WebSockets.check_upgrade(noconnectionupgrade)
end

sleep(2)