def export(self, class_name, method_name, export_data=False,
               export_dir='.', export_filename='data.json',
               export_append_checksum=False, **kwargs):
        """
        Port a trained estimator to the syntax of a chosen programming language.

        Parameters
        ----------
        :param class_name : string
            The name of the class in the returned result.
        :param method_name : string
            The name of the method in the returned result.
        :param export_data : bool, default: False
            Whether the model data should be saved or not.
        :param export_dir : string, default: '.' (current directory)
            The directory where the model data should be saved.
        :param export_filename : string, default: 'data.json'
            The filename of the exported model data.
        :param export_append_checksum : bool, default: False
            Whether to append the checksum to the filename or not.

        Returns
        -------
        :return : string
            The transpiled algorithm with the defined placeholders.
        """
        # Arguments:
        self.class_name = class_name
        self.method_name = method_name

        # Templates of primitive data types:
        temp_type = self.temp('type')
        temp_arr = self.temp('arr')
        temp_arr_ = self.temp('arr[]')
        temp_arr__ = self.temp('arr[][]')

        # Estimator:
        est = self.estimator
        self.params = est.get_params()

        # Check kernel type:
        supported_kernels = ['linear', 'rbf', 'poly', 'sigmoid']
        if self.params['kernel'] not in supported_kernels:
            msg = 'The kernel type is not supported.'
            raise ValueError(msg)

        self.n_features = len(est.support_vectors_[0])
        self.svs_rows = est.n_support_
        self.n_svs_rows = len(est.n_support_)

        self.weights = self.temp('arr[]', skipping=True).format(
            type='int', name='weights', values=', '.join([str(e) for e in
                                                          self.svs_rows]),
            n=len(self.svs_rows))
        self.n_weights = len(self.svs_rows)

        self.n_classes = len(est.classes_)
        self.is_binary = self.n_classes == 2
        self.prefix = 'binary' if self.is_binary else 'multi'

        # Support vectors:
        vectors = []
        for vector in est.support_vectors_:
            _vectors = [temp_type.format(self.repr(v)) for v in vector]
            _vectors = temp_arr.format(', '.join(_vectors))
            vectors.append(_vectors)
        vectors = ', '.join(vectors)
        vectors = self.temp('arr[][]', skipping=True).format(
            type='double', name='vectors', values=vectors,
            n=len(est.support_vectors_), m=len(est.support_vectors_[0]))
        self.vectors = vectors
        self.n_vectors = len(est.support_vectors_)

        # Coefficients:
        coeffs = []
        for coeff in est.dual_coef_:
            _coeffs = [temp_type.format(self.repr(c)) for c in coeff]
            _coeffs = temp_arr.format(', '.join(_coeffs))
            coeffs.append(_coeffs)
        coeffs = ', '.join(coeffs)
        coeffs = temp_arr__.format(type='double', name='coefficients',
                                   values=coeffs, n=len(est.dual_coef_),
                                   m=len(est.dual_coef_[0]))
        self.coefficients = coeffs
        self.n_coefficients = len(est.dual_coef_)

        # Interceptions:
        inters = [temp_type.format(self.repr(i)) for i in est._intercept_]
        inters = ', '.join(inters)
        inters = temp_arr_.format(type='double', name='intercepts',
                                  values=inters, n=len(est._intercept_))
        self.intercepts = inters
        self.n_intercepts = len(est._intercept_)

        # Kernel:
        self.kernel = str(self.params['kernel'])
        if self.target_language == 'c':
            self.kernel = self.kernel[0]

        # Gamma:
        self.gamma = self.params['gamma']
        if self.gamma == 'auto':
            self.gamma = 1. / self.n_features
        self.gamma = self.repr(self.gamma)

        # Coefficient and degree:
        self.coef0 = self.repr(self.params['coef0'])
        self.degree = self.repr(self.params['degree'])

        if self.target_method == 'predict':
            # Exported:
            if export_data and os.path.isdir(export_dir):
                self.export_data(export_dir, export_filename,
                                 export_append_checksum)
                return self.predict('exported')
            # Separated:
            return self.predict('separated')
Port a trained estimator to the syntax of a chosen programming language.

        Parameters
        ----------
        :param class_name : string
            The name of the class in the returned result.
        :param method_name : string
            The name of the method in the returned result.
        :param export_data : bool, default: False
            Whether the model data should be saved or not.
        :param export_dir : string, default: '.' (current directory)
            The directory where the model data should be saved.
        :param export_filename : string, default: 'data.json'
            The filename of the exported model data.
        :param export_append_checksum : bool, default: False
            Whether to append the checksum to the filename or not.

        Returns
        -------
        :return : string
            The transpiled algorithm with the defined placeholders.