Plots function

        :param func: function to plot
        :param mins: minimum of values (x, y ...)
        :param maxs: maximum of values (x, y ...)
        :param precision: precision to plot
        :param kind: kind of plot, "slice", "countour"

def plot_type(self, func, mins, maxs, precision, kind):
        """Plots function

        :param func: function to plot
        :param mins: minimum of values (x, y ...)
        :param maxs: maximum of values (x, y ...)
        :param precision: precision to plot
        :param kind: kind of plot, "slice", "countour"
        """

        min_x, min_y, min_z = mins[0], mins[1], mins[2]
        max_x, max_y, max_z = maxs[0], maxs[1], maxs[2]

        def set_labels(graph, label_x, label_y, label_z):
            """Sets given labels to axes of graph

            :param graph: plot
            :param label_x: new label on x axis
            :param label_y: new label on y axis
            :param label_z: new label on z axis
            """
            graph.set_xlabel(label_x)
            graph.set_ylabel(label_y)
            graph.set_zlabel(label_z)

        def set_limits(graph):
            """Set chart limits to axes of graph

            :param graph: plot
            """
            graph.set_xlim(min_x, max_x)
            graph.set_ylim(min_y, max_y)
            graph.set_zlim(min_z, max_z)

        def get_precision(min_val, max_val):
            """Calculates precision

            :param min_val: minimum
            :param max_val: maximum
            :return: precision: prevision of values
            """
            return int((max_val - min_val) * (1 + precision))

        def get_precision_delta(min_val, max_val):
            """Calculates precision delta

            :param min_val: minimum
            :param max_val: maximum
            :return: delta: Precision delta
            """
            return float(max_val - min_val) / float(10 * precision)

        def plot_slice():
            """ Plots slice

            :return: shows plot
            """
            chart = plt.axes(projection="3d")  # general settings
            points_x = get_precision(min_x, max_x)
            points_y = get_precision(min_y, max_z)

            x_axis = numpy.outer(linspace(min_x, max_x, points_x), points_x)
            y_axis = numpy.outer(
                linspace(min_y, max_y, points_y).flatten(), points_y
            ).T

            def update(val):
                """Updates chart with value

                :param val: value
                """
                chart.clear()
                x_const = slider.val
                z_axis = func(x_const, x_axis, y_axis)
                chart.plot_surface(
                    x_axis, y_axis, z_axis, alpha=0.3, linewidth=2.0
                )
                set_labels(chart, "y", "z", "w")

            # slider
            axis_slider = plt.axes([0.12, 0.03, 0.78, 0.03], axisbg="white")
            slider = Slider(axis_slider, "x", min_x, max_x, valinit=min_x)

            slider.on_changed(update)
            set_limits(chart)
            self.show_plot()

            slider.on_changed(update)
            set_labels(chart, "y", "z", "w")

        def plot_countour():
            """Plots countour
            """
            # general settings
            fig = plt.figure()
            chart = fig.gca(projection="3d")

            # create axes
            x_axis = numpy.arange(min_x, max_x, get_precision_delta(
                min_x, max_x)).tolist()
            y_axis = numpy.arange(min_y, max_y, get_precision_delta(
                min_y, max_y)).tolist()
            x_axis, y_axis = numpy.meshgrid(x_axis, y_axis)

            def update(val):
                """Updates chart with value

                :param val: value
                """
                chart.clear()  # re-plot
                x_const = slider.val
                z_axis = []

                # add new points
                for i, _ in enumerate(x_axis):
                    z_axis.append(func(x_const, x_axis[i], y_axis[i]))

                # show
                chart.contour(
                    x_axis, y_axis, z_axis, zdir="x", offset=min_x
                )
                chart.contour(
                    x_axis, y_axis, z_axis, zdir="y", offset=min_y
                )
                chart.contour(
                    x_axis, y_axis, z_axis, zdir="z", offset=min_z
                )
                chart.contour(x_axis, y_axis, z_axis, extend3d=True)
                set_labels(chart, "y", "z", "w")

            # slider
            axis_slider = plt.axes([0.12, 0.03, 0.78, 0.03], axisbg="white")
            slider = Slider(axis_slider, "x", min_x, max_x, valinit=min_x)

            slider.on_changed(update)
            set_limits(chart)

        if kind == "slice":
            plot_slice()
        elif kind == "countour":
            plot_countour()

        self.show_plot()