Charts¶

def get_bar_labels(
    self,
    color: ParsableManimColor | None = None,
    font_size: float = 24,
    buff: float = MED_SMALL_BUFF,
    label_constructor: type[ManimTextLabel] = Tex,
) -> VGroup:
    """Make labels of the bars' values: each above its bar (below it, for a
    negative value), in the bar's color unless given another.

    Args:
        color: The labels' color; None for each bar's fill color.
        font_size: Their font size.
        buff: The gap between each bar and its label, in scene units.
        label_constructor: The class they are typeset with: [Tex][manimgx.Tex],
            [MathTex][manimgx.MathTex], ….

    Returns:
        A new group of the labels, from left to right, not added to the chart.

    Examples:
        ```python
        import manimgx as m


        class BarChartGetBarLabelsExample(m.Scene):
            def construct(self) -> None:
                chart = m.BarChart(
                    values=[9, 7, 4, 3, 1],
                    y_range=[0, 10, 2],
                    x_length=10,
                    y_length=5,
                    bar_colors=[m.BLUE, m.GREEN, m.YELLOW],
                )
                self.add(chart, chart.get_bar_labels(font_size=40))
        ```
    """
    bar_labels = VGroup()
    for bar, value in zip(self.bars, self.values, strict=False):
        bar_lbl = label_constructor(str(value))
        if color is None:
            bar_lbl.set_color(bar.get_fill_color())
        else:
            bar_lbl.set_color(color)
        bar_lbl.font_size = font_size
        pos = UP if value >= 0 else DOWN
        bar_lbl.next_to(bar, pos, buff=buff)
        bar_labels.add(bar_lbl)
    return bar_labels

def change_bar_values(
    self, values: Iterable[float], update_colors: bool = True
) -> Self:
    """Change the bars' values: each bar is stretched to its new height from the
    x-axis, crossing to its other side if the value changes sign.

    The y-axis stays as it is, and labels made before do not follow; to animate the
    change, use `.animate`.

    Args:
        values: The new values, from left to right; fewer than the bars change the
            first ones only.
        update_colors: Whether to color the bars along the chart's gradient again (a
            bar remade from a value of 0 needs it).

    Examples:
        ```python
        import manimgx as m


        class BarChartChangeBarValuesExample(m.Scene):
            def construct(self) -> None:
                chart = m.BarChart(
                    values=[4, 8, 2, 6], y_range=[-4, 8, 2], x_length=9, y_length=6
                )
                self.add(chart)
                self.play(chart.animate.change_bar_values([7, -3, 5, 1]))
        ```
    """
    values = list(values)
    # the bars as they are: a bar remade below takes its place in `self.bars`
    for i, (bar, value) in enumerate(zip(list(self.bars), values, strict=False)):
        chart_val = self.values[i]
        if chart_val == 0:  # a bar of no height has no side to grow from: remade
            self.bars.remove(bar)
            self.bars.insert(i, self._create_bar(i, value))
            continue
        bar_lim, aligned_edge = (
            (bar.get_bottom(), DOWN) if chart_val > 0 else (bar.get_top(), UP)
        )
        quotient = value / chart_val
        if quotient < 0:
            aligned_edge = UP if chart_val > 0 else DOWN
        bar.stretch_to_fit_height(abs(quotient) * bar.height)
        bar.move_to(bar_lim, aligned_edge)
    if update_colors:
        self._update_colors()
    self.values[: len(values)] = values
    return self

def get_division_along_dimension(
    self,
    p_list: float | Iterable[float],
    dim: int,
    colors: Sequence[ParsableManimColor],
    vect: Vector3D,
) -> VGroup:
    """Make the parts that divide the sample space along a dimension, one per
    probability, each that fraction of it.

    The parts follow one another in the direction `vect`, from the space's edge
    opposite it; they are colored along a gradient of `colors`, and each is a sample
    space itself.

    Args:
        p_list: The probabilities: a part is added for the rest, if they sum to less
            than 1.
        dim: The dimension divided: 0 for the width, 1 for the height.
        colors: The colors, a gradient over the parts.
        vect: The direction the parts follow one another in.

    Returns:
        A new group of the parts, not added to the space.
    """
    p_list_complete = self.complete_p_list(p_list)
    last_point = self.get_critical_point(-vect)
    parts = VGroup()
    for factor, color in zip(
        p_list_complete, color_gradient(colors, len(p_list_complete)), strict=True
    ):
        part = SampleSpace()
        part.set_fill(color, 1)
        part.replace(self, stretch=True)
        part.stretch(factor, dim)
        part.move_to(last_point, -vect)
        last_point = part.get_critical_point(vect)
        parts.add(part)
    return parts

def get_vertical_division(
    self,
    p_list: float | Iterable[float],
    colors: Sequence[ParsableManimColor] = (MAROON_B, YELLOW),
    vect: Vector3D = RIGHT,
) -> VGroup:
    """Make vertical strips that divide the sample space, one per probability, from
    left to right (see
    [get_division_along_dimension][manimgx.SampleSpace.get_division_along_dimension]).

    Args:
        p_list: The probabilities, completed to sum to 1.
        colors: The colors, a gradient over the strips.
        vect: The direction the strips follow one another in: RIGHT, from the left.

    Returns:
        A new group of the strips, not added to the space.
    """
    return self.get_division_along_dimension(p_list, 0, colors, vect)

def divide_vertically(
    self,
    p_list: float | Iterable[float],
    colors: Sequence[ParsableManimColor] = (MAROON_B, YELLOW),
    vect: Vector3D = RIGHT,
) -> Self:
    """Divide the sample space into vertical strips, one per probability, from left
    to right: each is that fraction of its width.

    The probabilities are completed to sum to 1. The strips are added to the space,
    as one group, and kept as its `vertical_parts`.

    Args:
        p_list: A probability, or probabilities.
        colors: The strips' colors: a gradient over them.
        vect: The direction the strips follow one another in: RIGHT, from the left.

    Examples:
        ```python
        import manimgx as m


        class SampleSpaceDivideVerticallyExample(m.Scene):
            def construct(self) -> None:
                space = m.SampleSpace(width=9, height=4)
                space.divide_vertically([0.25, 0.25], colors=[m.RED_E, m.GOLD_E])
                parts = space.vertical_parts
                labels = [m.Text(n).move_to(p) for n, p in zip("ABC", parts)]
                self.add(space, *labels)
        ```
    """
    self.vertical_parts = self.get_vertical_division(p_list, colors, vect)
    self.add(self.vertical_parts)
    return self