diff --git a/README.rst b/README.rst
index c207324d..e1aa8e5e 100644
--- a/README.rst
+++ b/README.rst
@@ -80,6 +80,7 @@ Besides the numerical argument, there are two main optional arguments, ``to:`` a
 * ``ar`` (Arabic)
 * ``az`` (Azerbaijani)
 * ``be`` (Belarusian)
+* ``bn`` (Bangladeshi)
 * ``ce`` (Chechen)
 * ``cy`` (Welsh)
 * ``cz`` (Czech)
diff --git a/num2words/__init__.py b/num2words/__init__.py
index c513d853..da0eceea 100644
--- a/num2words/__init__.py
+++ b/num2words/__init__.py
@@ -17,21 +17,22 @@
 
 from __future__ import unicode_literals
 
-from . import (lang_AM, lang_AR, lang_AZ, lang_BE, lang_CA, lang_CE, lang_CY,
-               lang_CZ, lang_DE, lang_DK, lang_EN, lang_EN_IN, lang_EN_NG,
-               lang_EO, lang_ES, lang_ES_CO, lang_ES_CR, lang_ES_GT,
-               lang_ES_NI, lang_ES_VE, lang_FA, lang_FI, lang_FR, lang_FR_BE,
-               lang_FR_CH, lang_FR_DZ, lang_HE, lang_HU, lang_ID, lang_IS,
-               lang_IT, lang_JA, lang_KN, lang_KO, lang_KZ, lang_LT, lang_LV,
-               lang_NL, lang_NO, lang_PL, lang_PT, lang_PT_BR, lang_RO,
-               lang_RU, lang_SK, lang_SL, lang_SR, lang_SV, lang_TE, lang_TET,
-               lang_TG, lang_TH, lang_TR, lang_UK, lang_VI)
+from . import (lang_AM, lang_AR, lang_AZ, lang_BE, lang_BN, lang_CA, lang_CE,
+               lang_CY, lang_CZ, lang_DE, lang_DK, lang_EN, lang_EN_IN,
+               lang_EN_NG, lang_EO, lang_ES, lang_ES_CO, lang_ES_CR,
+               lang_ES_GT, lang_ES_NI, lang_ES_VE, lang_FA, lang_FI, lang_FR,
+               lang_FR_BE, lang_FR_CH, lang_FR_DZ, lang_HE, lang_HU, lang_ID,
+               lang_IS, lang_IT, lang_JA, lang_KN, lang_KO, lang_KZ, lang_LT,
+               lang_LV, lang_NL, lang_NO, lang_PL, lang_PT, lang_PT_BR,
+               lang_RO, lang_RU, lang_SK, lang_SL, lang_SR, lang_SV, lang_TE,
+               lang_TET, lang_TG, lang_TH, lang_TR, lang_UK, lang_VI)
 
 CONVERTER_CLASSES = {
     'am': lang_AM.Num2Word_AM(),
     'ar': lang_AR.Num2Word_AR(),
     'az': lang_AZ.Num2Word_AZ(),
     'be': lang_BE.Num2Word_BE(),
+    'bn': lang_BN.Num2Word_BN(),
     'ca': lang_CA.Num2Word_CA(),
     'ce': lang_CE.Num2Word_CE(),
     'cy': lang_CY.Num2Word_CY(),
diff --git a/num2words/lang_BN.py b/num2words/lang_BN.py
new file mode 100644
index 00000000..ef86ed71
--- /dev/null
+++ b/num2words/lang_BN.py
@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+# Author: Mehedi Hasan Khondoker
+# Email: mehedihasankhondoker [at] gmail.com
+# Copyright (c) 2024, Mehedi Hasan Khondoker.  All Rights Reserved.
+
+# This library is build for Bangladesh format Number to Word conversion.
+# You are welcome as contributor to the library.
+
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+
+
+from decimal import Decimal
+
+RANKING = ['', 'প্রথম', 'দ্বিতীয়', 'তৃতীয়', 'চতুর্থ', 'পঞ্চম', 'ষষ্ঠ',
+           'সপ্তম', 'অষ্টম', 'নবম', 'দশম']  # pragma: no cover
+
+AKOK = ['', 'এক', 'দুই', 'তিন', 'চার', 'পাঁচ', 'ছয়',
+        'সাত', 'আট', 'নয়']  # pragma: no cover
+
+DOSOK = [
+    'দশ', 'এগারো', 'বারো', 'তেরো', 'চৌদ্দ', 'পনের',
+    'ষোল', 'সতের', 'আঠারো', 'উনিশ',
+    'বিশ', 'একুশ', 'বাইশ', 'তেইশ', 'চব্বিশ', 'পঁচিশ',
+    'ছাব্বিশ', 'সাতাশ', 'আটাশ', 'উনত্রিশ',
+    'ত্রিশ', 'একত্রিশ', 'বত্রিশ', 'তেত্রিশ', 'চৌত্রিশ', 'পঁইত্রিশ',
+    'ছত্রিশ', 'সাতত্রিশ', 'আটত্রিশ', 'উনচল্লিশ', 'চল্লিশ',
+    'একচল্লিশ', 'বিয়াল্লিশ', 'তেতাল্লিশ', 'চৌচল্লিশ',
+    'পঁয়তাল্লিশ', 'ছেচল্লিশ', 'সাতচল্লিশ', 'আটচল্লিশ', 'উনপঞ্চাশ',
+    'পঞ্চাশ', 'একান্ন', 'বাহান্ন', 'তিপ্পান্ন', 'চুয়ান্ন', 'পঞ্চান্ন',
+    'ছাপ্পান্ন', 'সাতান্ন', 'আটান্ন', 'উনষাট', 'ষাট',
+    'একষট্টি', 'বাষট্টি', 'তেষট্টি', 'চৌষট্টি', 'পঁয়ষট্টি',
+    'ছিষট্টি', 'সাতষট্টি', 'আটষট্টি', 'উনসত্তর', 'সত্তর',
+    'একাত্তর ', 'বাহাত্তর', 'তিয়াত্তর', 'চুয়াত্তর', 'পঁচাত্তর',
+    'ছিয়াত্তর', 'সাতাত্তর', 'আটাত্তর', 'উনআশি', 'আশি',
+    'একাশি', 'বিরাশি', 'তিরাশি', 'চুরাশি', 'পঁচাশি',
+    'ছিয়াশি', 'সাতাশি', 'আটাশি', 'উননব্বই', 'নব্বই',
+    'একানব্বই', 'বিরানব্বই', 'তিরানব্বই', 'চুরানব্বই', 'পঁচানব্বই',
+    'ছিয়ানব্বই', 'সাতানব্বই', 'আটানব্বই', 'নিরানব্বই'
+]  # pragma: no cover
+HAZAR = ' হাজার '  # pragma: no cover
+LAKH = ' লাখ '  # pragma: no cover
+KOTI = ' কোটি '  # pragma: no cover
+MAX_NUMBER = 9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999  # noqa: E501 # pragma: no cover
+
+
+class NumberTooLargeError(Exception):
+    """Custom exception for numbers that are too large."""
+    pass
+
+
+class Num2Word_BN:
+
+    @staticmethod
+    def str_to_number(number):
+        return abs(Decimal(str(number)))  # pragma: no cover
+
+    @staticmethod
+    def parse_number(number: Decimal):
+        dosomik = str(number - int(number)).split('.')[1:]
+        dosomik_str = ''.join(dosomik) if dosomik else 0
+        return int(number), int(dosomik_str)
+
+    @staticmethod
+    def parse_paisa(number: Decimal):
+        # 1-99 for paisa count so two digits are valid.
+        paisa = str(number - int(number)).split('.')[1:]
+        paisa_str = ''.join(paisa) if paisa else 0
+
+        # this is need, when we parse to decimal it removes trailing 0 .
+        if paisa_str:
+            paisa_str = str(int(paisa_str) * 100)[:2]
+        return int(number), int(paisa_str)
+
+    def _is_smaller_than_max_number(self, number):
+        if MAX_NUMBER >= number:
+            return True
+        raise NumberTooLargeError(f'Too Large number maximum '
+                                  f'value={MAX_NUMBER}')
+
+    def _dosomik_to_bengali_word(self, number):
+        word = ''
+        for i in str(number):
+            word += ' ' + AKOK[int(i)]
+        return word
+
+    def _number_to_bengali_word(self, number):
+        if number == 0:
+            return 'শূন্য'
+
+        words = ''
+
+        if number >= 10 ** 7:
+            words += self._number_to_bengali_word(number // 10 ** 7) + KOTI
+            number %= 10 ** 7
+
+        if number >= 10 ** 5:
+            words += self._number_to_bengali_word(number // 10 ** 5) + LAKH
+            number %= 10 ** 5
+
+        if number >= 1000:
+            words += self._number_to_bengali_word(number // 1000) + HAZAR
+            number %= 1000
+
+        if number >= 100:
+            words += AKOK[number // 100] + 'শত '
+            number %= 100
+
+        if 10 <= number <= 99:
+            words += DOSOK[number - 10] + ' '
+            number = 0
+
+        if 0 < number < 10:
+            words += AKOK[number] + ' '
+
+        return words.strip()
+
+    def to_currency(self, val):
+        """
+        This function represent a number to word in bangla taka and paisa.
+        example:
+        1 = এক টাকা,
+        101 = একশত এক টাকা,
+        9999.15 = নয় হাজার নয়শত নিরানব্বই টাকা পনের পয়সা
+        and so on.
+        """
+
+        dosomik_word = None
+        number = self.str_to_number(val)
+        number, decimal_part = self.parse_paisa(number)
+        self._is_smaller_than_max_number(number)
+
+        if decimal_part > 0:
+            dosomik_word = f' {self._number_to_bengali_word(decimal_part)} পয়সা'  # noqa: E501
+
+        words = f'{self._number_to_bengali_word(number)} টাকা'
+
+        if dosomik_word:
+            return (words + dosomik_word).strip()
+        return words.strip()
+
+    def to_cardinal(self, number):
+        """
+        This function represent a number to word in bangla.
+        example:
+        1 = এক,
+        101 = একশত এক,
+        9999 = নয় হাজার নয়শত নিরানব্বই
+        and so on.
+        """
+
+        dosomik_word = None
+        number = self.str_to_number(number)
+        number, decimal_part = self.parse_number(number)
+        self._is_smaller_than_max_number(number)
+
+        if decimal_part > 0:
+            dosomik_word = f' দশমিক{self._dosomik_to_bengali_word(decimal_part)}'  # noqa: E501
+
+        words = self._number_to_bengali_word(number)
+
+        if dosomik_word:
+            return (words + dosomik_word).strip()
+        return words.strip()
+
+    def to_ordinal(self, number):
+        return self.to_cardinal(number)
+
+    def to_ordinal_num(self, number):
+        """
+        This function represent a number to ranking in bangla.
+        example:
+        1 = প্রথম,
+        2 = দ্বিতীয়,
+        1001 = এক হাজার একতম
+        and so on.
+        """
+        self._is_smaller_than_max_number(number)
+
+        if number in range(1, 11):
+            return RANKING[number]
+        else:
+            rank = self.to_cardinal(int(abs(number)))
+            if rank.endswith('ত'):
+                return rank + 'ম'
+            return rank + 'তম'
+
+    def to_year(self, number):
+        """
+        This function represent a number to year in bangla.
+        example:
+        2002 = দুই হাজার দুই সাল,
+        2024 = দুই হাজার চব্বিশ সাল
+        and so on.
+        """
+        self._is_smaller_than_max_number(number)
+        return self.to_cardinal(int(abs(number))) + ' সাল'
diff --git a/tests/test_base.py b/tests/test_base.py
index efa1bc81..c9abe14d 100644
--- a/tests/test_base.py
+++ b/tests/test_base.py
@@ -62,3 +62,27 @@ def test_is_title(self):
             self.base.title("one"),
             "one"
             )
+
+    def test_set_high_numwords_not_implemented(self):
+        with self.assertRaises(NotImplementedError):
+            self.base.set_high_numwords()
+
+    def test_to_ordinal_num(self):
+        from num2words.base import Num2Word_Base
+        self.base = Num2Word_Base()
+        self.assertEqual(
+            self.base.to_ordinal_num(1),
+            1
+        )
+        self.assertEqual(
+            self.base.to_ordinal_num(100),
+            100
+        )
+        self.assertEqual(
+            self.base.to_ordinal_num(1000),
+            1000
+        )
+
+    def test_pluralize_not_implemented(self):
+        with self.assertRaises(NotImplementedError):
+            self.base.pluralize(n=None, forms=None)
diff --git a/tests/test_bn.py b/tests/test_bn.py
new file mode 100644
index 00000000..9147916c
--- /dev/null
+++ b/tests/test_bn.py
@@ -0,0 +1,365 @@
+# -*- coding: utf-8 -*-
+# Author: Mehedi Hasan Khondoker
+# Email: mehedihasankhondoker [at] gmail.com
+# Copyright (c) 2024, Mehedi Hasan Khondoker.  All Rights Reserved.
+
+# This library is build for Bangladesh format Number to Word conversion.
+# You are welcome as contributor to the library.
+
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+
+from __future__ import unicode_literals
+
+from decimal import Decimal
+from unittest import TestCase
+
+from num2words import num2words
+from num2words.lang_BN import Num2Word_BN, NumberTooLargeError
+
+
+class Num2WordsBNTest(TestCase):
+    maxDiff = None
+
+    def test_negative(self):
+        self.assertEqual(num2words(-1, lang="bn"), u'এক')
+
+    def test_0(self):
+        self.assertEqual(num2words(0, lang="bn"), u'শূন্য')
+
+    def test_1_to_10(self):
+        self.assertEqual(num2words(1, lang="bn"), u'এক')
+        self.assertEqual(num2words(2, lang="bn"), u'দুই')
+        self.assertEqual(num2words(7, lang="bn"), u'সাত')
+        self.assertEqual(num2words(10, lang="bn"), u'দশ')
+
+    def test_11_to_19(self):
+        self.assertEqual(num2words(11, lang="bn"), u'এগারো')
+        self.assertEqual(num2words(13, lang="bn"), u'তেরো')
+        self.assertEqual(num2words(15, lang="bn"), u'পনের')
+        self.assertEqual(num2words(16, lang="bn"), u'ষোল')
+        self.assertEqual(num2words(19, lang="bn"), u'উনিশ')
+
+    def test_20_to_99(self):
+        self.assertEqual(num2words(20, lang="bn"), u'বিশ')
+        self.assertEqual(num2words(23, lang="bn"), u'তেইশ')
+        self.assertEqual(num2words(28, lang="bn"), u'আটাশ')
+        self.assertEqual(num2words(31, lang="bn"), u'একত্রিশ')
+        self.assertEqual(num2words(40, lang="bn"), u'চল্লিশ')
+        self.assertEqual(num2words(66, lang="bn"), u'ছিষট্টি')
+        self.assertEqual(num2words(92, lang="bn"), u'বিরানব্বই')
+
+    def test_100_to_999(self):
+        self.assertEqual(num2words(100, lang="bn"), u'একশত')
+        self.assertEqual(num2words(111, lang="bn"), u'একশত এগারো')
+        self.assertEqual(num2words(150, lang="bn"), u'একশত পঞ্চাশ')
+        self.assertEqual(num2words(196, lang="bn"), u'একশত ছিয়ানব্বই')
+        self.assertEqual(num2words(200, lang="bn"), u'দুইশত')
+        self.assertEqual(num2words(210, lang="bn"), u'দুইশত দশ')
+        self.assertEqual(num2words(701, lang="bn"), u'সাতশত এক')
+        self.assertEqual(num2words(999, lang="bn"), u'নয়শত নিরানব্বই')
+
+    def test_1000_to_9999(self):
+        self.assertEqual(num2words(1000, lang="bn"), u'এক হাজার')
+        self.assertEqual(num2words(1001, lang="bn"), u'এক হাজার এক')
+        self.assertEqual(num2words(1002, lang="bn"), u'এক হাজার দুই')
+        self.assertEqual(num2words(1010, lang="bn"), u'এক হাজার দশ')
+        self.assertEqual(num2words(1110, lang="bn"), u'এক হাজার একশত দশ')
+        self.assertEqual(num2words(1111, lang="bn"), u'এক হাজার একশত এগারো')
+        self.assertEqual(num2words(1500, lang="bn"), u'এক হাজার পাঁচশত')
+        self.assertEqual(num2words(2000, lang="bn"), u'দুই হাজার')
+        self.assertEqual(num2words(2042, lang="bn"), u'দুই হাজার বিয়াল্লিশ')
+        self.assertEqual(num2words(3000, lang="bn"), u'তিন হাজার')
+        self.assertEqual(num2words(3301, lang="bn"), u'তিন হাজার তিনশত এক')
+        self.assertEqual(num2words(3108, lang="bn"), u'তিন হাজার একশত আট')
+        self.assertEqual(num2words(6870, lang="bn"), u'ছয় হাজার আটশত সত্তর')
+        self.assertEqual(num2words(7378, lang="bn"),
+                         u'সাত হাজার তিনশত আটাত্তর')
+        self.assertEqual(num2words(9999, lang="bn"),
+                         u'নয় হাজার নয়শত নিরানব্বই')
+
+    def test_10000_to_99999(self):
+        self.assertEqual(num2words(10000, lang="bn"),
+                         u'দশ হাজার')
+        self.assertEqual(num2words(10501, lang="bn"),
+                         u'দশ হাজার পাঁচশত এক')
+        self.assertEqual(num2words(10999, lang="bn"),
+                         u'দশ হাজার নয়শত নিরানব্বই')
+        self.assertEqual(num2words(13000, lang="bn"), u'তেরো হাজার')
+        self.assertEqual(num2words(15333, lang="bn"),
+                         u'পনের হাজার তিনশত তেত্রিশ')
+        self.assertEqual(num2words(21111, lang="bn"), u'একুশ হাজার একশত এগারো')
+        self.assertEqual(num2words(21003, lang="bn"), u'একুশ হাজার তিন')
+        self.assertEqual(num2words(25020, lang="bn"), u'পঁচিশ হাজার বিশ')
+        self.assertEqual(num2words(68700, lang="bn"),
+                         u'আটষট্টি হাজার সাতশত')
+        self.assertEqual(num2words(73781, lang="bn"),
+                         u'তিয়াত্তর হাজার সাতশত একাশি')
+        self.assertEqual(num2words(99999, lang="bn"),
+                         u'নিরানব্বই হাজার নয়শত নিরানব্বই')
+
+    def test_100000_to_999999(self):
+        self.assertEqual(num2words(100000, lang="bn"), u'এক লাখ')
+        self.assertEqual(num2words('100000', lang="bn"), u'এক লাখ')
+        self.assertEqual(num2words(199999, lang="bn"),
+                         u'এক লাখ নিরানব্বই হাজার নয়শত নিরানব্বই')
+        self.assertEqual(num2words(110000, lang="bn"), u'এক লাখ দশ হাজার')
+        self.assertEqual(num2words(150010, lang="bn"),
+                         u'এক লাখ পঞ্চাশ হাজার দশ')
+        self.assertEqual(num2words('200200', lang="bn"), u'দুই লাখ দুইশত')
+        self.assertEqual(num2words(737812, lang="bn"),
+                         u'সাত লাখ সাতত্রিশ হাজার আটশত বারো')
+        self.assertEqual(num2words('999999', lang="bn"),
+                         u'নয় লাখ নিরানব্বই হাজার নয়শত নিরানব্বই')
+
+    def test_1000000_to_9999999999999999(self):
+        self.assertEqual(num2words(1000000, lang="bn"), u'দশ লাখ')
+        self.assertEqual(num2words(20000000, lang="bn"), u'দুই কোটি')
+        self.assertEqual(num2words(300000000, lang="bn"), u'ত্রিশ কোটি')
+        self.assertEqual(num2words(4000000000, lang="bn"), u'চারশত কোটি')
+        self.assertEqual(num2words(50000000000, lang="bn"), u'পাঁচ হাজার কোটি')
+        self.assertEqual(num2words(600000000000, lang="bn"), u'ষাট হাজার কোটি')
+        self.assertEqual(num2words(7000000000000, lang="bn"), u'সাত লাখ কোটি')
+        self.assertEqual(num2words(80000000000000, lang="bn"), u'আশি লাখ কোটি')
+        self.assertEqual(num2words
+                         (900000000000000, lang="bn"), u'নয় কোটি কোটি')
+        self.assertEqual(num2words(999999999999999, lang="bn"),
+                         u'নয় কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই')  # noqa: E501
+        self.assertEqual(num2words(9999999999999999, lang="bn"),
+                         u'নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই')  # noqa: E501
+
+    def test_dosomik_0_to_999999999999999999(self):
+        self.assertEqual(num2words(0.56, lang="bn"), u'শূন্য দশমিক পাঁচ ছয়')
+        self.assertEqual(num2words(1.11, lang="bn"), u'এক দশমিক এক এক')
+        self.assertEqual(num2words(2.66, lang="bn"), u'দুই দশমিক ছয় ছয়')
+        self.assertEqual(num2words(7.68, lang="bn"), u'সাত দশমিক ছয় আট')
+        self.assertEqual(num2words('10.35', lang="bn"), u'দশ দশমিক তিন পাঁচ')
+        self.assertEqual(num2words('11.47', lang="bn"), u'এগারো দশমিক চার সাত')
+        self.assertEqual(num2words(13.69, lang="bn"), u'তেরো দশমিক ছয় নয়')
+        self.assertEqual(num2words(15.96, lang="bn"), u'পনের দশমিক নয় ছয়')
+        self.assertEqual(num2words(16.9999, lang="bn"),
+                         u'ষোল দশমিক নয় নয় নয় নয়')
+        self.assertEqual(num2words(19.56587, lang="bn"),
+                         u'উনিশ দশমিক পাঁচ ছয় পাঁচ আট সাত')
+        self.assertEqual(num2words(31.31, lang="bn"), u'একত্রিশ দশমিক তিন এক')
+        self.assertEqual(num2words(40.85, lang="bn"), u'চল্লিশ দশমিক আট পাঁচ')
+        self.assertEqual(num2words(66.66, lang="bn"), u'ছিষট্টি দশমিক ছয় ছয়')
+        self.assertEqual(num2words(92.978, lang="bn"),
+                         u'বিরানব্বই দশমিক নয় সাত আট')
+        self.assertEqual(num2words(1000001.10, lang="bn"),
+                         u'দশ লাখ এক দশমিক এক')
+        self.assertEqual(num2words(20000000.22, lang="bn"),
+                         u'দুই কোটি দশমিক দুই দুই')
+        self.assertEqual(num2words(300030000.33, lang="bn"),
+                         u'ত্রিশ কোটি ত্রিশ হাজার দশমিক তিন তিন')
+        self.assertEqual(num2words('4004000444.44', lang="bn"),
+                         u'চারশত কোটি চল্লিশ লাখ চারশত চৌচল্লিশ দশমিক চার চার')
+        self.assertEqual(num2words(50000000001.50, lang="bn"),
+                         u'পাঁচ হাজার কোটি এক দশমিক পাঁচ')
+        self.assertEqual(num2words(600000000600.66, lang="bn"),
+                         u'ষাট হাজার কোটি ছয়শত দশমিক ছয় ছয়')
+        self.assertEqual(num2words(7000000000000.77, lang="bn"),
+                         u'সাত লাখ কোটি দশমিক সাত সাত')
+        self.assertEqual(num2words(80000000000888.88, lang="bn"),
+                         u'আশি লাখ কোটি আটশত আটাশি দশমিক আট আট')
+        self.assertEqual(num2words(900000000000000.9, lang="bn"),
+                         u'নয় কোটি কোটি দশমিক নয়')
+        self.assertEqual(num2words(999999999999999.9, lang="bn"),
+                         u'নয় কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয়')  # noqa: E501
+        self.assertEqual(num2words(9999999999999999.99, lang="bn"),
+                         u'একশত কোটি কোটি')
+        self.assertEqual(num2words(99999999999999999.99, lang="bn"),
+                         u'এক হাজার কোটি কোটি')
+        self.assertEqual(num2words('999999999999999999.9', lang="bn"),
+                         u'নয় হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয়')  # noqa: E501
+
+    def test_to_currency(self):
+        n = Num2Word_BN()
+        self.assertEqual(n.to_currency(20.0), u'বিশ টাকা')
+        self.assertEqual(n.to_currency(20.50), u'বিশ টাকা পঞ্চাশ পয়সা')
+        self.assertEqual(n.to_currency(33.51), u'তেত্রিশ টাকা একান্ন পয়সা')
+        self.assertEqual(n.to_currency(99.99),
+                         u'নিরানব্বই টাকা নিরানব্বই পয়সা')
+        self.assertEqual(n.to_currency(10000.1),
+                         u'দশ হাজার টাকা দশ পয়সা')
+        self.assertEqual(n.to_currency(555555.50),
+                         u'পাঁচ লাখ পঞ্চান্ন হাজার পাঁচশত পঞ্চান্ন টাকা পঞ্চাশ পয়সা')  # noqa: E501
+        self.assertEqual(n.to_currency(6666676),
+                         u'ছিষট্টি লাখ ছিষট্টি হাজার ছয়শত ছিয়াত্তর টাকা')
+        self.assertEqual(n.to_currency(777777777),
+                         u'সাতাত্তর কোটি সাতাত্তর লাখ সাতাত্তর হাজার সাতশত সাতাত্তর টাকা')  # noqa: E501
+        self.assertEqual(n.to_currency(7777777778),
+                         u'সাতশত সাতাত্তর কোটি সাতাত্তর লাখ সাতাত্তর হাজার সাতশত আটাত্তর টাকা')  # noqa: E501
+        self.assertEqual(n.to_currency(97777777778),
+                         u'নয় হাজার সাতশত সাতাত্তর কোটি সাতাত্তর লাখ সাতাত্তর হাজার সাতশত আটাত্তর টাকা')  # noqa: E501
+        self.assertEqual(n.to_currency(977777777781),
+                         u'সাতানব্বই হাজার সাতশত সাতাত্তর কোটি সাতাত্তর লাখ সাতাত্তর হাজার সাতশত একাশি টাকা')  # noqa: E501
+        self.assertEqual(n.to_currency(9777777779781),
+                         u'নয় লাখ সাতাত্তর হাজার সাতশত সাতাত্তর কোটি সাতাত্তর লাখ উনআশি হাজার সাতশত একাশি টাকা')  # noqa: E501
+
+    def test_to_cardinal(self):
+        n = Num2Word_BN()
+        self.assertEqual(n.to_cardinal(0.56), u'শূন্য দশমিক পাঁচ ছয়')
+        self.assertEqual(n.to_cardinal(1.11), u'এক দশমিক এক এক')
+        self.assertEqual(n.to_cardinal(2.66), u'দুই দশমিক ছয় ছয়')
+        self.assertEqual(n.to_cardinal(7.68), u'সাত দশমিক ছয় আট')
+        self.assertEqual(n.to_cardinal('10.35'), u'দশ দশমিক তিন পাঁচ')
+        self.assertEqual(n.to_cardinal('11.47'), u'এগারো দশমিক চার সাত')
+        self.assertEqual(n.to_cardinal(13.69), u'তেরো দশমিক ছয় নয়')
+        self.assertEqual(n.to_cardinal(15.96), u'পনের দশমিক নয় ছয়')
+        self.assertEqual(n.to_cardinal(16.9999), u'ষোল দশমিক নয় নয় নয় নয়')
+        self.assertEqual(n.to_cardinal(19.56587),
+                         u'উনিশ দশমিক পাঁচ ছয় পাঁচ আট সাত')
+        self.assertEqual(n.to_cardinal(31.31), u'একত্রিশ দশমিক তিন এক')
+        self.assertEqual(n.to_cardinal(40.85), u'চল্লিশ দশমিক আট পাঁচ')
+        self.assertEqual(n.to_cardinal(66.66), u'ছিষট্টি দশমিক ছয় ছয়')
+        self.assertEqual(n.to_cardinal(92.978), u'বিরানব্বই দশমিক নয় সাত আট')
+        self.assertEqual(n.to_cardinal(1000001.10), u'দশ লাখ এক দশমিক এক')
+        self.assertEqual(n.to_cardinal(20000000.22), u'দুই কোটি দশমিক দুই দুই')
+        self.assertEqual(n.to_cardinal(300030000.33),
+                         u'ত্রিশ কোটি ত্রিশ হাজার দশমিক তিন তিন')
+        self.assertEqual(n.to_cardinal('4004000444.44'),
+                         u'চারশত কোটি চল্লিশ লাখ চারশত চৌচল্লিশ দশমিক চার চার')
+        self.assertEqual(n.to_cardinal(50000000001.50),
+                         u'পাঁচ হাজার কোটি এক দশমিক পাঁচ')
+        self.assertEqual(n.to_cardinal(600000000600.66),
+                         u'ষাট হাজার কোটি ছয়শত দশমিক ছয় ছয়')
+        self.assertEqual(n.to_cardinal(7000000000000.77),
+                         u'সাত লাখ কোটি দশমিক সাত সাত')
+        self.assertEqual(n.to_cardinal(80000000000888.88),
+                         u'আশি লাখ কোটি আটশত আটাশি দশমিক আট আট')
+        self.assertEqual(n.to_cardinal(900000000000000.9),
+                         u'নয় কোটি কোটি দশমিক নয়')
+        self.assertEqual(n.to_cardinal(999999999999999.9),
+                         u'নয় কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয়')  # noqa: E501
+        self.assertEqual(n.to_cardinal(9999999999999999.99),
+                         u'একশত কোটি কোটি')
+        self.assertEqual(n.to_cardinal(99999999999999999.99),
+                         u'এক হাজার কোটি কোটি')
+        self.assertEqual(n.to_cardinal('999999999999999999.99'),
+                         u'নয় হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয় নয়')  # noqa: E501
+
+    def test_to_ordinal(self):
+        n = Num2Word_BN()
+        self.assertEqual(n.to_ordinal(0.56), u'শূন্য দশমিক পাঁচ ছয়')
+        self.assertEqual(n.to_ordinal(1.11), u'এক দশমিক এক এক')
+        self.assertEqual(n.to_ordinal(2.66), u'দুই দশমিক ছয় ছয়')
+        self.assertEqual(n.to_ordinal(7.68), u'সাত দশমিক ছয় আট')
+        self.assertEqual(n.to_ordinal('10.35'), u'দশ দশমিক তিন পাঁচ')
+        self.assertEqual(n.to_ordinal('11.47'), u'এগারো দশমিক চার সাত')
+        self.assertEqual(n.to_ordinal(13.69), u'তেরো দশমিক ছয় নয়')
+        self.assertEqual(n.to_ordinal(15.96), u'পনের দশমিক নয় ছয়')
+        self.assertEqual(n.to_ordinal(16.9999), u'ষোল দশমিক নয় নয় নয় নয়')
+        self.assertEqual(n.to_ordinal(19.56587),
+                         u'উনিশ দশমিক পাঁচ ছয় পাঁচ আট সাত')
+        self.assertEqual(n.to_ordinal(31.31), u'একত্রিশ দশমিক তিন এক')
+        self.assertEqual(n.to_ordinal(40.85), u'চল্লিশ দশমিক আট পাঁচ')
+        self.assertEqual(n.to_ordinal(66.66), u'ছিষট্টি দশমিক ছয় ছয়')
+        self.assertEqual(n.to_ordinal(92.978), u'বিরানব্বই দশমিক নয় সাত আট')
+        self.assertEqual(n.to_ordinal(1000001.10), u'দশ লাখ এক দশমিক এক')
+        self.assertEqual(n.to_ordinal(20000000.22), u'দুই কোটি দশমিক দুই দুই')
+        self.assertEqual(n.to_ordinal(300030000.33),
+                         u'ত্রিশ কোটি ত্রিশ হাজার দশমিক তিন তিন')
+        self.assertEqual(n.to_ordinal('4004000444.44'),
+                         u'চারশত কোটি চল্লিশ লাখ চারশত চৌচল্লিশ দশমিক চার চার')
+        self.assertEqual(n.to_ordinal(50000000001.50),
+                         u'পাঁচ হাজার কোটি এক দশমিক পাঁচ')
+        self.assertEqual(n.to_ordinal(600000000600.66),
+                         u'ষাট হাজার কোটি ছয়শত দশমিক ছয় ছয়')
+        self.assertEqual(n.to_ordinal(7000000000000.77),
+                         u'সাত লাখ কোটি দশমিক সাত সাত')
+        self.assertEqual(n.to_ordinal(80000000000888.88),
+                         u'আশি লাখ কোটি আটশত আটাশি দশমিক আট আট')
+        self.assertEqual(n.to_ordinal(900000000000000.9),
+                         u'নয় কোটি কোটি দশমিক নয়')
+        self.assertEqual(n.to_ordinal(999999999999999.9),
+                         u'নয় কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয়')  # noqa: E501
+        self.assertEqual(n.to_ordinal(9999999999999999.99),
+                         u'একশত কোটি কোটি')
+        self.assertEqual(n.to_ordinal(99999999999999999.99),
+                         u'এক হাজার কোটি কোটি')
+        self.assertEqual(n.to_ordinal('999999999999999999.99'),
+                         u'নয় হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই দশমিক নয় নয়')  # noqa: E501
+
+    def test_to_year(self):
+        n = Num2Word_BN()
+        self.assertEqual(n.to_year(1), u'এক সাল')
+        self.assertEqual(n.to_year(1000), u'এক হাজার সাল')
+        self.assertEqual(n.to_year(1500), u'এক হাজার পাঁচশত সাল')
+        self.assertEqual(n.to_year(1820), u'এক হাজার আটশত বিশ সাল')
+        self.assertEqual(n.to_year(1920), u'এক হাজার নয়শত বিশ সাল')
+        self.assertEqual(n.to_year(2024), u'দুই হাজার চব্বিশ সাল')
+        self.assertEqual(n.to_year(2004), u'দুই হাজার চার সাল')
+
+    def test_to_ordinal_num(self):
+        n = Num2Word_BN()
+        self.assertEqual(n.to_ordinal_num(1), u'প্রথম')
+        self.assertEqual(n.to_ordinal_num(1000), u'এক হাজারতম')
+        self.assertEqual(n.to_ordinal_num(1500), u'এক হাজার পাঁচশতম')
+        self.assertEqual(n.to_ordinal_num(1820), u'এক হাজার আটশত বিশতম')
+        self.assertEqual(n.to_ordinal_num(1920), u'এক হাজার নয়শত বিশতম')
+        self.assertEqual(n.to_ordinal_num(2024), u'দুই হাজার চব্বিশতম')
+        self.assertEqual(n.to_ordinal_num(2004), u'দুই হাজার চারতম')
+
+    def test_max_number_error(self):
+        n = Num2Word_BN()
+
+        with self.assertRaises(NumberTooLargeError):
+            n.to_ordinal(
+                99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991)  # noqa: E501
+
+        with self.assertRaises(NumberTooLargeError):
+            n.to_cardinal(
+                99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991)  # noqa: E501
+
+        with self.assertRaises(NumberTooLargeError):
+            n.to_year(
+                99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991)  # noqa: E501
+
+        with self.assertRaises(NumberTooLargeError):
+            n.to_ordinal_num(
+                99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991)  # noqa: E501
+
+        with self.assertRaises(NumberTooLargeError):
+            n.to_currency(
+                99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991)  # noqa: E501
+
+        with self.assertRaises(NumberTooLargeError):
+            num2words(
+                99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999991,  # noqa: E501
+                lang="bn")
+
+    def test_is_smaller_than_max_number(self):
+        n = Num2Word_BN()
+        self.assertEqual(n._is_smaller_than_max_number(55555), True)
+
+    def test_is_smaller_than_max_number_error(self):
+        with self.assertRaises(NumberTooLargeError):
+            n = Num2Word_BN()
+            n._is_smaller_than_max_number(99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999)  # noqa: E501
+
+    def test_parse_number(self):
+        n = Num2Word_BN()
+        self.assertEqual(n.parse_number(Decimal(3.25)), (3, 25))
+        self.assertEqual(n.parse_number(Decimal(300.2550)),
+                         (300, 2549999999999954525264911353588104248046875))
+
+    def test_parse_paisa(self):
+        n = Num2Word_BN()
+        self.assertEqual(n.parse_paisa(Decimal(3.25)), (3, 25))
+        self.assertEqual(n.parse_paisa(300.2550), (300, 25))
+        self.assertEqual(n.parse_paisa(100.5), (100, 50))
+
+    def test_number_to_bengali_word(self):
+        n = Num2Word_BN()
+        self.assertEqual(n._number_to_bengali_word(3), "তিন")
+        self.assertEqual(n._number_to_bengali_word(2550),
+                         "দুই হাজার পাঁচশত পঞ্চাশ")
+        self.assertEqual(n._number_to_bengali_word(9999999999999999),
+                         "নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই কোটি নিরানব্বই লাখ নিরানব্বই হাজার নয়শত নিরানব্বই")  # noqa: E501
diff --git a/tests/test_dk.py b/tests/test_dk.py
index 889e9d8e..4c2e6ce3 100644
--- a/tests/test_dk.py
+++ b/tests/test_dk.py
@@ -20,6 +20,7 @@
 from unittest import TestCase
 
 from num2words import num2words
+from num2words.lang_DK import Num2Word_DK
 
 
 class Num2WordsDKTest(TestCase):
@@ -35,3 +36,10 @@ def test_cardinal(self):
         self.assertEqual(num2words(8, to="cardinal", lang="dk"), "otte")
         self.assertEqual(num2words(18, to="cardinal", lang="dk"), "atten")
         self.assertEqual(num2words(45, to="cardinal", lang="dk"), "femogfyrre")
+
+    def test_to_ordinal_num(self):
+        num2words_dk = Num2Word_DK()
+        self.assertEqual(num2words_dk.to_ordinal_num(1), "1te")
+        self.assertEqual(num2words_dk.to_ordinal_num(2), "2en")
+        self.assertEqual(num2words_dk.to_ordinal_num(5), "5te")
+        self.assertEqual(num2words_dk.to_ordinal_num(10), "10ende")