PartitionNumbers

The integer partition counts $p(n) = 1, 1, 2, 3, 5, 7, …$ as a lazy indexed collection.

OEISA000041↗

PartitionNumbers$p(n)$, the number of integer partitions of $n$, an infinite indexed collection.

Domain: Collections

Details

• A lazy indexed collection: $Count(PartitionNumbers) = +\infty$, and $At(PartitionNumbers, k)$ unranks $p(k-1)$ via Euler's pentagonal-number recurrence, bigint throughout -- $At(PartitionNumbers, 1) = p(0) = 1$.
• OEIS A000041, starting exactly at its offset-0 term: $1, 1, 2, 3, 5, 7, 11, 15, …$.
• Membership goes through Element: $Element(11, PartitionNumbers)$ is true, $Element(9, PartitionNumbers)$ is false. See IntegerPartitions for the partitions themselves, not just their count.

Definition

Epsil, as the implementation runs it.

count()

PositiveInfinity

unrank(_r)

Apply((hs_l: integer) => Apply((hs_n: integer) => Fold(
                                                        Function(hs_t if False else Join(
                                                                                          hs_t,
                                                                                          [Fold(
                                                                                                 Function(pt_a +
                                                                                                          (2 *
                                                                                                           (pt_k % 2) -
                                                                                                           1) *
                                                                                                          ((hs_t[hs_m -
                                                                                                                 pt_k *
                                                                                                                 (3pt_k - 1) /
                                                                                                                 2 +
                                                                                                                 1] if pt_k *
                                                                                                                      (3pt_k - 1) /
                                                                                                                      2 <=
                                                                                                                      hs_m else 0) +
                                                                                                           (hs_t[hs_m -
                                                                                                                 pt_k *
                                                                                                                 (3pt_k + 1) /
                                                                                                                 2 +
                                                                                                                 1] if pt_k *
                                                                                                                      (3pt_k + 1) /
                                                                                                                      2 <=
                                                                                                                      hs_m else 0)), pt_a, pt_k),
                                                                                                 0,
                                                                                                 Range(1, hs_n, 1),
                                                                                               )],
                                                                                        ), hs_t, hs_m),
                                                        [1],
                                                        Range(1, hs_l, 1),
                                                      ), (1 + Floor(Sqrt(24hs_l +
                                                                        1)) - (1 +
                                                                              Floor(Sqrt(24hs_l + 1))) %
                                                                             6) /
                                                        6), _r)[_r + 1]

rank(_x)

