# DualVector: Unsupervised Vector Font Synthesis with Dual-Part Representation

Ying-Tian Liu1 Zhifei Zhang2 Yuan-Chen Guo1 Matthew Fisher2
Zhaowen Wang2 Song-Hai Zhang1∗
1 BNRist, Department of Computer Science and Technology, Tsinghua University 2
Adobe Research
<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>
{zzhang, matfishe<EMAIL_ADDRESS>
###### Abstract

Automatic generation of fonts can be an important aid to typeface design. Many
current approaches regard glyphs as pixelated images, which present artifacts
when scaling and inevitable quality losses after vectorization. On the other
hand, existing vector font synthesis methods either fail to represent the
shape concisely or require vector supervision during training. To push the
quality of vector font synthesis to the next level, we propose a novel dual-
part representation for vector glyphs, where each glyph is modeled as a
collection of closed “positive” and “negative” path pairs. The glyph contour
is then obtained by boolean operations on these paths. We first learn such a
representation only from glyph images and devise a subsequent contour
refinement step to align the contour with an image representation to further
enhance details. Our method, named DualVector, outperforms state-of-the-art
methods in vector font synthesis both quantitatively and qualitatively. Our
synthesized vector fonts can be easily converted to common digital font
formats like TrueType Font for practical use. The code is released at
https://github.com/thuliu-yt16/dualvector.

Figure 1: High-quality vector fonts (copyable on electronic devices)
synthesized by DualVector (left), with smoothly-interpolated styles (right).
Both sentences are pangrams. Please zoom in for details.

##  1 Introduction

Fonts with various styles play an important role in content display and
distribution. ††∗Corresponding authorExcellent font design is time-consuming
and labor-intensive. Recent machine learning innovations have made font
generation possible, but how to automatically generate high-quality vector
fonts remains a task of practical importance in the artistic and computer
graphics and vision communities.

Benefiting from the development of image generation techniques, mainstream
font synthesis methods [12, 2, 24, 41, 42] could generate pixelated glyph
images. Despite the promising quality, images of glyphs incur aliasing
artifacts on edges when discretely sampled, and thus are not competent for
high-quality rendering or printing at arbitrary resolutions. To alleviate this
problem, some methods [7, 34] adopt coordinate-based neural networks to model
a glyph as a contiguous neural field, which have also shown great potential in
modeling 3D geometry and scenes [7, 32, 30]. Although glyphs represented by
the implicit field can be rendered at arbitrary resolutions, it is hard to
preserve details in high-frequency regions such as edges and corners, not to
mention the high computational costs as the network needs to be evaluated for
every pixel. Researchers have made much effort to directly synthesize vector
fonts [27, 33, 4, 39] in recent years, with the main difficulty lying in
finding a representation of vector graphics that can be encoded or decoded
effectively in a deep learning framework. One typical approach represents a
vector shape as a sequence of drawing commands and adopts sequence modeling
techniques such as recurrent networks and transformers. The drawbacks are
twofold: (1) Modeling command sequences can be much harder than images. There
are infinitely many command sequences that correspond to the same-looking
shape, which brings ambiguities in learning and makes it hard to construct an
effective manifold for valid glyph shapes. (2) Ground-truth drawing commands
are often required to provide sufficient supervision for high-quality modeling
and synthesis.

To overcome these challenges, we first propose a dual-part vector font
representation, where each glyph shape is the union of a fixed number of dual
parts. Each dual part is formed by the subtraction of a “positive” and a
“negative” geometric primitive. While there are many choices for the geometric
primitives [6, 8, 25], we adopt closed Bézier paths for their great
representational ability. They are also widely supported in digital font
formats which makes it easy to convert our representation to these formats for
practical use. We reduce the problem of predicting complicated drawing command
sequences to predicting multiple basic primitives. From this perspective, both
manifold learning and latent space interpolation become more feasible.

Based on the dual-part representation, we introduce DualVector, a method to
learn such a representation for high-quality font modeling and synthesis from
only glyph images without any vector supervision. A straightforward way to
achieve this is to directly optimize the parameters of the Bézier curves with
differentiable rendering techniques for vector graphics [22]. However, this
approach easily gets stuck in the local minima as valuable gradients are only
defined at shape intersections. Taking inspiration from implicit field
training for 2D and 3D shapes [6, 32, 25], we supervise the occupancy value
derived from the analytical expression of the Bézier curves and adopt an
initialization strategy based on unsigned distance field (UDF) to provide
dense gradients across the entire pixel space. For local detail fidelity, we
also train a glyph image generation model and devise a subsequent contour
refinement step to align the contour of the vector shape with that of the
image by differentiable rendering [22]. We compare our approach with state-of-
the-art methods in font modeling and generation and demonstrate the superior
quality of our vector font outputs. Our main contributions are:

  * •

A new dual-part font representation based on boolean operations of Bézier
paths, which enables efficient shape modeling and unsupervised manifold
learning.

  * •

A method named DualVector that models both the dual-part and pixelated
representation, and introduces a contour refinement step to obtain vector
fonts with richer details as well as a UDF initialization strategy for better
convergence.

  * •

DualVector achieves state-of-the-art quality in font modeling and generation,
with outputs that can be easily converted to common digital font formats.

##  2 Related Work

###  2.1 Glyph Image Generation

Benefiting from the development of image generation[16, 10, 14], either black-
white [15, 37, 12, 40] or artistic glyph image generation[41, 2, 42, 23] is
well explored in the past decade. MC-GAN[2] synthesized ornamented glyphs for
capital letters in an end-to-end manner from a small subset of the same style.
Attr2Font[38] generated visually pleasing results according to style
attributes and content references. Most of these methods follow the
disentanglement of style and content codes, and so does the image generation
branch in DualVector. But these glyph image generation efforts do not step
outside the 2D pixelated representation which sets an upper bound for
rendering quality, efficiency, and practicality.

###  2.2 Image Rasterization and Vectorization

Rasterization and vectorization are dual problems in image processing.
Previous efforts on rasterization have typically focused on anti-aliasing[9,
11, 31] and high-performance rendering on modern graphics hardware[26, 17, 3,
21]. Traditional image vectorization approaches rely on region segmentation,
line extraction, and contour tracing for gray-scale images[35], pixel
arts[18], animations[44] and general images[36, 19, 5, 1, 45, 46]. Recently,
researchers have turned to bridging the raster and vector domains [22, 29],
enabling existing well-established algorithms for raster images to be also
applied to vector representations. DiffVG [22] is a differentiable rendering
technique for vector graphics enabling the optimization of vector primitive
parameters based on raster criteria. In our work, it is employed to align the
vector and pixel representation in the contour refinement step.

\begin{overpic}[scale={0.55}]{figure/method.pdf} \put(2.8,75.0){$z$}
\put(63.0,175.0){\scalebox{1.5}{$\mathcal{D}_{P}$}}
\put(63.0,59.0){\scalebox{1.5}{$\mathcal{D}_{I}$}}
\put(115.0,15.0){Reconstructed Image $\mathcal{I}$}
\put(220.0,60.0){$\mathcal{L}_{I}$} \put(455.0,175.0){$\mathcal{L}_{P}$}
\put(295.0,25.0){Initialization $\partial{\mathcal{O}}$}
\put(400.0,25.0){Vector Output} \put(115.0,126.0){Dual Parts
$\\{(P_{i},Q_{i})\\}_{i=1}^{N}$}
\put(272.0,126.0){$\\{P_{i}-Q_{i}\\}_{i=1}^{N}$}
\put(385.0,126.0){$\mathcal{O}/\hat{\mathcal{O}}$}
\put(354.0,65.0){$\mathcal{L}_{refine}$} \put(42.0,215.0){(a) {Vector Branch}}
\put(274.0,96.0){(c) {Contour Refinement}} \put(42.0,96.0){(b) {Image Branch}}
\put(229.0,180.0){\small Subtract} \put(337.0,180.0){\small Union}
\put(145.0,200.0){$P_{1}$} \put(181.0,200.0){$Q_{1}$}
\put(145.0,162.0){$P_{2}$} \put(181.0,162.0){$Q_{2}$} \end{overpic}

Figure 2: DualVector contains the following components: (a) a vector branch
that maps the latent code $z$ to several closed Bézier paths which are further
gathered to form a global shape of the glyph; (b) an image branch that
generates pixelated images with faithful details; (c) a contour refinement
step that obtains the contour via boolean operations on dual-parts and
optimizes it with the image guidance at inference time. Both the vector and
the image branch are trained using the glyph images. Dual parts are
distinguished by their colors.

###  2.3 Vector Font Generation

SVG-VAE [27] was the first attempt to build a sequential generative model on
SVG fonts. DeepSVG [4] developed a hierarchical transformer-based generative
model for complex SVG icons generation and interpolation.Exploiting implicit
neural representation, multi-implicits [34] modeled fonts with a permutation-
invariant set of learned implicit functions which can preserve font features,
such as smooth edges and sharp corners, and generate good interpolation
results. Liu _et al_. [25] proposed a primitive-based representation, which
views glyph shapes as the combination of primitives enclosed by implicit
curves. Implicit representation-based methods can convert the zero-level set
of their output fields to contour representation with the 2D marching cube
[28] algorithm, although it produces multiple segmented lines and lacks
accuracy and efficiency in rendering and editing. Im2Vec[33] can synthesize
complex vector graphics with varying topologies without vector supervision. It
rendered layered Bézier paths predicted from image features using DiffVG[22]
and trains the system in an auto-encoding manner. DeepVecFont[39] adopted a
dual-modality learning framework that utilizes both sequence and image
features for high-quality vector font synthesis. But the results it produces
may have the wrong topology, including self-intersection or invalid paths. In
contrast to these methods, our approach does not require vector supervision
and is very efficient in vector representation, with high quality glyph
generation.

##  3 DualVector

In this section, we first illustrate the proposed dual-part representation for
fonts (Sec. 3.1) and then introduce the components of DualVector for training
this representation from glyph images (Secs. 3.2, 3.3 and 3.4) and how the
model can be used for font reconstruction and generation (Sec. 3.5). In
DualVector, we adopt a joint representation of vector and image for fonts, as
shown in Fig. 2. The latent space is shared by both modalities, and we
associate each glyph with a latent code $z\in\mathbf{R}^{d}$ produced by the
task-specific encoding process. The latent code $z$ is fed into the two
decoding branches to obtain a dual-part representation and an image
representation respectively. The output of the vector branch is further
processed by a contour refinement step to generate the final contour
representation under the image guidance.

###  3.1 Dual-Part Representation

In our dual-part representation, we consider the closed parametric Bézier
paths as our basic primitives for several reasons: (1) Bézier paths are
powerful enough to approximate various shapes; (2) The contour of a closed
shape produced by boolean operations on Bézier paths is still a set of Bézier
paths, i.e., the closure property; (3) Bézier paths are widely used in modern
font design, making the learned representation highly applicable. For
convenience, we use a triplet of control points $(\bm{a},\bm{b},\bm{c})$ to
denote a quadratic Bézier curve $B(\cdot;\bm{a},\bm{b},\bm{c})$ determined by
the control points:

$B(t;\bm{a},\bm{b},\bm{c})=(1-t)^{2}\bm{a}+(1-t)t\bm{b}+t^{2}\bm{c}t\in[0,1]$
(1)

Since a glyph often consists of a number of strokes with similar appearances,
we propose to represent each glyph $g$ with $N$ closed Bézier paths
$\\{P_{i}\\}_{i=1}^{N}$. Each path $P_{i}$ is defined by $M$ end-to-end
connected quadratic Bézier curves
$\\{B_{i,j}(\bm{x}_{i,2j-1},\bm{x}_{i,2j},\bm{x}_{i,2j+1})\\}_{j=1}^{M}$
($\bm{x}_{i,2M+1}=\bm{x}_{i,1}$). We introduce the occupancy field of a closed
path $P_{i}$ as

$\mathcal{O}_{P_{i}}(\bm{x})=\left\\{\begin{array}[]{cc}1,&\bm{x}\in P_{i}\\\
0,&\bm{x}\notin P_{i}\end{array}\right.$ (2)

The entire glyph shape $g$ could simply be denoted as the union of all the
paths $\cup_{i}P_{i}$. We normalize the coordinate range of the glyph to
$[-1,1]^{2}$. Thus given any point $\bm{x}$ on the canvas $[-1,1]^{2}$, we can
determine whether it is inside the represented glyph shape by a maximum
operation, leading to the occupancy field of $g$:

$\mathcal{O}(\bm{x})=\max_{i}\mathcal{O}_{P_{i}}(\bm{x})=\left\\{\begin{array}[]{cc}1,&\bm{x}\in\cup_{i}P_{i}\\\
0,&\bm{x}\notin\cup_{i}P_{i}\end{array}\right.$ (3)

However, we find that the above representation can model fonts with convex
curves on the contour but struggles to reconstruct shapes with holes.
Therefore, in practice, we pair each path $P_{i}$ with a negative path
$Q_{i}$, and term this pair $(P_{i},Q_{i})$ as a “dual part”. In this way, $g$
is represented as $\cup_{i}(P_{i}-Q_{i})$. The occupancy field $\mathcal{O}$
is then derived as:

$\mathcal{O}(\bm{x})=\max_{i}[\min(\mathcal{O}_{P_{i}}(\bm{x}),1-\mathcal{O}_{Q_{i}}(\bm{x}))]=\left\\{\begin{array}[]{cc}1,&\bm{x}\in
g\\\ 0,&\bm{x}\notin g\end{array}\right.$ (4)

Even though $\mathcal{O}$ is the analytical occupancy field of $g$, it is not
differentiable w.r.t. the parameters of the paths. Therefore, in order to
apply gradient descent to learn such a representation, we calculate the
approximate occupancy field $\hat{\mathcal{O}}$ from the signed distance field
(SDF) of $g$. Since the distance $d(p;B)$ from any point $p$ to a Bézier curve
$B$ can be derived analytically, the SDF of a path can be calculated
differentiably w.r.t. its control points as follows:

$s_{P_{i}}(\bm{x})=[2\mathcal{O}_{P_{i}}(\bm{x})-1]\min_{j}d(\bm{x};B_{i,j})$
(5)

Following previous vector graphics rasterization techniques[31, 22, 34], we
approximate $\mathcal{O}$ by analytical pixel pre-filtering with a parabolic
kernel $\alpha$:

$\displaystyle\hat{\mathcal{O}}_{P_{i}}(\bm{x})=\alpha(s_{P_{i}}(\bm{x}))$ (6)
$\displaystyle\hat{\mathcal{O}}=\max_{i}[\min(\hat{\mathcal{O}}_{P_{i}},1-\hat{\mathcal{O}}_{Q_{i}})]$

###  3.2 Vector Branch

The vector branch takes a latent code $z$ and outputs a set of dual-parts that
represent a vector glyph. The path decoder $\mathcal{D}_{P}$ directly predicts
the control points of the positive paths $\\{P_{i}\\}_{i=1}^{N}$ and the
negative ones $\\{Q_{i}\\}_{i=1}^{N}$ from $z$:

$\\{\bm{x}_{i,j}\\}=\mathcal{D}_{P}(z),1\leq i\leq 2N,1\leq j\leq 2M$ (7)

where $\\{\bm{x}_{i,j}\\}_{i=1}^{N}$ are control points for
$\\{P_{i}\\}_{i=1}^{N}$ and $\\{\bm{x}_{i,j}\\}_{i=N+1}^{2N}$ are control
points for $\\{Q_{i}\\}_{i=1}^{N}$.

###  3.3 Image Branch

To combine with the advantages of image generation approaches, we train an
auxiliary image branch that maps $z$ to a pixelated image $\mathcal{I}$ of the
glyph it represents. Here we adopt a CNN-based decoder $\mathcal{D}_{I}$:

$\mathcal{I}=\mathcal{D}_{I}(z)$ (8)

where $\mathcal{I}$ is a gray-scale image in shape $H\times W$. It provides
detailed shape guidance to refine the vector shape contour.

###  3.4 Contour Refinement

Although the dual-part representation produced by the vector branch can
already be rendered, there still exists a gap between it and modern contour
representations for fonts. Therefore, we first convert it to the contour of
the glyph $\partial\mathcal{O}$ with an off-the-shelf tool Paper.js[20] which
can perform arbitrary boolean operations on SVG paths. Here the contour
$\partial\mathcal{O}$ is a set of K closed Bézier paths.

$\partial\mathcal{O}=\\{C_{1},C_{2},...,C_{K}\\}$ (9)

where $K$ denotes the number of independent paths. Each individual part or
hole increases $K$ by 1. $C_{i}$ is a closed Bézier path composed of $l_{i}$
quadratic Bézier segments
$\\{\hat{B}_{i,j}(\bm{\hat{x}}_{i,2j-1},\bm{\hat{x}}_{i,2j},\bm{\hat{x}}_{i,2j+1})\\}_{j=1}^{l_{i}}$.

After this conversion, we exploit the image generation results to further
refine $\partial\mathcal{O}$ with differentiable rendering techniques [22].
$\mathcal{I}$ could naturally serve as a pixelated version of the occupancy
field $\mathcal{O}$. During the refinement, we devise several strategies to
improve the quality and efficiency of our representation:

##### Subdivision

To improve the representational ability, we split long Bézier curves (with a
length greater than 10% of the canvas width) at their midpoints.

##### Simplification

To improve the efficiency of the contour representation, we replace the Bézier
curves with a line segment connecting its two endpoints if they are close
enough. For a Bézier curve $(\bm{a},\bm{b},\bm{c})$, we simply define how
faithfully the segment $\bm{ac}$ could represent the curve by the angle
between $\vec{\bm{ba}}$ and $\vec{\bm{bc}}$. Also, we examine if there exist
two adjacent Bézier segments that could be combined as a single one. Since all
quadratic Bézier curves are parts of a parabola curve, we derive the
parameters of the corresponding parabola curves from the control points and
combine the two curves if their parameters are close enough. We also aggregate
the endpoints of lines and curves that are too short.

##### Pruning

Prior to refinement, some Bézier paths on the contour may enclose extremely
small regions which will confuse the refinement process and produce redundant
curves that eventually converge to a single point. We trim those closed paths
$C_{i}$ with areas under a certain threshold.

More implementation details of these strategies can be found in the
supplemental material.

###  3.5 Implementation and Training

In this subsection, we will dive into how we utilize the proposed
representation in both the font reconstruction and generation tasks.

####  3.5.1 Optimization Objectives

Optimization objectives can be divided into those at training time and those
at inference time. The training-time objectives are task-related.

##### Font reconstruction.

For the font reconstruction task, the input to our system is a gray-scale
image of a glyph and the output is the corresponding vector representation.
The pixelated image $\mathcal{I}_{g}$ of the glyph $g$ is first passed through
an image encoder $\mathcal{E}$ to obtain the latent code $z$:

$z=\mathcal{E}(\mathcal{I}_{g})$ (10)

The latent code is then decoded by our vector branch and image branch into
dual-parts $\\{(P_{i},Q_{i})\\}_{i=1}^{N}$ and a pixelated output
$\mathcal{I}$. We optimize the trainable modules $\mathcal{E}$,
$\mathcal{D}_{I}$ and $\mathcal{D}_{P}$ simultaneously with the following loss
functions:

$\mathcal{L}=\lambda_{P}\mathcal{L}_{P}+\lambda_{I}\mathcal{L}_{I}$ (11)

where we adopt an extra perceptual loss [43]:

$\displaystyle\mathcal{L}_{P}$
$\displaystyle=\mathbb{E}_{\bm{x}\sim[-1,1]^{2}}[||\hat{\mathcal{O}}(\bm{x})-\mathcal{I}_{g}(\bm{x})||_{1}]$
(12) $\displaystyle\mathcal{L}_{I}$
$\displaystyle=||\mathcal{I}-\mathcal{I}_{g}||_{2}+\text{LPIPS}(\mathcal{I},\mathcal{I}_{g})$

##### Font generation.

The input to the font generation task is multiple style reference images
$\\{R_{i}\\}_{i=1}^{N_{R}}$ along with the corresponding character label $T$.
The number of references $N_{R}$ may vary during training to allow the model
to accept a variable number of references during inference. The style
references are first mapped to their features $\\{f_{i}\\}_{i=1}^{N_{R}}$ with
an image encoder $\mathcal{E}_{f}$. We then apply stacked self-attention
layers (SA) to aggregate these features to a style latent code $z_{style}$
with a variational loss to enable font sampling. Character labels are mapped
to vector representations by a learnable label embedding layer and then fused
with $z_{style}$ to yield the latent code $z_{T}$ of the target glyph. Then
$z_{T}$ is fed to the decoders to generate the glyph, the same as the
reconstruction task. The whole process can be described as follows:

$\displaystyle f_{i}$ $\displaystyle=\mathcal{E}_{f}(R_{i})$ (13)
$\displaystyle\mu,\sigma$ $\displaystyle=\text{SA}(f_{1},f_{2},...,f_{N_{R}})$
$\displaystyle z_{style}$
$\displaystyle=\mu+\epsilon\sigma,\epsilon\sim\mathcal{N}(0,1)$ $\displaystyle
z_{T}$ $\displaystyle=\text{FFN}([z_{style},T])$

To ease training, we use the pre-trained $\mathcal{E}$ from the reconstruction
task to encode ground truth output $g_{T}$ and train the encoder with the
following guidance:

$\mathcal{L}_{latent}=||z_{T}-\mathcal{E}(g_{T})||_{2}$ (14)

To enable font sampling, we adopt a Kullback-Leibler divergence loss[16]:

$\mathcal{L}_{kl}=\text{KL}(\mathcal{N}(\mu,\sigma^{2})||\mathcal{N}(0,1))$
(15)

Next, the encoder is fine-tuned along with the pre-trained $\mathcal{D}_{I}$
and $\mathcal{D}_{P}$ from the reconstruction task using the loss in 11 with
$\mathcal{L}_{kl}$.

##### Refinement

Both the reconstruction and generation tasks share the same contour refinement
process. Given $\partial{\mathcal{O}}$ and $\mathcal{I}$, the refinement
process produces the optimized glyph contour in SVG format by inference-time
optimization. In the optimization, we utilize DiffVG[22], denoted as DR, to
render the contour in a differentiable manner. The control points of
$\mathcal{O}$ are refined to minimize the following loss function:

$\mathcal{L}_{refine}=\mathcal{L}_{ras}+\lambda_{reg}\mathcal{L}_{reg}$ (16)

where $\mathcal{L}_{render}$ is the photometric loss between the rasterized
image and the image branch output.

$\mathcal{L}_{ras}=||\text{DR}(\partial{\mathcal{O}})-\mathcal{I}||_{1}$ (17)

The regularization term limits the overall length of $\mathcal{O}$.

$\mathcal{L}_{reg}=\sum_{i=1}^{K}\text{len}(C_{i})$ (18)

####  3.5.2 Unsigned Distance Field Warm-up

Although the vector branch is end-to-end trainable, the gradients only appear
near the boundaries. Therefore, to overcome the vanishing gradient problem, we
add an extra loss based on the unsigned distance field (UDF) of the vector
parts to warm up the system training.

In general, for two closed curves $c_{1},c_{2}$, we cannot obtain the exact
SDF of the shape after arbitrary boolean operations on the curves by point-
wise operations on their respective SDFs. For the union of two SDFs, as an
approximation, we have

$s_{c_{1}\cup
c_{2}}(\bm{x})\left\\{\begin{array}[]{cc}=\min(s_{c_{1}}(\bm{x}),s_{c_{2}}(\bm{x})),&\bm{x}\notin
c_{1}\cup c_{2}\\\ \leq\min(s_{c_{1}}(\bm{x}),s_{c_{2}}(\bm{x})),&\bm{x}\in
c_{1}\cup c_{2}\end{array}\right.$ (19)

The $\min(\cdot)$ operation gives a correct SDF outside the shape but an
inaccurate SDF inside the shape. Similarly, the $\max(\cdot)$ gives a correct
SDF inside and an inaccurate SDF outside for the intersection of two SDFs.
Therefore, it is hard to calculate the accurate SDF $s_{\mathcal{O}}$ for the
glyph. Fortunately, we only aim to provide a coarse initialization for the
dual parts, preventing the optimization process from falling into local minima
early in the training. We find that using an approximate unsigned distance
field works well to achieve this goal. Here we define the UDF $u$ as

$u(\bm{x})=\max(0,s(\bm{x}))$ (20)

where $\min(\cdot)$ gives a correct global UDF for unions of shapes. The
approximate UDF $\hat{u}_{g}$ is computed as

$\hat{u}_{g}=\min_{i}[\max(u_{P_{i}},u_{Q_{i}})]$ (21)

where

$\displaystyle u_{P_{i}}(\bm{x})$ $\displaystyle=\max(s_{P_{i}}(\bm{x}),0)$
(22) $\displaystyle u_{Q_{i}}(\bm{x})$
$\displaystyle=\max(-s_{Q_{i}}(\bm{x}),0)$

We apply the following losses to warm up the training process for the font
reconstruction task:

$\displaystyle\mathcal{L}$
$\displaystyle=\lambda_{P}\mathcal{L}_{P}+\lambda_{I}\mathcal{L}_{I}+\lambda_{u}\mathcal{L}_{u}$
(23) $\displaystyle\mathcal{L}_{u}$
$\displaystyle=\mathbb{E}_{\bm{x}\sim[-1,1]^{2}}[||\hat{u}_{g}(\bm{x})-u_{g}(\bm{x})||_{1}]$

where the ground truth UDF $u_{g}$ is derived from the pixel image $g$.

##  4 Experiments

###  4.1 Dataset

We use the SVG-Fonts dataset from SVG-VAE[27] for all the experiments.
Following DeepVecFont[39], we sample a subset of the dataset with 8035 fonts
for training and 1425 fonts for evaluation. The resolution of input glyph
images is set to $128\times 128$. Please refer to the supplementary material
for implementation details.

\begin{overpic}[scale={0.30}]{figure/recon_final_1.png}
\put(32.0,107.5){$\mathcal{O}$} \put(32.0,140.0){$\mathcal{I}$} \end{overpic}

Figure 3: Comparison of font reconstruction quality. We show the input glyph
image row by row, our reconstructed image $\mathcal{I}$ from the image branch,
dual-parts $\mathcal{O}$ from the vector branch, and our final result after
contour refinement, as well as vector outputs from alternative methods. Figure
4: Font generation results of Attr2Font, Im2Vec, Multi-Implicits, DeepVecFont,
and DualVector. The input style references are marked with red boxes. We trace
the zero-level sets of SDFs in a piece-wise linear way to get SVGs from Multi-
Implicits[34]. Typical failure cases are marked in blue dashed boxes. Some
details are zoomed-in in the leftmost column.

###  4.2 Font Reconstruction

In this experiment, we investigate how faithfully different methods can
reconstruct the input glyph images with vector outputs, which can also be
regarded as font vectorization. Im2Vec [33] and our method directly produce
vector representations from glyph images, while for Multi-Implicits[34], we
adopt the 2D marching cube algorithm and extract the contours. As can be seen
from a qualitative comparison in Fig. 3, our representation could faithfully
reconstruct global shapes as well as local details from the pixelated input.
Im2Vec[33] could only preserve coarse shapes and suffers from wrong topologies
as shown in the “A” example as it is easy to fall into local optimum without
the global gradient. Multi-Implicits[34] results in finer details than
Im2Vec[33] but still exhibit unsmooth edges and rounded corners. To
quantitatively evaluate how accurate the vector outputs are, we calculate
three metrics, namely SSIM, L1, and s-IoU, between the rendered images and the
ground truth images under different resolutions. Tab. 1 shows that our method
surpasses the two alternatives by a clear margin on all metrics. Using
parametric curves as primitives, our method, along with Im2Vec [33], maintains
a stable L1 error across all resolutions for the smooth edges, while for
Multi-Implicits[34] the L1 error gets larger as the resolution increases,
resulting from the high-frequency noises at the extracted boundaries.

Table 1: Quantitative comparison with Im2Vec [33] and Multi-Implicits [34] on three image-level metrics at different resolutions for the font reconstruction task. The gray scale is normalized to [0,1]. s-IoU, from [34], measures the overlap. Method | Resolution | SSIM$\uparrow$ | L1$\downarrow$ | s-IoU$\uparrow$
---|---|---|---|---
Ours | $128^{2}$ | 0.9436 | 0.0137 | 0.8879
$256^{2}$ | 0.9483 | 0.0136 | 0.9068
$512^{2}$ | 0.9579 | 0.0136 | 0.9135
Multi-Implicits | $128^{2}$ | 0.9231 | 0.0183 | 0.8709
$256^{2}$ | 0.9262 | 0.0208 | 0.8721
$512^{2}$ | 0.9419 | 0.0213 | 0.8739
Im2Vec | $128^{2}$ | 0.7800 | 0.0504 | 0.6832
$256^{2}$ | 0.8566 | 0.0504 | 0.6847
$512^{2}$ | 0.8957 | 0.0504 | 0.6851

###  4.3 Font Generation

To evaluate the generation ability of our method, we adopt the few-shot font
generation setting, where a subset of glyphs with the same style is given and
models are trained to produce a complete set of glyphs that are consistent
with the input glyphs in style. This task is also dubbed “font complement” or
“font style transfer” in other works. We compare our method with several
popular methods in font generation: DeepVecFont[39], Multi-Implicits[34],
Im2Vec[33] and Attr2Font[38]. For a fair comparison, we use the same four
characters, ‘A’, ‘B’, ‘a’, and ‘b’ as style references for each font and
evaluate image-level metrics on the generated characters. Since Im2Vec[33] is
an image vectorization method, we apply it to the images generated by
Attr2Font[38]. Multi-Implicits[34] follows an auto-decoder architecture, so we
freeze the decoder and find the optimal latent vector for a font by minimizing
the losses between the given style references and the predicted ones using
gradient descent.

As illustrated in Fig. 4, DeepVecFont[39] may generate characters with wrong
topologies due to the incorrect initial contour prediction, such as ‘A’, ‘L’,
and ‘Z’. The fixed topology in the optimization process makes it difficult to
produce the necessary details, which are particularly symbolic in serif fonts.
In addition, unconstrained contour generation may also produce self-
intersections, like the ‘g’ and ‘r’, which are not easy to fix in subsequent
processing. Im2Vec[33] tends to produce rounded corners and is only able to
produce the coarse style, lacking details. Multi-Implicits[34] generates
vector results from implicit signed distance fields (SDF) through a 2D
Marching cube algorithm, leading to free-form contours. Therefore the edges
are not smooth enough and have unpleasing noises, such as the ‘g’ and ‘x’ in
the figure. Attr2Font[38] can generate generally satisfactory font images, but
it cannot maintain high-quality rendering when scaling.

Table 2: Quantitative comparison of image-level metrics of Attr2Font[38],
Im2Vec[33], Multi-Implicits[34], DeepVecFont[39] and DualVector in the font
complement experiment.

Method | Resolution | SSIM$\uparrow$ | L1$\downarrow$ | s-IoU$\uparrow$
---|---|---|---|---
Ours | $128^{2}$ | 0.8288 | 0.0461 | 0.7395
$256^{2}$ | 0.8727 | 0.0460 | 0.7453
$512^{2}$ | 0.9075 | 0.0460 | 0.7469
DeepVecFont | $128^{2}$ | 0.8165 | 0.0506 | 0.7125
$256^{2}$ | 0.8640 | 0.0506 | 0.7171
$512^{2}$ | 0.9011 | 0.0506 | 0.7182
Multi-Implicits | $128^{2}$ | 0.8025 | 0.0578 | 0.6857
$256^{2}$ | 0.8533 | 0.0603 | 0.6814
$512^{2}$ | 0.8914 | 0.0608 | 0.6811
Im2Vec | $128^{2}$ | 0.7576 | 0.0733 | 0.5731
$256^{2}$ | 0.8270 | 0.0734 | 0.5751
$512^{2}$ | 0.8739 | 0.0734 | 0.5756
Attr2Font111[38] synthesizes pixelated images only. | $128^{2}$ | 0.7841 | 0.0512 | 0.6393

Table 3: The average number of commands used per glyph for different methods
in the font generation task. M, L, Q, and C denote move, straight line,
quadratic Bézier curve, and cubic Bézier curve respectively.

Command | M | L | Q | C | Total$\downarrow$
---|---|---|---|---|---
Ours | 1.42 | 8.21 | 11.06 | 0 | 20.69
DeepVecFont [39] | 1.37 | 8.23 | 0 | 9.68 | 19.28
Multi-Implicits [34] | 6.16 | 1446.53 | 0 | 0 | 1452.69
Im2Vec [33] | 4 | 0 | 0 | 80 | 84
Human-Designed | 1.38 | 9.17 | 0 | 8.51 | 19.06

Compared with the above methods, our method is capable of not only grasping
the overall style of the input references but also generating new glyphs with
clear boundaries and sharp edges, achieving optimal visual quality. The
efficient dual-part representation along with the differentiable occupancy
supervision establishes a link between pixelated images and vector graphics,
allowing the unsupervised synthesis of vector fonts with aligned shapes and
correct topologies. The refinement step allows the composition of the contour
to be freely changed and thus ensures that our synthesized glyphs have high-
fidelity details under the guidance of high-resolution glyph images.
Quantitative results on three image-level metrics at different resolutions are
shown in Tab. 2. For methods producing vector shapes, we also count the
average number of commands used for each synthesized vector character, with
smaller numbers indicating more compact outputs. The results are shown in Tab.
3. Multi-Implicits[34] uses a large number of short line segments to represent
the boundary due to the marching cube algorithm. Im2Vec[33] represents a shape
with 4 parts each enclosed by 20 cubic Bézier curves, lacking flexibility and
details. Our method performs boolean operations on the quadratic Bézier curves
from dual parts, achieving comparable compactness with human-designed fonts
and outputs from methods with vector supervision [39].

###  4.4 Ablation Studies

\begin{overpic}[scale={0.475}]{figure/ablation.png} \put(32.0,-8.0){(a)}
\put(100.0,-8.0){(b)} \put(168.0,-8.0){(c)} \put(218.0,-8.0){{Full Model}}
\put(234.0,68.0){GT} \end{overpic}

Figure 5: The contours of an “M” reconstructed by our method, compared with
three degraded variants.

To demonstrate the effectiveness of several key design choices in our method,
we conduct ablation studies on the font reconstruction task. We investigate
the following degraded variants: (a) replace the union of dual parts with the
union of all the paths; (b) train without the UDF warm-up process; and (c)
remove the refining strategy during refinement. We show the comparison results
of a representative case in Fig. 5. Without the dual-part representation,
variant (a) cannot reconstruct concave regions very well, as they can be hard
to represent by the union of simply closed paths. Without UDF initialization,
variant (b) produces contours with useless curves that are hard to be
eliminated during optimization. Without the refining strategy, variant (c) may
generate inaccurate edges with zigzags. Quantitative results in Tab. 4 also
verify the quality improvements brought by the three design choices.

Table 4: Quantitative results of reconstruction accuracy for different model variants in ablation studies. All the output vector glyphs are rendered at $512\times 512$ to compute the L1 error. | L1$\downarrow$ |  $\\#$Lines$\downarrow$ |  $\\#$ Curves$\downarrow$
---|---|---|---
(a) w/o dual parts | 0.0143 | 12.23 | 14.06
(b) w/o warm-up | 0.0146 | 11.19 | 13.12
(c) w/o refining strategy | 0.0148 | - | 22.07
Full Model | 0.0136 | 8.97 | 11.81

We also experimentally investigate the effect of different $(N,M)$s on the
representation capacity. We choose several settings of $(N,M)$ and train only
the vector branch (i.e. no contour refinement) with the same number of epochs
to reconstruct the input. Tab. 5 shows that $M=4$ is optimal and the
reconstruction accuracy of the vector branch increases as $N$ increases. The
accuracy does not gain too much changing $N$ from 6 to 8. So considering the
time cost for training and inference, we select $(N,M)=(6,4)$ in the above
experiments.

Table 5: Different reconstruction settings and metrics. The image-based metrics use a resolution of $512\times 512$.  $N$ | $M$ | SSIM$\uparrow$ | L1$\downarrow$ | s-IOU$\uparrow$
---|---|---|---|---
2 | 4 | 0.9262 | 0.0282 | 0.8338
4 | 4 | 0.9292 | 0.0259 | 0.8464
6 | 4 | 0.9303 | 0.0250 | 0.8512
8 | 4 | 0.9306 | 0.0247 | 0.8525
6 | 3 | 0.9293 | 0.0256 | 0.8480
6 | 5 | 0.9300 | 0.0252 | 0.8498

###  4.5 Font Sampling and Interpolation

In the font generation task, the style latent code $z_{style}$ is trained with
a variational loss $\mathcal{L}_{kl}$, enabling generating fonts of new styles
by sampling $z_{style}$ from $\mathcal{N}(0,1)$. We show in Fig. 1 (left) and
Fig. 6 multiple styles of fonts sampled. Please refer to our supplementary
material for more examples. Also, benefiting from our dual-part
representation, we can perform smooth interpolation between arbitrary font
styles as demonstrated in Fig. 1 (right).

Figure 6: New fonts with style codes sampled in $\mathcal{N}(0,1)$.

##  5 Limitations

The contour refinement step requires gradient descent during inference and
therefore imposes a large time overhead, similar to DeepVecFont[39]. The
process could potentially be accomplished by forwarding inferences of some
generation models, such as the diffusion models[13]. Another limitation is
that DualVector only focuses on the synthesis of glyphs on a fixed-size
canvas, without considering the kerning between them, making the spacing
between characters less natural. This may be solved by post-processing the SVG
with some automatic kerning methods or by learning through a data-driven
approach.

##  6 Conclusion

We present DualVector as a new representation and generation method for vector
fonts. DualVector models a glyph as dual parts and introduces a contour
refinement step to add pleasing details to the contours of the dual parts. Our
method is able to generate vector fonts without vector supervision, which can
be directly converted to common digital font formats for content presentation
and distribution. Comparisons with different methods of font reconstruction
and generation tasks demonstrate that our approach produces fonts with the
best quality among all the alternatives. In the future, more plausible
initialization and supervision could be exploited to generalize this
representation to more complex fonts (e.g. Chinese fonts). We hope this
research contributes to the typeface design industry and provide inspiration
for broader works on the understanding and generation of 2D man-made content
such as cartoon characters and icons.

Acknowledgement This work was supported by the Natural Science Foundation of
China (Project Number 61832016), and Tsinghua-Tencent Joint Laboratory for
Internet Innovation Technology.

## References

  * [1] Adobe Inc.  Adobe illustrator.
  * [2] Samaneh Azadi, Matthew Fisher, Vladimir Kim, Zhaowen Wang, Eli Shechtman, and Trevor Darrell.  Multi-content gan for few-shot font style transfer.  In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, volume 11, page 13, 2018.
  * [3] Vineet Batra, Mark J. Kilgard, Harish Kumar, and Tristan Lorach.  Accelerating vector graphics rendering using the graphics hardware pipeline.  ACM Trans. Graph., 34(4), jul 2015.
  * [4] Alexandre Carlier, Martin Danelljan, Alexandre Alahi, and Radu Timofte.  Deepsvg: A hierarchical generative network for vector graphics animation.  In Hugo Larochelle, Marc’Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin, editors, Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.
  * [5] Cedar Lake Ventures, Inc.  Vector magic.
  * [6] Zhiqin Chen, Andrea Tagliasacchi, and Hao Zhang.  Bsp-net: Generating compact meshes via binary space partitioning.  In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2020, Seattle, WA, USA, June 13-19, 2020, pages 42–51. IEEE, 2020.
  * [7] Zhiqin Chen and Hao Zhang.  Learning implicit fields for generative shape modeling.  In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, Long Beach, CA, USA, June 16-20, 2019, pages 5939–5948. Computer Vision Foundation / IEEE, 2019.
  * [8] Boyang Deng, Kyle Genova, Soroosh Yazdani, Sofien Bouaziz, Geoffrey E. Hinton, and Andrea Tagliasacchi.  Cvxnet: Learnable convex decomposition.  In 2020 IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2020, Seattle, WA, USA, June 13-19, 2020, pages 31–41. IEEE, 2020.
  * [9] A. E. Fabris and A. R. Forrest.  Antialiasing of curves by discrete pre-filtering.  In Proceedings of the 24th Annual Conference on Computer Graphics and Interactive Techniques, SIGGRAPH ’97, page 317–326, USA, 1997\. ACM Press/Addison-Wesley Publishing Co.
  * [10] Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron C. Courville, and Yoshua Bengio.  Generative adversarial nets.  In Zoubin Ghahramani, Max Welling, Corinna Cortes, Neil D. Lawrence, and Kilian Q. Weinberger, editors, Advances in Neural Information Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December 8-13 2014, Montreal, Quebec, Canada, pages 2672–2680, 2014.
  * [11] Chris Green.  Improved alpha-tested magnification for vector textures and special effects.  In ACM SIGGRAPH 2007 courses, pages 9–18. 2007.
  * [12] Hideaki Hayashi, Kohtaro Abe, and Seiichi Uchida.  Glyphgan: Style-consistent font generation based on generative adversarial networks.  Knowl. Based Syst., 186, 2019.
  * [13] Jonathan Ho, Ajay Jain, and Pieter Abbeel.  Denoising diffusion probabilistic models.  In NeurIPS, 2020.
  * [14] Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros.  Image-to-image translation with conditional adversarial networks.  In Computer Vision and Pattern Recognition (CVPR), 2017 IEEE Conference on, 2017.
  * [15] Yue Jiang, Zhouhui Lian, Yingmin Tang, and Jianguo Xiao.  Dcfont: an end-to-end deep chinese font generation system.  In Diego Gutierrez and Hui Huang, editors, SIGGRAPH Asia 2017 Technical Briefs, Bangkok, Thailand, November 27 - 30, 2017, pages 22:1–22:4. ACM, 2017.
  * [16] Diederik P. Kingma and Max Welling.  Auto-encoding variational bayes.  In Yoshua Bengio and Yann LeCun, editors, 2nd International Conference on Learning Representations, ICLR 2014, Banff, AB, Canada, April 14-16, 2014, Conference Track Proceedings, pages 1–14, 2014.
  * [17] Yoshiyuki Kokojima, Kaoru Sugita, Takahiro Saito, and Takashi Takemoto.  Resolution independent rendering of deformable vector objects using graphics hardware.  In ACM SIGGRAPH 2006 Sketches, SIGGRAPH ’06, page 118–es, New York, NY, USA, 2006. Association for Computing Machinery.
  * [18] Johannes Kopf and Dani Lischinski.  Depixelizing pixel art.  ACM Transactions on Graphics (Proceedings of SIGGRAPH 2011), 30(4):99:1 – 99:8, 2011.
  * [19] Gregory Lecot and Bruno Levy.  Ardeco: Automatic region detection and conversion.  In Proceedings of the 17th Eurographics Conference on Rendering Techniques, EGSR ’06, page 349–360, Goslar, DEU, 2006. Eurographics Association.
  * [20] Jürg Lehni and Jonathan Puckey.  Paper.js: The swiss army knife of vector graphics scripting.  https://github.com/paperjs/paper.js, 2021.
  * [21] Rui Li, Qiming Hou, and Kun Zhou.  Efficient gpu path rendering using scanline rasterization.  ACM Trans. Graph., 35(6), nov 2016.
  * [22] Tzu-Mao Li, Michal Lukác, Michaël Gharbi, and Jonathan Ragan-Kelley.  Differentiable vector graphics rasterization for editing and learning.  ACM Trans. Graph., 39(6):193:1–193:15, 2020.
  * [23] Xiang Li, Lei Wu, Xu Chen, Lei Meng, and Xiangxu Meng.  Dse-net: Artistic font image synthesis via disentangled style encoding.  In ICME, pages 1–6. IEEE, 2022.
  * [24] Xianming Lin, Jie Li, Hualin Zeng, and Rongrong Ji.  Font generation based on least squares conditional generative adversarial nets.  Multim. Tools Appl., 78(1):783–797, 2019.
  * [25] Ying-Tian Liu, Yuan-Chen Guo, Yi-Xiao Li, Chen Wang, and Song-Hai Zhang.  Learning implicit glyph shape representation.  IEEE Transactions on Visualization and Computer Graphics, pages 1–12, 2022.
  * [26] Charles Loop and Jim Blinn.  Resolution independent curve rendering using programmable graphics hardware.  In ACM SIGGRAPH 2005 Papers, pages 1000–1009. 2005.
  * [27] Raphael Gontijo Lopes, David Ha, Douglas Eck, and Jonathon Shlens.  A learned representation for scalable vector graphics.  In 2019 IEEE/CVF International Conference on Computer Vision, ICCV 2019, Seoul, Korea (South), October 27 - November 2, 2019, pages 7929–7938. IEEE, 2019.
  * [28] William E. Lorensen and Harvey E. Cline.  Marching cubes: A high resolution 3d surface construction algorithm.  SIGGRAPH Comput. Graph., 21(4):163–169, aug 1987.
  * [29] Xu Ma, Yuqian Zhou, Xingqian Xu, Bin Sun, Valerii Filev, Nikita Orlov, Yun Fu, and Humphrey Shi.  Towards layer-wise image vectorization.  In Proceedings of the IEEE conference on computer vision and pattern recognition, 2022.
  * [30] Ben Mildenhall, Pratul P. Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng.  Nerf: Representing scenes as neural radiance fields for view synthesis.  In ECCV (1), volume 12346 of Lecture Notes in Computer Science, pages 405–421. Springer, 2020.
  * [31] Diego Nehab and Hugues Hoppe.  Random-access rendering of general vector graphics.  ACM Trans. Graph., 27(5):135, 2008.
  * [32] Jeong Joon Park, Peter Florence, Julian Straub, Richard A. Newcombe, and Steven Lovegrove.  Deepsdf: Learning continuous signed distance functions for shape representation.  In CVPR, pages 165–174. Computer Vision Foundation / IEEE, 2019\.
  * [33] Pradyumna Reddy, Michaël Gharbi, Michal Lukác, and Niloy J. Mitra.  Im2vec: Synthesizing vector graphics without vector supervision.  In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2021, virtual, June 19-25, 2021, pages 7342–7351. Computer Vision Foundation / IEEE, 2021.
  * [34] Pradyumna Reddy, Zhifei Zhang, Zhaowen Wang, Matthew Fisher, Hailin Jin, and Niloy J. Mitra.  A multi-implicit neural representation for fonts.  In Marc’Aurelio Ranzato, Alina Beygelzimer, Yann N. Dauphin, Percy Liang, and Jennifer Wortman Vaughan, editors, Advances in Neural Information Processing Systems 34: Annual Conference on Neural Information Processing Systems 2021, NeurIPS 2021, December 6-14, 2021, virtual, pages 12637–12647, 2021.
  * [35] Peter Selinger.  Potrace: a polygon-based tracing algorithm.  2003\.
  * [36] Jian Sun, Lin Liang, Fang Wen, and Heung-Yeung Shum.  Image vectorization using optimized gradient meshes.  ACM Trans. Graph., 26(3):11–es, jul 2007.
  * [37] Yuchen Tian.  zi2zi: Master chinese calligraphy with conditional adversarial networks.  https://github.com/kaonashi-tyc/zi2zi, 2017.
  * [38] Yizhi Wang, Yue Gao, and Zhouhui Lian.  Attribute2font: Creating fonts you want from attributes.  ACM Trans. Graph., 39(4), July 2020.
  * [39] Yizhi Wang and Zhouhui Lian.  Deepvecfont: synthesizing high-quality vector fonts via dual-modality learning.  ACM Trans. Graph., 40(6):265:1–265:15, 2021.
  * [40] Yankun Xi, Guoli Yan, Jing Hua, and Zichun Zhong.  Jointfontgan: Joint geometry-content GAN for font generation via few-shot learning.  In ACM Multimedia, pages 4309–4317. ACM, 2020.
  * [41] Shuai Yang, Jiaying Liu, Wenjing Wang, and Zongming Guo.  Tet-gan: Text effects transfer via stylization and destylization.  In AAAI Conference on Artificial Intelligence, 2019.
  * [42] Gao Yue, Guo Yuan, Lian Zhouhui, Tang Yingmin, and Xiao Jianguo.  Artistic glyph image synthesis via one-stage few-shot learning.  ACM Trans. Graph., 38(6), 2019.
  * [43] Richard Zhang, Phillip Isola, Alexei A. Efros, Eli Shechtman, and Oliver Wang.  The unreasonable effectiveness of deep features as a perceptual metric.  In 2018 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2018, Salt Lake City, UT, USA, June 18-22, 2018, pages 586–595. Computer Vision Foundation / IEEE Computer Society, 2018.
  * [44] Song-Hai Zhang, Tao Chen, Yi-Fei Zhang, Shi-Min Hu, and Ralph R. Martin.  Vectorizing cartoon animations.  IEEE Transactions on Visualization and Computer Graphics, 15(4):618–629, 2009.
  * [45] Shuang Zhao, Frédo Durand, and Changxi Zheng.  Inverse diffusion curves using shape optimization.  IEEE Trans. Vis. Comput. Graph., 24(7):2153–2166, 2018.
  * [46] Haikuan Zhu, Juan Cao, Yanyang Xiao, Zhonggui Chen, Zichun Zhong, and Yongjie Jessica Zhang.  Tcb-spline-based image vectorization.  ACM Trans. Graph., 41(3):34:1–34:17, 2022.


# Implementation of computation formulas for certain classes of Apostol-type
polynomials and some properties associated with these polynomials

Irem Kucukoglu

Department of Engineering Fundamental Sciences, Faculty of Engineering,
Alanya Alaaddin Keykubat University TR-07425 Antalya, Turkey,
<EMAIL_ADDRESS>

Abstract. The main purpose of this paper is to present various identities and
computation formulas for certain classes of Apostol-type numbers and
polynomials. The results of this paper contain not only the $\lambda$-Apostol-
Daehee numbers and polynomials, but also Simsek numbers and polynomials, the
Stirling numbers of the first kind, the Daehee numbers, and the Chu-
Vandermonde identity. Furthermore, we derive an infinite series representation
for the $\lambda$-Apostol-Daehee polynomials. By using functional equations
containing the generating functions for the Cauchy numbers and the Riemann
integrals of the generating functions for the $\lambda$-Apostol-Daehee numbers
and polynomials, we also derive some identities and formulas for these numbers
and polynomials. Moreover, we give implementation of a computation formula for
the $\lambda$-Apostol-Daehee polynomials in Mathematica by Wolfram language.
By this implementation, we also present some plots of these polynomials in
order to investigate their behaviour some randomly selected special cases of
its parameters. Finally, we conclude the paper with some comments and
observations on our results.

>
>

2010 Mathematics Subject Classification. 05A10, 05A15, 05A19, 11B37, 11B73,
11B83, 11S23, 33F05, 65D20.

Key Words. Generating functions, Functional Equations, Special numbers and
polynomials, Stirling numbers of the first kind, Apostol-type numbers and
polynomials, Simsek numbers and polynomials, Bernoulli numbers of the second
kind, Daehee numbers and polynomials, Integral formulas, Chu-Vandermonde
identity, Bernstein basis functions, Combinatorial sums, Mathematica
implementation.

##  1\. Introduction

In recent years, many studies on Apostol-type numbers and polynomials have
been carried out by some researchers (see [4]-[34]). Among others, in this
paper, we are mainly dealt with the $\lambda$-Apostol-Daehee numbers
$\mathfrak{D}_{n}\left(\lambda\right)$ and polynomials
$\mathfrak{D}_{n}\left(x;\lambda\right)$ introduced and investigated by Simsek
[27, 28] respectively as in the following generating functions:

(1.1)
$G_{\mathfrak{D}}\left(t;\lambda\right):=\frac{\log\lambda+\log\left(1+\lambda
t\right)}{\lambda\left(1+\lambda
t\right)-1}=\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(\lambda\right)\frac{t^{n}}{n!},$

and

(1.2)
$G_{\mathfrak{D}}\left(t,x;\lambda\right):=\frac{\log\lambda+\log\left(1+\lambda
t\right)}{\lambda\left(1+\lambda t\right)-1}\left(1+\lambda
t\right)^{x}=\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(x;\lambda\right)\frac{t^{n}}{n!},$

(cf. [27, 28]; and also see [32]).

First few values of the numbers $\mathcal{D}_{n}(\lambda)$ are given as
follows:

$\displaystyle\mathcal{D}_{0}(\lambda)$ $\displaystyle=$
$\displaystyle\frac{\log\lambda}{\lambda-1},$
$\displaystyle\mathcal{D}_{1}(\lambda)$ $\displaystyle=$
$\displaystyle-\frac{\lambda^{2}\log\lambda}{\left(\lambda-1\right)^{2}}+\frac{\lambda}{\lambda-1},$
$\displaystyle\mathcal{D}_{2}(\lambda)$ $\displaystyle=$
$\displaystyle\frac{2\lambda^{4}\log\lambda}{\left(\lambda-1\right)^{3}}+\frac{\lambda^{2}\left(1-3\lambda\right)}{\left(\lambda-1\right)^{2}},$
$\displaystyle\mathcal{D}_{3}(\lambda)$ $\displaystyle=$
$\displaystyle-\frac{6\lambda^{6}\log\lambda}{\left(\lambda-1\right)^{4}}+\frac{\lambda^{3}\left(11\lambda^{2}-7\lambda+2\right)}{\left(\lambda-1\right)^{3}},$

and so on (cf. [14, 27, 28, 32]).

Another family of Apostol-type numbers and polynomials is the family of the
numbers $Y_{n}\left(\lambda\right)$ (so-called Simsek numbers) and the
polynomials $Y_{n}\left(x;\lambda\right)$ (so-called Simsek polynomials)
defined respectively by the following generating functions (cf. [29]):

(1.3) $F\left(t,\lambda\right):=\frac{2}{\lambda\left(1+\lambda
t\right)-1}=\sum\limits_{n=0}^{\infty}Y_{n}\left(\lambda\right)\frac{t^{n}}{n!},$

and

(1.4) $F\left(t,x,\lambda\right):=\frac{2\left(1+\lambda
t\right)^{x}}{\lambda\left(1+\lambda
t\right)-1}=\sum\limits_{n=0}^{\infty}Y_{n}\left(x;\lambda\right)\frac{t^{n}}{n!}.$

For $n\in\mathbb{N}_{0}:=\\{0,1,2,3,\dots\\}$, the numbers $Y_{n}(\lambda)$
are computed by the following explicit formula:

(1.5)
$Y_{n}(\lambda)=2(-1)^{n}\frac{n!}{\lambda-1}\left(\frac{\lambda^{2}}{\lambda-1}\right)^{n},$

by which, one may easily compute first few values of the numbers
$Y_{n}\left(\lambda\right)$ as below:

$\displaystyle Y_{0}(\lambda)=\frac{2}{\lambda-1},\quad
Y_{1}(\lambda)=-\frac{2\lambda^{2}}{\left(\lambda-1\right)^{2}},\quad
Y_{2}(\lambda)=\frac{4\lambda^{4}}{\left(\lambda-1\right)^{3}},$
$\displaystyle
Y_{3}(\lambda)=-\frac{12\lambda^{6}}{\left(\lambda-1\right)^{4}},\quad
Y_{4}(\lambda)=\frac{48\lambda^{8}}{\left(\lambda-1\right)^{5}},$

and so on (cf. [29]; and also see [34]).

Let $\left(x\right)_{n}=x\left(x-1\right)\dots\left(x-n+1\right)$ with
$\left(x\right)_{0}=1$. Then, the combination of (1.3) with (1.4) yields the
relation between the numbers $Y_{n}(\lambda)$ and the polynomials
$Y_{n}(x;\lambda)$ given by

(1.6)
$Y_{n}(x;\lambda)=\sum_{j=0}^{n}\binom{n}{j}Y_{j}(\lambda)\lambda^{n-j}(x)_{n-j},$

by which, one may easily compute first few values of the polynomials
$Y_{n}\left(x;\lambda\right)$ as below:

$\displaystyle Y_{0}(x;\lambda)$ $\displaystyle=$
$\displaystyle\frac{2}{\lambda-1},$ $\displaystyle Y_{1}(x;\lambda)$
$\displaystyle=$
$\displaystyle\frac{2\lambda}{\lambda-1}x-\frac{2\lambda^{2}}{\left(\lambda-1\right)^{2}},$
$\displaystyle Y_{2}(x;\lambda)$ $\displaystyle=$
$\displaystyle\frac{2\lambda^{2}}{\lambda-1}x^{2}-\frac{6\lambda^{3}-2\lambda^{2}}{\left(\lambda-1\right)^{2}}x+\frac{4\lambda^{4}}{\left(\lambda-1\right)^{3}},$
$\displaystyle Y_{3}(x;\lambda)$ $\displaystyle=$
$\displaystyle\frac{2\lambda^{3}}{\lambda-1}x^{3}-\frac{12\lambda^{4}-6\lambda^{3}}{\left(\lambda-1\right)^{2}}x^{2}+\frac{22\lambda^{5}-14\lambda^{4}+4\lambda^{3}}{\left(\lambda-1\right)^{3}}x-\frac{12\lambda^{6}}{\left(\lambda-1\right)^{4}},$

and so on (cf. [29]; and also see [34]).

Another family of Apostol-type numbers and polynomials is the family of the
numbers $Y_{n}^{\left(-k\right)}\left(\lambda\right)$ (so-called negative
higher-order Simsek numbers) and the polynomials
$Q_{n}\left(x;\lambda,k\right)$ (so-called negative higher-order Simsek
polynomials) defined respectively by the following generating functions:

(1.7)
$\mathcal{G}_{Y}\left(t,k;\lambda\right):=2^{-k}\left(\lambda\left(1+\lambda
t\right)-1\right)^{k}=\sum_{n=0}^{\infty}Y_{n}^{\left(-k\right)}\left(\lambda\right)\frac{t^{n}}{n!}$

and

(1.8)
$\mathcal{G}_{Q}\left(t,x,k;\lambda\right):=\mathcal{G}_{Y}\left(t,k;\lambda\right)\left(1+\lambda
t\right)^{x}=\sum_{n=0}^{\infty}Q_{n}\left(x;\lambda,k\right)\frac{t^{n}}{n!},$

(cf. [15]).

For $n\in\mathbb{N}_{0}$, the numbers
$Y_{n}^{\left(-k\right)}\left(\lambda\right)$ are computed by the following
explicit formula:

(1.9)
$Y_{n}^{\left(-k\right)}\left(\lambda\right)=\left\\{\begin{array}[]{cc}2^{-k}n!\binom{k}{n}\lambda^{2n}\left(\lambda-1\right)^{k-n}&\text{if}\quad
n\leq k\\\ 0&\text{if}\quad n>k\end{array}\right.$

by which, one may easily compute the values of the numbers
$Y_{n}^{\left(-k\right)}\left(\lambda\right)$ as below:

$\displaystyle Y_{0}^{\left(-k\right)}\left(\lambda\right)$ $\displaystyle=$
$\displaystyle 2^{-k}\left(\lambda-1\right)^{k},$ $\displaystyle
Y_{1}^{\left(-k\right)}\left(\lambda\right)$ $\displaystyle=$ $\displaystyle
2^{-k}\binom{k}{1}\lambda^{2}\left(\lambda-1\right)^{k-1},$ $\displaystyle
Y_{2}^{\left(-k\right)}\left(\lambda\right)$ $\displaystyle=$ $\displaystyle
2^{-k}2!\binom{k}{2}\lambda^{4}\left(\lambda-1\right)^{k-2},$
$\displaystyle\vdots$ $\displaystyle
Y_{j}^{\left(-k\right)}\left(\lambda\right)$ $\displaystyle=$ $\displaystyle
2^{-k}j!\binom{k}{j}\lambda^{2j}\left(\lambda-1\right)^{k-j}\quad\mathit{for}\quad
j\leq k,$ $\displaystyle\vdots$ $\displaystyle
Y_{k}^{\left(-k\right)}\left(\lambda\right)$ $\displaystyle=$ $\displaystyle
2^{-k}k!\lambda^{2k},$

(cf. [15]).

The combination of (1.7) with (1.8) yields the relation between the numbers
$Y_{n}^{\left(-k\right)}\left(\lambda\right)$ and the polynomials
$Q_{n}\left(x;\lambda,k\right)$ is given, for $k,n\in\mathbb{N}_{0}$, by

(1.10)
$Q_{n}\left(x;\lambda,k\right)=\sum_{j=0}^{n}\binom{n}{j}Y_{j}^{\left(-k\right)}\left(\lambda\right)\lambda^{n-j}\left(x\right)_{n-j},$

by which, one may easily compute first few values of the polynomials
$Q_{n}\left(x;\lambda,k\right)$ as below:

$\displaystyle Q_{0}\left(x;\lambda,k\right)$ $\displaystyle=$ $\displaystyle
2^{-k}\left(\lambda-1\right)^{k},$ $\displaystyle
Q_{1}\left(x;\lambda,k\right)$ $\displaystyle=$ $\displaystyle
2^{-k}\left(\lambda-1\right)^{k}\lambda
x+2^{-k}k\lambda^{2}\left(\lambda-1\right)^{k-1},$ $\displaystyle
Q_{2}\left(x;\lambda,k\right)$ $\displaystyle=$ $\displaystyle
2^{-k}\left(\lambda-1\right)^{k}\lambda^{2}x^{2}+\left(-2^{-k}\left(\lambda-1\right)^{k}\lambda^{2}+2^{-k+1}k\lambda^{3}\left(\lambda-1\right)^{k-1}\right)x$
$\displaystyle+2^{-k}k\left(k-1\right)\lambda^{4}\left(\lambda-1\right)^{k-1},$

and so on (cf. [15]).

Let $x\in\left[0,1\right]$ and $k\in\mathbb{N}_{0}$. Then, the Bernstein Basis
functions, $B_{k}^{n}(x)$, is defined as below:

(1.11) $B_{k}^{n}(x)=\binom{n}{k}x^{k}(1-x)^{n-k},\qquad\left(k=0,1,\dots,n;\
\ n\in\mathbb{N}_{0}\right)$

and its generating function is given by

(1.12)
$\frac{\left(xt\right)^{k}e^{\left(1-x\right)t}}{k!}=\sum_{n=0}^{\infty}B_{k}^{n}(x)\frac{t^{n}}{n!},$

so that the Bernstein Basis functions have relationships with a large number
of concepts including the Bezier curves, the binomial distribution, the
Poisson distribution, the Catalan numbers, and etc.; see, for details, [1, 10,
9, 16, 21, 23, 24, 25, 31] and also cited references therein.

It is concluded with the help of (1.9) and (1.11) that there exists the
following relation between the numbers
$Y_{n}^{\left(-k\right)}\left(\lambda\right)$ and the Bernstein basis
functions:

(1.13)
$Y_{n}^{\left(-k\right)}\left(\lambda\right)=\frac{\left(-1\right)^{k-n}n!}{2^{k}}\lambda^{n}B_{n}^{k}(\lambda)$

where $n,k\in\mathbb{N}_{0}$ and $\lambda\in\left[0,1\right]$ (cf. [15]).

Actually, the numbers $Y_{n}^{\left(-k\right)}\left(\lambda\right)$ have other
relations than its relation to the Bernstein basis functions. Among others,
the numbers $Y_{n}^{\left(-k\right)}\left(\lambda\right)$ have relationships
with the Poisson–Charlier polynomials, the Bell polynomials (i.e., exponential
polynomials) and other kinds of combinatorial numbers. To see the relations
mentioned above, the interested reader may glance at the recent paper [15].

The Stirling numbers of the first kind, $S_{1}(n,k)$, are defined, for
$n,k\in\mathbb{N}_{0}$, by the following recurrence relation:

$S_{1}(n+1,k)=-nS_{1}(n,k)+S_{1}(n,k-1)$

with the side conditions $S_{1}(0,0)=1$, $S_{1}(0,k)=0$ if $k>0$,
$S_{1}(n,0)=0$ if $n>0$, $S_{1}(n,k)=0$ if $k>n$; and these numbers are also
given by

(1.14) $\left(x\right)_{n}=\sum_{k=0}^{n}S_{1}\left(n,k\right)x^{k}$

and

(1.15)
$\frac{\left(\log(1+t)\right)^{k}}{k!}=\sum_{n=k}^{\infty}S_{1}(n,k)\frac{t^{n}}{n!}$

(cf. [2, 3, 5, 8, 18, 22]; and the references cited therein).

The Cauchy numbers (or the Bernoulli numbers of the second kind),
$b_{n}\left(0\right)$, are defined by

(1.16) $b_{n}\left(0\right)=\int\limits_{0}^{1}\left(x\right)_{n}dx$

and

(1.17)
$G_{C}\left(t\right):=\frac{t}{\log\left(t+1\right)}=\sum_{n=0}^{\infty}b_{n}\left(0\right)\frac{t^{n}}{n!}$

(cf. [20, p. 116], [13], [17], [18]).

The combination of (1.14) with (1.16) yields the relation between the Cauchy
numbers and the Stirling numbers of the first kind given by

(1.18)
$b_{n}\left(0\right)=\sum\limits_{m=0}^{n}\frac{S_{1}\left(n,m\right)}{m+1},$

(cf. [5, p. 294], [17, p. 1908], [20, p. 114]).

The Daehee numbers, $D_{n}$, are defined by the following generating function:

(1.19)
$F_{D}\left(t\right):=\frac{\log\left(1+t\right)}{t}=\sum_{n=0}^{\infty}D_{n}\frac{t^{n}}{n!}$

and these numbers are computed, for $n\in\mathbb{N}_{0}$, by the following
explicit formula:

(1.20) $D_{n}=\frac{\left(-1\right)^{n}n!}{n+1}$

(cf. [7, 11, 27, 28]).

The well-known Chu-Vandermonde identity is given by

(1.21)
$\binom{x+y}{n}=\frac{1}{n!}\sum\limits_{k=0}^{n}\binom{n}{k}\left(x\right)_{k}\left(y\right)_{n-k}$

(cf. [5, 6, 30]).

The outline of this paper may briefly given as follows:

In Section 2, we present various identities and computation formulas
containing not only the $\lambda$-Apostol-Daehee numbers and polynomials, but
also Simsek numbers and polynomials, the Stirling numbers of the first kind,
the Daehee numbers and the Chu-Vandermonde identity. Besides, we derive an
infinite series representation for the $\lambda$-Apostol-Daehee polynomials.

In Section 3, by using functional equations containing the generating
functions for the Cauchy numbers and the integrals of the generating functions
for the $\lambda$-Apostol-Daehee numbers and polynomials, we also derive some
identities and formulas for these numbers and polynomials.

In Section 4, we give Mathematica implementation of a formula which computes
the $\lambda$-Apostol-Daehee polynomials in terms of the Simsek polynomials.
By this implementation, some plots of the $\lambda$-Apostol-Daehee polynomials
are presented for some randomly selected special cases.

In Section 5, we conclude the paper with some comments and observations on our
results.

##  2\. Identities containing Apostol-type numbers and polynomials

In this section, by using the techniques of generating function and their
functional equations, we derive some identities involving not only the Chu-
Vandermonde identity, but also some special numbers and polynomials such as
the numbers $\mathfrak{D}_{n}\left(\lambda\right)$, the polynomials
$\mathfrak{D}_{n}\left(x;\lambda\right)$, the numbers
$Y_{n}\left(\lambda\right)$, the polynomials $Y_{n}\left(x;\lambda\right)$,
the numbers $S_{1}\left(n,m\right)$ and the numbers $D_{n}$. In addition, we
get computation formulas for not only the numbers
$\mathfrak{D}_{n}\left(\lambda\right)$, but also the polynomials
$\mathfrak{D}_{n}\left(x;\lambda\right)$. Moreover, we derive an infinite
series representation for the polynomials
$\mathfrak{D}_{m}\left(x;\lambda\right)$ in terms of the polynomials
$Q_{m}\left(x;\lambda,n\right)$.

By (1.2), we have

$\left(1+\lambda t\right)^{x}=\frac{\lambda\left(1+\lambda
t\right)-1}{\log\lambda+\log\left(1+\lambda
t\right)}\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(x;\lambda\right)\frac{t^{n}}{n!}$

and

$\left(1+\lambda t\right)^{y}=\frac{\lambda\left(1+\lambda
t\right)-1}{\log\lambda+\log\left(1+\lambda
t\right)}\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(y;\lambda\right)\frac{t^{n}}{n!}.$

Multiplying the above two equations each other, we get

$\left(1+\lambda t\right)^{x+y}=\left(\frac{\lambda\left(1+\lambda
t\right)-1}{\log\lambda+\log\left(1+\lambda
t\right)}\right)^{2}\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(x;\lambda\right)\frac{t^{n}}{n!}\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(y;\lambda\right)\frac{t^{n}}{n!}.$

With the application of the Binomial theorem and the Cauchy product rule to
the above equation, we get

$\sum_{n=0}^{\infty}\binom{x+y}{n}\lambda^{n}t^{n}=\frac{\left(\lambda\left(1+\lambda
t\right)-1\right)^{2}}{\left(\log\lambda\right)^{2}\left(1+\frac{\log\left(1+\lambda
t\right)}{\log\lambda}\right)^{2}}\sum_{n=0}^{\infty}\sum_{j=0}^{n}\binom{n}{j}\mathfrak{D}_{j}\left(x;\lambda\right)\mathfrak{D}_{n-j}\left(y;\lambda\right)\frac{t^{n}}{n!}.$

Thus, we have

$\displaystyle\sum_{n=0}^{\infty}\binom{x+y}{n}\lambda^{n}t^{n}$
$\displaystyle=$ $\displaystyle\frac{\left(\lambda\left(1+\lambda
t\right)-1\right)^{2}}{\left(\log\lambda\right)^{2}}\sum_{n=0}^{\infty}\binom{-2}{n}\frac{\left(\log\left(1+\lambda
t\right)\right)^{n}}{\left(\log\lambda\right)^{n}}$
$\displaystyle\times\sum_{n=0}^{\infty}\sum_{j=0}^{n}\binom{n}{j}\mathfrak{D}_{j}\left(x;\lambda\right)\mathfrak{D}_{n-j}\left(y;\lambda\right)\frac{t^{n}}{n!}.$

By combining (1.15) with the above equation, after some elementary
calculations, we get

$\displaystyle\sum_{n=0}^{\infty}\binom{x+y}{n}\lambda^{n}t^{n}$
$\displaystyle=$ $\displaystyle\frac{\left(\lambda\left(1+\lambda
t\right)-1\right)^{2}}{\left(\log\lambda\right)^{2}}\sum_{m=0}^{\infty}\sum_{n=0}^{m}\binom{-2}{n}n!\frac{S_{1}\left(m,n\right)}{\left(\log\lambda\right)^{n}}\frac{t^{m}}{m!}$
$\displaystyle\times\sum_{n=0}^{\infty}\sum_{j=0}^{n}\binom{n}{j}\mathfrak{D}_{j}\left(x;\lambda\right)\mathfrak{D}_{n-j}\left(y;\lambda\right)\frac{t^{n}}{n!}.$

By applying the Cauchy product rule to the above equation, we get

$\displaystyle\sum_{m=0}^{\infty}\binom{x+y}{m}\lambda^{m}t^{m}$
$\displaystyle=$
$\displaystyle\frac{\left(\lambda^{4}t^{2}+2\lambda^{2}\left(\lambda-1\right)t+\left(\lambda-1\right)^{2}\right)}{\left(\log\lambda\right)^{2}}$
$\displaystyle\times\sum_{m=0}^{\infty}\sum_{k=0}^{m}\binom{m}{k}\sum_{n=0}^{k}\binom{-2}{n}n!\frac{S_{1}\left(k,n\right)}{\left(\log\lambda\right)^{n}}$
$\displaystyle\times\sum_{j=0}^{m-k}\binom{m-k}{j}\mathfrak{D}_{j}\left(x;\lambda\right)\mathfrak{D}_{m-k-j}\left(y;\lambda\right)\frac{t^{m}}{m!}.$

After some elementary calculations and by comparing the coefficients of
$\frac{t^{m}}{m!}$ on both sides of the above equation, we arrive at the
following theorem:

######  Theorem 1.

Let $m\in\mathbb{N}\setminus\\{0,1\\}$. Then we have

$\displaystyle\binom{x+y}{m}$ $\displaystyle=$
$\displaystyle\frac{\lambda^{4-m}}{\left(\log\lambda\right)^{2}}m\left(m-1\right)A\left(m-2\right)$
$\displaystyle+\frac{2\lambda^{2-m}\left(\lambda-1\right)}{\left(\log\lambda\right)^{2}}mA\left(m-1\right)$
$\displaystyle+\frac{\lambda^{-m}\left(\lambda-1\right)^{2}}{\left(\log\lambda\right)^{2}}A\left(m\right),$

where

$\displaystyle
A\left(m\right)=\sum_{k=0}^{m}\sum_{n=0}^{k}\sum_{j=0}^{m-k}\binom{m}{k}\binom{-2}{n}\binom{m-k}{j}\frac{n!S_{1}\left(k,n\right)\mathfrak{D}_{j}\left(x;\lambda\right)\mathfrak{D}_{m-k-j}\left(y;\lambda\right)}{\left(\log\lambda\right)^{n}}.$

Combining (1) with (1.21) yields the following corollary:

######  Corollary 1.

Let $m\in\mathbb{N}\setminus\\{0,1\\}$. Then we have

$\displaystyle\sum\limits_{k=0}^{m}\binom{m}{k}\left(x\right)_{k}\left(y\right)_{m-k}$
$\displaystyle=$
$\displaystyle\frac{\lambda^{4-m}}{\left(\log\lambda\right)^{2}}m\left(m-1\right)A\left(m-2\right)$
$\displaystyle+\frac{2\lambda^{2-m}\left(\lambda-1\right)}{\left(\log\lambda\right)^{2}}mA\left(m-1\right)$
$\displaystyle+\frac{\lambda^{-m}\left(\lambda-1\right)^{2}}{\left(\log\lambda\right)^{2}}A\left(m\right).$

By the combination of (1.2) with (1.4) and (1.19), we get the following
functional equation:

(2.3)
$G_{\mathfrak{D}}\left(t,x;\lambda\right)=\left(\frac{\log\lambda}{2}+\frac{\lambda
tF_{D}\left(\lambda t\right)}{2}\right)F\left(t,x,\lambda\right).$

which yields

$\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(x;\lambda\right)\frac{t^{n}}{n!}=\left(\frac{\log\lambda}{2}+\frac{\lambda
t}{2}\sum_{n=0}^{\infty}\lambda^{n}D_{n}\frac{t^{n}}{n!}\right)\sum_{n=0}^{\infty}{Y}_{n}\left(x;\lambda\right)\frac{t^{n}}{n!}.$

By applying the Cauchy product rule to the above equation, after some
elementary calculations, we get

$\displaystyle\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(x;\lambda\right)\frac{t^{n}}{n!}$
$\displaystyle=$
$\displaystyle\frac{\log\lambda}{2}\sum_{n=0}^{\infty}{Y}_{n}\left(x;\lambda\right)\frac{t^{n}}{n!}$
$\displaystyle+\frac{1}{2}\sum_{n=0}^{\infty}\sum_{j=0}^{n-1}n\binom{n-1}{j}\lambda^{n-j}D_{n-j-1}{Y}_{j}\left(x;\lambda\right)\frac{t^{n}}{n!}.$

Comparing the coefficients of $\frac{t^{n}}{n!}$ on both sides of the above
equation yields the following theorem:

######  Theorem 2.

Let $n\in\mathbb{N}$. Then we have

(2.4)
$\mathfrak{D}_{n}\left(x;\lambda\right)=\frac{\log\lambda}{2}{Y}_{n}\left(x;\lambda\right)+\frac{1}{2}\sum\limits_{j=0}^{n-1}n\binom{n-1}{j}\lambda^{n-j}D_{n-j-1}{Y}_{j}\left(x;\lambda\right).$

Using (1.20) in (2.4), we get a relation between $\lambda$-Apostol-Daehee
polynomials and Simsek polynomials, given by following corollary:

######  Corollary 2.

Let $n\in\mathbb{N}$. Then we have

(2.5)
$\mathfrak{D}_{n}\left(x;\lambda\right)=\frac{\log\lambda}{2}{Y}_{n}\left(x;\lambda\right)-\frac{n!}{2}\sum\limits_{j=0}^{n-1}\left(-1\right)^{n-j}\frac{\lambda^{n-j}{Y}_{j}\left(x;\lambda\right)}{j!\left(n-j\right)}.$

Substituting $x=0$ into (2.5), we also get a relation, between
$\lambda$-Apostol-Daehee numbers and Simsek numbers, given by following
corollary:

######  Corollary 3.

Let $n\in\mathbb{N}$. Then we have

(2.6)
$\mathfrak{D}_{n}\left(\lambda\right)=\frac{\log\lambda}{2}{Y}_{n}\left(\lambda\right)+\frac{n!}{2}\sum\limits_{j=0}^{n-1}\left(-1\right)^{n-j-1}\frac{\lambda^{n-j}{Y}_{j}\left(\lambda\right)}{j!\left(n-j\right)}.$

Combining (1.5) with (2.6), we get a computation formula for the numbers
$\mathfrak{D}_{n}\left(\lambda\right)$ by the following corollary:

######  Corollary 4.

(2.7)
$\mathfrak{D}_{n}\left(\lambda\right)=\frac{(-1)^{n}n!}{\lambda-1}\left(\left(\frac{\lambda^{2}}{\lambda-1}\right)^{n}\log\lambda-\lambda^{n}\sum\limits_{j=0}^{n-1}\frac{1}{n-j}\left(\frac{\lambda}{\lambda-1}\right)^{j}\right).$

######  Remark 1.

The computation formula (2.7), obtained by reduction from the equation (2.4),
may also be obtained with the help of the application of the binomial theorem
on the generating function for the numbers
$\mathfrak{D}_{n}\left(\lambda\right)$. In the meanwhile, for another form of
this formula, the interested reader may see the recent paper [14, Theorem 8,
p. 492] in which other methods and generating function families used in order
to achieve the aforementioned formula.

By (2.7), we obtain a finite sum whose values is computed by the numbers
$\mathfrak{D}_{n}\left(\lambda\right)$ given by the following corollary:

######  Corollary 5.

Let $n\in\mathbb{N}$. Then we have

(2.8)
$\sum\limits_{j=0}^{n-1}\frac{1}{n-j}\left(\frac{\lambda}{\lambda-1}\right)^{j}=(-1)^{n+1}\frac{\left(\lambda-1\right)\mathfrak{D}_{n}\left(\lambda\right)}{n!\lambda^{n}}+\left(\frac{\lambda}{\lambda-1}\right)^{n}\log\lambda.$

By using the Taylor series expansion of the function
$\log\left(1+\left(\lambda\left(1+\lambda t\right)-1\right)\right)$, by
assuming that $|\lambda\left(1+\lambda t\right)-1|<1$, in the equation (1.2),
and then by making some simplifications, we get

$\sum_{m=0}^{\infty}\mathfrak{D}_{m}\left(x;\lambda\right)\frac{t^{m}}{m!}=\left(1+\lambda
t\right)^{x}\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{\left(\lambda\left(1+\lambda
t\right)-1\right)^{n}}{n+1}.$

By combining (1.8) with the above equation, we get

$\sum_{m=0}^{\infty}\mathfrak{D}_{m}\left(x;\lambda\right)\frac{t^{m}}{m!}=\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{2^{n}}{n+1}\sum_{m=0}^{\infty}Q_{m}\left(x;\lambda,n\right)\frac{t^{m}}{m!}.$

which yields

$\sum_{m=0}^{\infty}\mathfrak{D}_{m}\left(x;\lambda\right)\frac{t^{m}}{m!}=\sum_{n=0}^{\infty}\sum_{m=0}^{\infty}\left(-1\right)^{n}\frac{2^{n}Q_{m}\left(x;\lambda,n\right)}{n+1}\frac{t^{m}}{m!}.$

By assuming that $|\lambda-1|<1$ and comparing the coefficients of
$\frac{t^{m}}{m!}$ on both sides of the above equation yields a relation,
between the numbers $\mathfrak{D}_{m}\left(x;\lambda\right)$ and the
polynomials $Q_{m}\left(x;\lambda,n\right)$, given by the following theorem:

######  Theorem 3.

If $|\lambda-1|<1$, then we have the following infinite series representation
for the polynomials $\mathfrak{D}_{m}\left(x;\lambda\right)$:

(2.9)
$\mathfrak{D}_{m}\left(x;\lambda\right)=\sum_{n=0}^{\infty}\left(-1\right)^{n}\frac{2^{n}Q_{m}\left(x;\lambda,n\right)}{n+1}.$

##  3\. Further identities derived from integral formulas and Cauchy numbers

In this section, by using functional equations involving the generating
functions for the Cauchy numbers and the integrals of the generating functions
for the numbers $\mathfrak{D}_{n}\left(\lambda\right)$, the polynomials
$\mathfrak{D}_{n}\left(x;\lambda\right)$, we derive some identities and
formulas.

Integrating both-sides of the equation (1.2), with respect to the variable
$x$, from $0$ to $1$, we get the following integral formula:

(3.1)
$\displaystyle\int\limits_{0}^{1}G_{\mathfrak{D}}\left(t,x;\lambda\right)\mathrm{d}x$
$\displaystyle=$
$\displaystyle\int\limits_{0}^{1}\frac{\log\lambda+\log\left(1+\lambda
t\right)}{\lambda\left(1+\lambda t\right)-1}\left(1+\lambda
t\right)^{x}\mathrm{d}x$ (3.2) $\displaystyle=$ $\displaystyle\frac{\lambda
t\left(\log\lambda+\log\left(1+\lambda
t\right)\right)}{\left(\lambda\left(1+\lambda
t\right)-1\right)\log\left(1+\lambda t\right)},$

which, by (1.17) and (1.1), yields the following functional equation:

(3.3)
$\displaystyle\int\limits_{0}^{1}G_{\mathfrak{D}}\left(t,x;\lambda\right)\mathrm{d}x=G_{\mathfrak{D}}\left(t;\lambda\right)G_{C}\left(\lambda
t\right).$

Combining the above equation with (1.17), (1.1) and (1.2) yields

(3.4)
$\displaystyle\int\limits_{0}^{1}\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(x;\lambda\right)\frac{t^{n}}{n!}\mathrm{d}x=\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(\lambda\right)\frac{t^{n}}{n!}\sum_{n=0}^{\infty}\lambda^{n}b_{n}\left(0\right)\frac{t^{n}}{n!}.$

By applying the Cauchy product rule to the right-hand side of the above
equation, after some elementary calculations, we get

(3.5)
$\displaystyle\sum_{n=0}^{\infty}\int\limits_{0}^{1}\mathfrak{D}_{n}\left(x;\lambda\right)\mathrm{d}x\frac{t^{n}}{n!}=\sum_{n=0}^{\infty}\sum_{m=0}^{n}\binom{n}{m}\lambda^{m}b_{m}\left(0\right)\mathfrak{D}_{n-m}\left(\lambda\right)\frac{t^{n}}{n!}.$

Comparing the coefficients of $\frac{t^{n}}{n!}$ on both sides of the above
equation yields the following theorem:

######  Theorem 4.

(3.6)
$\displaystyle\int\limits_{0}^{1}\mathfrak{D}_{n}\left(x;\lambda\right)\mathrm{d}x=\sum_{m=0}^{n}\binom{n}{m}\lambda^{m}b_{m}\left(0\right)\mathfrak{D}_{n-m}\left(\lambda\right).$

######  Remark 2.

By using the generating function for the $k$-th order $\lambda$-Apostol-Daehee
polynomials, Choi [4, Theorem 5, p.1854] gave the following integral formula:

$\int\limits_{\alpha}^{\alpha+1}\mathfrak{D}^{\left(k\right)}_{n}\left(x;\lambda\right)\mathrm{d}x=\sum_{m=0}^{n}m!\binom{n}{m}\lambda^{m}\mathfrak{D}^{\left(k\right)}_{n-m}\left(\alpha;\lambda\right)p_{m}.$

If we substitute $k=1$ and $\alpha=0$ into the above formula, we get

$\int\limits_{0}^{1}\mathfrak{D}_{n}\left(x;\lambda\right)\mathrm{d}x=\sum_{m=0}^{n}m!\binom{n}{m}\lambda^{m}\mathfrak{D}_{n-m}\left(\lambda\right)p_{m}.$

When we compare the above formula with the equation (3.6), it is shown that
the numbers $m!p_{m}$ considered in the formula above actually correspond to
the Cauchy numbers $b_{m}\left(0\right)$ which is obtained by the techniques
of generating functions and their functional equations. Thus, we conclude that
Choi [4] modified the numbers $b_{m}\left(0\right)$ as follows:

$m!p_{m}=b_{m}\left(0\right)$

in order to obtain an integral formula for the higher-order $\lambda$-Apostol-
Daehee polynomials.

Integrating both-sides of the equation (1.2), with respect to the variable
$x$, from $0$ to $z$, we get the following integral formula:

(3.7)
$\displaystyle\int\limits_{0}^{z}G_{\mathfrak{D}}\left(t,x;\lambda\right)\mathrm{d}x$
$\displaystyle=$
$\displaystyle\int\limits_{0}^{z}\frac{\log\lambda+\log\left(1+\lambda
t\right)}{\lambda\left(1+\lambda t\right)-1}\left(1+\lambda
t\right)^{x}\mathrm{d}x$ (3.8) $\displaystyle=$
$\displaystyle\frac{\left(\left(1+\lambda
t\right)^{z}-1\right)\left(\log\lambda+\log\left(1+\lambda
t\right)\right)}{\left(\lambda\left(1+\lambda
t\right)-1\right)\log\left(1+\lambda t\right)}$

which, by (1.1) and (1.2), yields the following functional equation:

(3.9)
$\displaystyle\int\limits_{0}^{z}G_{\mathfrak{D}}\left(t,x;\lambda\right)\mathrm{d}x=\frac{\left(G_{\mathfrak{D}}\left(t,z;\lambda\right)-G_{\mathfrak{D}}\left(t;\lambda\right)\right)G_{C}\left(\lambda
t\right)}{\lambda t}.$

Combining the above equation with (1.17), (1.1) and (1.2) yields

$\displaystyle\int\limits_{0}^{z}\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(x;\lambda\right)\frac{t^{n}}{n!}\mathrm{d}x=\frac{1}{\lambda
t}\left(\sum_{n=0}^{\infty}\left(\mathfrak{D}_{n}\left(z;\lambda\right)-\mathfrak{D}_{n}\left(\lambda\right)\right)\frac{t^{n}}{n!}\right)\sum_{n=0}^{\infty}\lambda^{n}b_{n}\left(0\right)\frac{t^{n}}{n!}.$

By applying the Cauchy product rule to the right-hand side of the above
equation, after some elementary calculations, we get

$\displaystyle\int\limits_{0}^{z}\sum_{n=0}^{\infty}\mathfrak{D}_{n}\left(x;\lambda\right)\frac{t^{n}}{n!}\mathrm{d}x$
$\displaystyle=$
$\displaystyle\sum_{n=0}^{\infty}\frac{1}{n+1}\sum_{m=0}^{n+1}\binom{n+1}{m}\lambda^{m-1}b_{m}\left(0\right)$
$\displaystyle\times\left(\mathfrak{D}_{n+1-m}\left(z;\lambda\right)-\mathfrak{D}_{n+1-m}\left(\lambda\right)\right)\frac{t^{n}}{n!}.$

Comparing the coefficients of $\frac{t^{n}}{n!}$ on both sides of the above
equation yields the following theorem:

######  Theorem 5.

(3.10)
$\displaystyle\int\limits_{0}^{z}\mathfrak{D}_{n}\left(x;\lambda\right)\mathrm{d}x$
$\displaystyle=\frac{1}{n+1}\sum_{m=0}^{n+1}\binom{n+1}{m}\lambda^{m-1}b_{m}\left(0\right)\left(\mathfrak{D}_{n+1-m}\left(z;\lambda\right)-\mathfrak{D}_{n+1-m}\left(\lambda\right)\right).$

##  4\. Implementation of computation formulas involving $\lambda$-Apostol-
Daehee polynomials

In this section, by implementing some of our results with the aid of the
Wolfram programming language in Mathematica [35], we compute a few values of
the $\lambda$-Apostol-Daehee polynomials. In addition, we also give some
illustrations involving two dimensional plots of the $\lambda$-Apostol-Daehee
polynomials.

We first give Mathematica implementation of the equation (2.4) in
Implementation 1 in which we utilized from the Implementation 2 and the
Implementation 3 given by Simsek and Kucukoglu [33] in order to compute the
rational functions $Y_{n}\left(\lambda\right)$ and the polynomials
$Y_{n}\left(x;\lambda\right)$.

Implementation 1: Let the expression lparameter denote the parameter $\lambda$
of the polynomials $\mathfrak{D}_{n}\left(x;\lambda\right)$. Then, the
following Mathematica code returns the values of these polynomials.

⬇

1DPoly[x_,lparameter_,n_]:=(Log[lparameter]/2)*YPoly[x,lparameter,n]+(Factorial[n]/2)*Sum[((-1)^(n-j-1))*((((lparameter)^(n-j))*YPoly[x,lparameter,j])/(Factorial[j]*(n-j))),
{j,0,n-1}]

Implementation 2: Let the expression lparameter denote the parameter $\lambda$
of the polynomials $Y_{n}\left(x;\lambda\right)$. Then, the following
Mathematica code returns the values of these polynomials (cf. [33]).

⬇

1YPoly[x_,lparameter_,n_]:=Sum[Binomial[n,j]*(lparameter^(n-j))*FactorialPower[x,
n-j, 1]*YNum[lparameter,j], {j,0,n}]

Implementation 3: Let the expression lparameter denote the parameter
$\lambda$. Then, the following Mathematica code returns the values of the
rational functions $Y_{n}\left(\lambda\right)$ (cf. [33]).

⬇

1YNum[l_,n_]:=2*((-1)^n)* (Factorial[n]/(l-1))*(((l^2)/(l-1))^n)

By using the Implementation 1 in Mathematica, we compute first three values of
the $\lambda$-Apostol-Daehee polynomials as follows:

$\displaystyle\mathfrak{D}_{0}\left(x;\lambda\right)=\frac{\log\lambda}{\lambda-1},$
$\displaystyle\mathfrak{D}_{1}\left(x;\lambda\right)=\frac{\lambda}{\lambda-1}+\left(\frac{\lambda
x}{\lambda-1}-\frac{\lambda^{2}}{\left(\lambda-1\right)^{2}}\right)\log\lambda,$
$\displaystyle\mathfrak{D}_{2}\left(x;\lambda\right)=-\frac{2\lambda^{3}}{\left(\lambda-1\right)^{2}}+\frac{\lambda^{2}\left(2x-1\right)}{\lambda-1}+\left(\frac{2\lambda^{4}}{\left(\lambda-1\right)^{3}}-\frac{2\lambda^{3}x}{\left(\lambda-1\right)^{2}}+\frac{\lambda^{2}x\left(x-1\right)}{\lambda-1}\right)\log\lambda,$

and so on.

By using the Implementation 1 and the Plot command in Mathematica, we also
give some two dimensional plots of the polynomials
$\mathfrak{D}_{n}\left(x;\lambda\right)$ in Figure 1-Figure 5.

Figure 1-Figure 3 shows the effects of the parameter $x$ on the graphs of the
polynomials $\mathfrak{D}_{n}\left(x;\lambda\right)$.

Figure 1. Plots of the polynomials $\mathfrak{D}_{n}\left(1;\lambda\right)$
for randomly selected special case when
$\lambda\in\left[\frac{3}{2},\frac{7}{2}\right]$ with $n\in\\{0,1,2,3\\}$.
Figure 2. Plots of the polynomials $\mathfrak{D}_{n}\left(2;\lambda\right)$
for randomly selected special case when
$\lambda\in\left[\frac{3}{2},\frac{7}{2}\right]$ with $n\in\\{0,1,2,3\\}$.
Figure 3. Plots of the polynomials $\mathfrak{D}_{n}\left(3;\lambda\right)$
for randomly selected case when
$\lambda\in\left[\frac{3}{2},\frac{7}{2}\right]$ with $n\in\\{0,1,2,3\\}$.

Figure 5 shows the effects of the parameter $\lambda$ on the graphs of the
polynomials $\mathfrak{D}_{n}\left(x;\lambda\right)$.

(a)

(b)

(c)

Figure 4. Plots of the polynomials $\mathfrak{D}_{n}\left(x;\lambda\right)$
for the randomly selected special cases when $x\in\left[-2,2\right]$ and
$n\in\\{0,1,2,3\\}$ (a) $\lambda=\frac{3}{2}$; (b) $\lambda=e$; (c)
$\lambda=\frac{7}{2}$; (d) $\lambda=e^{2}$. (a) Figure 5. Plots of the
polynomials $\mathfrak{D}_{n}\left(x;\lambda\right)$ for the randomly selected
special cases when $x\in\left[-2,2\right]$ and $n\in\\{0,1,2,3\\}$ (a)
$\lambda=\frac{3}{2}$; (b) $\lambda=e$; (c) $\lambda=\frac{7}{2}$; (d)
$\lambda=e^{2}$.

##  5\. Conclusion

In this paper, we present various identities and computation formulas
containing not only the $\lambda$-Apostol-Daehee numbers and polynomials, but
also Simsek numbers and polynomials, the Stirling numbers of the first kind,
the Daehee numbers, and also the Chu-Vandermonde identity. Furthermore, by
using functional equations containing the generating functions for the Cauchy
numbers and the integrals of the generating functions for the
$\lambda$-Apostol-Daehee numbers and polynomials, we also derive some
identities and formulas for these numbers and polynomials. In addition, we
give Mathematica implementation of a computation formula which computes the
$\lambda$-Apostol-Daehee polynomials in terms of the polynomials
$Y_{n}\left(x;\lambda\right)$. By the aid of the Mathematica implementation,
we also give some plots which help the readers to analyze the behaviour of the
$\lambda$-Apostol-Daehee polynomials for some randomly selected special cases
of its parameters. As a conclusion, the results of this paper have the
potential to affect many researchers conducting a research not only in
computational mathematics, discrete mathematics and combinatorics, but also in
other related fields.

For future studies, it is planned to investigate connections of the
$\lambda$-Apostol-Daehee numbers with some special functions such as the
Bernstein basis functions which possess many applications not only in
approximation theory, but also in the construction of the Bezier curves widely
used in computer-aided geometric design (cf. [1, 10, 9, 16, 21, 23, 24, 25,
31] and also cited references therein).

## References

  * [1] Acikgoz, M., Araci, S., On generating function of the Bernstein polynomials, AIP Conf. Proc., 1281 (1) (2010), 1141, https://dx.doi.org/10.1063/1.3497855.
  * [2] Bona, M., Introduction to Enumerative Combinatorics, The McGraw-Hill Companies Inc., New York, 2007.
  * [3] Charalambides, C. A., Enumerative Combinatorics, Chapman and Hall/ CRC Press Company, London, 2002.
  * [4] Choi, J., Note on Apostol-Daehee polynomials and numbers, Far East J. Math. Sci., 101 (8) (2017), 1845–1857.
  * [5] Comtet, L., Advanced Combinatorics, D. Reidel Publication Company, Dordrecht-Holland/Boston-U.S.A., 1974.
  * [6] Jordan, C., Calculus of Finite Differences (2nd ed.), Chelsea Publishing Company, New York, 1950.
  * [7] El-Desouky, B. S., Mustafa, A., New results and matrix representation for Daehee and Bernoulli numbers and polynomials, Appl. Math. Sci. (Ruse) 9 (2015), 3593–3610.
  * [8] Cakic, N. P., Milovanovic, G. V., On generalized Stirling numbers and polynomials, Mathematica Balkanica 18 (2004), 241–248.
  * [9] Duman, O., Nonlinear Bernstein-type operators providing a better error estimation, Miskolc Math. Notes, 15 (2) (2014), 393–400.
  * [10] Erkus, E., Duman, O., Srivastava, H. M., Statistical approximation of certain positive linear operators constructed by means of the Chan-Chyan-Srivastava polynomials, Appl. Math. Comput., 182 (2006), 213–222.
  * [11] Kim, D. S., Kim, T., Daehee numbers and polynomials, Appl. Math. Sci. (Ruse), 7 (2013), 5969–5976.
  * [12] Kim, D. S., Kim, T., Lee, S.-H., Seo, J.-J., A Note on the lambda-Daehee Polynomials, Int. J. Math. Anal, 7 (62) (2013), 3069–3080.
  * [13] Kim, T., Kim, D. S., Dolgy, D. V., Seo J.-J., Bernoulli polynomials of the second kind and their identities arising from umbral calculus, J. Nonlinear Sci. Appl. 9 (2016), 860–869.
  * [14] Kucukoglu, I., Simsek, Y., On a family of special numbers and polynomials associated with Apostol-type numbers and poynomials and combinatorial numbers, Appl. Anal. Discrete Math., 13 (2019), 478–494.
  * [15] Kucukoglu, I., Simsek, B., Simsek, Y., Generating Functions for New Families of Combinatorial Numbers and Polynomials: Approach to Poisson–Charlier Polynomials and Probability Distribution Function, Axioms, 8 (4) (2019), 112, https://dx.doi.org/10.3390/axioms8040112.
  * [16] Lorentz, G. G., Bernstein Polynomials, Chelsea Pub. Comp., New York, NY, USA, 1986.
  * [17] Merlini, D., Sprugnoli, R., Verri, M. C., The Cauchy numbers, Discrete Math., 306 (16) (2006), 1906–1920.
  * [18] Qi, F., Explicit formulas for computing Bernoulli numbers of the second kind and Stirling numbers of the first kind, Filomat, 28 (2) (2014), 319–327.
  * [19] Park, J.-W., On the $\lambda$-Daehee polynomials with $q$-parameter, J. Comput. Anal. Appl., 20 (1) (2016), 11–20.
  * [20] Roman, S., The Umbral Calculus, Dover Publ. Inc., New York, 2005.
  * [21] Simsek, Y., Functional equations from generating functions: A novel approach to deriving identities for the Bernstein basis functions, Fixed Point Theory Appl., Article number: 80 (2013), 1–13.
  * [22] Simsek, Y., Generating functions for generalized Stirling type numbers, array type polynomials, Eulerian type polynomials and their alications, Fixed Point Theory Appl., 87 (2013), 343–355.
  * [23] Simsek, Y., Unification of the Bernstein-type polynomialsand their applications, Bound. Value Probl., Article number: 56 (2013), 1–15.
  * [24] Simsek, Y., Generating functions for the Bernstein type polynomials: A new approach to deriving identities and applications for the polynomials, Hacet. J. Math. Stat., 43 (1) (2014), 1–14.
  * [25] Simsek, Y., Analysis of the Bernstein basis functions: an approach to combinatorial sums involving binomial coefficients and Catalan numbers, Math. Methods Appl. Sci., 38 (14) (2015), 3007–3021.
  * [26] Simsek, Y., Analysis of the $p$-adic $q$-Volkenborn integrals: An approach to generalized Apostol-type special numbers and polynomials and their applications, Cogent Math. Stat. 1269393 (2016), https://dx.doi.org/10.1080/23311835.2016.1269393.
  * [27] Simsek, Y., Apostol type Daehee numbers and polynomials, Adv. Stud. Contemp. Math. (Kyungshang), 26 (3) (2016), 555–566.
  * [28] Simsek, Y., Identities on the Changhee numbers and Apostol-type Daehee polynomials, Adv. Stud. Contemp. Math. (Kyungshang), 27 (2) (2017), 199–212.
  * [29] Simsek, Y., Construction of some new families of Apostol-type numbers and polynomials via Dirichlet character and $p$-adic $q$-integrals, Turk. J. Math., 42 (2018), 557–577.
  * [30] Simsek, Y., Explicit formulas for $p$-adic integrals: Approach to $p$-adic distributions and some families of special numbers and polynomials, Montes Taurus J. Pure Appl. Math., 1 (1) (2019), 1–76.
  * [31] Simsek, Y., Acikgoz, M., A new generating function of ($q$-) Bernstein-type polynomials and their interpolation function, Abstr. Appl. Anal., 769095 (2010), https://dx.doi.org/10.1155/2010/769095.
  * [32] Simsek, Y., Yardimci, A., Applications on the Apostol-Daehee numbers and polynomials associated with special numbers, polynomials, and $p$-adic integrals, Adv. Difference Equ., 308 (2016), https://dx.doi.org/10.1186/s13662-016-1041-x.
  * [33] Simsek, Y., Kucukoglu, I., Some Certain Classes of Combinatorial Numbers and Polynomials Attached to Dirichlet Characters: Their Construction by $p$-adic Integration and Applications to Probability Distribution Functions, A Chapter in the Book: Mathematical Analysis in Interdisciplinary Research, Th. M. Rassias, I. N. Parasidis and E. Providas (Eds.), Springer International Publishing, Springer Nature Switzerland AG, In press.
  * [34] Srivastava, H. M., Kucukoglu, I., Simsek, Y., Partial differential equations for a new family of numbers and polynomials unifying the Apostol-type numbers and the Apostol-type polynomials, J. Number Theory, 181 (2017), 117–146.
  * [35] Wolfram Research Inc., Mathematica Online (Wolfram Cloud), Champaign, IL, 2020, https://www.wolframcloud.com