图表¶

def get_bar_labels(
    self,
    color: ParsableManimColor | None = None,
    font_size: float = 24,
    buff: float = MED_SMALL_BUFF,
    label_constructor: type[ManimTextLabel] = Tex,
) -> VGroup:
    """制作条值的标签：每个在其条上方（负值在下方），采用条的颜色，除非给出其他颜色。

    Args:
        color: 标签的颜色；None 表示每个条的填充颜色。
        font_size: 它们的字号。
        buff: 每个条与其标签之间的间距，以场景单位计。
        label_constructor: 它们的排版类：[Tex][manimgx.Tex]、[MathTex][manimgx.MathTex]、…。

    Returns:
        标签的新组，从左到右，未添加到图表。

    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:
    """改变条的值：每个条从 x 轴拉伸到其新高度，若值变号则跨到另一侧。

    y 轴保持不变，之前制作的标签不跟随；要为变化制作动画，用 `.animate`。

    Args:
        values: 新值，从左到右；少于条数则仅改变前几个。
        update_colors: 是否再次沿图表的渐变为条着色（从值为 0 重建的条需要它）。

    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:
    """制作沿某维度划分样本空间的部分，每个概率一个，每个为其那个分数。

    部分在 `vect` 方向上一个接一个，从空间与之相对的边起；它们沿 `colors` 的渐变着色，每个本身是一个样本空间。

    Args:
        p_list: 概率：若其和小于 1，为余数添加一个部分。
        dim: 被划分的维度：0 为宽度，1 为高度。
        colors: 颜色，部分上的渐变。
        vect: 部分一个接一个的方向。

    Returns:
        部分的新组，未添加到空间。
    """
    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:
    """制作划分样本空间的垂直条，每个概率一个，从左到右（参见 [get_division_along_dimension][manimgx.SampleSpace.get_division_along_dimension]）。

    Args:
        p_list: 概率，补全至和为 1。
        colors: 颜色，条上的渐变。
        vect: 条一个接一个的方向：RIGHT，从左起。

    Returns:
        条的新组，未添加到空间。
    """
    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:
    """将样本空间分为垂直条，每个概率一个，从左到右：每个为其宽度的那个分数。

    概率补全至和为 1。条添加到空间，作为一个组，并保留为其 `vertical_parts`。

    Args:
        p_list: 一个概率，或多个概率。
        colors: 条的颜色：其上的渐变。
        vect: 条一个接一个的方向：RIGHT，从左起。

    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