Apply(
       (hs_b: integer) => Apply(
                                 (hs_all: list<integer>) => Fold(
                                                                  Function(
                                                                            (hs_i if hs_p < 0 &&
                                                                                     hs_all[hs_i + 1] ==
                                                                                     _x else hs_p) if hs_i < Length(hs_all) else hs_p,
                                                                            hs_p,
                                                                            hs_i,
                                                                          ),
                                                                  -1,
                                                                  Range(
                                                                         0,
                                                                         hs_b,
                                                                         1,
                                                                       ),
                                                                ),
                                 Apply((hs_l: integer) => Apply(
                                                                 (hs_n: integer) => Fold(
                                                                                          Function(hs_t if hs_t[Length(hs_t)] > _x else Join(
                                                                                                                                              hs_t,
                                                                                                                                              [Fold(Function(pt_a +
                                                                                                                                                             (2 *
                                                                                                                                                              (pt_k % 2) -
                                                                                                                                                              1) *
                                                                                                                                                             ((hs_t[hs_m -
                                                                                                                                                                    pt_k *
                                                                                                                                                                    (3pt_k - 1) /
                                                                                                                                                                    2 +
                                                                                                                                                                    1] if pt_k *
                                                                                                                                                                         (3pt_k - 1) /
                                                                                                                                                                         2 <=
                                                                                                                                                                         hs_m else 0) +
                                                                                                                                                              (hs_t[hs_m -
                                                                                                                                                                    pt_k *
                                                                                                                                                                    (3pt_k + 1) /
                                                                                                                                                                    2 +
                                                                                                                                                                    1] if pt_k *
                                                                                                                                                                         (3pt_k + 1) /
                                                                                                                                                                         2 <=
                                                                                                                                                                         hs_m else 0)), pt_a, pt_k), 0, Range(1, hs_n, 1))],
                                                                                                                                            ), hs_t, hs_m),
                                                                                          [1],
                                                                                          Range(1, hs_l, 1),
                                                                                        ),
                                                                 (1 +
                                                                  Floor(Sqrt(24hs_l +
                                                                             1)) - (1 +
                                                                      Floor(Sqrt(24hs_l + 1))) % 6) / 6,
                                                               ), hs_b),
                               ),
       ((Apply(
                (fl_r: list<integer>) => fl_r[2],
                Fold(
                      Function([
                                 (fl_s[1] - fl_s[1] % 2 ^ fl_k) / 2 ^ fl_k,
                                 fl_s[2] + fl_k,
                               ] if fl_s[1] >= 2 ^ fl_k else fl_s, fl_s, fl_k),
                      [_x + 2, 0],
                      [
                        8_192,
                        4_096,
                        2_048,
                        1_024,
                        512,
                        256,
                        128,
                        64,
                        32,
                        16,
                        8,
                        4,
                        2,
                        1,
                      ],
                    ),
              ) + 4) * (Apply(
                              (fl_r: list<integer>) => fl_r[2],
                              Fold(Function(
                                             [
                                               (fl_s[1] - fl_s[1] % 2 ^ fl_k) /
                                               2 ^ fl_k,
                                               fl_s[2] + fl_k,
                                             ] if fl_s[1] >= 2 ^ fl_k else fl_s,
                                             fl_s,
                                             fl_k,
                                           ), [_x + 2, 0], [
                                                            8_192,
                                                            4_096,
                                                            2_048,
                                                            1_024,
                                                            512,
                                                            256,
                                                            128,
                                                            64,
                                                            32,
                                                            16,
                                                            8,
                                                            4,
                                                            2,
                                                            1,
                                                          ]),
                            ) + 4) - (Apply(
                                            (fl_r: list<integer>) => fl_r[2],
                                            Fold(Function(
                                                           [
                                                             (fl_s[1] - fl_s[1] %
                                                                        2 ^ fl_k) / 2 ^
                                                                            fl_k,
                                                             fl_s[2] + fl_k,
                                                           ] if fl_s[1] >= 2 ^
                                                                          fl_k else fl_s,
                                                           fl_s,
                                                           fl_k,
                                                         ), [_x + 2, 0], [
                                                                          8_192,
                                                                          4_096,
                                                                          2_048,
                                                                          1_024,
                                                                          512,
                                                                          256,
                                                                          128,
                                                                          64,
                                                                          32,
                                                                          16,
                                                                          8,
                                                                          4,
                                                                          2,
                                                                          1,
                                                                        ]),
                                          ) + 4) * (Apply(
                                                          (fl_r: list<integer>) => fl_r[2],
                                                          Fold(Function(
                                                                         [
                                                                           (fl_s[1] -
                                                                            fl_s[1] %
                                                                            2 ^
                                                                            fl_k) /
                                                                           2 ^
                                                                           fl_k,
                                                                           fl_s[2] +
                                                                           fl_k,
                                                                         ] if fl_s[1] >=
                                                                             2 ^
                                                                             fl_k else fl_s,
                                                                         fl_s,
                                                                         fl_k,
                                                                       ), [
                                                                           _x +
                                                                           2,
                                                                           0,
                                                                         ], [
                                                                             8_192,
                                                                             4_096,
                                                                             2_048,
                                                                             1_024,
                                                                             512,
                                                                             256,
                                                                             128,
                                                                             64,
                                                                             32,
                                                                             16,
                                                                             8,
                                                                             4,
                                                                             2,
                                                                             1,
                                                                           ]),
                                                        ) + 4) % 8) / 8 + 12,
     ) if _x >= 0 else -1

valid(_x)

Apply(
       (hs_b: integer) => Apply(
                                 (hs_all: list<integer>) => Fold(
                                                                  Function(
                                                                            (hs_i if hs_p < 0 &&
                                                                                     hs_all[hs_i + 1] ==
                                                                                     _x else hs_p) if hs_i < Length(hs_all) else hs_p,
                                                                            hs_p,
                                                                            hs_i,
                                                                          ),
                                                                  -1,
                                                                  Range(
                                                                         0,
                                                                         hs_b,
                                                                         1,
                                                                       ),
                                                                ),
                                 Apply((hs_l: integer) => Apply(
                                                                 (hs_n: integer) => Fold(
                                                                                          Function(hs_t if hs_t[Length(hs_t)] > _x else Join(
                                                                                                                                              hs_t,
                                                                                                                                              [Fold(Function(pt_a +
                                                                                                                                                             (2 *
                                                                                                                                                              (pt_k % 2) -
                                                                                                                                                              1) *
                                                                                                                                                             ((hs_t[hs_m -
                                                                                                                                                                    pt_k *
                                                                                                                                                                    (3pt_k - 1) /
                                                                                                                                                                    2 +
                                                                                                                                                                    1] if pt_k *
                                                                                                                                                                         (3pt_k - 1) /
                                                                                                                                                                         2 <=
                                                                                                                                                                         hs_m else 0) +
                                                                                                                                                              (hs_t[hs_m -
                                                                                                                                                                    pt_k *
                                                                                                                                                                    (3pt_k + 1) /
                                                                                                                                                                    2 +
                                                                                                                                                                    1] if pt_k *
                                                                                                                                                                         (3pt_k + 1) /
                                                                                                                                                                         2 <=
                                                                                                                                                                         hs_m else 0)), pt_a, pt_k), 0, Range(1, hs_n, 1))],
                                                                                                                                            ), hs_t, hs_m),
                                                                                          [1],
                                                                                          Range(1, hs_l, 1),
                                                                                        ),
                                                                 (1 +
                                                                  Floor(Sqrt(24hs_l +
                                                                             1)) - (1 +
                                                                      Floor(Sqrt(24hs_l + 1))) % 6) / 6,
                                                               ), hs_b),
                               ),
       ((Apply(
                (fl_r: list<integer>) => fl_r[2],
                Fold(
                      Function([
                                 (fl_s[1] - fl_s[1] % 2 ^ fl_k) / 2 ^ fl_k,
                                 fl_s[2] + fl_k,
                               ] if fl_s[1] >= 2 ^ fl_k else fl_s, fl_s, fl_k),
                      [_x + 2, 0],
                      [
                        8_192,
                        4_096,
                        2_048,
                        1_024,
                        512,
                        256,
                        128,
                        64,
                        32,
                        16,
                        8,
                        4,
                        2,
                        1,
                      ],
                    ),
              ) + 4) * (Apply(
                              (fl_r: list<integer>) => fl_r[2],
                              Fold(Function(
                                             [
                                               (fl_s[1] - fl_s[1] % 2 ^ fl_k) /
                                               2 ^ fl_k,
                                               fl_s[2] + fl_k,
                                             ] if fl_s[1] >= 2 ^ fl_k else fl_s,
                                             fl_s,
                                             fl_k,
                                           ), [_x + 2, 0], [
                                                            8_192,
                                                            4_096,
                                                            2_048,
                                                            1_024,
                                                            512,
                                                            256,
                                                            128,
                                                            64,
                                                            32,
                                                            16,
                                                            8,
                                                            4,
                                                            2,
                                                            1,
                                                          ]),
                            ) + 4) - (Apply(
                                            (fl_r: list<integer>) => fl_r[2],
                                            Fold(Function(
                                                           [
                                                             (fl_s[1] - fl_s[1] %
                                                                        2 ^ fl_k) / 2 ^
                                                                            fl_k,
                                                             fl_s[2] + fl_k,
                                                           ] if fl_s[1] >= 2 ^
                                                                          fl_k else fl_s,
                                                           fl_s,
                                                           fl_k,
                                                         ), [_x + 2, 0], [
                                                                          8_192,
                                                                          4_096,
                                                                          2_048,
                                                                          1_024,
                                                                          512,
                                                                          256,
                                                                          128,
                                                                          64,
                                                                          32,
                                                                          16,
                                                                          8,
                                                                          4,
                                                                          2,
                                                                          1,
                                                                        ]),
                                          ) + 4) * (Apply(
                                                          (fl_r: list<integer>) => fl_r[2],
                                                          Fold(Function(
                                                                         [
                                                                           (fl_s[1] -
                                                                            fl_s[1] %
                                                                            2 ^
                                                                            fl_k) /
                                                                           2 ^
                                                                           fl_k,
                                                                           fl_s[2] +
                                                                           fl_k,
                                                                         ] if fl_s[1] >=
                                                                             2 ^
                                                                             fl_k else fl_s,
                                                                         fl_s,
                                                                         fl_k,
                                                                       ), [
                                                                           _x +
                                                                           2,
                                                                           0,
                                                                         ], [
                                                                             8_192,
                                                                             4_096,
                                                                             2_048,
                                                                             1_024,
                                                                             512,
                                                                             256,
                                                                             128,
                                                                             64,
                                                                             32,
                                                                             16,
                                                                             8,
                                                                             4,
                                                                             2,
                                                                             1,
                                                                           ]),
                                                        ) + 4) % 8) / 8 + 12,
     ) >= 0 if _x >= 0 else False

Enumeration

Examples

1 more kept as data, checked against the oracles

About

Examples	1
Crosswalk	OEIS

See also: Count, At, Element, IntegerPartitions, BellNumbers